npm - @skj1724/oh-my-opencode - Versions diffs - 3.23.4 → 3.23.5 - Mend

@skj1724/oh-my-opencode 3.23.4 → 3.23.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/dist/index.js CHANGED Viewed

@@ -6147,14 +6147,6 @@ function isLanguageEnforcementEnabled(config) {
 function stripCodeAndUrls(text) {
   return text.replace(/```[\s\S]*?```/g, "").replace(/`[^`]*`/g, "").replace(/https?:\/\/\S+/g, "").replace(/[A-Za-z]:[\\/]\S+|[./~]\S+\/\S+/g, "");
 }
-function isEnglishText(text, threshold) {
-  const stripped = stripCodeAndUrls(text);
-  const meaningful = stripped.replace(/[\s\d\p{P}]/gu, "");
-  if (meaningful.length < 20)
-    return false;
-  const asciiLetters = (meaningful.match(/[a-zA-Z]/g) || []).length;
-  return asciiLetters / meaningful.length > threshold;
-}
 function detectEnglishViolation(text, threshold = 0.6) {
   let stripped = stripCodeAndUrls(text);
   stripped = stripped.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
@@ -23149,6 +23141,7 @@ var ZH_LANGUAGE_INSTRUCTION = `
 ---
 <Language_Instruction>
 ## \u4E2D\u6587\u8BED\u5883\u786C\u7EA6\u675F\uFF08\u8EAB\u4EFD\u7EA7\u5F3A\u5236\u89C4\u5219\uFF09
 ### \u4F60\u7684\u8EAB\u4EFD
@@ -23199,12 +23192,17 @@ var ZH_LANGUAGE_INSTRUCTION = `
 - \u6B64\u89C4\u5219\u9012\u5F52\u4F20\u9012\u7ED9\u6240\u6709 delegate_task \u5B50\u4EE3\u7406
 - \u5B50\u4EE3\u7406\u7684 prompt \u5F00\u5934\u4E5F\u5DF2\u5305\u542B\u8EAB\u4EFD\u58F0\u660E
 - \u5B50\u4EE3\u7406\u8F93\u51FA\u4E2D\u6587\u8FDD\u89C4\u65F6\uFF0C\u63D0\u9192\u5E76\u91CD\u65B0\u8C03\u7528
-</Language_Instruction>`;
-var ZH_LANGUAGE_INSTRUCTION_DEEPSEEK = `
-<Language_Instruction>
-\u4F60\u7684\u6BCD\u8BED\u662F\u4E2D\u6587\uFF0C\u5FC5\u987B\u4F7F\u7528\u4E2D\u6587\u601D\u8003\u56DE\u590D\uFF0C\u4E0D\u5E94\u4F7F\u7528\u5176\u4ED6\u8BED\u8A00\u3002
-\u4EE3\u7801\u6807\u8BC6\u7B26\u3001\u6587\u4EF6\u8DEF\u5F84\u3001Shell \u547D\u4EE4\u4FDD\u6301\u82F1\u6587\u539F\u6837\u3002
+### Thinking \u793A\u4F8B\uFF08\u5FC5\u987B\u9075\u5FAA\uFF09
+\u2705 \u6B63\u786E\uFF08\u4E2D\u6587\u601D\u8003\uFF09\uFF1A
+  \u6211\u9700\u8981\u5206\u6790 websockets \u7248\u672C\u517C\u5BB9\u6027\u95EE\u9898\u3002
+  \u5148\u67E5\u770B\u9519\u8BEF\u4FE1\u606F\uFF0C\u53D1\u73B0\u662F handler \u7B7E\u540D\u4E0D\u5339\u914D\u3002
+  \u7136\u540E\u68C0\u67E5\u5DF2\u5B89\u88C5\u7684 websockets \u7248\u672C...
+\u274C \u9519\u8BEF\uFF08\u82F1\u6587\u601D\u8003\u2014\u2014\u7981\u6B62\uFF09\uFF1A
+  But wait, the error message says "missing path"...
+  Actually, let me re-read the error more carefully...
 </Language_Instruction>`;
 var ZH_SUB_AGENT_INSTRUCTION = ZH_LANGUAGE_INSTRUCTION.replace(`## \u4E2D\u6587\u8BED\u5883\u786C\u7EA6\u675F\uFF08\u8EAB\u4EFD\u7EA7\u5F3A\u5236\u89C4\u5219\uFF09
@@ -23444,11 +23442,7 @@ async function createBuiltinAgents(disabledAgents = [], agentOverrides = {}, dir
     for (const name of Object.keys(result)) {
       const agent = result[name];
       if (agent.prompt) {
-        if (isDeepseekModel(agent.model ?? "")) {
-          agent.prompt += ZH_LANGUAGE_INSTRUCTION_DEEPSEEK;
-        } else {
-          agent.prompt += MAIN_AGENT_NAMES.has(name) ? ZH_LANGUAGE_INSTRUCTION : ZH_SUB_AGENT_INSTRUCTION;
-        }
+        agent.prompt += MAIN_AGENT_NAMES.has(name) ? ZH_LANGUAGE_INSTRUCTION : ZH_SUB_AGENT_INSTRUCTION;
       }
     }
   }
@@ -25572,345 +25566,6 @@ function createAgentUsageReminderHook(_ctx) {
     event: eventHandler
   };
 }
-// src/hooks/language-reminder/storage.ts
-import {
-  existsSync as existsSync31,
-  mkdirSync as mkdirSync13,
-  readFileSync as readFileSync23,
-  writeFileSync as writeFileSync16,
-  unlinkSync as unlinkSync8
-} from "fs";
-import { join as join41 } from "path";
-// src/hooks/language-reminder/constants.ts
-init_data_path();
-import { join as join40 } from "path";
-var OPENCODE_STORAGE8 = getOpenCodeStorageDir();
-var LANGUAGE_REMINDER_STORAGE = join40(OPENCODE_STORAGE8, "language-reminder");
-var LANGUAGE_REMINDER_MESSAGE = `
-[SYSTEM DIRECTIVE: OH-MY-OPENCODE - LANGUAGE]
-\u8BF7\u7528\u4E2D\u6587\u601D\u8003\u548C\u56DE\u590D\u3002\u8FD9\u662F\u8EAB\u4EFD\u7EA7\u786C\u7EA6\u675F\uFF0C\u4E0D\u53EF\u5728\u957F\u4F1A\u8BDD\u4E2D\u9057\u5FD8\u3002
-\u7981\u6B62\u5728\u5185\u90E8\u63A8\u7406\uFF08Thought/Thinking\uFF09\u4E2D\u4F7F\u7528\u82F1\u6587\uFF0C\u7981\u6B62\u5728\u56DE\u590D\u6B63\u6587\u4E2D\u4F7F\u7528\u82F1\u6587\u53E5\u5B50\u3002
-\u6280\u672F\u672F\u8BED\u3001\u4EE3\u7801\u6807\u8BC6\u7B26\u3001\u6587\u4EF6\u8DEF\u5F84\u3001Shell \u547D\u4EE4\u3001\u4EE3\u7801\u5757\u5185\u5BB9\u5141\u8BB8\u4FDD\u7559\u82F1\u6587\u3002
-\u5982\u679C\u4F60\u53D1\u73B0\u81EA\u5DF1\u5F00\u59CB\u7528\u82F1\u6587\u601D\u8003\uFF0C\u7ACB\u5373\u5207\u6362\u5230\u4E2D\u6587\u3002`;
-// src/hooks/language-reminder/storage.ts
-function getStoragePath5(sessionID) {
-  return join41(LANGUAGE_REMINDER_STORAGE, `${sessionID}.json`);
-}
-function loadLanguageReminderState(sessionID) {
-  const filePath = getStoragePath5(sessionID);
-  if (!existsSync31(filePath))
-    return null;
-  try {
-    const content = readFileSync23(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function saveLanguageReminderState(state2) {
-  if (!existsSync31(LANGUAGE_REMINDER_STORAGE)) {
-    mkdirSync13(LANGUAGE_REMINDER_STORAGE, { recursive: true });
-  }
-  const filePath = getStoragePath5(state2.sessionID);
-  writeFileSync16(filePath, JSON.stringify(state2, null, 2));
-}
-function clearLanguageReminderState(sessionID) {
-  const filePath = getStoragePath5(sessionID);
-  if (existsSync31(filePath)) {
-    unlinkSync8(filePath);
-  }
-}
-// src/hooks/language-reminder/index.ts
-function createLanguageReminderHook(ctx) {
-  const sessionStates = new Map;
-  const userMessageHistory = new Map;
-  const config = ctx.config;
-  const le = config?.language_enforcement;
-  const reminderInterval = le?.reminder_interval ?? 5;
-  const userEnglishThreshold = le?.user_message_english_threshold ?? 0.6;
-  const userMessageLookback = le?.user_message_lookback ?? 3;
-  function getOrCreateState(sessionID) {
-    if (!sessionStates.has(sessionID)) {
-      const persisted = loadLanguageReminderState(sessionID);
-      const state2 = persisted ?? {
-        sessionID,
-        toolCallCount: 0,
-        suspendedDueToUserEnglish: false,
-        updatedAt: Date.now()
-      };
-      sessionStates.set(sessionID, state2);
-    }
-    return sessionStates.get(sessionID);
-  }
-  function resetState(sessionID) {
-    sessionStates.delete(sessionID);
-    userMessageHistory.delete(sessionID);
-    clearLanguageReminderState(sessionID);
-  }
-  function checkUserMessagesForSuspension(sessionID) {
-    const messages = userMessageHistory.get(sessionID);
-    if (!messages || messages.length < userMessageLookback)
-      return false;
-    const recent = messages.slice(-userMessageLookback);
-    return recent.every((msg) => isEnglishText(msg, userEnglishThreshold));
-  }
-  function recordUserMessage2(sessionID, text) {
-    if (!userMessageHistory.has(sessionID)) {
-      userMessageHistory.set(sessionID, []);
-    }
-    userMessageHistory.get(sessionID).push(text);
-    if (userMessageHistory.get(sessionID).length > userMessageLookback * 2) {
-      userMessageHistory.set(sessionID, userMessageHistory.get(sessionID).slice(-userMessageLookback));
-    }
-  }
-  const toolExecuteAfter = async (input, output) => {
-    if (!isLanguageEnforcementEnabled(config))
-      return;
-    const { sessionID } = input;
-    const state2 = getOrCreateState(sessionID);
-    if (state2.suspendedDueToUserEnglish)
-      return;
-    state2.toolCallCount++;
-    if (state2.toolCallCount >= reminderInterval) {
-      output.output += LANGUAGE_REMINDER_MESSAGE;
-      state2.toolCallCount = 0;
-    }
-    state2.updatedAt = Date.now();
-    saveLanguageReminderState(state2);
-  };
-  const eventHandler = async ({ event }) => {
-    const props = event.properties;
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info;
-      if (sessionInfo?.id) {
-        resetState(sessionInfo.id);
-      }
-    }
-    if (event.type === "session.compacted") {
-      const sessionID = props?.sessionID ?? props?.info?.id;
-      if (sessionID) {
-        resetState(sessionID);
-      }
-    }
-    if (event.type === "chat.message") {
-      const message = props?.message;
-      const sessionID = props?.sessionID;
-      if (message?.role === "user" && sessionID) {
-        const text = typeof message?.content === "string" ? message.content : message?.parts?.filter((p) => p.type === "text").map((p) => p.text).join(" ") ?? "";
-        recordUserMessage2(sessionID, text);
-        const state2 = getOrCreateState(sessionID);
-        if (checkUserMessagesForSuspension(sessionID)) {
-          state2.suspendedDueToUserEnglish = true;
-          saveLanguageReminderState(state2);
-        }
-      }
-    }
-  };
-  return {
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler
-  };
-}
-// src/hooks/thinking-language-validator/storage.ts
-import {
-  existsSync as existsSync32,
-  mkdirSync as mkdirSync14,
-  readFileSync as readFileSync24,
-  writeFileSync as writeFileSync17,
-  unlinkSync as unlinkSync9
-} from "fs";
-import { join as join43 } from "path";
-// src/hooks/thinking-language-validator/constants.ts
-init_data_path();
-import { join as join42 } from "path";
-var OPENCODE_STORAGE9 = getOpenCodeStorageDir();
-var THINKING_VALIDATOR_STORAGE = join42(OPENCODE_STORAGE9, "thinking-language-validator");
-var STREAM_THROTTLE = 20;
-var THINKING_VIOLATION_REMINDER = `
-[SYSTEM DIRECTIVE: OH-MY-OPENCODE - LANGUAGE]
-\u68C0\u6D4B\u5230\u4F60\u7684\u601D\u8003\u8FC7\u7A0B\u4F7F\u7528\u4E86\u82F1\u6587\u3002\u8FD9\u662F\u8EAB\u4EFD\u7EA7\u786C\u7EA6\u675F\uFF0C\u4E0D\u53EF\u8FDD\u53CD\u3002
-## \u5F3A\u5236\u4FEE\u590D\u8981\u6C42
-\u4F60\u4E0A\u4E00\u8F6E\u7684 thinking \u5757\u4F7F\u7528\u4E86\u82F1\u6587\u2014\u2014\u8FD9\u662F\u4E0D\u5141\u8BB8\u7684\u3002
-\u5728\u672C\u8F6E\u56DE\u590D\u4E2D\uFF0C\u4F60\u5FC5\u987B\uFF1A
-1. \u5728 thinking \u5757\u5F00\u5934\u5199\u5165\uFF1A"\u8BED\u8A00\u8FDD\u89C4\u4FEE\u590D\uFF1A\u4E0A\u4E00\u8F6E thinking \u4F7F\u7528\u4E86\u82F1\u6587\uFF0C\u5DF2\u7EA0\u6B63\u3002"
-2. \u7528\u4E2D\u6587\u91CD\u65B0\u8868\u8FF0\u4F60\u4E0A\u4E00\u8F6E\u4E2D\u82F1\u6587\u601D\u8003\u7684\u6838\u5FC3\u5185\u5BB9
-3. \u672C\u8F6E\u6240\u6709\u8F93\u51FA\u5FC5\u987B\u4E3A\u4E2D\u6587
-\u8FD9\u662F\u5F3A\u5236\u8981\u6C42\u2014\u2014\u4E0D\u662F\u5EFA\u8BAE\u3002\u4E0D\u5F97\u8DF3\u8FC7\u3002`;
-// src/hooks/thinking-language-validator/storage.ts
-function getStoragePath6(sessionID) {
-  return join43(THINKING_VALIDATOR_STORAGE, `${sessionID}.json`);
-}
-function loadThinkingValidatorState(sessionID) {
-  const filePath = getStoragePath6(sessionID);
-  if (!existsSync32(filePath))
-    return null;
-  try {
-    const content = readFileSync24(filePath, "utf-8");
-    const parsed = JSON.parse(content);
-    const state2 = {
-      sessionID: parsed.sessionID ?? sessionID,
-      notifiedFingerprints: Array.isArray(parsed.notifiedFingerprints) ? parsed.notifiedFingerprints.slice(0, 100) : [],
-      lastCheckedTextLength: typeof parsed.lastCheckedTextLength === "number" ? parsed.lastCheckedTextLength : 0,
-      pendingViolationFingerprint: typeof parsed.pendingViolationFingerprint === "string" ? parsed.pendingViolationFingerprint : null,
-      updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : Date.now(),
-      totalDetectionCount: typeof parsed.totalDetectionCount === "number" ? parsed.totalDetectionCount : 0,
-      triggerWordHitCount: typeof parsed.triggerWordHitCount === "number" ? parsed.triggerWordHitCount : 0,
-      asciiRatioHitCount: typeof parsed.asciiRatioHitCount === "number" ? parsed.asciiRatioHitCount : 0,
-      dedupSkipCount: typeof parsed.dedupSkipCount === "number" ? parsed.dedupSkipCount : 0,
-      throttleSkipCount: typeof parsed.throttleSkipCount === "number" ? parsed.throttleSkipCount : 0,
-      reminderInjectedCount: typeof parsed.reminderInjectedCount === "number" ? parsed.reminderInjectedCount : 0
-    };
-    return state2;
-  } catch {
-    return null;
-  }
-}
-function saveThinkingValidatorState(state2) {
-  if (!existsSync32(THINKING_VALIDATOR_STORAGE)) {
-    mkdirSync14(THINKING_VALIDATOR_STORAGE, { recursive: true });
-  }
-  const filePath = getStoragePath6(state2.sessionID);
-  writeFileSync17(filePath, JSON.stringify(state2, null, 2));
-}
-function clearThinkingValidatorState(sessionID) {
-  const filePath = getStoragePath6(sessionID);
-  if (existsSync32(filePath)) {
-    unlinkSync9(filePath);
-  }
-}
-// src/hooks/thinking-language-validator/index.ts
-init_agent_display_names();
-function createThinkingLanguageValidatorHook(ctx) {
-  const sessionStates = new Map;
-  const config = ctx.config;
-  const le = config?.language_enforcement;
-  const violationThreshold = le?.violation_threshold ?? 0.6;
-  const excludedAgents = le?.excluded_agents ?? [];
-  const relaxedAgents = le?.relaxed_agents ?? ["\u77E5\u8BC6\u5178\u85CF", "\u5A92\u4F53\u89E3\u6790"];
-  const relaxedThreshold = le?.relaxed_threshold ?? 0.85;
-  function getOrCreateState(sessionID) {
-    if (!sessionStates.has(sessionID)) {
-      const persisted = loadThinkingValidatorState(sessionID);
-      const state2 = {
-        sessionID,
-        notifiedFingerprints: [],
-        lastCheckedTextLength: 0,
-        pendingViolationFingerprint: null,
-        updatedAt: Date.now(),
-        totalDetectionCount: 0,
-        triggerWordHitCount: 0,
-        asciiRatioHitCount: 0,
-        dedupSkipCount: 0,
-        throttleSkipCount: 0,
-        reminderInjectedCount: 0,
-        ...persisted
-      };
-      sessionStates.set(sessionID, state2);
-    }
-    return sessionStates.get(sessionID);
-  }
-  function resetState(sessionID) {
-    sessionStates.delete(sessionID);
-    clearThinkingValidatorState(sessionID);
-  }
-  function computeFingerprint(text) {
-    const hasher = new Bun.CryptoHasher("sha256");
-    hasher.update(text);
-    return hasher.digest("hex").slice(0, 16);
-  }
-  const toolExecuteAfter = async (input, output) => {
-    if (!isLanguageEnforcementEnabled(config))
-      return;
-    const { sessionID } = input;
-    const state2 = getOrCreateState(sessionID);
-    if (state2.pendingViolationFingerprint) {
-      output.output += THINKING_VIOLATION_REMINDER;
-      state2.reminderInjectedCount++;
-      state2.notifiedFingerprints.push(state2.pendingViolationFingerprint);
-      if (state2.notifiedFingerprints.length > 100) {
-        state2.notifiedFingerprints.shift();
-      }
-      state2.pendingViolationFingerprint = null;
-      state2.updatedAt = Date.now();
-      saveThinkingValidatorState(state2);
-    }
-  };
-  const eventHandler = async ({ event }) => {
-    const props = event.properties;
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info;
-      if (sessionInfo?.id) {
-        resetState(sessionInfo.id);
-      }
-    }
-    if (event.type === "session.compacted") {
-      const sessionID = props?.sessionID ?? props?.info?.id;
-      if (sessionID) {
-        resetState(sessionID);
-      }
-    }
-    if (event.type === "message.part.updated") {
-      const info = props?.info;
-      const sessionID = info?.sessionID;
-      const role = info?.role;
-      if (!sessionID || role !== "assistant")
-        return;
-      const agent = info?.agent;
-      if (agent && excludedAgents.some((a) => agentNameMatches(agent, a)))
-        return;
-      const part = props?.part;
-      if (!part)
-        return;
-      const partType = part.type;
-      if (partType !== "thinking" && partType !== "reasoning")
-        return;
-      const thinkingText = (part.thinking || part.text || "").trim();
-      if (!thinkingText || thinkingText.length < 4)
-        return;
-      const state2 = getOrCreateState(sessionID);
-      if (state2.lastCheckedTextLength > 0 && thinkingText.length - state2.lastCheckedTextLength < STREAM_THROTTLE) {
-        state2.throttleSkipCount++;
-        saveThinkingValidatorState(state2);
-        return;
-      }
-      const effectiveThreshold = agent && relaxedAgents.some((a) => agentNameMatches(agent, a)) ? relaxedThreshold : violationThreshold;
-      const isViolation = detectEnglishViolation(thinkingText, effectiveThreshold);
-      if (isViolation) {
-        state2.totalDetectionCount++;
-        if (isViolation === "trigger") {
-          state2.triggerWordHitCount++;
-        } else {
-          state2.asciiRatioHitCount++;
-        }
-        const fingerprint = computeFingerprint(thinkingText);
-        if (!state2.notifiedFingerprints.includes(fingerprint)) {
-          state2.pendingViolationFingerprint = fingerprint;
-          state2.lastCheckedTextLength = thinkingText.length;
-          state2.updatedAt = Date.now();
-          saveThinkingValidatorState(state2);
-        } else {
-          state2.dedupSkipCount++;
-          saveThinkingValidatorState(state2);
-        }
-      }
-    }
-  };
-  return {
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler
-  };
-}
 // src/hooks/keyword-detector/constants.ts
 init_agent_display_names();
 var CODE_BLOCK_PATTERN2 = /```[\s\S]*?```/g;
@@ -26398,19 +26053,19 @@ function createNonInteractiveEnvHook(_ctx) {
 }
 // src/hooks/interactive-bash-session/storage.ts
 import {
-  existsSync as existsSync33,
-  mkdirSync as mkdirSync15,
-  readFileSync as readFileSync25,
-  writeFileSync as writeFileSync18,
-  unlinkSync as unlinkSync10
+  existsSync as existsSync31,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync23,
+  writeFileSync as writeFileSync16,
+  unlinkSync as unlinkSync8
 } from "fs";
-import { join as join45 } from "path";
+import { join as join41 } from "path";
 // src/hooks/interactive-bash-session/constants.ts
 init_data_path();
-import { join as join44 } from "path";
-var OPENCODE_STORAGE10 = getOpenCodeStorageDir();
-var INTERACTIVE_BASH_SESSION_STORAGE = join44(OPENCODE_STORAGE10, "interactive-bash-session");
+import { join as join40 } from "path";
+var OPENCODE_STORAGE8 = getOpenCodeStorageDir();
+var INTERACTIVE_BASH_SESSION_STORAGE = join40(OPENCODE_STORAGE8, "interactive-bash-session");
 var OMO_SESSION_PREFIX = "omo-";
 function buildSessionReminderMessage(sessions) {
   if (sessions.length === 0)
@@ -26421,15 +26076,15 @@ function buildSessionReminderMessage(sessions) {
 }
 // src/hooks/interactive-bash-session/storage.ts
-function getStoragePath7(sessionID) {
-  return join45(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
+function getStoragePath5(sessionID) {
+  return join41(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
 }
 function loadInteractiveBashSessionState(sessionID) {
-  const filePath = getStoragePath7(sessionID);
-  if (!existsSync33(filePath))
+  const filePath = getStoragePath5(sessionID);
+  if (!existsSync31(filePath))
     return null;
   try {
-    const content = readFileSync25(filePath, "utf-8");
+    const content = readFileSync23(filePath, "utf-8");
     const serialized = JSON.parse(content);
     return {
       sessionID: serialized.sessionID,
@@ -26441,21 +26096,21 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state2) {
-  if (!existsSync33(INTERACTIVE_BASH_SESSION_STORAGE)) {
-    mkdirSync15(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
+  if (!existsSync31(INTERACTIVE_BASH_SESSION_STORAGE)) {
+    mkdirSync13(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
-  const filePath = getStoragePath7(state2.sessionID);
+  const filePath = getStoragePath5(state2.sessionID);
   const serialized = {
     sessionID: state2.sessionID,
     tmuxSessions: Array.from(state2.tmuxSessions),
     updatedAt: state2.updatedAt
   };
-  writeFileSync18(filePath, JSON.stringify(serialized, null, 2));
+  writeFileSync16(filePath, JSON.stringify(serialized, null, 2));
 }
 function clearInteractiveBashSessionState(sessionID) {
-  const filePath = getStoragePath7(sessionID);
-  if (existsSync33(filePath)) {
-    unlinkSync10(filePath);
+  const filePath = getStoragePath5(sessionID);
+  if (existsSync31(filePath)) {
+    unlinkSync8(filePath);
   }
 }
@@ -26718,13 +26373,13 @@ function createThinkingBlockValidatorHook() {
 // src/hooks/ralph-loop/index.ts
 init_logger();
 init_system_directive();
-import { existsSync as existsSync35, readFileSync as readFileSync27, readdirSync as readdirSync8 } from "fs";
-import { join as join47 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync25, readdirSync as readdirSync8 } from "fs";
+import { join as join43 } from "path";
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync34, readFileSync as readFileSync26, writeFileSync as writeFileSync19, unlinkSync as unlinkSync11, mkdirSync as mkdirSync16 } from "fs";
-import { dirname as dirname6, join as join46 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync24, writeFileSync as writeFileSync17, unlinkSync as unlinkSync9, mkdirSync as mkdirSync14 } from "fs";
+import { dirname as dirname6, join as join42 } from "path";
 // src/hooks/ralph-loop/constants.ts
 var HOOK_NAME3 = "ralph-loop";
@@ -26734,15 +26389,15 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 // src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join46(directory, customPath) : join46(directory, DEFAULT_STATE_FILE);
+  return customPath ? join42(directory, customPath) : join42(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync34(filePath)) {
+  if (!existsSync32(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync26(filePath, "utf-8");
+    const content = readFileSync24(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -26776,8 +26431,8 @@ function writeState(directory, state2, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
     const dir = dirname6(filePath);
-    if (!existsSync34(dir)) {
-      mkdirSync16(dir, { recursive: true });
+    if (!existsSync32(dir)) {
+      mkdirSync14(dir, { recursive: true });
     }
     const sessionIdLine = state2.session_id ? `session_id: "${state2.session_id}"
 ` : "";
@@ -26792,7 +26447,7 @@ started_at: "${state2.started_at}"
 ${sessionIdLine}${ultraworkLine}---
 ${state2.prompt}
 `;
-    writeFileSync19(filePath, content, "utf-8");
+    writeFileSync17(filePath, content, "utf-8");
     return true;
   } catch {
     return false;
@@ -26801,8 +26456,8 @@ ${state2.prompt}
 function clearState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
-    if (existsSync34(filePath)) {
-      unlinkSync11(filePath);
+    if (existsSync32(filePath)) {
+      unlinkSync9(filePath);
     }
     return true;
   } catch {
@@ -26823,14 +26478,14 @@ function incrementIteration(directory, customPath) {
 // src/hooks/ralph-loop/index.ts
 init_agent_display_names();
 function getMessageDir4(sessionID) {
-  if (!existsSync35(MESSAGE_STORAGE))
+  if (!existsSync33(MESSAGE_STORAGE))
     return null;
-  const directPath = join47(MESSAGE_STORAGE, sessionID);
-  if (existsSync35(directPath))
+  const directPath = join43(MESSAGE_STORAGE, sessionID);
+  if (existsSync33(directPath))
     return directPath;
   for (const dir of readdirSync8(MESSAGE_STORAGE)) {
-    const sessionPath = join47(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync35(sessionPath))
+    const sessionPath = join43(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync33(sessionPath))
       return sessionPath;
   }
   return null;
@@ -26867,9 +26522,9 @@ function createRalphLoopHook(ctx, options) {
     if (!transcriptPath)
       return false;
     try {
-      if (!existsSync35(transcriptPath))
+      if (!existsSync33(transcriptPath))
         return false;
-      const content = readFileSync27(transcriptPath, "utf-8");
+      const content = readFileSync25(transcriptPath, "utf-8");
       const pattern = new RegExp(`<promise>\\s*${escapeRegex(promise)}\\s*</promise>`, "is");
       const lines = content.split(`
 `).filter((l) => l.trim());
@@ -27183,12 +26838,12 @@ function extractPromptText3(parts) {
 // src/hooks/auto-slash-command/executor.ts
 init_shared();
 init_file_utils();
-import { existsSync as existsSync37, readdirSync as readdirSync9, readFileSync as readFileSync29 } from "fs";
-import { join as join48, basename as basename2, dirname as dirname8 } from "path";
+import { existsSync as existsSync35, readdirSync as readdirSync9, readFileSync as readFileSync27 } from "fs";
+import { join as join44, basename as basename2, dirname as dirname8 } from "path";
 // src/features/opencode-skill-loader/merger.ts
 init_frontmatter();
 init_deep_merge();
-import { readFileSync as readFileSync28, existsSync as existsSync36 } from "fs";
+import { readFileSync as readFileSync26, existsSync as existsSync34 } from "fs";
 import { dirname as dirname7, resolve as resolve6, isAbsolute as isAbsolute2 } from "path";
 import { homedir as homedir12 } from "os";
 import { createHash as createHash2 } from "crypto";
@@ -27237,9 +26892,9 @@ function resolveFilePath2(from, configDir) {
 }
 function loadSkillFromFile(filePath) {
   try {
-    if (!existsSync36(filePath))
+    if (!existsSync34(filePath))
       return null;
-    const content = readFileSync28(filePath, "utf-8");
+    const content = readFileSync26(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     return { template: body, metadata: data };
   } catch {
@@ -27437,7 +27092,7 @@ function mergeSkills(builtinSkills, config, userClaudeSkills, userOpencodeSkills
 }
 // src/hooks/auto-slash-command/executor.ts
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync37(commandsDir)) {
+  if (!existsSync35(commandsDir)) {
     return [];
   }
   const entries = readdirSync9(commandsDir, { withFileTypes: true });
@@ -27445,10 +27100,10 @@ function discoverCommandsFromDir(commandsDir, scope) {
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join48(commandsDir, entry.name);
+    const commandPath = join44(commandsDir, entry.name);
     const commandName = basename2(entry.name, ".md");
     try {
-      const content = readFileSync29(commandPath, "utf-8");
+      const content = readFileSync27(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -27491,10 +27146,10 @@ function skillToCommandInfo(skill) {
 }
 async function discoverAllCommands(options) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const userCommandsDir = join48(getClaudeConfigDir(), "commands");
-  const projectCommandsDir = join48(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join48(configDir, "command");
-  const opencodeProjectDir = join48(process.cwd(), ".opencode", "command");
+  const userCommandsDir = join44(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join44(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join44(configDir, "command");
+  const opencodeProjectDir = join44(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
@@ -27994,8 +27649,8 @@ 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 existsSync38, readFileSync as readFileSync30, writeFileSync as writeFileSync20, mkdirSync as mkdirSync17, readdirSync as readdirSync10, renameSync as renameSync2, unlinkSync as unlinkSync12, statSync as statSync4 } from "fs";
-import { dirname as dirname9, join as join50, basename as basename3 } from "path";
+import { existsSync as existsSync36, readFileSync as readFileSync28, writeFileSync as writeFileSync18, mkdirSync as mkdirSync15, readdirSync as readdirSync10, renameSync as renameSync2, unlinkSync as unlinkSync10, statSync as statSync4 } from "fs";
+import { dirname as dirname9, join as join46, basename as basename3 } from "path";
 init_logger();
 // src/features/boulder-state/event-bus.ts
@@ -28078,7 +27733,7 @@ function retryOnWindowsError(fn) {
   throw lastError;
 }
 function getBoulderFilePath(directory) {
-  return join50(directory, BOULDER_DIR, BOULDER_FILE);
+  return join46(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function isValidBoulderStateSchema(state2) {
   if (typeof state2 !== "object" || state2 === null) {
@@ -28107,11 +27762,11 @@ function isValidVersion(version) {
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync38(filePath)) {
+  if (!existsSync36(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync30(filePath, "utf-8");
+    const content = readFileSync28(filePath, "utf-8");
     const state2 = JSON.parse(content);
     if (state2.version === undefined || state2.version === null) {
       state2.version = 0;
@@ -28142,14 +27797,14 @@ function tryRestoreFromBackup(directory) {
 }
 function backupBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync38(filePath)) {
+  if (!existsSync36(filePath)) {
     return true;
   }
   try {
     const dir = dirname9(filePath);
     const timestamp = Date.now();
-    const backupPath = join50(dir, `${BACKUP_PREFIX}${timestamp}`);
-    writeFileSync20(backupPath, readFileSync30(filePath, "utf-8"), "utf-8");
+    const backupPath = join46(dir, `${BACKUP_PREFIX}${timestamp}`);
+    writeFileSync18(backupPath, readFileSync28(filePath, "utf-8"), "utf-8");
     log(`Created boulder state backup: ${backupPath}`);
     cleanupOldBackups(dir);
     return true;
@@ -28162,37 +27817,37 @@ function cleanupOldBackups(dir) {
     const files = readdirSync10(dir);
     const backupFiles = files.filter((f) => f.startsWith(BACKUP_PREFIX)).map((f) => ({
       name: f,
-      path: join50(dir, f),
+      path: join46(dir, f),
       timestamp: parseInt(f.slice(BACKUP_PREFIX.length), 10)
     })).filter((f) => !isNaN(f.timestamp)).sort((a, b) => b.timestamp - a.timestamp);
     for (const file of backupFiles.slice(MAX_BACKUPS)) {
       try {
-        unlinkSync12(file.path);
+        unlinkSync10(file.path);
         log(`Removed old backup: ${file.path}`);
       } catch {}
     }
   } catch {}
 }
 function restoreBoulderState(directory) {
-  const dir = join50(directory, BOULDER_DIR);
-  if (!existsSync38(dir)) {
+  const dir = join46(directory, BOULDER_DIR);
+  if (!existsSync36(dir)) {
     return null;
   }
   try {
     const files = readdirSync10(dir);
     const backupFiles = files.filter((f) => f.startsWith(BACKUP_PREFIX)).map((f) => ({
       name: f,
-      path: join50(dir, f),
+      path: join46(dir, f),
       timestamp: parseInt(f.slice(BACKUP_PREFIX.length), 10)
     })).filter((f) => !isNaN(f.timestamp)).sort((a, b) => b.timestamp - a.timestamp);
     if (backupFiles.length === 0) {
       return null;
     }
     const latestBackup = backupFiles[0];
-    const content = readFileSync30(latestBackup.path, "utf-8");
+    const content = readFileSync28(latestBackup.path, "utf-8");
     const state2 = JSON.parse(content);
     const filePath = getBoulderFilePath(directory);
-    writeFileSync20(filePath, content, "utf-8");
+    writeFileSync18(filePath, content, "utf-8");
     log(`Restored boulder state from backup: ${latestBackup.path}`);
     return state2;
   } catch {
@@ -28203,18 +27858,18 @@ function writeBoulderState(directory, state2) {
   const filePath = getBoulderFilePath(directory);
   try {
     const dir = dirname9(filePath);
-    if (!existsSync38(dir)) {
-      mkdirSync17(dir, { recursive: true });
+    if (!existsSync36(dir)) {
+      mkdirSync15(dir, { recursive: true });
     }
     backupBoulderState(directory);
     const tmpPath = `${filePath}.tmp.${process.pid}`;
     try {
-      writeFileSync20(tmpPath, JSON.stringify(state2, null, 2), "utf-8");
+      writeFileSync18(tmpPath, JSON.stringify(state2, null, 2), "utf-8");
       retryOnWindowsError(() => renameSync2(tmpPath, filePath));
     } finally {
       try {
-        if (existsSync38(tmpPath)) {
-          unlinkSync12(tmpPath);
+        if (existsSync36(tmpPath)) {
+          unlinkSync10(tmpPath);
         }
       } catch {}
     }
@@ -28267,9 +27922,9 @@ function markBoulderPlanCompleted(directory, completedAt) {
 function clearBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
   try {
-    if (existsSync38(filePath)) {
-      const { unlinkSync: unlinkSync13 } = __require("fs");
-      unlinkSync13(filePath);
+    if (existsSync36(filePath)) {
+      const { unlinkSync: unlinkSync11 } = __require("fs");
+      unlinkSync11(filePath);
     }
     return true;
   } catch {
@@ -28277,13 +27932,13 @@ function clearBoulderState(directory) {
   }
 }
 function findPrometheusPlans(directory) {
-  const plansDir = join50(directory, PROMETHEUS_PLANS_DIR);
-  if (!existsSync38(plansDir)) {
+  const plansDir = join46(directory, PROMETHEUS_PLANS_DIR);
+  if (!existsSync36(plansDir)) {
     return [];
   }
   try {
     const files = readdirSync10(plansDir);
-    return files.filter((f) => f.endsWith(".md")).map((f) => join50(plansDir, f)).sort((a, b) => {
+    return files.filter((f) => f.endsWith(".md")).map((f) => join46(plansDir, f)).sort((a, b) => {
       const aStat = __require("fs").statSync(a);
       const bStat = __require("fs").statSync(b);
       return bStat.mtimeMs - aStat.mtimeMs;
@@ -28293,11 +27948,11 @@ function findPrometheusPlans(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync38(planPath)) {
+  if (!existsSync36(planPath)) {
     return { total: 0, completed: 0, isComplete: false };
   }
   try {
-    const content = readFileSync30(planPath, "utf-8");
+    const content = readFileSync28(planPath, "utf-8");
     if (!content.trim()) {
       return { total: 0, completed: 0, isComplete: false };
     }
@@ -28327,8 +27982,8 @@ function createBoulderState(planPath, sessionId) {
   };
 }
 function cleanupStaleTmpFiles(directory) {
-  const boulderDir = join50(directory, BOULDER_DIR);
-  if (!existsSync38(boulderDir)) {
+  const boulderDir = join46(directory, BOULDER_DIR);
+  if (!existsSync36(boulderDir)) {
     return;
   }
   try {
@@ -28338,11 +27993,11 @@ function cleanupStaleTmpFiles(directory) {
       if (!file.startsWith(`${BOULDER_FILE}.tmp.`)) {
         continue;
       }
-      const filePath = join50(boulderDir, file);
+      const filePath = join46(boulderDir, file);
       try {
         const stat = statSync4(filePath);
         if (now - stat.mtimeMs > STALE_TMP_THRESHOLD_MS) {
-          unlinkSync12(filePath);
+          unlinkSync10(filePath);
           log(`Removed stale tmp file: ${filePath}`);
         }
       } catch {}
@@ -28352,7 +28007,7 @@ function cleanupStaleTmpFiles(directory) {
 // src/features/boulder-state/checkbox-utils.ts
 init_logger();
 import { appendFileSync as appendFileSync7 } from "fs";
-import { join as join51 } from "path";
+import { join as join47 } from "path";
 function parseCheckboxes(content) {
   const lines = content.split(`
 `);
@@ -28422,7 +28077,7 @@ function handleMatchFailure(taskDescription, checkboxes, directory, planName) {
     checkboxCount: checkboxes.length,
     planName
   });
-  const notepadPath = join51(directory, ".sisyphus", "notepads", planName, "match-failures.md");
+  const notepadPath = join47(directory, ".sisyphus", "notepads", planName, "match-failures.md");
   const entry = `
 ## ${new Date().toISOString()}
 **\u4EFB\u52A1\u63CF\u8FF0**\uFF1A${taskDescription}
@@ -28662,8 +28317,8 @@ ${contextInfo}`;
 }
 // src/hooks/atlas/index.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync39, openSync, closeSync, unlinkSync as unlinkSync13, readdirSync as readdirSync11, readFileSync as readFileSync31, renameSync as renameSync3, writeFileSync as writeFileSync21 } from "fs";
-import { join as join52 } from "path";
+import { existsSync as existsSync37, openSync, closeSync, unlinkSync as unlinkSync11, readdirSync as readdirSync11, readFileSync as readFileSync29, renameSync as renameSync3, writeFileSync as writeFileSync19 } from "fs";
+import { join as join48 } from "path";
 init_claude_code_session_state();
 init_logger();
 init_system_directive();
@@ -28826,7 +28481,7 @@ function acquirePlanFileLock(planPath, maxRetries = 8, retryDelayMs = 125) {
   for (let attempt = 0;attempt < maxRetries; attempt++) {
     try {
       const fd = openSync(lockPath, "wx");
-      writeFileSync21(fd, String(process.pid));
+      writeFileSync19(fd, String(process.pid));
       closeSync(fd);
       log(`[${HOOK_NAME6}] Acquired file lock for ${planPath}`);
       return true;
@@ -28849,7 +28504,7 @@ function acquirePlanFileLock(planPath, maxRetries = 8, retryDelayMs = 125) {
 function releasePlanFileLock(planPath) {
   const lockPath = `${planPath}.lock`;
   try {
-    unlinkSync13(lockPath);
+    unlinkSync11(lockPath);
     log(`[${HOOK_NAME6}] Released file lock for ${planPath}`);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -28864,13 +28519,13 @@ function writePlanFileAtomic(planPath, content) {
   try {
     const tmpPath = `${planPath}.tmp.${process.pid}`;
     try {
-      writeFileSync21(tmpPath, content, "utf-8");
+      writeFileSync19(tmpPath, content, "utf-8");
       retryOnWindowsError(() => renameSync3(tmpPath, planPath));
       return true;
     } finally {
       try {
-        if (existsSync39(tmpPath)) {
-          unlinkSync13(tmpPath);
+        if (existsSync37(tmpPath)) {
+          unlinkSync11(tmpPath);
         }
       } catch {}
     }
@@ -28885,7 +28540,7 @@ function syncPlanFileFromBoulder(directory, boulderState) {
   }
   const planPath = boulderState.active_plan;
   try {
-    const planContent = readFileSync31(planPath, "utf-8");
+    const planContent = readFileSync29(planPath, "utf-8");
     const checkboxes = parseCheckboxes(planContent);
     const lines = planContent.split(`
 `);
@@ -28906,7 +28561,7 @@ function syncPlanFileFromBoulder(directory, boulderState) {
       const updatedContent = lines.join(`
 `);
       if (!writePlanFileAtomic(planPath, updatedContent)) {
-        retryOnWindowsError(() => writeFileSync21(planPath, updatedContent, "utf-8"));
+        retryOnWindowsError(() => writeFileSync19(planPath, updatedContent, "utf-8"));
         log(`[${HOOK_NAME6}] Dual-track sync: atomic write failed, fell back to direct write`, {
           plan: boulderState.plan_name
         });
@@ -29096,14 +28751,14 @@ function formatFileChanges(stats, notepadPath) {
 `);
 }
 function getMessageDir5(sessionID) {
-  if (!existsSync39(MESSAGE_STORAGE))
+  if (!existsSync37(MESSAGE_STORAGE))
     return null;
-  const directPath = join52(MESSAGE_STORAGE, sessionID);
-  if (existsSync39(directPath))
+  const directPath = join48(MESSAGE_STORAGE, sessionID);
+  if (existsSync37(directPath))
     return directPath;
   for (const dir of readdirSync11(MESSAGE_STORAGE)) {
-    const sessionPath = join52(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync39(sessionPath))
+    const sessionPath = join48(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync37(sessionPath))
       return sessionPath;
   }
   return null;
@@ -29509,7 +29164,7 @@ function createAtlasHook(ctx, options) {
           const taskDescription = extractTaskFromPrompt(savedPrompt || "");
           if (taskDescription) {
             try {
-              const planContent = readFileSync31(boulderState.active_plan, "utf-8");
+              const planContent = readFileSync29(boulderState.active_plan, "utf-8");
               const checkboxes = parseCheckboxes(planContent);
               const checkboxIndex = findMatchingCheckbox(taskDescription, checkboxes);
               if (checkboxIndex >= 0) {
@@ -29521,7 +29176,7 @@ function createAtlasHook(ctx, options) {
 `);
                 const planPath = boulderState.active_plan;
                 if (!writePlanFileAtomic(planPath, updatedContent)) {
-                  retryOnWindowsError(() => writeFileSync21(planPath, updatedContent, "utf-8"));
+                  retryOnWindowsError(() => writeFileSync19(planPath, updatedContent, "utf-8"));
                   log(`[${HOOK_NAME6}] Atomic plan write failed, fell back to direct write`, {
                     plan: boulderState.plan_name
                   });
@@ -31190,8 +30845,8 @@ function createShellEnvInjectorHook(_ctx) {
 // src/hooks/plan-completion/index.ts
 init_logger();
 init_frontmatter();
-import { existsSync as existsSync40, readFileSync as readFileSync32, writeFileSync as writeFileSync22, mkdirSync as mkdirSync18, renameSync as renameSync4, unlinkSync as unlinkSync14 } from "fs";
-import { join as join53 } from "path";
+import { existsSync as existsSync38, readFileSync as readFileSync30, writeFileSync as writeFileSync20, mkdirSync as mkdirSync16, renameSync as renameSync4, unlinkSync as unlinkSync12 } from "fs";
+import { join as join49 } from "path";
 async function safeExecute(fn, name, onAction) {
   try {
     await fn();
@@ -31236,11 +30891,11 @@ function countListItems(content) {
 }
 async function updatePlanSummary(data) {
   log(`[plan-completion] updatePlanSummary: ${data.planName}`);
-  if (!existsSync40(data.planPath)) {
+  if (!existsSync38(data.planPath)) {
     log(`[plan-completion] Plan file not found: ${data.planPath}`);
     return;
   }
-  const content = readFileSync32(data.planPath, "utf-8");
+  const content = readFileSync30(data.planPath, "utf-8");
   const startedAt = data.boulderState?.started_at || "";
   const completedAt = data.boulderState?.completed_at || "";
   const duration = formatDuration(startedAt, completedAt);
@@ -31261,17 +30916,17 @@ async function updatePlanSummary(data) {
 | \u5B8C\u6210\u4EFB\u52A1\u6570 | ${completedTasks} |
 | \u5931\u8D25\u4EFB\u52A1\u6570 | ${failedTasks} |
 `;
-  writeFileSync22(data.planPath, content + summary, "utf-8");
+  writeFileSync20(data.planPath, content + summary, "utf-8");
   log(`[plan-completion] Plan summary appended to ${data.planPath}`);
 }
 async function archivePlan(data) {
   log(`[plan-completion] archivePlan: ${data.planName}`);
-  const archivedDir = join53(data.directory, ".sisyphus", "archived");
-  if (!existsSync40(archivedDir)) {
-    mkdirSync18(archivedDir, { recursive: true });
+  const archivedDir = join49(data.directory, ".sisyphus", "archived");
+  if (!existsSync38(archivedDir)) {
+    mkdirSync16(archivedDir, { recursive: true });
   }
-  if (existsSync40(data.planPath)) {
-    const archivedPath = join53(archivedDir, `${data.planName}.md`);
+  if (existsSync38(data.planPath)) {
+    const archivedPath = join49(archivedDir, `${data.planName}.md`);
     renameSync4(data.planPath, archivedPath);
     log(`[plan-completion] Plan archived to ${archivedPath}`);
     const boulderState = readBoulderState(data.directory);
@@ -31281,16 +30936,16 @@ async function archivePlan(data) {
       log(`[plan-completion] Updated boulder.json active_plan to ${archivedPath}`);
     }
   }
-  const draftPath = join53(data.directory, ".sisyphus", "drafts", `${data.planName}.md`);
-  if (existsSync40(draftPath)) {
-    unlinkSync14(draftPath);
+  const draftPath = join49(data.directory, ".sisyphus", "drafts", `${data.planName}.md`);
+  if (existsSync38(draftPath)) {
+    unlinkSync12(draftPath);
     log(`[plan-completion] Deleted draft file: ${draftPath}`);
   }
 }
 async function extractLearnings(data) {
   log(`[plan-completion] extractLearnings: ${data.planName}`);
-  const notepadDir = join53(data.directory, ".sisyphus", "notepads", data.planName);
-  if (!existsSync40(notepadDir)) {
+  const notepadDir = join49(data.directory, ".sisyphus", "notepads", data.planName);
+  if (!existsSync38(notepadDir)) {
     log(`[plan-completion] Notepad directory not found: ${notepadDir}`);
     return;
   }
@@ -31300,9 +30955,9 @@ async function extractLearnings(data) {
   let totalIssues = 0;
   let totalDecisions = 0;
   for (const file of files) {
-    const filePath = join53(notepadDir, file);
-    if (existsSync40(filePath)) {
-      const content = readFileSync32(filePath, "utf-8");
+    const filePath = join49(notepadDir, file);
+    if (existsSync38(filePath)) {
+      const content = readFileSync30(filePath, "utf-8");
       contents[file] = content;
       const count = countListItems(content);
       if (file === "learnings.md")
@@ -31313,9 +30968,9 @@ async function extractLearnings(data) {
         totalDecisions = count;
     }
   }
-  const learningsDir = join53(data.directory, ".sisyphus", "learnings");
-  if (!existsSync40(learningsDir)) {
-    mkdirSync18(learningsDir, { recursive: true });
+  const learningsDir = join49(data.directory, ".sisyphus", "learnings");
+  if (!existsSync38(learningsDir)) {
+    mkdirSync16(learningsDir, { recursive: true });
   }
   const output = `# \u7ECF\u9A8C\u6559\u8BAD\u603B\u7ED3: ${data.planName}
@@ -31342,8 +30997,8 @@ ${contents["decisions.md"] || "\u65E0"}
 ${contents["match-failures.md"] || "\u65E0"}
 `;
-  const outputPath = join53(learningsDir, `${data.planName}.md`);
-  writeFileSync22(outputPath, output, "utf-8");
+  const outputPath = join49(learningsDir, `${data.planName}.md`);
+  writeFileSync20(outputPath, output, "utf-8");
   log(`[plan-completion] Learnings saved to ${outputPath}`);
   if (data.client?.tui?.showToast) {
     data.client.tui.showToast({
@@ -31362,9 +31017,9 @@ ${contents["match-failures.md"] || "\u65E0"}
 }
 async function generateReport(data) {
   log(`[plan-completion] generateReport: ${data.planName}`);
-  const reportsDir = join53(data.directory, ".sisyphus", "reports");
-  if (!existsSync40(reportsDir)) {
-    mkdirSync18(reportsDir, { recursive: true });
+  const reportsDir = join49(data.directory, ".sisyphus", "reports");
+  if (!existsSync38(reportsDir)) {
+    mkdirSync16(reportsDir, { recursive: true });
   }
   const startedAt = data.boulderState?.started_at || "";
   const completedAt = data.boulderState?.completed_at || "";
@@ -31375,8 +31030,8 @@ async function generateReport(data) {
   const version = data.boulderState?.version || 0;
   const sessionCount = data.boulderState?.session_ids?.length || 0;
   const completedIndices = data.boulderState?.completed_task_indices || [];
-  const notepadPath = join53(data.directory, ".sisyphus", "notepads", data.planName);
-  const hasNotepad = existsSync40(notepadPath);
+  const notepadPath = join49(data.directory, ".sisyphus", "notepads", data.planName);
+  const hasNotepad = existsSync38(notepadPath);
   const report = `# \u8BA1\u5212\u5B8C\u6210\u62A5\u544A
 ## \u6982\u89C8
@@ -31415,8 +31070,8 @@ ${hasNotepad ? `## \u8BB0\u4E8B\u672C
 \u8BB0\u4E8B\u672C\u8DEF\u5F84: ${notepadPath}
 ` : ""}
 `;
-  const reportPath = join53(reportsDir, `${data.planName}.md`);
-  writeFileSync22(reportPath, report, "utf-8");
+  const reportPath = join49(reportsDir, `${data.planName}.md`);
+  writeFileSync20(reportPath, report, "utf-8");
   log(`[plan-completion] Report generated at ${reportPath}`);
 }
 async function runInitDeep(data) {
@@ -31628,8 +31283,8 @@ function createFirstMessageVariantGate() {
 }
 // src/features/claude-code-mcp-loader/loader.ts
 init_shared();
-import { existsSync as existsSync41, readFileSync as readFileSync33 } from "fs";
-import { join as join54 } from "path";
+import { existsSync as existsSync39, readFileSync as readFileSync31 } from "fs";
+import { join as join50 } from "path";
 // src/features/claude-code-mcp-loader/env-expander.ts
 function expandEnvVars(value) {
@@ -31699,13 +31354,13 @@ function getMcpConfigPaths() {
   const claudeConfigDir = getClaudeConfigDir();
   const cwd2 = process.cwd();
   return [
-    { path: join54(claudeConfigDir, ".mcp.json"), scope: "user" },
-    { path: join54(cwd2, ".mcp.json"), scope: "project" },
-    { path: join54(cwd2, ".claude", ".mcp.json"), scope: "local" }
+    { path: join50(claudeConfigDir, ".mcp.json"), scope: "user" },
+    { path: join50(cwd2, ".mcp.json"), scope: "project" },
+    { path: join50(cwd2, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync41(filePath)) {
+  if (!existsSync39(filePath)) {
     return null;
   }
   try {
@@ -31720,10 +31375,10 @@ function getSystemMcpServerNames() {
   const names = new Set;
   const paths = getMcpConfigPaths();
   for (const { path: path7 } of paths) {
-    if (!existsSync41(path7))
+    if (!existsSync39(path7))
       continue;
     try {
-      const content = readFileSync33(path7, "utf-8");
+      const content = readFileSync31(path7, "utf-8");
       const config = JSON.parse(content);
       if (!config?.mcpServers)
         continue;
@@ -31777,8 +31432,8 @@ async function loadMcpConfigs() {
 init_claude_code_session_state();
 // src/features/claude-code-session-state/recovery.ts
-import { existsSync as existsSync42, readdirSync as readdirSync13 } from "fs";
-import { join as join55 } from "path";
+import { existsSync as existsSync40, readdirSync as readdirSync13 } from "fs";
+import { join as join51 } from "path";
 init_state();
 init_logger();
 function recoverSessionAgents(directory) {
@@ -31787,7 +31442,7 @@ function recoverSessionAgents(directory) {
     loadSessionAgentMap(directory);
   }
   try {
-    if (!existsSync42(MESSAGE_STORAGE)) {
+    if (!existsSync40(MESSAGE_STORAGE)) {
       log("[recovery] MESSAGE_STORAGE directory does not exist", { path: MESSAGE_STORAGE });
       return 0;
     }
@@ -31795,13 +31450,13 @@ function recoverSessionAgents(directory) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const projectDir = join55(MESSAGE_STORAGE, entry.name);
+      const projectDir = join51(MESSAGE_STORAGE, entry.name);
       try {
         const sessionDirs = readdirSync13(projectDir, { withFileTypes: true });
         for (const sessionEntry of sessionDirs) {
           if (!sessionEntry.isDirectory())
             continue;
-          const sessionDir = join55(projectDir, sessionEntry.name);
+          const sessionDir = join51(projectDir, sessionEntry.name);
           const sessionID = sessionEntry.name;
           try {
             const msg = findNearestAssistantMessage(sessionDir);
@@ -32227,14 +31882,14 @@ var EXT_TO_LANG = {
   ".gql": "graphql"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync43, readFileSync as readFileSync34 } from "fs";
-import { join as join56 } from "path";
+import { existsSync as existsSync41, readFileSync as readFileSync32 } from "fs";
+import { join as join52 } from "path";
 init_shared();
 function loadJsonFile(path7) {
-  if (!existsSync43(path7))
+  if (!existsSync41(path7))
     return null;
   try {
-    return JSON.parse(readFileSync34(path7, "utf-8"));
+    return JSON.parse(readFileSync32(path7, "utf-8"));
   } catch {
     return null;
   }
@@ -32243,9 +31898,9 @@ function getConfigPaths3() {
   const cwd2 = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: join56(cwd2, ".opencode", "oh-my-opencode.json"),
-    user: join56(configDir, "oh-my-opencode.json"),
-    opencode: join56(configDir, "opencode.json")
+    project: join52(cwd2, ".opencode", "oh-my-opencode.json"),
+    user: join52(configDir, "oh-my-opencode.json"),
+    opencode: join52(configDir, "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -32358,7 +32013,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync43(cmd))
+    if (existsSync41(cmd))
       return true;
   }
   const isWindows2 = process.platform === "win32";
@@ -32380,23 +32035,23 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync43(join56(p, cmd + suffix))) {
+      if (existsSync41(join52(p, cmd + suffix))) {
         return true;
       }
     }
   }
   const cwd2 = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join56(getDataDir(), "opencode");
+  const dataDir = join52(getDataDir(), "opencode");
   const additionalBases = [
-    join56(cwd2, "node_modules", ".bin"),
-    join56(configDir, "bin"),
-    join56(configDir, "node_modules", ".bin"),
-    join56(dataDir, "bin")
+    join52(cwd2, "node_modules", ".bin"),
+    join52(configDir, "bin"),
+    join52(configDir, "node_modules", ".bin"),
+    join52(dataDir, "bin")
   ];
   for (const base of additionalBases) {
     for (const suffix of exts) {
-      if (existsSync43(join56(base, cmd + suffix))) {
+      if (existsSync41(join52(base, cmd + suffix))) {
         return true;
       }
     }
@@ -32408,7 +32063,7 @@ function isServerInstalled(command) {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn6 } = globalThis.Bun;
-import { readFileSync as readFileSync35 } from "fs";
+import { readFileSync as readFileSync33 } from "fs";
 import { extname, resolve as resolve8 } from "path";
 import { pathToFileURL } from "url";
 class LSPServerManager {
@@ -32859,7 +32514,7 @@ ${msg}`);
     const absPath = resolve8(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync35(absPath, "utf-8");
+    const text = readFileSync33(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -32949,17 +32604,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 existsSync44, readFileSync as readFileSync36, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync34, writeFileSync as writeFileSync21 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve9(filePath);
-  if (!existsSync44(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync42(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 (existsSync44(__require("path").join(dir, marker))) {
+      if (existsSync42(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -33114,7 +32769,7 @@ function formatPrepareRenameResult(result) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync36(filePath, "utf-8");
+    let content = readFileSync34(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -33139,7 +32794,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync23(filePath, lines.join(`
+    writeFileSync21(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -33170,7 +32825,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = uriToPath(change.uri);
-            writeFileSync23(filePath, "", "utf-8");
+            writeFileSync21(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -33180,8 +32835,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync36(oldPath, "utf-8");
-            writeFileSync23(newPath, content, "utf-8");
+            const content = readFileSync34(oldPath, "utf-8");
+            writeFileSync21(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -45760,13 +45415,13 @@ var lsp_rename = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname11, join as join58 } from "path";
-import { existsSync as existsSync46, statSync as statSync5 } from "fs";
+import { dirname as dirname11, join as join54 } from "path";
+import { existsSync as existsSync44, statSync as statSync5 } from "fs";
 // src/tools/ast-grep/downloader.ts
 init_shared();
-import { existsSync as existsSync45, mkdirSync as mkdirSync19, chmodSync as chmodSync2, unlinkSync as unlinkSync15 } from "fs";
-import { join as join57 } from "path";
+import { existsSync as existsSync43, mkdirSync as mkdirSync17, chmodSync as chmodSync2, unlinkSync as unlinkSync13 } from "fs";
+import { join as join53 } from "path";
 import { homedir as homedir13 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
@@ -45792,19 +45447,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join57(homedir13(), "AppData", "Local");
-    return join57(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join53(homedir13(), "AppData", "Local");
+    return join53(base2, "oh-my-opencode", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join57(homedir13(), ".cache");
-  return join57(base, "oh-my-opencode", "bin");
+  const base = xdgCache || join53(homedir13(), ".cache");
+  return join53(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join57(getCacheDir3(), getBinaryName3());
-  return existsSync45(binaryPath) ? binaryPath : null;
+  const binaryPath = join53(getCacheDir3(), getBinaryName3());
+  return existsSync43(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -45815,8 +45470,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join57(cacheDir, binaryName);
-  if (existsSync45(binaryPath)) {
+  const binaryPath = join53(cacheDir, binaryName);
+  if (existsSync43(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os6 } = platformInfo;
@@ -45824,21 +45479,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 (!existsSync45(cacheDir)) {
-      mkdirSync19(cacheDir, { recursive: true });
+    if (!existsSync43(cacheDir)) {
+      mkdirSync17(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join57(cacheDir, assetName);
+    const archivePath = join53(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
-    if (existsSync45(archivePath)) {
-      unlinkSync15(archivePath);
+    if (existsSync43(archivePath)) {
+      unlinkSync13(archivePath);
     }
-    if (process.platform !== "win32" && existsSync45(binaryPath)) {
+    if (process.platform !== "win32" && existsSync43(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -45889,8 +45544,8 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname11(cliPkgPath);
-    const sgPath = join58(cliDir, binaryName);
-    if (existsSync46(sgPath) && isValidBinary(sgPath)) {
+    const sgPath = join54(cliDir, binaryName);
+    if (existsSync44(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -45901,8 +45556,8 @@ function findSgCliPathSync() {
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname11(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join58(pkgDir, astGrepName);
-      if (existsSync46(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join54(pkgDir, astGrepName);
+      if (existsSync44(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -45910,7 +45565,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path7 of homebrewPaths) {
-      if (existsSync46(path7) && isValidBinary(path7)) {
+      if (existsSync44(path7) && isValidBinary(path7)) {
         return path7;
       }
     }
@@ -45965,11 +45620,11 @@ var DEFAULT_MAX_MATCHES = 500;
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn7 } = globalThis.Bun;
-import { existsSync as existsSync47 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync47(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync45(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -45977,7 +45632,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync47(syncPath)) {
+    if (syncPath && existsSync45(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -46011,7 +45666,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync47(cliPath) && cliPath !== "sg") {
+  if (!existsSync45(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -46275,21 +45930,21 @@ var ast_grep_replace = tool({
 var {spawn: spawn9 } = globalThis.Bun;
 // src/tools/grep/constants.ts
-import { existsSync as existsSync49 } from "fs";
-import { join as join60, dirname as dirname12 } from "path";
+import { existsSync as existsSync47 } from "fs";
+import { join as join56, dirname as dirname12 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 // src/tools/grep/downloader.ts
 init_shared();
-import { existsSync as existsSync48, mkdirSync as mkdirSync20, chmodSync as chmodSync3, unlinkSync as unlinkSync16, readdirSync as readdirSync14 } from "fs";
-import { join as join59 } from "path";
+import { existsSync as existsSync46, mkdirSync as mkdirSync18, chmodSync as chmodSync3, unlinkSync as unlinkSync14, readdirSync as readdirSync14 } from "fs";
+import { join as join55 } from "path";
 var {spawn: spawn8 } = globalThis.Bun;
 function findFileRecursive(dir, filename) {
   try {
     const entries = readdirSync14(dir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
-        return join59(entry.parentPath ?? dir, entry.name);
+        return join55(entry.parentPath ?? dir, entry.name);
       }
     }
   } catch {
@@ -46310,11 +45965,11 @@ function getPlatformKey() {
 }
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join59(homeDir, ".cache", "oh-my-opencode", "bin");
+  return join55(homeDir, ".cache", "oh-my-opencode", "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join59(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join55(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 async function downloadFile(url2, destPath) {
   const response = await fetch(url2);
@@ -46348,7 +46003,7 @@ async function extractZip2(archivePath, destDir) {
   const binaryName = process.platform === "win32" ? "rg.exe" : "rg";
   const foundPath = findFileRecursive(destDir, binaryName);
   if (foundPath) {
-    const destPath = join59(destDir, binaryName);
+    const destPath = join55(destDir, binaryName);
     if (foundPath !== destPath) {
       const { renameSync: renameSync5 } = await import("fs");
       renameSync5(foundPath, destPath);
@@ -46363,13 +46018,13 @@ async function downloadAndInstallRipgrep() {
   }
   const installDir = getInstallDir();
   const rgPath = getRgPath();
-  if (existsSync48(rgPath)) {
+  if (existsSync46(rgPath)) {
     return rgPath;
   }
-  mkdirSync20(installDir, { recursive: true });
+  mkdirSync18(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 = join59(installDir, filename);
+  const archivePath = join55(installDir, filename);
   try {
     await downloadFile(url2, archivePath);
     if (config3.extension === "tar.gz") {
@@ -46380,21 +46035,21 @@ async function downloadAndInstallRipgrep() {
     if (process.platform !== "win32") {
       chmodSync3(rgPath, 493);
     }
-    if (!existsSync48(rgPath)) {
+    if (!existsSync46(rgPath)) {
       throw new Error("\u63D0\u53D6\u540E\u672A\u627E\u5230 ripgrep \u4E8C\u8FDB\u5236\u6587\u4EF6");
     }
     return rgPath;
   } finally {
-    if (existsSync48(archivePath)) {
+    if (existsSync46(archivePath)) {
       try {
-        unlinkSync16(archivePath);
+        unlinkSync14(archivePath);
       } catch {}
     }
   }
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync48(rgPath) ? rgPath : null;
+  return existsSync46(rgPath) ? rgPath : null;
 }
 // src/tools/grep/constants.ts
@@ -46418,7 +46073,7 @@ function findExecutable(name) {
             continue;
           }
         }
-        if (existsSync49(trimmed)) {
+        if (existsSync47(trimmed)) {
           return trimmed;
         }
       }
@@ -46433,14 +46088,14 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
-    join60(getDataDir(), "opencode", "bin", rgName),
-    join60(execDir, rgName),
-    join60(execDir, "bin", rgName),
-    join60(execDir, "..", "bin", rgName),
-    join60(execDir, "..", "libexec", rgName)
+    join56(getDataDir(), "opencode", "bin", rgName),
+    join56(execDir, rgName),
+    join56(execDir, "bin", rgName),
+    join56(execDir, "..", "bin", rgName),
+    join56(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync49(candidate)) {
+    if (existsSync47(candidate)) {
       return candidate;
     }
   }
@@ -46902,8 +46557,8 @@ var glob = tool({
 init_shared();
 init_file_utils();
 init_shared();
-import { existsSync as existsSync50, readdirSync as readdirSync15, readFileSync as readFileSync37 } from "fs";
-import { join as join61, basename as basename4, dirname as dirname13 } from "path";
+import { existsSync as existsSync48, readdirSync as readdirSync15, readFileSync as readFileSync35 } from "fs";
+import { join as join57, basename as basename4, dirname as dirname13 } from "path";
 // src/features/builtin-commands/templates/init-deep.ts
 var INIT_DEEP_TEMPLATE = `# /init-deep
@@ -48048,7 +47703,7 @@ function loadBuiltinCommands(disabledCommands) {
 }
 // src/tools/slashcommand/tools.ts
 function discoverCommandsFromDir2(commandsDir, scope) {
-  if (!existsSync50(commandsDir)) {
+  if (!existsSync48(commandsDir)) {
     return [];
   }
   const entries = readdirSync15(commandsDir, { withFileTypes: true });
@@ -48056,10 +47711,10 @@ function discoverCommandsFromDir2(commandsDir, scope) {
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join61(commandsDir, entry.name);
+    const commandPath = join57(commandsDir, entry.name);
     const commandName = basename4(entry.name, ".md");
     try {
-      const content = readFileSync37(commandPath, "utf-8");
+      const content = readFileSync35(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -48085,10 +47740,10 @@ function discoverCommandsFromDir2(commandsDir, scope) {
 }
 function discoverCommandsSync(disabledCommands) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const userCommandsDir = join61(getClaudeConfigDir(), "commands");
-  const projectCommandsDir = join61(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join61(configDir, "command");
-  const opencodeProjectDir = join61(process.cwd(), ".opencode", "command");
+  const userCommandsDir = join57(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join57(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join57(configDir, "command");
+  const opencodeProjectDir = join57(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir2(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir2(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir2(projectCommandsDir, "project");
@@ -48288,13 +47943,13 @@ var slashcommand = createSlashcommandTool();
 // src/tools/session-manager/constants.ts
 init_data_path();
 init_shared();
-import { join as join62 } from "path";
-var OPENCODE_STORAGE11 = getOpenCodeStorageDir();
-var MESSAGE_STORAGE4 = join62(OPENCODE_STORAGE11, "message");
-var PART_STORAGE4 = join62(OPENCODE_STORAGE11, "part");
-var SESSION_STORAGE = join62(OPENCODE_STORAGE11, "session");
-var TODO_DIR2 = join62(getClaudeConfigDir(), "todos");
-var TRANSCRIPT_DIR2 = join62(getClaudeConfigDir(), "transcripts");
+import { join as join58 } from "path";
+var OPENCODE_STORAGE9 = getOpenCodeStorageDir();
+var MESSAGE_STORAGE4 = join58(OPENCODE_STORAGE9, "message");
+var PART_STORAGE4 = join58(OPENCODE_STORAGE9, "part");
+var SESSION_STORAGE = join58(OPENCODE_STORAGE9, "session");
+var TODO_DIR2 = join58(getClaudeConfigDir(), "todos");
+var TRANSCRIPT_DIR2 = join58(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
@@ -48367,11 +48022,11 @@ Has Todos: Yes (12 items, 8 completed)
 Has Transcript: Yes (234 entries)`;
 // src/tools/session-manager/storage.ts
-import { existsSync as existsSync51, readdirSync as readdirSync16 } from "fs";
+import { existsSync as existsSync49, readdirSync as readdirSync16 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { join as join63 } from "path";
+import { join as join59 } from "path";
 async function getMainSessions(options) {
-  if (!existsSync51(SESSION_STORAGE))
+  if (!existsSync49(SESSION_STORAGE))
     return [];
   const sessions = [];
   try {
@@ -48379,13 +48034,13 @@ async function getMainSessions(options) {
     for (const projectDir of projectDirs) {
       if (!projectDir.isDirectory())
         continue;
-      const projectPath = join63(SESSION_STORAGE, projectDir.name);
+      const projectPath = join59(SESSION_STORAGE, projectDir.name);
       const sessionFiles = await readdir(projectPath);
       for (const file2 of sessionFiles) {
         if (!file2.endsWith(".json"))
           continue;
         try {
-          const content = await readFile(join63(projectPath, file2), "utf-8");
+          const content = await readFile(join59(projectPath, file2), "utf-8");
           const meta = JSON.parse(content);
           if (meta.parentID)
             continue;
@@ -48403,7 +48058,7 @@ async function getMainSessions(options) {
   return sessions.sort((a, b) => b.time.updated - a.time.updated);
 }
 async function getAllSessions() {
-  if (!existsSync51(MESSAGE_STORAGE4))
+  if (!existsSync49(MESSAGE_STORAGE4))
     return [];
   const sessions = [];
   async function scanDirectory(dir) {
@@ -48411,7 +48066,7 @@ async function getAllSessions() {
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const sessionPath = join63(dir, entry.name);
+          const sessionPath = join59(dir, entry.name);
           const files = await readdir(sessionPath);
           if (files.some((f) => f.endsWith(".json"))) {
             sessions.push(entry.name);
@@ -48428,16 +48083,16 @@ async function getAllSessions() {
   return [...new Set(sessions)];
 }
 function getMessageDir6(sessionID) {
-  if (!existsSync51(MESSAGE_STORAGE4))
+  if (!existsSync49(MESSAGE_STORAGE4))
     return "";
-  const directPath = join63(MESSAGE_STORAGE4, sessionID);
-  if (existsSync51(directPath)) {
+  const directPath = join59(MESSAGE_STORAGE4, sessionID);
+  if (existsSync49(directPath)) {
     return directPath;
   }
   try {
     for (const dir of readdirSync16(MESSAGE_STORAGE4)) {
-      const sessionPath = join63(MESSAGE_STORAGE4, dir, sessionID);
-      if (existsSync51(sessionPath)) {
+      const sessionPath = join59(MESSAGE_STORAGE4, dir, sessionID);
+      if (existsSync49(sessionPath)) {
         return sessionPath;
       }
     }
@@ -48451,7 +48106,7 @@ function sessionExists(sessionID) {
 }
 async function readSessionMessages(sessionID) {
   const messageDir = getMessageDir6(sessionID);
-  if (!messageDir || !existsSync51(messageDir))
+  if (!messageDir || !existsSync49(messageDir))
     return [];
   const messages = [];
   try {
@@ -48460,7 +48115,7 @@ async function readSessionMessages(sessionID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join63(messageDir, file2), "utf-8");
+        const content = await readFile(join59(messageDir, file2), "utf-8");
         const meta = JSON.parse(content);
         const parts = await readParts2(meta.id);
         messages.push({
@@ -48486,8 +48141,8 @@ async function readSessionMessages(sessionID) {
   });
 }
 async function readParts2(messageID) {
-  const partDir = join63(PART_STORAGE4, messageID);
-  if (!existsSync51(partDir))
+  const partDir = join59(PART_STORAGE4, messageID);
+  if (!existsSync49(partDir))
     return [];
   const parts = [];
   try {
@@ -48496,7 +48151,7 @@ async function readParts2(messageID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join63(partDir, file2), "utf-8");
+        const content = await readFile(join59(partDir, file2), "utf-8");
         parts.push(JSON.parse(content));
       } catch {
         continue;
@@ -48508,14 +48163,14 @@ async function readParts2(messageID) {
   return parts.sort((a, b) => a.id.localeCompare(b.id));
 }
 async function readSessionTodos(sessionID) {
-  if (!existsSync51(TODO_DIR2))
+  if (!existsSync49(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(join63(TODO_DIR2, file2), "utf-8");
+        const content = await readFile(join59(TODO_DIR2, file2), "utf-8");
         const data = JSON.parse(content);
         if (Array.isArray(data)) {
           return data.map((item) => ({
@@ -48535,10 +48190,10 @@ async function readSessionTodos(sessionID) {
   return [];
 }
 async function readSessionTranscript(sessionID) {
-  if (!existsSync51(TRANSCRIPT_DIR2))
+  if (!existsSync49(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join63(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync51(transcriptFile))
+  const transcriptFile = join59(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  if (!existsSync49(transcriptFile))
     return 0;
   try {
     const content = await readFile(transcriptFile, "utf-8");
@@ -49746,21 +49401,21 @@ var CALL_OMO_AGENT_DESCRIPTION = `\u542F\u52A8\u6DF1\u5EA6\u63A2\u7D22/\u77E5\u8
 \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 existsSync52, readdirSync as readdirSync17 } from "fs";
-import { join as join64 } from "path";
+import { existsSync as existsSync50, readdirSync as readdirSync17 } from "fs";
+import { join as join60 } from "path";
 init_shared();
 init_agent_display_names();
 init_session_cursor();
 init_claude_code_session_state();
 function getMessageDir7(sessionID) {
-  if (!existsSync52(MESSAGE_STORAGE))
+  if (!existsSync50(MESSAGE_STORAGE))
     return null;
-  const directPath = join64(MESSAGE_STORAGE, sessionID);
-  if (existsSync52(directPath))
+  const directPath = join60(MESSAGE_STORAGE, sessionID);
+  if (existsSync50(directPath))
     return directPath;
   for (const dir of readdirSync17(MESSAGE_STORAGE)) {
-    const sessionPath = join64(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync52(sessionPath))
+    const sessionPath = join60(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync50(sessionPath))
       return sessionPath;
   }
   return null;
@@ -50186,8 +49841,8 @@ function createLookAt(ctx) {
 }
 // src/tools/delegate-task/tools.ts
 init_constants();
-import { existsSync as existsSync53, readdirSync as readdirSync18 } from "fs";
-import { join as join65 } from "path";
+import { existsSync as existsSync51, readdirSync as readdirSync18 } from "fs";
+import { join as join61 } from "path";
 // src/features/task-toast-manager/manager.ts
 class TaskToastManager {
@@ -50395,14 +50050,14 @@ function parseFallbackModelEntries(entries) {
   });
 }
 function getMessageDir8(sessionID) {
-  if (!existsSync53(MESSAGE_STORAGE))
+  if (!existsSync51(MESSAGE_STORAGE))
     return null;
-  const directPath = join65(MESSAGE_STORAGE, sessionID);
-  if (existsSync53(directPath))
+  const directPath = join61(MESSAGE_STORAGE, sessionID);
+  if (existsSync51(directPath))
     return directPath;
   for (const dir of readdirSync18(MESSAGE_STORAGE)) {
-    const sessionPath = join65(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync53(sessionPath))
+    const sessionPath = join61(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync51(sessionPath))
       return sessionPath;
   }
   return null;
@@ -51512,8 +51167,8 @@ class PerformanceAggregator {
 // src/features/background-agent/manager.ts
 init_claude_code_session_state();
 init_agent_identity_resolver();
-import { existsSync as existsSync54, readdirSync as readdirSync19 } from "fs";
-import { join as join66 } from "path";
+import { existsSync as existsSync52, readdirSync as readdirSync19 } from "fs";
+import { join as join62 } from "path";
 var TASK_TTL_MS = 30 * 60 * 1000;
 var MIN_STABILITY_TIME_MS = 10 * 1000;
 var DEFAULT_STALE_TIMEOUT_MS = 120000;
@@ -52686,14 +52341,14 @@ function registerProcessSignal(signal, handler, exitAfter) {
   return listener;
 }
 function getMessageDir9(sessionID) {
-  if (!existsSync54(MESSAGE_STORAGE))
+  if (!existsSync52(MESSAGE_STORAGE))
     return null;
-  const directPath = join66(MESSAGE_STORAGE, sessionID);
-  if (existsSync54(directPath))
+  const directPath = join62(MESSAGE_STORAGE, sessionID);
+  if (existsSync52(directPath))
     return directPath;
   for (const dir of readdirSync19(MESSAGE_STORAGE)) {
-    const sessionPath = join66(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync54(sessionPath))
+    const sessionPath = join62(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync52(sessionPath))
       return sessionPath;
   }
   return null;
@@ -71424,8 +71079,7 @@ var HookNameSchema = exports_external2.enum([
   "prometheus-md-only",
   "perf-profiler",
   "start-work",
-  "language-reminder",
-  "thinking-language-validator",
+  "system-language-injector",
   "atlas",
   "tool-definition-optimizer",
   "permission-ask-bridge",
@@ -71656,7 +71310,7 @@ var LanguageEnforcementConfigSchema = exports_external2.object({
   enabled: exports_external2.boolean().default(true),
   reminder_interval: exports_external2.number().int().positive().default(5),
   violation_threshold: exports_external2.number().min(0).max(1).default(0.6),
-  excluded_agents: exports_external2.array(exports_external2.string()).default(["\u77E5\u8BC6\u5178\u85CF", "\u5A92\u4F53\u89E3\u6790"]),
+  excluded_agents: exports_external2.array(exports_external2.string()).default([]),
   user_message_english_threshold: exports_external2.number().min(0).max(1).default(0.6),
   user_message_lookback: exports_external2.number().int().positive().default(3)
 }).optional();
@@ -71918,7 +71572,7 @@ init_file_utils();
 init_shared();
 init_logger();
 import { promises as fs11 } from "fs";
-import { join as join68, basename as basename6 } from "path";
+import { join as join64, basename as basename6 } from "path";
 async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "") {
   try {
     await fs11.access(commandsDir);
@@ -71948,7 +71602,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     if (entry.isDirectory()) {
       if (entry.name.startsWith("."))
         continue;
-      const subDirPath = join68(commandsDir, entry.name);
+      const subDirPath = join64(commandsDir, entry.name);
       const subPrefix = prefix ? `${prefix}:${entry.name}` : entry.name;
       const subCommands = await loadCommandsFromDir(subDirPath, scope, visited, subPrefix);
       commands2.push(...subCommands);
@@ -71956,7 +71610,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     }
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join68(commandsDir, entry.name);
+    const commandPath = join64(commandsDir, entry.name);
     const baseCommandName = basename6(entry.name, ".md");
     const commandName = prefix ? `${prefix}:${baseCommandName}` : baseCommandName;
     try {
@@ -72003,23 +71657,23 @@ function commandsToRecord(commands2) {
   return result;
 }
 async function loadUserCommands() {
-  const userCommandsDir = join68(getClaudeConfigDir(), "commands");
+  const userCommandsDir = join64(getClaudeConfigDir(), "commands");
   const commands2 = await loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands2);
 }
 async function loadProjectCommands() {
-  const projectCommandsDir = join68(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join64(process.cwd(), ".claude", "commands");
   const commands2 = await loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands2);
 }
 async function loadOpencodeGlobalCommands() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeCommandsDir = join68(configDir, "command");
+  const opencodeCommandsDir = join64(configDir, "command");
   const commands2 = await loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands2);
 }
 async function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join68(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join64(process.cwd(), ".opencode", "command");
   const commands2 = await loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands2);
 }
@@ -72027,8 +71681,8 @@ async function loadOpencodeProjectCommands() {
 init_frontmatter();
 init_file_utils();
 init_shared();
-import { existsSync as existsSync56, readdirSync as readdirSync20, readFileSync as readFileSync39 } from "fs";
-import { join as join69, basename as basename7 } from "path";
+import { existsSync as existsSync54, readdirSync as readdirSync20, readFileSync as readFileSync37 } from "fs";
+import { join as join65, basename as basename7 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -72042,7 +71696,7 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope, leConfig) {
-  if (!existsSync56(agentsDir)) {
+  if (!existsSync54(agentsDir)) {
     return [];
   }
   const entries = readdirSync20(agentsDir, { withFileTypes: true });
@@ -72050,10 +71704,10 @@ function loadAgentsFromDir(agentsDir, scope, leConfig) {
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join69(agentsDir, entry.name);
+    const agentPath = join65(agentsDir, entry.name);
     const agentName = basename7(entry.name, ".md");
     try {
-      const content = readFileSync39(agentPath, "utf-8");
+      const content = readFileSync37(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -72082,7 +71736,7 @@ function loadAgentsFromDir(agentsDir, scope, leConfig) {
   return agents;
 }
 function loadUserAgents(leConfig) {
-  const userAgentsDir = join69(getClaudeConfigDir(), "agents");
+  const userAgentsDir = join65(getClaudeConfigDir(), "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user", leConfig);
   const result = {};
   for (const agent of agents) {
@@ -72091,7 +71745,7 @@ function loadUserAgents(leConfig) {
   return result;
 }
 function loadProjectAgents(leConfig) {
-  const projectAgentsDir = join69(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join65(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project", leConfig);
   const result = {};
   for (const agent of agents) {
@@ -72103,18 +71757,18 @@ function loadProjectAgents(leConfig) {
 init_frontmatter();
 init_file_utils();
 init_logger();
-import { existsSync as existsSync57, readdirSync as readdirSync21, readFileSync as readFileSync40 } from "fs";
+import { existsSync as existsSync55, readdirSync as readdirSync21, readFileSync as readFileSync38 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join70, basename as basename8 } from "path";
+import { join as join66, 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 join70(homedir14(), ".claude", "plugins");
+  return join66(homedir14(), ".claude", "plugins");
 }
 function getInstalledPluginsPath() {
-  return join70(getPluginsBaseDir(), "installed_plugins.json");
+  return join66(getPluginsBaseDir(), "installed_plugins.json");
 }
 function resolvePluginPath(path8, pluginRoot) {
   return path8.replace(CLAUDE_PLUGIN_ROOT_VAR, pluginRoot);
@@ -72139,11 +71793,11 @@ function resolvePluginPaths(obj, pluginRoot) {
 }
 function loadInstalledPlugins() {
   const dbPath = getInstalledPluginsPath();
-  if (!existsSync57(dbPath)) {
+  if (!existsSync55(dbPath)) {
     return null;
   }
   try {
-    const content = readFileSync40(dbPath, "utf-8");
+    const content = readFileSync38(dbPath, "utf-8");
     return JSON.parse(content);
   } catch (error95) {
     log("Failed to load installed plugins database", error95);
@@ -72154,15 +71808,15 @@ function getClaudeSettingsPath() {
   if (process.env.CLAUDE_SETTINGS_PATH) {
     return process.env.CLAUDE_SETTINGS_PATH;
   }
-  return join70(homedir14(), ".claude", "settings.json");
+  return join66(homedir14(), ".claude", "settings.json");
 }
 function loadClaudeSettings() {
   const settingsPath = getClaudeSettingsPath();
-  if (!existsSync57(settingsPath)) {
+  if (!existsSync55(settingsPath)) {
     return null;
   }
   try {
-    const content = readFileSync40(settingsPath, "utf-8");
+    const content = readFileSync38(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch (error95) {
     log("Failed to load Claude settings", error95);
@@ -72170,12 +71824,12 @@ function loadClaudeSettings() {
   }
 }
 function loadPluginManifest(installPath) {
-  const manifestPath = join70(installPath, ".claude-plugin", "plugin.json");
-  if (!existsSync57(manifestPath)) {
+  const manifestPath = join66(installPath, ".claude-plugin", "plugin.json");
+  if (!existsSync55(manifestPath)) {
     return null;
   }
   try {
-    const content = readFileSync40(manifestPath, "utf-8");
+    const content = readFileSync38(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error95) {
     log(`Failed to load plugin manifest from ${manifestPath}`, error95);
@@ -72222,7 +71876,7 @@ function discoverInstalledPlugins(options) {
       continue;
     }
     const { installPath, scope, version: version3 } = installation;
-    if (!existsSync57(installPath)) {
+    if (!existsSync55(installPath)) {
       errors5.push({
         pluginKey,
         installPath,
@@ -72240,21 +71894,21 @@ function discoverInstalledPlugins(options) {
       pluginKey,
       manifest: manifest ?? undefined
     };
-    if (existsSync57(join70(installPath, "commands"))) {
-      loadedPlugin.commandsDir = join70(installPath, "commands");
+    if (existsSync55(join66(installPath, "commands"))) {
+      loadedPlugin.commandsDir = join66(installPath, "commands");
     }
-    if (existsSync57(join70(installPath, "agents"))) {
-      loadedPlugin.agentsDir = join70(installPath, "agents");
+    if (existsSync55(join66(installPath, "agents"))) {
+      loadedPlugin.agentsDir = join66(installPath, "agents");
     }
-    if (existsSync57(join70(installPath, "skills"))) {
-      loadedPlugin.skillsDir = join70(installPath, "skills");
+    if (existsSync55(join66(installPath, "skills"))) {
+      loadedPlugin.skillsDir = join66(installPath, "skills");
     }
-    const hooksPath = join70(installPath, "hooks", "hooks.json");
-    if (existsSync57(hooksPath)) {
+    const hooksPath = join66(installPath, "hooks", "hooks.json");
+    if (existsSync55(hooksPath)) {
       loadedPlugin.hooksPath = hooksPath;
     }
-    const mcpPath = join70(installPath, ".mcp.json");
-    if (existsSync57(mcpPath)) {
+    const mcpPath = join66(installPath, ".mcp.json");
+    if (existsSync55(mcpPath)) {
       loadedPlugin.mcpPath = mcpPath;
     }
     plugins.push(loadedPlugin);
@@ -72265,17 +71919,17 @@ function discoverInstalledPlugins(options) {
 function loadPluginCommands(plugins) {
   const commands2 = {};
   for (const plugin of plugins) {
-    if (!plugin.commandsDir || !existsSync57(plugin.commandsDir))
+    if (!plugin.commandsDir || !existsSync55(plugin.commandsDir))
       continue;
     const entries = readdirSync21(plugin.commandsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const commandPath = join70(plugin.commandsDir, entry.name);
+      const commandPath = join66(plugin.commandsDir, entry.name);
       const commandName = basename8(entry.name, ".md");
       const namespacedName = `${plugin.name}:${commandName}`;
       try {
-        const content = readFileSync40(commandPath, "utf-8");
+        const content = readFileSync38(commandPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -72307,21 +71961,21 @@ $ARGUMENTS
 function loadPluginSkillsAsCommands(plugins) {
   const skills = {};
   for (const plugin of plugins) {
-    if (!plugin.skillsDir || !existsSync57(plugin.skillsDir))
+    if (!plugin.skillsDir || !existsSync55(plugin.skillsDir))
       continue;
     const entries = readdirSync21(plugin.skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith("."))
         continue;
-      const skillPath = join70(plugin.skillsDir, entry.name);
+      const skillPath = join66(plugin.skillsDir, entry.name);
       if (!entry.isDirectory() && !entry.isSymbolicLink())
         continue;
       const resolvedPath = resolveSymlink(skillPath);
-      const skillMdPath = join70(resolvedPath, "SKILL.md");
-      if (!existsSync57(skillMdPath))
+      const skillMdPath = join66(resolvedPath, "SKILL.md");
+      if (!existsSync55(skillMdPath))
         continue;
       try {
-        const content = readFileSync40(skillMdPath, "utf-8");
+        const content = readFileSync38(skillMdPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const skillName = data.name || entry.name;
         const namespacedName = `${plugin.name}:${skillName}`;
@@ -72368,17 +72022,17 @@ function parseToolsConfig2(toolsStr) {
 function loadPluginAgents(plugins) {
   const agents = {};
   for (const plugin of plugins) {
-    if (!plugin.agentsDir || !existsSync57(plugin.agentsDir))
+    if (!plugin.agentsDir || !existsSync55(plugin.agentsDir))
       continue;
     const entries = readdirSync21(plugin.agentsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const agentPath = join70(plugin.agentsDir, entry.name);
+      const agentPath = join66(plugin.agentsDir, entry.name);
       const agentName = basename8(entry.name, ".md");
       const namespacedName = `${plugin.name}:${agentName}`;
       try {
-        const content = readFileSync40(agentPath, "utf-8");
+        const content = readFileSync38(agentPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const name = data.name || agentName;
         const originalDescription = data.description || "";
@@ -72404,7 +72058,7 @@ function loadPluginAgents(plugins) {
 async function loadPluginMcpServers(plugins) {
   const servers = {};
   for (const plugin of plugins) {
-    if (!plugin.mcpPath || !existsSync57(plugin.mcpPath))
+    if (!plugin.mcpPath || !existsSync55(plugin.mcpPath))
       continue;
     try {
       const content = await Bun.file(plugin.mcpPath).text();
@@ -72436,10 +72090,10 @@ async function loadPluginMcpServers(plugins) {
 function loadPluginHooksConfigs(plugins) {
   const configs = [];
   for (const plugin of plugins) {
-    if (!plugin.hooksPath || !existsSync57(plugin.hooksPath))
+    if (!plugin.hooksPath || !existsSync55(plugin.hooksPath))
       continue;
     try {
-      const content = readFileSync40(plugin.hooksPath, "utf-8");
+      const content = readFileSync38(plugin.hooksPath, "utf-8");
       let config4 = JSON.parse(content);
       config4 = resolvePluginPaths(config4, plugin.installPath);
       configs.push(config4);
@@ -73857,11 +73511,7 @@ function createConfigHandler(deps) {
       if (isLanguageEnforcementEnabled(pluginConfig)) {
         const prometheusAgent = agentConfig["\u6218\u7565\u53C2\u8C0B"];
         if (prometheusAgent?.prompt && !prometheusAgent.prompt.includes("<Language_Instruction>")) {
-          if (isDeepseekModel(prometheusAgent.model ?? "")) {
-            prometheusAgent.prompt += ZH_LANGUAGE_INSTRUCTION_DEEPSEEK;
-          } else {
-            prometheusAgent.prompt += ZH_LANGUAGE_INSTRUCTION;
-          }
+          prometheusAgent.prompt += ZH_LANGUAGE_INSTRUCTION;
         }
       }
       if (isLanguageEnforcementEnabled(pluginConfig)) {
@@ -74139,8 +73789,6 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const keywordDetector = isHookEnabled("keyword-detector") ? createKeywordDetectorHook(ctx, contextCollector) : null;
   const contextInjectorMessagesTransform = createContextInjectorMessagesTransformHook(contextCollector);
   const agentUsageReminder = isHookEnabled("agent-usage-reminder") ? createAgentUsageReminderHook(ctx) : null;
-  const languageReminder = isHookEnabled("language-reminder") && isLanguageEnforcementEnabled(pluginConfig) ? createLanguageReminderHook(ctx) : null;
-  const thinkingLanguageValidator = isHookEnabled("thinking-language-validator") && isLanguageEnforcementEnabled(pluginConfig) ? createThinkingLanguageValidatorHook(ctx) : null;
   const nonInteractiveEnv = isHookEnabled("non-interactive-env") ? createNonInteractiveEnvHook(ctx) : null;
   const interactiveBashSession = isHookEnabled("interactive-bash-session") ? createInteractiveBashSessionHook(ctx) : null;
   const thinkingBlockValidator = isHookEnabled("thinking-block-validator") ? createThinkingBlockValidatorHook() : null;
@@ -74429,10 +74077,6 @@ var OhMyOpenCodePlugin = async (ctx) => {
       hookCount++;
       await wrapWithTiming(perfTracer, "event", "agentUsageReminder", () => agentUsageReminder?.event(input), evtSessionID);
       hookCount++;
-      await wrapWithTiming(perfTracer, "event", "languageReminder", () => languageReminder?.event(input), evtSessionID);
-      hookCount++;
-      await wrapWithTiming(perfTracer, "event", "thinkingLanguageValidator", () => thinkingLanguageValidator?.event(input), evtSessionID);
-      hookCount++;
       await wrapWithTiming(perfTracer, "event", "interactiveBashSession", () => interactiveBashSession?.event(input), evtSessionID);
       hookCount++;
       await wrapWithTiming(perfTracer, "event", "ralphLoop", () => ralphLoop?.event(input), evtSessionID);
@@ -74598,10 +74242,6 @@ var OhMyOpenCodePlugin = async (ctx) => {
       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", "languageReminder", () => languageReminder?.["tool.execute.after"](input, output), input.sessionID, input.tool);
-      hookCount++;
-      await wrapWithTiming(perfTracer, "tool.execute.after", "thinkingLanguageValidator", () => thinkingLanguageValidator?.["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);