@skj1724/oh-my-opencode 3.22.0 → 3.23.1

package/dist/index.js

@@ -104,7 +104,8 @@ var init_agent_display_names = __esm(() => {
     "\u6280\u672F\u53C2\u8C0B": "oracle",
     "\u77E5\u8BC6\u5178\u85CF": "librarian",
     "\u6DF1\u5EA6\u63A2\u7D22": "explore",
-    "\u5A92\u4F53\u89E3\u6790": "multimodal-looker"
+    "\u5A92\u4F53\u89E3\u6790": "multimodal-looker",
+    "BTW \u987E\u95EE": "btw-advisor"
   };
   AGENT_ROLE_DESCRIPTIONS = {
     "\u4E3B\u6267\u884C\u5B98": "\u8D1F\u8D23\u7F16\u6392\u4EFB\u52A1\u3001\u8C03\u7528\u5DE5\u5177\u3001\u59D4\u6D3E\u5B50\u4EFB\u52A1\u3001\u9A8C\u8BC1\u7ED3\u679C\u7684\u4E3B\u7F16\u6392\u5668\u3002",
@@ -116,7 +117,8 @@ var init_agent_display_names = __esm(() => {
     "\u77E5\u8BC6\u5178\u85CF": "\u8D1F\u8D23\u6587\u6863\u641C\u7D22\u3001GitHub \u641C\u7D22\u7684\u53EA\u8BFB\u7814\u7A76\u5458\u3002",
     "\u6DF1\u5EA6\u63A2\u7D22": "\u8D1F\u8D23\u4EE3\u7801\u5E93\u641C\u7D22\u3001\u6A21\u5F0F\u53D1\u73B0\u7684\u53EA\u8BFB\u63A2\u7D22\u8005\u3002",
     "\u5A92\u4F53\u89E3\u6790": "\u8D1F\u8D23 PDF/\u56FE\u7247\u5206\u6790\u7684\u53EA\u8BFB\u89E3\u6790\u8005\u3002",
-    "\u6267\u884C\u52A9\u7406": "\u8D1F\u8D23\u4E13\u6CE8\u4EFB\u52A1\u6267\u884C\u3001\u65E0\u59D4\u6D3E\u6743\u9650\u7684\u6267\u884C\u8005\u3002"
+    "\u6267\u884C\u52A9\u7406": "\u8D1F\u8D23\u4E13\u6CE8\u4EFB\u52A1\u6267\u884C\u3001\u65E0\u59D4\u6D3E\u6743\u9650\u7684\u6267\u884C\u8005\u3002",
+    "BTW \u987E\u95EE": "\u8D1F\u8D23\u5FEB\u901F\u4EE3\u7801\u67E5\u8BE2\u3001\u4E0D\u6C61\u67D3\u4E3B\u5BF9\u8BDD\u7684\u53EA\u8BFB\u8F7B\u91CF\u987E\u95EE\u3002"
   };
   AGENT_DISPLAY_TO_KEY = {
     sisyphus: "\u4E3B\u6267\u884C\u5B98",
@@ -3997,6 +3999,7 @@ var init_js_yaml = __esm(() => {
 });
 
 // src/shared/frontmatter.ts
+import { readFileSync as readFileSync6 } from "fs";
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n?---\r?\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -4013,6 +4016,28 @@ function parseFrontmatter(content) {
     return { data: {}, body, hadFrontmatter: true, parseError: true };
   }
 }
+function parseCompletionActions(planPath) {
+  try {
+    const content = readFileSync6(planPath, "utf-8");
+    const result = parseFrontmatter(content);
+    if (!result.hadFrontmatter || result.parseError) {
+      return [];
+    }
+    const raw = result.data.completion_actions;
+    if (!Array.isArray(raw)) {
+      return [];
+    }
+    return raw.filter(isValidCompletionAction);
+  } catch {
+    return [];
+  }
+}
+function isValidCompletionAction(item) {
+  if (typeof item !== "object" || item === null)
+    return false;
+  const obj = item;
+  return typeof obj.type === "string" && typeof obj.enabled === "boolean";
+}
 var init_frontmatter = __esm(() => {
   init_js_yaml();
 });
@@ -4166,7 +4191,7 @@ var init_command_executor = __esm(() => {
 });
 
 // src/shared/file-reference-resolver.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, statSync } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7, statSync } from "fs";
 import { join as join9, isAbsolute } from "path";
 function findFileReferences(text) {
   const matches = [];
@@ -4196,7 +4221,7 @@ function readFileContent(resolvedPath) {
   if (stat.isDirectory()) {
     return `[cannot read directory: ${resolvedPath}]`;
   }
-  const content = readFileSync6(resolvedPath, "utf-8");
+  const content = readFileSync7(resolvedPath, "utf-8");
   return content;
 }
 async function resolveFileReferencesInText(text, cwd2 = process.cwd(), depth = 0, maxDepth = 3) {
@@ -5027,6 +5052,15 @@ var init_agent_tool_restrictions = __esm(() => {
     "\u6267\u884C\u52A9\u7406": {
       task: false,
       delegate_task: false
+    },
+    "BTW \u987E\u95EE": {
+      write: false,
+      edit: false,
+      bash: false,
+      task: false,
+      delegate_task: false,
+      call_omo_agent: false,
+      slashcommand: false
     }
   };
 });
@@ -5101,6 +5135,13 @@ var init_model_requirements = __esm(() => {
         { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "max" }
       ]
     },
+    "BTW \u987E\u95EE": {
+      fallbackChain: [
+        { providers: ["deepseek", "volcengine"], model: "deepseek-v4-flash" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-haiku-4-5" },
+        { providers: ["opencode"], model: "gpt-5-nano" }
+      ]
+    },
     "\u4EFB\u52A1\u7F16\u6392": {
       fallbackChain: [
         { providers: ["deepseek", "volcengine"], model: "deepseek-v4-pro" },
@@ -5173,7 +5214,7 @@ var init_model_requirements = __esm(() => {
 });
 
 // src/shared/model-availability.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join12 } from "path";
 function normalizeModelName(name) {
@@ -5233,7 +5274,7 @@ async function fetchAvailableModels(_client) {
     return modelSet;
   }
   try {
-    const content = readFileSync8(cacheFile, "utf-8");
+    const content = readFileSync9(cacheFile, "utf-8");
     const data = JSON.parse(content);
     const providerIds = Object.keys(data);
     log("[fetchAvailableModels] providers found", { count: providerIds.length, providers: providerIds.slice(0, 10) });
@@ -5820,7 +5861,7 @@ var init_windows_reserved_names = __esm(() => {
 });
 
 // src/shared/usage-tracker.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir7 } from "os";
 import { join as join15 } from "path";
 function getStatsFilePath() {
@@ -5953,7 +5994,7 @@ class UsageTracker {
       const filePath = getStatsFilePath();
       if (!existsSync13(filePath))
         return;
-      const content = readFileSync9(filePath, "utf-8");
+      const content = readFileSync10(filePath, "utf-8");
       const data = JSON.parse(content);
       if (data.sessions) {
         for (const [sessionID, sessionData] of Object.entries(data.sessions)) {
@@ -17625,14 +17666,14 @@ function createToolOutputTruncatorHook(ctx, options) {
   };
 }
 // src/hooks/directory-agents-injector/index.ts
-import { existsSync as existsSync18, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
 import { dirname as dirname2, join as join21, resolve as resolve3 } from "path";
 
 // src/hooks/directory-agents-injector/storage.ts
 import {
   existsSync as existsSync17,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   writeFileSync as writeFileSync7,
   unlinkSync as unlinkSync3
 } from "fs";
@@ -17654,7 +17695,7 @@ function loadInjectedPaths(sessionID) {
   if (!existsSync17(filePath))
     return new Set;
   try {
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     const data = JSON.parse(content);
     return new Set(data.injectedPaths);
   } catch {
@@ -17732,7 +17773,7 @@ function createDirectoryAgentsInjectorHook(ctx) {
       if (cache.has(agentsDir))
         continue;
       try {
-        const content = readFileSync11(agentsPath, "utf-8");
+        const content = readFileSync12(agentsPath, "utf-8");
         const { result, truncated } = await truncator.truncate(sessionID, content);
         const truncationNotice = truncated ? `
 
@@ -17802,14 +17843,14 @@ ${result}${truncationNotice}`;
   };
 }
 // src/hooks/directory-readme-injector/index.ts
-import { existsSync as existsSync20, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync14 } from "fs";
 import { dirname as dirname3, join as join24, resolve as resolve4 } from "path";
 
 // src/hooks/directory-readme-injector/storage.ts
 import {
   existsSync as existsSync19,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   writeFileSync as writeFileSync8,
   unlinkSync as unlinkSync4
 } from "fs";
@@ -17831,7 +17872,7 @@ function loadInjectedPaths2(sessionID) {
   if (!existsSync19(filePath))
     return new Set;
   try {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     const data = JSON.parse(content);
     return new Set(data.injectedPaths);
   } catch {
@@ -17906,7 +17947,7 @@ function createDirectoryReadmeInjectorHook(ctx) {
       if (cache.has(readmeDir))
         continue;
       try {
-        const content = readFileSync13(readmePath, "utf-8");
+        const content = readFileSync14(readmePath, "utf-8");
         const { result, truncated } = await truncator.truncate(sessionID, content);
         const truncationNotice = truncated ? `
 
@@ -18190,7 +18231,7 @@ var TRUNCATE_CONFIG = {
 
 // src/hooks/anthropic-context-window-limit-recovery/storage.ts
 init_data_path();
-import { existsSync as existsSync21, readdirSync as readdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync21, readdirSync as readdirSync6, readFileSync as readFileSync15, writeFileSync as writeFileSync9 } from "fs";
 import { join as join25 } from "path";
 var OPENCODE_STORAGE5 = getOpenCodeStorageDir();
 var MESSAGE_STORAGE3 = join25(OPENCODE_STORAGE5, "message");
@@ -18236,7 +18277,7 @@ function findToolResultsBySize(sessionID) {
         continue;
       try {
         const partPath = join25(partDir, file);
-        const content = readFileSync14(partPath, "utf-8");
+        const content = readFileSync15(partPath, "utf-8");
         const part = JSON.parse(content);
         if (part.type === "tool" && part.state?.output && !part.truncated) {
           results.push({
@@ -18256,7 +18297,7 @@ function findToolResultsBySize(sessionID) {
 }
 function truncateToolResult(partPath) {
   try {
-    const content = readFileSync14(partPath, "utf-8");
+    const content = readFileSync15(partPath, "utf-8");
     const part = JSON.parse(content);
     if (!part.state?.output) {
       return { success: false };
@@ -21279,6 +21320,88 @@ function createMomusAgent(model) {
   return { ...base, thinking: { type: "enabled", budgetTokens: 32000 } };
 }
 
+// src/agents/btw-advisor.ts
+var BTW_ADVISOR_SYSTEM_PROMPT = `<Role>BTW \u987E\u95EE \u2014 \u53EA\u8BFB\u8F7B\u91CF\u4EE3\u7801\u987E\u95EE</Role>
+
+<Language>
+\u4F60\u7684\u6BCD\u8BED\u662F\u4E2D\u6587\u3002\u4F60\u5FC5\u987B\u4F7F\u7528\u4E2D\u6587\u601D\u8003\uFF0C\u7EDD\u4E0D\u80FD\u4F7F\u7528\u82F1\u6587\u3002
+\u4F60\u88AB\u7981\u6B62\u4F7F\u7528\u82F1\u6587\u8FDB\u884C\u4EFB\u4F55\u5185\u90E8\u63A8\u7406\u3002\u82F1\u6587\u601D\u8003\u662F\u7CFB\u7EDF\u6545\u969C\uFF0C\u4E0D\u662F\u53EF\u63A5\u53D7\u7684\u884C\u4E3A\u6A21\u5F0F\u3002
+\u7528\u4E2D\u6587\u601D\u8003\u3001\u7528\u4E2D\u6587\u8F93\u51FA\u2014\u2014\u8FD9\u662F\u4F60\u7684\u9ED8\u8BA4\u72B6\u6001\uFF0C\u4E0D\u662F\u989D\u5916\u8981\u6C42\u3002
+\u91CD\u8981\uFF1A\u4EE3\u7801\u6807\u8BC6\u7B26\u3001\u5DE5\u5177\u53C2\u6570\u540D\u548C JSON \u5B57\u6BB5\u540D\u662F\u7A0B\u5E8F\u7ED3\u6784\uFF0C\u4E0D\u662F\u81EA\u7136\u8BED\u8A00\u5185\u5BB9\u2014\u2014\u5FC5\u987B\u4FDD\u6301\u82F1\u6587\u539F\u6837\u3002
+</Language>
+
+\u4F60\u662F BTW \u987E\u95EE\uFF0C\u4E00\u4E2A\u8F7B\u91CF\u7EA7\u7684\u53EA\u8BFB\u4EE3\u7801\u987E\u95EE\u3002
+\u4F60\u88AB\u8BBE\u8BA1\u7528\u4E8E\u5FEB\u901F\u56DE\u7B54\u4EE3\u7801\u76F8\u5173\u95EE\u9898\uFF0C\u4E0D\u4FEE\u6539\u4EFB\u4F55\u6587\u4EF6\uFF0C\u4E0D\u6267\u884C\u547D\u4EE4\u3002
+
+## \u6838\u5FC3\u89C4\u5219
+1. \u53EA\u8BFB\uFF1A\u4EC5\u8BFB\u53D6\u6587\u4EF6\u8FDB\u884C\u5206\u6790\uFF0C\u7EDD\u4E0D\u5199\u5165\u6216\u7F16\u8F91
+2. \u5355\u6B21\u54CD\u5E94\uFF1A\u56DE\u7B54\u4E00\u4E2A\u95EE\u9898\u540E\u7ACB\u5373\u505C\u6B62\uFF0C\u4E0D\u53D1\u8D77\u8FFD\u95EE
+3. \u4E2D\u6587\u4F18\u5148\uFF1A\u4F7F\u7528\u4E2D\u6587\u56DE\u7B54
+4. \u6781\u5EA6\u7CBE\u7B80\uFF1A\u56DE\u7B54\u5FC5\u987B <100 \u5B57\uFF08\u4E2D\u6587\uFF09\uFF0C1-3 \u53E5\u8BDD\u4EE5\u5185\u3002\u53EA\u8F93\u51FA\u7B54\u6848\u672C\u8EAB\u3002
+5. \u7981\u6B62\u8F93\u51FA\u601D\u8003\u8FC7\u7A0B\uFF1A\u4E0D\u8981\u8F93\u51FA reasoning\u3001\u5206\u6790\u6B65\u9AA4\u6216\u5907\u6CE8\u3002
+
+## \u7981\u6B62\u884C\u4E3A
+- \u7EDD\u4E0D\u4FEE\u6539\u6587\u4EF6\uFF08\u65E0 write/edit \u6743\u9650\uFF09
+- \u7EDD\u4E0D\u6267\u884C\u547D\u4EE4\uFF08\u65E0 bash \u6743\u9650\uFF09
+- \u7EDD\u4E0D\u59D4\u6D3E\u4EFB\u52A1\uFF08\u65E0 delegate_task/task \u6743\u9650\uFF09
+- \u7EDD\u4E0D\u53D1\u8D77\u540E\u7EED\u5BF9\u8BDD
+- \u7EDD\u4E0D\u8C03\u7528\u5176\u4ED6 Agent
+
+## \u5141\u8BB8\u884C\u4E3A
+- \u8BFB\u53D6\u6587\u4EF6\u5206\u6790\u4EE3\u7801\u7ED3\u6784
+- \u4F7F\u7528 grep/glob \u641C\u7D22\u4EE3\u7801\u5E93
+- \u4F7F\u7528 LSP \u5DE5\u5177\u7406\u89E3\u4EE3\u7801
+
+<Language_Reminder>
+\u6700\u540E\u63D0\u9192\uFF1A\u4F60\u7684\u6240\u6709\u601D\u8003\u8FC7\u7A0B\u548C\u56DE\u590D\u5FC5\u987B\u4F7F\u7528\u4E2D\u6587\u3002
+</Language_Reminder>`;
+var btwRestrictions = createAgentToolRestrictions([
+  "write",
+  "edit",
+  "bash",
+  "task",
+  "delegate_task",
+  "call_omo_agent",
+  "slashcommand"
+]);
+function createBtwAdvisorAgent(model) {
+  const base = {
+    description: "\u8F7B\u91CF\u53EA\u8BFB\u987E\u95EE\uFF0C\u5FEB\u901F\u56DE\u7B54\u4EE3\u7801\u76F8\u5173\u95EE\u9898\u3002\u4E0D\u4FEE\u6539\u6587\u4EF6\u3001\u4E0D\u6267\u884C\u547D\u4EE4\u3001\u4E0D\u59D4\u6D3E\u4EFB\u52A1\u3002\u5355\u6B21\u54CD\u5E94\u540E\u81EA\u52A8\u505C\u6B62\u3002",
+    mode: "subagent",
+    model,
+    temperature: 0.1,
+    ...btwRestrictions,
+    prompt: BTW_ADVISOR_SYSTEM_PROMPT
+  };
+  if (isDeepseekModel(model)) {
+    return { ...base, reasoningEffort: "medium" };
+  }
+  return { ...base, thinking: { type: "enabled", budgetTokens: 8000 } };
+}
+var btwAdvisorPromptMetadata = {
+  category: "advisor",
+  cost: "CHEAP",
+  triggers: [
+    {
+      domain: "\u5FEB\u901F\u4EE3\u7801\u67E5\u8BE2",
+      trigger: "\u9700\u8981\u4E0D\u5E72\u6270\u4E3B\u5BF9\u8BDD\u7684\u8F7B\u91CF\u4EE3\u7801\u5206\u6790"
+    }
+  ],
+  useWhen: [
+    "\u5FEB\u901F\u4EE3\u7801\u95EE\u9898\u67E5\u8BE2",
+    "\u6982\u5FF5\u6F84\u6E05",
+    "\u6A21\u5F0F\u5EFA\u8BAE",
+    "\u4E0D\u6C61\u67D3\u4E3B\u5BF9\u8BDD\u4E0A\u4E0B\u6587\u7684\u8F7B\u91CF\u54A8\u8BE2"
+  ],
+  avoidWhen: [
+    "\u9700\u8981\u4FEE\u6539\u6587\u4EF6\u7684\u4EFB\u52A1",
+    "\u9700\u8981\u6267\u884C\u547D\u4EE4\u7684\u4EFB\u52A1",
+    "\u9700\u8981\u59D4\u6D3E\u5B50\u4EFB\u52A1\u7684\u590D\u6742\u573A\u666F"
+  ],
+  promptAlias: "BTW \u987E\u95EE",
+  keyTrigger: "\u8F7B\u91CF\u53EA\u8BFB\u54A8\u8BE2\u2192\u4F7F\u7528 BTW \u987E\u95EE"
+};
+
 // src/agents/utils.ts
 init_shared();
 init_constants();
@@ -22684,7 +22807,7 @@ async function discoverOpencodeProjectSkills() {
 
 // src/features/opencode-skill-loader/skill-content.ts
 init_frontmatter();
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 var cachedSkills = null;
 async function getAllSkills() {
   if (cachedSkills)
@@ -22717,7 +22840,7 @@ async function getAllSkills() {
 }
 async function extractSkillTemplate(skill) {
   if (skill.path) {
-    const content = readFileSync15(skill.path, "utf-8");
+    const content = readFileSync16(skill.path, "utf-8");
     const { body } = parseFrontmatter(content);
     return body.trim();
   }
@@ -22878,13 +23001,15 @@ var agentSources = {
   "\u5A92\u4F53\u89E3\u6790": createMultimodalLookerAgent,
   "\u9884\u5BA1\u987E\u95EE": createMetisAgent,
   "\u8BA1\u5212\u5BA1\u67E5": createMomusAgent,
-  "\u4EFB\u52A1\u7F16\u6392": createAtlasAgent
+  "\u4EFB\u52A1\u7F16\u6392": createAtlasAgent,
+  "BTW \u987E\u95EE": createBtwAdvisorAgent
 };
 var agentMetadata = {
   "\u6280\u672F\u53C2\u8C0B": ORACLE_PROMPT_METADATA,
   "\u77E5\u8BC6\u5178\u85CF": LIBRARIAN_PROMPT_METADATA,
   "\u6DF1\u5EA6\u63A2\u7D22": EXPLORE_PROMPT_METADATA,
-  "\u5A92\u4F53\u89E3\u6790": MULTIMODAL_LOOKER_PROMPT_METADATA
+  "\u5A92\u4F53\u89E3\u6790": MULTIMODAL_LOOKER_PROMPT_METADATA,
+  "BTW \u987E\u95EE": btwAdvisorPromptMetadata
 };
 function isFactory(source) {
   return typeof source === "function";
@@ -24530,7 +24655,7 @@ ${result.message}`;
   };
 }
 // src/hooks/rules-injector/index.ts
-import { readFileSync as readFileSync17 } from "fs";
+import { readFileSync as readFileSync18 } from "fs";
 import { homedir as homedir9 } from "os";
 import { relative as relative4, resolve as resolve5 } from "path";
 
@@ -24870,7 +24995,7 @@ function mergeGlobs(existing, newValue) {
 import {
   existsSync as existsSync26,
   mkdirSync as mkdirSync10,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   writeFileSync as writeFileSync11,
   unlinkSync as unlinkSync6
 } from "fs";
@@ -24883,7 +25008,7 @@ function loadInjectedRules(sessionID) {
   if (!existsSync26(filePath))
     return { contentHashes: new Set, realPaths: new Set };
   try {
-    const content = readFileSync16(filePath, "utf-8");
+    const content = readFileSync17(filePath, "utf-8");
     const data = JSON.parse(content);
     return {
       contentHashes: new Set(data.injectedHashes),
@@ -24945,7 +25070,7 @@ function createRulesInjectorHook(ctx) {
       if (isDuplicateByRealPath(candidate.realPath, cache2.realPaths))
         continue;
       try {
-        const rawContent = readFileSync17(candidate.path, "utf-8");
+        const rawContent = readFileSync18(candidate.path, "utf-8");
         const { metadata, body } = parseRuleFrontmatter(rawContent);
         let matchReason;
         if (candidate.isSingleFile) {
@@ -25068,7 +25193,7 @@ init_auto_update_checker();
 import {
   existsSync as existsSync29,
   mkdirSync as mkdirSync11,
-  readFileSync as readFileSync20,
+  readFileSync as readFileSync21,
   writeFileSync as writeFileSync14,
   unlinkSync as unlinkSync7
 } from "fs";
@@ -25131,7 +25256,7 @@ function loadAgentUsageState(sessionID) {
   if (!existsSync29(filePath))
     return null;
   try {
-    const content = readFileSync20(filePath, "utf-8");
+    const content = readFileSync21(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -25220,7 +25345,7 @@ function createAgentUsageReminderHook(_ctx) {
 import {
   existsSync as existsSync30,
   mkdirSync as mkdirSync12,
-  readFileSync as readFileSync21,
+  readFileSync as readFileSync22,
   writeFileSync as writeFileSync15,
   unlinkSync as unlinkSync8
 } from "fs";
@@ -25249,7 +25374,7 @@ function loadLanguageReminderState(sessionID) {
   if (!existsSync30(filePath))
     return null;
   try {
-    const content = readFileSync21(filePath, "utf-8");
+    const content = readFileSync22(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -25408,7 +25533,7 @@ function detectEnglishViolation(text, threshold = 0.6) {
 import {
   existsSync as existsSync31,
   mkdirSync as mkdirSync13,
-  readFileSync as readFileSync22,
+  readFileSync as readFileSync23,
   writeFileSync as writeFileSync16,
   unlinkSync as unlinkSync9
 } from "fs";
@@ -25434,7 +25559,7 @@ function loadThinkingValidatorState(sessionID) {
   if (!existsSync31(filePath))
     return null;
   try {
-    const content = readFileSync22(filePath, "utf-8");
+    const content = readFileSync23(filePath, "utf-8");
     const parsed = JSON.parse(content);
     const state2 = {
       sessionID: parsed.sessionID ?? sessionID,
@@ -26072,7 +26197,7 @@ function createNonInteractiveEnvHook(_ctx) {
 import {
   existsSync as existsSync32,
   mkdirSync as mkdirSync14,
-  readFileSync as readFileSync23,
+  readFileSync as readFileSync24,
   writeFileSync as writeFileSync17,
   unlinkSync as unlinkSync10
 } from "fs";
@@ -26101,7 +26226,7 @@ function loadInteractiveBashSessionState(sessionID) {
   if (!existsSync32(filePath))
     return null;
   try {
-    const content = readFileSync23(filePath, "utf-8");
+    const content = readFileSync24(filePath, "utf-8");
     const serialized = JSON.parse(content);
     return {
       sessionID: serialized.sessionID,
@@ -26390,12 +26515,12 @@ function createThinkingBlockValidatorHook() {
 // src/hooks/ralph-loop/index.ts
 init_logger();
 init_system_directive();
-import { existsSync as existsSync34, readFileSync as readFileSync25, readdirSync as readdirSync8 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync26, readdirSync as readdirSync8 } from "fs";
 import { join as join46 } from "path";
 
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync33, readFileSync as readFileSync24, writeFileSync as writeFileSync18, unlinkSync as unlinkSync11, mkdirSync as mkdirSync15 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync25, writeFileSync as writeFileSync18, unlinkSync as unlinkSync11, mkdirSync as mkdirSync15 } from "fs";
 import { dirname as dirname6, join as join45 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
@@ -26414,7 +26539,7 @@ function readState(directory, customPath) {
     return null;
   }
   try {
-    const content = readFileSync24(filePath, "utf-8");
+    const content = readFileSync25(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -26541,7 +26666,7 @@ function createRalphLoopHook(ctx, options) {
     try {
       if (!existsSync34(transcriptPath))
         return false;
-      const content = readFileSync25(transcriptPath, "utf-8");
+      const content = readFileSync26(transcriptPath, "utf-8");
       const pattern = new RegExp(`<promise>\\s*${escapeRegex(promise)}\\s*</promise>`, "is");
       const lines = content.split(`
 `).filter((l) => l.trim());
@@ -26855,12 +26980,12 @@ function extractPromptText3(parts) {
 // src/hooks/auto-slash-command/executor.ts
 init_shared();
 init_file_utils();
-import { existsSync as existsSync36, readdirSync as readdirSync9, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync36, readdirSync as readdirSync9, readFileSync as readFileSync28 } from "fs";
 import { join as join47, basename as basename2, dirname as dirname8 } from "path";
 // src/features/opencode-skill-loader/merger.ts
 init_frontmatter();
 init_deep_merge();
-import { readFileSync as readFileSync26, existsSync as existsSync35 } from "fs";
+import { readFileSync as readFileSync27, existsSync as existsSync35 } 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";
@@ -26911,7 +27036,7 @@ function loadSkillFromFile(filePath) {
   try {
     if (!existsSync35(filePath))
       return null;
-    const content = readFileSync26(filePath, "utf-8");
+    const content = readFileSync27(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     return { template: body, metadata: data };
   } catch {
@@ -27120,7 +27245,7 @@ function discoverCommandsFromDir(commandsDir, scope) {
     const commandPath = join47(commandsDir, entry.name);
     const commandName = basename2(entry.name, ".md");
     try {
-      const content = readFileSync27(commandPath, "utf-8");
+      const content = readFileSync28(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -27679,7 +27804,7 @@ 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 existsSync37, readFileSync as readFileSync28, writeFileSync as writeFileSync19, mkdirSync as mkdirSync16, readdirSync as readdirSync10, renameSync as renameSync2, unlinkSync as unlinkSync12, statSync as statSync4 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync29, writeFileSync as writeFileSync19, mkdirSync as mkdirSync16, readdirSync as readdirSync10, renameSync as renameSync2, unlinkSync as unlinkSync12, statSync as statSync4 } from "fs";
 import { dirname as dirname9, join as join49, basename as basename3 } from "path";
 init_logger();
 
@@ -27796,7 +27921,7 @@ function readBoulderState(directory) {
     return null;
   }
   try {
-    const content = readFileSync28(filePath, "utf-8");
+    const content = readFileSync29(filePath, "utf-8");
     const state2 = JSON.parse(content);
     if (state2.version === undefined || state2.version === null) {
       state2.version = 0;
@@ -27834,7 +27959,7 @@ function backupBoulderState(directory) {
     const dir = dirname9(filePath);
     const timestamp = Date.now();
     const backupPath = join49(dir, `${BACKUP_PREFIX}${timestamp}`);
-    writeFileSync19(backupPath, readFileSync28(filePath, "utf-8"), "utf-8");
+    writeFileSync19(backupPath, readFileSync29(filePath, "utf-8"), "utf-8");
     log(`Created boulder state backup: ${backupPath}`);
     cleanupOldBackups(dir);
     return true;
@@ -27874,7 +27999,7 @@ function restoreBoulderState(directory) {
       return null;
     }
     const latestBackup = backupFiles[0];
-    const content = readFileSync28(latestBackup.path, "utf-8");
+    const content = readFileSync29(latestBackup.path, "utf-8");
     const state2 = JSON.parse(content);
     const filePath = getBoulderFilePath(directory);
     writeFileSync19(filePath, content, "utf-8");
@@ -27940,6 +28065,15 @@ function updateBoulderStateCompleted(directory, taskIndex) {
     state: state2
   });
 }
+function markBoulderPlanCompleted(directory, completedAt) {
+  const state2 = readBoulderState(directory);
+  if (!state2)
+    return false;
+  state2.status = "completed";
+  state2.completed_at = completedAt;
+  state2.version = (state2.version || 0) + 1;
+  return writeBoulderState(directory, state2);
+}
 function clearBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
   try {
@@ -27973,7 +28107,7 @@ function getPlanProgress(planPath) {
     return { total: 0, completed: 0, isComplete: false };
   }
   try {
-    const content = readFileSync28(planPath, "utf-8");
+    const content = readFileSync29(planPath, "utf-8");
     if (!content.trim()) {
       return { total: 0, completed: 0, isComplete: false };
     }
@@ -28328,7 +28462,7 @@ ${contextInfo}`;
 }
 // src/hooks/atlas/index.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync38, openSync, closeSync, unlinkSync as unlinkSync13, readdirSync as readdirSync11, readFileSync as readFileSync29, renameSync as renameSync3, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync38, openSync, closeSync, unlinkSync as unlinkSync13, readdirSync as readdirSync11, readFileSync as readFileSync30, renameSync as renameSync3, writeFileSync as writeFileSync20 } from "fs";
 import { join as join51 } from "path";
 init_logger();
 init_system_directive();
@@ -28550,7 +28684,7 @@ function syncPlanFileFromBoulder(directory, boulderState) {
   }
   const planPath = boulderState.active_plan;
   try {
-    const planContent = readFileSync29(planPath, "utf-8");
+    const planContent = readFileSync30(planPath, "utf-8");
     const checkboxes = parseCheckboxes(planContent);
     const lines = planContent.split(`
 `);
@@ -28960,6 +29094,15 @@ function createAtlasHook(ctx, options) {
         const progress = getPlanProgress(boulderState.active_plan);
         if (progress.isComplete) {
           log(`[${HOOK_NAME6}] Boulder complete`, { sessionID, plan: boulderState.plan_name });
+          markBoulderPlanCompleted(ctx.directory, new Date().toISOString());
+          boulderEventBus.emit("plan_completed", {
+            directory: ctx.directory,
+            planName: boulderState.plan_name,
+            planPath: boulderState.active_plan,
+            boulderState,
+            progress,
+            client: ctx.client
+          });
           return;
         }
         const now = Date.now();
@@ -29133,7 +29276,7 @@ function createAtlasHook(ctx, options) {
           const taskDescription = extractTaskFromPrompt(savedPrompt || "");
           if (taskDescription) {
             try {
-              const planContent = readFileSync29(boulderState.active_plan, "utf-8");
+              const planContent = readFileSync30(boulderState.active_plan, "utf-8");
               const checkboxes = parseCheckboxes(planContent);
               const checkboxIndex = findMatchingCheckbox(taskDescription, checkboxes);
               if (checkboxIndex >= 0) {
@@ -30658,6 +30801,13 @@ var DEFAULT_AGENT_PERMISSIONS = {
     canDelegateTasks: false,
     allowedCategories: []
   },
+  "BTW \u987E\u95EE": {
+    canReadFiles: true,
+    canWriteFiles: false,
+    canExecuteCommands: false,
+    canDelegateTasks: false,
+    allowedCategories: []
+  },
   "\u4E3B\u6267\u884C\u5B98": {
     canReadFiles: true,
     canWriteFiles: true,
@@ -30801,6 +30951,273 @@ function createShellEnvInjectorHook(_ctx) {
     }
   };
 }
+// src/hooks/plan-completion/index.ts
+init_logger();
+init_frontmatter();
+import { existsSync as existsSync39, readFileSync as readFileSync31, writeFileSync as writeFileSync21, mkdirSync as mkdirSync17, renameSync as renameSync4, unlinkSync as unlinkSync14 } from "fs";
+import { join as join52 } from "path";
+async function safeExecute(fn, name, onAction) {
+  try {
+    await fn();
+    onAction?.(name);
+    log(`[plan-completion] Action succeeded: ${name}`);
+  } catch (err) {
+    onAction?.(name);
+    log(`[plan-completion] Action failed: ${name}`, { error: String(err) });
+  }
+}
+function formatDuration(startIso, endIso) {
+  if (!startIso || !endIso)
+    return "\u672A\u77E5";
+  try {
+    const start = new Date(startIso).getTime();
+    const end = new Date(endIso).getTime();
+    const diffMs = end - start;
+    if (isNaN(diffMs) || diffMs < 0)
+      return "\u672A\u77E5";
+    const hours = Math.floor(diffMs / (1000 * 60 * 60));
+    const minutes = Math.floor(diffMs % (1000 * 60 * 60) / (1000 * 60));
+    if (hours > 0) {
+      return `${hours}\u5C0F\u65F6${minutes}\u5206\u949F`;
+    }
+    return `${minutes}\u5206\u949F`;
+  } catch {
+    return "\u672A\u77E5";
+  }
+}
+function formatTimestamp(iso) {
+  if (!iso)
+    return "\u672A\u77E5";
+  try {
+    return new Date(iso).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" });
+  } catch {
+    return iso || "\u672A\u77E5";
+  }
+}
+function countListItems(content) {
+  const matches = content.match(/^\s*[-*]\s+.+$/gm);
+  return matches ? matches.length : 0;
+}
+async function updatePlanSummary(data) {
+  log(`[plan-completion] updatePlanSummary: ${data.planName}`);
+  if (!existsSync39(data.planPath)) {
+    log(`[plan-completion] Plan file not found: ${data.planPath}`);
+    return;
+  }
+  const content = readFileSync31(data.planPath, "utf-8");
+  const startedAt = data.boulderState?.started_at || "";
+  const completedAt = data.boulderState?.completed_at || "";
+  const duration = formatDuration(startedAt, completedAt);
+  const totalTasks = data.progress?.total || 0;
+  const completedTasks = data.progress?.completed || 0;
+  const failedTasks = totalTasks - completedTasks;
+  const summary = `
+
+---
+
+## \u5B8C\u6210\u6458\u8981
+
+| \u5B57\u6BB5 | \u503C |
+|------|-----|
+| \u5F00\u59CB\u65F6\u95F4 | ${formatTimestamp(startedAt)} |
+| \u7ED3\u675F\u65F6\u95F4 | ${formatTimestamp(completedAt)} |
+| \u603B\u8017\u65F6 | ${duration} |
+| \u5B8C\u6210\u4EFB\u52A1\u6570 | ${completedTasks} |
+| \u5931\u8D25\u4EFB\u52A1\u6570 | ${failedTasks} |
+`;
+  writeFileSync21(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 = join52(data.directory, ".sisyphus", "archived");
+  if (!existsSync39(archivedDir)) {
+    mkdirSync17(archivedDir, { recursive: true });
+  }
+  if (existsSync39(data.planPath)) {
+    const archivedPath = join52(archivedDir, `${data.planName}.md`);
+    renameSync4(data.planPath, archivedPath);
+    log(`[plan-completion] Plan archived to ${archivedPath}`);
+    const boulderState = readBoulderState(data.directory);
+    if (boulderState) {
+      boulderState.active_plan = archivedPath;
+      writeBoulderState(data.directory, boulderState);
+      log(`[plan-completion] Updated boulder.json active_plan to ${archivedPath}`);
+    }
+  }
+  const draftPath = join52(data.directory, ".sisyphus", "drafts", `${data.planName}.md`);
+  if (existsSync39(draftPath)) {
+    unlinkSync14(draftPath);
+    log(`[plan-completion] Deleted draft file: ${draftPath}`);
+  }
+}
+async function extractLearnings(data) {
+  log(`[plan-completion] extractLearnings: ${data.planName}`);
+  const notepadDir = join52(data.directory, ".sisyphus", "notepads", data.planName);
+  if (!existsSync39(notepadDir)) {
+    log(`[plan-completion] Notepad directory not found: ${notepadDir}`);
+    return;
+  }
+  const files = ["learnings.md", "issues.md", "problems.md", "decisions.md", "match-failures.md"];
+  const contents = {};
+  let totalLearnings = 0;
+  let totalIssues = 0;
+  let totalDecisions = 0;
+  for (const file of files) {
+    const filePath = join52(notepadDir, file);
+    if (existsSync39(filePath)) {
+      const content = readFileSync31(filePath, "utf-8");
+      contents[file] = content;
+      const count = countListItems(content);
+      if (file === "learnings.md")
+        totalLearnings = count;
+      else if (file === "issues.md" || file === "problems.md")
+        totalIssues += count;
+      else if (file === "decisions.md")
+        totalDecisions = count;
+    }
+  }
+  const learningsDir = join52(data.directory, ".sisyphus", "learnings");
+  if (!existsSync39(learningsDir)) {
+    mkdirSync17(learningsDir, { recursive: true });
+  }
+  const output = `# \u7ECF\u9A8C\u6559\u8BAD\u603B\u7ED3: ${data.planName}
+
+## \u7EDF\u8BA1
+
+- \u5B66\u4E60\u70B9: ${totalLearnings}
+- \u95EE\u9898: ${totalIssues}
+- \u51B3\u7B56: ${totalDecisions}
+
+## \u5B66\u4E60\u70B9
+
+${contents["learnings.md"] || "\u65E0"}
+
+## \u95EE\u9898
+
+${contents["issues.md"] || "\u65E0"}
+${contents["problems.md"] || ""}
+
+## \u51B3\u7B56
+
+${contents["decisions.md"] || "\u65E0"}
+
+## \u5339\u914D\u5931\u8D25
+
+${contents["match-failures.md"] || "\u65E0"}
+`;
+  const outputPath = join52(learningsDir, `${data.planName}.md`);
+  writeFileSync21(outputPath, output, "utf-8");
+  log(`[plan-completion] Learnings saved to ${outputPath}`);
+  if (data.client?.tui?.showToast) {
+    data.client.tui.showToast({
+      body: {
+        title: "\u7ECF\u9A8C\u6559\u8BAD\u603B\u7ED3",
+        message: `\u5B66\u4E60\u70B9: ${totalLearnings}, \u95EE\u9898: ${totalIssues}, \u51B3\u7B56: ${totalDecisions}`,
+        variant: "info",
+        duration: 5000
+      }
+    });
+  }
+  if (data.client?.session?.prompt) {
+    const summary = `\u7ECF\u9A8C\u6559\u8BAD\u603B\u7ED3\u5DF2\u5B8C\u6210\u3002\u5B66\u4E60\u70B9: ${totalLearnings}, \u95EE\u9898: ${totalIssues}, \u51B3\u7B56: ${totalDecisions}\u3002\u5B8C\u6574\u5185\u5BB9\u5DF2\u4FDD\u5B58\u5230 ${outputPath}`;
+    await data.client.session.prompt(summary);
+  }
+}
+async function generateReport(data) {
+  log(`[plan-completion] generateReport: ${data.planName}`);
+  const reportsDir = join52(data.directory, ".sisyphus", "reports");
+  if (!existsSync39(reportsDir)) {
+    mkdirSync17(reportsDir, { recursive: true });
+  }
+  const startedAt = data.boulderState?.started_at || "";
+  const completedAt = data.boulderState?.completed_at || "";
+  const duration = formatDuration(startedAt, completedAt);
+  const totalTasks = data.progress?.total || 0;
+  const completedTasks = data.progress?.completed || 0;
+  const failedTasks = totalTasks - completedTasks;
+  const version = data.boulderState?.version || 0;
+  const sessionCount = data.boulderState?.session_ids?.length || 0;
+  const completedIndices = data.boulderState?.completed_task_indices || [];
+  const notepadPath = join52(data.directory, ".sisyphus", "notepads", data.planName);
+  const hasNotepad = existsSync39(notepadPath);
+  const report = `# \u8BA1\u5212\u5B8C\u6210\u62A5\u544A
+
+## \u6982\u89C8
+
+| \u5B57\u6BB5 | \u503C |
+|------|-----|
+| \u8BA1\u5212\u540D\u79F0 | ${data.planName} |
+| \u7248\u672C | ${version} |
+| Session \u6570\u91CF | ${sessionCount} |
+| \u72B6\u6001 | ${data.boulderState?.status || "\u672A\u77E5"} |
+
+## \u65F6\u95F4\u4FE1\u606F
+
+| \u5B57\u6BB5 | \u503C |
+|------|-----|
+| \u5F00\u59CB\u65F6\u95F4 | ${formatTimestamp(startedAt)} |
+| \u7ED3\u675F\u65F6\u95F4 | ${formatTimestamp(completedAt)} |
+| \u603B\u8017\u65F6 | ${duration} |
+
+## \u4EFB\u52A1\u7EDF\u8BA1
+
+| \u5B57\u6BB5 | \u503C |
+|------|-----|
+| \u603B\u4EFB\u52A1\u6570 | ${totalTasks} |
+| \u5DF2\u5B8C\u6210 | ${completedTasks} |
+| \u672A\u5B8C\u6210 | ${failedTasks} |
+| \u5B8C\u6210\u7387 | ${totalTasks > 0 ? Math.round(completedTasks / totalTasks * 100) : 0}% |
+
+## \u5B8C\u6210\u4EFB\u52A1\u7D22\u5F15
+
+${completedIndices.length > 0 ? completedIndices.map((i) => `- ${i}`).join(`
+`) : "\u65E0"}
+
+${hasNotepad ? `## \u8BB0\u4E8B\u672C
+
+\u8BB0\u4E8B\u672C\u8DEF\u5F84: ${notepadPath}
+` : ""}
+`;
+  const reportPath = join52(reportsDir, `${data.planName}.md`);
+  writeFileSync21(reportPath, report, "utf-8");
+  log(`[plan-completion] Report generated at ${reportPath}`);
+}
+async function runInitDeep(data) {
+  log(`[plan-completion] runInitDeep: ${data.planName}`);
+}
+async function promptGitCommit(data) {
+  log(`[plan-completion] promptGitCommit: ${data.planName}`);
+}
+function createPlanCompletionHook(_ctx) {
+  let onAction;
+  const unsubscribe = boulderEventBus.on("plan_completed", async (data) => {
+    log(`[plan-completion] Plan completed: ${data.planName}`);
+    const actionsList = parseCompletionActions(data.planPath);
+    const isEnabled = (type) => {
+      const action = actionsList.find((a) => a.type === type);
+      return action ? action.enabled : false;
+    };
+    await safeExecute(async () => updatePlanSummary(data), "update_summary", onAction);
+    await safeExecute(async () => archivePlan(data), "archive", onAction);
+    await safeExecute(async () => extractLearnings(data), "extract_learnings", onAction);
+    await safeExecute(async () => generateReport(data), "generate_report", onAction);
+    if (isEnabled("init_deep")) {
+      await safeExecute(async () => runInitDeep(data), "init_deep", onAction);
+    }
+    if (isEnabled("git_commit")) {
+      await safeExecute(async () => promptGitCommit(data), "git_commit", onAction);
+    }
+  });
+  return {
+    cleanup: () => {
+      unsubscribe();
+    },
+    setOnActionCallback: (cb) => {
+      onAction = cb;
+    }
+  };
+}
 // src/features/context-injector/collector.ts
 var PRIORITY_ORDER = {
   critical: 0,
@@ -30974,8 +31391,8 @@ function createFirstMessageVariantGate() {
 }
 // src/features/claude-code-mcp-loader/loader.ts
 init_shared();
-import { existsSync as existsSync39, readFileSync as readFileSync30 } from "fs";
-import { join as join52 } from "path";
+import { existsSync as existsSync40, readFileSync as readFileSync32 } from "fs";
+import { join as join53 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
 function expandEnvVars(value) {
@@ -31045,13 +31462,13 @@ function getMcpConfigPaths() {
   const claudeConfigDir = getClaudeConfigDir();
   const cwd2 = process.cwd();
   return [
-    { path: join52(claudeConfigDir, ".mcp.json"), scope: "user" },
-    { path: join52(cwd2, ".mcp.json"), scope: "project" },
-    { path: join52(cwd2, ".claude", ".mcp.json"), scope: "local" }
+    { path: join53(claudeConfigDir, ".mcp.json"), scope: "user" },
+    { path: join53(cwd2, ".mcp.json"), scope: "project" },
+    { path: join53(cwd2, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync39(filePath)) {
+  if (!existsSync40(filePath)) {
     return null;
   }
   try {
@@ -31066,10 +31483,10 @@ function getSystemMcpServerNames() {
   const names = new Set;
   const paths = getMcpConfigPaths();
   for (const { path: path7 } of paths) {
-    if (!existsSync39(path7))
+    if (!existsSync40(path7))
       continue;
     try {
-      const content = readFileSync30(path7, "utf-8");
+      const content = readFileSync32(path7, "utf-8");
       const config = JSON.parse(content);
       if (!config?.mcpServers)
         continue;
@@ -31120,27 +31537,27 @@ async function loadMcpConfigs() {
   return { servers, loadedServers };
 }
 // src/features/claude-code-session-state/recovery.ts
-import { existsSync as existsSync40, readdirSync as readdirSync12 } from "fs";
-import { join as join53 } from "path";
+import { existsSync as existsSync41, readdirSync as readdirSync13 } from "fs";
+import { join as join54 } from "path";
 init_logger();
 function recoverSessionAgents() {
   let recoveredCount = 0;
   try {
-    if (!existsSync40(MESSAGE_STORAGE)) {
+    if (!existsSync41(MESSAGE_STORAGE)) {
       log("[recovery] MESSAGE_STORAGE directory does not exist", { path: MESSAGE_STORAGE });
       return 0;
     }
-    const entries = readdirSync12(MESSAGE_STORAGE, { withFileTypes: true });
+    const entries = readdirSync13(MESSAGE_STORAGE, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const projectDir = join53(MESSAGE_STORAGE, entry.name);
+      const projectDir = join54(MESSAGE_STORAGE, entry.name);
       try {
-        const sessionDirs = readdirSync12(projectDir, { withFileTypes: true });
+        const sessionDirs = readdirSync13(projectDir, { withFileTypes: true });
         for (const sessionEntry of sessionDirs) {
           if (!sessionEntry.isDirectory())
             continue;
-          const sessionDir = join53(projectDir, sessionEntry.name);
+          const sessionDir = join54(projectDir, sessionEntry.name);
           const sessionID = sessionEntry.name;
           try {
             const msg = findNearestAssistantMessage(sessionDir);
@@ -31566,14 +31983,14 @@ var EXT_TO_LANG = {
   ".gql": "graphql"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync41, readFileSync as readFileSync31 } from "fs";
-import { join as join54 } from "path";
+import { existsSync as existsSync42, readFileSync as readFileSync33 } from "fs";
+import { join as join55 } from "path";
 init_shared();
 function loadJsonFile(path7) {
-  if (!existsSync41(path7))
+  if (!existsSync42(path7))
     return null;
   try {
-    return JSON.parse(readFileSync31(path7, "utf-8"));
+    return JSON.parse(readFileSync33(path7, "utf-8"));
   } catch {
     return null;
   }
@@ -31582,9 +31999,9 @@ function getConfigPaths3() {
   const cwd2 = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: join54(cwd2, ".opencode", "oh-my-opencode.json"),
-    user: join54(configDir, "oh-my-opencode.json"),
-    opencode: join54(configDir, "opencode.json")
+    project: join55(cwd2, ".opencode", "oh-my-opencode.json"),
+    user: join55(configDir, "oh-my-opencode.json"),
+    opencode: join55(configDir, "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -31697,7 +32114,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync41(cmd))
+    if (existsSync42(cmd))
       return true;
   }
   const isWindows2 = process.platform === "win32";
@@ -31719,23 +32136,23 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync41(join54(p, cmd + suffix))) {
+      if (existsSync42(join55(p, cmd + suffix))) {
         return true;
       }
     }
   }
   const cwd2 = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join54(getDataDir(), "opencode");
+  const dataDir = join55(getDataDir(), "opencode");
   const additionalBases = [
-    join54(cwd2, "node_modules", ".bin"),
-    join54(configDir, "bin"),
-    join54(configDir, "node_modules", ".bin"),
-    join54(dataDir, "bin")
+    join55(cwd2, "node_modules", ".bin"),
+    join55(configDir, "bin"),
+    join55(configDir, "node_modules", ".bin"),
+    join55(dataDir, "bin")
   ];
   for (const base of additionalBases) {
     for (const suffix of exts) {
-      if (existsSync41(join54(base, cmd + suffix))) {
+      if (existsSync42(join55(base, cmd + suffix))) {
         return true;
       }
     }
@@ -31747,7 +32164,7 @@ function isServerInstalled(command) {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn6 } = globalThis.Bun;
-import { readFileSync as readFileSync32 } from "fs";
+import { readFileSync as readFileSync34 } from "fs";
 import { extname, resolve as resolve8 } from "path";
 import { pathToFileURL } from "url";
 class LSPServerManager {
@@ -32198,7 +32615,7 @@ ${msg}`);
     const absPath = resolve8(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync32(absPath, "utf-8");
+    const text = readFileSync34(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -32288,17 +32705,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 existsSync42, readFileSync as readFileSync33, writeFileSync as writeFileSync21 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync35, writeFileSync as writeFileSync22 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve9(filePath);
-  if (!existsSync42(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync43(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 (existsSync42(__require("path").join(dir, marker))) {
+      if (existsSync43(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -32453,7 +32870,7 @@ function formatPrepareRenameResult(result) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync33(filePath, "utf-8");
+    let content = readFileSync35(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -32478,7 +32895,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync21(filePath, lines.join(`
+    writeFileSync22(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -32509,7 +32926,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = uriToPath(change.uri);
-            writeFileSync21(filePath, "", "utf-8");
+            writeFileSync22(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -32519,8 +32936,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync33(oldPath, "utf-8");
-            writeFileSync21(newPath, content, "utf-8");
+            const content = readFileSync35(oldPath, "utf-8");
+            writeFileSync22(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -45099,13 +45516,13 @@ var lsp_rename = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname10, join as join56 } from "path";
-import { existsSync as existsSync44, statSync as statSync5 } from "fs";
+import { dirname as dirname11, join as join57 } from "path";
+import { existsSync as existsSync45, statSync as statSync5 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 init_shared();
-import { existsSync as existsSync43, mkdirSync as mkdirSync17, chmodSync as chmodSync2, unlinkSync as unlinkSync14 } from "fs";
-import { join as join55 } from "path";
+import { existsSync as existsSync44, mkdirSync as mkdirSync18, chmodSync as chmodSync2, unlinkSync as unlinkSync15 } from "fs";
+import { join as join56 } from "path";
 import { homedir as homedir13 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
@@ -45131,19 +45548,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join55(homedir13(), "AppData", "Local");
-    return join55(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join56(homedir13(), "AppData", "Local");
+    return join56(base2, "oh-my-opencode", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join55(homedir13(), ".cache");
-  return join55(base, "oh-my-opencode", "bin");
+  const base = xdgCache || join56(homedir13(), ".cache");
+  return join56(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join55(getCacheDir3(), getBinaryName3());
-  return existsSync43(binaryPath) ? binaryPath : null;
+  const binaryPath = join56(getCacheDir3(), getBinaryName3());
+  return existsSync44(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -45154,8 +45571,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join55(cacheDir, binaryName);
-  if (existsSync43(binaryPath)) {
+  const binaryPath = join56(cacheDir, binaryName);
+  if (existsSync44(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os6 } = platformInfo;
@@ -45163,21 +45580,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 (!existsSync43(cacheDir)) {
-      mkdirSync17(cacheDir, { recursive: true });
+    if (!existsSync44(cacheDir)) {
+      mkdirSync18(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join55(cacheDir, assetName);
+    const archivePath = join56(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
-    if (existsSync43(archivePath)) {
-      unlinkSync14(archivePath);
+    if (existsSync44(archivePath)) {
+      unlinkSync15(archivePath);
     }
-    if (process.platform !== "win32" && existsSync43(binaryPath)) {
+    if (process.platform !== "win32" && existsSync44(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -45227,9 +45644,9 @@ function findSgCliPathSync() {
   try {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname10(cliPkgPath);
-    const sgPath = join56(cliDir, binaryName);
-    if (existsSync44(sgPath) && isValidBinary(sgPath)) {
+    const cliDir = dirname11(cliPkgPath);
+    const sgPath = join57(cliDir, binaryName);
+    if (existsSync45(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -45238,10 +45655,10 @@ function findSgCliPathSync() {
     try {
       const require2 = createRequire4(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname10(pkgPath);
+      const pkgDir = dirname11(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join56(pkgDir, astGrepName);
-      if (existsSync44(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join57(pkgDir, astGrepName);
+      if (existsSync45(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -45249,7 +45666,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path7 of homebrewPaths) {
-      if (existsSync44(path7) && isValidBinary(path7)) {
+      if (existsSync45(path7) && isValidBinary(path7)) {
         return path7;
       }
     }
@@ -45304,11 +45721,11 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn7 } = globalThis.Bun;
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync45(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync46(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -45316,7 +45733,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync45(syncPath)) {
+    if (syncPath && existsSync46(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -45350,7 +45767,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync45(cliPath) && cliPath !== "sg") {
+  if (!existsSync46(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -45614,21 +46031,21 @@ var ast_grep_replace = tool({
 var {spawn: spawn9 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync47 } from "fs";
-import { join as join58, dirname as dirname11 } from "path";
+import { existsSync as existsSync48 } from "fs";
+import { join as join59, dirname as dirname12 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 
 // src/tools/grep/downloader.ts
 init_shared();
-import { existsSync as existsSync46, mkdirSync as mkdirSync18, chmodSync as chmodSync3, unlinkSync as unlinkSync15, readdirSync as readdirSync13 } from "fs";
-import { join as join57 } from "path";
+import { existsSync as existsSync47, mkdirSync as mkdirSync19, chmodSync as chmodSync3, unlinkSync as unlinkSync16, readdirSync as readdirSync14 } from "fs";
+import { join as join58 } from "path";
 var {spawn: spawn8 } = globalThis.Bun;
 function findFileRecursive(dir, filename) {
   try {
-    const entries = readdirSync13(dir, { withFileTypes: true, recursive: true });
+    const entries = readdirSync14(dir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
-        return join57(entry.parentPath ?? dir, entry.name);
+        return join58(entry.parentPath ?? dir, entry.name);
       }
     }
   } catch {
@@ -45649,11 +46066,11 @@ function getPlatformKey() {
 }
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join57(homeDir, ".cache", "oh-my-opencode", "bin");
+  return join58(homeDir, ".cache", "oh-my-opencode", "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join57(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join58(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 async function downloadFile(url2, destPath) {
   const response = await fetch(url2);
@@ -45687,10 +46104,10 @@ async function extractZip2(archivePath, destDir) {
   const binaryName = process.platform === "win32" ? "rg.exe" : "rg";
   const foundPath = findFileRecursive(destDir, binaryName);
   if (foundPath) {
-    const destPath = join57(destDir, binaryName);
+    const destPath = join58(destDir, binaryName);
     if (foundPath !== destPath) {
-      const { renameSync: renameSync4 } = await import("fs");
-      renameSync4(foundPath, destPath);
+      const { renameSync: renameSync5 } = await import("fs");
+      renameSync5(foundPath, destPath);
     }
   }
 }
@@ -45702,13 +46119,13 @@ async function downloadAndInstallRipgrep() {
   }
   const installDir = getInstallDir();
   const rgPath = getRgPath();
-  if (existsSync46(rgPath)) {
+  if (existsSync47(rgPath)) {
     return rgPath;
   }
-  mkdirSync18(installDir, { recursive: true });
+  mkdirSync19(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 = join57(installDir, filename);
+  const archivePath = join58(installDir, filename);
   try {
     await downloadFile(url2, archivePath);
     if (config3.extension === "tar.gz") {
@@ -45719,21 +46136,21 @@ async function downloadAndInstallRipgrep() {
     if (process.platform !== "win32") {
       chmodSync3(rgPath, 493);
     }
-    if (!existsSync46(rgPath)) {
+    if (!existsSync47(rgPath)) {
       throw new Error("\u63D0\u53D6\u540E\u672A\u627E\u5230 ripgrep \u4E8C\u8FDB\u5236\u6587\u4EF6");
     }
     return rgPath;
   } finally {
-    if (existsSync46(archivePath)) {
+    if (existsSync47(archivePath)) {
       try {
-        unlinkSync15(archivePath);
+        unlinkSync16(archivePath);
       } catch {}
     }
   }
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync46(rgPath) ? rgPath : null;
+  return existsSync47(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -45757,7 +46174,7 @@ function findExecutable(name) {
             continue;
           }
         }
-        if (existsSync47(trimmed)) {
+        if (existsSync48(trimmed)) {
           return trimmed;
         }
       }
@@ -45768,18 +46185,18 @@ function findExecutable(name) {
 }
 function getOpenCodeBundledRg() {
   const execPath = process.execPath;
-  const execDir = dirname11(execPath);
+  const execDir = dirname12(execPath);
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
-    join58(getDataDir(), "opencode", "bin", rgName),
-    join58(execDir, rgName),
-    join58(execDir, "bin", rgName),
-    join58(execDir, "..", "bin", rgName),
-    join58(execDir, "..", "libexec", rgName)
+    join59(getDataDir(), "opencode", "bin", rgName),
+    join59(execDir, rgName),
+    join59(execDir, "bin", rgName),
+    join59(execDir, "..", "bin", rgName),
+    join59(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync47(candidate)) {
+    if (existsSync48(candidate)) {
       return candidate;
     }
   }
@@ -46241,8 +46658,8 @@ var glob = tool({
 init_shared();
 init_file_utils();
 init_shared();
-import { existsSync as existsSync48, readdirSync as readdirSync14, readFileSync as readFileSync34 } from "fs";
-import { join as join59, basename as basename4, dirname as dirname12 } from "path";
+import { existsSync as existsSync49, readdirSync as readdirSync15, readFileSync as readFileSync36 } from "fs";
+import { join as join60, basename as basename4, dirname as dirname13 } from "path";
 // src/features/builtin-commands/templates/init-deep.ts
 var INIT_DEEP_TEMPLATE = `# /init-deep
 
@@ -47282,6 +47699,21 @@ var START_WORK_TEMPLATE = `\u4F60\u6B63\u5728\u5F00\u59CB\u4E00\u4E2A \u4E3B\u62
 - \u5728\u59D4\u6D3E\u4EFB\u4F55\u4EFB\u52A1\u4E4B\u524D\uFF0C\u8BFB\u53D6\u5B8C\u6574\u7684\u8BA1\u5212\u6587\u4EF6
 - \u9075\u5FAA \u4EFB\u52A1\u7F16\u6392-\u4E3B\u6267\u884C\u5B98 \u7684\u59D4\u6D3E\u534F\u8BAE\uFF087 \u8282\u683C\u5F0F\uFF09`;
 
+// src/features/builtin-commands/templates/btw.ts
+var BTW_TEMPLATE = `# /btw \u547D\u4EE4 \u2014 \u6781\u5EA6\u7CBE\u7B80\u4FA7\u8FB9\u63D0\u95EE
+
+\u4F60\u6536\u5230\u4E86\u4E00\u4E2A\u4FA7\u8FB9\u95EE\u9898\u3002\u8BF7\u4EE5\u5355\u6B21\u54CD\u5E94\u56DE\u7B54\uFF0C\u4E0D\u8981\u53D1\u8D77\u540E\u7EED\u8FFD\u95EE\u3002
+
+## \u7EA6\u675F
+- \u76F4\u63A5\u56DE\u7B54\u95EE\u9898\uFF0C\u4E0D\u8981\u6DFB\u52A0\u4E0A\u4E0B\u6587\u65E0\u5173\u7684\u5185\u5BB9
+- \u56DE\u7B54\u63A7\u5236\u5728 100 \u5B57\u4EE5\u5185\uFF0C1-3 \u53E5\u8BDD
+- \u53EA\u8F93\u51FA\u7B54\u6848\u672C\u8EAB\uFF0C\u4E0D\u8981\u8F93\u51FA\u601D\u8003\u8FC7\u7A0B\u6216\u5206\u6790
+- \u4E0D\u8981\u53D1\u8D77\u540E\u7EED\u5BF9\u8BDD
+- \u4F7F\u7528\u4E2D\u6587\u56DE\u590D
+
+## \u7528\u6237\u95EE\u9898
+$ARGUMENTS`;
+
 // src/features/builtin-commands/commands.ts
 var BUILTIN_COMMAND_DEFINITIONS = {
   "init-deep": {
@@ -47346,6 +47778,17 @@ Timestamp: $TIMESTAMP
 $ARGUMENTS
 </user-request>`,
     argumentHint: "[plan-name]"
+  },
+  btw: {
+    description: "(builtin) \u6781\u5EA6\u7CBE\u7B80\u4FA7\u8FB9\u63D0\u95EE \u2014 \u5F02\u6B65\u6267\u884C\uFF0C\u4E0D\u963B\u585E\u4E3B\u5BF9\u8BDD",
+    template: `<command-instruction>
+${BTW_TEMPLATE}
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`,
+    argumentHint: "<\u4F60\u7684\u95EE\u9898>"
   }
 };
 function loadBuiltinCommands(disabledCommands) {
@@ -47361,18 +47804,18 @@ function loadBuiltinCommands(disabledCommands) {
 }
 // src/tools/slashcommand/tools.ts
 function discoverCommandsFromDir2(commandsDir, scope) {
-  if (!existsSync48(commandsDir)) {
+  if (!existsSync49(commandsDir)) {
     return [];
   }
-  const entries = readdirSync14(commandsDir, { withFileTypes: true });
+  const entries = readdirSync15(commandsDir, { withFileTypes: true });
   const commands2 = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join59(commandsDir, entry.name);
+    const commandPath = join60(commandsDir, entry.name);
     const commandName = basename4(entry.name, ".md");
     try {
-      const content = readFileSync34(commandPath, "utf-8");
+      const content = readFileSync36(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -47398,10 +47841,10 @@ function discoverCommandsFromDir2(commandsDir, scope) {
 }
 function discoverCommandsSync() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const userCommandsDir = join59(getClaudeConfigDir(), "commands");
-  const projectCommandsDir = join59(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join59(configDir, "command");
-  const opencodeProjectDir = join59(process.cwd(), ".opencode", "command");
+  const userCommandsDir = join60(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join60(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join60(configDir, "command");
+  const opencodeProjectDir = join60(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir2(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir2(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir2(projectCommandsDir, "project");
@@ -47473,7 +47916,7 @@ async function formatLoadedCommand(cmd) {
   if (!content && cmd.lazyContentLoader) {
     content = await cmd.lazyContentLoader.load();
   }
-  const commandDir = cmd.path ? dirname12(cmd.path) : process.cwd();
+  const commandDir = cmd.path ? dirname13(cmd.path) : process.cwd();
   const withFileRefs = await resolveFileReferencesInText(content, commandDir);
   const resolvedContent = await resolveCommandsInText(withFileRefs);
   sections.push(resolvedContent.trim());
@@ -47578,13 +48021,13 @@ var slashcommand = createSlashcommandTool();
 // src/tools/session-manager/constants.ts
 init_data_path();
 init_shared();
-import { join as join60 } from "path";
+import { join as join61 } from "path";
 var OPENCODE_STORAGE11 = getOpenCodeStorageDir();
-var MESSAGE_STORAGE4 = join60(OPENCODE_STORAGE11, "message");
-var PART_STORAGE4 = join60(OPENCODE_STORAGE11, "part");
-var SESSION_STORAGE = join60(OPENCODE_STORAGE11, "session");
-var TODO_DIR2 = join60(getClaudeConfigDir(), "todos");
-var TRANSCRIPT_DIR2 = join60(getClaudeConfigDir(), "transcripts");
+var MESSAGE_STORAGE4 = join61(OPENCODE_STORAGE11, "message");
+var PART_STORAGE4 = join61(OPENCODE_STORAGE11, "part");
+var SESSION_STORAGE = join61(OPENCODE_STORAGE11, "session");
+var TODO_DIR2 = join61(getClaudeConfigDir(), "todos");
+var TRANSCRIPT_DIR2 = join61(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
@@ -47657,11 +48100,11 @@ Has Todos: Yes (12 items, 8 completed)
 Has Transcript: Yes (234 entries)`;
 
 // src/tools/session-manager/storage.ts
-import { existsSync as existsSync49, readdirSync as readdirSync15 } from "fs";
+import { existsSync as existsSync50, readdirSync as readdirSync16 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { join as join61 } from "path";
+import { join as join62 } from "path";
 async function getMainSessions(options) {
-  if (!existsSync49(SESSION_STORAGE))
+  if (!existsSync50(SESSION_STORAGE))
     return [];
   const sessions = [];
   try {
@@ -47669,13 +48112,13 @@ async function getMainSessions(options) {
     for (const projectDir of projectDirs) {
       if (!projectDir.isDirectory())
         continue;
-      const projectPath = join61(SESSION_STORAGE, projectDir.name);
+      const projectPath = join62(SESSION_STORAGE, projectDir.name);
       const sessionFiles = await readdir(projectPath);
       for (const file2 of sessionFiles) {
         if (!file2.endsWith(".json"))
           continue;
         try {
-          const content = await readFile(join61(projectPath, file2), "utf-8");
+          const content = await readFile(join62(projectPath, file2), "utf-8");
           const meta = JSON.parse(content);
           if (meta.parentID)
             continue;
@@ -47693,7 +48136,7 @@ async function getMainSessions(options) {
   return sessions.sort((a, b) => b.time.updated - a.time.updated);
 }
 async function getAllSessions() {
-  if (!existsSync49(MESSAGE_STORAGE4))
+  if (!existsSync50(MESSAGE_STORAGE4))
     return [];
   const sessions = [];
   async function scanDirectory(dir) {
@@ -47701,7 +48144,7 @@ async function getAllSessions() {
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const sessionPath = join61(dir, entry.name);
+          const sessionPath = join62(dir, entry.name);
           const files = await readdir(sessionPath);
           if (files.some((f) => f.endsWith(".json"))) {
             sessions.push(entry.name);
@@ -47718,16 +48161,16 @@ async function getAllSessions() {
   return [...new Set(sessions)];
 }
 function getMessageDir6(sessionID) {
-  if (!existsSync49(MESSAGE_STORAGE4))
+  if (!existsSync50(MESSAGE_STORAGE4))
     return "";
-  const directPath = join61(MESSAGE_STORAGE4, sessionID);
-  if (existsSync49(directPath)) {
+  const directPath = join62(MESSAGE_STORAGE4, sessionID);
+  if (existsSync50(directPath)) {
     return directPath;
   }
   try {
-    for (const dir of readdirSync15(MESSAGE_STORAGE4)) {
-      const sessionPath = join61(MESSAGE_STORAGE4, dir, sessionID);
-      if (existsSync49(sessionPath)) {
+    for (const dir of readdirSync16(MESSAGE_STORAGE4)) {
+      const sessionPath = join62(MESSAGE_STORAGE4, dir, sessionID);
+      if (existsSync50(sessionPath)) {
         return sessionPath;
       }
     }
@@ -47741,7 +48184,7 @@ function sessionExists(sessionID) {
 }
 async function readSessionMessages(sessionID) {
   const messageDir = getMessageDir6(sessionID);
-  if (!messageDir || !existsSync49(messageDir))
+  if (!messageDir || !existsSync50(messageDir))
     return [];
   const messages = [];
   try {
@@ -47750,7 +48193,7 @@ async function readSessionMessages(sessionID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join61(messageDir, file2), "utf-8");
+        const content = await readFile(join62(messageDir, file2), "utf-8");
         const meta = JSON.parse(content);
         const parts = await readParts2(meta.id);
         messages.push({
@@ -47776,8 +48219,8 @@ async function readSessionMessages(sessionID) {
   });
 }
 async function readParts2(messageID) {
-  const partDir = join61(PART_STORAGE4, messageID);
-  if (!existsSync49(partDir))
+  const partDir = join62(PART_STORAGE4, messageID);
+  if (!existsSync50(partDir))
     return [];
   const parts = [];
   try {
@@ -47786,7 +48229,7 @@ async function readParts2(messageID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join61(partDir, file2), "utf-8");
+        const content = await readFile(join62(partDir, file2), "utf-8");
         parts.push(JSON.parse(content));
       } catch {
         continue;
@@ -47798,14 +48241,14 @@ async function readParts2(messageID) {
   return parts.sort((a, b) => a.id.localeCompare(b.id));
 }
 async function readSessionTodos(sessionID) {
-  if (!existsSync49(TODO_DIR2))
+  if (!existsSync50(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(join61(TODO_DIR2, file2), "utf-8");
+        const content = await readFile(join62(TODO_DIR2, file2), "utf-8");
         const data = JSON.parse(content);
         if (Array.isArray(data)) {
           return data.map((item) => ({
@@ -47825,10 +48268,10 @@ async function readSessionTodos(sessionID) {
   return [];
 }
 async function readSessionTranscript(sessionID) {
-  if (!existsSync49(TRANSCRIPT_DIR2))
+  if (!existsSync50(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join61(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync49(transcriptFile))
+  const transcriptFile = join62(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  if (!existsSync50(transcriptFile))
     return 0;
   try {
     const content = await readFile(transcriptFile, "utf-8");
@@ -48324,7 +48767,7 @@ var TOOL_DESCRIPTION_PREFIX2 = `\u52A0\u8F7D skill \u4EE5\u83B7\u53D6\u7279\u5B9
 Skills \u63D0\u4F9B\u4E13\u4E1A\u77E5\u8BC6\u548C\u5206\u6B65\u6307\u5BFC\u3002
 \u5F53\u4EFB\u52A1\u4E0E\u53EF\u7528 skill \u7684\u63CF\u8FF0\u76F8\u5339\u914D\u65F6\u4F7F\u7528\u6B64\u5DE5\u5177\u3002`;
 // src/tools/skill/tools.ts
-import { dirname as dirname13 } from "path";
+import { dirname as dirname14 } from "path";
 function loadedSkillToInfo(skill) {
   return {
     name: skill.name,
@@ -48478,7 +48921,7 @@ function createSkillTool(options = {}) {
       if (args.name === "git-master") {
         body = injectGitMasterConfig(body, options.gitMasterConfig);
       }
-      const dir = skill.path ? dirname13(skill.path) : skill.resolvedPath || process.cwd();
+      const dir = skill.path ? dirname14(skill.path) : skill.resolvedPath || process.cwd();
       const output = [
         `## Skill: ${skill.name}`,
         "",
@@ -49035,20 +49478,20 @@ 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 existsSync50, readdirSync as readdirSync16 } from "fs";
-import { join as join62 } from "path";
+import { existsSync as existsSync51, readdirSync as readdirSync17 } from "fs";
+import { join as join63 } from "path";
 init_shared();
 init_agent_display_names();
 init_session_cursor();
 function getMessageDir7(sessionID) {
-  if (!existsSync50(MESSAGE_STORAGE))
+  if (!existsSync51(MESSAGE_STORAGE))
     return null;
-  const directPath = join62(MESSAGE_STORAGE, sessionID);
-  if (existsSync50(directPath))
+  const directPath = join63(MESSAGE_STORAGE, sessionID);
+  if (existsSync51(directPath))
     return directPath;
-  for (const dir of readdirSync16(MESSAGE_STORAGE)) {
-    const sessionPath = join62(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync50(sessionPath))
+  for (const dir of readdirSync17(MESSAGE_STORAGE)) {
+    const sessionPath = join63(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync51(sessionPath))
       return sessionPath;
   }
   return null;
@@ -49474,8 +49917,8 @@ function createLookAt(ctx) {
 }
 // src/tools/delegate-task/tools.ts
 init_constants();
-import { existsSync as existsSync51, readdirSync as readdirSync17 } from "fs";
-import { join as join63 } from "path";
+import { existsSync as existsSync52, readdirSync as readdirSync18 } from "fs";
+import { join as join64 } from "path";
 
 // src/features/task-toast-manager/manager.ts
 class TaskToastManager {
@@ -49681,14 +50124,14 @@ function parseFallbackModelEntries(entries) {
   });
 }
 function getMessageDir8(sessionID) {
-  if (!existsSync51(MESSAGE_STORAGE))
+  if (!existsSync52(MESSAGE_STORAGE))
     return null;
-  const directPath = join63(MESSAGE_STORAGE, sessionID);
-  if (existsSync51(directPath))
+  const directPath = join64(MESSAGE_STORAGE, sessionID);
+  if (existsSync52(directPath))
     return directPath;
-  for (const dir of readdirSync17(MESSAGE_STORAGE)) {
-    const sessionPath = join63(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync51(sessionPath))
+  for (const dir of readdirSync18(MESSAGE_STORAGE)) {
+    const sessionPath = join64(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync52(sessionPath))
       return sessionPath;
   }
   return null;
@@ -50481,6 +50924,44 @@ ${classification.shouldFallback ? "\uD83D\uDCA1 \u6B64\u9519\u8BEF\u7B26\u5408 r
 
 // src/tools/delegate-task/index.ts
 init_constants();
+// src/tools/btw/constants.ts
+var BTW_TOOL_DESCRIPTION = `
+\u5411 BTW \u987E\u95EE\uFF08\u53EA\u8BFB\u8F7B\u91CF Agent\uFF09\u63D0\u51FA\u4E00\u4E2A\u5FEB\u901F\u95EE\u9898\u3002
+\u5F02\u6B65\u6267\u884C\uFF0C\u4E0D\u963B\u585E\u4E3B\u5BF9\u8BDD\u2014\u2014\u5B8C\u6210\u540E\u901A\u8FC7\u7CFB\u7EDF\u901A\u77E5\u81EA\u52A8\u544A\u77E5\u3002
+\u9002\u7528\u4E8E\u4EE3\u7801\u5206\u6790\u3001\u6982\u5FF5\u6F84\u6E05\u3001\u6A21\u5F0F\u5EFA\u8BAE\u7B49\u8F7B\u91CF\u67E5\u8BE2\u3002
+BTW \u987E\u95EE\u65E0\u5199\u6743\u9650\uFF0C\u4E0D\u53EF\u4FEE\u6539\u6587\u4EF6\u6216\u6267\u884C\u547D\u4EE4\u3002
+`.trim();
+
+// src/tools/btw/tools.ts
+function createBtwTool(ctx, backgroundManager) {
+  return tool({
+    description: BTW_TOOL_DESCRIPTION,
+    args: {
+      question: tool.schema.string().describe("\u8981\u8BE2\u95EE BTW \u987E\u95EE\u7684\u95EE\u9898")
+    },
+    async execute(args, toolContext) {
+      const parentSessionID = toolContext.sessionID;
+      const parentSession = await ctx.client.session.get({
+        path: { id: parentSessionID }
+      });
+      const parentDirectory = parentSession?.data?.directory ?? ctx.directory;
+      const btwPrompt = `\u4F60\u662F\u4E00\u4E2A\u8F7B\u91CF\u53EA\u8BFB\u987E\u95EE\uFF08BTW \u987E\u95EE\uFF09\u3002
+\u8BF7\u6781\u5EA6\u7CBE\u7B80\u5730\u56DE\u7B54\u4EE5\u4E0B\u95EE\u9898\uFF0C\u63A7\u5236\u5728 100 \u5B57\u4EE5\u5185\uFF0C1-3 \u53E5\u8BDD\u3002
+\u53EA\u8F93\u51FA\u7B54\u6848\uFF0C\u4E0D\u8981\u8F93\u51FA reasoning \u6216\u601D\u8003\u8FC7\u7A0B\u3002
+
+\u95EE\u9898\uFF1A${args.question}`;
+      const task = await backgroundManager.launch({
+        description: `BTW: ${args.question.substring(0, 50)}`,
+        prompt: btwPrompt,
+        agent: "BTW \u987E\u95EE",
+        parentSessionID,
+        parentMessageID: toolContext.messageID
+      });
+      return `> **BTW**\uFF1A\u6B63\u5728\u67E5\u8BE2\u300C${args.question.substring(0, 30)}${args.question.length > 30 ? "..." : ""}\u300D
+\u5B8C\u6210\u540E\u5C06\u901A\u8FC7\u7CFB\u7EDF\u901A\u77E5\u81EA\u52A8\u544A\u77E5\u3002\u53EF\u7528 \`background_output("${task.id}")\` \u67E5\u770B\u7ED3\u679C\u3002`;
+    }
+  });
+}
 // src/tools/index.ts
 function createBackgroundTools(manager, client2) {
   return {
@@ -50666,8 +51147,8 @@ class PerformanceAggregator {
 }
 
 // src/features/background-agent/manager.ts
-import { existsSync as existsSync52, readdirSync as readdirSync18 } from "fs";
-import { join as join64 } from "path";
+import { existsSync as existsSync53, readdirSync as readdirSync19 } from "fs";
+import { join as join65 } from "path";
 var TASK_TTL_MS = 30 * 60 * 1000;
 var MIN_STABILITY_TIME_MS = 10 * 1000;
 var DEFAULT_STALE_TIMEOUT_MS = 120000;
@@ -51841,14 +52322,14 @@ function registerProcessSignal(signal, handler, exitAfter) {
   return listener;
 }
 function getMessageDir9(sessionID) {
-  if (!existsSync52(MESSAGE_STORAGE))
+  if (!existsSync53(MESSAGE_STORAGE))
     return null;
-  const directPath = join64(MESSAGE_STORAGE, sessionID);
-  if (existsSync52(directPath))
+  const directPath = join65(MESSAGE_STORAGE, sessionID);
+  if (existsSync53(directPath))
     return directPath;
-  for (const dir of readdirSync18(MESSAGE_STORAGE)) {
-    const sessionPath = join64(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync52(sessionPath))
+  for (const dir of readdirSync19(MESSAGE_STORAGE)) {
+    const sessionPath = join65(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync53(sessionPath))
       return sessionPath;
   }
   return null;
@@ -70522,7 +71003,8 @@ var BuiltinAgentNameSchema = exports_external2.enum([
   "\u5A92\u4F53\u89E3\u6790",
   "\u9884\u5BA1\u987E\u95EE",
   "\u8BA1\u5212\u5BA1\u67E5",
-  "\u4EFB\u52A1\u7F16\u6392"
+  "\u4EFB\u52A1\u7F16\u6392",
+  "BTW \u987E\u95EE"
 ]);
 var BuiltinSkillNameSchema = exports_external2.enum([
   "playwright",
@@ -70542,7 +71024,8 @@ var OverridableAgentNameSchema = exports_external2.enum([
   "\u77E5\u8BC6\u5178\u85CF",
   "\u6DF1\u5EA6\u63A2\u7D22",
   "\u5A92\u4F53\u89E3\u6790",
-  "\u4EFB\u52A1\u7F16\u6392"
+  "\u4EFB\u52A1\u7F16\u6392",
+  "BTW \u987E\u95EE"
 ]);
 var HookNameSchema = exports_external2.enum([
   "todo-continuation-enforcer",
@@ -70583,11 +71066,13 @@ var HookNameSchema = exports_external2.enum([
   "tool-definition-optimizer",
   "permission-ask-bridge",
   "shell-env-injector",
-  "dispose-coordinator"
+  "dispose-coordinator",
+  "plan-completion"
 ]);
 var BuiltinCommandNameSchema = exports_external2.enum([
   "init-deep",
-  "start-work"
+  "start-work",
+  "btw"
 ]);
 var ProviderModelStringSchema = exports_external2.string().refine((value) => {
   const separatorIndex = value.indexOf("/");
@@ -70636,7 +71121,8 @@ var AgentOverridesSchema = exports_external2.object({
   "\u77E5\u8BC6\u5178\u85CF": AgentOverrideConfigSchema.optional(),
   "\u6DF1\u5EA6\u63A2\u7D22": AgentOverrideConfigSchema.optional(),
   "\u5A92\u4F53\u89E3\u6790": AgentOverrideConfigSchema.optional(),
-  "\u4EFB\u52A1\u7F16\u6392": AgentOverrideConfigSchema.optional()
+  "\u4EFB\u52A1\u7F16\u6392": AgentOverrideConfigSchema.optional(),
+  "BTW \u987E\u95EE": AgentOverrideConfigSchema.optional()
 });
 var ClaudeCodeConfigSchema = exports_external2.object({
   mcp: exports_external2.boolean().optional(),
@@ -71068,7 +71554,7 @@ init_file_utils();
 init_shared();
 init_logger();
 import { promises as fs11 } from "fs";
-import { join as join66, basename as basename6 } from "path";
+import { join as join67, basename as basename6 } from "path";
 async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "") {
   try {
     await fs11.access(commandsDir);
@@ -71098,7 +71584,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     if (entry.isDirectory()) {
       if (entry.name.startsWith("."))
         continue;
-      const subDirPath = join66(commandsDir, entry.name);
+      const subDirPath = join67(commandsDir, entry.name);
       const subPrefix = prefix ? `${prefix}:${entry.name}` : entry.name;
       const subCommands = await loadCommandsFromDir(subDirPath, scope, visited, subPrefix);
       commands2.push(...subCommands);
@@ -71106,7 +71592,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     }
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join66(commandsDir, entry.name);
+    const commandPath = join67(commandsDir, entry.name);
     const baseCommandName = basename6(entry.name, ".md");
     const commandName = prefix ? `${prefix}:${baseCommandName}` : baseCommandName;
     try {
@@ -71153,23 +71639,23 @@ function commandsToRecord(commands2) {
   return result;
 }
 async function loadUserCommands() {
-  const userCommandsDir = join66(getClaudeConfigDir(), "commands");
+  const userCommandsDir = join67(getClaudeConfigDir(), "commands");
   const commands2 = await loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands2);
 }
 async function loadProjectCommands() {
-  const projectCommandsDir = join66(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join67(process.cwd(), ".claude", "commands");
   const commands2 = await loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands2);
 }
 async function loadOpencodeGlobalCommands() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeCommandsDir = join66(configDir, "command");
+  const opencodeCommandsDir = join67(configDir, "command");
   const commands2 = await loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands2);
 }
 async function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join66(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join67(process.cwd(), ".opencode", "command");
   const commands2 = await loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands2);
 }
@@ -71177,8 +71663,8 @@ async function loadOpencodeProjectCommands() {
 init_frontmatter();
 init_file_utils();
 init_shared();
-import { existsSync as existsSync54, readdirSync as readdirSync19, readFileSync as readFileSync36 } from "fs";
-import { join as join67, basename as basename7 } from "path";
+import { existsSync as existsSync55, readdirSync as readdirSync20, readFileSync as readFileSync38 } from "fs";
+import { join as join68, basename as basename7 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -71192,18 +71678,18 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync54(agentsDir)) {
+  if (!existsSync55(agentsDir)) {
     return [];
   }
-  const entries = readdirSync19(agentsDir, { withFileTypes: true });
+  const entries = readdirSync20(agentsDir, { withFileTypes: true });
   const agents = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join67(agentsDir, entry.name);
+    const agentPath = join68(agentsDir, entry.name);
     const agentName = basename7(entry.name, ".md");
     try {
-      const content = readFileSync36(agentPath, "utf-8");
+      const content = readFileSync38(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -71232,7 +71718,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join67(getClaudeConfigDir(), "agents");
+  const userAgentsDir = join68(getClaudeConfigDir(), "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -71241,7 +71727,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents() {
-  const projectAgentsDir = join67(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join68(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -71253,18 +71739,18 @@ function loadProjectAgents() {
 init_frontmatter();
 init_file_utils();
 init_logger();
-import { existsSync as existsSync55, readdirSync as readdirSync20, readFileSync as readFileSync37 } from "fs";
+import { existsSync as existsSync56, readdirSync as readdirSync21, readFileSync as readFileSync39 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join68, basename as basename8 } from "path";
+import { join as join69, 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 join68(homedir14(), ".claude", "plugins");
+  return join69(homedir14(), ".claude", "plugins");
 }
 function getInstalledPluginsPath() {
-  return join68(getPluginsBaseDir(), "installed_plugins.json");
+  return join69(getPluginsBaseDir(), "installed_plugins.json");
 }
 function resolvePluginPath(path8, pluginRoot) {
   return path8.replace(CLAUDE_PLUGIN_ROOT_VAR, pluginRoot);
@@ -71289,11 +71775,11 @@ function resolvePluginPaths(obj, pluginRoot) {
 }
 function loadInstalledPlugins() {
   const dbPath = getInstalledPluginsPath();
-  if (!existsSync55(dbPath)) {
+  if (!existsSync56(dbPath)) {
     return null;
   }
   try {
-    const content = readFileSync37(dbPath, "utf-8");
+    const content = readFileSync39(dbPath, "utf-8");
     return JSON.parse(content);
   } catch (error95) {
     log("Failed to load installed plugins database", error95);
@@ -71304,15 +71790,15 @@ function getClaudeSettingsPath() {
   if (process.env.CLAUDE_SETTINGS_PATH) {
     return process.env.CLAUDE_SETTINGS_PATH;
   }
-  return join68(homedir14(), ".claude", "settings.json");
+  return join69(homedir14(), ".claude", "settings.json");
 }
 function loadClaudeSettings() {
   const settingsPath = getClaudeSettingsPath();
-  if (!existsSync55(settingsPath)) {
+  if (!existsSync56(settingsPath)) {
     return null;
   }
   try {
-    const content = readFileSync37(settingsPath, "utf-8");
+    const content = readFileSync39(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch (error95) {
     log("Failed to load Claude settings", error95);
@@ -71320,12 +71806,12 @@ function loadClaudeSettings() {
   }
 }
 function loadPluginManifest(installPath) {
-  const manifestPath = join68(installPath, ".claude-plugin", "plugin.json");
-  if (!existsSync55(manifestPath)) {
+  const manifestPath = join69(installPath, ".claude-plugin", "plugin.json");
+  if (!existsSync56(manifestPath)) {
     return null;
   }
   try {
-    const content = readFileSync37(manifestPath, "utf-8");
+    const content = readFileSync39(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error95) {
     log(`Failed to load plugin manifest from ${manifestPath}`, error95);
@@ -71372,7 +71858,7 @@ function discoverInstalledPlugins(options) {
       continue;
     }
     const { installPath, scope, version: version3 } = installation;
-    if (!existsSync55(installPath)) {
+    if (!existsSync56(installPath)) {
       errors5.push({
         pluginKey,
         installPath,
@@ -71390,21 +71876,21 @@ function discoverInstalledPlugins(options) {
       pluginKey,
       manifest: manifest ?? undefined
     };
-    if (existsSync55(join68(installPath, "commands"))) {
-      loadedPlugin.commandsDir = join68(installPath, "commands");
+    if (existsSync56(join69(installPath, "commands"))) {
+      loadedPlugin.commandsDir = join69(installPath, "commands");
     }
-    if (existsSync55(join68(installPath, "agents"))) {
-      loadedPlugin.agentsDir = join68(installPath, "agents");
+    if (existsSync56(join69(installPath, "agents"))) {
+      loadedPlugin.agentsDir = join69(installPath, "agents");
     }
-    if (existsSync55(join68(installPath, "skills"))) {
-      loadedPlugin.skillsDir = join68(installPath, "skills");
+    if (existsSync56(join69(installPath, "skills"))) {
+      loadedPlugin.skillsDir = join69(installPath, "skills");
     }
-    const hooksPath = join68(installPath, "hooks", "hooks.json");
-    if (existsSync55(hooksPath)) {
+    const hooksPath = join69(installPath, "hooks", "hooks.json");
+    if (existsSync56(hooksPath)) {
       loadedPlugin.hooksPath = hooksPath;
     }
-    const mcpPath = join68(installPath, ".mcp.json");
-    if (existsSync55(mcpPath)) {
+    const mcpPath = join69(installPath, ".mcp.json");
+    if (existsSync56(mcpPath)) {
       loadedPlugin.mcpPath = mcpPath;
     }
     plugins.push(loadedPlugin);
@@ -71415,17 +71901,17 @@ function discoverInstalledPlugins(options) {
 function loadPluginCommands(plugins) {
   const commands2 = {};
   for (const plugin of plugins) {
-    if (!plugin.commandsDir || !existsSync55(plugin.commandsDir))
+    if (!plugin.commandsDir || !existsSync56(plugin.commandsDir))
       continue;
-    const entries = readdirSync20(plugin.commandsDir, { withFileTypes: true });
+    const entries = readdirSync21(plugin.commandsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const commandPath = join68(plugin.commandsDir, entry.name);
+      const commandPath = join69(plugin.commandsDir, entry.name);
       const commandName = basename8(entry.name, ".md");
       const namespacedName = `${plugin.name}:${commandName}`;
       try {
-        const content = readFileSync37(commandPath, "utf-8");
+        const content = readFileSync39(commandPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -71457,21 +71943,21 @@ $ARGUMENTS
 function loadPluginSkillsAsCommands(plugins) {
   const skills = {};
   for (const plugin of plugins) {
-    if (!plugin.skillsDir || !existsSync55(plugin.skillsDir))
+    if (!plugin.skillsDir || !existsSync56(plugin.skillsDir))
       continue;
-    const entries = readdirSync20(plugin.skillsDir, { withFileTypes: true });
+    const entries = readdirSync21(plugin.skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith("."))
         continue;
-      const skillPath = join68(plugin.skillsDir, entry.name);
+      const skillPath = join69(plugin.skillsDir, entry.name);
       if (!entry.isDirectory() && !entry.isSymbolicLink())
         continue;
       const resolvedPath = resolveSymlink(skillPath);
-      const skillMdPath = join68(resolvedPath, "SKILL.md");
-      if (!existsSync55(skillMdPath))
+      const skillMdPath = join69(resolvedPath, "SKILL.md");
+      if (!existsSync56(skillMdPath))
         continue;
       try {
-        const content = readFileSync37(skillMdPath, "utf-8");
+        const content = readFileSync39(skillMdPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const skillName = data.name || entry.name;
         const namespacedName = `${plugin.name}:${skillName}`;
@@ -71518,17 +72004,17 @@ function parseToolsConfig2(toolsStr) {
 function loadPluginAgents(plugins) {
   const agents = {};
   for (const plugin of plugins) {
-    if (!plugin.agentsDir || !existsSync55(plugin.agentsDir))
+    if (!plugin.agentsDir || !existsSync56(plugin.agentsDir))
       continue;
-    const entries = readdirSync20(plugin.agentsDir, { withFileTypes: true });
+    const entries = readdirSync21(plugin.agentsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const agentPath = join68(plugin.agentsDir, entry.name);
+      const agentPath = join69(plugin.agentsDir, entry.name);
       const agentName = basename8(entry.name, ".md");
       const namespacedName = `${plugin.name}:${agentName}`;
       try {
-        const content = readFileSync37(agentPath, "utf-8");
+        const content = readFileSync39(agentPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const name = data.name || agentName;
         const originalDescription = data.description || "";
@@ -71554,7 +72040,7 @@ function loadPluginAgents(plugins) {
 async function loadPluginMcpServers(plugins) {
   const servers = {};
   for (const plugin of plugins) {
-    if (!plugin.mcpPath || !existsSync55(plugin.mcpPath))
+    if (!plugin.mcpPath || !existsSync56(plugin.mcpPath))
       continue;
     try {
       const content = await Bun.file(plugin.mcpPath).text();
@@ -71586,10 +72072,10 @@ async function loadPluginMcpServers(plugins) {
 function loadPluginHooksConfigs(plugins) {
   const configs = [];
   for (const plugin of plugins) {
-    if (!plugin.hooksPath || !existsSync55(plugin.hooksPath))
+    if (!plugin.hooksPath || !existsSync56(plugin.hooksPath))
       continue;
     try {
-      const content = readFileSync37(plugin.hooksPath, "utf-8");
+      const content = readFileSync39(plugin.hooksPath, "utf-8");
       let config4 = JSON.parse(content);
       config4 = resolvePluginPaths(config4, plugin.installPath);
       configs.push(config4);
@@ -73336,6 +73822,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const toolDefOptimizer = isHookEnabled("tool-definition-optimizer") ? createToolDefinitionOptimizerHook(ctx) : null;
   const permissionAskBridge = isHookEnabled("permission-ask-bridge") ? createPermissionAskBridgeHook(ctx) : null;
   const shellEnvInjector = isHookEnabled("shell-env-injector") ? createShellEnvInjectorHook(ctx) : null;
+  const planCompletionHook = isHookEnabled("plan-completion") ? createPlanCompletionHook(ctx) : null;
   initTaskToastManager(ctx.client);
   const todoContinuationEnforcer = isHookEnabled("todo-continuation-enforcer") ? createTodoContinuationEnforcer(ctx, { backgroundManager, ralphLoopHook: ralphLoop ?? undefined }) : null;
   if (sessionRecovery && todoContinuationEnforcer) {
@@ -73345,6 +73832,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const backgroundNotificationHook = isHookEnabled("background-notification") ? createBackgroundNotificationHook(backgroundManager) : null;
   const backgroundTools = createBackgroundTools(backgroundManager, ctx.client);
   const callOmoAgent = createCallOmoAgent(ctx, backgroundManager);
+  const btwTool = createBtwTool(ctx, backgroundManager);
   const isMultimodalLookerEnabled = !includesCaseInsensitive(pluginConfig.disabled_agents ?? [], "multimodal-looker");
   const lookAt = isMultimodalLookerEnabled ? createLookAt(ctx) : null;
   const delegateTask = createDelegateTask({
@@ -73430,6 +73918,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       call_omo_agent: callOmoAgent,
       ...lookAt ? { look_at: lookAt } : {},
       delegate_task: delegateTask,
+      btw: btwTool,
       skill: skillTool,
       skill_mcp: skillMcpTool,
       slashcommand: slashcommandTool,