@blackbelt-technology/pi-agent-dashboard 0.3.0 → 0.4.0

package/packages/extension/src/__tests__/enrich-model-metadata.test.ts

@@ -0,0 +1,201 @@
+/**
+ * Tests for enrichModelMetadata — the pure helper that resolves a discovered
+ * custom-provider model id against a catalog probe (typically backed by pi's
+ * `modelRegistry.find(provider, id)`) and falls back to api-appropriate
+ * defaults when the probe has no match.
+ *
+ * The helper takes an optional `probe` parameter so unit tests can supply a
+ * fake catalog without needing `@mariozechner/pi-ai` installed — in
+ * production, registerEntry() injects `modelRegistry.find` as the probe.
+ *
+ * Spec: openspec/changes/enrich-custom-provider-model-metadata/specs/provider-auth-bridge/spec.md
+ */
+
+import { describe, it, expect } from "vitest";
+import { enrichModelMetadata, type CatalogProbe } from "../provider-register.js";
+
+// Minimal fake catalog mirroring a subset of pi-ai's real MODELS export.
+// Keys are `${provider}|${id}` so our probe is a single Map lookup.
+const FAKE_CATALOG = new Map<string, any>([
+  [
+    "anthropic|claude-opus-4-7",
+    {
+      contextWindow: 1_000_000,
+      maxTokens: 128_000,
+      reasoning: true,
+      cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+      input: ["text", "image"],
+    },
+  ],
+  [
+    "anthropic|claude-sonnet-4-6",
+    {
+      contextWindow: 1_000_000,
+      maxTokens: 64_000,
+      reasoning: true,
+      cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+      input: ["text", "image"],
+    },
+  ],
+  [
+    "anthropic|claude-haiku-4-5",
+    {
+      contextWindow: 200_000,
+      maxTokens: 64_000,
+      reasoning: true,
+      cost: { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+      input: ["text", "image"],
+    },
+  ],
+  [
+    "openai|gpt-5",
+    {
+      contextWindow: 400_000,
+      maxTokens: 128_000,
+      reasoning: true,
+      cost: { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 0 },
+      input: ["text", "image"],
+    },
+  ],
+  [
+    "opencode|claude-opus-4-7",
+    {
+      // Deliberately different values so tests can prove the candidate-
+      // provider probe order is deterministic (anthropic checked first).
+      contextWindow: 999,
+      maxTokens: 1,
+      reasoning: true,
+      cost: { input: 9, output: 9, cacheRead: 9, cacheWrite: 9 },
+      input: ["text"],
+    },
+  ],
+]);
+
+const fakeProbe: CatalogProbe = (provider, id) =>
+  FAKE_CATALOG.get(`${provider}|${id}`) ?? null;
+
+describe("enrichModelMetadata — catalog matches via probe", () => {
+  it("resolves `cc/claude-opus-4-7` + anthropic-messages to Opus 4.7 catalog entry (1M ctx)", () => {
+    const result = enrichModelMetadata("cc/claude-opus-4-7", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.maxTokens).toBe(128_000);
+    expect(result.reasoning).toBe(true);
+    expect(result.cost).toEqual({
+      input: 5,
+      output: 25,
+      cacheRead: 0.5,
+      cacheWrite: 6.25,
+    });
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("resolves bare `claude-sonnet-4-6` + anthropic-messages to Sonnet 4.6 (1M ctx)", () => {
+    const result = enrichModelMetadata("claude-sonnet-4-6", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.reasoning).toBe(true);
+  });
+
+  it("resolves `anthropic/claude-opus-4-7` prefix to Opus 4.7 (1M ctx)", () => {
+    const result = enrichModelMetadata("anthropic/claude-opus-4-7", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.maxTokens).toBe(128_000);
+  });
+
+  it("resolves `claude-haiku-4-5` + anthropic-messages to Haiku 4.5 (200k ctx — verifies we don't over-claim)", () => {
+    const result = enrichModelMetadata("claude-haiku-4-5", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(200_000);
+    expect(result.reasoning).toBe(true);
+    expect(result.cost.input).toBe(1);
+    expect(result.cost.output).toBe(5);
+  });
+
+  it("resolves `openrouter/openai/gpt-5` prefix to gpt-5 via openai-completions candidates", () => {
+    const result = enrichModelMetadata("openrouter/openai/gpt-5", "openai-completions", fakeProbe);
+    expect(result.contextWindow).toBe(400_000);
+    expect(result.maxTokens).toBe(128_000);
+    expect(result.reasoning).toBe(true);
+  });
+});
+
+describe("enrichModelMetadata — fallback defaults (no probe or no match)", () => {
+  it("no probe supplied → falls back to api-appropriate default", () => {
+    const result = enrichModelMetadata("cc/claude-opus-4-7", "anthropic-messages");
+    expect(result.contextWindow).toBe(200_000);
+    expect(result.maxTokens).toBe(64_000);
+  });
+
+  it("unknown id + anthropic-messages returns 200k / 64k / no reasoning / zero cost / text+image", () => {
+    const result = enrichModelMetadata("some-unknown-anthropic-model", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(200_000);
+    expect(result.maxTokens).toBe(64_000);
+    expect(result.reasoning).toBe(false);
+    expect(result.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("unknown id + openai-completions returns 128k / 16k / zero cost / text+image", () => {
+    const result = enrichModelMetadata("some-unknown-openai-model", "openai-completions", fakeProbe);
+    expect(result.contextWindow).toBe(128_000);
+    expect(result.maxTokens).toBe(16_384);
+    expect(result.reasoning).toBe(false);
+    expect(result.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("unknown id + google-generative-ai returns 1M / 65k / zero cost / text+image", () => {
+    const result = enrichModelMetadata("some-unknown-gemini-model", "google-generative-ai", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.maxTokens).toBe(65_536);
+    expect(result.reasoning).toBe(false);
+    expect(result.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("prefixed unknown + openai-completions falls back (both prefixed and bare miss)", () => {
+    const result = enrichModelMetadata("minimax/custom-private-model", "openai-completions", fakeProbe);
+    expect(result.contextWindow).toBe(128_000);
+    expect(result.maxTokens).toBe(16_384);
+    expect(result.cost.input).toBe(0);
+  });
+
+  it("no api argument + no probe defaults to openai-completions fallback", () => {
+    const result = enrichModelMetadata("some-unknown-model");
+    expect(result.contextWindow).toBe(128_000);
+    expect(result.maxTokens).toBe(16_384);
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("unknown api string + probe still probes openai-completions candidates", () => {
+    const result = enrichModelMetadata("some-unknown-model", "some-weird-api", fakeProbe);
+    expect(result.contextWindow).toBe(128_000);
+  });
+
+  it("probe that throws is tolerated (falls through to fallback)", () => {
+    const throwingProbe: CatalogProbe = () => {
+      throw new Error("registry not ready");
+    };
+    const result = enrichModelMetadata("claude-opus-4-7", "anthropic-messages", throwingProbe);
+    expect(result.contextWindow).toBe(200_000); // anthropic-messages fallback
+  });
+});
+
+describe("enrichModelMetadata — probe order determinism", () => {
+  it("prefers `anthropic` over `opencode` for anthropic-messages (first in candidate list wins)", () => {
+    // The fake catalog has `claude-opus-4-7` under BOTH `anthropic` (1M) and
+    // `opencode` (999). With api=anthropic-messages, candidates = ["anthropic", "opencode"]
+    // so the anthropic entry must win.
+    const result = enrichModelMetadata("claude-opus-4-7", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.maxTokens).toBe(128_000);
+  });
+
+  it("multi-segment prefix `openrouter/anthropic/claude-opus-4-7` resolves via bare-id lookup", () => {
+    // After stripping the last segment, `claude-opus-4-7` matches `anthropic` (1M).
+    const result = enrichModelMetadata(
+      "openrouter/anthropic/claude-opus-4-7",
+      "anthropic-messages",
+      fakeProbe,
+    );
+    expect(result.contextWindow).toBe(1_000_000);
+  });
+});

package/packages/extension/src/__tests__/git-info.test.ts

@@ -1,112 +1,124 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { gatherGitInfo, detectBranch, detectRemoteUrl, detectPrNumber } from "../git-info.js";
-
-const { execSyncMock } = vi.hoisted(() => ({
-  execSyncMock: vi.fn(),
+/**
+ * Tests for git-info.ts.
+ *
+ * The file now delegates to `@blackbelt-technology/pi-dashboard-shared/platform/git.js`
+ * (the Recipe-based tool module). We mock that module so the tests focus
+ * on the git-info orchestration logic (branch detection, detached HEAD
+ * fallback, PR detection) without spawning git.
+ *
+ * See change: platform-command-executor.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const { currentBranchOr, headShaOr, remoteUrlOr, prNumberOr } = vi.hoisted(() => ({
+  currentBranchOr: vi.fn(),
+  headShaOr: vi.fn(),
+  remoteUrlOr: vi.fn(),
+  prNumberOr: vi.fn(),
 }));
 
-vi.mock("node:child_process", () => ({
-  default: { execSync: execSyncMock },
-  execSync: execSyncMock,
+vi.mock("@blackbelt-technology/pi-dashboard-shared/platform/git.js", () => ({
+  currentBranchOr,
+  headShaOr,
+  remoteUrlOr,
+  prNumberOr,
 }));
 
+import { gatherGitInfo, detectBranch, detectRemoteUrl, detectPrNumber } from "../git-info.js";
+
 describe("git-info", () => {
   beforeEach(() => {
-    execSyncMock.mockReset();
+    currentBranchOr.mockReset();
+    headShaOr.mockReset();
+    remoteUrlOr.mockReset();
+    prNumberOr.mockReset();
   });
 
   describe("detectBranch", () => {
     it("returns branch name", () => {
-      execSyncMock.mockReturnValue("main\n");
+      currentBranchOr.mockReturnValue("main");
       expect(detectBranch("/test")).toBe("main");
     });
 
     it("returns undefined when not a git repo", () => {
-      execSyncMock.mockImplementation(() => { throw new Error("not a git repo"); });
+      currentBranchOr.mockReturnValue(undefined);
       expect(detectBranch("/test")).toBeUndefined();
     });
 
     it("returns short SHA for detached HEAD", () => {
-      execSyncMock
-        .mockReturnValueOnce("HEAD\n")       // rev-parse --abbrev-ref HEAD
-        .mockReturnValueOnce("abc1234\n");   // rev-parse --short HEAD
+      currentBranchOr.mockReturnValue("HEAD");
+      headShaOr.mockReturnValue("abc1234");
       expect(detectBranch("/test")).toBe("abc1234");
     });
 
     it("returns 'HEAD' as fallback if short SHA fails", () => {
-      execSyncMock
-        .mockReturnValueOnce("HEAD\n")
-        .mockImplementationOnce(() => { throw new Error("fail"); });
+      currentBranchOr.mockReturnValue("HEAD");
+      headShaOr.mockReturnValue(undefined);
       expect(detectBranch("/test")).toBe("HEAD");
     });
   });
 
   describe("detectRemoteUrl", () => {
-    it("returns remote URL", () => {
-      execSyncMock.mockReturnValue("git@github.com:user/repo.git\n");
-      expect(detectRemoteUrl("/test")).toBe("git@github.com:user/repo.git");
+    it("returns origin remote URL", () => {
+      remoteUrlOr.mockReturnValue("git@github.com:org/repo.git");
+      expect(detectRemoteUrl("/test")).toBe("git@github.com:org/repo.git");
     });
 
-    it("returns undefined when no origin", () => {
-      execSyncMock.mockImplementation(() => { throw new Error("no remote"); });
+    it("returns undefined when no remote is configured", () => {
+      remoteUrlOr.mockReturnValue(undefined);
       expect(detectRemoteUrl("/test")).toBeUndefined();
     });
   });
 
   describe("detectPrNumber", () => {
-    it("returns PR number from gh CLI", () => {
-      execSyncMock.mockReturnValue("42\n");
+    it("returns PR number when gh finds one", () => {
+      prNumberOr.mockReturnValue(42);
       expect(detectPrNumber("/test")).toBe(42);
     });
 
-    it("returns undefined when gh CLI fails", () => {
-      execSyncMock.mockImplementation(() => { throw new Error("gh not found"); });
+    it("returns undefined when gh is missing or no PR exists", () => {
+      prNumberOr.mockReturnValue(undefined);
       expect(detectPrNumber("/test")).toBeUndefined();
     });
   });
 
   describe("gatherGitInfo", () => {
-    it("returns full git info with links", () => {
-      execSyncMock
-        .mockReturnValueOnce("feat/foo\n")    // branch
-        .mockReturnValueOnce("git@github.com:user/repo.git\n")  // remote
-        .mockReturnValueOnce("7\n");          // PR
-
-      const info = gatherGitInfo("/test");
-      expect(info).toEqual({
-        gitBranch: "feat/foo",
-        gitBranchUrl: "https://github.com/user/repo/tree/feat%2Ffoo",
-        gitPrNumber: 7,
-        gitPrUrl: "https://github.com/user/repo/pull/7",
-      });
-    });
-
     it("returns undefined when not a git repo", () => {
-      execSyncMock.mockImplementation(() => { throw new Error("not a git repo"); });
+      currentBranchOr.mockReturnValue(undefined);
       expect(gatherGitInfo("/test")).toBeUndefined();
     });
 
-    it("returns info without PR when gh fails", () => {
-      execSyncMock
-        .mockReturnValueOnce("main\n")
-        .mockReturnValueOnce("git@github.com:user/repo.git\n")
-        .mockImplementationOnce(() => { throw new Error("gh not found"); });
+    it("returns GitInfo for a repo with branch + remote + PR", () => {
+      currentBranchOr.mockReturnValue("feature/x");
+      remoteUrlOr.mockReturnValue("git@github.com:org/repo.git");
+      prNumberOr.mockReturnValue(123);
 
       const info = gatherGitInfo("/test");
-      expect(info?.gitBranch).toBe("main");
-      expect(info?.gitPrNumber).toBeUndefined();
-      expect(info?.gitPrUrl).toBeUndefined();
+      expect(info?.gitBranch).toBe("feature/x");
+      expect(info?.gitPrNumber).toBe(123);
+      // Branch URLs URL-encode slashes (feature/x → feature%2Fx) in some builders
+      expect(info?.gitBranchUrl).toMatch(/feature(\/|%2F)x/);
+      expect(info?.gitPrUrl).toContain("123");
     });
 
-    it("returns info without links when no remote", () => {
-      execSyncMock
-        .mockReturnValueOnce("main\n")
-        .mockImplementationOnce(() => { throw new Error("no remote"); })
-        .mockImplementationOnce(() => { throw new Error("gh not found"); });
+    it("returns GitInfo without links when there's no remote", () => {
+      currentBranchOr.mockReturnValue("main");
+      remoteUrlOr.mockReturnValue(undefined);
+      prNumberOr.mockReturnValue(undefined);
 
       const info = gatherGitInfo("/test");
       expect(info?.gitBranch).toBe("main");
       expect(info?.gitBranchUrl).toBeUndefined();
     });
+
+    it("handles detached HEAD with short SHA", () => {
+      currentBranchOr.mockReturnValue("HEAD");
+      headShaOr.mockReturnValue("abc1234");
+      remoteUrlOr.mockReturnValue(undefined);
+      prNumberOr.mockReturnValue(undefined);
+
+      const info = gatherGitInfo("/test");
+      expect(info?.gitBranch).toBe("abc1234");
+    });
   });
 });

package/packages/extension/src/__tests__/openspec-poller.test.ts

@@ -1,119 +1,124 @@
+/**
+ * Tests for openspec-poller.ts — the higher-level aggregator that combines
+ * `openspec list` + per-change `openspec status` into the dashboard's
+ * `OpenSpecData` shape.
+ *
+ * The file now delegates to `platform/openspec.ts` for the subprocess work.
+ * We mock that module so the tests focus on the aggregation logic
+ * (empty results, artifact mapping, per-change status failures) without
+ * spawning openspec.
+ *
+ * See change: platform-command-executor.
+ */
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { SpawnSyncReturns } from "node:child_process";
-
-// We need to mock spawnSync before importing the module under test
-const mockSpawnSync = vi.fn<(...args: any[]) => any>();
-const mockExecFile = vi.fn<(...args: any[]) => any>();
-vi.mock("node:child_process", () => ({
-  spawnSync: mockSpawnSync,
-  execFile: mockExecFile,
-  // re-export defaults that node:child_process has
-  default: { spawnSync: mockSpawnSync, execFile: mockExecFile },
+
+const { listOr, statusOr } = vi.hoisted(() => ({
+  listOr: vi.fn(),
+  statusOr: vi.fn(),
 }));
 
-// Import after mock is set up
-const { pollOpenSpec } = await import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js");
-
-function ok(data: unknown): Partial<SpawnSyncReturns<string>> {
-  return { status: 0, stdout: JSON.stringify(data), stderr: "" };
-}
-
-function fail(): Partial<SpawnSyncReturns<string>> {
-  return { status: 1, stdout: "", stderr: "error" };
-}
-
-function mockCli(responses: Map<string, unknown>) {
-  mockSpawnSync.mockImplementation((_cmd: any, args: any) => {
-    const a = args as string[];
-    if (a.includes("list")) {
-      const d = responses.get("list");
-      return d ? ok(d) : fail();
-    }
-    if (a.includes("status")) {
-      const idx = a.indexOf("--change");
-      const name = idx >= 0 ? a[idx + 1] : "";
-      const d = responses.get(`status:${name}`);
-      return d ? ok(d) : fail();
-    }
-    return fail();
-  });
-}
+vi.mock("@blackbelt-technology/pi-dashboard-shared/platform/openspec.js", () => ({
+  listOr,
+  statusOr,
+}));
 
-beforeEach(() => {
-  mockSpawnSync.mockReset();
-});
+import { pollOpenSpec } from "@blackbelt-technology/pi-dashboard-shared/openspec-poller.js";
 
 describe("pollOpenSpec", () => {
-  it("returns initialized=false when CLI throws", () => {
-    mockSpawnSync.mockImplementation(() => { throw new Error("ENOENT"); });
-    const result = pollOpenSpec("/project");
-    expect(result).toEqual({ initialized: false, changes: [] });
+  beforeEach(() => {
+    listOr.mockReset();
+    statusOr.mockReset();
   });
 
-  it("returns initialized=false when list returns non-zero exit", () => {
-    mockSpawnSync.mockReturnValue(fail());
-    const result = pollOpenSpec("/project");
-    expect(result).toEqual({ initialized: false, changes: [] });
+  it("returns initialized=false when list fails", () => {
+    listOr.mockReturnValue(null);
+    expect(pollOpenSpec("/test")).toEqual({ initialized: false, changes: [] });
+  });
+
+  it("returns initialized=false when list returns non-array changes", () => {
+    listOr.mockReturnValue({ changes: "not an array" });
+    expect(pollOpenSpec("/test")).toEqual({ initialized: false, changes: [] });
   });
 
   it("returns initialized=true with changes on success", () => {
-    mockCli(new Map([
-      ["list", {
-        changes: [
-          { name: "feat-a", status: "in-progress", completedTasks: 3, totalTasks: 5 },
-          { name: "feat-b", status: "complete", completedTasks: 4, totalTasks: 4 },
-        ],
-      }],
-      ["status:feat-a", {
-        artifacts: [
-          { id: "proposal", status: "done" },
-          { id: "design", status: "ready" },
-          { id: "tasks", status: "blocked" },
-        ],
-      }],
-      ["status:feat-b", {
-        artifacts: [
-          { id: "proposal", status: "done" },
-          { id: "tasks", status: "done" },
-        ],
-      }],
-    ]));
-
-    const result = pollOpenSpec("/project");
-    expect(result.initialized).toBe(true);
-    expect(result.changes).toHaveLength(2);
-    expect(result.changes[0]).toEqual({
-      name: "feat-a",
-      status: "in-progress",
-      completedTasks: 3,
-      totalTasks: 5,
+    listOr.mockReturnValue({
+      changes: [
+        { name: "add-auth", status: "in-progress", completedTasks: 3, totalTasks: 10 },
+      ],
+    });
+    statusOr.mockReturnValue({
       artifacts: [
         { id: "proposal", status: "done" },
-        { id: "design", status: "ready" },
-        { id: "tasks", status: "blocked" },
+        { id: "tasks", status: "ready" },
       ],
     });
-    expect(result.changes[1].status).toBe("complete");
-  });
 
-  it("handles invalid JSON gracefully", () => {
-    mockSpawnSync.mockReturnValue({ status: 0, stdout: "not json {{{", stderr: "" });
-    const result = pollOpenSpec("/project");
-    expect(result).toEqual({ initialized: false, changes: [] });
+    const result = pollOpenSpec("/test");
+    expect(result.initialized).toBe(true);
+    expect(result.changes).toHaveLength(1);
+    expect(result.changes[0]).toMatchObject({
+      name: "add-auth",
+      status: "in-progress",
+      completedTasks: 3,
+      totalTasks: 10,
+    });
+    expect(result.changes[0].artifacts).toEqual([
+      { id: "proposal", status: "done" },
+      { id: "tasks", status: "ready" },
+    ]);
   });
 
   it("handles status call failure gracefully (empty artifacts)", () => {
-    mockCli(new Map([
-      ["list", {
-        changes: [
-          { name: "feat-a", status: "no-tasks", completedTasks: 0, totalTasks: 0 },
-        ],
-      }],
-      // No status:feat-a — status call fails
-    ]));
-
-    const result = pollOpenSpec("/project");
+    listOr.mockReturnValue({
+      changes: [
+        { name: "x", status: "complete", completedTasks: 5, totalTasks: 5 },
+      ],
+    });
+    statusOr.mockReturnValue(null); // status failed
+
+    const result = pollOpenSpec("/test");
     expect(result.initialized).toBe(true);
     expect(result.changes[0].artifacts).toEqual([]);
   });
+
+  it("normalizes unknown status values to 'no-tasks'", () => {
+    listOr.mockReturnValue({
+      changes: [
+        { name: "x", status: "weird-future-status", completedTasks: 0, totalTasks: 0 },
+      ],
+    });
+    statusOr.mockReturnValue(null);
+
+    const result = pollOpenSpec("/test");
+    expect(result.changes[0].status).toBe("no-tasks");
+  });
+
+  it("normalizes unknown artifact statuses to 'blocked'", () => {
+    listOr.mockReturnValue({
+      changes: [
+        { name: "x", status: "in-progress", completedTasks: 0, totalTasks: 1 },
+      ],
+    });
+    statusOr.mockReturnValue({
+      artifacts: [{ id: "proposal", status: "some-new-state" }],
+    });
+
+    const result = pollOpenSpec("/test");
+    expect(result.changes[0].artifacts[0].status).toBe("blocked");
+  });
+
+  it("calls statusOr once per change, with the change name", () => {
+    listOr.mockReturnValue({
+      changes: [
+        { name: "a", status: "in-progress", completedTasks: 0, totalTasks: 1 },
+        { name: "b", status: "complete", completedTasks: 2, totalTasks: 2 },
+      ],
+    });
+    statusOr.mockReturnValue({ artifacts: [] });
+
+    pollOpenSpec("/test");
+    expect(statusOr).toHaveBeenCalledTimes(2);
+    expect(statusOr).toHaveBeenNthCalledWith(1, { cwd: "/test", change: "a" });
+    expect(statusOr).toHaveBeenNthCalledWith(2, { cwd: "/test", change: "b" });
+  });
 });

package/packages/extension/src/__tests__/process-scanner-kill.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Tests that `killProcessByPgid` routes through the platform's
+ * `killPidWithGroup` helper (not raw `process.kill`).
+ *
+ * See change: route-kill-paths-through-platform.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const killPidWithGroupSpy = vi.fn((_pid: number, _sig: any, _opts?: any) => undefined);
+
+vi.mock("@blackbelt-technology/pi-dashboard-shared/platform/process.js", async () => {
+  const actual = await vi.importActual<typeof import("@blackbelt-technology/pi-dashboard-shared/platform/process.js")>(
+    "@blackbelt-technology/pi-dashboard-shared/platform/process.js",
+  );
+  return {
+    ...actual,
+    killPidWithGroup: (pid: number, sig: any, opts?: any) => killPidWithGroupSpy(pid, sig, opts),
+  };
+});
+
+const { killProcessByPgid } = await import("../process-scanner.js");
+
+describe("killProcessByPgid platform routing", () => {
+  beforeEach(() => {
+    killPidWithGroupSpy.mockClear();
+  });
+
+  it("invokes killPidWithGroup with the resolved platform on Unix", () => {
+    const ok = killProcessByPgid(4242, { _platform: "linux" } as any);
+    expect(ok).toBe(true);
+    expect(killPidWithGroupSpy).toHaveBeenCalledTimes(1);
+    const [pid, sig, opts] = killPidWithGroupSpy.mock.calls[0];
+    expect(pid).toBe(4242);
+    expect(sig).toBe("SIGTERM");
+    expect(opts?.platform).toBe("linux");
+  });
+
+  it("invokes killPidWithGroup with platform=darwin for macOS pgids", () => {
+    killProcessByPgid(9999, { _platform: "darwin" } as any);
+    const [pid, , opts] = killPidWithGroupSpy.mock.calls[0];
+    expect(pid).toBe(9999);
+    expect(opts?.platform).toBe("darwin");
+  });
+
+  it("does NOT call process.kill directly on Unix", () => {
+    const processKillSpy = vi.spyOn(process, "kill");
+    try {
+      killProcessByPgid(1234, { _platform: "linux" } as any);
+    } catch { /* ignore */ }
+    expect(processKillSpy).not.toHaveBeenCalled();
+    processKillSpy.mockRestore();
+  });
+
+  it("reports failure if killPidWithGroup throws", () => {
+    killPidWithGroupSpy.mockImplementationOnce(() => {
+      throw new Error("ESRCH");
+    });
+    const ok = killProcessByPgid(4242, { _platform: "linux" } as any);
+    expect(ok).toBe(false);
+  });
+});