@trim21/personal-pi-extensions 0.0.432 → 0.0.435

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.0.432",
+  "version": "0.0.435",
   "type": "module",
   "description": "Custom pi coding-agent extensions: bwrap sandbox, workspace guard, opencode edit, and more",
   "keywords": [

package/src/bwrap/core.ts

@@ -11,7 +11,12 @@ import { Value } from "typebox/value";
 import { parseWithSchema } from "../lib/parse-with-schema.js";
 import { expandHome } from "../lib/path.js";
 import { type ApprovalRule } from "./approval-rules.js";
-import { type NetworkStack, resolveDnsServers, startNetworkStack } from "./network-stack.js";
+import {
+  type NetworkStack,
+  resolveDnsServers,
+  startNetworkStack,
+  TimeoutError,
+} from "./network-stack.js";
 
 const PROTECTED_DIRS = [".pi", ".agent"];
 
@@ -399,7 +404,8 @@ export function createBwrapBashOperations(
       await fsAccess(cwd, constants.F_OK).catch(() => {
         throw new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`);
       });
-      if (signal?.aborted) throw new Error("aborted");
+      // 已中断（signal.reason 是 name=AbortError 的 DOMException）：直接抛，不再执行
+      signal?.throwIfAborted();
 
       // 干净环境：不继承父进程 env/PATH，由 bash -lc 从 /etc/profile 与用户 profile 重建
       const home = process.env.HOME;
@@ -470,9 +476,17 @@ export function createBwrapBashOperations(
         child.once("close", (exitCode) => {
           if (timeoutHandle) clearTimeout(timeoutHandle);
           signal?.removeEventListener("abort", onAbort);
-          if (signal?.aborted) reject(new Error("aborted"));
-          else if (timedOut) reject(new Error(`timeout:${timeout}`));
-          else resolve({ exitCode });
+          // 中断：reject signal.reason（默认是 name=AbortError 的 DOMException）
+          if (signal?.aborted) {
+            reject(
+              signal.reason instanceof Error
+                ? signal.reason
+                : new Error("The operation was aborted"),
+            );
+          } else if (timedOut) {
+            // 超时：name=TimeoutError（对齐标准错误分类）
+            reject(new TimeoutError(timeout));
+          } else resolve({ exitCode });
         });
       });
     },

package/src/bwrap/mihomo-config.ts

@@ -27,6 +27,8 @@ export interface MihomoConfig {
     nameserver: string[];
     "default-nameserver": string[];
     "fake-ip-filter"?: string[];
+    /** 域名级 DNS 规则（mihomo >= 1.18）：allowlist 域名 DIRECT，其余 REJECT。 */
+    rules: string[];
   };
   tun: {
     enable: true;
@@ -111,6 +113,8 @@ function ipRule(host: string): string {
 interface BuiltRules {
   rules: string[];
   fakeIpFilter: string[];
+  /** DNS 层规则：allowlist 域名正常解析，未允许域名直接拒绝（解析失败而非 fake-ip 后连接失败）。 */
+  dnsRules: string[];
 }
 
 /**
@@ -119,14 +123,20 @@ interface BuiltRules {
  *   拿到 fakeip 再进 TUN 形成环（loopback detector 会拒绝）；
  * - 无端口条目直接匹配；带端口条目用 AND 组合（域名/IP + DST-PORT）精确放行；
  * - 最后以 MATCH,REJECT 兜底实现 deny-by-default。
+ * dns.rules 同步构建：allowlist 域名 DIRECT，其余 MATCH,REJECT——未允许域名
+ * 在 DNS 层即被拒绝（curl 报 Could not resolve host），而不是先拿 fake-ip、
+ * 到连接层才断（报 TLS decode error，容易误判为网络故障）。
  */
 function buildRules(allowlist: readonly string[]): BuiltRules {
   const rules: string[] = [];
   const fakeIpFilter: string[] = [];
+  const dnsRules: string[] = [];
   for (const entry of allowlist) {
     const { host, port } = parseAllowlistEntry(entry);
     if (!isIp(host)) {
       fakeIpFilter.push(`+.${host}`);
+      // DNS 层按域名放行（端口无关）；连接层规则保留端口语义
+      dnsRules.push(`DOMAIN-SUFFIX,${host},DIRECT`);
       if (port === undefined) {
         rules.push(`DOMAIN-SUFFIX,${host},DIRECT`);
       } else {
@@ -139,7 +149,8 @@ function buildRules(allowlist: readonly string[]): BuiltRules {
     }
   }
   rules.push("MATCH,REJECT");
-  return { rules, fakeIpFilter };
+  dnsRules.push("MATCH,REJECT");
+  return { rules, fakeIpFilter, dnsRules };
 }
 
 /**
@@ -154,7 +165,7 @@ export function generateMihomoConfig(options: MihomoConfigOptions): MihomoConfig
   if (dnsServers.length === 0) {
     throw new Error("At least one DNS server is required");
   }
-  const { rules, fakeIpFilter } = buildRules(allowlist);
+  const { rules, fakeIpFilter, dnsRules } = buildRules(allowlist);
   return {
     "mixed-port": 0,
     mode: "rule",
@@ -168,6 +179,7 @@ export function generateMihomoConfig(options: MihomoConfigOptions): MihomoConfig
       nameserver: [...dnsServers],
       "default-nameserver": [...dnsServers],
       ...(fakeIpFilter.length > 0 && { "fake-ip-filter": fakeIpFilter }),
+      rules: dnsRules,
     },
     tun: {
       enable: true,

package/src/bwrap/network-stack.ts

@@ -6,6 +6,14 @@ import { fileURLToPath } from "node:url";
 
 import { generateMihomoConfig } from "./mihomo-config.js";
 
+/** 命令超时错误：name=TimeoutError（对齐标准错误分类），message 保留 timeout:N 格式。 */
+export class TimeoutError extends Error {
+  constructor(timeout: number | undefined) {
+    super(`timeout:${timeout}`);
+    this.name = "TimeoutError";
+  }
+}
+
 export interface NetworkStackOptions {
   /** 允许直连的域名 / IP:port 列表（每次命令从配置重新读取）。 */
   readonly allowlist: readonly string[];
@@ -225,9 +233,17 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
           settled = true;
           if (timeoutHandle) clearTimeout(timeoutHandle);
           execOptions.signal?.removeEventListener("abort", onAbort);
-          if (execOptions.signal?.aborted) reject(new Error("aborted"));
-          else if (timedOut) reject(new Error(`timeout:${execOptions.timeout}`));
-          else resolve({ exitCode });
+          // 中断：reject signal.reason（默认是 name=AbortError 的 DOMException）
+          if (execOptions.signal?.aborted) {
+            reject(
+              execOptions.signal.reason instanceof Error
+                ? execOptions.signal.reason
+                : new Error("The operation was aborted"),
+            );
+          } else if (timedOut) {
+            // 超时：name=TimeoutError（对齐标准错误分类）
+            reject(new TimeoutError(execOptions.timeout));
+          } else resolve({ exitCode });
         });
       });
     },

package/src/bwrap/runtime.ts

@@ -108,6 +108,35 @@ export interface BwrapExecutionResult {
   truncation: TruncationResult;
 }
 
+/**
+ * 超时/中断时命令终止前已捕获的部分输出快照（截断后的文本 + 落盘信息）。
+ * 展示格式（输出在前、状态在最后）由上层 Bash 工具按各自风格拼接。
+ */
+export interface BashExecutionPartial {
+  output: string;
+  truncation: TruncationResult;
+  fullOutputPath?: string;
+}
+
+/** 命令超时或中断（abort signal）时抛出的错误，携带部分输出供上层展示。 */
+export class BashInterruptedError extends Error {
+  readonly kind: "timeout" | "aborted";
+  readonly partial: BashExecutionPartial;
+
+  constructor(
+    kind: "timeout" | "aborted",
+    message: string,
+    partial: BashExecutionPartial,
+    cause: unknown,
+  ) {
+    super(message, { cause });
+    this.kind = kind;
+    this.partial = partial;
+    // 对齐标准错误分类：中断=AbortError（用户取消），超时=TimeoutError
+    this.name = kind === "aborted" ? "AbortError" : "TimeoutError";
+  }
+}
+
 function escapeHtml(text: string): string {
   return text
     .replaceAll("&", "&")
@@ -402,35 +431,35 @@ export class BwrapRuntime {
         signal: request.signal,
         timeout: request.timeout,
       });
-      await output.close();
-      const truncation = truncateTail(output.tailText());
-      // 未截断：完整输出已直接返回给模型，临时文件没有用途，删掉避免
-      // agent-dir/tmp 堆积无主文件（删除失败只残留文件，不影响命令结果）
-      if (!truncation.truncated && output.filePath) {
-        try {
-          await unlink(output.filePath);
-        } catch {
-          // 删除失败（如沙箱只读）：best-effort，命令结果不受影响
-        }
-        output.filePath = undefined;
-      }
+      const partial = await this.finalizeOutput(output);
       return {
         exitCode,
-        output: truncation.content,
-        ...(output.filePath && { fullOutputPath: output.filePath }),
-        // 用精确统计值覆盖尾部缓冲的估算（提示文本的行数/字节数要准确）
-        truncation: { ...truncation, ...output.stats },
+        output: partial.output,
+        ...(partial.fullOutputPath && { fullOutputPath: partial.fullOutputPath }),
+        truncation: partial.truncation,
       };
     } catch (error) {
-      // 底层统一把超时/中断转成可读文案（对齐 pi 内置 bash 工具）
-      if (error instanceof Error && error.message.startsWith("timeout:")) {
-        throw new Error(
+      // 超时/中断：把命令终止前已捕获的输出附在错误上（文本 + 落盘路径），
+      // 展示时输出在前、状态在最后（对齐 pi 内置 bash），避免只报超时丢输出
+      // 超时识别：优先 name=TimeoutError（对齐标准错误分类），
+      // 兼容 pi local ops 抛的 `timeout:N`（name=Error）
+      if (
+        error instanceof Error &&
+        (error.name === "TimeoutError" || error.message.startsWith("timeout:"))
+      ) {
+        const partial = await this.finalizeOutput(output);
+        throw new BashInterruptedError(
+          "timeout",
           `Command timed out after ${error.message.slice("timeout:".length)} seconds`,
-          { cause: error },
+          partial,
+          error,
         );
       }
-      if (error instanceof Error && error.message === "aborted") {
-        throw new Error("Command aborted", { cause: error });
+      // 中断识别：优先 name=AbortError（throwIfAborted/signal.reason），
+      // 兼容 pi local ops 抛的 new Error("aborted")
+      if (error instanceof Error && (error.name === "AbortError" || error.message === "aborted")) {
+        const partial = await this.finalizeOutput(output);
+        throw new BashInterruptedError("aborted", "Command aborted", partial, error);
       }
       throw error;
     } finally {
@@ -439,6 +468,28 @@ export class BwrapRuntime {
     }
   }
 
+  /** 关闭输出流并返回截断后的快照；未截断时删除临时文件（成功与超时/中断路径共用）。 */
+  private async finalizeOutput(output: BashOutput): Promise<BashExecutionPartial> {
+    await output.close();
+    const truncation = truncateTail(output.tailText());
+    // 未截断：完整输出已直接返回给模型，临时文件没有用途，删掉避免
+    // agent-dir/tmp 堆积无主文件（删除失败只残留文件，不影响命令结果）
+    if (!truncation.truncated && output.filePath) {
+      try {
+        await unlink(output.filePath);
+      } catch {
+        // 删除失败（如沙箱只读）：best-effort，命令结果不受影响
+      }
+      output.filePath = undefined;
+    }
+    return {
+      output: truncation.content,
+      ...(output.filePath && { fullOutputPath: output.filePath }),
+      // 用精确统计值覆盖尾部缓冲的估算（提示文本的行数/字节数要准确）
+      truncation: { ...truncation, ...output.stats },
+    };
+  }
+
   private resolve(ctx: Pick<ExtensionContext, "cwd" | "hasUI">): ResolvedBwrap {
     const config = loadBwrapConfig(ctx.cwd);
     if (!ctx.hasUI) return resolveHeadlessBwrap(config);

package/src/claude-code/common.ts

@@ -53,10 +53,6 @@ export function toRelativePath(filePath: string, cwd: string): string {
   return relativePath.startsWith("..") ? filePath : relativePath;
 }
 
-export function throwIfAborted(signal: AbortSignal | undefined): void {
-  if (signal?.aborted) throw new Error("Operation aborted");
-}
-
 export function snapshotsEqual(left: FileSnapshot, right: FileSnapshot): boolean {
   return left.digest === right.digest;
 }

package/src/claude-code/files.ts

@@ -27,7 +27,6 @@ import {
   type FileSnapshot,
   requireAbsolutePath,
   snapshotsEqual,
-  throwIfAborted,
 } from "./common.js";
 import { convertLeadingTabsToSpaces, findActualString, preserveQuoteStyle } from "./edit-utils.js";
 
@@ -256,7 +255,7 @@ export function registerFileTools(
       { additionalProperties: false },
     ),
     async execute(_id, params, signal, _onUpdate, ctx) {
-      throwIfAborted(signal);
+      signal?.throwIfAborted();
       const filePath = requireAbsolutePath(params.file_path);
       if (
         params.offset !== undefined &&
@@ -280,7 +279,7 @@ export function registerFileTools(
         }
         throw error;
       }
-      throwIfAborted(signal);
+      signal?.throwIfAborted();
 
       const extension = extname(filePath).toLowerCase();
       if (extension === ".pdf") {
@@ -392,7 +391,7 @@ export function registerFileTools(
       { additionalProperties: false },
     ),
     async execute(_id, params, signal, _onUpdate, ctx) {
-      throwIfAborted(signal);
+      signal?.throwIfAborted();
       const filePath = requireAbsolutePath(params.file_path);
       await guardWriteAccess(ctx, {
         toolName: "Edit",
@@ -438,7 +437,7 @@ export function registerFileTools(
               const key = await readStateKey(filePath);
               state.reads.set(key, snapshot);
               const diff = generateDiffString("", convertLeadingTabsToSpaces(newString));
-              throwIfAborted(signal);
+              signal?.throwIfAborted();
               const {
                 text: diagnosticText,
                 errorCount,
@@ -495,7 +494,7 @@ export function registerFileTools(
             const key = await readStateKey(filePath);
             requireCurrentRead(state, key, filePath, content);
             await access(filePath, constants.R_OK | constants.W_OK);
-            throwIfAborted(signal);
+            signal?.throwIfAborted();
             const original = content.toString("utf8");
 
             // CRLF 规范化后匹配（old_string 不需要带 \r），写回时恢复原行尾
@@ -541,7 +540,7 @@ export function registerFileTools(
             const text = replaceAll
               ? `The file ${filePath} has been updated. All occurrences were successfully replaced.`
               : `The file ${filePath} has been updated successfully.`;
-            throwIfAborted(signal);
+            signal?.throwIfAborted();
             const {
               text: diagnosticText,
               errorCount,
@@ -602,7 +601,7 @@ export function registerFileTools(
       { additionalProperties: false },
     ),
     async execute(_id, params, signal, _onUpdate, ctx) {
-      throwIfAborted(signal);
+      signal?.throwIfAborted();
       const filePath = requireAbsolutePath(params.file_path);
       await guardWriteAccess(ctx, {
         toolName: "Write",
@@ -628,7 +627,7 @@ export function registerFileTools(
                 throw error;
               }
             }
-            throwIfAborted(signal);
+            signal?.throwIfAborted();
             await mkdir(dirname(filePath), { recursive: true });
             await writeFile(filePath, params.content, "utf8");
             const snapshot = snapshotOf(params.content);
@@ -640,7 +639,7 @@ export function registerFileTools(
               original === undefined
                 ? `File created successfully at: ${filePath}`
                 : `The file ${filePath} has been updated successfully.`;
-            throwIfAborted(signal);
+            signal?.throwIfAborted();
             const {
               text: diagnosticText,
               errorCount,

package/src/claude-code/glob.ts

@@ -15,7 +15,7 @@ import { promisify } from "node:util";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
-import { searchRoot, suggestPathUnderCwd, throwIfAborted, toRelativePath } from "./common.js";
+import { searchRoot, suggestPathUnderCwd, toRelativePath } from "./common.js";
 
 const GLOB_RESULT_LIMIT = 100;
 
@@ -58,7 +58,7 @@ export async function globFiles(
   cwd: string,
   signal?: AbortSignal,
 ): Promise<{ files: string[]; truncated: boolean }> {
-  throwIfAborted(signal);
+  signal?.throwIfAborted();
   let searchDir = cwd;
   let searchPattern = pattern;
   if (isAbsolute(pattern)) {
@@ -87,7 +87,6 @@ export async function globFiles(
     });
     stdout = result.stdout;
   } catch (error) {
-    if (signal?.aborted) throwIfAborted(signal);
     // rg exit code 1 = 搜索完成但无匹配，对齐 Claude Code 的 ripGrep（正常空结果）
     const code = (error as { code?: unknown }).code;
     if (code === 1) return { files: [], truncated: false };

package/src/claude-code/grep.ts

@@ -17,7 +17,7 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
 
-import { searchRoot, suggestPathUnderCwd, throwIfAborted, toRelativePath } from "./common.js";
+import { searchRoot, suggestPathUnderCwd, toRelativePath } from "./common.js";
 
 const GREP_OUTPUT_MODES = ["content", "files_with_matches", "count"] as const;
 
@@ -272,7 +272,7 @@ export function registerGrepTool(pi: ExtensionAPI): void {
         }
       }
       const result = await pi.exec("rg", buildGrepArguments(params, ctx.cwd), { signal });
-      throwIfAborted(signal);
+      signal?.throwIfAborted();
       if (result.code !== 0 && result.code !== 1) {
         throw new Error(result.stderr.trim() || `ripgrep exited with code ${result.code}`);
       }

package/src/claude-code/session-tools.ts

@@ -193,7 +193,7 @@ export function registerSessionTools(pi: ExtensionAPI): void {
       if (!ctx.hasUI) throw new Error("Cannot ask questions: interactive UI is not available");
       const answers: Record<string, string> = {};
       for (const question of params.questions) {
-        if (signal?.aborted) throw new Error("Operation aborted");
+        signal?.throwIfAborted();
         answers[question.question] = question.multiSelect
           ? await askMultiple(question, ctx, signal)
           : await askSingle(question, ctx, signal);

package/src/claude-code/shell.ts

@@ -6,10 +6,11 @@ import {
   type BashToolDetails,
   type ExtensionAPI,
   formatSize,
+  type TruncationResult,
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
-import { type BwrapRuntime, createBwrapRuntime } from "../bwrap/runtime.js";
+import { BashInterruptedError, type BwrapRuntime, createBwrapRuntime } from "../bwrap/runtime.js";
 import { resolveWorkdir } from "../lib/path.js";
 
 const DEFAULT_TIMEOUT_MS = 120_000;
@@ -36,6 +37,25 @@ function formatBashError(exitCode: number | null, output: string): string {
   );
 }
 
+/** 输出被截断时附加的 `[Showing lines...]` 提示（成功、超时、中断路径共用）。 */
+function appendTruncationNotice(
+  text: string,
+  truncation: TruncationResult,
+  fullOutputPath: string | undefined,
+): string {
+  if (!fullOutputPath || !truncation.truncated) return text;
+  const startLine = truncation.totalLines - truncation.outputLines + 1;
+  const endLine = truncation.totalLines;
+  if (truncation.lastLinePartial) {
+    const lastLineSize = formatSize(text.length - text.lastIndexOf("\n", text.length - 2) - 1);
+    return `${text}\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${fullOutputPath}]`;
+  }
+  if (truncation.truncatedBy === "lines") {
+    return `${text}\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${fullOutputPath}]`;
+  }
+  return `${text}\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(truncation.maxBytes)} limit). Full output: ${fullOutputPath}]`;
+}
+
 /**
  * 成功路径：消费 runtime 的截断结果（输出已由 runtime 截断并落盘），
  * 截断时追加 `[Showing lines X-Y of N. Full output: path]` 提示。
@@ -46,21 +66,7 @@ export function formatBashSuccess(result: Awaited<ReturnType<BwrapRuntime["execu
   details: BashToolDetails | undefined;
 } {
   const { output, truncation, fullOutputPath } = result;
-  let text = output || "(no output)";
-  if (fullOutputPath && truncation.truncated) {
-    const startLine = truncation.totalLines - truncation.outputLines + 1;
-    const endLine = truncation.totalLines;
-    if (truncation.lastLinePartial) {
-      const lastLineSize = formatSize(
-        output.length - output.lastIndexOf("\n", output.length - 2) - 1,
-      );
-      text += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${fullOutputPath}]`;
-    } else if (truncation.truncatedBy === "lines") {
-      text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${fullOutputPath}]`;
-    } else {
-      text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(truncation.maxBytes)} limit). Full output: ${fullOutputPath}]`;
-    }
-  }
+  const text = appendTruncationNotice(output || "(no output)", truncation, fullOutputPath);
   return {
     content: [{ type: "text", text }],
     details: fullOutputPath && truncation.truncated ? { truncation, fullOutputPath } : undefined,
@@ -133,13 +139,24 @@ export function registerShellTools(
         });
       } catch (error) {
         if (!(error instanceof Error)) throw error;
-        const timeoutMatch = /Command timed out after [\d.]+ seconds/.exec(error.message);
-        const message = timeoutMatch
-          ? error.message.slice(0, timeoutMatch.index) +
-            `Command timed out after ${timeout} milliseconds` +
-            error.message.slice(timeoutMatch.index + timeoutMatch[0].length)
-          : error.message;
-        throw new Error(message, { cause: error });
+        if (error instanceof BashInterruptedError) {
+          // 输出在前（必要时带截断提示），状态文本在最后
+          const text = appendTruncationNotice(
+            error.partial.output || "",
+            error.partial.truncation,
+            error.partial.fullOutputPath,
+          );
+          if (error.kind === "aborted") {
+            // 用户取消：直接返回已捕获的输出，不抛错
+            const full = text ? `${text}\n\nCommand aborted` : "Command aborted";
+            return { content: [{ type: "text", text: full }], details: undefined };
+          }
+          const full = text
+            ? `${text}\n\nCommand timed out after ${timeout} milliseconds`
+            : `Command timed out after ${timeout} milliseconds`;
+          throw new Error(full, { cause: error });
+        }
+        throw error;
       }
 
       // 对齐 Claude Code：非 0 退出码视为错误（不做 grep/find 等命令语义化特判，

package/src/lib/path.ts

@@ -61,7 +61,7 @@ export function formatDisplayPath(cwd: string, filePath: string): string {
 }
 
 /** subtitle 中路径的最大显示长度，超过时退化为 `parent/basename`。 */
-export const MAX_SUBTITLE_PATH_LENGTH = 20;
+export const MAX_SUBTITLE_PATH_LENGTH = 30;
 
 function shortenSubtitlePath(filePath: string, display: string): string {
   if (display.length <= MAX_SUBTITLE_PATH_LENGTH) return display;

package/src/opencode/bash.ts

@@ -1,10 +1,10 @@
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, TruncationResult } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
-import { type BwrapRuntime, createBwrapRuntime } from "../bwrap/runtime.js";
+import { BashInterruptedError, type BwrapRuntime, createBwrapRuntime } from "../bwrap/runtime.js";
 import { resolveWorkdir } from "../lib/path.js";
 
 const DEFAULT_TIMEOUT_MS = 120_000;
@@ -16,6 +16,18 @@ const CAPTURE_TRUNCATED_NOTICE = "[output capture truncated at the in-memory saf
 /** Bash tool guidance, kept in markdown so it reads like documentation. */
 const BASH_PROMPT = readFileSync(fileURLToPath(new URL("bash.md", import.meta.url)), "utf8").trim();
 
+/** opencode 风格截断提示（成功、超时、中断路径共用）。 */
+function appendTruncationNotice(
+  text: string,
+  truncation: TruncationResult,
+  fullOutputPath: string | undefined,
+): string {
+  if (!truncation.truncated) return text;
+  let out = `${text}\n\n${CAPTURE_TRUNCATED_NOTICE}`;
+  if (fullOutputPath) out += `\nFull output: ${fullOutputPath}`;
+  return out;
+}
+
 /**
  * 对齐上游 opencode（packages/core/src/tool/bash.ts）：
  * 命令失败（非 0 退出码）与超时都不抛错，输出与状态文本一起返回，
@@ -89,17 +101,21 @@ export default function opencodeBash(
         });
       } catch (error) {
         if (!(error instanceof Error)) throw error;
-        // 对齐上游 opencode：超时不抛错，返回提示文本（丢弃部分输出）
-        if (/Command timed out after [\d.]+ seconds/.test(error.message)) {
+        if (error instanceof BashInterruptedError) {
+          const text = appendTruncationNotice(
+            error.partial.output || "",
+            error.partial.truncation,
+            error.partial.fullOutputPath,
+          );
+          const status =
+            error.kind === "timeout"
+              ? `Command exceeded timeout of ${timeout} ms. Retry with a larger timeout if the command is expected to take longer.`
+              : "Command aborted";
+          const full = text ? `${text}\n\n${status}` : status;
+          // 对齐上游 opencode：超时与中断都不抛错，输出与状态文本一起返回
           return {
-            content: [
-              {
-                type: "text" as const,
-                text: `Command exceeded timeout of ${timeout} ms. Retry with a larger timeout if the command is expected to take longer.`,
-              },
-              { type: "text" as const, text: "Command timed out before completion." },
-            ],
-            details: { timeout: true },
+            content: [{ type: "text" as const, text: full }],
+            details: error.kind === "timeout" ? { timeout: true } : {},
           };
         }
         throw error;
@@ -107,10 +123,7 @@ export default function opencodeBash(
 
       // 命令失败（非 0 退出码）不抛错：输出与状态文本一起返回
       let text = result.output || "(no output)";
-      if (result.truncation.truncated) {
-        text += `\n\n${CAPTURE_TRUNCATED_NOTICE}`;
-        if (result.fullOutputPath) text += `\nFull output: ${result.fullOutputPath}`;
-      }
+      text = appendTruncationNotice(text, result.truncation, result.fullOutputPath);
       return {
         content: [
           { type: "text" as const, text },