oh-my-opencode 3.12.0 → 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();
@@ -17584,120 +17612,156 @@ import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync
 import { join as join9 } from "path";
 var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json";
 var PROVIDER_MODELS_CACHE_FILE = "provider-models.json";
-function getCacheFilePath(filename) {
-  return join9(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;
-  }
-  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 createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDir) {
+  function getCacheFilePath(filename) {
+    return join9(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;
+    }
   }
-}
-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 hasConnectedProvidersCache() {
+    const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
+    return existsSync8(cacheFile);
   }
-}
-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 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) });
+    }
   }
-  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 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;
+    }
   }
-}
-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) });
+  function hasProviderModelsCache() {
+    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+    return existsSync8(cacheFile);
   }
-}
-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();
@@ -20372,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;
     }
@@ -20389,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 {
@@ -20399,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) {
@@ -20414,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) {
@@ -20436,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;
@@ -20470,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) {
@@ -20481,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,
@@ -20581,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)
@@ -36302,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) {
@@ -36362,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) {
@@ -36841,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 {
@@ -38259,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",
@@ -38345,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) {
@@ -38354,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("");
@@ -39011,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;
@@ -39886,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",
@@ -39899,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)
@@ -40079,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(),
@@ -40091,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,
@@ -43673,6 +43750,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`, {
@@ -43909,6 +43989,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`, {
@@ -47514,9 +47597,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(),
@@ -47712,7 +47795,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({
@@ -49115,7 +49199,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
 
@@ -49132,7 +49216,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>"\`
@@ -49194,9 +49278,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
@@ -49578,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,
@@ -49588,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) {
@@ -53356,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;
@@ -53370,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) {
@@ -54652,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;
@@ -54757,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 {
@@ -55062,6 +55178,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) {
@@ -73166,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);
@@ -75636,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 {
@@ -76328,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 {
@@ -76357,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;
         }
@@ -76368,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;
         }
@@ -76379,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;
         }
@@ -77406,6 +77566,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,
@@ -77417,7 +77578,8 @@ function createToolGuardHooks(args) {
     writeExistingFileGuard,
     hashlineReadEnhancer,
     jsonErrorRecovery,
-    readImageResizer
+    readImageResizer,
+    todoDescriptionOverride
   };
 }
 
@@ -77944,8 +78106,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;
@@ -78366,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",
@@ -78444,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)
@@ -78500,51 +78678,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
   };
 }
 
@@ -78643,6 +78827,7 @@ class BackgroundManager {
   preStartDescendantReservations;
   enableParentSessionNotifications;
   taskHistory = new TaskHistory;
+  cachedCircuitBreakerSettings;
   constructor(ctx, config4, options) {
     this.tasks = new Map;
     this.notifications = new Map;
@@ -79235,35 +79420,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;
@@ -79910,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,
@@ -79919,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) {
@@ -82575,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)
@@ -97677,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,
@@ -97707,7 +97901,10 @@ function createPluginInterface(args) {
     "tool.execute.after": createToolExecuteAfterHandler3({
       ctx,
       hooks: hooks2
-    })
+    }),
+    "tool.definition": async (input, output) => {
+      await hooks2.todoDescriptionOverride?.["tool.definition"]?.(input, output);
+    }
   };
 }