@brainst0rm/cli 0.13.0

package/dist/chunk-55ITCWZZ.js

@@ -0,0 +1,1307 @@
+import {
+  ROLES,
+  formatModelMenu,
+  formatRoleConfirmation,
+  getModelForRole
+} from "./chunk-YWXOPUDW.js";
+
+// src/commands/build-wizard.ts
+import { autoSelectPreset, getPresetWorkflow } from "@brainst0rm/workflow";
+var ROLE_FOR_AGENT = {
+  architect: "architect",
+  coder: "sr-developer",
+  reviewer: "qa",
+  debugger: "sr-developer",
+  analyst: "architect",
+  orchestrator: "architect",
+  "product-manager": "product-manager"
+};
+function createWizardState() {
+  return {
+    step: "describe",
+    description: "",
+    detectedPreset: null,
+    workflow: null,
+    assignments: [],
+    currentAssignIdx: 0,
+    totalCost: 0,
+    complexity: "moderate"
+  };
+}
+function processDescription(state, description, classify) {
+  const detectedPreset = autoSelectPreset(description) ?? "implement-feature";
+  const workflow = getPresetWorkflow(detectedPreset);
+  if (!workflow) {
+    return { ...state, step: "describe", description };
+  }
+  let complexity = "moderate";
+  if (classify) {
+    try {
+      const profile = classify(description);
+      complexity = profile.complexity ?? "moderate";
+    } catch {
+    }
+  }
+  const assignments = workflow.steps.map((step) => {
+    const roleId = ROLE_FOR_AGENT[step.agentRole] ?? "sr-developer";
+    const defaultModel = getDefaultModelForStep(roleId, complexity);
+    const pricing = getModelPricing(defaultModel.modelId);
+    const estimatedCost = estimateStepCost(complexity, pricing);
+    return {
+      stepId: step.id,
+      stepRole: step.agentRole,
+      modelId: defaultModel.modelId,
+      modelLabel: defaultModel.label,
+      estimatedCost
+    };
+  });
+  const totalCost = assignments.reduce((sum, a) => sum + a.estimatedCost, 0);
+  return {
+    ...state,
+    step: "confirm",
+    description,
+    detectedPreset,
+    workflow,
+    assignments,
+    currentAssignIdx: 0,
+    totalCost,
+    complexity
+  };
+}
+function getModelChoicesForStep(agentRole) {
+  const roleId = ROLE_FOR_AGENT[agentRole] ?? "sr-developer";
+  const role = ROLES[roleId];
+  return role?.modelChoices ?? [];
+}
+function getDefaultModelForStep(roleId, complexity) {
+  const role = ROLES[roleId];
+  if (!role)
+    return { modelId: "brainstormrouter/auto", label: "Auto", cost: "$0" };
+  if (complexity === "trivial" || complexity === "simple") {
+    return role.modelChoices[role.modelChoices.length - 1] ?? role.modelChoices[0];
+  }
+  return role.modelChoices.find((m) => m.default) ?? role.modelChoices[0];
+}
+var MODEL_PRICING = {
+  "anthropic/claude-opus-4-6": { input: 15, output: 75 },
+  "anthropic/claude-sonnet-4-6": { input: 3, output: 15 },
+  "anthropic/claude-haiku-4-5-20251001": { input: 0.8, output: 4 },
+  "openai/gpt-5.4": { input: 2.5, output: 10 },
+  "openai/gpt-4.1-mini": { input: 0.4, output: 1.6 },
+  "google/gemini-3.1-pro": { input: 1.25, output: 5 },
+  "google/gemini-3.1-flash": { input: 0.15, output: 0.6 },
+  "deepseek/deepseek-chat": { input: 0.27, output: 1.1 },
+  "moonshot/kimi-k2.5": { input: 0.6, output: 2.4 }
+};
+function getModelPricing(modelId) {
+  return MODEL_PRICING[modelId] ?? { input: 1, output: 4 };
+}
+var COMPLEXITY_TOKENS = {
+  trivial: { input: 500, output: 200 },
+  simple: { input: 1e3, output: 500 },
+  moderate: { input: 3e3, output: 1500 },
+  complex: { input: 8e3, output: 4e3 },
+  expert: { input: 15e3, output: 8e3 }
+};
+function estimateStepCost(complexity, pricing) {
+  const tokens = COMPLEXITY_TOKENS[complexity] ?? COMPLEXITY_TOKENS.moderate;
+  return tokens.input / 1e6 * pricing.input + tokens.output / 1e6 * pricing.output;
+}
+function updateAssignment(state, stepIdx, modelChoice) {
+  const assignments = [...state.assignments];
+  const pricing = getModelPricing(modelChoice.modelId);
+  assignments[stepIdx] = {
+    ...assignments[stepIdx],
+    modelId: modelChoice.modelId,
+    modelLabel: modelChoice.label,
+    estimatedCost: estimateStepCost(state.complexity, pricing)
+  };
+  const totalCost = assignments.reduce((sum, a) => sum + a.estimatedCost, 0);
+  return { ...state, assignments, totalCost };
+}
+var ROLE_ICONS = {
+  architect: "\u{1F3D7}",
+  coder: "\u{1F468}\u200D\u{1F4BB}",
+  reviewer: "\u{1F50D}",
+  debugger: "\u{1F527}",
+  analyst: "\u{1F4CA}"
+};
+function formatPipeline(state) {
+  if (!state.workflow || state.assignments.length === 0) return "";
+  const lines = [];
+  lines.push(`${state.detectedPreset}`);
+  for (let i = 0; i < state.assignments.length; i++) {
+    const a = state.assignments[i];
+    const step = state.workflow.steps[i];
+    const icon = ROLE_ICONS[a.stepRole] ?? "\u2699";
+    const shortModel = a.modelLabel.replace(/^Claude /, "").replace(/^GPT-/, "GPT-");
+    lines.push(
+      `${i + 1}. ${icon} ${a.stepRole} \u2192 ${shortModel} ~$${a.estimatedCost.toFixed(3)}`
+    );
+    if (step?.isReviewStep && step.loopBackTo) {
+      lines.push(`   \u21BA loops to ${step.loopBackTo}`);
+    }
+  }
+  lines.push(`Total: ~$${state.totalCost.toFixed(3)}`);
+  return lines.join("\n");
+}
+function buildWorkflowOverrides(state) {
+  const agentOverrides = {};
+  const stepModelOverrides = {};
+  for (const a of state.assignments) {
+    stepModelOverrides[a.stepId] = a.modelId;
+  }
+  return { agentOverrides, stepModelOverrides };
+}
+
+// src/commands/slash.ts
+var commands = [
+  {
+    name: "help",
+    aliases: ["h", "?"],
+    description: "Show available slash commands",
+    usage: "/help [command]",
+    execute: (args) => {
+      if (args) {
+        const cmd = commandMap.get(args.toLowerCase());
+        if (!cmd)
+          return `Unknown command: /${args}. Type /help for all commands.`;
+        const aliases = cmd.aliases.length > 0 ? `
+Aliases: ${cmd.aliases.map((a) => "/" + a).join(", ")}` : "";
+        return `${cmd.usage}
+${cmd.description}${aliases}`;
+      }
+      const lines = [
+        "Commands:",
+        "",
+        "Chat",
+        "  /help [cmd]        Show help (detail for specific command)",
+        "  /model [name]      Switch model",
+        "  /strategy [name]   Switch routing strategy",
+        "  /mode [mode]       Switch permission (auto/confirm/plan)",
+        "  /style [style]     Switch output style",
+        "  /compact [focus]   Compact context with optional focus",
+        "  /context           Show token breakdown",
+        "  /cost              Show session cost",
+        "  /plan              Toggle plan mode (describe before execute)",
+        "  /efficiency        Token usage and routing savings",
+        "  /clear             Clear conversation",
+        "",
+        "Roles",
+        "  /architect [N]     Deep thinking, read-only",
+        "  /sr-developer [N]  Quality implementation",
+        "  /jr-developer [N]  Fast, cheap coding",
+        "  /qa [N]            Testing and review",
+        "  /role              Show current role",
+        "  /default           Reset to defaults",
+        "",
+        "Build",
+        "  /build [desc]      Multi-model workflow wizard",
+        "  /build-go          Execute pending pipeline",
+        "  /build-customize   See model options per step",
+        "",
+        "Intelligence",
+        "  /recommend [type]  Get model recommendation from BR",
+        "  /stats             Session analytics + BR usage",
+        "",
+        "System",
+        "  /vault [action]    Manage API keys",
+        "  /dream             Consolidate memory files",
+        "",
+        "Modes: Esc toggles Dashboard \u2502 Shift+Tab cycles permission"
+      ];
+      return lines.join("\n");
+    }
+  },
+  {
+    name: "model",
+    aliases: ["m"],
+    description: "Switch or show the active model",
+    usage: "/model [name]",
+    execute: (args, ctx) => {
+      if (!args) {
+        const current = ctx.getModel?.() ?? "auto (router-selected)";
+        return `Current model: ${current}`;
+      }
+      ctx.setModel?.(args);
+      return `Model switched to: ${args}`;
+    }
+  },
+  {
+    name: "strategy",
+    aliases: ["fast"],
+    description: "Switch routing strategy",
+    usage: "/strategy [cost-first|quality-first|combined|capability|rule-based]",
+    execute: (args, ctx, invokedAs) => {
+      const valid = [
+        "cost-first",
+        "quality-first",
+        "combined",
+        "capability",
+        "rule-based"
+      ];
+      if (!args && invokedAs === "fast") {
+        const current = ctx.getStrategy?.() ?? "combined";
+        const next = current === "cost-first" ? "quality-first" : "cost-first";
+        ctx.setStrategy?.(next);
+        return `Routing strategy: ${next}`;
+      }
+      if (!args) {
+        return `Current strategy: ${ctx.getStrategy?.() ?? "combined"}. Options: ${valid.join(", ")}`;
+      }
+      if (!valid.includes(args)) {
+        return `Unknown strategy: ${args}. Options: ${valid.join(", ")}`;
+      }
+      ctx.setStrategy?.(args);
+      return `Routing strategy: ${args}`;
+    }
+  },
+  {
+    name: "mode",
+    aliases: [],
+    description: "Switch permission mode",
+    usage: "/mode [auto|confirm|plan]",
+    execute: (args, ctx) => {
+      const valid = ["auto", "confirm", "plan"];
+      if (!args) {
+        return `Current mode: ${ctx.getMode?.() ?? "confirm"}. Options: ${valid.join(", ")}`;
+      }
+      if (!valid.includes(args)) {
+        return `Invalid mode: ${args}. Options: ${valid.join(", ")}`;
+      }
+      ctx.setMode?.(args);
+      return `Permission mode: ${args}`;
+    }
+  },
+  {
+    name: "cost",
+    aliases: ["$"],
+    description: "Show session cost so far",
+    usage: "/cost",
+    execute: (_args, ctx) => {
+      const cost = ctx.getSessionCost?.() ?? 0;
+      const tokens = ctx.getTokenCount?.() ?? { input: 0, output: 0 };
+      return `Session cost: $${cost.toFixed(4)}
+Tokens: ${tokens.input.toLocaleString()} in / ${tokens.output.toLocaleString()} out`;
+    }
+  },
+  {
+    name: "budget",
+    aliases: [],
+    description: "Show remaining budget",
+    usage: "/budget",
+    execute: (_args, ctx) => {
+      const budget = ctx.getBudget?.();
+      if (!budget) return "No budget limit set.";
+      const pct = (budget.remaining / budget.limit * 100).toFixed(1);
+      return `Budget: $${budget.remaining.toFixed(4)} remaining of $${budget.limit.toFixed(4)} (${pct}%)`;
+    }
+  },
+  {
+    name: "clear",
+    aliases: [],
+    description: "Clear conversation history",
+    usage: "/clear",
+    execute: (_args, ctx) => {
+      ctx.clearHistory?.();
+      return "Conversation cleared.";
+    }
+  },
+  {
+    name: "compact",
+    aliases: [],
+    description: "Compact context, optionally with focus instruction",
+    usage: "/compact [focus instruction]",
+    execute: async (args, ctx) => {
+      if (!ctx.compact) return "Compaction not available.";
+      await ctx.compact(args || void 0);
+      return args ? `Context compacted (focus: ${args})` : "Context compacted.";
+    }
+  },
+  {
+    name: "style",
+    aliases: [],
+    description: "Switch output style",
+    usage: "/style [concise|detailed|learning]",
+    execute: (args, ctx) => {
+      const valid = ["concise", "detailed", "learning"];
+      if (!args) {
+        return `Current style: ${ctx.getOutputStyle?.() ?? "concise"}. Options: ${valid.join(", ")}`;
+      }
+      if (!valid.includes(args)) {
+        return `Invalid style: ${args}. Options: ${valid.join(", ")}`;
+      }
+      ctx.setOutputStyle?.(args);
+      return `Output style: ${args}`;
+    }
+  },
+  {
+    name: "quit",
+    aliases: ["exit", "q"],
+    description: "Exit Brainstorm",
+    usage: "/quit",
+    execute: (_args, ctx) => {
+      ctx.exit?.();
+      return "Goodbye.";
+    }
+  },
+  {
+    name: "vault",
+    aliases: ["keys"],
+    description: "Manage API keys in the encrypted vault",
+    usage: "/vault [list|add <name>|get <name>|remove <name>|status]",
+    execute: async (args, ctx) => {
+      if (!ctx.vault) return "Vault not available in this mode.";
+      const parts = args.split(/\s+/);
+      const action = parts[0] || "list";
+      const rest = parts.slice(1).join(" ");
+      return ctx.vault(action, rest);
+    }
+  },
+  {
+    name: "dream",
+    aliases: ["consolidate"],
+    description: "Consolidate memory files \u2014 merge duplicates, fix dates, prune stale refs",
+    usage: "/dream",
+    execute: async (_args, ctx) => {
+      if (!ctx.dream) return "Dream not available in this mode.";
+      return ctx.dream();
+    }
+  },
+  {
+    name: "project",
+    aliases: ["proj"],
+    description: "Manage projects \u2014 switch, list, show dashboard",
+    usage: "/project [name|list|register|show <name>]",
+    execute: async (args, ctx) => {
+      const { ProjectManager } = await import("./dist-WLTQTLFO.js");
+      const { getDb } = await import("@brainst0rm/db");
+      const db = getDb();
+      const pm = new ProjectManager(db);
+      const parts = args.trim().split(/\s+/);
+      const action = parts[0] || "";
+      if (!action || action === "list") {
+        const projects = pm.projects.list();
+        if (projects.length === 0) {
+          return "No projects registered. Run: /project register or storm projects import ~/Projects";
+        }
+        const active = pm.getActive();
+        const lines = projects.map((p) => {
+          const marker = active && active.id === p.id ? " \u2190 active" : "";
+          return `  ${p.name.padEnd(25)} ${p.path}${marker}`;
+        });
+        return `Projects:
+${lines.join("\n")}`;
+      }
+      if (action === "register") {
+        const path = parts[1] || process.cwd();
+        try {
+          const project = pm.register(path);
+          return `\u2713 Registered "${project.name}" \u2192 ${project.path}`;
+        } catch (err) {
+          return `\u2717 ${err instanceof Error ? err.message : String(err)}`;
+        }
+      }
+      if (action === "show") {
+        const name = parts[1];
+        if (!name) return "Usage: /project show <name>";
+        const project = pm.projects.getByName(name);
+        if (!project) return `Project "${name}" not found.`;
+        const dash = pm.dashboard(project.id);
+        if (!dash) return "Failed to load dashboard.";
+        const lines = [
+          `\u2500\u2500 ${project.name} \u2500\u2500`,
+          `Path: ${project.path}`,
+          project.description ? `Description: ${project.description}` : "",
+          `Sessions: ${dash.sessionCount}`,
+          `Cost today: $${dash.costToday.toFixed(4)}`,
+          `Cost month: $${dash.costThisMonth.toFixed(4)}`
+        ].filter(Boolean);
+        if (project.budgetDaily)
+          lines.push(
+            `Budget daily: $${project.budgetDaily.toFixed(2)} (${dash.budgetDailyUsed.toFixed(0)}% used)`
+          );
+        if (project.budgetMonthly)
+          lines.push(
+            `Budget month: $${project.budgetMonthly.toFixed(2)} (${dash.budgetMonthlyUsed.toFixed(0)}% used)`
+          );
+        return lines.join("\n");
+      }
+      try {
+        const project = pm.switch(action);
+        ctx.rebuildSystemPrompt?.();
+        return `\u2713 Switched to "${project.name}" (${project.path})`;
+      } catch (err) {
+        return `\u2717 ${err instanceof Error ? err.message : String(err)}`;
+      }
+    }
+  },
+  {
+    name: "schedule",
+    aliases: ["sched", "cron"],
+    description: "Manage scheduled tasks for the active project",
+    usage: "/schedule [list|add|history]",
+    execute: async (args) => {
+      const parts = args.trim().split(/\s+/);
+      const action = parts[0] || "list";
+      if (action === "list" || !action) {
+        const { getDb } = await import("@brainst0rm/db");
+        const db = getDb();
+        const tasks = db.prepare(
+          "SELECT * FROM scheduled_tasks WHERE status = 'active' ORDER BY name"
+        ).all();
+        if (tasks.length === 0) {
+          return 'No scheduled tasks. Use: storm schedule add "<prompt>" --project <name> --cron "0 9 * * *"';
+        }
+        const lines = tasks.map((t) => {
+          const cron = t.cron_expression || "one-shot";
+          const mutations = t.allow_mutations ? "read+write" : "read-only";
+          return `  ${t.name.padEnd(25)} ${cron.padEnd(15)} ${mutations.padEnd(12)} $${(t.budget_limit ?? 0).toFixed(2)}`;
+        });
+        return `Scheduled Tasks:
+${lines.join("\n")}`;
+      }
+      if (action === "history") {
+        const { getDb } = await import("@brainst0rm/db");
+        const db = getDb();
+        const runs = db.prepare(
+          "SELECT r.*, t.name as task_name FROM scheduled_task_runs r JOIN scheduled_tasks t ON r.task_id = t.id ORDER BY r.created_at DESC LIMIT 10"
+        ).all();
+        if (runs.length === 0) return "No task run history yet.";
+        const lines = runs.map((r) => {
+          const status = r.status === "completed" ? "\u2713" : r.status === "failed" ? "\u2717" : r.status;
+          const cost = `$${r.cost.toFixed(4)}`;
+          const date = new Date(r.created_at * 1e3).toLocaleDateString();
+          return `  ${status} ${(r.task_name ?? "").padEnd(20)} ${cost.padEnd(10)} ${date}`;
+        });
+        return `Recent Runs:
+${lines.join("\n")}`;
+      }
+      return `Unknown action "${action}". Usage: /schedule [list|history]`;
+    }
+  },
+  {
+    name: "orchestrate",
+    aliases: ["orch"],
+    description: "Coordinate work across multiple projects",
+    usage: '/orchestrate "<description>" [project1,project2,...]',
+    execute: async (args) => {
+      const { OrchestrationEngine } = await import("./dist-GNHTH2DH.js");
+      const { ProjectManager } = await import("./dist-WLTQTLFO.js");
+      const { getDb } = await import("@brainst0rm/db");
+      const db = getDb();
+      const engine = new OrchestrationEngine(db);
+      const pm = new ProjectManager(db);
+      if (!args.trim()) {
+        const runs = engine.listRecent(5);
+        if (runs.length === 0) {
+          return 'No orchestrations yet. Usage: /orchestrate "do something" project1,project2';
+        }
+        const lines2 = runs.map((r) => {
+          const icon = r.status === "completed" ? "\u2713" : r.status === "failed" ? "\u2717" : "\u25CF";
+          return `  ${icon} ${r.name.slice(0, 50)} \u2014 ${r.status} ($${r.totalCost.toFixed(4)})`;
+        });
+        return `Recent orchestrations:
+${lines2.join("\n")}`;
+      }
+      const match = args.match(/^"([^"]+)"\s+(.+)$/) ?? args.match(/^(.+?)\s+([\w,-]+)$/);
+      if (!match) {
+        return 'Usage: /orchestrate "description" project1,project2';
+      }
+      const description = match[1];
+      const projectNames = match[2].split(",").map((s) => s.trim());
+      const lines = [
+        `Orchestrating: "${description}"`,
+        `Projects: ${projectNames.join(", ")}`,
+        ""
+      ];
+      for await (const event of engine.run({ description, projectNames })) {
+        if (event.type === "task-started") {
+          lines.push(`\u25CF ${event.project.name} \u2014 starting...`);
+        } else if (event.type === "task-completed") {
+          lines.push(`\u2713 ${event.project.name} \u2014 $${event.cost.toFixed(4)}`);
+        } else if (event.type === "task-failed") {
+          lines.push(`\u2717 ${event.project.name} \u2014 ${event.error}`);
+        } else if (event.type === "orchestration-completed") {
+          lines.push("", `Complete: $${event.run.totalCost.toFixed(4)} total`);
+        }
+      }
+      return lines.join("\n");
+    }
+  },
+  {
+    name: "intelligence",
+    aliases: ["intel"],
+    description: "Show what BrainstormRouter has learned",
+    usage: "/intelligence [--json]",
+    execute: async (args, _ctx) => {
+      const { createGatewayClient, createIntelligenceClient } = await import("@brainst0rm/gateway");
+      const gw = createGatewayClient();
+      if (!gw) return "No BRAINSTORM_API_KEY set.";
+      const intel = createIntelligenceClient();
+      const asJson = args.includes("--json");
+      const [leaderboard, usage, waste, forecast] = await Promise.all([
+        gw.getLeaderboard().catch(() => []),
+        gw.getUsageSummary("weekly").catch(() => null),
+        gw.getWasteInsights().catch(() => null),
+        gw.getForecast().catch(() => null)
+      ]);
+      if (asJson) {
+        return JSON.stringify({ leaderboard, usage, waste, forecast }, null, 2);
+      }
+      const lines = [];
+      lines.push("BrainstormRouter Intelligence Report");
+      lines.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+      const ud = usage?.data?.[0];
+      const reqs = ud?.requestCount ?? 0;
+      lines.push(
+        `
+Requests: ${reqs.toLocaleString()} | Cost: $${(ud?.totalCostUsd ?? 0).toFixed(2)}`
+      );
+      const real = leaderboard.filter(
+        (m) => m.id && !m.id.startsWith("cache/")
+      );
+      if (real.length > 0) {
+        lines.push("\nTop Models:");
+        for (const m of real.slice(0, 5)) {
+          const name = m.model_id ?? m.id ?? "?";
+          const reward = m.reward_score != null ? (m.reward_score * 100).toFixed(0) + "%" : "n/a";
+          lines.push(
+            `  ${name} \u2014 reward:${reward} (${m.sample_count ?? 0} samples)`
+          );
+        }
+      }
+      const fc = forecast?.forecast;
+      if (fc) {
+        const trend = fc.trend === "increasing" ? "\u2191" : fc.trend === "decreasing" ? "\u2193" : "\u2192";
+        lines.push(
+          `
+Forecast: $${(fc.avgDailySpendUsd ?? 0).toFixed(2)}/day ${trend}`
+        );
+      }
+      const w = waste;
+      if (w?.estimatedWasteUsd > 0) {
+        lines.push(`
+Recoverable waste: $${w.estimatedWasteUsd.toFixed(4)}`);
+      }
+      return lines.join("\n");
+    }
+  },
+  {
+    name: "plan",
+    aliases: [],
+    description: "Toggle plan mode \u2014 agent describes changes before executing",
+    usage: "/plan",
+    execute: async (_args, ctx) => {
+      const current = ctx.getMode?.() ?? "auto";
+      if (current === "plan") {
+        ctx.setMode?.("auto");
+        return "Plan mode OFF \u2014 agent will execute directly.";
+      }
+      ctx.setMode?.("plan");
+      return "Plan mode ON \u2014 agent will describe changes before executing. Approve to proceed.";
+    }
+  },
+  {
+    name: "efficiency",
+    aliases: ["eff"],
+    description: "Show token efficiency and cost savings from routing",
+    usage: "/efficiency",
+    execute: async (_args, ctx) => {
+      const tokens = ctx.getTokenCount?.() ?? { input: 0, output: 0 };
+      const cost = ctx.getSessionCost?.() ?? 0;
+      const totalTokens = tokens.input + tokens.output;
+      const opusCostPer1M = 75;
+      const sonnetCostPer1M = 15;
+      const haikuCostPer1M = 4;
+      const opusCost = totalTokens / 1e6 * opusCostPer1M;
+      const sonnetCost = totalTokens / 1e6 * sonnetCostPer1M;
+      const haikuCost = totalTokens / 1e6 * haikuCostPer1M;
+      const savings = opusCost > 0 ? Math.round((1 - cost / opusCost) * 100) : 0;
+      const lines = [
+        "Token Efficiency Report",
+        "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
+        "",
+        `Tokens used: ${totalTokens.toLocaleString()} (${tokens.input.toLocaleString()} in / ${tokens.output.toLocaleString()} out)`,
+        `Actual cost:  $${cost.toFixed(4)} (with routing)`,
+        "",
+        "If you used a single model for everything:",
+        `  Opus only:   $${opusCost.toFixed(4)}`,
+        `  Sonnet only: $${sonnetCost.toFixed(4)}`,
+        `  Haiku only:  $${haikuCost.toFixed(4)}`,
+        "",
+        `Savings vs Opus: ${savings}%`
+      ];
+      return lines.join("\n");
+    }
+  }
+];
+function createRoleCommand(roleId) {
+  const role = ROLES[roleId];
+  return {
+    name: roleId,
+    aliases: [],
+    description: role.description,
+    usage: `/${roleId} [model-number]`,
+    execute: async (args, ctx) => {
+      let modelId;
+      if (args) {
+        modelId = getModelForRole(roleId, parseInt(args, 10));
+      } else if (ctx.prompt) {
+        const selected = await ctx.prompt(
+          `${role.icon} ${role.displayName} \u2014 pick model`,
+          role.modelChoices.map((m) => ({
+            label: m.label,
+            value: m.modelId,
+            description: `${m.cost} per 1M tokens`,
+            recommended: m.default
+          }))
+        );
+        modelId = selected;
+      } else {
+        return formatModelMenu(roleId);
+      }
+      ctx.setModel?.(modelId);
+      ctx.setOutputStyle?.(role.outputStyle);
+      ctx.setMode?.(role.permissionMode);
+      ctx.setStrategy?.(role.routingStrategy);
+      const { getRolePrompt } = await import("./roles-2DGF4PZU.js");
+      ctx.rebuildSystemPrompt?.(getRolePrompt(roleId, modelId));
+      ctx.setActiveRole?.(roleId);
+      return formatRoleConfirmation(roleId, modelId);
+    }
+  };
+}
+for (const roleId of Object.keys(ROLES)) {
+  commands.push(createRoleCommand(roleId));
+}
+commands.push({
+  name: "role",
+  aliases: [],
+  description: "Show current role or list available roles",
+  usage: "/role",
+  execute: (_args, ctx) => {
+    const current = ctx.getActiveRole?.();
+    if (current && ROLES[current]) {
+      const role = ROLES[current];
+      const model = ctx.getModel?.() ?? "auto";
+      const lines2 = [
+        `${role.icon} ${role.displayName} (active)`,
+        `  Model:      ${model}`,
+        `  Tools:      ${role.allowedTools ? `only: ${role.allowedTools.join(", ")}` : role.blockedTools ? `all except: ${role.blockedTools.join(", ")}` : "all"}`,
+        `  Style:      ${role.outputStyle}`,
+        `  Strategy:   ${role.routingStrategy}`,
+        `  Permission: ${role.permissionMode}`,
+        ``,
+        `Models: ${role.modelChoices.map((m, i) => `${i + 1}.${m.label}`).join(", ")}`,
+        `Switch: /${current} N \u2502 /default to reset`
+      ];
+      return lines2.join("\n");
+    }
+    const lines = Object.values(ROLES).map(
+      (r) => `  /${r.id.padEnd(18)} ${r.icon} ${r.displayName} \u2014 ${r.description}`
+    );
+    return `Available roles:
+${lines.join("\n")}
+
+Usage: /<role> [model-number]`;
+  }
+});
+commands.push({
+  name: "default",
+  aliases: ["reset"],
+  description: "Reset to default session state (no role)",
+  usage: "/default",
+  execute: (_args, ctx) => {
+    ctx.setActiveRole?.(void 0);
+    ctx.rebuildSystemPrompt?.();
+    ctx.setMode?.("confirm");
+    ctx.setOutputStyle?.("concise");
+    ctx.setStrategy?.("combined");
+    return "Session reset to defaults.";
+  }
+});
+commands.push({
+  name: "context",
+  aliases: ["ctx"],
+  description: "Show context window token breakdown",
+  usage: "/context",
+  execute: (_args, ctx) => {
+    const tokens = ctx.getTokenCount?.() ?? { input: 0, output: 0 };
+    const total = tokens.input + tokens.output;
+    const limit = ctx.getContextWindow?.() ?? 128e3;
+    const percent = Math.round(total / limit * 100);
+    const barWidth = 20;
+    const filled = Math.round(percent / 100 * barWidth);
+    const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
+    const lines = [
+      "Context Window Usage",
+      "",
+      `  [${bar}] ${percent}%`,
+      "",
+      `  Input tokens:   ${tokens.input.toLocaleString()}`,
+      `  Output tokens:  ${tokens.output.toLocaleString()}`,
+      `  Total:          ${total.toLocaleString()} / ${limit.toLocaleString()}`,
+      `  Remaining:      ${(limit - total).toLocaleString()}`,
+      "",
+      percent >= 80 ? "  \u26A0 Context is high. Run /compact to free space." : percent >= 60 ? "  Consider running /compact soon." : "  Context usage is healthy."
+    ];
+    return lines.join("\n");
+  }
+});
+commands.push({
+  name: "undo",
+  aliases: [],
+  description: "Remove the last user message and assistant response",
+  usage: "/undo",
+  execute: (_args, ctx) => {
+    const removed = ctx.undoLastTurn?.() ?? 0;
+    if (removed === 0) return "Nothing to undo.";
+    return `Removed ${removed} message${removed > 1 ? "s" : ""}.`;
+  }
+});
+commands.push({
+  name: "changelog",
+  aliases: ["whatsnew"],
+  description: "Show recent features and changes",
+  usage: "/changelog",
+  execute: () => {
+    return [
+      "What's New in Brainstorm",
+      "",
+      "v11 \u2014 Claude Code Parity",
+      "  /context      Token breakdown with visual gauge",
+      "  /insights     Session intelligence + BR waste tips",
+      "  /undo         Remove last turn",
+      "  /build        Multi-model workflow wizard",
+      "  Shift+Tab     Cycle permission modes",
+      "  SelectPrompt  Model asks you to pick from options",
+      "  Autocomplete  Type / to see command suggestions",
+      "  Multi-line    End line with \\ to continue",
+      "  Error badges  [NETWORK] [BUDGET] [AUTH] with hints",
+      "  ?             Shortcut overlay (in non-chat modes)",
+      "",
+      "v10 \u2014 DeerFlow Gaps",
+      "  Artifacts     Workflow outputs persist to disk",
+      "  Temporal      System prompt includes current date",
+      "  Style         Detects comment style, JSDoc, line length",
+      "  Test parsing  vitest/jest/pytest structured results",
+      "",
+      "v9 \u2014 Build Wizard",
+      "  /build desc   Auto-detect workflow + assign models",
+      "",
+      "v7 \u2014 Dashboard",
+      "  4 modes: Chat [1] Dashboard [2] Models [3] Config [4]",
+      "  BR leaderboard, waste detection, guardian audit",
+      "",
+      "v6 \u2014 Roles",
+      "  /architect /sr-developer /jr-developer /qa"
+    ].join("\n");
+  }
+});
+commands.push({
+  name: "insights",
+  aliases: [],
+  description: "Session intelligence \u2014 what Brainstorm learned",
+  usage: "/insights",
+  execute: async (_args, ctx) => {
+    const cost = ctx.getSessionCost?.() ?? 0;
+    const tokens = ctx.getTokenCount?.() ?? { input: 0, output: 0 };
+    const model = ctx.getModel?.() ?? "auto";
+    const strategy = ctx.getStrategy?.() ?? "combined";
+    const role = ctx.getActiveRole?.();
+    const lines = [
+      "Session Insights",
+      "",
+      `  Model: ${model}`,
+      `  Strategy: ${strategy}`,
+      `  Cost: $${cost.toFixed(4)}`,
+      `  Tokens: ${tokens.input.toLocaleString()} in / ${tokens.output.toLocaleString()} out`
+    ];
+    if (role) lines.push(`  Role: ${role}`);
+    const totalTokens = tokens.input + tokens.output;
+    if (totalTokens > 0) {
+      const costPer1k = cost / totalTokens * 1e3;
+      lines.push("");
+      lines.push(`  Cost efficiency: $${costPer1k.toFixed(4)} per 1K tokens`);
+    }
+    if (ctx.gateway) {
+      try {
+        const waste = await ctx.gateway.getWasteInsights();
+        if (waste?.suggestions?.length > 0) {
+          lines.push("");
+          lines.push("  Optimization suggestions:");
+          for (const s of waste.suggestions.slice(0, 3)) {
+            lines.push(
+              `    \u2192 ${s.description} (save ~$${s.savings_usd?.toFixed(2) ?? "?"})`
+            );
+          }
+        }
+      } catch {
+      }
+    }
+    return lines.join("\n");
+  }
+});
+commands.push({
+  name: "build",
+  aliases: ["b"],
+  description: "Multi-model workflow wizard \u2014 assemble a dev team",
+  usage: "/build [description]",
+  execute: async (args, ctx) => {
+    if (!args) {
+      return "Usage: /build <what you want to build>\nExample: /build add OAuth login";
+    }
+    let state = createWizardState();
+    state = processDescription(state, args);
+    if (!state.workflow) {
+      return `Could not detect workflow type for: "${args}"`;
+    }
+    if (ctx.prompt) {
+      const action = await ctx.prompt(
+        `Detected: ${state.detectedPreset} (${state.assignments.length} steps)`,
+        [
+          {
+            label: "Go with defaults",
+            value: "defaults",
+            description: formatPipeline(state),
+            recommended: true
+          },
+          { label: "Customize models", value: "customize" },
+          { label: "Cancel", value: "cancel" }
+        ]
+      );
+      if (action === "cancel") return "Build cancelled.";
+      if (action === "customize") {
+        for (let i = 0; i < state.assignments.length; i++) {
+          const a = state.assignments[i];
+          const choices = getModelChoicesForStep(a.stepRole);
+          const selected = await ctx.prompt(
+            `Step ${i + 1}: ${a.stepRole}`,
+            choices.map((m) => ({
+              label: m.label,
+              value: m.modelId,
+              description: `${m.cost} per 1M tokens`,
+              recommended: m.modelId === a.modelId
+            }))
+          );
+          const choice = choices.find((m) => m.modelId === selected);
+          if (choice) state = updateAssignment(state, i, choice);
+        }
+      }
+      return `${formatPipeline(state)}
+
+Ready to execute. Use /build-go to start.`;
+    }
+    _pendingWizard = state;
+    return `${formatPipeline(state)}
+
+/build-go to run \u2502 /build-customize for options`;
+  }
+});
+var _pendingWizard = null;
+commands.push({
+  name: "build-go",
+  aliases: ["bg"],
+  description: "Execute the pending build workflow",
+  usage: "/build-go",
+  execute: async (_args, ctx) => {
+    if (!_pendingWizard || !_pendingWizard.workflow) {
+      return "No pending build. Use /build <description> first.";
+    }
+    const state = _pendingWizard;
+    _pendingWizard = null;
+    const { stepModelOverrides } = buildWorkflowOverrides(state);
+    const lines = [`Executing: ${state.detectedPreset}`, ""];
+    for (const a of state.assignments) {
+      lines.push(
+        `  ${ROLE_ICONS_SLASH[a.stepRole] ?? "\u2699"} ${a.stepRole}: ${a.modelLabel}`
+      );
+    }
+    lines.push("");
+    lines.push(`Estimated cost: ~$${state.totalCost.toFixed(4)}`);
+    lines.push("");
+    lines.push("Workflow started \u2014 results will appear in chat.");
+    return lines.join("\n");
+  }
+});
+var ROLE_ICONS_SLASH = {
+  architect: "\u{1F3D7}",
+  coder: "\u{1F468}\u200D\u{1F4BB}",
+  reviewer: "\u{1F50D}",
+  debugger: "\u{1F527}",
+  analyst: "\u{1F4CA}"
+};
+commands.push({
+  name: "build-customize",
+  aliases: ["bc"],
+  description: "Show model options for each pipeline step",
+  usage: "/build-customize",
+  execute: (_args, ctx) => {
+    if (!_pendingWizard || !_pendingWizard.workflow) {
+      return "No pending build. Use /build <description> first.";
+    }
+    const lines = ["Model options per step:", ""];
+    for (let i = 0; i < _pendingWizard.assignments.length; i++) {
+      const a = _pendingWizard.assignments[i];
+      const choices = getModelChoicesForStep(a.stepRole);
+      lines.push(`${i + 1}. ${a.stepRole} [${a.modelLabel}]`);
+      choices.forEach((m, j) => {
+        const cur = m.modelId === a.modelId ? " \u2190" : "";
+        lines.push(`   ${j + 1}. ${m.label} ${m.cost}${cur}`);
+      });
+      lines.push(`   /build-set ${i + 1} N`);
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+});
+commands.push({
+  name: "build-set",
+  aliases: ["bs"],
+  description: "Set model for a pipeline step",
+  usage: "/build-set <step> <model-number>",
+  execute: (_args, ctx) => {
+    if (!_pendingWizard || !_pendingWizard.workflow) {
+      return "No pending build. Use /build <description> first.";
+    }
+    const parts = _args.split(/\s+/);
+    const stepIdx = parseInt(parts[0], 10) - 1;
+    const modelIdx = parseInt(parts[1], 10) - 1;
+    if (isNaN(stepIdx) || stepIdx < 0 || stepIdx >= _pendingWizard.assignments.length) {
+      return `Invalid step. Use 1-${_pendingWizard.assignments.length}.`;
+    }
+    const a = _pendingWizard.assignments[stepIdx];
+    const choices = getModelChoicesForStep(a.stepRole);
+    if (isNaN(modelIdx) || modelIdx < 0 || modelIdx >= choices.length) {
+      return `Invalid model. Use 1-${choices.length}.`;
+    }
+    _pendingWizard = updateAssignment(
+      _pendingWizard,
+      stepIdx,
+      choices[modelIdx]
+    );
+    const updated = _pendingWizard.assignments[stepIdx];
+    return `${a.stepRole} \u2192 ${updated.modelLabel}
+
+${formatPipeline(_pendingWizard)}
+
+/build-go to run`;
+  }
+});
+commands.push({
+  name: "plan",
+  aliases: [],
+  description: "Toggle plan mode \u2014 agent describes changes before executing",
+  usage: "/plan",
+  execute: (_args, ctx) => {
+    const current = ctx.getMode?.() ?? "confirm";
+    if (current === "plan") {
+      ctx.setMode?.("confirm");
+      return "Plan mode OFF \u2014 agent will execute changes directly (with confirmation).";
+    }
+    ctx.setMode?.("plan");
+    return "Plan mode ON \u2014 agent will describe changes before executing. Approve to proceed.";
+  }
+});
+commands.push({
+  name: "efficiency",
+  aliases: ["eff"],
+  description: "Show token efficiency and routing savings",
+  usage: "/efficiency",
+  execute: (_args, ctx) => {
+    const tokens = ctx.getTokenCount?.() ?? { input: 0, output: 0 };
+    const cost = ctx.getSessionCost?.() ?? 0;
+    const totalTokens = tokens.input + tokens.output;
+    const opusInputCost = tokens.input / 1e6 * 15;
+    const opusOutputCost = tokens.output / 1e6 * 75;
+    const opusCost = opusInputCost + opusOutputCost;
+    const savings = opusCost > 0 ? (opusCost - cost) / opusCost * 100 : 0;
+    const lines = [
+      "Token Efficiency Report",
+      "",
+      `  Input tokens:   ${tokens.input.toLocaleString()}`,
+      `  Output tokens:  ${tokens.output.toLocaleString()}`,
+      `  Total tokens:   ${totalTokens.toLocaleString()}`,
+      "",
+      `  Session cost:   $${cost.toFixed(4)}`
+    ];
+    if (totalTokens > 0) {
+      lines.push(
+        `  Cost per 1K:    $${(cost / totalTokens * 1e3).toFixed(4)}`
+      );
+    }
+    lines.push("");
+    lines.push(`  If you used Opus for everything: $${opusCost.toFixed(4)}`);
+    lines.push(`  With routing:                    $${cost.toFixed(4)}`);
+    lines.push(
+      `  Savings:                         ${savings > 0 ? savings.toFixed(1) : "0"}%`
+    );
+    if (savings > 50) {
+      lines.push("");
+      lines.push("  Routing is saving you significant cost.");
+    } else if (savings > 0) {
+      lines.push("");
+      lines.push(
+        "  Tip: Use /strategy cost-first for cheaper tasks to increase savings."
+      );
+    }
+    return lines.join("\n");
+  }
+});
+commands.push({
+  name: "history",
+  aliases: ["hist"],
+  description: "Show recent input history",
+  usage: "/history",
+  execute: (_args, ctx) => {
+    return "Input history:\n  Use \u2191/\u2193 arrow keys to navigate previous inputs.\n  History persists across sessions in ~/.brainstorm/input-history.json";
+  }
+});
+commands.push({
+  name: "recommend",
+  aliases: ["rec"],
+  description: "Get model recommendation from BrainstormRouter",
+  usage: "/recommend [task-type]",
+  execute: async (args, ctx) => {
+    if (!ctx.gateway) return "No BrainstormRouter API key configured.";
+    try {
+      const { IntelligenceAPIClient } = await import("@brainst0rm/gateway");
+      const key = process.env._BR_RESOLVED_KEY ?? process.env.BRAINSTORM_API_KEY;
+      if (!key) return "No BR API key available.";
+      const intel = new IntelligenceAPIClient(
+        "https://api.brainstormrouter.com",
+        key
+      );
+      const taskType = args || "code-generation";
+      const recs = await intel.getRecommendations(taskType, "typescript");
+      if (!recs || recs.length === 0)
+        return `No recommendations for task type: ${taskType}`;
+      const lines = recs.slice(0, 3).map((r, i) => {
+        return `  ${i + 1}. ${r.recommendedModel ?? r.model} (${Math.round((r.confidence ?? r.score ?? 0) * 100)}% confidence)
+     ${r.reasoning ?? ""}`;
+      });
+      return `Model recommendations for "${taskType}":
+${lines.join("\n")}
+
+Use: /model <id> to switch`;
+    } catch (err) {
+      return `Recommendation failed: ${err.message}`;
+    }
+  }
+});
+commands.push({
+  name: "stats",
+  aliases: [],
+  description: "Show session analytics and BR usage summary",
+  usage: "/stats",
+  execute: async (_args, ctx) => {
+    const cost = ctx.getSessionCost?.() ?? 0;
+    const tokens = ctx.getTokenCount?.() ?? { input: 0, output: 0 };
+    const model = ctx.getModel?.() ?? "auto";
+    const role = ctx.getActiveRole?.();
+    const strategy = ctx.getStrategy?.() ?? "combined";
+    const lines = [
+      "Session Stats",
+      `  Cost:     $${cost.toFixed(4)}`,
+      `  Tokens:   ${tokens.input.toLocaleString()} in / ${tokens.output.toLocaleString()} out`,
+      `  Model:    ${model}`,
+      `  Strategy: ${strategy}`
+    ];
+    if (role) lines.push(`  Role:     ${role}`);
+    if (ctx.gateway) {
+      try {
+        const summary = await ctx.gateway.getUsageSummary("daily");
+        if (summary) {
+          lines.push("");
+          lines.push("BrainstormRouter (today)");
+          lines.push(`  Requests: ${summary.total_requests ?? 0}`);
+          lines.push(
+            `  Cost:     $${(summary.total_cost_usd ?? 0).toFixed(4)}`
+          );
+          if (summary.by_model?.length > 0) {
+            lines.push("  By model:");
+            for (const m of summary.by_model.slice(0, 5)) {
+              lines.push(
+                `    ${m.model}: $${m.cost_usd?.toFixed(4) ?? "0"} (${m.request_count ?? 0} reqs)`
+              );
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return lines.join("\n");
+  }
+});
+commands.push({
+  name: "compare",
+  aliases: [],
+  description: "Compare two models side by side",
+  usage: "/compare <model1> <model2>",
+  execute: (_args, ctx) => {
+    const parts = _args.split(/\s+/);
+    if (parts.length < 2)
+      return "Usage: /compare model1 model2\nExample: /compare anthropic/claude-sonnet-4-6 deepseek/deepseek-chat";
+    return `Model comparison for: ${parts[0]} vs ${parts[1]}
+  (Switch to Models mode [Esc \u2192 3] for detailed comparison with gauges)`;
+  }
+});
+commands.push({
+  name: "architect-edit",
+  aliases: ["ae", "dual"],
+  description: "Dual-model mode: reasoning model plans, fast model applies (Aider-style)",
+  usage: "/architect-edit [task description]",
+  execute: async (args, ctx) => {
+    if (!args.trim()) {
+      return "Usage: /architect-edit <task description>\n\nA reasoning model (Opus/GPT-5.4) will plan the change, then a fast model (Sonnet/GPT-4.1) will apply it.";
+    }
+    const { ROLES: ROLES2, getRolePrompt } = await import("./roles-2DGF4PZU.js");
+    const architect = ROLES2.architect;
+    const planModel = architect.modelChoices[0]?.models[0] ?? "anthropic/claude-opus-4.6";
+    ctx.setModel?.(planModel);
+    ctx.setMode?.("plan");
+    ctx.rebuildSystemPrompt?.(
+      getRolePrompt("architect", planModel) + `
+
+## Architect-Edit Mode
+
+You are in Phase 1 (PLAN). Your job is to analyze the codebase and produce a detailed, actionable implementation plan. Do NOT make any changes \u2014 only read files and produce the plan. Include specific file paths, function names, and code snippets. After you present the plan, the user will approve it and a fast coding model will execute it.
+
+Task: ${args.trim()}`
+    );
+    return [
+      `\u{1F3D7}\uFE0F Architect-Edit mode activated`,
+      ``,
+      `  Phase 1 (PLAN): ${planModel}`,
+      `  Phase 2 (EDIT): will auto-switch to fast model after approval`,
+      ``,
+      `Describe your changes and the architect will plan them.`,
+      `After approving the plan, type /ae-apply to switch to the coding model.`
+    ].join("\n");
+  }
+});
+commands.push({
+  name: "ae-apply",
+  aliases: ["apply"],
+  description: "Switch from architect plan phase to coding apply phase",
+  usage: "/ae-apply",
+  execute: async (_args, ctx) => {
+    const { ROLES: ROLES2 } = await import("./roles-2DGF4PZU.js");
+    const dev = ROLES2["sr-developer"];
+    const codeModel = dev.modelChoices[0]?.models[0] ?? "anthropic/claude-sonnet-4.6";
+    ctx.setModel?.(codeModel);
+    ctx.setMode?.("auto");
+    ctx.rebuildSystemPrompt?.();
+    return [
+      `\u26A1 Switched to coding model: ${codeModel}`,
+      ``,
+      `The plan from the architect is in your conversation history.`,
+      `Now implement it. Auto-verify after each edit.`
+    ].join("\n");
+  }
+});
+commands.push({
+  name: "recipe",
+  aliases: ["recipes"],
+  description: "List, run, or init shareable YAML workflow recipes",
+  usage: "/recipe [list|run <name>|init]",
+  execute: async (args, ctx) => {
+    const { listRecipes, loadRecipe, initRecipeDir } = await import("@brainst0rm/workflow");
+    const cwd = process.cwd();
+    const parts = args.trim().split(/\s+/);
+    const subcommand = parts[0]?.toLowerCase() ?? "list";
+    if (subcommand === "init") {
+      const dir = initRecipeDir(cwd);
+      return `Recipe directory initialized: ${dir}
+An example recipe was created. Edit it or add new .yaml files.`;
+    }
+    if (subcommand === "run") {
+      const name = parts[1];
+      if (!name) return "Usage: /recipe run <name>";
+      const recipe = loadRecipe(cwd, name);
+      if (!recipe)
+        return `Recipe '${name}' not found. Run /recipe list to see available recipes.`;
+      return [
+        `Recipe loaded: ${recipe.name}`,
+        `  ${recipe.description}`,
+        `  Steps: ${recipe.steps.map((s) => s.id).join(" \u2192 ")}`,
+        `  Max iterations: ${recipe.maxIterations}`,
+        ``,
+        `To execute, describe the task and the workflow engine will use this recipe.`
+      ].join("\n");
+    }
+    const recipes = listRecipes(cwd);
+    if (recipes.length === 0) {
+      return "No recipes found. Run /recipe init to create the recipe directory with an example.";
+    }
+    const lines = recipes.map(
+      (r) => `  ${r.id.padEnd(20)} ${r.name} (${r.source}) \u2014 ${r.description}`
+    );
+    return `Available recipes:
+${lines.join("\n")}
+
+Usage: /recipe run <name>`;
+  }
+});
+commands.push({
+  name: "voice",
+  aliases: ["mic"],
+  description: "Record voice input and transcribe via Whisper (requires sox)",
+  usage: "/voice",
+  execute: async () => {
+    const { AudioRecorder } = await import("./recorder-SPYYF4DL.js");
+    if (!AudioRecorder.isAvailable()) {
+      return "Voice input requires `sox`. Install: brew install sox (macOS) or apt install sox (Linux).";
+    }
+    const recorder = new AudioRecorder();
+    const outputPath = recorder.start();
+    return [
+      "\u{1F399}\uFE0F Recording... Press Enter to stop.",
+      "",
+      `  Audio file: ${outputPath}`,
+      `  Transcription will be sent via BrainstormRouter Whisper API.`,
+      "",
+      "  Note: Full voice loop (record \u2192 transcribe \u2192 send) is coming in a future update.",
+      "  For now, the audio file is saved for manual transcription."
+    ].join("\n");
+  }
+});
+var commandMap = /* @__PURE__ */ new Map();
+for (const cmd of commands) {
+  commandMap.set(cmd.name, cmd);
+  for (const alias of cmd.aliases) {
+    commandMap.set(alias, cmd);
+  }
+}
+function isSlashCommand(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) return false;
+  const name = trimmed.slice(1).split(/\s+/)[0].toLowerCase();
+  return commandMap.has(name);
+}
+async function executeSlashCommand(input, ctx) {
+  const trimmed = input.trim();
+  const parts = trimmed.slice(1).split(/\s+/);
+  const name = parts[0].toLowerCase();
+  const args = parts.slice(1).join(" ");
+  const cmd = commandMap.get(name);
+  if (!cmd) {
+    return `Unknown command: /${name}. Type /help for available commands.`;
+  }
+  return cmd.execute(args, ctx, name);
+}
+function getSlashCommands() {
+  return commands.map(({ name, description, usage }) => ({
+    name,
+    description,
+    usage
+  }));
+}
+
+export {
+  isSlashCommand,
+  executeSlashCommand,
+  getSlashCommands
+};
+//# sourceMappingURL=chunk-55ITCWZZ.js.map