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

package/packages/extension/src/__tests__/ask-user-schema-discriminator.test.ts

@@ -0,0 +1,141 @@
+/**
+ * Regression guard for the `ask_user` tool's parameters JSON Schema shape.
+ *
+ * History:
+ *   1. Pre-a53933f — schema was `Type.Union` of per-method `Type.Object`
+ *      arms (root-level `anyOf`). Anthropic loved it; OpenAI rejected it
+ *      ("schema must be a JSON Schema of 'type: \"object\"', got
+ *      'type: \"None\"'").
+ *
+ *   2. a53933f — collapsed to a single flat `Type.Object` (root
+ *      `type: "object"`, all fields optional). OpenAI happy. Anthropic
+ *      lost its per-method strictness; Claude started emitting
+ *      multiselect calls without `options` and the dashboard auto-
+ *      cancelled them — the user-visible bug behind
+ *      fix-multiselect-auto-cancel-on-dashboard.
+ *
+ *   3. Layer-2 attempt of fix-multiselect-auto-cancel-on-dashboard —
+ *      tried to keep root `type: "object"` AND attach a body-level
+ *      `oneOf` discriminator over `method`. Anthropic worked. Real
+ *      OpenAI gpt-5 rejected it (verified 2026-04-30) with: "schema
+ *      must have type 'object' and not have 'oneOf' / 'anyOf' / 'allOf'
+ *      / 'enum' / 'not' at the top level." The fallback documented in
+ *      tasks.md §9.7 was taken: Layer 2 dropped, Layer 1 (multiselect
+ *      dashboard routing) ships alone — that's what actually fixes the
+ *      user bug.
+ *
+ * This test pins the post-fallback shape so it cannot regress in
+ * either direction:
+ *   • Root MUST be `type: "object"` (OpenAI rule).
+ *   • Root MUST NOT have `oneOf`, `anyOf`, `allOf`, `enum`, `not`.
+ *   • The same five forbidden keys MUST NOT appear on `SubQuestionSchema`
+ *     either — OpenAI applies the rule recursively per the error message.
+ *
+ * Per-method strictness is enforced by `prepareArguments` rescue + the
+ * `execute` runtime switch (covered by `ask-user-tool.test.ts`).
+ *
+ * See change: fix-multiselect-auto-cancel-on-dashboard.
+ */
+import { describe, it, expect, vi } from "vitest";
+import { registerAskUserTool } from "../ask-user-tool.js";
+
+const FORBIDDEN_TOP_LEVEL_KEYS = ["oneOf", "anyOf", "allOf", "enum", "not"] as const;
+
+interface PiSchema {
+  type?: string;
+  properties?: Record<string, any>;
+  required?: string[];
+  description?: string;
+  oneOf?: unknown;
+  anyOf?: unknown;
+  allOf?: unknown;
+  enum?: unknown;
+  not?: unknown;
+}
+
+function captureRegisteredTool() {
+  const calls: any[] = [];
+  const pi = {
+    registerTool: vi.fn((def: any) => calls.push(def)),
+  };
+  registerAskUserTool(pi as any);
+  expect(calls.length).toBe(1);
+  return calls[0];
+}
+
+function getSubQuestionSchema(parameters: PiSchema): PiSchema {
+  const items = parameters.properties?.questions?.items;
+  expect(items).toBeDefined();
+  return items as PiSchema;
+}
+
+// Walk a Union<Literal> schema (typebox emits it as `anyOf` of `{const: ...}`)
+// into a flat list of literal values.
+function flattenUnionLiterals(s: any): string[] {
+  if (!s) return [];
+  if (Array.isArray(s.anyOf)) return s.anyOf.flatMap(flattenUnionLiterals);
+  if (s.const !== undefined) return [String(s.const)];
+  return [];
+}
+
+describe("ask_user parameters schema — OpenAI strict-mode shape", () => {
+  it("root is type:object", () => {
+    const tool = captureRegisteredTool();
+    const params = tool.parameters as PiSchema;
+    expect(params.type).toBe("object");
+  });
+
+  it.each(FORBIDDEN_TOP_LEVEL_KEYS)(
+    "root has NO `%s` (OpenAI strict mode forbids it at the top level)",
+    (key) => {
+      const tool = captureRegisteredTool();
+      const params = tool.parameters as Record<string, unknown>;
+      expect(
+        params[key],
+        `parameters.${key} would break OpenAI gpt-5: "schema must have type 'object' and not have 'oneOf' / 'anyOf' / 'allOf' / 'enum' / 'not' at the top level."`,
+      ).toBeUndefined();
+    },
+  );
+
+  it("declares the five method literals (regression guard for MethodEnum)", () => {
+    const tool = captureRegisteredTool();
+    const methodSchema = (tool.parameters as PiSchema).properties?.method;
+    expect(methodSchema).toBeDefined();
+    // typebox emits a Union<Literal> as `anyOf` UNDER `properties.method`
+    // (NOT at the schema root). That is OpenAI-legal because it isn't at
+    // the top level. We only assert the literal set is preserved.
+    const methods = flattenUnionLiterals(methodSchema);
+    expect(methods).toEqual(
+      expect.arrayContaining(["confirm", "select", "multiselect", "input", "batch"]),
+    );
+  });
+});
+
+describe("ask_user SubQuestionSchema — OpenAI strict-mode shape", () => {
+  it("sub-question schema is type:object", () => {
+    const tool = captureRegisteredTool();
+    const sq = getSubQuestionSchema(tool.parameters);
+    expect(sq.type).toBe("object");
+  });
+
+  it.each(FORBIDDEN_TOP_LEVEL_KEYS)(
+    "sub-question schema has NO `%s` at top level (OpenAI rule applies recursively)",
+    (key) => {
+      const tool = captureRegisteredTool();
+      const sq = getSubQuestionSchema(tool.parameters) as Record<string, unknown>;
+      expect(sq[key]).toBeUndefined();
+    },
+  );
+
+  it("sub-question excludes 'batch' from method literals (no nesting)", () => {
+    const tool = captureRegisteredTool();
+    const sq = getSubQuestionSchema(tool.parameters);
+    const methodSchema = sq.properties?.method;
+    expect(methodSchema).toBeDefined();
+    const methods = flattenUnionLiterals(methodSchema);
+    expect(methods).toEqual(
+      expect.arrayContaining(["confirm", "select", "multiselect", "input"]),
+    );
+    expect(methods).not.toContain("batch");
+  });
+});

package/packages/extension/src/__tests__/ask-user-tool.test.ts

@@ -80,13 +80,24 @@ describe("registerAskUserTool", () => {
     it("passes message through opts for input", async () => {
       const { tool, ctx } = getToolAndMockCtx();
       await tool.execute("id", { method: "input", title: "Q", message: "Details here" }, undefined, undefined, ctx);
-      expect(ctx.ui.input).toHaveBeenCalledWith("Q", undefined, { message: "Details here" });
+      // toolCallId is also threaded through opts since change
+      // `fix-interactive-ui-reorder`. Asserts both fields without
+      // pinning property order.
+      expect(ctx.ui.input).toHaveBeenCalledWith(
+        "Q",
+        undefined,
+        expect.objectContaining({ message: "Details here", toolCallId: "id" }),
+      );
     });
 
     it("passes message through opts for select", async () => {
       const { tool, ctx } = getToolAndMockCtx();
       await tool.execute("id", { method: "select", title: "Pick", message: "Context", options: ["A", "B"] }, undefined, undefined, ctx);
-      expect(ctx.ui.select).toHaveBeenCalledWith("Pick", ["A", "B"], { message: "Context" });
+      expect(ctx.ui.select).toHaveBeenCalledWith(
+        "Pick",
+        ["A", "B"],
+        expect.objectContaining({ message: "Context", toolCallId: "id" }),
+      );
     });
 
     it("dispatches multiselect through the polyfill via ctx.ui.custom", async () => {
@@ -104,28 +115,48 @@ describe("registerAskUserTool", () => {
       expect(result.details.result).toEqual(["A"]);
     });
 
-    it("does not pass opts when message is undefined", async () => {
+    it("passes only toolCallId through opts when message is undefined", async () => {
       const { tool, ctx } = getToolAndMockCtx();
       await tool.execute("id", { method: "input", title: "Q" }, undefined, undefined, ctx);
-      expect(ctx.ui.input).toHaveBeenCalledWith("Q", undefined, undefined);
+      // Even with no `message`, the wrapper still attaches toolCallId so
+      // the resulting prompt_request can be paired by the client reducer.
+      expect(ctx.ui.input).toHaveBeenCalledWith(
+        "Q",
+        undefined,
+        expect.objectContaining({ toolCallId: "id" }),
+      );
     });
 
     it("falls back to message when title is missing", async () => {
       const { tool, ctx } = getToolAndMockCtx();
       await tool.execute("id", { method: "input", message: "Detailed question" }, undefined, undefined, ctx);
-      expect(ctx.ui.input).toHaveBeenCalledWith("Detailed question", undefined, { message: "Detailed question" });
+      expect(ctx.ui.input).toHaveBeenCalledWith(
+        "Detailed question",
+        undefined,
+        expect.objectContaining({ message: "Detailed question", toolCallId: "id" }),
+      );
     });
 
     it("falls back to 'Question' when both title and message are missing", async () => {
       const { tool, ctx } = getToolAndMockCtx();
       await tool.execute("id", { method: "confirm" }, undefined, undefined, ctx);
-      expect(ctx.ui.confirm).toHaveBeenCalledWith("Question", "");
+      // confirm now also threads toolCallId via 3rd arg.
+      expect(ctx.ui.confirm).toHaveBeenCalledWith(
+        "Question",
+        "",
+        expect.objectContaining({ toolCallId: "id" }),
+      );
     });
 
     it("parses options from JSON string", async () => {
       const { tool, ctx } = getToolAndMockCtx();
       await tool.execute("id", { method: "select", title: "Pick", options: '["A", "B"]' }, undefined, undefined, ctx);
-      expect(ctx.ui.select).toHaveBeenCalledWith("Pick", ["A", "B"], undefined);
+      // No message, no other opts — only toolCallId.
+      expect(ctx.ui.select).toHaveBeenCalledWith(
+        "Pick",
+        ["A", "B"],
+        expect.objectContaining({ toolCallId: "id" }),
+      );
     });
 
     it("throws when select reaches execute with unparseable options string", async () => {
@@ -160,6 +191,19 @@ describe("registerAskUserTool", () => {
       return pi.registerTool.mock.calls[0][0];
     }
 
+    it("leaves empty {} args untouched (no synthetic method) so schema rejection still fires", () => {
+      // Regression test for the Opus-emits-empty-args bug seen in session 019dd05c.
+      // Our rescue layer must NOT silently fabricate a method/title when there is
+      // nothing to rescue — the framework's schema validator must still reject {}
+      // so the model is forced to retry with valid args.
+      const tool = getTool();
+      const result = tool.prepareArguments({});
+      expect(result.method).toBeUndefined();
+      expect(result.title).toBeUndefined();
+      expect(result.questions).toBeUndefined();
+      expect(Object.keys(result).filter((k) => k !== "__normalizations")).toHaveLength(0);
+    });
+
     it("parses stringified options array", () => {
       const tool = getTool();
       const result = tool.prepareArguments({ method: "select", title: "Pick", options: '["A", "B"]' });

package/packages/extension/src/__tests__/multiselect-dashboard-routing.test.ts

@@ -0,0 +1,203 @@
+/**
+ * Tests for the bridge's `ctx.ui.multiselect` PromptBus patch and the TUI
+ * adapter's multiselect handling. The patch lives in `bridge.ts` but is
+ * exercised here through a small reproduction harness so we don't pull in
+ * the full session lifecycle.
+ *
+ * See change: fix-multiselect-auto-cancel-on-dashboard.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { decodeMultiselectAnswer } from "../multiselect-decode.js";
+
+// ──────────────────────────────────────────────────────────────────────
+// `decodeMultiselectAnswer` — pure helper used by both the runtime patch
+// and the TUI adapter's response encoding round-trip.
+// ──────────────────────────────────────────────────────────────────────
+
+describe("decodeMultiselectAnswer", () => {
+  it("resolves cancellation as undefined", () => {
+    expect(decodeMultiselectAnswer({ cancelled: true })).toBeUndefined();
+    expect(decodeMultiselectAnswer({ cancelled: true, answer: '["x"]' })).toBeUndefined();
+  });
+
+  it("resolves successful selection from JSON-encoded array", () => {
+    expect(decodeMultiselectAnswer({ cancelled: false, answer: '["a","c"]' })).toEqual(["a", "c"]);
+  });
+
+  it("resolves empty selection as []", () => {
+    expect(decodeMultiselectAnswer({ cancelled: false, answer: "[]" })).toEqual([]);
+  });
+
+  it("resolves null / undefined / empty answer as [] (not undefined)", () => {
+    expect(decodeMultiselectAnswer({ cancelled: false, answer: undefined })).toEqual([]);
+    expect(decodeMultiselectAnswer({ cancelled: false, answer: "" })).toEqual([]);
+  });
+
+  it("resolves unparseable JSON as [] without throwing", () => {
+    expect(decodeMultiselectAnswer({ cancelled: false, answer: "not-json" })).toEqual([]);
+    expect(decodeMultiselectAnswer({ cancelled: false, answer: "{not:array}" })).toEqual([]);
+  });
+
+  it("resolves valid JSON that is not an array as []", () => {
+    expect(decodeMultiselectAnswer({ cancelled: false, answer: '"just-a-string"' })).toEqual([]);
+    expect(decodeMultiselectAnswer({ cancelled: false, answer: '{"k":"v"}' })).toEqual([]);
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────
+// Bridge patch reproduction — emulate the assignment block in
+// `bridge.ts:935-948` plus the new multiselect arm and assert behavior.
+// We cannot import `bridge.ts` directly (it has heavy session-lifecycle
+// imports), so we reproduce the assignment closure here. The closure
+// shape MUST match `bridge.ts` exactly; if `bridge.ts` drifts, the
+// regression guard test (see "ctx.ui.multiselect is assigned by the
+// bridge patch block" below) re-loads the bridge source and asserts
+// the assignment exists.
+// ──────────────────────────────────────────────────────────────────────
+
+interface BusRequestArgs {
+  pipeline: string;
+  type: string;
+  question: string;
+  options?: string[];
+  metadata?: Record<string, unknown>;
+}
+
+interface FakeBus {
+  request: (args: BusRequestArgs) => Promise<{ cancelled?: boolean; answer?: string }>;
+}
+
+function applyMultiselectPatch(
+  ctx: { ui: Record<string, any> },
+  bus: FakeBus,
+): void {
+  const existing = (ctx.ui as any).multiselect;
+  if (typeof existing === "function") {
+    // eslint-disable-next-line no-console
+    console.warn("[bridge] ctx.ui.multiselect already exists — overriding for PromptBus routing");
+  }
+  (ctx.ui as any).multiselect = (title: string, options: string[], opts?: { message?: string }) =>
+    bus.request({
+      pipeline: "command",
+      type: "multiselect",
+      question: title,
+      options,
+      metadata: opts?.message ? { message: opts.message } : undefined,
+    }).then((r) => decodeMultiselectAnswer(r));
+}
+
+describe("bridge ctx.ui.multiselect patch", () => {
+  let ctx: { ui: Record<string, any> };
+  let bus: FakeBus;
+  let requestSpy: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    requestSpy = vi.fn();
+    bus = { request: requestSpy as any };
+    ctx = { ui: {} };
+  });
+
+  it("assigns ctx.ui.multiselect as a function after the patch runs", () => {
+    expect(typeof ctx.ui.multiselect).toBe("undefined");
+    applyMultiselectPatch(ctx, bus);
+    expect(typeof ctx.ui.multiselect).toBe("function");
+  });
+
+  it("dispatches bus.request with the right shape on call", async () => {
+    applyMultiselectPatch(ctx, bus);
+    requestSpy.mockResolvedValue({ cancelled: false, answer: '["a","c"]' });
+
+    const result = await ctx.ui.multiselect("Pick", ["a", "b", "c"], { message: "ctx" });
+
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+    expect(requestSpy).toHaveBeenCalledWith({
+      pipeline: "command",
+      type: "multiselect",
+      question: "Pick",
+      options: ["a", "b", "c"],
+      metadata: { message: "ctx" },
+    });
+    expect(result).toEqual(["a", "c"]);
+  });
+
+  it("omits metadata when no message is provided", async () => {
+    applyMultiselectPatch(ctx, bus);
+    requestSpy.mockResolvedValue({ cancelled: false, answer: "[]" });
+
+    await ctx.ui.multiselect("Pick", ["a", "b"]);
+
+    expect(requestSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ metadata: undefined }),
+    );
+  });
+
+  it("resolves successful selection through the decoder", async () => {
+    applyMultiselectPatch(ctx, bus);
+    requestSpy.mockResolvedValue({ cancelled: false, answer: '["a","c"]' });
+    await expect(ctx.ui.multiselect("t", ["a", "b", "c"])).resolves.toEqual(["a", "c"]);
+  });
+
+  it("resolves empty selection as []", async () => {
+    applyMultiselectPatch(ctx, bus);
+    requestSpy.mockResolvedValue({ cancelled: false, answer: "[]" });
+    await expect(ctx.ui.multiselect("t", ["a"])).resolves.toEqual([]);
+  });
+
+  it("resolves cancellation as undefined", async () => {
+    applyMultiselectPatch(ctx, bus);
+    requestSpy.mockResolvedValue({ cancelled: true });
+    await expect(ctx.ui.multiselect("t", ["a"])).resolves.toBeUndefined();
+  });
+
+  it("resolves unparseable answer as [] without throwing", async () => {
+    applyMultiselectPatch(ctx, bus);
+    requestSpy.mockResolvedValue({ cancelled: false, answer: "not-json" });
+    await expect(ctx.ui.multiselect("t", ["a"])).resolves.toEqual([]);
+  });
+
+  it("warns when ctx.ui.multiselect was already a function before the patch", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    ctx.ui.multiselect = () => Promise.resolve(["pre-existing"]);
+
+    applyMultiselectPatch(ctx, bus);
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("already exists"),
+    );
+    // The patch still wins — subsequent calls go through bus.request.
+    requestSpy.mockResolvedValue({ cancelled: false, answer: '["winner"]' });
+    return ctx.ui.multiselect("t", ["a"]).then((r: any) => {
+      expect(r).toEqual(["winner"]);
+      expect(requestSpy).toHaveBeenCalled();
+      warnSpy.mockRestore();
+    });
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────
+// Source regression guard — re-load bridge.ts as text and assert the
+// multiselect patch line exists. Mirrors `no-direct-process-kill.test.ts`
+// pattern: textual scan over a single file, fail with file:line if the
+// expected snippet is missing or moved.
+// ──────────────────────────────────────────────────────────────────────
+
+describe("bridge.ts source regression guard", () => {
+  it("contains the ctx.ui.multiselect PromptBus assignment", async () => {
+    const fs = await import("node:fs");
+    const path = await import("node:path");
+    const url = await import("node:url");
+    const here = path.dirname(url.fileURLToPath(import.meta.url));
+    const bridgePath = path.resolve(here, "../bridge.ts");
+    const src = fs.readFileSync(bridgePath, "utf8");
+
+    // The assignment must mention `multiselect` as a key on ctx.ui AND
+    // dispatch through bus.request with type:"multiselect".
+    expect(src).toMatch(/\(ctx\.ui as any\)\.multiselect\s*=/);
+    expect(src).toMatch(/type:\s*"multiselect"/);
+  });
+
+  // Note: the previous-change assertions about `custom: ctx.ui.custom?.bind(...)`
+  // capture and the TUI `prompt.type === "multiselect"` arm were removed by
+  // change `fix-multiselect-tui-arm-self-cancel`. The inverse-guard for that
+  // removal lives in `no-tui-multiselect-arm-regression.test.ts`.
+});

package/packages/extension/src/__tests__/multiselect-polyfill.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Tests for `polyfillMultiselect`'s fallback chain. After the
+ * fix-multiselect-auto-cancel-on-dashboard change, the polyfill prefers a
+ * bridge-patched `ctx.ui.multiselect` (the PromptBus path that surfaces in
+ * the dashboard browser) and falls back to the legacy `ctx.ui.custom` +
+ * `MultiSelectList` overlay only when the patch is absent (older pi
+ * versions or non-bridge embeddings).
+ *
+ * See change: fix-multiselect-auto-cancel-on-dashboard.
+ */
+import { describe, it, expect, vi } from "vitest";
+import { polyfillMultiselect } from "../multiselect-polyfill.js";
+
+describe("polyfillMultiselect — fallback chain", () => {
+  it("delegates to ctx.ui.multiselect when present (primary, bus-routed path)", async () => {
+    const multiselectFn = vi.fn().mockResolvedValue(["a"]);
+    const customFn = vi.fn();
+    const ctx = {
+      ui: {
+        multiselect: multiselectFn,
+        custom: customFn,
+      },
+    };
+
+    const result = await polyfillMultiselect(ctx as any, "Pick", ["a", "b"]);
+
+    expect(result).toEqual(["a"]);
+    expect(multiselectFn).toHaveBeenCalledTimes(1);
+    expect(multiselectFn).toHaveBeenCalledWith("Pick", ["a", "b"], undefined);
+    expect(customFn).not.toHaveBeenCalled();
+  });
+
+  it("forwards opts.message to ctx.ui.multiselect when present", async () => {
+    const multiselectFn = vi.fn().mockResolvedValue([]);
+    const ctx = { ui: { multiselect: multiselectFn, custom: vi.fn() } };
+
+    await polyfillMultiselect(ctx as any, "Pick", ["a"], { message: "ctx" });
+
+    expect(multiselectFn).toHaveBeenCalledWith("Pick", ["a"], { message: "ctx" });
+  });
+
+  it("propagates undefined (cancellation) through the primary path", async () => {
+    const multiselectFn = vi.fn().mockResolvedValue(undefined);
+    const ctx = { ui: { multiselect: multiselectFn, custom: vi.fn() } };
+
+    await expect(polyfillMultiselect(ctx as any, "t", ["a"])).resolves.toBeUndefined();
+  });
+
+  it("falls back to ctx.ui.custom when ctx.ui.multiselect is absent (TUI path)", async () => {
+    let capturedDone: ((r: string[] | undefined) => void) | undefined;
+    const customFn = vi.fn().mockImplementation((factory: any) => {
+      return new Promise<string[] | undefined>((resolve) => {
+        const done = (r: string[] | undefined) => resolve(r);
+        capturedDone = done;
+        const component = factory({}, {}, {}, done);
+        // Simulate user confirming after the factory wires the component.
+        component?.onConfirm?.(["b"]);
+      });
+    });
+    const ctx = { ui: { custom: customFn } };
+
+    const result = await polyfillMultiselect(ctx as any, "Pick", ["a", "b"]);
+
+    expect(result).toEqual(["b"]);
+    expect(customFn).toHaveBeenCalledTimes(1);
+    expect(capturedDone).toBeTypeOf("function");
+  });
+
+  it("falls back to ctx.ui.custom and resolves undefined on cancel", async () => {
+    const customFn = vi.fn().mockImplementation((factory: any) => {
+      return new Promise<string[] | undefined>((resolve) => {
+        const component = factory({}, {}, {}, (r: any) => resolve(r));
+        component?.onCancel?.();
+      });
+    });
+    const ctx = { ui: { custom: customFn } };
+
+    await expect(polyfillMultiselect(ctx as any, "Pick", ["a"])).resolves.toBeUndefined();
+  });
+
+  it("does NOT fall back to ctx.ui.custom when ctx.ui.multiselect resolves to []", async () => {
+    // Empty selection is a valid answer — must NOT trigger the legacy fallback.
+    const multiselectFn = vi.fn().mockResolvedValue([]);
+    const customFn = vi.fn();
+    const ctx = { ui: { multiselect: multiselectFn, custom: customFn } };
+
+    const result = await polyfillMultiselect(ctx as any, "t", ["a"]);
+
+    expect(result).toEqual([]);
+    expect(customFn).not.toHaveBeenCalled();
+  });
+});

package/packages/extension/src/__tests__/no-tui-multiselect-arm-regression.test.ts

@@ -0,0 +1,81 @@
+/**
+ * Repo-level invariant: `packages/extension/src/bridge.ts` MUST NOT
+ * contain the co-occurrence of two substrings:
+ *
+ *   1. `originals.custom`
+ *   2. `prompt.type === "multiselect"`
+ *
+ * If both appear in the same file, a contributor has (re)introduced the
+ * TUI PromptBus-adapter multiselect arm that was removed by change
+ * `fix-multiselect-tui-arm-self-cancel`. The arm is forbidden because
+ * pi 0.70's RPC mode (the only mode dashboard headless sessions run
+ * under) defines `ExtensionUIContext.custom` as an unconditional no-op
+ * (`async custom() { return undefined; }`, see
+ * `~/.nvm/.../@mariozechner/pi-coding-agent/dist/modes/rpc/rpc-mode.js`
+ * lines 150-153). Awaiting that primitive resolves to `undefined`
+ * synchronously, and the TUI arm's `bus.respond({ cancelled: true,
+ * source: "tui" })` triggers the PromptBus's first-response-wins
+ * dismissal — which auto-cancels the dashboard's already-rendered
+ * `MultiselectRenderer` within ~1 event-loop tick.
+ *
+ * The bus-routed `(ctx.ui as any).multiselect = (...) => bus.request(...)`
+ * patch site uses the substring `type: "multiselect"` (object-literal
+ * shape), not `prompt.type === "multiselect"` (equality-check shape),
+ * so it is unaffected by this lint.
+ *
+ * To remove a legitimate `originals.custom` reference (e.g. for a
+ * future use that does not include multiselect prompt routing), keep
+ * one substring and ensure the other does not co-occur.
+ *
+ * See change: fix-multiselect-tui-arm-self-cancel.
+ */
+import { describe, it, expect } from "vitest";
+import fs from "node:fs/promises";
+import path from "node:path";
+import url from "node:url";
+
+const FORBIDDEN_A = "originals.custom";
+const FORBIDDEN_B = 'prompt.type === "multiselect"';
+
+function findLineNumbers(src: string, needle: string): number[] {
+  const lines = src.split(/\r?\n/);
+  const hits: number[] = [];
+  lines.forEach((line, idx) => {
+    if (line.includes(needle)) hits.push(idx + 1);
+  });
+  return hits;
+}
+
+describe("no TUI multiselect arm regression in bridge.ts", () => {
+  it("bridge.ts MUST NOT contain both `originals.custom` and `prompt.type === \"multiselect\"`", async () => {
+    const here = path.dirname(url.fileURLToPath(import.meta.url));
+    const bridgePath = path.resolve(here, "..", "bridge.ts");
+    const src = await fs.readFile(bridgePath, "utf-8");
+
+    const hasA = src.includes(FORBIDDEN_A);
+    const hasB = src.includes(FORBIDDEN_B);
+
+    if (hasA && hasB) {
+      const linesA = findLineNumbers(src, FORBIDDEN_A);
+      const linesB = findLineNumbers(src, FORBIDDEN_B);
+      const msg =
+        `Forbidden co-occurrence in ${path.relative(process.cwd(), bridgePath)}:\n` +
+        `  - "${FORBIDDEN_A}" found on line(s): ${linesA.join(", ")}\n` +
+        `  - "${FORBIDDEN_B}" found on line(s): ${linesB.join(", ")}\n` +
+        `\n` +
+        `This pattern was removed by change "fix-multiselect-tui-arm-self-cancel".\n` +
+        `pi 0.70 RPC mode's ctx.ui.custom is a no-op, so a TUI multiselect\n` +
+        `arm that awaits originals.custom auto-cancels the dashboard-rendered\n` +
+        `dialog within ~1 event-loop tick. The bus-routed ctx.ui.multiselect\n` +
+        `patch + DashboardDefaultAdapter handle multiselect end-to-end without\n` +
+        `any TUI arm participation. See:\n` +
+        `  openspec/changes/archive/<date>-fix-multiselect-tui-arm-self-cancel/\n` +
+        `(or openspec/changes/fix-multiselect-tui-arm-self-cancel/ if not yet archived).`;
+      expect.fail(msg);
+    }
+
+    // Guardrail: at least one of the two substrings absent (we already
+    // assert above that both-present is illegal). Either-alone is fine.
+    expect(hasA && hasB).toBe(false);
+  });
+});

package/packages/extension/src/__tests__/openspec-activity-detector.test.ts

@@ -229,4 +229,41 @@ describe("detectOpenSpecActivity", () => {
       expect(result).toBeNull();
     });
   });
+
+  describe("flag-shaped change names", () => {
+    it("returns null for `openspec archive --help`", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: "openspec archive --help",
+      });
+      expect(result).toBeNull();
+    });
+
+    it("returns null for `openspec new change --help`", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: "openspec new change --help",
+      });
+      expect(result).toBeNull();
+    });
+
+    it("returns null when --change is followed by another flag", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: "openspec foo --change --help",
+      });
+      expect(result).toBeNull();
+    });
+
+    it("still extracts a real change name from `openspec archive add-auth`", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: "openspec archive add-auth",
+      });
+      expect(result).toEqual({ changeName: "add-auth", isActive: true });
+    });
+
+    it("still extracts a quoted change name from `openspec archive \"add-auth\"`", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: 'openspec archive "add-auth"',
+      });
+      expect(result).toEqual({ changeName: "add-auth", isActive: true });
+    });
+  });
 });