@skj1724/oh-my-opencode 3.19.4 → 3.19.6

package/dist/index.js

@@ -46,6 +46,84 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/shared/fileio-monitor.ts
+import { readdirSync, readFileSync, writeFileSync, existsSync } from "fs";
+import { relative } from "path";
+import { cwd } from "process";
+function summarize(path) {
+  let result;
+  try {
+    result = relative(cwd(), path);
+  } catch {
+    result = path;
+  }
+  if (result.length > MAX_PATH_LENGTH) {
+    return result.slice(0, MAX_PATH_LENGTH - 3) + "...";
+  }
+  return result;
+}
+function setFileIOMonitor(monitor) {
+  globalMonitor = monitor;
+}
+function getFileIOMonitor() {
+  return globalMonitor;
+}
+function createFileIOMonitor(tracer) {
+  return {
+    readdirSync(path) {
+      if (!tracer.isEnabled()) {
+        return readdirSync(path);
+      }
+      const start = performance.now();
+      try {
+        return readdirSync(path);
+      } finally {
+        const durationMs = performance.now() - start;
+        tracer.recordFileIO("readdirSync", summarize(path), durationMs);
+      }
+    },
+    readFileSync(path, options) {
+      if (!tracer.isEnabled()) {
+        return readFileSync(path, options);
+      }
+      const start = performance.now();
+      try {
+        return readFileSync(path, options);
+      } finally {
+        const durationMs = performance.now() - start;
+        tracer.recordFileIO("readFileSync", summarize(path), durationMs);
+      }
+    },
+    writeFileSync(path, data, options) {
+      if (!tracer.isEnabled()) {
+        writeFileSync(path, data, options);
+        return;
+      }
+      const start = performance.now();
+      try {
+        writeFileSync(path, data, options);
+      } finally {
+        const durationMs = performance.now() - start;
+        tracer.recordFileIO("writeFileSync", summarize(path), durationMs);
+      }
+    },
+    existsSync(path) {
+      if (!tracer.isEnabled()) {
+        return existsSync(path);
+      }
+      const start = performance.now();
+      try {
+        return existsSync(path);
+      } finally {
+        const durationMs = performance.now() - start;
+        tracer.recordFileIO("existsSync", summarize(path), durationMs);
+      }
+    }
+  };
+}
+var MAX_PATH_LENGTH = 120, globalMonitor = null;
+var init_fileio_monitor = () => {};
+
 // src/shared/data-path.ts
 import * as path from "path";
 import * as os from "os";
@@ -2767,17 +2845,17 @@ var init_frontmatter = __esm(() => {
 import { spawn as spawn2 } from "child_process";
 import { exec } from "child_process";
 import { promisify } from "util";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { homedir as homedir2 } from "os";
 function getHomeDir() {
   return process.env.HOME || process.env.USERPROFILE || homedir2();
 }
 function findShellPath(defaultPaths, customPath) {
-  if (customPath && existsSync4(customPath)) {
+  if (customPath && existsSync5(customPath)) {
     return customPath;
   }
   for (const path3 of defaultPaths) {
-    if (existsSync4(path3)) {
+    if (existsSync5(path3)) {
       return path3;
     }
   }
@@ -2789,9 +2867,9 @@ function findZshPath(customZshPath) {
 function findBashPath() {
   return findShellPath(DEFAULT_BASH_PATHS);
 }
-async function executeHookCommand(command, stdin, cwd, options) {
+async function executeHookCommand(command, stdin, cwd2, options) {
   const home = getHomeDir();
-  let expandedCommand = command.replace(/^~(?=\/|$)/g, home).replace(/\s~(?=\/)/g, ` ${home}`).replace(/\$CLAUDE_PROJECT_DIR/g, cwd).replace(/\$\{CLAUDE_PROJECT_DIR\}/g, cwd);
+  let expandedCommand = command.replace(/^~(?=\/|$)/g, home).replace(/\s~(?=\/)/g, ` ${home}`).replace(/\$CLAUDE_PROJECT_DIR/g, cwd2).replace(/\$\{CLAUDE_PROJECT_DIR\}/g, cwd2);
   let finalCommand = expandedCommand;
   if (options?.forceZsh) {
     const zshPath = findZshPath(options.zshPath);
@@ -2807,9 +2885,9 @@ async function executeHookCommand(command, stdin, cwd, options) {
   }
   return new Promise((resolve) => {
     const proc = spawn2(finalCommand, {
-      cwd,
+      cwd: cwd2,
       shell: true,
-      env: { ...process.env, HOME: home, CLAUDE_PROJECT_DIR: cwd }
+      env: { ...process.env, HOME: home, CLAUDE_PROJECT_DIR: cwd2 }
     });
     let stdout = "";
     let stderr = "";
@@ -2912,7 +2990,7 @@ var init_command_executor = __esm(() => {
 });
 
 // src/shared/file-reference-resolver.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3, statSync } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4, statSync } from "fs";
 import { join as join8, isAbsolute } from "path";
 function findFileReferences(text) {
   const matches = [];
@@ -2928,24 +3006,24 @@ function findFileReferences(text) {
   }
   return matches;
 }
-function resolveFilePath(filePath, cwd) {
+function resolveFilePath(filePath, cwd2) {
   if (isAbsolute(filePath)) {
     return filePath;
   }
-  return join8(cwd, filePath);
+  return join8(cwd2, filePath);
 }
 function readFileContent(resolvedPath) {
-  if (!existsSync5(resolvedPath)) {
+  if (!existsSync6(resolvedPath)) {
     return `[file not found: ${resolvedPath}]`;
   }
   const stat = statSync(resolvedPath);
   if (stat.isDirectory()) {
     return `[cannot read directory: ${resolvedPath}]`;
   }
-  const content = readFileSync3(resolvedPath, "utf-8");
+  const content = readFileSync4(resolvedPath, "utf-8");
   return content;
 }
-async function resolveFileReferencesInText(text, cwd = process.cwd(), depth = 0, maxDepth = 3) {
+async function resolveFileReferencesInText(text, cwd2 = process.cwd(), depth = 0, maxDepth = 3) {
   if (depth >= maxDepth) {
     return text;
   }
@@ -2955,7 +3033,7 @@ async function resolveFileReferencesInText(text, cwd = process.cwd(), depth = 0,
   }
   const replacements = new Map;
   for (const match of matches) {
-    const resolvedPath = resolveFilePath(match.filePath, cwd);
+    const resolvedPath = resolveFilePath(match.filePath, cwd2);
     const content = readFileContent(resolvedPath);
     replacements.set(match.fullMatch, content);
   }
@@ -2964,7 +3042,7 @@ async function resolveFileReferencesInText(text, cwd = process.cwd(), depth = 0,
     resolved = resolved.split(pattern).join(replacement);
   }
   if (findFileReferences(resolved).length > 0 && depth + 1 < maxDepth) {
-    return resolveFileReferencesInText(resolved, cwd, depth + 1, maxDepth);
+    return resolveFileReferencesInText(resolved, cwd2, depth + 1, maxDepth);
   }
   return resolved;
 }
@@ -4138,7 +4216,7 @@ var init_main = __esm(() => {
 });
 
 // src/shared/jsonc-parser.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
 function parseJsonc(content) {
   const errors = [];
   const result = parse2(content, errors, {
@@ -4169,10 +4247,10 @@ function parseJsoncSafe(content) {
 function detectConfigFile(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
-  if (existsSync6(jsoncPath)) {
+  if (existsSync7(jsoncPath)) {
     return { format: "jsonc", path: jsoncPath };
   }
-  if (existsSync6(jsonPath)) {
+  if (existsSync7(jsonPath)) {
     return { format: "json", path: jsonPath };
   }
   return { format: "none", path: jsonPath };
@@ -4318,7 +4396,7 @@ var init_migration = __esm(() => {
 });
 
 // src/shared/opencode-config-dir.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join10, resolve as resolve2 } from "path";
 function isDevBuild(version) {
@@ -4350,13 +4428,13 @@ function getCliConfigDir() {
   if (process.platform === "win32") {
     const crossPlatformDir = join10(homedir4(), ".config", "opencode");
     const crossPlatformConfig = join10(crossPlatformDir, "opencode.json");
-    if (existsSync7(crossPlatformConfig)) {
+    if (existsSync8(crossPlatformConfig)) {
       return crossPlatformDir;
     }
     const appData = process.env.APPDATA || join10(homedir4(), "AppData", "Roaming");
     const appdataDir = join10(appData, "opencode");
     const appdataConfig = join10(appdataDir, "opencode.json");
-    if (existsSync7(appdataConfig)) {
+    if (existsSync8(appdataConfig)) {
       return appdataDir;
     }
     return crossPlatformDir;
@@ -4375,7 +4453,7 @@ function getOpenCodeConfigDir(options) {
     const legacyDir = getCliConfigDir();
     const legacyConfig = join10(legacyDir, "opencode.json");
     const legacyConfigC = join10(legacyDir, "opencode.jsonc");
-    if (existsSync7(legacyConfig) || existsSync7(legacyConfigC)) {
+    if (existsSync8(legacyConfig) || existsSync8(legacyConfigC)) {
       return legacyDir;
     }
   }
@@ -4853,7 +4931,7 @@ var init_model_requirements = __esm(() => {
 });
 
 // src/shared/model-availability.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join12 } from "path";
 function normalizeModelName(name) {
@@ -4908,12 +4986,12 @@ async function fetchAvailableModels(_client) {
   const modelSet = new Set;
   const cacheFile = join12(getOpenCodeCacheDir(), "models.json");
   log("[fetchAvailableModels] reading cache file", { cacheFile });
-  if (!existsSync9(cacheFile)) {
+  if (!existsSync10(cacheFile)) {
     log("[fetchAvailableModels] cache file not found, returning empty set");
     return modelSet;
   }
   try {
-    const content = readFileSync6(cacheFile, "utf-8");
+    const content = readFileSync7(cacheFile, "utf-8");
     const data = JSON.parse(content);
     const providerIds = Object.keys(data);
     log("[fetchAvailableModels] providers found", { count: providerIds.length, providers: providerIds.slice(0, 10) });
@@ -4936,7 +5014,7 @@ async function fetchAvailableModels(_client) {
 }
 function isModelCacheAvailable() {
   const cacheFile = join12(getOpenCodeCacheDir(), "models.json");
-  return existsSync9(cacheFile);
+  return existsSync10(cacheFile);
 }
 var cachedModels = null;
 var init_model_availability = __esm(() => {
@@ -5033,6 +5111,216 @@ class PerfTimer {
   }
 }
 
+// src/shared/perf-tracer.ts
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync11 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join13 } from "path";
+
+class PerfTracer {
+  buffer = [];
+  enabled;
+  outputDir;
+  slowThreshold;
+  eventCount = 0;
+  memorySnapshotInterval;
+  constructor(config) {
+    this.enabled = config.enabled;
+    this.outputDir = config.outputDir ?? join13(tmpdir2(), "oh-my-opencode-perf");
+    this.slowThreshold = config.slowThreshold ?? 100;
+    this.memorySnapshotInterval = config.memorySnapshotInterval ?? 5;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  isSlowHook(durationMs) {
+    return durationMs > this.slowThreshold;
+  }
+  recordHook(pipeline, hook, durationMs, sessionID, tool, error) {
+    if (!this.enabled)
+      return;
+    const span = {
+      t: new Date().toISOString(),
+      type: "hook",
+      pipeline,
+      hook,
+      durationMs,
+      sessionID
+    };
+    if (tool !== undefined)
+      span.tool = tool;
+    if (error !== undefined)
+      span.error = error;
+    this.buffer.push(span);
+  }
+  recordPipeline(name, totalDurationMs, hookCount, sessionID) {
+    if (!this.enabled)
+      return;
+    this.buffer.push({
+      t: new Date().toISOString(),
+      type: "pipeline",
+      name,
+      totalDurationMs,
+      hookCount,
+      sessionID
+    });
+  }
+  recordApiCall(method, durationMs, sessionID, messageCount, error) {
+    if (!this.enabled)
+      return;
+    const span = {
+      t: new Date().toISOString(),
+      type: "api",
+      method,
+      durationMs,
+      sessionID
+    };
+    if (messageCount !== undefined)
+      span.messageCount = messageCount;
+    if (error !== undefined)
+      span.error = error;
+    this.buffer.push(span);
+  }
+  recordFileIO(operation, path4, durationMs, fileCount) {
+    if (!this.enabled)
+      return;
+    const span = {
+      t: new Date().toISOString(),
+      type: "fileio",
+      operation,
+      path: path4,
+      durationMs
+    };
+    if (fileCount !== undefined)
+      span.fileCount = fileCount;
+    this.buffer.push(span);
+  }
+  recordPolling(durationMs, taskCount, sessionCount) {
+    if (!this.enabled)
+      return;
+    this.buffer.push({
+      t: new Date().toISOString(),
+      type: "polling",
+      durationMs,
+      taskCount,
+      sessionCount
+    });
+  }
+  snapshotMemory(trigger, mapSizes) {
+    if (!this.enabled)
+      return;
+    this.eventCount++;
+    if (this.eventCount % this.memorySnapshotInterval !== 0)
+      return;
+    this.buffer.push({
+      t: new Date().toISOString(),
+      type: "memory",
+      trigger,
+      mapSizes
+    });
+  }
+  flush() {
+    if (this.buffer.length === 0)
+      return;
+    if (!existsSync11(this.outputDir)) {
+      mkdirSync3(this.outputDir, { recursive: true });
+    }
+    const date = new Date().toISOString().slice(0, 10);
+    const filePath = join13(this.outputDir, `${date}.jsonl`);
+    let output = "";
+    for (const span of this.buffer) {
+      output += JSON.stringify(span) + `
+`;
+    }
+    appendFileSync2(filePath, output);
+    this.buffer = [];
+  }
+  reset() {
+    this.buffer = [];
+    this.eventCount = 0;
+  }
+}
+var init_perf_tracer = () => {};
+
+// src/shared/windows-reserved-names.ts
+import { existsSync as existsSync12, readdirSync as readdirSync5 } from "fs";
+import { join as join14 } from "path";
+function scanForReservedNames(directory, maxDepth = 2) {
+  if (!existsSync12(directory))
+    return [];
+  const found = [];
+  _scan(directory, 0, maxDepth, found);
+  return found;
+}
+function _scan(dir, depth, maxDepth, found) {
+  if (depth > maxDepth)
+    return;
+  let entries;
+  try {
+    entries = readdirSync5(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const upper = name.toUpperCase();
+    const baseName = upper.split(".")[0] ?? "";
+    if (WIN_RESERVED_NAMES.has(upper) || WIN_RESERVED_NAMES.has(baseName)) {
+      found.push(join14(dir, name));
+    }
+    const fullPath = join14(dir, name);
+    try {
+      const stat = existsSync12(fullPath);
+      if (stat && depth < maxDepth) {
+        _scan(fullPath, depth + 1, maxDepth, found);
+      }
+    } catch {}
+  }
+}
+function formatReservedNamesWarning(found) {
+  const lines = [
+    "",
+    "\u26A0\uFE0F  WINDOWS RESERVED DEVICE NAMES DETECTED",
+    "   The following paths match Windows reserved device names (NUL, CON, AUX, etc.):",
+    "",
+    ...found.map((p) => `   - ${p}`),
+    "",
+    "   These will cause 'error: short read while indexing' git failures on Windows.",
+    "   This can make OpenCode's snapshot system extremely slow (30+ minutes).",
+    "",
+    "   Fix: Rename these files/directories to avoid reserved names.",
+    "   e.g., rename 'nul' \u2192 'null-device', 'con' \u2192 'console-util'",
+    ""
+  ];
+  return lines.join(`
+`);
+}
+var WIN_RESERVED_NAMES;
+var init_windows_reserved_names = __esm(() => {
+  WIN_RESERVED_NAMES = new Set([
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    "COM1",
+    "COM2",
+    "COM3",
+    "COM4",
+    "COM5",
+    "COM6",
+    "COM7",
+    "COM8",
+    "COM9",
+    "LPT1",
+    "LPT2",
+    "LPT3",
+    "LPT4",
+    "LPT5",
+    "LPT6",
+    "LPT7",
+    "LPT8",
+    "LPT9"
+  ]);
+});
+
 // src/shared/index.ts
 var init_shared = __esm(() => {
   init_frontmatter();
@@ -5060,6 +5348,9 @@ var init_shared = __esm(() => {
   init_model_requirements();
   init_model_resolver();
   init_model_availability();
+  init_perf_tracer();
+  init_fileio_monitor();
+  init_windows_reserved_names();
 });
 
 // node_modules/picomatch/lib/constants.js
@@ -10944,49 +11235,49 @@ var require_fast_uri = __commonJS((exports, module) => {
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
-  function resolveComponent(base, relative5, options, skipNormalization) {
+  function resolveComponent(base, relative6, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
       base = parse11(serialize(base, options), options);
-      relative5 = parse11(serialize(relative5, options), options);
+      relative6 = parse11(serialize(relative6, options), options);
     }
     options = options || {};
-    if (!options.tolerant && relative5.scheme) {
-      target.scheme = relative5.scheme;
-      target.userinfo = relative5.userinfo;
-      target.host = relative5.host;
-      target.port = relative5.port;
-      target.path = removeDotSegments(relative5.path || "");
-      target.query = relative5.query;
+    if (!options.tolerant && relative6.scheme) {
+      target.scheme = relative6.scheme;
+      target.userinfo = relative6.userinfo;
+      target.host = relative6.host;
+      target.port = relative6.port;
+      target.path = removeDotSegments(relative6.path || "");
+      target.query = relative6.query;
     } else {
-      if (relative5.userinfo !== undefined || relative5.host !== undefined || relative5.port !== undefined) {
-        target.userinfo = relative5.userinfo;
-        target.host = relative5.host;
-        target.port = relative5.port;
-        target.path = removeDotSegments(relative5.path || "");
-        target.query = relative5.query;
+      if (relative6.userinfo !== undefined || relative6.host !== undefined || relative6.port !== undefined) {
+        target.userinfo = relative6.userinfo;
+        target.host = relative6.host;
+        target.port = relative6.port;
+        target.path = removeDotSegments(relative6.path || "");
+        target.query = relative6.query;
       } else {
-        if (!relative5.path) {
+        if (!relative6.path) {
           target.path = base.path;
-          if (relative5.query !== undefined) {
-            target.query = relative5.query;
+          if (relative6.query !== undefined) {
+            target.query = relative6.query;
           } else {
             target.query = base.query;
           }
         } else {
-          if (relative5.path[0] === "/") {
-            target.path = removeDotSegments(relative5.path);
+          if (relative6.path[0] === "/") {
+            target.path = removeDotSegments(relative6.path);
           } else {
             if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {
-              target.path = "/" + relative5.path;
+              target.path = "/" + relative6.path;
             } else if (!base.path) {
-              target.path = relative5.path;
+              target.path = relative6.path;
             } else {
-              target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative5.path;
+              target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative6.path;
             }
             target.path = removeDotSegments(target.path);
           }
-          target.query = relative5.query;
+          target.query = relative6.query;
         }
         target.userinfo = base.userinfo;
         target.host = base.host;
@@ -10994,7 +11285,7 @@ var require_fast_uri = __commonJS((exports, module) => {
       }
       target.scheme = base.scheme;
     }
-    target.fragment = relative5.fragment;
+    target.fragment = relative6.fragment;
     return target;
   }
   function equal(uriA, uriB, options) {
@@ -14201,7 +14492,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
   var getPathKey = require_path_key();
   function resolveCommandAttempt(parsed, withoutPathExt) {
     const env = parsed.options.env || process.env;
-    const cwd = process.cwd();
+    const cwd2 = process.cwd();
     const hasCustomCwd = parsed.options.cwd != null;
     const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
     if (shouldSwitchCwd) {
@@ -14217,7 +14508,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
       });
     } catch (e) {} finally {
       if (shouldSwitchCwd) {
-        process.chdir(cwd);
+        process.chdir(cwd2);
       }
     }
     if (resolved) {
@@ -14424,7 +14715,7 @@ var require_cross_spawn = __commonJS((exports, module) => {
 });
 
 // src/hooks/todo-continuation-enforcer.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync3, readdirSync as readdirSync3 } from "fs";
 import { join as join5 } from "path";
 
 // src/features/claude-code-session-state/state.ts
@@ -14452,7 +14743,8 @@ function clearSessionAgent(sessionID) {
   sessionAgentMap.delete(sessionID);
 }
 // src/features/hook-message-injector/injector.ts
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+init_fileio_monitor();
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join3 } from "path";
 
 // src/features/hook-message-injector/constants.ts
@@ -14464,11 +14756,12 @@ var PART_STORAGE = join2(OPENCODE_STORAGE, "part");
 
 // src/features/hook-message-injector/injector.ts
 function findNearestMessageWithFields(messageDir) {
+  const monitor = getFileIOMonitor();
   try {
-    const files = readdirSync(messageDir).filter((f) => f.endsWith(".json")).sort().reverse();
+    const files = (monitor?.readdirSync(messageDir) ?? readdirSync2(messageDir)).filter((f) => f.endsWith(".json")).sort().reverse();
     for (const file of files) {
       try {
-        const content = readFileSync(join3(messageDir, file), "utf-8");
+        const content = monitor?.readFileSync(join3(messageDir, file), "utf-8") ?? readFileSync2(join3(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.agent && msg.model?.providerID && msg.model?.modelID) {
           return msg;
@@ -14479,7 +14772,7 @@ function findNearestMessageWithFields(messageDir) {
     }
     for (const file of files) {
       try {
-        const content = readFileSync(join3(messageDir, file), "utf-8");
+        const content = monitor?.readFileSync(join3(messageDir, file), "utf-8") ?? readFileSync2(join3(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.agent || msg.model?.providerID && msg.model?.modelID) {
           return msg;
@@ -14494,11 +14787,12 @@ function findNearestMessageWithFields(messageDir) {
   return null;
 }
 function findFirstMessageWithAgent(messageDir) {
+  const monitor = getFileIOMonitor();
   try {
-    const files = readdirSync(messageDir).filter((f) => f.endsWith(".json")).sort();
+    const files = (monitor?.readdirSync(messageDir) ?? readdirSync2(messageDir)).filter((f) => f.endsWith(".json")).sort();
     for (const file of files) {
       try {
-        const content = readFileSync(join3(messageDir, file), "utf-8");
+        const content = monitor?.readFileSync(join3(messageDir, file), "utf-8") ?? readFileSync2(join3(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.agent) {
           return msg.agent;
@@ -14523,20 +14817,24 @@ function generatePartId() {
   return `prt_${timestamp}${random}`;
 }
 function getOrCreateMessageDir(sessionID) {
-  if (!existsSync(MESSAGE_STORAGE)) {
-    mkdirSync(MESSAGE_STORAGE, { recursive: true });
+  const monitor = getFileIOMonitor();
+  const _exists = (p) => monitor?.existsSync(p) ?? existsSync2(p);
+  const _mkdir = (p, opts) => monitor ? undefined : mkdirSync(p, opts);
+  const _readdir = (p) => monitor?.readdirSync(p) ?? readdirSync2(p);
+  if (!_exists(MESSAGE_STORAGE)) {
+    _mkdir(MESSAGE_STORAGE, { recursive: true });
   }
   const directPath = join3(MESSAGE_STORAGE, sessionID);
-  if (existsSync(directPath)) {
+  if (_exists(directPath)) {
     return directPath;
   }
-  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+  for (const dir of _readdir(MESSAGE_STORAGE)) {
     const sessionPath = join3(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync(sessionPath)) {
+    if (_exists(sessionPath)) {
       return sessionPath;
     }
   }
-  mkdirSync(directPath, { recursive: true });
+  _mkdir(directPath, { recursive: true });
   return directPath;
 }
 function injectHookMessage(sessionID, hookContent, originalMessage) {
@@ -14585,12 +14883,22 @@ function injectHookMessage(sessionID, hookContent, originalMessage) {
     sessionID
   };
   try {
-    writeFileSync(join3(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
+    const monitor = getFileIOMonitor();
+    if (monitor) {
+      monitor.writeFileSync(join3(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
+    } else {
+      writeFileSync2(join3(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
+    }
     const partDir = join3(PART_STORAGE, messageID);
-    if (!existsSync(partDir)) {
+    const _exists = (p) => monitor?.existsSync(p) ?? existsSync2(p);
+    if (!_exists(partDir)) {
       mkdirSync(partDir, { recursive: true });
     }
-    writeFileSync(join3(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
+    if (monitor) {
+      monitor.writeFileSync(join3(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
+    } else {
+      writeFileSync2(join3(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
+    }
     return true;
   } catch {
     return false;
@@ -14612,14 +14920,14 @@ var COUNTDOWN_SECONDS = 2;
 var TOAST_DURATION_MS = 900;
 var COUNTDOWN_GRACE_PERIOD_MS = 500;
 function getMessageDir(sessionID) {
-  if (!existsSync2(MESSAGE_STORAGE))
+  if (!existsSync3(MESSAGE_STORAGE))
     return null;
   const directPath = join5(MESSAGE_STORAGE, sessionID);
-  if (existsSync2(directPath))
+  if (existsSync3(directPath))
     return directPath;
-  for (const dir of readdirSync2(MESSAGE_STORAGE)) {
+  for (const dir of readdirSync3(MESSAGE_STORAGE)) {
     const sessionPath = join5(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync2(sessionPath))
+    if (existsSync3(sessionPath))
       return sessionPath;
   }
   return null;
@@ -15397,7 +15705,7 @@ function createSessionNotification(ctx, config = {}) {
   };
 }
 // src/hooks/session-recovery/storage.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync4, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
 import { join as join7 } from "path";
 
 // src/hooks/session-recovery/constants.ts
@@ -15418,15 +15726,15 @@ function generatePartId2() {
   return `prt_${timestamp}${random}`;
 }
 function getMessageDir2(sessionID) {
-  if (!existsSync3(MESSAGE_STORAGE2))
+  if (!existsSync4(MESSAGE_STORAGE2))
     return "";
   const directPath = join7(MESSAGE_STORAGE2, sessionID);
-  if (existsSync3(directPath)) {
+  if (existsSync4(directPath)) {
     return directPath;
   }
-  for (const dir of readdirSync3(MESSAGE_STORAGE2)) {
+  for (const dir of readdirSync4(MESSAGE_STORAGE2)) {
     const sessionPath = join7(MESSAGE_STORAGE2, dir, sessionID);
-    if (existsSync3(sessionPath)) {
+    if (existsSync4(sessionPath)) {
       return sessionPath;
     }
   }
@@ -15434,14 +15742,14 @@ function getMessageDir2(sessionID) {
 }
 function readMessages(sessionID) {
   const messageDir = getMessageDir2(sessionID);
-  if (!messageDir || !existsSync3(messageDir))
+  if (!messageDir || !existsSync4(messageDir))
     return [];
   const messages = [];
-  for (const file of readdirSync3(messageDir)) {
+  for (const file of readdirSync4(messageDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const content = readFileSync2(join7(messageDir, file), "utf-8");
+      const content = readFileSync3(join7(messageDir, file), "utf-8");
       messages.push(JSON.parse(content));
     } catch {
       continue;
@@ -15457,14 +15765,14 @@ function readMessages(sessionID) {
 }
 function readParts(messageID) {
   const partDir = join7(PART_STORAGE2, messageID);
-  if (!existsSync3(partDir))
+  if (!existsSync4(partDir))
     return [];
   const parts = [];
-  for (const file of readdirSync3(partDir)) {
+  for (const file of readdirSync4(partDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const content = readFileSync2(join7(partDir, file), "utf-8");
+      const content = readFileSync3(join7(partDir, file), "utf-8");
       parts.push(JSON.parse(content));
     } catch {
       continue;
@@ -15495,7 +15803,7 @@ function messageHasContent(messageID) {
 }
 function injectTextPart(sessionID, messageID, text) {
   const partDir = join7(PART_STORAGE2, messageID);
-  if (!existsSync3(partDir)) {
+  if (!existsSync4(partDir)) {
     mkdirSync2(partDir, { recursive: true });
   }
   const partId = generatePartId2();
@@ -15508,7 +15816,7 @@ function injectTextPart(sessionID, messageID, text) {
     synthetic: true
   };
   try {
-    writeFileSync2(join7(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
+    writeFileSync3(join7(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
     return true;
   } catch {
     return false;
@@ -15604,7 +15912,7 @@ function findLastThinkingContent(sessionID, beforeMessageID) {
 }
 function prependThinkingPart(sessionID, messageID) {
   const partDir = join7(PART_STORAGE2, messageID);
-  if (!existsSync3(partDir)) {
+  if (!existsSync4(partDir)) {
     mkdirSync2(partDir, { recursive: true });
   }
   const previousThinking = findLastThinkingContent(sessionID, messageID);
@@ -15614,11 +15922,11 @@ function prependThinkingPart(sessionID, messageID) {
     sessionID,
     messageID,
     type: "thinking",
-    thinking: previousThinking || "[Continuing from previous reasoning]",
+    thinking: previousThinking || "[\u63A5\u7EED\u4E4B\u524D\u7684\u63A8\u7406]",
     synthetic: true
   };
   try {
-    writeFileSync2(join7(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
+    writeFileSync3(join7(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
     return true;
   } catch {
     return false;
@@ -15626,15 +15934,15 @@ function prependThinkingPart(sessionID, messageID) {
 }
 function stripThinkingParts(messageID) {
   const partDir = join7(PART_STORAGE2, messageID);
-  if (!existsSync3(partDir))
+  if (!existsSync4(partDir))
     return false;
   let anyRemoved = false;
-  for (const file of readdirSync3(partDir)) {
+  for (const file of readdirSync4(partDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
       const filePath = join7(partDir, file);
-      const content = readFileSync2(filePath, "utf-8");
+      const content = readFileSync3(filePath, "utf-8");
       const part = JSON.parse(content);
       if (THINKING_TYPES.has(part.type)) {
         unlinkSync(filePath);
@@ -15648,22 +15956,22 @@ function stripThinkingParts(messageID) {
 }
 function replaceEmptyTextParts(messageID, replacementText) {
   const partDir = join7(PART_STORAGE2, messageID);
-  if (!existsSync3(partDir))
+  if (!existsSync4(partDir))
     return false;
   let anyReplaced = false;
-  for (const file of readdirSync3(partDir)) {
+  for (const file of readdirSync4(partDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
       const filePath = join7(partDir, file);
-      const content = readFileSync2(filePath, "utf-8");
+      const content = readFileSync3(filePath, "utf-8");
       const part = JSON.parse(content);
       if (part.type === "text") {
         const textPart = part;
         if (!textPart.text?.trim()) {
           textPart.text = replacementText;
           textPart.synthetic = true;
-          writeFileSync2(filePath, JSON.stringify(textPart, null, 2));
+          writeFileSync3(filePath, JSON.stringify(textPart, null, 2));
           anyReplaced = true;
         }
       }
@@ -15932,25 +16240,25 @@ function createSessionRecoveryHook(ctx, options) {
 // src/hooks/comment-checker/cli.ts
 var {spawn: spawn5 } = globalThis.Bun;
 import { createRequire as createRequire2 } from "module";
-import { dirname, join as join14 } from "path";
-import { existsSync as existsSync11 } from "fs";
+import { dirname, join as join16 } from "path";
+import { existsSync as existsSync14 } from "fs";
 import * as fs5 from "fs";
-import { tmpdir as tmpdir3 } from "os";
+import { tmpdir as tmpdir4 } from "os";
 
 // src/hooks/comment-checker/downloader.ts
 init_shared();
 var {spawn: spawn4 } = globalThis.Bun;
-import { existsSync as existsSync10, mkdirSync as mkdirSync3, chmodSync, unlinkSync as unlinkSync2, appendFileSync as appendFileSync2 } from "fs";
-import { join as join13 } from "path";
-import { homedir as homedir7, tmpdir as tmpdir2 } from "os";
+import { existsSync as existsSync13, mkdirSync as mkdirSync4, chmodSync, unlinkSync as unlinkSync2, appendFileSync as appendFileSync3 } from "fs";
+import { join as join15 } from "path";
+import { homedir as homedir7, tmpdir as tmpdir3 } from "os";
 import { createRequire } from "module";
 var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE = join13(tmpdir2(), "comment-checker-debug.log");
+var DEBUG_FILE = join15(tmpdir3(), "comment-checker-debug.log");
 function debugLog(...args) {
   if (DEBUG) {
     const msg = `[${new Date().toISOString()}] [comment-checker:downloader] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
 `;
-    appendFileSync2(DEBUG_FILE, msg);
+    appendFileSync3(DEBUG_FILE, msg);
   }
 }
 var REPO = "code-yeongyu/go-claude-code-comment-checker";
@@ -15964,19 +16272,19 @@ var PLATFORM_MAP = {
 function getCacheDir() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join13(homedir7(), "AppData", "Local");
-    return join13(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join15(homedir7(), "AppData", "Local");
+    return join15(base2, "oh-my-opencode", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join13(homedir7(), ".cache");
-  return join13(base, "oh-my-opencode", "bin");
+  const base = xdgCache || join15(homedir7(), ".cache");
+  return join15(base, "oh-my-opencode", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
 }
 function getCachedBinaryPath() {
-  const binaryPath = join13(getCacheDir(), getBinaryName());
-  return existsSync10(binaryPath) ? binaryPath : null;
+  const binaryPath = join15(getCacheDir(), getBinaryName());
+  return existsSync13(binaryPath) ? binaryPath : null;
 }
 function getPackageVersion() {
   try {
@@ -16008,8 +16316,8 @@ async function downloadCommentChecker() {
   }
   const cacheDir = getCacheDir();
   const binaryName = getBinaryName();
-  const binaryPath = join13(cacheDir, binaryName);
-  if (existsSync10(binaryPath)) {
+  const binaryPath = join15(cacheDir, binaryName);
+  if (existsSync13(binaryPath)) {
     debugLog("Binary already cached at:", binaryPath);
     return binaryPath;
   }
@@ -16020,14 +16328,14 @@ async function downloadCommentChecker() {
   debugLog(`Downloading from: ${downloadUrl}`);
   console.log(`[oh-my-opencode] Downloading comment-checker binary...`);
   try {
-    if (!existsSync10(cacheDir)) {
-      mkdirSync3(cacheDir, { recursive: true });
+    if (!existsSync13(cacheDir)) {
+      mkdirSync4(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join13(cacheDir, assetName);
+    const archivePath = join15(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     debugLog(`Downloaded archive to: ${archivePath}`);
@@ -16036,10 +16344,10 @@ async function downloadCommentChecker() {
     } else {
       await extractZip(archivePath, cacheDir);
     }
-    if (existsSync10(archivePath)) {
+    if (existsSync13(archivePath)) {
       unlinkSync2(archivePath);
     }
-    if (process.platform !== "win32" && existsSync10(binaryPath)) {
+    if (process.platform !== "win32" && existsSync13(binaryPath)) {
       chmodSync(binaryPath, 493);
     }
     debugLog(`Successfully downloaded binary to: ${binaryPath}`);
@@ -16063,7 +16371,7 @@ async function ensureCommentCheckerBinary() {
 
 // src/hooks/comment-checker/cli.ts
 var DEBUG2 = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE2 = join14(tmpdir3(), "comment-checker-debug.log");
+var DEBUG_FILE2 = join16(tmpdir4(), "comment-checker-debug.log");
 function debugLog2(...args) {
   if (DEBUG2) {
     const msg = `[${new Date().toISOString()}] [comment-checker:cli] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
@@ -16089,8 +16397,8 @@ function findCommentCheckerPathSync() {
     const require2 = createRequire2(import.meta.url);
     const cliPkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
     const cliDir = dirname(cliPkgPath);
-    const binaryPath = join14(cliDir, "bin", binaryName);
-    if (existsSync11(binaryPath)) {
+    const binaryPath = join16(cliDir, "bin", binaryName);
+    if (existsSync14(binaryPath)) {
       debugLog2("found binary in main package:", binaryPath);
       return binaryPath;
     }
@@ -16111,7 +16419,7 @@ async function getCommentCheckerPath() {
   }
   initPromise = (async () => {
     const syncPath = findCommentCheckerPathSync();
-    if (syncPath && existsSync11(syncPath)) {
+    if (syncPath && existsSync14(syncPath)) {
       resolvedCliPath = syncPath;
       debugLog2("using sync-resolved path:", syncPath);
       return syncPath;
@@ -16147,7 +16455,7 @@ async function runCommentChecker(input, cliPath, customPrompt) {
     debugLog2("comment-checker binary not found");
     return { hasComments: false, message: "" };
   }
-  if (!existsSync11(binaryPath)) {
+  if (!existsSync14(binaryPath)) {
     debugLog2("comment-checker binary does not exist:", binaryPath);
     return { hasComments: false, message: "" };
   }
@@ -16185,11 +16493,11 @@ async function runCommentChecker(input, cliPath, customPrompt) {
 
 // src/hooks/comment-checker/index.ts
 import * as fs6 from "fs";
-import { existsSync as existsSync12 } from "fs";
-import { tmpdir as tmpdir4 } from "os";
-import { join as join15 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { tmpdir as tmpdir5 } from "os";
+import { join as join17 } from "path";
 var DEBUG3 = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE3 = join15(tmpdir4(), "comment-checker-debug.log");
+var DEBUG_FILE3 = join17(tmpdir5(), "comment-checker-debug.log");
 function debugLog3(...args) {
   if (DEBUG3) {
     const msg = `[${new Date().toISOString()}] [comment-checker:hook] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
@@ -16269,7 +16577,7 @@ function createCommentCheckerHooks(config) {
       }
       try {
         const cliPath = await cliPathPromise;
-        if (!cliPath || !existsSync12(cliPath)) {
+        if (!cliPath || !existsSync15(cliPath)) {
           debugLog3("CLI not available, skipping comment check");
           return;
         }
@@ -16349,36 +16657,36 @@ function createToolOutputTruncatorHook(ctx, options) {
   };
 }
 // src/hooks/directory-agents-injector/index.ts
-import { existsSync as existsSync14, readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname2, join as join18, resolve as resolve3 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname2, join as join20, resolve as resolve3 } from "path";
 
 // src/hooks/directory-agents-injector/storage.ts
 import {
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync7,
-  writeFileSync as writeFileSync4,
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync5,
   unlinkSync as unlinkSync3
 } from "fs";
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 
 // src/hooks/directory-agents-injector/constants.ts
 init_data_path();
-import { join as join16 } from "path";
+import { join as join18 } from "path";
 var OPENCODE_STORAGE3 = getOpenCodeStorageDir();
-var AGENTS_INJECTOR_STORAGE = join16(OPENCODE_STORAGE3, "directory-agents");
+var AGENTS_INJECTOR_STORAGE = join18(OPENCODE_STORAGE3, "directory-agents");
 var AGENTS_FILENAME = "AGENTS.md";
 
 // src/hooks/directory-agents-injector/storage.ts
 function getStoragePath(sessionID) {
-  return join17(AGENTS_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join19(AGENTS_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedPaths(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (!existsSync13(filePath))
+  if (!existsSync16(filePath))
     return new Set;
   try {
-    const content = readFileSync7(filePath, "utf-8");
+    const content = readFileSync8(filePath, "utf-8");
     const data = JSON.parse(content);
     return new Set(data.injectedPaths);
   } catch {
@@ -16386,19 +16694,19 @@ function loadInjectedPaths(sessionID) {
   }
 }
 function saveInjectedPaths(sessionID, paths) {
-  if (!existsSync13(AGENTS_INJECTOR_STORAGE)) {
-    mkdirSync4(AGENTS_INJECTOR_STORAGE, { recursive: true });
+  if (!existsSync16(AGENTS_INJECTOR_STORAGE)) {
+    mkdirSync5(AGENTS_INJECTOR_STORAGE, { recursive: true });
   }
   const data = {
     sessionID,
     injectedPaths: [...paths],
     updatedAt: Date.now()
   };
-  writeFileSync4(getStoragePath(sessionID), JSON.stringify(data, null, 2));
+  writeFileSync5(getStoragePath(sessionID), JSON.stringify(data, null, 2));
 }
 function clearInjectedPaths(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (existsSync13(filePath)) {
+  if (existsSync16(filePath)) {
     unlinkSync3(filePath);
   }
 }
@@ -16428,8 +16736,8 @@ function createDirectoryAgentsInjectorHook(ctx) {
     while (true) {
       const isRootDir = current === ctx.directory;
       if (!isRootDir) {
-        const agentsPath = join18(current, AGENTS_FILENAME);
-        if (existsSync14(agentsPath)) {
+        const agentsPath = join20(current, AGENTS_FILENAME);
+        if (existsSync17(agentsPath)) {
           found.push(agentsPath);
         }
       }
@@ -16456,7 +16764,7 @@ function createDirectoryAgentsInjectorHook(ctx) {
       if (cache.has(agentsDir))
         continue;
       try {
-        const content = readFileSync8(agentsPath, "utf-8");
+        const content = readFileSync9(agentsPath, "utf-8");
         const { result, truncated } = await truncator.truncate(sessionID, content);
         const truncationNotice = truncated ? `
 
@@ -16526,36 +16834,36 @@ ${result}${truncationNotice}`;
   };
 }
 // src/hooks/directory-readme-injector/index.ts
-import { existsSync as existsSync16, readFileSync as readFileSync10 } from "fs";
-import { dirname as dirname3, join as join21, resolve as resolve4 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync11 } from "fs";
+import { dirname as dirname3, join as join23, resolve as resolve4 } from "path";
 
 // src/hooks/directory-readme-injector/storage.ts
 import {
-  existsSync as existsSync15,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync9,
-  writeFileSync as writeFileSync5,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync10,
+  writeFileSync as writeFileSync6,
   unlinkSync as unlinkSync4
 } from "fs";
-import { join as join20 } from "path";
+import { join as join22 } from "path";
 
 // src/hooks/directory-readme-injector/constants.ts
 init_data_path();
-import { join as join19 } from "path";
+import { join as join21 } from "path";
 var OPENCODE_STORAGE4 = getOpenCodeStorageDir();
-var README_INJECTOR_STORAGE = join19(OPENCODE_STORAGE4, "directory-readme");
+var README_INJECTOR_STORAGE = join21(OPENCODE_STORAGE4, "directory-readme");
 var README_FILENAME = "README.md";
 
 // src/hooks/directory-readme-injector/storage.ts
 function getStoragePath2(sessionID) {
-  return join20(README_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join22(README_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedPaths2(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (!existsSync15(filePath))
+  if (!existsSync18(filePath))
     return new Set;
   try {
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync10(filePath, "utf-8");
     const data = JSON.parse(content);
     return new Set(data.injectedPaths);
   } catch {
@@ -16563,19 +16871,19 @@ function loadInjectedPaths2(sessionID) {
   }
 }
 function saveInjectedPaths2(sessionID, paths) {
-  if (!existsSync15(README_INJECTOR_STORAGE)) {
-    mkdirSync5(README_INJECTOR_STORAGE, { recursive: true });
+  if (!existsSync18(README_INJECTOR_STORAGE)) {
+    mkdirSync6(README_INJECTOR_STORAGE, { recursive: true });
   }
   const data = {
     sessionID,
     injectedPaths: [...paths],
     updatedAt: Date.now()
   };
-  writeFileSync5(getStoragePath2(sessionID), JSON.stringify(data, null, 2));
+  writeFileSync6(getStoragePath2(sessionID), JSON.stringify(data, null, 2));
 }
 function clearInjectedPaths2(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (existsSync15(filePath)) {
+  if (existsSync18(filePath)) {
     unlinkSync4(filePath);
   }
 }
@@ -16603,8 +16911,8 @@ function createDirectoryReadmeInjectorHook(ctx) {
     const found = [];
     let current = startDir;
     while (true) {
-      const readmePath = join21(current, README_FILENAME);
-      if (existsSync16(readmePath)) {
+      const readmePath = join23(current, README_FILENAME);
+      if (existsSync19(readmePath)) {
         found.push(readmePath);
       }
       if (current === ctx.directory)
@@ -16630,7 +16938,7 @@ function createDirectoryReadmeInjectorHook(ctx) {
       if (cache.has(readmeDir))
         continue;
       try {
-        const content = readFileSync10(readmePath, "utf-8");
+        const content = readFileSync11(readmePath, "utf-8");
         const { result, truncated } = await truncator.truncate(sessionID, content);
         const truncationNotice = truncated ? `
 
@@ -16914,22 +17222,22 @@ var TRUNCATE_CONFIG = {
 
 // src/hooks/anthropic-context-window-limit-recovery/storage.ts
 init_data_path();
-import { existsSync as existsSync17, readdirSync as readdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync20, readdirSync as readdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
+import { join as join24 } from "path";
 var OPENCODE_STORAGE5 = getOpenCodeStorageDir();
-var MESSAGE_STORAGE3 = join22(OPENCODE_STORAGE5, "message");
-var PART_STORAGE3 = join22(OPENCODE_STORAGE5, "part");
+var MESSAGE_STORAGE3 = join24(OPENCODE_STORAGE5, "message");
+var PART_STORAGE3 = join24(OPENCODE_STORAGE5, "part");
 var TRUNCATION_MESSAGE = "[TOOL RESULT TRUNCATED - Context limit exceeded. Original output was too large and has been truncated to recover the session. Please re-run this tool if you need the full output.]";
 function getMessageDir3(sessionID) {
-  if (!existsSync17(MESSAGE_STORAGE3))
+  if (!existsSync20(MESSAGE_STORAGE3))
     return "";
-  const directPath = join22(MESSAGE_STORAGE3, sessionID);
-  if (existsSync17(directPath)) {
+  const directPath = join24(MESSAGE_STORAGE3, sessionID);
+  if (existsSync20(directPath)) {
     return directPath;
   }
-  for (const dir of readdirSync4(MESSAGE_STORAGE3)) {
-    const sessionPath = join22(MESSAGE_STORAGE3, dir, sessionID);
-    if (existsSync17(sessionPath)) {
+  for (const dir of readdirSync6(MESSAGE_STORAGE3)) {
+    const sessionPath = join24(MESSAGE_STORAGE3, dir, sessionID);
+    if (existsSync20(sessionPath)) {
       return sessionPath;
     }
   }
@@ -16937,10 +17245,10 @@ function getMessageDir3(sessionID) {
 }
 function getMessageIds(sessionID) {
   const messageDir = getMessageDir3(sessionID);
-  if (!messageDir || !existsSync17(messageDir))
+  if (!messageDir || !existsSync20(messageDir))
     return [];
   const messageIds = [];
-  for (const file of readdirSync4(messageDir)) {
+  for (const file of readdirSync6(messageDir)) {
     if (!file.endsWith(".json"))
       continue;
     const messageId = file.replace(".json", "");
@@ -16952,15 +17260,15 @@ function findToolResultsBySize(sessionID) {
   const messageIds = getMessageIds(sessionID);
   const results = [];
   for (const messageID of messageIds) {
-    const partDir = join22(PART_STORAGE3, messageID);
-    if (!existsSync17(partDir))
+    const partDir = join24(PART_STORAGE3, messageID);
+    if (!existsSync20(partDir))
       continue;
-    for (const file of readdirSync4(partDir)) {
+    for (const file of readdirSync6(partDir)) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const partPath = join22(partDir, file);
-        const content = readFileSync11(partPath, "utf-8");
+        const partPath = join24(partDir, file);
+        const content = readFileSync12(partPath, "utf-8");
         const part = JSON.parse(content);
         if (part.type === "tool" && part.state?.output && !part.truncated) {
           results.push({
@@ -16980,7 +17288,7 @@ function findToolResultsBySize(sessionID) {
 }
 function truncateToolResult(partPath) {
   try {
-    const content = readFileSync11(partPath, "utf-8");
+    const content = readFileSync12(partPath, "utf-8");
     const part = JSON.parse(content);
     if (!part.state?.output) {
       return { success: false };
@@ -16994,7 +17302,7 @@ function truncateToolResult(partPath) {
       part.state.time = { start: Date.now() };
     }
     part.state.time.compacted = Date.now();
-    writeFileSync6(partPath, JSON.stringify(part, null, 2));
+    writeFileSync7(partPath, JSON.stringify(part, null, 2));
     return { success: true, toolName, originalSize };
   } catch {
     return { success: false };
@@ -17494,15 +17802,29 @@ function createCompactionContextInjector() {
 }
 // src/hooks/think-mode/detector.ts
 var ENGLISH_PATTERNS = [/\bultrathink\b/i, /\bthink\b/i];
-var MULTILINGUAL_KEYWORDS = [
+var CHINESE_KEYWORDS = [
+  "\u601D\u8003",
+  "\u8003\u8651",
+  "\u8003\u616E",
+  "\u6DF1\u5165\u601D\u8003",
+  "\u4ED4\u7EC6\u60F3\u60F3",
+  "\u4ED4\u7EC6\u601D\u8003",
+  "\u8BA4\u771F\u601D\u8003",
+  "\u597D\u597D\u60F3\u60F3",
+  "\u597D\u597D\u8003\u8651",
+  "\u7422\u78E8",
+  "\u5206\u6790\u4E00\u4E0B",
+  "\u53CD\u601D",
+  "\u63A8\u6572",
+  "\u659F\u914C",
+  "\u6DF1\u601D\u719F\u8651",
+  "\u60F3\u4E00\u60F3"
+];
+var OTHER_MULTILINGUAL_KEYWORDS = [
   "\uC0DD\uAC01",
   "\uACE0\uBBFC",
   "\uAC80\uD1A0",
   "\uC81C\uB300\uB85C",
-  "\u601D\u8003",
-  "\u8003\u8651",
-  "\u8003\u616E",
-  "\u601D\u8003",
   "\u8003\u3048",
   "\u719F\u8003",
   "\u0938\u094B\u091A",
@@ -17580,8 +17902,9 @@ var MULTILINGUAL_KEYWORDS = [
   "fikir",
   "berfikir"
 ];
-var MULTILINGUAL_PATTERNS = MULTILINGUAL_KEYWORDS.map((kw) => new RegExp(kw, "i"));
-var THINK_PATTERNS = [...ENGLISH_PATTERNS, ...MULTILINGUAL_PATTERNS];
+var CHINESE_PATTERNS = CHINESE_KEYWORDS.map((kw) => new RegExp(kw, "i"));
+var MULTILINGUAL_PATTERNS = OTHER_MULTILINGUAL_KEYWORDS.map((kw) => new RegExp(kw, "i"));
+var THINK_PATTERNS = [...ENGLISH_PATTERNS, ...CHINESE_PATTERNS, ...MULTILINGUAL_PATTERNS];
 var CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
 var INLINE_CODE_PATTERN = /`[^`]+`/g;
 function removeCodeBlocks(text) {
@@ -17729,53 +18052,55 @@ init_shared();
 var thinkModeState = new Map;
 function createThinkModeHook() {
   return {
-    "chat.params": async (output, sessionID) => {
-      const promptText = extractPromptText(output.parts);
+    "chat.params": async (input, output) => {
+      const promptText = extractPromptText(input.message.parts ?? []);
       const state2 = {
         requested: false,
         modelSwitched: false,
         thinkingConfigInjected: false
       };
       if (!detectThinkKeyword(promptText)) {
-        thinkModeState.set(sessionID, state2);
+        thinkModeState.set(input.sessionID, state2);
         return;
       }
       state2.requested = true;
-      const currentModel = output.message.model;
-      if (!currentModel) {
-        thinkModeState.set(sessionID, state2);
+      const modelID = input.model.id;
+      const providerID = input.model.providerID;
+      if (!modelID) {
+        thinkModeState.set(input.sessionID, state2);
         return;
       }
-      state2.providerID = currentModel.providerID;
-      state2.modelID = currentModel.modelID;
-      if (isAlreadyHighVariant(currentModel.modelID)) {
-        thinkModeState.set(sessionID, state2);
+      state2.providerID = providerID;
+      state2.modelID = modelID;
+      if (isAlreadyHighVariant(modelID)) {
+        thinkModeState.set(input.sessionID, state2);
         return;
       }
-      const highVariant = getHighVariant(currentModel.modelID);
-      const thinkingConfig = getThinkingConfig(currentModel.providerID, currentModel.modelID);
+      const highVariant = getHighVariant(modelID);
+      const thinkingConfig = getThinkingConfig(providerID, modelID);
       if (highVariant) {
-        output.message.model = {
-          providerID: currentModel.providerID,
-          modelID: highVariant
-        };
+        input.model.id = highVariant;
         state2.modelSwitched = true;
         log("Think mode: model switched to high variant", {
-          sessionID,
-          from: currentModel.modelID,
+          sessionID: input.sessionID,
+          from: modelID,
           to: highVariant
         });
       }
       if (thinkingConfig) {
-        Object.assign(output.message, thinkingConfig);
+        const { maxTokens, ...thinkingOptions } = thinkingConfig;
+        if (typeof maxTokens === "number") {
+          output.maxOutputTokens = maxTokens;
+        }
+        Object.assign(output.options, thinkingOptions);
         state2.thinkingConfigInjected = true;
         log("Think mode: thinking config injected", {
-          sessionID,
-          provider: currentModel.providerID,
+          sessionID: input.sessionID,
+          provider: providerID,
           config: thinkingConfig
         });
       }
-      thinkModeState.set(sessionID, state2);
+      thinkModeState.set(input.sessionID, state2);
     },
     event: async ({ event }) => {
       if (event.type === "session.deleted") {
@@ -17789,8 +18114,8 @@ function createThinkModeHook() {
 }
 // src/hooks/claude-code-hooks/config.ts
 init_shared();
-import { join as join23 } from "path";
-import { existsSync as existsSync18 } from "fs";
+import { join as join25 } from "path";
+import { existsSync as existsSync21 } from "fs";
 function normalizeHookMatcher(raw) {
   return {
     matcher: raw.matcher ?? raw.pattern ?? "*",
@@ -17816,11 +18141,11 @@ function normalizeHooksConfig(raw) {
 function getClaudeSettingsPaths(customPath) {
   const claudeConfigDir = getClaudeConfigDir();
   const paths = [
-    join23(claudeConfigDir, "settings.json"),
-    join23(process.cwd(), ".claude", "settings.json"),
-    join23(process.cwd(), ".claude", "settings.local.json")
+    join25(claudeConfigDir, "settings.json"),
+    join25(process.cwd(), ".claude", "settings.json"),
+    join25(process.cwd(), ".claude", "settings.local.json")
   ];
-  if (customPath && existsSync18(customPath)) {
+  if (customPath && existsSync21(customPath)) {
     paths.unshift(customPath);
   }
   return paths;
@@ -17845,7 +18170,7 @@ async function loadClaudeHooksConfig(customSettingsPath) {
   const paths = getClaudeSettingsPaths(customSettingsPath);
   let mergedConfig = {};
   for (const settingsPath of paths) {
-    if (existsSync18(settingsPath)) {
+    if (existsSync21(settingsPath)) {
       try {
         const content = await Bun.file(settingsPath).text();
         const settings = JSON.parse(content);
@@ -17864,14 +18189,14 @@ async function loadClaudeHooksConfig(customSettingsPath) {
 // src/hooks/claude-code-hooks/config-loader.ts
 init_logger();
 init_shared();
-import { existsSync as existsSync19 } from "fs";
-import { join as join24 } from "path";
-var USER_CONFIG_PATH = join24(getOpenCodeConfigDir({ binary: "opencode" }), "opencode-cc-plugin.json");
+import { existsSync as existsSync22 } from "fs";
+import { join as join26 } from "path";
+var USER_CONFIG_PATH = join26(getOpenCodeConfigDir({ binary: "opencode" }), "opencode-cc-plugin.json");
 function getProjectConfigPath() {
-  return join24(process.cwd(), ".opencode", "opencode-cc-plugin.json");
+  return join26(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
 async function loadConfigFromPath(path4) {
-  if (!existsSync19(path4)) {
+  if (!existsSync22(path4)) {
     return null;
   }
   try {
@@ -18059,17 +18384,17 @@ init_shared();
 // src/hooks/claude-code-hooks/transcript.ts
 init_tool_name();
 init_shared();
-import { join as join25 } from "path";
-import { mkdirSync as mkdirSync6, appendFileSync as appendFileSync5, existsSync as existsSync20, writeFileSync as writeFileSync7, unlinkSync as unlinkSync5 } from "fs";
-import { tmpdir as tmpdir5 } from "os";
+import { join as join27 } from "path";
+import { mkdirSync as mkdirSync7, appendFileSync as appendFileSync6, existsSync as existsSync23, writeFileSync as writeFileSync8, unlinkSync as unlinkSync5 } from "fs";
+import { tmpdir as tmpdir6 } from "os";
 import { randomUUID } from "crypto";
-var TRANSCRIPT_DIR = join25(getClaudeConfigDir(), "transcripts");
+var TRANSCRIPT_DIR = join27(getClaudeConfigDir(), "transcripts");
 function getTranscriptPath(sessionId) {
-  return join25(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
+  return join27(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
 }
 function ensureTranscriptDir() {
-  if (!existsSync20(TRANSCRIPT_DIR)) {
-    mkdirSync6(TRANSCRIPT_DIR, { recursive: true });
+  if (!existsSync23(TRANSCRIPT_DIR)) {
+    mkdirSync7(TRANSCRIPT_DIR, { recursive: true });
   }
 }
 function appendTranscriptEntry(sessionId, entry) {
@@ -18077,7 +18402,7 @@ function appendTranscriptEntry(sessionId, entry) {
   const path4 = getTranscriptPath(sessionId);
   const line = JSON.stringify(entry) + `
 `;
-  appendFileSync5(path4, line);
+  appendFileSync6(path4, line);
 }
 function recordToolUse(sessionId, toolName, toolInput) {
   appendTranscriptEntry(sessionId, {
@@ -18155,8 +18480,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
       }
     };
     entries.push(JSON.stringify(currentEntry));
-    const tempPath = join25(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-    writeFileSync7(tempPath, entries.join(`
+    const tempPath = join27(tmpdir6(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+    writeFileSync8(tempPath, entries.join(`
 `) + `
 `);
     return tempPath;
@@ -18175,8 +18500,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
           ]
         }
       };
-      const tempPath = join25(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-      writeFileSync7(tempPath, JSON.stringify(currentEntry) + `
+      const tempPath = join27(tmpdir6(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+      writeFileSync8(tempPath, JSON.stringify(currentEntry) + `
 `);
       return tempPath;
     } catch {
@@ -18391,11 +18716,11 @@ ${USER_PROMPT_SUBMIT_TAG_CLOSE}`);
 init_shared();
 
 // src/hooks/claude-code-hooks/todo.ts
-import { join as join26 } from "path";
+import { join as join28 } from "path";
 init_shared();
-var TODO_DIR = join26(getClaudeConfigDir(), "todos");
+var TODO_DIR = join28(getClaudeConfigDir(), "todos");
 function getTodoPath(sessionId) {
-  return join26(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
+  return join28(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
 }
 
 // src/hooks/claude-code-hooks/stop.ts
@@ -18837,24 +19162,24 @@ ${result.message}`;
   };
 }
 // src/hooks/rules-injector/index.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { homedir as homedir8 } from "os";
-import { relative as relative3, resolve as resolve5 } from "path";
+import { relative as relative4, resolve as resolve5 } from "path";
 
 // src/hooks/rules-injector/finder.ts
 import {
-  existsSync as existsSync21,
-  readdirSync as readdirSync5,
+  existsSync as existsSync24,
+  readdirSync as readdirSync7,
   realpathSync,
   statSync as statSync2
 } from "fs";
-import { dirname as dirname4, join as join28, relative } from "path";
+import { dirname as dirname4, join as join30, relative as relative2 } from "path";
 
 // src/hooks/rules-injector/constants.ts
 init_data_path();
-import { join as join27 } from "path";
+import { join as join29 } from "path";
 var OPENCODE_STORAGE6 = getOpenCodeStorageDir();
-var RULES_INJECTOR_STORAGE = join27(OPENCODE_STORAGE6, "rules-injector");
+var RULES_INJECTOR_STORAGE = join29(OPENCODE_STORAGE6, "rules-injector");
 var PROJECT_MARKERS = [
   ".git",
   "pyproject.toml",
@@ -18895,8 +19220,8 @@ function findProjectRoot(startPath) {
   }
   while (true) {
     for (const marker of PROJECT_MARKERS) {
-      const markerPath = join28(current, marker);
-      if (existsSync21(markerPath)) {
+      const markerPath = join30(current, marker);
+      if (existsSync24(markerPath)) {
         return current;
       }
     }
@@ -18908,12 +19233,12 @@ function findProjectRoot(startPath) {
   }
 }
 function findRuleFilesRecursive(dir, results) {
-  if (!existsSync21(dir))
+  if (!existsSync24(dir))
     return;
   try {
-    const entries = readdirSync5(dir, { withFileTypes: true });
+    const entries = readdirSync7(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join28(dir, entry.name);
+      const fullPath = join30(dir, entry.name);
       if (entry.isDirectory()) {
         findRuleFilesRecursive(fullPath, results);
       } else if (entry.isFile()) {
@@ -18938,7 +19263,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
   let distance = 0;
   while (true) {
     for (const [parent, subdir] of PROJECT_RULE_SUBDIRS) {
-      const ruleDir = join28(currentDir, parent, subdir);
+      const ruleDir = join30(currentDir, parent, subdir);
       const files = [];
       findRuleFilesRecursive(ruleDir, files);
       for (const filePath of files) {
@@ -18964,8 +19289,8 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
   }
   if (projectRoot) {
     for (const ruleFile of PROJECT_RULE_FILES) {
-      const filePath = join28(projectRoot, ruleFile);
-      if (existsSync21(filePath)) {
+      const filePath = join30(projectRoot, ruleFile);
+      if (existsSync24(filePath)) {
         try {
           const stat = statSync2(filePath);
           if (stat.isFile()) {
@@ -18985,7 +19310,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
       }
     }
   }
-  const userRuleDir = join28(homeDir, USER_RULE_DIR);
+  const userRuleDir = join30(homeDir, USER_RULE_DIR);
   const userFiles = [];
   findRuleFilesRecursive(userRuleDir, userFiles);
   for (const filePath of userFiles) {
@@ -19012,7 +19337,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
 // src/hooks/rules-injector/matcher.ts
 var import_picomatch = __toESM(require_picomatch2(), 1);
 import { createHash } from "crypto";
-import { relative as relative2 } from "path";
+import { relative as relative3 } from "path";
 function shouldApplyRule(metadata, currentFilePath, projectRoot) {
   if (metadata.alwaysApply === true) {
     return { applies: true, reason: "alwaysApply" };
@@ -19025,7 +19350,7 @@ function shouldApplyRule(metadata, currentFilePath, projectRoot) {
   if (patterns.length === 0) {
     return { applies: false };
   }
-  const relativePath = projectRoot ? relative2(projectRoot, currentFilePath) : currentFilePath;
+  const relativePath = projectRoot ? relative3(projectRoot, currentFilePath) : currentFilePath;
   for (const pattern of patterns) {
     if (import_picomatch.default.isMatch(relativePath, pattern, { dot: true, bash: true })) {
       return { applies: true, reason: `glob: ${pattern}` };
@@ -19174,22 +19499,22 @@ function mergeGlobs(existing, newValue) {
 
 // src/hooks/rules-injector/storage.ts
 import {
-  existsSync as existsSync22,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync12,
-  writeFileSync as writeFileSync8,
+  existsSync as existsSync25,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync13,
+  writeFileSync as writeFileSync9,
   unlinkSync as unlinkSync6
 } from "fs";
-import { join as join29 } from "path";
+import { join as join31 } from "path";
 function getStoragePath3(sessionID) {
-  return join29(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join31(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (!existsSync22(filePath))
+  if (!existsSync25(filePath))
     return { contentHashes: new Set, realPaths: new Set };
   try {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     const data = JSON.parse(content);
     return {
       contentHashes: new Set(data.injectedHashes),
@@ -19200,8 +19525,8 @@ function loadInjectedRules(sessionID) {
   }
 }
 function saveInjectedRules(sessionID, data) {
-  if (!existsSync22(RULES_INJECTOR_STORAGE)) {
-    mkdirSync7(RULES_INJECTOR_STORAGE, { recursive: true });
+  if (!existsSync25(RULES_INJECTOR_STORAGE)) {
+    mkdirSync8(RULES_INJECTOR_STORAGE, { recursive: true });
   }
   const storageData = {
     sessionID,
@@ -19209,11 +19534,11 @@ function saveInjectedRules(sessionID, data) {
     injectedRealPaths: [...data.realPaths],
     updatedAt: Date.now()
   };
-  writeFileSync8(getStoragePath3(sessionID), JSON.stringify(storageData, null, 2));
+  writeFileSync9(getStoragePath3(sessionID), JSON.stringify(storageData, null, 2));
 }
 function clearInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (existsSync22(filePath)) {
+  if (existsSync25(filePath)) {
     unlinkSync6(filePath);
   }
 }
@@ -19251,7 +19576,7 @@ function createRulesInjectorHook(ctx) {
       if (isDuplicateByRealPath(candidate.realPath, cache2.realPaths))
         continue;
       try {
-        const rawContent = readFileSync13(candidate.path, "utf-8");
+        const rawContent = readFileSync14(candidate.path, "utf-8");
         const { metadata, body } = parseRuleFrontmatter(rawContent);
         let matchReason;
         if (candidate.isSingleFile) {
@@ -19265,7 +19590,7 @@ function createRulesInjectorHook(ctx) {
         const contentHash = createContentHash(body);
         if (isDuplicateByContentHash(contentHash, cache2.contentHashes))
           continue;
-        const relativePath = projectRoot ? relative3(projectRoot, candidate.path) : candidate.path;
+        const relativePath = projectRoot ? relative4(projectRoot, candidate.path) : candidate.path;
         toInject.push({
           relativePath,
           matchReason,
@@ -19369,19 +19694,19 @@ init_auto_update_checker();
 
 // src/hooks/agent-usage-reminder/storage.ts
 import {
-  existsSync as existsSync25,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync16,
-  writeFileSync as writeFileSync11,
+  existsSync as existsSync28,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync17,
+  writeFileSync as writeFileSync12,
   unlinkSync as unlinkSync7
 } from "fs";
-import { join as join34 } from "path";
+import { join as join36 } from "path";
 
 // src/hooks/agent-usage-reminder/constants.ts
 init_data_path();
-import { join as join33 } from "path";
+import { join as join35 } from "path";
 var OPENCODE_STORAGE7 = getOpenCodeStorageDir();
-var AGENT_USAGE_REMINDER_STORAGE = join33(OPENCODE_STORAGE7, "agent-usage-reminder");
+var AGENT_USAGE_REMINDER_STORAGE = join35(OPENCODE_STORAGE7, "agent-usage-reminder");
 var TARGET_TOOLS = new Set([
   "grep",
   "safe_grep",
@@ -19427,29 +19752,29 @@ delegate_task(agent="librarian", prompt="\u67E5\u627E Z \u7684\u6587\u6863")
 
 // src/hooks/agent-usage-reminder/storage.ts
 function getStoragePath4(sessionID) {
-  return join34(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
+  return join36(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
 }
 function loadAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (!existsSync25(filePath))
+  if (!existsSync28(filePath))
     return null;
   try {
-    const content = readFileSync16(filePath, "utf-8");
+    const content = readFileSync17(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function saveAgentUsageState(state2) {
-  if (!existsSync25(AGENT_USAGE_REMINDER_STORAGE)) {
-    mkdirSync8(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
+  if (!existsSync28(AGENT_USAGE_REMINDER_STORAGE)) {
+    mkdirSync9(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath4(state2.sessionID);
-  writeFileSync11(filePath, JSON.stringify(state2, null, 2));
+  writeFileSync12(filePath, JSON.stringify(state2, null, 2));
 }
 function clearAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (existsSync25(filePath)) {
+  if (existsSync28(filePath)) {
     unlinkSync7(filePath);
   }
 }
@@ -20032,19 +20357,19 @@ function createNonInteractiveEnvHook(_ctx) {
 }
 // src/hooks/interactive-bash-session/storage.ts
 import {
-  existsSync as existsSync26,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync17,
-  writeFileSync as writeFileSync12,
+  existsSync as existsSync29,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync18,
+  writeFileSync as writeFileSync13,
   unlinkSync as unlinkSync8
 } from "fs";
-import { join as join36 } from "path";
+import { join as join38 } from "path";
 
 // src/hooks/interactive-bash-session/constants.ts
 init_data_path();
-import { join as join35 } from "path";
+import { join as join37 } from "path";
 var OPENCODE_STORAGE8 = getOpenCodeStorageDir();
-var INTERACTIVE_BASH_SESSION_STORAGE = join35(OPENCODE_STORAGE8, "interactive-bash-session");
+var INTERACTIVE_BASH_SESSION_STORAGE = join37(OPENCODE_STORAGE8, "interactive-bash-session");
 var OMO_SESSION_PREFIX = "omo-";
 function buildSessionReminderMessage(sessions) {
   if (sessions.length === 0)
@@ -20056,14 +20381,14 @@ function buildSessionReminderMessage(sessions) {
 
 // src/hooks/interactive-bash-session/storage.ts
 function getStoragePath5(sessionID) {
-  return join36(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
+  return join38(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
 }
 function loadInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (!existsSync26(filePath))
+  if (!existsSync29(filePath))
     return null;
   try {
-    const content = readFileSync17(filePath, "utf-8");
+    const content = readFileSync18(filePath, "utf-8");
     const serialized = JSON.parse(content);
     return {
       sessionID: serialized.sessionID,
@@ -20075,8 +20400,8 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state2) {
-  if (!existsSync26(INTERACTIVE_BASH_SESSION_STORAGE)) {
-    mkdirSync9(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
+  if (!existsSync29(INTERACTIVE_BASH_SESSION_STORAGE)) {
+    mkdirSync10(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath5(state2.sessionID);
   const serialized = {
@@ -20084,11 +20409,11 @@ function saveInteractiveBashSessionState(state2) {
     tmuxSessions: Array.from(state2.tmuxSessions),
     updatedAt: state2.updatedAt
   };
-  writeFileSync12(filePath, JSON.stringify(serialized, null, 2));
+  writeFileSync13(filePath, JSON.stringify(serialized, null, 2));
 }
 function clearInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (existsSync26(filePath)) {
+  if (existsSync29(filePath)) {
     unlinkSync8(filePath);
   }
 }
@@ -20342,7 +20667,7 @@ function createThinkingBlockValidatorHook() {
           continue;
         if (hasContentParts(msg.parts) && !startsWithThinkingBlock(msg.parts)) {
           const previousThinking = findPreviousThinkingContent(messages, i2);
-          const thinkingContent = previousThinking || "[Continuing from previous reasoning]";
+          const thinkingContent = previousThinking || "[\u63A5\u7EED\u4E4B\u524D\u7684\u63A8\u7406]";
           prependThinkingBlock(msg, thinkingContent);
         }
       }
@@ -20352,13 +20677,13 @@ function createThinkingBlockValidatorHook() {
 // src/hooks/ralph-loop/index.ts
 init_logger();
 init_system_directive();
-import { existsSync as existsSync28, readFileSync as readFileSync19, readdirSync as readdirSync6 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync20, readdirSync as readdirSync8 } from "fs";
+import { join as join40 } from "path";
 
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync27, readFileSync as readFileSync18, writeFileSync as writeFileSync13, unlinkSync as unlinkSync9, mkdirSync as mkdirSync10 } from "fs";
-import { dirname as dirname6, join as join37 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync19, writeFileSync as writeFileSync14, unlinkSync as unlinkSync9, mkdirSync as mkdirSync11 } from "fs";
+import { dirname as dirname6, join as join39 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
 var HOOK_NAME3 = "ralph-loop";
@@ -20368,15 +20693,15 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 
 // src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join37(directory, customPath) : join37(directory, DEFAULT_STATE_FILE);
+  return customPath ? join39(directory, customPath) : join39(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync27(filePath)) {
+  if (!existsSync30(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync18(filePath, "utf-8");
+    const content = readFileSync19(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -20410,8 +20735,8 @@ function writeState(directory, state2, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
     const dir = dirname6(filePath);
-    if (!existsSync27(dir)) {
-      mkdirSync10(dir, { recursive: true });
+    if (!existsSync30(dir)) {
+      mkdirSync11(dir, { recursive: true });
     }
     const sessionIdLine = state2.session_id ? `session_id: "${state2.session_id}"
 ` : "";
@@ -20426,7 +20751,7 @@ started_at: "${state2.started_at}"
 ${sessionIdLine}${ultraworkLine}---
 ${state2.prompt}
 `;
-    writeFileSync13(filePath, content, "utf-8");
+    writeFileSync14(filePath, content, "utf-8");
     return true;
   } catch {
     return false;
@@ -20435,7 +20760,7 @@ ${state2.prompt}
 function clearState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
-    if (existsSync27(filePath)) {
+    if (existsSync30(filePath)) {
       unlinkSync9(filePath);
     }
     return true;
@@ -20456,14 +20781,14 @@ function incrementIteration(directory, customPath) {
 
 // src/hooks/ralph-loop/index.ts
 function getMessageDir4(sessionID) {
-  if (!existsSync28(MESSAGE_STORAGE))
+  if (!existsSync31(MESSAGE_STORAGE))
     return null;
-  const directPath = join38(MESSAGE_STORAGE, sessionID);
-  if (existsSync28(directPath))
+  const directPath = join40(MESSAGE_STORAGE, sessionID);
+  if (existsSync31(directPath))
     return directPath;
-  for (const dir of readdirSync6(MESSAGE_STORAGE)) {
-    const sessionPath = join38(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync28(sessionPath))
+  for (const dir of readdirSync8(MESSAGE_STORAGE)) {
+    const sessionPath = join40(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync31(sessionPath))
       return sessionPath;
   }
   return null;
@@ -20500,9 +20825,9 @@ function createRalphLoopHook(ctx, options) {
     if (!transcriptPath)
       return false;
     try {
-      if (!existsSync28(transcriptPath))
+      if (!existsSync31(transcriptPath))
         return false;
-      const content = readFileSync19(transcriptPath, "utf-8");
+      const content = readFileSync20(transcriptPath, "utf-8");
       const pattern = new RegExp(`<promise>\\s*${escapeRegex(promise)}\\s*</promise>`, "is");
       const lines = content.split(`
 `).filter((l) => l.trim());
@@ -20816,8 +21141,8 @@ function extractPromptText3(parts) {
 // src/hooks/auto-slash-command/executor.ts
 init_shared();
 init_file_utils();
-import { existsSync as existsSync30, readdirSync as readdirSync7, readFileSync as readFileSync22 } from "fs";
-import { join as join40, basename as basename2, dirname as dirname8 } from "path";
+import { existsSync as existsSync33, readdirSync as readdirSync9, readFileSync as readFileSync23 } from "fs";
+import { join as join42, basename as basename2, dirname as dirname8 } from "path";
 // src/features/opencode-skill-loader/loader.ts
 init_js_yaml();
 init_frontmatter();
@@ -20825,7 +21150,7 @@ init_file_utils();
 init_shared();
 init_opencode_config_dir();
 import { promises as fs9 } from "fs";
-import { join as join39, basename } from "path";
+import { join as join41, basename } from "path";
 function parseSkillMcpConfigFromFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!frontmatterMatch)
@@ -20841,7 +21166,7 @@ function parseSkillMcpConfigFromFrontmatter(content) {
   return;
 }
 async function loadMcpJsonFromDir(skillDir) {
-  const mcpJsonPath = join39(skillDir, "mcp.json");
+  const mcpJsonPath = join41(skillDir, "mcp.json");
   try {
     const content = await fs9.readFile(mcpJsonPath, "utf-8");
     const parsed = JSON.parse(content);
@@ -20922,11 +21247,11 @@ async function loadSkillsFromDir(skillsDir, scope) {
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const entryPath = join39(skillsDir, entry.name);
+    const entryPath = join41(skillsDir, entry.name);
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       const resolvedPath = await resolveSymlinkAsync(entryPath);
       const dirName = entry.name;
-      const skillMdPath = join39(resolvedPath, "SKILL.md");
+      const skillMdPath = join41(resolvedPath, "SKILL.md");
       try {
         await fs9.access(skillMdPath);
         const skill = await loadSkillFromPath(skillMdPath, resolvedPath, dirName, scope);
@@ -20934,7 +21259,7 @@ async function loadSkillsFromDir(skillsDir, scope) {
           skills.push(skill);
         continue;
       } catch {}
-      const namedSkillMdPath = join39(resolvedPath, `${dirName}.md`);
+      const namedSkillMdPath = join41(resolvedPath, `${dirName}.md`);
       try {
         await fs9.access(namedSkillMdPath);
         const skill = await loadSkillFromPath(namedSkillMdPath, resolvedPath, dirName, scope);
@@ -20962,23 +21287,23 @@ function skillsToRecord(skills) {
   return result;
 }
 async function loadUserSkills() {
-  const userSkillsDir = join39(getClaudeConfigDir(), "skills");
+  const userSkillsDir = join41(getClaudeConfigDir(), "skills");
   const skills = await loadSkillsFromDir(userSkillsDir, "user");
   return skillsToRecord(skills);
 }
 async function loadProjectSkills() {
-  const projectSkillsDir = join39(process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join41(process.cwd(), ".claude", "skills");
   const skills = await loadSkillsFromDir(projectSkillsDir, "project");
   return skillsToRecord(skills);
 }
 async function loadOpencodeGlobalSkills() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeSkillsDir = join39(configDir, "skills");
+  const opencodeSkillsDir = join41(configDir, "skills");
   const skills = await loadSkillsFromDir(opencodeSkillsDir, "opencode");
   return skillsToRecord(skills);
 }
 async function loadOpencodeProjectSkills() {
-  const opencodeProjectDir = join39(process.cwd(), ".opencode", "skills");
+  const opencodeProjectDir = join41(process.cwd(), ".opencode", "skills");
   const skills = await loadSkillsFromDir(opencodeProjectDir, "opencode-project");
   return skillsToRecord(skills);
 }
@@ -21007,28 +21332,29 @@ async function discoverSkills(options = {}) {
   return [...opencodeProjectSkills, ...projectSkills, ...opencodeGlobalSkills, ...userSkills];
 }
 async function discoverUserClaudeSkills() {
-  const userSkillsDir = join39(getClaudeConfigDir(), "skills");
+  const userSkillsDir = join41(getClaudeConfigDir(), "skills");
   return loadSkillsFromDir(userSkillsDir, "user");
 }
 async function discoverProjectClaudeSkills() {
-  const projectSkillsDir = join39(process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join41(process.cwd(), ".claude", "skills");
   return loadSkillsFromDir(projectSkillsDir, "project");
 }
 async function discoverOpencodeGlobalSkills() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeSkillsDir = join39(configDir, "skills");
+  const opencodeSkillsDir = join41(configDir, "skills");
   return loadSkillsFromDir(opencodeSkillsDir, "opencode");
 }
 async function discoverOpencodeProjectSkills() {
-  const opencodeProjectDir = join39(process.cwd(), ".opencode", "skills");
+  const opencodeProjectDir = join41(process.cwd(), ".opencode", "skills");
   return loadSkillsFromDir(opencodeProjectDir, "opencode-project");
 }
 // src/features/opencode-skill-loader/merger.ts
 init_frontmatter();
 init_deep_merge();
-import { readFileSync as readFileSync20, existsSync as existsSync29 } from "fs";
+import { readFileSync as readFileSync21, existsSync as existsSync32 } from "fs";
 import { dirname as dirname7, resolve as resolve6, isAbsolute as isAbsolute2 } from "path";
 import { homedir as homedir11 } from "os";
+import { createHash as createHash2 } from "crypto";
 var SCOPE_PRIORITY = {
   builtin: 1,
   config: 2,
@@ -21074,9 +21400,9 @@ function resolveFilePath2(from, configDir) {
 }
 function loadSkillFromFile(filePath) {
   try {
-    if (!existsSync29(filePath))
+    if (!existsSync32(filePath))
       return null;
-    const content = readFileSync20(filePath, "utf-8");
+    const content = readFileSync21(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     return { template: body, metadata: data };
   } catch {
@@ -21163,13 +21489,28 @@ function mergeSkillDefinitions(base, patch) {
     allowedTools: mergedTools ? [...new Set(mergedTools)] : undefined
   };
 }
+function contentHash(content) {
+  return createHash2("md5").update(content).digest("hex").slice(0, 8);
+}
+function emptyDedupStats() {
+  return { totalScanned: 0, unique: 0, skippedByScope: 0, skippedByContent: 0, byScope: {} };
+}
 function mergeSkills(builtinSkills, config, userClaudeSkills, userOpencodeSkills, projectClaudeSkills, projectOpencodeSkills, options = {}) {
   const skillMap = new Map;
+  const contentHashes = new Map;
+  const stats = emptyDedupStats();
   for (const builtin of builtinSkills) {
     const loaded = builtinToLoaded(builtin);
     skillMap.set(loaded.name, loaded);
+    stats.byScope["builtin"] = (stats.byScope["builtin"] ?? 0) + 1;
+    stats.unique++;
+    if (loaded.definition.template) {
+      contentHashes.set(loaded.name, contentHash(loaded.definition.template));
+    }
   }
+  stats.totalScanned += builtinSkills.length;
   const normalizedConfig = normalizeConfig(config);
+  let configLoaded = 0;
   for (const [name, entry] of Object.entries(normalizedConfig.entries)) {
     if (entry === false)
       continue;
@@ -21184,9 +21525,18 @@ function mergeSkills(builtinSkills, config, userClaudeSkills, userOpencodeSkills
         skillMap.set(name, mergeSkillDefinitions(existing, entry));
       } else {
         skillMap.set(name, loaded);
+        configLoaded++;
+        stats.unique++;
+        if (loaded.definition.template) {
+          contentHashes.set(name, contentHash(loaded.definition.template));
+        }
       }
     }
   }
+  if (configLoaded > 0) {
+    stats.byScope["config"] = configLoaded;
+    stats.totalScanned += configLoaded;
+  }
   const fileSystemSkills = [
     ...userClaudeSkills,
     ...userOpencodeSkills,
@@ -21194,10 +21544,30 @@ function mergeSkills(builtinSkills, config, userClaudeSkills, userOpencodeSkills
     ...projectOpencodeSkills
   ];
   for (const skill of fileSystemSkills) {
+    stats.totalScanned++;
+    stats.byScope[skill.scope] = (stats.byScope[skill.scope] ?? 0) + 1;
     const existing = skillMap.get(skill.name);
-    if (!existing || SCOPE_PRIORITY[skill.scope] > SCOPE_PRIORITY[existing.scope]) {
-      skillMap.set(skill.name, skill);
+    const hash = skill.definition.template ? contentHash(skill.definition.template) : undefined;
+    if (existing) {
+      const existingHash = contentHashes.get(skill.name);
+      if (hash && existingHash && hash === existingHash) {
+        stats.skippedByContent++;
+        continue;
+      }
+      if (SCOPE_PRIORITY[skill.scope] <= SCOPE_PRIORITY[existing.scope]) {
+        stats.skippedByScope++;
+        continue;
+      }
     }
+    skillMap.set(skill.name, skill);
+    if (hash) {
+      contentHashes.set(skill.name, hash);
+    }
+    stats.unique++;
+  }
+  if (stats.skippedByContent > 0 || stats.skippedByScope > 1) {
+    const scopeSummary = Object.entries(stats.byScope).map(([scope, count]) => `${scope}:${count}`).join(", ");
+    console.debug(`[skill-loader] Scanned ${stats.totalScanned} skills (${scopeSummary}), ` + `${stats.unique} loaded, ` + `${stats.skippedByContent} skipped (identical content), ` + `${stats.skippedByScope} skipped (lower priority scope)`);
   }
   for (const [name, entry] of Object.entries(normalizedConfig.entries)) {
     if (entry === true)
@@ -22423,7 +22793,7 @@ function createBuiltinSkills() {
 
 // src/features/opencode-skill-loader/skill-content.ts
 init_frontmatter();
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync22 } from "fs";
 var cachedSkills = null;
 async function getAllSkills() {
   if (cachedSkills)
@@ -22456,7 +22826,7 @@ async function getAllSkills() {
 }
 async function extractSkillTemplate(skill) {
   if (skill.path) {
-    const content = readFileSync21(skill.path, "utf-8");
+    const content = readFileSync22(skill.path, "utf-8");
     const { body } = parseFrontmatter(content);
     return body.trim();
   }
@@ -22558,18 +22928,18 @@ async function resolveMultipleSkillsAsync(skillNames, options) {
 }
 // src/hooks/auto-slash-command/executor.ts
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync30(commandsDir)) {
+  if (!existsSync33(commandsDir)) {
     return [];
   }
-  const entries = readdirSync7(commandsDir, { withFileTypes: true });
+  const entries = readdirSync9(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join40(commandsDir, entry.name);
+    const commandPath = join42(commandsDir, entry.name);
     const commandName = basename2(entry.name, ".md");
     try {
-      const content = readFileSync22(commandPath, "utf-8");
+      const content = readFileSync23(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -22612,10 +22982,10 @@ function skillToCommandInfo(skill) {
 }
 async function discoverAllCommands(options) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const userCommandsDir = join40(getClaudeConfigDir(), "commands");
-  const projectCommandsDir = join40(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join40(configDir, "command");
-  const opencodeProjectDir = join40(process.cwd(), ".opencode", "command");
+  const userCommandsDir = join42(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join42(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join42(configDir, "command");
+  const opencodeProjectDir = join42(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
@@ -22785,8 +23155,8 @@ ${EDIT_ERROR_REMINDER}`;
   };
 }
 // src/hooks/prometheus-md-only/index.ts
-import { existsSync as existsSync31, readdirSync as readdirSync8 } from "fs";
-import { join as join41, resolve as resolve7, relative as relative4, isAbsolute as isAbsolute3 } from "path";
+import { existsSync as existsSync34, readdirSync as readdirSync10 } from "fs";
+import { join as join43, resolve as resolve7, relative as relative5, isAbsolute as isAbsolute3 } from "path";
 
 // src/hooks/prometheus-md-only/constants.ts
 init_system_directive();
@@ -22891,7 +23261,7 @@ init_logger();
 init_system_directive();
 function isAllowedFile(filePath, workspaceRoot) {
   const resolved = resolve7(workspaceRoot, filePath);
-  const rel = relative4(workspaceRoot, resolved);
+  const rel = relative5(workspaceRoot, resolved);
   if (rel.startsWith("..") || isAbsolute3(rel)) {
     return false;
   }
@@ -22905,14 +23275,14 @@ function isAllowedFile(filePath, workspaceRoot) {
   return true;
 }
 function getMessageDir5(sessionID) {
-  if (!existsSync31(MESSAGE_STORAGE))
+  if (!existsSync34(MESSAGE_STORAGE))
     return null;
-  const directPath = join41(MESSAGE_STORAGE, sessionID);
-  if (existsSync31(directPath))
+  const directPath = join43(MESSAGE_STORAGE, sessionID);
+  if (existsSync34(directPath))
     return directPath;
-  for (const dir of readdirSync8(MESSAGE_STORAGE)) {
-    const sessionPath = join41(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync31(sessionPath))
+  for (const dir of readdirSync10(MESSAGE_STORAGE)) {
+    const sessionPath = join43(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync34(sessionPath))
       return sessionPath;
   }
   return null;
@@ -23026,18 +23396,18 @@ var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 var PROMETHEUS_PLANS_DIR = ".sisyphus/plans";
 // src/features/boulder-state/storage.ts
-import { existsSync as existsSync32, readFileSync as readFileSync23, writeFileSync as writeFileSync14, mkdirSync as mkdirSync11, readdirSync as readdirSync9 } from "fs";
-import { dirname as dirname9, join as join42, basename as basename3 } from "path";
+import { existsSync as existsSync35, readFileSync as readFileSync24, writeFileSync as writeFileSync15, mkdirSync as mkdirSync12, readdirSync as readdirSync11 } from "fs";
+import { dirname as dirname9, join as join44, basename as basename3 } from "path";
 function getBoulderFilePath(directory) {
-  return join42(directory, BOULDER_DIR, BOULDER_FILE);
+  return join44(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync32(filePath)) {
+  if (!existsSync35(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync23(filePath, "utf-8");
+    const content = readFileSync24(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -23047,10 +23417,10 @@ function writeBoulderState(directory, state2) {
   const filePath = getBoulderFilePath(directory);
   try {
     const dir = dirname9(filePath);
-    if (!existsSync32(dir)) {
-      mkdirSync11(dir, { recursive: true });
+    if (!existsSync35(dir)) {
+      mkdirSync12(dir, { recursive: true });
     }
-    writeFileSync14(filePath, JSON.stringify(state2, null, 2), "utf-8");
+    writeFileSync15(filePath, JSON.stringify(state2, null, 2), "utf-8");
     return true;
   } catch {
     return false;
@@ -23071,7 +23441,7 @@ function appendSessionId(directory, sessionId) {
 function clearBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
   try {
-    if (existsSync32(filePath)) {
+    if (existsSync35(filePath)) {
       const { unlinkSync: unlinkSync10 } = __require("fs");
       unlinkSync10(filePath);
     }
@@ -23081,13 +23451,13 @@ function clearBoulderState(directory) {
   }
 }
 function findPrometheusPlans(directory) {
-  const plansDir = join42(directory, PROMETHEUS_PLANS_DIR);
-  if (!existsSync32(plansDir)) {
+  const plansDir = join44(directory, PROMETHEUS_PLANS_DIR);
+  if (!existsSync35(plansDir)) {
     return [];
   }
   try {
-    const files = readdirSync9(plansDir);
-    return files.filter((f) => f.endsWith(".md")).map((f) => join42(plansDir, f)).sort((a, b) => {
+    const files = readdirSync11(plansDir);
+    return files.filter((f) => f.endsWith(".md")).map((f) => join44(plansDir, f)).sort((a, b) => {
       const aStat = __require("fs").statSync(a);
       const bStat = __require("fs").statSync(b);
       return bStat.mtimeMs - aStat.mtimeMs;
@@ -23097,11 +23467,11 @@ function findPrometheusPlans(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync32(planPath)) {
+  if (!existsSync35(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync23(planPath, "utf-8");
+    const content = readFileSync24(planPath, "utf-8");
     const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) || [];
     const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) || [];
     const total = uncheckedMatches.length + checkedMatches.length;
@@ -23318,8 +23688,8 @@ ${contextInfo}`;
 }
 // src/hooks/atlas/index.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync33, readdirSync as readdirSync10 } from "fs";
-import { join as join43 } from "path";
+import { existsSync as existsSync36, readdirSync as readdirSync12 } from "fs";
+import { join as join45 } from "path";
 init_logger();
 init_system_directive();
 var HOOK_NAME6 = "atlas";
@@ -23648,14 +24018,14 @@ function formatFileChanges(stats, notepadPath) {
 `);
 }
 function getMessageDir6(sessionID) {
-  if (!existsSync33(MESSAGE_STORAGE))
+  if (!existsSync36(MESSAGE_STORAGE))
     return null;
-  const directPath = join43(MESSAGE_STORAGE, sessionID);
-  if (existsSync33(directPath))
+  const directPath = join45(MESSAGE_STORAGE, sessionID);
+  if (existsSync36(directPath))
     return directPath;
-  for (const dir of readdirSync10(MESSAGE_STORAGE)) {
-    const sessionPath = join43(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync33(sessionPath))
+  for (const dir of readdirSync12(MESSAGE_STORAGE)) {
+    const sessionPath = join45(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync36(sessionPath))
       return sessionPath;
   }
   return null;
@@ -24009,7 +24379,7 @@ var DELEGATE_TASK_ERROR_PATTERNS = [
   }
 ];
 function detectDelegateTaskError(output) {
-  if (!output.includes("[ERROR]") && !output.includes("Invalid arguments"))
+  if (!output.includes("[ERROR]") && !output.includes("Invalid arguments") && !output.includes("\u53C2\u6570\u9519\u8BEF\uFF1A"))
     return null;
   for (const errorPattern of DELEGATE_TASK_ERROR_PATTERNS) {
     if (output.includes(errorPattern.pattern)) {
@@ -24109,6 +24479,28 @@ function createQuestionLabelTruncatorHook() {
     }
   };
 }
+// src/hooks/perf-profiler/index.ts
+function createPerfProfilerHook(options) {
+  return {
+    event: async (input) => {
+      if (input.event.type === "message.part.updated")
+        return;
+      const tracer = options.tracer;
+      if (!tracer.isEnabled())
+        return;
+      const mapSizes = {};
+      for (const [name, fn] of Object.entries(options.memoryProbes ?? {})) {
+        try {
+          mapSizes[name] = fn();
+        } catch {}
+      }
+      tracer.snapshotMemory(input.event.type, mapSizes);
+    },
+    "tool.execute.before": async () => {},
+    "tool.execute.after": async () => {},
+    "chat.message": async () => {}
+  };
+}
 // src/features/context-injector/collector.ts
 var PRIORITY_ORDER = {
   critical: 0,
@@ -24282,8 +24674,8 @@ function createFirstMessageVariantGate() {
 }
 // src/features/claude-code-mcp-loader/loader.ts
 init_shared();
-import { existsSync as existsSync34, readFileSync as readFileSync24 } from "fs";
-import { join as join44 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync25 } from "fs";
+import { join as join46 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
 function expandEnvVars(value) {
@@ -24351,15 +24743,15 @@ function transformMcpServer(name, server) {
 init_logger();
 function getMcpConfigPaths() {
   const claudeConfigDir = getClaudeConfigDir();
-  const cwd = process.cwd();
+  const cwd2 = process.cwd();
   return [
-    { path: join44(claudeConfigDir, ".mcp.json"), scope: "user" },
-    { path: join44(cwd, ".mcp.json"), scope: "project" },
-    { path: join44(cwd, ".claude", ".mcp.json"), scope: "local" }
+    { path: join46(claudeConfigDir, ".mcp.json"), scope: "user" },
+    { path: join46(cwd2, ".mcp.json"), scope: "project" },
+    { path: join46(cwd2, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync34(filePath)) {
+  if (!existsSync37(filePath)) {
     return null;
   }
   try {
@@ -24374,10 +24766,10 @@ function getSystemMcpServerNames() {
   const names = new Set;
   const paths = getMcpConfigPaths();
   for (const { path: path7 } of paths) {
-    if (!existsSync34(path7))
+    if (!existsSync37(path7))
       continue;
     try {
-      const content = readFileSync24(path7, "utf-8");
+      const content = readFileSync25(path7, "utf-8");
       const config = JSON.parse(content);
       if (!config?.mcpServers)
         continue;
@@ -24820,25 +25212,25 @@ var EXT_TO_LANG = {
   ".gql": "graphql"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync35, readFileSync as readFileSync25 } from "fs";
-import { join as join45 } from "path";
+import { existsSync as existsSync38, readFileSync as readFileSync26 } from "fs";
+import { join as join47 } from "path";
 init_shared();
 function loadJsonFile(path7) {
-  if (!existsSync35(path7))
+  if (!existsSync38(path7))
     return null;
   try {
-    return JSON.parse(readFileSync25(path7, "utf-8"));
+    return JSON.parse(readFileSync26(path7, "utf-8"));
   } catch {
     return null;
   }
 }
 function getConfigPaths3() {
-  const cwd = process.cwd();
+  const cwd2 = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: join45(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join45(configDir, "oh-my-opencode.json"),
-    opencode: join45(configDir, "opencode.json")
+    project: join47(cwd2, ".opencode", "oh-my-opencode.json"),
+    user: join47(configDir, "oh-my-opencode.json"),
+    opencode: join47(configDir, "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -24951,7 +25343,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync35(cmd))
+    if (existsSync38(cmd))
       return true;
   }
   const isWindows2 = process.platform === "win32";
@@ -24973,23 +25365,23 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync35(join45(p, cmd + suffix))) {
+      if (existsSync38(join47(p, cmd + suffix))) {
         return true;
       }
     }
   }
-  const cwd = process.cwd();
+  const cwd2 = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join45(getDataDir(), "opencode");
+  const dataDir = join47(getDataDir(), "opencode");
   const additionalBases = [
-    join45(cwd, "node_modules", ".bin"),
-    join45(configDir, "bin"),
-    join45(configDir, "node_modules", ".bin"),
-    join45(dataDir, "bin")
+    join47(cwd2, "node_modules", ".bin"),
+    join47(configDir, "bin"),
+    join47(configDir, "node_modules", ".bin"),
+    join47(dataDir, "bin")
   ];
   for (const base of additionalBases) {
     for (const suffix of exts) {
-      if (existsSync35(join45(base, cmd + suffix))) {
+      if (existsSync38(join47(base, cmd + suffix))) {
         return true;
       }
     }
@@ -25001,7 +25393,7 @@ function isServerInstalled(command) {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn6 } = globalThis.Bun;
-import { readFileSync as readFileSync26 } from "fs";
+import { readFileSync as readFileSync27 } from "fs";
 import { extname, resolve as resolve8 } from "path";
 import { pathToFileURL } from "url";
 class LSPServerManager {
@@ -25451,7 +25843,7 @@ ${msg}`);
     const absPath = resolve8(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync26(absPath, "utf-8");
+    const text = readFileSync27(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -25541,17 +25933,17 @@ ${msg}`);
 // src/tools/lsp/utils.ts
 import { extname as extname2, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { existsSync as existsSync36, readFileSync as readFileSync27, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync28, writeFileSync as writeFileSync16 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve9(filePath);
-  if (!existsSync36(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync39(dir) || !__require("fs").statSync(dir).isDirectory()) {
     dir = __require("path").dirname(dir);
   }
   const markers = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
   let prevDir = "";
   while (dir !== prevDir) {
     for (const marker of markers) {
-      if (existsSync36(__require("path").join(dir, marker))) {
+      if (existsSync39(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -25706,7 +26098,7 @@ function formatPrepareRenameResult(result) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync27(filePath, "utf-8");
+    let content = readFileSync28(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -25731,7 +26123,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync15(filePath, lines.join(`
+    writeFileSync16(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -25762,7 +26154,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = uriToPath(change.uri);
-            writeFileSync15(filePath, "", "utf-8");
+            writeFileSync16(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -25772,8 +26164,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync27(oldPath, "utf-8");
-            writeFileSync15(newPath, content, "utf-8");
+            const content = readFileSync28(oldPath, "utf-8");
+            writeFileSync16(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -38352,13 +38744,13 @@ var lsp_rename = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname10, join as join47 } from "path";
-import { existsSync as existsSync38, statSync as statSync4 } from "fs";
+import { dirname as dirname10, join as join49 } from "path";
+import { existsSync as existsSync41, statSync as statSync4 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 init_shared();
-import { existsSync as existsSync37, mkdirSync as mkdirSync12, chmodSync as chmodSync2, unlinkSync as unlinkSync10 } from "fs";
-import { join as join46 } from "path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync13, chmodSync as chmodSync2, unlinkSync as unlinkSync10 } from "fs";
+import { join as join48 } from "path";
 import { homedir as homedir12 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
@@ -38384,19 +38776,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join46(homedir12(), "AppData", "Local");
-    return join46(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join48(homedir12(), "AppData", "Local");
+    return join48(base2, "oh-my-opencode", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join46(homedir12(), ".cache");
-  return join46(base, "oh-my-opencode", "bin");
+  const base = xdgCache || join48(homedir12(), ".cache");
+  return join48(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join46(getCacheDir3(), getBinaryName3());
-  return existsSync37(binaryPath) ? binaryPath : null;
+  const binaryPath = join48(getCacheDir3(), getBinaryName3());
+  return existsSync40(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -38407,8 +38799,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join46(cacheDir, binaryName);
-  if (existsSync37(binaryPath)) {
+  const binaryPath = join48(cacheDir, binaryName);
+  if (existsSync40(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os6 } = platformInfo;
@@ -38416,21 +38808,21 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   console.log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    if (!existsSync37(cacheDir)) {
-      mkdirSync12(cacheDir, { recursive: true });
+    if (!existsSync40(cacheDir)) {
+      mkdirSync13(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join46(cacheDir, assetName);
+    const archivePath = join48(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
-    if (existsSync37(archivePath)) {
+    if (existsSync40(archivePath)) {
       unlinkSync10(archivePath);
     }
-    if (process.platform !== "win32" && existsSync37(binaryPath)) {
+    if (process.platform !== "win32" && existsSync40(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -38481,8 +38873,8 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname10(cliPkgPath);
-    const sgPath = join47(cliDir, binaryName);
-    if (existsSync38(sgPath) && isValidBinary(sgPath)) {
+    const sgPath = join49(cliDir, binaryName);
+    if (existsSync41(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -38493,8 +38885,8 @@ function findSgCliPathSync() {
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname10(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join47(pkgDir, astGrepName);
-      if (existsSync38(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join49(pkgDir, astGrepName);
+      if (existsSync41(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -38502,7 +38894,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path7 of homebrewPaths) {
-      if (existsSync38(path7) && isValidBinary(path7)) {
+      if (existsSync41(path7) && isValidBinary(path7)) {
         return path7;
       }
     }
@@ -38557,11 +38949,11 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn7 } = globalThis.Bun;
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync42 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync39(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync42(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -38569,7 +38961,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync39(syncPath)) {
+    if (syncPath && existsSync42(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -38603,7 +38995,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync39(cliPath) && cliPath !== "sg") {
+  if (!existsSync42(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -38867,21 +39259,21 @@ var ast_grep_replace = tool({
 var {spawn: spawn9 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync41 } from "fs";
-import { join as join49, dirname as dirname11 } from "path";
+import { existsSync as existsSync44 } from "fs";
+import { join as join51, dirname as dirname11 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 
 // src/tools/grep/downloader.ts
 init_shared();
-import { existsSync as existsSync40, mkdirSync as mkdirSync13, chmodSync as chmodSync3, unlinkSync as unlinkSync11, readdirSync as readdirSync11 } from "fs";
-import { join as join48 } from "path";
+import { existsSync as existsSync43, mkdirSync as mkdirSync14, chmodSync as chmodSync3, unlinkSync as unlinkSync11, readdirSync as readdirSync13 } from "fs";
+import { join as join50 } from "path";
 var {spawn: spawn8 } = globalThis.Bun;
 function findFileRecursive(dir, filename) {
   try {
-    const entries = readdirSync11(dir, { withFileTypes: true, recursive: true });
+    const entries = readdirSync13(dir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
-        return join48(entry.parentPath ?? dir, entry.name);
+        return join50(entry.parentPath ?? dir, entry.name);
       }
     }
   } catch {
@@ -38902,11 +39294,11 @@ function getPlatformKey() {
 }
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join48(homeDir, ".cache", "oh-my-opencode", "bin");
+  return join50(homeDir, ".cache", "oh-my-opencode", "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join48(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join50(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 async function downloadFile(url2, destPath) {
   const response = await fetch(url2);
@@ -38940,7 +39332,7 @@ async function extractZip2(archivePath, destDir) {
   const binaryName = process.platform === "win32" ? "rg.exe" : "rg";
   const foundPath = findFileRecursive(destDir, binaryName);
   if (foundPath) {
-    const destPath = join48(destDir, binaryName);
+    const destPath = join50(destDir, binaryName);
     if (foundPath !== destPath) {
       const { renameSync } = await import("fs");
       renameSync(foundPath, destPath);
@@ -38955,13 +39347,13 @@ async function downloadAndInstallRipgrep() {
   }
   const installDir = getInstallDir();
   const rgPath = getRgPath();
-  if (existsSync40(rgPath)) {
+  if (existsSync43(rgPath)) {
     return rgPath;
   }
-  mkdirSync13(installDir, { recursive: true });
+  mkdirSync14(installDir, { recursive: true });
   const filename = `ripgrep-${RG_VERSION}-${config3.platform}.${config3.extension}`;
   const url2 = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/${filename}`;
-  const archivePath = join48(installDir, filename);
+  const archivePath = join50(installDir, filename);
   try {
     await downloadFile(url2, archivePath);
     if (config3.extension === "tar.gz") {
@@ -38972,12 +39364,12 @@ async function downloadAndInstallRipgrep() {
     if (process.platform !== "win32") {
       chmodSync3(rgPath, 493);
     }
-    if (!existsSync40(rgPath)) {
+    if (!existsSync43(rgPath)) {
       throw new Error("ripgrep binary not found after extraction");
     }
     return rgPath;
   } finally {
-    if (existsSync40(archivePath)) {
+    if (existsSync43(archivePath)) {
       try {
         unlinkSync11(archivePath);
       } catch {}
@@ -38986,7 +39378,7 @@ async function downloadAndInstallRipgrep() {
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync40(rgPath) ? rgPath : null;
+  return existsSync43(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -39011,14 +39403,14 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
-    join49(getDataDir(), "opencode", "bin", rgName),
-    join49(execDir, rgName),
-    join49(execDir, "bin", rgName),
-    join49(execDir, "..", "bin", rgName),
-    join49(execDir, "..", "libexec", rgName)
+    join51(getDataDir(), "opencode", "bin", rgName),
+    join51(execDir, rgName),
+    join51(execDir, "bin", rgName),
+    join51(execDir, "..", "bin", rgName),
+    join51(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync41(candidate)) {
+    if (existsSync44(candidate)) {
       return candidate;
     }
   }
@@ -39355,26 +39747,26 @@ async function runRgFiles(options, resolvedCli) {
   const isRg = cli.backend === "rg";
   const isWindows2 = process.platform === "win32";
   let command;
-  let cwd;
+  let cwd2;
   if (isRg) {
     const args = buildRgArgs2(options);
     const paths = options.paths?.length ? options.paths : ["."];
     args.push(...paths);
     command = [cli.path, ...args];
-    cwd = undefined;
+    cwd2 = undefined;
   } else if (isWindows2) {
     command = buildPowerShellCommand(options);
-    cwd = undefined;
+    cwd2 = undefined;
   } else {
     const args = buildFindArgs(options);
     const paths = options.paths?.length ? options.paths : ["."];
-    cwd = paths[0] || ".";
+    cwd2 = paths[0] || ".";
     command = [cli.path, ...args];
   }
   const proc = spawn10(command, {
     stdout: "pipe",
     stderr: "pipe",
-    cwd
+    cwd: cwd2
   });
   const timeoutPromise = new Promise((_, reject) => {
     const id = setTimeout(() => {
@@ -39412,7 +39804,7 @@ async function runRgFiles(options, resolvedCli) {
       } else if (isWindows2) {
         filePath = line.trim();
       } else {
-        filePath = `${cwd}/${line}`;
+        filePath = `${cwd2}/${line}`;
       }
       const mtime = await getFileMtime(filePath);
       files.push({ path: filePath, mtime });
@@ -39480,8 +39872,8 @@ var glob = tool({
 init_shared();
 init_file_utils();
 init_shared();
-import { existsSync as existsSync42, readdirSync as readdirSync12, readFileSync as readFileSync28 } from "fs";
-import { join as join50, basename as basename4, dirname as dirname12 } from "path";
+import { existsSync as existsSync45, readdirSync as readdirSync14, readFileSync as readFileSync29 } from "fs";
+import { join as join52, basename as basename4, dirname as dirname12 } from "path";
 // src/features/builtin-commands/templates/init-deep.ts
 var INIT_DEEP_TEMPLATE = `# /init-deep
 
@@ -40597,18 +40989,18 @@ function loadBuiltinCommands(disabledCommands) {
 }
 // src/tools/slashcommand/tools.ts
 function discoverCommandsFromDir2(commandsDir, scope) {
-  if (!existsSync42(commandsDir)) {
+  if (!existsSync45(commandsDir)) {
     return [];
   }
-  const entries = readdirSync12(commandsDir, { withFileTypes: true });
+  const entries = readdirSync14(commandsDir, { withFileTypes: true });
   const commands2 = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join50(commandsDir, entry.name);
+    const commandPath = join52(commandsDir, entry.name);
     const commandName = basename4(entry.name, ".md");
     try {
-      const content = readFileSync28(commandPath, "utf-8");
+      const content = readFileSync29(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -40634,10 +41026,10 @@ function discoverCommandsFromDir2(commandsDir, scope) {
 }
 function discoverCommandsSync() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const userCommandsDir = join50(getClaudeConfigDir(), "commands");
-  const projectCommandsDir = join50(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join50(configDir, "command");
-  const opencodeProjectDir = join50(process.cwd(), ".opencode", "command");
+  const userCommandsDir = join52(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join52(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join52(configDir, "command");
+  const opencodeProjectDir = join52(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir2(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir2(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir2(projectCommandsDir, "project");
@@ -40814,13 +41206,13 @@ var slashcommand = createSlashcommandTool();
 // src/tools/session-manager/constants.ts
 init_data_path();
 init_shared();
-import { join as join51 } from "path";
+import { join as join53 } from "path";
 var OPENCODE_STORAGE9 = getOpenCodeStorageDir();
-var MESSAGE_STORAGE4 = join51(OPENCODE_STORAGE9, "message");
-var PART_STORAGE4 = join51(OPENCODE_STORAGE9, "part");
-var SESSION_STORAGE = join51(OPENCODE_STORAGE9, "session");
-var TODO_DIR2 = join51(getClaudeConfigDir(), "todos");
-var TRANSCRIPT_DIR2 = join51(getClaudeConfigDir(), "transcripts");
+var MESSAGE_STORAGE4 = join53(OPENCODE_STORAGE9, "message");
+var PART_STORAGE4 = join53(OPENCODE_STORAGE9, "part");
+var SESSION_STORAGE = join53(OPENCODE_STORAGE9, "session");
+var TODO_DIR2 = join53(getClaudeConfigDir(), "todos");
+var TRANSCRIPT_DIR2 = join53(getClaudeConfigDir(), "transcripts");
 var SESSION_LIST_DESCRIPTION = `\u5217\u51FA\u6240\u6709 OpenCode session\uFF0C\u652F\u6301\u53EF\u9009\u8FC7\u6EE4\u3002
 
 \u8FD4\u56DE\u53EF\u7528\u7684 session ID \u5217\u8868\uFF0C\u5305\u542B\u6D88\u606F\u6570\u91CF\u3001\u65E5\u671F\u8303\u56F4\u548C\u4F7F\u7528\u8FC7\u7684 agents \u7B49\u5143\u6570\u636E\u3002
@@ -40893,11 +41285,11 @@ Has Todos: Yes (12 items, 8 completed)
 Has Transcript: Yes (234 entries)`;
 
 // src/tools/session-manager/storage.ts
-import { existsSync as existsSync43, readdirSync as readdirSync13 } from "fs";
+import { existsSync as existsSync46, readdirSync as readdirSync15 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { join as join52 } from "path";
+import { join as join54 } from "path";
 async function getMainSessions(options) {
-  if (!existsSync43(SESSION_STORAGE))
+  if (!existsSync46(SESSION_STORAGE))
     return [];
   const sessions = [];
   try {
@@ -40905,13 +41297,13 @@ async function getMainSessions(options) {
     for (const projectDir of projectDirs) {
       if (!projectDir.isDirectory())
         continue;
-      const projectPath = join52(SESSION_STORAGE, projectDir.name);
+      const projectPath = join54(SESSION_STORAGE, projectDir.name);
       const sessionFiles = await readdir(projectPath);
       for (const file2 of sessionFiles) {
         if (!file2.endsWith(".json"))
           continue;
         try {
-          const content = await readFile(join52(projectPath, file2), "utf-8");
+          const content = await readFile(join54(projectPath, file2), "utf-8");
           const meta = JSON.parse(content);
           if (meta.parentID)
             continue;
@@ -40929,7 +41321,7 @@ async function getMainSessions(options) {
   return sessions.sort((a, b) => b.time.updated - a.time.updated);
 }
 async function getAllSessions() {
-  if (!existsSync43(MESSAGE_STORAGE4))
+  if (!existsSync46(MESSAGE_STORAGE4))
     return [];
   const sessions = [];
   async function scanDirectory(dir) {
@@ -40937,7 +41329,7 @@ async function getAllSessions() {
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const sessionPath = join52(dir, entry.name);
+          const sessionPath = join54(dir, entry.name);
           const files = await readdir(sessionPath);
           if (files.some((f) => f.endsWith(".json"))) {
             sessions.push(entry.name);
@@ -40954,16 +41346,16 @@ async function getAllSessions() {
   return [...new Set(sessions)];
 }
 function getMessageDir7(sessionID) {
-  if (!existsSync43(MESSAGE_STORAGE4))
+  if (!existsSync46(MESSAGE_STORAGE4))
     return "";
-  const directPath = join52(MESSAGE_STORAGE4, sessionID);
-  if (existsSync43(directPath)) {
+  const directPath = join54(MESSAGE_STORAGE4, sessionID);
+  if (existsSync46(directPath)) {
     return directPath;
   }
   try {
-    for (const dir of readdirSync13(MESSAGE_STORAGE4)) {
-      const sessionPath = join52(MESSAGE_STORAGE4, dir, sessionID);
-      if (existsSync43(sessionPath)) {
+    for (const dir of readdirSync15(MESSAGE_STORAGE4)) {
+      const sessionPath = join54(MESSAGE_STORAGE4, dir, sessionID);
+      if (existsSync46(sessionPath)) {
         return sessionPath;
       }
     }
@@ -40977,7 +41369,7 @@ function sessionExists(sessionID) {
 }
 async function readSessionMessages(sessionID) {
   const messageDir = getMessageDir7(sessionID);
-  if (!messageDir || !existsSync43(messageDir))
+  if (!messageDir || !existsSync46(messageDir))
     return [];
   const messages = [];
   try {
@@ -40986,7 +41378,7 @@ async function readSessionMessages(sessionID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join52(messageDir, file2), "utf-8");
+        const content = await readFile(join54(messageDir, file2), "utf-8");
         const meta = JSON.parse(content);
         const parts = await readParts2(meta.id);
         messages.push({
@@ -41012,8 +41404,8 @@ async function readSessionMessages(sessionID) {
   });
 }
 async function readParts2(messageID) {
-  const partDir = join52(PART_STORAGE4, messageID);
-  if (!existsSync43(partDir))
+  const partDir = join54(PART_STORAGE4, messageID);
+  if (!existsSync46(partDir))
     return [];
   const parts = [];
   try {
@@ -41022,7 +41414,7 @@ async function readParts2(messageID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join52(partDir, file2), "utf-8");
+        const content = await readFile(join54(partDir, file2), "utf-8");
         parts.push(JSON.parse(content));
       } catch {
         continue;
@@ -41034,14 +41426,14 @@ async function readParts2(messageID) {
   return parts.sort((a, b) => a.id.localeCompare(b.id));
 }
 async function readSessionTodos(sessionID) {
-  if (!existsSync43(TODO_DIR2))
+  if (!existsSync46(TODO_DIR2))
     return [];
   try {
     const allFiles = await readdir(TODO_DIR2);
     const todoFiles = allFiles.filter((f) => f.includes(sessionID) && f.endsWith(".json"));
     for (const file2 of todoFiles) {
       try {
-        const content = await readFile(join52(TODO_DIR2, file2), "utf-8");
+        const content = await readFile(join54(TODO_DIR2, file2), "utf-8");
         const data = JSON.parse(content);
         if (Array.isArray(data)) {
           return data.map((item) => ({
@@ -41061,10 +41453,10 @@ async function readSessionTodos(sessionID) {
   return [];
 }
 async function readSessionTranscript(sessionID) {
-  if (!existsSync43(TRANSCRIPT_DIR2))
+  if (!existsSync46(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join52(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync43(transcriptFile))
+  const transcriptFile = join54(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  if (!existsSync46(transcriptFile))
     return 0;
   try {
     const content = await readFile(transcriptFile, "utf-8");
@@ -42266,19 +42658,19 @@ var CALL_OMO_AGENT_DESCRIPTION = `\u542F\u52A8 explore/librarian agent\u3002run_
 
 \u4F20\u5165 \`session_id=<id>\` \u53EF\u7EE7\u7EED\u4E4B\u524D\u7684 agent\uFF0C\u4FDD\u7559\u5B8C\u6574\u4E0A\u4E0B\u6587\u3002Prompts \u5FC5\u987B\u4E3A\u4E2D\u6587\u3002\u4F7F\u7528 \`background_output\` \u83B7\u53D6\u5F02\u6B65\u7ED3\u679C\u3002`;
 // src/tools/call-omo-agent/tools.ts
-import { existsSync as existsSync44, readdirSync as readdirSync14 } from "fs";
-import { join as join53 } from "path";
+import { existsSync as existsSync47, readdirSync as readdirSync16 } from "fs";
+import { join as join55 } from "path";
 init_shared();
 init_session_cursor();
 function getMessageDir8(sessionID) {
-  if (!existsSync44(MESSAGE_STORAGE))
+  if (!existsSync47(MESSAGE_STORAGE))
     return null;
-  const directPath = join53(MESSAGE_STORAGE, sessionID);
-  if (existsSync44(directPath))
+  const directPath = join55(MESSAGE_STORAGE, sessionID);
+  if (existsSync47(directPath))
     return directPath;
-  for (const dir of readdirSync14(MESSAGE_STORAGE)) {
-    const sessionPath = join53(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync44(sessionPath))
+  for (const dir of readdirSync16(MESSAGE_STORAGE)) {
+    const sessionPath = join55(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync47(sessionPath))
       return sessionPath;
   }
   return null;
@@ -42687,14 +43079,17 @@ If the requested information is not found, clearly state what is missing.`;
 }
 // src/tools/delegate-task/tools.ts
 init_constants2();
-import { existsSync as existsSync45, readdirSync as readdirSync15 } from "fs";
-import { join as join54 } from "path";
+import { existsSync as existsSync48, readdirSync as readdirSync17 } from "fs";
+import { join as join56 } from "path";
 
 // src/features/task-toast-manager/manager.ts
 class TaskToastManager {
   tasks = new Map;
   client;
   concurrencyManager;
+  completionBatch = [];
+  completionDebounceTimer;
+  static COMPLETION_DEBOUNCE_MS = 800;
   constructor(client2, concurrencyManager) {
     this.client = client2;
     this.concurrencyManager = concurrencyManager;
@@ -42806,13 +43201,36 @@ class TaskToastManager {
     }).catch(() => {});
   }
   showCompletionToast(task) {
+    this.removeTask(task.id);
+    this.completionBatch.push(task);
+    if (this.completionDebounceTimer) {
+      clearTimeout(this.completionDebounceTimer);
+    }
+    this.completionDebounceTimer = setTimeout(() => {
+      this.flushCompletionBatch();
+    }, TaskToastManager.COMPLETION_DEBOUNCE_MS);
+  }
+  flushCompletionBatch() {
     const tuiClient = this.client;
-    if (!tuiClient.tui?.showToast)
+    if (!tuiClient.tui?.showToast) {
+      this.completionBatch = [];
+      return;
+    }
+    const batch = [...this.completionBatch];
+    this.completionBatch = [];
+    if (batch.length === 0)
       return;
-    this.removeTask(task.id);
     const remaining = this.getRunningTasks();
     const queued = this.getQueuedTasks();
-    let message = `"${task.description}" finished in ${task.duration}`;
+    let message;
+    if (batch.length === 1) {
+      message = `"${batch[0].description}" finished in ${batch[0].duration}`;
+    } else {
+      const lines = batch.map((t) => `  \u2713 "${t.description}" (${t.duration})`);
+      message = `${batch.length} tasks completed:
+${lines.join(`
+`)}`;
+    }
     if (remaining.length > 0 || queued.length > 0) {
       message += `
 
@@ -42820,12 +43238,13 @@ Still running: ${remaining.length} | Queued: ${queued.length}`;
     }
     tuiClient.tui.showToast({
       body: {
-        title: "Task Completed",
+        title: batch.length === 1 ? "Task Completed" : `${batch.length} Tasks Completed`,
         message,
         variant: "success",
-        duration: 5000
+        duration: batch.length > 1 ? 7000 : 5000
       }
     }).catch(() => {});
+    this.completionDebounceTimer = undefined;
   }
 }
 var instance = null;
@@ -42847,14 +43266,14 @@ function parseModelString(model) {
   return;
 }
 function getMessageDir9(sessionID) {
-  if (!existsSync45(MESSAGE_STORAGE))
+  if (!existsSync48(MESSAGE_STORAGE))
     return null;
-  const directPath = join54(MESSAGE_STORAGE, sessionID);
-  if (existsSync45(directPath))
+  const directPath = join56(MESSAGE_STORAGE, sessionID);
+  if (existsSync48(directPath))
     return directPath;
-  for (const dir of readdirSync15(MESSAGE_STORAGE)) {
-    const sessionPath = join54(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync45(sessionPath))
+  for (const dir of readdirSync17(MESSAGE_STORAGE)) {
+    const sessionPath = join56(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync48(sessionPath))
       return sessionPath;
   }
   return null;
@@ -43682,12 +44101,14 @@ class PerformanceAggregator {
 }
 
 // src/features/background-agent/manager.ts
-import { existsSync as existsSync46, readdirSync as readdirSync16 } from "fs";
-import { join as join55 } from "path";
+import { existsSync as existsSync49, readdirSync as readdirSync18 } from "fs";
+import { join as join57 } from "path";
 var TASK_TTL_MS = 30 * 60 * 1000;
 var MIN_STABILITY_TIME_MS = 10 * 1000;
-var DEFAULT_STALE_TIMEOUT_MS = 180000;
+var DEFAULT_STALE_TIMEOUT_MS = 120000;
 var MIN_RUNTIME_BEFORE_STALE_MS = 30000;
+var STEP_TIMEOUT_MS = 600000;
+var MIN_IDLE_TIME_MS = 15000;
 
 class BackgroundManager {
   static cleanupManagers = new Set;
@@ -43703,6 +44124,7 @@ class BackgroundManager {
   shutdownTriggered = false;
   config;
   perfAggregator = new PerformanceAggregator;
+  perfTracer;
   queuesByKey = new Map;
   processingKeys = new Set;
   constructor(ctx, config3) {
@@ -43715,6 +44137,9 @@ class BackgroundManager {
     this.config = config3;
     this.registerProcessCleanup();
   }
+  setPerfTracer(tracer) {
+    this.perfTracer = tracer;
+  }
   async launch(input) {
     log("[background-agent] launch() called with:", {
       agent: input.agent,
@@ -43736,7 +44161,11 @@ class BackgroundManager {
       parentMessageID: input.parentMessageID,
       parentModel: input.parentModel,
       parentAgent: input.parentAgent,
-      model: input.model
+      model: input.model,
+      maxSteps: this.config?.maxSteps,
+      maxRuntimeMs: this.config?.maxRuntimeMs,
+      stepTimeoutMs: this.config?.stepTimeoutMs ?? STEP_TIMEOUT_MS,
+      stepCount: 0
     };
     this.tasks.set(task.id, task);
     if (input.parentSessionID) {
@@ -43828,7 +44257,8 @@ class BackgroundManager {
     task.sessionID = sessionID;
     task.progress = {
       toolCalls: 0,
-      lastUpdate: new Date
+      lastUpdate: new Date,
+      stepStartedAt: Date.now()
     };
     task.concurrencyKey = concurrencyKey;
     task.concurrencyGroup = concurrencyKey;
@@ -43968,7 +44398,11 @@ class BackgroundManager {
       },
       parentAgent: input.parentAgent,
       concurrencyKey: input.concurrencyKey,
-      concurrencyGroup
+      concurrencyGroup,
+      maxSteps: this.config?.maxSteps,
+      maxRuntimeMs: this.config?.maxRuntimeMs,
+      stepTimeoutMs: this.config?.stepTimeoutMs ?? STEP_TIMEOUT_MS,
+      stepCount: 0
     };
     this.tasks.set(task.id, task);
     subagentSessions.add(input.sessionID);
@@ -44008,12 +44442,14 @@ class BackgroundManager {
     existingTask.parentModel = input.parentModel;
     existingTask.parentAgent = input.parentAgent;
     existingTask.startedAt = new Date;
+    existingTask.stepCount = 0;
     if (existingTask.progress) {
       existingTask.progress.phaseTiming = undefined;
     }
     existingTask.progress = {
       toolCalls: existingTask.progress?.toolCalls ?? 0,
-      lastUpdate: new Date
+      lastUpdate: new Date,
+      stepStartedAt: Date.now()
     };
     this.startPolling();
     if (existingTask.sessionID) {
@@ -44115,11 +44551,20 @@ class BackgroundManager {
       const task = this.findBySession(sessionID);
       if (!task || task.status !== "running")
         return;
+      task.stepCount = (task.stepCount ?? 0) + 1;
+      if (task.progress) {
+        task.progress.stepStartedAt = Date.now();
+      }
+      if (this.isStepLimitExceeded(task)) {
+        this.tryCompleteTask(task, `step limit (${task.maxSteps} steps)`).catch((err) => {
+          log("[background-agent] Error completing task on step limit:", err);
+        });
+        return;
+      }
       const startedAt = task.startedAt;
       if (!startedAt)
         return;
       const elapsedMs = Date.now() - startedAt.getTime();
-      const MIN_IDLE_TIME_MS = 5000;
       if (elapsedMs < MIN_IDLE_TIME_MS) {
         log("[background-agent] Ignoring early session.idle, elapsed:", { elapsedMs, taskId: task.id });
         return;
@@ -44506,6 +44951,41 @@ ${perfSnapshot ? `| \u6392\u961F ${PerfTimer.formatDuration(new Date(0), new Dat
       const runtime = now - startedAt.getTime();
       if (runtime < MIN_RUNTIME_BEFORE_STALE_MS)
         continue;
+      if (this.isRuntimeLimitExceeded(task)) {
+        task.status = "cancelled";
+        task.error = `Runtime limit exceeded (${Math.round(runtime / 60000)}min)`;
+        task.completedAt = new Date;
+        if (task.concurrencyKey) {
+          this.concurrencyManager.release(task.concurrencyKey);
+          task.concurrencyKey = undefined;
+        }
+        this.client.session.abort({ path: { id: sessionID } }).catch(() => {});
+        log(`[background-agent] Task ${task.id} interrupted: runtime limit`);
+        try {
+          await this.notifyParentSession(task);
+        } catch (err) {
+          log("[background-agent] Error in notifyParentSession for runtime-limit task:", { taskId: task.id, error: err });
+        }
+        continue;
+      }
+      if (this.isStepTimeoutExceeded(task)) {
+        const stepTimeoutMs = task.stepTimeoutMs ?? STEP_TIMEOUT_MS;
+        task.status = "cancelled";
+        task.error = `Step timeout exceeded (single step > ${Math.round(stepTimeoutMs / 60000)}min)`;
+        task.completedAt = new Date;
+        if (task.concurrencyKey) {
+          this.concurrencyManager.release(task.concurrencyKey);
+          task.concurrencyKey = undefined;
+        }
+        this.client.session.abort({ path: { id: sessionID } }).catch(() => {});
+        log(`[background-agent] Task ${task.id} interrupted: step timeout`);
+        try {
+          await this.notifyParentSession(task);
+        } catch (err) {
+          log("[background-agent] Error in notifyParentSession for step-timeout task:", { taskId: task.id, error: err });
+        }
+        continue;
+      }
       const timeSinceLastUpdate = now - task.progress.lastUpdate.getTime();
       if (timeSinceLastUpdate <= staleTimeoutMs)
         continue;
@@ -44530,125 +45010,165 @@ ${perfSnapshot ? `| \u6392\u961F ${PerfTimer.formatDuration(new Date(0), new Dat
       }
     }
   }
+  isStepLimitExceeded(task) {
+    const maxSteps = task.maxSteps;
+    if (!maxSteps || maxSteps <= 0)
+      return false;
+    return (task.stepCount ?? 0) >= maxSteps;
+  }
+  isRuntimeLimitExceeded(task) {
+    const maxRuntimeMs = task.maxRuntimeMs;
+    if (!maxRuntimeMs || maxRuntimeMs <= 0)
+      return false;
+    if (!task.startedAt)
+      return false;
+    const runtime = Date.now() - task.startedAt.getTime();
+    return runtime >= maxRuntimeMs;
+  }
+  isStepTimeoutExceeded(task) {
+    const stepTimeoutMs = task.stepTimeoutMs;
+    if (!stepTimeoutMs || stepTimeoutMs <= 0)
+      return false;
+    if (!task.progress?.stepStartedAt)
+      return false;
+    const stepDuration = Date.now() - task.progress.stepStartedAt;
+    return stepDuration >= stepTimeoutMs;
+  }
   async pollRunningTasks() {
-    this.pruneStaleTasksAndNotifications();
-    await this.checkAndInterruptStaleTasks();
-    const statusResult = await this.client.session.status();
-    const allStatuses = statusResult.data ?? {};
-    for (const task of this.tasks.values()) {
-      if (task.status !== "running")
-        continue;
-      const sessionID = task.sessionID;
-      if (!sessionID)
-        continue;
-      try {
-        const sessionStatus = allStatuses[sessionID];
-        if (sessionStatus?.type === "idle") {
-          const hasValidOutput = await this.validateSessionHasOutput(sessionID);
-          if (!hasValidOutput) {
-            log("[background-agent] Polling idle but no valid output yet, waiting:", task.id);
-            continue;
-          }
-          if (task.status !== "running")
-            continue;
-          const hasIncompleteTodos2 = await this.checkSessionTodos(sessionID);
-          if (hasIncompleteTodos2) {
-            log("[background-agent] Task has incomplete todos via polling, waiting:", task.id);
-            continue;
-          }
-          await this.tryCompleteTask(task, "polling (idle status)");
+    const start = this.perfTracer?.isEnabled() ? performance.now() : undefined;
+    try {
+      this.pruneStaleTasksAndNotifications();
+      await this.checkAndInterruptStaleTasks();
+      const statusResult = await this.client.session.status();
+      const allStatuses = statusResult.data ?? {};
+      for (const task of this.tasks.values()) {
+        if (task.status !== "running")
           continue;
-        }
-        const messagesResult = await this.client.session.messages({
-          path: { id: sessionID }
-        });
-        if (!messagesResult.error && messagesResult.data) {
-          const messages = messagesResult.data;
-          const assistantMsgs = messages.filter((m) => m.info?.role === "assistant");
-          let toolCalls = 0;
-          let lastTool;
-          let lastMessage;
-          for (const msg of assistantMsgs) {
-            const parts = msg.parts ?? [];
-            for (const part of parts) {
-              if (part.type === "tool_use" || part.tool) {
-                toolCalls++;
-                lastTool = part.tool || part.name || "unknown";
-              }
-              if (part.type === "text" && part.text) {
-                lastMessage = part.text;
-              }
+        const sessionID = task.sessionID;
+        if (!sessionID)
+          continue;
+        try {
+          const sessionStatus = allStatuses[sessionID];
+          if (sessionStatus?.type === "idle") {
+            const hasValidOutput = await this.validateSessionHasOutput(sessionID);
+            if (!hasValidOutput) {
+              log("[background-agent] Polling idle but no valid output yet, waiting:", task.id);
+              continue;
             }
-          }
-          if (!task.progress) {
-            task.progress = { toolCalls: 0, lastUpdate: new Date };
-          }
-          if (task.startedAt && !task.progress.phaseTiming) {
-            const now = Date.now();
-            task.progress.phaseTiming = {
-              queueWaitMs: task.queuedAt ? now - task.queuedAt.getTime() : 0,
-              totalRunMs: now - task.startedAt.getTime(),
-              toolCallCount: 0
-            };
-          }
-          if (task.progress.phaseTiming && task.progress.phaseTiming.firstResponseMs === undefined && assistantMsgs.length > 0) {
-            task.progress.phaseTiming.firstResponseMs = Date.now() - task.startedAt.getTime();
-          }
-          task.progress.toolCalls = toolCalls;
-          task.progress.lastTool = lastTool;
-          task.progress.lastUpdate = new Date;
-          if (lastMessage) {
-            task.progress.lastMessage = lastMessage;
-            task.progress.lastMessageAt = new Date;
-          }
-          const currentMsgCount = messages.length;
-          const startedAt = task.startedAt;
-          if (!startedAt)
+            if (task.status !== "running")
+              continue;
+            const hasIncompleteTodos2 = await this.checkSessionTodos(sessionID);
+            if (hasIncompleteTodos2) {
+              log("[background-agent] Task has incomplete todos via polling, waiting:", task.id);
+              continue;
+            }
+            if (this.isStepLimitExceeded(task)) {
+              await this.tryCompleteTask(task, `step limit via polling (${task.maxSteps} steps)`);
+              continue;
+            }
+            await this.tryCompleteTask(task, "polling (idle status)");
             continue;
-          const elapsedMs = Date.now() - startedAt.getTime();
-          if (elapsedMs >= MIN_STABILITY_TIME_MS) {
-            if (task.lastMsgCount === currentMsgCount) {
-              task.stablePolls = (task.stablePolls ?? 0) + 1;
-              if (task.stablePolls >= 3) {
-                const recheckStatus = await this.client.session.status();
-                const recheckData = recheckStatus.data ?? {};
-                const currentStatus = recheckData[sessionID];
-                if (currentStatus?.type !== "idle") {
-                  log("[background-agent] Stability reached but session not idle, resetting:", {
-                    taskId: task.id,
-                    sessionStatus: currentStatus?.type ?? "not_in_status"
-                  });
-                  task.stablePolls = 0;
-                  continue;
+          }
+          const messagesResult = await this.client.session.messages({
+            path: { id: sessionID }
+          });
+          if (!messagesResult.error && messagesResult.data) {
+            const messages = messagesResult.data;
+            const assistantMsgs = messages.filter((m) => m.info?.role === "assistant");
+            let toolCalls = 0;
+            let lastTool;
+            let lastMessage;
+            for (const msg of assistantMsgs) {
+              const parts = msg.parts ?? [];
+              for (const part of parts) {
+                if (part.type === "tool_use" || part.tool) {
+                  toolCalls++;
+                  lastTool = part.tool || part.name || "unknown";
                 }
-                const hasValidOutput = await this.validateSessionHasOutput(sessionID);
-                if (!hasValidOutput) {
-                  log("[background-agent] Stability reached but no valid output, waiting:", task.id);
-                  continue;
+                if (part.type === "text" && part.text) {
+                  lastMessage = part.text;
                 }
-                if (task.status !== "running")
-                  continue;
-                const hasIncompleteTodos2 = await this.checkSessionTodos(sessionID);
-                if (!hasIncompleteTodos2) {
-                  await this.tryCompleteTask(task, "stability detection");
-                  continue;
+              }
+            }
+            if (!task.progress) {
+              task.progress = { toolCalls: 0, lastUpdate: new Date };
+            }
+            if (task.startedAt && !task.progress.phaseTiming) {
+              const now = Date.now();
+              task.progress.phaseTiming = {
+                queueWaitMs: task.queuedAt ? now - task.queuedAt.getTime() : 0,
+                totalRunMs: now - task.startedAt.getTime(),
+                toolCallCount: 0
+              };
+            }
+            if (task.progress.phaseTiming && task.progress.phaseTiming.firstResponseMs === undefined && assistantMsgs.length > 0) {
+              task.progress.phaseTiming.firstResponseMs = Date.now() - task.startedAt.getTime();
+            }
+            task.progress.toolCalls = toolCalls;
+            task.progress.lastTool = lastTool;
+            task.progress.lastUpdate = new Date;
+            if (lastMessage) {
+              task.progress.lastMessage = lastMessage;
+              task.progress.lastMessageAt = new Date;
+            }
+            const currentMsgCount = messages.length;
+            const startedAt = task.startedAt;
+            if (!startedAt)
+              continue;
+            const elapsedMs = Date.now() - startedAt.getTime();
+            if (elapsedMs >= MIN_STABILITY_TIME_MS) {
+              if (task.lastMsgCount === currentMsgCount) {
+                task.stablePolls = (task.stablePolls ?? 0) + 1;
+                if (task.stablePolls >= 3) {
+                  const recheckStatus = await this.client.session.status();
+                  const recheckData = recheckStatus.data ?? {};
+                  const currentStatus = recheckData[sessionID];
+                  if (currentStatus?.type !== "idle") {
+                    log("[background-agent] Stability reached but session not idle, resetting:", {
+                      taskId: task.id,
+                      sessionStatus: currentStatus?.type ?? "not_in_status"
+                    });
+                    task.stablePolls = 0;
+                    continue;
+                  }
+                  const hasValidOutput = await this.validateSessionHasOutput(sessionID);
+                  if (!hasValidOutput) {
+                    log("[background-agent] Stability reached but no valid output, waiting:", task.id);
+                    continue;
+                  }
+                  if (task.status !== "running")
+                    continue;
+                  if (this.isStepLimitExceeded(task)) {
+                    await this.tryCompleteTask(task, `step limit via stability (${task.maxSteps} steps)`);
+                    continue;
+                  }
+                  const hasIncompleteTodos2 = await this.checkSessionTodos(sessionID);
+                  if (!hasIncompleteTodos2) {
+                    await this.tryCompleteTask(task, "stability detection");
+                    continue;
+                  }
                 }
+              } else {
+                task.stablePolls = 0;
               }
-            } else {
-              task.stablePolls = 0;
             }
+            task.lastMsgCount = currentMsgCount;
           }
-          task.lastMsgCount = currentMsgCount;
+        } catch (error45) {
+          log("[background-agent] Poll error for task:", { taskId: task.id, error: error45 });
         }
-      } catch (error45) {
-        log("[background-agent] Poll error for task:", { taskId: task.id, error: error45 });
       }
-    }
-    if (!this.hasRunningTasks()) {
-      this.stopPolling();
-      if (this.perfAggregator.taskCount >= 2) {
-        const report = this.perfAggregator.getReport();
-        log("[perf] Session report:", report);
+      if (!this.hasRunningTasks()) {
+        this.stopPolling();
+        if (this.perfAggregator.taskCount >= 2) {
+          const report = this.perfAggregator.getReport();
+          log("[perf] Session report:", report);
+        }
+      }
+    } finally {
+      if (start !== undefined) {
+        const duration3 = performance.now() - start;
+        this.perfTracer.recordPolling(duration3, this.getRunningTasks().length, new Set(...this.tasks.values().map((t) => t.parentSessionID).filter(Boolean)).size);
       }
     }
   }
@@ -44686,14 +45206,14 @@ function registerProcessSignal(signal, handler, exitAfter) {
   return listener;
 }
 function getMessageDir10(sessionID) {
-  if (!existsSync46(MESSAGE_STORAGE))
+  if (!existsSync49(MESSAGE_STORAGE))
     return null;
-  const directPath = join55(MESSAGE_STORAGE, sessionID);
-  if (existsSync46(directPath))
+  const directPath = join57(MESSAGE_STORAGE, sessionID);
+  if (existsSync49(directPath))
     return directPath;
-  for (const dir of readdirSync16(MESSAGE_STORAGE)) {
-    const sessionPath = join55(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync46(sessionPath))
+  for (const dir of readdirSync18(MESSAGE_STORAGE)) {
+    const sessionPath = join57(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync49(sessionPath))
       return sessionPath;
   }
   return null;
@@ -62607,6 +63127,7 @@ var HookNameSchema = exports_external2.enum([
   "edit-error-recovery",
   "delegate-task-retry",
   "prometheus-md-only",
+  "perf-profiler",
   "start-work",
   "atlas"
 ]);
@@ -62720,11 +63241,21 @@ var DynamicContextPruningConfigSchema = exports_external2.object({
     }).optional()
   }).optional()
 });
+var ProfilingConfigSchema = exports_external2.object({
+  enabled: exports_external2.boolean().default(false),
+  output_dir: exports_external2.string().optional(),
+  slow_threshold_ms: exports_external2.number().default(100),
+  memory_snapshot_interval: exports_external2.number().default(5),
+  trace_api: exports_external2.boolean().default(true),
+  trace_fileio: exports_external2.boolean().default(true),
+  trace_polling: exports_external2.boolean().default(true)
+});
 var ExperimentalConfigSchema = exports_external2.object({
   aggressive_truncation: exports_external2.boolean().optional(),
   auto_resume: exports_external2.boolean().optional(),
   truncate_all_tool_outputs: exports_external2.boolean().optional(),
-  dynamic_context_pruning: DynamicContextPruningConfigSchema.optional()
+  dynamic_context_pruning: DynamicContextPruningConfigSchema.optional(),
+  profiling: ProfilingConfigSchema.optional()
 });
 var SkillSourceSchema = exports_external2.union([
   exports_external2.string(),
@@ -62769,7 +63300,10 @@ var BackgroundTaskConfigSchema = exports_external2.object({
   defaultConcurrency: exports_external2.number().min(1).optional(),
   providerConcurrency: exports_external2.record(exports_external2.string(), exports_external2.number().min(0)).optional(),
   modelConcurrency: exports_external2.record(exports_external2.string(), exports_external2.number().min(0)).optional(),
-  staleTimeoutMs: exports_external2.number().min(60000).optional()
+  staleTimeoutMs: exports_external2.number().min(60000).optional(),
+  maxSteps: exports_external2.number().min(0).optional(),
+  maxRuntimeMs: exports_external2.number().min(0).optional(),
+  stepTimeoutMs: exports_external2.number().min(0).optional()
 });
 var NotificationConfigSchema = exports_external2.object({
   force_enable: exports_external2.boolean().optional()
@@ -64864,21 +65398,21 @@ TODO \u5217\u8868\uFF1A[\u8DEF\u5F84]
 
 **\u5BF9\u4E8E\u63A2\u7D22\uFF08explore/librarian\uFF09**\uFF1A\u59CB\u7EC8\u540E\u53F0\u8FD0\u884C
 \`\`\`typescript
-delegate_task(subagent_type="explore", run_in_background=true, ...)
-delegate_task(subagent_type="librarian", run_in_background=true, ...)
+delegate_task(subagent_type="explore", run_in_background=true, load_skills=[], ...)
+delegate_task(subagent_type="librarian", run_in_background=true, load_skills=[], ...)
 \`\`\`
 
 **\u5BF9\u4E8E\u4EFB\u52A1\u6267\u884C**\uFF1A\u7EDD\u4E0D\u7528\u540E\u53F0\u8FD0\u884C
 \`\`\`typescript
-delegate_task(category="...", run_in_background=false, ...)
+delegate_task(category="...", run_in_background=false, load_skills=[], ...)
 \`\`\`
 
 **\u5E76\u884C\u4EFB\u52A1\u7EC4**\uFF1A\u5728\u4E00\u6761\u6D88\u606F\u4E2D\u591A\u6B21\u8C03\u7528
 \`\`\`typescript
 // \u4EFB\u52A12\u30013\u30014\u662F\u72EC\u7ACB\u7684\u2014\u2014\u4E00\u8D77\u8C03\u7528
-delegate_task(category="quick", prompt="\u4EFB\u52A12...")
-delegate_task(category="quick", prompt="\u4EFB\u52A13...")
-delegate_task(category="quick", prompt="\u4EFB\u52A14...")
+delegate_task(category="quick", prompt="\u4EFB\u52A12...", load_skills=[])
+delegate_task(category="quick", prompt="\u4EFB\u52A13...", load_skills=[])
+delegate_task(category="quick", prompt="\u4EFB\u52A14...", load_skills=[])
 \`\`\`
 
 **\u540E\u53F0\u7BA1\u7406**\uFF1A
@@ -65753,7 +66287,7 @@ init_file_utils();
 init_shared();
 init_logger();
 import { promises as fs11 } from "fs";
-import { join as join57, basename as basename6 } from "path";
+import { join as join59, basename as basename6 } from "path";
 async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "") {
   try {
     await fs11.access(commandsDir);
@@ -65783,7 +66317,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     if (entry.isDirectory()) {
       if (entry.name.startsWith("."))
         continue;
-      const subDirPath = join57(commandsDir, entry.name);
+      const subDirPath = join59(commandsDir, entry.name);
       const subPrefix = prefix ? `${prefix}:${entry.name}` : entry.name;
       const subCommands = await loadCommandsFromDir(subDirPath, scope, visited, subPrefix);
       commands2.push(...subCommands);
@@ -65791,7 +66325,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     }
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join57(commandsDir, entry.name);
+    const commandPath = join59(commandsDir, entry.name);
     const baseCommandName = basename6(entry.name, ".md");
     const commandName = prefix ? `${prefix}:${baseCommandName}` : baseCommandName;
     try {
@@ -65838,23 +66372,23 @@ function commandsToRecord(commands2) {
   return result;
 }
 async function loadUserCommands() {
-  const userCommandsDir = join57(getClaudeConfigDir(), "commands");
+  const userCommandsDir = join59(getClaudeConfigDir(), "commands");
   const commands2 = await loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands2);
 }
 async function loadProjectCommands() {
-  const projectCommandsDir = join57(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join59(process.cwd(), ".claude", "commands");
   const commands2 = await loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands2);
 }
 async function loadOpencodeGlobalCommands() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeCommandsDir = join57(configDir, "command");
+  const opencodeCommandsDir = join59(configDir, "command");
   const commands2 = await loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands2);
 }
 async function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join57(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join59(process.cwd(), ".opencode", "command");
   const commands2 = await loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands2);
 }
@@ -65862,8 +66396,8 @@ async function loadOpencodeProjectCommands() {
 init_frontmatter();
 init_file_utils();
 init_shared();
-import { existsSync as existsSync48, readdirSync as readdirSync17, readFileSync as readFileSync30 } from "fs";
-import { join as join58, basename as basename7 } from "path";
+import { existsSync as existsSync51, readdirSync as readdirSync19, readFileSync as readFileSync31 } from "fs";
+import { join as join60, basename as basename7 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -65877,18 +66411,18 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync48(agentsDir)) {
+  if (!existsSync51(agentsDir)) {
     return [];
   }
-  const entries = readdirSync17(agentsDir, { withFileTypes: true });
+  const entries = readdirSync19(agentsDir, { withFileTypes: true });
   const agents = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join58(agentsDir, entry.name);
+    const agentPath = join60(agentsDir, entry.name);
     const agentName = basename7(entry.name, ".md");
     try {
-      const content = readFileSync30(agentPath, "utf-8");
+      const content = readFileSync31(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -65915,7 +66449,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join58(getClaudeConfigDir(), "agents");
+  const userAgentsDir = join60(getClaudeConfigDir(), "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -65924,7 +66458,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents() {
-  const projectAgentsDir = join58(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join60(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -65936,18 +66470,18 @@ function loadProjectAgents() {
 init_frontmatter();
 init_file_utils();
 init_logger();
-import { existsSync as existsSync49, readdirSync as readdirSync18, readFileSync as readFileSync31 } from "fs";
+import { existsSync as existsSync52, readdirSync as readdirSync20, readFileSync as readFileSync32 } from "fs";
 import { homedir as homedir13 } from "os";
-import { join as join59, basename as basename8 } from "path";
+import { join as join61, basename as basename8 } from "path";
 var CLAUDE_PLUGIN_ROOT_VAR = "${CLAUDE_PLUGIN_ROOT}";
 function getPluginsBaseDir() {
   if (process.env.CLAUDE_PLUGINS_HOME) {
     return process.env.CLAUDE_PLUGINS_HOME;
   }
-  return join59(homedir13(), ".claude", "plugins");
+  return join61(homedir13(), ".claude", "plugins");
 }
 function getInstalledPluginsPath() {
-  return join59(getPluginsBaseDir(), "installed_plugins.json");
+  return join61(getPluginsBaseDir(), "installed_plugins.json");
 }
 function resolvePluginPath(path8, pluginRoot) {
   return path8.replace(CLAUDE_PLUGIN_ROOT_VAR, pluginRoot);
@@ -65972,11 +66506,11 @@ function resolvePluginPaths(obj, pluginRoot) {
 }
 function loadInstalledPlugins() {
   const dbPath = getInstalledPluginsPath();
-  if (!existsSync49(dbPath)) {
+  if (!existsSync52(dbPath)) {
     return null;
   }
   try {
-    const content = readFileSync31(dbPath, "utf-8");
+    const content = readFileSync32(dbPath, "utf-8");
     return JSON.parse(content);
   } catch (error92) {
     log("Failed to load installed plugins database", error92);
@@ -65987,15 +66521,15 @@ function getClaudeSettingsPath() {
   if (process.env.CLAUDE_SETTINGS_PATH) {
     return process.env.CLAUDE_SETTINGS_PATH;
   }
-  return join59(homedir13(), ".claude", "settings.json");
+  return join61(homedir13(), ".claude", "settings.json");
 }
 function loadClaudeSettings() {
   const settingsPath = getClaudeSettingsPath();
-  if (!existsSync49(settingsPath)) {
+  if (!existsSync52(settingsPath)) {
     return null;
   }
   try {
-    const content = readFileSync31(settingsPath, "utf-8");
+    const content = readFileSync32(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch (error92) {
     log("Failed to load Claude settings", error92);
@@ -66003,12 +66537,12 @@ function loadClaudeSettings() {
   }
 }
 function loadPluginManifest(installPath) {
-  const manifestPath = join59(installPath, ".claude-plugin", "plugin.json");
-  if (!existsSync49(manifestPath)) {
+  const manifestPath = join61(installPath, ".claude-plugin", "plugin.json");
+  if (!existsSync52(manifestPath)) {
     return null;
   }
   try {
-    const content = readFileSync31(manifestPath, "utf-8");
+    const content = readFileSync32(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error92) {
     log(`Failed to load plugin manifest from ${manifestPath}`, error92);
@@ -66055,7 +66589,7 @@ function discoverInstalledPlugins(options) {
       continue;
     }
     const { installPath, scope, version: version3 } = installation;
-    if (!existsSync49(installPath)) {
+    if (!existsSync52(installPath)) {
       errors5.push({
         pluginKey,
         installPath,
@@ -66073,21 +66607,21 @@ function discoverInstalledPlugins(options) {
       pluginKey,
       manifest: manifest ?? undefined
     };
-    if (existsSync49(join59(installPath, "commands"))) {
-      loadedPlugin.commandsDir = join59(installPath, "commands");
+    if (existsSync52(join61(installPath, "commands"))) {
+      loadedPlugin.commandsDir = join61(installPath, "commands");
     }
-    if (existsSync49(join59(installPath, "agents"))) {
-      loadedPlugin.agentsDir = join59(installPath, "agents");
+    if (existsSync52(join61(installPath, "agents"))) {
+      loadedPlugin.agentsDir = join61(installPath, "agents");
     }
-    if (existsSync49(join59(installPath, "skills"))) {
-      loadedPlugin.skillsDir = join59(installPath, "skills");
+    if (existsSync52(join61(installPath, "skills"))) {
+      loadedPlugin.skillsDir = join61(installPath, "skills");
     }
-    const hooksPath = join59(installPath, "hooks", "hooks.json");
-    if (existsSync49(hooksPath)) {
+    const hooksPath = join61(installPath, "hooks", "hooks.json");
+    if (existsSync52(hooksPath)) {
       loadedPlugin.hooksPath = hooksPath;
     }
-    const mcpPath = join59(installPath, ".mcp.json");
-    if (existsSync49(mcpPath)) {
+    const mcpPath = join61(installPath, ".mcp.json");
+    if (existsSync52(mcpPath)) {
       loadedPlugin.mcpPath = mcpPath;
     }
     plugins.push(loadedPlugin);
@@ -66098,17 +66632,17 @@ function discoverInstalledPlugins(options) {
 function loadPluginCommands(plugins) {
   const commands2 = {};
   for (const plugin of plugins) {
-    if (!plugin.commandsDir || !existsSync49(plugin.commandsDir))
+    if (!plugin.commandsDir || !existsSync52(plugin.commandsDir))
       continue;
-    const entries = readdirSync18(plugin.commandsDir, { withFileTypes: true });
+    const entries = readdirSync20(plugin.commandsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const commandPath = join59(plugin.commandsDir, entry.name);
+      const commandPath = join61(plugin.commandsDir, entry.name);
       const commandName = basename8(entry.name, ".md");
       const namespacedName = `${plugin.name}:${commandName}`;
       try {
-        const content = readFileSync31(commandPath, "utf-8");
+        const content = readFileSync32(commandPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -66140,21 +66674,21 @@ $ARGUMENTS
 function loadPluginSkillsAsCommands(plugins) {
   const skills = {};
   for (const plugin of plugins) {
-    if (!plugin.skillsDir || !existsSync49(plugin.skillsDir))
+    if (!plugin.skillsDir || !existsSync52(plugin.skillsDir))
       continue;
-    const entries = readdirSync18(plugin.skillsDir, { withFileTypes: true });
+    const entries = readdirSync20(plugin.skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith("."))
         continue;
-      const skillPath = join59(plugin.skillsDir, entry.name);
+      const skillPath = join61(plugin.skillsDir, entry.name);
       if (!entry.isDirectory() && !entry.isSymbolicLink())
         continue;
       const resolvedPath = resolveSymlink(skillPath);
-      const skillMdPath = join59(resolvedPath, "SKILL.md");
-      if (!existsSync49(skillMdPath))
+      const skillMdPath = join61(resolvedPath, "SKILL.md");
+      if (!existsSync52(skillMdPath))
         continue;
       try {
-        const content = readFileSync31(skillMdPath, "utf-8");
+        const content = readFileSync32(skillMdPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const skillName = data.name || entry.name;
         const namespacedName = `${plugin.name}:${skillName}`;
@@ -66201,17 +66735,17 @@ function parseToolsConfig2(toolsStr) {
 function loadPluginAgents(plugins) {
   const agents = {};
   for (const plugin of plugins) {
-    if (!plugin.agentsDir || !existsSync49(plugin.agentsDir))
+    if (!plugin.agentsDir || !existsSync52(plugin.agentsDir))
       continue;
-    const entries = readdirSync18(plugin.agentsDir, { withFileTypes: true });
+    const entries = readdirSync20(plugin.agentsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const agentPath = join59(plugin.agentsDir, entry.name);
+      const agentPath = join61(plugin.agentsDir, entry.name);
       const agentName = basename8(entry.name, ".md");
       const namespacedName = `${plugin.name}:${agentName}`;
       try {
-        const content = readFileSync31(agentPath, "utf-8");
+        const content = readFileSync32(agentPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const name = data.name || agentName;
         const originalDescription = data.description || "";
@@ -66237,7 +66771,7 @@ function loadPluginAgents(plugins) {
 async function loadPluginMcpServers(plugins) {
   const servers = {};
   for (const plugin of plugins) {
-    if (!plugin.mcpPath || !existsSync49(plugin.mcpPath))
+    if (!plugin.mcpPath || !existsSync52(plugin.mcpPath))
       continue;
     try {
       const content = await Bun.file(plugin.mcpPath).text();
@@ -66269,10 +66803,10 @@ async function loadPluginMcpServers(plugins) {
 function loadPluginHooksConfigs(plugins) {
   const configs = [];
   for (const plugin of plugins) {
-    if (!plugin.hooksPath || !existsSync49(plugin.hooksPath))
+    if (!plugin.hooksPath || !existsSync52(plugin.hooksPath))
       continue;
     try {
-      const content = readFileSync31(plugin.hooksPath, "utf-8");
+      const content = readFileSync32(plugin.hooksPath, "utf-8");
       let config4 = JSON.parse(content);
       config4 = resolvePluginPaths(config4, plugin.installPath);
       configs.push(config4);
@@ -66658,8 +67192,8 @@ Prometheus\uFF1A"\u5FEB\u901F\u4FEE\u590D\u2014\u2014\u6211\u770B\u5230\u62FC\u5
 
 **\u5148\u505A\u7814\u7A76\uFF1A**
 \`\`\`typescript
-delegate_task(subagent_type="explore", prompt="\u4F7F\u7528 lsp_find_references \u6A21\u5F0F\u67E5\u627E [\u76EE\u6807] \u7684\u6240\u6709\u4F7F\u7528\u4F4D\u7F6E...", run_in_background=true)
-delegate_task(subagent_type="explore", prompt="\u67E5\u627E [\u53D7\u5F71\u54CD\u4EE3\u7801] \u7684\u6D4B\u8BD5\u8986\u76D6\u7387...", run_in_background=true)
+delegate_task(subagent_type="explore", prompt="\u4F7F\u7528 lsp_find_references \u6A21\u5F0F\u67E5\u627E [\u76EE\u6807] \u7684\u6240\u6709\u4F7F\u7528\u4F4D\u7F6E...", run_in_background=true, load_skills=[])
+delegate_task(subagent_type="explore", prompt="\u67E5\u627E [\u53D7\u5F71\u54CD\u4EE3\u7801] \u7684\u6D4B\u8BD5\u8986\u76D6\u7387...", run_in_background=true, load_skills=[])
 \`\`\`
 
 **\u8BBF\u8C08\u91CD\u70B9\uFF1A**
@@ -66682,9 +67216,9 @@ delegate_task(subagent_type="explore", prompt="\u67E5\u627E [\u53D7\u5F71\u54CD\
 **\u8BBF\u8C08\u524D\u7814\u7A76\uFF08\u5F3A\u5236\u8981\u6C42\uFF09\uFF1A**
 \`\`\`typescript
 // \u5728\u5411\u7528\u6237\u63D0\u95EE\u4E4B\u524D\u542F\u52A8
-delegate_task(subagent_type="explore", prompt="\u5728\u4EE3\u7801\u5E93\u4E2D\u67E5\u627E\u7C7B\u4F3C\u5B9E\u73B0...", run_in_background=true)
-delegate_task(subagent_type="explore", prompt="\u67E5\u627E [\u529F\u80FD\u7C7B\u578B] \u7684\u9879\u76EE\u6A21\u5F0F...", run_in_background=true)
-delegate_task(subagent_type="librarian", prompt="\u67E5\u627E [\u6280\u672F] \u7684\u6700\u4F73\u5B9E\u8DF5...", run_in_background=true)
+delegate_task(subagent_type="explore", prompt="\u5728\u4EE3\u7801\u5E93\u4E2D\u67E5\u627E\u7C7B\u4F3C\u5B9E\u73B0...", run_in_background=true, load_skills=[])
+delegate_task(subagent_type="explore", prompt="\u67E5\u627E [\u529F\u80FD\u7C7B\u578B] \u7684\u9879\u76EE\u6A21\u5F0F...", run_in_background=true, load_skills=[])
+delegate_task(subagent_type="librarian", prompt="\u67E5\u627E [\u6280\u672F] \u7684\u6700\u4F73\u5B9E\u8DF5...", run_in_background=true, load_skills=[])
 \`\`\`
 
 **\u8BBF\u8C08\u91CD\u70B9**\uFF08\u7814\u7A76\u4E4B\u540E\uFF09\uFF1A
@@ -66723,7 +67257,7 @@ Prometheus\uFF1A"\u6211\u53D1\u73B0\u4E86\u4E00\u4E9B\u60C5\u51B5\uFF1A
 
 \u8FD0\u884C\u6B64\u68C0\u67E5\uFF1A
 \`\`\`typescript
-delegate_task(subagent_type="explore", prompt="\u67E5\u627E\u6D4B\u8BD5\u57FA\u7840\u8BBE\u65BD\uFF1Apackage.json \u4E2D\u7684\u6D4B\u8BD5\u811A\u672C\u3001\u6D4B\u8BD5\u914D\u7F6E\u6587\u4EF6\uFF08jest.config\u3001vitest.config\u3001pytest.ini \u7B49\uFF09\u3001\u73B0\u6709\u6D4B\u8BD5\u6587\u4EF6\uFF08*.test.*\u3001*.spec.*\u3001test_*\uFF09\u3002\u62A5\u544A\uFF1A1\uFF09\u662F\u5426\u5B58\u5728\u6D4B\u8BD5\u57FA\u7840\u8BBE\u65BD\uFF1F2\uFF09\u4F7F\u7528\u4EC0\u4E48\u6846\u67B6\uFF1F3\uFF09\u793A\u4F8B\u6D4B\u8BD5\u6587\u4EF6\u6A21\u5F0F\u3002", run_in_background=true)
+delegate_task(subagent_type="explore", prompt="\u67E5\u627E\u6D4B\u8BD5\u57FA\u7840\u8BBE\u65BD\uFF1Apackage.json \u4E2D\u7684\u6D4B\u8BD5\u811A\u672C\u3001\u6D4B\u8BD5\u914D\u7F6E\u6587\u4EF6\uFF08jest.config\u3001vitest.config\u3001pytest.ini \u7B49\uFF09\u3001\u73B0\u6709\u6D4B\u8BD5\u6587\u4EF6\uFF08*.test.*\u3001*.spec.*\u3001test_*\uFF09\u3002\u62A5\u544A\uFF1A1\uFF09\u662F\u5426\u5B58\u5728\u6D4B\u8BD5\u57FA\u7840\u8BBE\u65BD\uFF1F2\uFF09\u4F7F\u7528\u4EC0\u4E48\u6846\u67B6\uFF1F3\uFF09\u793A\u4F8B\u6D4B\u8BD5\u6587\u4EF6\u6A21\u5F0F\u3002", run_in_background=true, load_skills=[])
 \`\`\`
 
 #### \u7B2C2\u6B65\uFF1A\u8BE2\u95EE\u6D4B\u8BD5\u95EE\u9898\uFF08\u5F3A\u5236\u8981\u6C42\uFF09
@@ -66812,13 +67346,13 @@ delegate_task(subagent_type="explore", prompt="\u67E5\u627E\u6D4B\u8BD5\u57FA\u7
 
 **\u5148\u505A\u7814\u7A76\uFF1A**
 \`\`\`typescript
-delegate_task(subagent_type="explore", prompt="\u67E5\u627E\u5F53\u524D\u7CFB\u7EDF\u67B6\u6784\u548C\u6A21\u5F0F...", run_in_background=true)
-delegate_task(subagent_type="librarian", prompt="\u67E5\u627E [\u9886\u57DF] \u7684\u67B6\u6784\u6700\u4F73\u5B9E\u8DF5...", run_in_background=true)
+delegate_task(subagent_type="explore", prompt="\u67E5\u627E\u5F53\u524D\u7CFB\u7EDF\u67B6\u6784\u548C\u6A21\u5F0F...", run_in_background=true, load_skills=[])
+delegate_task(subagent_type="librarian", prompt="\u67E5\u627E [\u9886\u57DF] \u7684\u67B6\u6784\u6700\u4F73\u5B9E\u8DF5...", run_in_background=true, load_skills=[])
 \`\`\`
 
 **Oracle \u54A8\u8BE2**\uFF08\u5F53\u98CE\u9669\u8F83\u9AD8\u65F6\u63A8\u8350\uFF09\uFF1A
 \`\`\`typescript
-delegate_task(subagent_type="oracle", prompt="\u9700\u8981\u67B6\u6784\u54A8\u8BE2\uFF1A[\u4E0A\u4E0B\u6587]...", run_in_background=false)
+delegate_task(subagent_type="oracle", prompt="\u9700\u8981\u67B6\u6784\u54A8\u8BE2\uFF1A[\u4E0A\u4E0B\u6587]...", run_in_background=false, load_skills=[])
 \`\`\`
 
 **\u8BBF\u8C08\u91CD\u70B9\uFF1A**
@@ -66835,9 +67369,9 @@ delegate_task(subagent_type="oracle", prompt="\u9700\u8981\u67B6\u6784\u54A8\u8B
 
 **\u5E76\u884C\u8C03\u7814\uFF1A**
 \`\`\`typescript
-delegate_task(subagent_type="explore", prompt="\u67E5\u627E X \u5F53\u524D\u662F\u5982\u4F55\u5904\u7406\u7684...", run_in_background=true)
-delegate_task(subagent_type="librarian", prompt="\u67E5\u627E Y \u7684\u5B98\u65B9\u6587\u6863...", run_in_background=true)
-delegate_task(subagent_type="librarian", prompt="\u67E5\u627E Z \u7684\u5F00\u6E90\u5B9E\u73B0...", run_in_background=true)
+delegate_task(subagent_type="explore", prompt="\u67E5\u627E X \u5F53\u524D\u662F\u5982\u4F55\u5904\u7406\u7684...", run_in_background=true, load_skills=[])
+delegate_task(subagent_type="librarian", prompt="\u67E5\u627E Y \u7684\u5B98\u65B9\u6587\u6863...", run_in_background=true, load_skills=[])
+delegate_task(subagent_type="librarian", prompt="\u67E5\u627E Z \u7684\u5F00\u6E90\u5B9E\u73B0...", run_in_background=true, load_skills=[])
 \`\`\`
 
 **\u8BBF\u8C08\u91CD\u70B9\uFF1A**
@@ -66863,17 +67397,17 @@ delegate_task(subagent_type="librarian", prompt="\u67E5\u627E Z \u7684\u5F00\u6E
 
 **\u7528\u4E8E\u7406\u89E3\u4EE3\u7801\u5E93\uFF1A**
 \`\`\`typescript
-delegate_task(subagent_type="explore", prompt="\u67E5\u627E\u4E0E [\u4E3B\u9898] \u76F8\u5173\u7684\u6240\u6709\u6587\u4EF6\u3002\u5C55\u793A\u6A21\u5F0F\u3001\u7EA6\u5B9A\u548C\u7ED3\u6784\u3002", run_in_background=true)
+delegate_task(subagent_type="explore", prompt="\u67E5\u627E\u4E0E [\u4E3B\u9898] \u76F8\u5173\u7684\u6240\u6709\u6587\u4EF6\u3002\u5C55\u793A\u6A21\u5F0F\u3001\u7EA6\u5B9A\u548C\u7ED3\u6784\u3002", run_in_background=true, load_skills=[])
 \`\`\`
 
 **\u7528\u4E8E\u5916\u90E8\u77E5\u8BC6\uFF1A**
 \`\`\`typescript
-delegate_task(subagent_type="librarian", prompt="\u67E5\u627E [\u5E93] \u7684\u5B98\u65B9\u6587\u6863\u3002\u91CD\u70B9\u5173\u6CE8 [\u7279\u5B9A\u529F\u80FD] \u548C\u6700\u4F73\u5B9E\u8DF5\u3002", run_in_background=true)
+delegate_task(subagent_type="librarian", prompt="\u67E5\u627E [\u5E93] \u7684\u5B98\u65B9\u6587\u6863\u3002\u91CD\u70B9\u5173\u6CE8 [\u7279\u5B9A\u529F\u80FD] \u548C\u6700\u4F73\u5B9E\u8DF5\u3002", run_in_background=true, load_skills=[])
 \`\`\`
 
 **\u7528\u4E8E\u5B9E\u73B0\u793A\u4F8B\uFF1A**
 \`\`\`typescript
-delegate_task(subagent_type="librarian", prompt="\u67E5\u627E [\u529F\u80FD] \u7684\u5F00\u6E90\u5B9E\u73B0\u3002\u5BFB\u627E\u751F\u4EA7\u8D28\u91CF\u7684\u793A\u4F8B\u3002", run_in_background=true)
+delegate_task(subagent_type="librarian", prompt="\u67E5\u627E [\u529F\u80FD] \u7684\u5F00\u6E90\u5B9E\u73B0\u3002\u5BFB\u627E\u751F\u4EA7\u8D28\u91CF\u7684\u793A\u4F8B\u3002", run_in_background=true, load_skills=[])
 \`\`\`
 
 ## \u8BBF\u8C08\u6A21\u5F0F\u53CD\u6A21\u5F0F
@@ -66971,6 +67505,7 @@ todoWrite([
 \`\`\`typescript
 delegate_task(
   subagent_type="metis",
+  load_skills=[],
   prompt=\`\u5728\u6211\u751F\u6210\u5DE5\u4F5C\u8BA1\u5212\u4E4B\u524D\uFF0C\u5BA1\u67E5\u8FD9\u6B21\u89C4\u5212\u4F1A\u8BDD\uFF1A
 
   **\u7528\u6237\u76EE\u6807**\uFF1A{\u603B\u7ED3\u7528\u6237\u60F3\u8981\u4EC0\u4E48}
@@ -67138,7 +67673,7 @@ while (true) {
   const result = delegate_task(
     subagent_type="momus",
     prompt=".sisyphus/plans/{name}.md",
-    run_in_background=false
+    run_in_background=false, load_skills=[]
   )
 
   if (result.verdict === "OKAY") {
@@ -67798,11 +68333,56 @@ function createConfigHandler(deps) {
     };
   };
 }
+// src/index.ts
+init_perf_tracer();
+init_fileio_monitor();
+
+// src/tools/perf-profiler/client-patch.ts
+function patchSessionClient(client2, tracer) {
+  if (!tracer.isEnabled())
+    return;
+  const session = client2.session;
+  if (!session || typeof session !== "object")
+    return;
+  function wrap(methodName, extractMessageCount) {
+    const original = session[methodName];
+    if (typeof original !== "function")
+      return;
+    session[methodName] = async function(opts) {
+      const start = performance.now();
+      let error92;
+      try {
+        const result = await original.call(session, opts);
+        const durationMs = performance.now() - start;
+        tracer.recordApiCall(methodName, durationMs, opts?.path?.id ?? "", extractMessageCount ? extractMessageCount(result) : undefined);
+        return result;
+      } catch (err) {
+        const durationMs = performance.now() - start;
+        error92 = err instanceof Error ? err.message : String(err);
+        tracer.recordApiCall(methodName, durationMs, opts?.path?.id ?? "", undefined, error92);
+        throw err;
+      }
+    };
+  }
+  wrap("messages", (r) => r?.data?.length ?? undefined);
+  wrap("prompt", (r) => r?.data ? 1 : undefined);
+  wrap("todo", (r) => r?.data?.length ?? undefined);
+  wrap("status", (r) => r?.data ? Object.keys(r.data).length : undefined);
+  wrap("summarize");
+}
+
 // src/index.ts
 var OhMyOpenCodePlugin = async (ctx) => {
   log("[OhMyOpenCodePlugin] ENTRY - plugin loading", { directory: ctx.directory });
   startBackgroundCheck2();
   const pluginConfig = loadPluginConfig(ctx.directory, ctx);
+  if (process.platform === "win32") {
+    const reservedNames = scanForReservedNames(ctx.directory, 3);
+    if (reservedNames.length > 0) {
+      console.warn(formatReservedNamesWarning(reservedNames));
+      log("[oh-my-opencode] Windows reserved device names detected:", reservedNames);
+    }
+  }
   const disabledHooks = new Set(pluginConfig.disabled_hooks ?? []);
   const firstMessageVariantGate = createFirstMessageVariantGate();
   const isHookEnabled = (hookName) => !disabledHooks.has(hookName);
@@ -67863,6 +68443,34 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const taskResumeInfo = createTaskResumeInfoHook();
   const backgroundManager = new BackgroundManager(ctx, pluginConfig.background_task);
   const atlasHook = isHookEnabled("atlas") ? createAtlasHook(ctx, { directory: ctx.directory, backgroundManager }) : null;
+  const perfTracer = pluginConfig.experimental?.profiling?.enabled ? new PerfTracer({
+    enabled: true,
+    outputDir: pluginConfig.experimental.profiling.output_dir,
+    slowThreshold: pluginConfig.experimental.profiling.slow_threshold_ms,
+    memorySnapshotInterval: pluginConfig.experimental.profiling.memory_snapshot_interval
+  }) : new PerfTracer({ enabled: false });
+  const memoryProbes = {};
+  if (perfTracer.isEnabled()) {
+    memoryProbes.subagentSessions = () => subagentSessions.size;
+    memoryProbes.backgroundRunningTasks = () => backgroundManager.getRunningTasks().length;
+    memoryProbes.backgroundCompletedTasks = () => backgroundManager.getCompletedTasks().length;
+  }
+  const perfProfiler = isHookEnabled("perf-profiler") ? createPerfProfilerHook({
+    config: pluginConfig.experimental?.profiling ?? { enabled: false, slow_threshold_ms: 100, memory_snapshot_interval: 5, trace_api: true, trace_fileio: true, trace_polling: true },
+    tracer: perfTracer,
+    memoryProbes
+  }) : null;
+  if (perfTracer.isEnabled()) {
+    try {
+      patchSessionClient(ctx.client, perfTracer);
+    } catch {}
+    try {
+      setFileIOMonitor(createFileIOMonitor(perfTracer));
+    } catch {}
+    try {
+      backgroundManager.setPerfTracer(perfTracer);
+    } catch {}
+  }
   initTaskToastManager(ctx.client);
   const todoContinuationEnforcer = isHookEnabled("todo-continuation-enforcer") ? createTodoContinuationEnforcer(ctx, { backgroundManager }) : null;
   if (sessionRecovery && todoContinuationEnforcer) {
@@ -67927,6 +68535,27 @@ var OhMyOpenCodePlugin = async (ctx) => {
     pluginConfig,
     modelCacheState
   });
+  async function wrapWithTiming(tracer, pipeline2, hookName, fn, sessionID, tool3) {
+    const start = performance.now();
+    let error92;
+    try {
+      await fn();
+    } catch (e) {
+      error92 = String(e);
+      throw e;
+    } finally {
+      tracer.recordHook(pipeline2, hookName, performance.now() - start, sessionID ?? "", tool3, error92);
+    }
+  }
+  function getEventSessionID(input) {
+    const props = input.event.properties;
+    if (!props)
+      return "";
+    const info = props.info;
+    if (input.event.type === "session.deleted" || input.event.type === "session.created")
+      return info?.id ?? "";
+    return props.sessionID ?? "";
+  }
   return {
     tool: {
       ...builtinTools,
@@ -67953,10 +68582,17 @@ var OhMyOpenCodePlugin = async (ctx) => {
       } else {
         applyAgentVariant(pluginConfig, input.agent, message);
       }
-      await keywordDetector?.["chat.message"]?.(input, output);
-      await claudeCodeHooks["chat.message"]?.(input, output);
-      await autoSlashCommand?.["chat.message"]?.(input, output);
-      await startWork?.["chat.message"]?.(input, output);
+      const pipelineStart = performance.now();
+      let hookCount = 0;
+      await wrapWithTiming(perfTracer, "chat.message", "keywordDetector", () => keywordDetector?.["chat.message"]?.(input, output), input.sessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "chat.message", "claudeCodeHooks", () => claudeCodeHooks["chat.message"]?.(input, output), input.sessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "chat.message", "autoSlashCommand", () => autoSlashCommand?.["chat.message"]?.(input, output), input.sessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "chat.message", "startWork", () => startWork?.["chat.message"]?.(input, output), input.sessionID);
+      hookCount++;
+      perfTracer.recordPipeline("chat.message", performance.now() - pipelineStart, hookCount, input.sessionID);
       if (ralphLoop) {
         const parts = output.parts;
         const promptText = parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
@@ -67986,27 +68622,49 @@ var OhMyOpenCodePlugin = async (ctx) => {
         }
       }
     },
+    "chat.params": async (input, output) => {
+      await thinkMode?.["chat.params"]?.(input, output);
+    },
     "experimental.chat.messages.transform": async (input, output) => {
       await contextInjectorMessagesTransform?.["experimental.chat.messages.transform"]?.(input, output);
       await thinkingBlockValidator?.["experimental.chat.messages.transform"]?.(input, output);
     },
     config: configHandler,
     event: async (input) => {
-      await autoUpdateChecker?.event(input);
-      await claudeCodeHooks.event(input);
-      await backgroundNotificationHook?.event(input);
-      await sessionNotification?.(input);
-      await todoContinuationEnforcer?.handler(input);
-      await contextWindowMonitor?.event(input);
-      await directoryAgentsInjector?.event(input);
-      await directoryReadmeInjector?.event(input);
-      await rulesInjector?.event(input);
-      await thinkMode?.event(input);
-      await anthropicContextWindowLimitRecovery?.event(input);
-      await agentUsageReminder?.event(input);
-      await interactiveBashSession?.event(input);
-      await ralphLoop?.event(input);
-      await atlasHook?.handler(input);
+      const pipelineStart = performance.now();
+      let hookCount = 0;
+      await perfProfiler?.event?.(input);
+      const evtSessionID = getEventSessionID(input);
+      await wrapWithTiming(perfTracer, "event", "autoUpdateChecker", () => autoUpdateChecker?.event(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "claudeCodeHooks", () => claudeCodeHooks.event(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "backgroundNotificationHook", () => backgroundNotificationHook?.event(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "sessionNotification", () => sessionNotification?.(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "todoContinuationEnforcer", () => todoContinuationEnforcer?.handler(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "contextWindowMonitor", () => contextWindowMonitor?.event(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "directoryAgentsInjector", () => directoryAgentsInjector?.event(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "directoryReadmeInjector", () => directoryReadmeInjector?.event(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "rulesInjector", () => rulesInjector?.event(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "thinkMode", () => thinkMode?.event(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "anthropicContextWindowLimitRecovery", () => anthropicContextWindowLimitRecovery?.event(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "agentUsageReminder", () => agentUsageReminder?.event(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "interactiveBashSession", () => interactiveBashSession?.event(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "ralphLoop", () => ralphLoop?.event(input), evtSessionID);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "event", "atlasHook", () => atlasHook?.handler(input), evtSessionID);
+      hookCount++;
       const { event } = input;
       const props = event.properties;
       if (event.type === "session.created") {
@@ -68059,17 +68717,30 @@ var OhMyOpenCodePlugin = async (ctx) => {
           }
         }
       }
+      perfTracer.recordPipeline("event", performance.now() - pipelineStart, hookCount, evtSessionID);
+      perfTracer.flush();
     },
     "tool.execute.before": async (input, output) => {
-      await questionLabelTruncator["tool.execute.before"]?.(input, output);
-      await claudeCodeHooks["tool.execute.before"](input, output);
-      await nonInteractiveEnv?.["tool.execute.before"](input, output);
-      await commentChecker?.["tool.execute.before"](input, output);
-      await directoryAgentsInjector?.["tool.execute.before"]?.(input, output);
-      await directoryReadmeInjector?.["tool.execute.before"]?.(input, output);
-      await rulesInjector?.["tool.execute.before"]?.(input, output);
-      await prometheusMdOnly?.["tool.execute.before"]?.(input, output);
-      await atlasHook?.["tool.execute.before"]?.(input, output);
+      const pipelineStart = performance.now();
+      let hookCount = 0;
+      await wrapWithTiming(perfTracer, "tool.execute.before", "questionLabelTruncator", () => questionLabelTruncator["tool.execute.before"]?.(input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.before", "claudeCodeHooks", () => claudeCodeHooks["tool.execute.before"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.before", "nonInteractiveEnv", () => nonInteractiveEnv?.["tool.execute.before"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.before", "commentChecker", () => commentChecker?.["tool.execute.before"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.before", "directoryAgentsInjector", () => directoryAgentsInjector?.["tool.execute.before"]?.(input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.before", "directoryReadmeInjector", () => directoryReadmeInjector?.["tool.execute.before"]?.(input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.before", "rulesInjector", () => rulesInjector?.["tool.execute.before"]?.(input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.before", "prometheusMdOnly", () => prometheusMdOnly?.["tool.execute.before"]?.(input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.before", "atlasHook", () => atlasHook?.["tool.execute.before"]?.(input, output), input.sessionID, input.tool);
+      hookCount++;
       if (input.tool === "task") {
         const args = output.args;
         const subagentType = args.subagent_type;
@@ -68109,22 +68780,40 @@ var OhMyOpenCodePlugin = async (ctx) => {
           });
         }
       }
+      perfTracer.recordPipeline("tool.execute.before", performance.now() - pipelineStart, hookCount, input.sessionID);
     },
     "tool.execute.after": async (input, output) => {
-      await claudeCodeHooks["tool.execute.after"](input, output);
-      await toolOutputTruncator?.["tool.execute.after"](input, output);
-      await contextWindowMonitor?.["tool.execute.after"](input, output);
-      await commentChecker?.["tool.execute.after"](input, output);
-      await directoryAgentsInjector?.["tool.execute.after"](input, output);
-      await directoryReadmeInjector?.["tool.execute.after"](input, output);
-      await rulesInjector?.["tool.execute.after"](input, output);
-      await emptyTaskResponseDetector?.["tool.execute.after"](input, output);
-      await agentUsageReminder?.["tool.execute.after"](input, output);
-      await interactiveBashSession?.["tool.execute.after"](input, output);
-      await editErrorRecovery?.["tool.execute.after"](input, output);
-      await delegateTaskRetry?.["tool.execute.after"](input, output);
-      await atlasHook?.["tool.execute.after"]?.(input, output);
-      await taskResumeInfo["tool.execute.after"](input, output);
+      const pipelineStart = performance.now();
+      let hookCount = 0;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "claudeCodeHooks", () => claudeCodeHooks["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "toolOutputTruncator", () => toolOutputTruncator?.["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "contextWindowMonitor", () => contextWindowMonitor?.["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "commentChecker", () => commentChecker?.["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "directoryAgentsInjector", () => directoryAgentsInjector?.["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "directoryReadmeInjector", () => directoryReadmeInjector?.["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "rulesInjector", () => rulesInjector?.["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "emptyTaskResponseDetector", () => emptyTaskResponseDetector?.["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "agentUsageReminder", () => agentUsageReminder?.["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "interactiveBashSession", () => interactiveBashSession?.["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "editErrorRecovery", () => editErrorRecovery?.["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "delegateTaskRetry", () => delegateTaskRetry?.["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "atlasHook", () => atlasHook?.["tool.execute.after"]?.(input, output), input.sessionID, input.tool);
+      hookCount++;
+      await wrapWithTiming(perfTracer, "tool.execute.after", "taskResumeInfo", () => taskResumeInfo["tool.execute.after"](input, output), input.sessionID, input.tool);
+      hookCount++;
+      perfTracer.recordPipeline("tool.execute.after", performance.now() - pipelineStart, hookCount, input.sessionID);
     }
   };
 };