@skj1724/oh-my-opencode 3.19.4 → 3.19.5

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,136 @@ 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/index.ts
 var init_shared = __esm(() => {
   init_frontmatter();
@@ -5060,6 +5268,8 @@ var init_shared = __esm(() => {
   init_model_requirements();
   init_model_resolver();
   init_model_availability();
+  init_perf_tracer();
+  init_fileio_monitor();
 });
 
 // node_modules/picomatch/lib/constants.js
@@ -10944,49 +11154,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 +11204,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 +14411,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 +14427,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
       });
     } catch (e) {} finally {
       if (shouldSwitchCwd) {
-        process.chdir(cwd);
+        process.chdir(cwd2);
       }
     }
     if (resolved) {
@@ -14424,7 +14634,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 +14662,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 +14675,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 +14691,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 +14706,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 +14736,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 +14802,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 +14839,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 +15624,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 +15645,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 +15661,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 +15684,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 +15722,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 +15735,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 +15831,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 +15841,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 +15853,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 +15875,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 +16159,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 join15 } from "path";
+import { existsSync as existsSync13 } 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 existsSync12, mkdirSync as mkdirSync4, chmodSync, unlinkSync as unlinkSync2, appendFileSync as appendFileSync3 } from "fs";
+import { join as join14 } 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 = join14(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 +16191,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 || join14(homedir7(), "AppData", "Local");
+    return join14(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 || join14(homedir7(), ".cache");
+  return join14(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 = join14(getCacheDir(), getBinaryName());
+  return existsSync12(binaryPath) ? binaryPath : null;
 }
 function getPackageVersion() {
   try {
@@ -16008,8 +16235,8 @@ async function downloadCommentChecker() {
   }
   const cacheDir = getCacheDir();
   const binaryName = getBinaryName();
-  const binaryPath = join13(cacheDir, binaryName);
-  if (existsSync10(binaryPath)) {
+  const binaryPath = join14(cacheDir, binaryName);
+  if (existsSync12(binaryPath)) {
     debugLog("Binary already cached at:", binaryPath);
     return binaryPath;
   }
@@ -16020,14 +16247,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 (!existsSync12(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 = join14(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     debugLog(`Downloaded archive to: ${archivePath}`);
@@ -16036,10 +16263,10 @@ async function downloadCommentChecker() {
     } else {
       await extractZip(archivePath, cacheDir);
     }
-    if (existsSync10(archivePath)) {
+    if (existsSync12(archivePath)) {
       unlinkSync2(archivePath);
     }
-    if (process.platform !== "win32" && existsSync10(binaryPath)) {
+    if (process.platform !== "win32" && existsSync12(binaryPath)) {
       chmodSync(binaryPath, 493);
     }
     debugLog(`Successfully downloaded binary to: ${binaryPath}`);
@@ -16063,7 +16290,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 = join15(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 +16316,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 = join15(cliDir, "bin", binaryName);
+    if (existsSync13(binaryPath)) {
       debugLog2("found binary in main package:", binaryPath);
       return binaryPath;
     }
@@ -16111,7 +16338,7 @@ async function getCommentCheckerPath() {
   }
   initPromise = (async () => {
     const syncPath = findCommentCheckerPathSync();
-    if (syncPath && existsSync11(syncPath)) {
+    if (syncPath && existsSync13(syncPath)) {
       resolvedCliPath = syncPath;
       debugLog2("using sync-resolved path:", syncPath);
       return syncPath;
@@ -16147,7 +16374,7 @@ async function runCommentChecker(input, cliPath, customPrompt) {
     debugLog2("comment-checker binary not found");
     return { hasComments: false, message: "" };
   }
-  if (!existsSync11(binaryPath)) {
+  if (!existsSync13(binaryPath)) {
     debugLog2("comment-checker binary does not exist:", binaryPath);
     return { hasComments: false, message: "" };
   }
@@ -16185,11 +16412,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 existsSync14 } from "fs";
+import { tmpdir as tmpdir5 } from "os";
+import { join as join16 } from "path";
 var DEBUG3 = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE3 = join15(tmpdir4(), "comment-checker-debug.log");
+var DEBUG_FILE3 = join16(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 +16496,7 @@ function createCommentCheckerHooks(config) {
       }
       try {
         const cliPath = await cliPathPromise;
-        if (!cliPath || !existsSync12(cliPath)) {
+        if (!cliPath || !existsSync14(cliPath)) {
           debugLog3("CLI not available, skipping comment check");
           return;
         }
@@ -16349,36 +16576,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 existsSync16, readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname2, join as join19, 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 existsSync15,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync5,
   unlinkSync as unlinkSync3
 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 
 // src/hooks/directory-agents-injector/constants.ts
 init_data_path();
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 var OPENCODE_STORAGE3 = getOpenCodeStorageDir();
-var AGENTS_INJECTOR_STORAGE = join16(OPENCODE_STORAGE3, "directory-agents");
+var AGENTS_INJECTOR_STORAGE = join17(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 join18(AGENTS_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedPaths(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (!existsSync13(filePath))
+  if (!existsSync15(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 +16613,19 @@ function loadInjectedPaths(sessionID) {
   }
 }
 function saveInjectedPaths(sessionID, paths) {
-  if (!existsSync13(AGENTS_INJECTOR_STORAGE)) {
-    mkdirSync4(AGENTS_INJECTOR_STORAGE, { recursive: true });
+  if (!existsSync15(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 (existsSync15(filePath)) {
     unlinkSync3(filePath);
   }
 }
@@ -16428,8 +16655,8 @@ function createDirectoryAgentsInjectorHook(ctx) {
     while (true) {
       const isRootDir = current === ctx.directory;
       if (!isRootDir) {
-        const agentsPath = join18(current, AGENTS_FILENAME);
-        if (existsSync14(agentsPath)) {
+        const agentsPath = join19(current, AGENTS_FILENAME);
+        if (existsSync16(agentsPath)) {
           found.push(agentsPath);
         }
       }
@@ -16456,7 +16683,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 +16753,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 existsSync18, readFileSync as readFileSync11 } from "fs";
+import { dirname as dirname3, join as join22, 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 existsSync17,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync10,
+  writeFileSync as writeFileSync6,
   unlinkSync as unlinkSync4
 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 
 // src/hooks/directory-readme-injector/constants.ts
 init_data_path();
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 var OPENCODE_STORAGE4 = getOpenCodeStorageDir();
-var README_INJECTOR_STORAGE = join19(OPENCODE_STORAGE4, "directory-readme");
+var README_INJECTOR_STORAGE = join20(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 join21(README_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedPaths2(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (!existsSync15(filePath))
+  if (!existsSync17(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 +16790,19 @@ function loadInjectedPaths2(sessionID) {
   }
 }
 function saveInjectedPaths2(sessionID, paths) {
-  if (!existsSync15(README_INJECTOR_STORAGE)) {
-    mkdirSync5(README_INJECTOR_STORAGE, { recursive: true });
+  if (!existsSync17(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 (existsSync17(filePath)) {
     unlinkSync4(filePath);
   }
 }
@@ -16603,8 +16830,8 @@ function createDirectoryReadmeInjectorHook(ctx) {
     const found = [];
     let current = startDir;
     while (true) {
-      const readmePath = join21(current, README_FILENAME);
-      if (existsSync16(readmePath)) {
+      const readmePath = join22(current, README_FILENAME);
+      if (existsSync18(readmePath)) {
         found.push(readmePath);
       }
       if (current === ctx.directory)
@@ -16630,7 +16857,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 +17141,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 existsSync19, readdirSync as readdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
+import { join as join23 } from "path";
 var OPENCODE_STORAGE5 = getOpenCodeStorageDir();
-var MESSAGE_STORAGE3 = join22(OPENCODE_STORAGE5, "message");
-var PART_STORAGE3 = join22(OPENCODE_STORAGE5, "part");
+var MESSAGE_STORAGE3 = join23(OPENCODE_STORAGE5, "message");
+var PART_STORAGE3 = join23(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 (!existsSync19(MESSAGE_STORAGE3))
     return "";
-  const directPath = join22(MESSAGE_STORAGE3, sessionID);
-  if (existsSync17(directPath)) {
+  const directPath = join23(MESSAGE_STORAGE3, sessionID);
+  if (existsSync19(directPath)) {
     return directPath;
   }
-  for (const dir of readdirSync4(MESSAGE_STORAGE3)) {
-    const sessionPath = join22(MESSAGE_STORAGE3, dir, sessionID);
-    if (existsSync17(sessionPath)) {
+  for (const dir of readdirSync5(MESSAGE_STORAGE3)) {
+    const sessionPath = join23(MESSAGE_STORAGE3, dir, sessionID);
+    if (existsSync19(sessionPath)) {
       return sessionPath;
     }
   }
@@ -16937,10 +17164,10 @@ function getMessageDir3(sessionID) {
 }
 function getMessageIds(sessionID) {
   const messageDir = getMessageDir3(sessionID);
-  if (!messageDir || !existsSync17(messageDir))
+  if (!messageDir || !existsSync19(messageDir))
     return [];
   const messageIds = [];
-  for (const file of readdirSync4(messageDir)) {
+  for (const file of readdirSync5(messageDir)) {
     if (!file.endsWith(".json"))
       continue;
     const messageId = file.replace(".json", "");
@@ -16952,15 +17179,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 = join23(PART_STORAGE3, messageID);
+    if (!existsSync19(partDir))
       continue;
-    for (const file of readdirSync4(partDir)) {
+    for (const file of readdirSync5(partDir)) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const partPath = join22(partDir, file);
-        const content = readFileSync11(partPath, "utf-8");
+        const partPath = join23(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 +17207,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 +17221,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 +17721,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 +17821,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 +17971,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 +18033,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 join24 } from "path";
+import { existsSync as existsSync20 } from "fs";
 function normalizeHookMatcher(raw) {
   return {
     matcher: raw.matcher ?? raw.pattern ?? "*",
@@ -17816,11 +18060,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")
+    join24(claudeConfigDir, "settings.json"),
+    join24(process.cwd(), ".claude", "settings.json"),
+    join24(process.cwd(), ".claude", "settings.local.json")
   ];
-  if (customPath && existsSync18(customPath)) {
+  if (customPath && existsSync20(customPath)) {
     paths.unshift(customPath);
   }
   return paths;
@@ -17845,7 +18089,7 @@ async function loadClaudeHooksConfig(customSettingsPath) {
   const paths = getClaudeSettingsPaths(customSettingsPath);
   let mergedConfig = {};
   for (const settingsPath of paths) {
-    if (existsSync18(settingsPath)) {
+    if (existsSync20(settingsPath)) {
       try {
         const content = await Bun.file(settingsPath).text();
         const settings = JSON.parse(content);
@@ -17864,14 +18108,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 existsSync21 } from "fs";
+import { join as join25 } from "path";
+var USER_CONFIG_PATH = join25(getOpenCodeConfigDir({ binary: "opencode" }), "opencode-cc-plugin.json");
 function getProjectConfigPath() {
-  return join24(process.cwd(), ".opencode", "opencode-cc-plugin.json");
+  return join25(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
 async function loadConfigFromPath(path4) {
-  if (!existsSync19(path4)) {
+  if (!existsSync21(path4)) {
     return null;
   }
   try {
@@ -18059,17 +18303,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 join26 } from "path";
+import { mkdirSync as mkdirSync7, appendFileSync as appendFileSync6, existsSync as existsSync22, 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 = join26(getClaudeConfigDir(), "transcripts");
 function getTranscriptPath(sessionId) {
-  return join25(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
+  return join26(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
 }
 function ensureTranscriptDir() {
-  if (!existsSync20(TRANSCRIPT_DIR)) {
-    mkdirSync6(TRANSCRIPT_DIR, { recursive: true });
+  if (!existsSync22(TRANSCRIPT_DIR)) {
+    mkdirSync7(TRANSCRIPT_DIR, { recursive: true });
   }
 }
 function appendTranscriptEntry(sessionId, entry) {
@@ -18077,7 +18321,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 +18399,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 = join26(tmpdir6(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+    writeFileSync8(tempPath, entries.join(`
 `) + `
 `);
     return tempPath;
@@ -18175,8 +18419,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
           ]
         }
       };
-      const tempPath = join25(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-      writeFileSync7(tempPath, JSON.stringify(currentEntry) + `
+      const tempPath = join26(tmpdir6(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+      writeFileSync8(tempPath, JSON.stringify(currentEntry) + `
 `);
       return tempPath;
     } catch {
@@ -18391,11 +18635,11 @@ ${USER_PROMPT_SUBMIT_TAG_CLOSE}`);
 init_shared();
 
 // src/hooks/claude-code-hooks/todo.ts
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 init_shared();
-var TODO_DIR = join26(getClaudeConfigDir(), "todos");
+var TODO_DIR = join27(getClaudeConfigDir(), "todos");
 function getTodoPath(sessionId) {
-  return join26(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
+  return join27(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
 }
 
 // src/hooks/claude-code-hooks/stop.ts
@@ -18837,24 +19081,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 existsSync23,
+  readdirSync as readdirSync6,
   realpathSync,
   statSync as statSync2
 } from "fs";
-import { dirname as dirname4, join as join28, relative } from "path";
+import { dirname as dirname4, join as join29, relative as relative2 } from "path";
 
 // src/hooks/rules-injector/constants.ts
 init_data_path();
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 var OPENCODE_STORAGE6 = getOpenCodeStorageDir();
-var RULES_INJECTOR_STORAGE = join27(OPENCODE_STORAGE6, "rules-injector");
+var RULES_INJECTOR_STORAGE = join28(OPENCODE_STORAGE6, "rules-injector");
 var PROJECT_MARKERS = [
   ".git",
   "pyproject.toml",
@@ -18895,8 +19139,8 @@ function findProjectRoot(startPath) {
   }
   while (true) {
     for (const marker of PROJECT_MARKERS) {
-      const markerPath = join28(current, marker);
-      if (existsSync21(markerPath)) {
+      const markerPath = join29(current, marker);
+      if (existsSync23(markerPath)) {
         return current;
       }
     }
@@ -18908,12 +19152,12 @@ function findProjectRoot(startPath) {
   }
 }
 function findRuleFilesRecursive(dir, results) {
-  if (!existsSync21(dir))
+  if (!existsSync23(dir))
     return;
   try {
-    const entries = readdirSync5(dir, { withFileTypes: true });
+    const entries = readdirSync6(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join28(dir, entry.name);
+      const fullPath = join29(dir, entry.name);
       if (entry.isDirectory()) {
         findRuleFilesRecursive(fullPath, results);
       } else if (entry.isFile()) {
@@ -18938,7 +19182,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 = join29(currentDir, parent, subdir);
       const files = [];
       findRuleFilesRecursive(ruleDir, files);
       for (const filePath of files) {
@@ -18964,8 +19208,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 = join29(projectRoot, ruleFile);
+      if (existsSync23(filePath)) {
         try {
           const stat = statSync2(filePath);
           if (stat.isFile()) {
@@ -18985,7 +19229,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
       }
     }
   }
-  const userRuleDir = join28(homeDir, USER_RULE_DIR);
+  const userRuleDir = join29(homeDir, USER_RULE_DIR);
   const userFiles = [];
   findRuleFilesRecursive(userRuleDir, userFiles);
   for (const filePath of userFiles) {
@@ -19012,7 +19256,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 +19269,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 +19418,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 existsSync24,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync13,
+  writeFileSync as writeFileSync9,
   unlinkSync as unlinkSync6
 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 function getStoragePath3(sessionID) {
-  return join29(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join30(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (!existsSync22(filePath))
+  if (!existsSync24(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 +19444,8 @@ function loadInjectedRules(sessionID) {
   }
 }
 function saveInjectedRules(sessionID, data) {
-  if (!existsSync22(RULES_INJECTOR_STORAGE)) {
-    mkdirSync7(RULES_INJECTOR_STORAGE, { recursive: true });
+  if (!existsSync24(RULES_INJECTOR_STORAGE)) {
+    mkdirSync8(RULES_INJECTOR_STORAGE, { recursive: true });
   }
   const storageData = {
     sessionID,
@@ -19209,11 +19453,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 (existsSync24(filePath)) {
     unlinkSync6(filePath);
   }
 }
@@ -19251,7 +19495,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 +19509,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 +19613,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 existsSync27,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync17,
+  writeFileSync as writeFileSync12,
   unlinkSync as unlinkSync7
 } from "fs";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 
 // src/hooks/agent-usage-reminder/constants.ts
 init_data_path();
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 var OPENCODE_STORAGE7 = getOpenCodeStorageDir();
-var AGENT_USAGE_REMINDER_STORAGE = join33(OPENCODE_STORAGE7, "agent-usage-reminder");
+var AGENT_USAGE_REMINDER_STORAGE = join34(OPENCODE_STORAGE7, "agent-usage-reminder");
 var TARGET_TOOLS = new Set([
   "grep",
   "safe_grep",
@@ -19427,29 +19671,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 join35(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
 }
 function loadAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (!existsSync25(filePath))
+  if (!existsSync27(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 (!existsSync27(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 (existsSync27(filePath)) {
     unlinkSync7(filePath);
   }
 }
@@ -20032,19 +20276,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 existsSync28,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync18,
+  writeFileSync as writeFileSync13,
   unlinkSync as unlinkSync8
 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 
 // src/hooks/interactive-bash-session/constants.ts
 init_data_path();
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 var OPENCODE_STORAGE8 = getOpenCodeStorageDir();
-var INTERACTIVE_BASH_SESSION_STORAGE = join35(OPENCODE_STORAGE8, "interactive-bash-session");
+var INTERACTIVE_BASH_SESSION_STORAGE = join36(OPENCODE_STORAGE8, "interactive-bash-session");
 var OMO_SESSION_PREFIX = "omo-";
 function buildSessionReminderMessage(sessions) {
   if (sessions.length === 0)
@@ -20056,14 +20300,14 @@ function buildSessionReminderMessage(sessions) {
 
 // src/hooks/interactive-bash-session/storage.ts
 function getStoragePath5(sessionID) {
-  return join36(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
+  return join37(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
 }
 function loadInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (!existsSync26(filePath))
+  if (!existsSync28(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 +20319,8 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state2) {
-  if (!existsSync26(INTERACTIVE_BASH_SESSION_STORAGE)) {
-    mkdirSync9(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
+  if (!existsSync28(INTERACTIVE_BASH_SESSION_STORAGE)) {
+    mkdirSync10(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath5(state2.sessionID);
   const serialized = {
@@ -20084,11 +20328,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 (existsSync28(filePath)) {
     unlinkSync8(filePath);
   }
 }
@@ -20342,7 +20586,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 +20596,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 existsSync30, readFileSync as readFileSync20, readdirSync as readdirSync7 } from "fs";
+import { join as join39 } 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 existsSync29, readFileSync as readFileSync19, writeFileSync as writeFileSync14, unlinkSync as unlinkSync9, mkdirSync as mkdirSync11 } from "fs";
+import { dirname as dirname6, join as join38 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
 var HOOK_NAME3 = "ralph-loop";
@@ -20368,15 +20612,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 ? join38(directory, customPath) : join38(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync27(filePath)) {
+  if (!existsSync29(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 +20654,8 @@ function writeState(directory, state2, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
     const dir = dirname6(filePath);
-    if (!existsSync27(dir)) {
-      mkdirSync10(dir, { recursive: true });
+    if (!existsSync29(dir)) {
+      mkdirSync11(dir, { recursive: true });
     }
     const sessionIdLine = state2.session_id ? `session_id: "${state2.session_id}"
 ` : "";
@@ -20426,7 +20670,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 +20679,7 @@ ${state2.prompt}
 function clearState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
-    if (existsSync27(filePath)) {
+    if (existsSync29(filePath)) {
       unlinkSync9(filePath);
     }
     return true;
@@ -20456,14 +20700,14 @@ function incrementIteration(directory, customPath) {
 
 // src/hooks/ralph-loop/index.ts
 function getMessageDir4(sessionID) {
-  if (!existsSync28(MESSAGE_STORAGE))
+  if (!existsSync30(MESSAGE_STORAGE))
     return null;
-  const directPath = join38(MESSAGE_STORAGE, sessionID);
-  if (existsSync28(directPath))
+  const directPath = join39(MESSAGE_STORAGE, sessionID);
+  if (existsSync30(directPath))
     return directPath;
-  for (const dir of readdirSync6(MESSAGE_STORAGE)) {
-    const sessionPath = join38(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync28(sessionPath))
+  for (const dir of readdirSync7(MESSAGE_STORAGE)) {
+    const sessionPath = join39(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync30(sessionPath))
       return sessionPath;
   }
   return null;
@@ -20500,9 +20744,9 @@ function createRalphLoopHook(ctx, options) {
     if (!transcriptPath)
       return false;
     try {
-      if (!existsSync28(transcriptPath))
+      if (!existsSync30(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 +21060,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 existsSync32, readdirSync as readdirSync8, readFileSync as readFileSync23 } from "fs";
+import { join as join41, basename as basename2, dirname as dirname8 } from "path";
 // src/features/opencode-skill-loader/loader.ts
 init_js_yaml();
 init_frontmatter();
@@ -20825,7 +21069,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 join40, basename } from "path";
 function parseSkillMcpConfigFromFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!frontmatterMatch)
@@ -20841,7 +21085,7 @@ function parseSkillMcpConfigFromFrontmatter(content) {
   return;
 }
 async function loadMcpJsonFromDir(skillDir) {
-  const mcpJsonPath = join39(skillDir, "mcp.json");
+  const mcpJsonPath = join40(skillDir, "mcp.json");
   try {
     const content = await fs9.readFile(mcpJsonPath, "utf-8");
     const parsed = JSON.parse(content);
@@ -20922,11 +21166,11 @@ async function loadSkillsFromDir(skillsDir, scope) {
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const entryPath = join39(skillsDir, entry.name);
+    const entryPath = join40(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 = join40(resolvedPath, "SKILL.md");
       try {
         await fs9.access(skillMdPath);
         const skill = await loadSkillFromPath(skillMdPath, resolvedPath, dirName, scope);
@@ -20934,7 +21178,7 @@ async function loadSkillsFromDir(skillsDir, scope) {
           skills.push(skill);
         continue;
       } catch {}
-      const namedSkillMdPath = join39(resolvedPath, `${dirName}.md`);
+      const namedSkillMdPath = join40(resolvedPath, `${dirName}.md`);
       try {
         await fs9.access(namedSkillMdPath);
         const skill = await loadSkillFromPath(namedSkillMdPath, resolvedPath, dirName, scope);
@@ -20962,23 +21206,23 @@ function skillsToRecord(skills) {
   return result;
 }
 async function loadUserSkills() {
-  const userSkillsDir = join39(getClaudeConfigDir(), "skills");
+  const userSkillsDir = join40(getClaudeConfigDir(), "skills");
   const skills = await loadSkillsFromDir(userSkillsDir, "user");
   return skillsToRecord(skills);
 }
 async function loadProjectSkills() {
-  const projectSkillsDir = join39(process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join40(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 = join40(configDir, "skills");
   const skills = await loadSkillsFromDir(opencodeSkillsDir, "opencode");
   return skillsToRecord(skills);
 }
 async function loadOpencodeProjectSkills() {
-  const opencodeProjectDir = join39(process.cwd(), ".opencode", "skills");
+  const opencodeProjectDir = join40(process.cwd(), ".opencode", "skills");
   const skills = await loadSkillsFromDir(opencodeProjectDir, "opencode-project");
   return skillsToRecord(skills);
 }
@@ -21007,26 +21251,26 @@ async function discoverSkills(options = {}) {
   return [...opencodeProjectSkills, ...projectSkills, ...opencodeGlobalSkills, ...userSkills];
 }
 async function discoverUserClaudeSkills() {
-  const userSkillsDir = join39(getClaudeConfigDir(), "skills");
+  const userSkillsDir = join40(getClaudeConfigDir(), "skills");
   return loadSkillsFromDir(userSkillsDir, "user");
 }
 async function discoverProjectClaudeSkills() {
-  const projectSkillsDir = join39(process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join40(process.cwd(), ".claude", "skills");
   return loadSkillsFromDir(projectSkillsDir, "project");
 }
 async function discoverOpencodeGlobalSkills() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeSkillsDir = join39(configDir, "skills");
+  const opencodeSkillsDir = join40(configDir, "skills");
   return loadSkillsFromDir(opencodeSkillsDir, "opencode");
 }
 async function discoverOpencodeProjectSkills() {
-  const opencodeProjectDir = join39(process.cwd(), ".opencode", "skills");
+  const opencodeProjectDir = join40(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 existsSync31 } from "fs";
 import { dirname as dirname7, resolve as resolve6, isAbsolute as isAbsolute2 } from "path";
 import { homedir as homedir11 } from "os";
 var SCOPE_PRIORITY = {
@@ -21074,9 +21318,9 @@ function resolveFilePath2(from, configDir) {
 }
 function loadSkillFromFile(filePath) {
   try {
-    if (!existsSync29(filePath))
+    if (!existsSync31(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 {
@@ -22423,7 +22667,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 +22700,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 +22802,18 @@ async function resolveMultipleSkillsAsync(skillNames, options) {
 }
 // src/hooks/auto-slash-command/executor.ts
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync30(commandsDir)) {
+  if (!existsSync32(commandsDir)) {
     return [];
   }
-  const entries = readdirSync7(commandsDir, { withFileTypes: true });
+  const entries = readdirSync8(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join40(commandsDir, entry.name);
+    const commandPath = join41(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 +22856,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 = join41(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join41(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join41(configDir, "command");
+  const opencodeProjectDir = join41(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
@@ -22785,8 +23029,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 existsSync33, readdirSync as readdirSync9 } from "fs";
+import { join as join42, resolve as resolve7, relative as relative5, isAbsolute as isAbsolute3 } from "path";
 
 // src/hooks/prometheus-md-only/constants.ts
 init_system_directive();
@@ -22891,7 +23135,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 +23149,14 @@ function isAllowedFile(filePath, workspaceRoot) {
   return true;
 }
 function getMessageDir5(sessionID) {
-  if (!existsSync31(MESSAGE_STORAGE))
+  if (!existsSync33(MESSAGE_STORAGE))
     return null;
-  const directPath = join41(MESSAGE_STORAGE, sessionID);
-  if (existsSync31(directPath))
+  const directPath = join42(MESSAGE_STORAGE, sessionID);
+  if (existsSync33(directPath))
     return directPath;
-  for (const dir of readdirSync8(MESSAGE_STORAGE)) {
-    const sessionPath = join41(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync31(sessionPath))
+  for (const dir of readdirSync9(MESSAGE_STORAGE)) {
+    const sessionPath = join42(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync33(sessionPath))
       return sessionPath;
   }
   return null;
@@ -23026,18 +23270,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 existsSync34, readFileSync as readFileSync24, writeFileSync as writeFileSync15, mkdirSync as mkdirSync12, readdirSync as readdirSync10 } from "fs";
+import { dirname as dirname9, join as join43, basename as basename3 } from "path";
 function getBoulderFilePath(directory) {
-  return join42(directory, BOULDER_DIR, BOULDER_FILE);
+  return join43(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync32(filePath)) {
+  if (!existsSync34(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 +23291,10 @@ function writeBoulderState(directory, state2) {
   const filePath = getBoulderFilePath(directory);
   try {
     const dir = dirname9(filePath);
-    if (!existsSync32(dir)) {
-      mkdirSync11(dir, { recursive: true });
+    if (!existsSync34(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 +23315,7 @@ function appendSessionId(directory, sessionId) {
 function clearBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
   try {
-    if (existsSync32(filePath)) {
+    if (existsSync34(filePath)) {
       const { unlinkSync: unlinkSync10 } = __require("fs");
       unlinkSync10(filePath);
     }
@@ -23081,13 +23325,13 @@ function clearBoulderState(directory) {
   }
 }
 function findPrometheusPlans(directory) {
-  const plansDir = join42(directory, PROMETHEUS_PLANS_DIR);
-  if (!existsSync32(plansDir)) {
+  const plansDir = join43(directory, PROMETHEUS_PLANS_DIR);
+  if (!existsSync34(plansDir)) {
     return [];
   }
   try {
-    const files = readdirSync9(plansDir);
-    return files.filter((f) => f.endsWith(".md")).map((f) => join42(plansDir, f)).sort((a, b) => {
+    const files = readdirSync10(plansDir);
+    return files.filter((f) => f.endsWith(".md")).map((f) => join43(plansDir, f)).sort((a, b) => {
       const aStat = __require("fs").statSync(a);
       const bStat = __require("fs").statSync(b);
       return bStat.mtimeMs - aStat.mtimeMs;
@@ -23097,11 +23341,11 @@ function findPrometheusPlans(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync32(planPath)) {
+  if (!existsSync34(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 +23562,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 existsSync35, readdirSync as readdirSync11 } from "fs";
+import { join as join44 } from "path";
 init_logger();
 init_system_directive();
 var HOOK_NAME6 = "atlas";
@@ -23648,14 +23892,14 @@ function formatFileChanges(stats, notepadPath) {
 `);
 }
 function getMessageDir6(sessionID) {
-  if (!existsSync33(MESSAGE_STORAGE))
+  if (!existsSync35(MESSAGE_STORAGE))
     return null;
-  const directPath = join43(MESSAGE_STORAGE, sessionID);
-  if (existsSync33(directPath))
+  const directPath = join44(MESSAGE_STORAGE, sessionID);
+  if (existsSync35(directPath))
     return directPath;
-  for (const dir of readdirSync10(MESSAGE_STORAGE)) {
-    const sessionPath = join43(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync33(sessionPath))
+  for (const dir of readdirSync11(MESSAGE_STORAGE)) {
+    const sessionPath = join44(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync35(sessionPath))
       return sessionPath;
   }
   return null;
@@ -24109,6 +24353,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 +24548,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 existsSync36, readFileSync as readFileSync25 } from "fs";
+import { join as join45 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
 function expandEnvVars(value) {
@@ -24351,15 +24617,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: join45(claudeConfigDir, ".mcp.json"), scope: "user" },
+    { path: join45(cwd2, ".mcp.json"), scope: "project" },
+    { path: join45(cwd2, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync34(filePath)) {
+  if (!existsSync36(filePath)) {
     return null;
   }
   try {
@@ -24374,10 +24640,10 @@ function getSystemMcpServerNames() {
   const names = new Set;
   const paths = getMcpConfigPaths();
   for (const { path: path7 } of paths) {
-    if (!existsSync34(path7))
+    if (!existsSync36(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 +25086,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 existsSync37, readFileSync as readFileSync26 } from "fs";
+import { join as join46 } from "path";
 init_shared();
 function loadJsonFile(path7) {
-  if (!existsSync35(path7))
+  if (!existsSync37(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: join46(cwd2, ".opencode", "oh-my-opencode.json"),
+    user: join46(configDir, "oh-my-opencode.json"),
+    opencode: join46(configDir, "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -24951,7 +25217,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync35(cmd))
+    if (existsSync37(cmd))
       return true;
   }
   const isWindows2 = process.platform === "win32";
@@ -24973,23 +25239,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 (existsSync37(join46(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 = join46(getDataDir(), "opencode");
   const additionalBases = [
-    join45(cwd, "node_modules", ".bin"),
-    join45(configDir, "bin"),
-    join45(configDir, "node_modules", ".bin"),
-    join45(dataDir, "bin")
+    join46(cwd2, "node_modules", ".bin"),
+    join46(configDir, "bin"),
+    join46(configDir, "node_modules", ".bin"),
+    join46(dataDir, "bin")
   ];
   for (const base of additionalBases) {
     for (const suffix of exts) {
-      if (existsSync35(join45(base, cmd + suffix))) {
+      if (existsSync37(join46(base, cmd + suffix))) {
         return true;
       }
     }
@@ -25001,7 +25267,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 +25717,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 +25807,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 existsSync38, readFileSync as readFileSync28, writeFileSync as writeFileSync16 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve9(filePath);
-  if (!existsSync36(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync38(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 (existsSync38(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -25706,7 +25972,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 +25997,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 +26028,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 +26038,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 +38618,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 join48 } from "path";
+import { existsSync as existsSync40, 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 existsSync39, mkdirSync as mkdirSync13, chmodSync as chmodSync2, unlinkSync as unlinkSync10 } from "fs";
+import { join as join47 } from "path";
 import { homedir as homedir12 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
@@ -38384,19 +38650,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 || join47(homedir12(), "AppData", "Local");
+    return join47(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 || join47(homedir12(), ".cache");
+  return join47(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 = join47(getCacheDir3(), getBinaryName3());
+  return existsSync39(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -38407,8 +38673,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join46(cacheDir, binaryName);
-  if (existsSync37(binaryPath)) {
+  const binaryPath = join47(cacheDir, binaryName);
+  if (existsSync39(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os6 } = platformInfo;
@@ -38416,21 +38682,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 (!existsSync39(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 = join47(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
-    if (existsSync37(archivePath)) {
+    if (existsSync39(archivePath)) {
       unlinkSync10(archivePath);
     }
-    if (process.platform !== "win32" && existsSync37(binaryPath)) {
+    if (process.platform !== "win32" && existsSync39(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -38481,8 +38747,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 = join48(cliDir, binaryName);
+    if (existsSync40(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -38493,8 +38759,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 = join48(pkgDir, astGrepName);
+      if (existsSync40(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -38502,7 +38768,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 (existsSync40(path7) && isValidBinary(path7)) {
         return path7;
       }
     }
@@ -38557,11 +38823,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 existsSync41 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync39(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync41(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -38569,7 +38835,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync39(syncPath)) {
+    if (syncPath && existsSync41(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -38603,7 +38869,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 (!existsSync41(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -38867,21 +39133,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 existsSync43 } from "fs";
+import { join as join50, 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 existsSync42, mkdirSync as mkdirSync14, chmodSync as chmodSync3, unlinkSync as unlinkSync11, readdirSync as readdirSync12 } from "fs";
+import { join as join49 } from "path";
 var {spawn: spawn8 } = globalThis.Bun;
 function findFileRecursive(dir, filename) {
   try {
-    const entries = readdirSync11(dir, { withFileTypes: true, recursive: true });
+    const entries = readdirSync12(dir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
-        return join48(entry.parentPath ?? dir, entry.name);
+        return join49(entry.parentPath ?? dir, entry.name);
       }
     }
   } catch {
@@ -38902,11 +39168,11 @@ function getPlatformKey() {
 }
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join48(homeDir, ".cache", "oh-my-opencode", "bin");
+  return join49(homeDir, ".cache", "oh-my-opencode", "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join48(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join49(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 async function downloadFile(url2, destPath) {
   const response = await fetch(url2);
@@ -38940,7 +39206,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 = join49(destDir, binaryName);
     if (foundPath !== destPath) {
       const { renameSync } = await import("fs");
       renameSync(foundPath, destPath);
@@ -38955,13 +39221,13 @@ async function downloadAndInstallRipgrep() {
   }
   const installDir = getInstallDir();
   const rgPath = getRgPath();
-  if (existsSync40(rgPath)) {
+  if (existsSync42(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 = join49(installDir, filename);
   try {
     await downloadFile(url2, archivePath);
     if (config3.extension === "tar.gz") {
@@ -38972,12 +39238,12 @@ async function downloadAndInstallRipgrep() {
     if (process.platform !== "win32") {
       chmodSync3(rgPath, 493);
     }
-    if (!existsSync40(rgPath)) {
+    if (!existsSync42(rgPath)) {
       throw new Error("ripgrep binary not found after extraction");
     }
     return rgPath;
   } finally {
-    if (existsSync40(archivePath)) {
+    if (existsSync42(archivePath)) {
       try {
         unlinkSync11(archivePath);
       } catch {}
@@ -38986,7 +39252,7 @@ async function downloadAndInstallRipgrep() {
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync40(rgPath) ? rgPath : null;
+  return existsSync42(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -39011,14 +39277,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)
+    join50(getDataDir(), "opencode", "bin", rgName),
+    join50(execDir, rgName),
+    join50(execDir, "bin", rgName),
+    join50(execDir, "..", "bin", rgName),
+    join50(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync41(candidate)) {
+    if (existsSync43(candidate)) {
       return candidate;
     }
   }
@@ -39355,26 +39621,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 +39678,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 +39746,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 existsSync44, readdirSync as readdirSync13, readFileSync as readFileSync29 } from "fs";
+import { join as join51, basename as basename4, dirname as dirname12 } from "path";
 // src/features/builtin-commands/templates/init-deep.ts
 var INIT_DEEP_TEMPLATE = `# /init-deep
 
@@ -40597,18 +40863,18 @@ function loadBuiltinCommands(disabledCommands) {
 }
 // src/tools/slashcommand/tools.ts
 function discoverCommandsFromDir2(commandsDir, scope) {
-  if (!existsSync42(commandsDir)) {
+  if (!existsSync44(commandsDir)) {
     return [];
   }
-  const entries = readdirSync12(commandsDir, { withFileTypes: true });
+  const entries = readdirSync13(commandsDir, { withFileTypes: true });
   const commands2 = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join50(commandsDir, entry.name);
+    const commandPath = join51(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 +40900,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 = join51(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join51(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join51(configDir, "command");
+  const opencodeProjectDir = join51(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir2(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir2(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir2(projectCommandsDir, "project");
@@ -40814,13 +41080,13 @@ var slashcommand = createSlashcommandTool();
 // src/tools/session-manager/constants.ts
 init_data_path();
 init_shared();
-import { join as join51 } from "path";
+import { join as join52 } 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 = join52(OPENCODE_STORAGE9, "message");
+var PART_STORAGE4 = join52(OPENCODE_STORAGE9, "part");
+var SESSION_STORAGE = join52(OPENCODE_STORAGE9, "session");
+var TODO_DIR2 = join52(getClaudeConfigDir(), "todos");
+var TRANSCRIPT_DIR2 = join52(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 +41159,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 existsSync45, readdirSync as readdirSync14 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 async function getMainSessions(options) {
-  if (!existsSync43(SESSION_STORAGE))
+  if (!existsSync45(SESSION_STORAGE))
     return [];
   const sessions = [];
   try {
@@ -40905,13 +41171,13 @@ async function getMainSessions(options) {
     for (const projectDir of projectDirs) {
       if (!projectDir.isDirectory())
         continue;
-      const projectPath = join52(SESSION_STORAGE, projectDir.name);
+      const projectPath = join53(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(join53(projectPath, file2), "utf-8");
           const meta = JSON.parse(content);
           if (meta.parentID)
             continue;
@@ -40929,7 +41195,7 @@ async function getMainSessions(options) {
   return sessions.sort((a, b) => b.time.updated - a.time.updated);
 }
 async function getAllSessions() {
-  if (!existsSync43(MESSAGE_STORAGE4))
+  if (!existsSync45(MESSAGE_STORAGE4))
     return [];
   const sessions = [];
   async function scanDirectory(dir) {
@@ -40937,7 +41203,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 = join53(dir, entry.name);
           const files = await readdir(sessionPath);
           if (files.some((f) => f.endsWith(".json"))) {
             sessions.push(entry.name);
@@ -40954,16 +41220,16 @@ async function getAllSessions() {
   return [...new Set(sessions)];
 }
 function getMessageDir7(sessionID) {
-  if (!existsSync43(MESSAGE_STORAGE4))
+  if (!existsSync45(MESSAGE_STORAGE4))
     return "";
-  const directPath = join52(MESSAGE_STORAGE4, sessionID);
-  if (existsSync43(directPath)) {
+  const directPath = join53(MESSAGE_STORAGE4, sessionID);
+  if (existsSync45(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 readdirSync14(MESSAGE_STORAGE4)) {
+      const sessionPath = join53(MESSAGE_STORAGE4, dir, sessionID);
+      if (existsSync45(sessionPath)) {
         return sessionPath;
       }
     }
@@ -40977,7 +41243,7 @@ function sessionExists(sessionID) {
 }
 async function readSessionMessages(sessionID) {
   const messageDir = getMessageDir7(sessionID);
-  if (!messageDir || !existsSync43(messageDir))
+  if (!messageDir || !existsSync45(messageDir))
     return [];
   const messages = [];
   try {
@@ -40986,7 +41252,7 @@ async function readSessionMessages(sessionID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join52(messageDir, file2), "utf-8");
+        const content = await readFile(join53(messageDir, file2), "utf-8");
         const meta = JSON.parse(content);
         const parts = await readParts2(meta.id);
         messages.push({
@@ -41012,8 +41278,8 @@ async function readSessionMessages(sessionID) {
   });
 }
 async function readParts2(messageID) {
-  const partDir = join52(PART_STORAGE4, messageID);
-  if (!existsSync43(partDir))
+  const partDir = join53(PART_STORAGE4, messageID);
+  if (!existsSync45(partDir))
     return [];
   const parts = [];
   try {
@@ -41022,7 +41288,7 @@ async function readParts2(messageID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join52(partDir, file2), "utf-8");
+        const content = await readFile(join53(partDir, file2), "utf-8");
         parts.push(JSON.parse(content));
       } catch {
         continue;
@@ -41034,14 +41300,14 @@ async function readParts2(messageID) {
   return parts.sort((a, b) => a.id.localeCompare(b.id));
 }
 async function readSessionTodos(sessionID) {
-  if (!existsSync43(TODO_DIR2))
+  if (!existsSync45(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(join53(TODO_DIR2, file2), "utf-8");
         const data = JSON.parse(content);
         if (Array.isArray(data)) {
           return data.map((item) => ({
@@ -41061,10 +41327,10 @@ async function readSessionTodos(sessionID) {
   return [];
 }
 async function readSessionTranscript(sessionID) {
-  if (!existsSync43(TRANSCRIPT_DIR2))
+  if (!existsSync45(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join52(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync43(transcriptFile))
+  const transcriptFile = join53(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  if (!existsSync45(transcriptFile))
     return 0;
   try {
     const content = await readFile(transcriptFile, "utf-8");
@@ -42266,19 +42532,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 existsSync46, readdirSync as readdirSync15 } from "fs";
+import { join as join54 } from "path";
 init_shared();
 init_session_cursor();
 function getMessageDir8(sessionID) {
-  if (!existsSync44(MESSAGE_STORAGE))
+  if (!existsSync46(MESSAGE_STORAGE))
     return null;
-  const directPath = join53(MESSAGE_STORAGE, sessionID);
-  if (existsSync44(directPath))
+  const directPath = join54(MESSAGE_STORAGE, sessionID);
+  if (existsSync46(directPath))
     return directPath;
-  for (const dir of readdirSync14(MESSAGE_STORAGE)) {
-    const sessionPath = join53(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync44(sessionPath))
+  for (const dir of readdirSync15(MESSAGE_STORAGE)) {
+    const sessionPath = join54(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync46(sessionPath))
       return sessionPath;
   }
   return null;
@@ -42687,8 +42953,8 @@ 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 existsSync47, readdirSync as readdirSync16 } from "fs";
+import { join as join55 } from "path";
 
 // src/features/task-toast-manager/manager.ts
 class TaskToastManager {
@@ -42847,14 +43113,14 @@ function parseModelString(model) {
   return;
 }
 function getMessageDir9(sessionID) {
-  if (!existsSync45(MESSAGE_STORAGE))
+  if (!existsSync47(MESSAGE_STORAGE))
     return null;
-  const directPath = join54(MESSAGE_STORAGE, sessionID);
-  if (existsSync45(directPath))
+  const directPath = join55(MESSAGE_STORAGE, sessionID);
+  if (existsSync47(directPath))
     return directPath;
-  for (const dir of readdirSync15(MESSAGE_STORAGE)) {
-    const sessionPath = join54(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync45(sessionPath))
+  for (const dir of readdirSync16(MESSAGE_STORAGE)) {
+    const sessionPath = join55(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync47(sessionPath))
       return sessionPath;
   }
   return null;
@@ -43682,8 +43948,8 @@ 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 existsSync48, readdirSync as readdirSync17 } from "fs";
+import { join as join56 } from "path";
 var TASK_TTL_MS = 30 * 60 * 1000;
 var MIN_STABILITY_TIME_MS = 10 * 1000;
 var DEFAULT_STALE_TIMEOUT_MS = 180000;
@@ -43703,6 +43969,7 @@ class BackgroundManager {
   shutdownTriggered = false;
   config;
   perfAggregator = new PerformanceAggregator;
+  perfTracer;
   queuesByKey = new Map;
   processingKeys = new Set;
   constructor(ctx, config3) {
@@ -43715,6 +43982,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,
@@ -44531,124 +44801,132 @@ ${perfSnapshot ? `| \u6392\u961F ${PerfTimer.formatDuration(new Date(0), new Dat
     }
   }
   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;
+            }
+            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;
+                  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 +44964,14 @@ function registerProcessSignal(signal, handler, exitAfter) {
   return listener;
 }
 function getMessageDir10(sessionID) {
-  if (!existsSync46(MESSAGE_STORAGE))
+  if (!existsSync48(MESSAGE_STORAGE))
     return null;
-  const directPath = join55(MESSAGE_STORAGE, sessionID);
-  if (existsSync46(directPath))
+  const directPath = join56(MESSAGE_STORAGE, sessionID);
+  if (existsSync48(directPath))
     return directPath;
-  for (const dir of readdirSync16(MESSAGE_STORAGE)) {
-    const sessionPath = join55(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync46(sessionPath))
+  for (const dir of readdirSync17(MESSAGE_STORAGE)) {
+    const sessionPath = join56(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync48(sessionPath))
       return sessionPath;
   }
   return null;
@@ -62607,6 +62885,7 @@ var HookNameSchema = exports_external2.enum([
   "edit-error-recovery",
   "delegate-task-retry",
   "prometheus-md-only",
+  "perf-profiler",
   "start-work",
   "atlas"
 ]);
@@ -62720,11 +62999,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(),
@@ -65753,7 +66042,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 join58, basename as basename6 } from "path";
 async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "") {
   try {
     await fs11.access(commandsDir);
@@ -65783,7 +66072,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 = join58(commandsDir, entry.name);
       const subPrefix = prefix ? `${prefix}:${entry.name}` : entry.name;
       const subCommands = await loadCommandsFromDir(subDirPath, scope, visited, subPrefix);
       commands2.push(...subCommands);
@@ -65791,7 +66080,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     }
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join57(commandsDir, entry.name);
+    const commandPath = join58(commandsDir, entry.name);
     const baseCommandName = basename6(entry.name, ".md");
     const commandName = prefix ? `${prefix}:${baseCommandName}` : baseCommandName;
     try {
@@ -65838,23 +66127,23 @@ function commandsToRecord(commands2) {
   return result;
 }
 async function loadUserCommands() {
-  const userCommandsDir = join57(getClaudeConfigDir(), "commands");
+  const userCommandsDir = join58(getClaudeConfigDir(), "commands");
   const commands2 = await loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands2);
 }
 async function loadProjectCommands() {
-  const projectCommandsDir = join57(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join58(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 = join58(configDir, "command");
   const commands2 = await loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands2);
 }
 async function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join57(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join58(process.cwd(), ".opencode", "command");
   const commands2 = await loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands2);
 }
@@ -65862,8 +66151,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 existsSync50, readdirSync as readdirSync18, readFileSync as readFileSync31 } from "fs";
+import { join as join59, basename as basename7 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -65877,18 +66166,18 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync48(agentsDir)) {
+  if (!existsSync50(agentsDir)) {
     return [];
   }
-  const entries = readdirSync17(agentsDir, { withFileTypes: true });
+  const entries = readdirSync18(agentsDir, { withFileTypes: true });
   const agents = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join58(agentsDir, entry.name);
+    const agentPath = join59(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 +66204,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join58(getClaudeConfigDir(), "agents");
+  const userAgentsDir = join59(getClaudeConfigDir(), "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -65924,7 +66213,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents() {
-  const projectAgentsDir = join58(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join59(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -65936,18 +66225,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 existsSync51, readdirSync as readdirSync19, readFileSync as readFileSync32 } from "fs";
 import { homedir as homedir13 } from "os";
-import { join as join59, basename as basename8 } from "path";
+import { join as join60, 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 join60(homedir13(), ".claude", "plugins");
 }
 function getInstalledPluginsPath() {
-  return join59(getPluginsBaseDir(), "installed_plugins.json");
+  return join60(getPluginsBaseDir(), "installed_plugins.json");
 }
 function resolvePluginPath(path8, pluginRoot) {
   return path8.replace(CLAUDE_PLUGIN_ROOT_VAR, pluginRoot);
@@ -65972,11 +66261,11 @@ function resolvePluginPaths(obj, pluginRoot) {
 }
 function loadInstalledPlugins() {
   const dbPath = getInstalledPluginsPath();
-  if (!existsSync49(dbPath)) {
+  if (!existsSync51(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 +66276,15 @@ function getClaudeSettingsPath() {
   if (process.env.CLAUDE_SETTINGS_PATH) {
     return process.env.CLAUDE_SETTINGS_PATH;
   }
-  return join59(homedir13(), ".claude", "settings.json");
+  return join60(homedir13(), ".claude", "settings.json");
 }
 function loadClaudeSettings() {
   const settingsPath = getClaudeSettingsPath();
-  if (!existsSync49(settingsPath)) {
+  if (!existsSync51(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 +66292,12 @@ function loadClaudeSettings() {
   }
 }
 function loadPluginManifest(installPath) {
-  const manifestPath = join59(installPath, ".claude-plugin", "plugin.json");
-  if (!existsSync49(manifestPath)) {
+  const manifestPath = join60(installPath, ".claude-plugin", "plugin.json");
+  if (!existsSync51(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 +66344,7 @@ function discoverInstalledPlugins(options) {
       continue;
     }
     const { installPath, scope, version: version3 } = installation;
-    if (!existsSync49(installPath)) {
+    if (!existsSync51(installPath)) {
       errors5.push({
         pluginKey,
         installPath,
@@ -66073,21 +66362,21 @@ function discoverInstalledPlugins(options) {
       pluginKey,
       manifest: manifest ?? undefined
     };
-    if (existsSync49(join59(installPath, "commands"))) {
-      loadedPlugin.commandsDir = join59(installPath, "commands");
+    if (existsSync51(join60(installPath, "commands"))) {
+      loadedPlugin.commandsDir = join60(installPath, "commands");
     }
-    if (existsSync49(join59(installPath, "agents"))) {
-      loadedPlugin.agentsDir = join59(installPath, "agents");
+    if (existsSync51(join60(installPath, "agents"))) {
+      loadedPlugin.agentsDir = join60(installPath, "agents");
     }
-    if (existsSync49(join59(installPath, "skills"))) {
-      loadedPlugin.skillsDir = join59(installPath, "skills");
+    if (existsSync51(join60(installPath, "skills"))) {
+      loadedPlugin.skillsDir = join60(installPath, "skills");
     }
-    const hooksPath = join59(installPath, "hooks", "hooks.json");
-    if (existsSync49(hooksPath)) {
+    const hooksPath = join60(installPath, "hooks", "hooks.json");
+    if (existsSync51(hooksPath)) {
       loadedPlugin.hooksPath = hooksPath;
     }
-    const mcpPath = join59(installPath, ".mcp.json");
-    if (existsSync49(mcpPath)) {
+    const mcpPath = join60(installPath, ".mcp.json");
+    if (existsSync51(mcpPath)) {
       loadedPlugin.mcpPath = mcpPath;
     }
     plugins.push(loadedPlugin);
@@ -66098,17 +66387,17 @@ function discoverInstalledPlugins(options) {
 function loadPluginCommands(plugins) {
   const commands2 = {};
   for (const plugin of plugins) {
-    if (!plugin.commandsDir || !existsSync49(plugin.commandsDir))
+    if (!plugin.commandsDir || !existsSync51(plugin.commandsDir))
       continue;
-    const entries = readdirSync18(plugin.commandsDir, { withFileTypes: true });
+    const entries = readdirSync19(plugin.commandsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const commandPath = join59(plugin.commandsDir, entry.name);
+      const commandPath = join60(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 +66429,21 @@ $ARGUMENTS
 function loadPluginSkillsAsCommands(plugins) {
   const skills = {};
   for (const plugin of plugins) {
-    if (!plugin.skillsDir || !existsSync49(plugin.skillsDir))
+    if (!plugin.skillsDir || !existsSync51(plugin.skillsDir))
       continue;
-    const entries = readdirSync18(plugin.skillsDir, { withFileTypes: true });
+    const entries = readdirSync19(plugin.skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith("."))
         continue;
-      const skillPath = join59(plugin.skillsDir, entry.name);
+      const skillPath = join60(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 = join60(resolvedPath, "SKILL.md");
+      if (!existsSync51(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 +66490,17 @@ function parseToolsConfig2(toolsStr) {
 function loadPluginAgents(plugins) {
   const agents = {};
   for (const plugin of plugins) {
-    if (!plugin.agentsDir || !existsSync49(plugin.agentsDir))
+    if (!plugin.agentsDir || !existsSync51(plugin.agentsDir))
       continue;
-    const entries = readdirSync18(plugin.agentsDir, { withFileTypes: true });
+    const entries = readdirSync19(plugin.agentsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const agentPath = join59(plugin.agentsDir, entry.name);
+      const agentPath = join60(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 +66526,7 @@ function loadPluginAgents(plugins) {
 async function loadPluginMcpServers(plugins) {
   const servers = {};
   for (const plugin of plugins) {
-    if (!plugin.mcpPath || !existsSync49(plugin.mcpPath))
+    if (!plugin.mcpPath || !existsSync51(plugin.mcpPath))
       continue;
     try {
       const content = await Bun.file(plugin.mcpPath).text();
@@ -66269,10 +66558,10 @@ async function loadPluginMcpServers(plugins) {
 function loadPluginHooksConfigs(plugins) {
   const configs = [];
   for (const plugin of plugins) {
-    if (!plugin.hooksPath || !existsSync49(plugin.hooksPath))
+    if (!plugin.hooksPath || !existsSync51(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);
@@ -67798,6 +68087,44 @@ 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 });
@@ -67863,6 +68190,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 +68282,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 +68329,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 +68369,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 +68464,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 +68527,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);
     }
   };
 };