evil-omo 3.12.0 → 3.12.2

package/dist/index.js

@@ -16190,7 +16190,7 @@ async function resolveFileReferencesInText(text, cwd = process.cwd(), depth = 0,
   }
   let resolved = text;
   for (const [pattern, replacement] of replacements.entries()) {
-    resolved = resolved.split(pattern).join(replacement);
+    resolved = resolved.replaceAll(pattern, replacement);
   }
   if (findFileReferences(resolved).length > 0 && depth + 1 < maxDepth) {
     return resolveFileReferencesInText(resolved, cwd, depth + 1, maxDepth);
@@ -16289,6 +16289,7 @@ function transformToolName(toolName) {
 function escapeRegexExceptAsterisk(str2) {
   return str2.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
 }
+var regexCache = new Map;
 function matchesToolMatcher(toolName, matcher) {
   if (!matcher) {
     return true;
@@ -16296,8 +16297,12 @@ function matchesToolMatcher(toolName, matcher) {
   const patterns = matcher.split("|").map((p) => p.trim());
   return patterns.some((p) => {
     if (p.includes("*")) {
-      const escaped = escapeRegexExceptAsterisk(p);
-      const regex = new RegExp(`^${escaped.replace(/\*/g, ".*")}$`, "i");
+      let regex = regexCache.get(p);
+      if (!regex) {
+        const escaped = escapeRegexExceptAsterisk(p);
+        regex = new RegExp(`^${escaped.replace(/\*/g, ".*")}$`, "i");
+        regexCache.set(p, regex);
+      }
       return regex.test(toolName);
     }
     return p.toLowerCase() === toolName.toLowerCase();
@@ -17653,120 +17658,156 @@ import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync
 import { join as join10 } from "path";
 var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json";
 var PROVIDER_MODELS_CACHE_FILE = "provider-models.json";
-function getCacheFilePath(filename) {
-  return join10(getOmoOpenCodeCacheDir(), filename);
-}
-function ensureCacheDir2() {
-  const cacheDir = getOmoOpenCodeCacheDir();
-  if (!existsSync8(cacheDir)) {
-    mkdirSync2(cacheDir, { recursive: true });
-  }
-}
-function readConnectedProvidersCache() {
-  const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
-  if (!existsSync8(cacheFile)) {
-    log("[connected-providers-cache] Cache file not found", { cacheFile });
-    return null;
+function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDir) {
+  function getCacheFilePath(filename) {
+    return join10(getCacheDir2(), filename);
+  }
+  let memConnected;
+  let memProviderModels;
+  function ensureCacheDir2() {
+    const cacheDir = getCacheDir2();
+    if (!existsSync8(cacheDir)) {
+      mkdirSync2(cacheDir, { recursive: true });
+    }
+  }
+  function readConnectedProvidersCache() {
+    if (memConnected !== undefined)
+      return memConnected;
+    const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
+    if (!existsSync8(cacheFile)) {
+      log("[connected-providers-cache] Cache file not found", { cacheFile });
+      memConnected = null;
+      return null;
+    }
+    try {
+      const content = readFileSync4(cacheFile, "utf-8");
+      const data = JSON.parse(content);
+      log("[connected-providers-cache] Read cache", { count: data.connected.length, updatedAt: data.updatedAt });
+      memConnected = data.connected;
+      return data.connected;
+    } catch (err) {
+      log("[connected-providers-cache] Error reading cache", { error: String(err) });
+      memConnected = null;
+      return null;
+    }
   }
-  try {
-    const content = readFileSync4(cacheFile, "utf-8");
-    const data = JSON.parse(content);
-    log("[connected-providers-cache] Read cache", { count: data.connected.length, updatedAt: data.updatedAt });
-    return data.connected;
-  } catch (err) {
-    log("[connected-providers-cache] Error reading cache", { error: String(err) });
-    return null;
+  function hasConnectedProvidersCache() {
+    const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
+    return existsSync8(cacheFile);
   }
-}
-function hasConnectedProvidersCache() {
-  const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
-  return existsSync8(cacheFile);
-}
-function writeConnectedProvidersCache(connected) {
-  ensureCacheDir2();
-  const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
-  const data = {
-    connected,
-    updatedAt: new Date().toISOString()
-  };
-  try {
-    writeFileSync2(cacheFile, JSON.stringify(data, null, 2));
-    log("[connected-providers-cache] Cache written", { count: connected.length });
-  } catch (err) {
-    log("[connected-providers-cache] Error writing cache", { error: String(err) });
+  function writeConnectedProvidersCache(connected) {
+    ensureCacheDir2();
+    const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
+    const data = {
+      connected,
+      updatedAt: new Date().toISOString()
+    };
+    try {
+      writeFileSync2(cacheFile, JSON.stringify(data, null, 2));
+      memConnected = connected;
+      log("[connected-providers-cache] Cache written", { count: connected.length });
+    } catch (err) {
+      log("[connected-providers-cache] Error writing cache", { error: String(err) });
+    }
   }
-}
-function readProviderModelsCache() {
-  const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
-  if (!existsSync8(cacheFile)) {
-    log("[connected-providers-cache] Provider-models cache file not found", { cacheFile });
-    return null;
+  function readProviderModelsCache() {
+    if (memProviderModels !== undefined)
+      return memProviderModels;
+    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+    if (!existsSync8(cacheFile)) {
+      log("[connected-providers-cache] Provider-models cache file not found", { cacheFile });
+      memProviderModels = null;
+      return null;
+    }
+    try {
+      const content = readFileSync4(cacheFile, "utf-8");
+      const data = JSON.parse(content);
+      log("[connected-providers-cache] Read provider-models cache", {
+        providerCount: Object.keys(data.models).length,
+        updatedAt: data.updatedAt
+      });
+      memProviderModels = data;
+      return data;
+    } catch (err) {
+      log("[connected-providers-cache] Error reading provider-models cache", { error: String(err) });
+      memProviderModels = null;
+      return null;
+    }
   }
-  try {
-    const content = readFileSync4(cacheFile, "utf-8");
-    const data = JSON.parse(content);
-    log("[connected-providers-cache] Read provider-models cache", {
-      providerCount: Object.keys(data.models).length,
-      updatedAt: data.updatedAt
-    });
-    return data;
-  } catch (err) {
-    log("[connected-providers-cache] Error reading provider-models cache", { error: String(err) });
-    return null;
+  function hasProviderModelsCache() {
+    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+    return existsSync8(cacheFile);
   }
-}
-function hasProviderModelsCache() {
-  const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
-  return existsSync8(cacheFile);
-}
-function writeProviderModelsCache(data) {
-  ensureCacheDir2();
-  const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
-  const cacheData = {
-    ...data,
-    updatedAt: new Date().toISOString()
-  };
-  try {
-    writeFileSync2(cacheFile, JSON.stringify(cacheData, null, 2));
-    log("[connected-providers-cache] Provider-models cache written", {
-      providerCount: Object.keys(data.models).length
-    });
-  } catch (err) {
-    log("[connected-providers-cache] Error writing provider-models cache", { error: String(err) });
-  }
-}
-async function updateConnectedProvidersCache(client) {
-  if (!client?.provider?.list) {
-    log("[connected-providers-cache] client.provider.list not available");
-    return;
+  function writeProviderModelsCache(data) {
+    ensureCacheDir2();
+    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+    const cacheData = {
+      ...data,
+      updatedAt: new Date().toISOString()
+    };
+    try {
+      writeFileSync2(cacheFile, JSON.stringify(cacheData, null, 2));
+      memProviderModels = cacheData;
+      log("[connected-providers-cache] Provider-models cache written", {
+        providerCount: Object.keys(data.models).length
+      });
+    } catch (err) {
+      log("[connected-providers-cache] Error writing provider-models cache", { error: String(err) });
+    }
   }
-  try {
-    const result = await client.provider.list();
-    const connected = result.data?.connected ?? [];
-    log("[connected-providers-cache] Fetched connected providers", { count: connected.length, providers: connected });
-    writeConnectedProvidersCache(connected);
-    const modelsByProvider = {};
-    const allProviders = result.data?.all ?? [];
-    for (const provider of allProviders) {
-      if (provider.models) {
-        const modelIds = Object.keys(provider.models);
-        if (modelIds.length > 0) {
-          modelsByProvider[provider.id] = modelIds;
+  async function updateConnectedProvidersCache(client) {
+    if (!client?.provider?.list) {
+      log("[connected-providers-cache] client.provider.list not available");
+      return;
+    }
+    try {
+      const result = await client.provider.list();
+      const connected = result.data?.connected ?? [];
+      log("[connected-providers-cache] Fetched connected providers", {
+        count: connected.length,
+        providers: connected
+      });
+      writeConnectedProvidersCache(connected);
+      const modelsByProvider = {};
+      const allProviders = result.data?.all ?? [];
+      for (const provider of allProviders) {
+        if (provider.models) {
+          const modelIds = Object.keys(provider.models);
+          if (modelIds.length > 0) {
+            modelsByProvider[provider.id] = modelIds;
+          }
         }
       }
+      log("[connected-providers-cache] Extracted models from provider list", {
+        providerCount: Object.keys(modelsByProvider).length,
+        totalModels: Object.values(modelsByProvider).reduce((sum, ids) => sum + ids.length, 0)
+      });
+      writeProviderModelsCache({
+        models: modelsByProvider,
+        connected
+      });
+    } catch (err) {
+      log("[connected-providers-cache] Error updating cache", { error: String(err) });
     }
-    log("[connected-providers-cache] Extracted models from provider list", {
-      providerCount: Object.keys(modelsByProvider).length,
-      totalModels: Object.values(modelsByProvider).reduce((sum, ids) => sum + ids.length, 0)
-    });
-    writeProviderModelsCache({
-      models: modelsByProvider,
-      connected
-    });
-  } catch (err) {
-    log("[connected-providers-cache] Error updating cache", { error: String(err) });
   }
+  return {
+    readConnectedProvidersCache,
+    hasConnectedProvidersCache,
+    readProviderModelsCache,
+    hasProviderModelsCache,
+    writeProviderModelsCache,
+    updateConnectedProvidersCache
+  };
 }
+var defaultConnectedProvidersCacheStore = createConnectedProvidersCacheStore(() => getOmoOpenCodeCacheDir());
+var {
+  readConnectedProvidersCache,
+  hasConnectedProvidersCache,
+  readProviderModelsCache,
+  hasProviderModelsCache,
+  writeProviderModelsCache,
+  updateConnectedProvidersCache
+} = defaultConnectedProvidersCacheStore;
 
 // src/shared/model-availability.ts
 init_logger();
@@ -20446,15 +20487,18 @@ async function handleSessionIdle(args) {
     shouldSkipContinuation
   } = args;
   log(`[${HOOK_NAME}] session.idle`, { sessionID });
+  console.error(`[TODO-DIAG] session.idle fired for ${sessionID}`);
   const state2 = sessionStateStore.getState(sessionID);
   if (state2.isRecovering) {
     log(`[${HOOK_NAME}] Skipped: in recovery`, { sessionID });
+    console.error(`[TODO-DIAG] BLOCKED: isRecovering=true`);
     return;
   }
   if (state2.abortDetectedAt) {
     const timeSinceAbort = Date.now() - state2.abortDetectedAt;
     if (timeSinceAbort < ABORT_WINDOW_MS) {
       log(`[${HOOK_NAME}] Skipped: abort detected via event ${timeSinceAbort}ms ago`, { sessionID });
+      console.error(`[TODO-DIAG] BLOCKED: abort detected ${timeSinceAbort}ms ago`);
       state2.abortDetectedAt = undefined;
       return;
     }
@@ -20463,6 +20507,7 @@ async function handleSessionIdle(args) {
   const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running") : false;
   if (hasRunningBgTasks) {
     log(`[${HOOK_NAME}] Skipped: background tasks running`, { sessionID });
+    console.error(`[TODO-DIAG] BLOCKED: background tasks running`, backgroundManager?.getTasksByParentSession(sessionID).filter((t) => t.status === "running").map((t) => t.id));
     return;
   }
   try {
@@ -20473,10 +20518,12 @@ async function handleSessionIdle(args) {
     const messages = normalizeSDKResponse(messagesResp, []);
     if (isLastAssistantMessageAborted(messages)) {
       log(`[${HOOK_NAME}] Skipped: last assistant message was aborted (API fallback)`, { sessionID });
+      console.error(`[TODO-DIAG] BLOCKED: last assistant message aborted`);
       return;
     }
     if (hasUnansweredQuestion(messages)) {
       log(`[${HOOK_NAME}] Skipped: pending question awaiting user response`, { sessionID });
+      console.error(`[TODO-DIAG] BLOCKED: hasUnansweredQuestion=true`);
       return;
     }
   } catch (error) {
@@ -20488,21 +20535,27 @@ async function handleSessionIdle(args) {
     todos = normalizeSDKResponse(response, [], { preferResponseOnMissingData: true });
   } catch (error) {
     log(`[${HOOK_NAME}] Todo fetch failed`, { sessionID, error: String(error) });
+    console.error(`[TODO-DIAG] BLOCKED: todo fetch failed`, String(error));
     return;
   }
   if (!todos || todos.length === 0) {
+    sessionStateStore.resetContinuationProgress(sessionID);
     sessionStateStore.resetContinuationProgress(sessionID);
     log(`[${HOOK_NAME}] No todos`, { sessionID });
+    console.error(`[TODO-DIAG] BLOCKED: no todos`);
     return;
   }
   const incompleteCount = getIncompleteCount(todos);
   if (incompleteCount === 0) {
+    sessionStateStore.resetContinuationProgress(sessionID);
     sessionStateStore.resetContinuationProgress(sessionID);
     log(`[${HOOK_NAME}] All todos complete`, { sessionID, total: todos.length });
+    console.error(`[TODO-DIAG] BLOCKED: all todos complete (${todos.length})`);
     return;
   }
   if (state2.inFlight) {
     log(`[${HOOK_NAME}] Skipped: injection in flight`, { sessionID });
+    console.error(`[TODO-DIAG] BLOCKED: inFlight=true`);
     return;
   }
   if (state2.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES && state2.lastInjectedAt && Date.now() - state2.lastInjectedAt >= FAILURE_RESET_WINDOW_MS) {
@@ -20510,20 +20563,14 @@ async function handleSessionIdle(args) {
     log(`[${HOOK_NAME}] Reset consecutive failures after recovery window`, { sessionID, failureResetWindowMs: FAILURE_RESET_WINDOW_MS });
   }
   if (state2.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
-    log(`[${HOOK_NAME}] Skipped: max consecutive failures reached`, {
-      sessionID,
-      consecutiveFailures: state2.consecutiveFailures,
-      maxConsecutiveFailures: MAX_CONSECUTIVE_FAILURES
-    });
+    log(`[${HOOK_NAME}] Skipped: max consecutive failures reached`, { sessionID, consecutiveFailures: state2.consecutiveFailures });
+    console.error(`[TODO-DIAG] BLOCKED: consecutiveFailures=${state2.consecutiveFailures} >= ${MAX_CONSECUTIVE_FAILURES}`);
     return;
   }
   const effectiveCooldown = CONTINUATION_COOLDOWN_MS * Math.pow(2, Math.min(state2.consecutiveFailures, 5));
   if (state2.lastInjectedAt && Date.now() - state2.lastInjectedAt < effectiveCooldown) {
-    log(`[${HOOK_NAME}] Skipped: cooldown active`, {
-      sessionID,
-      effectiveCooldown,
-      consecutiveFailures: state2.consecutiveFailures
-    });
+    log(`[${HOOK_NAME}] Skipped: cooldown active`, { sessionID, effectiveCooldown, consecutiveFailures: state2.consecutiveFailures });
+    console.error(`[TODO-DIAG] BLOCKED: cooldown active (${effectiveCooldown}ms, failures=${state2.consecutiveFailures})`);
     return;
   }
   let resolvedInfo;
@@ -20544,10 +20591,12 @@ async function handleSessionIdle(args) {
   const resolvedAgentName = resolvedInfo?.agent;
   if (resolvedAgentName && skipAgents.some((s) => getAgentConfigKey(s) === getAgentConfigKey(resolvedAgentName))) {
     log(`[${HOOK_NAME}] Skipped: agent in skipAgents list`, { sessionID, agent: resolvedAgentName });
+    console.error(`[TODO-DIAG] BLOCKED: agent '${resolvedAgentName}' in skipAgents`);
     return;
   }
   if ((compactionGuardActive || encounteredCompaction) && !resolvedInfo?.agent) {
     log(`[${HOOK_NAME}] Skipped: compaction occurred but no agent info resolved`, { sessionID });
+    console.error(`[TODO-DIAG] BLOCKED: compaction guard + no agent`);
     return;
   }
   if (state2.recentCompactionAt && resolvedInfo?.agent) {
@@ -20555,16 +20604,20 @@ async function handleSessionIdle(args) {
   }
   if (isContinuationStopped?.(sessionID)) {
     log(`[${HOOK_NAME}] Skipped: continuation stopped for session`, { sessionID });
+    console.error(`[TODO-DIAG] BLOCKED: isContinuationStopped=true`);
     return;
   }
   if (shouldSkipContinuation?.(sessionID)) {
     log(`[${HOOK_NAME}] Skipped: another continuation hook already injected`, { sessionID });
+    console.error(`[TODO-DIAG] BLOCKED: shouldSkipContinuation=true (gptPermissionContinuation recently injected)`);
     return;
   }
   const progressUpdate = sessionStateStore.trackContinuationProgress(sessionID, incompleteCount, todos);
   if (shouldStopForStagnation({ sessionID, incompleteCount, progressUpdate })) {
+    console.error(`[TODO-DIAG] BLOCKED: stagnation detected (count=${progressUpdate.stagnationCount})`);
     return;
   }
+  console.error(`[TODO-DIAG] PASSED all gates! Starting countdown (${incompleteCount}/${todos.length} incomplete)`);
   startCountdown({
     ctx,
     sessionID,
@@ -20655,6 +20708,9 @@ function createTodoContinuationHandler(args) {
   } = args;
   return async ({ event }) => {
     const props = event.properties;
+    if (event.type === "session.idle") {
+      console.error(`[TODO-DIAG] handler received session.idle event`, { sessionID: props?.sessionID });
+    }
     if (event.type === "session.error") {
       const sessionID = props?.sessionID;
       if (!sessionID)
@@ -36377,6 +36433,15 @@ function takePendingCall(callID) {
 import * as fs6 from "fs";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join31 } from "path";
+var ApplyPatchMetadataSchema = zod_default.object({
+  files: zod_default.array(zod_default.object({
+    filePath: zod_default.string(),
+    movePath: zod_default.string().optional(),
+    before: zod_default.string(),
+    after: zod_default.string(),
+    type: zod_default.string().optional()
+  }))
+});
 var DEBUG3 = process.env.COMMENT_CHECKER_DEBUG === "1";
 var DEBUG_FILE3 = join31(tmpdir4(), "comment-checker-debug.log");
 function debugLog3(...args) {
@@ -36437,15 +36502,6 @@ function createCommentCheckerHooks(config2) {
         debugLog3("skipping due to tool failure in output");
         return;
       }
-      const ApplyPatchMetadataSchema = zod_default.object({
-        files: zod_default.array(zod_default.object({
-          filePath: zod_default.string(),
-          movePath: zod_default.string().optional(),
-          before: zod_default.string(),
-          after: zod_default.string(),
-          type: zod_default.string().optional()
-        }))
-      });
       if (toolLower === "apply_patch") {
         const parsed = ApplyPatchMetadataSchema.safeParse(output.metadata);
         if (!parsed.success) {
@@ -36916,7 +36972,7 @@ function isTokenLimitError(text) {
     return false;
   }
   const lower = text.toLowerCase();
-  return TOKEN_LIMIT_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()));
+  return TOKEN_LIMIT_KEYWORDS.some((kw) => lower.includes(kw));
 }
 function parseAnthropicTokenLimitError(err) {
   try {
@@ -38334,7 +38390,6 @@ function createAnthropicContextWindowLimitRecoveryHook(ctx, options) {
   };
 }
 // src/hooks/think-mode/detector.ts
-var ENGLISH_PATTERNS = [/\bultrathink\b/i, /\bthink\b/i];
 var MULTILINGUAL_KEYWORDS = [
   "\uC0DD\uAC01",
   "\uAC80\uD1A0",
@@ -38420,8 +38475,7 @@ var MULTILINGUAL_KEYWORDS = [
   "fikir",
   "berfikir"
 ];
-var MULTILINGUAL_PATTERNS = MULTILINGUAL_KEYWORDS.map((kw) => new RegExp(kw, "i"));
-var THINK_PATTERNS = [...ENGLISH_PATTERNS, ...MULTILINGUAL_PATTERNS];
+var COMBINED_THINK_PATTERN = new RegExp(`\\b(?:ultrathink|think)\\b|${MULTILINGUAL_KEYWORDS.join("|")}`, "i");
 var CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
 var INLINE_CODE_PATTERN = /`[^`]+`/g;
 function removeCodeBlocks(text) {
@@ -38429,7 +38483,7 @@ function removeCodeBlocks(text) {
 }
 function detectThinkKeyword(text) {
   const textWithoutCode = removeCodeBlocks(text);
-  return THINK_PATTERNS.some((pattern) => pattern.test(textWithoutCode));
+  return COMBINED_THINK_PATTERN.test(textWithoutCode);
 }
 function extractPromptText(parts) {
   return parts.filter((p) => p.type === "text").map((p) => p.text || "").join("");
@@ -39086,16 +39140,16 @@ async function loadPluginExtendedConfig() {
   }
   return merged;
 }
-var regexCache = new Map;
+var regexCache2 = new Map;
 function getRegex(pattern) {
-  let regex = regexCache.get(pattern);
+  let regex = regexCache2.get(pattern);
   if (!regex) {
     try {
       regex = new RegExp(pattern);
-      regexCache.set(pattern, regex);
+      regexCache2.set(pattern, regex);
     } catch {
       regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-      regexCache.set(pattern, regex);
+      regexCache2.set(pattern, regex);
     }
   }
   return regex;
@@ -39961,8 +40015,6 @@ function createToolExecuteAfterHandler(ctx, config2) {
     if (!output) {
       return;
     }
-    const claudeConfig = await loadClaudeHooksConfig();
-    const extendedConfig = await loadPluginExtendedConfig();
     const cachedInput = getToolInput(input.sessionID, input.tool, input.callID) || {};
     appendTranscriptEntry(input.sessionID, {
       type: "tool_result",
@@ -39974,6 +40026,8 @@ function createToolExecuteAfterHandler(ctx, config2) {
     if (isHookDisabled(config2, "PostToolUse")) {
       return;
     }
+    const claudeConfig = await loadClaudeHooksConfig();
+    const extendedConfig = await loadPluginExtendedConfig();
     const postClient = {
       session: {
         messages: (opts) => ctx.client.session.messages(opts)
@@ -40154,8 +40208,6 @@ function createToolExecuteBeforeHandler(ctx, config2) {
       output.args.todos = parsed;
       log("todowrite: parsed todos string to array", { sessionID: input.sessionID });
     }
-    const claudeConfig = await loadClaudeHooksConfig();
-    const extendedConfig = await loadPluginExtendedConfig();
     appendTranscriptEntry(input.sessionID, {
       type: "tool_use",
       timestamp: new Date().toISOString(),
@@ -40166,6 +40218,8 @@ function createToolExecuteBeforeHandler(ctx, config2) {
     if (isHookDisabled(config2, "PreToolUse")) {
       return;
     }
+    const claudeConfig = await loadClaudeHooksConfig();
+    const extendedConfig = await loadPluginExtendedConfig();
     const preCtx = {
       sessionId: input.sessionID,
       toolName: input.tool,
@@ -43759,6 +43813,9 @@ async function injectContinuationPrompt(ctx, options) {
 async function handleDetectedCompletion(ctx, input) {
   const { sessionID, state: state3, loopState, directory, apiTimeoutMs } = input;
   if (state3.ultrawork && !state3.verification_pending) {
+    if (state3.verification_session_id) {
+      ctx.client.session.abort({ path: { id: state3.verification_session_id } }).catch(() => {});
+    }
     const verificationState = loopState.markVerificationPending(sessionID);
     if (!verificationState) {
       log(`[${HOOK_NAME3}] Failed to transition ultrawork loop to verification`, {
@@ -43995,6 +44052,9 @@ async function handleFailedVerification(ctx, input) {
     });
     return false;
   }
+  if (state3.verification_session_id) {
+    ctx.client.session.abort({ path: { id: state3.verification_session_id } }).catch(() => {});
+  }
   const resumedState = loopState.restartAfterFailedVerification(parentSessionID, messageCountAtStart);
   if (!resumedState) {
     log(`[${HOOK_NAME3}] Failed to restart loop after verification failure`, {
@@ -47600,9 +47660,9 @@ var BabysittingConfigSchema = exports_external.object({
 });
 // src/config/schema/background-task.ts
 var CircuitBreakerConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional(),
   maxToolCalls: exports_external.number().int().min(10).optional(),
-  windowSize: exports_external.number().int().min(5).optional(),
-  repetitionThresholdPercent: exports_external.number().gt(0).max(100).optional()
+  consecutiveThreshold: exports_external.number().int().min(5).optional()
 });
 var BackgroundTaskConfigSchema = exports_external.object({
   defaultConcurrency: exports_external.number().min(1).optional(),
@@ -47798,7 +47858,8 @@ var HookNameSchema = exports_external.enum([
   "write-existing-file-guard",
   "anthropic-effort",
   "hashline-read-enhancer",
-  "read-image-resizer"
+  "read-image-resizer",
+  "todo-description-override"
 ]);
 // src/config/schema/notification.ts
 var NotificationConfigSchema = exports_external.object({
@@ -49201,7 +49262,7 @@ var START_WORK_TEMPLATE = `You are starting a Sisyphus work session.
   - \`--worktree <path>\` (optional): absolute path to an existing git worktree to work in
     - If specified and valid: hook pre-sets worktree_path in boulder.json
     - If specified but invalid: you must run \`git worktree add <path> <branch>\` first
-    - If omitted: you MUST choose or create a worktree (see Worktree Setup below)
+    - If omitted: work directly in the current project directory (no worktree)
 
 ## WHAT TO DO
 
@@ -49218,7 +49279,7 @@ var START_WORK_TEMPLATE = `You are starting a Sisyphus work session.
      - If ONE plan: auto-select it
      - If MULTIPLE plans: show list with timestamps, ask user to select
 
-4. **Worktree Setup** (when \`worktree_path\` not already set in boulder.json):
+4. **Worktree Setup** (ONLY when \`--worktree\` was explicitly specified and \`worktree_path\` not already set in boulder.json):
    1. \`git worktree list --porcelain\` \u2014 see available worktrees
    2. Create: \`git worktree add <absolute-path> <branch-or-HEAD>\`
    3. Update boulder.json to add \`"worktree_path": "<absolute-path>"\`
@@ -49280,9 +49341,41 @@ Reading plan and beginning execution...
 
 - The session_id is injected by the hook - use it directly
 - Always update boulder.json BEFORE starting work
-- Always set worktree_path in boulder.json before executing any tasks
+- If worktree_path is set in boulder.json, all work happens inside that worktree directory
 - Read the FULL plan file before delegating any tasks
-- Follow atlas delegation protocols (7-section format)`;
+- Follow atlas delegation protocols (7-section format)
+
+## TASK BREAKDOWN (MANDATORY)
+
+After reading the plan file, you MUST decompose every plan task into granular, implementation-level sub-steps and register ALL of them as task/todo items BEFORE starting any work.
+
+**How to break down**:
+- Each plan checkbox item (e.g., \`- [ ] Add user authentication\`) must be split into concrete, actionable sub-tasks
+- Sub-tasks should be specific enough that each one touches a clear set of files/functions
+- Include: file to modify, what to change, expected behavior, and how to verify
+- Do NOT leave any task vague \u2014 "implement feature X" is NOT acceptable; "add validateToken() to src/auth/middleware.ts that checks JWT expiry and returns 401" IS acceptable
+
+**Example breakdown**:
+Plan task: \`- [ ] Add rate limiting to API\`
+\u2192 Todo items:
+  1. Create \`src/middleware/rate-limiter.ts\` with sliding window algorithm (max 100 req/min per IP)
+  2. Add RateLimiter middleware to \`src/app.ts\` router chain, before auth middleware
+  3. Add rate limit headers (X-RateLimit-Limit, X-RateLimit-Remaining) to response in \`rate-limiter.ts\`
+  4. Add test: verify 429 response after exceeding limit in \`src/middleware/rate-limiter.test.ts\`
+  5. Add test: verify headers are present on normal responses
+
+Register these as task/todo items so progress is tracked and visible throughout the session.
+
+## WORKTREE COMPLETION
+
+When working in a worktree (\`worktree_path\` is set in boulder.json) and ALL plan tasks are complete:
+1. Commit all remaining changes in the worktree
+2. Switch to the main working directory (the original repo, NOT the worktree)
+3. Merge the worktree branch into the current branch: \`git merge <worktree-branch>\`
+4. If merge succeeds, clean up: \`git worktree remove <worktree-path>\`
+5. Remove the boulder.json state
+
+This is the DEFAULT behavior when \`--worktree\` was used. Skip merge only if the user explicitly instructs otherwise (e.g., asks to create a PR instead).`;
 
 // src/features/builtin-commands/templates/handoff.ts
 var HANDOFF_TEMPLATE = `# Handoff Command
@@ -49664,9 +49757,6 @@ function skillToCommandInfo(skill) {
     lazyContentLoader: skill.lazyContent
   };
 }
-function filterDiscoveredCommandsByScope(commands3, scope) {
-  return commands3.filter((command) => command.scope === scope);
-}
 async function discoverAllCommands(options) {
   const discoveredCommands = discoverCommandsSync(process.cwd(), {
     pluginsEnabled: options?.pluginsEnabled,
@@ -49674,14 +49764,17 @@ async function discoverAllCommands(options) {
   });
   const skills2 = options?.skills ?? await discoverAllSkills();
   const skillCommands = skills2.map(skillToCommandInfo);
+  const scopeOrder = ["project", "user", "opencode-project", "opencode", "builtin", "plugin"];
+  const grouped = new Map;
+  for (const cmd of discoveredCommands) {
+    const list = grouped.get(cmd.scope) ?? [];
+    list.push(cmd);
+    grouped.set(cmd.scope, list);
+  }
+  const orderedCommands = scopeOrder.flatMap((scope) => grouped.get(scope) ?? []);
   return [
     ...skillCommands,
-    ...filterDiscoveredCommandsByScope(discoveredCommands, "project"),
-    ...filterDiscoveredCommandsByScope(discoveredCommands, "user"),
-    ...filterDiscoveredCommandsByScope(discoveredCommands, "opencode-project"),
-    ...filterDiscoveredCommandsByScope(discoveredCommands, "opencode"),
-    ...filterDiscoveredCommandsByScope(discoveredCommands, "builtin"),
-    ...filterDiscoveredCommandsByScope(discoveredCommands, "plugin")
+    ...orderedCommands
   ];
 }
 async function findCommand2(commandName, options) {
@@ -53440,6 +53533,7 @@ function getErrorMessage2(error48) {
     return "";
   }
 }
+var DEFAULT_RETRY_PATTERN = new RegExp(`\\b(${DEFAULT_CONFIG2.retry_on_errors.join("|")})\\b`);
 function extractStatusCode(error48, retryOnErrors) {
   if (!error48)
     return;
@@ -53454,8 +53548,7 @@ function extractStatusCode(error48, retryOnErrors) {
   if (statusCode !== undefined) {
     return statusCode;
   }
-  const codes = retryOnErrors ?? DEFAULT_CONFIG2.retry_on_errors;
-  const pattern = new RegExp(`\\b(${codes.join("|")})\\b`);
+  const pattern = retryOnErrors ? new RegExp(`\\b(${retryOnErrors.join("|")})\\b`) : DEFAULT_RETRY_PATTERN;
   const message = getErrorMessage2(error48);
   const statusMatch = message.match(pattern);
   if (statusMatch) {
@@ -55146,6 +55239,46 @@ function createReadImageResizerHook(_ctx) {
     }
   };
 }
+// src/hooks/todo-description-override/description.ts
+var TODOWRITE_DESCRIPTION = `Use this tool to create and manage a structured task list for tracking progress on multi-step work.
+
+## Todo Format (MANDATORY)
+
+Each todo title MUST encode four elements: WHERE, WHY, HOW, and EXPECTED RESULT.
+
+Format: "[WHERE] [HOW] to [WHY] \u2014 expect [RESULT]"
+
+GOOD:
+- "src/utils/validation.ts: Add validateEmail() for input sanitization \u2014 returns boolean"
+- "UserService.create(): Call validateEmail() before DB insert \u2014 rejects invalid emails with 400"
+- "validation.test.ts: Add test for missing @ sign \u2014 expect validateEmail('foo') to return false"
+
+BAD:
+- "Implement email validation" (where? how? what result?)
+- "Add dark mode" (this is a feature, not a todo)
+- "Fix auth" (what file? what changes? what's expected?)
+
+## Granularity Rules
+
+Each todo MUST be a single atomic action completable in 1-3 tool calls. If it needs more, split it.
+
+**Size test**: Can you complete this todo by editing one file or running one command? If not, it's too big.
+
+## Task Management
+- One in_progress at a time. Complete it before starting the next.
+- Mark completed immediately after finishing each item.
+- Skip this tool for single trivial tasks (one-step, obvious action).`;
+
+// src/hooks/todo-description-override/hook.ts
+function createTodoDescriptionOverrideHook() {
+  return {
+    "tool.definition": async (input, output) => {
+      if (input.toolID === "todowrite") {
+        output.description = TODOWRITE_DESCRIPTION;
+      }
+    }
+  };
+}
 // src/hooks/anthropic-effort/hook.ts
 var OPUS_4_6_PATTERN = /claude-opus-4[-.]6/i;
 function isClaudeProvider(providerID, modelID) {
@@ -75723,10 +75856,11 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
           allTasks.push(task);
         }
       }
+      const taskMap = new Map(allTasks.map((t) => [t.id, t]));
       const activeTasks = allTasks.filter((task) => task.status !== "completed" && task.status !== "deleted");
       const summaries = activeTasks.map((task) => {
         const unresolvedBlockers = task.blockedBy.filter((blockerId) => {
-          const blockerTask = allTasks.find((t) => t.id === blockerId);
+          const blockerTask = taskMap.get(blockerId);
           return !blockerTask || blockerTask.status !== "completed";
         });
         return {
@@ -76415,6 +76549,15 @@ function applyPrepend(lines, text) {
 }
 
 // src/tools/hashline-edit/edit-operations.ts
+function arraysEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i2 = 0;i2 < a.length; i2++) {
+    if (a[i2] !== b[i2])
+      return false;
+  }
+  return true;
+}
 function applyHashlineEditsWithReport(content, edits) {
   if (edits.length === 0) {
     return {
@@ -76444,9 +76587,7 @@ function applyHashlineEditsWithReport(content, edits) {
     switch (edit.op) {
       case "replace": {
         const next = edit.end ? applyReplaceLines(lines, edit.pos, edit.end, edit.lines, { skipValidation: true }) : applySetLine(lines, edit.pos, edit.lines, { skipValidation: true });
-        if (next.join(`
-`) === lines.join(`
-`)) {
+        if (arraysEqual(next, lines)) {
           noopEdits += 1;
           break;
         }
@@ -76455,9 +76596,7 @@ function applyHashlineEditsWithReport(content, edits) {
       }
       case "append": {
         const next = edit.pos ? applyInsertAfter(lines, edit.pos, edit.lines, { skipValidation: true }) : applyAppend(lines, edit.lines);
-        if (next.join(`
-`) === lines.join(`
-`)) {
+        if (arraysEqual(next, lines)) {
           noopEdits += 1;
           break;
         }
@@ -76466,9 +76605,7 @@ function applyHashlineEditsWithReport(content, edits) {
       }
       case "prepend": {
         const next = edit.pos ? applyInsertBefore(lines, edit.pos, edit.lines, { skipValidation: true }) : applyPrepend(lines, edit.lines);
-        if (next.join(`
-`) === lines.join(`
-`)) {
+        if (arraysEqual(next, lines)) {
           noopEdits += 1;
           break;
         }
@@ -77493,6 +77630,7 @@ function createToolGuardHooks(args) {
   const hashlineReadEnhancer = isHookEnabled("hashline-read-enhancer") ? safeHook("hashline-read-enhancer", () => createHashlineReadEnhancerHook(ctx, { hashline_edit: { enabled: pluginConfig.hashline_edit ?? false } })) : null;
   const jsonErrorRecovery = isHookEnabled("json-error-recovery") ? safeHook("json-error-recovery", () => createJsonErrorRecoveryHook(ctx)) : null;
   const readImageResizer = isHookEnabled("read-image-resizer") ? safeHook("read-image-resizer", () => createReadImageResizerHook(ctx)) : null;
+  const todoDescriptionOverride = isHookEnabled("todo-description-override") ? safeHook("todo-description-override", () => createTodoDescriptionOverrideHook()) : null;
   return {
     commentChecker,
     toolOutputTruncator,
@@ -77504,7 +77642,8 @@ function createToolGuardHooks(args) {
     writeExistingFileGuard,
     hashlineReadEnhancer,
     jsonErrorRecovery,
-    readImageResizer
+    readImageResizer,
+    todoDescriptionOverride
   };
 }
 
@@ -78031,8 +78170,8 @@ var MIN_STABILITY_TIME_MS2 = 10 * 1000;
 var DEFAULT_STALE_TIMEOUT_MS = 1200000;
 var DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 1800000;
 var DEFAULT_MAX_TOOL_CALLS = 200;
-var DEFAULT_CIRCUIT_BREAKER_WINDOW_SIZE = 20;
-var DEFAULT_CIRCUIT_BREAKER_REPETITION_THRESHOLD_PERCENT = 80;
+var DEFAULT_CIRCUIT_BREAKER_CONSECUTIVE_THRESHOLD = 20;
+var DEFAULT_CIRCUIT_BREAKER_ENABLED = true;
 var MIN_RUNTIME_BEFORE_STALE_MS = 30000;
 var MIN_IDLE_TIME_MS = 5000;
 var POLLING_INTERVAL_MS = 3000;
@@ -78453,6 +78592,22 @@ function removeTaskToastTracking(taskId) {
   }
 }
 
+// src/features/background-agent/session-status-classifier.ts
+var ACTIVE_SESSION_STATUSES = new Set(["busy", "retry", "running"]);
+var KNOWN_TERMINAL_STATUSES = new Set(["idle", "interrupted"]);
+function isActiveSessionStatus(type2) {
+  if (ACTIVE_SESSION_STATUSES.has(type2)) {
+    return true;
+  }
+  if (!KNOWN_TERMINAL_STATUSES.has(type2)) {
+    log("[background-agent] Unknown session status type encountered:", type2);
+  }
+  return false;
+}
+function isTerminalSessionStatus(type2) {
+  return KNOWN_TERMINAL_STATUSES.has(type2) && type2 !== "idle";
+}
+
 // src/features/background-agent/task-poller.ts
 var TERMINAL_TASK_STATUSES = new Set([
   "completed",
@@ -78531,7 +78686,7 @@ async function checkAndInterruptStaleTasks(args) {
     if (!startedAt || !sessionID)
       continue;
     const sessionStatus = sessionStatuses?.[sessionID]?.type;
-    const sessionIsRunning = sessionStatus !== undefined && sessionStatus !== "idle";
+    const sessionIsRunning = sessionStatus !== undefined && isActiveSessionStatus(sessionStatus);
     const runtime = now - startedAt.getTime();
     if (!task.progress?.lastUpdate) {
       if (sessionIsRunning)
@@ -78587,51 +78742,57 @@ async function checkAndInterruptStaleTasks(args) {
 // src/features/background-agent/loop-detector.ts
 function resolveCircuitBreakerSettings(config4) {
   return {
+    enabled: config4?.circuitBreaker?.enabled ?? DEFAULT_CIRCUIT_BREAKER_ENABLED,
     maxToolCalls: config4?.circuitBreaker?.maxToolCalls ?? config4?.maxToolCalls ?? DEFAULT_MAX_TOOL_CALLS,
-    windowSize: config4?.circuitBreaker?.windowSize ?? DEFAULT_CIRCUIT_BREAKER_WINDOW_SIZE,
-    repetitionThresholdPercent: config4?.circuitBreaker?.repetitionThresholdPercent ?? DEFAULT_CIRCUIT_BREAKER_REPETITION_THRESHOLD_PERCENT
+    consecutiveThreshold: config4?.circuitBreaker?.consecutiveThreshold ?? DEFAULT_CIRCUIT_BREAKER_CONSECUTIVE_THRESHOLD
   };
 }
-function recordToolCall(window, toolName, settings) {
-  const previous = window?.toolNames ?? [];
-  const toolNames = [...previous, toolName].slice(-settings.windowSize);
+function recordToolCall(window, toolName, settings, toolInput) {
+  const signature = createToolCallSignature(toolName, toolInput);
+  if (window && window.lastSignature === signature) {
+    return {
+      lastSignature: signature,
+      consecutiveCount: window.consecutiveCount + 1,
+      threshold: settings.consecutiveThreshold
+    };
+  }
   return {
-    toolNames,
-    windowSize: settings.windowSize,
-    thresholdPercent: settings.repetitionThresholdPercent
+    lastSignature: signature,
+    consecutiveCount: 1,
+    threshold: settings.consecutiveThreshold
   };
 }
-function detectRepetitiveToolUse(window) {
-  if (!window || window.toolNames.length === 0) {
-    return { triggered: false };
-  }
-  const counts = new Map;
-  for (const toolName of window.toolNames) {
-    counts.set(toolName, (counts.get(toolName) ?? 0) + 1);
+function sortObject2(obj) {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (typeof obj !== "object")
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map(sortObject2);
+  const sorted = {};
+  const keys = Object.keys(obj).sort();
+  for (const key of keys) {
+    sorted[key] = sortObject2(obj[key]);
   }
-  let repeatedTool;
-  let repeatedCount = 0;
-  for (const [toolName, count] of counts.entries()) {
-    if (count > repeatedCount) {
-      repeatedTool = toolName;
-      repeatedCount = count;
-    }
+  return sorted;
+}
+function createToolCallSignature(toolName, toolInput) {
+  if (toolInput === undefined || toolInput === null) {
+    return toolName;
   }
-  const sampleSize = window.toolNames.length;
-  const minimumSampleSize = Math.min(window.windowSize, Math.ceil(window.windowSize * window.thresholdPercent / 100));
-  if (sampleSize < minimumSampleSize) {
-    return { triggered: false };
+  if (Object.keys(toolInput).length === 0) {
+    return toolName;
   }
-  const thresholdCount = Math.ceil(sampleSize * window.thresholdPercent / 100);
-  if (!repeatedTool || repeatedCount < thresholdCount) {
+  return `${toolName}::${JSON.stringify(sortObject2(toolInput))}`;
+}
+function detectRepetitiveToolUse(window) {
+  if (!window || window.consecutiveCount < window.threshold) {
     return { triggered: false };
   }
   return {
     triggered: true,
-    toolName: repeatedTool,
-    repeatedCount,
-    sampleSize,
-    thresholdPercent: window.thresholdPercent
+    toolName: window.lastSignature.split("::")[0],
+    repeatedCount: window.consecutiveCount
   };
 }
 
@@ -78730,6 +78891,7 @@ class BackgroundManager {
   preStartDescendantReservations;
   enableParentSessionNotifications;
   taskHistory = new TaskHistory;
+  cachedCircuitBreakerSettings;
   constructor(ctx, config4, options) {
     this.tasks = new Map;
     this.notifications = new Map;
@@ -79322,35 +79484,36 @@ class BackgroundManager {
       }
       task.progress.lastUpdate = new Date;
       if (partInfo?.type === "tool" || partInfo?.tool) {
-        const countedToolPartIDs = task.progress.countedToolPartIDs ?? [];
-        const shouldCountToolCall = !partInfo.id || partInfo.state?.status !== "running" || !countedToolPartIDs.includes(partInfo.id);
+        const countedToolPartIDs = task.progress.countedToolPartIDs ?? new Set;
+        const shouldCountToolCall = !partInfo.id || partInfo.state?.status !== "running" || !countedToolPartIDs.has(partInfo.id);
         if (!shouldCountToolCall) {
           return;
         }
         if (partInfo.id && partInfo.state?.status === "running") {
-          task.progress.countedToolPartIDs = [...countedToolPartIDs, partInfo.id];
+          countedToolPartIDs.add(partInfo.id);
+          task.progress.countedToolPartIDs = countedToolPartIDs;
         }
         task.progress.toolCalls += 1;
         task.progress.lastTool = partInfo.tool;
-        const circuitBreaker = resolveCircuitBreakerSettings(this.config);
+        const circuitBreaker = this.cachedCircuitBreakerSettings ?? (this.cachedCircuitBreakerSettings = resolveCircuitBreakerSettings(this.config));
         if (partInfo.tool) {
-          task.progress.toolCallWindow = recordToolCall(task.progress.toolCallWindow, partInfo.tool, circuitBreaker);
-          const loopDetection = detectRepetitiveToolUse(task.progress.toolCallWindow);
-          if (loopDetection.triggered) {
-            log("[background-agent] Circuit breaker: repetitive tool usage detected", {
-              taskId: task.id,
-              agent: task.agent,
-              sessionID,
-              toolName: loopDetection.toolName,
-              repeatedCount: loopDetection.repeatedCount,
-              sampleSize: loopDetection.sampleSize,
-              thresholdPercent: loopDetection.thresholdPercent
-            });
-            this.cancelTask(task.id, {
-              source: "circuit-breaker",
-              reason: `Subagent repeatedly called ${loopDetection.toolName} ${loopDetection.repeatedCount}/${loopDetection.sampleSize} times in the recent tool-call window (${loopDetection.thresholdPercent}% threshold). This usually indicates an infinite loop. The task was automatically cancelled to prevent excessive token usage.`
-            });
-            return;
+          task.progress.toolCallWindow = recordToolCall(task.progress.toolCallWindow, partInfo.tool, circuitBreaker, partInfo.state?.input);
+          if (circuitBreaker.enabled) {
+            const loopDetection = detectRepetitiveToolUse(task.progress.toolCallWindow);
+            if (loopDetection.triggered) {
+              log("[background-agent] Circuit breaker: consecutive tool usage detected", {
+                taskId: task.id,
+                agent: task.agent,
+                sessionID,
+                toolName: loopDetection.toolName,
+                repeatedCount: loopDetection.repeatedCount
+              });
+              this.cancelTask(task.id, {
+                source: "circuit-breaker",
+                reason: `Subagent called ${loopDetection.toolName} ${loopDetection.repeatedCount} consecutive times (threshold: ${circuitBreaker.consecutiveThreshold}). This usually indicates an infinite loop. The task was automatically cancelled to prevent excessive token usage.`
+              });
+              return;
+            }
           }
         }
         const maxToolCalls = circuitBreaker.maxToolCalls;
@@ -79997,7 +80160,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
               continue;
             }
           }
-          if (sessionStatus && sessionStatus.type !== "idle") {
+          if (sessionStatus && isActiveSessionStatus(sessionStatus.type)) {
             log("[background-agent] Session still running, relying on event-based progress:", {
               taskId: task.id,
               sessionID,
@@ -80006,6 +80169,17 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
             });
             continue;
           }
+          if (sessionStatus && isTerminalSessionStatus(sessionStatus.type)) {
+            await this.tryCompleteTask(task, `polling (terminal session status: ${sessionStatus.type})`);
+            continue;
+          }
+          if (sessionStatus && sessionStatus.type !== "idle") {
+            log("[background-agent] Unknown session status, treating as potentially idle:", {
+              taskId: task.id,
+              sessionID,
+              sessionStatus: sessionStatus.type
+            });
+          }
           const completionSource = sessionStatus?.type === "idle" ? "polling (idle status)" : "polling (session gone from status)";
           const hasValidOutput = await this.validateSessionHasOutput(sessionID);
           if (!hasValidOutput) {
@@ -97783,10 +97957,7 @@ function createPluginInterface(args) {
   const { ctx, pluginConfig, firstMessageVariantGate, managers, hooks: hooks2, tools } = args;
   return {
     tool: tools,
-    "chat.params": async (input, output) => {
-      const handler = createChatParamsHandler({ anthropicEffort: hooks2.anthropicEffort });
-      await handler(input, output);
-    },
+    "chat.params": createChatParamsHandler({ anthropicEffort: hooks2.anthropicEffort }),
     "chat.headers": createChatHeadersHandler({ ctx }),
     "chat.message": createChatMessageHandler3({
       ctx,
@@ -97813,7 +97984,10 @@ function createPluginInterface(args) {
     "tool.execute.after": createToolExecuteAfterHandler3({
       ctx,
       hooks: hooks2
-    })
+    }),
+    "tool.definition": async (input, output) => {
+      await hooks2.todoDescriptionOverride?.["tool.definition"]?.(input, output);
+    }
   };
 }