@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/core/test/synapse.test.ts

@@ -0,0 +1,67 @@
+import { Context } from "@deepseek-ai/cordis";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import synapsePlugin, { buildSynapseGraph } from "../src/plugins/synapse.js";
+import { provideLaunchContext, PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+
+const contexts: Context[] = [];
+
+afterEach(async () => {
+  vi.restoreAllMocks();
+  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
+});
+
+describe("synapse", () => {
+  test("builds fork graph with orphan accounting", () => {
+    const sessions = [
+      { id: "root", path: "/root.jsonl", cwd: "/workspace", firstMessage: "Root", messageCount: 2, modified: new Date("2026-01-01") },
+      {
+        id: "child",
+        path: "/child.jsonl",
+        cwd: "/workspace",
+        firstMessage: "Child",
+        messageCount: 3,
+        modified: new Date("2026-01-02"),
+        parentSessionPath: "/root.jsonl",
+      },
+      {
+        id: "orphan",
+        path: "/orphan.jsonl",
+        cwd: "/workspace",
+        firstMessage: "Orphan",
+        messageCount: 1,
+        modified: new Date("2026-01-03"),
+        parentSessionPath: "/missing.jsonl",
+      },
+    ];
+    const graph = buildSynapseGraph(sessions as never, "/child.jsonl");
+    expect(graph).toMatchObject({
+      activeSessionId: "child",
+      orphanCount: 1,
+      edges: [{ from: "root", to: "child", kind: "fork" }],
+    });
+    expect(graph.nodes.find((node) => node.id === "root")).toMatchObject({ branchCount: 1 });
+    expect(graph.nodes.find((node) => node.id === "child")).toMatchObject({ parentSessionId: "root", active: true });
+  });
+
+  test("refreshes native sessions and exposes strict sequential metadata", async () => {
+    vi.spyOn(SessionManager, "list").mockResolvedValue([
+      { id: "root", path: "/root.jsonl", cwd: "/workspace", firstMessage: "Root", messageCount: 1, modified: new Date("2026-01-01") } as never,
+    ]);
+    const context = new Context();
+    const tools = new PiToolRegistry();
+    const panels = new PiPluginUiRegistry();
+    provideLaunchContext(context, { cwd: "/workspace", agentDir: "/agent", args: [], requestExit() {} });
+    context.provide("piSession", { manager: { getSessionDir: () => "/agent/sessions", getSessionFile: () => "/root.jsonl" } } as never);
+    context.provide("piTools", tools);
+    context.provide("piPluginUi", panels);
+    await context.plugin(synapsePlugin, { maxSessions: 10 });
+    contexts.push(context);
+    const tool = tools.snapshot().customTools.find((item) => item.name === "synapse_session_map");
+    if (tool === undefined) throw new Error("synapse_session_map was not registered");
+    expect(tool.executionMode).toBe("sequential");
+    expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
+    await expect(tool.execute("map", {}, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { nodes: [{ id: "root" }] } });
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { nodes: [{ id: "root" }], refreshes: 2 } }]);
+  });
+});

package/packages/core/test/tab-manager.test.ts

@@ -0,0 +1,58 @@
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
+import { afterEach, describe, expect, test } from "vitest";
+import tabManagerPlugin from "../src/plugins/tab-manager.js";
+import { provideLaunchContext, PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+
+const contexts: Context[] = [];
+
+async function fixture() {
+  const root = await mkdtemp(join(tmpdir(), "pi-harness-tabs-"));
+  const context = new Context();
+  const tools = new PiToolRegistry();
+  const panels = new PiPluginUiRegistry();
+  provideLaunchContext(context, { cwd: root, agentDir: root, args: [], requestExit() {} });
+  context.provide("piSession", { manager: { getSessionId: () => "session-1", getSessionFile: () => join(root, "session-1.jsonl") } } as never);
+  context.provide("piTools", tools);
+  context.provide("piPluginUi", panels);
+  await context.plugin(tabManagerPlugin);
+  contexts.push(context);
+  const tool = tools.snapshot().customTools.find((item) => item.name === "session_tab_manage");
+  if (tool === undefined) throw new Error("session_tab_manage was not registered");
+  return { root, context, tools, panels, tool };
+}
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
+});
+
+describe("tab manager", () => {
+  test("pins, renames, lists, and removes a session tab", async () => {
+    const { tool, panels } = await fixture();
+    expect(tool.executionMode).toBe("sequential");
+    expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
+    await expect(tool.execute("pin", { action: "pin", label: "Current" }, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { id: "session-1", label: "Current", pinned: true },
+    });
+    await expect(tool.execute("rename", { action: "rename", label: "Renamed" }, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { activeId: "session-1", tabs: [{ label: "Renamed", pinned: true }] },
+    });
+    await expect(tool.execute("list", { action: "list" }, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { tabs: [{ label: "Renamed" }] },
+    });
+    await expect(tool.execute("remove", { action: "remove" }, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { tabs: [], activeId: null },
+    });
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { tabs: [], activeId: null } }]);
+  });
+
+  test("rejects invalid labels and disposes its registry entries", async () => {
+    const { context, tool, tools, panels } = await fixture();
+    await expect(tool.execute("rename", { action: "rename", label: "" }, undefined, undefined, {} as never)).rejects.toThrow(/label/iu);
+    await context.fiber.dispose();
+    expect(tools.snapshot().customTools).toHaveLength(0);
+    await expect(panels.snapshot()).resolves.toHaveLength(0);
+  });
+});

package/packages/core/test/taskboard.test.ts

@@ -0,0 +1,73 @@
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
+import { afterEach, describe, expect, test } from "vitest";
+import taskboardPlugin from "../src/plugins/taskboard.js";
+import { provideLaunchContext, PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+
+const contexts: Context[] = [];
+
+async function fixture() {
+  const root = await mkdtemp(join(tmpdir(), "pi-harness-taskboard-"));
+  const context = new Context();
+  const tools = new PiToolRegistry();
+  const panels = new PiPluginUiRegistry();
+  provideLaunchContext(context, { cwd: root, agentDir: root, args: [], requestExit() {} });
+  context.provide("piTools", tools);
+  context.provide("piPluginUi", panels);
+  await context.plugin(taskboardPlugin, { fileName: "tasks.sqlite", keyPrefix: "TST" });
+  contexts.push(context);
+  const find = (name: string) => {
+    const tool = tools.snapshot().customTools.find((item) => item.name === name);
+    if (tool === undefined) throw new Error(`${name} was not registered`);
+    return tool;
+  };
+  return {
+    context,
+    tools,
+    panels,
+    create: find("taskboard_create"),
+    list: find("taskboard_list"),
+    update: find("taskboard_update"),
+    accept: find("taskboard_accept"),
+  };
+}
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
+});
+
+describe("taskboard", () => {
+  test("creates, updates, lists, and accepts a review task", async () => {
+    const { create, list, update, accept, panels } = await fixture();
+    for (const tool of [create, list, update, accept]) {
+      expect(tool.executionMode).toBe("sequential");
+      expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
+    }
+    const created = await create.execute(
+      "create",
+      { title: "Ship feature", description: "Review and release", priority: "high" },
+      undefined,
+      undefined,
+      {} as never,
+    );
+    expect(created.details).toMatchObject({ key: "TST-1", status: "backlog", priority: "high" });
+    await expect(update.execute("update", { key: "TST-1", status: "in_review" }, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { key: "TST-1", status: "in_review" },
+    });
+    await expect(accept.execute("accept", { key: "TST-1", confirm: false }, undefined, undefined, {} as never)).rejects.toThrow(/confirm=true/iu);
+    await expect(accept.execute("accept", { key: "TST-1", confirm: true }, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { key: "TST-1", status: "done" },
+    });
+    await expect(list.execute("list", { status: "done" }, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { total: 1 } });
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { total: 1, counts: { done: 1 } } }]);
+  });
+
+  test("cleans up all registrations on disposal", async () => {
+    const { context, tools, panels } = await fixture();
+    await context.fiber.dispose();
+    expect(tools.snapshot().customTools).toHaveLength(0);
+    await expect(panels.snapshot()).resolves.toHaveLength(0);
+  });
+});

package/packages/core/test/telemetry-blocker.test.ts

@@ -0,0 +1,61 @@
+import { Context } from "@deepseek-ai/cordis";
+import { afterEach, describe, expect, test } from "vitest";
+import telemetryBlockerPlugin from "../src/plugins/telemetry-blocker.js";
+import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+
+const contexts: Context[] = [];
+
+async function fixture() {
+  const context = new Context();
+  const tools = new PiToolRegistry();
+  const panels = new PiPluginUiRegistry();
+  context.provide("piTools", tools);
+  context.provide("piPluginUi", panels);
+  await context.plugin(telemetryBlockerPlugin);
+  contexts.push(context);
+  const tool = tools.snapshot().customTools.find((item) => item.name === "telemetry_status");
+  if (tool === undefined) throw new Error("telemetry_status was not registered");
+  return { context, tools, panels, tool };
+}
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
+});
+
+describe("telemetry blocker", () => {
+  test("blocks telemetry and reports only bounded event names", async () => {
+    const { context, tool, panels } = await fixture();
+    expect(tool.executionMode).toBe("sequential");
+    expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
+    context.emit("pi/telemetry", { name: "usage", properties: { secret: "should-not-retain" } });
+    const long = "x".repeat(200);
+    context.emit("pi/telemetry", { name: long });
+    await expect(tool.execute("status", {}, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { blocked: 2, names: ["usage", long.slice(0, 80)] },
+    });
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { enabled: false, blocked: 2, names: ["usage", long.slice(0, 80)] } }]);
+  });
+
+  test("rejects empty event names and cleans up registrations", async () => {
+    const { context, tools, panels } = await fixture();
+    expect(() => context.emit("pi/telemetry", { name: "   " })).toThrow(/must not be empty/iu);
+    await context.fiber.dispose();
+    expect(tools.snapshot().customTools).toHaveLength(0);
+    await expect(panels.snapshot()).resolves.toHaveLength(0);
+  });
+
+  test("rejects unknown plugin configuration before activation", async () => {
+    const context = new Context();
+    context.provide("piTools", new PiToolRegistry());
+    context.provide("piPluginUi", new PiPluginUiRegistry());
+    let error: unknown;
+    try {
+      await context.plugin(telemetryBlockerPlugin, { unexpected: true });
+    } catch (caught) {
+      error = caught;
+    }
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toMatch(/config keys: unexpected/iu);
+    await context.fiber.dispose();
+  });
+});

package/packages/core/test/test-harness.test.ts

@@ -0,0 +1,297 @@
+import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
+import { afterEach, describe, expect, test } from "vitest";
+import testHarnessPlugin from "../src/plugins/test-harness.js";
+import { PiPluginUiRegistry, PiToolRegistry, provideLaunchContext } from "../src/services.js";
+
+const contexts: Context[] = [];
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map(async (context) => context.fiber.dispose()));
+  await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
+});
+
+async function fixture(): Promise<{ context: Context; panels: PiPluginUiRegistry; root: string; tools: PiToolRegistry }> {
+  const root = await mkdtemp(join(tmpdir(), "pi-harness-test-harness-"));
+  temporaryDirectories.push(root);
+  await writeFile(join(root, "package.json"), JSON.stringify({ private: true, scripts: { test: "node -e \"process.stdout.write('ok')\"" } }), "utf8");
+  const context = new Context();
+  contexts.push(context);
+  const tools = new PiToolRegistry();
+  const panels = new PiPluginUiRegistry();
+  provideLaunchContext(context, { cwd: root, agentDir: root, args: [], requestExit() {} });
+  context.provide("piTools", tools);
+  context.provide("piPluginUi", panels);
+  return { context, panels, root, tools };
+}
+
+function registeredTool(tools: PiToolRegistry) {
+  const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "run_project_tests");
+  if (tool === undefined) throw new Error("run_project_tests was not registered");
+  return tool;
+}
+
+interface RunDetails {
+  script: string;
+  command: string;
+  status: string;
+  exitCode: number | null;
+  signal: string | null;
+  durationMs: number;
+  output: string;
+  outputBytes: number;
+  outputTruncated: boolean;
+}
+
+async function waitForFile(path: string, description: string, timeoutMs = 5_000): Promise<void> {
+  const started = Date.now();
+  for (;;) {
+    try {
+      await access(path);
+      return;
+    } catch {
+      if (Date.now() - started >= timeoutMs) throw new Error(`Timed out waiting for ${description}`);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  }
+}
+
+function stopFixtureProcess(pid: number | undefined): void {
+  if (pid === undefined || !Number.isSafeInteger(pid) || pid <= 0) return;
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ESRCH") throw error;
+  }
+}
+
+describe("test-harness", () => {
+  test("declares a strict sequential tool contract", async () => {
+    const { context, tools } = await fixture();
+    await context.plugin(testHarnessPlugin);
+    const tool = registeredTool(tools);
+
+    expect(testHarnessPlugin).toHaveProperty("Config");
+    expect(tool.executionMode).toBe("sequential");
+    const parameters = tool.parameters as { type: unknown; additionalProperties: unknown; properties: { script: { anyOf: readonly { const?: unknown }[] } } };
+    expect(parameters.type).toBe("object");
+    expect(parameters.additionalProperties).toBe(false);
+    expect(Array.isArray(parameters.properties.script.anyOf)).toBe(true);
+    expect(parameters.properties.script.anyOf.map((item) => item.const)).toEqual(["test", "build", "format:check", "lint", "typecheck"]);
+  });
+
+  test("rejects malformed raw parameters without invoking accessors", async () => {
+    const { context, tools } = await fixture();
+    await context.plugin(testHarnessPlugin);
+    const tool = registeredTool(tools);
+    let getterCalls = 0;
+    const accessor = Object.defineProperty({}, "script", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return "not-allowed";
+      },
+    });
+    const revocable = Proxy.revocable({}, {});
+    revocable.revoke();
+    const withSymbol = { script: "test", [Symbol("extra")]: true };
+
+    for (const parameters of [
+      null,
+      [],
+      new Date(),
+      { script: 1 },
+      { script: " test" },
+      { script: "test " },
+      { script: "test", extra: true },
+      withSymbol,
+      accessor,
+    ]) {
+      await expect(tool.execute("invalid", parameters as never, undefined, undefined, {} as never)).rejects.toThrow(/test harness parameters/iu);
+    }
+    await expect(tool.execute("proxy", revocable.proxy, undefined, undefined, {} as never)).rejects.toThrow(/accessible plain object/iu);
+    expect(getterCalls).toBe(0);
+  });
+
+  test("rejects unknown or invalid configuration before registering surfaces", async () => {
+    for (const config of [{ unexpected: true }, { timeoutMs: 99 }, { timeoutMs: 1_000.5 }, { timeoutMs: 600_001 }]) {
+      const { context, panels, tools } = await fixture();
+
+      await expect(context.plugin(testHarnessPlugin, config as never)).rejects.toThrow(/test-harness|timeoutMs|unknown/iu);
+      expect(tools.snapshot().customTools).toEqual([]);
+      await expect(panels.snapshot()).resolves.toEqual([]);
+    }
+  });
+
+  test("rolls back the tool when panel registration fails", async () => {
+    const { context, panels, tools } = await fixture();
+    panels.register({ id: "test-harness-panel", pluginId: "fixture", title: "Fixture", read: () => ({}) });
+
+    await expect(context.plugin(testHarnessPlugin)).rejects.toThrow(/panel is already registered: test-harness-panel/iu);
+    expect(tools.snapshot().customTools).toEqual([]);
+    await expect(panels.snapshot()).resolves.toMatchObject([{ id: "test-harness-panel", pluginId: "fixture" }]);
+  });
+
+  test("reports real successful and failed npm script outcomes through detached snapshots", async () => {
+    const { context, panels, root, tools } = await fixture();
+    await writeFile(join(root, "pass.mjs"), 'process.stdout.write("passed\\n"); process.stderr.write("warning\\n");\n', "utf8");
+    await writeFile(join(root, "fail.mjs"), 'process.stdout.write("before failure\\n"); process.stderr.write("failed\\n"); process.exitCode = 7;\n', "utf8");
+    await writeFile(join(root, "package.json"), JSON.stringify({ private: true, scripts: { test: "node pass.mjs", build: "node fail.mjs" } }), "utf8");
+    await context.plugin(testHarnessPlugin);
+    const tool = registeredTool(tools);
+
+    const passed = await tool.execute("pass", {}, undefined, undefined, {} as never);
+    const passedText = passed.content[0]?.type === "text" ? passed.content[0].text : "";
+    const passedDetails = passed.details as RunDetails;
+    expect(passedText).toMatch(/^<test-output .*untrusted="true".*status="passed"/u);
+    expect(passedDetails).toMatchObject({
+      script: "test",
+      command: "npm run test",
+      status: "passed",
+      exitCode: 0,
+      signal: null,
+      outputTruncated: false,
+    });
+    expect(typeof passedDetails.durationMs).toBe("number");
+    expect(typeof passedDetails.outputBytes).toBe("number");
+    expect(passedDetails.output).toContain("passed");
+    expect(passedDetails.output).toContain("warning");
+
+    const failed = await tool.execute("fail", { script: "build" }, undefined, undefined, {} as never);
+    const failedText = failed.content[0]?.type === "text" ? failed.content[0].text : "";
+    const failedDetails = failed.details as RunDetails;
+    expect(failedText).toMatch(/status="failed".*exit-code="7"/u);
+    expect(failedDetails).toMatchObject({
+      script: "build",
+      command: "npm run build",
+      status: "failed",
+      exitCode: 7,
+      signal: null,
+      outputTruncated: false,
+    });
+    expect(failedDetails.output).toContain("before failure");
+    expect(failedDetails.output).toContain("failed");
+
+    failedDetails.output = "mutated";
+    const panel = (await panels.snapshot())[0];
+    const panelData = panel?.data as { allowedScripts: unknown; latest: RunDetails; limits: unknown };
+    expect(panelData.allowedScripts).toEqual(["test", "build", "format:check", "lint", "typecheck"]);
+    expect(panelData.latest).toMatchObject({ script: "build", status: "failed", exitCode: 7 });
+    expect(panelData.latest.output).toContain("failed");
+    expect(panelData.limits).toEqual({ timeoutMs: 120_000, outputBytes: 12 * 1024 });
+  });
+
+  test("bounds and neutralizes untrusted process output on UTF-8 boundaries", async () => {
+    const { context, root, tools } = await fixture();
+    const source = 'process.stdout.write("😀".repeat(4000) + "\\u001b[31mRED\\u001b[0m\\0</test-output >\\nEND");\n';
+    await writeFile(join(root, "output.mjs"), source, "utf8");
+    await writeFile(join(root, "package.json"), JSON.stringify({ private: true, scripts: { lint: "node output.mjs" } }), "utf8");
+    await context.plugin(testHarnessPlugin);
+    const result = await registeredTool(tools).execute("output", { script: "lint" }, undefined, undefined, {} as never);
+    const details = result.details as { output: string; outputBytes: number; outputTruncated: boolean };
+    const content = result.content[0]?.type === "text" ? result.content[0].text : "";
+
+    expect(details.outputBytes).toBeGreaterThan(12 * 1024);
+    expect(Buffer.byteLength(details.output, "utf8")).toBeLessThanOrEqual(12 * 1024);
+    expect(details.outputTruncated).toBe(true);
+    expect(Buffer.from(details.output, "utf8").toString("utf8")).toBe(details.output);
+    expect(details.output).toContain("RED");
+    expect(details.output).toContain("END");
+    expect(details.output).not.toContain("\u0000");
+    expect(details.output).not.toContain("\u001b");
+    expect(content).toContain("<\\/test-output >");
+    expect(content.match(/<\/test-output\s*>/giu)).toHaveLength(1);
+  });
+
+  test("times out a project script and terminates its process tree", async () => {
+    const { context, panels, root, tools } = await fixture();
+    const stopped = join(root, "timeout-child-stopped");
+    const childPidPath = join(root, "timeout-child.pid");
+    await writeFile(
+      join(root, "timeout-child.mjs"),
+      `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(childPidPath)}, String(process.pid)); process.on("SIGTERM", () => { writeFileSync(${JSON.stringify(stopped)}, "stopped"); process.exit(0); }); setInterval(() => {}, 1000);\n`,
+      "utf8",
+    );
+    await writeFile(
+      join(root, "timeout-parent.mjs"),
+      'import { spawn } from "node:child_process"; spawn(process.execPath, ["timeout-child.mjs"], { stdio: "ignore" }); setInterval(() => {}, 1000);\n',
+      "utf8",
+    );
+    await writeFile(join(root, "package.json"), JSON.stringify({ private: true, scripts: { test: "node timeout-parent.mjs" } }), "utf8");
+    await context.plugin(testHarnessPlugin, { timeoutMs: 2_000 });
+    let childPid: number | undefined;
+    try {
+      const execution = registeredTool(tools).execute("timeout", {}, undefined, undefined, {} as never);
+      await waitForFile(childPidPath, "timed-out npm descendant to start");
+      const result = await execution;
+      childPid = Number(await readFile(childPidPath, "utf8"));
+
+      expect(result.details).toMatchObject({ status: "timed-out", exitCode: null, outputTruncated: false });
+      await waitForFile(stopped, "timed-out npm process tree to stop");
+      await expect(panels.snapshot()).resolves.toMatchObject([{ data: { latest: { status: "timed-out" } } }]);
+    } finally {
+      if (childPid === undefined) childPid = Number(await readFile(childPidPath, "utf8").catch(() => ""));
+      stopFixtureProcess(childPid);
+    }
+  });
+
+  test("caller cancellation terminates active npm descendants and records a cancelled run", async () => {
+    const { context, panels, root, tools } = await fixture();
+    const childReady = join(root, "child-ready");
+    const childStopped = join(root, "child-stopped");
+    const parentStopped = join(root, "parent-stopped");
+    const childPidPath = join(root, "child.pid");
+    await writeFile(
+      join(root, "child.mjs"),
+      `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(childPidPath)}, String(process.pid)); writeFileSync(${JSON.stringify(childReady)}, "ready"); process.on("SIGTERM", () => { writeFileSync(${JSON.stringify(childStopped)}, "stopped"); process.exit(0); }); setInterval(() => {}, 1000);\n`,
+      "utf8",
+    );
+    await writeFile(
+      join(root, "parent.mjs"),
+      `import { spawn } from "node:child_process"; import { writeFileSync } from "node:fs"; spawn(process.execPath, ["child.mjs"], { stdio: "ignore" }); process.on("SIGTERM", () => { writeFileSync(${JSON.stringify(parentStopped)}, "stopped"); process.exit(0); }); setTimeout(() => process.exit(0), 500);\n`,
+      "utf8",
+    );
+    await writeFile(join(root, "package.json"), JSON.stringify({ private: true, scripts: { test: "node parent.mjs" } }), "utf8");
+    await context.plugin(testHarnessPlugin);
+    const controller = new AbortController();
+    const execution = registeredTool(tools).execute("cancel", {}, controller.signal, undefined, {} as never);
+    let childPid: number | undefined;
+    try {
+      await waitForFile(childReady, "npm descendant to start");
+      childPid = Number(await readFile(childPidPath, "utf8"));
+      controller.abort(new Error("cancelled by caller"));
+
+      await expect(execution).rejects.toThrow(/project verification was cancelled/iu);
+      await waitForFile(parentStopped, "npm script parent to stop");
+      await waitForFile(childStopped, "npm script descendant to stop");
+      await expect(panels.snapshot()).resolves.toMatchObject([{ data: { latest: { status: "cancelled", exitCode: null } } }]);
+    } finally {
+      stopFixtureProcess(childPid);
+    }
+  });
+
+  test("plugin disposal cancels an active verification and removes both surfaces", async () => {
+    const { context, panels, root, tools } = await fixture();
+    const ready = join(root, "dispose-ready");
+    const stopped = join(root, "dispose-stopped");
+    await writeFile(
+      join(root, "dispose.mjs"),
+      `import { writeFileSync } from "node:fs"; writeFileSync(${JSON.stringify(ready)}, "ready"); process.on("SIGTERM", () => { writeFileSync(${JSON.stringify(stopped)}, "stopped"); process.exit(0); }); setInterval(() => {}, 1000);\n`,
+      "utf8",
+    );
+    await writeFile(join(root, "package.json"), JSON.stringify({ private: true, scripts: { test: "node dispose.mjs" } }), "utf8");
+    await context.plugin(testHarnessPlugin);
+    const execution = registeredTool(tools).execute("dispose", {}, undefined, undefined, {} as never);
+    await waitForFile(ready, "verification script to start before disposal");
+
+    await context.fiber.dispose();
+
+    await expect(execution).rejects.toThrow(/project verification was cancelled/iu);
+    await waitForFile(stopped, "verification script to stop on disposal");
+    expect(tools.snapshot().customTools).toEqual([]);
+    await expect(panels.snapshot()).resolves.toEqual([]);
+  });
+});