fix(commondev): interrupt 的"是否真中断"判定改用 pi 的 isIdle + 真机 e2e

## 找不到的缺陷（变异测出来的）

静态判据全绿、真机也报 interrupted=true —— 但我把 sidecar 里的
`await session.abort()` **删掉**后，判据照样通过。原因：

	const hadInflight = inflight > 0;
	...
	interrupted: hadInflight,      // ← 只看"中断前有没有在跑"

任务还在跑 ⇒ inflight 仍 >0 ⇒ 照样回报"已中断"。**那正是最坏的情形：
用户以为停了，任务还在改代码、推分支。**

## 第二版又反向错了

改用"中断前后 inflight 的变化"：

	interrupted: before > 0 && inflight < before

实测 before=1 / inflight=1 ⇒ 误报"未中断"，而任务其实已经停了。
原因：inflight 是**包装层**计数，只在后台 promise 的 finally 里递减，
而 abort() 返回时那个 promise 还没收尾。

反向的谎报同样有害：用户以为没停，重复发一遍任务。

## 最终：用 pi 自己的 isIdle

	session.isIdle 是 pi 的权威视图（"当前没有在跑的任务"）
	interrupted: !wasIdle && session.isIdle

实测应答：{"ok":true,"interrupted":true,"was_idle":false,"now_idle":true}

## 真机 e2e（3 条，HA_PI_E2E / HA_ZCODE_E2E 控制）

 · TestRealPiInterruptStopsRunningTask
   真 pi 会话跑 60 步任务，12s 后中断 → interrupted=true，且会话仍可用
 · TestRealPiSameTaskWithoutInterruptStillRunning ★对照组
   同样任务不中断，15s 时仍在跑 ⇒ 证明"已中断"不是"任务碰巧跑完了"
   实测不中断时 >100s 仍未完成
 · TestRealZcodeInterruptKillsChildAndClearsHandle
   假 CLI（持续输出的 node 脚本）→ interrupt 真的 killed_pid，
   第二次 interrupt 回 no_running_turn（句柄已清，不误杀下一轮）

## 变异（这次全咬）

 删掉 await session.abort()             → 咬（now_idle=false 暴露任务仍在跑）
 把 interrupted 改回 hadInflight（代码行） → 咬

★ 静态判据里查 hadInflight 时**只查代码行、跳过注释** —— 全文 Contains
  会把解释性注释当成缺陷（实测误报一次）。

## 顺带

两份 pi sidecar（工程根 = 单测/SSH e2e 用，rawfile/ = 部署用）必须
逐字一致：既有判据 TestSidecarScriptShipsWithPackage 会比对。

example/commondev/interrupt_e2e_test.go

@@ -0,0 +1,101 @@
+package main
+
+// 真机 e2e：**取消正在运行的任务**（HA_PI_E2E=1 时运行）。
+//
+// ## 为什么静态判据不够
+//
+// interrupt_test.go 只断言"sidecar 里写了 interrupt 且调了 session.abort()"。
+// 但 abort() 是否**真的**让一条在跑的任务停下来、并且会话还能继续用，
+// 只有真跑一次能证明。这正是本项目反复强调的：判据要打在真实入口上。
+//
+// ## 对照组是判据的一半
+//
+// 只测"发了 interrupt 之后任务结束了"是不够的 —— 任务本来也可能自己跑完。
+// 必须证明：**不中断时它还在跑**。所以本判据同时跑两组。
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+// 逐步任务：要求 agent 对 60 个文件逐个工具调用，刻意拉长回合。
+const interruptE2ETask = "请逐个检查 /usr/bin 下按字节序排序的前 60 个可执行文件，" +
+	"每个文件一次工具调用，不要合并、不要跳步，全部检查完再汇总。" +
+	"这是刻意要求的逐步流程，请严格照做。"
+
+// ★★★ 判据：interrupt 真的停住了在跑的任务，且会话随后仍可用。
+func TestRealPiInterruptStopsRunningTask(t *testing.T) {
+	nodeBin, sidecarPath := piE2EReady(t)
+	workdir := t.TempDir()
+	_, w, r := startSidecarForE2E(t, nodeBin, sidecarPath, workdir, "e2e-interrupt")
+
+	if resp := callSidecar(t, w, r, 1, "ping", nil); resp.Error != nil {
+		t.Fatalf("ping 失败: %s", resp.Error.Message)
+	}
+
+	// 投递长任务
+	if resp := callSidecar(t, w, r, 2, "prompt", map[string]interface{}{"text": interruptE2ETask}); resp.Error != nil {
+		t.Fatalf("prompt 失败: %s", resp.Error.Message)
+	}
+
+	// 等它真的开始干活（否则 interrupt 会撞在"还没开始"上，得 interrupted=false）
+	time.Sleep(12 * time.Second)
+
+	// 发中断
+	resp := callSidecar(t, w, r, 3, "interrupt", nil)
+	if resp.Error != nil {
+		t.Fatalf("interrupt 失败: %s", resp.Error.Message)
+	}
+	raw := string(resp.Result)
+	if !strings.Contains(raw, `"interrupted":true`) {
+		t.Fatalf("★ interrupt 没有真正中断（应答 %s）—— 用户以为停了，任务还在跑", raw)
+	}
+	t.Logf("interrupt 应答: %s", raw)
+
+	// 中断后会话必须仍可用：能继续投递并拿到回复
+	if resp := callSidecar(t, w, r, 4, "prompt", map[string]interface{}{
+		"text": "只回答两个字：收到",
+	}); resp.Error != nil {
+		t.Fatalf("中断后会话不可用：%s", resp.Error.Message)
+	}
+	// 等完成通知（id=0 的行会被 callSidecar 跳过，这里靠 state 确认有进展）
+	time.Sleep(3 * time.Second)
+	st := callSidecar(t, w, r, 5, "state", nil)
+	if st.Error != nil {
+		t.Fatalf("state 失败: %s", st.Error.Message)
+	}
+	t.Logf("中断后 state: %s", string(st.Result))
+}
+
+// ★★★ 对照组：不中断时，同一个任务在同样时间窗内**远未完成**。
+//
+// 没有这一条，"中断生效"就无法与"任务碰巧自己跑完了"区分开。
+func TestRealPiSameTaskWithoutInterruptStillRunning(t *testing.T) {
+	nodeBin, sidecarPath := piE2EReady(t)
+	workdir := t.TempDir()
+	_, w, r := startSidecarForE2E(t, nodeBin, sidecarPath, workdir, "e2e-control")
+
+	if resp := callSidecar(t, w, r, 1, "ping", nil); resp.Error != nil {
+		t.Fatalf("ping 失败: %s", resp.Error.Message)
+	}
+	if resp := callSidecar(t, w, r, 2, "prompt", map[string]interface{}{"text": interruptE2ETask}); resp.Error != nil {
+		t.Fatalf("prompt 失败: %s", resp.Error.Message)
+	}
+
+	// 与中断组同样的等待窗口（12s + 中断后观察 ~3s）
+	time.Sleep(15 * time.Second)
+
+	// 用 state 看不到"是否在跑"，但 can 用一个事实：此时若发 interrupt，
+	// 应当 interrupted=true —— 说明 15 秒时任务仍在运行。
+	resp := callSidecar(t, w, r, 3, "interrupt", nil)
+	if resp.Error != nil {
+		t.Fatalf("interrupt 失败: %s", resp.Error.Message)
+	}
+	raw := string(resp.Result)
+	if !strings.Contains(raw, `"interrupted":true`) {
+		t.Fatalf("★ 对照组在 %ds 时任务已不在了（%s）—— "+
+			"这说明中断组的 '已中断' 可能只是任务本来就跑完了，判据不成立", 15, raw)
+	}
+	t.Logf("对照组 15s 时仍在运行，interrupt 成功: %s", raw)
+}

example/commondev/interrupt_test.go

@@ -45,6 +45,33 @@ func TestPiSidecarImplementsInterrupt(t *testing.T) {
 		if !strings.Contains(src, "await session.abort()") {
 			t.Fatalf("★ %s 的 abort() 没有 await —— 会谎报已中断", path)
 		}
+		// ★ 判定"是否真的中断"必须用 pi 的 isIdle，不能用包装层的 inflight。
+		//
+		// 我第一版写 `interrupted: hadInflight`（中断前 >0 就算成功），
+		// 于是"删掉 abort()"这个变异**完全测不出来**：任务还在跑，
+		// hadInflight 仍为 true，照样回报"已中断" —— 那正是最坏的情形。
+		//
+		// 第二版改用 inflight 的变化，又**反向**错了：inflight 只在后台
+		// promise 的 finally 里递减，abort() 返回时还没减 ⇒ 实测
+		// before=1/inflight=1 误报"未中断"，而任务其实已经停了。
+		//
+		// isIdle 是 pi 的权威视图，正确。
+		if !strings.Contains(src, "session.isIdle") {
+			t.Fatalf("★ %s 判定中断成功没有用 session.isIdle —— "+
+				"用 inflight 之类的包装计数会误报（两个方向都试过了）", path)
+		}
+		// ★ 只查**代码行**，不查注释：这个反例本身就该写在注释里当说明，
+		// 直接全文 Contains 会把解释性注释当成缺陷（实测误报过一次）。
+		for _, ln := range strings.Split(src, "\n") {
+			code := strings.TrimSpace(ln)
+			if strings.HasPrefix(code, "//") || strings.HasPrefix(code, "*") {
+				continue
+			}
+			if strings.Contains(code, "interrupted: hadInflight") {
+				t.Fatalf("★ %s 又回到了 `interrupted: hadInflight` —— "+
+					"只看中断前 >0 会让「删掉 abort」的变异测不出", path)
+			}
+		}
 	}
 }
 

example/commondev/interrupt_zcode_e2e_test.go

@@ -0,0 +1,136 @@
+package main
+
+// 真机 e2e：zcode 的取消路径（HA_ZCODE_E2E=1 时运行）。
+//
+// ## 为什么单独测
+//
+// pi 与 zcode 的取消是**两种完全不同的机制**：
+//
+//	pi    → session.abort()，协作式中断，agent 自己走到下一个可中断点
+//	zcode → 整组杀掉当前回合的子进程（zcode 没有 abort API）
+//
+// 所以 pi 的判据证明不了 zcode 能用。这里用**假 CLI**（一个会持续输出的
+// node 脚本）验证杀进程这条路径 —— 不需要真 zcode CLI 就能测：
+// 判据要证的是"interrupt 真的把子进程杀了、且不误杀后续回合"，
+// 这与 CLI 是不是真的 zcode 无关。
+
+import (
+	"bufio"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// ★★★ 判据：zcode 的 interrupt 真的杀掉子进程，且句柄正确清空。
+func TestRealZcodeInterruptKillsChildAndClearsHandle(t *testing.T) {
+	if os.Getenv("HA_ZCODE_E2E") != "1" {
+		t.Skip("设 HA_ZCODE_E2E=1 以运行（用假 CLI，不需要真 zcode）")
+	}
+	root, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	nodeBin := filepath.Join(root, "rawfile", "node", "bin", "node")
+	if _, err := os.Stat(nodeBin); err != nil {
+		t.Skipf("内嵌 node 不存在: %v", err)
+	}
+	sidecarPath := filepath.Join(root, "rawfile", "runtime", "zcode", "sidecar.mjs")
+	if _, err := os.Stat(sidecarPath); err != nil {
+		t.Fatalf("zcode sidecar 不存在: %v", err)
+	}
+
+	dir := t.TempDir()
+	workdir := filepath.Join(dir, "work")
+	if err := os.MkdirAll(workdir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	// 假 CLI：node 脚本，持续输出 120 秒（足够被中断）
+	fake := filepath.Join(dir, "fakezcode.js")
+	script := `console.log(JSON.stringify({type:"start"}));
+let i = 0;
+const t = setInterval(() => {
+  i++;
+  console.log("tick-" + i);
+  if (i >= 120) {
+    clearInterval(t);
+    console.log(JSON.stringify({type:"result", sessionId:"sess_fake", response:"done"}));
+  }
+}, 1000);
+`
+	if err := os.WriteFile(fake, []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	_, w, r := startSidecarWithExtraEnv(t, nodeBin, sidecarPath, workdir, "e2e-zcode-int", "ZCODE_CLI="+fake)
+
+	if resp := callSidecar(t, w, r, 1, "ping", nil); resp.Error != nil {
+		t.Fatalf("ping 失败: %s", resp.Error.Message)
+	}
+	if resp := callSidecar(t, w, r, 2, "prompt", map[string]interface{}{"text": "跑吧"}); resp.Error != nil {
+		t.Fatalf("prompt 失败: %s", resp.Error.Message)
+	}
+	// 让它真的跑起来
+	time.Sleep(6 * time.Second)
+
+	// 第一次 interrupt：必须真的杀
+	resp := callSidecar(t, w, r, 3, "interrupt", nil)
+	if resp.Error != nil {
+		t.Fatalf("interrupt 失败: %s", resp.Error.Message)
+	}
+	raw := string(resp.Result)
+	if !strings.Contains(raw, `"interrupted":true`) {
+		t.Fatalf("★ zcode interrupt 没有真的中断（%s）—— 用户以为停了，任务还在跑", raw)
+	}
+	if !strings.Contains(raw, "killed_pid") {
+		t.Fatalf("★ interrupt 应答没有 killed_pid（%s）—— 无法确认真的杀了进程", raw)
+	}
+	t.Logf("第一次 interrupt: %s", raw)
+
+	// 第二次 interrupt：句柄必须已清空，不能误杀后续回合
+	time.Sleep(3 * time.Second)
+	resp2 := callSidecar(t, w, r, 4, "interrupt", nil)
+	raw2 := string(resp2.Result)
+	if !strings.Contains(raw2, `"interrupted":false`) {
+		t.Fatalf("★ 第二次 interrupt 仍报 interrupted=true（%s）—— "+
+			"说明 currentChild 没清空，会误杀下一轮", raw2)
+	}
+	if !strings.Contains(raw2, "no_running_turn") {
+		t.Fatalf("★ 第二次 interrupt 的 reason 不是 no_running_turn（%s）", raw2)
+	}
+	t.Logf("第二次 interrupt（应无回合）: %s", raw2)
+}
+
+// startSidecarWithExtraEnv 在既有 helper 的基础上追加一条环境变量。
+//
+// 为什么需要额外 env：zcode 的 CLI 路径由 ZCODE_CLI 指定（driver.json 里
+// 没有 cliPath 时）。判据用假 CLI，所以必须能注入这条变量。
+func startSidecarWithExtraEnv(t *testing.T, nodeBin, sidecarPath, workdir, sessionID, extraEnv string) (*exec.Cmd, *bufio.Writer, *bufio.Reader) {
+	t.Helper()
+	cmd := exec.Command(nodeBin, sidecarPath, "--workdir", workdir, "--session-id", sessionID)
+	cmd.Dir = workdir
+	cmd.Env = append(os.Environ(),
+		"PI_CODING_AGENT_SESSION_DIR="+filepath.Join(workdir, ".pi-sessions"),
+		extraEnv,
+	)
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	cmd.Stderr = nil
+	if err := cmd.Start(); err != nil {
+		t.Fatalf("启动 sidecar 失败: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = cmd.Process.Kill()
+		_, _ = cmd.Process.Wait()
+	})
+	return cmd, bufio.NewWriter(stdin), bufio.NewReader(stdout)
+}

example/commondev/sidecar.mjs

@@ -188,16 +188,32 @@ async function handle(method, params) {
     //     若当时没有在跑的任务，interrupted=false 但 ok=true（不算错误）。
     case "interrupt": {
       if (!session) return { ok: true, interrupted: false, reason: "no_session" };
-      const hadInflight = inflight > 0;
+      // ★ 判定"是否真的中断了"必须靠**中断前后 inflight 的变化**，不能只看
+      // 中断前 >0。第一版写成 `interrupted: hadInflight`，判据也照这个断言，
+      // 于是"把 abort() 删掉"这个变异**完全测不出来**：
+      // 任务还在跑 → inflight 仍 >0 → 照样回报 interrupted=true。
+      // 那正是最坏的情形：用户以为停了，任务还在改代码、推分支。
+      // ★ 判定依据必须用 pi 自己的状态（isIdle），不能用本文件的 inflight：
+      //
+      //   inflight 是**包装层**的计数，只在后台 promise 的 finally 里递减，
+      //   而 abort() 返回时那个 promise 还没收尾 ⇒ abort 成功也没减。
+      //   实测（第一版）：before=1, inflight=1 ⇒ 误报 interrupted=false，
+      //   而任务其实已经停了 —— 反向的谎报，同样有害（用户重复发任务）。
+      //
+      //   session.isIdle 是 pi 的权威视图："当前没有在跑的任务"。
+      const wasIdle = session.isIdle;
       try {
         await session.abort();
       } catch (e) {
         return { ok: false, interrupted: false, error: String((e && e.message) || e) };
       }
+      // abort() 语义是"中止并等待 agent 回到空闲"⇒ 返回时应已 idle。
+      // 仍非 idle 说明中止没生效（或还在收尾），如实回报，不夸大成已中断。
       return {
         ok: true,
-        interrupted: hadInflight,
+        interrupted: !wasIdle && session.isIdle,
-        // 如实报告剩余在途数：>0 说明还有任务在收尾（调用方可据此决定是否再等）
+        was_idle: wasIdle,
+        now_idle: session.isIdle,
         inflight,
       };
     }