crewswarm 0.9.2 → 0.9.4

package/scripts/live-bridge-matrix.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const jsonMode = process.argv.includes("--json");
+const home = os.homedir();
+const crewDir = path.join(home, ".crewswarm");
+const logsDir = path.join(crewDir, "logs");
+
+function exists(file) {
+  try {
+    return fs.existsSync(file);
+  } catch {
+    return false;
+  }
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+const telegramCfg = readJson(path.join(crewDir, "telegram-bridge.json"));
+const whatsappCfg = readJson(path.join(crewDir, "whatsapp-bridge.json"));
+
+const payload = {
+  telegram: {
+    configured: Boolean(telegramCfg?.token),
+    allowedChats: Array.isArray(telegramCfg?.allowedChatIds) ? telegramCfg.allowedChatIds.length : 0,
+    logFile: path.join(logsDir, "telegram-bridge.jsonl"),
+    messagesFile: path.join(logsDir, "telegram-messages.jsonl"),
+    logPresent: exists(path.join(logsDir, "telegram-bridge.jsonl")),
+    messagesPresent: exists(path.join(logsDir, "telegram-messages.jsonl")),
+  },
+  whatsapp: {
+    configured: exists(path.join(crewDir, "whatsapp-auth", "creds.json")),
+    allowedNumbers: Array.isArray(whatsappCfg?.allowedNumbers) ? whatsappCfg.allowedNumbers.length : 0,
+    logFile: path.join(logsDir, "whatsapp-bridge.jsonl"),
+    messagesFile: path.join(logsDir, "whatsapp-messages.jsonl"),
+    logPresent: exists(path.join(logsDir, "whatsapp-bridge.jsonl")),
+    messagesPresent: exists(path.join(logsDir, "whatsapp-messages.jsonl")),
+  },
+  checklist: [
+    "1. Start the stack with `npm run restart-all`.",
+    "2. Run `node scripts/health-check.mjs` and confirm crew-lead/dashboard are up.",
+    "3. For Telegram: run `node --test test/e2e/telegram-roundtrip.test.mjs` with a configured bot token.",
+    "4. For WhatsApp: run `node --test test/e2e/whatsapp-roundtrip.test.mjs` after QR auth is established.",
+    "5. Send one inbound message and confirm project/history logs update.",
+  ],
+};
+
+if (jsonMode) {
+  console.log(JSON.stringify(payload, null, 2));
+  process.exit(0);
+}
+
+console.log("CrewSwarm live bridge matrix");
+console.log("");
+console.log("Telegram:");
+console.log(`  configured: ${payload.telegram.configured ? "yes" : "no"}`);
+console.log(`  allowed chats: ${payload.telegram.allowedChats}`);
+console.log(`  log present: ${payload.telegram.logPresent ? "yes" : "no"}`);
+console.log(`  messages log present: ${payload.telegram.messagesPresent ? "yes" : "no"}`);
+console.log("");
+console.log("WhatsApp:");
+console.log(`  configured: ${payload.whatsapp.configured ? "yes" : "no"}`);
+console.log(`  allowed numbers: ${payload.whatsapp.allowedNumbers}`);
+console.log(`  log present: ${payload.whatsapp.logPresent ? "yes" : "no"}`);
+console.log(`  messages log present: ${payload.whatsapp.messagesPresent ? "yes" : "no"}`);
+console.log("");
+console.log("Checklist:");
+for (const item of payload.checklist) {
+  console.log(`  ${item}`);
+}

package/scripts/live-cli-matrix.mjs

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import { execFileSync, spawn } from "node:child_process";
+
+const jsonMode = process.argv.includes("--json");
+const smokeMode = process.argv.includes("--smoke");
+const cwd = process.cwd();
+const PROMPT = "Reply with exactly CLI_MATRIX_OK and nothing else.";
+const openCodeModel = process.env.CREWSWARM_OPENCODE_MODEL || "opencode/big-pickle";
+
+function hasBin(bin) {
+  try {
+    if (bin.includes("/") && fs.existsSync(bin)) return true;
+    execFileSync("which", [bin], { stdio: "pipe", timeout: 4000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function runCli(bin, args, timeoutMs = Number(process.env.CREWSWARM_LIVE_CLI_TIMEOUT_MS || 30000)) {
+  return new Promise((resolve) => {
+    const child = spawn(bin, args, {
+      cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let done = false;
+    const timer = setTimeout(() => {
+      if (!done) {
+        done = true;
+        child.kill("SIGKILL");
+        resolve({ ok: false, error: `timeout after ${timeoutMs}ms`, stdout, stderr });
+      }
+    }, timeoutMs);
+
+    child.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
+    child.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
+    child.on("error", (error) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve({ ok: false, error: String(error.message || error), stdout, stderr });
+    });
+    child.on("close", (code) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      const combined = `${stdout}\n${stderr}`;
+      resolve({
+        ok: code === 0 && combined.includes("CLI_MATRIX_OK"),
+        code,
+        stdout,
+        stderr,
+      });
+    });
+  });
+}
+
+const cursorBin = process.env.CURSOR_CLI_BIN || "agent";
+const clis = [
+  {
+    id: "claude",
+    available: hasBin("claude"),
+    command: ["claude", ["-p", "--print", PROMPT]],
+    timeoutMs: Number(process.env.CREWSWARM_LIVE_CLAUDE_TIMEOUT_MS || 120000),
+  },
+  {
+    id: "codex",
+    available: hasBin("codex"),
+    command: ["codex", ["exec", "--sandbox", "read-only", "--json", PROMPT]],
+    timeoutMs: Number(process.env.CREWSWARM_LIVE_CODEX_TIMEOUT_MS || 30000),
+  },
+  {
+    id: "cursor",
+    available: hasBin(cursorBin),
+    command: [
+      cursorBin,
+      [
+        "-p",
+        "--force",
+        "--trust",
+        "--output-format",
+        "stream-json",
+        PROMPT,
+        "--model",
+        process.env.CREWSWARM_CURSOR_MODEL || "composer-2-fast",
+        "--workspace",
+        cwd,
+      ],
+    ],
+    timeoutMs: Number(process.env.CREWSWARM_LIVE_CURSOR_TIMEOUT_MS || 30000),
+  },
+  {
+    id: "gemini",
+    available: hasBin("gemini"),
+    command: ["gemini", ["-p", PROMPT]],
+    timeoutMs: Number(process.env.CREWSWARM_LIVE_GEMINI_TIMEOUT_MS || 120000),
+  },
+  {
+    id: "opencode",
+    available: hasBin("opencode"),
+    command: ["opencode", ["run", "--model", openCodeModel, PROMPT]],
+    timeoutMs: Number(process.env.CREWSWARM_LIVE_OPENCODE_TIMEOUT_MS || 120000),
+  },
+  {
+    id: "crew-cli",
+    available: true,
+    command: ["node", ["crew-cli/bin/crew.js", "exec", PROMPT]],
+    timeoutMs: Number(process.env.CREWSWARM_LIVE_CREWCLI_TIMEOUT_MS || 30000),
+  },
+];
+
+const results = [];
+if (smokeMode) {
+  for (const cli of clis.filter((item) => item.available)) {
+    const [bin, args] = cli.command;
+    const started = Date.now();
+    const result = await runCli(bin, args, cli.timeoutMs);
+    results.push({
+      cli: cli.id,
+      durationMs: Date.now() - started,
+      ...result,
+    });
+  }
+}
+
+const payload = {
+  cwd,
+  smokeMode,
+  clis: clis.map(({ id, available, command }) => ({ id, available, command: [command[0], ...command[1]] })),
+  results,
+  checklist: [
+    "Run `node scripts/live-cli-matrix.mjs --smoke` to execute one tiny one-shot through each installed CLI.",
+    "Expect some failures if auth/session state or credits are missing for a given lane.",
+    "Use this as a release-time trust check, not an always-on CI gate.",
+  ],
+};
+
+if (jsonMode) {
+  console.log(JSON.stringify(payload, null, 2));
+  process.exit(0);
+}
+
+console.log("CrewSwarm live CLI matrix");
+console.log("");
+for (const cli of payload.clis) {
+  console.log(`${cli.id.padEnd(10)} ${cli.available ? "available" : "missing"}`);
+}
+if (smokeMode) {
+  console.log("");
+  console.log("Smoke results:");
+  for (const result of results) {
+    const status = result.ok ? "PASS" : "FAIL";
+    const detail = result.ok
+      ? (result.stdout || result.stderr).trim().slice(0, 120)
+      : (result.error || result.stderr || result.stdout || "").trim().slice(0, 160);
+    console.log(`${status.padEnd(5)} ${result.cli.padEnd(10)} ${detail}`);
+  }
+} else {
+  console.log("");
+  console.log("Run with --smoke to execute one tiny real one-shot through each installed CLI.");
+}

package/scripts/live-crewchat-check.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const jsonMode = process.argv.includes("--json");
+const repoRoot = process.cwd();
+const appPath = path.join(os.homedir(), "Applications", "crewchat.app");
+const buildScript = path.join(repoRoot, "build-crewchat.sh");
+const sourcePath = path.join(repoRoot, "apps", "crewchat", "CrewChat.swift");
+
+const payload = {
+  buildScriptPresent: fs.existsSync(buildScript),
+  sourcePresent: fs.existsSync(sourcePath),
+  installedAppPresent: fs.existsSync(appPath),
+  appPath,
+  checklist: [
+    "1. Build: ./build-crewchat.sh",
+    "2. Launch: open -a crewchat.app",
+    "3. Switch between crew-lead, CLI, and agent modes.",
+    "4. Send one text message, one image, and one voice note.",
+    "5. Confirm per-project and per-mode history isolation.",
+  ],
+};
+
+if (jsonMode) {
+  console.log(JSON.stringify(payload, null, 2));
+  process.exit(0);
+}
+
+console.log("crewchat live verification");
+console.log("");
+console.log(`Build script present: ${payload.buildScriptPresent ? "yes" : "no"}`);
+console.log(`Source present: ${payload.sourcePresent ? "yes" : "no"}`);
+console.log(`Installed app present: ${payload.installedAppPresent ? "yes" : "no"}`);
+console.log(`App path: ${payload.appPath}`);
+console.log("");
+console.log("Checklist:");
+for (const item of payload.checklist) {
+  console.log(`  ${item}`);
+}

package/scripts/live-engine-matrix.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const configPath = path.join(os.homedir(), ".crewswarm", "crewswarm.json");
+const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+const agents = Array.isArray(config.agents) ? config.agents : config.agents?.list || [];
+
+function detectRoute(agent) {
+  if (agent.useCursorCli) return "cursor";
+  if (agent.useClaudeCode) return "claude-code";
+  if (agent.useCodex) return "codex";
+  if (agent.useGeminiCli) return "gemini-cli";
+  if (agent.useCrewCLI) return "crew-cli";
+  if (agent.useOpenCode) return "opencode";
+  if (agent.useDockerSandbox) return "docker-sandbox";
+  return "direct";
+}
+
+function modelForRoute(agent, route) {
+  if (route === "cursor") return agent.cursorCliModel || "(auto)";
+  if (route === "claude-code") return agent.claudeCodeModel || "(auto)";
+  if (route === "codex") return agent.codexModel || "(auto)";
+  if (route === "gemini-cli") return agent.geminiCliModel || "(auto)";
+  if (route === "crew-cli") return agent.crewCliModel || "(default)";
+  if (route === "opencode") return agent.opencodeModel || "(default)";
+  return agent.model || "(none)";
+}
+
+const rows = agents.map((agent) => {
+  const route = detectRoute(agent);
+  return {
+    id: agent.id,
+    route,
+    model: modelForRoute(agent, route),
+    fallback: agent.fallbackModel || agent.opencodeFallbackModel || "",
+  };
+});
+
+console.log("CrewSwarm live engine matrix");
+console.log("");
+for (const row of rows) {
+  console.log(`${row.id.padEnd(22)} ${row.route.padEnd(15)} ${row.model}${row.fallback ? `  fallback=${row.fallback}` : ""}`);
+}
+
+console.log("");
+console.log("Next step:");
+console.log("Run a real task through each important route and confirm the observed runtime/model in logs or UI.");

package/scripts/live-provider-failover-matrix.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const jsonMode = process.argv.includes("--json");
+const configPath = path.join(os.homedir(), ".crewswarm", "crewswarm.json");
+
+function readConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+const cfg = readConfig();
+const providers = cfg.providers || {};
+const agents = Array.isArray(cfg.agents) ? cfg.agents : cfg.agents?.list || [];
+
+const activeProviders = Object.entries(providers)
+  .filter(([, value]) => value?.apiKey && String(value.apiKey).trim())
+  .map(([id, value]) => ({
+    id,
+    hasBaseUrl: Boolean(value.baseUrl),
+  }));
+
+const interestingAgents = agents
+  .filter((agent) => {
+    return (
+      agent.id === "crew-main" ||
+      agent.id === "crew-coder" ||
+      agent.id === "crew-qa" ||
+      agent.id === "crew-pm" ||
+      agent.useClaudeCode ||
+      agent.useCodex ||
+      agent.useGeminiCli ||
+      agent.useCrewCLI ||
+      agent.useCursorCli
+    );
+  })
+  .map((agent) => ({
+    id: agent.id,
+    primary: agent.model || "(none)",
+    fallback: agent.fallbackModel || agent.opencodeFallbackModel || "",
+    route:
+      agent.useClaudeCode ? "claude-code" :
+      agent.useCodex ? "codex" :
+      agent.useGeminiCli ? "gemini-cli" :
+      agent.useCrewCLI ? "crew-cli" :
+      agent.useCursorCli ? "cursor" :
+      agent.useOpenCode ? "opencode" :
+      "direct",
+  }));
+
+const payload = {
+  configPath,
+  configuredProviders: activeProviders,
+  agents: interestingAgents,
+  checklist: [
+    "1. Run `npm run restart-all` and confirm `node scripts/health-check.mjs` passes.",
+    "2. For each important route, trigger one real task and confirm the observed runtime/model in logs or UI.",
+    "3. Intentionally disable or exhaust one primary provider, then confirm fallback activates.",
+    "4. Record which routes fail closed vs. fail over successfully.",
+  ],
+  sampleTasks: [
+    'crew-main: "say: PROVIDER_FAILOVER_OK"',
+    'crew-coder: "Create test-output/provider-fallback.txt with one line: PROVIDER_FALLBACK_OK"',
+    'crew-qa: "Summarize which provider/model you are using in one line"',
+  ],
+};
+
+if (jsonMode) {
+  console.log(JSON.stringify(payload, null, 2));
+  process.exit(0);
+}
+
+console.log("CrewSwarm live provider/failover matrix");
+console.log("");
+console.log(`Config: ${configPath}`);
+console.log("");
+console.log("Configured providers:");
+if (!activeProviders.length) {
+  console.log("  (none)");
+} else {
+  for (const provider of activeProviders) {
+    console.log(`  - ${provider.id}${provider.hasBaseUrl ? " (custom baseUrl)" : ""}`);
+  }
+}
+console.log("");
+console.log("Interesting agents/routes:");
+for (const agent of interestingAgents) {
+  console.log(
+    `  - ${agent.id}: route=${agent.route} primary=${agent.primary}${agent.fallback ? ` fallback=${agent.fallback}` : ""}`,
+  );
+}
+console.log("");
+console.log("Checklist:");
+for (const item of payload.checklist) {
+  console.log(`  ${item}`);
+}
+console.log("");
+console.log("Sample tasks:");
+for (const item of payload.sampleTasks) {
+  console.log(`  - ${item}`);
+}

package/scripts/live-provider-matrix.mjs

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { _callLLMOnce } from "../lib/crew-lead/llm-caller.mjs";
+
+const jsonMode = process.argv.includes("--json");
+const smokeMode = process.argv.includes("--smoke");
+const configPath = path.join(os.homedir(), ".crewswarm", "crewswarm.json");
+const SMOKE_PROMPT = "Reply with exactly PROVIDER_MATRIX_OK and nothing else.";
+
+function readConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function modelFromConfig(providerId, providerCfg, agents) {
+  const directModel = String(
+    providerCfg?.defaultModel || providerCfg?.model || providerCfg?.chatModel || "",
+  ).trim();
+  if (directModel) return directModel;
+
+  const listed = Array.isArray(providerCfg?.models)
+    ? providerCfg.models.map((entry) => String(entry?.id || "").trim()).filter(Boolean)
+    : [];
+
+  const preferredDefaults = {
+    anthropic: "claude-3-haiku-20240307",
+    nvidia: "meta/llama-3.1-8b-instruct",
+    ollama: "qwen3-coder:480b-cloud",
+    "openai-local": "gpt-5.1",
+    opencode: "gpt-5.1",
+  };
+  const preferred = preferredDefaults[providerId];
+  if (preferred && listed.includes(preferred)) return preferred;
+
+  const prefixMap = {
+    google: ["google/", "gemini"],
+    anthropic: ["anthropic/", "claude"],
+    openai: ["openai/", "gpt-"],
+    xai: ["xai/", "grok"],
+    deepseek: ["deepseek/", "deepseek"],
+    groq: ["groq/", "llama", "mixtral", "qwen", "kimi", "compound"],
+    mistral: ["mistral/", "mistral"],
+    perplexity: ["perplexity/", "sonar"],
+    nvidia: ["nvidia/", "meta/", "google/", "deepseek-ai/"],
+    cerebras: ["cerebras/"],
+    openrouter: ["openrouter/"],
+    fireworks: ["fireworks/", "accounts/fireworks/"],
+    opencode: [],
+    "openai-local": ["openai-local/"],
+  };
+  const prefixes = prefixMap[providerId] || [];
+  const found = agents.find((agent) => {
+    const model = String(agent?.model || "").toLowerCase();
+    return prefixes.some((prefix) => model.startsWith(prefix) || model.includes(prefix));
+  });
+  if (found?.model) return String(found.model);
+
+  const firstListed = listed[0];
+  if (firstListed) return String(firstListed);
+
+  const hardcoded = {
+    google: "gemini-2.5-flash",
+    anthropic: "claude-3-haiku-20240307",
+    openai: "gpt-5.1",
+    xai: "grok-4.1-fast",
+    deepseek: "deepseek-chat",
+    groq: "llama-3.1-8b-instant",
+    mistral: "mistral-small-latest",
+    perplexity: "sonar",
+    nvidia: "meta/llama-3.1-8b-instruct",
+    cerebras: "llama-3.3-70b",
+    openrouter: "meta-llama/llama-3.1-8b-instruct:free",
+    fireworks: "accounts/fireworks/models/gpt-oss-20b",
+    opencode: "gpt-5.1",
+    ollama: "qwen3-coder:480b-cloud",
+    "openai-local": "gpt-5.1",
+  };
+  return hardcoded[providerId] || "(unknown)";
+}
+
+function normalizeModel(providerId, modelId, providerCfg) {
+  const raw = String(modelId || "").trim();
+  if (!raw) return raw;
+
+  const prefixStrips = {
+    google: [/^google\/models\//i, /^google\//i],
+    anthropic: [/^anthropic\//i],
+    openai: [/^openai\//i],
+    xai: [/^xai\//i],
+    deepseek: [/^deepseek\//i],
+    perplexity: [/^perplexity\//i],
+    openrouter: [/^openrouter\//i],
+    fireworks: [/^fireworks\//i],
+  };
+
+  let normalized = raw;
+  for (const pattern of prefixStrips[providerId] || []) {
+    normalized = normalized.replace(pattern, "");
+  }
+
+  if (providerId === "google" && normalized.startsWith("models/")) {
+    normalized = normalized.replace(/^models\//i, "");
+  }
+
+  const listed = Array.isArray(providerCfg?.models)
+    ? providerCfg.models.map((entry) => String(entry?.id || "").trim()).filter(Boolean)
+    : [];
+  if (listed.includes(normalized)) return normalized;
+  if (listed.includes(raw)) return raw;
+
+  if (
+    providerId === "nvidia" &&
+    listed.length > 0 &&
+    (normalized.includes("gemini") || normalized.includes("grok") || normalized.includes("claude"))
+  ) {
+    return listed[0];
+  }
+
+  return normalized;
+}
+
+function mapProviderKey(providerId) {
+  if (providerId === "google") return "google";
+  if (providerId === "xai") return "xai";
+  return providerId;
+}
+
+async function smokeProvider(providerId, providerCfg, modelId) {
+  const messages = [{ role: "user", content: SMOKE_PROMPT }];
+  const started = Date.now();
+  try {
+    const timeoutMs =
+      providerId === "ollama"
+        ? Number(process.env.CREWSWARM_LIVE_OLLAMA_TIMEOUT_MS || 90000)
+        : providerId === "openai-local"
+          ? Number(process.env.CREWSWARM_LIVE_OPENAI_LOCAL_TIMEOUT_MS || 45000)
+          : Number(process.env.CREWSWARM_LIVE_PROVIDER_TIMEOUT_MS || 20000);
+    const reply = await _callLLMOnce(
+      providerCfg.baseUrl,
+      providerCfg.apiKey,
+      modelId,
+      mapProviderKey(providerId),
+      messages,
+      { stream: false, timeoutMs },
+    );
+    const text = String(reply || "").trim();
+    return {
+      ok: text.includes("PROVIDER_MATRIX_OK"),
+      reply: text.slice(0, 120),
+      durationMs: Date.now() - started,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: String(error?.message || error),
+      durationMs: Date.now() - started,
+    };
+  }
+}
+
+const cfg = readConfig();
+const providers = cfg.providers || {};
+const agents = Array.isArray(cfg.agents) ? cfg.agents : cfg.agents?.list || [];
+
+const configuredProviders = Object.entries(providers)
+  .filter(([, value]) => value?.apiKey && value?.baseUrl)
+  .map(([id, value]) => ({
+    id,
+    baseUrl: value.baseUrl,
+    model: normalizeModel(id, modelFromConfig(id, value, agents), value),
+    listedModels: Array.isArray(value.models) ? value.models.length : 0,
+  }));
+
+const results = [];
+if (smokeMode) {
+  for (const provider of configuredProviders) {
+    const providerCfg = providers[provider.id];
+    results.push({
+      provider: provider.id,
+      model: provider.model,
+      ...(await smokeProvider(provider.id, providerCfg, provider.model)),
+    });
+  }
+}
+
+const payload = {
+  configPath,
+  smokeMode,
+  providers: configuredProviders,
+  results,
+  checklist: [
+    "Use `node scripts/live-provider-matrix.mjs --smoke` to run one tiny real call per configured provider.",
+    "Use `node scripts/live-provider-failover-matrix.mjs` to inspect route/fallback expectations.",
+    "Treat failures as wiring, auth, quota, or model-selection issues to investigate before release.",
+  ],
+};
+
+if (jsonMode) {
+  console.log(JSON.stringify(payload, null, 2));
+  process.exit(0);
+}
+
+console.log("CrewSwarm live provider matrix");
+console.log("");
+for (const provider of configuredProviders) {
+  console.log(
+    `${provider.id.padEnd(14)} model=${provider.model}${provider.listedModels ? `  listedModels=${provider.listedModels}` : ""}`,
+  );
+}
+
+if (smokeMode) {
+  console.log("");
+  console.log("Smoke results:");
+  for (const result of results) {
+    const status = result.ok ? "PASS" : "FAIL";
+    const detail = result.ok ? result.reply : result.error;
+    console.log(`${status.padEnd(5)} ${result.provider.padEnd(14)} ${result.model}  ${detail}`);
+  }
+} else {
+  console.log("");
+  console.log("Run with --smoke to send one tiny real request through each configured provider.");
+}

package/scripts/restart-all-from-repo.sh

@@ -241,13 +241,13 @@ else
   SVC_STATUS["mcp-server"]="up"
 fi
 
-# ── 8. Vibe Studio + file watcher (ports 3333, 3334) ────────────────────────
+# ── 8. Vibe + file watcher (ports 3333, 3334) ───────────────────────────────
 if [[ "$START_STUDIO" -eq 1 ]]; then
   echo ""
-  echo "Starting Vibe (Studio) + file watcher (ports 3333, 3334)..."
+  echo "Starting Vibe + file watcher (ports 3333, 3334)..."
   if [[ ! -d "$REPO_DIR/apps/vibe/dist" ]]; then
-    echo "  Building Studio (first run)..."
-    (cd "$REPO_DIR" && npm run studio:build) >/dev/null 2>&1 || true
+    echo "  Building Vibe (first run)..."
+    (cd "$REPO_DIR" && npm run vibe:build) >/dev/null 2>&1 || true
   fi
   sleep 1
   nohup "$NODE" "$REPO_DIR/apps/vibe/server.mjs" >> /tmp/studio.log 2>&1 &