opencode-auto-resume 1.1.20 → 1.2.0

package/dist/v2/index.js

@@ -0,0 +1,4010 @@
+// @bun
+// src/v2/index.ts
+import { readFileSync, mkdirSync, statSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { readFile } from "fs/promises";
+var define = (plugin) => plugin;
+async function configMentionsTaskComplete(cfgPath) {
+  try {
+    const raw = await readFile(cfgPath, "utf8");
+    return /"[^"]*task-complete[^"]*"/i.test(raw);
+  } catch {
+    return false;
+  }
+}
+var CTX_WRAPUP_TRIGGER = "ctx-wrapup";
+var DEFAULT_CHUNK_TIMEOUT_MS = 180000;
+var DEFAULT_CHECK_INTERVAL_MS = 5000;
+var DEFAULT_GRACE_PERIOD_MS = 3000;
+var DEFAULT_STUCK_TOOL_AGE_MS = 60000;
+var LONG_RUNNING_TOOL_STALE_TTL_MS = 10 * 60000;
+var LONG_RUNNING_TOOLS = ["shell"];
+var STALL_JITTER_MS = 60000;
+var DEFAULT_MAX_RETRIES = 3;
+var LOCAL_PROVIDERS = new Set([
+  "llama-server",
+  "ollama",
+  "llama.cpp",
+  "llama-cpp",
+  "vllm",
+  "text-generation-inference",
+  "tgi",
+  "lmstudio",
+  "koboldcpp",
+  "exllama",
+  "mlc-llm",
+  "ggml",
+  "llamacpp"
+]);
+var FAST_PROFILE = {
+  chunkTimeoutMs: 180000,
+  gracePeriodMs: 3000,
+  maxRetries: 3,
+  lifetimeMaxContinues: 9
+};
+var SLOW_PROFILE = {
+  chunkTimeoutMs: 600000,
+  gracePeriodMs: 60000,
+  maxRetries: 5,
+  lifetimeMaxContinues: 20
+};
+var FAILURE_LOOP_MAX = 3;
+var PROVIDER_RETRY_GRACE_MS = 120000;
+var DEFAULT_BASE_BACKOFF_MS = 1000;
+var DEFAULT_MAX_BACKOFF_MS = 8000;
+var DEFAULT_LOOP_MAX_CONTINUES = 3;
+var DEFAULT_LOOP_WINDOW_MS = 10 * 60000;
+var DEFAULT_LIFETIME_MAX_CONTINUES = 9;
+var DEFAULT_DEBUG = false;
+var DEFAULT_ACTIVE_USER_WINDOW_MS = 5 * 60000;
+var DEFAULT_DISCOVERY_DELAY_MS = 5000;
+var DEFAULT_SESSION_DISCOVERY_INTERVAL_MS = 60000;
+var DEFAULT_WARMUP_MS = 15000;
+var DEFAULT_SHARE_WATCH_STATE = false;
+var DEFAULT_MIN_ACTIVITY_GAP_MS = 1000;
+var DEFAULT_TOOL_TEXT_CHECK_DELAY_MS = 3000;
+var DEFAULT_SUBAGENT_WAIT_MS = 15000;
+var SUBAGENT_STUCK_MS = 60000;
+var DEFAULT_SUBAGENT_DEAD_MS = 60 * 60000;
+var SUBAGENT_RECOVERY_PROMPT = "It looks like you may have stalled or timed out. Please retry the last operation or continue with the task.";
+var DEFAULT_SILENT_DEAD_STREAM_MIN_TOKENS = 200;
+var DEFAULT_CONTEXT_SATURATION_THRESHOLD = 0.85;
+var CHECKED_TOOL_PART_IDS_MAX = 500;
+var QUOTA_STATE_PREFIX = "resume-quota/";
+var COUNTER_STATE_PREFIX = "resume-counters/";
+var PAUSED_MARKER_FILE = `${process.env.HOME ?? ""}/.config/opencode/auto-resume.paused`;
+var QUOTA_STATE_MAX_AGE_MS = 48 * 3600000;
+var TODO_CACHE_TTL_MS = 3000;
+var DEFAULT_STREAMING_FAILURE_ERROR_NAMES = [
+  "ProviderError",
+  "APIError",
+  "StreamError",
+  "ConnectionError",
+  "TimeoutError"
+];
+var DEFAULT_STREAMING_FAILURE_MESSAGE_PATTERNS = [
+  "streaming response failed",
+  "stream.*fail",
+  "connection.*reset",
+  "connection.*closed",
+  "aborted due to timeout"
+];
+var DONE_CLAIM_PATTERN_SOURCES = [
+  "^task\\s+done[.!]*$",
+  "^done[.!]*$",
+  "^all\\s+done[.!]*$",
+  "^finished[.!]*$",
+  "^complete[.!]*$",
+  "^task\\s+complete[.!]*$",
+  "^task\\s+completed[.!]*$",
+  "^all\\s+tasks?\\s+complete[.!]*$",
+  "^all\\s+tasks?\\s+completed[.!]*$",
+  "^(?:i['\u2019]?m\\s+)?done\\s+with\\s+task",
+  "\\bdone\\s+with\\s+(?:the\\s+)?(?:task|work|implementation)",
+  "\\bfinished\\s+(?:the\\s+)?(?:task|work|implementation)",
+  "\\b(?:all|everything)\\s+(?:[\\w-]+\\s+)?(?:is\\s+)?(?:complete|done|finished)",
+  "\\bnothing\\s+(?:else\\s+)?(?:left|remaining|to do)"
+];
+var DEFAULT_DONE_CLAIM_PATTERNS = [...DONE_CLAIM_PATTERN_SOURCES];
+var DEFAULT_READY_TO_CONTINUE_PATTERNS = [
+  "ready to continue with task",
+  "continuing with task",
+  "continue with task",
+  "proceeding with task",
+  "ready to proceed with task",
+  "will continue with task",
+  "moving on to task"
+];
+var THINKING_TOOL_RECOVERY_PROMPT = "I noticed you have a tool call generated in your thinking/reasoning. " + "Please execute it using the proper tool calling mechanism instead of keeping it in reasoning.";
+var DONE_WITHOUT_DETAILS_PROMPT = "Your last response claimed the task is complete but contained no work description. This is not acceptable. " + "You MUST respond now with a full, detailed report of everything you did: " + "for each file you modified, state the full path and the exact changes; " + "list every command you ran to verify and its result; state the final outcome. " + "Do NOT reply with 'done', 'task completed', or any short acknowledgment \u2014 " + "your ONLY acceptable response right now is this detailed report. Write it now.";
+var SHELL_OPEN_MAX_MS = 30 * 60000;
+var OOC_ERROR_RE = /exceeds the available context size|context size \(\d+\)|too large to compact|too many tokens|prompt is too long/i;
+var PERMANENT_ERROR_TYPES = new Set([
+  "provider.auth",
+  "provider.no-route",
+  "provider.content-filter"
+]);
+var INDETERMINATE_ERROR_TYPES = new Set(["provider.unsupported-operation", "provider.unknown"]);
+var INDETERMINATE_STRIKES = 2;
+var PERMANENT_STATUS_CODES = new Set([401, 403]);
+var PERMANENT_HISTORY_RE = /referenced (reasoning )?item [^\n]{0,80}not found|no tool output found for (function )?call/i;
+var PERMANENT_GONE_RE = /model\b.{0,80}\b(deprecat\w*|discontinued|retired|removed|no longer (available|supported|offered))\b|\bno llm route for\b/i;
+var PERMANENT_UNKNOWN_MODEL_RE = /\b(model[_ ]?not[_ ]?found|model_not_found|unknown model|no such model|invalid model|unsupported model)\b/i;
+var RATE_LIMIT_RE = /rate.?limit|too many requests|\b429\b|quota exceeded|provider\.quota|provider\.free|insufficient.?quota|resource.?exhausted|overloaded|throttl|slow down|please wait|try again later|too many tokens.{0,120}(short period|wait|retr|throttl|slow|per (second|minute|hour|day)|rate|limit|quota)|free[ -]?limit|free usage limit reached|usage limit reached|connect a provider or subscribe/i;
+var DEFAULT_RATE_LIMIT_COOLDOWNS_MS = [15, 30, 60, 120, 120, 120, 120, 120].map((m) => m * 60000);
+var DEFAULT_SEND_TIMEOUT_MS = 30000;
+var SEND_SLOW_MS = 1e4;
+var SELF_ABORT_TTL_MS = 30000;
+var ABORT_ERROR_TYPE_RE = /^(abort|aborted|cancel|cancelled|canceled|interrupted)$/i;
+var ABORT_ERROR_MSG_RE = /step interrupted|interrupted by user|request cancelled|request canceled|execution interrupted/i;
+var MAX_INTERRUPTS_PER_WINDOW = 2;
+var INTERRUPT_WINDOW_MS = 10 * 60000;
+var DEFAULT_INJECT_INTERVAL_MS = 15000;
+var OWN_PROMPT_TIME_MS = 30000;
+var MAX_IDLE_SESSIONS = 50;
+var IDLE_CLEANUP_MS = 10 * 60000;
+var COMPACTION_STALE_TTL_MS = 30 * 60000;
+var PERMISSION_STALE_TTL_MS = 30 * 60000;
+var NEVER_INTERRUPT_STALE_TTL_MS = 30 * 60000;
+var TEXT_BUFFER_TRIM_LEN = 20000;
+var TOOL_STATE_RUNNING = "running";
+var NEVER_RETRY_RE = /blocked by cc safety net|do not retry|access to a sensitive path/i;
+function toolErrorText(state) {
+  const e = state?.error ?? state?.output;
+  if (typeof e === "string")
+    return e;
+  if (e && typeof e === "object") {
+    const t = e;
+    const parts = [t.type, t.message].filter((x) => typeof x === "string" && x.length > 0);
+    if (parts.length > 0)
+      return parts.join(" ");
+  }
+  return "";
+}
+var TOOL_STATE_PENDING = "pending";
+var TOOL_STATE_COMPLETED = "completed";
+var AWAITING_USER_TOOLS = new Set(["question", "permission", "ask", "confirm"]);
+var CONTINUE_PROMPT = "continue";
+var SAFE_CONTINUE_PROMPT = `continue
+Only continue work already in progress. Do not start anything new, ` + "and do not take destructive or irreversible actions without explicit user approval.";
+var SAFE_EMPTY_IDLE_PROMPT = `continue
+If work was already in progress, continue it and finish nothing else. ` + "Otherwise ask the user what to do next rather than starting something new. " + "Do not take destructive or irreversible actions without explicit user approval.";
+var TASK_COMPLETE_ACK = "Task completion acknowledged. No further continuation will be sent. " + "End your turn now with a brief text reply \u2014 do not call task_complete or any other tool again " + "unless the user sends a new message.";
+var TASK_COMPLETE_REPEAT_WARNING = "Task completion acknowledged already on your previous call \u2014 completion is recorded. " + "End your turn now with a brief text reply. Do not call task_complete again; " + "further repeat calls are rejected as errors.";
+var TASK_COMPLETE_REPEAT_ERROR = "task_complete already acknowledged twice with no new user message or tool work since \u2014 " + "completion is recorded. End your turn with text and make no further tool calls.";
+var UNKNOWN_TOOL_THRESHOLD = 2;
+var TOOL_IDS_CACHE_MS = 5 * 60000;
+var UNKNOWN_TOOL_LIST_LIMIT = 20;
+var TASK_COMPLETE_DESCRIPTION = "Signal that all work is complete and stop automatic continuation prompts. Call this ONLY after finishing everything requested. Call exactly once per completed round of work \u2014 repeat calls with no new user message in between are rejected.";
+var TOOL_TEXT_RECOVERY_PROMPT = "Your last message contained a raw tool call printed as text instead of being executed. " + "Please use the proper tool calling mechanism to execute it.";
+var DONE_WITHOUT_WORK_PROMPT = "I need you to verify more carefully that you have actually completed all the required tasks. " + "Your response indicated you're done, but no work was detected. Please check your todo list " + "and complete any remaining work.";
+var TOOL_LOOP_RECOVERY_PROMPT = "I notice you've been calling the same tool multiple times in a row without making progress. " + "Please step back and reassess your approach. Consider: " + "1) Are you stuck in a loop? 2) Do you need different information first? " + "3) Should you try a different tool or break the task into smaller steps? " + "Take a moment to think about what's blocking you and propose a different strategy.";
+var TASK_TOOL_HINTS = ["task", "agent", "subagent", "dispatch"];
+var TOOL_TEXT_PATTERNS = [
+  /<function\s*=/i,
+  /<function>/i,
+  /<\/function>/i,
+  /<parameter\s*=/i,
+  /<parameter>/i,
+  /<\/parameter>/i,
+  /<tool_call[\s>]/i,
+  /<\/tool_call>/i,
+  /<tool[\s_]name\s*=/i,
+  /<invoke\s+/i,
+  /<func(?:t|ti|tio|tion)?$/im,
+  /<par(?:a|am|ame|amet|amete|ameter)?$/im,
+  /<(?:edit|write|read|bash|grep|glob|search|replace|execute|run)\s*(?:\s[^>]*)?\s*(?:\/>|>)/i,
+  /{"type":\s*"function"/i,
+  /{"name":\s*"[a-zA-Z_]/i,
+  /\{\s*"type"\s*:?$/im,
+  /\{\s*"name"\s*:?$/im
+];
+var TRUNCATED_XML_PATTERNS = [
+  { open: /<function[^>]*>/i, close: /<\/function>/i },
+  { open: /<parameter[^>]*>/i, close: /<\/parameter>/i },
+  { open: /<tool_call[^>]*>/i, close: /<\/tool_call>/i },
+  { open: /\{\s*"type"\s*:/i, close: /}/ },
+  { open: /\{\s*"name"\s*:/i, close: /}/ }
+];
+var READY_TO_CONTINUE_PATTERNS = [
+  /ready to continue with task/i,
+  /continuing with task/i,
+  /continue with task/i,
+  /proceeding with task/i,
+  /ready to proceed with task/i,
+  /will continue with task/i,
+  /moving on to task/i
+];
+var DONE_CLAIM_PATTERNS = DONE_CLAIM_PATTERN_SOURCES.map((s) => new RegExp(s, "im"));
+var STREAMING_FAILURE_MESSAGE_PATTERNS = [
+  "stream.*fail",
+  "stream.*timeout",
+  "connection.*reset",
+  "connection.*closed",
+  "connection.*error",
+  "socket.*hang",
+  "econnreset",
+  "etimedout",
+  "rate.?limit",
+  "overloaded",
+  "server error",
+  "internal error"
+];
+function stripCodeBlocks(text) {
+  return text.replace(/```[\s\S]*?```/g, "").replace(/`[^`\n]+`/g, "");
+}
+function stripBoundaryMarkers(text) {
+  return text.replace(/(?:\s*@\d+@)+\s*$/, "");
+}
+function containsToolCallAsText(text) {
+  if (text.length <= 10)
+    return false;
+  const stripped = stripCodeBlocks(text);
+  if (TOOL_TEXT_PATTERNS.some((pat) => pat.test(stripped)))
+    return true;
+  for (const { open, close } of TRUNCATED_XML_PATTERNS) {
+    if (open.test(stripped) && !close.test(stripped))
+      return true;
+  }
+  return false;
+}
+function containsReadyToContinuePattern(text, patterns = READY_TO_CONTINUE_PATTERNS) {
+  const lines = text.split(`
+`);
+  const lastLines = lines.slice(-3).join(`
+`);
+  return patterns.some((pat) => pat.test(lastLines));
+}
+function containsDoneClaimPattern(text, patterns = DONE_CLAIM_PATTERNS) {
+  const lines = text.split(`
+`);
+  const lastLines = lines.slice(-5).join(`
+`);
+  return patterns.some((pat) => pat.test(lastLines));
+}
+var STOP_STATEMENT_PATTERNS = [
+  /no action needed/i,
+  /\bstop(ping|ped)?\s+(here|there|now)\b[.!]*$/i,
+  /\bnothing\b[^.;:!?\u2014\u2013\n]*\b(further|else|pending|left|remaining|outstanding|launched|queued|scheduled|to do)\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bno (further|additional|more) (action|work|steps?|runs?|anything)\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bnone (pending|left|remaining|outstanding)\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\b(stopping|halt|halted|standing down|pausing|paused)\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\b(that'?s|thats|this is) (all|it|everything)\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\b(parked|not started|unstarted)\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bTASK COMPLETE\s*[.!]*\s*$/,
+  /\btask completed\s*[.!]*\s*$/i,
+  /\bstanding by\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bready (?:when you have the|for your|for the) (?:next\s+)?(?:task|instruction)s?\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bnothing in progress\b/i,
+  /\bwaiting\s+(?:on|for)\s+(?:you|the user|your|my|the next|further)\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bawaiting\s+(?:you|the user|your|further|the next)\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bblocked\b[^.;:!?\u2014\u2013\n]*(?:\bneed\b|\bawaiting\b|\bon\b)[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\b(?:on hold|holding off)\s+(?:pending|awaiting|waiting for)\s+(?:your|the user|further|the next)\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\b(?:can'?t|cannot|unable to)\s+proceed\s+without\s+(?:your|the user)'?\s*(?:input|guidance|decision|approval|confirmation|direction)s?\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\b(?:i\s+)?need\s+(?:your|the user)'?\s*(?:input|guidance|decision|approval|confirmation|direction|clarification)s?\b[^.;:!?\u2014\u2013\n]*(?:\bto\s+continue\b|\bbefore\b)?[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bstop\s+and\s+wait\s+for\s+your\s+approval\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bask\s+me\s+to\s+add\s+them\s+to\s+the\s+chat\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bFINISHED\s*[.!]*\s*$/,
+  /\bi\s+have\s+completed\s+(?:the\s+)?(?:task|work|implementation)\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bthe\s+(?:task|work)\s+is\s+(?:finished|complete|done)\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bready\s+when\s+you'?re\s+ready\b[^.;:!?\u2014\u2013\n]*[.!]*$/i,
+  /\bready\s+and\s+waiting\b[^.;:!?\u2014\u2013\n]*[.!]*$/i
+];
+function containsStopStatement(text) {
+  const lines = stripBoundaryMarkers(text).split(`
+`);
+  const lastLines = lines.slice(-3).join(`
+`);
+  const trimmedTail = lastLines.trim().replace(/[.!?\u2026]+$/, "");
+  const finalClause = trimmedTail.split(/[.;:!?\u2014\u2013]/).pop() ?? trimmedTail;
+  if (/,\s*(then|so|next|now|afterwards?|and then)\b/i.test(finalClause))
+    return false;
+  return STOP_STATEMENT_PATTERNS.some((pat) => pat.test(lastLines));
+}
+function turnEndsWithCompletionClaim(text) {
+  return endsWithCelebration(text) || containsStopStatement(text);
+}
+function containsWorkDescription(text) {
+  if (/`[^`\n]*\.[a-zA-Z0-9]{1,8}[^`\n]*`/.test(text))
+    return true;
+  if (/[\w\-~.][\w\-.~\/]*\/[\w\-.~]*\.[a-zA-Z]{1,8}\b/.test(text))
+    return true;
+  if (/^(changed|modified|deleted|created|updated|renamed|moved|files?\s+changed|verification|verified|tests?(?:\s+run|\s+passing|\s+pass)?|results?|outcome|commands?\s+(?:run|executed))/im.test(text))
+    return true;
+  return false;
+}
+function endsWithCelebration(text) {
+  const lastLine = stripBoundaryMarkers(text).split(`
+`).filter((l) => l.trim().length > 0).pop() ?? "";
+  return lastLine.trim().replace(/[.!?]+$/, "").endsWith("\uD83C\uDF89");
+}
+function isOpenTodo(t) {
+  return t.status === "pending" || t.status === "in_progress";
+}
+function getOpenTodos(todos) {
+  if (!Array.isArray(todos))
+    return [];
+  return todos.filter(isOpenTodo);
+}
+function buildOpenTodosReminder(todos) {
+  if (!Array.isArray(todos))
+    return "continue";
+  const open = todos.filter(isOpenTodo);
+  if (open.length === 0)
+    return "continue";
+  const list = open.map((t, i) => `${i + 1}. [${t.status}] ${t.content}`).join(`
+`);
+  const plural = open.length > 1 ? "s" : "";
+  const taskWord = open.length > 1 ? "tasks" : "task";
+  const thisWord = open.length > 1 ? "these" : "this";
+  return `You have ${open.length} unfinished task${plural}:
+${list}
+
+Please continue working on ${thisWord} ${taskWord}.`;
+}
+function serverBaseUrls(cmdline) {
+  const out = [];
+  const push = (v) => {
+    if (typeof v !== "string" || !v)
+      return;
+    const url = v.startsWith("http") ? v : `http://127.0.0.1:${v.replace(/^:/, "")}`;
+    if (!out.includes(url))
+      out.push(url.replace(/\/$/, ""));
+  };
+  const env = process.env;
+  push(env.OPENCODE_SERVER_URL);
+  push(env.OPENCODE_URL);
+  push(env.OPENCODE_SERVER_PORT);
+  push(env.OPENCODE_PORT);
+  push(env.PORT);
+  try {
+    const raw = cmdline ?? readFileSync("/proc/self/cmdline", "utf8");
+    const argv = raw.split("\x00");
+    const portFlag = argv.indexOf("--port");
+    if (portFlag !== -1 && argv[portFlag + 1]) {
+      const hostFlag = argv.indexOf("--hostname");
+      const host = hostFlag !== -1 && argv[hostFlag + 1] ? argv[hostFlag + 1] : "127.0.0.1";
+      push(`http://${host}:${argv[portFlag + 1]}`);
+    }
+  } catch {}
+  return out;
+}
+function serverHeaders() {
+  const pw = process.env.OPENCODE_SERVER_PASSWORD || process.env.OPENCODE_PASSWORD;
+  if (!pw)
+    return {};
+  return { Authorization: `Basic ${Buffer.from(`opencode:${pw}`).toString("base64")}` };
+}
+function normalizeTodoList(input) {
+  if (input === null || typeof input !== "object")
+    return;
+  const todos = input.todos;
+  if (!Array.isArray(todos))
+    return;
+  const out = [];
+  for (const entry of todos) {
+    if (entry === null || typeof entry !== "object")
+      continue;
+    const e = entry;
+    if (typeof e.content !== "string" || typeof e.status !== "string")
+      continue;
+    const todo = { content: e.content, status: e.status, priority: "medium" };
+    if (typeof e.priority === "string")
+      todo.priority = e.priority;
+    out.push(todo);
+  }
+  return out.length > 0 ? out : undefined;
+}
+function todosFromMessages(messages) {
+  if (!Array.isArray(messages))
+    return;
+  const candidates = [];
+  let order = 0;
+  for (const message of messages) {
+    if (message === null || typeof message !== "object")
+      continue;
+    const content = message.content;
+    if (!Array.isArray(content))
+      continue;
+    for (const part of content) {
+      if (part === null || typeof part !== "object")
+        continue;
+      const p = part;
+      if (p.type !== "tool" || p.name !== "todowrite")
+        continue;
+      if (p.state?.status !== "completed")
+        continue;
+      const list = normalizeTodoList(p.state.input);
+      if (!list)
+        continue;
+      const t = p.state?.time ?? p.time ?? message.time ?? {};
+      const at = [t?.end, t?.start, t?.created].find((v) => typeof v === "number");
+      candidates.push({ list, at: typeof at === "number" ? at : null, order: order++ });
+    }
+  }
+  if (candidates.length === 0)
+    return;
+  candidates.sort((a, b) => {
+    if (a.at !== null && b.at !== null && a.at !== b.at)
+      return b.at - a.at;
+    if (a.at === null !== (b.at === null))
+      return a.at === null ? 1 : -1;
+    return a.order - b.order;
+  });
+  return candidates[0]?.list;
+}
+function containsActionIntent(text) {
+  if (text.length <= 15)
+    return false;
+  const cleaned = text.replace(/<[a-zA-Z/?][^>]*>/g, "").trim();
+  const lines = cleaned.split(`
+`);
+  let lastLine = "";
+  for (let i = lines.length - 1;i >= 0; i--) {
+    if (lines[i].trim().length > 0) {
+      lastLine = lines[i].trim();
+      break;
+    }
+  }
+  return lastLine.endsWith(":") && lastLine.length > 5 && lastLine.length < 500;
+}
+function isUserHandoff(text) {
+  const lines = text.split(`
+`);
+  let last = "";
+  for (let i = lines.length - 1;i >= 0; i--) {
+    const t = lines[i].trim();
+    if (t.length > 0) {
+      last = t;
+      break;
+    }
+  }
+  if (!last)
+    return false;
+  if (last.endsWith("?") || last.endsWith("\uFF1F"))
+    return true;
+  const patterns = [
+    /let\s+me\s+know/i,
+    /your\s+call/i,
+    /up\s+to\s+you/i,
+    /which\s+(would|do\s+you|option)/i,
+    /should\s+I/i,
+    /want\s+me\s+to/i,
+    /would\s+you\s+like/i,
+    /say\s+the\s+word/i,
+    /give\s+the\s+go-?ahead/i,
+    /if\s+you'?d\s+like/i
+  ];
+  return patterns.some((p) => p.test(last));
+}
+function backoffMs(attempt, base, max) {
+  return Math.min(base * Math.pow(2, attempt - 1), max);
+}
+function isSilenceReason(reason) {
+  return /^no activity for \d+s/i.test(reason);
+}
+function isProviderRetryFresh(w, now = Date.now()) {
+  return w.providerRetryAt > 0 && now - w.providerRetryAt < PROVIDER_RETRY_GRACE_MS;
+}
+function isStreamingFailure(message, patterns = STREAMING_FAILURE_MESSAGE_PATTERNS) {
+  const lower = message.toLowerCase();
+  if (!lower)
+    return false;
+  return patterns.some((pattern) => {
+    try {
+      return new RegExp(pattern, "i").test(lower);
+    } catch {
+      return lower.includes(pattern.toLowerCase());
+    }
+  });
+}
+function isStreamingFailureName(name, names) {
+  return names.some((candidate) => candidate.toLowerCase() === name.toLowerCase());
+}
+function detectPatternLoop(recentTools) {
+  if (recentTools.length < 6)
+    return false;
+  for (const patternLen of [1, 2, 3]) {
+    if (recentTools.length < patternLen * 3)
+      continue;
+    const pattern = recentTools.slice(-patternLen);
+    let matches = 0;
+    for (let i = recentTools.length - patternLen * 2;i >= 0; i -= patternLen) {
+      const slice = recentTools.slice(i, i + patternLen);
+      if (slice.length !== patternLen)
+        break;
+      if (!slice.every((t, idx) => t === pattern[idx]))
+        break;
+      matches++;
+    }
+    if (matches >= 2)
+      return true;
+  }
+  return false;
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0)
+    return n;
+  if (n === 0)
+    return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0;j <= n; j++)
+    prev[j] = j;
+  for (let i = 1;i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1;j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    const tmp = prev;
+    prev = curr;
+    curr = tmp;
+  }
+  return prev[n];
+}
+var TOOL_NAME_ALIASES = {
+  bash: "shell"
+};
+function resolveToolSuggestion(wrongName, available) {
+  const alias = TOOL_NAME_ALIASES[wrongName.toLowerCase()];
+  if (alias && available.includes(alias))
+    return alias;
+  return suggestClosestTool(wrongName, available);
+}
+function suggestClosestTool(wrongName, available) {
+  const lower = wrongName.toLowerCase();
+  let best = null;
+  let bestDist = Infinity;
+  for (const id of available) {
+    const dist = levenshtein(lower, id.toLowerCase());
+    const threshold = Math.max(2, Math.floor(lower.length / 2));
+    if (dist < bestDist && dist <= threshold) {
+      bestDist = dist;
+      best = id;
+    }
+  }
+  return best;
+}
+function trackToolCall(w, toolName) {
+  const now = Date.now();
+  w.recentToolCalls = w.recentToolCalls.filter((c) => now - c.at < 120000);
+  w.recentToolCalls.push({ toolName, at: now });
+  const recentTools = w.recentToolCalls.slice(-12).map((c) => c.toolName);
+  if (recentTools.length < 6)
+    return false;
+  const lastTool = recentTools[recentTools.length - 1];
+  const consecutiveSame = recentTools.slice(-4).filter((t) => t === lastTool).length;
+  if (consecutiveSame >= 4)
+    return true;
+  return detectPatternLoop(recentTools);
+}
+function short(sid) {
+  return sid.length > 12 ? `\u2026${sid.slice(-8)}` : sid;
+}
+function sidOf(ev) {
+  const sid = ev.data?.sessionID;
+  return typeof sid === "string" ? sid : undefined;
+}
+function msgRole(m) {
+  const mm = m;
+  if (!mm || typeof mm !== "object")
+    return "";
+  const v = mm.role ?? mm.type ?? mm.info?.role;
+  return typeof v === "string" ? v : "";
+}
+function msgAt(m) {
+  const mm = m;
+  const t = mm?.time?.created ?? mm?.info?.time?.created;
+  return typeof t === "number" ? t : 0;
+}
+function messageTextOf(m) {
+  const mm = m;
+  if (!mm || typeof mm !== "object")
+    return;
+  if (Array.isArray(mm.content)) {
+    const parts = mm.content.filter((p) => p?.type === "text" && typeof p.text === "string").map((p) => p.text);
+    if (parts.length > 0)
+      return parts.join(`
+`);
+  }
+  if (typeof mm.text === "string" && mm.text.length > 0)
+    return mm.text;
+  if (typeof mm.info?.content === "string" && mm.info.content.length > 0)
+    return mm.info.content;
+  return;
+}
+var OWN_PROMPT_SHAPES = [
+  /^continue\s*\u2014\s*stalled\s*\(/,
+  /^continue\s*\nOnly continue work already in progress\./,
+  /^continue\s*\nIf work was already in progress,/
+];
+function looksLikeOwnPrompt(text) {
+  if (typeof text !== "string" || text.length === 0)
+    return false;
+  return OWN_PROMPT_SHAPES.some((re) => re.test(text));
+}
+function isTaskToolCall(ev) {
+  const tool = ev.data?.tool ?? ev.data?.toolName;
+  if (typeof tool === "string") {
+    const lower = tool.toLowerCase();
+    if (TASK_TOOL_HINTS.some((h) => lower.includes(h)))
+      return true;
+  }
+  const desc = ev.data?.input?.description ?? ev.data?.input?.subagent_type ?? ev.data?.input?.agent;
+  return typeof desc === "string";
+}
+var REGISTRY_KEY = `__auto_resume_singleton__:${process.pid}`;
+function registryKeyFor(scope) {
+  return scope ? `${REGISTRY_KEY}:${scope}` : REGISTRY_KEY;
+}
+function singletonRegistry(scope) {
+  const g = globalThis;
+  const key = registryKeyFor(scope);
+  let reg = g[key];
+  if (!reg) {
+    reg = {};
+    g[key] = reg;
+  }
+  return reg;
+}
+var MODULE_INSTANCE = `${process.pid}.${Math.random().toString(36).slice(2, 8)}`;
+var HOST_BOOT = new Date(Date.now() - process.uptime() * 1000).toISOString();
+var v2_default = define({
+  id: "auto-resume.v2",
+  setup: async (ctx) => {
+    const opts = ctx.options ?? {};
+    const registry = singletonRegistry(opts.registryScope);
+    const superseded = registry.live;
+    if (superseded) {
+      try {
+        superseded.dispose();
+      } catch {}
+      registry.live = undefined;
+    }
+    const registryScope = opts.registryScope;
+    const chunkTimeoutMs = opts.chunkTimeoutMs ?? DEFAULT_CHUNK_TIMEOUT_MS;
+    const checkIntervalMs = opts.checkIntervalMs ?? DEFAULT_CHECK_INTERVAL_MS;
+    const gracePeriodMs = opts.gracePeriodMs ?? DEFAULT_GRACE_PERIOD_MS;
+    const stuckToolAgeMs = opts.stuckToolAgeMs ?? DEFAULT_STUCK_TOOL_AGE_MS;
+    const neverInterruptTools = (opts.neverInterruptTools ?? ["compress"]).map((n) => String(n).toLowerCase());
+    const maxRetries = opts.maxRetries ?? opts.maxRecoveryRetries ?? DEFAULT_MAX_RETRIES;
+    const baseBackoff = opts.baseBackoffMs ?? DEFAULT_BASE_BACKOFF_MS;
+    const maxBackoff = opts.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+    const loopMaxContinues = opts.loopMaxContinues ?? DEFAULT_LOOP_MAX_CONTINUES;
+    const baseLoopMaxContinues = loopMaxContinues;
+    const loopWindowMs = opts.loopWindowMs ?? DEFAULT_LOOP_WINDOW_MS;
+    const lifetimeMaxContinues = opts.lifetimeMaxContinues ?? DEFAULT_LIFETIME_MAX_CONTINUES;
+    const debug = opts.debug ?? DEFAULT_DEBUG;
+    const activeUserWindowMs = opts.activeUserWindowMs ?? DEFAULT_ACTIVE_USER_WINDOW_MS;
+    const injectIntervalMs = opts.injectIntervalMs ?? DEFAULT_INJECT_INTERVAL_MS;
+    const envVisible = process.env.AUTO_RESUME_VISIBLE_CONTINUE;
+    const visibleContinue = opts.visibleContinue ?? (envVisible === undefined || envVisible === "" ? true : /^(1|true|yes)$/i.test(envVisible));
+    const quietCorrections = opts.quietCorrections ?? true;
+    const richContinuePrompt = opts.richContinuePrompt ?? true;
+    const rateLimitCooldownsMs = Array.isArray(opts.rateLimitCooldownsMs) && opts.rateLimitCooldownsMs.length > 0 && opts.rateLimitCooldownsMs.every((n) => typeof n === "number" && n > 0) ? opts.rateLimitCooldownsMs : DEFAULT_RATE_LIMIT_COOLDOWNS_MS;
+    const sendTimeoutMs = opts.sendTimeoutMs ?? DEFAULT_SEND_TIMEOUT_MS;
+    const subagentWaitMs = opts.subagentWaitMs ?? DEFAULT_SUBAGENT_WAIT_MS;
+    const subagentDeadMs = opts.subagentDeadMs ?? DEFAULT_SUBAGENT_DEAD_MS;
+    const toolTextCheckDelayMs = opts.toolTextCheckDelayMs ?? DEFAULT_TOOL_TEXT_CHECK_DELAY_MS;
+    const rawBusyStallStrategy = opts.busyStallStrategy ?? "continue";
+    const busyStallStrategy = rawBusyStallStrategy === "abort" || rawBusyStallStrategy === "off" ? rawBusyStallStrategy : "continue";
+    const resumeOnActionIntent = opts.resumeOnActionIntent !== false;
+    const warmupMs = opts.warmupMs ?? DEFAULT_WARMUP_MS;
+    const shareWatchState = opts.shareWatchState ?? DEFAULT_SHARE_WATCH_STATE;
+    const discoveryDelayMs = opts.discoveryDelayMs ?? DEFAULT_DISCOVERY_DELAY_MS;
+    const minActivityGapMs = opts.minActivityGapMs ?? DEFAULT_MIN_ACTIVITY_GAP_MS;
+    const contextSaturationThreshold = opts.contextSaturationThreshold ?? DEFAULT_CONTEXT_SATURATION_THRESHOLD;
+    const subagentNativeCompactionEnabled = opts.subagentNativeCompactionEnabled ?? false;
+    const silentDeadStreamMinTokens = opts.silentDeadStreamMinTokens ?? DEFAULT_SILENT_DEAD_STREAM_MIN_TOKENS;
+    const streamingFailureErrorNames = opts.streamingFailureErrorNames ?? DEFAULT_STREAMING_FAILURE_ERROR_NAMES;
+    const streamingFailureMessagePatterns = opts.streamingFailureMessagePatterns ?? DEFAULT_STREAMING_FAILURE_MESSAGE_PATTERNS;
+    const doneWithoutDetailsPrompt = opts.doneWithoutDetailsPrompt ?? DONE_WITHOUT_DETAILS_PROMPT;
+    const doneWithoutWorkPrompt = opts.doneWithoutWorkPrompt ?? DONE_WITHOUT_WORK_PROMPT;
+    const thinkingToolRecoveryPrompt = opts.thinkingToolRecoveryPrompt ?? THINKING_TOOL_RECOVERY_PROMPT;
+    function compilePatterns(raw, fallback, flags) {
+      const sources = Array.isArray(raw) && raw.length > 0 ? raw : fallback;
+      const out = [];
+      for (const source of sources) {
+        try {
+          out.push(new RegExp(source, flags));
+        } catch {}
+      }
+      return out;
+    }
+    const doneClaimPatterns = compilePatterns(opts.doneClaimPatterns, DEFAULT_DONE_CLAIM_PATTERNS, "im");
+    const readyToContinuePatterns = compilePatterns(opts.readyToContinuePatterns, DEFAULT_READY_TO_CONTINUE_PATTERNS, "i");
+    const streamingFailureMessageRegexes = compilePatterns(streamingFailureMessagePatterns, DEFAULT_STREAMING_FAILURE_MESSAGE_PATTERNS, "i");
+    const FEATURE_GATED_OPTIONS = [];
+    const RECOGNISED_OPTIONS = new Set([
+      "chunkTimeoutMs",
+      "checkIntervalMs",
+      "gracePeriodMs",
+      "maxRetries",
+      "maxRecoveryRetries",
+      "baseBackoffMs",
+      "maxBackoffMs",
+      "loopMaxContinues",
+      "loopWindowMs",
+      "lifetimeMaxContinues",
+      "debug",
+      "activeUserWindowMs",
+      "injectIntervalMs",
+      "visibleContinue",
+      "quietCorrections",
+      "richContinuePrompt",
+      "continuePrompt",
+      "toolTextRecoveryPrompt",
+      "actionIntentPrompt",
+      "doneWithoutWorkPrompt",
+      "busyStallStrategy",
+      "contextSaturationThreshold",
+      "subagentNativeCompactionEnabled",
+      "resumeOnActionIntent",
+      "discoveryDelayMs",
+      "warmupMs",
+      "minActivityGapMs",
+      "toolTextCheckDelayMs",
+      "subagentWaitMs",
+      "shareWatchState",
+      "registryScope",
+      "neverInterruptTools",
+      "subagentDeadMs",
+      "silentDeadStreamMinTokens",
+      "streamingFailureErrorNames",
+      "streamingFailureMessagePatterns",
+      "doneClaimPatterns",
+      "readyToContinuePatterns",
+      "doneWithoutDetailsPrompt",
+      "thinkingToolRecoveryPrompt",
+      "doneWithoutWorkPrompt",
+      "rateLimitCooldownsMs",
+      "sendTimeoutMs",
+      "stuckToolAgeMs",
+      "modelProfiles",
+      "defaultFast",
+      "defaultSlow"
+    ]);
+    const unknownOptions = Object.keys(opts).filter((key) => !RECOGNISED_OPTIONS.has(key));
+    if (unknownOptions.length > 0) {
+      log("warn", `ignoring unrecognised option(s): ${unknownOptions.join(", ")} \u2014 ` + `this v2 build does not read them. See the README on npm (opencode-auto-resume).`);
+    }
+    if (typeof ctx.app?.version !== "string") {
+      log("warn", "this looks like the opencode v1 build running on the wrong server: ctx.app.version is missing. The v2 bundle requires opencode v2 \u2014 update the plugin package (the npm build auto-selects per server) or load the build matching your server; see the README on npm (opencode-auto-resume).");
+    }
+    const gatedInUse = Object.keys(opts).filter((key) => FEATURE_GATED_OPTIONS.includes(key));
+    const dbg = (...args) => {
+      if (!debug)
+        return;
+      console.log("[auto-resume:debug]", ...args);
+    };
+    function log(level, msg) {
+      const line = `[auto-resume] ${msg}`;
+      if (level === "error")
+        console.error(line);
+      else if (level === "warn")
+        console.warn(line);
+      else
+        console.log(line);
+    }
+    const registryForState = singletonRegistry(registryScope);
+    let adoptedSessions = 0;
+    let sessions;
+    if (shareWatchState) {
+      if (!(registryForState.sessions instanceof Map)) {
+        registryForState.sessions = new Map;
+      }
+      sessions = registryForState.sessions;
+      adoptedSessions = sessions.size;
+    } else {
+      sessions = new Map;
+    }
+    const openShells = new Map;
+    function openShellCount(sid, now = Date.now()) {
+      let n = 0;
+      for (const [id, s] of openShells) {
+        if (now - s.startedAt > SHELL_OPEN_MAX_MS) {
+          openShells.delete(id);
+          continue;
+        }
+        if (s.sessionID === sid)
+          n++;
+      }
+      return n;
+    }
+    function forgetShells(sid) {
+      for (const [id, s] of openShells) {
+        if (s.sessionID === sid)
+          openShells.delete(id);
+      }
+    }
+    function ensureWatch(sid) {
+      let w = sessions.get(sid);
+      if (w) {
+        w.emptyIdleNudged ??= false;
+        w.workRetries ??= 0;
+        w.recoverGeneration ??= 0;
+        w.lifetimeContinues ??= 0;
+        w.inflightTools ??= new Map;
+        w.lastStuckToolCheck ??= 0;
+        return w;
+      }
+      if (!w) {
+        w = {
+          createdAt: Date.now(),
+          lastActivityAt: Date.now(),
+          status: "unknown",
+          userCancelled: false,
+          userCancelledAt: 0,
+          resumeAttempts: 0,
+          episodeRefires: 0,
+          workRetries: 0,
+          workSinceNudge: false,
+          lifetimeContinues: 0,
+          lastRetryAt: 0,
+          providerRetryAt: 0,
+          quotaNoticedAt: 0,
+          gaveUp: false,
+          lastQuotaNoticeAt: 0,
+          paused: false,
+          lastGenuineUserAt: 0,
+          consecFailureRecovers: 0,
+          failureLoopLatched: false,
+          aborting: false,
+          selfAbortAt: 0,
+          interruptsThisWindow: 0,
+          interruptWindowStart: 0,
+          lastInjectAt: 0,
+          lastProdText: "",
+          prodAssistantSnapshot: "",
+          completedSinceProd: 0,
+          succeededSinceProd: 0,
+          ownPromptTexts: [],
+          recovering: false,
+          oocLocked: false,
+          oocLockReason: null,
+          permLocked: false,
+          permLockReason: null,
+          indeterminateStrikes: 0,
+          selfRecovery: false,
+          textParts: new Map,
+          lastAssistantText: "",
+          lastAssistantMessageID: null,
+          toolTextAttempts: 0,
+          stuckToolAttempts: 0,
+          continueTimestamps: [],
+          doneClaimAttempts: 0,
+          doneClaimOpenTodosAttempts: 0,
+          todoNudgeAttempts: 0,
+          intentNudgeAttempts: 0,
+          completionSignaled: false,
+          completionSignaledAt: 0,
+          emptyIdleNudged: false,
+          todos: [],
+          todosFetchedAt: 0,
+          taskCompleteSignals: 0,
+          taskCompleteOverrides: 0,
+          orphanWatchStartAt: null,
+          orphanWatchArmedAt: null,
+          orphanRecoveryTried: false,
+          toolTextTimer: null,
+          recoverTimer: null,
+          recoverGeneration: 0,
+          lastSubagentCheckAt: 0,
+          pendingTools: 0,
+          toolsInFlightAtIdle: 0,
+          inflightTools: new Map,
+          rateLimitedAt: 0,
+          rateLimitAttempts: 0,
+          awaitingQuotaRetry: false,
+          unknownToolErrors: new Map,
+          unknownToolSuggestionSent: false,
+          checkedToolPartIDs: new Set,
+          lastUserMessageSeenAt: 0,
+          lastSilentReasoningCheck: 0,
+          lastStuckToolCheck: 0,
+          lastTokenTotal: 0,
+          contextWrapupAttempts: 0,
+          pendingRecoveryArmed: false,
+          permissionPending: false,
+          permissionPendingAt: null,
+          lastWasTaskTool: false,
+          idleSince: null,
+          compacting: false,
+          compactionStartedAt: null,
+          recentToolCalls: []
+        };
+        sessions.set(sid, w);
+      }
+      return w;
+    }
+    function resolveProfile(sid) {
+      const w = sessions.get(sid);
+      const model = w?.model ?? "";
+      const provider = model.split("/")[0]?.trim().toLowerCase() ?? "";
+      const isLocal = LOCAL_PROVIDERS.has(provider);
+      let base = isLocal ? { ...SLOW_PROFILE } : { ...FAST_PROFILE };
+      const defaultOverride = isLocal ? opts.defaultSlow : opts.defaultFast;
+      if (defaultOverride)
+        base = { ...base, ...defaultOverride };
+      const providerOverride = opts.modelProfiles?.[provider] ?? opts.modelProfiles?.[model.split("/")[0]?.trim() ?? ""];
+      if (providerOverride)
+        base = { ...base, ...providerOverride };
+      const chunkTimeoutMs = opts.chunkTimeoutMs ?? base.chunkTimeoutMs;
+      const gracePeriodMs = opts.gracePeriodMs ?? base.gracePeriodMs;
+      const maxRetries = opts.maxRetries ?? opts.maxRecoveryRetries ?? base.maxRetries;
+      const lifetimeMaxContinues = opts.lifetimeMaxContinues ?? base.lifetimeMaxContinues;
+      return { ...base, chunkTimeoutMs, gracePeriodMs, maxRetries, lifetimeMaxContinues };
+    }
+    let pausedCacheMtime = 0;
+    let pausedCacheSet = new Set;
+    function readPausedSet() {
+      try {
+        const st = statSync(PAUSED_MARKER_FILE);
+        if (st.mtimeMs === pausedCacheMtime)
+          return pausedCacheSet;
+        pausedCacheMtime = st.mtimeMs;
+        const raw = readFileSync(PAUSED_MARKER_FILE, "utf8");
+        const s = new Set;
+        for (const line of raw.split(/\r?\n/)) {
+          const t = line.trim();
+          if (t)
+            s.add(t);
+        }
+        pausedCacheSet = s;
+        return s;
+      } catch {
+        pausedCacheMtime = 0;
+        pausedCacheSet = new Set;
+        return pausedCacheSet;
+      }
+    }
+    function isPaused(sid) {
+      const s = readPausedSet();
+      return s.has("*") || s.has(sid);
+    }
+    function setPaused(sid, on) {
+      const s = readPausedSet();
+      if (on)
+        s.add(sid);
+      else
+        s.delete(sid);
+      try {
+        mkdirSync(dirname(PAUSED_MARKER_FILE), { recursive: true });
+      } catch {}
+      try {
+        writeFileSync(PAUSED_MARKER_FILE, [...s].join(`
+`) + (s.size ? `
+` : ""), "utf8");
+        pausedCacheMtime = 0;
+      } catch (e) {
+        dbg(`${short(sid)} pause write failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    function touch(sid) {
+      const w = ensureWatch(sid);
+      const now = Date.now();
+      if (now - w.lastActivityAt < minActivityGapMs)
+        return;
+      w.lastActivityAt = now;
+    }
+    function markBusy(sid) {
+      const w = ensureWatch(sid);
+      if (w.status !== "busy") {
+        dbg(`${short(sid)} idle/unknown -> busy`);
+        w.toolTextAttempts = 0;
+        w.stuckToolAttempts = 0;
+        w.lastStuckToolCheck = 0;
+        w.todoNudgeAttempts = 0;
+        w.intentNudgeAttempts = 0;
+        if (w.toolTextTimer) {
+          clearTimeout(w.toolTextTimer);
+          w.toolTextTimer = null;
+        }
+        w.orphanWatchStartAt = null;
+        w.orphanWatchArmedAt = null;
+        w.recentToolCalls = [];
+        w.textParts.clear();
+        w.lastAssistantText = "";
+      }
+      w.status = "busy";
+      w.idleSince = null;
+      w.lastActivityAt = Date.now();
+    }
+    function markIdle(sid) {
+      const w = ensureWatch(sid);
+      if (w.status !== "idle") {
+        dbg(`${short(sid)} ${w.status} -> idle`);
+        w.status = "idle";
+        w.idleSince = Date.now();
+        w.pendingTools = 0;
+        w.orphanWatchStartAt = null;
+        w.orphanWatchArmedAt = null;
+      }
+      clearStalePermissionFlag(sid, w);
+    }
+    function clearStalePermissionFlag(sid, w) {
+      if (!w.permissionPending)
+        return;
+      if (w.permissionPendingAt && Date.now() - w.permissionPendingAt > PERMISSION_STALE_TTL_MS) {
+        dbg(`${short(sid)} permission prompt silent >${PERMISSION_STALE_TTL_MS / 60000}m \u2014 clearing flag`);
+        w.permissionPending = false;
+        w.permissionPendingAt = null;
+      }
+    }
+    function recordContinue(sid) {
+      const w = sessions.get(sid);
+      if (!w)
+        return;
+      const now = Date.now();
+      w.continueTimestamps.push(now);
+      w.lifetimeContinues = (w.lifetimeContinues ?? 0) + 1;
+      const cutoff = now - loopWindowMs;
+      while (w.continueTimestamps.length > 0 && w.continueTimestamps[0] < cutoff) {
+        w.continueTimestamps.shift();
+      }
+    }
+    function continuesInWindow(w) {
+      const cutoff = Date.now() - loopWindowMs;
+      while (w.continueTimestamps.length > 0 && w.continueTimestamps[0] < cutoff) {
+        w.continueTimestamps.shift();
+      }
+      return w.continueTimestamps.length;
+    }
+    function lifetimeExhausted(sid, w) {
+      const profile = resolveProfile(sid);
+      const profileLifetimeMaxContinues = profile.lifetimeMaxContinues;
+      if ((w.lifetimeContinues ?? 0) >= profileLifetimeMaxContinues) {
+        if (!w.gaveUp) {
+          log("warn", `${short(sid)} lifetime cap (${profileLifetimeMaxContinues} continues, no genuine user message) \u2014 standing down`);
+          w.gaveUp = true;
+        }
+        return true;
+      }
+      return false;
+    }
+    function selfAbortActive(w) {
+      return w.selfAbortAt > 0 && Date.now() - w.selfAbortAt < SELF_ABORT_TTL_MS;
+    }
+    function isAbortError(errType, errMsg) {
+      return ABORT_ERROR_TYPE_RE.test(errType.trim()) || ABORT_ERROR_MSG_RE.test(errMsg);
+    }
+    function isRateLimitError(errType, errMsg) {
+      return RATE_LIMIT_RE.test(`${errType} ${errMsg}`);
+    }
+    async function sendQuotaNotice(sid, text) {
+      try {
+        await sendBound("quota-notice", sid, () => ctx.session.synthetic({ sessionID: sid, text, description: "auto-resume: quota notice", resume: false }));
+      } catch (e) {
+        log("warn", `${short(sid)} quota notice failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    function serveQuotaRung(sid, w, rung, ladder) {
+      w.rateLimitAttempts = rung + 1;
+      w.rateLimitedAt = Date.now();
+      w.awaitingQuotaRetry = false;
+      w.pendingRecoveryArmed = true;
+      w.quotaNoticedAt = 0;
+      log("info", `${short(sid)} rate-limit cooldown served \u2014 retrying (attempt ${rung + 1}/${ladder.length}) mod=${MODULE_INSTANCE}`);
+      syncQuotaState(sid, w);
+      const cooldownMin = Math.max(1, Math.round(ladder[rung] / 60000));
+      recover(sid, `rate-limit cooldown served (rung ${rung + 1}/${ladder.length}, ${cooldownMin}m)`);
+    }
+    function handleRateLimitFailure(sid, w, errType, errMsg) {
+      if (isPaused(sid)) {
+        dbg(`${short(sid)} paused \u2014 not arming quota ladder`);
+        return;
+      }
+      const ladder = rateLimitCooldownsMs;
+      const tag = "rate-limit";
+      const n = w.rateLimitAttempts;
+      markIdle(sid);
+      if (n >= ladder.length) {
+        w.awaitingQuotaRetry = false;
+        log("warn", `${short(sid)} ${tag} budget exhausted (${ladder.length} attempts) \u2014 standing down until user turn`);
+        if (!w.quotaNoticedAt && Date.now() - w.lastQuotaNoticeAt > 100) {
+          w.quotaNoticedAt = Date.now();
+          w.lastQuotaNoticeAt = Date.now();
+          sendQuotaNotice(sid, `Rate limited \u2014 standing down until you return (budget exhausted after ${ladder.length} attempts).`);
+        }
+        return;
+      }
+      const now = Date.now();
+      if (w.rateLimitedAt > 0 && now - w.rateLimitedAt >= ladder[n]) {
+        serveQuotaRung(sid, w, n, ladder);
+        return;
+      }
+      if (w.rateLimitedAt > 0 && now - w.rateLimitedAt < ladder[n]) {
+        return;
+      }
+      if (w.rateLimitedAt === 0)
+        w.rateLimitedAt = now;
+      w.awaitingQuotaRetry = true;
+      const waitMs = Math.max(0, ladder[n] - (now - w.rateLimitedAt));
+      log("warn", `${short(sid)} rate limited (${errType || "error"}) \u2014 standing down, next attempt in ${Math.ceil(waitMs / 1000)}s (${n + 1}/${ladder.length})`);
+      if (!w.quotaNoticedAt && Date.now() - w.lastQuotaNoticeAt > 100) {
+        w.quotaNoticedAt = Date.now();
+        w.lastQuotaNoticeAt = Date.now();
+        const mins = Math.max(1, Math.round(waitMs / 60000));
+        const when = mins >= 60 ? `~${Math.floor(mins / 60)}h ${mins % 60}m` : `~${mins}m`;
+        sendQuotaNotice(sid, `Rate limited, retrying in ${when} (attempt ${n + 1}/${ladder.length}).`);
+      }
+      log("warn", `quota-armed sid=${sid} at=${now} rung=${n} ladder=${ladder.length}`);
+      syncQuotaState(sid, w);
+    }
+    function interruptBudget(w) {
+      if (w.interruptWindowStart === 0 || Date.now() - w.interruptWindowStart > INTERRUPT_WINDOW_MS) {
+        w.interruptWindowStart = Date.now();
+        w.interruptsThisWindow = 0;
+      }
+      return MAX_INTERRUPTS_PER_WINDOW - w.interruptsThisWindow;
+    }
+    function busySessions() {
+      const out = [];
+      for (const [sid, w] of sessions) {
+        if (w.status === "busy" && !w.userCancelled)
+          out.push(sid);
+      }
+      return out;
+    }
+    let sessionRowsCache = null;
+    const SESSION_ROWS_TTL_MS = 1e4;
+    async function listSessionsHttp() {
+      const now = Date.now();
+      if (sessionRowsCache && now - sessionRowsCache.at < SESSION_ROWS_TTL_MS)
+        return sessionRowsCache.rows;
+      for (const base of serverBaseUrls()) {
+        try {
+          const res = await fetch(`${base}/api/session?limit=500`, { headers: serverHeaders() });
+          if (!res.ok)
+            continue;
+          const body = await res.json();
+          const data = body?.data ?? body;
+          if (Array.isArray(data)) {
+            const rows = data.filter((r) => r !== null && typeof r === "object");
+            sessionRowsCache = { at: now, rows };
+            return rows;
+          }
+        } catch {}
+      }
+      return sessionRowsCache?.rows ?? [];
+    }
+    async function isSubAgentSession(sid) {
+      const w = ensureWatch(sid);
+      if (typeof w.isSubAgent === "boolean")
+        return w.isSubAgent;
+      let sub = false;
+      try {
+        const res = await ctx.client?.session.get({ path: { id: sid } });
+        sub = !!res?.data?.parentID;
+      } catch {
+        sub = false;
+      }
+      if (!sub) {
+        try {
+          const rows = await listSessionsHttp();
+          sub = rows.some((r) => r?.id === sid && typeof r?.parentID === "string");
+        } catch {
+          sub = false;
+        }
+      }
+      w.isSubAgent = sub;
+      return sub;
+    }
+    const RECENT_PROD_WINDOW_MS = 60000;
+    async function recentOwnProdInLog(sid, text) {
+      const pages = [];
+      try {
+        const message = ctx.client?.session?.message;
+        if (typeof message?.list === "function") {
+          const res = await message.list.call(message, { path: { id: sid } });
+          const data = res?.data ?? res;
+          if (Array.isArray(data))
+            pages.push(...data);
+        }
+      } catch {}
+      if (pages.length === 0) {
+        for (const base of serverBaseUrls()) {
+          try {
+            const res = await fetch(`${base}/api/session/${encodeURIComponent(sid)}/message?limit=20`, { headers: serverHeaders() });
+            if (!res.ok)
+              continue;
+            const body = (await res.json())?.data;
+            if (Array.isArray(body)) {
+              pages.push(...body);
+              break;
+            }
+          } catch {}
+        }
+      }
+      if (pages.length === 0)
+        return false;
+      const now = Date.now();
+      for (const m of pages) {
+        if (m === null || typeof m !== "object")
+          continue;
+        const msg = m;
+        if (msg.role !== "user")
+          continue;
+        let t = "";
+        if (typeof msg.text === "string") {
+          t = msg.text;
+        } else if (Array.isArray(msg.content)) {
+          t = msg.content.filter((p) => !!p && typeof p === "object" && p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+        }
+        if (t !== text)
+          return false;
+        const created = msg.time?.created;
+        if (typeof created === "number" && now - created > RECENT_PROD_WINDOW_MS)
+          return false;
+        return true;
+      }
+      return false;
+    }
+    const injectLocks = new Map;
+    async function withInjectLock(sid, fn) {
+      const prev = injectLocks.get(sid) ?? Promise.resolve();
+      let release;
+      const current = new Promise((resolve) => {
+        release = resolve;
+      });
+      const tail = prev.then(() => current);
+      injectLocks.set(sid, tail);
+      await prev;
+      try {
+        return await fn();
+      } finally {
+        release();
+        if (injectLocks.get(sid) === tail)
+          injectLocks.delete(sid);
+      }
+    }
+    async function injectOnceLocked(sid, text, notification, allowDuringSelfAbort, checkDuplicate, forceSynthetic = false) {
+      if (!running)
+        return false;
+      const w = ensureWatch(sid);
+      if (await isSubAgentSession(sid)) {
+        dbg(`${short(sid)} subagent session \u2014 injection refused (parent owns recovery)`);
+        return false;
+      }
+      {
+        const kind = lockKind(w);
+        if (kind) {
+          dbg(`${short(sid)} locked (${kind}) \u2014 injection refused on every path`);
+          return false;
+        }
+      }
+      if (!allowDuringSelfAbort && selfAbortActive(w)) {
+        dbg(`${short(sid)} injection refused \u2014 inside our own abort window`);
+        return false;
+      }
+      if (!allowDuringSelfAbort && w.status === "busy" && Date.now() - w.lastActivityAt < chunkTimeoutMs) {
+        dbg(`${short(sid)} injection refused \u2014 session busy and live (${Math.round((Date.now() - w.lastActivityAt) / 1000)}s since last event)`);
+        return false;
+      }
+      const since = Date.now() - w.lastInjectAt;
+      if (!allowDuringSelfAbort && w.lastInjectAt > 0 && since < injectIntervalMs) {
+        dbg(`${short(sid)} injection debounced \u2014 ${Math.round(since / 1000)}s since last (min ${injectIntervalMs / 1000}s)`);
+        return false;
+      }
+      if (checkDuplicate && !allowDuringSelfAbort && w.lastProdText !== "" && text === w.lastProdText && w.pendingTools <= 0 && w.completedSinceProd === 0 && w.lastAssistantText === w.prodAssistantSnapshot) {
+        dbg(`${short(sid)} duplicate continue suppressed \u2014 identical text, no progress since last prod`);
+        return false;
+      }
+      w.lastInjectAt = Date.now();
+      if (!allowDuringSelfAbort && await recentOwnProdInLog(sid, text)) {
+        dbg(`${short(sid)} duplicate continue suppressed \u2014 identical prod already in session log`);
+        return false;
+      }
+      const sent = await notifyAndPrompt(sid, text, notification, true, forceSynthetic);
+      if (sent) {
+        w.lastProdText = text;
+        w.completedSinceProd = 0;
+        w.succeededSinceProd = 0;
+        w.prodAssistantSnapshot = w.lastAssistantText;
+        w.ownPromptTexts.push(text);
+        if (w.ownPromptTexts.length > 10)
+          w.ownPromptTexts.shift();
+      }
+      return sent;
+    }
+    async function injectOnce(sid, text, notification, allowDuringSelfAbort = false, checkDuplicate = false, forceSynthetic = false) {
+      const sendText = forceSynthetic ? `${text} Do not acknowledge this message and do not reply to it visibly; apply it silently and continue the task.` : text;
+      return withInjectLock(sid, () => injectOnceLocked(sid, sendText, notification, allowDuringSelfAbort, checkDuplicate, forceSynthetic));
+    }
+    function cleanupIdleSessions() {
+      const now = Date.now();
+      const busy = new Set;
+      for (const [sid, w] of sessions) {
+        if (w.status === "busy")
+          busy.add(sid);
+      }
+      let idleCount = 0;
+      const toDelete = [];
+      for (const [sid, w] of sessions) {
+        if (w.status !== "busy") {
+          idleCount++;
+          if (w.idleSince && now - w.idleSince > IDLE_CLEANUP_MS)
+            toDelete.push(sid);
+        }
+      }
+      if (idleCount > MAX_IDLE_SESSIONS) {
+        const entries = [];
+        for (const [sid, w] of sessions) {
+          if (w.status !== "busy" && w.idleSince)
+            entries.push({ sid, since: w.idleSince });
+        }
+        entries.sort((a, b) => a.since - b.since);
+        const excess = idleCount - MAX_IDLE_SESSIONS;
+        for (let i = 0;i < excess && i < entries.length; i++) {
+          if (!toDelete.includes(entries[i].sid))
+            toDelete.push(entries[i].sid);
+        }
+      }
+      let cleaned = 0;
+      for (const sid of toDelete) {
+        if (openShellCount(sid) > 0)
+          continue;
+        forgetShells(sid);
+        sessions.delete(sid);
+        cleaned++;
+      }
+      if (cleaned > 0)
+        dbg(`cleaned ${cleaned} idle sessions, total=${sessions.size}`);
+    }
+    function appendText(sid, messageID, delta) {
+      const w = ensureWatch(sid);
+      if (delta && (w.consecFailureRecovers > 0 || w.failureLoopLatched)) {
+        w.consecFailureRecovers = 0;
+        if (w.failureLoopLatched) {
+          w.failureLoopLatched = false;
+          log("info", `${short(sid)} model output after failure loop \u2014 latch cleared`);
+        }
+      }
+      const mid = messageID ?? "_anon";
+      w.textParts.set(mid, (w.textParts.get(mid) ?? "") + delta);
+      w.lastAssistantMessageID = mid;
+      w.lastAssistantText = w.textParts.get(mid) ?? "";
+      if (w.textParts.size > 2) {
+        const oldest = w.textParts.keys().next().value;
+        if (oldest !== undefined && oldest !== mid)
+          w.textParts.delete(oldest);
+      }
+      if (w.lastAssistantText.length > TEXT_BUFFER_TRIM_LEN) {
+        w.textParts.set(mid, w.lastAssistantText.slice(-TEXT_BUFFER_TRIM_LEN));
+        w.lastAssistantText = w.textParts.get(mid) ?? "";
+      }
+    }
+    async function sendBound(label, sid, send) {
+      const started = Date.now();
+      let timer;
+      try {
+        await Promise.race([
+          send(),
+          new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`${label} timed out after ${sendTimeoutMs}ms`)), sendTimeoutMs);
+          })
+        ]);
+      } finally {
+        if (timer !== undefined)
+          clearTimeout(timer);
+      }
+      const elapsed = Date.now() - started;
+      if (elapsed > SEND_SLOW_MS) {
+        log("warn", `${short(sid)} ${label} took ${Math.round(elapsed / 1000)}s (over ${SEND_SLOW_MS / 1000}s slow threshold)`);
+      }
+    }
+    async function notifyAndPrompt(sid, text, notification, resume = true, forceSynthetic = false) {
+      ensureWatch(sid).selfRecovery = true;
+      if (visibleContinue && !forceSynthetic) {
+        try {
+          await sendBound("prompt", sid, () => ctx.session.prompt({ sessionID: sid, text }));
+          return true;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log("warn", `${short(sid)} visible prompt failed: ${msg}`);
+          if (await recentOwnProdInLog(sid, text)) {
+            dbg(`${short(sid)} prompt threw but the text is already the newest user message \u2014 treating as delivered`);
+            return true;
+          }
+          if (!running)
+            return false;
+        }
+      }
+      try {
+        await sendBound("synthetic", sid, () => ctx.session.synthetic({
+          sessionID: sid,
+          text,
+          description: `auto-resume: ${notification}`,
+          resume
+        }));
+        return true;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log("warn", `${short(sid)} synthetic failed: ${msg}`);
+        if (!running)
+          return false;
+        if (await recentOwnProdInLog(sid, text)) {
+          dbg(`${short(sid)} synthetic threw but the text is already the newest user message \u2014 treating as delivered`);
+          return true;
+        }
+        try {
+          await sendBound("prompt", sid, () => ctx.session.prompt({ sessionID: sid, text }));
+          return true;
+        } catch {
+          log("error", `${short(sid)} all recovery attempts failed: ${msg}`);
+          return false;
+        }
+      }
+    }
+    async function tryAbortAndResume(sid, w, force = false) {
+      if (await isSubAgentSession(sid)) {
+        dbg(`${short(sid)} subagent session \u2014 abort+resume refused`);
+        return false;
+      }
+      if (w.userCancelled) {
+        dbg(`${short(sid)} user cancelled \u2014 refusing abort+resume escalation`);
+        return false;
+      }
+      if (!force && w.status === "busy") {
+        dbg(`${short(sid)} busy \u2014 refusing abort+resume escalation`);
+        return false;
+      }
+      if (w.aborting || selfAbortActive(w))
+        return false;
+      {
+        const kind = lockKind(w);
+        if (kind) {
+          dbg(`${short(sid)} ${kind} locked \u2014 refusing abort+resume escalation`);
+          return false;
+        }
+      }
+      if (w.compacting) {
+        dbg(`${short(sid)} mid-compaction \u2014 refusing abort+resume escalation`);
+        return false;
+      }
+      if (interruptBudget(w) <= 0) {
+        w.continueTimestamps = [];
+        log("warn", `${short(sid)} interrupt budget exhausted (${MAX_INTERRUPTS_PER_WINDOW}/${INTERRUPT_WINDOW_MS / 60000}m) \u2014 skipping interrupt, loop guard reset`);
+        return false;
+      }
+      w.aborting = true;
+      w.selfAbortAt = Date.now();
+      w.interruptsThisWindow++;
+      log("warn", `${short(sid)} escalating: interrupt + fresh continue (${w.interruptsThisWindow}/${MAX_INTERRUPTS_PER_WINDOW} per ${INTERRUPT_WINDOW_MS / 60000}m)`);
+      try {
+        await ctx.session.interrupt({ sessionID: sid });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log("warn", `${short(sid)} interrupt failed: ${msg}`);
+      }
+      await new Promise((r) => setTimeout(r, 2000));
+      if (!running)
+        return false;
+      w.aborting = false;
+      w.resumeAttempts = 0;
+      syncCounters(sid, w);
+      w.gaveUp = false;
+      w.emptyIdleNudged = false;
+      const ok = await injectOnce(sid, opts.continuePrompt ?? SAFE_CONTINUE_PROMPT, "abort+resume escalation", true);
+      if (ok) {
+        w.lastRetryAt = Date.now();
+        log("info", `${short(sid)} resumed after abort`);
+      }
+      return ok;
+    }
+    function permanentFailureReason(errMsg, errType, status) {
+      if (errType && PERMANENT_ERROR_TYPES.has(errType))
+        return `type ${errType}`;
+      if (typeof status === "number" && PERMANENT_STATUS_CODES.has(status))
+        return `http ${status}`;
+      if (PERMANENT_GONE_RE.test(errMsg))
+        return errMsg.slice(0, 160);
+      if (PERMANENT_HISTORY_RE.test(errMsg))
+        return errMsg.slice(0, 160);
+      if (PERMANENT_UNKNOWN_MODEL_RE.test(errMsg)) {
+        if (status === 404)
+          return null;
+        return errMsg.slice(0, 160);
+      }
+      return null;
+    }
+    function maybeLockPermanent(sid, errMsg, errType, status) {
+      const w = ensureWatch(sid);
+      if (w.permLocked)
+        return true;
+      let why = permanentFailureReason(errMsg, errType, status);
+      if (why === null && errType && INDETERMINATE_ERROR_TYPES.has(errType)) {
+        w.indeterminateStrikes++;
+        if (w.indeterminateStrikes < INDETERMINATE_STRIKES) {
+          log("info", `${short(sid)} indeterminate failure (${errType}) ${w.indeterminateStrikes}/${INDETERMINATE_STRIKES} \u2014 one recovery attempt before latching mod=${MODULE_INSTANCE}`);
+          return false;
+        }
+        why = `type ${errType} (${INDETERMINATE_STRIKES} strikes)`;
+      }
+      if (why === null)
+        return false;
+      w.permLocked = true;
+      w.permLockReason = why;
+      log("warn", `${short(sid)} permanent failure latched (${why}) \u2014 recovery locked out until a genuine turn: ${errMsg.slice(0, 120)} mod=${MODULE_INSTANCE}`);
+      return true;
+    }
+    function lockKind(w) {
+      if (w.permLocked)
+        return "permanent";
+      if (w.oocLocked)
+        return "ooc";
+      return null;
+    }
+    function lockReason(w) {
+      const kind = lockKind(w);
+      if (kind === "permanent")
+        return w.permLockReason?.slice(0, 80) ?? "n/a";
+      if (kind === "ooc")
+        return w.oocLockReason?.slice(0, 80) ?? "n/a";
+      return "n/a";
+    }
+    function clearLocks(w, sid) {
+      if (w.oocLocked) {
+        w.oocLocked = false;
+        w.oocLockReason = null;
+        log("info", `${short(sid)} genuine execution \u2014 clearing OOC lock mod=${MODULE_INSTANCE}`);
+      }
+      w.indeterminateStrikes = 0;
+      if (w.permLocked) {
+        w.permLocked = false;
+        w.permLockReason = null;
+        log("info", `${short(sid)} genuine execution \u2014 clearing permanent-failure lock mod=${MODULE_INSTANCE}`);
+      }
+      w.consecFailureRecovers = 0;
+      if (w.failureLoopLatched) {
+        w.failureLoopLatched = false;
+        log("info", `${short(sid)} genuine execution \u2014 clearing failure-loop latch mod=${MODULE_INSTANCE}`);
+      }
+    }
+    function maybeLockOoc(sid, errMsg, errType = "") {
+      const w = ensureWatch(sid);
+      if (w.oocLocked)
+        return;
+      if (isRateLimitError(errType, errMsg))
+        return;
+      if (!OOC_ERROR_RE.test(errMsg))
+        return;
+      w.oocLocked = true;
+      w.oocLockReason = errMsg.slice(0, 200);
+      log("warn", `${short(sid)} OOC error latched \u2014 recovery locked out until a genuine turn: ${errMsg.slice(0, 120)} mod=${MODULE_INSTANCE}`);
+    }
+    async function buildStallContinueText(sid, reason, attempt, providerFault = false, prospectiveRetries) {
+      const w = ensureWatch(sid);
+      if (opts.continuePrompt !== undefined && opts.continuePrompt !== "")
+        return opts.continuePrompt;
+      if (!richContinuePrompt)
+        return CONTINUE_PROMPT;
+      let suffix = "Todo list unavailable.";
+      try {
+        const todos = await readTodos(sid);
+        const open = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
+        if (open.length > 0) {
+          const lines = open.slice(0, 5).map((t) => `\u2022 [${t.status}] ${String(t.content).slice(0, 120)}`);
+          if (open.length > 5)
+            lines.push(`\u2022 \u2026and ${open.length - 5} more`);
+          suffix = `Remaining todos:
+${lines.join(`
+`)}`;
+        } else {
+          suffix = "No open todos recorded.";
+        }
+      } catch {}
+      const now = new Date().toLocaleString("en-US", {
+        month: "short",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+        timeZoneName: "short"
+      });
+      const elapsed = w.lastActivityAt ? Math.round((Date.now() - w.lastActivityAt) / 1000) : 0;
+      const hms = (n) => n < 60 ? `${n}s` : n < 3600 ? `${Math.floor(n / 60)}m ${n % 60}s` : `${Math.floor(n / 3600)}h ${Math.floor(n % 3600 / 60)}m`;
+      const isRateLimitReason = /rate-limit/i.test(reason);
+      const isSilence = isSilenceReason(reason);
+      const shown = providerFault ? attempt : attempt;
+      const retries = prospectiveRetries ?? w.workRetries;
+      const head = [
+        isSilence ? null : reason,
+        isRateLimitReason ? null : `attempt ${Math.min(shown, maxRetries)}/${maxRetries} (retry #${retries})`,
+        isSilence ? `idle ${hms(elapsed)}` : null,
+        now
+      ].filter((x) => typeof x === "string" && x.length > 0).join("; ");
+      return (`continue \u2014 stalled (${head}).
+Only continue work already in progress. ` + `Do not start anything new, and do not take destructive or irreversible actions without explicit user approval.
+${suffix}`).slice(0, 2000);
+    }
+    async function recover(sid, reason) {
+      const w = ensureWatch(sid);
+      if (isPaused(sid)) {
+        dbg(`${short(sid)} paused \u2014 skipping recover (${reason})`);
+        return;
+      }
+      if (w.recovering || w.aborting || w.gaveUp || w.userCancelled || w.permissionPending)
+        return;
+      if (w.failureLoopLatched) {
+        dbg(`${short(sid)} failure loop latched \u2014 standing down until a genuine turn or fresh model output`);
+        return;
+      }
+      if (reason.startsWith("session.step.failed") || reason.startsWith("session.execution.failed")) {
+        w.consecFailureRecovers++;
+        if (w.consecFailureRecovers > FAILURE_LOOP_MAX) {
+          w.failureLoopLatched = true;
+          log("warn", `${short(sid)} ${w.consecFailureRecovers} consecutive failure recoveries with no model output \u2014 backend likely down, standing down until a genuine turn mod=${MODULE_INSTANCE}`);
+          return;
+        }
+      }
+      {
+        const kind = lockKind(w);
+        if (kind) {
+          dbg(`${short(sid)} ${kind} locked \u2014 refusing recovery (reason: ${lockReason(w)})`);
+          return;
+        }
+      }
+      if (w.compacting) {
+        dbg(`${short(sid)} mid-compaction \u2014 refusing recovery (reason: ${reason})`);
+        return;
+      }
+      if (selfAbortActive(w)) {
+        dbg(`${short(sid)} self-abort in flight \u2014 refusing recovery (reason: ${reason})`);
+        return;
+      }
+      if (continuesInWindow(w) >= baseLoopMaxContinues) {
+        log("warn", `${short(sid)} hallucination loop (${baseLoopMaxContinues} continues/${loopWindowMs / 1000}s) \u2014 abort+resume`);
+        await tryAbortAndResume(sid, w);
+        w.continueTimestamps = [];
+        return;
+      }
+      if (w.lastProdText !== "" && w.lastAssistantText !== w.prodAssistantSnapshot) {
+        w.workSinceNudge = true;
+        log("info", `${short(sid)} text growth since last prod \u2014 restarting the stall ladder`);
+        if (w.resumeAttempts > 0)
+          w.episodeRefires++;
+        w.resumeAttempts = 0;
+        if (w.completionSignaled) {
+          w.completionSignaled = false;
+          w.completionSignaledAt = 0;
+          dbg(`${short(sid)} model output after TASK COMPLETE \u2014 re-opening latched completion`);
+        }
+      } else if (isSilenceReason(reason) && w.succeededSinceProd > 0) {
+        w.workSinceNudge = true;
+        log("info", `${short(sid)} progress since last prod \u2014 restarting the stall ladder`);
+        if (w.resumeAttempts > 0)
+          w.episodeRefires++;
+        w.resumeAttempts = 0;
+      }
+      syncCounters(sid, w);
+      if (lifetimeExhausted(sid, w))
+        return;
+      const profile = resolveProfile(sid);
+      const profileMaxRetries = profile.maxRetries;
+      const profileLifetimeMaxContinues = profile.lifetimeMaxContinues;
+      const providerFault = isProviderRetryFresh(w) && (reason.startsWith("session.step.failed") || reason.startsWith("session.execution.failed"));
+      if (!providerFault && w.resumeAttempts >= profileMaxRetries) {
+        log("warn", `${short(sid)} giving up after ${profileMaxRetries} attempts (${reason}) mod=${MODULE_INSTANCE}`);
+        w.gaveUp = true;
+        return;
+      }
+      w.recovering = true;
+      const attempt = providerFault ? Math.max(1, w.resumeAttempts) : w.resumeAttempts + 1;
+      const delay = backoffMs(attempt, baseBackoff, maxBackoff);
+      if (providerFault) {
+        log("info", `${short(sid)} provider-fault stall (${reason}) \u2014 retry scheduled ${Math.round((Date.now() - w.providerRetryAt) / 1000)}s ago, holding the ladder at ${attempt}/${profileMaxRetries}`);
+      }
+      log("info", `${short(sid)} stall detected (${reason}) \u2014 resume attempt ${attempt}/${profileMaxRetries} in ${delay}ms` + ` (work #${w.workRetries} this session)`);
+      if (w.recoverTimer)
+        clearTimeout(w.recoverTimer);
+      const gen = ++w.recoverGeneration;
+      const armedAt = Date.now();
+      let delivered = false;
+      w.recoverTimer = setTimeout(async () => {
+        w.recoverTimer = null;
+        if (gen !== w.recoverGeneration)
+          return;
+        let rungFloor = -1;
+        if (!running)
+          return;
+        try {
+          if (w.userCancelled || w.gaveUp)
+            return;
+          const history = await loadMessages(sid);
+          noteInboundUserMessage(sid, w, history);
+          if (w.lastGenuineUserAt >= armedAt) {
+            dbg(`${short(sid)} genuine user message after arm \u2014 parking recovery`);
+            return;
+          }
+          if (w.status === "idle" && !w.pendingRecoveryArmed)
+            return;
+          if (w.compacting) {
+            dbg(`${short(sid)} mid-compaction at inject time \u2014 not interrupting`);
+            return;
+          }
+          if (w.status === "busy" && Date.now() - w.lastActivityAt < chunkTimeoutMs) {
+            dbg(`${short(sid)} still busy and live at inject time (${Math.round((Date.now() - w.lastActivityAt) / 1000)}s since last event) \u2014 not interrupting`);
+            return;
+          }
+          if (await parentWaitingOnSubagents(sid, new Set(await getActiveSessions()))) {
+            dbg(`${short(sid)} waiting on subagents at inject time \u2014 not interrupting`);
+            return;
+          }
+          if (isWaitingOnUser(sid, w, history)) {
+            dbg(`${short(sid)} waiting on user input at inject time \u2014 not interrupting`);
+            return;
+          }
+          rungFloor = w.workRetries;
+          const prospectiveRetries = w.workRetries + 1;
+          w.workRetries = prospectiveRetries;
+          const progressReportThreshold = Math.max(7, Math.floor(profileLifetimeMaxContinues * 0.7));
+          const isProgressReport = prospectiveRetries >= progressReportThreshold;
+          const stallText = isProgressReport ? `PROGRESS REPORT REQUIRED (attempt ${Math.min(attempt, profileMaxRetries)}/${profileMaxRetries}, retry #${prospectiveRetries}/${profileLifetimeMaxContinues}): this session has been nudged multiple times. Please report exactly what you have completed and what remains. If work is done, call task_complete. If blocked, say what you need. If still working, say what step you are on. Do not start new work \u2014 only continue the current task.` : await buildStallContinueText(sid, reason, attempt, providerFault, prospectiveRetries);
+          const ok = await injectOnce(sid, stallText, isProgressReport ? "stalled \u2014 progress report" : "stalled \u2014 retrying", false, true);
+          w.pendingRecoveryArmed = false;
+          if (ok) {
+            delivered = true;
+            w.workSinceNudge = false;
+            if (!providerFault && attempt > w.resumeAttempts)
+              w.resumeAttempts = attempt;
+            recordContinue(sid);
+            syncCounters(sid, w);
+            w.lastRetryAt = Date.now();
+            touch(sid);
+            markBusy(sid);
+          } else if (attempt >= maxRetries) {
+            await tryAbortAndResume(sid, w);
+          }
+        } finally {
+          if (!delivered && rungFloor >= 0 && w.workRetries === rungFloor + 1)
+            w.workRetries = rungFloor;
+          syncCounters(sid, w);
+          w.recovering = false;
+          if (!delivered) {
+            dbg(`${short(sid)} attempt ${attempt}/${maxRetries} not delivered \u2014 rung not consumed (${reason})`);
+          }
+        }
+      }, delay);
+    }
+    async function readTodos(sid) {
+      const w = ensureWatch(sid);
+      const now = Date.now();
+      if (w.todosFetchedAt && now - w.todosFetchedAt < TODO_CACHE_TTL_MS)
+        return w.todos;
+      const fromMessages = await todosFromMessageSources(sid);
+      if (fromMessages) {
+        w.todos = fromMessages;
+        w.todosFetchedAt = now;
+        return w.todos;
+      }
+      if (!ctx.storage)
+        return w.todos;
+      try {
+        const raw = await ctx.storage.get(`todos/${sid}`);
+        const record = raw;
+        const list = Array.isArray(record?.todos) ? record.todos : [];
+        w.todos = list.filter((t) => !!t && typeof t === "object" && typeof t.content === "string" && typeof t.status === "string");
+        w.todosFetchedAt = now;
+        return w.todos;
+      } catch (e) {
+        dbg(`${short(sid)} todo read failed:`, e instanceof Error ? e.message : String(e));
+        return w.todos;
+      }
+    }
+    async function todosFromMessageSources(sid) {
+      try {
+        const message = ctx.client?.session?.message;
+        if (typeof message?.list === "function") {
+          const res = await message.list.call(message, { path: { id: sid } });
+          const got = todosFromMessages(res?.data ?? res);
+          if (got) {
+            dbg(`${short(sid)} todos via ctx.client.session.message.list (${got.length})`);
+            return got;
+          }
+        }
+      } catch (e) {
+        dbg(`${short(sid)} client message.list failed:`, e instanceof Error ? e.message : String(e));
+      }
+      for (const base of serverBaseUrls()) {
+        try {
+          const res = await fetch(`${base}/api/session/${encodeURIComponent(sid)}/message?limit=200`, {
+            headers: serverHeaders()
+          });
+          if (!res.ok) {
+            dbg(`${short(sid)} HTTP message read ${res.status} from ${base}`);
+            continue;
+          }
+          const body = await res.json();
+          const got = todosFromMessages(body?.data ?? body);
+          if (got) {
+            dbg(`${short(sid)} todos via HTTP ${base} (${got.length})`);
+            return got;
+          }
+        } catch (e) {
+          dbg(`${short(sid)} HTTP message read failed:`, e instanceof Error ? e.message : String(e));
+        }
+      }
+      return;
+    }
+    function schedulePatternPass(sid) {
+      const w = ensureWatch(sid);
+      if (w.toolTextTimer)
+        clearTimeout(w.toolTextTimer);
+      w.toolTextTimer = setTimeout(() => {
+        w.toolTextTimer = null;
+        if (w.status !== "idle") {
+          dbg(`${short(sid)} pattern pass skipped \u2014 session is ${w.status}, not idle`);
+          return;
+        }
+        if (w.userCancelled)
+          return;
+        inspectOnIdle(sid, "pattern");
+      }, toolTextCheckDelayMs);
+      dbg(`${short(sid)} pattern pass armed for +${toolTextCheckDelayMs}ms`);
+    }
+    async function targetedRecovery(sid, kind, prompt, budgetKey) {
+      const w = ensureWatch(sid);
+      if (w.recovering || w.userCancelled || w.permissionPending)
+        return;
+      {
+        const locked = lockKind(w);
+        if (locked) {
+          dbg(`${short(sid)} locked (${locked}) \u2014 skipping ${kind} nudge`);
+          return;
+        }
+      }
+      if (w.compacting) {
+        dbg(`${short(sid)} mid-compaction \u2014 skipping ${kind} nudge`);
+        return;
+      }
+      const busyShells = openShellCount(sid);
+      if (busyShells > 0) {
+        dbg(`${short(sid)} ${busyShells} shell(s) still running \u2014 skipping ${kind} nudge`);
+        return;
+      }
+      if (selfAbortActive(w)) {
+        dbg(`${short(sid)} self-abort in flight \u2014 skipping ${kind} nudge`);
+        return;
+      }
+      if (continuesInWindow(w) >= baseLoopMaxContinues) {
+        log("warn", `${short(sid)} loop guard before ${kind} nudge \u2014 abort+resume`);
+        await tryAbortAndResume(sid, w);
+        w.continueTimestamps = [];
+        return;
+      }
+      if (lifetimeExhausted(sid, w))
+        return;
+      recordContinue(sid);
+      syncCounters(sid, w);
+      if (w[budgetKey] >= maxRetries) {
+        dbg(`${short(sid)} ${kind} budget exhausted`);
+        return;
+      }
+      const attemptNum = w[budgetKey] + 1;
+      log("info", `${short(sid)} ${kind} detected \u2014 sending targeted prompt (${attemptNum}/${maxRetries})`);
+      w.recovering = true;
+      const ok = await injectOnce(sid, prompt, "recovering: " + kind, false, false, quietCorrections);
+      w.recovering = false;
+      if (ok) {
+        w[budgetKey] = attemptNum;
+        touch(sid);
+        markBusy(sid);
+      } else {
+        dbg(`${short(sid)} ${kind} nudge not delivered \u2014 attempt ${attemptNum} not counted`);
+      }
+    }
+    async function loadMessages(sid) {
+      try {
+        const res = await ctx.session.context({ sessionID: sid });
+        const arr = Array.isArray(res) ? res : res?.messages ?? [];
+        if (arr.length > 1) {
+          const at = (m) => {
+            const mm = m;
+            const t = mm?.time?.created ?? mm?.info?.time?.created;
+            return typeof t === "number" ? t : 0;
+          };
+          return [...arr].sort((a, b) => at(a) - at(b));
+        }
+        return arr;
+      } catch (e) {
+        dbg(`${short(sid)} session.context() failed:`, e instanceof Error ? e.message : String(e));
+        return [];
+      }
+    }
+    function lastAssistantTextFrom(messages) {
+      for (let i = messages.length - 1;i >= 0; i--) {
+        const msg = messages[i];
+        if (!msg || msgRole(msg) !== "assistant")
+          continue;
+        if (Array.isArray(msg.content)) {
+          const text = msg.content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
+          if (text)
+            return text;
+          continue;
+        }
+        const flat = typeof msg.text === "string" && msg.text || typeof msg.info?.content === "string" && msg.info.content || "";
+        if (flat)
+          return flat;
+      }
+      return "";
+    }
+    function lastAssistantReasoning(messages) {
+      for (let i = messages.length - 1;i >= 0; i--) {
+        const msg = messages[i];
+        if (!msg || msgRole(msg) !== "assistant" || !Array.isArray(msg.content))
+          continue;
+        const reasoning = msg.content.filter((part) => part?.type === "reasoning" && typeof part.text === "string").map((part) => part.text).join("");
+        if (reasoning)
+          return reasoning;
+      }
+      return "";
+    }
+    function lastSilentDeadStream(messages) {
+      for (let i = messages.length - 1;i >= 0; i--) {
+        const msg = messages[i];
+        if (msgRole(msg) !== "assistant")
+          continue;
+        const finish = typeof msg.finish === "string" ? msg.finish : undefined;
+        if (!finish)
+          continue;
+        const parts = Array.isArray(msg.content) ? msg.content : [];
+        const hasText = parts.some((p) => p?.type === "text" && typeof p.text === "string" && p.text.length > 0);
+        if (hasText)
+          return null;
+        const hasToolCalls = parts.some((p) => {
+          const t = p?.type ?? "";
+          return t === "tool_use" || t === "tool" || t === "tool_call" || t.startsWith("tool");
+        });
+        if (hasToolCalls)
+          return null;
+        return { finish, outputTokens: posNum(msg.tokens?.output) };
+      }
+      return null;
+    }
+    async function recoverSilentDeadStream(sid, messages) {
+      const dead = lastSilentDeadStream(messages);
+      if (!dead)
+        return false;
+      if (dead.outputTokens < silentDeadStreamMinTokens) {
+        dbg(`${short(sid)} last finished message has no text, but only ${dead.outputTokens} output tokens (floor ${silentDeadStreamMinTokens}) \u2014 not treating it as a dead stream`);
+        return false;
+      }
+      const w = ensureWatch(sid);
+      if (w.toolsInFlightAtIdle > 0) {
+        dbg(`${short(sid)} silent dead stream, but ${w.toolsInFlightAtIdle} tool(s) still in flight \u2014 working, not stalled`);
+        return true;
+      }
+      if (w.status === "busy") {
+        dbg(`${short(sid)} silent dead stream, but the session is busy again \u2014 genuine restart, leaving it alone`);
+        return true;
+      }
+      if ((await getActiveSessions()).includes(sid)) {
+        dbg(`${short(sid)} silent dead stream, but the server still lists the session \u2014 possibly a provider retry; deferring, not burying`);
+        return false;
+      }
+      w.pendingRecoveryArmed = true;
+      log("info", `${short(sid)} silent dead stream: finish=${dead.finish}, ${dead.outputTokens} output tokens, no text parts; resuming`);
+      await recover(sid, `Silent dead stream (${dead.finish})`);
+      return true;
+    }
+    async function nudgeEmptyIdleTurn(sid, w, messages) {
+      if (w.emptyIdleNudged)
+        return false;
+      if (w.userCancelled || w.gaveUp || w.permissionPending)
+        return false;
+      if (w.completionSignaled)
+        return false;
+      if (w.failureLoopLatched) {
+        dbg(`${short(sid)} failure loop latched \u2014 standing down until a genuine turn`);
+        return false;
+      }
+      if (w.recovering || w.resumeAttempts > 0)
+        return false;
+      if (hasAssistantReplySinceUser(messages))
+        return false;
+      if (isWaitingOnUser(sid, w, messages)) {
+        dbg(`${short(sid)} empty idle turn is waiting on the user \u2014 not nudging`);
+        return false;
+      }
+      {
+        const kind = lockKind(w);
+        if (kind) {
+          dbg(`${short(sid)} ${kind} locked \u2014 refusing empty-idle nudge (reason: ${lockReason(w)})`);
+          return false;
+        }
+      }
+      if (w.compacting) {
+        dbg(`${short(sid)} mid-compaction \u2014 refusing empty-idle nudge`);
+        return false;
+      }
+      if (selfAbortActive(w)) {
+        dbg(`${short(sid)} self-abort in flight \u2014 refusing empty-idle nudge`);
+        return false;
+      }
+      if (continuesInWindow(w) >= baseLoopMaxContinues) {
+        log("warn", `${short(sid)} hallucination loop (${baseLoopMaxContinues} continues/${loopWindowMs / 1000}s) \u2014 abort+resume`);
+        await tryAbortAndResume(sid, w);
+        w.continueTimestamps = [];
+        return true;
+      }
+      w.emptyIdleNudged = true;
+      if (lifetimeExhausted(sid, w))
+        return true;
+      recordContinue(sid);
+      syncCounters(sid, w);
+      log("info", `${short(sid)} idle with no reply, no question, no completion claim \u2014 instant nudge (single-shot this episode)`);
+      const wasSelfRecovery = w.selfRecovery;
+      const sent = await notifyAndPrompt(sid, opts.continuePrompt ?? SAFE_EMPTY_IDLE_PROMPT, "empty-idle nudge");
+      if (!wasSelfRecovery)
+        w.selfRecovery = false;
+      return sent;
+    }
+    function hasAssistantReplySinceUser(messages) {
+      for (let i = messages.length - 1;i >= 0; i--) {
+        const m = messages[i];
+        if (!m || typeof m !== "object")
+          continue;
+        const role = msgRole(m);
+        if (role === "user")
+          return false;
+        if (role === "assistant")
+          return true;
+      }
+      return false;
+    }
+    function hasPendingUserInput(messages) {
+      const newest = messages[messages.length - 1];
+      if (newest?.type !== "assistant")
+        return false;
+      for (const part of newest.content ?? []) {
+        const t = part?.type ?? "";
+        if (!(t === "tool_use" || t === "tool" || t === "tool_call" || t.startsWith("tool")))
+          continue;
+        const status = part?.state?.status;
+        if (status === TOOL_STATE_RUNNING || status === TOOL_STATE_PENDING)
+          return true;
+        if (status !== TOOL_STATE_COMPLETED && AWAITING_USER_TOOLS.has(part?.name ?? ""))
+          return true;
+      }
+      return false;
+    }
+    function isWaitingOnUser(sid, w, messages) {
+      noteInboundUserMessage(sid, w, messages);
+      const newest = messages[messages.length - 1];
+      if (newest?.type !== "assistant")
+        return false;
+      for (const part of newest.content ?? []) {
+        const t = part?.type ?? "";
+        if (!(t === "tool_use" || t === "tool" || t === "tool_call" || t.startsWith("tool")))
+          continue;
+        if (!AWAITING_USER_TOOLS.has(part?.name ?? ""))
+          continue;
+        if (part?.state?.status !== TOOL_STATE_COMPLETED)
+          return true;
+      }
+      return false;
+    }
+    function lastUserMessageAt(messages) {
+      for (let i = messages.length - 1;i >= 0; i--) {
+        const m = messages[i];
+        const isUser = msgRole(m) === "user";
+        if (!isUser)
+          continue;
+        const ts = m.time?.created ?? m.info?.time?.created;
+        return typeof ts === "number" ? ts : undefined;
+      }
+      return;
+    }
+    async function shouldStandDownForUser(sid, messages, activeUserWindowMs) {
+      try {
+        if (messages.length === 0)
+          return false;
+        if (hasPendingUserInput(messages))
+          return true;
+        const lastUserAt = lastUserMessageAt(messages);
+        if (lastUserAt !== undefined && Date.now() - lastUserAt < activeUserWindowMs)
+          return true;
+        return false;
+      } catch {
+        return false;
+      }
+    }
+    function rememberOwnPrompts(w, messages) {
+      const start = Math.max(0, messages.length - 40);
+      for (let i = start;i < messages.length; i++) {
+        const m = messages[i];
+        if (msgRole(m) !== "user")
+          continue;
+        const text = messageTextOf(m);
+        if (!looksLikeOwnPrompt(text))
+          continue;
+        if (!w.ownPromptTexts.includes(text)) {
+          w.ownPromptTexts.push(text);
+          if (w.ownPromptTexts.length > 10)
+            w.ownPromptTexts.shift();
+        }
+        const at = msgAt(m);
+        if (at > 0 && at > w.lastInjectAt)
+          w.lastInjectAt = at;
+      }
+    }
+    function noteInboundUserMessage(sid, w, messages) {
+      rememberOwnPrompts(w, messages);
+      let latest = null;
+      for (let i = messages.length - 1;i >= 0; i--) {
+        const m = messages[i];
+        const isUser = msgRole(m) === "user";
+        if (!isUser)
+          continue;
+        const text = messageTextOf(m);
+        latest = { id: typeof m.id === "string" ? m.id : undefined, at: m.time?.created ?? m.info?.time?.created, text };
+        break;
+      }
+      if (!latest)
+        return;
+      const isNew = latest.id ? latest.id !== w.lastUserMessageID : typeof latest.at === "number" && latest.at > w.lastUserMessageSeenAt;
+      if (!isNew)
+        return;
+      w.lastUserMessageID = latest.id;
+      if (typeof latest.at === "number")
+        w.lastUserMessageSeenAt = latest.at;
+      const ownByText = typeof latest.text === "string" && latest.text.length > 0 && w.ownPromptTexts.includes(latest.text);
+      const ownByShape = looksLikeOwnPrompt(latest.text);
+      const ownByTime = typeof latest.at === "number" && w.lastInjectAt > 0 && latest.at >= w.lastInjectAt && latest.at - w.lastInjectAt < OWN_PROMPT_TIME_MS;
+      const ownByTimeOnly = ownByTime && !(typeof latest.text === "string" && latest.text.length > 0);
+      if (ownByText || ownByShape || ownByTimeOnly) {
+        dbg(`${short(sid)} newest user message is our own prompt \u2014 not re-arming budgets`);
+        return;
+      }
+      if (w.doneClaimAttempts > 0 || w.doneClaimOpenTodosAttempts > 0) {
+        dbg(`${short(sid)} new user message \u2014 re-arming the done-claim budgets`);
+      }
+      w.doneClaimAttempts = 0;
+      w.doneClaimOpenTodosAttempts = 0;
+      if (w.userCancelled && typeof latest.at === "number" && latest.at >= w.userCancelledAt) {
+        dbg(`${short(sid)} new user message after interrupt \u2014 re-arming recovery`);
+        w.userCancelled = false;
+      }
+      w.taskCompleteSignals = 0;
+      if (w.unknownToolErrors.size > 0 || w.unknownToolSuggestionSent) {
+        dbg(`${short(sid)} new user message \u2014 re-arming the unknown-tool budget`);
+      }
+      w.unknownToolErrors.clear();
+      w.unknownToolSuggestionSent = false;
+      w.stuckToolAttempts = 0;
+      w.lastGenuineUserAt = typeof latest.at === "number" ? Math.min(latest.at, Date.now()) : Date.now();
+      touch(sid);
+      if (w.completionSignaled) {
+        w.completionSignaled = false;
+        w.completionSignaledAt = 0;
+        dbg(`${short(sid)} genuine new user message \u2014 re-opening latched completion`);
+      }
+      if (w.resumeAttempts > 0) {
+        dbg(`${short(sid)} new user message \u2014 restarting the stall ladder`);
+      }
+      w.resumeAttempts = 0;
+      w.providerRetryAt = 0;
+      w.episodeRefires = 0;
+      w.lifetimeContinues = 0;
+      w.workRetries = 0;
+      if (ctx.storage?.remove) {
+        ctx.storage.remove(`${COUNTER_STATE_PREFIX}${sid}`).catch(() => {});
+      }
+      w.gaveUp = false;
+      w.emptyIdleNudged = false;
+    }
+    let cachedToolIds = null;
+    let cachedToolIdsAt = 0;
+    async function getAvailableToolIds() {
+      if (cachedToolIds && Date.now() - cachedToolIdsAt < TOOL_IDS_CACHE_MS)
+        return cachedToolIds;
+      if (!ctx.tool?.list)
+        return cachedToolIds ?? [];
+      try {
+        const listed = await ctx.tool.list();
+        const ids = listed.map((t) => typeof t?.id === "string" && t.id ? t.id : typeof t?.name === "string" ? t.name : "").filter((n) => n.length > 0);
+        cachedToolIds = ids;
+        cachedToolIdsAt = Date.now();
+        return ids;
+      } catch (e) {
+        log("warn", `failed to list tools: ${e instanceof Error ? e.message : String(e)}`);
+        return cachedToolIds ?? [];
+      }
+    }
+    function scanToolParts(messages, lastUserAt, cutoff) {
+      const stuck = [];
+      let trailing = null;
+      let anythingInFlight = false;
+      for (const m of messages) {
+        if (!m || msgRole(m) !== "assistant" || !Array.isArray(m.content))
+          continue;
+        for (const part of m.content) {
+          if (part?.type !== "tool") {
+            trailing = null;
+            continue;
+          }
+          const st = part?.state?.status;
+          const name = typeof part?.name === "string" && part.name ? part.name : "(unnamed)";
+          const created = typeof part?.time?.created === "number" ? part.time.created : typeof m?.time?.created === "number" ? m.time.created : 0;
+          if (st === "error") {
+            const rawErr = part?.state && typeof part.state === "object" ? part.state.error : undefined;
+            const eType = rawErr && typeof rawErr === "object" && typeof rawErr.type === "string" ? rawErr.type : "";
+            const eMsg = toolErrorText(part?.state);
+            if (isAbortError(eType, eMsg)) {
+              trailing = null;
+              continue;
+            }
+            if (NEVER_RETRY_RE.test(eMsg)) {
+              trailing = null;
+              continue;
+            }
+            trailing = { name, err: eMsg.slice(0, 160), created };
+            continue;
+          }
+          if (st === "completed") {
+            trailing = null;
+            continue;
+          }
+          if (created <= lastUserAt)
+            continue;
+          anythingInFlight = true;
+          if (created >= cutoff)
+            continue;
+          if (!stuck.includes(name))
+            stuck.push(name);
+        }
+      }
+      return { stuck, trailing, anythingInFlight };
+    }
+    function buildStuckNudgePrompt(stuck) {
+      const names = stuck.slice(0, 3).join('", "');
+      return `A "${names}" call never returned a result and the turn went idle waiting on it. ` + `Proceed without it: continue the task from where you left off and do not retry the same call.`;
+    }
+    async function checkForStuckToolCalls(sid, w) {
+      if (w.userCancelled || w.completionSignaled)
+        return false;
+      {
+        const locked = lockKind(w);
+        if (locked) {
+          dbg(`${short(sid)} locked (${locked}) \u2014 skipping stuck-tool pass`);
+          return false;
+        }
+      }
+      const messages = await loadMessages(sid);
+      let lastUserAt = 0;
+      for (const m of messages) {
+        if (msgRole(m) === "user")
+          lastUserAt = Math.max(lastUserAt, msgAt(m));
+      }
+      const cutoff = Date.now() - stuckToolAgeMs;
+      const { stuck, trailing, anythingInFlight } = scanToolParts(messages, lastUserAt, cutoff);
+      if (trailing && !anythingInFlight && trailing.created > lastUserAt) {
+        const available = await getAvailableToolIds();
+        if (available.length > 0 && available.includes(trailing.name)) {
+          const prompt = `The "${trailing.name}" call failed${trailing.err ? ` with: ${trailing.err}` : ""}. ` + `Retry it now \u2014 reissue the same call.`;
+          log("warn", `${short(sid)} "${trailing.name}" failed at end of turn, retrying promptly (attempt ${(w.stuckToolAttempts ?? 0) + 1}/${maxRetries})`);
+          return targetedRecovery(sid, "stuck-tool", prompt, "stuckToolAttempts").then(() => true);
+        }
+      }
+      if (stuck.length === 0)
+        return false;
+      const prompt = buildStuckNudgePrompt(stuck);
+      const names = stuck.slice(0, 3).join('", "');
+      log("warn", `${short(sid)} tool call(s) "${names}" stuck unfinished \u2014 nudging to proceed without it`);
+      return targetedRecovery(sid, "stuck-tool", prompt, "stuckToolAttempts").then(() => true);
+    }
+    async function checkForSilentReasoningTurn(sid, w) {
+      if (w.userCancelled || w.completionSignaled)
+        return false;
+      {
+        const locked = lockKind(w);
+        if (locked) {
+          dbg(`${short(sid)} locked (${locked}) \u2014 skipping silent-reasoning pass`);
+          return false;
+        }
+      }
+      const messages = await loadMessages(sid);
+      let lastUserAt = 0;
+      for (const m of messages) {
+        if (msgRole(m) === "user")
+          lastUserAt = Math.max(lastUserAt, msgAt(m));
+      }
+      let newestPostUserAt = 0;
+      let sawReasoning = false;
+      for (const m of messages) {
+        if (!m || msgRole(m) !== "assistant" || !Array.isArray(m.content))
+          continue;
+        const at = msgAt(m);
+        if (at <= lastUserAt)
+          continue;
+        if (at > newestPostUserAt)
+          newestPostUserAt = at;
+        for (const part of m.content) {
+          const t = part?.type ?? "";
+          if (t === "text" && typeof part?.text === "string" && part.text.length > 0)
+            return false;
+          if (t === "tool_use" || t === "tool" || t === "tool_call" || t.startsWith("tool"))
+            return false;
+          if (t === "reasoning" && typeof part?.text === "string" && part.text.length > 0)
+            sawReasoning = true;
+        }
+      }
+      if (!sawReasoning)
+        return false;
+      if (Date.now() - newestPostUserAt < chunkTimeoutMs)
+        return false;
+      const prompt = `Your last turn produced reasoning but no visible output and no tool calls. ` + `Continue the task: produce the answer or the next tool call.`;
+      log("warn", `${short(sid)} reasoning-only turn with no output \u2014 nudging to continue`);
+      return targetedRecovery(sid, "silent-reasoning", prompt, "stuckToolAttempts").then(() => true);
+    }
+    async function checkForUnknownToolCalls(sid, w) {
+      if (w.userCancelled || w.completionSignaled)
+        return false;
+      {
+        const locked = lockKind(w);
+        if (locked) {
+          dbg(`${short(sid)} locked (${locked}) \u2014 skipping unknown-tool pass`);
+          return false;
+        }
+      }
+      try {
+        const messages = await loadMessages(sid);
+        noteInboundUserMessage(sid, w, messages);
+        if (containsStopStatement(w.lastAssistantText || lastAssistantTextFrom(messages)))
+          return false;
+        if (w.unknownToolSuggestionSent)
+          return false;
+        const available = await getAvailableToolIds();
+        if (available.length === 0)
+          return false;
+        for (const msg of messages) {
+          const content = msg?.content;
+          if (!Array.isArray(content))
+            continue;
+          for (const part of content) {
+            if (part?.type !== "tool")
+              continue;
+            const partId = typeof part.id === "string" ? part.id : "";
+            if (!partId || w.checkedToolPartIDs.has(partId))
+              continue;
+            w.checkedToolPartIDs.add(partId);
+            if (w.checkedToolPartIDs.size > CHECKED_TOOL_PART_IDS_MAX) {
+              const oldest = w.checkedToolPartIDs.values().next().value;
+              if (typeof oldest === "string")
+                w.checkedToolPartIDs.delete(oldest);
+            }
+            const state = part.state;
+            if (state?.status !== "error")
+              continue;
+            const toolName = typeof part.name === "string" ? part.name : "";
+            if (!toolName || available.includes(toolName))
+              continue;
+            const count = (w.unknownToolErrors.get(toolName) ?? 0) + 1;
+            w.unknownToolErrors.set(toolName, count);
+            if (count < UNKNOWN_TOOL_THRESHOLD)
+              continue;
+            const suggestion = resolveToolSuggestion(toolName, available);
+            const toolList = available.slice(0, UNKNOWN_TOOL_LIST_LIMIT).join(", ");
+            const prompt = suggestion ? `You tried to use the tool "${toolName}" ${count} times, but it does not exist. ` + `The closest matching tool is "${suggestion}". ` + `Please use "${suggestion}" instead and adjust your arguments accordingly. ` + `Available tools include: ${toolList}.` : `You tried to use the tool "${toolName}" ${count} times, but it does not exist. ` + `Please check the available tools and use the correct one. ` + `Available tools include: ${toolList}.`;
+            w.unknownToolSuggestionSent = true;
+            log("warn", `${short(sid)} unknown tool "${toolName}" called ${count}x, suggesting "${suggestion ?? "(none)"}" mod=${MODULE_INSTANCE}`);
+            await injectOnce(sid, prompt, "unknown-tool", false, false, quietCorrections);
+            return true;
+          }
+        }
+        return false;
+      } catch (e) {
+        log("warn", `${short(sid)} unknown-tool check failed: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+      }
+    }
+    async function registerTaskCompleteFallback() {
+      if (!ctx.tool?.transform) {
+        dbg("tool registry unavailable \u2014 task_complete not offered");
+        return;
+      }
+      let provided = false;
+      try {
+        const listed = await ctx.tool.list?.() ?? [];
+        const arr = Array.isArray(listed) ? listed : [];
+        provided = arr.some((t) => {
+          const n = String(t?.id ?? t?.name ?? t ?? "").toLowerCase();
+          return n === "task_complete" || n.endsWith("/task_complete");
+        });
+      } catch (e) {
+        dbg("tool list failed \u2014 checking the config instead:", e instanceof Error ? e.message : String(e));
+      }
+      if (!provided) {
+        const cfgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "opencode.jsonc");
+        provided = await configMentionsTaskComplete(cfgPath);
+        if (provided)
+          log("info", "task-complete plugin configured in opencode.jsonc \u2014 fallback stays out");
+      }
+      if (provided)
+        return;
+      try {
+        await ctx.tool.transform((editor) => {
+          editor.add({
+            name: "task_complete",
+            description: TASK_COMPLETE_DESCRIPTION,
+            options: { codemode: false },
+            input: { type: "object", properties: {}, additionalProperties: false },
+            execute: async (_input, toolCtx) => {
+              const sid = toolCtx?.sessionID;
+              if (!sid)
+                return { content: TASK_COMPLETE_ACK };
+              const w = ensureWatch(sid);
+              if (!await isSubAgentSession(sid)) {
+                const open = getOpenTodos(await readTodos(sid));
+                if (open.length > 0 && w.taskCompleteOverrides < maxRetries) {
+                  w.taskCompleteOverrides++;
+                  w.taskCompleteSignals = 0;
+                  const reminder = buildOpenTodosReminder(open);
+                  const blockMsg = `Mark any finished todos complete and do not redo completed work.
+${reminder}`;
+                  log("info", `${short(sid)} task_complete blocked: ${open.length} open todos remain (override ${w.taskCompleteOverrides}/${maxRetries})`);
+                  let awaitingInput = false;
+                  try {
+                    awaitingInput = hasPendingUserInput(await loadMessages(sid));
+                  } catch (e) {
+                    dbg(`${short(sid)} task_complete block: awaiting-input check failed:`, e instanceof Error ? e.message : String(e));
+                  }
+                  if (awaitingInput) {
+                    log("info", `${short(sid)} task_complete blocked but user input pending \u2014 skipping visible nudge`);
+                  } else {
+                    await injectOnce(sid, blockMsg, "task-complete-blocked");
+                  }
+                  return { content: blockMsg };
+                }
+              }
+              w.completionSignaled = true;
+              w.completionSignaledAt = Date.now();
+              log("info", `${short(sid)} task_complete called, ${await isSubAgentSession(sid) ? "subagent" : "agent"} done`);
+              w.taskCompleteSignals++;
+              if (w.taskCompleteSignals === 2)
+                return { content: TASK_COMPLETE_REPEAT_WARNING };
+              if (w.taskCompleteSignals > 2)
+                throw new Error(TASK_COMPLETE_REPEAT_ERROR);
+              return { content: TASK_COMPLETE_ACK };
+            }
+          });
+        });
+        log("info", "registered the task_complete tool (fallback \u2014 the task-complete plugin is not installed)");
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log("warn", `task_complete registration failed (${msg}) \u2014 continuing without it`);
+      }
+    }
+    async function observeTaskCompleteTool() {
+      if (!ctx.tool?.hook) {
+        dbg("tool hook unavailable \u2014 task_complete stand-down not observed");
+        return;
+      }
+      try {
+        ctx.tool.hook("execute.after", async (event) => {
+          if (event?.tool !== "task_complete")
+            return;
+          if (event?.status !== "completed")
+            return;
+          const sid = event?.sessionID;
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          const result = event?.result;
+          if (result?.metadata?.completed === false) {
+            const content = typeof result?.content === "string" ? result.content : "";
+            if (!content)
+              return;
+            let awaitingInput = false;
+            try {
+              awaitingInput = hasPendingUserInput(await loadMessages(sid));
+            } catch (e) {
+              dbg(`${short(sid)} task_complete block: awaiting-input check failed:`, e instanceof Error ? e.message : String(e));
+            }
+            if (awaitingInput) {
+              log("info", `${short(sid)} task_complete blocked but user input pending \u2014 skipping visible nudge`);
+              return;
+            }
+            await injectOnce(sid, content, "task-complete-blocked");
+            return;
+          }
+          w.completionSignaled = true;
+          w.completionSignaledAt = Date.now();
+          w.taskCompleteSignals = 0;
+          w.taskCompleteOverrides = 0;
+          log("info", `${short(sid)} task_complete called, ${await isSubAgentSession(sid) ? "subagent" : "agent"} done`);
+        });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log("warn", `task_complete observer failed (${msg}) \u2014 continuing without the stand-down`);
+      }
+    }
+    async function inspectOnIdle(sid, phase = "structural") {
+      const w = ensureWatch(sid);
+      const messages = await loadMessages(sid);
+      noteInboundUserMessage(sid, w, messages);
+      if (await recoverSilentDeadStream(sid, messages))
+        return;
+      if (await checkForStuckToolCalls(sid, w))
+        return;
+      if (await checkForSilentReasoningTurn(sid, w))
+        return;
+      let text = w.lastAssistantText;
+      if (!text)
+        text = lastAssistantTextFrom(messages);
+      if (!text) {
+        await nudgeEmptyIdleTurn(sid, w, messages);
+        return;
+      }
+      if (isUserHandoff(text)) {
+        dbg(`${short(sid)} idle turn ends with a user hand-off \u2014 skipping targeted recovery`);
+        return;
+      }
+      if (await shouldStandDownForUser(sid, messages, activeUserWindowMs)) {
+        {
+          const tailText = w.lastAssistantText || lastAssistantTextFrom(messages);
+          if (tailText && turnEndsWithCompletionClaim(tailText)) {
+            const open = getOpenTodos(await readTodos(sid));
+            if (open.length === 0 && !w.completionSignaled) {
+              w.completionSignaled = true;
+              w.completionSignaledAt = Date.now();
+              log("info", `${short(sid)} turn ends with a completion claim inside the activity window \u2014 latching completion, standing down`);
+            }
+          } else {
+            dbg(`${short(sid)} stand-down evaluation: tail is not a completion claim (score the tail, not the turn)`);
+          }
+        }
+        dbg(`${short(sid)} user has pending input or was recently active \u2014 standing down`);
+        {
+          const lastUser = lastUserMessageAt(messages);
+          const waitMs = (lastUser === undefined ? activeUserWindowMs : Math.max(0, lastUser + activeUserWindowMs - Date.now())) + 1000;
+          if (w.toolTextTimer)
+            clearTimeout(w.toolTextTimer);
+          w.toolTextTimer = setTimeout(() => {
+            w.toolTextTimer = null;
+            if (w.status !== "idle") {
+              dbg(`${short(sid)} stand-down recheck skipped \u2014 session is ${w.status}, not idle`);
+              return;
+            }
+            if (w.userCancelled)
+              return;
+            inspectOnIdle(sid, "pattern");
+          }, waitMs);
+        }
+        return;
+      }
+      if (phase === "structural") {
+        schedulePatternPass(sid);
+        return;
+      }
+      if (endsWithCelebration(text)) {
+        const open = getOpenTodos(await readTodos(sid));
+        if (open.length > 0) {
+          await targetedRecovery(sid, "open-todos-celebration-false-positive", buildOpenTodosReminder(open), "todoNudgeAttempts");
+          return;
+        }
+        if (!w.completionSignaled) {
+          w.completionSignaled = true;
+          w.completionSignaledAt = Date.now();
+          log("info", `${short(sid)} turn ends with a celebration and no open todos \u2014 latching completion, not nudging`);
+        } else {
+          dbg(`${short(sid)} completion already latched \u2014 skipping`);
+        }
+        return;
+      }
+      const reasoning = lastAssistantReasoning(messages);
+      if (reasoning && containsToolCallAsText(reasoning)) {
+        await targetedRecovery(sid, "tool-call-in-reasoning", thinkingToolRecoveryPrompt, "toolTextAttempts");
+        return;
+      }
+      if (containsToolCallAsText(text)) {
+        await targetedRecovery(sid, "tool-call-as-text", opts.toolTextRecoveryPrompt ?? TOOL_TEXT_RECOVERY_PROMPT, "toolTextAttempts");
+        return;
+      }
+      if (containsReadyToContinuePattern(text, readyToContinuePatterns)) {
+        await targetedRecovery(sid, "ready-to-continue", opts.continuePrompt ?? SAFE_CONTINUE_PROMPT, "intentNudgeAttempts");
+        return;
+      }
+      if (resumeOnActionIntent && containsActionIntent(text)) {
+        await targetedRecovery(sid, "action-intent", opts.actionIntentPrompt ?? opts.continuePrompt ?? SAFE_CONTINUE_PROMPT, "intentNudgeAttempts");
+        return;
+      }
+      if (containsStopStatement(text)) {
+        const open = getOpenTodos(await readTodos(sid));
+        if (open.length > 0) {
+          await targetedRecovery(sid, "stop-open-todos", buildOpenTodosReminder(open), "todoNudgeAttempts");
+          return;
+        }
+        if (!w.completionSignaled) {
+          w.completionSignaled = true;
+          w.completionSignaledAt = Date.now();
+          log("info", `${short(sid)} turn ends with an explicit stop and no open todos \u2014 latching completion, not nudging`);
+        } else {
+          dbg(`${short(sid)} completion already latched \u2014 skipping`);
+        }
+        return;
+      }
+      if (containsDoneClaimPattern(text, doneClaimPatterns)) {
+        const open = getOpenTodos(await readTodos(sid));
+        if (open.length > 0) {
+          await targetedRecovery(sid, "done-claim-open-todos", doneWithoutWorkPrompt, "doneClaimOpenTodosAttempts");
+          return;
+        }
+        if (w.doneClaimAttempts < maxRetries) {
+          if (!containsWorkDescription(text)) {
+            await targetedRecovery(sid, "done-claim-no-details", doneWithoutDetailsPrompt, "doneClaimAttempts");
+          } else {
+            dbg(`${short(sid)} done-claim carries a work description \u2014 skipping details prompt`);
+          }
+        }
+      }
+      await checkContextSaturation(sid);
+    }
+    async function getActiveSessions() {
+      try {
+        const fn = ctx.session.active;
+        if (typeof fn !== "function") {
+          const http = await activeSessionsHttp();
+          if (http !== null)
+            return http;
+          return busySessions();
+        }
+        const active = await fn.call(ctx.session);
+        return Object.keys(active ?? {}).filter((k) => typeof k === "string");
+      } catch {
+        const http = await activeSessionsHttp();
+        if (http !== null)
+          return http;
+        return busySessions();
+      }
+    }
+    let activeCache = null;
+    const ACTIVE_TTL_MS = 1e4;
+    async function activeSessionsHttp() {
+      const now = Date.now();
+      if (activeCache && now - activeCache.at < ACTIVE_TTL_MS)
+        return activeCache.ids;
+      for (const base of serverBaseUrls()) {
+        try {
+          const res = await fetch(`${base}/api/session/active`, { headers: serverHeaders() });
+          if (!res.ok)
+            continue;
+          const body = await res.json();
+          const data = body?.data ?? body;
+          if (data && typeof data === "object") {
+            const ids = Object.keys(data).filter((k) => k.startsWith("ses_"));
+            activeCache = { at: now, ids };
+            return ids;
+          }
+        } catch {}
+      }
+      return null;
+    }
+    function busySessionsForOrphanWatch() {
+      const out = [];
+      for (const [sid, w] of sessions) {
+        if (w.status === "busy" && !w.userCancelled)
+          out.push(sid);
+      }
+      return out;
+    }
+    async function listSubagentIds(parentSid) {
+      const listed = unwrapList(await callSessionApi("list", { parentID: parentSid }));
+      const out = [];
+      for (const row of listed) {
+        const sid = row?.id;
+        if (typeof sid !== "string" || !sid.startsWith("ses_"))
+          continue;
+        if (sid === parentSid)
+          continue;
+        if (row.parentID !== parentSid)
+          continue;
+        out.push(sid);
+      }
+      if (out.length === 0) {
+        for (const row of await listSessionsHttp()) {
+          const sid = row?.id;
+          if (typeof sid !== "string" || !sid.startsWith("ses_"))
+            continue;
+          if (sid === parentSid)
+            continue;
+          if (row?.parentID !== parentSid)
+            continue;
+          out.push(sid);
+        }
+      }
+      return out;
+    }
+    async function subagentVerdict(parentSid, activeIDs) {
+      try {
+        const children = await listSubagentIds(parentSid);
+        if (children.length === 0)
+          return { status: "idle" };
+        const now = Date.now();
+        let sawBusy = false;
+        let sawWaiting = null;
+        for (const child of children) {
+          const messages = await loadMessages(child);
+          const last = messages[messages.length - 1];
+          if (last && msgRole(last) === "assistant" && last.error !== undefined) {
+            dbg(`subagent ${short(child)} reported an error`);
+            return { status: "crashed" };
+          }
+          const msgTime = msgAt(last) || undefined;
+          const silentFor = typeof msgTime === "number" ? now - msgTime : Infinity;
+          if (activeIDs.has(child)) {
+            sawBusy = true;
+            continue;
+          }
+          const hasToolCall = (last?.content ?? []).some((p) => p?.type === "tool" && p.state?.status !== "completed" && p.state?.status !== "error");
+          const limit = hasToolCall ? SUBAGENT_STUCK_MS * 3 : SUBAGENT_STUCK_MS;
+          const deadLimit = hasToolCall ? subagentDeadMs * 3 : subagentDeadMs;
+          if (silentFor <= limit) {
+            if (sawWaiting === null)
+              sawWaiting = child;
+            continue;
+          }
+          if (silentFor <= deadLimit) {
+            dbg(`subagent ${short(child)} quiet for ${Math.round(silentFor / 1000)}s, inside ${Math.round(deadLimit / 1000)}s patience \u2014 waiting, not crashed (active=${activeIDs.has(child)})`);
+            if (sawWaiting === null)
+              sawWaiting = child;
+            continue;
+          }
+          dbg(`subagent ${short(child)} silent for ${Math.round(silentFor / 1000)}s (active=${activeIDs.has(child)})`);
+          return { status: "crashed", stuckSid: child };
+        }
+        if (sawBusy)
+          return { status: "busy" };
+        if (sawWaiting !== null)
+          return { status: "waiting", stuckSid: sawWaiting };
+        return { status: "idle" };
+      } catch (e) {
+        dbg(`subagent check failed for ${short(parentSid)}:`, e instanceof Error ? e.message : String(e));
+        return { status: "busy" };
+      }
+    }
+    async function recoverStuckSubagent(sid) {
+      if (!running)
+        return false;
+      try {
+        await callSessionApi("synthetic", { sessionID: sid, text: SUBAGENT_RECOVERY_PROMPT });
+        log("info", `${short(sid)} recovery prompt sent to stuck subagent`);
+        return true;
+      } catch (e) {
+        log("warn", `failed to recover subagent ${short(sid)}: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+      }
+    }
+    async function armOrphanWatch(sid) {
+      const w = sessions.get(sid);
+      if (!w || w.orphanWatchStartAt !== null)
+        return;
+      if (w.status !== "busy" || w.userCancelled || w.completionSignaled)
+        return;
+      try {
+        if (await isSubAgentSession(sid))
+          return;
+        const children = await listSubagentIds(sid);
+        if (w.orphanWatchStartAt !== null || w.status !== "busy" || w.userCancelled)
+          return;
+        if (children.length === 0) {
+          dbg(`${short(sid)} outlived a busy session but has no subagents \u2014 not an orphan parent`);
+          return;
+        }
+        w.orphanWatchStartAt = Date.now();
+        w.orphanWatchArmedAt = w.orphanWatchStartAt;
+        w.orphanRecoveryTried = false;
+        log("info", `subagents of ${short(sid)} fell quiet while it stayed busy. orphan watch (${subagentWaitMs / 1000}s, ${children.length} subagent(s))`);
+      } catch (e) {
+        dbg(`orphan arming check failed for ${short(sid)}:`, e instanceof Error ? e.message : String(e));
+      }
+    }
+    async function runOrphanWatch(sid, w, now, activeIDs) {
+      if (now - w.orphanWatchStartAt < subagentWaitMs + gracePeriodMs)
+        return;
+      const profile = resolveProfile(sid);
+      const profileMaxRetries = profile.maxRetries;
+      if (w.resumeAttempts >= profileMaxRetries) {
+        if (!w.gaveUp) {
+          w.gaveUp = true;
+          w.orphanWatchStartAt = null;
+          w.orphanWatchArmedAt = null;
+          w.orphanEscalatedChildSid = undefined;
+          log("warn", `${short(sid)} orphan watch gave up after ${profileMaxRetries} attempts`);
+        }
+        return;
+      }
+      if (w.pendingTools > 0) {
+        dbg(`${short(sid)} parent has ${w.pendingTools} tool(s) in flight \u2014 deferring orphan abort`);
+        w.orphanWatchStartAt = now;
+        return;
+      }
+      if (hasPendingUserInput(await loadMessages(sid))) {
+        dbg(`${short(sid)} parent is waiting on the user \u2014 deferring orphan abort`);
+        w.orphanWatchStartAt = now;
+        return;
+      }
+      if (w.orphanWatchArmedAt !== null) {
+        const msgs = await loadMessages(sid);
+        let newestUserAt = 0;
+        for (const m of msgs) {
+          if (msgRole(m) !== "user")
+            continue;
+          const at = msgAt(m);
+          if (typeof at === "number" && at > newestUserAt)
+            newestUserAt = at;
+        }
+        if (newestUserAt > w.orphanWatchArmedAt) {
+          dbg(`${short(sid)} user spoke ${Math.round((now - newestUserAt) / 1000)}s ago, after the orphan watch armed \u2014 deferring orphan abort`);
+          return;
+        }
+      }
+      const verdict = await subagentVerdict(sid, activeIDs);
+      if (verdict.status === "crashed") {
+        if (verdict.stuckSid && w.orphanEscalatedChildSid === verdict.stuckSid) {
+          w.resumeAttempts++;
+          const profile = resolveProfile(sid);
+          const profileMaxRetries = profile.maxRetries;
+          if (w.resumeAttempts >= profileMaxRetries) {
+            if (!w.gaveUp) {
+              w.gaveUp = true;
+              log("warn", `${short(sid)} orphan watch gave up after ${profileMaxRetries} attempts`);
+            }
+          } else {
+            w.orphanWatchStartAt = now;
+          }
+          dbg(`${short(sid)} subagent ${short(verdict.stuckSid)} already escalated this episode \u2014 not re-aborting the parent`);
+          return;
+        }
+        if (verdict.stuckSid && !w.orphanRecoveryTried) {
+          w.orphanRecoveryTried = true;
+          if (await recoverStuckSubagent(verdict.stuckSid)) {
+            w.orphanWatchStartAt = now;
+            return;
+          }
+        }
+        log("info", `${short(sid)} subagent crashed and did not recover \u2014 aborting and resuming the parent`);
+        if (verdict.stuckSid)
+          w.orphanEscalatedChildSid = verdict.stuckSid;
+        w.resumeAttempts++;
+        tryAbortAndResume(sid, w, true);
+        return;
+      }
+      if (verdict.status === "waiting") {
+        dbg(`${short(sid)} subagents quiet but inside patience \u2014 waiting, not aborting`);
+        w.orphanWatchStartAt = now;
+        return;
+      }
+      if (verdict.status === "busy") {
+        dbg(`${short(sid)} subagents still working \u2014 waiting`);
+        w.orphanWatchStartAt = now;
+        return;
+      }
+      log("info", `${short(sid)} stuck with no live subagents \u2014 aborting and resuming`);
+      tryAbortAndResume(sid, w);
+      w.resumeAttempts++;
+    }
+    async function parentWaitingOnSubagents(sid, activeIDs) {
+      const verdict = await subagentVerdict(sid, activeIDs);
+      if (verdict.status === "busy" || verdict.status === "waiting")
+        return true;
+      if (verdict.status === "crashed")
+        return false;
+      const w = ensureWatch(sid);
+      if (w.pendingTools <= 0)
+        return false;
+      return false;
+    }
+    function stallYoungAgeMsFor(name) {
+      return LONG_RUNNING_TOOLS.includes(name) ? LONG_RUNNING_TOOL_STALE_TTL_MS : stuckToolAgeMs;
+    }
+    async function hasYoungUnfinishedWork(sid, now) {
+      const messages = await loadMessages(sid);
+      let lastUserAt = 0;
+      for (const m of messages) {
+        if (msgRole(m) === "user")
+          lastUserAt = Math.max(lastUserAt, msgAt(m));
+      }
+      for (const m of messages) {
+        if (!m || msgRole(m) !== "assistant" || !Array.isArray(m.content))
+          continue;
+        for (const part of m.content) {
+          if (part?.type !== "tool")
+            continue;
+          const st = part?.state?.status;
+          if (st === "completed" || st === "error")
+            continue;
+          const created = typeof part?.time?.created === "number" ? part.time.created : typeof m?.time?.created === "number" ? m.time.created : 0;
+          if (created <= lastUserAt)
+            continue;
+          const name = typeof part?.name === "string" && part.name ? part.name.toLowerCase() : "";
+          const age = now - created;
+          if (neverInterruptTools.includes(name)) {
+            if (age < NEVER_INTERRUPT_STALE_TTL_MS)
+              return true;
+            continue;
+          }
+          if (age < stallYoungAgeMsFor(name))
+            return true;
+        }
+      }
+      return false;
+    }
+    async function checkActiveSessions() {
+      const now = Date.now();
+      const activeIDs = await getActiveSessions();
+      for (const sid of activeIDs) {
+        const w = ensureWatch(sid);
+        if (w.status !== "busy")
+          markBusy(sid);
+      }
+      const activeSet = new Set(activeIDs);
+      for (const [sid, w] of sessions) {
+        if (isPaused(sid))
+          continue;
+        if (w.status !== "busy" || w.userCancelled) {
+          if (w.status === "busy" && w.userCancelled) {
+            noteInboundUserMessage(sid, w, await loadMessages(sid));
+            if (w.userCancelled)
+              continue;
+          } else if (w.status === "idle" && !w.userCancelled) {
+            const idleFor = now - (w.idleSince ?? w.lastActivityAt);
+            if (idleFor > chunkTimeoutMs && now - w.lastSilentReasoningCheck > chunkTimeoutMs) {
+              w.lastSilentReasoningCheck = now;
+              await checkForSilentReasoningTurn(sid, w);
+            }
+            if (idleFor > stuckToolAgeMs && now - w.lastStuckToolCheck > stuckToolAgeMs) {
+              w.lastStuckToolCheck = now;
+              await checkForStuckToolCalls(sid, w);
+            }
+            {
+              const history = await loadMessages(sid);
+              noteInboundUserMessage(sid, w, history);
+              if (w.completionSignaled) {
+                if (w.lastGenuineUserAt > w.completionSignaledAt) {
+                  w.completionSignaled = false;
+                  w.completionSignaledAt = 0;
+                  dbg(`${short(sid)} genuine new user message after latched completion \u2014 re-opening stall detection`);
+                } else {
+                  dbg(`${short(sid)} completion latched \u2014 skipping stall detection`);
+                }
+              } else if (!isWaitingOnUser(sid, w, history)) {
+                if (w.compacting) {
+                  dbg(`${short(sid)} mid-compaction \u2014 skipping stall detection`);
+                } else if (await hasYoungUnfinishedWork(sid, now)) {
+                  dbg(`${short(sid)} tool call still unfinished in history \u2014 working, not stalled`);
+                } else if (await parentWaitingOnSubagents(sid, activeSet)) {
+                  dbg(`${short(sid)} waiting on subagents \u2014 skipping stall detection`);
+                } else {
+                  const profile = resolveProfile(sid);
+                  const profileChunkTimeoutMs = profile.chunkTimeoutMs;
+                  const profileGracePeriodMs = profile.gracePeriodMs;
+                  const silence = now - w.lastActivityAt;
+                  const fuseMult = Math.min(8, 2 ** Math.max(0, w.episodeRefires));
+                  const baseInterval = (profileChunkTimeoutMs + profileGracePeriodMs) * fuseMult;
+                  const jitter = baseInterval > 60000 ? Math.floor(Math.random() * STALL_JITTER_MS * 2) - STALL_JITTER_MS : 0;
+                  if (silence >= baseInterval + jitter) {
+                    try {
+                      const _qlast2 = history.length ? history[history.length - 1] : null;
+                      let _qtype2 = "";
+                      let _qmsg2 = "";
+                      if (_qlast2 && msgRole(_qlast2) === "assistant") {
+                        const _qe2 = _qlast2.error ?? _qlast2.info?.error;
+                        if (typeof _qe2 === "string")
+                          _qmsg2 = _qe2;
+                        else if (_qe2 && typeof _qe2 === "object") {
+                          _qtype2 = String(_qe2.name ?? _qe2.type ?? "");
+                          _qmsg2 = String(_qe2.message ?? "");
+                        }
+                        const _qtxt2 = lastAssistantTextFrom(history);
+                        if (_qtxt2)
+                          _qmsg2 = _qmsg2 ? `${_qmsg2} ${_qtxt2}` : _qtxt2;
+                      }
+                      if (isRateLimitError(_qtype2, _qmsg2)) {
+                        handleRateLimitFailure(sid, w, _qtype2, _qmsg2);
+                        continue;
+                      }
+                    } catch (e) {
+                      dbg(`${short(sid)} quota guard (idle) failed: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                    if (w.awaitingQuotaRetry || w.rateLimitedAt > 0) {
+                      dbg(`${short(sid)} quota-armed \u2014 skipping stall recover`);
+                      continue;
+                    }
+                    await recover(sid, `no activity for ${Math.ceil(silence / 1000)}s`);
+                  }
+                }
+              }
+            }
+            continue;
+          } else {
+            continue;
+          }
+        }
+        if (now - w.createdAt < warmupMs)
+          continue;
+        if (w.orphanWatchStartAt !== null) {
+          if (!w.aborting && !w.gaveUp && !w.completionSignaled) {
+            await runOrphanWatch(sid, w, now, activeSet);
+          }
+          continue;
+        }
+        if (w.completionSignaled) {
+          noteInboundUserMessage(sid, w, await loadMessages(sid));
+          if (w.lastGenuineUserAt > w.completionSignaledAt) {
+            w.completionSignaled = false;
+            w.completionSignaledAt = 0;
+            dbg(`${short(sid)} genuine new user message after latched completion \u2014 re-opening stall detection`);
+          } else {
+            dbg(`${short(sid)} completion latched \u2014 skipping stall detection`);
+            continue;
+          }
+        }
+        if (w.compacting && w.compactionStartedAt && now - w.compactionStartedAt > COMPACTION_STALE_TTL_MS) {
+          w.compacting = false;
+          w.compactionStartedAt = null;
+          log("warn", `${short(sid)} compaction flag stale (>${COMPACTION_STALE_TTL_MS / 60000}m) \u2014 clearing guard`);
+        }
+        if (w.compacting) {
+          dbg(`${short(sid)} mid-compaction \u2014 skipping stall detection`);
+          continue;
+        }
+        const profile = resolveProfile(sid);
+        const profileChunkTimeoutMs = profile.chunkTimeoutMs;
+        const profileGracePeriodMs = profile.gracePeriodMs;
+        const silence = now - w.lastActivityAt;
+        const fuseMult = Math.min(8, 2 ** Math.max(0, w.episodeRefires));
+        const baseInterval = (profileChunkTimeoutMs + profileGracePeriodMs) * fuseMult;
+        const jitter = baseInterval > 60000 ? Math.floor(Math.random() * STALL_JITTER_MS * 2) - STALL_JITTER_MS : 0;
+        if (silence < baseInterval + jitter)
+          continue;
+        {
+          const histText = lastAssistantTextFrom(await loadMessages(sid));
+          if (histText && isUserHandoff(histText)) {
+            dbg(`${short(sid)} quiet turn ends with a hand-off \u2014 waiting on user, not stalled`);
+            continue;
+          }
+          if (histText && turnEndsWithCompletionClaim(histText)) {
+            const open = getOpenTodos(await readTodos(sid));
+            if (open.length > 0) {
+              await targetedRecovery(sid, "stop-open-todos", buildOpenTodosReminder(open), "todoNudgeAttempts");
+            } else if (!w.completionSignaled) {
+              w.completionSignaled = true;
+              w.completionSignaledAt = Date.now();
+              log("info", `${short(sid)} quiet turn ends with a completion claim and no open todos \u2014 latching completion, not nudging`);
+            } else {
+              dbg(`${short(sid)} completion already latched \u2014 skipping`);
+            }
+            continue;
+          }
+        }
+        if (busyStallStrategy === "off") {
+          dbg(`stall on ${short(sid)} ignored (busyStallStrategy=off)`);
+          continue;
+        }
+        clearStalePermissionFlag(sid, w);
+        if (w.permissionPending) {
+          dbg(`${short(sid)} silent but permission pending \u2014 skipping`);
+          continue;
+        }
+        if (selfAbortActive(w)) {
+          dbg(`${short(sid)} silent but inside our own abort window \u2014 skipping`);
+          continue;
+        }
+        const busyShells = openShellCount(sid);
+        if (busyShells > 0) {
+          dbg(`${short(sid)} silent with ${busyShells} shell(s) still running \u2014 waiting`);
+          continue;
+        }
+        {
+          const now = Date.now();
+          let youngTool = false;
+          for (const [, rec] of w.inflightTools ?? []) {
+            const age = now - rec.at;
+            if (neverInterruptTools.includes(rec.name)) {
+              if (age < NEVER_INTERRUPT_STALE_TTL_MS) {
+                dbg(`${short(sid)} silent with exempt tool "${rec.name}" still running (${Math.round(age / 1000)}s) \u2014 waiting`);
+                youngTool = true;
+                break;
+              }
+              continue;
+            }
+            if (age < stallYoungAgeMsFor(rec.name))
+              youngTool = true;
+          }
+          if (youngTool)
+            continue;
+        }
+        if (await hasYoungUnfinishedWork(sid, now)) {
+          dbg(`${short(sid)} tool call still unfinished in history \u2014 working, not stalled`);
+          continue;
+        }
+        if (await parentWaitingOnSubagents(sid, activeSet)) {
+          dbg(`${short(sid)} waiting on subagents \u2014 skipping stall detection`);
+          continue;
+        }
+        if (isWaitingOnUser(sid, w, await loadMessages(sid))) {
+          dbg(`${short(sid)} waiting on user input \u2014 skipping stall detection`);
+          continue;
+        }
+        if (busyStallStrategy === "abort" && w.resumeAttempts < maxRetries) {
+          log("info", `${short(sid)} stall (busyStallStrategy=abort): aborting before continue`);
+          await tryAbortAndResume(sid, w, true);
+        } else {
+          try {
+            const _qm = await loadMessages(sid);
+            const _qlast = _qm.length ? _qm[_qm.length - 1] : null;
+            let _qtype = "";
+            let _qmsg = "";
+            if (_qlast && msgRole(_qlast) === "assistant") {
+              const _qe = _qlast.error ?? _qlast.info?.error;
+              if (typeof _qe === "string")
+                _qmsg = _qe;
+              else if (_qe && typeof _qe === "object") {
+                _qtype = String(_qe.name ?? _qe.type ?? "");
+                _qmsg = String(_qe.message ?? "");
+              }
+              const _qtxt = lastAssistantTextFrom(_qm);
+              if (_qtxt)
+                _qmsg = _qmsg ? `${_qmsg} ${_qtxt}` : _qtxt;
+            }
+            if (isRateLimitError(_qtype, _qmsg)) {
+              handleRateLimitFailure(sid, w, _qtype, _qmsg);
+              continue;
+            }
+          } catch (e) {
+            dbg(`${short(sid)} quota guard failed: ${e instanceof Error ? e.message : String(e)}`);
+          }
+          if (w.awaitingQuotaRetry || w.rateLimitedAt > 0) {
+            dbg(`${short(sid)} quota-armed \u2014 skipping stall recover`);
+            continue;
+          }
+          await recover(sid, `no activity for ${Math.ceil(silence / 1000)}s`);
+        }
+      }
+      for (const [rsid, rw] of sessions) {
+        if (!rw.awaitingQuotaRetry)
+          continue;
+        const ladder = rateLimitCooldownsMs;
+        const rn = rw.rateLimitAttempts;
+        if (rn >= ladder.length) {
+          rw.awaitingQuotaRetry = false;
+          continue;
+        }
+        if (rw.userCancelled || rw.gaveUp || rw.compacting || rw.permissionPending)
+          continue;
+        if (selfAbortActive(rw))
+          continue;
+        if (Date.now() - rw.rateLimitedAt < ladder[rn])
+          continue;
+        serveQuotaRung(rsid, rw, rn, ladder);
+      }
+      cleanupIdleSessions();
+    }
+    let watchdogBusy = false;
+    const watchdog = setInterval(() => {
+      if (watchdogBusy) {
+        dbg("watchdog sweep still running \u2014 skipping this tick");
+        return;
+      }
+      watchdogBusy = true;
+      checkActiveSessions().catch((e) => log("error", `watchdog failed: ${e instanceof Error ? e.message : String(e)}`)).finally(() => {
+        watchdogBusy = false;
+      });
+    }, checkIntervalMs);
+    const discoveryTimer = setInterval(() => {
+      discoverSessions().catch((e) => log("error", `discovery failed: ${e instanceof Error ? e.message : String(e)}`));
+    }, DEFAULT_SESSION_DISCOVERY_INTERVAL_MS);
+    const initialDiscovery = setTimeout(() => {
+      discoverSessions().catch(() => {});
+    }, discoveryDelayMs);
+    await registerTaskCompleteFallback();
+    await observeTaskCompleteTool();
+    function tokenTotalOf(tokens) {
+      if (!tokens || typeof tokens !== "object")
+        return 0;
+      const t = tokens;
+      const cache = t.cache ?? {};
+      return posNum(t.input) + posNum(t.output) + posNum(t.reasoning) + posNum(cache.read) + posNum(cache.write);
+    }
+    function posNum(v) {
+      return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+    }
+    const usableLimitCache = new Map;
+    async function getUsableContextLimit(sid) {
+      try {
+        let ref = sessions.get(sid)?.modelRef;
+        if (!ref) {
+          const msgs = await ctx.session.context({ sessionID: sid });
+          if (Array.isArray(msgs)) {
+            for (let i = msgs.length - 1;i >= 0; i--) {
+              const m = msgs[i];
+              if (msgRole(m) !== "assistant" || !m.model)
+                continue;
+              const providerID = m.model.providerID;
+              const modelID = m.model.modelID ?? m.model.id;
+              if (typeof providerID === "string" && typeof modelID === "string") {
+                ref = { providerID, modelID };
+                const w = sessions.get(sid);
+                if (w)
+                  w.modelRef = ref;
+              }
+              break;
+            }
+          }
+        }
+        if (!ref)
+          return null;
+        const key = `${ref.providerID}/${ref.modelID}`;
+        const cached = usableLimitCache.get(key);
+        if (cached !== undefined)
+          return cached;
+        const info = ctx.model?.get?.(ref.providerID, ref.modelID);
+        if (!info)
+          return null;
+        const limit = info.limit;
+        if (!limit || typeof limit.context !== "number" || limit.context === 0)
+          return null;
+        const usable = limit.context - Math.min(20000, limit.output ?? 0);
+        if (!Number.isFinite(usable) || usable <= 0)
+          return null;
+        usableLimitCache.set(key, usable);
+        return usable;
+      } catch (e) {
+        dbg(`usable-context-limit lookup failed for ${short(sid)}:`, e instanceof Error ? e.message : String(e));
+        return null;
+      }
+    }
+    async function callSessionApi(name, args) {
+      const fromDomain = ctx.session[name];
+      if (typeof fromDomain === "function") {
+        try {
+          return await fromDomain.call(ctx.session, args);
+        } catch (e) {
+          dbg(`ctx.session.${name}() failed:`, e instanceof Error ? e.message : String(e));
+        }
+      }
+      const fromClient = ctx.client?.session?.[name];
+      if (typeof fromClient === "function") {
+        try {
+          return await fromClient.call(ctx.client.session, args);
+        } catch (e) {
+          dbg(`ctx.client.session.${name}() failed:`, e instanceof Error ? e.message : String(e));
+        }
+      }
+      return;
+    }
+    let magicContextDetected = null;
+    async function isMagicContextInstalled() {
+      if (magicContextDetected !== null)
+        return magicContextDetected;
+      try {
+        const list = ctx.plugin?.list;
+        if (typeof list !== "function") {
+          dbg("magic-context detection: ctx.plugin.list unavailable, treating as not installed");
+          return false;
+        }
+        const plugins = unwrapList(await list.call(ctx.plugin));
+        magicContextDetected = plugins.some((p) => {
+          const id = typeof p?.id === "string" ? p.id : "";
+          if (id.toLowerCase().includes("magic-context"))
+            return true;
+          const src = p?.source;
+          const spec = src?.target ?? src?.path ?? "";
+          return typeof spec === "string" && spec.toLowerCase().includes("magic-context");
+        });
+        dbg(`magic-context detection: ${magicContextDetected ? "installed" : "not installed"}`);
+        return magicContextDetected;
+      } catch (e) {
+        dbg("magic-context detection failed, treating as not installed:", e instanceof Error ? e.message : String(e));
+        return false;
+      }
+    }
+    function unwrapList(response) {
+      if (Array.isArray(response))
+        return response;
+      if (response && typeof response === "object") {
+        const data = response.data;
+        if (Array.isArray(data))
+          return data;
+      }
+      return [];
+    }
+    async function checkContextSaturation(sid) {
+      const w = sessions.get(sid);
+      if (!w)
+        return;
+      if (w.lastTokenTotal <= 0)
+        return;
+      if (w.contextWrapupAttempts >= 1)
+        return;
+      if (w.userCancelled || w.completionSignaled || w.aborting)
+        return;
+      const usable = await getUsableContextLimit(sid);
+      if (!usable)
+        return;
+      if (w.lastTokenTotal / usable < contextSaturationThreshold)
+        return;
+      const pct = Math.round(w.lastTokenTotal / usable * 100);
+      if (await isSubAgentSession(sid)) {
+        if (!subagentNativeCompactionEnabled) {
+          dbg(`${short(sid)} subagent at ${pct}% of usable context; native compaction is opt-in`);
+          return;
+        }
+        w.contextWrapupAttempts++;
+        log("warn", `${short(sid)} context saturation (subagent): ${w.lastTokenTotal}/${usable} tokens (${pct}% of usable); triggering native compaction`);
+        if (w.userCancelled || w.completionSignaled)
+          return;
+        const compacted = await callSessionApi("compact", { sessionID: sid });
+        if (compacted === undefined) {
+          log("warn", `${short(sid)} native compaction is not exposed on this host \u2014 skipping`);
+        }
+        return;
+      }
+      if (!await isMagicContextInstalled()) {
+        dbg(`${short(sid)} at ${pct}% of usable context; magic-context not installed, not intervening`);
+        return;
+      }
+      w.contextWrapupAttempts++;
+      log("warn", `${short(sid)} context saturation: ${w.lastTokenTotal}/${usable} tokens (${pct}% of usable); sending magic-context wrapup command`);
+      if (w.userCancelled || w.completionSignaled)
+        return;
+      try {
+        await ctx.session.command({ sessionID: sid, name: CTX_WRAPUP_TRIGGER });
+      } catch (e) {
+        log("warn", `${short(sid)} magic-context wrapup command failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    async function discoverSessions() {
+      try {
+        const listed = unwrapList(await callSessionApi("list"));
+        let seeded = 0;
+        for (const row of listed) {
+          const sid = row?.id;
+          if (typeof sid !== "string" || !sid.startsWith("ses_"))
+            continue;
+          if (!sessions.has(sid)) {
+            ensureWatch(sid);
+            seeded++;
+          }
+        }
+        const active = await callSessionApi("active");
+        let adopted = 0;
+        if (active && typeof active === "object") {
+          for (const [sid, val] of Object.entries(active)) {
+            if (!sid.startsWith("ses_"))
+              continue;
+            const w = ensureWatch(sid);
+            if (w.status !== "busy") {
+              markBusy(sid);
+              adopted++;
+            }
+          }
+        }
+        if (seeded > 0 || adopted > 0) {
+          log("info", `discovery: seeded ${seeded} session(s), adopted ${adopted} already running`);
+        } else {
+          dbg("discovery: nothing new");
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        dbg(`session discovery failed: ${msg}`);
+      }
+    }
+    async function restoreQuotaLadders() {
+      let listed;
+      try {
+        listed = new Set(unwrapList(await callSessionApi("list")).map((r) => r.id).filter((id) => typeof id === "string"));
+      } catch {
+        return;
+      }
+      const horizon = rateLimitCooldownsMs.reduce((a, b) => a + b, 0);
+      const restored = new Set;
+      if (ctx.storage?.set) {
+        for (const sid of listed) {
+          let rec;
+          try {
+            rec = await ctx.storage.get(`${QUOTA_STATE_PREFIX}${sid}`);
+          } catch (e) {
+            dbg(`${short(sid)} quota record read failed:`, e instanceof Error ? e.message : String(e));
+            continue;
+          }
+          const r = rec;
+          if (!r || typeof r.at !== "number")
+            continue;
+          if (Date.now() - r.at >= QUOTA_STATE_MAX_AGE_MS) {
+            syncQuotaState(sid, ensureWatch(sid), true);
+            continue;
+          }
+          if (Date.now() - r.at >= horizon)
+            continue;
+          const w = ensureWatch(sid);
+          if (w.awaitingQuotaRetry || w.rateLimitedAt > 0)
+            continue;
+          if (w.status === "busy") {
+            dbg(`${short(sid)} busy \u2014 skipping quota restore`);
+            continue;
+          }
+          w.rateLimitedAt = r.at;
+          w.rateLimitAttempts = typeof r.rung === "number" ? r.rung : 0;
+          w.awaitingQuotaRetry = true;
+          w.quotaNoticedAt = typeof r.noticed === "number" && r.noticed > 0 ? r.noticed : r.at;
+          restored.add(sid);
+          log("warn", `${short(sid)} quota ladder restored (armed ${Math.round((Date.now() - r.at) / 1000)}s ago, rung ${w.rateLimitAttempts}) \u2014 retry due on schedule`);
+        }
+      }
+    }
+    async function syncQuotaState(sid, w, force = false) {
+      try {
+        const st = ctx.storage;
+        if (!st?.set)
+          return;
+        const key = `${QUOTA_STATE_PREFIX}${sid}`;
+        if (!w.rateLimitedAt) {
+          if (force || st.remove)
+            await st.remove?.(key);
+          return;
+        }
+        await st.set(key, {
+          v: 1,
+          at: w.rateLimitedAt,
+          rung: w.rateLimitAttempts,
+          noticed: w.quotaNoticedAt
+        });
+      } catch (e) {
+        dbg(`${short(sid)} quota state sync failed:`, e instanceof Error ? e.message : String(e));
+      }
+    }
+    async function syncCounters(sid, w) {
+      try {
+        const st = ctx.storage;
+        if (!st?.set)
+          return;
+        const key = `${COUNTER_STATE_PREFIX}${sid}`;
+        await st.set(key, {
+          v: 1,
+          workRetries: w.workRetries ?? 0,
+          resumeAttempts: w.resumeAttempts ?? 0,
+          lifetimeContinues: w.lifetimeContinues ?? 0,
+          episodeRefires: w.episodeRefires ?? 0,
+          at: Date.now()
+        });
+      } catch (e) {
+        dbg(`${short(sid)} counter sync failed:`, e instanceof Error ? e.message : String(e));
+      }
+    }
+    function handleEvent(ev) {
+      switch (ev.type) {
+        case "session.execution.started": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          if (w.selfRecovery) {
+            w.selfRecovery = false;
+          } else {
+            const providerRetryFresh = isProviderRetryFresh(w);
+            clearLocks(w, sid);
+            w.rateLimitedAt = 0;
+            w.rateLimitAttempts = 0;
+            w.quotaNoticedAt = 0;
+            w.awaitingQuotaRetry = false;
+            w.gaveUp = false;
+            (async () => {
+              const selfInjectFresh = w.lastInjectAt > 0 && w.lastInjectAt >= w.lastGenuineUserAt;
+              let ownRung = !providerRetryFresh && selfInjectFresh;
+              if (ownRung) {
+                try {
+                  for (const m of await loadMessages(sid)) {
+                    if (msgRole(m) === "user" && msgAt(m) > w.lastInjectAt) {
+                      ownRung = false;
+                      break;
+                    }
+                  }
+                } catch {
+                  ownRung = false;
+                }
+              }
+              if (!ownRung) {
+                w.lifetimeContinues = 0;
+                w.workRetries = 0;
+                w.emptyIdleNudged = false;
+                if (ctx.storage?.remove) {
+                  ctx.storage.remove(`${COUNTER_STATE_PREFIX}${sid}`).catch(() => {});
+                }
+              }
+              syncQuotaState(sid, w);
+              if (!ownRung) {
+                w.resumeAttempts = 0;
+              }
+            })();
+          }
+          markBusy(sid);
+          return;
+        }
+        case "session.usage.updated": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const total = tokenTotalOf(ev.data?.tokens);
+          if (total <= 0)
+            return;
+          const w = ensureWatch(sid);
+          if (total > w.lastTokenTotal)
+            touch(sid);
+          w.lastTokenTotal = total;
+          dbg(`${short(sid)} usage: ${total} tokens`);
+          return;
+        }
+        case "session.execution.succeeded":
+        case "session.idle": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          dbg(`${short(sid)} idle event data keys: ${JSON.stringify(Object.keys(ev?.data ?? {}))}`);
+          const busyBefore = busySessionsForOrphanWatch().length;
+          const wPre = ensureWatch(sid);
+          wPre.toolsInFlightAtIdle = wPre.pendingTools;
+          markIdle(sid);
+          const w = ensureWatch(sid);
+          w.pendingRecoveryArmed = false;
+          w.selfRecovery = false;
+          if (selfAbortActive(w)) {
+            dbg(`${short(sid)} idle after plugin-initiated abort \u2014 skipping targeted recovery`);
+            return;
+          }
+          const busyNow = busySessionsForOrphanWatch();
+          if (busyBefore > 1 && busyNow.length === 1) {
+            armOrphanWatch(busyNow[0]);
+          }
+          inspectOnIdle(sid);
+          if (!w.completionSignaled && !w.userCancelled) {
+            checkForUnknownToolCalls(sid, w);
+          }
+          return;
+        }
+        case "session.execution.interrupted": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          const reason = typeof ev.data?.reason === "string" ? ev.data.reason : undefined;
+          const mine = w.aborting || selfAbortActive(w);
+          if (!mine) {
+            w.userCancelled = reason === undefined || reason === "user";
+            if (w.userCancelled)
+              w.userCancelledAt = Date.now();
+          }
+          w.compacting = false;
+          w.compactionStartedAt = null;
+          w.recovering = false;
+          markIdle(sid);
+          return;
+        }
+        case "session.deleted": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          forgetShells(sid);
+          sessions.delete(sid);
+          return;
+        }
+        case "session.revert.staged": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          touch(sid);
+          return;
+        }
+        case "session.revert.cleared":
+        case "session.revert.committed": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          forgetShells(sid);
+          sessions.delete(sid);
+          return;
+        }
+        case "session.compaction.started": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          if (!w.compacting) {
+            w.compacting = true;
+            w.compactionStartedAt = Date.now();
+            log("info", `${short(sid)} compaction started \u2014 auto-resume recovery suspended until it ends`);
+          }
+          touch(sid);
+          return;
+        }
+        case "session.compaction.ended":
+        case "session.compaction.failed": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          if (w.compacting) {
+            w.compacting = false;
+            w.compactionStartedAt = null;
+            log("info", `${short(sid)} compaction ${ev.type.endsWith("failed") ? "failed" : "ended"} \u2014 guard cleared`);
+          }
+          touch(sid);
+          return;
+        }
+        case "session.step.started": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          w.agent = typeof ev.data?.agent === "string" ? ev.data.agent : w.agent;
+          {
+            const m = ev.data?.model;
+            const providerID = m?.providerID ?? m?.provider;
+            const modelID = m?.modelID ?? m?.id;
+            if (typeof providerID === "string" && typeof modelID === "string") {
+              w.modelRef = { providerID, modelID };
+              w.model = `${providerID}/${modelID}`;
+            } else if (m) {
+              w.model = `${providerID ?? "?"}/${modelID ?? "?"}`;
+            } else {
+              w.model = w.model;
+            }
+          }
+          w.lastWasTaskTool = false;
+          markBusy(sid);
+          return;
+        }
+        case "session.step.ended": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          touch(sid);
+          return;
+        }
+        case "session.step.streamed":
+        case "session.text.started":
+        case "session.reasoning.started":
+        case "session.synthetic": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          touch(sid);
+          return;
+        }
+        case "session.tool.input.started":
+        case "session.tool.input.delta": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          touch(sid);
+          return;
+        }
+        case "session.text.delta":
+        case "session.reasoning.delta": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          appendText(sid, ev.data?.assistantMessageID, typeof ev.data?.delta === "string" ? ev.data.delta : "");
+          touch(sid);
+          return;
+        }
+        case "session.text.ended":
+        case "session.reasoning.ended": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          touch(sid);
+          return;
+        }
+        case "session.tool.called": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          const name = typeof ev.data?.tool === "string" ? ev.data.tool : ev.data?.id ?? "tool";
+          w.lastWasTaskTool = isTaskToolCall(ev);
+          w.pendingTools++;
+          {
+            const callId = typeof ev.data?.id === "string" && ev.data.id ? ev.data.id : `${name}#${Date.now()}`;
+            w.inflightTools.set(callId, { name: String(name).toLowerCase(), at: Date.now() });
+          }
+          if (name !== "task_complete")
+            w.taskCompleteSignals = 0;
+          if (trackToolCall(w, name)) {
+            targetedRecovery(sid, "tool-loop", TOOL_LOOP_RECOVERY_PROMPT, "intentNudgeAttempts").catch(() => {});
+          }
+          touch(sid);
+          return;
+        }
+        case "session.tool.progress":
+        case "session.shell.started":
+        case "session.shell.ended": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          touch(sid);
+          return;
+        }
+        case "shell.created": {
+          const info = ev.data?.info;
+          if (!info || typeof info !== "object")
+            return;
+          const rec = info;
+          const id = rec.id;
+          const sid = rec.metadata?.sessionID;
+          if (typeof id !== "string" || typeof sid !== "string")
+            return;
+          openShells.set(id, { sessionID: sid, startedAt: Date.now() });
+          touch(sid);
+          return;
+        }
+        case "shell.exited": {
+          const id = ev.data?.id;
+          if (typeof id !== "string")
+            return;
+          const sid = openShells.get(id)?.sessionID;
+          if (sid === undefined)
+            return;
+          openShells.delete(id);
+          const wsh = ensureWatch(sid);
+          wsh.completedSinceProd++;
+          wsh.succeededSinceProd++;
+          touch(sid);
+          return;
+        }
+        case "session.tool.success": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          w.lastWasTaskTool = false;
+          w.pendingTools = Math.max(0, w.pendingTools - 1);
+          {
+            const callId = typeof ev.data?.id === "string" ? ev.data.id : undefined;
+            if (callId !== undefined)
+              w.inflightTools.delete(callId);
+            else {
+              const oldest = w.inflightTools.keys().next().value;
+              if (typeof oldest === "string")
+                w.inflightTools.delete(oldest);
+            }
+          }
+          w.completedSinceProd++;
+          w.succeededSinceProd++;
+          touch(sid);
+          return;
+        }
+        case "session.tool.failed": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          w.lastWasTaskTool = false;
+          w.pendingTools = Math.max(0, w.pendingTools - 1);
+          {
+            const callId = typeof ev.data?.id === "string" ? ev.data.id : undefined;
+            if (callId !== undefined)
+              w.inflightTools.delete(callId);
+            else {
+              const oldest = w.inflightTools.keys().next().value;
+              if (typeof oldest === "string")
+                w.inflightTools.delete(oldest);
+            }
+          }
+          w.completedSinceProd++;
+          touch(sid);
+          return;
+        }
+        case "permission.asked": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          w.permissionPending = true;
+          w.permissionPendingAt = Date.now();
+          return;
+        }
+        case "permission.replied": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          w.permissionPending = false;
+          w.permissionPendingAt = null;
+          touch(sid);
+          return;
+        }
+        case "session.retry.scheduled": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          touch(sid);
+          w.providerRetryAt = Date.now();
+          const errType = String(ev.data?.error?.type ?? "");
+          const errMsg = String(ev.data?.error?.message ?? "");
+          maybeLockOoc(sid, errMsg, errType);
+          if (maybeLockPermanent(sid, errMsg, errType, ev.data?.error?.status))
+            return;
+          log("info", `${short(sid)} provider retry #${ev.data?.attempt ?? "?"}: ${errType || errMsg}`);
+          if (!isStreamingFailure(errMsg, streamingFailureMessagePatterns) && !isStreamingFailureName(errType, streamingFailureErrorNames) && errType !== "retryable")
+            return;
+          if (nowSilenceTooLong(w)) {
+            w.pendingRecoveryArmed = true;
+            recover(sid, "streaming failure with scheduled retry");
+          }
+          return;
+        }
+        case "session.step.failed":
+        case "session.execution.failed": {
+          const sid = sidOf(ev);
+          if (!sid)
+            return;
+          const w = ensureWatch(sid);
+          const errMsg = String(ev.data?.error?.message ?? "");
+          const errType = String(ev.data?.error?.type ?? "");
+          if (w.aborting || selfAbortActive(w)) {
+            dbg(`${short(sid)} ${ev.type} is this plugin's own abort (${errType || "error"}) \u2014 not recovering`);
+            w.recovering = false;
+            w.pendingRecoveryArmed = false;
+            return;
+          }
+          if (isAbortError(errType, errMsg)) {
+            dbg(`${short(sid)} failure was an interrupt (${errType || "error"}) \u2014 not recovering`);
+            w.pendingRecoveryArmed = false;
+            return;
+          }
+          if (isRateLimitError(errType, errMsg)) {
+            handleRateLimitFailure(sid, w, errType, errMsg);
+            return;
+          }
+          maybeLockOoc(sid, errMsg, errType);
+          if (maybeLockPermanent(sid, errMsg, errType, ev.data?.error?.status)) {
+            markIdle(sid);
+            w.pendingRecoveryArmed = false;
+            w.recovering = false;
+            log("warn", `${short(sid)} ${ev.type}: ${errType || "error"} ${errMsg.slice(0, 160)}`);
+            return;
+          }
+          markIdle(sid);
+          w.pendingRecoveryArmed = true;
+          log("warn", `${short(sid)} ${ev.type}: ${errType || "error"} ${errMsg.slice(0, 160)}`);
+          recover(sid, `${ev.type}${isStreamingFailure(errMsg, streamingFailureMessagePatterns) ? " (streaming)" : ""}`);
+          return;
+        }
+        default:
+          return;
+      }
+    }
+    function nowSilenceTooLong(w) {
+      return Date.now() - w.lastActivityAt > chunkTimeoutMs + gracePeriodMs;
+    }
+    let running = true;
+    const eventAbort = new AbortController;
+    const pump = async () => {
+      try {
+        const stream = ctx.event.subscribe({ signal: eventAbort.signal });
+        for await (const raw of stream) {
+          if (!running)
+            return;
+          const ev = raw;
+          if (!ev || typeof ev.type !== "string")
+            continue;
+          try {
+            handleEvent(ev);
+          } catch (e) {
+            dbg("handler error:", e instanceof Error ? e.message : String(e));
+          }
+        }
+      } catch (e) {
+        if (running)
+          log("error", `event stream ended: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    };
+    pump();
+    restoreQuotaLadders();
+    (async () => {
+      try {
+        const listed = new Set(unwrapList(await callSessionApi("list")).map((r) => r.id).filter((id) => typeof id === "string"));
+        for (const sid of listed) {
+          let rec;
+          try {
+            rec = await ctx.storage.get(`${COUNTER_STATE_PREFIX}${sid}`);
+          } catch {
+            continue;
+          }
+          if (!rec || typeof rec !== "object")
+            continue;
+          const recObj = rec;
+          if (typeof recObj.v !== "number")
+            continue;
+          if (typeof recObj.at !== "number" || Date.now() - recObj.at > 24 * 3600000)
+            continue;
+          const w = ensureWatch(sid);
+          if (w.workRetries > 0)
+            continue;
+          w.workRetries = typeof recObj.workRetries === "number" ? recObj.workRetries : 0;
+          w.resumeAttempts = typeof recObj.resumeAttempts === "number" ? recObj.resumeAttempts : 0;
+          w.lifetimeContinues = typeof recObj.lifetimeContinues === "number" ? recObj.lifetimeContinues : 0;
+          w.episodeRefires = typeof recObj.episodeRefires === "number" ? recObj.episodeRefires : 0;
+          dbg(`${short(sid)} counters restored: workRetries=${w.workRetries} resumeAttempts=${w.resumeAttempts} lifetimeContinues=${w.lifetimeContinues}`);
+        }
+      } catch (e) {
+        dbg("counter restore failed:", e instanceof Error ? e.message : String(e));
+      }
+    })();
+    if (superseded) {
+      log("warn", `superseded live instance mod=${superseded.mod} (age ${Math.round((Date.now() - superseded.startedAt) / 1000)}s) by mod=${MODULE_INSTANCE} boot=${HOST_BOOT}`);
+    }
+    if (adoptedSessions > 0) {
+      log("info", `adopted ${adoptedSessions} watched session(s) from previous instance (stall memory retained) mod=${MODULE_INSTANCE}`);
+    }
+    if (ctx.command && typeof ctx.command.transform === "function") {
+      try {
+        await ctx.command.transform((cmd) => {
+          cmd.add({
+            name: "auto-resume",
+            description: "Pause or resume auto-resume for this session: /auto-resume off|on|status",
+            execute: async (input) => {
+              const sessionID = String(input?.sessionID ?? "");
+              const rawArg = input?.args ?? input?.prompt?.args ?? input?.prompt?.text ?? input?.text ?? "";
+              const verb = String(rawArg).trim().toLowerCase().split(/\s+/)[0] || "status";
+              const w = ensureWatch(sessionID);
+              const msg = (text) => ctx.session.prompt({ sessionID, text });
+              if (verb === "off" || verb === "pause") {
+                setPaused(sessionID, true);
+                w.paused = true;
+                await msg("auto-resume paused for this session. Run /auto-resume on to resume.");
+              } else if (verb === "on" || verb === "resume") {
+                setPaused(sessionID, false);
+                w.paused = false;
+                await msg("auto-resume resumed for this session.");
+              } else {
+                const state = isPaused(sessionID) ? "paused" : "active";
+                await msg(`auto-resume is ${state} for this session.`);
+              }
+            }
+          });
+        });
+      } catch (e) {
+        log("warn", `auto-resume command registration failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    try {
+      writeFileSync(PAUSED_MARKER_FILE, "", "utf8");
+    } catch {}
+    if (gatedInUse.length > 0) {
+      log("warn", `accepted-but-inert=${gatedInUse.join(",")} \u2014 this v2 build recognises these option(s) but does not act on them yet.`);
+    }
+    const dispose = () => {
+      running = false;
+      eventAbort.abort();
+      clearInterval(watchdog);
+      clearInterval(discoveryTimer);
+      clearTimeout(initialDiscovery);
+      for (const w of sessions.values()) {
+        if (w.toolTextTimer)
+          clearTimeout(w.toolTextTimer);
+        w.toolTextTimer = null;
+        if (w.recoverTimer)
+          clearTimeout(w.recoverTimer);
+        w.recoverTimer = null;
+      }
+      const reg = singletonRegistry(registryScope);
+      if (reg.live?.dispose === dispose)
+        reg.live = undefined;
+      log("info", `stopped mod=${MODULE_INSTANCE}`);
+    };
+    registry.live = { dispose, mod: MODULE_INSTANCE, startedAt: Date.now() };
+    return dispose;
+  }
+});
+export {
+  configMentionsTaskComplete,
+  v2_default as default
+};