@blackbelt-technology/pi-agent-dashboard 0.4.1 → 0.4.2

package/packages/shared/src/__tests__/openspec-design-evidence.test.ts

@@ -0,0 +1,288 @@
+/**
+ * Tests for the local-design-evidence override that fixes session-card
+ * button rendering for split-design (Case B) and no-design (Case A) changes.
+ * See change: fix-openspec-design-detection.
+ */
+import { describe, expect, it } from "vitest";
+import {
+  evaluateLocalDesignSatisfaction,
+  type DesignEvidenceProbe,
+} from "../openspec-design-evidence.js";
+
+/** In-memory probe stub. */
+function probe(opts: {
+  hasDesignFile?: boolean;
+  hasDesignDirWithMd?: boolean;
+  tasksHasCheckboxes?: boolean;
+}): DesignEvidenceProbe {
+  return {
+    hasDesignFile: () => opts.hasDesignFile === true,
+    hasDesignDirWithMd: () => opts.hasDesignDirWithMd === true,
+    tasksHasCheckboxes: () => opts.tasksHasCheckboxes === true,
+  };
+}
+
+describe("evaluateLocalDesignSatisfaction", () => {
+  it("R1: design.md (or design-*.md) present → satisfied", () => {
+    expect(evaluateLocalDesignSatisfaction("/c", probe({ hasDesignFile: true }))).toBe(true);
+  });
+
+  it("R2: design/ folder with .md → satisfied", () => {
+    expect(evaluateLocalDesignSatisfaction("/c", probe({ hasDesignDirWithMd: true }))).toBe(true);
+  });
+
+  it("R3: tasks.md with checkboxes → satisfied", () => {
+    expect(evaluateLocalDesignSatisfaction("/c", probe({ tasksHasCheckboxes: true }))).toBe(true);
+  });
+
+  it("no evidence → not satisfied", () => {
+    expect(evaluateLocalDesignSatisfaction("/c", probe({}))).toBe(false);
+  });
+
+  it("R1 short-circuits before R2/R3", () => {
+    let r2 = 0;
+    let r3 = 0;
+    const p: DesignEvidenceProbe = {
+      hasDesignFile: () => true,
+      hasDesignDirWithMd: () => {
+        r2++;
+        return false;
+      },
+      tasksHasCheckboxes: () => {
+        r3++;
+        return false;
+      },
+    };
+    expect(evaluateLocalDesignSatisfaction("/c", p)).toBe(true);
+    expect(r2).toBe(0);
+    expect(r3).toBe(0);
+  });
+
+  it("R2 short-circuits before R3", () => {
+    let r3 = 0;
+    const p: DesignEvidenceProbe = {
+      hasDesignFile: () => false,
+      hasDesignDirWithMd: () => true,
+      tasksHasCheckboxes: () => {
+        r3++;
+        return false;
+      },
+    };
+    expect(evaluateLocalDesignSatisfaction("/c", p)).toBe(true);
+    expect(r3).toBe(0);
+  });
+
+  it("passes the changeDir through to every probe call", () => {
+    const seen: string[] = [];
+    const p: DesignEvidenceProbe = {
+      hasDesignFile: (d) => {
+        seen.push(d);
+        return false;
+      },
+      hasDesignDirWithMd: (d) => {
+        seen.push(d);
+        return false;
+      },
+      tasksHasCheckboxes: (d) => {
+        seen.push(d);
+        return false;
+      },
+    };
+    evaluateLocalDesignSatisfaction("/abs/path/to/change", p);
+    expect(seen).toEqual([
+      "/abs/path/to/change",
+      "/abs/path/to/change",
+      "/abs/path/to/change",
+    ]);
+  });
+});
+
+// ── Real-fs probe tests (createFsDesignEvidenceProbe) ──────────────────────
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { createFsDesignEvidenceProbe } from "../openspec-design-evidence.js";
+
+function tmpChangeDir(): string {
+  return mkdtempSync(path.join(tmpdir(), "openspec-design-evidence-"));
+}
+
+describe("createFsDesignEvidenceProbe — R1", () => {
+  it("matches design.md", () => {
+    const d = tmpChangeDir();
+    try {
+      writeFileSync(path.join(d, "design.md"), "");
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.hasDesignFile(d)).toBe(true);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("matches design-rendering.md (split design)", () => {
+    const d = tmpChangeDir();
+    try {
+      writeFileSync(path.join(d, "design-rendering.md"), "");
+      writeFileSync(path.join(d, "design-state.md"), "");
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.hasDesignFile(d)).toBe(true);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("does NOT match designate.md (must start with 'design')", () => {
+    const d = tmpChangeDir();
+    try {
+      // 'designate' starts with 'design' — accepted by ^design.*\.md$.
+      // We're testing a non-matching name instead:
+      writeFileSync(path.join(d, "redesign.md"), "");
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.hasDesignFile(d)).toBe(false);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("does NOT match design.txt (must end with .md)", () => {
+    const d = tmpChangeDir();
+    try {
+      writeFileSync(path.join(d, "design.txt"), "");
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.hasDesignFile(d)).toBe(false);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("returns false on missing directory", () => {
+    const probe = createFsDesignEvidenceProbe();
+    expect(probe.hasDesignFile("/nonexistent/path/xyz123")).toBe(false);
+  });
+});
+
+describe("createFsDesignEvidenceProbe — R2", () => {
+  it("matches design/ folder with at least one .md", () => {
+    const d = tmpChangeDir();
+    try {
+      mkdirSync(path.join(d, "design"));
+      writeFileSync(path.join(d, "design", "architecture.md"), "");
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.hasDesignDirWithMd(d)).toBe(true);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("does NOT match empty design/ folder", () => {
+    const d = tmpChangeDir();
+    try {
+      mkdirSync(path.join(d, "design"));
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.hasDesignDirWithMd(d)).toBe(false);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("does NOT match design/ with only non-md files", () => {
+    const d = tmpChangeDir();
+    try {
+      mkdirSync(path.join(d, "design"));
+      writeFileSync(path.join(d, "design", "notes.txt"), "");
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.hasDesignDirWithMd(d)).toBe(false);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("returns false when design/ does not exist", () => {
+    const d = tmpChangeDir();
+    try {
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.hasDesignDirWithMd(d)).toBe(false);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("createFsDesignEvidenceProbe — R3", () => {
+  it("matches tasks.md with `- [ ]` checkbox", () => {
+    const d = tmpChangeDir();
+    try {
+      writeFileSync(path.join(d, "tasks.md"), "## 1. Setup\n\n- [ ] 1.1 Do thing\n");
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.tasksHasCheckboxes(d)).toBe(true);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("matches tasks.md with `- [x]` checkbox (already complete)", () => {
+    const d = tmpChangeDir();
+    try {
+      writeFileSync(path.join(d, "tasks.md"), "- [x] done\n");
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.tasksHasCheckboxes(d)).toBe(true);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("matches tasks.md with `- [X]` (uppercase X)", () => {
+    const d = tmpChangeDir();
+    try {
+      writeFileSync(path.join(d, "tasks.md"), "- [X] done\n");
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.tasksHasCheckboxes(d)).toBe(true);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("does NOT match empty tasks.md", () => {
+    const d = tmpChangeDir();
+    try {
+      writeFileSync(path.join(d, "tasks.md"), "");
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.tasksHasCheckboxes(d)).toBe(false);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("does NOT match tasks.md with only headings (no checkboxes)", () => {
+    const d = tmpChangeDir();
+    try {
+      writeFileSync(path.join(d, "tasks.md"), "## 1. Setup\n\nSome prose.\n");
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.tasksHasCheckboxes(d)).toBe(false);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("does NOT match a `[ ]` not preceded by `- `", () => {
+    const d = tmpChangeDir();
+    try {
+      writeFileSync(path.join(d, "tasks.md"), "this [ ] is inline text\n");
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.tasksHasCheckboxes(d)).toBe(false);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  it("returns false when tasks.md does not exist", () => {
+    const d = tmpChangeDir();
+    try {
+      const probe = createFsDesignEvidenceProbe();
+      expect(probe.tasksHasCheckboxes(d)).toBe(false);
+    } finally {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
+});

package/packages/shared/src/__tests__/openspec-effective-status-script.test.ts

@@ -0,0 +1,174 @@
+/**
+ * Parity test: the bash wrapper at
+ * `.pi/skills/openspec-shared/scripts/effective-status.sh` must apply the
+ * SAME R1/R2/R3 promotion as the TS `evaluateLocalDesignSatisfaction`,
+ * so skill-driven prompts and dashboard buttons cannot disagree.
+ *
+ * Strategy: the wrapper calls the real `openspec` CLI. We can't invoke it
+ * here without the binary on PATH and an in-tree change. Instead we
+ * verify the wrapper's RULE EVALUATION against the same fixtures we
+ * use for `evaluateLocalDesignSatisfaction`, by piping a synthetic
+ * `openspec status --json`-shaped JSON into the override section of the
+ * script. Since the script's CLI invocation is at the very top, we
+ * exercise it with a stubbed `openspec` shim on PATH.
+ *
+ * See change: fix-openspec-design-detection.
+ */
+import { describe, expect, it } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, chmodSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+const SCRIPT_PATH = path.resolve(
+  __dirname,
+  "../../../../.pi/skills/openspec-shared/scripts/effective-status.sh",
+);
+
+function setupHarness(): { root: string; changeName: string; changeDir: string; binDir: string } {
+  const root = mkdtempSync(path.join(tmpdir(), "effective-status-test-"));
+  const changeName = "demo-change";
+  const changesDir = path.join(root, "openspec", "changes", changeName);
+  mkdirSync(changesDir, { recursive: true });
+  const binDir = path.join(root, "bin");
+  mkdirSync(binDir, { recursive: true });
+  return { root, changeName, changeDir: changesDir, binDir };
+}
+
+function writeOpenspecStub(binDir: string, jsonOutput: string): void {
+  const stub = path.join(binDir, "openspec");
+  writeFileSync(
+    stub,
+    `#!/usr/bin/env bash\ncat <<'JSON_EOF'\n${jsonOutput}\nJSON_EOF\n`,
+    { mode: 0o755 },
+  );
+  chmodSync(stub, 0o755);
+}
+
+function runWrapper(root: string, binDir: string, changeName: string): unknown {
+  const out = execFileSync("bash", [SCRIPT_PATH, changeName], {
+    cwd: root,
+    env: { ...process.env, PATH: `${binDir}:${process.env.PATH ?? ""}` },
+    encoding: "utf8",
+  });
+  return JSON.parse(out);
+}
+
+const BASE_STATUS = JSON.stringify({
+  changeName: "demo-change",
+  schemaName: "spec-driven",
+  isComplete: false,
+  applyRequires: ["tasks"],
+  artifacts: [
+    { id: "proposal", outputPath: "proposal.md", status: "done" },
+    { id: "specs", outputPath: "specs/**/*.md", status: "done" },
+    { id: "design", outputPath: "design.md", status: "ready" },
+    { id: "tasks", outputPath: "tasks.md", status: "done" },
+  ],
+});
+
+describe("effective-status.sh — parity with evaluateLocalDesignSatisfaction", () => {
+  it("R1: design.md present → promotes design to done", () => {
+    const h = setupHarness();
+    try {
+      writeFileSync(path.join(h.changeDir, "design.md"), "");
+      writeOpenspecStub(h.binDir, BASE_STATUS);
+      const out = runWrapper(h.root, h.binDir, h.changeName) as any;
+      const design = out.artifacts.find((a: any) => a.id === "design");
+      expect(design.status).toBe("done");
+      expect(out.isComplete).toBe(true); // all artifacts done after promotion
+    } finally {
+      rmSync(h.root, { recursive: true, force: true });
+    }
+  });
+
+  it("R1: split design (design-A.md + design-B.md, no design.md) → promoted", () => {
+    const h = setupHarness();
+    try {
+      writeFileSync(path.join(h.changeDir, "design-rendering.md"), "");
+      writeFileSync(path.join(h.changeDir, "design-state.md"), "");
+      writeOpenspecStub(h.binDir, BASE_STATUS);
+      const out = runWrapper(h.root, h.binDir, h.changeName) as any;
+      expect(out.artifacts.find((a: any) => a.id === "design").status).toBe("done");
+    } finally {
+      rmSync(h.root, { recursive: true, force: true });
+    }
+  });
+
+  it("R2: design/ folder with .md → promoted", () => {
+    const h = setupHarness();
+    try {
+      mkdirSync(path.join(h.changeDir, "design"));
+      writeFileSync(path.join(h.changeDir, "design", "architecture.md"), "");
+      writeOpenspecStub(h.binDir, BASE_STATUS);
+      const out = runWrapper(h.root, h.binDir, h.changeName) as any;
+      expect(out.artifacts.find((a: any) => a.id === "design").status).toBe("done");
+    } finally {
+      rmSync(h.root, { recursive: true, force: true });
+    }
+  });
+
+  it("R3: tasks.md with `- [ ]` → promoted", () => {
+    const h = setupHarness();
+    try {
+      writeFileSync(path.join(h.changeDir, "tasks.md"), "## 1. x\n\n- [ ] 1.1 do\n");
+      writeOpenspecStub(h.binDir, BASE_STATUS);
+      const out = runWrapper(h.root, h.binDir, h.changeName) as any;
+      expect(out.artifacts.find((a: any) => a.id === "design").status).toBe("done");
+    } finally {
+      rmSync(h.root, { recursive: true, force: true });
+    }
+  });
+
+  it("no evidence → design stays ready", () => {
+    const h = setupHarness();
+    try {
+      writeFileSync(path.join(h.changeDir, "proposal.md"), "");
+      writeOpenspecStub(h.binDir, BASE_STATUS);
+      const out = runWrapper(h.root, h.binDir, h.changeName) as any;
+      expect(out.artifacts.find((a: any) => a.id === "design").status).toBe("ready");
+      expect(out.isComplete).toBe(false);
+    } finally {
+      rmSync(h.root, { recursive: true, force: true });
+    }
+  });
+
+  it("never demotes done → ready", () => {
+    const h = setupHarness();
+    try {
+      // No evidence in fs, but CLI says design done.
+      const cliDone = JSON.stringify({
+        ...JSON.parse(BASE_STATUS),
+        artifacts: [
+          { id: "proposal", outputPath: "proposal.md", status: "done" },
+          { id: "design", outputPath: "design.md", status: "done" },
+        ],
+        isComplete: true,
+      });
+      writeOpenspecStub(h.binDir, cliDone);
+      const out = runWrapper(h.root, h.binDir, h.changeName) as any;
+      expect(out.artifacts.find((a: any) => a.id === "design").status).toBe("done");
+      expect(out.isComplete).toBe(true);
+    } finally {
+      rmSync(h.root, { recursive: true, force: true });
+    }
+  });
+
+  it("never promotes blocked → done even with evidence", () => {
+    const h = setupHarness();
+    try {
+      writeFileSync(path.join(h.changeDir, "design.md"), "");
+      const blocked = JSON.stringify({
+        ...JSON.parse(BASE_STATUS),
+        artifacts: [
+          { id: "design", outputPath: "design.md", status: "blocked" },
+        ],
+      });
+      writeOpenspecStub(h.binDir, blocked);
+      const out = runWrapper(h.root, h.binDir, h.changeName) as any;
+      expect(out.artifacts.find((a: any) => a.id === "design").status).toBe("blocked");
+    } finally {
+      rmSync(h.root, { recursive: true, force: true });
+    }
+  });
+});

package/packages/shared/src/__tests__/openspec-poller-design-override.test.ts

@@ -0,0 +1,225 @@
+/**
+ * Verifies `buildOpenSpecData`'s design-artifact override behavior.
+ * Invariants: promote-only, design-only, never demote, isComplete only
+ * promoted to true (never demoted from CLI true).
+ *
+ * See change: fix-openspec-design-detection.
+ */
+import { describe, expect, it } from "vitest";
+import { buildOpenSpecData } from "../openspec-poller.js";
+import type { DesignEvidenceProbe } from "../openspec-design-evidence.js";
+
+function probe(satisfied: boolean, calls?: { count: number }): DesignEvidenceProbe {
+  return {
+    hasDesignFile: () => {
+      if (calls) calls.count++;
+      return satisfied;
+    },
+    hasDesignDirWithMd: () => false,
+    tasksHasCheckboxes: () => false,
+  };
+}
+
+const listResult = {
+  changes: [
+    { name: "x", status: "in-progress", completedTasks: 1, totalTasks: 3 },
+  ],
+};
+
+describe("buildOpenSpecData design override", () => {
+  it("promotes design ready→done when probe satisfies", () => {
+    const statusResults = new Map<string, any>([
+      [
+        "x",
+        {
+          artifacts: [
+            { id: "proposal", status: "done" },
+            { id: "specs", status: "done" },
+            { id: "design", status: "ready" },
+            { id: "tasks", status: "ready" },
+          ],
+          isComplete: false,
+        },
+      ],
+    ]);
+    const data = buildOpenSpecData(listResult, statusResults, () => probe(true));
+    const x = data.changes[0];
+    expect(x.artifacts.find((a) => a.id === "design")!.status).toBe("done");
+  });
+
+  it("does NOT promote when probe says not satisfied", () => {
+    const statusResults = new Map<string, any>([
+      [
+        "x",
+        {
+          artifacts: [
+            { id: "design", status: "ready" },
+          ],
+        },
+      ],
+    ]);
+    const data = buildOpenSpecData(listResult, statusResults, () => probe(false));
+    expect(data.changes[0].artifacts.find((a) => a.id === "design")!.status).toBe("ready");
+  });
+
+  it("never promotes blocked → done", () => {
+    const statusResults = new Map<string, any>([
+      [
+        "x",
+        {
+          artifacts: [{ id: "design", status: "blocked" }],
+        },
+      ],
+    ]);
+    const data = buildOpenSpecData(listResult, statusResults, () => probe(true));
+    expect(data.changes[0].artifacts.find((a) => a.id === "design")!.status).toBe("blocked");
+  });
+
+  it("never demotes done → ready (CLI says done; we trust it)", () => {
+    const statusResults = new Map<string, any>([
+      [
+        "x",
+        {
+          artifacts: [{ id: "design", status: "done" }],
+        },
+      ],
+    ]);
+    const data = buildOpenSpecData(listResult, statusResults, () => probe(false));
+    expect(data.changes[0].artifacts.find((a) => a.id === "design")!.status).toBe("done");
+  });
+
+  it("only mutates design — other artifact statuses pass through", () => {
+    const statusResults = new Map<string, any>([
+      [
+        "x",
+        {
+          artifacts: [
+            { id: "proposal", status: "ready" },
+            { id: "specs", status: "blocked" },
+            { id: "design", status: "ready" },
+            { id: "tasks", status: "ready" },
+          ],
+        },
+      ],
+    ]);
+    const data = buildOpenSpecData(listResult, statusResults, () => probe(true));
+    const arts = data.changes[0].artifacts;
+    expect(arts.find((a) => a.id === "proposal")!.status).toBe("ready");
+    expect(arts.find((a) => a.id === "specs")!.status).toBe("blocked");
+    expect(arts.find((a) => a.id === "design")!.status).toBe("done");
+    expect(arts.find((a) => a.id === "tasks")!.status).toBe("ready");
+  });
+
+  it("re-derives isComplete=true when all artifacts done after override", () => {
+    const statusResults = new Map<string, any>([
+      [
+        "x",
+        {
+          artifacts: [
+            { id: "proposal", status: "done" },
+            { id: "specs", status: "done" },
+            { id: "design", status: "ready" },
+            { id: "tasks", status: "done" },
+          ],
+          isComplete: false,
+        },
+      ],
+    ]);
+    const data = buildOpenSpecData(listResult, statusResults, () => probe(true));
+    expect(data.changes[0].isComplete).toBe(true);
+  });
+
+  it("does NOT promote isComplete when any non-design artifact is not done", () => {
+    const statusResults = new Map<string, any>([
+      [
+        "x",
+        {
+          artifacts: [
+            { id: "proposal", status: "done" },
+            { id: "specs", status: "ready" },
+            { id: "design", status: "ready" },
+            { id: "tasks", status: "blocked" },
+          ],
+          isComplete: false,
+        },
+      ],
+    ]);
+    const data = buildOpenSpecData(listResult, statusResults, () => probe(true));
+    // design becomes done, but specs/tasks are still not — isComplete passes through CLI value (false)
+    expect(data.changes[0].isComplete).toBe(false);
+  });
+
+  it("never demotes CLI isComplete=true to false", () => {
+    const statusResults = new Map<string, any>([
+      [
+        "x",
+        {
+          artifacts: [{ id: "proposal", status: "done" }],
+          isComplete: true,
+        },
+      ],
+    ]);
+    // Probe says NOT satisfied, single artifact is done so override re-derive would also be true.
+    // Use a more adversarial setup: probe NOT satisfied, single artifact is "ready", CLI says complete.
+    const adversarial = new Map<string, any>([
+      [
+        "x",
+        {
+          artifacts: [{ id: "proposal", status: "ready" }],
+          isComplete: true,
+        },
+      ],
+    ]);
+    const data = buildOpenSpecData(listResult, adversarial, () => probe(false));
+    expect(data.changes[0].isComplete).toBe(true);
+  });
+
+  it("no-probe call site preserves today's behavior verbatim", () => {
+    const statusResults = new Map<string, any>([
+      [
+        "x",
+        {
+          artifacts: [
+            { id: "design", status: "ready" },
+            { id: "tasks", status: "blocked" },
+          ],
+          isComplete: false,
+        },
+      ],
+    ]);
+    const data = buildOpenSpecData(listResult, statusResults);
+    expect(data.changes[0].artifacts.find((a) => a.id === "design")!.status).toBe("ready");
+    expect(data.changes[0].isComplete).toBe(false);
+  });
+
+  it("probe factory receives the change name", () => {
+    const seen: string[] = [];
+    const statusResults = new Map<string, any>([
+      [
+        "x",
+        {
+          artifacts: [{ id: "design", status: "ready" }],
+        },
+      ],
+    ]);
+    buildOpenSpecData(listResult, statusResults, (changeName) => {
+      seen.push(changeName);
+      return probe(false);
+    });
+    expect(seen).toContain("x");
+  });
+
+  it("probe is NOT consulted when CLI says design is already done", () => {
+    const calls = { count: 0 };
+    const statusResults = new Map<string, any>([
+      [
+        "x",
+        {
+          artifacts: [{ id: "design", status: "done" }],
+        },
+      ],
+    ]);
+    buildOpenSpecData(listResult, statusResults, () => probe(true, calls));
+    expect(calls.count).toBe(0);
+  });
+});