@trim21/personal-pi-extensions 0.1.454 → 0.1.459

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.1.454",
+  "version": "0.1.459",
   "type": "module",
   "description": "Custom pi coding-agent extensions: bwrap sandbox, workspace guard, opencode edit, and more",
   "keywords": [
@@ -12,6 +12,7 @@
   },
   "files": [
     "src",
+    "vendor",
     "README.md"
   ],
   "publishConfig": {
@@ -24,6 +25,7 @@
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "sandbox": "tsx bin/sandbox.ts",
+    "aft-search": "tsx bin/aft-search.ts",
     "build:holder": "esbuild src/bwrap/holder.ts --format=esm --target=node24 --outfile=src/bwrap/holder.js",
     "prepare": "husky"
   },
@@ -43,6 +45,7 @@
     "@types/turndown": "^5.0.6",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@vitest/coverage-v8": "^4.1.10",
+    "citty": "^0.2.2",
     "esbuild": "^0.28.2",
     "eslint": "^10.8.1",
     "eslint-config-prettier": "10.1.8",

package/src/bwrap/README.md

@@ -0,0 +1,92 @@
+# bwrap 沙箱与网络栈架构
+
+本文档描述 `net-allowlist` 模式下的进程模型、网络路径与生命周期管理。
+基础沙箱（bwrap 文件系统隔离）见 `core.ts` / `sandbox.ts`；本文聚焦网络栈
+（`network-stack.ts` / `holder.ts` / `mihomo-config.ts`）。
+
+## 进程模型
+
+`net-allowlist` 模式下，一个沙箱 session 的常驻进程树（宿主侧视角，共 4 个）：
+
+```
+pi 进程（network-stack.ts）
+├─ ① unshare -Urnp --fork --kill-child=SIGTERM -- node holder.js …
+│    创建 user+net+pid 三个 ns；--fork 后由子进程 exec node；
+│    自己留在原地 wait；--kill-child=SIGTERM 给 ② 设 PDEATHSIG。
+│    持 exit-fd 写端（fd 3）。
+│    └─ ② node holder.js    （pid-ns 的 init，即该 pid-ns 里的 PID 1）
+│         读 stdin（EOF 自杀）、等 tap0、拉起 ③；持 exit-fd 写端 fd 3。
+│         └─ ③ mihomo       （netns 内：TUN "Meta" + 策略路由 + fakeip DNS）
+└─ ④ slirp4netns -c --userns-path=…/ns/user --netns-type=pid <①的pid> tap0 -e 3
+     必须在宿主 netns 启动（原因见「设计约束」）；持 exit-fd 读端 + tapfd。
+```
+
+每条命令的短命子树（命令结束即退，与常驻栈无关）：
+
+```
+nsenter -U -n --preserve-credentials -t <①的pid> \
+  -- bwrap --unshare-user --unshare-pid … -- bash -lc '<command>'
+```
+
+nsenter 进入 holder 的 userns/netns，bwrap 在里面再嵌套创建自己的 user/pid
+ns 跑命令。一个 session 内 N 条命令复用同一套常驻栈。
+
+## 网络路径
+
+- **mihomo（③）**：TUN（`auto-route` + `strict-route`）+ fakeip +
+  deny-by-default。allowlist 域名进 `fake-ip-filter`（真实解析），DNS 层
+  `DOMAIN-SUFFIX,…,DIRECT`；连接层未命中 allowlist 的流量 `MATCH,REJECT`。
+  注意：fakeip 对不在 filter 里的域名**直接本地应答**，不会走到
+  `dns.rules` 的 REJECT——未允许域名是先拿 fakeip、连接层再被拒。
+- **slirp4netns（④）**：egress NAT。它 fork helper 进 netns 创建 tap0 并把
+  tapfd 传回主进程，真正的出站 socket 在宿主 netns。
+- **interface-name: tap0**：mihomo 出站静态绑定 slirp 接口。不能用
+  `auto-detect-interface` 顶替——启动瞬间 tap0 可能尚未就绪，monitor 事后
+  纠正但 DNS 拨号已走错接口，上游查询进自己的 TUN 被 `dns-hijack` 自劫持。
+- **mihomo `-d <uuid 目录>`**：cache.db 等落盘位置，放
+  `<agentDir>/tmp/mihomo-<uuid>/`，每次启动独立目录避免并发争抢 bbolt 锁。
+
+## 生命周期与清理
+
+exit-fd（socketpair）是 slirp4netns 与 holder 之间唯一的生命周期绑定：
+读端给 slirp4netns（`-e 3`），写端由 holder 进程持有（network-stack 经
+`unshare` 的额外 stdio 传入 fd 3）。Node 对额外 stdio pipe 没有公开的 fd
+访问器（`stdio[3].fd` 恒为 undefined），只能经 `_handle.fd` 取原始 fd 再
+dup 给 slirp4netns，且仅在子进程存活期间有效。
+
+| 触发              | 清理链路                                                                                              |
+| ----------------- | ----------------------------------------------------------------------------------------------------- |
+| 正常 `stop()`     | SIGTERM ④（先杀，它 pin 着 netns）→ SIGTERM ① → `--kill-child` 转发给 ② → ② 杀 ③ 退出 → 内核清 pid ns |
+| pi 进程被 SIGKILL | stdin 写端关闭 → ② EOF 自杀 → pid ns 清理 → exit-fd 写端关闭 → ④ HUP 自杀 → tapfd 释放 → netns 销毁   |
+| 单独 kill ①       | PDEATHSIG → ② SIGTERM → 同上；① wait 结束退出 → 写端全关 → ④ 退                                       |
+| 单独 kill ②       | pid-ns init 死 → 内核清 ③；① 退出 → 写端全关 → ④ 退                                                   |
+
+四条路径下常驻进程全部收敛、netns 引用归零。
+
+## 设计约束与教训
+
+1. **slirp4netns 必须在宿主 netns 启动**。它的 egress socket 决定出站视角；
+   若留在沙盒 netns 里（holder 内启动），出站流量会被 mihomo 的 TUN 策略
+   路由 + `dns-hijack any:53` 自劫持成环：上游 DNS 查询自己劫自己，
+   mihomo 对劫持查询回 SERVFAIL（源 IP 伪装成原目的地址），allowlist 域名
+   全部 `ENOTFOUND`，而未 allowlist 域名反而"正常"（fakeip 本地应答）。
+   宿主侧启动后必须用 exit-fd 绑定生命周期，否则 holder 死后 slirp4netns
+   持 tapfd 泄漏 netns。
+2. **tap fd pin 住 netns**：slirp4netns 持有 tapfd 期间 netns 不会销毁，
+   所以任何架构下 slirp4netns 的终止都必须显式保证（stop() / exit-fd）。
+3. **fakeip 短路**：`dns.rules` 的 REJECT 拦不住 fakeip 应答，deny-by-default
+   实际由连接层 `MATCH,REJECT` 兜底。诊断时不要把"未允许域名能解析出
+   198.18.x.x"当成 DNS 层放行。
+4. **诊断手段**：`pnpm sandbox --verbose` 透传 holder（mihomo/slirp4netns）
+   日志；`nsenter -U -n --preserve-credentials -t <holderPid>` 可手动进入
+   netns 用 AF_PACKET 抓 tap0 / 检查 `ip rule`（注意：沙盒里看不到宿主机
+   进程，宿主机诊断必须在沙盒外做）。
+
+## 调试入口
+
+```sh
+# 诊断执行（与扩展同一条代码路径）
+pnpm sandbox --verbose -- '<command>'
+# 修改 holder.ts 后需重新构建构建产物 holder.js
+pnpm build:holder
+```

package/src/bwrap/core.ts

@@ -2,6 +2,7 @@ import { type ChildProcess, spawn } from "node:child_process";
 import { constants, type Dirent, existsSync, readFileSync } from "node:fs";
 import { access as fsAccess, readdir, stat } from "node:fs/promises";
 import { delimiter, join } from "node:path";
+import { fileURLToPath } from "node:url";
 
 import { StringEnum } from "@earendil-works/pi-ai";
 import { type BashOperations, getAgentDir, getShellConfig } from "@earendil-works/pi-coding-agent";
@@ -241,16 +242,28 @@ function findCommandInPath(name: string, hint: string): string {
   throw new Error(hint);
 }
 
-export function findMihomo(override?: string): string {
+// npm 包内自带的静态编译 mihomo（linux-x64），发布时由 CI 下载到 vendor/；
+// 源码方式运行（vendor 不存在）时自然跳过，走 PATH 查找。
+const VENDORED_MIHOMO_PATH = fileURLToPath(
+  new URL("../../vendor/mihomo-linux-x64", import.meta.url),
+);
+
+export function findMihomo(override?: string, bundledPath = VENDORED_MIHOMO_PATH): string {
   if (override) {
     if (!existsSync(override)) {
       throw new Error(`mihomo not found at configured path: ${override}`);
     }
     return override;
   }
-  return findCommandInPath(
-    "mihomo",
-    "mihomo not found in PATH. Install it from https://github.com/MetaCubeX/mihomo",
+  // 优先全局 PATH（用户自装的 mihomo），没有时回退到包内自带二进制
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    const candidate = join(directory, "mihomo");
+    if (existsSync(candidate)) return candidate;
+  }
+  if (existsSync(bundledPath)) return bundledPath;
+  throw new Error(
+    "mihomo not found in PATH and the package ships no bundled binary. " +
+      "Install it from https://github.com/MetaCubeX/mihomo",
   );
 }
 

package/src/bwrap/holder.js

@@ -1,12 +1,11 @@
 import { spawn } from "node:child_process";
-import { readFile } from "node:fs/promises";
 import { setTimeout as sleep } from "node:timers/promises";
 const args = process.argv.slice(2);
 const configBase64 = args[0];
 const mihomoPath = args[1];
-const slirp4netnsPath = args[2];
-const tunMtu = Number(args[3]);
-if (!configBase64 || !mihomoPath || !slirp4netnsPath || !tunMtu) {
+const tunMtu = Number(args[2]);
+const mihomoHome = args[3];
+if (!configBase64 || !mihomoPath || !tunMtu || !mihomoHome) {
   process.exit(2);
 }
 process.chdir("/");
@@ -27,16 +26,8 @@ async function waitFor(attempts, delayMs, predicate) {
 async function main() {
   process.stdin.resume();
   process.stdin.on("end", () => process.exit(0));
-  const status = await readFile("/proc/self/status", "utf8");
-  const hostPid = /^NSpid:\s+(.+)$/m.exec(status)?.[1].split(/\s+/, 1)[0];
-  if (!hostPid) {
-    throw new Error("Failed to resolve host pid from NSpid");
-  }
-  spawn(slirp4netnsPath, ["-c", `--mtu=${tunMtu}`, "--netns-type=pid", hostPid, "tap0"], {
-    stdio: ["ignore", "inherit", "inherit"]
-  });
   await waitFor(100, 100, tap0Exists);
-  const mihomo = spawn(mihomoPath, ["-config", configBase64], {
+  const mihomo = spawn(mihomoPath, ["-d", mihomoHome, "-config", configBase64], {
     stdio: ["ignore", "inherit", "inherit"]
   });
   const stop = () => {

package/src/bwrap/holder.ts

@@ -1,17 +1,19 @@
 /* eslint-disable no-console, unicorn/no-process-exit -- 独立 CLI 脚本，由 unshare 直接执行 */
 import { spawn } from "node:child_process";
-import { readFile } from "node:fs/promises";
 import { setTimeout as sleep } from "node:timers/promises";
 
-// 用法：unshare -Urnp --fork --kill-child node holder.ts <config-base64> <mihomo> <slirp4netns> <mtu>
+// 用法：unshare -Urnp --fork --kill-child node holder.ts <config-base64> <mihomo> <mtu> <mihomo-home-dir>
 // 本进程是 pid namespace 的 init：无论以何种方式退出（含 SIGKILL），内核都会清理该 pid ns 内的
-// slirp4netns / mihomo，userns/netns 引用随之归零。
+// mihomo，userns/netns 引用随之归零。slirp4netns 由宿主侧启动（egress 必须留在宿主 netns，
+// 否则出站流量会绕回 mihomo 的 TUN 被 dns-hijack 自劫持），它通过 exit-fd 绑定本进程的生命周期：
+// fd 3 是 exit-fd 的写端（network-stack 经 unshare 传入），本进程存活期间保持打开，死亡即关闭，
+// slirp4netns 侧收到 HUP 自行退出并释放 tap fd，netns 引用随之归零。
 const args = process.argv.slice(2);
 const configBase64 = args[0];
 const mihomoPath = args[1];
-const slirp4netnsPath = args[2];
-const tunMtu = Number(args[3]);
-if (!configBase64 || !mihomoPath || !slirp4netnsPath || !tunMtu) {
+const tunMtu = Number(args[2]);
+const mihomoHome = args[3];
+if (!configBase64 || !mihomoPath || !tunMtu || !mihomoHome) {
   process.exit(2);
 }
 
@@ -40,28 +42,15 @@ async function waitFor(
 
 async function main(): Promise<void> {
   // 宿主（pi）进程死亡检测：宿主以任何方式退出（含 SIGKILL）都会关闭它持有的 stdin 写端，
-  // 这里读到 EOF 即自杀（init 退出即触发内核清理整个 pid ns）。
+  // 这里读到 EOF 即自杀（init 退出即触发内核清理整个 pid ns，顺带关闭 exit-fd 写端）。
   process.stdin.resume();
   process.stdin.on("end", () => process.exit(0));
 
-  // 宿主视角 pid（NSpid 第一项）：/proc 挂载是宿主的（-Urnp 不含 -m，宿主视角下
-  // /proc/1 是 systemd 而非本 pid ns 的 init），slirp4netns 的 setns 必须走宿主 /proc
-  const status = await readFile("/proc/self/status", "utf8");
-  const hostPid = /^NSpid:\s+(.+)$/m.exec(status)?.[1].split(/\s+/, 1)[0];
-  if (!hostPid) {
-    throw new Error("Failed to resolve host pid from NSpid");
-  }
-
-  // slirp4netns 提供 egress：本进程已在目标 userns/netns 内，setns 到自身 netns（no-op）；
-  // 日志 inherit 到 holder 的 stdout/stderr，宿主侧诊断（--verbose）可见
-  spawn(slirp4netnsPath, ["-c", `--mtu=${tunMtu}`, "--netns-type=pid", hostPid, "tap0"], {
-    stdio: ["ignore", "inherit", "inherit"],
-  });
-
-  // mihomo 日志透传到 holder 的 stdout/stderr，宿主侧监听 "Tun adapter listening" 判定就绪
+  // tap0 由宿主侧的 slirp4netns（fork 进本 netns）创建，就绪后再拉起 mihomo。
+  // mihomo 日志透传到 holder 的 stdout/stderr，宿主侧监听 "Tun adapter listening" 判定就绪。
   await waitFor(100, 100, tap0Exists);
 
-  const mihomo = spawn(mihomoPath, ["-config", configBase64], {
+  const mihomo = spawn(mihomoPath, ["-d", mihomoHome, "-config", configBase64], {
     stdio: ["ignore", "inherit", "inherit"],
   });
 

package/src/bwrap/mihomo-config.ts

@@ -20,6 +20,8 @@ export interface MihomoConfig {
   mode: "rule";
   "log-level": "info";
   ipv6: false;
+  /** 出站静态绑定 slirp 接口（固定名 tap0）。 */
+  "interface-name": string;
   dns: {
     enable: true;
     ipv6: false;
@@ -173,6 +175,11 @@ export function generateMihomoConfig(options: MihomoConfigOptions): MihomoConfig
     mode: "rule",
     "log-level": "info",
     ipv6: false,
+    // 静态绑定 tap0：auto-detect-interface 在启动瞬间可能探测到未就绪的接口
+    //（tap0 尚由 slirp4netns 创建），monitor 事后纠正但 DNS 拨号已经走错接口，
+    // 上游查询进自己的 TUN 被 dns-hijack 自劫持形成回环（allowlist 域名全部
+    // SERVFAIL）。slirp 接口名固定是 tap0，直接写死最可靠。
+    "interface-name": "tap0",
     dns: {
       enable: true,
       ipv6: false,

package/src/bwrap/network-stack.ts

@@ -1,7 +1,11 @@
 import { type ChildProcess, spawn } from "node:child_process";
-import { readFile, readlink } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readlink } from "node:fs/promises";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
 import { forEachLine } from "../lib/proc.js";
 import { generateMihomoConfig, TUN_MTU } from "./mihomo-config.js";
 
@@ -178,12 +182,15 @@ export interface NetworkStack {
 
 interface NetworkStackState {
   holderPid: number;
+  slirpPid: number;
 }
 
 /** 兜底：调用方忘记 stop() 时，对象被 GC 回收后 kill 残留进程。 */
 const stackFinalizer = new FinalizationRegistry<NetworkStackState>((state) => {
-  // SIGTERM 经 unshare --kill-child 转发给 init，内核清理 pid ns 内全部进程
+  // SIGTERM 经 unshare --kill-child 转发给 init，内核清理 pid ns 内全部进程；
+  // slirp4netns 在宿主侧持有 tap fd，单独终止
   killProcess(state.holderPid);
+  killProcess(state.slirpPid);
 });
 
 /**
@@ -203,10 +210,17 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
   const config = generateMihomoConfig({ allowlist, dnsServers });
   const configBase64 = Buffer.from(JSON.stringify(config)).toString("base64");
 
+  // mihomo 工作目录（-d）：cache.db 等落在这里，而不是它默认的 ~/.config/mihomo/
+  //（后者不存在时 mihomo 每次启动都告警且 fakeip 映射无持久化）。每次启动用独立
+  // uuid 目录，避免并发的多个 holder 争抢 bbolt 文件锁。
+  const mihomoHome = join(getAgentDir(), "tmp", `mihomo-${randomUUID()}`);
+  await mkdir(mihomoHome, { recursive: true });
+
   let holder: ChildProcess | undefined;
+  let slirp: ChildProcess | undefined;
   try {
     // unshare -p --fork：node 成为 pid namespace 的 init，任何方式退出（含 SIGKILL）
-    // 内核都会清理 pid ns 内全部进程（slirp4netns/mihomo），ns 引用随之归零；
+    // 内核都会清理 pid ns 内全部进程（mihomo），ns 引用随之归零；
     // --kill-child=SIGTERM：宿主侧 SIGTERM unshare 时转发给 init 走优雅退出
     holder = spawn(
       "unshare",
@@ -219,8 +233,8 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
         HOLDER_PATH,
         configBase64,
         mihomoPath,
-        slirp4netnsPath,
         String(TUN_MTU),
+        mihomoHome,
       ],
       {
         env: {
@@ -228,8 +242,9 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
           PATH: `${process.env.PATH ?? ""}:${SBIN_PATH_SUFFIX}`,
         },
         // stdin 保持 pipe：本进程持有写端，进程退出（含 SIGKILL）时内核关闭 fd，
-        // holder 读到 EOF 即自杀（init 退出 → 内核清理 pid ns）
-        stdio: ["pipe", "pipe", "pipe"],
+        // holder 读到 EOF 即自杀（init 退出 → 内核清理 pid ns）。
+        // fd 3：exit-fd 写端，传给 holder 持有（holder 死亡 → 读端 HUP → slirp4netns 退出）。
+        stdio: ["pipe", "pipe", "pipe", "pipe"],
       },
     );
     forwardOutput(holder, holderOutput);
@@ -239,9 +254,45 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
     const holderPid = holder.pid;
     await waitForNewUserns(holderPid);
 
+    // slirp4netns 提供 egress，必须在宿主 netns 启动：它的 egress socket 决定出站
+    // 视角，留在沙盒 netns 里会被 mihomo 的 TUN 策略路由 + dns-hijack 自劫持成环
+    //（上游 DNS 查询自己劫自己，allowlist 域名全部 SERVFAIL）。tap fd 会被它持有
+    // 而 pin 住 netns，因此用 exit-fd（holder 的 fd 3 写端的读端）绑定 holder 生命
+    // 周期：holder 退出 → 读端 HUP → slirp4netns 退出 → tap fd 释放。
+    // --userns-path / --netns-type=pid 都指向 unshare 进程：它创建并持有目标
+    // userns/netns（node holder 是它的子进程，同 ns）。
+    // exit-fd 的读端 fd：从 holder 的额外 stdio pipe 取父进程侧的原始 fd。
+    // Node 没有公开 API 拿它（stdio[3].fd 恒为 undefined，只能读 _handle，且仅在
+    // 子进程存活期间有效）；pipe 要跨两个子进程共享（holder 持写端、slirp4netns
+    // 持读端），所以必须把父进程侧的 fd 重新 dup 给 slirp4netns。
+    const exitReadFd = (holder.stdio[3] as unknown as { _handle?: { fd?: number } } | null)?._handle
+      ?.fd;
+    if (typeof exitReadFd !== "number") {
+      throw new TypeError("Failed to resolve exit-fd from holder stdio");
+    }
+    slirp = spawn(
+      slirp4netnsPath,
+      [
+        "-c",
+        `--mtu=${TUN_MTU}`,
+        `--userns-path=/proc/${String(holderPid)}/ns/user`,
+        "--netns-type=pid",
+        String(holderPid),
+        "tap0",
+        // exit-fd：本子进程的 fd 3（stdio 第 4 项 dup 为 fd 3）
+        "-e",
+        "3",
+      ],
+      { stdio: ["ignore", "pipe", "pipe", exitReadFd] },
+    );
+    forwardOutput(slirp, holderOutput);
+    if (slirp.pid === undefined) {
+      throw new Error("Failed to start slirp4netns");
+    }
+
     await waitForMihomoStarted(holder);
 
-    const state: NetworkStackState = { holderPid };
+    const state: NetworkStackState = { holderPid, slirpPid: slirp.pid };
     const stack: NetworkStack = {
       exec: async (execOptions: NetworkStackExecOptions) => {
         const child = spawn(
@@ -311,10 +362,14 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
       },
       stop: async () => {
         const children = await readChildPids(state.holderPid);
+        // slirp4netns 持有 tap fd（pin 住 netns），必须随 holder 一起显式终止；
+        // 先杀它再杀 holder，避免 stop() 与 exit-fd HUP 的收尾时序竞争
+        killProcess(state.slirpPid);
         // SIGTERM unshare → --kill-child 转发 SIGTERM 给 init（pid ns 的 pid 1），
         // init 优雅停 mihomo 后退出，内核清理 pid ns 内全部进程，ns 引用随之归零
         killProcess(state.holderPid);
         await waitForExit(state.holderPid);
+        await waitForExit(state.slirpPid);
         // 兜底：init 未在超时内退出 → SIGKILL init → 内核清 pid ns
         for (const pid of children) {
           killProcess(pid, "SIGKILL");
@@ -326,7 +381,11 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
     return stack;
   } catch (error) {
     // 失败清理：holder（unshare）的 SIGTERM 经 --kill-child 转发给 init，
-    // init 退出时内核清理 pid ns 内全部进程；调用方拿不到 stack，这里只能靠自己
+    // init 退出时内核清理 pid ns 内全部进程；slirp4netns 在宿主侧，需单独终止
+    //（exit-fd 写端也会随 holder 死亡关闭，这里主动杀只是不等到 HUP 轮询）
+    if (slirp?.pid) {
+      killProcess(slirp.pid);
+    }
     if (holder?.pid) {
       const children = await readChildPids(holder.pid);
       killProcess(holder.pid);

package/src/bwrap/runtime.ts

@@ -28,6 +28,7 @@ import { commandPatternsFor } from "./approval-suggest.js";
 import {
   type BwrapMode,
   findBwrap,
+  findMihomo,
   getBwrapConfigPaths,
   loadBwrapConfig,
   resolveBwrap,
@@ -273,6 +274,8 @@ export class BwrapRuntime {
   private resolved: ResolvedBwrap | undefined;
   private sandboxDisabled = false;
   private bwrapUnavailable = false;
+  /** net-allowlist 首次执行时解析一次 mihomo 路径，之后随 runtime 复用，不逐命令扫描 PATH。 */
+  private mihomoPath: string | undefined;
 
   setup(pi: ExtensionAPI): void {
     pi.registerFlag("no-bwrap", {
@@ -389,6 +392,12 @@ export class BwrapRuntime {
     }
     // 不经沙箱的三种情形：Windows（无 bubblewrap）、审批通过的全权限、allow-all 模式
     const local = isWindows || needsApproval || !runtime.bwrapEnabled;
+    // mihomoPath 是 ResolvedBwrap 的 override 语义：首次 net-allowlist 执行时解析
+    // 一次存入私有字段，之后写回 resolved 直达 createNetworkStack，不逐命令扫描 PATH
+    if (runtime.network && runtime.networkAllowlist.length > 0) {
+      runtime.mihomoPath ??= this.mihomoPath ?? findMihomo();
+      this.mihomoPath = runtime.mihomoPath;
+    }
     await using output = new BashOutput(request.ctx.sessionManager.getSessionId());
     const { onUpdate } = request;
 

package/src/lib/lsp/diagnostic.ts

@@ -1,10 +1,10 @@
 /**
- * 诊断报告格式化：报告 ERROR 与 WARN，每个文件最多 20 条。
+ * 诊断报告格式化：报告 ERROR 与 WARN，每个文件最多 5 条。
  */
 
 import type { Diagnostic } from "./client.js";
 
-const MAX_PER_FILE = 20;
+const MAX_PER_FILE = 5;
 
 const SEVERITY_LABELS: Record<number, string> = {
   1: "ERROR",