oh-my-opencode 3.12.1 → 3.12.2

package/dist/index.js

@@ -55,20 +55,43 @@ __export(exports_logger, {
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
+function flush() {
+  if (buffer.length === 0)
+    return;
+  const data = buffer.join("");
+  buffer = [];
+  try {
+    fs.appendFileSync(logFile, data);
+  } catch {}
+}
+function scheduleFlush() {
+  if (flushTimer)
+    return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flush();
+  }, FLUSH_INTERVAL_MS);
+}
 function log(message, data) {
   try {
     const timestamp2 = new Date().toISOString();
     const logEntry = `[${timestamp2}] ${message} ${data ? JSON.stringify(data) : ""}
 `;
-    fs.appendFileSync(logFile, logEntry);
+    buffer.push(logEntry);
+    if (buffer.length >= BUFFER_SIZE_LIMIT) {
+      flush();
+    } else {
+      scheduleFlush();
+    }
   } catch {}
 }
 function getLogFilePath() {
   return logFile;
 }
-var logFile;
+var logFile, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50;
 var init_logger = __esm(() => {
   logFile = path.join(os.tmpdir(), "oh-my-opencode.log");
+  buffer = [];
 });
 
 // src/shared/truncate-description.ts
@@ -2454,18 +2477,18 @@ var require_sharedArrayCancellation = __commonJS((exports) => {
       if (request.id === null) {
         return;
       }
-      const buffer = new SharedArrayBuffer(4);
-      const data = new Int32Array(buffer, 0, 1);
+      const buffer2 = new SharedArrayBuffer(4);
+      const data = new Int32Array(buffer2, 0, 1);
       data[0] = CancellationState.Continue;
-      this.buffers.set(request.id, buffer);
-      request.$cancellationData = buffer;
+      this.buffers.set(request.id, buffer2);
+      request.$cancellationData = buffer2;
     }
     async sendCancellation(_conn, id) {
-      const buffer = this.buffers.get(id);
-      if (buffer === undefined) {
+      const buffer2 = this.buffers.get(id);
+      if (buffer2 === undefined) {
         return;
       }
-      const data = new Int32Array(buffer, 0, 1);
+      const data = new Int32Array(buffer2, 0, 1);
       Atomics.store(data, 0, CancellationState.Cancelled);
     }
     cleanup(id) {
@@ -2478,8 +2501,8 @@ var require_sharedArrayCancellation = __commonJS((exports) => {
   exports.SharedArraySenderStrategy = SharedArraySenderStrategy;
 
   class SharedArrayBufferCancellationToken {
-    constructor(buffer) {
-      this.data = new Int32Array(buffer, 0, 1);
+    constructor(buffer2) {
+      this.data = new Int32Array(buffer2, 0, 1);
     }
     get isCancellationRequested() {
       return Atomics.load(this.data, 0) === CancellationState.Cancelled;
@@ -2490,8 +2513,8 @@ var require_sharedArrayCancellation = __commonJS((exports) => {
   }
 
   class SharedArrayBufferCancellationTokenSource {
-    constructor(buffer) {
-      this.token = new SharedArrayBufferCancellationToken(buffer);
+    constructor(buffer2) {
+      this.token = new SharedArrayBufferCancellationToken(buffer2);
     }
     cancel() {}
     dispose() {}
@@ -2502,11 +2525,11 @@ var require_sharedArrayCancellation = __commonJS((exports) => {
       this.kind = "request";
     }
     createCancellationTokenSource(request) {
-      const buffer = request.$cancellationData;
-      if (buffer === undefined) {
+      const buffer2 = request.$cancellationData;
+      if (buffer2 === undefined) {
         return new cancellation_1.CancellationTokenSource;
       }
-      return new SharedArrayBufferCancellationTokenSource(buffer);
+      return new SharedArrayBufferCancellationTokenSource(buffer2);
     }
   }
   exports.SharedArrayReceiverStrategy = SharedArrayReceiverStrategy;
@@ -2840,18 +2863,18 @@ var require_messageWriter = __commonJS((exports) => {
     }
     async write(msg) {
       return this.writeSemaphore.lock(async () => {
-        const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer) => {
+        const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer2) => {
           if (this.options.contentEncoder !== undefined) {
-            return this.options.contentEncoder.encode(buffer);
+            return this.options.contentEncoder.encode(buffer2);
           } else {
-            return buffer;
+            return buffer2;
           }
         });
-        return payload.then((buffer) => {
+        return payload.then((buffer2) => {
           const headers = [];
-          headers.push(ContentLength, buffer.byteLength.toString(), CRLF);
+          headers.push(ContentLength, buffer2.byteLength.toString(), CRLF);
           headers.push(CRLF);
-          return this.doWrite(msg, headers, buffer);
+          return this.doWrite(msg, headers, buffer2);
         }, (error48) => {
           this.fireError(error48);
           throw error48;
@@ -2953,9 +2976,9 @@ var require_messageBuffer = __commonJS((exports) => {
       if (state3 !== 4) {
         return;
       }
-      const buffer = this._read(chunkBytesRead + offset);
+      const buffer2 = this._read(chunkBytesRead + offset);
       const result = new Map;
-      const headers = this.toString(buffer, "ascii").split(CRLF);
+      const headers = this.toString(buffer2, "ascii").split(CRLF);
       if (headers.length < 2) {
         return result;
       }
@@ -4379,11 +4402,11 @@ var require_ril = __commonJS((exports) => {
         return new util_1.TextDecoder(encoding).decode(value);
       }
     }
-    asNative(buffer, length) {
+    asNative(buffer2, length) {
       if (length === undefined) {
-        return buffer instanceof Buffer ? buffer : Buffer.from(buffer);
+        return buffer2 instanceof Buffer ? buffer2 : Buffer.from(buffer2);
       } else {
-        return buffer instanceof Buffer ? buffer.slice(0, length) : Buffer.from(buffer, 0, length);
+        return buffer2 instanceof Buffer ? buffer2.slice(0, length) : Buffer.from(buffer2, 0, length);
       }
     }
     allocNative(length) {
@@ -4467,12 +4490,12 @@ var require_ril = __commonJS((exports) => {
       }),
       decoder: Object.freeze({
         name: "application/json",
-        decode: (buffer, options) => {
+        decode: (buffer2, options) => {
           try {
-            if (buffer instanceof Buffer) {
-              return Promise.resolve(JSON.parse(buffer.toString(options.charset)));
+            if (buffer2 instanceof Buffer) {
+              return Promise.resolve(JSON.parse(buffer2.toString(options.charset)));
             } else {
-              return Promise.resolve(JSON.parse(new util_1.TextDecoder(options.charset).decode(buffer)));
+              return Promise.resolve(JSON.parse(new util_1.TextDecoder(options.charset).decode(buffer2)));
             }
           } catch (err) {
             return Promise.reject(err);
@@ -8405,20 +8428,20 @@ var require_utils2 = __commonJS((exports, module) => {
     return acc;
   }
   var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-  function consumeIsZone(buffer) {
-    buffer.length = 0;
+  function consumeIsZone(buffer2) {
+    buffer2.length = 0;
     return true;
   }
-  function consumeHextets(buffer, address, output) {
-    if (buffer.length) {
-      const hex5 = stringArrayToHexStripped(buffer);
+  function consumeHextets(buffer2, address, output) {
+    if (buffer2.length) {
+      const hex5 = stringArrayToHexStripped(buffer2);
       if (hex5 !== "") {
         address.push(hex5);
       } else {
         output.error = true;
         return false;
       }
-      buffer.length = 0;
+      buffer2.length = 0;
     }
     return true;
   }
@@ -8426,7 +8449,7 @@ var require_utils2 = __commonJS((exports, module) => {
     let tokenCount = 0;
     const output = { error: false, address: "", zone: "" };
     const address = [];
-    const buffer = [];
+    const buffer2 = [];
     let endipv6Encountered = false;
     let endIpv6 = false;
     let consume = consumeHextets;
@@ -8439,7 +8462,7 @@ var require_utils2 = __commonJS((exports, module) => {
         if (endipv6Encountered === true) {
           endIpv6 = true;
         }
-        if (!consume(buffer, address, output)) {
+        if (!consume(buffer2, address, output)) {
           break;
         }
         if (++tokenCount > 7) {
@@ -8452,22 +8475,22 @@ var require_utils2 = __commonJS((exports, module) => {
         address.push(":");
         continue;
       } else if (cursor === "%") {
-        if (!consume(buffer, address, output)) {
+        if (!consume(buffer2, address, output)) {
           break;
         }
         consume = consumeIsZone;
       } else {
-        buffer.push(cursor);
+        buffer2.push(cursor);
         continue;
       }
     }
-    if (buffer.length) {
+    if (buffer2.length) {
       if (consume === consumeIsZone) {
-        output.zone = buffer.join("");
+        output.zone = buffer2.join("");
       } else if (endIpv6) {
-        address.push(buffer.join(""));
+        address.push(buffer2.join(""));
       } else {
-        address.push(stringArrayToHexStripped(buffer));
+        address.push(stringArrayToHexStripped(buffer2));
       }
     }
     output.address = address.join("");
@@ -12160,14 +12183,14 @@ var require_readShebang = __commonJS((exports, module) => {
   var shebangCommand = require_shebang_command();
   function readShebang(command) {
     const size = 150;
-    const buffer = Buffer.alloc(size);
+    const buffer2 = Buffer.alloc(size);
     let fd;
     try {
       fd = fs19.openSync(command, "r");
-      fs19.readSync(fd, buffer, 0, size, 0);
+      fs19.readSync(fd, buffer2, 0, size, 0);
       fs19.closeSync(fd);
     } catch (e) {}
-    return shebangCommand(buffer.toString());
+    return shebangCommand(buffer2.toString());
   }
   module.exports = readShebang;
 });
@@ -15246,7 +15269,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);
@@ -15345,6 +15368,7 @@ function transformToolName(toolName) {
 function escapeRegexExceptAsterisk(str2) {
   return str2.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
 }
+var regexCache = new Map;
 function matchesToolMatcher(toolName, matcher) {
   if (!matcher) {
     return true;
@@ -15352,8 +15376,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();
@@ -17588,6 +17616,8 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
   function getCacheFilePath(filename) {
     return join9(getCacheDir2(), filename);
   }
+  let memConnected;
+  let memProviderModels;
   function ensureCacheDir2() {
     const cacheDir = getCacheDir2();
     if (!existsSync8(cacheDir)) {
@@ -17595,18 +17625,23 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
     }
   }
   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;
     }
   }
@@ -17623,15 +17658,19 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
     };
     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() {
+    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 {
@@ -17641,9 +17680,11 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
         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;
     }
   }
@@ -17660,6 +17701,7 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
     };
     try {
       writeFileSync2(cacheFile, JSON.stringify(cacheData, null, 2));
+      memProviderModels = cacheData;
       log("[connected-providers-cache] Provider-models cache written", {
         providerCount: Object.keys(data.models).length
       });
@@ -20394,15 +20436,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;
     }
@@ -20411,6 +20456,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 {
@@ -20421,10 +20467,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) {
@@ -20436,21 +20484,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) {
@@ -20458,20 +20512,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;
@@ -20492,10 +20540,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) {
@@ -20503,16 +20553,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,
@@ -20603,6 +20657,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)
@@ -36324,6 +36381,15 @@ function takePendingCall(callID) {
 import * as fs6 from "fs";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join30 } 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 = join30(tmpdir4(), "comment-checker-debug.log");
 function debugLog3(...args) {
@@ -36384,15 +36450,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) {
@@ -36863,7 +36920,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 {
@@ -38281,7 +38338,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",
@@ -38367,8 +38423,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) {
@@ -38376,7 +38431,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("");
@@ -39033,16 +39088,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;
@@ -39908,8 +39963,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",
@@ -39921,6 +39974,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)
@@ -40101,8 +40156,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(),
@@ -40113,6 +40166,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,
@@ -47544,8 +47599,7 @@ var BabysittingConfigSchema = exports_external.object({
 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(),
@@ -49640,9 +49694,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,
@@ -49650,14 +49701,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) {
@@ -53418,6 +53472,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;
@@ -53432,8 +53487,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) {
@@ -54714,97 +54768,97 @@ function toImageDimensions(width, height) {
   }
   return { width, height };
 }
-function parsePngDimensions(buffer) {
-  if (buffer.length < 24) {
+function parsePngDimensions(buffer2) {
+  if (buffer2.length < 24) {
     return null;
   }
-  const isPngSignature = buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71 && buffer[4] === 13 && buffer[5] === 10 && buffer[6] === 26 && buffer[7] === 10;
-  if (!isPngSignature || buffer.toString("ascii", 12, 16) !== "IHDR") {
+  const isPngSignature = buffer2[0] === 137 && buffer2[1] === 80 && buffer2[2] === 78 && buffer2[3] === 71 && buffer2[4] === 13 && buffer2[5] === 10 && buffer2[6] === 26 && buffer2[7] === 10;
+  if (!isPngSignature || buffer2.toString("ascii", 12, 16) !== "IHDR") {
     return null;
   }
-  const width = buffer.readUInt32BE(16);
-  const height = buffer.readUInt32BE(20);
+  const width = buffer2.readUInt32BE(16);
+  const height = buffer2.readUInt32BE(20);
   return toImageDimensions(width, height);
 }
-function parseGifDimensions(buffer) {
-  if (buffer.length < 10) {
+function parseGifDimensions(buffer2) {
+  if (buffer2.length < 10) {
     return null;
   }
-  if (buffer.toString("ascii", 0, 4) !== "GIF8") {
+  if (buffer2.toString("ascii", 0, 4) !== "GIF8") {
     return null;
   }
-  const width = buffer.readUInt16LE(6);
-  const height = buffer.readUInt16LE(8);
+  const width = buffer2.readUInt16LE(6);
+  const height = buffer2.readUInt16LE(8);
   return toImageDimensions(width, height);
 }
-function parseJpegDimensions(buffer) {
-  if (buffer.length < 4 || buffer[0] !== 255 || buffer[1] !== 216) {
+function parseJpegDimensions(buffer2) {
+  if (buffer2.length < 4 || buffer2[0] !== 255 || buffer2[1] !== 216) {
     return null;
   }
   let offset = 2;
-  while (offset < buffer.length) {
-    if (buffer[offset] !== 255) {
+  while (offset < buffer2.length) {
+    if (buffer2[offset] !== 255) {
       offset += 1;
       continue;
     }
-    while (offset < buffer.length && buffer[offset] === 255) {
+    while (offset < buffer2.length && buffer2[offset] === 255) {
       offset += 1;
     }
-    if (offset >= buffer.length) {
+    if (offset >= buffer2.length) {
       return null;
     }
-    const marker = buffer[offset];
+    const marker = buffer2[offset];
     offset += 1;
     if (marker === 217 || marker === 218) {
       break;
     }
-    if (offset + 1 >= buffer.length) {
+    if (offset + 1 >= buffer2.length) {
       return null;
     }
-    const segmentLength = buffer.readUInt16BE(offset);
+    const segmentLength = buffer2.readUInt16BE(offset);
     if (segmentLength < 2) {
       return null;
     }
-    if ((marker === 192 || marker === 194) && offset + 7 < buffer.length) {
-      const height = buffer.readUInt16BE(offset + 3);
-      const width = buffer.readUInt16BE(offset + 5);
+    if ((marker === 192 || marker === 194) && offset + 7 < buffer2.length) {
+      const height = buffer2.readUInt16BE(offset + 3);
+      const width = buffer2.readUInt16BE(offset + 5);
       return toImageDimensions(width, height);
     }
     offset += segmentLength;
   }
   return null;
 }
-function readUInt24LE(buffer, offset) {
-  return buffer[offset] | buffer[offset + 1] << 8 | buffer[offset + 2] << 16;
+function readUInt24LE(buffer2, offset) {
+  return buffer2[offset] | buffer2[offset + 1] << 8 | buffer2[offset + 2] << 16;
 }
-function parseWebpDimensions(buffer) {
-  if (buffer.length < 16) {
+function parseWebpDimensions(buffer2) {
+  if (buffer2.length < 16) {
     return null;
   }
-  if (buffer.toString("ascii", 0, 4) !== "RIFF" || buffer.toString("ascii", 8, 12) !== "WEBP") {
+  if (buffer2.toString("ascii", 0, 4) !== "RIFF" || buffer2.toString("ascii", 8, 12) !== "WEBP") {
     return null;
   }
-  const chunkType = buffer.toString("ascii", 12, 16);
+  const chunkType = buffer2.toString("ascii", 12, 16);
   if (chunkType === "VP8 ") {
-    if (buffer[23] !== 157 || buffer[24] !== 1 || buffer[25] !== 42) {
+    if (buffer2[23] !== 157 || buffer2[24] !== 1 || buffer2[25] !== 42) {
       return null;
     }
-    const width = buffer.readUInt16LE(26) & 16383;
-    const height = buffer.readUInt16LE(28) & 16383;
+    const width = buffer2.readUInt16LE(26) & 16383;
+    const height = buffer2.readUInt16LE(28) & 16383;
     return toImageDimensions(width, height);
   }
   if (chunkType === "VP8L") {
-    if (buffer.length < 25 || buffer[20] !== 47) {
+    if (buffer2.length < 25 || buffer2[20] !== 47) {
       return null;
     }
-    const bits = buffer.readUInt32LE(21);
+    const bits = buffer2.readUInt32LE(21);
     const width = (bits & 16383) + 1;
     const height = (bits >>> 14 & 16383) + 1;
     return toImageDimensions(width, height);
   }
   if (chunkType === "VP8X") {
-    const width = readUInt24LE(buffer, 24) + 1;
-    const height = readUInt24LE(buffer, 27) + 1;
+    const width = readUInt24LE(buffer2, 24) + 1;
+    const height = readUInt24LE(buffer2, 27) + 1;
     return toImageDimensions(width, height);
   }
   return null;
@@ -54819,22 +54873,22 @@ function parseImageDimensions(base64DataUrl, mimeType) {
       return null;
     }
     const headerBase64 = rawBase64.length > HEADER_BASE64_CHARS ? rawBase64.slice(0, HEADER_BASE64_CHARS) : rawBase64;
-    const buffer = Buffer.from(headerBase64, "base64");
-    if (buffer.length === 0) {
+    const buffer2 = Buffer.from(headerBase64, "base64");
+    if (buffer2.length === 0) {
       return null;
     }
     const normalizedMime = mimeType.toLowerCase();
     if (normalizedMime === "image/png") {
-      return parsePngDimensions(buffer);
+      return parsePngDimensions(buffer2);
     }
     if (normalizedMime === "image/gif") {
-      return parseGifDimensions(buffer);
+      return parseGifDimensions(buffer2);
     }
     if (normalizedMime === "image/jpeg" || normalizedMime === "image/jpg") {
-      return parseJpegDimensions(buffer);
+      return parseJpegDimensions(buffer2);
     }
     if (normalizedMime === "image/webp") {
-      return parseWebpDimensions(buffer);
+      return parseWebpDimensions(buffer2);
     }
     return null;
   } catch {
@@ -73268,8 +73322,8 @@ function convertBase64ImageToJpeg(base64Data, mimeType) {
   const tempFiles = [inputPath];
   try {
     const cleanBase64 = base64Data.replace(/^data:[^;]+;base64,/, "");
-    const buffer = Buffer.from(cleanBase64, "base64");
-    writeFileSync19(inputPath, buffer);
+    const buffer2 = Buffer.from(cleanBase64, "base64");
+    writeFileSync19(inputPath, buffer2);
     log(`[image-converter] Converting Base64 ${mimeType} to JPEG`);
     const outputPath = convertImageToJpeg(inputPath, mimeType);
     tempFiles.push(outputPath);
@@ -75738,10 +75792,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 {
@@ -76430,6 +76485,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 {
@@ -76459,9 +76523,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;
         }
@@ -76470,9 +76532,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;
         }
@@ -76481,9 +76541,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;
         }
@@ -78048,8 +78106,7 @@ 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;
@@ -78471,6 +78528,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",
@@ -78549,7 +78622,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)
@@ -78607,18 +78680,22 @@ 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, toolInput) {
-  const previous = window?.toolSignatures ?? [];
   const signature = createToolCallSignature(toolName, toolInput);
-  const toolSignatures = [...previous, signature].slice(-settings.windowSize);
+  if (window && window.lastSignature === signature) {
+    return {
+      lastSignature: signature,
+      consecutiveCount: window.consecutiveCount + 1,
+      threshold: settings.consecutiveThreshold
+    };
+  }
   return {
-    toolSignatures,
-    windowSize: settings.windowSize,
-    thresholdPercent: settings.repetitionThresholdPercent
+    lastSignature: signature,
+    consecutiveCount: 1,
+    threshold: settings.consecutiveThreshold
   };
 }
 function sortObject2(obj) {
@@ -78645,36 +78722,13 @@ function createToolCallSignature(toolName, toolInput) {
   return `${toolName}::${JSON.stringify(sortObject2(toolInput))}`;
 }
 function detectRepetitiveToolUse(window) {
-  if (!window || window.toolSignatures.length === 0) {
-    return { triggered: false };
-  }
-  const counts = new Map;
-  for (const signature of window.toolSignatures) {
-    counts.set(signature, (counts.get(signature) ?? 0) + 1);
-  }
-  let repeatedTool;
-  let repeatedCount = 0;
-  for (const [toolName, count] of counts.entries()) {
-    if (count > repeatedCount) {
-      repeatedTool = toolName;
-      repeatedCount = count;
-    }
-  }
-  const sampleSize = window.toolSignatures.length;
-  const minimumSampleSize = Math.min(window.windowSize, Math.ceil(window.windowSize * window.thresholdPercent / 100));
-  if (sampleSize < minimumSampleSize) {
-    return { triggered: false };
-  }
-  const thresholdCount = Math.ceil(sampleSize * window.thresholdPercent / 100);
-  if (!repeatedTool || repeatedCount < thresholdCount) {
+  if (!window || window.consecutiveCount < window.threshold) {
     return { triggered: false };
   }
   return {
     triggered: true,
-    toolName: repeatedTool.split("::")[0],
-    repeatedCount,
-    sampleSize,
-    thresholdPercent: window.thresholdPercent
+    toolName: window.lastSignature.split("::")[0],
+    repeatedCount: window.consecutiveCount
   };
 }
 
@@ -78773,6 +78827,7 @@ class BackgroundManager {
   preStartDescendantReservations;
   enableParentSessionNotifications;
   taskHistory = new TaskHistory;
+  cachedCircuitBreakerSettings;
   constructor(ctx, config4, options) {
     this.tasks = new Map;
     this.notifications = new Map;
@@ -79365,34 +79420,33 @@ 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, partInfo.state?.input);
           if (circuitBreaker.enabled) {
             const loopDetection = detectRepetitiveToolUse(task.progress.toolCallWindow);
             if (loopDetection.triggered) {
-              log("[background-agent] Circuit breaker: repetitive tool usage detected", {
+              log("[background-agent] Circuit breaker: consecutive tool usage detected", {
                 taskId: task.id,
                 agent: task.agent,
                 sessionID,
                 toolName: loopDetection.toolName,
-                repeatedCount: loopDetection.repeatedCount,
-                sampleSize: loopDetection.sampleSize,
-                thresholdPercent: loopDetection.thresholdPercent
+                repeatedCount: loopDetection.repeatedCount
               });
               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.`
+                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;
             }
@@ -80042,7 +80096,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,
@@ -80051,6 +80105,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) {
@@ -82707,8 +82772,8 @@ async function generateVerifier(length) {
   return await random(length);
 }
 async function generateChallenge(code_verifier) {
-  const buffer = await (await crypto3).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
-  return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
+  const buffer2 = await (await crypto3).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
+  return btoa(String.fromCharCode(...new Uint8Array(buffer2))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
 }
 async function pkceChallenge(length) {
   if (!length)
@@ -97809,10 +97874,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,