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

package/packages/extension/src/__tests__/ui-modules.test.ts

@@ -0,0 +1,293 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { refreshUiModules, subscribeUiInvalidate, handleUiManagement, type UiModulesBridgeCtx } from "../ui-modules.js";
+import type { ExtensionUiModule } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+
+/**
+ * Minimal bus + ctx harness. The real bridge wires this up via `pi.events`
+ * (a real `EventEmitter`); the contract this module relies on is `on` /
+ * `emit`, so a hand-rolled bus is sufficient for tests.
+ */
+function createTestCtx(sessionId = "s1") {
+  const listeners = new Map<string, Array<(...args: any[]) => any>>();
+  const sent: any[] = [];
+
+  const ctx: UiModulesBridgeCtx & { _sent: any[]; _listeners: typeof listeners } = {
+    pi: {
+      events: {
+        on: vi.fn((event: string, fn: (...args: any[]) => any) => {
+          if (!listeners.has(event)) listeners.set(event, []);
+          listeners.get(event)!.push(fn);
+        }) as any,
+        emit: vi.fn((event: string, ...args: any[]) => {
+          const handlers = listeners.get(event) ?? [];
+          for (const h of handlers) h(...args);
+        }) as any,
+      },
+    },
+    connection: {
+      send: vi.fn((msg: unknown) => {
+        sent.push(msg);
+      }) as any,
+    },
+    getSessionId: () => sessionId,
+    _sent: sent,
+    _listeners: listeners,
+  };
+  return ctx;
+}
+
+const sampleModule = (id: string, command: string): ExtensionUiModule => ({
+  kind: "management-modal",
+  id,
+  command,
+  title: id,
+  view: { kind: "table", dataEvent: `${id}:rows`, fields: [{ key: "id", label: "ID", kind: "text" }] },
+});
+
+describe("refreshUiModules", () => {
+  it("emits ui:list-modules and forwards collected modules as ui_modules_list", () => {
+    const ctx = createTestCtx("session-A");
+    ctx._listeners.set("ui:list-modules", [
+      (probe: { modules: ExtensionUiModule[] }) => {
+        probe.modules.push(sampleModule("judo-status", "/judo:status"));
+        probe.modules.push(sampleModule("ragger-workspaces", "/ragger:workspaces"));
+      },
+    ]);
+
+    refreshUiModules(ctx);
+
+    expect(ctx.pi.events!.emit).toHaveBeenCalledWith("ui:list-modules", expect.any(Object));
+    expect(ctx._sent).toHaveLength(1);
+    expect(ctx._sent[0]).toMatchObject({
+      type: "ui_modules_list",
+      sessionId: "session-A",
+      modules: [
+        expect.objectContaining({ id: "judo-status", command: "/judo:status" }),
+        expect.objectContaining({ id: "ragger-workspaces", command: "/ragger:workspaces" }),
+      ],
+    });
+  });
+
+  it("forwards an empty modules list when no listeners push", () => {
+    const ctx = createTestCtx();
+    refreshUiModules(ctx);
+    expect(ctx._sent).toEqual([{ type: "ui_modules_list", sessionId: "s1", modules: [] }]);
+  });
+
+  it("last-write-wins on duplicate id and warns once per collision", () => {
+    const ctx = createTestCtx();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      ctx._listeners.set("ui:list-modules", [
+        (probe: { modules: ExtensionUiModule[] }) => {
+          // First push wins on insertion order; second push for same id replaces it.
+          const a: ExtensionUiModule = { ...sampleModule("dup", "/a"), title: "First" };
+          const b: ExtensionUiModule = { ...sampleModule("dup", "/b"), title: "Second" };
+          const c: ExtensionUiModule = { ...sampleModule("dup", "/c"), title: "Third" };
+          probe.modules.push(a, b, c);
+        },
+      ]);
+
+      refreshUiModules(ctx);
+
+      const sent = ctx._sent[0] as { modules: ExtensionUiModule[] };
+      expect(sent.modules).toHaveLength(1);
+      expect(sent.modules[0]).toMatchObject({ id: "dup", title: "Third", command: "/c" });
+      // Two collisions reported, but only one warning per id.
+      expect(warn).toHaveBeenCalledTimes(1);
+      expect(warn.mock.calls[0]?.[0]).toMatch(/duplicate module id "dup"/);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it("ignores modules with missing/empty id", () => {
+    const ctx = createTestCtx();
+    ctx._listeners.set("ui:list-modules", [
+      (probe: { modules: any[] }) => {
+        probe.modules.push({ kind: "management-modal", id: "", command: "/x", title: "x", view: { kind: "table" } });
+        probe.modules.push({ kind: "management-modal", command: "/y", title: "y", view: { kind: "table" } });
+        probe.modules.push(sampleModule("ok", "/ok"));
+      },
+    ]);
+
+    refreshUiModules(ctx);
+    const sent = ctx._sent[0] as { modules: ExtensionUiModule[] };
+    expect(sent.modules.map((m) => m.id)).toEqual(["ok"]);
+  });
+
+  it("does not throw or send when pi.events is missing", () => {
+    const ctx = createTestCtx();
+    ctx.pi = { events: undefined as any };
+    expect(() => refreshUiModules(ctx)).not.toThrow();
+    expect(ctx._sent).toHaveLength(0);
+  });
+
+  it("absorbs handler errors without breaking the bridge", () => {
+    const ctx = createTestCtx();
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    try {
+      ctx._listeners.set("ui:list-modules", [
+        () => {
+          throw new Error("listener exploded");
+        },
+      ]);
+      expect(() => refreshUiModules(ctx)).not.toThrow();
+      expect(errSpy).toHaveBeenCalled();
+      expect(ctx._sent).toHaveLength(0);
+    } finally {
+      errSpy.mockRestore();
+    }
+  });
+});
+
+describe("subscribeUiInvalidate", () => {
+  it("re-runs the probe whenever ui:invalidate fires (leading + trailing throttle, see Phase 2)", () => {
+    vi.useFakeTimers();
+    try {
+      const ctx = createTestCtx();
+      ctx._listeners.set("ui:list-modules", [
+        (probe: { modules: ExtensionUiModule[] }) => {
+          probe.modules.push(sampleModule("a", "/a"));
+        },
+      ]);
+
+      subscribeUiInvalidate(ctx);
+      // First emit triggers a leading-edge probe immediately.
+      ctx.pi.events!.emit("ui:invalidate", { id: "a" });
+      expect(ctx._sent).toHaveLength(1);
+      expect((ctx._sent[0] as any).type).toBe("ui_modules_list");
+
+      // Second emit within the throttle window coalesces into a trailing-edge
+      // probe; advance timers past the 50ms window to flush it.
+      ctx.pi.events!.emit("ui:invalidate", {});
+      vi.advanceTimersByTime(100);
+      expect(ctx._sent).toHaveLength(2);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("is a no-op when pi.events.on is missing", () => {
+    const ctx = createTestCtx();
+    ctx.pi = { events: { emit: vi.fn() as any } as any };
+    expect(() => subscribeUiInvalidate(ctx)).not.toThrow();
+  });
+});
+
+describe("handleUiManagement", () => {
+  it("re-emits the event on pi.events with action and _reply injected, and forwards synchronous data.items", () => {
+    const ctx = createTestCtx("S");
+    ctx._listeners.set("judo:status-rows", [
+      (data: { action: string; items?: unknown[] }) => {
+        expect(data.action).toBe("list");
+        data.items = [{ id: 1 }, { id: 2 }];
+      },
+    ]);
+
+    handleUiManagement(ctx, {
+      type: "ui_management",
+      sessionId: "S",
+      action: "list",
+      event: "judo:status-rows",
+    });
+
+    expect(ctx.pi.events!.emit).toHaveBeenCalledWith("judo:status-rows", expect.any(Object));
+    expect(ctx._sent).toEqual([
+      { type: "ui_data_list", sessionId: "S", event: "judo:status-rows", items: [{ id: 1 }, { id: 2 }] },
+    ]);
+  });
+
+  it("supports async _reply path (extension calls _reply asynchronously)", () => {
+    const ctx = createTestCtx();
+    ctx._listeners.set("judo:rows", [
+      (data: { _reply: (items: unknown[]) => void }) => {
+        // Simulate async: call _reply later in this tick.
+        setTimeout(() => data._reply([{ id: 7 }]), 0);
+      },
+    ]);
+
+    handleUiManagement(ctx, { type: "ui_management", sessionId: "s1", action: "list", event: "judo:rows" });
+    // Synchronous fast-path didn't fire because data.items wasn't set.
+    expect(ctx._sent).toHaveLength(0);
+    return new Promise<void>((resolve) => {
+      setTimeout(() => {
+        expect(ctx._sent).toEqual([
+          { type: "ui_data_list", sessionId: "s1", event: "judo:rows", items: [{ id: 7 }] },
+        ]);
+        resolve();
+      }, 5);
+    });
+  });
+
+  it("does not double-send if both data.items is set and _reply is called", () => {
+    const ctx = createTestCtx();
+    ctx._listeners.set("e", [
+      (data: { _reply: (items: unknown[]) => void; items?: unknown[] }) => {
+        data._reply([1, 2]);
+        data.items = [3, 4];
+      },
+    ]);
+    handleUiManagement(ctx, { type: "ui_management", sessionId: "s1", action: "list", event: "e" });
+    // _reply ran synchronously inside the emit; data.items fast-path is gated by `replied`.
+    expect(ctx._sent).toHaveLength(1);
+    expect((ctx._sent[0] as any).items).toEqual([1, 2]);
+  });
+
+  it("does NOT send a ui_data_list for fire-and-forget actions (no items, no _reply)", () => {
+    const ctx = createTestCtx();
+    ctx._listeners.set("judo:delete-row", [() => { /* side-effect only */ }]);
+    handleUiManagement(ctx, {
+      type: "ui_management",
+      sessionId: "s1",
+      action: "delete",
+      event: "judo:delete-row",
+      params: { id: 42 },
+    });
+    expect(ctx._sent).toHaveLength(0);
+  });
+
+  it("forwards the action and params verbatim to listeners", () => {
+    const ctx = createTestCtx();
+    let captured: any = null;
+    ctx._listeners.set("e", [(data: any) => { captured = { ...data }; }]);
+    handleUiManagement(ctx, {
+      type: "ui_management",
+      sessionId: "s1",
+      action: "delete",
+      event: "e",
+      params: { id: 42, force: true },
+    });
+    expect(captured).toMatchObject({ action: "delete", id: 42, force: true });
+    expect(typeof captured._reply).toBe("function");
+  });
+
+  it("absorbs handler errors without sending data", () => {
+    const ctx = createTestCtx();
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    try {
+      ctx._listeners.set("explode", [() => { throw new Error("boom"); }]);
+      expect(() => handleUiManagement(ctx, { type: "ui_management", sessionId: "s1", action: "list", event: "explode" })).not.toThrow();
+      expect(errSpy).toHaveBeenCalled();
+      expect(ctx._sent).toHaveLength(0);
+    } finally {
+      errSpy.mockRestore();
+    }
+  });
+});
+
+describe("Bridge invariants", () => {
+  it("ui-modules.ts does not import pi.newSession / ctx.fork / ctx.switchSession", async () => {
+    // Mirrors the contract checked by `no-session-replacement-calls.test.ts`,
+    // but localized to the new module so a regression is caught at unit-test
+    // granularity in addition to the global lint test.
+    const fs = await import("node:fs/promises");
+    const url = await import("node:url");
+    const path = await import("node:path");
+    const here = path.dirname(url.fileURLToPath(import.meta.url));
+    const src = await fs.readFile(path.join(here, "..", "ui-modules.ts"), "utf8");
+    expect(src).not.toMatch(/pi\.newSession\s*\(/);
+    expect(src).not.toMatch(/ctx\.fork\s*\(/);
+    expect(src).not.toMatch(/ctx\.switchSession\s*\(/);
+  });
+});

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

@@ -6,61 +6,93 @@
  * register ask_user. Runtime registration bypasses detectExtensionConflicts.
  */
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
+import { Type } from "typebox";
+import { polyfillMultiselect } from "./multiselect-polyfill.js";
 
 // ──────────────────────────────────────────────────────────────────────────
-// Single-question schema arms (reused inside the batch arm's questions array)
+// Schema definition
+//
+// IMPORTANT: We use a single flat `Type.Object` at the root (rather than a
+// `Type.Union` of per-method object arms) so the generated JSON Schema has
+// `"type": "object"` at the root.
+//
+// Rationale: OpenAI's function-calling validator (and especially the strict
+// mode used by GPT-4.1+/GPT-5.x/Codex/Responses API) REQUIRES the parameters
+// schema to be an object at the root. A `Type.Union` produces `anyOf` at the
+// root with no `type` field, which Anthropic accepts but OpenAI rejects with:
+//   "Invalid schema for function 'ask_user': schema must be a JSON Schema
+//    of 'type: \"object\"', got 'type: \"None\"'."
+//
+// Per-method validation (which fields are required for which `method`) is
+// enforced at runtime by `prepareArguments` (rescue/normalization) and the
+// `execute` switch below — the JSON Schema only needs to describe the union
+// of allowed fields.
 // ──────────────────────────────────────────────────────────────────────────
 
-const ConfirmSchema = Type.Object({
-  method: Type.Literal("confirm", { description: "Yes/no question" }),
-  title: Type.String({ description: "The question to confirm" }),
-  message: Type.Optional(Type.String({ description: "Additional context or detailed question body" })),
-});
-
-const SelectSchema = Type.Object({
-  method: Type.Literal("select", { description: "Pick one option from a list" }),
-  title: Type.String({ description: "Short title for the question" }),
-  options: Type.Array(Type.String(), {
-    minItems: 2,
-    description: "Options the user chooses between (at least 2; use 'confirm' for yes/no)",
-  }),
-  message: Type.Optional(Type.String({ description: "Additional context" })),
-});
-
-const MultiselectSchema = Type.Object({
-  method: Type.Literal("multiselect", { description: "Pick multiple options from a list" }),
-  title: Type.String({ description: "Short title for the question" }),
-  options: Type.Array(Type.String(), {
-    minItems: 1,
-    description: "Options the user can multi-select",
-  }),
-  message: Type.Optional(Type.String({ description: "Additional context" })),
-});
-
-const InputSchema = Type.Object({
-  method: Type.Literal("input", { description: "Free-text input" }),
-  title: Type.String({ description: "Short title for the question" }),
-  placeholder: Type.Optional(Type.String({ description: "Placeholder text for the input field" })),
-  message: Type.Optional(Type.String({ description: "Additional context" })),
-});
-
-// Sub-question union deliberately omits the batch arm (no nesting).
-const SubQuestionSchema = Type.Union([ConfirmSchema, SelectSchema, MultiselectSchema, InputSchema], {
-  description: "A single question inside a batch. Must not itself be a batch.",
-});
-
-const BatchSchema = Type.Object({
-  method: Type.Literal("batch", {
-    description: "Ask multiple related questions in one call; answers are returned as an ordered array.",
-  }),
-  title: Type.String({ description: "Header shown above the sequence of dialogs" }),
-  questions: Type.Array(SubQuestionSchema, {
-    minItems: 1,
-    description: "One or more sub-questions (confirm/select/multiselect/input). Cannot nest batch.",
-  }),
-  message: Type.Optional(Type.String({ description: "Additional context for the whole batch" })),
-});
+const MethodEnum = Type.Union(
+  [
+    Type.Literal("confirm"),
+    Type.Literal("select"),
+    Type.Literal("multiselect"),
+    Type.Literal("input"),
+    Type.Literal("batch"),
+  ],
+  {
+    description:
+      "Question kind. 'confirm' = yes/no, 'select' = pick one of options[], 'multiselect' = pick many of options[], 'input' = free text, 'batch' = ask several questions in one call (provide questions[]).",
+  },
+);
+
+// Sub-question schema for batch.method — flat object (root: type=object) so
+// the emitted JSON Schema stays OpenAI-compatible at every level.
+//
+// IMPORTANT: this object MUST NOT carry a root-level `oneOf` / `anyOf` /
+// `allOf` / `enum` / `not`. OpenAI strict mode (GPT-4.1+, GPT-5.x, Codex,
+// Responses API) explicitly rejects those at *any* schema's top level
+// with: "schema must have type 'object' and not have 'oneOf' / 'anyOf' /
+// 'allOf' / 'enum' / 'not' at the top level." An earlier draft of
+// fix-multiselect-auto-cancel-on-dashboard tried to add a body-level
+// `oneOf` discriminator to restore Anthropic's per-arm strictness, but
+// real-world OpenAI gpt-5 rejected it; the fallback path documented in
+// tasks.md §9.7 was taken — Layer 2 dropped, Layer 1 ships alone.
+//
+// Per-method requirements (select/multiselect need `options`, batch
+// needs `questions[]`, etc.) are enforced exclusively by
+// `prepareArguments` rescue + the `execute` switch's runtime guards.
+// Sub-questions cannot themselves be a batch (no nesting); enforced at
+// runtime in `execute`.
+//
+// See change: fix-multiselect-auto-cancel-on-dashboard.
+const SubQuestionSchema = Type.Object(
+  {
+    method: Type.Union(
+      [
+        Type.Literal("confirm"),
+        Type.Literal("select"),
+        Type.Literal("multiselect"),
+        Type.Literal("input"),
+      ],
+      { description: "Sub-question kind. Cannot be 'batch' (no nesting)." },
+    ),
+    title: Type.String({ description: "Short title / question text for this sub-question" }),
+    options: Type.Optional(
+      Type.Array(Type.String(), {
+        description:
+          "Required for 'select' (>=2) and 'multiselect' (>=1). Plain string[] — not [{label,value}].",
+      }),
+    ),
+    placeholder: Type.Optional(
+      Type.String({ description: "Placeholder for 'input' method" }),
+    ),
+    message: Type.Optional(
+      Type.String({ description: "Additional context for this sub-question" }),
+    ),
+  },
+  {
+    description:
+      "A single question inside a batch. Must not itself be a batch.",
+  },
+);
 
 // ──────────────────────────────────────────────────────────────────────────
 // Argument rescue helpers
@@ -121,7 +153,7 @@ export function registerAskUserTool(pi: ExtensionAPI): void {
     name: "ask_user",
     label: "Ask User",
     description:
-      "Ask the user a question interactively. Use this when you need clarification, confirmation, or a choice from the user before proceeding.",
+      "Ask the user a question interactively. Use this when you need clarification, confirmation, or a choice from the user before proceeding. UI provides a Select all toggle; do not add one.",
     promptSnippet:
       "Ask the user interactive questions (confirm, select, multiselect, input, or batch — multiple related questions at once)",
     promptGuidelines: [
@@ -131,9 +163,67 @@ export function registerAskUserTool(pi: ExtensionAPI): void {
       "Do not nest batches. Send `options` as a plain string[] — not [{label, value}].",
       "This applies to all workflows including OpenSpec, planning, and any situation where you need user input before proceeding.",
     ],
-    parameters: Type.Union(
-      [ConfirmSchema, SelectSchema, MultiselectSchema, InputSchema, BatchSchema],
-      { description: "Parameters for ask_user, discriminated by method." },
+    // Flat object schema (root: type=object) for OpenAI strict-mode
+    // compatibility.
+    //
+    // IMPORTANT: this object MUST NOT carry a root-level `oneOf` / `anyOf`
+    // / `allOf` / `enum` / `not`. OpenAI strict mode (GPT-4.1+, GPT-5.x,
+    // Codex, Responses API) explicitly rejects those at the top level with:
+    // "schema must have type 'object' and not have 'oneOf' / 'anyOf' /
+    // 'allOf' / 'enum' / 'not' at the top level."
+    //
+    // An earlier iteration of fix-multiselect-auto-cancel-on-dashboard
+    // ("Layer 2: defense in depth") tried adding a body-level `oneOf`
+    // discriminator over `method` so Anthropic would regain per-arm
+    // `required` + `minItems` enforcement. That worked for Anthropic
+    // models but real-world OpenAI gpt-5 rejected the schema (verified by
+    // the user 2026-04-30). The fallback documented in tasks.md §9.7 was
+    // taken: Layer 2 was dropped; Layer 1 (multiselect dashboard routing)
+    // ships alone, which is what actually fixes the user-reported bug.
+    //
+    // Per-method shape requirements (select/multiselect need `options`,
+    // batch needs `questions[]`, etc.) are enforced exclusively at runtime
+    // by `prepareArguments` (rescue/normalization) and the `execute` switch.
+    //
+    // The `no-root-oneof-in-ask-user-schema` guard test at
+    // packages/extension/src/__tests__/ask-user-schema-discriminator.test.ts
+    // pins this constraint so a future refactor cannot reintroduce it.
+    //
+    // See change: fix-multiselect-auto-cancel-on-dashboard.
+    parameters: Type.Object(
+      {
+        method: MethodEnum,
+        title: Type.Optional(
+          Type.String({
+            description:
+              "Short title / question text. Required for all methods except when 'questions' carry it (batch may omit and inherit from first sub-question).",
+          }),
+        ),
+        message: Type.Optional(
+          Type.String({ description: "Additional context shown alongside the question(s)." }),
+        ),
+        options: Type.Optional(
+          Type.Array(Type.String(), {
+            description:
+              "Required for method 'select' (>=2 items) and 'multiselect' (>=1 item). Plain string[] — not [{label,value}]. Ignored for other methods.",
+          }),
+        ),
+        placeholder: Type.Optional(
+          Type.String({
+            description: "Placeholder for method 'input'. Ignored for other methods.",
+          }),
+        ),
+        questions: Type.Optional(
+          Type.Array(SubQuestionSchema, {
+            description:
+              "Required for method 'batch' (>=1 sub-question). Each sub-question is its own confirm/select/multiselect/input — cannot nest 'batch'.",
+          }),
+        ),
+      },
+      {
+        description:
+          "Parameters for ask_user. The required fields depend on `method`: confirm→title; select→title+options(>=2); multiselect→title+options(>=1); input→title (placeholder optional); batch→questions[] (title auto-derived from first question if omitted). Validation is enforced at runtime by prepareArguments + execute (no schema-level discriminator — OpenAI strict mode forbids root-level oneOf).",
+      },
     ),
     prepareArguments(args: unknown) {
       let obj = (args && typeof args === "object" ? { ...(args as Record<string, unknown>) } : {}) as Record<string, unknown>;
@@ -222,6 +312,21 @@ export function registerAskUserTool(pi: ExtensionAPI): void {
       return obj as any;
     },
     async execute(_toolCallId: any, params: any, _signal: any, _onUpdate: any, ctx: any) {
+      // Capture the originating toolCallId so the resulting prompt_request
+      // metadata carries it; the client reducer pairs the interactiveUi
+      // row with its parent toolResult row using this id.
+      // See change: fix-interactive-ui-reorder.
+      const toolCallId: string | undefined =
+        typeof _toolCallId === "string" && _toolCallId.length > 0
+          ? _toolCallId
+          : undefined;
+      const withTcid = (
+        opts: Record<string, unknown> | undefined,
+      ): Record<string, unknown> | undefined => {
+        if (!toolCallId) return opts;
+        return { ...(opts ?? {}), toolCallId };
+      };
+
       // ── Batch branch ─────────────────────────────────────────────────
       if (params.method === "batch" && Array.isArray(params.questions)) {
         const results: Array<unknown> = [];
@@ -229,13 +334,17 @@ export function registerAskUserTool(pi: ExtensionAPI): void {
 
         for (const sq of params.questions) {
           const subTitle = `${params.title} — ${sq.title ?? "Question"}`;
-          const subMsg = params.message ? { message: params.message } : undefined;
+          const subMsg = withTcid(params.message ? { message: params.message } : undefined);
 
           let answer: unknown;
           try {
             switch (sq.method) {
               case "confirm":
-                answer = await ctx.ui.confirm(subTitle, sq.message ?? params.message ?? "");
+                answer = await ctx.ui.confirm(
+                  subTitle,
+                  sq.message ?? params.message ?? "",
+                  withTcid(undefined),
+                );
                 break;
               case "select": {
                 const opts = Array.isArray(sq.options) ? sq.options : [];
@@ -254,7 +363,7 @@ export function registerAskUserTool(pi: ExtensionAPI): void {
                     `ask_user batch: sub-question method "multiselect" requires a non-empty "options" array.`,
                   );
                 }
-                answer = await (ctx.ui as any).multiselect(subTitle, opts, subMsg);
+                answer = await polyfillMultiselect(ctx, subTitle, opts, subMsg);
                 break;
               }
               case "input":
@@ -311,7 +420,7 @@ export function registerAskUserTool(pi: ExtensionAPI): void {
 
       // ── Single-question branches (unchanged behavior) ────────────────
       let result: unknown;
-      const msgOpts = params.message ? { message: params.message } : undefined;
+      const msgOpts = withTcid(params.message ? { message: params.message } : undefined);
       const title = params.title || params.message || "Question";
 
       const options: string[] = Array.isArray(params.options)
@@ -330,13 +439,13 @@ export function registerAskUserTool(pi: ExtensionAPI): void {
 
       switch (params.method) {
         case "confirm":
-          result = await ctx.ui.confirm(title, params.message ?? "");
+          result = await ctx.ui.confirm(title, params.message ?? "", withTcid(undefined));
           break;
         case "select":
           result = await ctx.ui.select(title, options, msgOpts);
           break;
         case "multiselect":
-          result = await (ctx.ui as any).multiselect(title, options, msgOpts);
+          result = await polyfillMultiselect(ctx, title, options, msgOpts);
           break;
         case "input":
           result = await ctx.ui.input(title, params.placeholder, msgOpts);