diag(todo-continuation): add comprehensive debug logging for session idle handling

Add [TODO-DIAG] console.error statements throughout the todo continuation
enforcer to help diagnose why continuation prompts aren't being injected.

Changes:
- Add session.idle event handler diagnostic in handler.ts
- Add detailed blocking reason logging in idle-event.ts for all gate checks
- Update JSON schema to reflect circuit breaker config changes

🤖 Generated with assistance of [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)

assets/oh-my-opencode.schema.json

@@ -3716,15 +3716,10 @@
               "minimum": 10,
               "maximum": 9007199254740991
             },
-            "windowSize": {
+            "consecutiveThreshold": {
               "type": "integer",
               "minimum": 5,
               "maximum": 9007199254740991
-            },
-            "repetitionThresholdPercent": {
-              "type": "number",
-              "exclusiveMinimum": 0,
-              "maximum": 100
             }
           },
           "additionalProperties": false

src/cli/run/output-renderer.ts

@@ -45,26 +45,26 @@ export function writePaddedText(
     return { output: text, atLineStart: text.endsWith("\n") }
   }
 
-  let output = ""
+  const parts: string[] = []
   let lineStart = atLineStart
 
   for (let i = 0; i < text.length; i++) {
     const ch = text[i]
     if (lineStart) {
-      output += "  "
+      parts.push("  ")
       lineStart = false
     }
 
     if (ch === "\n") {
-      output += "  \n"
+      parts.push("  \n")
       lineStart = true
       continue
     }
 
-    output += ch
+    parts.push(ch)
   }
 
-  return { output, atLineStart: lineStart }
+  return { output: parts.join(""), atLineStart: lineStart }
 }
 
 function colorizeWithProfileColor(text: string, hexColor?: string): string {

src/config/schema/background-task-circuit-breaker.test.ts

@@ -8,27 +8,24 @@ describe("BackgroundTaskConfigSchema.circuitBreaker", () => {
       const result = BackgroundTaskConfigSchema.parse({
         circuitBreaker: {
           maxToolCalls: 150,
-          windowSize: 10,
-          repetitionThresholdPercent: 70,
+          consecutiveThreshold: 10,
         },
       })
-
       expect(result.circuitBreaker).toEqual({
         maxToolCalls: 150,
-        windowSize: 10,
-        repetitionThresholdPercent: 70,
+        consecutiveThreshold: 10,
       })
     })
   })
 
-  describe("#given windowSize below minimum", () => {
+  describe("#given consecutiveThreshold below minimum", () => {
     test("#when parsed #then throws ZodError", () => {
       let thrownError: unknown
 
       try {
         BackgroundTaskConfigSchema.parse({
           circuitBreaker: {
-            windowSize: 4,
+            consecutiveThreshold: 4,
           },
         })
       } catch (error) {
@@ -39,14 +36,14 @@ describe("BackgroundTaskConfigSchema.circuitBreaker", () => {
     })
   })
 
-  describe("#given repetitionThresholdPercent is zero", () => {
+  describe("#given consecutiveThreshold is zero", () => {
     test("#when parsed #then throws ZodError", () => {
       let thrownError: unknown
 
       try {
         BackgroundTaskConfigSchema.parse({
           circuitBreaker: {
-            repetitionThresholdPercent: 0,
+            consecutiveThreshold: 0,
           },
         })
       } catch (error) {

src/config/schema/background-task.ts

@@ -3,8 +3,7 @@ import { z } from "zod"
 const CircuitBreakerConfigSchema = z.object({
   enabled: z.boolean().optional(),
   maxToolCalls: z.number().int().min(10).optional(),
-  windowSize: z.number().int().min(5).optional(),
-  repetitionThresholdPercent: z.number().gt(0).max(100).optional(),
+  consecutiveThreshold: z.number().int().min(5).optional(),
 })
 
 export const BackgroundTaskConfigSchema = z.object({

src/features/background-agent/constants.ts

@@ -7,8 +7,7 @@ export const MIN_STABILITY_TIME_MS = 10 * 1000
 export const DEFAULT_STALE_TIMEOUT_MS = 1_200_000
 export const DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 1_800_000
 export const DEFAULT_MAX_TOOL_CALLS = 200
-export const DEFAULT_CIRCUIT_BREAKER_WINDOW_SIZE = 20
-export const DEFAULT_CIRCUIT_BREAKER_REPETITION_THRESHOLD_PERCENT = 80
+export const DEFAULT_CIRCUIT_BREAKER_CONSECUTIVE_THRESHOLD = 20
 export const DEFAULT_CIRCUIT_BREAKER_ENABLED = true
 export const MIN_RUNTIME_BEFORE_STALE_MS = 30_000
 export const MIN_IDLE_TIME_MS = 5000

src/features/background-agent/loop-detector.test.ts

@@ -37,16 +37,14 @@ describe("loop-detector", () => {
           maxToolCalls: 200,
           circuitBreaker: {
             maxToolCalls: 120,
-            windowSize: 10,
-            repetitionThresholdPercent: 70,
+            consecutiveThreshold: 7,
           },
         })
 
         expect(result).toEqual({
           enabled: true,
           maxToolCalls: 120,
-          windowSize: 10,
-          repetitionThresholdPercent: 70,
+          consecutiveThreshold: 7,
         })
       })
     })
@@ -56,8 +54,7 @@ describe("loop-detector", () => {
         const result = resolveCircuitBreakerSettings({
           circuitBreaker: {
             maxToolCalls: 100,
-            windowSize: 5,
-            repetitionThresholdPercent: 60,
+            consecutiveThreshold: 5,
           },
         })
 
@@ -71,8 +68,7 @@ describe("loop-detector", () => {
           circuitBreaker: {
             enabled: false,
             maxToolCalls: 100,
-            windowSize: 5,
-            repetitionThresholdPercent: 60,
+            consecutiveThreshold: 5,
           },
         })
 
@@ -86,8 +82,7 @@ describe("loop-detector", () => {
           circuitBreaker: {
             enabled: true,
             maxToolCalls: 100,
-            windowSize: 5,
-            repetitionThresholdPercent: 60,
+            consecutiveThreshold: 5,
           },
         })
 
@@ -151,55 +146,52 @@ describe("loop-detector", () => {
       })
     })
 
-    describe("#given the same tool dominates the recent window", () => {
+    describe("#given the same tool is called consecutively", () => {
       test("#when evaluated #then it triggers", () => {
-        const window = buildWindow([
-          "read",
-          "read",
-          "read",
-          "edit",
-          "read",
-          "read",
-          "read",
-          "read",
-          "grep",
-          "read",
-        ], {
-          circuitBreaker: {
-            windowSize: 10,
-            repetitionThresholdPercent: 80,
-          },
-        })
+        const window = buildWindow(Array.from({ length: 20 }, () => "read"))
 
         const result = detectRepetitiveToolUse(window)
 
         expect(result).toEqual({
           triggered: true,
           toolName: "read",
-          repeatedCount: 8,
-          sampleSize: 10,
-          thresholdPercent: 80,
+          repeatedCount: 20,
         })
       })
     })
 
-    describe("#given the window is not full yet", () => {
-      test("#when the current sample crosses the threshold #then it still triggers", () => {
-        const window = buildWindow(["read", "read", "edit", "read", "read", "read", "read", "read"], {
-          circuitBreaker: {
-            windowSize: 10,
-            repetitionThresholdPercent: 80,
-          },
-        })
+    describe("#given consecutive calls are interrupted by different tool", () => {
+      test("#when evaluated #then it does not trigger", () => {
+        const window = buildWindow([
+          ...Array.from({ length: 19 }, () => "read"),
+          "edit",
+          "read",
+        ])
 
         const result = detectRepetitiveToolUse(window)
 
+        expect(result).toEqual({ triggered: false })
+      })
+    })
+
+    describe("#given threshold boundary", () => {
+      test("#when below threshold #then it does not trigger", () => {
+        const belowThresholdWindow = buildWindow(Array.from({ length: 19 }, () => "read"))
+
+        const result = detectRepetitiveToolUse(belowThresholdWindow)
+
+        expect(result).toEqual({ triggered: false })
+      })
+
+      test("#when equal to threshold #then it triggers", () => {
+        const atThresholdWindow = buildWindow(Array.from({ length: 20 }, () => "read"))
+
+        const result = detectRepetitiveToolUse(atThresholdWindow)
+
         expect(result).toEqual({
           triggered: true,
           toolName: "read",
-          repeatedCount: 7,
-          sampleSize: 8,
-          thresholdPercent: 80,
+          repeatedCount: 20,
         })
       })
     })
@@ -210,9 +202,7 @@ describe("loop-detector", () => {
           tool: "read",
           input: { filePath: `/src/file-${i}.ts` },
         }))
-        const window = buildWindowWithInputs(calls, {
-          circuitBreaker: { windowSize: 20, repetitionThresholdPercent: 80 },
-        })
+        const window = buildWindowWithInputs(calls)
         const result = detectRepetitiveToolUse(window)
         expect(result.triggered).toBe(false)
       })
@@ -220,38 +210,30 @@ describe("loop-detector", () => {
 
     describe("#given same tool with identical file inputs", () => {
       test("#when evaluated #then it triggers with bare tool name", () => {
-        const calls = [
-          ...Array.from({ length: 16 }, () => ({ tool: "read", input: { filePath: "/src/same.ts" } })),
-          { tool: "grep", input: { pattern: "foo" } },
-          { tool: "edit", input: { filePath: "/src/other.ts" } },
-          { tool: "bash", input: { command: "ls" } },
-          { tool: "glob", input: { pattern: "**/*.ts" } },
-        ]
-        const window = buildWindowWithInputs(calls, {
-          circuitBreaker: { windowSize: 20, repetitionThresholdPercent: 80 },
-        })
+        const calls = Array.from({ length: 20 }, () => ({
+          tool: "read",
+          input: { filePath: "/src/same.ts" },
+        }))
+        const window = buildWindowWithInputs(calls)
         const result = detectRepetitiveToolUse(window)
-        expect(result.triggered).toBe(true)
-        expect(result.toolName).toBe("read")
-        expect(result.repeatedCount).toBe(16)
+        expect(result).toEqual({
+          triggered: true,
+          toolName: "read",
+          repeatedCount: 20,
+        })
       })
     })
 
     describe("#given tool calls with no input", () => {
-      test("#when the same tool dominates #then falls back to name-only detection", () => {
-        const calls = [
-          ...Array.from({ length: 16 }, () => ({ tool: "read" })),
-          { tool: "grep" },
-          { tool: "edit" },
-          { tool: "bash" },
-          { tool: "glob" },
-        ]
-        const window = buildWindowWithInputs(calls, {
-          circuitBreaker: { windowSize: 20, repetitionThresholdPercent: 80 },
-        })
+      test("#when evaluated #then it triggers", () => {
+        const calls = Array.from({ length: 20 }, () => ({ tool: "read" }))
+        const window = buildWindowWithInputs(calls)
         const result = detectRepetitiveToolUse(window)
-        expect(result.triggered).toBe(true)
-        expect(result.toolName).toBe("read")
+        expect(result).toEqual({
+          triggered: true,
+          toolName: "read",
+          repeatedCount: 20,
+        })
       })
     })
   })

src/features/background-agent/loop-detector.ts

@@ -1,8 +1,7 @@
 import type { BackgroundTaskConfig } from "../../config/schema"
 import {
   DEFAULT_CIRCUIT_BREAKER_ENABLED,
-  DEFAULT_CIRCUIT_BREAKER_REPETITION_THRESHOLD_PERCENT,
-  DEFAULT_CIRCUIT_BREAKER_WINDOW_SIZE,
+  DEFAULT_CIRCUIT_BREAKER_CONSECUTIVE_THRESHOLD,
   DEFAULT_MAX_TOOL_CALLS,
 } from "./constants"
 import type { ToolCallWindow } from "./types"
@@ -10,16 +9,13 @@ import type { ToolCallWindow } from "./types"
 export interface CircuitBreakerSettings {
   enabled: boolean
   maxToolCalls: number
-  windowSize: number
-  repetitionThresholdPercent: number
+  consecutiveThreshold: number
 }
 
 export interface ToolLoopDetectionResult {
   triggered: boolean
   toolName?: string
   repeatedCount?: number
-  sampleSize?: number
-  thresholdPercent?: number
 }
 
 export function resolveCircuitBreakerSettings(
@@ -29,10 +25,8 @@ export function resolveCircuitBreakerSettings(
     enabled: config?.circuitBreaker?.enabled ?? DEFAULT_CIRCUIT_BREAKER_ENABLED,
     maxToolCalls:
       config?.circuitBreaker?.maxToolCalls ?? config?.maxToolCalls ?? DEFAULT_MAX_TOOL_CALLS,
-    windowSize: config?.circuitBreaker?.windowSize ?? DEFAULT_CIRCUIT_BREAKER_WINDOW_SIZE,
-    repetitionThresholdPercent:
-      config?.circuitBreaker?.repetitionThresholdPercent ??
-      DEFAULT_CIRCUIT_BREAKER_REPETITION_THRESHOLD_PERCENT,
+    consecutiveThreshold:
+      config?.circuitBreaker?.consecutiveThreshold ?? DEFAULT_CIRCUIT_BREAKER_CONSECUTIVE_THRESHOLD,
   }
 }
 
@@ -42,14 +36,20 @@ export function recordToolCall(
   settings: CircuitBreakerSettings,
   toolInput?: Record<string, unknown> | null
 ): ToolCallWindow {
-  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,
   }
 }
 
@@ -82,46 +82,13 @@ export function createToolCallSignature(
 export function detectRepetitiveToolUse(
   window: ToolCallWindow | undefined
 ): ToolLoopDetectionResult {
-  if (!window || window.toolSignatures.length === 0) {
-    return { triggered: false }
-  }
-
-  const counts = new Map<string, number>()
-  for (const signature of window.toolSignatures) {
-    counts.set(signature, (counts.get(signature) ?? 0) + 1)
-  }
-
-  let repeatedTool: string | undefined
-  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,
   }
 }

src/features/background-agent/manager-circuit-breaker.test.ts

@@ -38,12 +38,11 @@ async function flushAsyncWork() {
 }
 
 describe("BackgroundManager circuit breaker", () => {
-  describe("#given the same tool dominates the recent window", () => {
-    test("#when tool events arrive #then the task is cancelled early", async () => {
+  describe("#given the same tool is called consecutively", () => {
+    test("#when consecutive tool events arrive #then the task is cancelled", async () => {
       const manager = createManager({
         circuitBreaker: {
-          windowSize: 20,
-          repetitionThresholdPercent: 80,
+          consecutiveThreshold: 20,
         },
       })
       const task: BackgroundTask = {
@@ -63,38 +62,17 @@ describe("BackgroundManager circuit breaker", () => {
       }
       getTaskMap(manager).set(task.id, task)
 
-      for (const toolName of [
-        "read",
-        "read",
-        "grep",
-        "read",
-        "edit",
-        "read",
-        "read",
-        "bash",
-        "read",
-        "read",
-        "read",
-        "glob",
-        "read",
-        "read",
-        "read",
-        "read",
-        "read",
-        "read",
-        "read",
-        "read",
-      ]) {
+      for (let i = 0; i < 20; i++) {
         manager.handleEvent({
           type: "message.part.updated",
-          properties: { sessionID: task.sessionID, type: "tool", tool: toolName },
+          properties: { sessionID: task.sessionID, type: "tool", tool: "read" },
         })
       }
 
       await flushAsyncWork()
 
       expect(task.status).toBe("cancelled")
-      expect(task.error).toContain("repeatedly called read 16/20 times")
+      expect(task.error).toContain("read 20 consecutive times")
     })
   })
 
@@ -102,8 +80,7 @@ describe("BackgroundManager circuit breaker", () => {
     test("#when the window fills #then the task keeps running", async () => {
       const manager = createManager({
         circuitBreaker: {
-          windowSize: 10,
-          repetitionThresholdPercent: 80,
+          consecutiveThreshold: 10,
         },
       })
       const task: BackgroundTask = {
@@ -153,8 +130,7 @@ describe("BackgroundManager circuit breaker", () => {
       const manager = createManager({
         maxToolCalls: 3,
         circuitBreaker: {
-          windowSize: 10,
-          repetitionThresholdPercent: 95,
+          consecutiveThreshold: 95,
         },
       })
       const task: BackgroundTask = {
@@ -193,8 +169,7 @@ describe("BackgroundManager circuit breaker", () => {
       const manager = createManager({
         maxToolCalls: 2,
         circuitBreaker: {
-          windowSize: 5,
-          repetitionThresholdPercent: 80,
+          consecutiveThreshold: 5,
         },
       })
       const task: BackgroundTask = {
@@ -233,7 +208,7 @@ describe("BackgroundManager circuit breaker", () => {
 
       expect(task.status).toBe("running")
       expect(task.progress?.toolCalls).toBe(1)
-      expect(task.progress?.countedToolPartIDs).toEqual(["tool-1"])
+      expect(task.progress?.countedToolPartIDs).toEqual(new Set(["tool-1"]))
     })
   })
 
@@ -241,8 +216,7 @@ describe("BackgroundManager circuit breaker", () => {
     test("#when tool events arrive with state.input #then task keeps running", async () => {
       const manager = createManager({
         circuitBreaker: {
-          windowSize: 20,
-          repetitionThresholdPercent: 80,
+          consecutiveThreshold: 20,
         },
       })
       const task: BackgroundTask = {
@@ -287,8 +261,7 @@ describe("BackgroundManager circuit breaker", () => {
     test("#when tool events arrive with state.input #then task is cancelled with bare tool name in error", async () => {
       const manager = createManager({
         circuitBreaker: {
-          windowSize: 20,
-          repetitionThresholdPercent: 80,
+          consecutiveThreshold: 20,
         },
       })
       const task: BackgroundTask = {
@@ -325,7 +298,7 @@ describe("BackgroundManager circuit breaker", () => {
       await flushAsyncWork()
 
       expect(task.status).toBe("cancelled")
-      expect(task.error).toContain("repeatedly called read")
+      expect(task.error).toContain("read 20 consecutive times")
       expect(task.error).not.toContain("::")
     })
   })
@@ -335,8 +308,7 @@ describe("BackgroundManager circuit breaker", () => {
       const manager = createManager({
         circuitBreaker: {
           enabled: false,
-          windowSize: 20,
-          repetitionThresholdPercent: 80,
+          consecutiveThreshold: 20,
         },
       })
       const task: BackgroundTask = {
@@ -379,8 +351,7 @@ describe("BackgroundManager circuit breaker", () => {
         maxToolCalls: 3,
         circuitBreaker: {
           enabled: false,
-          windowSize: 10,
-          repetitionThresholdPercent: 95,
+          consecutiveThreshold: 95,
         },
       })
       const task: BackgroundTask = {

src/features/background-agent/manager.polling.test.ts

@@ -153,4 +153,42 @@ describe("BackgroundManager pollRunningTasks", () => {
       expect(task.status).toBe("running")
     })
   })
+
+  describe("#given a running task whose session has terminal non-idle status", () => {
+    test('#when session status is "interrupted" #then completes the task', async () => {
+      //#given
+      const manager = createManagerWithClient({
+        status: async () => ({ data: { "ses-interrupted": { type: "interrupted" } } }),
+      })
+      const task = createRunningTask("ses-interrupted")
+      injectTask(manager, task)
+
+      //#when
+      const poll = (manager as unknown as { pollRunningTasks: () => Promise<void> }).pollRunningTasks
+      await poll.call(manager)
+      manager.shutdown()
+
+      //#then
+      expect(task.status).toBe("completed")
+      expect(task.completedAt).toBeDefined()
+    })
+
+    test('#when session status is an unknown type #then completes the task', async () => {
+      //#given
+      const manager = createManagerWithClient({
+        status: async () => ({ data: { "ses-unknown": { type: "some-weird-status" } } }),
+      })
+      const task = createRunningTask("ses-unknown")
+      injectTask(manager, task)
+
+      //#when
+      const poll = (manager as unknown as { pollRunningTasks: () => Promise<void> }).pollRunningTasks
+      await poll.call(manager)
+      manager.shutdown()
+
+      //#then
+      expect(task.status).toBe("completed")
+      expect(task.completedAt).toBeDefined()
+    })
+  })
 })

src/features/background-agent/manager.ts

@@ -52,10 +52,12 @@ import { join } from "node:path"
 import { pruneStaleTasksAndNotifications } from "./task-poller"
 import { checkAndInterruptStaleTasks } from "./task-poller"
 import { removeTaskToastTracking } from "./remove-task-toast-tracking"
+import { isActiveSessionStatus, isTerminalSessionStatus } from "./session-status-classifier"
 import {
   detectRepetitiveToolUse,
   recordToolCall,
   resolveCircuitBreakerSettings,
+  type CircuitBreakerSettings,
 } from "./loop-detector"
 import {
   createSubagentDepthLimitError,
@@ -151,6 +153,7 @@ export class BackgroundManager {
   private preStartDescendantReservations: Set<string>
   private enableParentSessionNotifications: boolean
   readonly taskHistory = new TaskHistory()
+  private cachedCircuitBreakerSettings?: CircuitBreakerSettings
 
   constructor(
     ctx: PluginInput,
@@ -900,23 +903,24 @@ export class BackgroundManager {
       task.progress.lastUpdate = new Date()
 
       if (partInfo?.type === "tool" || partInfo?.tool) {
-        const countedToolPartIDs = task.progress.countedToolPartIDs ?? []
+        const countedToolPartIDs = task.progress.countedToolPartIDs ?? new Set<string>()
         const shouldCountToolCall =
           !partInfo.id ||
           partInfo.state?.status !== "running" ||
-          !countedToolPartIDs.includes(partInfo.id)
+          !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,
@@ -928,18 +932,16 @@ export class BackgroundManager {
            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,
                })
                void 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
              }
@@ -1782,11 +1784,9 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           }
         }
 
-        // Match sync-session-poller pattern: only skip completion check when
-        // status EXISTS and is not idle (i.e., session is actively running).
-        // When sessionStatus is undefined, the session has completed and dropped
-        // from the status response — fall through to completion detection.
-        if (sessionStatus && sessionStatus.type !== "idle") {
+        // Only skip completion when session status is actively running.
+        // Unknown or terminal statuses (like "interrupted") fall through to completion.
+        if (sessionStatus && isActiveSessionStatus(sessionStatus.type)) {
           log("[background-agent] Session still running, relying on event-based progress:", {
             taskId: task.id,
             sessionID,
@@ -1796,6 +1796,24 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           continue
         }
 
+        // Explicit terminal non-idle status (e.g., "interrupted") — complete immediately,
+        // skipping output validation (session will never produce more output).
+        // Unknown statuses fall through to the idle/gone path with output validation.
+        if (sessionStatus && isTerminalSessionStatus(sessionStatus.type)) {
+          await this.tryCompleteTask(task, `polling (terminal session status: ${sessionStatus.type})`)
+          continue
+        }
+
+        // Unknown non-idle status — not active, not terminal, not idle.
+        // Fall through to idle/gone completion path with output validation.
+        if (sessionStatus && sessionStatus.type !== "idle") {
+          log("[background-agent] Unknown session status, treating as potentially idle:", {
+            taskId: task.id,
+            sessionID,
+            sessionStatus: sessionStatus.type,
+          })
+        }
+
         // Session is idle or no longer in status response (completed/disappeared)
         const completionSource = sessionStatus?.type === "idle"
           ? "polling (idle status)"

src/features/background-agent/session-status-classifier.test.ts

@@ -0,0 +1,66 @@
+import { describe, test, expect, mock } from "bun:test"
+import { isActiveSessionStatus, isTerminalSessionStatus } from "./session-status-classifier"
+
+const mockLog = mock()
+mock.module("../../shared", () => ({ log: mockLog }))
+
+describe("isActiveSessionStatus", () => {
+  describe("#given a known active session status", () => {
+    test('#when type is "busy" #then returns true', () => {
+      expect(isActiveSessionStatus("busy")).toBe(true)
+    })
+
+    test('#when type is "retry" #then returns true', () => {
+      expect(isActiveSessionStatus("retry")).toBe(true)
+    })
+
+    test('#when type is "running" #then returns true', () => {
+      expect(isActiveSessionStatus("running")).toBe(true)
+    })
+  })
+
+  describe("#given a known terminal session status", () => {
+    test('#when type is "idle" #then returns false', () => {
+      expect(isActiveSessionStatus("idle")).toBe(false)
+    })
+
+    test('#when type is "interrupted" #then returns false and does not log', () => {
+      mockLog.mockClear()
+      expect(isActiveSessionStatus("interrupted")).toBe(false)
+      expect(mockLog).not.toHaveBeenCalled()
+    })
+  })
+
+  describe("#given an unknown session status", () => {
+    test('#when type is an arbitrary unknown string #then returns false and logs warning', () => {
+      mockLog.mockClear()
+      expect(isActiveSessionStatus("some-unknown-status")).toBe(false)
+      expect(mockLog).toHaveBeenCalledWith(
+        "[background-agent] Unknown session status type encountered:",
+        "some-unknown-status",
+      )
+    })
+
+    test('#when type is empty string #then returns false', () => {
+      expect(isActiveSessionStatus("")).toBe(false)
+    })
+  })
+})
+
+describe("isTerminalSessionStatus", () => {
+  test('#when type is "interrupted" #then returns true', () => {
+    expect(isTerminalSessionStatus("interrupted")).toBe(true)
+  })
+
+  test('#when type is "idle" #then returns false (idle is handled separately)', () => {
+    expect(isTerminalSessionStatus("idle")).toBe(false)
+  })
+
+  test('#when type is "busy" #then returns false', () => {
+    expect(isTerminalSessionStatus("busy")).toBe(false)
+  })
+
+  test('#when type is an unknown string #then returns false', () => {
+    expect(isTerminalSessionStatus("some-unknown")).toBe(false)
+  })
+})

src/features/background-agent/session-status-classifier.ts

@@ -0,0 +1,20 @@
+import { log } from "../../shared"
+
+const ACTIVE_SESSION_STATUSES = new Set(["busy", "retry", "running"])
+const KNOWN_TERMINAL_STATUSES = new Set(["idle", "interrupted"])
+
+export function isActiveSessionStatus(type: string): boolean {
+  if (ACTIVE_SESSION_STATUSES.has(type)) {
+    return true
+  }
+
+  if (!KNOWN_TERMINAL_STATUSES.has(type)) {
+    log("[background-agent] Unknown session status type encountered:", type)
+  }
+
+  return false
+}
+
+export function isTerminalSessionStatus(type: string): boolean {
+  return KNOWN_TERMINAL_STATUSES.has(type) && type !== "idle"
+}

src/features/background-agent/task-poller.test.ts

@@ -417,6 +417,56 @@ describe("checkAndInterruptStaleTasks", () => {
     expect(task.status).toBe("cancelled")
     expect(onTaskInterrupted).toHaveBeenCalledWith(task)
   })
+
+  it('should NOT protect task when session has terminal non-idle status like "interrupted"', async () => {
+    //#given — lastUpdate is 5min old, session is "interrupted" (terminal, not active)
+    const task = createRunningTask({
+      startedAt: new Date(Date.now() - 300_000),
+      progress: {
+        toolCalls: 2,
+        lastUpdate: new Date(Date.now() - 300_000),
+      },
+    })
+
+    //#when — session status is "interrupted" (terminal)
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: { staleTimeoutMs: 180_000 },
+      concurrencyManager: mockConcurrencyManager as never,
+      notifyParentSession: mockNotify,
+      sessionStatuses: { "ses-1": { type: "interrupted" } },
+    })
+
+    //#then — terminal statuses should not protect from stale timeout
+    expect(task.status).toBe("cancelled")
+    expect(task.error).toContain("Stale timeout")
+  })
+
+  it('should NOT protect task when session has unknown status type', async () => {
+    //#given — lastUpdate is 5min old, session has an unknown status
+    const task = createRunningTask({
+      startedAt: new Date(Date.now() - 300_000),
+      progress: {
+        toolCalls: 2,
+        lastUpdate: new Date(Date.now() - 300_000),
+      },
+    })
+
+    //#when — session has unknown status type
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: { staleTimeoutMs: 180_000 },
+      concurrencyManager: mockConcurrencyManager as never,
+      notifyParentSession: mockNotify,
+      sessionStatuses: { "ses-1": { type: "some-weird-status" } },
+    })
+
+    //#then — unknown statuses should not protect from stale timeout
+    expect(task.status).toBe("cancelled")
+    expect(task.error).toContain("Stale timeout")
+  })
 })
 
 describe("pruneStaleTasksAndNotifications", () => {

src/features/background-agent/task-poller.ts

@@ -14,6 +14,7 @@ import {
 } from "./constants"
 import { removeTaskToastTracking } from "./remove-task-toast-tracking"
 
+import { isActiveSessionStatus } from "./session-status-classifier"
 const TERMINAL_TASK_STATUSES = new Set<BackgroundTask["status"]>([
   "completed",
   "error",
@@ -120,7 +121,7 @@ export 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) {

src/features/background-agent/types.ts

@@ -10,16 +10,16 @@ export type BackgroundTaskStatus =
   | "interrupt"
 
 export interface ToolCallWindow {
-  toolSignatures: string[]
-  windowSize: number
-  thresholdPercent: number
+  lastSignature: string
+  consecutiveCount: number
+  threshold: number
 }
 
 export interface TaskProgress {
   toolCalls: number
   lastTool?: string
   toolCallWindow?: ToolCallWindow
-  countedToolPartIDs?: string[]
+  countedToolPartIDs?: Set<string>
   lastUpdate: Date
   lastMessage?: string
   lastMessageAt?: Date

src/hooks/anthropic-context-window-limit-recovery/parser.ts

@@ -70,7 +70,7 @@ function isTokenLimitError(text: string): boolean {
     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))
 }
 
 export function parseAnthropicTokenLimitError(err: unknown): ParsedTokenLimitError | null {

src/hooks/atlas/session-last-agent.ts

@@ -18,9 +18,9 @@ function getLastAgentFromMessageDir(messageDir: string): string | null {
     const files = readdirSync(messageDir)
       .filter((fileName) => fileName.endsWith(".json"))
       .sort()
-      .reverse()
 
-    for (const fileName of files) {
+    for (let i = files.length - 1; i >= 0; i--) {
+      const fileName = files[i]
       try {
         const content = readFileSync(join(messageDir, fileName), "utf-8")
         const parsed = JSON.parse(content) as { agent?: unknown }

src/hooks/auto-slash-command/executor.ts

@@ -44,12 +44,6 @@ export interface ExecutorOptions {
   agent?: string
 }
 
-function filterDiscoveredCommandsByScope(
-  commands: DiscoveredCommandInfo[],
-  scope: DiscoveredCommandInfo["scope"],
-): DiscoveredCommandInfo[] {
-  return commands.filter(command => command.scope === scope)
-}
 
 async function discoverAllCommands(options?: ExecutorOptions): Promise<CommandInfo[]> {
   const discoveredCommands = discoverCommandsSync(process.cwd(), {
@@ -60,14 +54,18 @@ async function discoverAllCommands(options?: ExecutorOptions): Promise<CommandIn
   const skills = options?.skills ?? await discoverAllSkills()
   const skillCommands = skills.map(skillToCommandInfo)
 
+  const scopeOrder: DiscoveredCommandInfo["scope"][] = ["project", "user", "opencode-project", "opencode", "builtin", "plugin"]
+  const grouped = new Map<string, DiscoveredCommandInfo[]>()
+  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,
   ]
 }
 

src/hooks/claude-code-hooks/handlers/tool-execute-after-handler.ts

@@ -79,8 +79,6 @@ export function createToolExecuteAfterHandler(ctx: PluginInput, config: PluginCo
 			return
 		}
 
-		const claudeConfig = await loadClaudeHooksConfig()
-		const extendedConfig = await loadPluginExtendedConfig()
 
 		const cachedInput = getToolInput(input.sessionID, input.tool, input.callID) || {}
 
@@ -96,6 +94,9 @@ export function createToolExecuteAfterHandler(ctx: PluginInput, config: PluginCo
 			return
 		}
 
+		const claudeConfig = await loadClaudeHooksConfig()
+		const extendedConfig = await loadPluginExtendedConfig()
+
 		const postClient: PostToolUseClient = {
 			session: {
 				messages: (opts) => ctx.client.session.messages(opts),

src/hooks/claude-code-hooks/handlers/tool-execute-before-handler.ts

@@ -43,8 +43,6 @@ export function createToolExecuteBeforeHandler(ctx: PluginInput, config: PluginC
 			log("todowrite: parsed todos string to array", { sessionID: input.sessionID })
 		}
 
-		const claudeConfig = await loadClaudeHooksConfig()
-		const extendedConfig = await loadPluginExtendedConfig()
 
 		appendTranscriptEntry(input.sessionID, {
 			type: "tool_use",
@@ -59,6 +57,9 @@ export function createToolExecuteBeforeHandler(ctx: PluginInput, config: PluginC
 			return
 		}
 
+		const claudeConfig = await loadClaudeHooksConfig()
+		const extendedConfig = await loadPluginExtendedConfig()
+
 		const preCtx: PreToolUseContext = {
 			sessionId: input.sessionID,
 			toolName: input.tool,

src/hooks/comment-checker/hook.ts

@@ -3,6 +3,18 @@ import type { CommentCheckerConfig } from "../../config/schema"
 
 import z from "zod"
 
+const ApplyPatchMetadataSchema = z.object({
+  files: z.array(
+    z.object({
+      filePath: z.string(),
+      movePath: z.string().optional(),
+      before: z.string(),
+      after: z.string(),
+      type: z.string().optional(),
+    }),
+  ),
+})
+
 import {
   initializeCommentCheckerCli,
   getCommentCheckerCliPathPromise,
@@ -104,17 +116,6 @@ export function createCommentCheckerHooks(config?: CommentCheckerConfig) {
         return
       }
 
-      const ApplyPatchMetadataSchema = z.object({
-        files: z.array(
-          z.object({
-            filePath: z.string(),
-            movePath: z.string().optional(),
-            before: z.string(),
-            after: z.string(),
-            type: z.string().optional(),
-          }),
-        ),
-      })
 
       if (toolLower === "apply_patch") {
         const parsed = ApplyPatchMetadataSchema.safeParse(output.metadata)

src/hooks/runtime-fallback/error-classifier.ts

@@ -28,6 +28,8 @@ export function getErrorMessage(error: unknown): string {
   }
 }
 
+const DEFAULT_RETRY_PATTERN = new RegExp(`\\b(${DEFAULT_CONFIG.retry_on_errors.join("|")})\\b`)
+
 export function extractStatusCode(error: unknown, retryOnErrors?: number[]): number | undefined {
   if (!error) return undefined
 
@@ -45,8 +47,9 @@ export function extractStatusCode(error: unknown, retryOnErrors?: number[]): num
     return statusCode
   }
 
-  const codes = retryOnErrors ?? DEFAULT_CONFIG.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 = getErrorMessage(error)
   const statusMatch = message.match(pattern)
   if (statusMatch) {

src/hooks/think-mode/detector.ts

@@ -32,8 +32,10 @@ const MULTILINGUAL_KEYWORDS = [
   "fikir", "berfikir",
 ]
 
-const MULTILINGUAL_PATTERNS = MULTILINGUAL_KEYWORDS.map((kw) => new RegExp(kw, "i"))
-const THINK_PATTERNS = [...ENGLISH_PATTERNS, ...MULTILINGUAL_PATTERNS]
+const COMBINED_THINK_PATTERN = new RegExp(
+  `\\b(?:ultrathink|think)\\b|${MULTILINGUAL_KEYWORDS.join("|")}`,
+  "i"
+)
 
 const CODE_BLOCK_PATTERN = /```[\s\S]*?```/g
 const INLINE_CODE_PATTERN = /`[^`]+`/g
@@ -44,7 +46,7 @@ function removeCodeBlocks(text: string): string {
 
 export function detectThinkKeyword(text: string): boolean {
   const textWithoutCode = removeCodeBlocks(text)
-  return THINK_PATTERNS.some((pattern) => pattern.test(textWithoutCode))
+  return COMBINED_THINK_PATTERN.test(textWithoutCode)
 }
 
 export function extractPromptText(

src/hooks/todo-continuation-enforcer/handler.ts

@@ -31,6 +31,10 @@ export function createTodoContinuationHandler(args: {
   return async ({ event }: { event: { type: string; properties?: unknown } }): Promise<void> => {
     const props = event.properties as Record<string, unknown> | undefined
 
+    if (event.type === "session.idle") {
+      console.error(`[TODO-DIAG] handler received session.idle event`, { sessionID: (props?.sessionID as string) })
+    }
+
     if (event.type === "session.error") {
       const sessionID = props?.sessionID as string | undefined
       if (!sessionID) return

src/hooks/todo-continuation-enforcer/idle-event.ts

@@ -43,10 +43,12 @@ export async function handleSessionIdle(args: {
   } = args
 
   log(`[${HOOK_NAME}] session.idle`, { sessionID })
+  console.error(`[TODO-DIAG] session.idle fired for ${sessionID}`)
 
   const state = sessionStateStore.getState(sessionID)
   if (state.isRecovering) {
     log(`[${HOOK_NAME}] Skipped: in recovery`, { sessionID })
+    console.error(`[TODO-DIAG] BLOCKED: isRecovering=true`)
     return
   }
 
@@ -54,6 +56,7 @@ export async function handleSessionIdle(args: {
     const timeSinceAbort = Date.now() - state.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`)
       state.abortDetectedAt = undefined
       return
     }
@@ -66,6 +69,7 @@ export async function handleSessionIdle(args: {
 
   if (hasRunningBgTasks) {
     log(`[${HOOK_NAME}] Skipped: background tasks running`, { sessionID })
+    console.error(`[TODO-DIAG] BLOCKED: background tasks running`, backgroundManager?.getTasksByParentSession(sessionID).filter((t: {status:string}) => t.status === 'running').map((t: {id:string, status:string}) => t.id))
     return
   }
 
@@ -77,10 +81,12 @@ export async function handleSessionIdle(args: {
     const messages = normalizeSDKResponse(messagesResp, [] as Array<{ info?: MessageInfo }>)
     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) {
@@ -93,24 +99,30 @@ export async function handleSessionIdle(args: {
     todos = normalizeSDKResponse(response, [] as Todo[], { 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 (state.inFlight) {
     log(`[${HOOK_NAME}] Skipped: injection in flight`, { sessionID })
+    console.error(`[TODO-DIAG] BLOCKED: inFlight=true`)
     return
   }
 
@@ -124,22 +136,16 @@ export async function handleSessionIdle(args: {
   }
 
   if (state.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
-    log(`[${HOOK_NAME}] Skipped: max consecutive failures reached`, {
-      sessionID,
-      consecutiveFailures: state.consecutiveFailures,
-      maxConsecutiveFailures: MAX_CONSECUTIVE_FAILURES,
-    })
+    log(`[${HOOK_NAME}] Skipped: max consecutive failures reached`, { sessionID, consecutiveFailures: state.consecutiveFailures })
+    console.error(`[TODO-DIAG] BLOCKED: consecutiveFailures=${state.consecutiveFailures} >= ${MAX_CONSECUTIVE_FAILURES}`)
     return
   }
 
   const effectiveCooldown =
     CONTINUATION_COOLDOWN_MS * Math.pow(2, Math.min(state.consecutiveFailures, 5))
   if (state.lastInjectedAt && Date.now() - state.lastInjectedAt < effectiveCooldown) {
-    log(`[${HOOK_NAME}] Skipped: cooldown active`, {
-      sessionID,
-      effectiveCooldown,
-      consecutiveFailures: state.consecutiveFailures,
-    })
+    log(`[${HOOK_NAME}] Skipped: cooldown active`, { sessionID, effectiveCooldown, consecutiveFailures: state.consecutiveFailures })
+    console.error(`[TODO-DIAG] BLOCKED: cooldown active (${effectiveCooldown}ms, failures=${state.consecutiveFailures})`)
     return
   }
 
@@ -165,10 +171,12 @@ export 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 (state.recentCompactionAt && resolvedInfo?.agent) {
@@ -177,18 +185,22 @@ export 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,

src/plugin-interface.ts

@@ -32,10 +32,7 @@ export function createPluginInterface(args: {
   return {
     tool: tools,
 
-    "chat.params": async (input: unknown, output: unknown) => {
-      const handler = createChatParamsHandler({ anthropicEffort: hooks.anthropicEffort })
-      await handler(input, output)
-    },
+    "chat.params": createChatParamsHandler({ anthropicEffort: hooks.anthropicEffort }),
 
     "chat.headers": createChatHeadersHandler({ ctx }),
 

src/shared/connected-providers-cache.ts

@@ -32,6 +32,9 @@ export function createConnectedProvidersCacheStore(
 		return join(getCacheDir(), filename)
 	}
 
+	let memConnected: string[] | null | undefined
+	let memProviderModels: ProviderModelsCache | null | undefined
+
 	function ensureCacheDir(): void {
 		const cacheDir = getCacheDir()
 		if (!existsSync(cacheDir)) {
@@ -40,10 +43,12 @@ export function createConnectedProvidersCacheStore(
 	}
 
 	function readConnectedProvidersCache(): string[] | null {
+		if (memConnected !== undefined) return memConnected
 		const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE)
 
 		if (!existsSync(cacheFile)) {
 			log("[connected-providers-cache] Cache file not found", { cacheFile })
+			memConnected = null
 			return null
 		}
 
@@ -51,9 +56,11 @@ export function createConnectedProvidersCacheStore(
 			const content = readFileSync(cacheFile, "utf-8")
 			const data = JSON.parse(content) as ConnectedProvidersCache
 			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
 		}
 	}
@@ -74,6 +81,7 @@ export function createConnectedProvidersCacheStore(
 
 		try {
 			writeFileSync(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) })
@@ -81,10 +89,12 @@ export function createConnectedProvidersCacheStore(
 	}
 
 	function readProviderModelsCache(): ProviderModelsCache | null {
+		if (memProviderModels !== undefined) return memProviderModels
 		const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE)
 
 		if (!existsSync(cacheFile)) {
 			log("[connected-providers-cache] Provider-models cache file not found", { cacheFile })
+			memProviderModels = null
 			return null
 		}
 
@@ -95,9 +105,11 @@ export function createConnectedProvidersCacheStore(
 				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
 		}
 	}
@@ -118,6 +130,7 @@ export function createConnectedProvidersCacheStore(
 
 		try {
 			writeFileSync(cacheFile, JSON.stringify(cacheData, null, 2))
+			memProviderModels = cacheData
 			log("[connected-providers-cache] Provider-models cache written", {
 				providerCount: Object.keys(data.models).length,
 			})

src/shared/file-reference-resolver.ts

@@ -74,7 +74,7 @@ export async function resolveFileReferencesInText(
 
   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) {

src/shared/logger.ts

@@ -1,16 +1,42 @@
-// Shared logging utility for the plugin
-
 import * as fs from "fs"
 import * as os from "os"
 import * as path from "path"
 
 const logFile = path.join(os.tmpdir(), "oh-my-opencode.log")
 
+let buffer: string[] = []
+let flushTimer: ReturnType<typeof setTimeout> | null = null
+const FLUSH_INTERVAL_MS = 500
+const BUFFER_SIZE_LIMIT = 50
+
+function flush(): void {
+  if (buffer.length === 0) return
+  const data = buffer.join("")
+  buffer = []
+  try {
+    fs.appendFileSync(logFile, data)
+  } catch {
+  }
+}
+
+function scheduleFlush(): void {
+  if (flushTimer) return
+  flushTimer = setTimeout(() => {
+    flushTimer = null
+    flush()
+  }, FLUSH_INTERVAL_MS)
+}
+
 export function log(message: string, data?: unknown): void {
   try {
     const timestamp = new Date().toISOString()
     const logEntry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}\n`
-    fs.appendFileSync(logFile, logEntry)
+    buffer.push(logEntry)
+    if (buffer.length >= BUFFER_SIZE_LIMIT) {
+      flush()
+    } else {
+      scheduleFlush()
+    }
   } catch {
   }
 }

src/shared/pattern-matcher.ts

@@ -9,6 +9,8 @@ function escapeRegexExceptAsterisk(str: string): string {
   return str.replace(/[.+?^${}()|[\]\\]/g, "\\$&")
 }
 
+const regexCache = new Map<string, RegExp>()
+
 export function matchesToolMatcher(toolName: string, matcher: string): boolean {
   if (!matcher) {
     return true
@@ -17,8 +19,12 @@ export function matchesToolMatcher(toolName: string, matcher: string): boolean {
   return patterns.some((p) => {
     if (p.includes("*")) {
       // First escape regex special chars (except *), then convert * to .*
-      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()

src/tools/hashline-edit/edit-operations.ts

@@ -11,6 +11,14 @@ import {
 } from "./edit-operation-primitives"
 import { validateLineRefs } from "./validation"
 
+function arraysEqual(a: string[], b: string[]): boolean {
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false
+  }
+  return true
+}
+
 export interface HashlineApplyReport {
   content: string
   noopEdits: number
@@ -51,7 +59,7 @@ export function applyHashlineEditsWithReport(content: string, edits: HashlineEdi
         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("\n") === lines.join("\n")) {
+        if (arraysEqual(next, lines)) {
           noopEdits += 1
           break
         }
@@ -62,7 +70,7 @@ export function applyHashlineEditsWithReport(content: string, edits: HashlineEdi
         const next = edit.pos
           ? applyInsertAfter(lines, edit.pos, edit.lines, { skipValidation: true })
           : applyAppend(lines, edit.lines)
-        if (next.join("\n") === lines.join("\n")) {
+        if (arraysEqual(next, lines)) {
           noopEdits += 1
           break
         }
@@ -73,7 +81,7 @@ export function applyHashlineEditsWithReport(content: string, edits: HashlineEdi
         const next = edit.pos
           ? applyInsertBefore(lines, edit.pos, edit.lines, { skipValidation: true })
           : applyPrepend(lines, edit.lines)
-        if (next.join("\n") === lines.join("\n")) {
+        if (arraysEqual(next, lines)) {
           noopEdits += 1
           break
         }

src/tools/hashline-edit/hash-computation.ts

@@ -86,15 +86,17 @@ export async function* streamHashLinesFromUtf8(
     pending += text
     const chunksToYield: string[] = []
 
+    let lastIdx = 0
     while (true) {
-      const idx = pending.indexOf("\n")
+      const idx = pending.indexOf("\n", lastIdx)
       if (idx === -1) break
-      const line = pending.slice(0, idx)
-      pending = pending.slice(idx + 1)
+      const line = pending.slice(lastIdx, idx)
+      lastIdx = idx + 1
       endedWithNewline = true
       chunksToYield.push(...pushLine(line))
     }
 
+    pending = pending.slice(lastIdx)
     if (pending.length > 0) endedWithNewline = false
     return chunksToYield
   }

src/tools/hashline-edit/hashline-edit-diff.ts

@@ -4,7 +4,7 @@ export function generateHashlineDiff(oldContent: string, newContent: string, fil
   const oldLines = oldContent.split("\n")
   const newLines = newContent.split("\n")
 
-  let diff = `--- ${filePath}\n+++ ${filePath}\n`
+  const parts: string[] = [`--- ${filePath}\n+++ ${filePath}\n`]
   const maxLines = Math.max(oldLines.length, newLines.length)
 
   for (let i = 0; i < maxLines; i += 1) {
@@ -14,18 +14,18 @@ export function generateHashlineDiff(oldContent: string, newContent: string, fil
     const hash = computeLineHash(lineNum, newLine)
 
     if (i >= oldLines.length) {
-      diff += `+ ${lineNum}#${hash}|${newLine}\n`
+      parts.push(`+ ${lineNum}#${hash}|${newLine}\n`)
       continue
     }
     if (i >= newLines.length) {
-      diff += `- ${lineNum}#  |${oldLine}\n`
+      parts.push(`- ${lineNum}#  |${oldLine}\n`)
       continue
     }
     if (oldLine !== newLine) {
-      diff += `- ${lineNum}#  |${oldLine}\n`
-      diff += `+ ${lineNum}#${hash}|${newLine}\n`
+      parts.push(`- ${lineNum}#  |${oldLine}\n`)
+      parts.push(`+ ${lineNum}#${hash}|${newLine}\n`)
     }
   }
 
-  return diff
+  return parts.join("")
 }

src/tools/task/task-list.ts

@@ -45,6 +45,8 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
         }
       }
 
+      const taskMap = new Map(allTasks.map((t) => [t.id, t]))
+
       // Filter out completed and deleted tasks
       const activeTasks = allTasks.filter(
         (task) => task.status !== "completed" && task.status !== "deleted"
@@ -54,7 +56,7 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
       const summaries: TaskSummary[] = activeTasks.map((task) => {
         // Filter blockedBy to only include unresolved (non-completed) blockers
         const unresolvedBlockers = task.blockedBy.filter((blockerId) => {
-          const blockerTask = allTasks.find((t) => t.id === blockerId)
+          const blockerTask = taskMap.get(blockerId)
           // Include if blocker doesn't exist (missing) or if it's not completed
           return !blockerTask || blockerTask.status !== "completed"
         })