@skj1724/oh-my-opencode 3.23.3 → 3.23.5

package/dist/index.js

@@ -46,6 +46,59 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/features/claude-code-session-state/state.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+function setMainSession(id) {
+  _mainSessionID = id;
+}
+function getMainSessionID() {
+  return _mainSessionID;
+}
+function updateSessionAgent(sessionID, agent, source = "unknown") {
+  sessionAgentMap.set(sessionID, agent);
+  sessionAgentMetaMap.set(sessionID, { updatedAt: Date.now(), source });
+}
+function getSessionAgent(sessionID) {
+  return sessionAgentMap.get(sessionID);
+}
+function isSessionAgentStale(sessionID, staleThresholdMs) {
+  const meta = sessionAgentMetaMap.get(sessionID);
+  if (!meta)
+    return false;
+  return Date.now() - meta.updatedAt > staleThresholdMs;
+}
+function clearSessionAgent(sessionID) {
+  sessionAgentMap.delete(sessionID);
+  sessionAgentMetaMap.delete(sessionID);
+}
+function loadSessionAgentMap(directory) {
+  try {
+    const persistPath = join(directory, ".opencode", "session-agent-map.json");
+    if (!existsSync(persistPath))
+      return;
+    const content = readFileSync(persistPath, "utf-8");
+    const data = JSON.parse(content);
+    for (const [sessionID, entry] of Object.entries(data)) {
+      if (!sessionAgentMap.has(sessionID)) {
+        sessionAgentMap.set(sessionID, entry.agent);
+        sessionAgentMetaMap.set(sessionID, { updatedAt: entry.updatedAt, source: entry.source });
+      }
+    }
+  } catch {}
+}
+var subagentSessions, _mainSessionID, sessionAgentMap, sessionAgentMetaMap;
+var init_state = __esm(() => {
+  subagentSessions = new Set;
+  sessionAgentMap = new Map;
+  sessionAgentMetaMap = new Map;
+});
+
+// src/features/claude-code-session-state/index.ts
+var init_claude_code_session_state = __esm(() => {
+  init_state();
+});
+
 // src/shared/agent-display-names.ts
 function getAgentDisplayName(configKey) {
   const exactMatch = AGENT_DISPLAY_TO_KEY[configKey];
@@ -135,7 +188,7 @@ var init_agent_display_names = __esm(() => {
 });
 
 // src/shared/fileio-monitor.ts
-import { readdirSync, readFileSync, writeFileSync, existsSync } from "fs";
+import { readdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
 import { relative } from "path";
 import { cwd } from "process";
 function summarize(path) {
@@ -172,11 +225,11 @@ function createFileIOMonitor(tracer) {
     },
     readFileSync(path, options) {
       if (!tracer.isEnabled()) {
-        return readFileSync(path, options);
+        return readFileSync2(path, options);
       }
       const start = performance.now();
       try {
-        return readFileSync(path, options);
+        return readFileSync2(path, options);
       } finally {
         const durationMs = performance.now() - start;
         tracer.recordFileIO("readFileSync", summarize(path), durationMs);
@@ -184,12 +237,12 @@ function createFileIOMonitor(tracer) {
     },
     writeFileSync(path, data, options) {
       if (!tracer.isEnabled()) {
-        writeFileSync(path, data, options);
+        writeFileSync2(path, data, options);
         return;
       }
       const start = performance.now();
       try {
-        writeFileSync(path, data, options);
+        writeFileSync2(path, data, options);
       } finally {
         const durationMs = performance.now() - start;
         tracer.recordFileIO("writeFileSync", summarize(path), durationMs);
@@ -197,11 +250,11 @@ function createFileIOMonitor(tracer) {
     },
     existsSync(path) {
       if (!tracer.isEnabled()) {
-        return existsSync(path);
+        return existsSync2(path);
       }
       const start = performance.now();
       try {
-        return existsSync(path);
+        return existsSync2(path);
       } finally {
         const durationMs = performance.now() - start;
         tracer.recordFileIO("existsSync", summarize(path), durationMs);
@@ -262,9 +315,9 @@ var init_system_directive = __esm(() => {
 });
 
 // src/shared/opencode-config-dir.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join5, resolve } from "path";
+import { join as join6, resolve } from "path";
 function isDevBuild(version) {
   if (!version)
     return false;
@@ -274,15 +327,15 @@ function getTauriConfigDir(identifier) {
   const platform = process.platform;
   switch (platform) {
     case "darwin":
-      return join5(homedir2(), "Library", "Application Support", identifier);
+      return join6(homedir2(), "Library", "Application Support", identifier);
     case "win32": {
-      const appData = process.env.APPDATA || join5(homedir2(), "AppData", "Roaming");
-      return join5(appData, identifier);
+      const appData = process.env.APPDATA || join6(homedir2(), "AppData", "Roaming");
+      return join6(appData, identifier);
     }
     case "linux":
     default: {
-      const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir2(), ".config");
-      return join5(xdgConfig, identifier);
+      const xdgConfig = process.env.XDG_CONFIG_HOME || join6(homedir2(), ".config");
+      return join6(xdgConfig, identifier);
     }
   }
 }
@@ -292,21 +345,21 @@ function getCliConfigDir() {
     return resolve(envConfigDir);
   }
   if (process.platform === "win32") {
-    const crossPlatformDir = join5(homedir2(), ".config", "opencode");
-    const crossPlatformConfig = join5(crossPlatformDir, "opencode.json");
-    if (existsSync3(crossPlatformConfig)) {
+    const crossPlatformDir = join6(homedir2(), ".config", "opencode");
+    const crossPlatformConfig = join6(crossPlatformDir, "opencode.json");
+    if (existsSync4(crossPlatformConfig)) {
       return crossPlatformDir;
     }
-    const appData = process.env.APPDATA || join5(homedir2(), "AppData", "Roaming");
-    const appdataDir = join5(appData, "opencode");
-    const appdataConfig = join5(appdataDir, "opencode.json");
-    if (existsSync3(appdataConfig)) {
+    const appData = process.env.APPDATA || join6(homedir2(), "AppData", "Roaming");
+    const appdataDir = join6(appData, "opencode");
+    const appdataConfig = join6(appdataDir, "opencode.json");
+    if (existsSync4(appdataConfig)) {
       return appdataDir;
     }
     return crossPlatformDir;
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir2(), ".config");
-  return join5(xdgConfig, "opencode");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join6(homedir2(), ".config");
+  return join6(xdgConfig, "opencode");
 }
 function getOpenCodeConfigDir(options) {
   const { binary, version, checkExisting = true } = options;
@@ -317,9 +370,9 @@ function getOpenCodeConfigDir(options) {
   const tauriDir = getTauriConfigDir(identifier);
   if (checkExisting) {
     const legacyDir = getCliConfigDir();
-    const legacyConfig = join5(legacyDir, "opencode.json");
-    const legacyConfigC = join5(legacyDir, "opencode.jsonc");
-    if (existsSync3(legacyConfig) || existsSync3(legacyConfigC)) {
+    const legacyConfig = join6(legacyDir, "opencode.json");
+    const legacyConfigC = join6(legacyDir, "opencode.jsonc");
+    if (existsSync4(legacyConfig) || existsSync4(legacyConfigC)) {
       return legacyDir;
     }
   }
@@ -329,10 +382,10 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir(options);
   return {
     configDir,
-    configJson: join5(configDir, "opencode.json"),
-    configJsonc: join5(configDir, "opencode.jsonc"),
-    packageJson: join5(configDir, "package.json"),
-    omoConfig: join5(configDir, "oh-my-opencode.json")
+    configJson: join6(configDir, "opencode.json"),
+    configJsonc: join6(configDir, "opencode.jsonc"),
+    packageJson: join6(configDir, "package.json"),
+    omoConfig: join6(configDir, "oh-my-opencode.json")
   };
 }
 var TAURI_APP_IDENTIFIER = "ai.opencode.desktop", TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
@@ -1203,7 +1256,7 @@ var init_main = __esm(() => {
 });
 
 // src/shared/jsonc-parser.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 function parseJsonc(content) {
   const errors = [];
   const result = parse2(content, errors, {
@@ -1234,10 +1287,10 @@ function parseJsoncSafe(content) {
 function detectConfigFile(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
-  if (existsSync4(jsoncPath)) {
+  if (existsSync5(jsoncPath)) {
     return { format: "jsonc", path: jsoncPath };
   }
-  if (existsSync4(jsonPath)) {
+  if (existsSync5(jsonPath)) {
     return { format: "json", path: jsonPath };
   }
   return { format: "none", path: jsonPath };
@@ -3999,7 +4052,7 @@ var init_js_yaml = __esm(() => {
 });
 
 // src/shared/frontmatter.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n?---\r?\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -4018,7 +4071,7 @@ function parseFrontmatter(content) {
 }
 function parseCompletionActions(planPath) {
   try {
-    const content = readFileSync6(planPath, "utf-8");
+    const content = readFileSync7(planPath, "utf-8");
     const result = parseFrontmatter(content);
     if (!result.hadFrontmatter || result.parseError) {
       return [];
@@ -4046,17 +4099,17 @@ var init_frontmatter = __esm(() => {
 import { spawn as spawn2 } from "child_process";
 import { exec } from "child_process";
 import { promisify } from "util";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir3 } from "os";
 function getHomeDir() {
   return process.env.HOME || process.env.USERPROFILE || homedir3();
 }
 function findShellPath(defaultPaths, customPath) {
-  if (customPath && existsSync7(customPath)) {
+  if (customPath && existsSync8(customPath)) {
     return customPath;
   }
   for (const path3 of defaultPaths) {
-    if (existsSync7(path3)) {
+    if (existsSync8(path3)) {
       return path3;
     }
   }
@@ -4191,8 +4244,8 @@ var init_command_executor = __esm(() => {
 });
 
 // src/shared/file-reference-resolver.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, statSync } from "fs";
-import { join as join9, isAbsolute } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, statSync } from "fs";
+import { join as join10, isAbsolute } from "path";
 function findFileReferences(text) {
   const matches = [];
   let match;
@@ -4211,17 +4264,17 @@ function resolveFilePath(filePath, cwd2) {
   if (isAbsolute(filePath)) {
     return filePath;
   }
-  return join9(cwd2, filePath);
+  return join10(cwd2, filePath);
 }
 function readFileContent(resolvedPath) {
-  if (!existsSync8(resolvedPath)) {
+  if (!existsSync9(resolvedPath)) {
     return `[file not found: ${resolvedPath}]`;
   }
   const stat = statSync(resolvedPath);
   if (stat.isDirectory()) {
     return `[cannot read directory: ${resolvedPath}]`;
   }
-  const content = readFileSync7(resolvedPath, "utf-8");
+  const content = readFileSync8(resolvedPath, "utf-8");
   return content;
 }
 async function resolveFileReferencesInText(text, cwd2 = process.cwd(), depth = 0, maxDepth = 3) {
@@ -4542,13 +4595,13 @@ var init_config_errors = __esm(() => {
 
 // src/shared/claude-config-dir.ts
 import { homedir as homedir4 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function getClaudeConfigDir() {
   const envConfigDir = process.env.CLAUDE_CONFIG_DIR;
   if (envConfigDir) {
     return envConfigDir;
   }
-  return join10(homedir4(), ".claude");
+  return join11(homedir4(), ".claude");
 }
 var init_claude_config_dir = () => {};
 
@@ -5214,9 +5267,9 @@ var init_model_requirements = __esm(() => {
 });
 
 // src/shared/model-availability.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function normalizeModelName(name) {
   return name.toLowerCase().replace(/claude-(opus|sonnet|haiku)-4-5/g, "claude-$1-4.5").replace(/claude-(opus|sonnet|haiku)-4\.5/g, "claude-$1-4.5");
 }
@@ -5257,8 +5310,8 @@ function fuzzyMatchModel(target, available, providers) {
 function getOpenCodeCacheDir() {
   const xdgCache = process.env.XDG_CACHE_HOME;
   if (xdgCache)
-    return join12(xdgCache, "opencode");
-  return join12(homedir6(), ".cache", "opencode");
+    return join13(xdgCache, "opencode");
+  return join13(homedir6(), ".cache", "opencode");
 }
 async function fetchAvailableModels(_client) {
   log("[fetchAvailableModels] CALLED");
@@ -5267,14 +5320,14 @@ async function fetchAvailableModels(_client) {
     return cachedModels;
   }
   const modelSet = new Set;
-  const cacheFile = join12(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join13(getOpenCodeCacheDir(), "models.json");
   log("[fetchAvailableModels] reading cache file", { cacheFile });
-  if (!existsSync10(cacheFile)) {
+  if (!existsSync11(cacheFile)) {
     log("[fetchAvailableModels] cache file not found, returning empty set");
     return modelSet;
   }
   try {
-    const content = readFileSync9(cacheFile, "utf-8");
+    const content = readFileSync10(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) });
@@ -5296,8 +5349,8 @@ async function fetchAvailableModels(_client) {
   }
 }
 function isModelCacheAvailable() {
-  const cacheFile = join12(getOpenCodeCacheDir(), "models.json");
-  return existsSync10(cacheFile);
+  const cacheFile = join13(getOpenCodeCacheDir(), "models.json");
+  return existsSync11(cacheFile);
 }
 var cachedModels = null;
 var init_model_availability = __esm(() => {
@@ -5651,9 +5704,9 @@ class PerfTimer {
 }
 
 // src/shared/perf-tracer.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync4, existsSync as existsSync11 } from "fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, existsSync as existsSync12 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 
 class PerfTracer {
   buffer = [];
@@ -5664,7 +5717,7 @@ class PerfTracer {
   memorySnapshotInterval;
   constructor(config) {
     this.enabled = config.enabled;
-    this.outputDir = config.outputDir ?? join13(tmpdir2(), "oh-my-opencode-perf");
+    this.outputDir = config.outputDir ?? join14(tmpdir2(), "oh-my-opencode-perf");
     this.slowThreshold = config.slowThreshold ?? 100;
     this.memorySnapshotInterval = config.memorySnapshotInterval ?? 5;
   }
@@ -5760,11 +5813,11 @@ class PerfTracer {
   flush() {
     if (this.buffer.length === 0)
       return;
-    if (!existsSync11(this.outputDir)) {
-      mkdirSync4(this.outputDir, { recursive: true });
+    if (!existsSync12(this.outputDir)) {
+      mkdirSync5(this.outputDir, { recursive: true });
     }
     const date = new Date().toISOString().slice(0, 10);
-    const filePath = join13(this.outputDir, `${date}.jsonl`);
+    const filePath = join14(this.outputDir, `${date}.jsonl`);
     let output = "";
     for (const span of this.buffer) {
       output += JSON.stringify(span) + `
@@ -5781,10 +5834,10 @@ class PerfTracer {
 var init_perf_tracer = () => {};
 
 // src/shared/windows-reserved-names.ts
-import { existsSync as existsSync12, readdirSync as readdirSync5 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync5 } from "fs";
+import { join as join15 } from "path";
 function scanForReservedNames(directory, maxDepth = 2) {
-  if (!existsSync12(directory))
+  if (!existsSync13(directory))
     return [];
   const found = [];
   _scan(directory, 0, maxDepth, found);
@@ -5803,11 +5856,11 @@ function _scan(dir, depth, maxDepth, found) {
     const upper = name.toUpperCase();
     const baseName = upper.split(".")[0] ?? "";
     if (WIN_RESERVED_NAMES.has(upper) || WIN_RESERVED_NAMES.has(baseName)) {
-      found.push(join14(dir, name));
+      found.push(join15(dir, name));
     }
-    const fullPath = join14(dir, name);
+    const fullPath = join15(dir, name);
     try {
-      const stat = existsSync12(fullPath);
+      const stat = existsSync13(fullPath);
       if (stat && depth < maxDepth) {
         _scan(fullPath, depth + 1, maxDepth, found);
       }
@@ -5861,12 +5914,12 @@ var init_windows_reserved_names = __esm(() => {
 });
 
 // src/shared/usage-tracker.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 function getStatsFilePath() {
-  const configDir = join15(homedir7(), ".config", "opencode");
-  return join15(configDir, "usage-stats.json");
+  const configDir = join16(homedir7(), ".config", "opencode");
+  return join16(configDir, "usage-stats.json");
 }
 
 class UsageTracker {
@@ -5967,9 +6020,9 @@ class UsageTracker {
   persistToFile() {
     try {
       const filePath = getStatsFilePath();
-      const dir = join15(filePath, "..");
-      if (!existsSync13(dir)) {
-        mkdirSync5(dir, { recursive: true });
+      const dir = join16(filePath, "..");
+      if (!existsSync14(dir)) {
+        mkdirSync6(dir, { recursive: true });
       }
       const sessions = {};
       for (const [sessionID, records] of this.sessionData) {
@@ -5984,7 +6037,7 @@ class UsageTracker {
         sessions,
         lastUpdated: Date.now()
       };
-      writeFileSync6(filePath, JSON.stringify(data, null, 2), "utf-8");
+      writeFileSync7(filePath, JSON.stringify(data, null, 2), "utf-8");
     } catch (error) {
       log("UsageTracker: \u6301\u4E45\u5316\u5931\u8D25", error);
     }
@@ -5992,9 +6045,9 @@ class UsageTracker {
   loadFromDisk() {
     try {
       const filePath = getStatsFilePath();
-      if (!existsSync13(filePath))
+      if (!existsSync14(filePath))
         return;
-      const content = readFileSync10(filePath, "utf-8");
+      const content = readFileSync11(filePath, "utf-8");
       const data = JSON.parse(content);
       if (data.sessions) {
         for (const [sessionID, sessionData] of Object.entries(data.sessions)) {
@@ -6094,18 +6147,10 @@ function isLanguageEnforcementEnabled(config) {
 function stripCodeAndUrls(text) {
   return text.replace(/```[\s\S]*?```/g, "").replace(/`[^`]*`/g, "").replace(/https?:\/\/\S+/g, "").replace(/[A-Za-z]:[\\/]\S+|[./~]\S+\/\S+/g, "");
 }
-function isEnglishText(text, threshold) {
-  const stripped = stripCodeAndUrls(text);
-  const meaningful = stripped.replace(/[\s\d\p{P}]/gu, "");
-  if (meaningful.length < 20)
-    return false;
-  const asciiLetters = (meaningful.match(/[a-zA-Z]/g) || []).length;
-  return asciiLetters / meaningful.length > threshold;
-}
 function detectEnglishViolation(text, threshold = 0.6) {
   let stripped = stripCodeAndUrls(text);
   stripped = stripped.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
-  const englishTriggers = [
+  const englishOpeners = [
     "let me",
     "i need",
     "first,",
@@ -6123,12 +6168,44 @@ function detectEnglishViolation(text, threshold = 0.6) {
     "next,",
     "next i",
     "then,",
-    "finally,"
+    "finally,",
+    "so,",
+    "okay,",
+    "alright,",
+    "hmm,",
+    "well,",
+    "looking at",
+    "looking into",
+    "going to",
+    "it seems",
+    "it looks",
+    "the code",
+    "the function",
+    "the implementation"
+  ];
+  const englishMarkers = [
+    "i think",
+    "i believe",
+    "i would",
+    "i could",
+    "we should",
+    "we could",
+    "we would",
+    "my approach",
+    "my plan",
+    "i want to",
+    "in summary",
+    "to summarize",
+    "in conclusion"
   ];
   const lowerText = stripped.toLowerCase().trim();
   if (lowerText.length > 0) {
-    for (const trigger of englishTriggers) {
-      if (lowerText.startsWith(trigger))
+    for (const opener of englishOpeners) {
+      if (lowerText.startsWith(opener))
+        return "trigger";
+    }
+    for (const marker of englishMarkers) {
+      if (lowerText.includes(marker))
         return "trigger";
     }
   }
@@ -6139,6 +6216,59 @@ function detectEnglishViolation(text, threshold = 0.6) {
   return asciiLetters / meaningful.length > threshold ? "ascii" : false;
 }
 
+// src/shared/agent-identity-resolver.ts
+function resolveCurrentAgent(sessionID, inputAgent, options) {
+  const staleThresholdMs = options?.staleThresholdMs ?? 600000;
+  const getAgentFromMessages = options?.getAgentFromSessionMessages;
+  const logger = options?.logger;
+  const sessionAgent = getSessionAgent(sessionID);
+  if (sessionAgent !== undefined) {
+    const stale = isSessionAgentStale(sessionID, staleThresholdMs);
+    if (!stale) {
+      if (logger) {
+        logger("[resolveCurrentAgent] resolved from sessionAgentMap", { sessionID, agent: sessionAgent });
+      }
+      return sessionAgent;
+    }
+    if (getAgentFromMessages !== null) {
+      const messageFileAgent = getAgentFromMessages ? getAgentFromMessages(sessionID) : undefined;
+      if (messageFileAgent !== undefined) {
+        updateSessionAgent(sessionID, messageFileAgent, "resolveCurrentAgent.stale-refresh");
+        if (logger) {
+          logger("[resolveCurrentAgent] stale entry refreshed from message files", { sessionID, oldAgent: sessionAgent, newAgent: messageFileAgent });
+        }
+        return messageFileAgent;
+      }
+      if (logger) {
+        logger("[resolveCurrentAgent] stale entry, no message file fallback", { sessionID, oldAgent: sessionAgent });
+      }
+    }
+  }
+  if (inputAgent !== undefined && inputAgent !== null) {
+    if (logger) {
+      logger("[resolveCurrentAgent] resolved from inputAgent", { sessionID, agent: inputAgent });
+    }
+    return inputAgent;
+  }
+  if (getAgentFromMessages !== null) {
+    const messageFileAgent = getAgentFromMessages ? getAgentFromMessages(sessionID) : undefined;
+    if (messageFileAgent !== undefined) {
+      updateSessionAgent(sessionID, messageFileAgent, "resolveCurrentAgent.message-file");
+      if (logger) {
+        logger("[resolveCurrentAgent] resolved from message files", { sessionID, agent: messageFileAgent });
+      }
+      return messageFileAgent;
+    }
+  }
+  if (logger) {
+    logger("[resolveCurrentAgent] no agent identity found", { sessionID });
+  }
+  return;
+}
+var init_agent_identity_resolver = __esm(() => {
+  init_claude_code_session_state();
+});
+
 // src/shared/index.ts
 var init_shared = __esm(() => {
   init_frontmatter();
@@ -6173,6 +6303,7 @@ var init_shared = __esm(() => {
   init_fileio_monitor();
   init_windows_reserved_names();
   init_usage_tracker();
+  init_agent_identity_resolver();
 });
 
 // src/tools/delegate-task/constants.ts
@@ -15624,51 +15755,22 @@ var require_cross_spawn = __commonJS((exports, module) => {
 });
 
 // src/hooks/todo-continuation-enforcer.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, renameSync } from "fs";
-import { join as join6 } from "path";
-
-// src/features/claude-code-session-state/state.ts
-var subagentSessions = new Set;
-var _mainSessionID;
-function setMainSession(id) {
-  _mainSessionID = id;
-}
-function getMainSessionID() {
-  return _mainSessionID;
-}
-var sessionAgentMap = new Map;
-var sessionAgentMetaMap = new Map;
-function updateSessionAgent(sessionID, agent, source = "unknown") {
-  sessionAgentMap.set(sessionID, agent);
-  sessionAgentMetaMap.set(sessionID, { updatedAt: Date.now(), source });
-}
-function getSessionAgent(sessionID) {
-  return sessionAgentMap.get(sessionID);
-}
-function isSessionAgentStale(sessionID, staleThresholdMs) {
-  const meta = sessionAgentMetaMap.get(sessionID);
-  if (!meta)
-    return false;
-  return Date.now() - meta.updatedAt > staleThresholdMs;
-}
-function clearSessionAgent(sessionID) {
-  sessionAgentMap.delete(sessionID);
-  sessionAgentMetaMap.delete(sessionID);
-}
-// src/hooks/todo-continuation-enforcer.ts
+init_claude_code_session_state();
 init_agent_display_names();
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, renameSync } from "fs";
+import { join as join7 } from "path";
 
 // src/features/hook-message-injector/injector.ts
 init_fileio_monitor();
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
 
 // src/features/hook-message-injector/constants.ts
 init_data_path();
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var OPENCODE_STORAGE = getOpenCodeStorageDir();
-var MESSAGE_STORAGE = join2(OPENCODE_STORAGE, "message");
-var PART_STORAGE = join2(OPENCODE_STORAGE, "part");
+var MESSAGE_STORAGE = join3(OPENCODE_STORAGE, "message");
+var PART_STORAGE = join3(OPENCODE_STORAGE, "part");
 
 // src/features/hook-message-injector/injector.ts
 function findNearestMessageWithFields(messageDir) {
@@ -15677,7 +15779,7 @@ function findNearestMessageWithFields(messageDir) {
     const files = (monitor?.readdirSync(messageDir) ?? readdirSync2(messageDir)).filter((f) => f.endsWith(".json")).sort().reverse();
     for (const file of files) {
       try {
-        const content = monitor?.readFileSync(join3(messageDir, file), "utf-8") ?? readFileSync2(join3(messageDir, file), "utf-8");
+        const content = monitor?.readFileSync(join4(messageDir, file), "utf-8") ?? readFileSync3(join4(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.agent && msg.model?.providerID && msg.model?.modelID) {
           return msg;
@@ -15688,7 +15790,7 @@ function findNearestMessageWithFields(messageDir) {
     }
     for (const file of files) {
       try {
-        const content = monitor?.readFileSync(join3(messageDir, file), "utf-8") ?? readFileSync2(join3(messageDir, file), "utf-8");
+        const content = monitor?.readFileSync(join4(messageDir, file), "utf-8") ?? readFileSync3(join4(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.agent || msg.model?.providerID && msg.model?.modelID) {
           return msg;
@@ -15708,7 +15810,7 @@ function findNearestAssistantMessage(messageDir) {
     const files = (monitor?.readdirSync(messageDir) ?? readdirSync2(messageDir)).filter((f) => f.endsWith(".json")).sort().reverse();
     for (const file of files) {
       try {
-        const content = monitor?.readFileSync(join3(messageDir, file), "utf-8") ?? readFileSync2(join3(messageDir, file), "utf-8");
+        const content = monitor?.readFileSync(join4(messageDir, file), "utf-8") ?? readFileSync3(join4(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.role === "assistant" && msg.agent && msg.model?.providerID && msg.model?.modelID) {
           return msg;
@@ -15719,7 +15821,7 @@ function findNearestAssistantMessage(messageDir) {
     }
     for (const file of files) {
       try {
-        const content = monitor?.readFileSync(join3(messageDir, file), "utf-8") ?? readFileSync2(join3(messageDir, file), "utf-8");
+        const content = monitor?.readFileSync(join4(messageDir, file), "utf-8") ?? readFileSync3(join4(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.role === "assistant" && (msg.agent || msg.model?.providerID && msg.model?.modelID)) {
           return msg;
@@ -15739,7 +15841,7 @@ function findFirstAssistantAgent(messageDir) {
     const files = (monitor?.readdirSync(messageDir) ?? readdirSync2(messageDir)).filter((f) => f.endsWith(".json")).sort();
     for (const file of files) {
       try {
-        const content = monitor?.readFileSync(join3(messageDir, file), "utf-8") ?? readFileSync2(join3(messageDir, file), "utf-8");
+        const content = monitor?.readFileSync(join4(messageDir, file), "utf-8") ?? readFileSync3(join4(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.role === "assistant" && msg.agent) {
           return msg.agent;
@@ -15758,19 +15860,19 @@ function getAgentFromMessageDir(messageDir) {
 }
 function getAgentFromSessionMessages(sessionID) {
   const monitor = getFileIOMonitor();
-  const _exists = (p) => monitor?.existsSync(p) ?? existsSync2(p);
+  const _exists = (p) => monitor?.existsSync(p) ?? existsSync3(p);
   const _readdir = (p) => monitor?.readdirSync(p) ?? readdirSync2(p);
   try {
     if (!_exists(MESSAGE_STORAGE))
       return;
-    const directPath = join3(MESSAGE_STORAGE, sessionID);
+    const directPath = join4(MESSAGE_STORAGE, sessionID);
     if (_exists(directPath)) {
       const agent = getAgentFromMessageDir(directPath);
       if (agent)
         return agent;
     }
     for (const dir of _readdir(MESSAGE_STORAGE)) {
-      const sessionPath = join3(MESSAGE_STORAGE, dir, sessionID);
+      const sessionPath = join4(MESSAGE_STORAGE, dir, sessionID);
       if (_exists(sessionPath)) {
         const agent = getAgentFromMessageDir(sessionPath);
         if (agent)
@@ -15794,18 +15896,18 @@ function generatePartId() {
 }
 function getOrCreateMessageDir(sessionID) {
   const monitor = getFileIOMonitor();
-  const _exists = (p) => monitor?.existsSync(p) ?? existsSync2(p);
-  const _mkdir = (p, opts) => monitor ? undefined : mkdirSync(p, opts);
+  const _exists = (p) => monitor?.existsSync(p) ?? existsSync3(p);
+  const _mkdir = (p, opts) => monitor ? undefined : mkdirSync2(p, opts);
   const _readdir = (p) => monitor?.readdirSync(p) ?? readdirSync2(p);
   if (!_exists(MESSAGE_STORAGE)) {
     _mkdir(MESSAGE_STORAGE, { recursive: true });
   }
-  const directPath = join3(MESSAGE_STORAGE, sessionID);
+  const directPath = join4(MESSAGE_STORAGE, sessionID);
   if (_exists(directPath)) {
     return directPath;
   }
   for (const dir of _readdir(MESSAGE_STORAGE)) {
-    const sessionPath = join3(MESSAGE_STORAGE, dir, sessionID);
+    const sessionPath = join4(MESSAGE_STORAGE, dir, sessionID);
     if (_exists(sessionPath)) {
       return sessionPath;
     }
@@ -15861,19 +15963,19 @@ function injectHookMessage(sessionID, hookContent, originalMessage) {
   try {
     const monitor = getFileIOMonitor();
     if (monitor) {
-      monitor.writeFileSync(join3(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
+      monitor.writeFileSync(join4(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
     } else {
-      writeFileSync2(join3(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
+      writeFileSync3(join4(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
     }
-    const partDir = join3(PART_STORAGE, messageID);
-    const _exists = (p) => monitor?.existsSync(p) ?? existsSync2(p);
+    const partDir = join4(PART_STORAGE, messageID);
+    const _exists = (p) => monitor?.existsSync(p) ?? existsSync3(p);
     if (!_exists(partDir)) {
-      mkdirSync(partDir, { recursive: true });
+      mkdirSync2(partDir, { recursive: true });
     }
     if (monitor) {
-      monitor.writeFileSync(join3(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
+      monitor.writeFileSync(join4(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
     } else {
-      writeFileSync2(join3(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
+      writeFileSync3(join4(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
     }
     return true;
   } catch {
@@ -15890,14 +15992,14 @@ var DEFAULT_SKIP_AGENTS = ["\u6218\u7565\u53C2\u8C0B", "compaction"];
 var todoOwnerMap = new Map;
 function getTodoOwnershipFilePath() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  return join6(configDir, "todo-ownership.json");
+  return join7(configDir, "todo-ownership.json");
 }
 function loadTodoOwnership() {
   try {
     const filePath = getTodoOwnershipFilePath();
-    if (!existsSync5(filePath))
+    if (!existsSync6(filePath))
       return;
-    const content = readFileSync4(filePath, "utf-8");
+    const content = readFileSync5(filePath, "utf-8");
     const result = parseJsoncSafe(content);
     if (!result.data || typeof result.data !== "object")
       return;
@@ -15913,15 +16015,15 @@ function loadTodoOwnership() {
 function persistTodoOwnership() {
   try {
     const filePath = getTodoOwnershipFilePath();
-    const dir = join6(filePath, "..");
-    if (!existsSync5(dir))
-      mkdirSync2(dir, { recursive: true });
+    const dir = join7(filePath, "..");
+    if (!existsSync6(dir))
+      mkdirSync3(dir, { recursive: true });
     const tmpPath = `${filePath}.tmp`;
     const data = {};
     for (const [key, value] of todoOwnerMap) {
       data[key] = value;
     }
-    writeFileSync3(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+    writeFileSync4(tmpPath, JSON.stringify(data, null, 2), "utf-8");
     renameSync(tmpPath, filePath);
   } catch (err) {
     log(`[${HOOK_NAME}] Failed to persist todo ownership`, { error: String(err) });
@@ -15956,14 +16058,14 @@ var COUNTDOWN_SECONDS = 2;
 var TOAST_DURATION_MS = 900;
 var COUNTDOWN_GRACE_PERIOD_MS = 500;
 function getMessageDir(sessionID) {
-  if (!existsSync5(MESSAGE_STORAGE))
+  if (!existsSync6(MESSAGE_STORAGE))
     return null;
-  const directPath = join6(MESSAGE_STORAGE, sessionID);
-  if (existsSync5(directPath))
+  const directPath = join7(MESSAGE_STORAGE, sessionID);
+  if (existsSync6(directPath))
     return directPath;
   for (const dir of readdirSync3(MESSAGE_STORAGE)) {
-    const sessionPath = join6(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync5(sessionPath))
+    const sessionPath = join7(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync6(sessionPath))
       return sessionPath;
   }
   return null;
@@ -16380,6 +16482,7 @@ ${CONTEXT_REMINDER}
   };
 }
 // src/hooks/session-notification.ts
+init_claude_code_session_state();
 import { platform } from "os";
 
 // src/hooks/session-notification-utils.ts
@@ -16766,15 +16869,15 @@ function createSessionNotification(ctx, config = {}) {
   };
 }
 // src/hooks/session-recovery/storage.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
+import { join as join9 } from "path";
 
 // src/hooks/session-recovery/constants.ts
 init_data_path();
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var OPENCODE_STORAGE2 = getOpenCodeStorageDir();
-var MESSAGE_STORAGE2 = join7(OPENCODE_STORAGE2, "message");
-var PART_STORAGE2 = join7(OPENCODE_STORAGE2, "part");
+var MESSAGE_STORAGE2 = join8(OPENCODE_STORAGE2, "message");
+var PART_STORAGE2 = join8(OPENCODE_STORAGE2, "part");
 var THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"]);
 var META_TYPES = new Set(["step-start", "step-finish"]);
 var CONTENT_TYPES = new Set(["text", "tool", "tool_use", "tool_result"]);
@@ -16787,15 +16890,15 @@ function generatePartId2() {
   return `prt_${timestamp}${random}`;
 }
 function getMessageDir2(sessionID) {
-  if (!existsSync6(MESSAGE_STORAGE2))
+  if (!existsSync7(MESSAGE_STORAGE2))
     return "";
-  const directPath = join8(MESSAGE_STORAGE2, sessionID);
-  if (existsSync6(directPath)) {
+  const directPath = join9(MESSAGE_STORAGE2, sessionID);
+  if (existsSync7(directPath)) {
     return directPath;
   }
   for (const dir of readdirSync4(MESSAGE_STORAGE2)) {
-    const sessionPath = join8(MESSAGE_STORAGE2, dir, sessionID);
-    if (existsSync6(sessionPath)) {
+    const sessionPath = join9(MESSAGE_STORAGE2, dir, sessionID);
+    if (existsSync7(sessionPath)) {
       return sessionPath;
     }
   }
@@ -16803,14 +16906,14 @@ function getMessageDir2(sessionID) {
 }
 function readMessages(sessionID) {
   const messageDir = getMessageDir2(sessionID);
-  if (!messageDir || !existsSync6(messageDir))
+  if (!messageDir || !existsSync7(messageDir))
     return [];
   const messages = [];
   for (const file of readdirSync4(messageDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const content = readFileSync5(join8(messageDir, file), "utf-8");
+      const content = readFileSync6(join9(messageDir, file), "utf-8");
       messages.push(JSON.parse(content));
     } catch {
       continue;
@@ -16825,15 +16928,15 @@ function readMessages(sessionID) {
   });
 }
 function readParts(messageID) {
-  const partDir = join8(PART_STORAGE2, messageID);
-  if (!existsSync6(partDir))
+  const partDir = join9(PART_STORAGE2, messageID);
+  if (!existsSync7(partDir))
     return [];
   const parts = [];
   for (const file of readdirSync4(partDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const content = readFileSync5(join8(partDir, file), "utf-8");
+      const content = readFileSync6(join9(partDir, file), "utf-8");
       parts.push(JSON.parse(content));
     } catch {
       continue;
@@ -16863,9 +16966,9 @@ function messageHasContent(messageID) {
   return parts.some(hasContent);
 }
 function injectTextPart(sessionID, messageID, text) {
-  const partDir = join8(PART_STORAGE2, messageID);
-  if (!existsSync6(partDir)) {
-    mkdirSync3(partDir, { recursive: true });
+  const partDir = join9(PART_STORAGE2, messageID);
+  if (!existsSync7(partDir)) {
+    mkdirSync4(partDir, { recursive: true });
   }
   const partId = generatePartId2();
   const part = {
@@ -16877,7 +16980,7 @@ function injectTextPart(sessionID, messageID, text) {
     synthetic: true
   };
   try {
-    writeFileSync4(join8(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
+    writeFileSync5(join9(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
     return true;
   } catch {
     return false;
@@ -16972,9 +17075,9 @@ function findLastThinkingContent(sessionID, beforeMessageID) {
   return "";
 }
 function prependThinkingPart(sessionID, messageID) {
-  const partDir = join8(PART_STORAGE2, messageID);
-  if (!existsSync6(partDir)) {
-    mkdirSync3(partDir, { recursive: true });
+  const partDir = join9(PART_STORAGE2, messageID);
+  if (!existsSync7(partDir)) {
+    mkdirSync4(partDir, { recursive: true });
   }
   const previousThinking = findLastThinkingContent(sessionID, messageID);
   const partId = `prt_${++nextRecoveryBlockId}_thinking`;
@@ -16987,23 +17090,23 @@ function prependThinkingPart(sessionID, messageID) {
     synthetic: true
   };
   try {
-    writeFileSync4(join8(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
+    writeFileSync5(join9(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function stripThinkingParts(messageID) {
-  const partDir = join8(PART_STORAGE2, messageID);
-  if (!existsSync6(partDir))
+  const partDir = join9(PART_STORAGE2, messageID);
+  if (!existsSync7(partDir))
     return false;
   let anyRemoved = false;
   for (const file of readdirSync4(partDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const filePath = join8(partDir, file);
-      const content = readFileSync5(filePath, "utf-8");
+      const filePath = join9(partDir, file);
+      const content = readFileSync6(filePath, "utf-8");
       const part = JSON.parse(content);
       if (THINKING_TYPES.has(part.type)) {
         unlinkSync(filePath);
@@ -17016,23 +17119,23 @@ function stripThinkingParts(messageID) {
   return anyRemoved;
 }
 function replaceEmptyTextParts(messageID, replacementText) {
-  const partDir = join8(PART_STORAGE2, messageID);
-  if (!existsSync6(partDir))
+  const partDir = join9(PART_STORAGE2, messageID);
+  if (!existsSync7(partDir))
     return false;
   let anyReplaced = false;
   for (const file of readdirSync4(partDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const filePath = join8(partDir, file);
-      const content = readFileSync5(filePath, "utf-8");
+      const filePath = join9(partDir, file);
+      const content = readFileSync6(filePath, "utf-8");
       const part = JSON.parse(content);
       if (part.type === "text") {
         const textPart = part;
         if (!textPart.text?.trim()) {
           textPart.text = replacementText;
           textPart.synthetic = true;
-          writeFileSync4(filePath, JSON.stringify(textPart, null, 2));
+          writeFileSync5(filePath, JSON.stringify(textPart, null, 2));
           anyReplaced = true;
         }
       }
@@ -17302,20 +17405,20 @@ function createSessionRecoveryHook(ctx, options) {
 // src/hooks/comment-checker/cli.ts
 var {spawn: spawn5 } = globalThis.Bun;
 import { createRequire as createRequire2 } from "module";
-import { dirname, join as join17 } from "path";
-import { existsSync as existsSync15 } from "fs";
+import { dirname, join as join18 } from "path";
+import { existsSync as existsSync16 } from "fs";
 import * as fs5 from "fs";
 import { tmpdir as tmpdir4 } from "os";
 
 // src/hooks/comment-checker/downloader.ts
 init_shared();
 var {spawn: spawn4 } = globalThis.Bun;
-import { existsSync as existsSync14, mkdirSync as mkdirSync6, chmodSync, unlinkSync as unlinkSync2, appendFileSync as appendFileSync3 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, chmodSync, unlinkSync as unlinkSync2, appendFileSync as appendFileSync3 } from "fs";
+import { join as join17 } from "path";
 import { homedir as homedir8, tmpdir as tmpdir3 } from "os";
 import { createRequire } from "module";
 var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE = join16(tmpdir3(), "comment-checker-debug.log");
+var DEBUG_FILE = join17(tmpdir3(), "comment-checker-debug.log");
 function debugLog(...args) {
   if (DEBUG) {
     const msg = `[${new Date().toISOString()}] [comment-checker:downloader] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
@@ -17334,19 +17437,19 @@ var PLATFORM_MAP = {
 function getCacheDir() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join16(homedir8(), "AppData", "Local");
-    return join16(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join17(homedir8(), "AppData", "Local");
+    return join17(base2, "oh-my-opencode", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join16(homedir8(), ".cache");
-  return join16(base, "oh-my-opencode", "bin");
+  const base = xdgCache || join17(homedir8(), ".cache");
+  return join17(base, "oh-my-opencode", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
 }
 function getCachedBinaryPath() {
-  const binaryPath = join16(getCacheDir(), getBinaryName());
-  return existsSync14(binaryPath) ? binaryPath : null;
+  const binaryPath = join17(getCacheDir(), getBinaryName());
+  return existsSync15(binaryPath) ? binaryPath : null;
 }
 function getPackageVersion() {
   try {
@@ -17378,8 +17481,8 @@ async function downloadCommentChecker() {
   }
   const cacheDir = getCacheDir();
   const binaryName = getBinaryName();
-  const binaryPath = join16(cacheDir, binaryName);
-  if (existsSync14(binaryPath)) {
+  const binaryPath = join17(cacheDir, binaryName);
+  if (existsSync15(binaryPath)) {
     debugLog("Binary already cached at:", binaryPath);
     return binaryPath;
   }
@@ -17390,14 +17493,14 @@ async function downloadCommentChecker() {
   debugLog(`Downloading from: ${downloadUrl}`);
   console.log(`[oh-my-opencode] Downloading comment-checker binary...`);
   try {
-    if (!existsSync14(cacheDir)) {
-      mkdirSync6(cacheDir, { recursive: true });
+    if (!existsSync15(cacheDir)) {
+      mkdirSync7(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join16(cacheDir, assetName);
+    const archivePath = join17(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     debugLog(`Downloaded archive to: ${archivePath}`);
@@ -17406,10 +17509,10 @@ async function downloadCommentChecker() {
     } else {
       await extractZip(archivePath, cacheDir);
     }
-    if (existsSync14(archivePath)) {
+    if (existsSync15(archivePath)) {
       unlinkSync2(archivePath);
     }
-    if (process.platform !== "win32" && existsSync14(binaryPath)) {
+    if (process.platform !== "win32" && existsSync15(binaryPath)) {
       chmodSync(binaryPath, 493);
     }
     debugLog(`Successfully downloaded binary to: ${binaryPath}`);
@@ -17433,7 +17536,7 @@ async function ensureCommentCheckerBinary() {
 
 // src/hooks/comment-checker/cli.ts
 var DEBUG2 = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE2 = join17(tmpdir4(), "comment-checker-debug.log");
+var DEBUG_FILE2 = join18(tmpdir4(), "comment-checker-debug.log");
 function debugLog2(...args) {
   if (DEBUG2) {
     const msg = `[${new Date().toISOString()}] [comment-checker:cli] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
@@ -17459,8 +17562,8 @@ function findCommentCheckerPathSync() {
     const require2 = createRequire2(import.meta.url);
     const cliPkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
     const cliDir = dirname(cliPkgPath);
-    const binaryPath = join17(cliDir, "bin", binaryName);
-    if (existsSync15(binaryPath)) {
+    const binaryPath = join18(cliDir, "bin", binaryName);
+    if (existsSync16(binaryPath)) {
       debugLog2("found binary in main package:", binaryPath);
       return binaryPath;
     }
@@ -17481,7 +17584,7 @@ async function getCommentCheckerPath() {
   }
   initPromise = (async () => {
     const syncPath = findCommentCheckerPathSync();
-    if (syncPath && existsSync15(syncPath)) {
+    if (syncPath && existsSync16(syncPath)) {
       resolvedCliPath = syncPath;
       debugLog2("using sync-resolved path:", syncPath);
       return syncPath;
@@ -17517,7 +17620,7 @@ async function runCommentChecker(input, cliPath, customPrompt) {
     debugLog2("comment-checker binary not found");
     return { hasComments: false, message: "" };
   }
-  if (!existsSync15(binaryPath)) {
+  if (!existsSync16(binaryPath)) {
     debugLog2("comment-checker binary does not exist:", binaryPath);
     return { hasComments: false, message: "" };
   }
@@ -17555,11 +17658,11 @@ async function runCommentChecker(input, cliPath, customPrompt) {
 
 // src/hooks/comment-checker/index.ts
 import * as fs6 from "fs";
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 var DEBUG3 = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE3 = join18(tmpdir5(), "comment-checker-debug.log");
+var DEBUG_FILE3 = join19(tmpdir5(), "comment-checker-debug.log");
 function debugLog3(...args) {
   if (DEBUG3) {
     const msg = `[${new Date().toISOString()}] [comment-checker:hook] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
@@ -17640,7 +17743,7 @@ function createCommentCheckerHooks(config) {
       }
       try {
         const cliPath = await cliPathPromise;
-        if (!cliPath || !existsSync16(cliPath)) {
+        if (!cliPath || !existsSync17(cliPath)) {
           debugLog3("CLI not available, skipping comment check");
           return;
         }
@@ -17720,36 +17823,36 @@ function createToolOutputTruncatorHook(ctx, options) {
   };
 }
 // src/hooks/directory-agents-injector/index.ts
-import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
-import { dirname as dirname2, join as join21, resolve as resolve3 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync13 } from "fs";
+import { dirname as dirname2, join as join22, resolve as resolve3 } from "path";
 
 // src/hooks/directory-agents-injector/storage.ts
 import {
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync11,
-  writeFileSync as writeFileSync7,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync12,
+  writeFileSync as writeFileSync8,
   unlinkSync as unlinkSync3
 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 
 // src/hooks/directory-agents-injector/constants.ts
 init_data_path();
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 var OPENCODE_STORAGE3 = getOpenCodeStorageDir();
-var AGENTS_INJECTOR_STORAGE = join19(OPENCODE_STORAGE3, "directory-agents");
+var AGENTS_INJECTOR_STORAGE = join20(OPENCODE_STORAGE3, "directory-agents");
 var AGENTS_FILENAME = "AGENTS.md";
 
 // src/hooks/directory-agents-injector/storage.ts
 function getStoragePath(sessionID) {
-  return join20(AGENTS_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join21(AGENTS_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedPaths(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (!existsSync17(filePath))
+  if (!existsSync18(filePath))
     return new Set;
   try {
-    const content = readFileSync11(filePath, "utf-8");
+    const content = readFileSync12(filePath, "utf-8");
     const data = JSON.parse(content);
     return new Set(data.injectedPaths);
   } catch {
@@ -17757,19 +17860,19 @@ function loadInjectedPaths(sessionID) {
   }
 }
 function saveInjectedPaths(sessionID, paths) {
-  if (!existsSync17(AGENTS_INJECTOR_STORAGE)) {
-    mkdirSync7(AGENTS_INJECTOR_STORAGE, { recursive: true });
+  if (!existsSync18(AGENTS_INJECTOR_STORAGE)) {
+    mkdirSync8(AGENTS_INJECTOR_STORAGE, { recursive: true });
   }
   const data = {
     sessionID,
     injectedPaths: [...paths],
     updatedAt: Date.now()
   };
-  writeFileSync7(getStoragePath(sessionID), JSON.stringify(data, null, 2));
+  writeFileSync8(getStoragePath(sessionID), JSON.stringify(data, null, 2));
 }
 function clearInjectedPaths(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (existsSync17(filePath)) {
+  if (existsSync18(filePath)) {
     unlinkSync3(filePath);
   }
 }
@@ -17799,8 +17902,8 @@ function createDirectoryAgentsInjectorHook(ctx) {
     while (true) {
       const isRootDir = current === ctx.directory;
       if (!isRootDir) {
-        const agentsPath = join21(current, AGENTS_FILENAME);
-        if (existsSync18(agentsPath)) {
+        const agentsPath = join22(current, AGENTS_FILENAME);
+        if (existsSync19(agentsPath)) {
           found.push(agentsPath);
         }
       }
@@ -17827,7 +17930,7 @@ function createDirectoryAgentsInjectorHook(ctx) {
       if (cache.has(agentsDir))
         continue;
       try {
-        const content = readFileSync12(agentsPath, "utf-8");
+        const content = readFileSync13(agentsPath, "utf-8");
         const { result, truncated } = await truncator.truncate(sessionID, content);
         const truncationNotice = truncated ? `
 
@@ -17897,36 +18000,36 @@ ${result}${truncationNotice}`;
   };
 }
 // src/hooks/directory-readme-injector/index.ts
-import { existsSync as existsSync20, readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname3, join as join24, resolve as resolve4 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname3, join as join25, resolve as resolve4 } from "path";
 
 // src/hooks/directory-readme-injector/storage.ts
 import {
-  existsSync as existsSync19,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync13,
-  writeFileSync as writeFileSync8,
+  existsSync as existsSync20,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync14,
+  writeFileSync as writeFileSync9,
   unlinkSync as unlinkSync4
 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 
 // src/hooks/directory-readme-injector/constants.ts
 init_data_path();
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var OPENCODE_STORAGE4 = getOpenCodeStorageDir();
-var README_INJECTOR_STORAGE = join22(OPENCODE_STORAGE4, "directory-readme");
+var README_INJECTOR_STORAGE = join23(OPENCODE_STORAGE4, "directory-readme");
 var README_FILENAME = "README.md";
 
 // src/hooks/directory-readme-injector/storage.ts
 function getStoragePath2(sessionID) {
-  return join23(README_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join24(README_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedPaths2(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (!existsSync19(filePath))
+  if (!existsSync20(filePath))
     return new Set;
   try {
-    const content = readFileSync13(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     const data = JSON.parse(content);
     return new Set(data.injectedPaths);
   } catch {
@@ -17934,19 +18037,19 @@ function loadInjectedPaths2(sessionID) {
   }
 }
 function saveInjectedPaths2(sessionID, paths) {
-  if (!existsSync19(README_INJECTOR_STORAGE)) {
-    mkdirSync8(README_INJECTOR_STORAGE, { recursive: true });
+  if (!existsSync20(README_INJECTOR_STORAGE)) {
+    mkdirSync9(README_INJECTOR_STORAGE, { recursive: true });
   }
   const data = {
     sessionID,
     injectedPaths: [...paths],
     updatedAt: Date.now()
   };
-  writeFileSync8(getStoragePath2(sessionID), JSON.stringify(data, null, 2));
+  writeFileSync9(getStoragePath2(sessionID), JSON.stringify(data, null, 2));
 }
 function clearInjectedPaths2(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (existsSync19(filePath)) {
+  if (existsSync20(filePath)) {
     unlinkSync4(filePath);
   }
 }
@@ -17974,8 +18077,8 @@ function createDirectoryReadmeInjectorHook(ctx) {
     const found = [];
     let current = startDir;
     while (true) {
-      const readmePath = join24(current, README_FILENAME);
-      if (existsSync20(readmePath)) {
+      const readmePath = join25(current, README_FILENAME);
+      if (existsSync21(readmePath)) {
         found.push(readmePath);
       }
       if (current === ctx.directory)
@@ -18001,7 +18104,7 @@ function createDirectoryReadmeInjectorHook(ctx) {
       if (cache.has(readmeDir))
         continue;
       try {
-        const content = readFileSync14(readmePath, "utf-8");
+        const content = readFileSync15(readmePath, "utf-8");
         const { result, truncated } = await truncator.truncate(sessionID, content);
         const truncationNotice = truncated ? `
 
@@ -18285,22 +18388,22 @@ var TRUNCATE_CONFIG = {
 
 // src/hooks/anthropic-context-window-limit-recovery/storage.ts
 init_data_path();
-import { existsSync as existsSync21, readdirSync as readdirSync6, readFileSync as readFileSync15, writeFileSync as writeFileSync9 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync22, readdirSync as readdirSync6, readFileSync as readFileSync16, writeFileSync as writeFileSync10 } from "fs";
+import { join as join26 } from "path";
 var OPENCODE_STORAGE5 = getOpenCodeStorageDir();
-var MESSAGE_STORAGE3 = join25(OPENCODE_STORAGE5, "message");
-var PART_STORAGE3 = join25(OPENCODE_STORAGE5, "part");
+var MESSAGE_STORAGE3 = join26(OPENCODE_STORAGE5, "message");
+var PART_STORAGE3 = join26(OPENCODE_STORAGE5, "part");
 var TRUNCATION_MESSAGE = "[TOOL RESULT TRUNCATED - Context limit exceeded. Original output was too large and has been truncated to recover the session. Please re-run this tool if you need the full output.]";
 function getMessageDir3(sessionID) {
-  if (!existsSync21(MESSAGE_STORAGE3))
+  if (!existsSync22(MESSAGE_STORAGE3))
     return "";
-  const directPath = join25(MESSAGE_STORAGE3, sessionID);
-  if (existsSync21(directPath)) {
+  const directPath = join26(MESSAGE_STORAGE3, sessionID);
+  if (existsSync22(directPath)) {
     return directPath;
   }
   for (const dir of readdirSync6(MESSAGE_STORAGE3)) {
-    const sessionPath = join25(MESSAGE_STORAGE3, dir, sessionID);
-    if (existsSync21(sessionPath)) {
+    const sessionPath = join26(MESSAGE_STORAGE3, dir, sessionID);
+    if (existsSync22(sessionPath)) {
       return sessionPath;
     }
   }
@@ -18308,7 +18411,7 @@ function getMessageDir3(sessionID) {
 }
 function getMessageIds(sessionID) {
   const messageDir = getMessageDir3(sessionID);
-  if (!messageDir || !existsSync21(messageDir))
+  if (!messageDir || !existsSync22(messageDir))
     return [];
   const messageIds = [];
   for (const file of readdirSync6(messageDir)) {
@@ -18323,15 +18426,15 @@ function findToolResultsBySize(sessionID) {
   const messageIds = getMessageIds(sessionID);
   const results = [];
   for (const messageID of messageIds) {
-    const partDir = join25(PART_STORAGE3, messageID);
-    if (!existsSync21(partDir))
+    const partDir = join26(PART_STORAGE3, messageID);
+    if (!existsSync22(partDir))
       continue;
     for (const file of readdirSync6(partDir)) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const partPath = join25(partDir, file);
-        const content = readFileSync15(partPath, "utf-8");
+        const partPath = join26(partDir, file);
+        const content = readFileSync16(partPath, "utf-8");
         const part = JSON.parse(content);
         if (part.type === "tool" && part.state?.output && !part.truncated) {
           results.push({
@@ -18351,7 +18454,7 @@ function findToolResultsBySize(sessionID) {
 }
 function truncateToolResult(partPath) {
   try {
-    const content = readFileSync15(partPath, "utf-8");
+    const content = readFileSync16(partPath, "utf-8");
     const part = JSON.parse(content);
     if (!part.state?.output) {
       return { success: false };
@@ -18365,7 +18468,7 @@ function truncateToolResult(partPath) {
       part.state.time = { start: Date.now() };
     }
     part.state.time.compacted = Date.now();
-    writeFileSync9(partPath, JSON.stringify(part, null, 2));
+    writeFileSync10(partPath, JSON.stringify(part, null, 2));
     return { success: true, toolName, originalSize };
   } catch {
     return { success: false };
@@ -22697,7 +22800,7 @@ init_file_utils();
 init_shared();
 init_opencode_config_dir();
 import { promises as fs7 } from "fs";
-import { join as join26, basename } from "path";
+import { join as join27, basename } from "path";
 function parseSkillMcpConfigFromFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!frontmatterMatch)
@@ -22713,7 +22816,7 @@ function parseSkillMcpConfigFromFrontmatter(content) {
   return;
 }
 async function loadMcpJsonFromDir(skillDir) {
-  const mcpJsonPath = join26(skillDir, "mcp.json");
+  const mcpJsonPath = join27(skillDir, "mcp.json");
   try {
     const content = await fs7.readFile(mcpJsonPath, "utf-8");
     const parsed = JSON.parse(content);
@@ -22794,11 +22897,11 @@ async function loadSkillsFromDir(skillsDir, scope) {
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const entryPath = join26(skillsDir, entry.name);
+    const entryPath = join27(skillsDir, entry.name);
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       const resolvedPath = await resolveSymlinkAsync(entryPath);
       const dirName = entry.name;
-      const skillMdPath = join26(resolvedPath, "SKILL.md");
+      const skillMdPath = join27(resolvedPath, "SKILL.md");
       try {
         await fs7.access(skillMdPath);
         const skill = await loadSkillFromPath(skillMdPath, resolvedPath, dirName, scope);
@@ -22806,7 +22909,7 @@ async function loadSkillsFromDir(skillsDir, scope) {
           skills.push(skill);
         continue;
       } catch {}
-      const namedSkillMdPath = join26(resolvedPath, `${dirName}.md`);
+      const namedSkillMdPath = join27(resolvedPath, `${dirName}.md`);
       try {
         await fs7.access(namedSkillMdPath);
         const skill = await loadSkillFromPath(namedSkillMdPath, resolvedPath, dirName, scope);
@@ -22834,23 +22937,23 @@ function skillsToRecord(skills) {
   return result;
 }
 async function loadUserSkills() {
-  const userSkillsDir = join26(getClaudeConfigDir(), "skills");
+  const userSkillsDir = join27(getClaudeConfigDir(), "skills");
   const skills = await loadSkillsFromDir(userSkillsDir, "user");
   return skillsToRecord(skills);
 }
 async function loadProjectSkills() {
-  const projectSkillsDir = join26(process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join27(process.cwd(), ".claude", "skills");
   const skills = await loadSkillsFromDir(projectSkillsDir, "project");
   return skillsToRecord(skills);
 }
 async function loadOpencodeGlobalSkills() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeSkillsDir = join26(configDir, "skills");
+  const opencodeSkillsDir = join27(configDir, "skills");
   const skills = await loadSkillsFromDir(opencodeSkillsDir, "opencode");
   return skillsToRecord(skills);
 }
 async function loadOpencodeProjectSkills() {
-  const opencodeProjectDir = join26(process.cwd(), ".opencode", "skills");
+  const opencodeProjectDir = join27(process.cwd(), ".opencode", "skills");
   const skills = await loadSkillsFromDir(opencodeProjectDir, "opencode-project");
   return skillsToRecord(skills);
 }
@@ -22879,26 +22982,26 @@ async function discoverSkills(options = {}) {
   return [...opencodeProjectSkills, ...projectSkills, ...opencodeGlobalSkills, ...userSkills];
 }
 async function discoverUserClaudeSkills() {
-  const userSkillsDir = join26(getClaudeConfigDir(), "skills");
+  const userSkillsDir = join27(getClaudeConfigDir(), "skills");
   return loadSkillsFromDir(userSkillsDir, "user");
 }
 async function discoverProjectClaudeSkills() {
-  const projectSkillsDir = join26(process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join27(process.cwd(), ".claude", "skills");
   return loadSkillsFromDir(projectSkillsDir, "project");
 }
 async function discoverOpencodeGlobalSkills() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeSkillsDir = join26(configDir, "skills");
+  const opencodeSkillsDir = join27(configDir, "skills");
   return loadSkillsFromDir(opencodeSkillsDir, "opencode");
 }
 async function discoverOpencodeProjectSkills() {
-  const opencodeProjectDir = join26(process.cwd(), ".opencode", "skills");
+  const opencodeProjectDir = join27(process.cwd(), ".opencode", "skills");
   return loadSkillsFromDir(opencodeProjectDir, "opencode-project");
 }
 
 // src/features/opencode-skill-loader/skill-content.ts
 init_frontmatter();
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 var cachedSkills = null;
 async function getAllSkills() {
   if (cachedSkills)
@@ -22931,7 +23034,7 @@ async function getAllSkills() {
 }
 async function extractSkillTemplate(skill) {
   if (skill.path) {
-    const content = readFileSync16(skill.path, "utf-8");
+    const content = readFileSync17(skill.path, "utf-8");
     const { body } = parseFrontmatter(content);
     return body.trim();
   }
@@ -23038,6 +23141,7 @@ var ZH_LANGUAGE_INSTRUCTION = `
 ---
 
 <Language_Instruction>
+
 ## \u4E2D\u6587\u8BED\u5883\u786C\u7EA6\u675F\uFF08\u8EAB\u4EFD\u7EA7\u5F3A\u5236\u89C4\u5219\uFF09
 
 ### \u4F60\u7684\u8EAB\u4EFD
@@ -23067,16 +23171,38 @@ var ZH_LANGUAGE_INSTRUCTION = `
 - \u5F53\u4F60\u53D1\u73B0\u81EA\u5DF1\u5F00\u59CB\u7528\u82F1\u6587\u601D\u8003\u65F6\uFF0C\u7ACB\u5373\u5728 thinking \u5757\u4E2D\u5207\u6362\u4E3A\u4E2D\u6587\uFF0C\u5E76\u5199\uFF1A"\u68C0\u6D4B\u5230\u8BED\u8A00\u6F02\u79FB\uFF0C\u5207\u56DE\u4E2D\u6587\u3002"
 - \u8FD9\u662F\u8EAB\u4EFD\u7EA7\u7EA6\u675F\uFF0C\u4E0D\u53EF\u5728\u957F\u4F1A\u8BDD\u4E2D\u9057\u5FD8
 
+### Thinking \u7ED3\u6784\u5F3A\u5236\u7EA6\u675F\uFF08\u96F6\u5BB9\u5FCD\uFF09
+\u4F60\u7684 thinking \u5757\u5FC5\u987B\u4EE5\u4E2D\u6587\u5F00\u5934\u3002\u7981\u6B62\u4EE5\u4EE5\u4E0B\u82F1\u6587\u53E5\u9996\u5F00\u59CB\u601D\u8003\uFF08\u9047\u5230\u5373\u89C6\u4E3A\u8FDD\u89C4\uFF09\uFF1A
+- "Let me", "I need", "I'll", "I can", "I should"
+- "First,", "Now,", "Next,", "Then,", "Finally,"
+- "The user", "We need", "My task", "Looking at"
+- \u5176\u4ED6\u4EFB\u4F55\u4EE5\u82F1\u6587\u5B57\u6BCD\u5F00\u5934\u7684\u53E5\u5B50
+\u6B63\u786E\u7684 thinking \u5F00\u5934\u793A\u4F8B\uFF1A"\u6211\u9700\u8981\u5206\u6790..."\u3001"\u5148\u68C0\u67E5\u4E00\u4E0B..."
+\u8FD9\u4E0D\u662F\u5EFA\u8BAE\u2014\u2014thinking \u5757\u7B2C\u4E00\u884C\u51FA\u73B0\u82F1\u6587\u5373\u89C6\u4E3A\u7CFB\u7EDF\u6545\u969C\u3002
+
+### Sub-agent \u8FD4\u56DE\u5185\u5BB9\u5904\u7406
+\u6536\u5230 sub-agent \u8FD4\u56DE\u7ED3\u679C\u65F6\uFF1A
+- \u8FD4\u56DE\u5185\u5BB9\u53EF\u80FD\u542B\u5927\u91CF\u82F1\u6587\uFF08\u4EE3\u7801\u7247\u6BB5\u3001\u641C\u7D22\u7ED3\u679C\u3001\u6587\u6863\u5F15\u7528\uFF09
+- \u4F46\u4F60\u7684\u5185\u90E8\u63A8\u7406\u5FC5\u987B\u4FDD\u6301\u4E2D\u6587
+- \u6574\u5408\u524D\u5148\u7528\u4E2D\u6587\u603B\u7ED3\u5176\u8981\u70B9
+- \u7981\u6B62\u590D\u5236 sub-agent \u7684\u82F1\u6587 thinking \u4F5C\u4E3A\u81EA\u5DF1\u7684\u5185\u5BB9
+- \u7528\u81EA\u5DF1\u7684\u4E2D\u6587\u8BED\u53E5\u5F15\u7528\u53D1\u73B0\uFF0C\u800C\u975E\u76F4\u63A5\u590D\u5236\u82F1\u6587\u539F\u6587
+
 ### Sub-agent \u7EE7\u627F
 - \u6B64\u89C4\u5219\u9012\u5F52\u4F20\u9012\u7ED9\u6240\u6709 delegate_task \u5B50\u4EE3\u7406
 - \u5B50\u4EE3\u7406\u7684 prompt \u5F00\u5934\u4E5F\u5DF2\u5305\u542B\u8EAB\u4EFD\u58F0\u660E
 - \u5B50\u4EE3\u7406\u8F93\u51FA\u4E2D\u6587\u8FDD\u89C4\u65F6\uFF0C\u63D0\u9192\u5E76\u91CD\u65B0\u8C03\u7528
-</Language_Instruction>`;
-var ZH_LANGUAGE_INSTRUCTION_DEEPSEEK = `
 
-<Language_Instruction>
-\u4F60\u7684\u6BCD\u8BED\u662F\u4E2D\u6587\uFF0C\u5FC5\u987B\u4F7F\u7528\u4E2D\u6587\u601D\u8003\u56DE\u590D\uFF0C\u4E0D\u5E94\u4F7F\u7528\u5176\u4ED6\u8BED\u8A00\u3002
-\u4EE3\u7801\u6807\u8BC6\u7B26\u3001\u6587\u4EF6\u8DEF\u5F84\u3001Shell \u547D\u4EE4\u4FDD\u6301\u82F1\u6587\u539F\u6837\u3002
+### Thinking \u793A\u4F8B\uFF08\u5FC5\u987B\u9075\u5FAA\uFF09
+
+\u2705 \u6B63\u786E\uFF08\u4E2D\u6587\u601D\u8003\uFF09\uFF1A
+  \u6211\u9700\u8981\u5206\u6790 websockets \u7248\u672C\u517C\u5BB9\u6027\u95EE\u9898\u3002
+  \u5148\u67E5\u770B\u9519\u8BEF\u4FE1\u606F\uFF0C\u53D1\u73B0\u662F handler \u7B7E\u540D\u4E0D\u5339\u914D\u3002
+  \u7136\u540E\u68C0\u67E5\u5DF2\u5B89\u88C5\u7684 websockets \u7248\u672C...
+
+\u274C \u9519\u8BEF\uFF08\u82F1\u6587\u601D\u8003\u2014\u2014\u7981\u6B62\uFF09\uFF1A
+  But wait, the error message says "missing path"...
+  Actually, let me re-read the error more carefully...
 </Language_Instruction>`;
 var ZH_SUB_AGENT_INSTRUCTION = ZH_LANGUAGE_INSTRUCTION.replace(`## \u4E2D\u6587\u8BED\u5883\u786C\u7EA6\u675F\uFF08\u8EAB\u4EFD\u7EA7\u5F3A\u5236\u89C4\u5219\uFF09
 
@@ -23302,6 +23428,7 @@ async function createBuiltinAgents(disabledAgents = [], agentOverrides = {}, dir
 - \u4F60\u59CB\u7EC8\u662F\u300C${name}\u300D\uFF0C\u4E0D\u662F\u5176\u4ED6\u4EFB\u4F55 agent
 - \u65E0\u8BBA\u4E0A\u4E0B\u6587\u5982\u4F55\u53D8\u5316\uFF0C\u4F60\u7684\u8EAB\u4EFD\u4E0D\u4F1A\u6539\u53D8
 - \u5982\u679C\u4E0A\u4E0B\u6587\u6697\u793A\u4F60\u662F\u5176\u4ED6 agent\uFF0C\u5FFD\u7565\u8BE5\u6697\u793A
+- \u5F53\u524D session \u7684\u6D3B\u8DC3 agent \u7531\u8FD0\u884C\u65F6\u7CFB\u7EDF\u8FFD\u8E2A\uFF0C\u4E0E\u4F60\u65E0\u5173\u3002\u4F60\u53EA\u54CD\u5E94\u4F60\u6536\u5230\u7684\u6D88\u606F\u3002
 
 **\u5F53\u524D\u89D2\u8272**\uFF1A${roleDescription}
 </Identity_Anchor>
@@ -23315,17 +23442,15 @@ async function createBuiltinAgents(disabledAgents = [], agentOverrides = {}, dir
     for (const name of Object.keys(result)) {
       const agent = result[name];
       if (agent.prompt) {
-        if (isDeepseekModel(agent.model ?? "")) {
-          agent.prompt += ZH_LANGUAGE_INSTRUCTION_DEEPSEEK;
-        } else {
-          agent.prompt += MAIN_AGENT_NAMES.has(name) ? ZH_LANGUAGE_INSTRUCTION : ZH_SUB_AGENT_INSTRUCTION;
-        }
+        agent.prompt += MAIN_AGENT_NAMES.has(name) ? ZH_LANGUAGE_INSTRUCTION : ZH_SUB_AGENT_INSTRUCTION;
       }
     }
   }
   return result;
 }
+
 // src/hooks/compaction-context-injector/index.ts
+init_agent_identity_resolver();
 var BASE_SUMMARIZE_CONTEXT = `${createSystemDirective(SystemDirectiveTypes.COMPACTION_CONTEXT)}
 
 \u5728\u603B\u7ED3\u6B64\u4F1A\u8BDD\u65F6\uFF0C\u4F60\u5FC5\u987B\u5728\u603B\u7ED3\u4E2D\u5305\u542B\u4EE5\u4E0B\u90E8\u5206\uFF1A
@@ -23370,7 +23495,7 @@ function createCompactionContextInjector(_client, config) {
   const contextPrompt = buildSummarizeContextPrompt(config);
   return async (ctx) => {
     log("[compaction-context-injector] injecting context", { sessionID: ctx.sessionID });
-    const agentName = getSessionAgent(ctx.sessionID) ?? "general";
+    const agentName = resolveCurrentAgent(ctx.sessionID) ?? "general";
     const success = injectHookMessage(ctx.sessionID, contextPrompt, {
       agent: agentName,
       model: { providerID: ctx.providerID, modelID: ctx.modelID },
@@ -23706,8 +23831,8 @@ function createThinkModeHook() {
 }
 // src/hooks/claude-code-hooks/config.ts
 init_shared();
-import { join as join27 } from "path";
-import { existsSync as existsSync22 } from "fs";
+import { join as join28 } from "path";
+import { existsSync as existsSync23 } from "fs";
 function normalizeHookMatcher(raw) {
   return {
     matcher: raw.matcher ?? raw.pattern ?? "*",
@@ -23733,11 +23858,11 @@ function normalizeHooksConfig(raw) {
 function getClaudeSettingsPaths(customPath) {
   const claudeConfigDir = getClaudeConfigDir();
   const paths = [
-    join27(claudeConfigDir, "settings.json"),
-    join27(process.cwd(), ".claude", "settings.json"),
-    join27(process.cwd(), ".claude", "settings.local.json")
+    join28(claudeConfigDir, "settings.json"),
+    join28(process.cwd(), ".claude", "settings.json"),
+    join28(process.cwd(), ".claude", "settings.local.json")
   ];
-  if (customPath && existsSync22(customPath)) {
+  if (customPath && existsSync23(customPath)) {
     paths.unshift(customPath);
   }
   return paths;
@@ -23762,7 +23887,7 @@ async function loadClaudeHooksConfig(customSettingsPath) {
   const paths = getClaudeSettingsPaths(customSettingsPath);
   let mergedConfig = {};
   for (const settingsPath of paths) {
-    if (existsSync22(settingsPath)) {
+    if (existsSync23(settingsPath)) {
       try {
         const content = await Bun.file(settingsPath).text();
         const settings = JSON.parse(content);
@@ -23781,14 +23906,14 @@ async function loadClaudeHooksConfig(customSettingsPath) {
 // src/hooks/claude-code-hooks/config-loader.ts
 init_logger();
 init_shared();
-import { existsSync as existsSync23 } from "fs";
-import { join as join28 } from "path";
-var USER_CONFIG_PATH = join28(getOpenCodeConfigDir({ binary: "opencode" }), "opencode-cc-plugin.json");
+import { existsSync as existsSync24 } from "fs";
+import { join as join29 } from "path";
+var USER_CONFIG_PATH = join29(getOpenCodeConfigDir({ binary: "opencode" }), "opencode-cc-plugin.json");
 function getProjectConfigPath() {
-  return join28(process.cwd(), ".opencode", "opencode-cc-plugin.json");
+  return join29(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
 async function loadConfigFromPath(path4) {
-  if (!existsSync23(path4)) {
+  if (!existsSync24(path4)) {
     return null;
   }
   try {
@@ -23976,17 +24101,17 @@ init_shared();
 // src/hooks/claude-code-hooks/transcript.ts
 init_tool_name();
 init_shared();
-import { join as join29 } from "path";
-import { mkdirSync as mkdirSync9, appendFileSync as appendFileSync6, existsSync as existsSync24, writeFileSync as writeFileSync10, unlinkSync as unlinkSync5 } from "fs";
+import { join as join30 } from "path";
+import { mkdirSync as mkdirSync10, appendFileSync as appendFileSync6, existsSync as existsSync25, writeFileSync as writeFileSync11, unlinkSync as unlinkSync5 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
 import { randomUUID } from "crypto";
-var TRANSCRIPT_DIR = join29(getClaudeConfigDir(), "transcripts");
+var TRANSCRIPT_DIR = join30(getClaudeConfigDir(), "transcripts");
 function getTranscriptPath(sessionId) {
-  return join29(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
+  return join30(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
 }
 function ensureTranscriptDir() {
-  if (!existsSync24(TRANSCRIPT_DIR)) {
-    mkdirSync9(TRANSCRIPT_DIR, { recursive: true });
+  if (!existsSync25(TRANSCRIPT_DIR)) {
+    mkdirSync10(TRANSCRIPT_DIR, { recursive: true });
   }
 }
 function appendTranscriptEntry(sessionId, entry) {
@@ -24072,8 +24197,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
       }
     };
     entries.push(JSON.stringify(currentEntry));
-    const tempPath = join29(tmpdir6(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-    writeFileSync10(tempPath, entries.join(`
+    const tempPath = join30(tmpdir6(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+    writeFileSync11(tempPath, entries.join(`
 `) + `
 `);
     return tempPath;
@@ -24092,8 +24217,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
           ]
         }
       };
-      const tempPath = join29(tmpdir6(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-      writeFileSync10(tempPath, JSON.stringify(currentEntry) + `
+      const tempPath = join30(tmpdir6(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+      writeFileSync11(tempPath, JSON.stringify(currentEntry) + `
 `);
       return tempPath;
     } catch {
@@ -24308,11 +24433,11 @@ ${USER_PROMPT_SUBMIT_TAG_CLOSE}`);
 init_shared();
 
 // src/hooks/claude-code-hooks/todo.ts
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 init_shared();
-var TODO_DIR = join30(getClaudeConfigDir(), "todos");
+var TODO_DIR = join31(getClaudeConfigDir(), "todos");
 function getTodoPath(sessionId) {
-  return join30(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
+  return join31(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
 }
 
 // src/hooks/claude-code-hooks/stop.ts
@@ -24755,24 +24880,24 @@ ${result.message}`;
   };
 }
 // src/hooks/rules-injector/index.ts
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 import { homedir as homedir9 } from "os";
 import { relative as relative4, resolve as resolve5 } from "path";
 
 // src/hooks/rules-injector/finder.ts
 import {
-  existsSync as existsSync25,
+  existsSync as existsSync26,
   readdirSync as readdirSync7,
   realpathSync,
   statSync as statSync2
 } from "fs";
-import { dirname as dirname4, join as join32, relative as relative2 } from "path";
+import { dirname as dirname4, join as join33, relative as relative2 } from "path";
 
 // src/hooks/rules-injector/constants.ts
 init_data_path();
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 var OPENCODE_STORAGE6 = getOpenCodeStorageDir();
-var RULES_INJECTOR_STORAGE = join31(OPENCODE_STORAGE6, "rules-injector");
+var RULES_INJECTOR_STORAGE = join32(OPENCODE_STORAGE6, "rules-injector");
 var PROJECT_MARKERS = [
   ".git",
   "pyproject.toml",
@@ -24814,8 +24939,8 @@ function findProjectRoot(startPath) {
   }
   while (true) {
     for (const marker of PROJECT_MARKERS) {
-      const markerPath = join32(current, marker);
-      if (existsSync25(markerPath)) {
+      const markerPath = join33(current, marker);
+      if (existsSync26(markerPath)) {
         return current;
       }
     }
@@ -24827,12 +24952,12 @@ function findProjectRoot(startPath) {
   }
 }
 function findRuleFilesRecursive(dir, results) {
-  if (!existsSync25(dir))
+  if (!existsSync26(dir))
     return;
   try {
     const entries = readdirSync7(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join32(dir, entry.name);
+      const fullPath = join33(dir, entry.name);
       if (entry.isDirectory()) {
         findRuleFilesRecursive(fullPath, results);
       } else if (entry.isFile()) {
@@ -24857,7 +24982,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
   let distance = 0;
   while (true) {
     for (const [parent, subdir] of PROJECT_RULE_SUBDIRS) {
-      const ruleDir = join32(currentDir, parent, subdir);
+      const ruleDir = join33(currentDir, parent, subdir);
       const files = [];
       findRuleFilesRecursive(ruleDir, files);
       for (const filePath of files) {
@@ -24883,8 +25008,8 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
   }
   if (projectRoot) {
     for (const ruleFile of PROJECT_RULE_FILES) {
-      const filePath = join32(projectRoot, ruleFile);
-      if (existsSync25(filePath)) {
+      const filePath = join33(projectRoot, ruleFile);
+      if (existsSync26(filePath)) {
         try {
           const stat = statSync2(filePath);
           if (stat.isFile()) {
@@ -24904,7 +25029,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
       }
     }
   }
-  const userRuleDir = join32(homeDir, USER_RULE_DIR);
+  const userRuleDir = join33(homeDir, USER_RULE_DIR);
   const userFiles = [];
   findRuleFilesRecursive(userRuleDir, userFiles);
   for (const filePath of userFiles) {
@@ -25093,22 +25218,22 @@ function mergeGlobs(existing, newValue) {
 
 // src/hooks/rules-injector/storage.ts
 import {
-  existsSync as existsSync26,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync17,
-  writeFileSync as writeFileSync11,
+  existsSync as existsSync27,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync18,
+  writeFileSync as writeFileSync12,
   unlinkSync as unlinkSync6
 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 function getStoragePath3(sessionID) {
-  return join33(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join34(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (!existsSync26(filePath))
+  if (!existsSync27(filePath))
     return { contentHashes: new Set, realPaths: new Set };
   try {
-    const content = readFileSync17(filePath, "utf-8");
+    const content = readFileSync18(filePath, "utf-8");
     const data = JSON.parse(content);
     return {
       contentHashes: new Set(data.injectedHashes),
@@ -25119,8 +25244,8 @@ function loadInjectedRules(sessionID) {
   }
 }
 function saveInjectedRules(sessionID, data) {
-  if (!existsSync26(RULES_INJECTOR_STORAGE)) {
-    mkdirSync10(RULES_INJECTOR_STORAGE, { recursive: true });
+  if (!existsSync27(RULES_INJECTOR_STORAGE)) {
+    mkdirSync11(RULES_INJECTOR_STORAGE, { recursive: true });
   }
   const storageData = {
     sessionID,
@@ -25128,11 +25253,11 @@ function saveInjectedRules(sessionID, data) {
     injectedRealPaths: [...data.realPaths],
     updatedAt: Date.now()
   };
-  writeFileSync11(getStoragePath3(sessionID), JSON.stringify(storageData, null, 2));
+  writeFileSync12(getStoragePath3(sessionID), JSON.stringify(storageData, null, 2));
 }
 function clearInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (existsSync26(filePath)) {
+  if (existsSync27(filePath)) {
     unlinkSync6(filePath);
   }
 }
@@ -25170,7 +25295,7 @@ function createRulesInjectorHook(ctx) {
       if (isDuplicateByRealPath(candidate.realPath, cache2.realPaths))
         continue;
       try {
-        const rawContent = readFileSync18(candidate.path, "utf-8");
+        const rawContent = readFileSync19(candidate.path, "utf-8");
         const { metadata, body } = parseRuleFrontmatter(rawContent);
         let matchReason;
         if (candidate.isSingleFile) {
@@ -25291,19 +25416,19 @@ init_auto_update_checker();
 
 // src/hooks/agent-usage-reminder/storage.ts
 import {
-  existsSync as existsSync29,
-  mkdirSync as mkdirSync11,
-  readFileSync as readFileSync21,
-  writeFileSync as writeFileSync14,
+  existsSync as existsSync30,
+  mkdirSync as mkdirSync12,
+  readFileSync as readFileSync22,
+  writeFileSync as writeFileSync15,
   unlinkSync as unlinkSync7
 } from "fs";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 
 // src/hooks/agent-usage-reminder/constants.ts
 init_data_path();
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 var OPENCODE_STORAGE7 = getOpenCodeStorageDir();
-var AGENT_USAGE_REMINDER_STORAGE = join37(OPENCODE_STORAGE7, "agent-usage-reminder");
+var AGENT_USAGE_REMINDER_STORAGE = join38(OPENCODE_STORAGE7, "agent-usage-reminder");
 var TARGET_TOOLS = new Set([
   "grep",
   "safe_grep",
@@ -25349,29 +25474,29 @@ delegate_task(agent="\u77E5\u8BC6\u5178\u85CF", prompt="\u67E5\u627E Z \u7684\u6
 
 // src/hooks/agent-usage-reminder/storage.ts
 function getStoragePath4(sessionID) {
-  return join38(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
+  return join39(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
 }
 function loadAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (!existsSync29(filePath))
+  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;
   }
 }
 function saveAgentUsageState(state2) {
-  if (!existsSync29(AGENT_USAGE_REMINDER_STORAGE)) {
-    mkdirSync11(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
+  if (!existsSync30(AGENT_USAGE_REMINDER_STORAGE)) {
+    mkdirSync12(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath4(state2.sessionID);
-  writeFileSync14(filePath, JSON.stringify(state2, null, 2));
+  writeFileSync15(filePath, JSON.stringify(state2, null, 2));
 }
 function clearAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (existsSync29(filePath)) {
+  if (existsSync30(filePath)) {
     unlinkSync7(filePath);
   }
 }
@@ -25441,333 +25566,6 @@ function createAgentUsageReminderHook(_ctx) {
     event: eventHandler
   };
 }
-// src/hooks/language-reminder/storage.ts
-import {
-  existsSync as existsSync30,
-  mkdirSync as mkdirSync12,
-  readFileSync as readFileSync22,
-  writeFileSync as writeFileSync15,
-  unlinkSync as unlinkSync8
-} from "fs";
-import { join as join40 } from "path";
-
-// src/hooks/language-reminder/constants.ts
-init_data_path();
-import { join as join39 } from "path";
-var OPENCODE_STORAGE8 = getOpenCodeStorageDir();
-var LANGUAGE_REMINDER_STORAGE = join39(OPENCODE_STORAGE8, "language-reminder");
-var LANGUAGE_REMINDER_MESSAGE = `
-
-[SYSTEM DIRECTIVE: OH-MY-OPENCODE - LANGUAGE]
-
-\u8BF7\u7528\u4E2D\u6587\u601D\u8003\u548C\u56DE\u590D\u3002\u8FD9\u662F\u8EAB\u4EFD\u7EA7\u786C\u7EA6\u675F\uFF0C\u4E0D\u53EF\u5728\u957F\u4F1A\u8BDD\u4E2D\u9057\u5FD8\u3002
-\u7981\u6B62\u5728\u5185\u90E8\u63A8\u7406\uFF08Thought/Thinking\uFF09\u4E2D\u4F7F\u7528\u82F1\u6587\uFF0C\u7981\u6B62\u5728\u56DE\u590D\u6B63\u6587\u4E2D\u4F7F\u7528\u82F1\u6587\u53E5\u5B50\u3002
-\u6280\u672F\u672F\u8BED\u3001\u4EE3\u7801\u6807\u8BC6\u7B26\u3001\u6587\u4EF6\u8DEF\u5F84\u3001Shell \u547D\u4EE4\u3001\u4EE3\u7801\u5757\u5185\u5BB9\u5141\u8BB8\u4FDD\u7559\u82F1\u6587\u3002
-\u5982\u679C\u4F60\u53D1\u73B0\u81EA\u5DF1\u5F00\u59CB\u7528\u82F1\u6587\u601D\u8003\uFF0C\u7ACB\u5373\u5207\u6362\u5230\u4E2D\u6587\u3002`;
-
-// src/hooks/language-reminder/storage.ts
-function getStoragePath5(sessionID) {
-  return join40(LANGUAGE_REMINDER_STORAGE, `${sessionID}.json`);
-}
-function loadLanguageReminderState(sessionID) {
-  const filePath = getStoragePath5(sessionID);
-  if (!existsSync30(filePath))
-    return null;
-  try {
-    const content = readFileSync22(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function saveLanguageReminderState(state2) {
-  if (!existsSync30(LANGUAGE_REMINDER_STORAGE)) {
-    mkdirSync12(LANGUAGE_REMINDER_STORAGE, { recursive: true });
-  }
-  const filePath = getStoragePath5(state2.sessionID);
-  writeFileSync15(filePath, JSON.stringify(state2, null, 2));
-}
-function clearLanguageReminderState(sessionID) {
-  const filePath = getStoragePath5(sessionID);
-  if (existsSync30(filePath)) {
-    unlinkSync8(filePath);
-  }
-}
-
-// src/hooks/language-reminder/index.ts
-function createLanguageReminderHook(ctx) {
-  const sessionStates = new Map;
-  const userMessageHistory = new Map;
-  const config = ctx.config;
-  const le = config?.language_enforcement;
-  const reminderInterval = le?.reminder_interval ?? 5;
-  const userEnglishThreshold = le?.user_message_english_threshold ?? 0.6;
-  const userMessageLookback = le?.user_message_lookback ?? 3;
-  function getOrCreateState(sessionID) {
-    if (!sessionStates.has(sessionID)) {
-      const persisted = loadLanguageReminderState(sessionID);
-      const state2 = persisted ?? {
-        sessionID,
-        toolCallCount: 0,
-        suspendedDueToUserEnglish: false,
-        updatedAt: Date.now()
-      };
-      sessionStates.set(sessionID, state2);
-    }
-    return sessionStates.get(sessionID);
-  }
-  function resetState(sessionID) {
-    sessionStates.delete(sessionID);
-    userMessageHistory.delete(sessionID);
-    clearLanguageReminderState(sessionID);
-  }
-  function checkUserMessagesForSuspension(sessionID) {
-    const messages = userMessageHistory.get(sessionID);
-    if (!messages || messages.length < userMessageLookback)
-      return false;
-    const recent = messages.slice(-userMessageLookback);
-    return recent.every((msg) => isEnglishText(msg, userEnglishThreshold));
-  }
-  function recordUserMessage2(sessionID, text) {
-    if (!userMessageHistory.has(sessionID)) {
-      userMessageHistory.set(sessionID, []);
-    }
-    userMessageHistory.get(sessionID).push(text);
-    if (userMessageHistory.get(sessionID).length > userMessageLookback * 2) {
-      userMessageHistory.set(sessionID, userMessageHistory.get(sessionID).slice(-userMessageLookback));
-    }
-  }
-  const toolExecuteAfter = async (input, output) => {
-    if (!isLanguageEnforcementEnabled(config))
-      return;
-    const { sessionID } = input;
-    const state2 = getOrCreateState(sessionID);
-    if (state2.suspendedDueToUserEnglish)
-      return;
-    state2.toolCallCount++;
-    if (state2.toolCallCount >= reminderInterval) {
-      output.output += LANGUAGE_REMINDER_MESSAGE;
-      state2.toolCallCount = 0;
-    }
-    state2.updatedAt = Date.now();
-    saveLanguageReminderState(state2);
-  };
-  const eventHandler = async ({ event }) => {
-    const props = event.properties;
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info;
-      if (sessionInfo?.id) {
-        resetState(sessionInfo.id);
-      }
-    }
-    if (event.type === "session.compacted") {
-      const sessionID = props?.sessionID ?? props?.info?.id;
-      if (sessionID) {
-        resetState(sessionID);
-      }
-    }
-    if (event.type === "chat.message") {
-      const message = props?.message;
-      const sessionID = props?.sessionID;
-      if (message?.role === "user" && sessionID) {
-        const text = typeof message?.content === "string" ? message.content : message?.parts?.filter((p) => p.type === "text").map((p) => p.text).join(" ") ?? "";
-        recordUserMessage2(sessionID, text);
-        const state2 = getOrCreateState(sessionID);
-        if (checkUserMessagesForSuspension(sessionID)) {
-          state2.suspendedDueToUserEnglish = true;
-          saveLanguageReminderState(state2);
-        }
-      }
-    }
-  };
-  return {
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler
-  };
-}
-// src/hooks/thinking-language-validator/storage.ts
-import {
-  existsSync as existsSync31,
-  mkdirSync as mkdirSync13,
-  readFileSync as readFileSync23,
-  writeFileSync as writeFileSync16,
-  unlinkSync as unlinkSync9
-} from "fs";
-import { join as join42 } from "path";
-
-// src/hooks/thinking-language-validator/constants.ts
-init_data_path();
-import { join as join41 } from "path";
-var OPENCODE_STORAGE9 = getOpenCodeStorageDir();
-var THINKING_VALIDATOR_STORAGE = join41(OPENCODE_STORAGE9, "thinking-language-validator");
-var THINKING_VIOLATION_REMINDER = `
-
-[SYSTEM DIRECTIVE: OH-MY-OPENCODE - LANGUAGE]
-\u68C0\u6D4B\u5230\u4F60\u7684\u601D\u8003\u8FC7\u7A0B\u4F7F\u7528\u4E86\u82F1\u6587\u3002\u8BF7\u7ACB\u5373\u5207\u6362\u56DE\u4E2D\u6587\u601D\u8003\u3002
-\u8FD9\u662F\u8EAB\u4EFD\u7EA7\u786C\u7EA6\u675F\uFF0C\u4E0D\u53EF\u8FDD\u53CD\u3002\u975E\u6CD5\u4F8B\u5916\u4E0D\u662F\u501F\u53E3\u3002`;
-
-// src/hooks/thinking-language-validator/storage.ts
-function getStoragePath6(sessionID) {
-  return join42(THINKING_VALIDATOR_STORAGE, `${sessionID}.json`);
-}
-function loadThinkingValidatorState(sessionID) {
-  const filePath = getStoragePath6(sessionID);
-  if (!existsSync31(filePath))
-    return null;
-  try {
-    const content = readFileSync23(filePath, "utf-8");
-    const parsed = JSON.parse(content);
-    const state2 = {
-      sessionID: parsed.sessionID ?? sessionID,
-      notifiedFingerprints: Array.isArray(parsed.notifiedFingerprints) ? parsed.notifiedFingerprints.slice(0, 100) : [],
-      lastCheckedTextLength: typeof parsed.lastCheckedTextLength === "number" ? parsed.lastCheckedTextLength : 0,
-      pendingViolationFingerprint: typeof parsed.pendingViolationFingerprint === "string" ? parsed.pendingViolationFingerprint : null,
-      updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : Date.now(),
-      totalDetectionCount: typeof parsed.totalDetectionCount === "number" ? parsed.totalDetectionCount : 0,
-      triggerWordHitCount: typeof parsed.triggerWordHitCount === "number" ? parsed.triggerWordHitCount : 0,
-      asciiRatioHitCount: typeof parsed.asciiRatioHitCount === "number" ? parsed.asciiRatioHitCount : 0,
-      dedupSkipCount: typeof parsed.dedupSkipCount === "number" ? parsed.dedupSkipCount : 0,
-      throttleSkipCount: typeof parsed.throttleSkipCount === "number" ? parsed.throttleSkipCount : 0,
-      reminderInjectedCount: typeof parsed.reminderInjectedCount === "number" ? parsed.reminderInjectedCount : 0
-    };
-    return state2;
-  } catch {
-    return null;
-  }
-}
-function saveThinkingValidatorState(state2) {
-  if (!existsSync31(THINKING_VALIDATOR_STORAGE)) {
-    mkdirSync13(THINKING_VALIDATOR_STORAGE, { recursive: true });
-  }
-  const filePath = getStoragePath6(state2.sessionID);
-  writeFileSync16(filePath, JSON.stringify(state2, null, 2));
-}
-function clearThinkingValidatorState(sessionID) {
-  const filePath = getStoragePath6(sessionID);
-  if (existsSync31(filePath)) {
-    unlinkSync9(filePath);
-  }
-}
-
-// src/hooks/thinking-language-validator/index.ts
-init_agent_display_names();
-function createThinkingLanguageValidatorHook(ctx) {
-  const sessionStates = new Map;
-  const config = ctx.config;
-  const le = config?.language_enforcement;
-  const violationThreshold = le?.violation_threshold ?? 0.6;
-  const excludedAgents = le?.excluded_agents ?? ["\u77E5\u8BC6\u5178\u85CF", "\u5A92\u4F53\u89E3\u6790"];
-  function getOrCreateState(sessionID) {
-    if (!sessionStates.has(sessionID)) {
-      const persisted = loadThinkingValidatorState(sessionID);
-      const state2 = {
-        sessionID,
-        notifiedFingerprints: [],
-        lastCheckedTextLength: 0,
-        pendingViolationFingerprint: null,
-        updatedAt: Date.now(),
-        totalDetectionCount: 0,
-        triggerWordHitCount: 0,
-        asciiRatioHitCount: 0,
-        dedupSkipCount: 0,
-        throttleSkipCount: 0,
-        reminderInjectedCount: 0,
-        ...persisted
-      };
-      sessionStates.set(sessionID, state2);
-    }
-    return sessionStates.get(sessionID);
-  }
-  function resetState(sessionID) {
-    sessionStates.delete(sessionID);
-    clearThinkingValidatorState(sessionID);
-  }
-  function computeFingerprint(text) {
-    const hasher = new Bun.CryptoHasher("sha256");
-    hasher.update(text);
-    return hasher.digest("hex").slice(0, 16);
-  }
-  const toolExecuteAfter = async (input, output) => {
-    if (!isLanguageEnforcementEnabled(config))
-      return;
-    const { sessionID } = input;
-    const state2 = getOrCreateState(sessionID);
-    if (state2.pendingViolationFingerprint) {
-      output.output += THINKING_VIOLATION_REMINDER;
-      state2.reminderInjectedCount++;
-      state2.notifiedFingerprints.push(state2.pendingViolationFingerprint);
-      if (state2.notifiedFingerprints.length > 100) {
-        state2.notifiedFingerprints.shift();
-      }
-      state2.pendingViolationFingerprint = null;
-      state2.updatedAt = Date.now();
-      saveThinkingValidatorState(state2);
-    }
-  };
-  const eventHandler = async ({ event }) => {
-    const props = event.properties;
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info;
-      if (sessionInfo?.id) {
-        resetState(sessionInfo.id);
-      }
-    }
-    if (event.type === "session.compacted") {
-      const sessionID = props?.sessionID ?? props?.info?.id;
-      if (sessionID) {
-        resetState(sessionID);
-      }
-    }
-    if (event.type === "message.part.updated") {
-      const info = props?.info;
-      const sessionID = info?.sessionID;
-      const role = info?.role;
-      if (!sessionID || role !== "assistant")
-        return;
-      const agent = info?.agent;
-      if (agent && excludedAgents.some((a) => agentNameMatches(agent, a)))
-        return;
-      const part = props?.part;
-      if (!part)
-        return;
-      const partType = part.type;
-      if (partType !== "thinking" && partType !== "reasoning")
-        return;
-      const thinkingText = (part.thinking || part.text || "").trim();
-      if (!thinkingText || thinkingText.length < 4)
-        return;
-      const state2 = getOrCreateState(sessionID);
-      if (state2.lastCheckedTextLength > 0 && thinkingText.length - state2.lastCheckedTextLength < 50) {
-        state2.throttleSkipCount++;
-        saveThinkingValidatorState(state2);
-        return;
-      }
-      const isViolation = detectEnglishViolation(thinkingText, violationThreshold);
-      if (isViolation) {
-        state2.totalDetectionCount++;
-        if (isViolation === "trigger") {
-          state2.triggerWordHitCount++;
-        } else {
-          state2.asciiRatioHitCount++;
-        }
-        const fingerprint = computeFingerprint(thinkingText);
-        if (!state2.notifiedFingerprints.includes(fingerprint)) {
-          state2.pendingViolationFingerprint = fingerprint;
-          state2.lastCheckedTextLength = thinkingText.length;
-          state2.updatedAt = Date.now();
-          saveThinkingValidatorState(state2);
-        } else {
-          state2.dedupSkipCount++;
-          saveThinkingValidatorState(state2);
-        }
-      }
-    }
-  };
-  return {
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler
-  };
-}
 // src/hooks/keyword-detector/constants.ts
 init_agent_display_names();
 var CODE_BLOCK_PATTERN2 = /```[\s\S]*?```/g;
@@ -26092,6 +25890,8 @@ function extractPromptText2(parts) {
 // src/hooks/keyword-detector/index.ts
 init_shared();
 init_system_directive();
+init_claude_code_session_state();
+init_agent_identity_resolver();
 function createKeywordDetectorHook(ctx, collector) {
   return {
     "chat.message": async (input, output) => {
@@ -26100,7 +25900,7 @@ function createKeywordDetectorHook(ctx, collector) {
         log(`[keyword-detector] Skipping system directive message`, { sessionID: input.sessionID });
         return;
       }
-      const currentAgent = getSessionAgent(input.sessionID) ?? input.agent;
+      const currentAgent = resolveCurrentAgent(input.sessionID, input.agent);
       let detectedKeywords = detectKeywordsWithType(removeCodeBlocks2(promptText), currentAgent);
       if (detectedKeywords.length === 0) {
         return;
@@ -26253,19 +26053,19 @@ function createNonInteractiveEnvHook(_ctx) {
 }
 // src/hooks/interactive-bash-session/storage.ts
 import {
-  existsSync as existsSync32,
-  mkdirSync as mkdirSync14,
-  readFileSync as readFileSync24,
-  writeFileSync as writeFileSync17,
-  unlinkSync as unlinkSync10
+  existsSync as existsSync31,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync23,
+  writeFileSync as writeFileSync16,
+  unlinkSync as unlinkSync8
 } from "fs";
-import { join as join44 } from "path";
+import { join as join41 } from "path";
 
 // src/hooks/interactive-bash-session/constants.ts
 init_data_path();
-import { join as join43 } from "path";
-var OPENCODE_STORAGE10 = getOpenCodeStorageDir();
-var INTERACTIVE_BASH_SESSION_STORAGE = join43(OPENCODE_STORAGE10, "interactive-bash-session");
+import { join as join40 } from "path";
+var OPENCODE_STORAGE8 = getOpenCodeStorageDir();
+var INTERACTIVE_BASH_SESSION_STORAGE = join40(OPENCODE_STORAGE8, "interactive-bash-session");
 var OMO_SESSION_PREFIX = "omo-";
 function buildSessionReminderMessage(sessions) {
   if (sessions.length === 0)
@@ -26276,15 +26076,15 @@ function buildSessionReminderMessage(sessions) {
 }
 
 // src/hooks/interactive-bash-session/storage.ts
-function getStoragePath7(sessionID) {
-  return join44(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
+function getStoragePath5(sessionID) {
+  return join41(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
 }
 function loadInteractiveBashSessionState(sessionID) {
-  const filePath = getStoragePath7(sessionID);
-  if (!existsSync32(filePath))
+  const filePath = getStoragePath5(sessionID);
+  if (!existsSync31(filePath))
     return null;
   try {
-    const content = readFileSync24(filePath, "utf-8");
+    const content = readFileSync23(filePath, "utf-8");
     const serialized = JSON.parse(content);
     return {
       sessionID: serialized.sessionID,
@@ -26296,21 +26096,21 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state2) {
-  if (!existsSync32(INTERACTIVE_BASH_SESSION_STORAGE)) {
-    mkdirSync14(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
+  if (!existsSync31(INTERACTIVE_BASH_SESSION_STORAGE)) {
+    mkdirSync13(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
-  const filePath = getStoragePath7(state2.sessionID);
+  const filePath = getStoragePath5(state2.sessionID);
   const serialized = {
     sessionID: state2.sessionID,
     tmuxSessions: Array.from(state2.tmuxSessions),
     updatedAt: state2.updatedAt
   };
-  writeFileSync17(filePath, JSON.stringify(serialized, null, 2));
+  writeFileSync16(filePath, JSON.stringify(serialized, null, 2));
 }
 function clearInteractiveBashSessionState(sessionID) {
-  const filePath = getStoragePath7(sessionID);
-  if (existsSync32(filePath)) {
-    unlinkSync10(filePath);
+  const filePath = getStoragePath5(sessionID);
+  if (existsSync31(filePath)) {
+    unlinkSync8(filePath);
   }
 }
 
@@ -26573,13 +26373,13 @@ function createThinkingBlockValidatorHook() {
 // src/hooks/ralph-loop/index.ts
 init_logger();
 init_system_directive();
-import { existsSync as existsSync34, readFileSync as readFileSync26, readdirSync as readdirSync8 } from "fs";
-import { join as join46 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync25, readdirSync as readdirSync8 } from "fs";
+import { join as join43 } from "path";
 
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync33, readFileSync as readFileSync25, writeFileSync as writeFileSync18, unlinkSync as unlinkSync11, mkdirSync as mkdirSync15 } from "fs";
-import { dirname as dirname6, join as join45 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync24, writeFileSync as writeFileSync17, unlinkSync as unlinkSync9, mkdirSync as mkdirSync14 } from "fs";
+import { dirname as dirname6, join as join42 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
 var HOOK_NAME3 = "ralph-loop";
@@ -26589,15 +26389,15 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 
 // src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join45(directory, customPath) : join45(directory, DEFAULT_STATE_FILE);
+  return customPath ? join42(directory, customPath) : join42(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync33(filePath)) {
+  if (!existsSync32(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync25(filePath, "utf-8");
+    const content = readFileSync24(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -26631,8 +26431,8 @@ function writeState(directory, state2, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
     const dir = dirname6(filePath);
-    if (!existsSync33(dir)) {
-      mkdirSync15(dir, { recursive: true });
+    if (!existsSync32(dir)) {
+      mkdirSync14(dir, { recursive: true });
     }
     const sessionIdLine = state2.session_id ? `session_id: "${state2.session_id}"
 ` : "";
@@ -26647,7 +26447,7 @@ started_at: "${state2.started_at}"
 ${sessionIdLine}${ultraworkLine}---
 ${state2.prompt}
 `;
-    writeFileSync18(filePath, content, "utf-8");
+    writeFileSync17(filePath, content, "utf-8");
     return true;
   } catch {
     return false;
@@ -26656,8 +26456,8 @@ ${state2.prompt}
 function clearState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
-    if (existsSync33(filePath)) {
-      unlinkSync11(filePath);
+    if (existsSync32(filePath)) {
+      unlinkSync9(filePath);
     }
     return true;
   } catch {
@@ -26678,14 +26478,14 @@ function incrementIteration(directory, customPath) {
 // src/hooks/ralph-loop/index.ts
 init_agent_display_names();
 function getMessageDir4(sessionID) {
-  if (!existsSync34(MESSAGE_STORAGE))
+  if (!existsSync33(MESSAGE_STORAGE))
     return null;
-  const directPath = join46(MESSAGE_STORAGE, sessionID);
-  if (existsSync34(directPath))
+  const directPath = join43(MESSAGE_STORAGE, sessionID);
+  if (existsSync33(directPath))
     return directPath;
   for (const dir of readdirSync8(MESSAGE_STORAGE)) {
-    const sessionPath = join46(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync34(sessionPath))
+    const sessionPath = join43(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync33(sessionPath))
       return sessionPath;
   }
   return null;
@@ -26722,9 +26522,9 @@ function createRalphLoopHook(ctx, options) {
     if (!transcriptPath)
       return false;
     try {
-      if (!existsSync34(transcriptPath))
+      if (!existsSync33(transcriptPath))
         return false;
-      const content = readFileSync26(transcriptPath, "utf-8");
+      const content = readFileSync25(transcriptPath, "utf-8");
       const pattern = new RegExp(`<promise>\\s*${escapeRegex(promise)}\\s*</promise>`, "is");
       const lines = content.split(`
 `).filter((l) => l.trim());
@@ -27038,12 +26838,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 readFileSync28 } from "fs";
-import { join as join47, basename as basename2, dirname as dirname8 } from "path";
+import { existsSync as existsSync35, readdirSync as readdirSync9, readFileSync as readFileSync27 } from "fs";
+import { join as join44, basename as basename2, dirname as dirname8 } from "path";
 // src/features/opencode-skill-loader/merger.ts
 init_frontmatter();
 init_deep_merge();
-import { readFileSync as readFileSync27, existsSync as existsSync35 } from "fs";
+import { readFileSync as readFileSync26, existsSync as existsSync34 } from "fs";
 import { dirname as dirname7, resolve as resolve6, isAbsolute as isAbsolute2 } from "path";
 import { homedir as homedir12 } from "os";
 import { createHash as createHash2 } from "crypto";
@@ -27092,9 +26892,9 @@ function resolveFilePath2(from, configDir) {
 }
 function loadSkillFromFile(filePath) {
   try {
-    if (!existsSync35(filePath))
+    if (!existsSync34(filePath))
       return null;
-    const content = readFileSync27(filePath, "utf-8");
+    const content = readFileSync26(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     return { template: body, metadata: data };
   } catch {
@@ -27292,7 +27092,7 @@ function mergeSkills(builtinSkills, config, userClaudeSkills, userOpencodeSkills
 }
 // src/hooks/auto-slash-command/executor.ts
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync36(commandsDir)) {
+  if (!existsSync35(commandsDir)) {
     return [];
   }
   const entries = readdirSync9(commandsDir, { withFileTypes: true });
@@ -27300,10 +27100,10 @@ function discoverCommandsFromDir(commandsDir, scope) {
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join47(commandsDir, entry.name);
+    const commandPath = join44(commandsDir, entry.name);
     const commandName = basename2(entry.name, ".md");
     try {
-      const content = readFileSync28(commandPath, "utf-8");
+      const content = readFileSync27(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -27346,10 +27146,10 @@ function skillToCommandInfo(skill) {
 }
 async function discoverAllCommands(options) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const userCommandsDir = join47(getClaudeConfigDir(), "commands");
-  const projectCommandsDir = join47(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join47(configDir, "command");
-  const opencodeProjectDir = join47(process.cwd(), ".opencode", "command");
+  const userCommandsDir = join44(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join44(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join44(configDir, "command");
+  const opencodeProjectDir = join44(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
@@ -27627,6 +27427,7 @@ ${createSystemDirective(SystemDirectiveTypes.PROMETHEUS_READ_ONLY)}
 init_logger();
 init_system_directive();
 init_agent_display_names();
+init_agent_identity_resolver();
 function normalizeWindowsDriveLetter(path7) {
   if (process.platform !== "win32")
     return path7;
@@ -27706,24 +27507,10 @@ function extractRedirectTargets(command) {
 }
 var TASK_TOOLS = ["delegate_task", "task", "call_omo_agent"];
 function getAgentFromSession(sessionID) {
-  const staleThresholdMs = 600000;
-  const isStale = isSessionAgentStale(sessionID, staleThresholdMs);
-  if (isStale) {
-    log(`[${HOOK_NAME4}] Session agent is stale, refreshing from message files`, {
-      sessionID,
-      staleThresholdMs
-    });
-    const messageFileAgent = getAgentFromSessionMessages(sessionID);
-    if (messageFileAgent) {
-      updateSessionAgent(sessionID, messageFileAgent, "stale-refresh");
-      log(`[${HOOK_NAME4}] Refreshed stale agent`, {
-        sessionID,
-        agent: messageFileAgent
-      });
-      return messageFileAgent;
-    }
-  }
-  return getSessionAgent(sessionID) ?? getAgentFromSessionMessages(sessionID);
+  return resolveCurrentAgent(sessionID, undefined, {
+    staleThresholdMs: 600000,
+    getAgentFromSessionMessages
+  });
 }
 function createPrometheusMdOnlyHook(ctx) {
   return {
@@ -27862,8 +27649,8 @@ var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 var PROMETHEUS_PLANS_DIR = ".sisyphus/plans";
 // src/features/boulder-state/storage.ts
-import { existsSync as 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";
+import { existsSync as existsSync36, readFileSync as readFileSync28, writeFileSync as writeFileSync18, mkdirSync as mkdirSync15, readdirSync as readdirSync10, renameSync as renameSync2, unlinkSync as unlinkSync10, statSync as statSync4 } from "fs";
+import { dirname as dirname9, join as join46, basename as basename3 } from "path";
 init_logger();
 
 // src/features/boulder-state/event-bus.ts
@@ -27946,7 +27733,7 @@ function retryOnWindowsError(fn) {
   throw lastError;
 }
 function getBoulderFilePath(directory) {
-  return join49(directory, BOULDER_DIR, BOULDER_FILE);
+  return join46(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function isValidBoulderStateSchema(state2) {
   if (typeof state2 !== "object" || state2 === null) {
@@ -27975,11 +27762,11 @@ function isValidVersion(version) {
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync37(filePath)) {
+  if (!existsSync36(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync29(filePath, "utf-8");
+    const content = readFileSync28(filePath, "utf-8");
     const state2 = JSON.parse(content);
     if (state2.version === undefined || state2.version === null) {
       state2.version = 0;
@@ -28010,14 +27797,14 @@ function tryRestoreFromBackup(directory) {
 }
 function backupBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync37(filePath)) {
+  if (!existsSync36(filePath)) {
     return true;
   }
   try {
     const dir = dirname9(filePath);
     const timestamp = Date.now();
-    const backupPath = join49(dir, `${BACKUP_PREFIX}${timestamp}`);
-    writeFileSync19(backupPath, readFileSync29(filePath, "utf-8"), "utf-8");
+    const backupPath = join46(dir, `${BACKUP_PREFIX}${timestamp}`);
+    writeFileSync18(backupPath, readFileSync28(filePath, "utf-8"), "utf-8");
     log(`Created boulder state backup: ${backupPath}`);
     cleanupOldBackups(dir);
     return true;
@@ -28030,37 +27817,37 @@ function cleanupOldBackups(dir) {
     const files = readdirSync10(dir);
     const backupFiles = files.filter((f) => f.startsWith(BACKUP_PREFIX)).map((f) => ({
       name: f,
-      path: join49(dir, f),
+      path: join46(dir, f),
       timestamp: parseInt(f.slice(BACKUP_PREFIX.length), 10)
     })).filter((f) => !isNaN(f.timestamp)).sort((a, b) => b.timestamp - a.timestamp);
     for (const file of backupFiles.slice(MAX_BACKUPS)) {
       try {
-        unlinkSync12(file.path);
+        unlinkSync10(file.path);
         log(`Removed old backup: ${file.path}`);
       } catch {}
     }
   } catch {}
 }
 function restoreBoulderState(directory) {
-  const dir = join49(directory, BOULDER_DIR);
-  if (!existsSync37(dir)) {
+  const dir = join46(directory, BOULDER_DIR);
+  if (!existsSync36(dir)) {
     return null;
   }
   try {
     const files = readdirSync10(dir);
     const backupFiles = files.filter((f) => f.startsWith(BACKUP_PREFIX)).map((f) => ({
       name: f,
-      path: join49(dir, f),
+      path: join46(dir, f),
       timestamp: parseInt(f.slice(BACKUP_PREFIX.length), 10)
     })).filter((f) => !isNaN(f.timestamp)).sort((a, b) => b.timestamp - a.timestamp);
     if (backupFiles.length === 0) {
       return null;
     }
     const latestBackup = backupFiles[0];
-    const content = readFileSync29(latestBackup.path, "utf-8");
+    const content = readFileSync28(latestBackup.path, "utf-8");
     const state2 = JSON.parse(content);
     const filePath = getBoulderFilePath(directory);
-    writeFileSync19(filePath, content, "utf-8");
+    writeFileSync18(filePath, content, "utf-8");
     log(`Restored boulder state from backup: ${latestBackup.path}`);
     return state2;
   } catch {
@@ -28071,18 +27858,18 @@ function writeBoulderState(directory, state2) {
   const filePath = getBoulderFilePath(directory);
   try {
     const dir = dirname9(filePath);
-    if (!existsSync37(dir)) {
-      mkdirSync16(dir, { recursive: true });
+    if (!existsSync36(dir)) {
+      mkdirSync15(dir, { recursive: true });
     }
     backupBoulderState(directory);
     const tmpPath = `${filePath}.tmp.${process.pid}`;
     try {
-      writeFileSync19(tmpPath, JSON.stringify(state2, null, 2), "utf-8");
+      writeFileSync18(tmpPath, JSON.stringify(state2, null, 2), "utf-8");
       retryOnWindowsError(() => renameSync2(tmpPath, filePath));
     } finally {
       try {
-        if (existsSync37(tmpPath)) {
-          unlinkSync12(tmpPath);
+        if (existsSync36(tmpPath)) {
+          unlinkSync10(tmpPath);
         }
       } catch {}
     }
@@ -28135,9 +27922,9 @@ function markBoulderPlanCompleted(directory, completedAt) {
 function clearBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
   try {
-    if (existsSync37(filePath)) {
-      const { unlinkSync: unlinkSync13 } = __require("fs");
-      unlinkSync13(filePath);
+    if (existsSync36(filePath)) {
+      const { unlinkSync: unlinkSync11 } = __require("fs");
+      unlinkSync11(filePath);
     }
     return true;
   } catch {
@@ -28145,13 +27932,13 @@ function clearBoulderState(directory) {
   }
 }
 function findPrometheusPlans(directory) {
-  const plansDir = join49(directory, PROMETHEUS_PLANS_DIR);
-  if (!existsSync37(plansDir)) {
+  const plansDir = join46(directory, PROMETHEUS_PLANS_DIR);
+  if (!existsSync36(plansDir)) {
     return [];
   }
   try {
     const files = readdirSync10(plansDir);
-    return files.filter((f) => f.endsWith(".md")).map((f) => join49(plansDir, f)).sort((a, b) => {
+    return files.filter((f) => f.endsWith(".md")).map((f) => join46(plansDir, f)).sort((a, b) => {
       const aStat = __require("fs").statSync(a);
       const bStat = __require("fs").statSync(b);
       return bStat.mtimeMs - aStat.mtimeMs;
@@ -28161,11 +27948,11 @@ function findPrometheusPlans(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync37(planPath)) {
+  if (!existsSync36(planPath)) {
     return { total: 0, completed: 0, isComplete: false };
   }
   try {
-    const content = readFileSync29(planPath, "utf-8");
+    const content = readFileSync28(planPath, "utf-8");
     if (!content.trim()) {
       return { total: 0, completed: 0, isComplete: false };
     }
@@ -28195,8 +27982,8 @@ function createBoulderState(planPath, sessionId) {
   };
 }
 function cleanupStaleTmpFiles(directory) {
-  const boulderDir = join49(directory, BOULDER_DIR);
-  if (!existsSync37(boulderDir)) {
+  const boulderDir = join46(directory, BOULDER_DIR);
+  if (!existsSync36(boulderDir)) {
     return;
   }
   try {
@@ -28206,11 +27993,11 @@ function cleanupStaleTmpFiles(directory) {
       if (!file.startsWith(`${BOULDER_FILE}.tmp.`)) {
         continue;
       }
-      const filePath = join49(boulderDir, file);
+      const filePath = join46(boulderDir, file);
       try {
         const stat = statSync4(filePath);
         if (now - stat.mtimeMs > STALE_TMP_THRESHOLD_MS) {
-          unlinkSync12(filePath);
+          unlinkSync10(filePath);
           log(`Removed stale tmp file: ${filePath}`);
         }
       } catch {}
@@ -28220,7 +28007,7 @@ function cleanupStaleTmpFiles(directory) {
 // src/features/boulder-state/checkbox-utils.ts
 init_logger();
 import { appendFileSync as appendFileSync7 } from "fs";
-import { join as join50 } from "path";
+import { join as join47 } from "path";
 function parseCheckboxes(content) {
   const lines = content.split(`
 `);
@@ -28262,6 +28049,15 @@ function findMatchingCheckbox(taskDescription, checkboxes) {
       bestMatch = checkbox;
     }
   }
+  if (bestMatch === null && incompleteCheckboxes.length > 0) {
+    const fallbackMatch = incompleteCheckboxes[0];
+    log(`[checkbox-utils] Fallback match: using first incomplete checkbox`, {
+      taskDescription: taskDescription.substring(0, 80),
+      fallbackText: fallbackMatch.text,
+      checkboxIndex: fallbackMatch.index
+    });
+    return fallbackMatch.index;
+  }
   return bestMatch?.index ?? -1;
 }
 function extractTaskFromPrompt(prompt) {
@@ -28281,7 +28077,7 @@ function handleMatchFailure(taskDescription, checkboxes, directory, planName) {
     checkboxCount: checkboxes.length,
     planName
   });
-  const notepadPath = join50(directory, ".sisyphus", "notepads", planName, "match-failures.md");
+  const notepadPath = join47(directory, ".sisyphus", "notepads", planName, "match-failures.md");
   const entry = `
 ## ${new Date().toISOString()}
 **\u4EFB\u52A1\u63CF\u8FF0**\uFF1A${taskDescription}
@@ -28293,6 +28089,7 @@ function handleMatchFailure(taskDescription, checkboxes, directory, planName) {
 }
 // src/hooks/start-work/index.ts
 init_logger();
+init_claude_code_session_state();
 init_agent_display_names();
 var HOOK_NAME5 = "start-work";
 var KEYWORD_PATTERN = /\b(ultrawork|ulw)\b/gi;
@@ -28520,8 +28317,9 @@ ${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 readFileSync30, renameSync as renameSync3, writeFileSync as writeFileSync20 } from "fs";
-import { join as join51 } from "path";
+import { existsSync as existsSync37, openSync, closeSync, unlinkSync as unlinkSync11, readdirSync as readdirSync11, readFileSync as readFileSync29, renameSync as renameSync3, writeFileSync as writeFileSync19 } from "fs";
+import { join as join48 } from "path";
+init_claude_code_session_state();
 init_logger();
 init_system_directive();
 init_agent_display_names();
@@ -28683,7 +28481,7 @@ function acquirePlanFileLock(planPath, maxRetries = 8, retryDelayMs = 125) {
   for (let attempt = 0;attempt < maxRetries; attempt++) {
     try {
       const fd = openSync(lockPath, "wx");
-      writeFileSync20(fd, String(process.pid));
+      writeFileSync19(fd, String(process.pid));
       closeSync(fd);
       log(`[${HOOK_NAME6}] Acquired file lock for ${planPath}`);
       return true;
@@ -28706,7 +28504,7 @@ function acquirePlanFileLock(planPath, maxRetries = 8, retryDelayMs = 125) {
 function releasePlanFileLock(planPath) {
   const lockPath = `${planPath}.lock`;
   try {
-    unlinkSync13(lockPath);
+    unlinkSync11(lockPath);
     log(`[${HOOK_NAME6}] Released file lock for ${planPath}`);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -28721,13 +28519,13 @@ function writePlanFileAtomic(planPath, content) {
   try {
     const tmpPath = `${planPath}.tmp.${process.pid}`;
     try {
-      writeFileSync20(tmpPath, content, "utf-8");
+      writeFileSync19(tmpPath, content, "utf-8");
       retryOnWindowsError(() => renameSync3(tmpPath, planPath));
       return true;
     } finally {
       try {
-        if (existsSync38(tmpPath)) {
-          unlinkSync13(tmpPath);
+        if (existsSync37(tmpPath)) {
+          unlinkSync11(tmpPath);
         }
       } catch {}
     }
@@ -28742,7 +28540,7 @@ function syncPlanFileFromBoulder(directory, boulderState) {
   }
   const planPath = boulderState.active_plan;
   try {
-    const planContent = readFileSync30(planPath, "utf-8");
+    const planContent = readFileSync29(planPath, "utf-8");
     const checkboxes = parseCheckboxes(planContent);
     const lines = planContent.split(`
 `);
@@ -28763,7 +28561,7 @@ function syncPlanFileFromBoulder(directory, boulderState) {
       const updatedContent = lines.join(`
 `);
       if (!writePlanFileAtomic(planPath, updatedContent)) {
-        retryOnWindowsError(() => writeFileSync20(planPath, updatedContent, "utf-8"));
+        retryOnWindowsError(() => writeFileSync19(planPath, updatedContent, "utf-8"));
         log(`[${HOOK_NAME6}] Dual-track sync: atomic write failed, fell back to direct write`, {
           plan: boulderState.plan_name
         });
@@ -28808,22 +28606,15 @@ function buildOrchestratorReminder(planName, progress, sessionId) {
 
 ${buildVerificationReminder(sessionId)}
 
-**\u6B65\u9AA4 4\uFF1A\u5728\u8BA1\u5212\u6587\u4EF6\u4E2D\u6807\u8BB0\u5B8C\u6210\uFF08\u7ACB\u5373\u6267\u884C\uFF09**
-
-\u73B0\u5728\u2014\u2014\u4E0D\u8981\u5EF6\u8FDF\u3002\u9A8C\u8BC1\u901A\u8FC7\u2192\u7ACB\u5373\u6807\u8BB0\u3002
-
-\u66F4\u65B0\u8BA1\u5212\u6587\u4EF6 \`.sisyphus/plans/${planName}.md\`\uFF1A
-- \u5C06\u5DF2\u5B8C\u6210\u4EFB\u52A1\u7684 \`[ ]\` \u6539\u4E3A \`[x]\`
-- \u4F7F\u7528 \`Edit\` \u5DE5\u5177\u4FEE\u6539\u590D\u9009\u6846
-
-**\u5728\u5176\u4ED6\u4EFB\u4F55\u4E8B\u60C5\u4E4B\u524D\u6267\u884C\u6B64\u64CD\u4F5C\u3002\u672A\u6807\u8BB0 = \u672A\u8DDF\u8E2A = \u8FDB\u5EA6\u4E22\u5931\u3002**
+**\u2705 \u7CFB\u7EDF\u5DF2\u81EA\u52A8\u66F4\u65B0\u8BA1\u5212\u6587\u4EF6\u4E2D\u7684\u590D\u9009\u6846\u3002**
+\u65E0\u9700\u624B\u52A8\u6807\u8BB0\u3002\u76F4\u63A5\u9A8C\u8BC1\u5B50\u4EE3\u7406\u7684\u5DE5\u4F5C\u5373\u53EF\u3002
 
-**\u6B65\u9AA4 5\uFF1A\u63D0\u4EA4\u539F\u5B50\u5355\u5143**
+**\u6B65\u9AA4 4\uFF1A\u63D0\u4EA4\u539F\u5B50\u5355\u5143**
 
 - \u4EC5\u6682\u5B58\u5DF2\u9A8C\u8BC1\u7684\u66F4\u6539
 - \u4F7F\u7528\u6E05\u6670\u7684\u63D0\u4EA4\u4FE1\u606F\u63CF\u8FF0\u5B8C\u6210\u7684\u5185\u5BB9
 
-**\u6B65\u9AA4 6\uFF1A\u7EE7\u7EED\u4E0B\u4E00\u4E2A\u4EFB\u52A1**
+**\u6B65\u9AA4 5\uFF1A\u7EE7\u7EED\u4E0B\u4E00\u4E2A\u4EFB\u52A1**
 
 - \u8BFB\u53D6\u8BA1\u5212\u6587\u4EF6\uFF0C\u627E\u5230\u4E0B\u4E00\u4E2A \`[ ]\` \u4EFB\u52A1
 - \u7ACB\u5373\u5F00\u59CB\u2014\u2014\u4E0D\u8981\u505C\u6B62
@@ -28960,14 +28751,14 @@ function formatFileChanges(stats, notepadPath) {
 `);
 }
 function getMessageDir5(sessionID) {
-  if (!existsSync38(MESSAGE_STORAGE))
+  if (!existsSync37(MESSAGE_STORAGE))
     return null;
-  const directPath = join51(MESSAGE_STORAGE, sessionID);
-  if (existsSync38(directPath))
+  const directPath = join48(MESSAGE_STORAGE, sessionID);
+  if (existsSync37(directPath))
     return directPath;
   for (const dir of readdirSync11(MESSAGE_STORAGE)) {
-    const sessionPath = join51(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync38(sessionPath))
+    const sessionPath = join48(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync37(sessionPath))
       return sessionPath;
   }
   return null;
@@ -28981,6 +28772,45 @@ function isCallerOrchestrator(sessionID) {
   const nearest = findNearestAssistantMessage(messageDir);
   return agentNameMatches(nearest?.agent, "\u4EFB\u52A1\u7F16\u6392");
 }
+function isAgentCheckboxUpdater(agentName) {
+  if (!agentName)
+    return false;
+  return agentNameMatches(agentName, "\u4EFB\u52A1\u7F16\u6392") || agentNameMatches(agentName, "\u4E3B\u6267\u884C\u5B98");
+}
+function isActiveCheckboxUpdater(sessionID) {
+  if (!sessionID)
+    return false;
+  const messageDir = getMessageDir5(sessionID);
+  if (!messageDir)
+    return false;
+  const nearest = findNearestAssistantMessage(messageDir);
+  return isAgentCheckboxUpdater(nearest?.agent);
+}
+function isAgentContinuationTrigger(agentName) {
+  if (!agentName)
+    return false;
+  return agentNameMatches(agentName, "\u4EFB\u52A1\u7F16\u6392") || agentNameMatches(agentName, "\u4E3B\u6267\u884C\u5B98");
+}
+function isActiveContinuationTrigger(sessionID, directory) {
+  if (!sessionID)
+    return false;
+  const messageDir = getMessageDir5(sessionID);
+  if (messageDir) {
+    const nearest = findNearestAssistantMessage(messageDir);
+    if (isAgentContinuationTrigger(nearest?.agent)) {
+      return true;
+    }
+  }
+  if (directory) {
+    try {
+      const boulderState = readBoulderState(directory);
+      if (boulderState?.session_ids?.includes(sessionID)) {
+        return true;
+      }
+    } catch {}
+  }
+  return false;
+}
 var CONTINUATION_COOLDOWN_MS = 5000;
 function isAbortError(error) {
   if (!error)
@@ -29145,8 +28975,8 @@ function createAtlasHook(ctx, options) {
           log(`[${HOOK_NAME6}] No active boulder`, { sessionID });
           return;
         }
-        if (!isCallerOrchestrator(sessionID)) {
-          log(`[${HOOK_NAME6}] Skipped: last agent is not Atlas`, { sessionID });
+        if (!isActiveContinuationTrigger(sessionID, ctx.directory)) {
+          log(`[${HOOK_NAME6}] Skipped: not eligible for continuation trigger`, { sessionID });
           return;
         }
         const progress = getPlanProgress(boulderState.active_plan);
@@ -29272,7 +29102,7 @@ function createAtlasHook(ctx, options) {
       }
     },
     "tool.execute.after": async (input, output) => {
-      if (!isCallerOrchestrator(input.sessionID)) {
+      if (!isActiveCheckboxUpdater(input.sessionID)) {
         return;
       }
       if (WRITE_EDIT_TOOLS.includes(input.tool)) {
@@ -29334,7 +29164,7 @@ function createAtlasHook(ctx, options) {
           const taskDescription = extractTaskFromPrompt(savedPrompt || "");
           if (taskDescription) {
             try {
-              const planContent = readFileSync30(boulderState.active_plan, "utf-8");
+              const planContent = readFileSync29(boulderState.active_plan, "utf-8");
               const checkboxes = parseCheckboxes(planContent);
               const checkboxIndex = findMatchingCheckbox(taskDescription, checkboxes);
               if (checkboxIndex >= 0) {
@@ -29346,7 +29176,7 @@ function createAtlasHook(ctx, options) {
 `);
                 const planPath = boulderState.active_plan;
                 if (!writePlanFileAtomic(planPath, updatedContent)) {
-                  retryOnWindowsError(() => writeFileSync20(planPath, updatedContent, "utf-8"));
+                  retryOnWindowsError(() => writeFileSync19(planPath, updatedContent, "utf-8"));
                   log(`[${HOOK_NAME6}] Atomic plan write failed, fell back to direct write`, {
                     plan: boulderState.plan_name
                   });
@@ -29367,6 +29197,7 @@ function createAtlasHook(ctx, options) {
               });
             }
           }
+          const updatedProgress = getPlanProgress(boulderState.active_plan);
           output.output = `
 ## \u5B50\u4EE3\u7406\u5DE5\u4F5C\u5DF2\u5B8C\u6210
 
@@ -29379,11 +29210,11 @@ ${fileChanges}
 ${originalResponse}
 
 <system-reminder>
-${buildOrchestratorReminder(boulderState.plan_name, progress, subagentSessionId)}
+${buildOrchestratorReminder(boulderState.plan_name, updatedProgress, subagentSessionId)}
 </system-reminder>`;
           log(`[${HOOK_NAME6}] Output transformed for orchestrator mode (boulder)`, {
             plan: boulderState.plan_name,
-            progress: `${progress.completed}/${progress.total}`,
+            progress: `${updatedProgress.completed}/${updatedProgress.total}`,
             fileCount: gitStats.length
           });
         } else {
@@ -30196,6 +30027,7 @@ init_usage_tracker();
 init_model_health_registry();
 init_runtime_fallback();
 init_agent_display_names();
+init_claude_code_session_state();
 async function withTimeout(promise, timeoutMs, label) {
   let timer;
   return Promise.race([
@@ -30979,6 +30811,7 @@ function evaluatePermission(input, agentName) {
 
 // src/hooks/permission-ask-bridge/index.ts
 init_logger();
+init_claude_code_session_state();
 function createPermissionAskBridgeHook(ctx) {
   return {
     "permission.ask": async (input, output) => {
@@ -31012,8 +30845,8 @@ 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";
+import { existsSync as existsSync38, readFileSync as readFileSync30, writeFileSync as writeFileSync20, mkdirSync as mkdirSync16, renameSync as renameSync4, unlinkSync as unlinkSync12 } from "fs";
+import { join as join49 } from "path";
 async function safeExecute(fn, name, onAction) {
   try {
     await fn();
@@ -31058,11 +30891,11 @@ function countListItems(content) {
 }
 async function updatePlanSummary(data) {
   log(`[plan-completion] updatePlanSummary: ${data.planName}`);
-  if (!existsSync39(data.planPath)) {
+  if (!existsSync38(data.planPath)) {
     log(`[plan-completion] Plan file not found: ${data.planPath}`);
     return;
   }
-  const content = readFileSync31(data.planPath, "utf-8");
+  const content = readFileSync30(data.planPath, "utf-8");
   const startedAt = data.boulderState?.started_at || "";
   const completedAt = data.boulderState?.completed_at || "";
   const duration = formatDuration(startedAt, completedAt);
@@ -31083,17 +30916,17 @@ async function updatePlanSummary(data) {
 | \u5B8C\u6210\u4EFB\u52A1\u6570 | ${completedTasks} |
 | \u5931\u8D25\u4EFB\u52A1\u6570 | ${failedTasks} |
 `;
-  writeFileSync21(data.planPath, content + summary, "utf-8");
+  writeFileSync20(data.planPath, content + summary, "utf-8");
   log(`[plan-completion] Plan summary appended to ${data.planPath}`);
 }
 async function archivePlan(data) {
   log(`[plan-completion] archivePlan: ${data.planName}`);
-  const archivedDir = join52(data.directory, ".sisyphus", "archived");
-  if (!existsSync39(archivedDir)) {
-    mkdirSync17(archivedDir, { recursive: true });
+  const archivedDir = join49(data.directory, ".sisyphus", "archived");
+  if (!existsSync38(archivedDir)) {
+    mkdirSync16(archivedDir, { recursive: true });
   }
-  if (existsSync39(data.planPath)) {
-    const archivedPath = join52(archivedDir, `${data.planName}.md`);
+  if (existsSync38(data.planPath)) {
+    const archivedPath = join49(archivedDir, `${data.planName}.md`);
     renameSync4(data.planPath, archivedPath);
     log(`[plan-completion] Plan archived to ${archivedPath}`);
     const boulderState = readBoulderState(data.directory);
@@ -31103,16 +30936,16 @@ async function archivePlan(data) {
       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);
+  const draftPath = join49(data.directory, ".sisyphus", "drafts", `${data.planName}.md`);
+  if (existsSync38(draftPath)) {
+    unlinkSync12(draftPath);
     log(`[plan-completion] Deleted draft file: ${draftPath}`);
   }
 }
 async function extractLearnings(data) {
   log(`[plan-completion] extractLearnings: ${data.planName}`);
-  const notepadDir = join52(data.directory, ".sisyphus", "notepads", data.planName);
-  if (!existsSync39(notepadDir)) {
+  const notepadDir = join49(data.directory, ".sisyphus", "notepads", data.planName);
+  if (!existsSync38(notepadDir)) {
     log(`[plan-completion] Notepad directory not found: ${notepadDir}`);
     return;
   }
@@ -31122,9 +30955,9 @@ async function extractLearnings(data) {
   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");
+    const filePath = join49(notepadDir, file);
+    if (existsSync38(filePath)) {
+      const content = readFileSync30(filePath, "utf-8");
       contents[file] = content;
       const count = countListItems(content);
       if (file === "learnings.md")
@@ -31135,9 +30968,9 @@ async function extractLearnings(data) {
         totalDecisions = count;
     }
   }
-  const learningsDir = join52(data.directory, ".sisyphus", "learnings");
-  if (!existsSync39(learningsDir)) {
-    mkdirSync17(learningsDir, { recursive: true });
+  const learningsDir = join49(data.directory, ".sisyphus", "learnings");
+  if (!existsSync38(learningsDir)) {
+    mkdirSync16(learningsDir, { recursive: true });
   }
   const output = `# \u7ECF\u9A8C\u6559\u8BAD\u603B\u7ED3: ${data.planName}
 
@@ -31164,8 +30997,8 @@ ${contents["decisions.md"] || "\u65E0"}
 
 ${contents["match-failures.md"] || "\u65E0"}
 `;
-  const outputPath = join52(learningsDir, `${data.planName}.md`);
-  writeFileSync21(outputPath, output, "utf-8");
+  const outputPath = join49(learningsDir, `${data.planName}.md`);
+  writeFileSync20(outputPath, output, "utf-8");
   log(`[plan-completion] Learnings saved to ${outputPath}`);
   if (data.client?.tui?.showToast) {
     data.client.tui.showToast({
@@ -31184,9 +31017,9 @@ ${contents["match-failures.md"] || "\u65E0"}
 }
 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 reportsDir = join49(data.directory, ".sisyphus", "reports");
+  if (!existsSync38(reportsDir)) {
+    mkdirSync16(reportsDir, { recursive: true });
   }
   const startedAt = data.boulderState?.started_at || "";
   const completedAt = data.boulderState?.completed_at || "";
@@ -31197,8 +31030,8 @@ async function generateReport(data) {
   const version = data.boulderState?.version || 0;
   const sessionCount = data.boulderState?.session_ids?.length || 0;
   const completedIndices = data.boulderState?.completed_task_indices || [];
-  const notepadPath = join52(data.directory, ".sisyphus", "notepads", data.planName);
-  const hasNotepad = existsSync39(notepadPath);
+  const notepadPath = join49(data.directory, ".sisyphus", "notepads", data.planName);
+  const hasNotepad = existsSync38(notepadPath);
   const report = `# \u8BA1\u5212\u5B8C\u6210\u62A5\u544A
 
 ## \u6982\u89C8
@@ -31237,8 +31070,8 @@ ${hasNotepad ? `## \u8BB0\u4E8B\u672C
 \u8BB0\u4E8B\u672C\u8DEF\u5F84: ${notepadPath}
 ` : ""}
 `;
-  const reportPath = join52(reportsDir, `${data.planName}.md`);
-  writeFileSync21(reportPath, report, "utf-8");
+  const reportPath = join49(reportsDir, `${data.planName}.md`);
+  writeFileSync20(reportPath, report, "utf-8");
   log(`[plan-completion] Report generated at ${reportPath}`);
 }
 async function runInitDeep(data) {
@@ -31348,6 +31181,7 @@ class ContextCollector {
 var contextCollector = new ContextCollector;
 // src/features/context-injector/injector.ts
 init_shared();
+init_claude_code_session_state();
 function createContextInjectorMessagesTransformHook(collector) {
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
@@ -31449,8 +31283,8 @@ function createFirstMessageVariantGate() {
 }
 // src/features/claude-code-mcp-loader/loader.ts
 init_shared();
-import { existsSync as existsSync40, readFileSync as readFileSync32 } from "fs";
-import { join as join53 } from "path";
+import { existsSync as existsSync39, readFileSync as readFileSync31 } from "fs";
+import { join as join50 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
 function expandEnvVars(value) {
@@ -31520,13 +31354,13 @@ function getMcpConfigPaths() {
   const claudeConfigDir = getClaudeConfigDir();
   const cwd2 = process.cwd();
   return [
-    { path: join53(claudeConfigDir, ".mcp.json"), scope: "user" },
-    { path: join53(cwd2, ".mcp.json"), scope: "project" },
-    { path: join53(cwd2, ".claude", ".mcp.json"), scope: "local" }
+    { path: join50(claudeConfigDir, ".mcp.json"), scope: "user" },
+    { path: join50(cwd2, ".mcp.json"), scope: "project" },
+    { path: join50(cwd2, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync40(filePath)) {
+  if (!existsSync39(filePath)) {
     return null;
   }
   try {
@@ -31541,10 +31375,10 @@ function getSystemMcpServerNames() {
   const names = new Set;
   const paths = getMcpConfigPaths();
   for (const { path: path7 } of paths) {
-    if (!existsSync40(path7))
+    if (!existsSync39(path7))
       continue;
     try {
-      const content = readFileSync32(path7, "utf-8");
+      const content = readFileSync31(path7, "utf-8");
       const config = JSON.parse(content);
       if (!config?.mcpServers)
         continue;
@@ -31594,14 +31428,21 @@ async function loadMcpConfigs() {
   }
   return { servers, loadedServers };
 }
+// src/index.ts
+init_claude_code_session_state();
+
 // src/features/claude-code-session-state/recovery.ts
-import { existsSync as existsSync41, readdirSync as readdirSync13 } from "fs";
-import { join as join54 } from "path";
+import { existsSync as existsSync40, readdirSync as readdirSync13 } from "fs";
+import { join as join51 } from "path";
+init_state();
 init_logger();
-function recoverSessionAgents() {
+function recoverSessionAgents(directory) {
   let recoveredCount = 0;
+  if (directory) {
+    loadSessionAgentMap(directory);
+  }
   try {
-    if (!existsSync41(MESSAGE_STORAGE)) {
+    if (!existsSync40(MESSAGE_STORAGE)) {
       log("[recovery] MESSAGE_STORAGE directory does not exist", { path: MESSAGE_STORAGE });
       return 0;
     }
@@ -31609,13 +31450,13 @@ function recoverSessionAgents() {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const projectDir = join54(MESSAGE_STORAGE, entry.name);
+      const projectDir = join51(MESSAGE_STORAGE, entry.name);
       try {
         const sessionDirs = readdirSync13(projectDir, { withFileTypes: true });
         for (const sessionEntry of sessionDirs) {
           if (!sessionEntry.isDirectory())
             continue;
-          const sessionDir = join54(projectDir, sessionEntry.name);
+          const sessionDir = join51(projectDir, sessionEntry.name);
           const sessionID = sessionEntry.name;
           try {
             const msg = findNearestAssistantMessage(sessionDir);
@@ -32041,14 +31882,14 @@ var EXT_TO_LANG = {
   ".gql": "graphql"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync42, readFileSync as readFileSync33 } from "fs";
-import { join as join55 } from "path";
+import { existsSync as existsSync41, readFileSync as readFileSync32 } from "fs";
+import { join as join52 } from "path";
 init_shared();
 function loadJsonFile(path7) {
-  if (!existsSync42(path7))
+  if (!existsSync41(path7))
     return null;
   try {
-    return JSON.parse(readFileSync33(path7, "utf-8"));
+    return JSON.parse(readFileSync32(path7, "utf-8"));
   } catch {
     return null;
   }
@@ -32057,9 +31898,9 @@ function getConfigPaths3() {
   const cwd2 = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: join55(cwd2, ".opencode", "oh-my-opencode.json"),
-    user: join55(configDir, "oh-my-opencode.json"),
-    opencode: join55(configDir, "opencode.json")
+    project: join52(cwd2, ".opencode", "oh-my-opencode.json"),
+    user: join52(configDir, "oh-my-opencode.json"),
+    opencode: join52(configDir, "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -32172,7 +32013,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync42(cmd))
+    if (existsSync41(cmd))
       return true;
   }
   const isWindows2 = process.platform === "win32";
@@ -32194,23 +32035,23 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync42(join55(p, cmd + suffix))) {
+      if (existsSync41(join52(p, cmd + suffix))) {
         return true;
       }
     }
   }
   const cwd2 = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join55(getDataDir(), "opencode");
+  const dataDir = join52(getDataDir(), "opencode");
   const additionalBases = [
-    join55(cwd2, "node_modules", ".bin"),
-    join55(configDir, "bin"),
-    join55(configDir, "node_modules", ".bin"),
-    join55(dataDir, "bin")
+    join52(cwd2, "node_modules", ".bin"),
+    join52(configDir, "bin"),
+    join52(configDir, "node_modules", ".bin"),
+    join52(dataDir, "bin")
   ];
   for (const base of additionalBases) {
     for (const suffix of exts) {
-      if (existsSync42(join55(base, cmd + suffix))) {
+      if (existsSync41(join52(base, cmd + suffix))) {
         return true;
       }
     }
@@ -32222,7 +32063,7 @@ function isServerInstalled(command) {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn6 } = globalThis.Bun;
-import { readFileSync as readFileSync34 } from "fs";
+import { readFileSync as readFileSync33 } from "fs";
 import { extname, resolve as resolve8 } from "path";
 import { pathToFileURL } from "url";
 class LSPServerManager {
@@ -32673,7 +32514,7 @@ ${msg}`);
     const absPath = resolve8(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync34(absPath, "utf-8");
+    const text = readFileSync33(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -32763,17 +32604,17 @@ ${msg}`);
 // src/tools/lsp/utils.ts
 import { extname as extname2, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { existsSync as existsSync43, readFileSync as readFileSync35, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync34, writeFileSync as writeFileSync21 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve9(filePath);
-  if (!existsSync43(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync42(dir) || !__require("fs").statSync(dir).isDirectory()) {
     dir = __require("path").dirname(dir);
   }
   const markers = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
   let prevDir = "";
   while (dir !== prevDir) {
     for (const marker of markers) {
-      if (existsSync43(__require("path").join(dir, marker))) {
+      if (existsSync42(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -32928,7 +32769,7 @@ function formatPrepareRenameResult(result) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync35(filePath, "utf-8");
+    let content = readFileSync34(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -32953,7 +32794,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync22(filePath, lines.join(`
+    writeFileSync21(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -32984,7 +32825,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = uriToPath(change.uri);
-            writeFileSync22(filePath, "", "utf-8");
+            writeFileSync21(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -32994,8 +32835,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync35(oldPath, "utf-8");
-            writeFileSync22(newPath, content, "utf-8");
+            const content = readFileSync34(oldPath, "utf-8");
+            writeFileSync21(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -45574,13 +45415,13 @@ var lsp_rename = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname11, join as join57 } from "path";
-import { existsSync as existsSync45, statSync as statSync5 } from "fs";
+import { dirname as dirname11, join as join54 } from "path";
+import { existsSync as existsSync44, statSync as statSync5 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 init_shared();
-import { existsSync as existsSync44, mkdirSync as mkdirSync18, chmodSync as chmodSync2, unlinkSync as unlinkSync15 } from "fs";
-import { join as join56 } from "path";
+import { existsSync as existsSync43, mkdirSync as mkdirSync17, chmodSync as chmodSync2, unlinkSync as unlinkSync13 } from "fs";
+import { join as join53 } from "path";
 import { homedir as homedir13 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
@@ -45606,19 +45447,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join56(homedir13(), "AppData", "Local");
-    return join56(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join53(homedir13(), "AppData", "Local");
+    return join53(base2, "oh-my-opencode", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join56(homedir13(), ".cache");
-  return join56(base, "oh-my-opencode", "bin");
+  const base = xdgCache || join53(homedir13(), ".cache");
+  return join53(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join56(getCacheDir3(), getBinaryName3());
-  return existsSync44(binaryPath) ? binaryPath : null;
+  const binaryPath = join53(getCacheDir3(), getBinaryName3());
+  return existsSync43(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -45629,8 +45470,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join56(cacheDir, binaryName);
-  if (existsSync44(binaryPath)) {
+  const binaryPath = join53(cacheDir, binaryName);
+  if (existsSync43(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os6 } = platformInfo;
@@ -45638,21 +45479,21 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   console.log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    if (!existsSync44(cacheDir)) {
-      mkdirSync18(cacheDir, { recursive: true });
+    if (!existsSync43(cacheDir)) {
+      mkdirSync17(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join56(cacheDir, assetName);
+    const archivePath = join53(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
-    if (existsSync44(archivePath)) {
-      unlinkSync15(archivePath);
+    if (existsSync43(archivePath)) {
+      unlinkSync13(archivePath);
     }
-    if (process.platform !== "win32" && existsSync44(binaryPath)) {
+    if (process.platform !== "win32" && existsSync43(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -45703,8 +45544,8 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname11(cliPkgPath);
-    const sgPath = join57(cliDir, binaryName);
-    if (existsSync45(sgPath) && isValidBinary(sgPath)) {
+    const sgPath = join54(cliDir, binaryName);
+    if (existsSync44(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -45715,8 +45556,8 @@ function findSgCliPathSync() {
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname11(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join57(pkgDir, astGrepName);
-      if (existsSync45(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join54(pkgDir, astGrepName);
+      if (existsSync44(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -45724,7 +45565,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path7 of homebrewPaths) {
-      if (existsSync45(path7) && isValidBinary(path7)) {
+      if (existsSync44(path7) && isValidBinary(path7)) {
         return path7;
       }
     }
@@ -45779,11 +45620,11 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn7 } = globalThis.Bun;
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync46(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync45(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -45791,7 +45632,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync46(syncPath)) {
+    if (syncPath && existsSync45(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -45825,7 +45666,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync46(cliPath) && cliPath !== "sg") {
+  if (!existsSync45(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -46089,21 +45930,21 @@ var ast_grep_replace = tool({
 var {spawn: spawn9 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync48 } from "fs";
-import { join as join59, dirname as dirname12 } from "path";
+import { existsSync as existsSync47 } from "fs";
+import { join as join56, dirname as dirname12 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 
 // src/tools/grep/downloader.ts
 init_shared();
-import { existsSync as existsSync47, mkdirSync as mkdirSync19, chmodSync as chmodSync3, unlinkSync as unlinkSync16, readdirSync as readdirSync14 } from "fs";
-import { join as join58 } from "path";
+import { existsSync as existsSync46, mkdirSync as mkdirSync18, chmodSync as chmodSync3, unlinkSync as unlinkSync14, readdirSync as readdirSync14 } from "fs";
+import { join as join55 } from "path";
 var {spawn: spawn8 } = globalThis.Bun;
 function findFileRecursive(dir, filename) {
   try {
     const entries = readdirSync14(dir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
-        return join58(entry.parentPath ?? dir, entry.name);
+        return join55(entry.parentPath ?? dir, entry.name);
       }
     }
   } catch {
@@ -46124,11 +45965,11 @@ function getPlatformKey() {
 }
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join58(homeDir, ".cache", "oh-my-opencode", "bin");
+  return join55(homeDir, ".cache", "oh-my-opencode", "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join58(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join55(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 async function downloadFile(url2, destPath) {
   const response = await fetch(url2);
@@ -46162,7 +46003,7 @@ async function extractZip2(archivePath, destDir) {
   const binaryName = process.platform === "win32" ? "rg.exe" : "rg";
   const foundPath = findFileRecursive(destDir, binaryName);
   if (foundPath) {
-    const destPath = join58(destDir, binaryName);
+    const destPath = join55(destDir, binaryName);
     if (foundPath !== destPath) {
       const { renameSync: renameSync5 } = await import("fs");
       renameSync5(foundPath, destPath);
@@ -46177,13 +46018,13 @@ async function downloadAndInstallRipgrep() {
   }
   const installDir = getInstallDir();
   const rgPath = getRgPath();
-  if (existsSync47(rgPath)) {
+  if (existsSync46(rgPath)) {
     return rgPath;
   }
-  mkdirSync19(installDir, { recursive: true });
+  mkdirSync18(installDir, { recursive: true });
   const filename = `ripgrep-${RG_VERSION}-${config3.platform}.${config3.extension}`;
   const url2 = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/${filename}`;
-  const archivePath = join58(installDir, filename);
+  const archivePath = join55(installDir, filename);
   try {
     await downloadFile(url2, archivePath);
     if (config3.extension === "tar.gz") {
@@ -46194,21 +46035,21 @@ async function downloadAndInstallRipgrep() {
     if (process.platform !== "win32") {
       chmodSync3(rgPath, 493);
     }
-    if (!existsSync47(rgPath)) {
+    if (!existsSync46(rgPath)) {
       throw new Error("\u63D0\u53D6\u540E\u672A\u627E\u5230 ripgrep \u4E8C\u8FDB\u5236\u6587\u4EF6");
     }
     return rgPath;
   } finally {
-    if (existsSync47(archivePath)) {
+    if (existsSync46(archivePath)) {
       try {
-        unlinkSync16(archivePath);
+        unlinkSync14(archivePath);
       } catch {}
     }
   }
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync47(rgPath) ? rgPath : null;
+  return existsSync46(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -46232,7 +46073,7 @@ function findExecutable(name) {
             continue;
           }
         }
-        if (existsSync48(trimmed)) {
+        if (existsSync47(trimmed)) {
           return trimmed;
         }
       }
@@ -46247,14 +46088,14 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
-    join59(getDataDir(), "opencode", "bin", rgName),
-    join59(execDir, rgName),
-    join59(execDir, "bin", rgName),
-    join59(execDir, "..", "bin", rgName),
-    join59(execDir, "..", "libexec", rgName)
+    join56(getDataDir(), "opencode", "bin", rgName),
+    join56(execDir, rgName),
+    join56(execDir, "bin", rgName),
+    join56(execDir, "..", "bin", rgName),
+    join56(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync48(candidate)) {
+    if (existsSync47(candidate)) {
       return candidate;
     }
   }
@@ -46716,8 +46557,8 @@ var glob = tool({
 init_shared();
 init_file_utils();
 init_shared();
-import { existsSync as existsSync49, readdirSync as readdirSync15, readFileSync as readFileSync36 } from "fs";
-import { join as join60, basename as basename4, dirname as dirname13 } from "path";
+import { existsSync as existsSync48, readdirSync as readdirSync15, readFileSync as readFileSync35 } from "fs";
+import { join as join57, basename as basename4, dirname as dirname13 } from "path";
 // src/features/builtin-commands/templates/init-deep.ts
 var INIT_DEEP_TEMPLATE = `# /init-deep
 
@@ -47862,7 +47703,7 @@ function loadBuiltinCommands(disabledCommands) {
 }
 // src/tools/slashcommand/tools.ts
 function discoverCommandsFromDir2(commandsDir, scope) {
-  if (!existsSync49(commandsDir)) {
+  if (!existsSync48(commandsDir)) {
     return [];
   }
   const entries = readdirSync15(commandsDir, { withFileTypes: true });
@@ -47870,10 +47711,10 @@ function discoverCommandsFromDir2(commandsDir, scope) {
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join60(commandsDir, entry.name);
+    const commandPath = join57(commandsDir, entry.name);
     const commandName = basename4(entry.name, ".md");
     try {
-      const content = readFileSync36(commandPath, "utf-8");
+      const content = readFileSync35(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -47899,10 +47740,10 @@ function discoverCommandsFromDir2(commandsDir, scope) {
 }
 function discoverCommandsSync(disabledCommands) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  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 userCommandsDir = join57(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join57(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join57(configDir, "command");
+  const opencodeProjectDir = join57(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir2(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir2(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir2(projectCommandsDir, "project");
@@ -48102,13 +47943,13 @@ var slashcommand = createSlashcommandTool();
 // src/tools/session-manager/constants.ts
 init_data_path();
 init_shared();
-import { join as join61 } from "path";
-var OPENCODE_STORAGE11 = getOpenCodeStorageDir();
-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");
+import { join as join58 } from "path";
+var OPENCODE_STORAGE9 = getOpenCodeStorageDir();
+var MESSAGE_STORAGE4 = join58(OPENCODE_STORAGE9, "message");
+var PART_STORAGE4 = join58(OPENCODE_STORAGE9, "part");
+var SESSION_STORAGE = join58(OPENCODE_STORAGE9, "session");
+var TODO_DIR2 = join58(getClaudeConfigDir(), "todos");
+var TRANSCRIPT_DIR2 = join58(getClaudeConfigDir(), "transcripts");
 var SESSION_LIST_DESCRIPTION = `\u5217\u51FA\u6240\u6709 OpenCode session\uFF0C\u652F\u6301\u53EF\u9009\u8FC7\u6EE4\u3002
 
 \u8FD4\u56DE\u53EF\u7528\u7684 session ID \u5217\u8868\uFF0C\u5305\u542B\u6D88\u606F\u6570\u91CF\u3001\u65E5\u671F\u8303\u56F4\u548C\u4F7F\u7528\u8FC7\u7684 agents \u7B49\u5143\u6570\u636E\u3002
@@ -48181,11 +48022,11 @@ Has Todos: Yes (12 items, 8 completed)
 Has Transcript: Yes (234 entries)`;
 
 // src/tools/session-manager/storage.ts
-import { existsSync as existsSync50, readdirSync as readdirSync16 } from "fs";
+import { existsSync as existsSync49, readdirSync as readdirSync16 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { join as join62 } from "path";
+import { join as join59 } from "path";
 async function getMainSessions(options) {
-  if (!existsSync50(SESSION_STORAGE))
+  if (!existsSync49(SESSION_STORAGE))
     return [];
   const sessions = [];
   try {
@@ -48193,13 +48034,13 @@ async function getMainSessions(options) {
     for (const projectDir of projectDirs) {
       if (!projectDir.isDirectory())
         continue;
-      const projectPath = join62(SESSION_STORAGE, projectDir.name);
+      const projectPath = join59(SESSION_STORAGE, projectDir.name);
       const sessionFiles = await readdir(projectPath);
       for (const file2 of sessionFiles) {
         if (!file2.endsWith(".json"))
           continue;
         try {
-          const content = await readFile(join62(projectPath, file2), "utf-8");
+          const content = await readFile(join59(projectPath, file2), "utf-8");
           const meta = JSON.parse(content);
           if (meta.parentID)
             continue;
@@ -48217,7 +48058,7 @@ async function getMainSessions(options) {
   return sessions.sort((a, b) => b.time.updated - a.time.updated);
 }
 async function getAllSessions() {
-  if (!existsSync50(MESSAGE_STORAGE4))
+  if (!existsSync49(MESSAGE_STORAGE4))
     return [];
   const sessions = [];
   async function scanDirectory(dir) {
@@ -48225,7 +48066,7 @@ async function getAllSessions() {
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const sessionPath = join62(dir, entry.name);
+          const sessionPath = join59(dir, entry.name);
           const files = await readdir(sessionPath);
           if (files.some((f) => f.endsWith(".json"))) {
             sessions.push(entry.name);
@@ -48242,16 +48083,16 @@ async function getAllSessions() {
   return [...new Set(sessions)];
 }
 function getMessageDir6(sessionID) {
-  if (!existsSync50(MESSAGE_STORAGE4))
+  if (!existsSync49(MESSAGE_STORAGE4))
     return "";
-  const directPath = join62(MESSAGE_STORAGE4, sessionID);
-  if (existsSync50(directPath)) {
+  const directPath = join59(MESSAGE_STORAGE4, sessionID);
+  if (existsSync49(directPath)) {
     return directPath;
   }
   try {
     for (const dir of readdirSync16(MESSAGE_STORAGE4)) {
-      const sessionPath = join62(MESSAGE_STORAGE4, dir, sessionID);
-      if (existsSync50(sessionPath)) {
+      const sessionPath = join59(MESSAGE_STORAGE4, dir, sessionID);
+      if (existsSync49(sessionPath)) {
         return sessionPath;
       }
     }
@@ -48265,7 +48106,7 @@ function sessionExists(sessionID) {
 }
 async function readSessionMessages(sessionID) {
   const messageDir = getMessageDir6(sessionID);
-  if (!messageDir || !existsSync50(messageDir))
+  if (!messageDir || !existsSync49(messageDir))
     return [];
   const messages = [];
   try {
@@ -48274,7 +48115,7 @@ async function readSessionMessages(sessionID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join62(messageDir, file2), "utf-8");
+        const content = await readFile(join59(messageDir, file2), "utf-8");
         const meta = JSON.parse(content);
         const parts = await readParts2(meta.id);
         messages.push({
@@ -48300,8 +48141,8 @@ async function readSessionMessages(sessionID) {
   });
 }
 async function readParts2(messageID) {
-  const partDir = join62(PART_STORAGE4, messageID);
-  if (!existsSync50(partDir))
+  const partDir = join59(PART_STORAGE4, messageID);
+  if (!existsSync49(partDir))
     return [];
   const parts = [];
   try {
@@ -48310,7 +48151,7 @@ async function readParts2(messageID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join62(partDir, file2), "utf-8");
+        const content = await readFile(join59(partDir, file2), "utf-8");
         parts.push(JSON.parse(content));
       } catch {
         continue;
@@ -48322,14 +48163,14 @@ async function readParts2(messageID) {
   return parts.sort((a, b) => a.id.localeCompare(b.id));
 }
 async function readSessionTodos(sessionID) {
-  if (!existsSync50(TODO_DIR2))
+  if (!existsSync49(TODO_DIR2))
     return [];
   try {
     const allFiles = await readdir(TODO_DIR2);
     const todoFiles = allFiles.filter((f) => f.includes(sessionID) && f.endsWith(".json"));
     for (const file2 of todoFiles) {
       try {
-        const content = await readFile(join62(TODO_DIR2, file2), "utf-8");
+        const content = await readFile(join59(TODO_DIR2, file2), "utf-8");
         const data = JSON.parse(content);
         if (Array.isArray(data)) {
           return data.map((item) => ({
@@ -48349,10 +48190,10 @@ async function readSessionTodos(sessionID) {
   return [];
 }
 async function readSessionTranscript(sessionID) {
-  if (!existsSync50(TRANSCRIPT_DIR2))
+  if (!existsSync49(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join62(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync50(transcriptFile))
+  const transcriptFile = join59(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  if (!existsSync49(transcriptFile))
     return 0;
   try {
     const content = await readFile(transcriptFile, "utf-8");
@@ -49175,6 +49016,7 @@ var BACKGROUND_OUTPUT_DESCRIPTION = `\u83B7\u53D6\u540E\u53F0\u4EFB\u52A1\u7684\
 var BACKGROUND_CANCEL_DESCRIPTION = `\u53D6\u6D88\u6B63\u5728\u8FD0\u884C\u7684\u540E\u53F0\u4EFB\u52A1\u3002\u4F7F\u7528 all=true \u53EF\u5728\u6700\u7EC8\u56DE\u7B54\u524D\u53D6\u6D88\u6240\u6709\u4EFB\u52A1\u3002`;
 
 // src/tools/background-task/tools.ts
+init_claude_code_session_state();
 init_logger();
 init_session_cursor();
 init_agent_display_names();
@@ -49559,20 +49401,21 @@ var CALL_OMO_AGENT_DESCRIPTION = `\u542F\u52A8\u6DF1\u5EA6\u63A2\u7D22/\u77E5\u8
 
 \u4F20\u5165 \`session_id=<id>\` \u53EF\u7EE7\u7EED\u4E4B\u524D\u7684 agent\uFF0C\u4FDD\u7559\u5B8C\u6574\u4E0A\u4E0B\u6587\u3002Prompts \u5FC5\u987B\u4E3A\u4E2D\u6587\u3002\u4F7F\u7528 \`background_output\` \u83B7\u53D6\u5F02\u6B65\u7ED3\u679C\u3002`;
 // src/tools/call-omo-agent/tools.ts
-import { existsSync as existsSync51, readdirSync as readdirSync17 } from "fs";
-import { join as join63 } from "path";
+import { existsSync as existsSync50, readdirSync as readdirSync17 } from "fs";
+import { join as join60 } from "path";
 init_shared();
 init_agent_display_names();
 init_session_cursor();
+init_claude_code_session_state();
 function getMessageDir7(sessionID) {
-  if (!existsSync51(MESSAGE_STORAGE))
+  if (!existsSync50(MESSAGE_STORAGE))
     return null;
-  const directPath = join63(MESSAGE_STORAGE, sessionID);
-  if (existsSync51(directPath))
+  const directPath = join60(MESSAGE_STORAGE, sessionID);
+  if (existsSync50(directPath))
     return directPath;
   for (const dir of readdirSync17(MESSAGE_STORAGE)) {
-    const sessionPath = join63(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync51(sessionPath))
+    const sessionPath = join60(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync50(sessionPath))
       return sessionPath;
   }
   return null;
@@ -49998,8 +49841,8 @@ function createLookAt(ctx) {
 }
 // src/tools/delegate-task/tools.ts
 init_constants();
-import { existsSync as existsSync52, readdirSync as readdirSync18 } from "fs";
-import { join as join64 } from "path";
+import { existsSync as existsSync51, readdirSync as readdirSync18 } from "fs";
+import { join as join61 } from "path";
 
 // src/features/task-toast-manager/manager.ts
 class TaskToastManager {
@@ -50175,10 +50018,12 @@ function initTaskToastManager(client2, concurrencyManager) {
   return instance;
 }
 // src/tools/delegate-task/tools.ts
+init_claude_code_session_state();
 init_shared();
 init_agent_display_names();
 init_runtime_fallback();
 init_model_health_registry();
+init_agent_identity_resolver();
 var SISYPHUS_JUNIOR_AGENT = "\u6267\u884C\u52A9\u7406";
 var MAX_LOOP_ATTEMPTS = 10;
 function sleep(ms) {
@@ -50205,14 +50050,14 @@ function parseFallbackModelEntries(entries) {
   });
 }
 function getMessageDir8(sessionID) {
-  if (!existsSync52(MESSAGE_STORAGE))
+  if (!existsSync51(MESSAGE_STORAGE))
     return null;
-  const directPath = join64(MESSAGE_STORAGE, sessionID);
-  if (existsSync52(directPath))
+  const directPath = join61(MESSAGE_STORAGE, sessionID);
+  if (existsSync51(directPath))
     return directPath;
   for (const dir of readdirSync18(MESSAGE_STORAGE)) {
-    const sessionPath = join64(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync52(sessionPath))
+    const sessionPath = join61(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync51(sessionPath))
       return sessionPath;
   }
   return null;
@@ -50294,18 +50139,30 @@ function buildSystemContent(input) {
 
 `);
 }
-function extractResumeInfoFromMessages(messages) {
-  let agent;
-  let model;
+function extractResumeInfoFromMessages(sessionID, messages) {
+  const resolvedAgent = resolveCurrentAgent(sessionID);
+  if (resolvedAgent) {
+    for (let i = messages.length - 1;i >= 0; i--) {
+      const info = messages[i].info;
+      if (info?.model || info?.modelID && info?.providerID) {
+        return {
+          agent: resolvedAgent,
+          model: info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined)
+        };
+      }
+    }
+    return { agent: resolvedAgent, model: undefined };
+  }
   for (let i = messages.length - 1;i >= 0; i--) {
     const info = messages[i].info;
     if (info?.role === "assistant" && (info?.agent || info?.model || info?.modelID && info?.providerID)) {
-      agent = info.agent;
-      model = info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined);
-      break;
+      return {
+        agent: info.agent,
+        model: info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined)
+      };
     }
   }
-  return { agent, model };
+  return { agent: undefined, model: undefined };
 }
 async function pollTaskCompletion(client2, sessionID, maxWaitMs = 120000, pollIntervalMs = 2000) {
   const startTime = Date.now();
@@ -50483,7 +50340,7 @@ Agent \u7EE7\u7EED\u6267\u884C\uFF0C\u4FDD\u7559\u5B8C\u6574\u4E0A\u4E0B\u6587\u
           try {
             const messagesResp = await client2.session.messages({ path: { id: args.session_id } });
             const messages2 = messagesResp.data ?? [];
-            const resumeInfo = extractResumeInfoFromMessages(messages2);
+            const resumeInfo = extractResumeInfoFromMessages(args.session_id, messages2);
             resumeAgent = resumeInfo.agent;
             resumeModel = resumeInfo.model;
           } catch {
@@ -51308,8 +51165,10 @@ class PerformanceAggregator {
 }
 
 // src/features/background-agent/manager.ts
-import { existsSync as existsSync53, readdirSync as readdirSync19 } from "fs";
-import { join as join65 } from "path";
+init_claude_code_session_state();
+init_agent_identity_resolver();
+import { existsSync as existsSync52, readdirSync as readdirSync19 } from "fs";
+import { join as join62 } from "path";
 var TASK_TTL_MS = 30 * 60 * 1000;
 var MIN_STABILITY_TIME_MS = 10 * 1000;
 var DEFAULT_STALE_TIMEOUT_MS = 120000;
@@ -52102,15 +51961,15 @@ ${perfSnapshot ? `| \u6392\u961F ${PerfTimer.formatDuration(new Date(0), new Dat
 \u4F7F\u7528 \`background_output(task_id="${task.id}")\` \u5728\u51C6\u5907\u5C31\u7EEA\u65F6\u83B7\u53D6\u6B64\u7ED3\u679C\u3002
 </system-reminder>`;
     }
-    let agent = task.parentAgent;
+    const currentParentAgent = resolveCurrentAgent(task.parentSessionID);
+    const agent = currentParentAgent ?? task.parentAgent;
     let model;
     try {
       const messagesResp = await this.client.session.messages({ path: { id: task.parentSessionID } });
       const messages = messagesResp.data ?? [];
       for (let i = messages.length - 1;i >= 0; i--) {
         const info = messages[i].info;
-        if (info?.agent || info?.model || info?.modelID && info?.providerID) {
-          agent = info.agent ?? task.parentAgent;
+        if (info?.model || info?.modelID && info?.providerID) {
           model = info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined);
           break;
         }
@@ -52118,7 +51977,6 @@ ${perfSnapshot ? `| \u6392\u961F ${PerfTimer.formatDuration(new Date(0), new Dat
     } catch {
       const messageDir = getMessageDir9(task.parentSessionID);
       const currentMessage = messageDir ? findNearestAssistantMessage(messageDir) : null;
-      agent = currentMessage?.agent ?? task.parentAgent;
       model = currentMessage?.model?.providerID && currentMessage?.model?.modelID ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID } : undefined;
     }
     log("[background-agent] notifyParentSession context:", {
@@ -52483,14 +52341,14 @@ function registerProcessSignal(signal, handler, exitAfter) {
   return listener;
 }
 function getMessageDir9(sessionID) {
-  if (!existsSync53(MESSAGE_STORAGE))
+  if (!existsSync52(MESSAGE_STORAGE))
     return null;
-  const directPath = join65(MESSAGE_STORAGE, sessionID);
-  if (existsSync53(directPath))
+  const directPath = join62(MESSAGE_STORAGE, sessionID);
+  if (existsSync52(directPath))
     return directPath;
   for (const dir of readdirSync19(MESSAGE_STORAGE)) {
-    const sessionPath = join65(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync53(sessionPath))
+    const sessionPath = join62(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync52(sessionPath))
       return sessionPath;
   }
   return null;
@@ -71221,8 +71079,7 @@ var HookNameSchema = exports_external2.enum([
   "prometheus-md-only",
   "perf-profiler",
   "start-work",
-  "language-reminder",
-  "thinking-language-validator",
+  "system-language-injector",
   "atlas",
   "tool-definition-optimizer",
   "permission-ask-bridge",
@@ -71453,7 +71310,7 @@ var LanguageEnforcementConfigSchema = exports_external2.object({
   enabled: exports_external2.boolean().default(true),
   reminder_interval: exports_external2.number().int().positive().default(5),
   violation_threshold: exports_external2.number().min(0).max(1).default(0.6),
-  excluded_agents: exports_external2.array(exports_external2.string()).default(["\u77E5\u8BC6\u5178\u85CF", "\u5A92\u4F53\u89E3\u6790"]),
+  excluded_agents: exports_external2.array(exports_external2.string()).default([]),
   user_message_english_threshold: exports_external2.number().min(0).max(1).default(0.6),
   user_message_lookback: exports_external2.number().int().positive().default(3)
 }).optional();
@@ -71715,7 +71572,7 @@ init_file_utils();
 init_shared();
 init_logger();
 import { promises as fs11 } from "fs";
-import { join as join67, basename as basename6 } from "path";
+import { join as join64, basename as basename6 } from "path";
 async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "") {
   try {
     await fs11.access(commandsDir);
@@ -71745,7 +71602,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     if (entry.isDirectory()) {
       if (entry.name.startsWith("."))
         continue;
-      const subDirPath = join67(commandsDir, entry.name);
+      const subDirPath = join64(commandsDir, entry.name);
       const subPrefix = prefix ? `${prefix}:${entry.name}` : entry.name;
       const subCommands = await loadCommandsFromDir(subDirPath, scope, visited, subPrefix);
       commands2.push(...subCommands);
@@ -71753,7 +71610,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     }
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join67(commandsDir, entry.name);
+    const commandPath = join64(commandsDir, entry.name);
     const baseCommandName = basename6(entry.name, ".md");
     const commandName = prefix ? `${prefix}:${baseCommandName}` : baseCommandName;
     try {
@@ -71800,23 +71657,23 @@ function commandsToRecord(commands2) {
   return result;
 }
 async function loadUserCommands() {
-  const userCommandsDir = join67(getClaudeConfigDir(), "commands");
+  const userCommandsDir = join64(getClaudeConfigDir(), "commands");
   const commands2 = await loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands2);
 }
 async function loadProjectCommands() {
-  const projectCommandsDir = join67(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join64(process.cwd(), ".claude", "commands");
   const commands2 = await loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands2);
 }
 async function loadOpencodeGlobalCommands() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeCommandsDir = join67(configDir, "command");
+  const opencodeCommandsDir = join64(configDir, "command");
   const commands2 = await loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands2);
 }
 async function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join67(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join64(process.cwd(), ".opencode", "command");
   const commands2 = await loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands2);
 }
@@ -71824,8 +71681,8 @@ async function loadOpencodeProjectCommands() {
 init_frontmatter();
 init_file_utils();
 init_shared();
-import { existsSync as existsSync55, readdirSync as readdirSync20, readFileSync as readFileSync38 } from "fs";
-import { join as join68, basename as basename7 } from "path";
+import { existsSync as existsSync54, readdirSync as readdirSync20, readFileSync as readFileSync37 } from "fs";
+import { join as join65, basename as basename7 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -71839,7 +71696,7 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope, leConfig) {
-  if (!existsSync55(agentsDir)) {
+  if (!existsSync54(agentsDir)) {
     return [];
   }
   const entries = readdirSync20(agentsDir, { withFileTypes: true });
@@ -71847,10 +71704,10 @@ function loadAgentsFromDir(agentsDir, scope, leConfig) {
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join68(agentsDir, entry.name);
+    const agentPath = join65(agentsDir, entry.name);
     const agentName = basename7(entry.name, ".md");
     try {
-      const content = readFileSync38(agentPath, "utf-8");
+      const content = readFileSync37(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -71879,7 +71736,7 @@ function loadAgentsFromDir(agentsDir, scope, leConfig) {
   return agents;
 }
 function loadUserAgents(leConfig) {
-  const userAgentsDir = join68(getClaudeConfigDir(), "agents");
+  const userAgentsDir = join65(getClaudeConfigDir(), "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user", leConfig);
   const result = {};
   for (const agent of agents) {
@@ -71888,7 +71745,7 @@ function loadUserAgents(leConfig) {
   return result;
 }
 function loadProjectAgents(leConfig) {
-  const projectAgentsDir = join68(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join65(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project", leConfig);
   const result = {};
   for (const agent of agents) {
@@ -71900,18 +71757,18 @@ function loadProjectAgents(leConfig) {
 init_frontmatter();
 init_file_utils();
 init_logger();
-import { existsSync as existsSync56, readdirSync as readdirSync21, readFileSync as readFileSync39 } from "fs";
+import { existsSync as existsSync55, readdirSync as readdirSync21, readFileSync as readFileSync38 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join69, basename as basename8 } from "path";
+import { join as join66, basename as basename8 } from "path";
 var CLAUDE_PLUGIN_ROOT_VAR = "${CLAUDE_PLUGIN_ROOT}";
 function getPluginsBaseDir() {
   if (process.env.CLAUDE_PLUGINS_HOME) {
     return process.env.CLAUDE_PLUGINS_HOME;
   }
-  return join69(homedir14(), ".claude", "plugins");
+  return join66(homedir14(), ".claude", "plugins");
 }
 function getInstalledPluginsPath() {
-  return join69(getPluginsBaseDir(), "installed_plugins.json");
+  return join66(getPluginsBaseDir(), "installed_plugins.json");
 }
 function resolvePluginPath(path8, pluginRoot) {
   return path8.replace(CLAUDE_PLUGIN_ROOT_VAR, pluginRoot);
@@ -71936,11 +71793,11 @@ function resolvePluginPaths(obj, pluginRoot) {
 }
 function loadInstalledPlugins() {
   const dbPath = getInstalledPluginsPath();
-  if (!existsSync56(dbPath)) {
+  if (!existsSync55(dbPath)) {
     return null;
   }
   try {
-    const content = readFileSync39(dbPath, "utf-8");
+    const content = readFileSync38(dbPath, "utf-8");
     return JSON.parse(content);
   } catch (error95) {
     log("Failed to load installed plugins database", error95);
@@ -71951,15 +71808,15 @@ function getClaudeSettingsPath() {
   if (process.env.CLAUDE_SETTINGS_PATH) {
     return process.env.CLAUDE_SETTINGS_PATH;
   }
-  return join69(homedir14(), ".claude", "settings.json");
+  return join66(homedir14(), ".claude", "settings.json");
 }
 function loadClaudeSettings() {
   const settingsPath = getClaudeSettingsPath();
-  if (!existsSync56(settingsPath)) {
+  if (!existsSync55(settingsPath)) {
     return null;
   }
   try {
-    const content = readFileSync39(settingsPath, "utf-8");
+    const content = readFileSync38(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch (error95) {
     log("Failed to load Claude settings", error95);
@@ -71967,12 +71824,12 @@ function loadClaudeSettings() {
   }
 }
 function loadPluginManifest(installPath) {
-  const manifestPath = join69(installPath, ".claude-plugin", "plugin.json");
-  if (!existsSync56(manifestPath)) {
+  const manifestPath = join66(installPath, ".claude-plugin", "plugin.json");
+  if (!existsSync55(manifestPath)) {
     return null;
   }
   try {
-    const content = readFileSync39(manifestPath, "utf-8");
+    const content = readFileSync38(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error95) {
     log(`Failed to load plugin manifest from ${manifestPath}`, error95);
@@ -72019,7 +71876,7 @@ function discoverInstalledPlugins(options) {
       continue;
     }
     const { installPath, scope, version: version3 } = installation;
-    if (!existsSync56(installPath)) {
+    if (!existsSync55(installPath)) {
       errors5.push({
         pluginKey,
         installPath,
@@ -72037,21 +71894,21 @@ function discoverInstalledPlugins(options) {
       pluginKey,
       manifest: manifest ?? undefined
     };
-    if (existsSync56(join69(installPath, "commands"))) {
-      loadedPlugin.commandsDir = join69(installPath, "commands");
+    if (existsSync55(join66(installPath, "commands"))) {
+      loadedPlugin.commandsDir = join66(installPath, "commands");
     }
-    if (existsSync56(join69(installPath, "agents"))) {
-      loadedPlugin.agentsDir = join69(installPath, "agents");
+    if (existsSync55(join66(installPath, "agents"))) {
+      loadedPlugin.agentsDir = join66(installPath, "agents");
     }
-    if (existsSync56(join69(installPath, "skills"))) {
-      loadedPlugin.skillsDir = join69(installPath, "skills");
+    if (existsSync55(join66(installPath, "skills"))) {
+      loadedPlugin.skillsDir = join66(installPath, "skills");
     }
-    const hooksPath = join69(installPath, "hooks", "hooks.json");
-    if (existsSync56(hooksPath)) {
+    const hooksPath = join66(installPath, "hooks", "hooks.json");
+    if (existsSync55(hooksPath)) {
       loadedPlugin.hooksPath = hooksPath;
     }
-    const mcpPath = join69(installPath, ".mcp.json");
-    if (existsSync56(mcpPath)) {
+    const mcpPath = join66(installPath, ".mcp.json");
+    if (existsSync55(mcpPath)) {
       loadedPlugin.mcpPath = mcpPath;
     }
     plugins.push(loadedPlugin);
@@ -72062,17 +71919,17 @@ function discoverInstalledPlugins(options) {
 function loadPluginCommands(plugins) {
   const commands2 = {};
   for (const plugin of plugins) {
-    if (!plugin.commandsDir || !existsSync56(plugin.commandsDir))
+    if (!plugin.commandsDir || !existsSync55(plugin.commandsDir))
       continue;
     const entries = readdirSync21(plugin.commandsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const commandPath = join69(plugin.commandsDir, entry.name);
+      const commandPath = join66(plugin.commandsDir, entry.name);
       const commandName = basename8(entry.name, ".md");
       const namespacedName = `${plugin.name}:${commandName}`;
       try {
-        const content = readFileSync39(commandPath, "utf-8");
+        const content = readFileSync38(commandPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -72104,21 +71961,21 @@ $ARGUMENTS
 function loadPluginSkillsAsCommands(plugins) {
   const skills = {};
   for (const plugin of plugins) {
-    if (!plugin.skillsDir || !existsSync56(plugin.skillsDir))
+    if (!plugin.skillsDir || !existsSync55(plugin.skillsDir))
       continue;
     const entries = readdirSync21(plugin.skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith("."))
         continue;
-      const skillPath = join69(plugin.skillsDir, entry.name);
+      const skillPath = join66(plugin.skillsDir, entry.name);
       if (!entry.isDirectory() && !entry.isSymbolicLink())
         continue;
       const resolvedPath = resolveSymlink(skillPath);
-      const skillMdPath = join69(resolvedPath, "SKILL.md");
-      if (!existsSync56(skillMdPath))
+      const skillMdPath = join66(resolvedPath, "SKILL.md");
+      if (!existsSync55(skillMdPath))
         continue;
       try {
-        const content = readFileSync39(skillMdPath, "utf-8");
+        const content = readFileSync38(skillMdPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const skillName = data.name || entry.name;
         const namespacedName = `${plugin.name}:${skillName}`;
@@ -72165,17 +72022,17 @@ function parseToolsConfig2(toolsStr) {
 function loadPluginAgents(plugins) {
   const agents = {};
   for (const plugin of plugins) {
-    if (!plugin.agentsDir || !existsSync56(plugin.agentsDir))
+    if (!plugin.agentsDir || !existsSync55(plugin.agentsDir))
       continue;
     const entries = readdirSync21(plugin.agentsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const agentPath = join69(plugin.agentsDir, entry.name);
+      const agentPath = join66(plugin.agentsDir, entry.name);
       const agentName = basename8(entry.name, ".md");
       const namespacedName = `${plugin.name}:${agentName}`;
       try {
-        const content = readFileSync39(agentPath, "utf-8");
+        const content = readFileSync38(agentPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const name = data.name || agentName;
         const originalDescription = data.description || "";
@@ -72201,7 +72058,7 @@ function loadPluginAgents(plugins) {
 async function loadPluginMcpServers(plugins) {
   const servers = {};
   for (const plugin of plugins) {
-    if (!plugin.mcpPath || !existsSync56(plugin.mcpPath))
+    if (!plugin.mcpPath || !existsSync55(plugin.mcpPath))
       continue;
     try {
       const content = await Bun.file(plugin.mcpPath).text();
@@ -72233,10 +72090,10 @@ async function loadPluginMcpServers(plugins) {
 function loadPluginHooksConfigs(plugins) {
   const configs = [];
   for (const plugin of plugins) {
-    if (!plugin.hooksPath || !existsSync56(plugin.hooksPath))
+    if (!plugin.hooksPath || !existsSync55(plugin.hooksPath))
       continue;
     try {
-      const content = readFileSync39(plugin.hooksPath, "utf-8");
+      const content = readFileSync38(plugin.hooksPath, "utf-8");
       let config4 = JSON.parse(content);
       config4 = resolvePluginPaths(config4, plugin.installPath);
       configs.push(config4);
@@ -73654,11 +73511,7 @@ function createConfigHandler(deps) {
       if (isLanguageEnforcementEnabled(pluginConfig)) {
         const prometheusAgent = agentConfig["\u6218\u7565\u53C2\u8C0B"];
         if (prometheusAgent?.prompt && !prometheusAgent.prompt.includes("<Language_Instruction>")) {
-          if (isDeepseekModel(prometheusAgent.model ?? "")) {
-            prometheusAgent.prompt += ZH_LANGUAGE_INSTRUCTION_DEEPSEEK;
-          } else {
-            prometheusAgent.prompt += ZH_LANGUAGE_INSTRUCTION;
-          }
+          prometheusAgent.prompt += ZH_LANGUAGE_INSTRUCTION;
         }
       }
       if (isLanguageEnforcementEnabled(pluginConfig)) {
@@ -73857,7 +73710,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
     return;
   }
   log("[OhMyOpenCodePlugin] Starting session agent recovery...");
-  const recoveredAgents = recoverSessionAgents();
+  const recoveredAgents = recoverSessionAgents(ctx.directory);
   log("[OhMyOpenCodePlugin] Session agent recovery complete", { recoveredAgents });
   startBackgroundCheck2();
   const pluginConfig = loadPluginConfig(ctx.directory, ctx);
@@ -73936,8 +73789,6 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const keywordDetector = isHookEnabled("keyword-detector") ? createKeywordDetectorHook(ctx, contextCollector) : null;
   const contextInjectorMessagesTransform = createContextInjectorMessagesTransformHook(contextCollector);
   const agentUsageReminder = isHookEnabled("agent-usage-reminder") ? createAgentUsageReminderHook(ctx) : null;
-  const languageReminder = isHookEnabled("language-reminder") && isLanguageEnforcementEnabled(pluginConfig) ? createLanguageReminderHook(ctx) : null;
-  const thinkingLanguageValidator = isHookEnabled("thinking-language-validator") && isLanguageEnforcementEnabled(pluginConfig) ? createThinkingLanguageValidatorHook(ctx) : null;
   const nonInteractiveEnv = isHookEnabled("non-interactive-env") ? createNonInteractiveEnvHook(ctx) : null;
   const interactiveBashSession = isHookEnabled("interactive-bash-session") ? createInteractiveBashSessionHook(ctx) : null;
   const thinkingBlockValidator = isHookEnabled("thinking-block-validator") ? createThinkingBlockValidatorHook() : null;
@@ -74109,6 +73960,11 @@ var OhMyOpenCodePlugin = async (ctx) => {
         updateSessionAgent(input.sessionID, validatedAgent ?? input.agent, "chat.message");
       } else {
         const staleThresholdMs = pluginConfig.identity?.staleThresholdMs ?? 600000;
+        if (!getSessionAgent(input.sessionID)) {
+          log("[identity] chat.message without agent info and no session agent", {
+            sessionID: input.sessionID
+          });
+        }
         if (isSessionAgentStale(input.sessionID, staleThresholdMs)) {
           log("[identity] session agent stale", { sessionID: input.sessionID, staleThresholdMs });
           const messageFileAgent = getAgentFromSessionMessages(input.sessionID);
@@ -74221,10 +74077,6 @@ var OhMyOpenCodePlugin = async (ctx) => {
       hookCount++;
       await wrapWithTiming(perfTracer, "event", "agentUsageReminder", () => agentUsageReminder?.event(input), evtSessionID);
       hookCount++;
-      await wrapWithTiming(perfTracer, "event", "languageReminder", () => languageReminder?.event(input), evtSessionID);
-      hookCount++;
-      await wrapWithTiming(perfTracer, "event", "thinkingLanguageValidator", () => thinkingLanguageValidator?.event(input), evtSessionID);
-      hookCount++;
       await wrapWithTiming(perfTracer, "event", "interactiveBashSession", () => interactiveBashSession?.event(input), evtSessionID);
       hookCount++;
       await wrapWithTiming(perfTracer, "event", "ralphLoop", () => ralphLoop?.event(input), evtSessionID);
@@ -74240,6 +74092,9 @@ var OhMyOpenCodePlugin = async (ctx) => {
           try {
             cleanupStaleTmpFiles(ctx.directory);
           } catch {}
+          if (sessionInfo?.id) {
+            log("[identity] New main session created", { sessionID: sessionInfo.id });
+          }
         }
         firstMessageVariantGate.markSessionCreated(sessionInfo);
       }
@@ -74272,6 +74127,9 @@ var OhMyOpenCodePlugin = async (ctx) => {
           const validatedAgent = validateAndFixAgentIdentity(sessionID, agent);
           updateSessionAgent(sessionID, validatedAgent ?? agent, "message.updated");
         }
+        if (sessionID && agent && role === "assistant") {
+          updateSessionAgent(sessionID, agent, "message.updated.assistant");
+        }
       }
       if (event.type === "session.error") {
         const sessionID = props?.sessionID;
@@ -74384,10 +74242,6 @@ var OhMyOpenCodePlugin = async (ctx) => {
       hookCount++;
       await wrapWithTiming(perfTracer, "tool.execute.after", "agentUsageReminder", () => agentUsageReminder?.["tool.execute.after"](input, output), input.sessionID, input.tool);
       hookCount++;
-      await wrapWithTiming(perfTracer, "tool.execute.after", "languageReminder", () => languageReminder?.["tool.execute.after"](input, output), input.sessionID, input.tool);
-      hookCount++;
-      await wrapWithTiming(perfTracer, "tool.execute.after", "thinkingLanguageValidator", () => thinkingLanguageValidator?.["tool.execute.after"](input, output), input.sessionID, input.tool);
-      hookCount++;
       await wrapWithTiming(perfTracer, "tool.execute.after", "interactiveBashSession", () => interactiveBashSession?.["tool.execute.after"](input, output), input.sessionID, input.tool);
       hookCount++;
       await wrapWithTiming(perfTracer, "tool.execute.after", "editErrorRecovery", () => editErrorRecovery?.["tool.execute.after"](input, output), input.sessionID, input.tool);