muonroi-cli 1.2.0

package/src/models/catalog.json

@@ -0,0 +1,314 @@
+{
+  "version": "1.0",
+  "updated_at": "2026-05-02",
+  "models": [
+    {
+      "id": "claude-opus-4-7",
+      "name": "Claude Opus 4.7",
+      "provider": "anthropic",
+      "tier": "premium",
+      "context_window": 1000000,
+      "max_output_tokens": 128000,
+      "input_price_per_million": 15,
+      "output_price_per_million": 75,
+      "reasoning": true,
+      "thinking_type": "adaptive",
+      "supports_effort": true,
+      "default_reasoning_effort": "medium",
+      "description": "Most capable Anthropic model with adaptive thinking",
+      "aliases": ["claude-opus-4-7-latest"]
+    },
+    {
+      "id": "claude-sonnet-4-6",
+      "name": "Claude Sonnet 4.6",
+      "provider": "anthropic",
+      "tier": "balanced",
+      "context_window": 1000000,
+      "max_output_tokens": 128000,
+      "input_price_per_million": 3,
+      "output_price_per_million": 15,
+      "reasoning": true,
+      "thinking_type": "enabled",
+      "supports_effort": true,
+      "default_reasoning_effort": "medium",
+      "description": "Balanced Anthropic model for everyday coding",
+      "aliases": ["claude-sonnet-4-6-latest", "claude-sonnet-4-6-20250514"]
+    },
+    {
+      "id": "claude-opus-4-6",
+      "name": "Claude Opus 4.6",
+      "provider": "anthropic",
+      "tier": "premium",
+      "context_window": 1000000,
+      "max_output_tokens": 128000,
+      "input_price_per_million": 15,
+      "output_price_per_million": 75,
+      "reasoning": true,
+      "thinking_type": "enabled",
+      "supports_effort": true,
+      "default_reasoning_effort": "medium",
+      "description": "Premium Anthropic model with extended thinking",
+      "aliases": ["claude-opus-4-6-latest", "claude-opus-4-6-20250514"]
+    },
+    {
+      "id": "claude-opus-4-5-20251101",
+      "name": "Claude Opus 4.5",
+      "provider": "anthropic",
+      "tier": "premium",
+      "context_window": 200000,
+      "max_output_tokens": 32000,
+      "input_price_per_million": 15,
+      "output_price_per_million": 75,
+      "reasoning": true,
+      "thinking_type": "enabled",
+      "supports_effort": false,
+      "default_reasoning_effort": null,
+      "description": "Previous-gen premium Anthropic model",
+      "aliases": ["claude-opus-4-5", "claude-opus-4-5-latest"]
+    },
+    {
+      "id": "claude-haiku-4-5-20251001",
+      "name": "Claude Haiku 4.5",
+      "provider": "anthropic",
+      "tier": "fast",
+      "context_window": 200000,
+      "max_output_tokens": 8000,
+      "input_price_per_million": 0.80,
+      "output_price_per_million": 4,
+      "reasoning": false,
+      "thinking_type": null,
+      "supports_effort": false,
+      "default_reasoning_effort": null,
+      "description": "Fast and affordable Anthropic model",
+      "aliases": ["claude-haiku-4-5", "claude-haiku-4-5-latest"]
+    },
+    {
+      "id": "claude-sonnet-4-5-20250929",
+      "name": "Claude Sonnet 4.5",
+      "provider": "anthropic",
+      "tier": "balanced",
+      "context_window": 1000000,
+      "max_output_tokens": 64000,
+      "input_price_per_million": 3,
+      "output_price_per_million": 15,
+      "reasoning": true,
+      "thinking_type": "enabled",
+      "supports_effort": false,
+      "default_reasoning_effort": null,
+      "description": "Previous-gen balanced Anthropic model",
+      "aliases": ["claude-sonnet-4-5", "claude-sonnet-4-5-latest"]
+    },
+    {
+      "id": "gpt-4o",
+      "name": "GPT-4o",
+      "provider": "openai",
+      "tier": "balanced",
+      "context_window": 128000,
+      "max_output_tokens": 16000,
+      "input_price_per_million": 2.50,
+      "output_price_per_million": 10,
+      "reasoning": false,
+      "thinking_type": null,
+      "supports_effort": false,
+      "default_reasoning_effort": null,
+      "description": "OpenAI flagship multimodal model",
+      "aliases": ["gpt-4o-2024-11-20"]
+    },
+    {
+      "id": "gpt-4o-mini",
+      "name": "GPT-4o Mini",
+      "provider": "openai",
+      "tier": "fast",
+      "context_window": 128000,
+      "max_output_tokens": 16000,
+      "input_price_per_million": 0.15,
+      "output_price_per_million": 0.60,
+      "reasoning": false,
+      "thinking_type": null,
+      "supports_effort": false,
+      "default_reasoning_effort": null,
+      "description": "Small and affordable OpenAI model",
+      "aliases": ["gpt-4o-mini-2024-07-18"]
+    },
+    {
+      "id": "o3",
+      "name": "OpenAI o3",
+      "provider": "openai",
+      "tier": "premium",
+      "context_window": 200000,
+      "max_output_tokens": 100000,
+      "input_price_per_million": 10,
+      "output_price_per_million": 40,
+      "reasoning": true,
+      "thinking_type": "enabled",
+      "supports_effort": true,
+      "default_reasoning_effort": "medium",
+      "description": "OpenAI reasoning model",
+      "aliases": ["o3-2025-04-16"]
+    },
+    {
+      "id": "o3-mini",
+      "name": "OpenAI o3-mini",
+      "provider": "openai",
+      "tier": "fast",
+      "context_window": 200000,
+      "max_output_tokens": 100000,
+      "input_price_per_million": 1.10,
+      "output_price_per_million": 4.40,
+      "reasoning": true,
+      "thinking_type": "enabled",
+      "supports_effort": true,
+      "default_reasoning_effort": "medium",
+      "description": "Affordable OpenAI reasoning model",
+      "aliases": ["o3-mini-2025-01-31"]
+    },
+    {
+      "id": "o4-mini",
+      "name": "OpenAI o4-mini",
+      "provider": "openai",
+      "tier": "fast",
+      "context_window": 200000,
+      "max_output_tokens": 100000,
+      "input_price_per_million": 1.10,
+      "output_price_per_million": 4.40,
+      "reasoning": true,
+      "thinking_type": "enabled",
+      "supports_effort": true,
+      "default_reasoning_effort": "medium",
+      "description": "Affordable OpenAI reasoning model",
+      "aliases": ["o4-mini-2025-04-16"]
+    },
+    {
+      "id": "deepseek-chat",
+      "name": "DeepSeek Chat",
+      "provider": "deepseek",
+      "tier": "balanced",
+      "context_window": 128000,
+      "max_output_tokens": 8000,
+      "input_price_per_million": 0.27,
+      "output_price_per_million": 1.10,
+      "reasoning": false,
+      "thinking_type": null,
+      "supports_effort": false,
+      "default_reasoning_effort": null,
+      "description": "DeepSeek V3 general-purpose model (legacy, deprecated 2026/07/24)",
+      "aliases": ["deepseek-v3"],
+      "supports_vision": false
+    },
+    {
+      "id": "deepseek-reasoner",
+      "name": "DeepSeek Reasoner",
+      "provider": "deepseek",
+      "tier": "premium",
+      "context_window": 128000,
+      "max_output_tokens": 8000,
+      "input_price_per_million": 0.55,
+      "output_price_per_million": 2.19,
+      "reasoning": true,
+      "thinking_type": "enabled",
+      "supports_effort": false,
+      "default_reasoning_effort": null,
+      "description": "DeepSeek R1 reasoning model (legacy, deprecated 2026/07/24)",
+      "aliases": ["deepseek-r1"],
+      "supports_vision": false
+    },
+    {
+      "id": "deepseek-v4-flash",
+      "name": "DeepSeek V4 Flash",
+      "provider": "deepseek",
+      "tier": "fast",
+      "context_window": 128000,
+      "max_output_tokens": 8000,
+      "input_price_per_million": 0.10,
+      "output_price_per_million": 0.40,
+      "reasoning": false,
+      "thinking_type": null,
+      "supports_effort": false,
+      "default_reasoning_effort": null,
+      "description": "Fast and affordable DeepSeek model",
+      "aliases": ["deepseek-flash"],
+      "supports_vision": false
+    },
+    {
+      "id": "deepseek-v4-pro",
+      "name": "DeepSeek V4 Pro",
+      "provider": "deepseek",
+      "tier": "premium",
+      "context_window": 128000,
+      "max_output_tokens": 16000,
+      "input_price_per_million": 2.00,
+      "output_price_per_million": 8.00,
+      "reasoning": true,
+      "thinking_type": "enabled",
+      "supports_effort": false,
+      "default_reasoning_effort": null,
+      "description": "Most capable DeepSeek reasoning model",
+      "aliases": ["deepseek-pro"],
+      "supports_vision": false
+    },
+    {
+      "id": "gemini-2.5-pro",
+      "name": "Gemini 2.5 Pro",
+      "provider": "google",
+      "tier": "premium",
+      "context_window": 1048576,
+      "max_output_tokens": 65536,
+      "input_price_per_million": 1.25,
+      "output_price_per_million": 10,
+      "reasoning": true,
+      "thinking_type": "enabled",
+      "supports_effort": false,
+      "default_reasoning_effort": null,
+      "description": "Google flagship reasoning model",
+      "aliases": ["gemini-2.5-pro-latest"]
+    },
+    {
+      "id": "gemini-2.5-flash",
+      "name": "Gemini 2.5 Flash",
+      "provider": "google",
+      "tier": "fast",
+      "context_window": 1048576,
+      "max_output_tokens": 65536,
+      "input_price_per_million": 0.15,
+      "output_price_per_million": 0.60,
+      "reasoning": true,
+      "thinking_type": "enabled",
+      "supports_effort": false,
+      "default_reasoning_effort": null,
+      "description": "Fast and affordable Google model with thinking",
+      "aliases": ["gemini-2.5-flash-latest"]
+    },
+    {
+      "id": "grok-3",
+      "name": "Grok 3",
+      "provider": "xai",
+      "tier": "premium",
+      "context_window": 131000,
+      "max_output_tokens": 131000,
+      "input_price_per_million": 3,
+      "output_price_per_million": 15,
+      "reasoning": false,
+      "thinking_type": null,
+      "supports_effort": false,
+      "default_reasoning_effort": null,
+      "description": "xAI flagship model",
+      "aliases": ["grok-3-latest"]
+    },
+    {
+      "id": "grok-3-mini",
+      "name": "Grok 3 Mini",
+      "provider": "xai",
+      "tier": "fast",
+      "context_window": 131000,
+      "max_output_tokens": 131000,
+      "input_price_per_million": 0.30,
+      "output_price_per_million": 0.50,
+      "reasoning": true,
+      "thinking_type": "enabled",
+      "supports_effort": true,
+      "default_reasoning_effort": "medium",
+      "description": "Affordable xAI reasoning model",
+      "aliases": ["grok-3-mini-latest"]
+    }
+  ]
+}

package/src/models/classify-tier.ts

@@ -0,0 +1,37 @@
+import type { ModelTier } from "../types/index.js";
+
+/**
+ * Classify a model into fast/balanced/premium tier based on its id and pricing.
+ * Works across all providers — uses name heuristics + pricing signals.
+ */
+
+const FAST_PATTERNS = [
+  /haiku/i, /mini/i, /flash/i, /nano/i, /small/i, /lite/i,
+  /gpt-4o-mini/i, /gpt-3/i,
+  /deepseek-chat/i,
+  /grok-3-mini/i, /grok-2/i,
+  /gemma/i, /phi-/i, /llama.*8b/i,
+];
+
+const PREMIUM_PATTERNS = [
+  /opus/i, /pro(?!ject)/i,
+  /\bo[13]-(?!mini)/i, /o1(?!-mini)/i, /o3(?!-mini)/i,
+  /deepseek-reasoner/i,
+  /grok-3(?!-mini)/i,
+  /ultra/i, /large/i,
+];
+
+export function classifyModelTier(id: string, inputPrice?: number, outputPrice?: number): ModelTier {
+  const lower = id.toLowerCase();
+
+  if (FAST_PATTERNS.some((p) => p.test(lower))) return "fast";
+  if (PREMIUM_PATTERNS.some((p) => p.test(lower))) return "premium";
+
+  // Pricing-based fallback: cheap = fast, expensive = premium
+  if (typeof inputPrice === "number" && inputPrice > 0) {
+    if (inputPrice <= 1) return "fast";
+    if (inputPrice >= 10) return "premium";
+  }
+
+  return "balanced";
+}

package/src/models/index.ts

@@ -0,0 +1,9 @@
+export {
+  getEffectiveReasoningEffort,
+  getModelIds,
+  getModelInfo,
+  getSupportedReasoningEfforts,
+  loadCatalog,
+  MODELS,
+  normalizeModelId,
+} from "./registry";

package/src/models/registry.ts

@@ -0,0 +1,73 @@
+import type { ModelInfo, ReasoningEffort } from "../types";
+import { fetchCatalog, catalogModelToModelInfo } from "./catalog-client.js";
+
+const ALL_REASONING_EFFORTS: ReasoningEffort[] = ["low", "medium", "high", "xhigh"];
+
+// ---------------------------------------------------------------------------
+// Centralized model registry — populated by loadCatalog() at boot
+// ---------------------------------------------------------------------------
+
+export let MODELS: ModelInfo[] = [];
+export let isLoading = true;
+
+/**
+ * Load models from centralized catalog (CP endpoint with static fallback).
+ * Called once at boot. No provider API keys needed.
+ */
+export async function loadCatalog(): Promise<void> {
+  isLoading = true;
+  try {
+    const catalog = await fetchCatalog();
+    MODELS = catalog.map(catalogModelToModelInfo);
+  } catch {
+    // On total failure, MODELS stays empty — callers must handle
+  } finally {
+    isLoading = false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Lookup helpers
+// ---------------------------------------------------------------------------
+
+export function getModelIds(): string[] {
+  return MODELS.map((m) => m.id);
+}
+
+export function getModelInfo(idOrAlias: string): ModelInfo | undefined {
+  return MODELS.find((m) => m.id === idOrAlias || m.aliases?.includes(idOrAlias));
+}
+
+export function normalizeModelId(idOrAlias: string): string {
+  const m = getModelInfo(idOrAlias);
+  return m ? m.id : idOrAlias;
+}
+
+export function getEffectiveReasoningEffort(
+  modelId: string,
+  requestedEffort: ReasoningEffort | undefined,
+): ReasoningEffort | undefined {
+  if (requestedEffort === undefined) return undefined;
+  const info = getModelInfo(modelId);
+  if (!info?.reasoning) return undefined;
+  return requestedEffort;
+}
+
+export function getSupportedReasoningEfforts(modelId: string): ReasoningEffort[] {
+  const info = getModelInfo(modelId);
+  if (!info?.reasoning) return [];
+  return [...ALL_REASONING_EFFORTS];
+}
+
+/**
+ * Pick the first model matching a tier for a given provider.
+ * If no match for provider+tier, returns first model of that tier from any provider.
+ * Returns undefined if no models in that tier exist.
+ */
+export function getModelByTier(tier: "fast" | "balanced" | "premium", preferProvider?: string): ModelInfo | undefined {
+  if (preferProvider) {
+    const providerMatch = MODELS.find((m) => m.tier === tier && m.provider === preferProvider);
+    if (providerMatch) return providerMatch;
+  }
+  return MODELS.find((m) => m.tier === tier);
+}

package/src/ops/bug-report.test.ts

@@ -0,0 +1,172 @@
+import { afterEach, beforeEach, describe, expect, it, type Mock, vi } from "vitest";
+
+// RED phase: import module under test (will fail until bug-report.ts is created)
+import { type BugReportBundle, buildBugReport, formatBugReport } from "./bug-report.js";
+
+// Mock fs/promises for controlled test environment
+// bug-report.ts uses named import { readFile } from "fs/promises"
+vi.mock("fs/promises", () => {
+  const actual = require("fs/promises");
+  return {
+    ...actual,
+    readFile: vi.fn(),
+  };
+});
+
+// Mock runDoctor to avoid real network calls
+vi.mock("./doctor.js", () => ({
+  runDoctor: vi.fn().mockResolvedValue([
+    { name: "bun_version", status: "pass", detail: "Bun 1.3.13" },
+    { name: "os", status: "pass", detail: "linux 5.15" },
+    { name: "key_presence", status: "pass", detail: "API key in env" },
+    { name: "ollama", status: "warn", detail: "Ollama unreachable" },
+    { name: "ee", status: "warn", detail: "EE unreachable" },
+    { name: "qdrant", status: "warn", detail: "Qdrant unreachable" },
+    { name: "error_rate", status: "pass", detail: "0 errors in last 24h" },
+  ]),
+}));
+
+// Mock EE health to avoid real network calls
+vi.mock("../ee/health.js", () => ({
+  health: vi.fn().mockResolvedValue({ ok: false, status: 503 }),
+}));
+
+/** Helper to get the mocked readFile from the vi.mock above */
+async function getMockedReadFile(): Promise<Mock> {
+  const mod = await import("fs/promises");
+  return (mod as unknown as { readFile: Mock }).readFile;
+}
+
+describe("buildBugReport — required sections", () => {
+  beforeEach(async () => {
+    const readFile = await getMockedReadFile();
+    // Default: no config, no error log
+    readFile.mockRejectedValue(new Error("ENOENT: file not found"));
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns all required sections", async () => {
+    const bundle = await buildBugReport();
+    expect(bundle).toHaveProperty("generated_at");
+    expect(bundle).toHaveProperty("bun_version");
+    expect(bundle).toHaveProperty("os");
+    expect(bundle).toHaveProperty("doctor");
+    expect(bundle).toHaveProperty("config_redacted");
+    expect(bundle).toHaveProperty("error_log_tail");
+    expect(bundle.os).toHaveProperty("platform");
+    expect(bundle.os).toHaveProperty("release");
+    expect(bundle.os).toHaveProperty("arch");
+  });
+
+  it("generated_at is a valid ISO 8601 timestamp", async () => {
+    const bundle = await buildBugReport();
+    expect(() => new Date(bundle.generated_at)).not.toThrow();
+    expect(new Date(bundle.generated_at).toISOString()).toBe(bundle.generated_at);
+  });
+
+  it("doctor results contain 7 entries from runDoctor()", async () => {
+    const bundle = await buildBugReport();
+    expect(bundle.doctor).toHaveLength(7);
+  });
+});
+
+describe("buildBugReport — config_redacted does NOT contain authToken", () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("config_redacted excludes ee.authToken and includes cap.monthly_usd", async () => {
+    const mockConfig = JSON.stringify({
+      ee: { authToken: "secret-token-123456" },
+      cap: { monthly_usd: 15 },
+      router: { confidence_threshold: 0.55 },
+    });
+    const readFile = await getMockedReadFile();
+    readFile.mockImplementation((filePath: unknown) => {
+      // Match by filename ending to avoid Windows/Unix path separator issues
+      if (String(filePath).endsWith("config.json")) return Promise.resolve(mockConfig);
+      return Promise.reject(new Error("ENOENT: file not found"));
+    });
+
+    const bundle = await buildBugReport();
+
+    // Should include cap.monthly_usd
+    expect(bundle.config_redacted["cap.monthly_usd"]).toBe(15);
+
+    // Should NOT contain the auth token value anywhere in the bundle JSON
+    const bundleJson = JSON.stringify(bundle);
+    expect(bundleJson).not.toContain("secret-token-123456");
+
+    // Should NOT have authToken as a key
+    expect(Object.keys(bundle.config_redacted)).not.toContain("authToken");
+    expect(Object.keys(bundle.config_redacted)).not.toContain("ee.authToken");
+  });
+});
+
+describe("buildBugReport — error_log_tail scrubs API keys", () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("scrubs sk-ant-* keys from error log lines", async () => {
+    const errorLogContent = [
+      "2026-04-30T10:00:00Z Error calling sk-ant-abc123def456ghi789xyz at /api",
+      "2026-04-30T10:01:00Z Normal log line without secrets",
+    ].join("\n");
+
+    const readFile = await getMockedReadFile();
+    readFile.mockImplementation((filePath: unknown) => {
+      // Match by filename ending to avoid Windows/Unix path separator issues
+      if (String(filePath).endsWith("errors.log")) return Promise.resolve(errorLogContent);
+      return Promise.reject(new Error("ENOENT: file not found"));
+    });
+
+    const bundle = await buildBugReport();
+
+    // The error log tail should not contain the original API key
+    expect(bundle.error_log_tail.join(" ")).not.toContain("sk-ant-abc123def456ghi789xyz");
+    // Should have 2 lines from the log
+    expect(bundle.error_log_tail).toHaveLength(2);
+    // First line should be redacted (contains ***REDACTED***)
+    expect(bundle.error_log_tail[0]).toContain("***REDACTED***");
+    // Normal line should be intact
+    expect(bundle.error_log_tail[1]).toContain("Normal log line without secrets");
+  });
+
+  it("limits error_log_tail to max 20 lines", async () => {
+    const manyLines = Array.from(
+      { length: 30 },
+      (_, i) => `2026-04-30T10:00:0${String(i).padStart(2, "0")}Z Log line ${i}`,
+    ).join("\n");
+
+    const readFile = await getMockedReadFile();
+    readFile.mockImplementation((filePath: unknown) => {
+      if (String(filePath).endsWith("errors.log")) return Promise.resolve(manyLines);
+      return Promise.reject(new Error("ENOENT: file not found"));
+    });
+
+    const bundle = await buildBugReport();
+    expect(bundle.error_log_tail.length).toBeLessThanOrEqual(20);
+  });
+});
+
+describe("formatBugReport — produces valid JSON", () => {
+  it("formatBugReport produces valid JSON string", () => {
+    const bundle: BugReportBundle = {
+      generated_at: new Date().toISOString(),
+      bun_version: "1.3.13",
+      os: { platform: "linux", release: "5.15", arch: "x64" },
+      doctor: [{ name: "os", status: "pass", detail: "linux" }],
+      config_redacted: { "cap.monthly_usd": 15 },
+      error_log_tail: [],
+      ee_status: null,
+    };
+    const json = formatBugReport(bundle);
+    expect(() => JSON.parse(json)).not.toThrow();
+    const parsed = JSON.parse(json);
+    expect(parsed.bun_version).toBe("1.3.13");
+  });
+});

package/src/ops/bug-report.ts

@@ -0,0 +1,80 @@
+/**
+ * src/ops/bug-report.ts
+ *
+ * Anonymized diagnostic bundle builder for muonroi-cli bug-report command.
+ * All secrets are scrubbed via the process-wide redactor before inclusion.
+ *
+ * Config is allowlist-based — only safe fields are included.
+ * Error log tail is limited to 20 lines, all run through redactor.
+ */
+
+import { readFile } from "fs/promises";
+import os from "os";
+import path from "path";
+import { redactor } from "../utils/redactor.js";
+import { type CheckResult, runDoctor } from "./doctor.js";
+
+export interface BugReportBundle {
+  generated_at: string;
+  bun_version: string;
+  os: { platform: string; release: string; arch: string };
+  doctor: CheckResult[];
+  config_redacted: Record<string, unknown>;
+  error_log_tail: string[];
+  ee_status: { ok: boolean; status: number } | null;
+}
+
+async function loadConfigRedacted(): Promise<Record<string, unknown>> {
+  const configPath = path.join(os.homedir(), ".muonroi-cli", "config.json");
+  try {
+    const raw = await readFile(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    // Allowlist — only include safe fields, never include auth tokens or API keys
+    return {
+      "cap.monthly_usd": config?.cap?.monthly_usd ?? null,
+      "router.confidence_threshold": config?.router?.confidence_threshold ?? null,
+      mcp_servers_count: Array.isArray(config?.mcpServers) ? config.mcpServers.length : 0,
+    };
+  } catch {
+    return { error: "config not found" };
+  }
+}
+
+async function loadErrorLogTail(): Promise<string[]> {
+  const logPath = path.join(os.homedir(), ".muonroi-cli", "errors.log");
+  try {
+    const content = await readFile(logPath, "utf-8");
+    const lines = content.split("\n").filter(Boolean);
+    const tail = lines.slice(-20);
+    // Run each line through redactor to scrub any secrets that leaked into logs
+    return tail.map((line) => redactor.redact(line));
+  } catch {
+    return [];
+  }
+}
+
+export async function buildBugReport(): Promise<BugReportBundle> {
+  const [doctor, config, errorTail] = await Promise.all([runDoctor(), loadConfigRedacted(), loadErrorLogTail()]);
+
+  let eeStatus: { ok: boolean; status: number } | null = null;
+  try {
+    const { health } = await import("../ee/health.js");
+    eeStatus = await health();
+  } catch {
+    /* EE unavailable — leave null */
+  }
+
+  return {
+    generated_at: new Date().toISOString(),
+    bun_version: process.versions.bun ?? "unknown",
+    os: { platform: os.platform(), release: os.release(), arch: os.arch() },
+    doctor,
+    config_redacted: config,
+    error_log_tail: errorTail,
+    ee_status: eeStatus,
+  };
+}
+
+export function formatBugReport(bundle: BugReportBundle): string {
+  return JSON.stringify(bundle, null, 2);
+}