oh-my-opencode 3.12.1 → 3.12.2

package/dist/cli/index.js

@@ -4920,17 +4920,40 @@ var init_file_reference_resolver = () => {};
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
+function flush() {
+  if (buffer.length === 0)
+    return;
+  const data = buffer.join("");
+  buffer = [];
+  try {
+    fs.appendFileSync(logFile, data);
+  } catch {}
+}
+function scheduleFlush() {
+  if (flushTimer)
+    return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flush();
+  }, FLUSH_INTERVAL_MS);
+}
 function log(message, data) {
   try {
     const timestamp2 = new Date().toISOString();
     const logEntry = `[${timestamp2}] ${message} ${data ? JSON.stringify(data) : ""}
 `;
-    fs.appendFileSync(logFile, logEntry);
+    buffer.push(logEntry);
+    if (buffer.length >= BUFFER_SIZE_LIMIT) {
+      flush();
+    } else {
+      scheduleFlush();
+    }
   } catch {}
 }
-var logFile;
+var logFile, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50;
 var init_logger = __esm(() => {
   logFile = path.join(os.tmpdir(), "oh-my-opencode.log");
+  buffer = [];
 });
 
 // src/shared/deep-merge.ts
@@ -4974,6 +4997,12 @@ var init_snake_case = __esm(() => {
 
 // src/shared/tool-name.ts
 var init_tool_name = () => {};
+
+// src/shared/pattern-matcher.ts
+var regexCache;
+var init_pattern_matcher = __esm(() => {
+  regexCache = new Map;
+});
 // src/shared/file-utils.ts
 var init_file_utils = () => {};
 
@@ -6623,6 +6652,8 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
   function getCacheFilePath(filename) {
     return join4(getCacheDir2(), filename);
   }
+  let memConnected;
+  let memProviderModels;
   function ensureCacheDir() {
     const cacheDir = getCacheDir2();
     if (!existsSync3(cacheDir)) {
@@ -6630,18 +6661,23 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
     }
   }
   function readConnectedProvidersCache() {
+    if (memConnected !== undefined)
+      return memConnected;
     const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
     if (!existsSync3(cacheFile)) {
       log("[connected-providers-cache] Cache file not found", { cacheFile });
+      memConnected = null;
       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 });
+      memConnected = data.connected;
       return data.connected;
     } catch (err) {
       log("[connected-providers-cache] Error reading cache", { error: String(err) });
+      memConnected = null;
       return null;
     }
   }
@@ -6658,15 +6694,19 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
     };
     try {
       writeFileSync2(cacheFile, JSON.stringify(data, null, 2));
+      memConnected = connected;
       log("[connected-providers-cache] Cache written", { count: connected.length });
     } catch (err) {
       log("[connected-providers-cache] Error writing cache", { error: String(err) });
     }
   }
   function readProviderModelsCache() {
+    if (memProviderModels !== undefined)
+      return memProviderModels;
     const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE);
     if (!existsSync3(cacheFile)) {
       log("[connected-providers-cache] Provider-models cache file not found", { cacheFile });
+      memProviderModels = null;
       return null;
     }
     try {
@@ -6676,9 +6716,11 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
         providerCount: Object.keys(data.models).length,
         updatedAt: data.updatedAt
       });
+      memProviderModels = data;
       return data;
     } catch (err) {
       log("[connected-providers-cache] Error reading provider-models cache", { error: String(err) });
+      memProviderModels = null;
       return null;
     }
   }
@@ -6695,6 +6737,7 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
     };
     try {
       writeFileSync2(cacheFile, JSON.stringify(cacheData, null, 2));
+      memProviderModels = cacheData;
       log("[connected-providers-cache] Provider-models cache written", {
         providerCount: Object.keys(data.models).length
       });
@@ -7127,6 +7170,7 @@ var init_shared = __esm(() => {
   init_logger();
   init_snake_case();
   init_tool_name();
+  init_pattern_matcher();
   init_deep_merge();
   init_file_utils();
   init_dynamic_truncator();
@@ -8897,7 +8941,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.12.1",
+  version: "3.12.2",
   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",
@@ -8973,17 +9017,17 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "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"
+    "oh-my-opencode-darwin-arm64": "3.12.2",
+    "oh-my-opencode-darwin-x64": "3.12.2",
+    "oh-my-opencode-darwin-x64-baseline": "3.12.2",
+    "oh-my-opencode-linux-arm64": "3.12.2",
+    "oh-my-opencode-linux-arm64-musl": "3.12.2",
+    "oh-my-opencode-linux-x64": "3.12.2",
+    "oh-my-opencode-linux-x64-baseline": "3.12.2",
+    "oh-my-opencode-linux-x64-musl": "3.12.2",
+    "oh-my-opencode-linux-x64-musl-baseline": "3.12.2",
+    "oh-my-opencode-windows-x64": "3.12.2",
+    "oh-my-opencode-windows-x64-baseline": "3.12.2"
   },
   overrides: {
     "@opencode-ai/sdk": "^1.2.24"
@@ -10352,24 +10396,24 @@ function writePaddedText(text, atLineStart) {
     return { output: text, atLineStart: text.endsWith(`
 `) };
   }
-  let output = "";
+  const parts = [];
   let lineStart = atLineStart;
   for (let i2 = 0;i2 < text.length; i2++) {
     const ch = text[i2];
     if (lineStart) {
-      output += "  ";
+      parts.push("  ");
       lineStart = false;
     }
     if (ch === `
 `) {
-      output += `  
-`;
+      parts.push(`  
+`);
       lineStart = true;
       continue;
     }
-    output += ch;
+    parts.push(ch);
   }
-  return { output, atLineStart: lineStart };
+  return { output: parts.join(""), atLineStart: lineStart };
 }
 function colorizeWithProfileColor(text, hexColor) {
   if (!hexColor)
@@ -24364,8 +24408,7 @@ var BabysittingConfigSchema = exports_external.object({
 var CircuitBreakerConfigSchema = exports_external.object({
   enabled: exports_external.boolean().optional(),
   maxToolCalls: exports_external.number().int().min(10).optional(),
-  windowSize: exports_external.number().int().min(5).optional(),
-  repetitionThresholdPercent: exports_external.number().gt(0).max(100).optional()
+  consecutiveThreshold: exports_external.number().int().min(5).optional()
 });
 var BackgroundTaskConfigSchema = exports_external.object({
   defaultConcurrency: exports_external.number().min(1).optional(),
@@ -24863,7 +24906,7 @@ var createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseVa
         if (!response.body)
           throw new Error("No body in SSE response");
         const reader = response.body.pipeThrough(new TextDecoderStream).getReader();
-        let buffer = "";
+        let buffer2 = "";
         const abortHandler = () => {
           try {
             reader.cancel();
@@ -24875,11 +24918,11 @@ var createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseVa
             const { done, value } = await reader.read();
             if (done)
               break;
-            buffer += value;
-            const chunks = buffer.split(`
+            buffer2 += value;
+            const chunks = buffer2.split(`
 
 `);
-            buffer = chunks.pop() ?? "";
+            buffer2 = chunks.pop() ?? "";
             for (const chunk of chunks) {
               const lines = chunk.split(`
 `);

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

@@ -12,8 +12,7 @@ export declare const BackgroundTaskConfigSchema: z.ZodObject<{
     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>;
+        consecutiveThreshold: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>;

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

@@ -1345,8 +1345,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         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>;
+            consecutiveThreshold: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     notification: z.ZodOptional<z.ZodObject<{

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

@@ -6,8 +6,7 @@ export declare const MIN_STABILITY_TIME_MS: number;
 export declare const DEFAULT_STALE_TIMEOUT_MS = 1200000;
 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_CONSECUTIVE_THRESHOLD = 20;
 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;

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

@@ -3,15 +3,12 @@ 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 declare function resolveCircuitBreakerSettings(config?: BackgroundTaskConfig): CircuitBreakerSettings;
 export declare function recordToolCall(window: ToolCallWindow | undefined, toolName: string, settings: CircuitBreakerSettings, toolInput?: Record<string, unknown> | null): ToolCallWindow;

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

@@ -45,6 +45,7 @@ export declare class BackgroundManager {
     private preStartDescendantReservations;
     private enableParentSessionNotifications;
     readonly taskHistory: TaskHistory;
+    private cachedCircuitBreakerSettings?;
     constructor(ctx: PluginInput, config?: BackgroundTaskConfig, options?: {
         tmuxConfig?: TmuxConfig;
         onSubagentSessionCreated?: OnSubagentSessionCreated;

package/dist/features/background-agent/session-status-classifier.d.ts

@@ -0,0 +1,2 @@
+export declare function isActiveSessionStatus(type: string): boolean;
+export declare function isTerminalSessionStatus(type: string): boolean;

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

@@ -2,15 +2,15 @@ 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 {
-    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;