opencode-gbk-tools 0.1.28 → 0.1.30

package/dist/plugin/index.js

@@ -3816,6 +3816,9 @@ var require_lib = __commonJS({
   }
 });
 
+// src/plugin/index.ts
+import path5 from "path";
+
 // src/lib/session-pressure.ts
 var AUTO_SUMMARIZE_PRESSURE_RATIO = 0.85;
 var AUTO_SUMMARIZE_COOLDOWN_MS = 6e4;
@@ -3910,6 +3913,200 @@ function estimateSessionTokens(messages) {
   return Math.ceil(totalChars / 4);
 }
 
+// src/lib/encoding-memory.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+var ENCODING_MEMORY_VERSION = 1;
+var ENCODING_MEMORY_FILE_NAME = "encoding-memory.json";
+var CONFIG_DIR_ENV = "OPENCODE_GBK_TOOLS_CONFIG_DIR";
+var memoryCache = null;
+var loadingPromise = null;
+function resolveConfigDirectory() {
+  const override = process.env[CONFIG_DIR_ENV];
+  if (typeof override === "string" && override.trim().length > 0) {
+    return path.resolve(override);
+  }
+  if (process.platform === "win32") {
+    return path.join(process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming"), "opencode-gbk-tools");
+  }
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", "opencode-gbk-tools");
+  }
+  return path.join(process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config"), "opencode-gbk-tools");
+}
+function normalizeFilePath(filePath) {
+  const resolved = path.normalize(path.resolve(filePath));
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function toStoredFilePath(filePath) {
+  return path.normalize(path.resolve(filePath));
+}
+function isRememberedEntry(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const entry = value;
+  return typeof entry.filePath === "string" && isRememberedGbkEncoding(entry.encoding) && typeof entry.mtimeMs === "number" && Number.isFinite(entry.mtimeMs) && typeof entry.size === "number" && Number.isFinite(entry.size) && typeof entry.lastConfirmedAt === "number" && Number.isFinite(entry.lastConfirmedAt);
+}
+async function readEncodingMemoryMap() {
+  if (memoryCache) {
+    return memoryCache;
+  }
+  if (loadingPromise) {
+    return loadingPromise;
+  }
+  loadingPromise = (async () => {
+    const map2 = /* @__PURE__ */ new Map();
+    try {
+      const raw = await fs.readFile(getEncodingMemoryFilePath(), "utf8");
+      const parsed = JSON.parse(raw);
+      const entries = Array.isArray(parsed.entries) ? parsed.entries : [];
+      for (const entry of entries) {
+        if (isRememberedEntry(entry)) {
+          map2.set(normalizeFilePath(entry.filePath), entry);
+        }
+      }
+    } catch (error45) {
+      if (!(error45 instanceof Error && "code" in error45 && error45.code === "ENOENT")) {
+        throw error45;
+      }
+    }
+    memoryCache = map2;
+    loadingPromise = null;
+    return map2;
+  })();
+  return loadingPromise;
+}
+async function persistEncodingMemoryMap(map2) {
+  const entries = [...map2.values()].sort((a, b) => a.filePath.localeCompare(b.filePath));
+  const payload = {
+    version: ENCODING_MEMORY_VERSION,
+    entries
+  };
+  const filePath = getEncodingMemoryFilePath();
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(payload, null, 2), "utf8");
+}
+async function statRegularFile(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    return stat.isFile() ? stat : null;
+  } catch (error45) {
+    if (error45 instanceof Error && "code" in error45 && error45.code === "ENOENT") {
+      return null;
+    }
+    throw error45;
+  }
+}
+function isRememberedGbkEncoding(encoding) {
+  return encoding === "gbk" || encoding === "gb18030";
+}
+function getEncodingMemoryFilePath() {
+  return path.join(resolveConfigDirectory(), ENCODING_MEMORY_FILE_NAME);
+}
+async function rememberGbkEncoding(filePath, encoding) {
+  const stat = await statRegularFile(filePath);
+  if (!stat) {
+    return null;
+  }
+  const map2 = await readEncodingMemoryMap();
+  const entry = {
+    filePath: toStoredFilePath(filePath),
+    encoding,
+    mtimeMs: stat.mtimeMs,
+    size: Number(stat.size),
+    lastConfirmedAt: Date.now()
+  };
+  map2.set(normalizeFilePath(filePath), entry);
+  await persistEncodingMemoryMap(map2);
+  return entry;
+}
+async function forgetRememberedEncoding(filePath) {
+  const map2 = await readEncodingMemoryMap();
+  const deleted = map2.delete(normalizeFilePath(filePath));
+  if (deleted) {
+    await persistEncodingMemoryMap(map2);
+  }
+  return deleted;
+}
+async function getRememberedGbkEncoding(filePath) {
+  const map2 = await readEncodingMemoryMap();
+  const key = normalizeFilePath(filePath);
+  const entry = map2.get(key);
+  if (!entry) {
+    return null;
+  }
+  const stat = await statRegularFile(filePath);
+  if (!stat || stat.mtimeMs !== entry.mtimeMs || Number(stat.size) !== entry.size) {
+    map2.delete(key);
+    await persistEncodingMemoryMap(map2);
+    return null;
+  }
+  return entry;
+}
+
+// src/lib/path-sandbox.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/lib/errors.ts
+var GbkToolError = class extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "GbkToolError";
+    this.code = code;
+    this.cause = cause;
+  }
+};
+function createGbkError(code, message, cause) {
+  return new GbkToolError(code, message, cause);
+}
+var createTextError = createGbkError;
+
+// src/lib/path-sandbox.ts
+function resolveBaseDirectory(context) {
+  const value = context.directory ?? process.cwd();
+  return path2.isAbsolute(value) ? value : path2.resolve(process.cwd(), value);
+}
+function resolveWorkspaceRoot(context) {
+  const value = context.worktree ?? context.directory ?? process.cwd();
+  return path2.isAbsolute(value) ? value : path2.resolve(process.cwd(), value);
+}
+function resolveCandidatePath(filePath, context) {
+  return path2.resolve(resolveBaseDirectory(context), filePath);
+}
+async function resolveExistingAnchor(filePath) {
+  let current = filePath;
+  while (true) {
+    try {
+      return await fs2.realpath(current);
+    } catch {
+      const parent = path2.dirname(current);
+      if (parent === current) {
+        throw createGbkError("GBK_IO_ERROR", `\u65E0\u6CD5\u89E3\u6790\u8DEF\u5F84\u951A\u70B9: ${filePath}`);
+      }
+      current = parent;
+    }
+  }
+}
+async function assertPathAllowed(filePath, context, allowExternal = false) {
+  const candidatePath = resolveCandidatePath(filePath, context);
+  const workspaceRoot = resolveWorkspaceRoot(context);
+  if (!allowExternal) {
+    const realWorkspaceRoot = await fs2.realpath(workspaceRoot);
+    const realCandidateAnchor = await resolveExistingAnchor(candidatePath);
+    const relative = path2.relative(realWorkspaceRoot, realCandidateAnchor);
+    if (relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative)) {
+      return { candidatePath, workspaceRoot };
+    }
+    throw createGbkError("GBK_PATH_OUTSIDE_ROOT", `\u76EE\u6807\u8DEF\u5F84\u8D85\u51FA\u5DE5\u4F5C\u76EE\u5F55\u8303\u56F4: ${candidatePath}`);
+  }
+  return { candidatePath, workspaceRoot };
+}
+
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -4641,10 +4838,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path4) {
-  if (!path4)
+function getElementAtPath(obj, path6) {
+  if (!path6)
     return obj;
-  return path4.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -5005,11 +5202,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path4, issues) {
+function prefixIssues(path6, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path4);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -5177,7 +5374,7 @@ function treeifyError(error45, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error46, path4 = []) => {
+  const processError = (error46, path6 = []) => {
     var _a, _b;
     for (const issue2 of error46.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -5187,7 +5384,7 @@ function treeifyError(error45, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path4, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -5219,8 +5416,8 @@ function treeifyError(error45, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path4) {
+  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path6) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -16462,69 +16659,8 @@ function truncateToolOutput(content, sessionID, fallback = FALLBACK_MAX_OUTPUT_C
 var import_iconv_lite = __toESM(require_lib(), 1);
 import crypto from "crypto";
 import { createReadStream } from "fs";
-import fs2 from "fs/promises";
-import path2 from "path";
-
-// src/lib/errors.ts
-var GbkToolError = class extends Error {
-  code;
-  cause;
-  constructor(code, message, cause) {
-    super(message);
-    this.name = "GbkToolError";
-    this.code = code;
-    this.cause = cause;
-  }
-};
-function createGbkError(code, message, cause) {
-  return new GbkToolError(code, message, cause);
-}
-var createTextError = createGbkError;
-
-// src/lib/path-sandbox.ts
-import fs from "fs/promises";
-import path from "path";
-function resolveBaseDirectory(context) {
-  const value = context.directory ?? process.cwd();
-  return path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
-}
-function resolveWorkspaceRoot(context) {
-  const value = context.worktree ?? context.directory ?? process.cwd();
-  return path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
-}
-function resolveCandidatePath(filePath, context) {
-  return path.resolve(resolveBaseDirectory(context), filePath);
-}
-async function resolveExistingAnchor(filePath) {
-  let current = filePath;
-  while (true) {
-    try {
-      return await fs.realpath(current);
-    } catch {
-      const parent = path.dirname(current);
-      if (parent === current) {
-        throw createGbkError("GBK_IO_ERROR", `\u65E0\u6CD5\u89E3\u6790\u8DEF\u5F84\u951A\u70B9: ${filePath}`);
-      }
-      current = parent;
-    }
-  }
-}
-async function assertPathAllowed(filePath, context, allowExternal = false) {
-  const candidatePath = resolveCandidatePath(filePath, context);
-  const workspaceRoot = resolveWorkspaceRoot(context);
-  if (!allowExternal) {
-    const realWorkspaceRoot = await fs.realpath(workspaceRoot);
-    const realCandidateAnchor = await resolveExistingAnchor(candidatePath);
-    const relative = path.relative(realWorkspaceRoot, realCandidateAnchor);
-    if (relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative)) {
-      return { candidatePath, workspaceRoot };
-    }
-    throw createGbkError("GBK_PATH_OUTSIDE_ROOT", `\u76EE\u6807\u8DEF\u5F84\u8D85\u51FA\u5DE5\u4F5C\u76EE\u5F55\u8303\u56F4: ${candidatePath}`);
-  }
-  return { candidatePath, workspaceRoot };
-}
-
-// src/lib/gbk-file.ts
+import fs3 from "fs/promises";
+import path3 from "path";
 var STREAMING_FILE_SIZE_THRESHOLD_BYTES = 1024 * 1024;
 var STREAM_READ_CHUNK_SIZE_BYTES = 1024 * 1024;
 var gbkLineIndexCache = /* @__PURE__ */ new Map();
@@ -16538,8 +16674,8 @@ function buildGbkLineDiffPreview(filePath, encoding, beforeText, afterText) {
   const afterLines = normalizeNewlines(afterText).split("\n");
   const maxLines = Math.max(beforeLines.length, afterLines.length);
   const header = [
-    `${ANSI_DIM}--- ${path2.basename(filePath)} (${encoding})${ANSI_RESET}`,
-    `${ANSI_DIM}+++ ${path2.basename(filePath)} (${encoding})${ANSI_RESET}`
+    `${ANSI_DIM}--- ${path3.basename(filePath)} (${encoding})${ANSI_RESET}`,
+    `${ANSI_DIM}+++ ${path3.basename(filePath)} (${encoding})${ANSI_RESET}`
   ];
   const body = [];
   for (let index = 0; index < maxLines; index += 1) {
@@ -17033,7 +17169,7 @@ async function resolveReadableGbkFile(input) {
   const { candidatePath } = await assertPathAllowed(input.filePath, input.context, input.allowExternal ?? false);
   let stat;
   try {
-    stat = await fs2.stat(candidatePath);
+    stat = await fs3.stat(candidatePath);
   } catch (error45) {
     throw createGbkError("GBK_FILE_NOT_FOUND", `\u6587\u4EF6\u4E0D\u5B58\u5728: ${candidatePath}`, error45);
   }
@@ -17048,7 +17184,7 @@ async function resolveReadableGbkFile(input) {
 }
 async function readWholeGbkTextFile(input) {
   try {
-    const buffer = await fs2.readFile(input.filePath);
+    const buffer = await fs3.readFile(input.filePath);
     const content = await readBufferAsText(buffer, input.encoding);
     return {
       filePath: input.filePath,
@@ -17192,7 +17328,7 @@ async function appendEncodedText(filePath, encoding, text) {
     return 0;
   }
   const buffer = import_iconv_lite.default.encode(text, encoding);
-  await fs2.appendFile(filePath, buffer);
+  await fs3.appendFile(filePath, buffer);
   return buffer.byteLength;
 }
 async function copyFileByteRangeToHandle(sourcePath, handle, start, endExclusive) {
@@ -17271,11 +17407,11 @@ async function replaceLargeGbkFileTextInLineRange(input) {
     input.replaceAll,
     lineIndex.newlineStyle
   );
-  const tempPath = path2.join(
-    path2.dirname(input.filePath),
-    `${path2.basename(input.filePath)}.opencode-gbk-${crypto.randomUUID()}.tmp`
+  const tempPath = path3.join(
+    path3.dirname(input.filePath),
+    `${path3.basename(input.filePath)}.opencode-gbk-${crypto.randomUUID()}.tmp`
   );
-  const handle = await fs2.open(tempPath, "w");
+  const handle = await fs3.open(tempPath, "w");
   let bytesWritten = 0;
   try {
     bytesWritten += await copyFileByteRangeToHandle(input.filePath, handle, 0, rangeStart);
@@ -17283,8 +17419,8 @@ async function replaceLargeGbkFileTextInLineRange(input) {
     bytesWritten += await copyFileByteRangeToHandle(input.filePath, handle, rangeEnd, toSafeNumber(input.stat.size));
     await handle.close();
     const mode = typeof input.stat.mode === "bigint" ? Number(input.stat.mode) : input.stat.mode;
-    await fs2.chmod(tempPath, mode);
-    await fs2.rename(tempPath, input.filePath);
+    await fs3.chmod(tempPath, mode);
+    await fs3.rename(tempPath, input.filePath);
     return {
       mode: "replace",
       filePath: input.filePath,
@@ -17296,18 +17432,18 @@ async function replaceLargeGbkFileTextInLineRange(input) {
     };
   } catch (error45) {
     await handle.close().catch(() => void 0);
-    await fs2.rm(tempPath, { force: true }).catch(() => void 0);
+    await fs3.rm(tempPath, { force: true }).catch(() => void 0);
     throw error45;
   }
 }
 async function replaceLargeGbkFileByAnchor(input) {
   const lineIndex = await getGbkLineIndex(input);
   const newlineStyle = lineIndex.newlineStyle;
-  const tempPath = path2.join(
-    path2.dirname(input.filePath),
-    `${path2.basename(input.filePath)}.opencode-gbk-${crypto.randomUUID()}.tmp`
+  const tempPath = path3.join(
+    path3.dirname(input.filePath),
+    `${path3.basename(input.filePath)}.opencode-gbk-${crypto.randomUUID()}.tmp`
   );
-  const handle = await fs2.open(tempPath, "w");
+  const handle = await fs3.open(tempPath, "w");
   const alignedContent = alignTextToNewlineStyle(input.content, newlineStyle);
   const anchorVariants = buildFlexibleSearchVariants(input.anchor, newlineStyle);
   const maxAnchorLength = anchorVariants.reduce((maxLength, candidate) => Math.max(maxLength, candidate.length), input.anchor.length);
@@ -17420,8 +17556,8 @@ async function replaceLargeGbkFileByAnchor(input) {
     await finalizeInserted();
     await handle.close();
     const mode = typeof input.stat.mode === "bigint" ? Number(input.stat.mode) : input.stat.mode;
-    await fs2.chmod(tempPath, mode);
-    await fs2.rename(tempPath, input.filePath);
+    await fs3.chmod(tempPath, mode);
+    await fs3.rename(tempPath, input.filePath);
     invalidateGbkLineIndex(input.filePath);
     return {
       mode: input.mode,
@@ -17437,18 +17573,18 @@ async function replaceLargeGbkFileByAnchor(input) {
     };
   } catch (error45) {
     await handle.close().catch(() => void 0);
-    await fs2.rm(tempPath, { force: true }).catch(() => void 0);
+    await fs3.rm(tempPath, { force: true }).catch(() => void 0);
     throw error45;
   }
 }
 async function replaceLargeGbkFileText(input) {
   const lineIndex = await getGbkLineIndex(input);
   const newlineStyle = lineIndex.newlineStyle;
-  const tempPath = path2.join(
-    path2.dirname(input.filePath),
-    `${path2.basename(input.filePath)}.opencode-gbk-${crypto.randomUUID()}.tmp`
+  const tempPath = path3.join(
+    path3.dirname(input.filePath),
+    `${path3.basename(input.filePath)}.opencode-gbk-${crypto.randomUUID()}.tmp`
   );
-  const handle = await fs2.open(tempPath, "w");
+  const handle = await fs3.open(tempPath, "w");
   const carryLength = Math.max(input.oldString.length - 1, 0);
   const alignedNewString = alignTextToNewlineStyle(input.newString, newlineStyle);
   let carry = "";
@@ -17507,8 +17643,8 @@ async function replaceLargeGbkFileText(input) {
     }
     await handle.close();
     const mode = typeof input.stat.mode === "bigint" ? Number(input.stat.mode) : input.stat.mode;
-    await fs2.chmod(tempPath, mode);
-    await fs2.rename(tempPath, input.filePath);
+    await fs3.chmod(tempPath, mode);
+    await fs3.rename(tempPath, input.filePath);
     invalidateGbkLineIndex(input.filePath);
     return {
       filePath: input.filePath,
@@ -17520,7 +17656,7 @@ async function replaceLargeGbkFileText(input) {
     };
   } catch (error45) {
     await handle.close().catch(() => void 0);
-    await fs2.rm(tempPath, { force: true }).catch(() => void 0);
+    await fs3.rm(tempPath, { force: true }).catch(() => void 0);
     throw error45;
   }
 }
@@ -17648,7 +17784,7 @@ async function replaceGbkFileText(input) {
       };
     }
     const buffer2 = import_iconv_lite.default.encode(insertResult.outputText, current2.encoding);
-    await fs2.writeFile(current2.filePath, buffer2);
+    await fs3.writeFile(current2.filePath, buffer2);
     return {
       mode,
       filePath: current2.filePath,
@@ -17708,7 +17844,7 @@ async function replaceGbkFileText(input) {
     if (loose !== null) {
       const outputText2 = `${current.content.slice(0, scope.rangeStart)}${loose.content}${current.content.slice(scope.rangeEnd)}`;
       const buffer2 = import_iconv_lite.default.encode(outputText2, current.encoding);
-      await fs2.writeFile(current.filePath, buffer2);
+      await fs3.writeFile(current.filePath, buffer2);
       invalidateGbkLineIndex(current.filePath);
       return {
         mode: "replace",
@@ -17736,7 +17872,7 @@ async function replaceGbkFileText(input) {
   const replaced = replaceAll ? scope.selectedText.split(effectiveOldString).join(alignedNewString) : scope.selectedText.replace(effectiveOldString, alignedNewString);
   const outputText = `${current.content.slice(0, scope.rangeStart)}${replaced}${current.content.slice(scope.rangeEnd)}`;
   const buffer = import_iconv_lite.default.encode(outputText, current.encoding);
-  await fs2.writeFile(current.filePath, buffer);
+  await fs3.writeFile(current.filePath, buffer);
   invalidateGbkLineIndex(current.filePath);
   return {
     mode: "replace",
@@ -17821,11 +17957,11 @@ async function writeGbkFile(input) {
   const overwrite = input.overwrite ?? false;
   const append = input.append ?? false;
   const { candidatePath } = await assertPathAllowed(input.filePath, input.context, input.allowExternal ?? false);
-  const parent = path2.dirname(candidatePath);
+  const parent = path3.dirname(candidatePath);
   assertEncodingSupported(encoding);
   if (append) {
     try {
-      const parentStat = await fs2.stat(parent);
+      const parentStat = await fs3.stat(parent);
       if (!parentStat.isDirectory()) {
         throw createGbkError("GBK_PARENT_DIRECTORY_MISSING", `\u7236\u76EE\u5F55\u4E0D\u5B58\u5728: ${parent}`);
       }
@@ -17834,14 +17970,14 @@ async function writeGbkFile(input) {
         if (!createDirectories) {
           throw createGbkError("GBK_PARENT_DIRECTORY_MISSING", `\u7236\u76EE\u5F55\u4E0D\u5B58\u5728: ${parent}`);
         }
-        await fs2.mkdir(parent, { recursive: true });
+        await fs3.mkdir(parent, { recursive: true });
       } else if (error45 instanceof Error && "code" in error45) {
         throw error45;
       }
     }
     let existed = false;
     try {
-      await fs2.stat(candidatePath);
+      await fs3.stat(candidatePath);
       existed = true;
     } catch (error45) {
       if (!(error45 instanceof Error && "code" in error45 && error45.code === "ENOENT")) {
@@ -17860,7 +17996,7 @@ async function writeGbkFile(input) {
     };
   }
   try {
-    const stat = await fs2.stat(candidatePath);
+    const stat = await fs3.stat(candidatePath);
     if (stat.isDirectory()) {
       throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\u5F55: ${candidatePath}`);
     }
@@ -17877,7 +18013,7 @@ async function writeGbkFile(input) {
     }
   }
   try {
-    const parentStat = await fs2.stat(parent);
+    const parentStat = await fs3.stat(parent);
     if (!parentStat.isDirectory()) {
       throw createGbkError("GBK_PARENT_DIRECTORY_MISSING", `\u7236\u76EE\u5F55\u4E0D\u5B58\u5728: ${parent}`);
     }
@@ -17886,15 +18022,15 @@ async function writeGbkFile(input) {
       if (!createDirectories) {
         throw createGbkError("GBK_PARENT_DIRECTORY_MISSING", `\u7236\u76EE\u5F55\u4E0D\u5B58\u5728: ${parent}`);
       }
-      await fs2.mkdir(parent, { recursive: true });
+      await fs3.mkdir(parent, { recursive: true });
     } else if (error45 instanceof Error && "code" in error45) {
       throw error45;
     }
   }
   try {
-    const existed = await fs2.stat(candidatePath).then(() => true).catch(() => false);
+    const existed = await fs3.stat(candidatePath).then(() => true).catch(() => false);
     const buffer = import_iconv_lite.default.encode(input.content, encoding);
-    await fs2.writeFile(candidatePath, buffer);
+    await fs3.writeFile(candidatePath, buffer);
     invalidateGbkLineIndex(candidatePath);
     return {
       filePath: candidatePath,
@@ -18110,39 +18246,12 @@ var gbk_write_default = tool({
   }
 });
 
-// src/plugin/text-guidance.ts
-var TEXT_TOOL_SYSTEM_MARKER = "[opencode-gbk-tools:text-rules]";
-var TEXT_TOOL_SYSTEM_PROMPT = [
-  TEXT_TOOL_SYSTEM_MARKER,
-  "\u6587\u672C\u6587\u4EF6\u5904\u7406\u89C4\u5219\uFF1A",
-  "- \u5904\u7406\u6587\u672C\u6587\u4EF6\u65F6\uFF0C\u9ED8\u8BA4\u4F18\u5148\u4F7F\u7528 gbk_read\u3001gbk_write\u3001gbk_edit\u3001gbk_search\u3002",
-  "- gbk_* \u9002\u5408\u5F53\u524D\u4ED3\u5E93\u7684\u81EA\u52A8\u7F16\u7801\u6587\u672C\u4E0E GBK/GB18030 \u6587\u4EF6\uFF1B\u5373\u4F7F\u4E0D\u662F\u660E\u786E\u7684 GBK \u6587\u4EF6\uFF0C\u4E5F\u4F18\u5148\u8D70\u8FD9\u7EC4\u5DE5\u5177\u3002",
-  "- \u65B0\u5EFA .txt \u6587\u4EF6\u5728 encoding=auto \u4E0B\u9ED8\u8BA4\u4F7F\u7528 GBK\uFF1B\u5176\u4ED6\u65B0\u6587\u4EF6\u8BF7\u663E\u5F0F\u6307\u5B9A encoding\u3002",
-  "- \u5982\u679C\u610F\u56FE\u662F\u2018\u5728\u67D0\u6807\u7B7E\u524D\u540E\u63D2\u5165\u5185\u5BB9\u2019\uFF0C\u4F18\u5148\u4F7F\u7528 mode=insertAfter \u6216 mode=insertBefore\uFF0C\u5E76\u4F20 anchor/content\u3002",
-  "- \u53EA\u6709\u5728\u660E\u786E\u505A\u7CBE\u786E\u66FF\u6362\u65F6\uFF0C\u624D\u4F7F\u7528 oldString/newString\u3002",
-  "- anchor\u3001startAnchor\u3001endAnchor\u3001oldString \u82E5\u76F4\u63A5\u590D\u5236\u81EA\u8BFB\u53D6\u7ED3\u679C\uFF0C\u53EF\u4FDD\u7559 LF \u6362\u884C\uFF1B\u5DE5\u5177\u4F1A\u5C3D\u91CF\u6309\u6587\u4EF6\u6362\u884C\u98CE\u683C\u81EA\u52A8\u5BF9\u9F50\u3002",
-  '- \u82E5\u8BFB\u53D6\u7ED3\u679C\u5E26\u6709 "N: " \u884C\u53F7\u524D\u7F00\uFF0Cgbk_edit \u4F1A\u5C3D\u91CF\u81EA\u52A8\u5265\u79BB\u8FD9\u4E9B\u524D\u7F00\u540E\u518D\u5339\u914D\u3002',
-  "- text_read\u3001text_write\u3001text_edit \u4EC5\u4F5C\u4E3A\u517C\u5BB9\u5DE5\u5177\uFF0C\u4E0D\u518D\u4F5C\u4E3A\u9ED8\u8BA4\u63A8\u8350\u8DEF\u5F84\u3002"
-].join("\n");
-function appendTextToolSystemPrompt(system) {
-  if (system.some((item) => item.includes(TEXT_TOOL_SYSTEM_MARKER))) {
-    return;
-  }
-  if (system.length === 0) {
-    system.push(TEXT_TOOL_SYSTEM_PROMPT);
-    return;
-  }
-  system[0] = `${system[0]}
-
-${TEXT_TOOL_SYSTEM_PROMPT}`;
-}
-
 // src/lib/text-file.ts
 var import_iconv_lite2 = __toESM(require_lib(), 1);
 import crypto2 from "crypto";
 import { createReadStream as createReadStream2 } from "fs";
-import fs3 from "fs/promises";
-import path3 from "path";
+import fs4 from "fs/promises";
+import path4 from "path";
 var TEXT_STREAMING_FILE_SIZE_THRESHOLD_BYTES = 1024 * 1024;
 var TEXT_DETECTION_SAMPLE_BYTES = 64 * 1024;
 var UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
@@ -18178,7 +18287,7 @@ function resolveExplicitTextEncoding(value, fallback) {
   return requested === "auto" ? fallback : requested;
 }
 function shouldDefaultNewTextFileToGbk(filePath) {
-  return path3.extname(filePath).toLowerCase() === ".txt";
+  return path4.extname(filePath).toLowerCase() === ".txt";
 }
 function getBomPrefix(encoding, hasBom) {
   if (!hasBom) {
@@ -18474,8 +18583,8 @@ function buildLineDiffPreview(filePath, encoding, beforeText, afterText) {
   const afterLines = normalizeNewlines2(afterText).split("\n");
   const maxLines = Math.max(beforeLines.length, afterLines.length);
   const header = [
-    `${ANSI_DIM2}--- ${path3.basename(filePath)} (${encoding})${ANSI_RESET2}`,
-    `${ANSI_DIM2}+++ ${path3.basename(filePath)} (${encoding})${ANSI_RESET2}`
+    `${ANSI_DIM2}--- ${path4.basename(filePath)} (${encoding})${ANSI_RESET2}`,
+    `${ANSI_DIM2}+++ ${path4.basename(filePath)} (${encoding})${ANSI_RESET2}`
   ];
   const body = [];
   for (let index = 0; index < maxLines; index += 1) {
@@ -18591,7 +18700,7 @@ async function resolveReadableTextFile(input) {
   const { candidatePath } = await assertPathAllowed(input.filePath, input.context, input.allowExternal ?? false);
   let stat;
   try {
-    stat = await fs3.stat(candidatePath);
+    stat = await fs4.stat(candidatePath);
   } catch (error45) {
     throw createTextError("GBK_FILE_NOT_FOUND", `\u6587\u4EF6\u4E0D\u5B58\u5728: ${candidatePath}`, error45);
   }
@@ -18601,7 +18710,7 @@ async function resolveReadableTextFile(input) {
   return { filePath: candidatePath, stat };
 }
 async function readDetectionBuffer(filePath, sampleSize = TEXT_DETECTION_SAMPLE_BYTES) {
-  const handle = await fs3.open(filePath, "r");
+  const handle = await fs4.open(filePath, "r");
   try {
     const buffer = Buffer.alloc(sampleSize);
     const { bytesRead } = await handle.read(buffer, 0, sampleSize, 0);
@@ -18764,8 +18873,8 @@ async function visitDecodedTextChunks2(resolved, visitor) {
   }
 }
 async function writeLargeTextFile(filePath, encoding, hasBom, producer) {
-  const tempPath = path3.join(path3.dirname(filePath), `${path3.basename(filePath)}.opencode-text-${crypto2.randomUUID()}.tmp`);
-  const handle = await fs3.open(tempPath, "w");
+  const tempPath = path4.join(path4.dirname(filePath), `${path4.basename(filePath)}.opencode-text-${crypto2.randomUUID()}.tmp`);
+  const handle = await fs4.open(tempPath, "w");
   try {
     if (hasBom) {
       const bom = getBomPrefix(encoding, hasBom);
@@ -18775,11 +18884,11 @@ async function writeLargeTextFile(filePath, encoding, hasBom, producer) {
     }
     const bytesWritten = await producer(handle);
     await handle.close();
-    await fs3.rename(tempPath, filePath);
+    await fs4.rename(tempPath, filePath);
     return bytesWritten + getBomPrefix(encoding, hasBom).length;
   } catch (error45) {
     await handle.close().catch(() => void 0);
-    await fs3.rm(tempPath, { force: true }).catch(() => void 0);
+    await fs4.rm(tempPath, { force: true }).catch(() => void 0);
     throw error45;
   }
 }
@@ -18874,7 +18983,7 @@ async function replaceLargeTextFileText(input) {
 async function readWholeTextFile(input) {
   const resolved = await resolveReadableTextFile(input);
   try {
-    const buffer = await fs3.readFile(resolved.filePath);
+    const buffer = await fs4.readFile(resolved.filePath);
     assertLikelyTextBuffer(buffer);
     const detected = detectTextEncodingFromBuffer(buffer, input.encoding ?? "auto");
     const content = decodeText(buffer, detected.detectedEncoding);
@@ -19070,7 +19179,7 @@ function ensureLossless(input, encoding, hasBom = encoding === "utf8-bom") {
 }
 async function ensureParentDirectory(parent, createDirectories) {
   try {
-    const parentStat = await fs3.stat(parent);
+    const parentStat = await fs4.stat(parent);
     if (!parentStat.isDirectory()) {
       throw createTextError("GBK_PARENT_DIRECTORY_MISSING", `\u7236\u76EE\u5F55\u4E0D\u5B58\u5728: ${parent}`);
     }
@@ -19079,12 +19188,26 @@ async function ensureParentDirectory(parent, createDirectories) {
       if (!createDirectories) {
         throw createTextError("GBK_PARENT_DIRECTORY_MISSING", `\u7236\u76EE\u5F55\u4E0D\u5B58\u5728: ${parent}`);
       }
-      await fs3.mkdir(parent, { recursive: true });
+      await fs4.mkdir(parent, { recursive: true });
       return;
     }
     throw error45;
   }
 }
+async function detectTextFileEncoding(input) {
+  const detected = await detectReadableTextFile(input);
+  const fileSize = typeof detected.stat.size === "bigint" ? Number(detected.stat.size) : detected.stat.size;
+  return {
+    filePath: detected.filePath,
+    encoding: detected.encoding,
+    requestedEncoding: detected.requestedEncoding,
+    detectedEncoding: detected.detectedEncoding,
+    confidence: detected.confidence,
+    hasBom: detected.hasBom,
+    bytesRead: Math.min(fileSize, TEXT_DETECTION_SAMPLE_BYTES),
+    newlineStyle: "unknown"
+  };
+}
 async function readTextFile(input) {
   const offset = normalizeOptionalPositiveInteger(input.offset, "offset") ?? 1;
   const limit = normalizeOptionalPositiveInteger(input.limit, "limit") ?? 2e3;
@@ -19142,7 +19265,7 @@ async function writeTextFile(input) {
   const overwrite = input.overwrite ?? false;
   const append = input.append ?? false;
   const { candidatePath } = await assertPathAllowed(input.filePath, input.context, input.allowExternal ?? false);
-  const parent = path3.dirname(candidatePath);
+  const parent = path4.dirname(candidatePath);
   await ensureParentDirectory(parent, createDirectories);
   let existing = null;
   try {
@@ -19171,7 +19294,7 @@ async function writeTextFile(input) {
   const outputContent = existing && preserveNewlineStyle ? alignTextToNewlineStyle2(rawContent, existing.newlineStyle) : rawContent;
   ensureLossless(outputContent, targetEncoding, targetHasBom);
   const buffer = encodeText(outputContent, targetEncoding, targetHasBom);
-  await fs3.writeFile(candidatePath, buffer);
+  await fs4.writeFile(candidatePath, buffer);
   return {
     filePath: candidatePath,
     encoding: targetEncoding,
@@ -19235,7 +19358,7 @@ async function replaceTextFileText(input) {
     const targetHasBom2 = normalizedInput.preserveEncoding === false ? targetEncoding2 === "utf8-bom" || targetEncoding2 === "utf16le" || targetEncoding2 === "utf16be" : loaded2.hasBom;
     ensureLossless(insertResult.outputText, targetEncoding2, targetHasBom2);
     const buffer2 = encodeText(insertResult.outputText, targetEncoding2, targetHasBom2);
-    await fs3.writeFile(loaded2.filePath, buffer2);
+    await fs4.writeFile(loaded2.filePath, buffer2);
     return {
       mode,
       filePath: loaded2.filePath,
@@ -19312,7 +19435,7 @@ async function replaceTextFileText(input) {
       const outputText2 = `${loaded.content.slice(0, scope.rangeStart)}${loose.content}${loaded.content.slice(scope.rangeEnd)}`;
       ensureLossless(outputText2, targetEncoding, targetHasBom);
       const buffer2 = encodeText(outputText2, targetEncoding, targetHasBom);
-      await fs3.writeFile(loaded.filePath, buffer2);
+      await fs4.writeFile(loaded.filePath, buffer2);
       return {
         mode: "replace",
         filePath: loaded.filePath,
@@ -19344,7 +19467,7 @@ async function replaceTextFileText(input) {
   const outputText = `${loaded.content.slice(0, scope.rangeStart)}${replaced}${loaded.content.slice(scope.rangeEnd)}`;
   ensureLossless(outputText, targetEncoding, targetHasBom);
   const buffer = encodeText(outputText, targetEncoding, targetHasBom);
-  await fs3.writeFile(loaded.filePath, buffer);
+  await fs4.writeFile(loaded.filePath, buffer);
   return {
     mode: "replace",
     filePath: loaded.filePath,
@@ -19362,6 +19485,35 @@ async function replaceTextFileText(input) {
   };
 }
 
+// src/plugin/text-guidance.ts
+var TEXT_TOOL_SYSTEM_MARKER = "[opencode-gbk-tools:text-rules]";
+var TEXT_TOOL_SYSTEM_PROMPT = [
+  TEXT_TOOL_SYSTEM_MARKER,
+  "\u6587\u672C\u6587\u4EF6\u5904\u7406\u89C4\u5219\uFF1A",
+  "- \u666E\u901A UTF-8 / UTF-8 BOM / UTF-16 \u6587\u672C\uFF0C\u4F18\u5148\u4F7F\u7528 OpenCode \u5185\u7F6E read\u3001write\u3001edit\u3002",
+  "- \u9047\u5230 GBK / GB18030 \u6587\u4EF6\u3001\u4E2D\u6587\u4E71\u7801\u3001\u975E UTF-8 \u65E7\u6587\u672C\uFF0C\u4F18\u5148\u4F7F\u7528 gbk_read\u3001gbk_write\u3001gbk_edit\u3001gbk_search\uFF0C\u4E0D\u8981\u5148\u5C1D\u8BD5 text_* \u6216\u5185\u7F6E read/write/edit\u3002",
+  "- \u65B0\u5EFA .txt \u6587\u4EF6\u5728 encoding=auto \u4E0B\u9ED8\u8BA4\u4F7F\u7528 GBK\uFF1B\u5176\u4ED6\u65B0\u6587\u4EF6\u8BF7\u663E\u5F0F\u6307\u5B9A encoding\u3002",
+  "- \u5BF9\u73B0\u6709 .txt / .cfg / .ini / .log \u7B49\u65E7\u6587\u672C\u6587\u4EF6\uFF0C\u53EA\u8981\u6000\u7591\u662F\u4E2D\u6587\u672C\u5730\u7F16\u7801\uFF0C\u4F18\u5148\u5148\u7528 gbk_read \u5224\u65AD\uFF0C\u4E0D\u8981\u5148 edit \u518D\u56E0\u4E3A\u5339\u914D\u5931\u8D25\u6216\u6587\u4EF6\u65F6\u95F4\u6233\u53D8\u5316\u800C\u56DE\u9000\u3002",
+  "- \u5DF2\u786E\u8BA4\u6216\u9996\u6B21\u68C0\u6D4B\u5230\u662F GBK/GB18030 \u7684\u6587\u4EF6\u4F1A\u88AB\u63D2\u4EF6\u6301\u4E45\u8BB0\u5FC6\uFF1B\u518D\u6B21\u64CD\u4F5C\u540C\u4E00\u8DEF\u5F84\u65F6\uFF0C\u4F1A\u76F4\u63A5\u62E6\u622A\u5185\u7F6E read/write/edit \u548C text_*\uFF0C\u5E76\u8981\u6C42\u6539\u7528 gbk_*\u3002",
+  "- \u5982\u679C\u610F\u56FE\u662F\u2018\u5728\u67D0\u6807\u7B7E\u524D\u540E\u63D2\u5165\u5185\u5BB9\u2019\uFF0C\u4F18\u5148\u4F7F\u7528 mode=insertAfter \u6216 mode=insertBefore\uFF0C\u5E76\u4F20 anchor/content\u3002",
+  "- \u53EA\u6709\u5728\u660E\u786E\u505A\u7CBE\u786E\u66FF\u6362\u65F6\uFF0C\u624D\u4F7F\u7528 oldString/newString\u3002",
+  "- anchor\u3001startAnchor\u3001endAnchor\u3001oldString \u82E5\u76F4\u63A5\u590D\u5236\u81EA\u8BFB\u53D6\u7ED3\u679C\uFF0C\u53EF\u4FDD\u7559 LF \u6362\u884C\uFF1Bgbk_edit / text_edit \u4F1A\u5C3D\u91CF\u6309\u6587\u4EF6\u6362\u884C\u98CE\u683C\u81EA\u52A8\u5BF9\u9F50\u3002",
+  '- \u82E5\u8BFB\u53D6\u7ED3\u679C\u5E26\u6709 "N: " \u884C\u53F7\u524D\u7F00\uFF0Cgbk_edit / text_edit \u4F1A\u5C3D\u91CF\u81EA\u52A8\u5265\u79BB\u8FD9\u4E9B\u524D\u7F00\u540E\u518D\u5339\u914D\u3002',
+  "- gbk-engine \u662F\u5F3A\u5236 GBK \u4E13\u5C5E\u6A21\u5F0F\uFF1A\u53EA\u5141\u8BB8 gbk_*\uFF0C\u4E0D\u8D70\u5185\u7F6E\u8BFB\u5199\u7F16\u8F91\u5DE5\u5177\u3002"
+].join("\n");
+function appendTextToolSystemPrompt(system) {
+  if (system.some((item) => item.includes(TEXT_TOOL_SYSTEM_MARKER))) {
+    return;
+  }
+  if (system.length === 0) {
+    system.push(TEXT_TOOL_SYSTEM_PROMPT);
+    return;
+  }
+  system[0] = `${system[0]}
+
+${TEXT_TOOL_SYSTEM_PROMPT}`;
+}
+
 // src/tools/text_edit.ts
 var text_edit_default = tool({
   description: `Edit text files with automatic encoding detection and preservation.
@@ -19505,6 +19657,58 @@ var MANAGED_TOOL_IDS = /* @__PURE__ */ new Set([
   "text_write",
   "text_edit"
 ]);
+var BUILTIN_TEXT_TOOL_IDS = /* @__PURE__ */ new Set(["read", "write", "edit"]);
+var TEXT_TOOL_IDS = /* @__PURE__ */ new Set(["text_read", "text_write", "text_edit"]);
+var ROUTED_TEXT_TOOL_IDS = /* @__PURE__ */ new Set([...BUILTIN_TEXT_TOOL_IDS, ...TEXT_TOOL_IDS]);
+function getToolFilePath(args) {
+  if (!args || typeof args !== "object") {
+    return null;
+  }
+  const filePath = args.filePath;
+  return typeof filePath === "string" ? filePath : null;
+}
+function getToolAllowExternal(args) {
+  if (!args || typeof args !== "object") {
+    return false;
+  }
+  return args.allowExternal === true;
+}
+function normalizeSessionFilePath(filePath, directory, worktree) {
+  const resolved = path5.normalize(resolveCandidatePath(filePath, { directory, worktree }));
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function buildGbkRoutingMessage(filePath, encoding) {
+  return `\u6587\u4EF6\u68C0\u6D4B\u4E3A ${encoding.toUpperCase()} \u7F16\u7801\uFF0C\u8BF7\u76F4\u63A5\u6539\u7528 gbk_read\u3001gbk_write\u3001gbk_edit \u6216 gbk_search\uFF0C\u4E0D\u8981\u5148\u4F7F\u7528\u5185\u7F6E read/write/edit \u6216 text_*\uFF1A${filePath}`;
+}
+function buildTextEditSessionRoutingMessage(filePath) {
+  return `\u5F53\u524D\u4F1A\u8BDD\u5DF2\u5BF9\u8BE5\u6587\u4EF6\u4F7F\u7528 text_edit\uFF0C\u8BF7\u7EE7\u7EED\u4F7F\u7528 text_read\u3001text_write\u3001text_edit \u6216\u76F4\u63A5\u6539\u7528 gbk_*\uFF1B\u4E0D\u8981\u518D\u5207\u56DE\u5185\u7F6E read/write/edit\uFF0C\u4EE5\u514D\u89E6\u53D1\u6587\u4EF6\u65B0\u9C9C\u5EA6\u68C0\u67E5\u51B2\u7A81\uFF1A${filePath}`;
+}
+async function detectExistingGbkEncoding(filePath, allowExternal, directory, worktree) {
+  try {
+    const detected = await detectTextFileEncoding({
+      filePath,
+      encoding: "auto",
+      allowExternal,
+      context: { directory, worktree }
+    });
+    return isRememberedGbkEncoding(detected.encoding) ? detected.encoding : null;
+  } catch {
+    return null;
+  }
+}
+async function maybePersistRememberedEncoding(metadata) {
+  const filePath = typeof metadata.filePath === "string" ? metadata.filePath : null;
+  const encoding = metadata.encoding;
+  if (!filePath) {
+    return;
+  }
+  if (isRememberedGbkEncoding(encoding)) {
+    await rememberGbkEncoding(filePath, encoding);
+    metadata.rememberedEncoding = encoding;
+    return;
+  }
+  await forgetRememberedEncoding(filePath);
+}
 function truncateMetadataPreview(value, sessionID) {
   const previewMaxChars = Math.max(800, Math.min(2e3, Math.floor(getMaxOutputChars(sessionID) / 2)));
   if (value.length <= previewMaxChars) return value;
@@ -19555,7 +19759,25 @@ async function maybeAutoSummarizeSession(client, directory, input) {
     markAutoSummarizeFinished(input.sessionID, false);
   }
 }
-function createOpencodeGbkHooks(client, directory) {
+function createOpencodeGbkHooks(client, directory, worktree) {
+  const sessionTextEditedFiles = /* @__PURE__ */ new Map();
+  function rememberSessionTextEditFile(sessionID, normalizedFilePath) {
+    if (!sessionID) {
+      return;
+    }
+    let files = sessionTextEditedFiles.get(sessionID);
+    if (!files) {
+      files = /* @__PURE__ */ new Set();
+      sessionTextEditedFiles.set(sessionID, files);
+    }
+    files.add(normalizedFilePath);
+  }
+  function hasSessionTextEditFile(sessionID, normalizedFilePath) {
+    if (!sessionID) {
+      return false;
+    }
+    return sessionTextEditedFiles.get(sessionID)?.has(normalizedFilePath) ?? false;
+  }
   return {
     tool: {
       gbk_read: gbk_read_default,
@@ -19581,6 +19803,38 @@ function createOpencodeGbkHooks(client, directory) {
         await maybeAutoSummarizeSession(client, directory, input);
       }
     },
+    async "tool.execute.before"(input, output) {
+      const filePath = getToolFilePath(output.args);
+      if (!filePath) {
+        return;
+      }
+      if (!ROUTED_TEXT_TOOL_IDS.has(input.tool)) {
+        return;
+      }
+      const normalizedFilePath = normalizeSessionFilePath(filePath, directory, worktree);
+      if (BUILTIN_TEXT_TOOL_IDS.has(input.tool) && hasSessionTextEditFile(input.sessionID, normalizedFilePath)) {
+        throw new Error(buildTextEditSessionRoutingMessage(filePath));
+      }
+      const resolvedFilePath = resolveCandidatePath(filePath, { directory, worktree });
+      const remembered = await getRememberedGbkEncoding(resolvedFilePath);
+      if (remembered) {
+        throw new Error(buildGbkRoutingMessage(filePath, remembered.encoding));
+      }
+      const detectedEncoding = await detectExistingGbkEncoding(
+        resolvedFilePath,
+        getToolAllowExternal(output.args),
+        directory,
+        worktree
+      );
+      if (!detectedEncoding) {
+        return;
+      }
+      try {
+        await rememberGbkEncoding(resolvedFilePath, detectedEncoding);
+      } catch {
+      }
+      throw new Error(buildGbkRoutingMessage(filePath, detectedEncoding));
+    },
     async "tool.execute.after"(input, output) {
       if (!MANAGED_TOOL_IDS.has(input.tool)) return;
       const maxOutputChars = getMaxOutputChars(input.sessionID);
@@ -19596,6 +19850,17 @@ function createOpencodeGbkHooks(client, directory) {
       if (typeof metadata.diffPreview === "string") {
         metadata.diffPreview = truncateMetadataPreview(metadata.diffPreview, input.sessionID);
       }
+      if (input.tool === "text_edit" && typeof metadata.filePath === "string") {
+        rememberSessionTextEditFile(
+          input.sessionID,
+          normalizeSessionFilePath(metadata.filePath, directory, worktree)
+        );
+      }
+      try {
+        await maybePersistRememberedEncoding(metadata);
+      } catch {
+        metadata.encodingMemoryWarning = "\u8BB0\u5FC6\u6587\u4EF6\u7F16\u7801\u5931\u8D25\uFF0C\u5DF2\u5FFD\u7565";
+      }
       metadata.maxOutputChars = maxOutputChars;
       if (compactionCount > 0) {
         metadata.sessionCompactions = compactionCount;
@@ -19622,7 +19887,7 @@ function createOpencodeGbkHooks(client, directory) {
 var pluginModule = {
   id: "opencode-gbk-tools",
   async server(ctx) {
-    return createOpencodeGbkHooks(ctx.client, ctx.directory);
+    return createOpencodeGbkHooks(ctx.client, ctx.directory, ctx.worktree);
   }
 };
 var plugin_default = pluginModule;