oh-my-opencode 3.12.0 → 3.12.1

package/dist/cli/index.js

@@ -6619,85 +6619,146 @@ var init_agent_tool_restrictions = () => {};
 // src/shared/connected-providers-cache.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync } from "fs";
 import { join as join4 } from "path";
-function getCacheFilePath(filename) {
-  return join4(getOmoOpenCodeCacheDir(), filename);
-}
-function ensureCacheDir() {
-  const cacheDir = getOmoOpenCodeCacheDir();
-  if (!existsSync3(cacheDir)) {
-    mkdirSync(cacheDir, { recursive: true });
+function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDir) {
+  function getCacheFilePath(filename) {
+    return join4(getCacheDir2(), filename);
   }
-}
-function writeConnectedProvidersCache(connected) {
-  ensureCacheDir();
-  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 ensureCacheDir() {
+    const cacheDir = getCacheDir2();
+    if (!existsSync3(cacheDir)) {
+      mkdirSync(cacheDir, { recursive: true });
+    }
   }
-}
-function hasProviderModelsCache() {
-  const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
-  return existsSync3(cacheFile);
-}
-function writeProviderModelsCache(data) {
-  ensureCacheDir();
-  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 readConnectedProvidersCache() {
+    const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
+    if (!existsSync3(cacheFile)) {
+      log("[connected-providers-cache] Cache file not found", { cacheFile });
+      return null;
+    }
+    try {
+      const content = readFileSync2(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;
+    }
   }
-}
-async function updateConnectedProvidersCache(client) {
-  if (!client?.provider?.list) {
-    log("[connected-providers-cache] client.provider.list not available");
-    return;
+  function hasConnectedProvidersCache() {
+    const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
+    return existsSync3(cacheFile);
   }
-  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) });
+  function writeConnectedProvidersCache(connected) {
+    ensureCacheDir();
+    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 readProviderModelsCache() {
+    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+    if (!existsSync3(cacheFile)) {
+      log("[connected-providers-cache] Provider-models cache file not found", { cacheFile });
+      return null;
+    }
+    try {
+      const content = readFileSync2(cacheFile, "utf-8");
+      const data = JSON.parse(content);
+      log("[connected-providers-cache] Read provider-models cache", {
+        providerCount: Object.keys(data.models).length,
+        updatedAt: data.updatedAt
+      });
+      return data;
+    } catch (err) {
+      log("[connected-providers-cache] Error reading provider-models cache", { error: String(err) });
+      return null;
+    }
+  }
+  function hasProviderModelsCache() {
+    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+    return existsSync3(cacheFile);
+  }
+  function writeProviderModelsCache(data) {
+    ensureCacheDir();
+    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+    const cacheData = {
+      ...data,
+      updatedAt: new Date().toISOString()
+    };
+    try {
+      writeFileSync2(cacheFile, JSON.stringify(cacheData, null, 2));
+      log("[connected-providers-cache] Provider-models cache written", {
+        providerCount: Object.keys(data.models).length
+      });
+    } catch (err) {
+      log("[connected-providers-cache] Error writing provider-models cache", { error: String(err) });
+    }
+  }
+  async function updateConnectedProvidersCache(client) {
+    if (!client?.provider?.list) {
+      log("[connected-providers-cache] client.provider.list not available");
+      return;
+    }
+    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) });
+    }
+  }
+  return {
+    readConnectedProvidersCache,
+    hasConnectedProvidersCache,
+    readProviderModelsCache,
+    hasProviderModelsCache,
+    writeProviderModelsCache,
+    updateConnectedProvidersCache
+  };
 }
-var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json", PROVIDER_MODELS_CACHE_FILE = "provider-models.json";
+var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json", PROVIDER_MODELS_CACHE_FILE = "provider-models.json", defaultConnectedProvidersCacheStore, readConnectedProvidersCache, hasConnectedProvidersCache, readProviderModelsCache, hasProviderModelsCache, writeProviderModelsCache, updateConnectedProvidersCache;
 var init_connected_providers_cache = __esm(() => {
   init_logger();
   init_data_path();
+  defaultConnectedProvidersCacheStore = createConnectedProvidersCacheStore(() => getOmoOpenCodeCacheDir());
+  ({
+    readConnectedProvidersCache,
+    hasConnectedProvidersCache,
+    readProviderModelsCache,
+    hasProviderModelsCache,
+    writeProviderModelsCache,
+    updateConnectedProvidersCache
+  } = defaultConnectedProvidersCacheStore);
 });
 
 // src/shared/model-availability.ts
@@ -8836,7 +8897,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.12.0",
+  version: "3.12.1",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -8912,17 +8973,17 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "3.12.0",
-    "oh-my-opencode-darwin-x64": "3.12.0",
-    "oh-my-opencode-darwin-x64-baseline": "3.12.0",
-    "oh-my-opencode-linux-arm64": "3.12.0",
-    "oh-my-opencode-linux-arm64-musl": "3.12.0",
-    "oh-my-opencode-linux-x64": "3.12.0",
-    "oh-my-opencode-linux-x64-baseline": "3.12.0",
-    "oh-my-opencode-linux-x64-musl": "3.12.0",
-    "oh-my-opencode-linux-x64-musl-baseline": "3.12.0",
-    "oh-my-opencode-windows-x64": "3.12.0",
-    "oh-my-opencode-windows-x64-baseline": "3.12.0"
+    "oh-my-opencode-darwin-arm64": "3.12.1",
+    "oh-my-opencode-darwin-x64": "3.12.1",
+    "oh-my-opencode-darwin-x64-baseline": "3.12.1",
+    "oh-my-opencode-linux-arm64": "3.12.1",
+    "oh-my-opencode-linux-arm64-musl": "3.12.1",
+    "oh-my-opencode-linux-x64": "3.12.1",
+    "oh-my-opencode-linux-x64-baseline": "3.12.1",
+    "oh-my-opencode-linux-x64-musl": "3.12.1",
+    "oh-my-opencode-linux-x64-musl-baseline": "3.12.1",
+    "oh-my-opencode-windows-x64": "3.12.1",
+    "oh-my-opencode-windows-x64-baseline": "3.12.1"
   },
   overrides: {
     "@opencode-ai/sdk": "^1.2.24"
@@ -24301,6 +24362,7 @@ 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()
@@ -24493,7 +24555,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({

package/dist/config/schema/background-task.d.ts

@@ -10,6 +10,7 @@ export declare const BackgroundTaskConfigSchema: z.ZodObject<{
     syncPollTimeoutMs: z.ZodOptional<z.ZodNumber>;
     maxToolCalls: z.ZodOptional<z.ZodNumber>;
     circuitBreaker: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
         maxToolCalls: z.ZodOptional<z.ZodNumber>;
         windowSize: z.ZodOptional<z.ZodNumber>;
         repetitionThresholdPercent: z.ZodOptional<z.ZodNumber>;

package/dist/config/schema/hooks.d.ts

@@ -48,5 +48,6 @@ export declare const HookNameSchema: z.ZodEnum<{
     "anthropic-effort": "anthropic-effort";
     "hashline-read-enhancer": "hashline-read-enhancer";
     "read-image-resizer": "read-image-resizer";
+    "todo-description-override": "todo-description-override";
 }>;
 export type HookName = z.infer<typeof HookNameSchema>;

package/dist/config/schema/oh-my-opencode-config.d.ts

@@ -1343,6 +1343,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         syncPollTimeoutMs: z.ZodOptional<z.ZodNumber>;
         maxToolCalls: z.ZodOptional<z.ZodNumber>;
         circuitBreaker: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
             maxToolCalls: z.ZodOptional<z.ZodNumber>;
             windowSize: z.ZodOptional<z.ZodNumber>;
             repetitionThresholdPercent: z.ZodOptional<z.ZodNumber>;

package/dist/create-hooks.d.ts

@@ -50,6 +50,7 @@ export declare function createHooks(args: {
     hashlineReadEnhancer: ReturnType<typeof import("./hooks").createHashlineReadEnhancerHook> | null;
     jsonErrorRecovery: ReturnType<typeof import("./hooks").createJsonErrorRecoveryHook> | null;
     readImageResizer: ReturnType<typeof import("./hooks").createReadImageResizerHook> | null;
+    todoDescriptionOverride: ReturnType<typeof import("./hooks").createTodoDescriptionOverrideHook> | null;
     contextWindowMonitor: ReturnType<typeof import("./hooks").createContextWindowMonitorHook> | null;
     preemptiveCompaction: ReturnType<typeof import("./hooks").createPreemptiveCompactionHook> | null;
     sessionRecovery: ReturnType<typeof import("./hooks").createSessionRecoveryHook> | null;

package/dist/features/background-agent/constants.d.ts

@@ -8,6 +8,7 @@ export declare const DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 1800000;
 export declare const DEFAULT_MAX_TOOL_CALLS = 200;
 export declare const DEFAULT_CIRCUIT_BREAKER_WINDOW_SIZE = 20;
 export declare const DEFAULT_CIRCUIT_BREAKER_REPETITION_THRESHOLD_PERCENT = 80;
+export declare const DEFAULT_CIRCUIT_BREAKER_ENABLED = true;
 export declare const MIN_RUNTIME_BEFORE_STALE_MS = 30000;
 export declare const MIN_IDLE_TIME_MS = 5000;
 export declare const POLLING_INTERVAL_MS = 3000;

package/dist/features/background-agent/loop-detector.d.ts

@@ -1,6 +1,7 @@
 import type { BackgroundTaskConfig } from "../../config/schema";
 import type { ToolCallWindow } from "./types";
 export interface CircuitBreakerSettings {
+    enabled: boolean;
     maxToolCalls: number;
     windowSize: number;
     repetitionThresholdPercent: number;
@@ -13,5 +14,6 @@ export interface ToolLoopDetectionResult {
     thresholdPercent?: number;
 }
 export declare function resolveCircuitBreakerSettings(config?: BackgroundTaskConfig): CircuitBreakerSettings;
-export declare function recordToolCall(window: ToolCallWindow | undefined, toolName: string, settings: CircuitBreakerSettings): ToolCallWindow;
+export declare function recordToolCall(window: ToolCallWindow | undefined, toolName: string, settings: CircuitBreakerSettings, toolInput?: Record<string, unknown> | null): ToolCallWindow;
+export declare function createToolCallSignature(toolName: string, toolInput?: Record<string, unknown> | null): string;
 export declare function detectRepetitiveToolUse(window: ToolCallWindow | undefined): ToolLoopDetectionResult;

package/dist/features/background-agent/types.d.ts

@@ -2,7 +2,7 @@ import type { FallbackEntry } from "../../shared/model-requirements";
 import type { SessionPermissionRule } from "../../shared/question-denied-session-permission";
 export type BackgroundTaskStatus = "pending" | "running" | "completed" | "error" | "cancelled" | "interrupt";
 export interface ToolCallWindow {
-    toolNames: string[];
+    toolSignatures: string[];
     windowSize: number;
     thresholdPercent: number;
 }

package/dist/features/builtin-commands/templates/start-work.d.ts

@@ -1 +1 @@
-export declare const START_WORK_TEMPLATE = "You are starting a Sisyphus work session.\n\n## ARGUMENTS\n\n- `/start-work [plan-name] [--worktree <path>]`\n  - `plan-name` (optional): name or partial match of the plan to start\n  - `--worktree <path>` (optional): absolute path to an existing git worktree to work in\n    - If specified and valid: hook pre-sets worktree_path in boulder.json\n    - If specified but invalid: you must run `git worktree add <path> <branch>` first\n    - If omitted: you MUST choose or create a worktree (see Worktree Setup below)\n\n## WHAT TO DO\n\n1. **Find available plans**: Search for Prometheus-generated plan files at `.sisyphus/plans/`\n\n2. **Check for active boulder state**: Read `.sisyphus/boulder.json` if it exists\n\n3. **Decision logic**:\n   - If `.sisyphus/boulder.json` exists AND plan is NOT complete (has unchecked boxes):\n     - **APPEND** current session to session_ids\n     - Continue work on existing plan\n   - If no active plan OR plan is complete:\n     - List available plan files\n     - If ONE plan: auto-select it\n     - If MULTIPLE plans: show list with timestamps, ask user to select\n\n4. **Worktree Setup** (when `worktree_path` not already set in boulder.json):\n   1. `git worktree list --porcelain` \u2014 see available worktrees\n   2. Create: `git worktree add <absolute-path> <branch-or-HEAD>`\n   3. Update boulder.json to add `\"worktree_path\": \"<absolute-path>\"`\n   4. All work happens inside that worktree directory\n\n5. **Create/Update boulder.json**:\n   ```json\n   {\n     \"active_plan\": \"/absolute/path/to/plan.md\",\n     \"started_at\": \"ISO_TIMESTAMP\",\n     \"session_ids\": [\"session_id_1\", \"session_id_2\"],\n     \"plan_name\": \"plan-name\",\n     \"worktree_path\": \"/absolute/path/to/git/worktree\"\n   }\n   ```\n\n6. **Read the plan file** and start executing tasks according to atlas workflow\n\n## OUTPUT FORMAT\n\nWhen listing plans for selection:\n```\nAvailable Work Plans\n\nCurrent Time: {ISO timestamp}\nSession ID: {current session id}\n\n1. [plan-name-1.md] - Modified: {date} - Progress: 3/10 tasks\n2. [plan-name-2.md] - Modified: {date} - Progress: 0/5 tasks\n\nWhich plan would you like to work on? (Enter number or plan name)\n```\n\nWhen resuming existing work:\n```\nResuming Work Session\n\nActive Plan: {plan-name}\nProgress: {completed}/{total} tasks\nSessions: {count} (appending current session)\nWorktree: {worktree_path}\n\nReading plan and continuing from last incomplete task...\n```\n\nWhen auto-selecting single plan:\n```\nStarting Work Session\n\nPlan: {plan-name}\nSession ID: {session_id}\nStarted: {timestamp}\nWorktree: {worktree_path}\n\nReading plan and beginning execution...\n```\n\n## CRITICAL\n\n- The session_id is injected by the hook - use it directly\n- Always update boulder.json BEFORE starting work\n- Always set worktree_path in boulder.json before executing any tasks\n- Read the FULL plan file before delegating any tasks\n- Follow atlas delegation protocols (7-section format)";
+export declare const START_WORK_TEMPLATE = "You are starting a Sisyphus work session.\n\n## ARGUMENTS\n\n- `/start-work [plan-name] [--worktree <path>]`\n  - `plan-name` (optional): name or partial match of the plan to start\n  - `--worktree <path>` (optional): absolute path to an existing git worktree to work in\n    - If specified and valid: hook pre-sets worktree_path in boulder.json\n    - If specified but invalid: you must run `git worktree add <path> <branch>` first\n    - If omitted: work directly in the current project directory (no worktree)\n\n## WHAT TO DO\n\n1. **Find available plans**: Search for Prometheus-generated plan files at `.sisyphus/plans/`\n\n2. **Check for active boulder state**: Read `.sisyphus/boulder.json` if it exists\n\n3. **Decision logic**:\n   - If `.sisyphus/boulder.json` exists AND plan is NOT complete (has unchecked boxes):\n     - **APPEND** current session to session_ids\n     - Continue work on existing plan\n   - If no active plan OR plan is complete:\n     - List available plan files\n     - If ONE plan: auto-select it\n     - If MULTIPLE plans: show list with timestamps, ask user to select\n\n4. **Worktree Setup** (ONLY when `--worktree` was explicitly specified and `worktree_path` not already set in boulder.json):\n   1. `git worktree list --porcelain` \u2014 see available worktrees\n   2. Create: `git worktree add <absolute-path> <branch-or-HEAD>`\n   3. Update boulder.json to add `\"worktree_path\": \"<absolute-path>\"`\n   4. All work happens inside that worktree directory\n\n5. **Create/Update boulder.json**:\n   ```json\n   {\n     \"active_plan\": \"/absolute/path/to/plan.md\",\n     \"started_at\": \"ISO_TIMESTAMP\",\n     \"session_ids\": [\"session_id_1\", \"session_id_2\"],\n     \"plan_name\": \"plan-name\",\n     \"worktree_path\": \"/absolute/path/to/git/worktree\"\n   }\n   ```\n\n6. **Read the plan file** and start executing tasks according to atlas workflow\n\n## OUTPUT FORMAT\n\nWhen listing plans for selection:\n```\nAvailable Work Plans\n\nCurrent Time: {ISO timestamp}\nSession ID: {current session id}\n\n1. [plan-name-1.md] - Modified: {date} - Progress: 3/10 tasks\n2. [plan-name-2.md] - Modified: {date} - Progress: 0/5 tasks\n\nWhich plan would you like to work on? (Enter number or plan name)\n```\n\nWhen resuming existing work:\n```\nResuming Work Session\n\nActive Plan: {plan-name}\nProgress: {completed}/{total} tasks\nSessions: {count} (appending current session)\nWorktree: {worktree_path}\n\nReading plan and continuing from last incomplete task...\n```\n\nWhen auto-selecting single plan:\n```\nStarting Work Session\n\nPlan: {plan-name}\nSession ID: {session_id}\nStarted: {timestamp}\nWorktree: {worktree_path}\n\nReading plan and beginning execution...\n```\n\n## CRITICAL\n\n- The session_id is injected by the hook - use it directly\n- Always update boulder.json BEFORE starting work\n- If worktree_path is set in boulder.json, all work happens inside that worktree directory\n- Read the FULL plan file before delegating any tasks\n- Follow atlas delegation protocols (7-section format)\n\n## TASK BREAKDOWN (MANDATORY)\n\nAfter 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.\n\n**How to break down**:\n- Each plan checkbox item (e.g., `- [ ] Add user authentication`) must be split into concrete, actionable sub-tasks\n- Sub-tasks should be specific enough that each one touches a clear set of files/functions\n- Include: file to modify, what to change, expected behavior, and how to verify\n- 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\n\n**Example breakdown**:\nPlan task: `- [ ] Add rate limiting to API`\n\u2192 Todo items:\n  1. Create `src/middleware/rate-limiter.ts` with sliding window algorithm (max 100 req/min per IP)\n  2. Add RateLimiter middleware to `src/app.ts` router chain, before auth middleware\n  3. Add rate limit headers (X-RateLimit-Limit, X-RateLimit-Remaining) to response in `rate-limiter.ts`\n  4. Add test: verify 429 response after exceeding limit in `src/middleware/rate-limiter.test.ts`\n  5. Add test: verify headers are present on normal responses\n\nRegister these as task/todo items so progress is tracked and visible throughout the session.\n\n## WORKTREE COMPLETION\n\nWhen working in a worktree (`worktree_path` is set in boulder.json) and ALL plan tasks are complete:\n1. Commit all remaining changes in the worktree\n2. Switch to the main working directory (the original repo, NOT the worktree)\n3. Merge the worktree branch into the current branch: `git merge <worktree-branch>`\n4. If merge succeeds, clean up: `git worktree remove <worktree-path>`\n5. Remove the boulder.json state\n\nThis 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).";

package/dist/hooks/index.d.ts

@@ -48,3 +48,4 @@ export { createWriteExistingFileGuardHook } from "./write-existing-file-guard";
 export { createHashlineReadEnhancerHook } from "./hashline-read-enhancer";
 export { createJsonErrorRecoveryHook, JSON_ERROR_TOOL_EXCLUDE_LIST, JSON_ERROR_PATTERNS, JSON_ERROR_REMINDER } from "./json-error-recovery";
 export { createReadImageResizerHook } from "./read-image-resizer";
+export { createTodoDescriptionOverrideHook } from "./todo-description-override";

package/dist/hooks/todo-description-override/description.d.ts

@@ -0,0 +1 @@
+export declare const TODOWRITE_DESCRIPTION = "Use this tool to create and manage a structured task list for tracking progress on multi-step work.\n\n## Todo Format (MANDATORY)\n\nEach todo title MUST encode four elements: WHERE, WHY, HOW, and EXPECTED RESULT.\n\nFormat: \"[WHERE] [HOW] to [WHY] \u2014 expect [RESULT]\"\n\nGOOD:\n- \"src/utils/validation.ts: Add validateEmail() for input sanitization \u2014 returns boolean\"\n- \"UserService.create(): Call validateEmail() before DB insert \u2014 rejects invalid emails with 400\"\n- \"validation.test.ts: Add test for missing @ sign \u2014 expect validateEmail('foo') to return false\"\n\nBAD:\n- \"Implement email validation\" (where? how? what result?)\n- \"Add dark mode\" (this is a feature, not a todo)\n- \"Fix auth\" (what file? what changes? what's expected?)\n\n## Granularity Rules\n\nEach todo MUST be a single atomic action completable in 1-3 tool calls. If it needs more, split it.\n\n**Size test**: Can you complete this todo by editing one file or running one command? If not, it's too big.\n\n## Task Management\n- One in_progress at a time. Complete it before starting the next.\n- Mark completed immediately after finishing each item.\n- Skip this tool for single trivial tasks (one-step, obvious action).";

package/dist/hooks/todo-description-override/hook.d.ts

@@ -0,0 +1,8 @@
+export declare function createTodoDescriptionOverrideHook(): {
+    "tool.definition": (input: {
+        toolID: string;
+    }, output: {
+        description: string;
+        parameters: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/todo-description-override/index.d.ts

@@ -0,0 +1 @@
+export { createTodoDescriptionOverrideHook } from "./hook";

package/dist/index.js

@@ -17584,120 +17584,142 @@ 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 createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDir) {
+  function getCacheFilePath(filename) {
+    return join9(getCacheDir2(), filename);
   }
-}
-function readConnectedProvidersCache() {
-  const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
-  if (!existsSync8(cacheFile)) {
-    log("[connected-providers-cache] Cache file not found", { cacheFile });
-    return null;
+  function ensureCacheDir2() {
+    const cacheDir = getCacheDir2();
+    if (!existsSync8(cacheDir)) {
+      mkdirSync2(cacheDir, { recursive: true });
+    }
   }
-  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 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 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));
+      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() {
+    const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
+    if (!existsSync8(cacheFile)) {
+      log("[connected-providers-cache] Provider-models cache file not found", { cacheFile });
+      return null;
+    }
+    try {
+      const content = readFileSync4(cacheFile, "utf-8");
+      const data = JSON.parse(content);
+      log("[connected-providers-cache] Read provider-models cache", {
+        providerCount: Object.keys(data.models).length,
+        updatedAt: data.updatedAt
+      });
+      return data;
+    } catch (err) {
+      log("[connected-providers-cache] Error reading provider-models cache", { error: String(err) });
+      return null;
+    }
   }
-}
-function hasProviderModelsCache() {
-  const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
-  return existsSync8(cacheFile);
-}
-function 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));
+      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();
@@ -43673,6 +43695,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 +43934,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,6 +47542,7 @@ 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()
@@ -47712,7 +47741,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 +49145,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 +49162,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 +49224,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
@@ -55062,6 +55124,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) {
@@ -77406,6 +77508,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 +77520,8 @@ function createToolGuardHooks(args) {
     writeExistingFileGuard,
     hashlineReadEnhancer,
     jsonErrorRecovery,
-    readImageResizer
+    readImageResizer,
+    todoDescriptionOverride
   };
 }
 
@@ -77946,6 +78050,7 @@ 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_ENABLED = true;
 var MIN_RUNTIME_BEFORE_STALE_MS = 30000;
 var MIN_IDLE_TIME_MS = 5000;
 var POLLING_INTERVAL_MS = 3000;
@@ -78500,27 +78605,52 @@ 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
   };
 }
-function recordToolCall(window, toolName, settings) {
-  const previous = window?.toolNames ?? [];
-  const toolNames = [...previous, toolName].slice(-settings.windowSize);
+function recordToolCall(window, toolName, settings, toolInput) {
+  const previous = window?.toolSignatures ?? [];
+  const signature = createToolCallSignature(toolName, toolInput);
+  const toolSignatures = [...previous, signature].slice(-settings.windowSize);
   return {
-    toolNames,
+    toolSignatures,
     windowSize: settings.windowSize,
     thresholdPercent: settings.repetitionThresholdPercent
   };
 }
+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]);
+  }
+  return sorted;
+}
+function createToolCallSignature(toolName, toolInput) {
+  if (toolInput === undefined || toolInput === null) {
+    return toolName;
+  }
+  if (Object.keys(toolInput).length === 0) {
+    return toolName;
+  }
+  return `${toolName}::${JSON.stringify(sortObject2(toolInput))}`;
+}
 function detectRepetitiveToolUse(window) {
-  if (!window || window.toolNames.length === 0) {
+  if (!window || window.toolSignatures.length === 0) {
     return { triggered: false };
   }
   const counts = new Map;
-  for (const toolName of window.toolNames) {
-    counts.set(toolName, (counts.get(toolName) ?? 0) + 1);
+  for (const signature of window.toolSignatures) {
+    counts.set(signature, (counts.get(signature) ?? 0) + 1);
   }
   let repeatedTool;
   let repeatedCount = 0;
@@ -78530,7 +78660,7 @@ function detectRepetitiveToolUse(window) {
       repeatedCount = count;
     }
   }
-  const sampleSize = window.toolNames.length;
+  const sampleSize = window.toolSignatures.length;
   const minimumSampleSize = Math.min(window.windowSize, Math.ceil(window.windowSize * window.thresholdPercent / 100));
   if (sampleSize < minimumSampleSize) {
     return { triggered: false };
@@ -78541,7 +78671,7 @@ function detectRepetitiveToolUse(window) {
   }
   return {
     triggered: true,
-    toolName: repeatedTool,
+    toolName: repeatedTool.split("::")[0],
     repeatedCount,
     sampleSize,
     thresholdPercent: window.thresholdPercent
@@ -79247,23 +79377,25 @@ class BackgroundManager {
         task.progress.lastTool = partInfo.tool;
         const circuitBreaker = 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: 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;
+            }
           }
         }
         const maxToolCalls = circuitBreaker.maxToolCalls;
@@ -97707,7 +97839,10 @@ function createPluginInterface(args) {
     "tool.execute.after": createToolExecuteAfterHandler3({
       ctx,
       hooks: hooks2
-    })
+    }),
+    "tool.definition": async (input, output) => {
+      await hooks2.todoDescriptionOverride?.["tool.definition"]?.(input, output);
+    }
   };
 }
 

package/dist/oh-my-opencode.schema.json

@@ -3708,6 +3708,9 @@
         "circuitBreaker": {
           "type": "object",
           "properties": {
+            "enabled": {
+              "type": "boolean"
+            },
             "maxToolCalls": {
               "type": "integer",
               "minimum": 10,

package/dist/plugin/hooks/create-core-hooks.d.ts

@@ -23,6 +23,7 @@ export declare function createCoreHooks(args: {
     hashlineReadEnhancer: ReturnType<typeof import("../../hooks").createHashlineReadEnhancerHook> | null;
     jsonErrorRecovery: ReturnType<typeof import("../../hooks").createJsonErrorRecoveryHook> | null;
     readImageResizer: ReturnType<typeof import("../../hooks").createReadImageResizerHook> | null;
+    todoDescriptionOverride: ReturnType<typeof import("../../hooks").createTodoDescriptionOverrideHook> | null;
     contextWindowMonitor: ReturnType<typeof import("../../hooks").createContextWindowMonitorHook> | null;
     preemptiveCompaction: ReturnType<typeof import("../../hooks").createPreemptiveCompactionHook> | null;
     sessionRecovery: ReturnType<typeof import("../../hooks").createSessionRecoveryHook> | null;

package/dist/plugin/hooks/create-tool-guard-hooks.d.ts

@@ -1,7 +1,7 @@
 import type { HookName, OhMyOpenCodeConfig } from "../../config";
 import type { ModelCacheState } from "../../plugin-state";
 import type { PluginContext } from "../types";
-import { createCommentCheckerHooks, createToolOutputTruncatorHook, createDirectoryAgentsInjectorHook, createDirectoryReadmeInjectorHook, createEmptyTaskResponseDetectorHook, createRulesInjectorHook, createTasksTodowriteDisablerHook, createWriteExistingFileGuardHook, createHashlineReadEnhancerHook, createReadImageResizerHook, createJsonErrorRecoveryHook } from "../../hooks";
+import { createCommentCheckerHooks, createToolOutputTruncatorHook, createDirectoryAgentsInjectorHook, createDirectoryReadmeInjectorHook, createEmptyTaskResponseDetectorHook, createRulesInjectorHook, createTasksTodowriteDisablerHook, createWriteExistingFileGuardHook, createHashlineReadEnhancerHook, createReadImageResizerHook, createJsonErrorRecoveryHook, createTodoDescriptionOverrideHook } from "../../hooks";
 export type ToolGuardHooks = {
     commentChecker: ReturnType<typeof createCommentCheckerHooks> | null;
     toolOutputTruncator: ReturnType<typeof createToolOutputTruncatorHook> | null;
@@ -14,6 +14,7 @@ export type ToolGuardHooks = {
     hashlineReadEnhancer: ReturnType<typeof createHashlineReadEnhancerHook> | null;
     jsonErrorRecovery: ReturnType<typeof createJsonErrorRecoveryHook> | null;
     readImageResizer: ReturnType<typeof createReadImageResizerHook> | null;
+    todoDescriptionOverride: ReturnType<typeof createTodoDescriptionOverrideHook> | null;
 };
 export declare function createToolGuardHooks(args: {
     ctx: PluginContext;

package/dist/shared/connected-providers-cache.d.ts

@@ -10,36 +10,33 @@ interface ProviderModelsCache {
     connected: string[];
     updatedAt: string;
 }
-/**
- * Read the connected providers cache.
- * Returns the list of connected provider IDs, or null if cache doesn't exist.
- */
-export declare function readConnectedProvidersCache(): string[] | null;
-/**
- * Check if connected providers cache exists.
- */
-export declare function hasConnectedProvidersCache(): boolean;
-/**
- * Read the provider-models cache.
- * Returns the cache data, or null if cache doesn't exist.
- */
-export declare function readProviderModelsCache(): ProviderModelsCache | null;
-/**
- * Check if provider-models cache exists.
- */
-export declare function hasProviderModelsCache(): boolean;
-/**
- * Write the provider-models cache.
- */
-export declare function writeProviderModelsCache(data: {
+export declare function createConnectedProvidersCacheStore(getCacheDir?: () => string): {
+    readConnectedProvidersCache: () => string[] | null;
+    hasConnectedProvidersCache: () => boolean;
+    readProviderModelsCache: () => ProviderModelsCache | null;
+    hasProviderModelsCache: () => boolean;
+    writeProviderModelsCache: (data: {
+        models: Record<string, string[]>;
+        connected: string[];
+    }) => void;
+    updateConnectedProvidersCache: (client: {
+        provider?: {
+            list?: () => Promise<{
+                data?: {
+                    connected?: string[];
+                    all?: Array<{
+                        id: string;
+                        models?: Record<string, unknown>;
+                    }>;
+                };
+            }>;
+        };
+    }) => Promise<void>;
+};
+export declare const readConnectedProvidersCache: () => string[] | null, hasConnectedProvidersCache: () => boolean, readProviderModelsCache: () => ProviderModelsCache | null, hasProviderModelsCache: () => boolean, writeProviderModelsCache: (data: {
     models: Record<string, string[]>;
     connected: string[];
-}): void;
-/**
- * Update the connected providers cache by fetching from the client.
- * Also updates the provider-models cache with model lists per provider.
- */
-export declare function updateConnectedProvidersCache(client: {
+}) => void, updateConnectedProvidersCache: (client: {
     provider?: {
         list?: () => Promise<{
             data?: {
@@ -51,5 +48,5 @@ export declare function updateConnectedProvidersCache(client: {
             };
         }>;
     };
-}): Promise<void>;
+}) => Promise<void>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "3.12.0",
+  "version": "3.12.1",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -76,17 +76,17 @@
     "typescript": "^5.7.3"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "3.12.0",
-    "oh-my-opencode-darwin-x64": "3.12.0",
-    "oh-my-opencode-darwin-x64-baseline": "3.12.0",
-    "oh-my-opencode-linux-arm64": "3.12.0",
-    "oh-my-opencode-linux-arm64-musl": "3.12.0",
-    "oh-my-opencode-linux-x64": "3.12.0",
-    "oh-my-opencode-linux-x64-baseline": "3.12.0",
-    "oh-my-opencode-linux-x64-musl": "3.12.0",
-    "oh-my-opencode-linux-x64-musl-baseline": "3.12.0",
-    "oh-my-opencode-windows-x64": "3.12.0",
-    "oh-my-opencode-windows-x64-baseline": "3.12.0"
+    "oh-my-opencode-darwin-arm64": "3.12.1",
+    "oh-my-opencode-darwin-x64": "3.12.1",
+    "oh-my-opencode-darwin-x64-baseline": "3.12.1",
+    "oh-my-opencode-linux-arm64": "3.12.1",
+    "oh-my-opencode-linux-arm64-musl": "3.12.1",
+    "oh-my-opencode-linux-x64": "3.12.1",
+    "oh-my-opencode-linux-x64-baseline": "3.12.1",
+    "oh-my-opencode-linux-x64-musl": "3.12.1",
+    "oh-my-opencode-linux-x64-musl-baseline": "3.12.1",
+    "oh-my-opencode-windows-x64": "3.12.1",
+    "oh-my-opencode-windows-x64-baseline": "3.12.1"
   },
   "overrides": {
     "@opencode-ai/sdk": "^1.2.24"