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

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

@@ -7,7 +7,114 @@
  */
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { StringEnum } from "@mariozechner/pi-ai";
+
+// ──────────────────────────────────────────────────────────────────────────
+// Single-question schema arms (reused inside the batch arm's questions array)
+// ──────────────────────────────────────────────────────────────────────────
+
+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" })),
+});
+
+// ──────────────────────────────────────────────────────────────────────────
+// Argument rescue helpers
+// ──────────────────────────────────────────────────────────────────────────
+
+type NormalizationWarning = string;
+
+function normalizeSubQuestion(
+  sq: unknown,
+  warnings: NormalizationWarning[],
+): Record<string, unknown> {
+  if (!sq || typeof sq !== "object" || Array.isArray(sq)) return sq as any;
+  let obj = { ...(sq as Record<string, unknown>) };
+
+  // Flatten `input_type: {method, options, ...}` wrapper if present.
+  if (obj.input_type && typeof obj.input_type === "object" && !Array.isArray(obj.input_type)) {
+    const inner = obj.input_type as Record<string, unknown>;
+    const { input_type: _drop, ...rest } = obj;
+    obj = { ...inner, ...rest };
+    delete (obj as Record<string, unknown>).input_type;
+  }
+
+  // Rename `question` / `header` → `title` (only if title missing).
+  if (obj.title === undefined) {
+    if (typeof obj.question === "string") obj.title = obj.question;
+    else if (typeof obj.header === "string") obj.title = obj.header;
+  }
+
+  // Parse stringified options.
+  if (typeof obj.options === "string") {
+    try {
+      const parsed = JSON.parse(obj.options);
+      if (Array.isArray(parsed)) obj.options = parsed;
+    } catch {
+      /* leave as-is */
+    }
+  }
+
+  // Convert options: [{label, value}] → [label, ...] with a warning.
+  if (Array.isArray(obj.options) && obj.options.length > 0 && obj.options.every(
+    (o) => o && typeof o === "object" && !Array.isArray(o) && typeof (o as any).label === "string",
+  )) {
+    obj.options = (obj.options as Array<Record<string, unknown>>).map((o) => o.label as string);
+    warnings.push(
+      "ask_user: options with {label, value} pairs are not supported — only labels were used. Send options as string[].",
+    );
+  }
+
+  return obj;
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Tool registration
+// ──────────────────────────────────────────────────────────────────────────
 
 export function registerAskUserTool(pi: ExtensionAPI): void {
   pi.registerTool({
@@ -16,49 +123,211 @@ export function registerAskUserTool(pi: ExtensionAPI): void {
     description:
       "Ask the user a question interactively. Use this when you need clarification, confirmation, or a choice from the user before proceeding.",
     promptSnippet:
-      "Ask the user interactive questions (confirm, select, multiselect, or free text input)",
+      "Ask the user interactive questions (confirm, select, multiselect, input, or batch — multiple related questions at once)",
     promptGuidelines: [
       "When you need to ask the user a question, ALWAYS use the ask_user tool instead of writing the question as plain text.",
       "Use method 'confirm' for yes/no questions, 'select' when offering specific choices, 'multiselect' when the user should pick multiple items from a list, and 'input' for open-ended questions.",
+      "Use method 'batch' with a `questions` array to ask multiple related questions in one call (e.g. project setup: name + language + init git). Prefer single-method calls for standalone questions.",
+      "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.Object({
-      method: StringEnum(["confirm", "select", "multiselect", "input"] as const, {
-        description:
-          "Type of question: confirm (yes/no), select (pick from options), multiselect (pick multiple), input (free text)",
-      }),
-      title: Type.Optional(Type.String({ description: "Short title for the question (optional, falls back to message)" })),
-      message: Type.Optional(Type.String({ description: "Additional context or detailed question body (all methods)" })),
-      options: Type.Optional(
-        Type.Array(Type.String(), { description: "Options to choose from (for select)" }),
-      ),
-      placeholder: Type.Optional(Type.String({ description: "Placeholder text (for input)" })),
-    }),
+    parameters: Type.Union(
+      [ConfirmSchema, SelectSchema, MultiselectSchema, InputSchema, BatchSchema],
+      { description: "Parameters for ask_user, discriminated by method." },
+    ),
     prepareArguments(args: unknown) {
-      const obj = (args && typeof args === "object" ? args : {}) as Record<string, unknown>;
-      // LLMs sometimes send options as a JSON string instead of an array
+      let obj = (args && typeof args === "object" ? { ...(args as Record<string, unknown>) } : {}) as Record<string, unknown>;
+
+      // 1. LLMs sometimes wrap everything under `params` (stringified or object).
+      if (obj.params !== undefined) {
+        let inner: Record<string, unknown> | undefined;
+        if (typeof obj.params === "string") {
+          try {
+            const parsed = JSON.parse(obj.params);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+              inner = parsed as Record<string, unknown>;
+            }
+          } catch { /* leave as-is */ }
+        } else if (obj.params && typeof obj.params === "object" && !Array.isArray(obj.params)) {
+          inner = obj.params as Record<string, unknown>;
+        }
+        if (inner) {
+          const { params: _omit, ...rest } = obj;
+          obj = { ...inner, ...rest };
+          delete (obj as Record<string, unknown>).params;
+        }
+      }
+
+      // 2. `question` → `title` (only if title missing).
+      if (obj.title === undefined && typeof obj.question === "string") {
+        obj.title = obj.question;
+      }
+
+      // 3. Stringified top-level `options` for single-method calls.
       if (typeof obj.options === "string") {
         try {
           const parsed = JSON.parse(obj.options);
           if (Array.isArray(parsed)) obj.options = parsed;
-        } catch { /* leave as-is, validation will report */ }
+        } catch { /* leave as-is */ }
+      }
+
+      // 4. Batch rescue: `questions` as a JSON string → parsed array.
+      if (typeof obj.questions === "string") {
+        try {
+          const parsed = JSON.parse(obj.questions);
+          if (Array.isArray(parsed)) obj.questions = parsed;
+        } catch { /* leave as-is */ }
+      }
+
+      // 5. If `questions` is a non-empty array and `method` is absent, synthesize `method: "batch"`.
+      if (
+        !obj.method &&
+        Array.isArray(obj.questions) &&
+        obj.questions.length > 0
+      ) {
+        obj.method = "batch";
+      }
+
+      // 6. For any batch call (synthesized or explicit), backfill a missing outer `title`
+      //    from the first sub-question so the schema validates. Opus frequently sends
+      //    `{method:"batch", questions:[...]}` without an outer `title`.
+      if (
+        obj.method === "batch" &&
+        Array.isArray(obj.questions) &&
+        obj.questions.length > 0 &&
+        obj.title === undefined
+      ) {
+        const first = obj.questions[0] as Record<string, unknown> | undefined;
+        const candidate =
+          (first && (first.title ?? first.question ?? first.header)) || "Questions";
+        obj.title = typeof candidate === "string" ? candidate : "Questions";
       }
+
+      // 7. For batch calls, normalize each sub-question (input_type, question/header, {label,value}).
+      const warnings: NormalizationWarning[] = [];
+      if (obj.method === "batch" && Array.isArray(obj.questions)) {
+        obj.questions = obj.questions.map((sq) => normalizeSubQuestion(sq, warnings));
+      }
+
+      if (warnings.length > 0) {
+        // Non-enumerable so it doesn't interfere with schema validation.
+        Object.defineProperty(obj, "__normalizations", {
+          value: warnings,
+          enumerable: false,
+          configurable: true,
+          writable: true,
+        });
+      }
+
       return obj as any;
     },
     async execute(_toolCallId: any, params: any, _signal: any, _onUpdate: any, ctx: any) {
-      let result: unknown;
+      // ── Batch branch ─────────────────────────────────────────────────
+      if (params.method === "batch" && Array.isArray(params.questions)) {
+        const results: Array<unknown> = [];
+        let cancelled = false;
 
-      const msgOpts = params.message ? { message: params.message } : undefined;
+        for (const sq of params.questions) {
+          const subTitle = `${params.title} — ${sq.title ?? "Question"}`;
+          const subMsg = 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 ?? "");
+                break;
+              case "select": {
+                const opts = Array.isArray(sq.options) ? sq.options : [];
+                if (opts.length === 0) {
+                  throw new Error(
+                    `ask_user batch: sub-question method "select" requires a non-empty "options" array.`,
+                  );
+                }
+                answer = await ctx.ui.select(subTitle, opts, subMsg);
+                break;
+              }
+              case "multiselect": {
+                const opts = Array.isArray(sq.options) ? sq.options : [];
+                if (opts.length === 0) {
+                  throw new Error(
+                    `ask_user batch: sub-question method "multiselect" requires a non-empty "options" array.`,
+                  );
+                }
+                answer = await (ctx.ui as any).multiselect(subTitle, opts, subMsg);
+                break;
+              }
+              case "input":
+                answer = await ctx.ui.input(subTitle, sq.placeholder, subMsg);
+                break;
+              default:
+                throw new Error(`ask_user batch: unknown sub-question method "${sq.method}"`);
+            }
+          } catch (err) {
+            // Propagate hard errors (schema/logic bugs); cancellation is signalled by undefined.
+            throw err;
+          }
+
+          // Treat `undefined` from input/select/multiselect as cancellation.
+          // (confirm always resolves to a boolean and has no cancel path.)
+          if (
+            (sq.method === "input" || sq.method === "select" || sq.method === "multiselect") &&
+            answer === undefined
+          ) {
+            cancelled = true;
+            results.push(null);
+            break;
+          }
 
+          results.push(answer);
+        }
+
+        const warnings: string[] = (params as any).__normalizations ?? [];
+        const lines: string[] = [];
+        if (cancelled) {
+          lines.push(`User cancelled batch after ${results.filter((r) => r !== null).length} of ${params.questions.length} answers.`);
+        } else {
+          lines.push(`User completed batch (${results.length} answers).`);
+        }
+        params.questions.forEach((sq: any, i: number) => {
+          const ans = i < results.length ? results[i] : "(not asked)";
+          lines.push(`  ${i + 1}. ${sq.title ?? sq.method}: ${JSON.stringify(ans)}`);
+        });
+        if (warnings.length > 0) {
+          lines.push("", "Warnings:");
+          for (const w of warnings) lines.push(`  - ${w}`);
+        }
+
+        return {
+          content: [{ type: "text", text: lines.join("\n") }],
+          details: {
+            method: "batch",
+            results,
+            cancelled,
+            warnings,
+          },
+        };
+      }
+
+      // ── Single-question branches (unchanged behavior) ────────────────
+      let result: unknown;
+      const msgOpts = params.message ? { message: params.message } : undefined;
       const title = params.title || params.message || "Question";
 
-      // LLMs sometimes send options as a JSON string instead of an array
       const options: string[] = Array.isArray(params.options)
         ? params.options
         : typeof params.options === "string"
           ? (() => { try { const p = JSON.parse(params.options); return Array.isArray(p) ? p : []; } catch { return []; } })()
           : [];
 
+      if ((params.method === "select" || params.method === "multiselect") && options.length === 0) {
+        throw new Error(
+          `ask_user: method "${params.method}" requires a non-empty "options" array. ` +
+          `Received: ${JSON.stringify(params.options)}. ` +
+          `If no choices are available, use method "input" instead.`,
+        );
+      }
+
       switch (params.method) {
         case "confirm":
           result = await ctx.ui.confirm(title, params.message ?? "");

package/packages/extension/src/bridge.ts

@@ -5,6 +5,7 @@
  * forwards all pi events, and relays commands back.
  */
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Loader } from "@mariozechner/pi-tui";
 import { ConnectionManager } from "./connection.js";
 import { detectSessionSource } from "./source-detector.js";
 import { mapEventToProtocol } from "./event-forwarder.js";
@@ -25,7 +26,7 @@ import { expandPromptTemplateFromDisk } from "./prompt-expander.js";
 import { PromptBus } from "./prompt-bus.js";
 import { DashboardDefaultAdapter } from "./dashboard-default-adapter.js";
 import { registerAskUserTool } from "./ask-user-tool.js";
-import { activate as activateProviderRegister, onProviderChanged } from "./provider-register.js";
+import { activate as activateProviderRegister, onProviderChanged, reloadProviders } from "./provider-register.js";
 import type { FlowInfo } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 import { startMetricsMonitor, stopMetricsMonitor, collectMetrics } from "./process-metrics.js";
 import { scanChildProcesses } from "./process-scanner.js";
@@ -74,6 +75,10 @@ export default function (pi: ExtensionAPI) {
     // registered before session_start fires and models_list is sent.
     activateProviderRegister(pi);
 
+    // Anthropic-messages payload transforms (system prompt rewrite + tool
+    // filter/remap) are handled by the installed @benvargas/pi-claude-code-use
+    // package when present. No local duplication here.
+
     initBridge(pi);
   } catch (err) {
     // Never crash the host pi agent — dashboard is non-essential
@@ -211,7 +216,31 @@ function initBridge(pi: ExtensionAPI) {
       // Legacy extension_ui_response removed — now handled by prompt_response → promptBus.respond()
       // Reload auth credentials when dashboard notifies of changes
       if (msg.type === "credentials_updated") {
-        try { cachedModelRegistry?.authStorage?.reload?.(); } catch { /* ignore */ }
+        try {
+          // Hot-reload providers.json diff BEFORE refreshing the registry,
+          // so any newly added providers are registered before getAvailable() runs.
+          const diff = await reloadProviders(pi).catch((err) => {
+            console.error("[dashboard] reloadProviders failed:", err);
+            return { added: [], removed: [], changed: [] };
+          });
+          if (diff.added.length || diff.removed.length || diff.changed.length) {
+            console.log(
+              `[dashboard] hot-reloaded providers: added=${JSON.stringify(diff.added)} removed=${JSON.stringify(diff.removed)} changed=${JSON.stringify(diff.changed)}`,
+            );
+          }
+          cachedModelRegistry?.authStorage?.reload?.();
+          cachedModelRegistry?.refresh?.();
+        } catch (err) { console.error("[dashboard] credentials reload failed:", err); }
+        // Push updated models list to dashboard client
+        if (cachedModelRegistry && sessionReady) {
+          try {
+            const models = cachedModelRegistry.getAvailable().map((m: any) => ({
+              provider: m.provider,
+              id: m.id,
+            }));
+            connection.send({ type: "models_list", sessionId, models });
+          } catch (err) { console.error("[dashboard] models_list push failed:", err); }
+        }
         return;
       }
       // Route flow management actions from dashboard buttons
@@ -456,7 +485,9 @@ function initBridge(pi: ExtensionAPI) {
       }
       // Fallback: send as user message (template-expanded).
       // Uses deliverAs:followUp so it queues properly when agent is streaming.
-      const expanded = expandPromptTemplateFromDisk(text, process.cwd());
+      // expandPromptTemplateFromDisk handles skill commands (/skill:xxx) and
+      // prompt templates by reading the file content from disk.
+      const expanded = expandPromptTemplateFromDisk(text, process.cwd(), pi);
       (pi.sendUserMessage as any)(expanded, { deliverAs: "followUp" });
     },
   });
@@ -581,8 +612,23 @@ function initBridge(pi: ExtensionAPI) {
         }
       }
 
-      // For message_start and message_end, enrich with entryId (current leaf)
-      if (eventType === "message_start" || eventType === "message_end") {
+      // For message_start, enrich with entryId immediately (current leaf)
+      if (eventType === "message_start") {
+        const entryId = ctx.sessionManager?.getLeafId?.();
+        if (entryId) {
+          const enriched = { ...event, entryId };
+          const msg = mapEventToProtocol(sessionId, enriched);
+          connection.send(msg);
+          return;
+        }
+      }
+
+      // For message_end, defer getLeafId() so it runs after pi core persists the entry.
+      // Pi core calls _emit (which invokes this handler) BEFORE appendMessage (which updates leafId).
+      // Since _emit doesn't await async handlers, yielding via queueMicrotask lets appendMessage
+      // run first, so getLeafId() returns the correct entry ID for the just-persisted message.
+      if (eventType === "message_end") {
+        await new Promise<void>(resolve => queueMicrotask(resolve));
         const entryId = ctx.sessionManager?.getLeafId?.();
         if (entryId) {
           const enriched = { ...event, entryId };
@@ -917,17 +963,72 @@ function initBridge(pi: ExtensionAPI) {
     }
 
     // Discover or auto-start server (non-blocking — connection will reconnect)
+    //
+    // When a real launchServer() is about to run (not on mDNS/health-check
+    // paths), mount an animated TUI widget above the editor using pi-tui's
+    // Loader (a real Component, self-animating at 80ms, like pi-flows'
+    // architect-widget). The previous implementation used
+    // ctx.ui.setStatus(...) which only writes a footer string and relies on
+    // the TUI render loop being ticked elsewhere — on the cold-start path
+    // nothing else requests renders, so the spinner never animated and often
+    // never appeared. setWidget(key, factory, {placement:"aboveEditor"}) gives
+    // us a managed component that owns its own render loop and is always
+    // visible while the launch is in flight.
+    let spinnerTimer: NodeJS.Timeout | null = null;
+    let spinnerStart = 0;
+    let activeLoader: Loader | null = null;
+    const stopSpinner = () => {
+      if (spinnerTimer) {
+        clearInterval(spinnerTimer);
+        spinnerTimer = null;
+      }
+      activeLoader = null;
+      ctx.ui.setWidget("pi-dashboard-launch", undefined);
+    };
     autoStartServer(config, {
       discoverDashboard,
       isDashboardRunning,
       launchServer,
       notify: (msg, level) => ctx.ui.notify(msg, level),
+      onLaunchStart: () => {
+        spinnerStart = Date.now();
+        const buildMessage = () => {
+          const elapsed = Math.floor((Date.now() - spinnerStart) / 1000);
+          return `starting dashboard server … (${elapsed}s)`;
+        };
+        ctx.ui.setWidget(
+          "pi-dashboard-launch",
+          (tui: unknown, theme: { fg: (role: string, s: string) => string }) => {
+            const loader = new Loader(
+              tui as ConstructorParameters<typeof Loader>[0],
+              (s: string) => theme.fg("accent", s),
+              (s: string) => theme.fg("muted", s),
+              buildMessage(),
+            );
+            activeLoader = loader;
+            // Loader has stop() but no dispose(); wire dispose so that
+            // setExtensionWidget's teardown stops the 80ms animation interval.
+            (loader as Loader & { dispose?: () => void }).dispose = () => loader.stop();
+            return loader;
+          },
+          { placement: "aboveEditor" },
+        );
+        // Refresh the elapsed-seconds label every second. Frame animation is
+        // driven by the Loader's own 80ms interval.
+        spinnerTimer = setInterval(() => {
+          activeLoader?.setMessage(buildMessage());
+        }, 1000);
+      },
+      onLaunchEnd: () => {
+        stopSpinner();
+      },
     }).then((result) => {
+      stopSpinner(); // safety net — covers onLaunchEnd not firing
       if (result.server && result.server.piPort !== config.piPort) {
         // Server found on a different piPort than configured — update connection URL
         connection.updateUrl(`ws://${result.server.host === 'localhost' ? 'localhost' : result.server.host}:${result.server.piPort}`);
       }
-    }).catch(() => {});
+    }).catch(() => { stopSpinner(); });
 
     // Send initial git info
     sendGitInfoIfChanged(ctx.cwd);

package/packages/extension/src/command-handler.ts

@@ -1,7 +1,8 @@
 /**
  * Handles server→extension messages by dispatching to pi API.
  */
-import { spawnSync } from "node:child_process";
+import { readdirSync } from "node:fs";
+import { join, relative } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import type {
   ServerToExtensionMessage,
@@ -10,47 +11,33 @@ import type {
 import { killProcessByPgid } from "./process-scanner.js";
 import type { FileEntry, PiSessionInfo } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 import { filterHiddenCommands } from "./bridge-context.js";
+import { expandPromptTemplateFromDisk } from "./prompt-expander.js";
 
-/** Escape regex special characters for fd pattern */
-function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+const IGNORE_DIRS = new Set([".git", "node_modules", ".next", "dist", "build", ".cache", "__pycache__", ".venv"]);
+const MAX_RESULTS = 20;
 
-/** Search files using fd */
 function searchFiles(cwd: string, query: string): FileEntry[] {
-  const args = [
-    "--base-directory", cwd,
-    "--max-results", "20",
-    "--type", "f",
-    "--type", "d",
-    "--full-path",
-    "--hidden",
-    "--exclude", ".git",
-  ];
-
-  if (query) {
-    args.push(escapeRegex(query));
-  }
-
-  try {
-    const result = spawnSync("fd", args, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5000,
-    });
-
-    if (result.status !== 0 || !result.stdout) {
-      return [];
+  const results: FileEntry[] = [];
+  const lowerQuery = query?.toLowerCase() ?? "";
+
+  function walk(dir: string, depth: number): void {
+    if (results.length >= MAX_RESULTS || depth > 6) return;
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      if (results.length >= MAX_RESULTS) return;
+      if (IGNORE_DIRS.has(entry.name)) continue;
+      const fullPath = join(dir, entry.name);
+      const relPath = relative(cwd, fullPath).replace(/\\/g, "/") + (entry.isDirectory() ? "/" : "");
+      if (!lowerQuery || relPath.toLowerCase().includes(lowerQuery)) {
+        results.push({ path: relPath, isDirectory: entry.isDirectory() });
+      }
+      if (entry.isDirectory()) walk(fullPath, depth + 1);
     }
-
-    return result.stdout.trim().split("\n").filter(Boolean).map((line) => {
-      const normalized = line.replace(/\\/g, "/");
-      const isDirectory = normalized.endsWith("/");
-      return { path: normalized, isDirectory };
-    });
-  } catch {
-    return [];
   }
+
+  walk(cwd, 0);
+  return results;
 }
 
 /** Parsed result from parseSendPrompt */
@@ -288,8 +275,15 @@ export function createCommandHandler(
             return undefined;
           }
 
-          // Passthrough: send as regular user message (with image handling)
-          sendUserMessageWithImages(pi, msg.text, msg.images);
+          // Passthrough: send as regular user message (with image handling).
+          // Multi-line slash commands (e.g. "/skill:foo\nuser text") are classified as
+          // passthrough by parseSendPrompt to preserve images (the slash route strips them),
+          // so we expand prompt templates / skills here before sending.
+          let outgoing = msg.text;
+          if (outgoing.startsWith("/")) {
+            outgoing = expandPromptTemplateFromDisk(outgoing, process.cwd(), pi);
+          }
+          sendUserMessageWithImages(pi, outgoing, msg.images);
           return undefined;
         }
 
@@ -338,6 +332,7 @@ export function createCommandHandler(
           const registry = options?.getModelRegistry?.();
           if (registry) {
             try {
+              registry.authStorage?.reload?.();
               registry.refresh();
               const models = registry.getAvailable().map((m: any) => ({
                 provider: m.provider,

package/packages/extension/src/dev-build.ts

@@ -2,7 +2,7 @@
  * Dev build-on-reload helper.
  * Builds the Vite client and requests server shutdown.
  */
-import { execSync as defaultExecSync } from "node:child_process";
+import { execSync as defaultExecSync } from "@blackbelt-technology/pi-dashboard-shared/platform/exec.js";
 
 export interface DevBuildOptions {
   packageRoot: string;