@arthur-ai/buzz 2.1.554-dev.0

package/dist/index.js

@@ -0,0 +1,2452 @@
+#!/usr/bin/env node
+import {
+  buzzSay,
+  confirm,
+  logError,
+  logInfo,
+  logSuccess,
+  logWarn,
+  note,
+  p,
+  password,
+  select,
+  text
+} from "./chunk-DNHKKPJY.js";
+
+// src/index.ts
+import figlet from "figlet";
+import chalk3 from "chalk";
+import { intro, outro } from "@clack/prompts";
+
+// src/workflow/steps/01-prereqs.ts
+import { execa } from "execa";
+import ora from "ora";
+
+// src/errors.ts
+var BuzzError = class extends Error {
+  constructor(message, fatal = true) {
+    super(message);
+    this.fatal = fatal;
+    this.name = "BuzzError";
+  }
+  fatal;
+};
+
+// src/workflow/steps/01-prereqs.ts
+async function step1_VerifyPrereqs(state) {
+  const spinner = ora({ text: buzzSay("Running pre-flight checklist..."), color: "cyan" }).start();
+  try {
+    const { stdout } = await execa("git", ["status", "--porcelain"], {
+      cwd: state.repoPath
+    });
+    const dirtyLines = stdout.split("\n").filter((l) => l.length > 0).filter((l) => !(l[1] === " " && l[0] !== "?"));
+    if (dirtyLines.length > 0) {
+      spinner.stop();
+      logError("Cannot proceed \u2014 uncommitted work in progress detected in your repository.");
+      note(
+        "Please commit or stash your unstaged changes and re-run Buzz.\n(Staged/added changes are fine.)",
+        "git status is dirty"
+      );
+      throw new BuzzError("Git repository has uncommitted changes.");
+    }
+  } catch (err) {
+    if (err instanceof BuzzError) throw err;
+    spinner.stop();
+    logError("This directory is not a git repository, or git is not installed.");
+    throw new BuzzError("Not a git repository.");
+  }
+  spinner.text = buzzSay("Git status confirmed. Checking Claude Code...");
+  const claudeWhich = await execa("which", ["claude"]).catch(() => null);
+  if (!claudeWhich) {
+    spinner.stop();
+    logError("Claude Code is not installed.");
+    note(
+      "Install Claude Code with:\n  npm install -g @anthropic-ai/claude-code\nThen re-run Buzz.",
+      "Missing dependency"
+    );
+    throw new BuzzError("Claude Code is not installed.");
+  }
+  const claudeVersion = await execa("claude", ["--version"]).catch(() => null);
+  if (!claudeVersion) {
+    spinner.stop();
+    logError("Claude Code binary is not responding.");
+    throw new BuzzError("Claude Code binary is not working.");
+  }
+  spinner.text = buzzSay("Checking Claude Code authentication...");
+  const authStatus = await execa("claude", ["auth", "status"]).catch(() => null);
+  let isAuthenticated = authStatus?.exitCode === 0;
+  if (!isAuthenticated) {
+    spinner.stop();
+    logError("Claude Code is not authenticated.");
+    const { password: password2 } = await import("./prompts-NKUEI6PW.js");
+    const apiKey = await password2("Enter your ANTHROPIC_API_KEY to continue:");
+    process.env.ANTHROPIC_API_KEY = apiKey;
+    spinner.start(buzzSay("Verifying API key..."));
+    const authVerify = await execa("claude", ["auth", "status"]).catch(() => null);
+    isAuthenticated = authVerify?.exitCode === 0;
+    if (!isAuthenticated) {
+      spinner.stop();
+      logError("The provided ANTHROPIC_API_KEY does not appear to be valid.");
+      throw new BuzzError("Claude Code is not authenticated.");
+    }
+  }
+  spinner.stop();
+  logSuccess("All systems go. Pre-flight checklist complete.");
+  logSuccess(`Running in repo: ${state.repoPath}`);
+}
+
+// src/workflow/steps/02-arthur-engine.ts
+import fs2 from "fs";
+import path2 from "path";
+import ora2 from "ora";
+import { execa as execa2 } from "execa";
+
+// src/config/env.ts
+import fs from "fs";
+import { createHash } from "crypto";
+import path from "path";
+import os from "os";
+import * as dotenv from "dotenv";
+function getBuzzEnvPath(repoPath) {
+  const resolved = path.resolve(repoPath);
+  const hash = createHash("sha1").update(resolved).digest("hex").slice(0, 12);
+  const key = `${path.basename(resolved)}-${hash}`;
+  return path.join(os.homedir(), ".arthur-engine", "local-stack", "buzz", key, ".env");
+}
+var GENAI_ENGINE_ENV_PATH = path.join(
+  os.homedir(),
+  ".arthur-engine",
+  "local-stack",
+  "genai-engine",
+  ".env"
+);
+var GENAI_ENGINE_DIR = path.join(
+  os.homedir(),
+  ".arthur-engine",
+  "local-stack",
+  "genai-engine"
+);
+function readBuzzConfig(envPath) {
+  if (!fs.existsSync(envPath)) return {};
+  const result = dotenv.config({ path: envPath, override: false, processEnv: {} });
+  return result.parsed ?? {};
+}
+function writeBuzzConfig(config2, envPath) {
+  fs.mkdirSync(path.dirname(envPath), { recursive: true });
+  const existing = readBuzzConfig(envPath);
+  const merged = { ...existing, ...config2 };
+  const content = Object.entries(merged).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${v}`).join("\n");
+  fs.writeFileSync(envPath, content + "\n", "utf-8");
+}
+function readGenaiEngineConfig() {
+  if (!fs.existsSync(GENAI_ENGINE_ENV_PATH)) return {};
+  const result = dotenv.config({ path: GENAI_ENGINE_ENV_PATH, override: false, processEnv: {} });
+  return result.parsed ?? {};
+}
+
+// src/arthur/client.ts
+var ArthurEngineClient = class {
+  constructor(baseUrl, apiKey) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  apiKey;
+  baseUrl;
+  get headers() {
+    return {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  /** Returns true if the engine is reachable (regardless of auth status). */
+  async verifyConnection() {
+    try {
+      const res = await fetch(`${this.baseUrl}/api/v2/tasks?page=0&page_size=1`, {
+        headers: this.headers,
+        signal: AbortSignal.timeout(1e4)
+      });
+      return res.status === 200 || res.status === 401;
+    } catch {
+      return false;
+    }
+  }
+  /** Returns true if the API key is valid. */
+  async login() {
+    try {
+      const res = await fetch(`${this.baseUrl}/api/v2/tasks?page=0&page_size=1`, {
+        headers: this.headers,
+        signal: AbortSignal.timeout(1e4)
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  async getTasks() {
+    const res = await fetch(`${this.baseUrl}/api/v2/tasks`, {
+      headers: this.headers,
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!res.ok) throw new Error(`Failed to get tasks: HTTP ${res.status}`);
+    const data = await res.json();
+    return data.tasks ?? data.data ?? [];
+  }
+  async createTask(name) {
+    const res = await fetch(`${this.baseUrl}/api/v2/tasks`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({ name }),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Failed to create task: HTTP ${res.status} ${body}`);
+    }
+    return await res.json();
+  }
+  async getTraces(taskId) {
+    try {
+      const res = await fetch(
+        `${this.baseUrl}/api/v1/traces?task_ids=${encodeURIComponent(taskId)}&page_size=5`,
+        {
+          headers: this.headers,
+          signal: AbortSignal.timeout(15e3)
+        }
+      );
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        return { traces: [], error: `HTTP ${res.status}: ${body}` };
+      }
+      const data = await res.json();
+      return { traces: data.traces ?? data.data ?? [] };
+    } catch (err) {
+      return { traces: [], error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async getTraceDetail(traceId) {
+    try {
+      const res = await fetch(
+        `${this.baseUrl}/api/v1/traces/${encodeURIComponent(traceId)}`,
+        {
+          headers: this.headers,
+          signal: AbortSignal.timeout(15e3)
+        }
+      );
+      if (!res.ok) return null;
+      return await res.json();
+    } catch {
+      return null;
+    }
+  }
+  async getModelProviders() {
+    try {
+      const res = await fetch(`${this.baseUrl}/api/v1/model_providers`, {
+        headers: this.headers,
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!res.ok) return [];
+      const data = await res.json();
+      return data.providers ?? [];
+    } catch {
+      return [];
+    }
+  }
+  async createLlmEval(taskId, evalSlug, body) {
+    try {
+      const res = await fetch(
+        `${this.baseUrl}/api/v1/tasks/${encodeURIComponent(taskId)}/llm_evals/${encodeURIComponent(evalSlug)}`,
+        {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(15e3)
+        }
+      );
+      if (!res.ok) {
+        const text2 = await res.text().catch(() => "");
+        return { error: `HTTP ${res.status}: ${text2}` };
+      }
+      return { eval: await res.json() };
+    } catch (err) {
+      return { error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async createTransform(taskId, body) {
+    try {
+      const res = await fetch(
+        `${this.baseUrl}/api/v1/tasks/${encodeURIComponent(taskId)}/traces/transforms`,
+        {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(15e3)
+        }
+      );
+      if (!res.ok) {
+        const text2 = await res.text().catch(() => "");
+        return { error: `HTTP ${res.status}: ${text2}` };
+      }
+      return { transform: await res.json() };
+    } catch (err) {
+      return { error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async createContinuousEval(taskId, body) {
+    try {
+      const res = await fetch(
+        `${this.baseUrl}/api/v1/tasks/${encodeURIComponent(taskId)}/continuous_evals`,
+        {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(15e3)
+        }
+      );
+      if (!res.ok) {
+        const text2 = await res.text().catch(() => "");
+        return { error: `HTTP ${res.status}: ${text2}` };
+      }
+      return { continuousEval: await res.json() };
+    } catch (err) {
+      return { error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async getLlmEvals(taskId) {
+    try {
+      const res = await fetch(
+        `${this.baseUrl}/api/v1/tasks/${encodeURIComponent(taskId)}/llm_evals?page=0&page_size=100`,
+        {
+          headers: this.headers,
+          signal: AbortSignal.timeout(15e3)
+        }
+      );
+      if (!res.ok) return [];
+      const data = await res.json();
+      return data.evals ?? data.items ?? [];
+    } catch {
+      return [];
+    }
+  }
+  async getContinuousEvals(taskId) {
+    try {
+      const res = await fetch(
+        `${this.baseUrl}/api/v1/tasks/${encodeURIComponent(taskId)}/continuous_evals?page=0&page_size=100`,
+        {
+          headers: this.headers,
+          signal: AbortSignal.timeout(15e3)
+        }
+      );
+      if (!res.ok) return [];
+      const data = await res.json();
+      return data.evals ?? [];
+    } catch {
+      return [];
+    }
+  }
+  async configureModelProvider(provider, credentials) {
+    try {
+      const res = await fetch(
+        `${this.baseUrl}/api/v1/model_providers/${encodeURIComponent(provider)}`,
+        {
+          method: "PUT",
+          headers: this.headers,
+          body: JSON.stringify({ api_key: credentials.api_key }),
+          signal: AbortSignal.timeout(15e3)
+        }
+      );
+      if (!res.ok) {
+        const text2 = await res.text().catch(() => "");
+        return { success: false, error: `HTTP ${res.status}: ${text2}` };
+      }
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async createPrompt(taskId, promptName, body) {
+    try {
+      const res = await fetch(
+        `${this.baseUrl}/api/v1/tasks/${encodeURIComponent(taskId)}/prompts/${encodeURIComponent(promptName)}`,
+        {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(15e3)
+        }
+      );
+      if (!res.ok) {
+        const text2 = await res.text().catch(() => "");
+        return { error: `HTTP ${res.status}: ${text2}` };
+      }
+      return { prompt: await res.json() };
+    } catch (err) {
+      return { error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+};
+
+// src/workflow/steps/02-arthur-engine.ts
+var DOCKER_COMPOSE_PATH = path2.join(GENAI_ENGINE_DIR, "docker-compose.yml");
+var ENV_PATH = path2.join(GENAI_ENGINE_DIR, ".env");
+var INSTALL_SCRIPT = "bash <(curl -sSL https://get-genai-engine.arthur.ai/mac)";
+function readLocalAdminKey() {
+  const cfg = readGenaiEngineConfig();
+  if (cfg.GENAI_ENGINE_ADMIN_KEY) return cfg.GENAI_ENGINE_ADMIN_KEY;
+  if (!fs2.existsSync(DOCKER_COMPOSE_PATH)) return "";
+  const content = fs2.readFileSync(DOCKER_COMPOSE_PATH, "utf-8");
+  const match = content.match(/^\s*-\s*GENAI_ENGINE_ADMIN_KEY=(.+)$/m);
+  return match ? match[1].trim() : "";
+}
+async function waitForEngine(url, apiKey, options = {}) {
+  const client = new ArthurEngineClient(url, apiKey);
+  const start = Date.now();
+  const watchDocker = options.watchDocker === true && fs2.existsSync(DOCKER_COMPOSE_PATH);
+  if (watchDocker) {
+    p.log.info(buzzSay("First-time startup may take several minutes while models are downloaded."));
+    p.log.info(buzzSay("Subsequent startups will load them from the local cache on disk."));
+  }
+  const spinner = ora2({ text: buzzSay("Waiting for Arthur Engine to become ready..."), color: "cyan" }).start();
+  let recentLogLine = "";
+  const logsProcess = watchDocker ? execa2("docker", ["compose", "-f", DOCKER_COMPOSE_PATH, "logs", "--follow", "--tail", "10", "--no-color"], {
+    all: true,
+    reject: false
+  }) : null;
+  logsProcess?.all?.on("data", (chunk) => {
+    const text2 = chunk.toString();
+    const lines = text2.split("\n").filter((l) => l.trim() && !l.includes("Attaching to"));
+    for (const line of lines) {
+      const stripped = line.replace(/^[\w-]+-\d+\s*\|\s*/, "").trim();
+      if (stripped) recentLogLine = stripped.slice(0, 120);
+    }
+  });
+  try {
+    while (true) {
+      if (await client.verifyConnection()) {
+        spinner.stop();
+        logSuccess("Arthur Engine is online.");
+        return true;
+      }
+      if (watchDocker) {
+        try {
+          const { stdout } = await execa2("docker", [
+            "compose",
+            "-f",
+            DOCKER_COMPOSE_PATH,
+            "ps",
+            "--status",
+            "running",
+            "-q"
+          ]);
+          if (!stdout.trim()) {
+            spinner.stop();
+            logError("Arthur Engine container has exited unexpectedly.");
+            return false;
+          }
+        } catch {
+        }
+      } else if (Date.now() - start >= 12e4) {
+        spinner.stop();
+        logError("Engine did not become ready in time.");
+        return false;
+      }
+      await new Promise((r) => setTimeout(r, 5e3));
+      const elapsed = Math.round((Date.now() - start) / 1e3);
+      const logHint = recentLogLine ? `
+  ${recentLogLine}` : "";
+      spinner.text = buzzSay(`Engine starting up... (${elapsed}s elapsed)${logHint}`);
+    }
+  } finally {
+    logsProcess?.kill();
+  }
+}
+async function detectLocalArthurEngine() {
+  if (!fs2.existsSync(DOCKER_COMPOSE_PATH) || !fs2.existsSync(ENV_PATH)) {
+    return { status: "not-installed" };
+  }
+  const cfg = readGenaiEngineConfig();
+  const url = cfg.GENAI_ENGINE_INGRESS_URI ?? "http://localhost:3030";
+  const apiKey = readLocalAdminKey();
+  try {
+    const { stdout } = await execa2("docker", ["compose", "-f", DOCKER_COMPOSE_PATH, "ps", "--status", "running", "-q"]);
+    if (!stdout.trim()) return { status: "down", url, apiKey };
+  } catch {
+    return { status: "down", url, apiKey };
+  }
+  const client = new ArthurEngineClient(url, apiKey);
+  if (!await client.verifyConnection()) return { status: "down", url, apiKey };
+  return { status: "running", url, apiKey };
+}
+async function verifyAndLogin(url, apiKey) {
+  const client = new ArthurEngineClient(url, apiKey);
+  const spinner = ora2({ text: buzzSay("Verifying Arthur Engine connection..."), color: "cyan" }).start();
+  const reachable = await client.verifyConnection();
+  if (!reachable) {
+    spinner.stop();
+    logError(`Arthur Engine at ${url} is not reachable.`);
+    throw new BuzzError(`Engine at ${url} is not reachable.`);
+  }
+  spinner.text = buzzSay("Engine reachable. Verifying API key...");
+  const loggedIn = await client.login();
+  if (!loggedIn) {
+    spinner.stop();
+    logError("API key is invalid. Cannot authenticate with Arthur Engine.");
+    throw new BuzzError("Arthur Engine API key is invalid.");
+  }
+  spinner.stop();
+  logSuccess("Arthur Engine connection and authentication verified.");
+}
+async function handleLocalInstall(state) {
+  note(
+    `Running the Arthur GenAI Engine install script:
+  ${INSTALL_SCRIPT}
+
+This will install Docker and start the local engine.`,
+    "Installing Arthur GenAI Engine"
+  );
+  const proceed = await confirm("Ready to run the local install script?");
+  if (!proceed) {
+    throw new BuzzError("Installation cancelled by user.");
+  }
+  p.log.info(buzzSay("Initiating Arthur Engine launch sequence..."));
+  try {
+    await execa2("bash", ["-c", INSTALL_SCRIPT], { stdio: "inherit" });
+  } catch (err) {
+    logError("Install script failed.");
+    throw new BuzzError(`Install script failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const cfg = readGenaiEngineConfig();
+  const url = cfg.GENAI_ENGINE_INGRESS_URI ?? "http://localhost:3030";
+  let apiKey = readLocalAdminKey();
+  if (!apiKey) {
+    logWarn("Could not find API key in engine config files.");
+    apiKey = await password("Enter your Arthur Engine admin API key:");
+  }
+  const ready = await waitForEngine(url, apiKey, { watchDocker: true });
+  if (!ready) {
+    throw new BuzzError("Arthur Engine did not start in time. Check Docker logs.");
+  }
+  writeBuzzConfig({ ARTHUR_ENGINE_URL: url, ARTHUR_API_KEY: apiKey }, state.buzzEnvPath);
+  state.engineUrl = url;
+  state.apiKey = apiKey;
+  logSuccess(`All systems nominal. Local Arthur Engine ready at ${url}`);
+}
+async function handleRemoteEngine(state) {
+  note(
+    "Enter the URL and API key for your remote Arthur GenAI Engine.\nExample URL: https://myengine.example.com",
+    "Remote Arthur Engine"
+  );
+  const url = await text("Arthur Engine URL:", "https://myengine.example.com");
+  const apiKey = await password("Arthur Engine API key:");
+  await verifyAndLogin(url, apiKey);
+  const taskId = await text("Arthur Engine task ID:", "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
+  writeBuzzConfig({ ARTHUR_ENGINE_URL: url, ARTHUR_API_KEY: apiKey, ARTHUR_TASK_ID: taskId }, state.buzzEnvPath);
+  state.engineUrl = url;
+  state.apiKey = apiKey;
+  state.taskId = taskId;
+  logSuccess(`All systems nominal. Remote Arthur Engine configured at ${url}`);
+}
+function isLocalEngine(url) {
+  return url.includes("localhost") || url.includes("127.0.0.1");
+}
+async function step2_EnsureArthurEngine(state) {
+  const buzzCfg = readBuzzConfig(state.buzzEnvPath);
+  if (buzzCfg.ARTHUR_ENGINE_URL && buzzCfg.ARTHUR_API_KEY) {
+    const useExisting = await confirm(
+      `Found Arthur Engine config at ${buzzCfg.ARTHUR_ENGINE_URL}. Use this?`
+    );
+    if (useExisting) {
+      const url = buzzCfg.ARTHUR_ENGINE_URL;
+      const apiKey = buzzCfg.ARTHUR_API_KEY;
+      const spinner = ora2({ text: buzzSay("Verifying Arthur Engine connection..."), color: "cyan" }).start();
+      const reachable = await new ArthurEngineClient(url, apiKey).verifyConnection();
+      spinner.stop();
+      if (reachable) {
+        await verifyAndLogin(url, apiKey);
+        state.engineUrl = url;
+        state.apiKey = apiKey;
+        return;
+      }
+      logWarn(`Arthur Engine at ${url} is not reachable.`);
+      if (isLocalEngine(url)) {
+        const recovery = await select(
+          "What would you like to do?",
+          [
+            { value: "wait", label: "I'll bring it back up", hint: "Buzz will wait until the engine is ready" },
+            { value: "install", label: "Rerun the Arthur GenAI Engine installer", hint: "Re-runs the install script" },
+            { value: "remote", label: "Connect to a remote engine instead", hint: "Need URL + API key + task ID" }
+          ]
+        );
+        if (recovery === "wait") {
+          const ready = await waitForEngine(url, apiKey, { watchDocker: true });
+          if (!ready) throw new BuzzError("Arthur Engine did not come back online in time. Check Docker logs.");
+          await verifyAndLogin(url, apiKey);
+          state.engineUrl = url;
+          state.apiKey = apiKey;
+          logSuccess(`All systems nominal. Arthur Engine back online at ${url}`);
+          return;
+        } else if (recovery === "install") {
+          await handleLocalInstall(state);
+          return;
+        } else {
+          await handleRemoteEngine(state);
+          return;
+        }
+      } else {
+        const recovery = await select(
+          "What would you like to do?",
+          [
+            { value: "retry", label: "Check again", hint: "Try reconnecting to the same URL" },
+            { value: "remote", label: "Connect to a different remote engine", hint: "Need URL + API key" }
+          ]
+        );
+        if (recovery === "retry") {
+          await verifyAndLogin(url, apiKey);
+          state.engineUrl = url;
+          state.apiKey = apiKey;
+          return;
+        } else {
+          await handleRemoteEngine(state);
+          return;
+        }
+      }
+    }
+  }
+  const local = await detectLocalArthurEngine();
+  if (local.status === "running") {
+    const useLocal = await confirm(
+      `Detected Arthur Engine running at ${local.url}. Use this?`
+    );
+    if (useLocal) {
+      await verifyAndLogin(local.url, local.apiKey);
+      writeBuzzConfig({ ARTHUR_ENGINE_URL: local.url, ARTHUR_API_KEY: local.apiKey }, state.buzzEnvPath);
+      state.engineUrl = local.url;
+      state.apiKey = local.apiKey;
+      return;
+    }
+  } else if (local.status === "down") {
+    logWarn(`Found a local Arthur Engine installation at ${local.url} but it is not reachable.`);
+    const recovery = await select(
+      "What would you like to do?",
+      [
+        { value: "restart", label: "I'll bring it back up", hint: "Buzz will wait until the engine is ready" },
+        { value: "install", label: "Run a fresh install", hint: "Re-runs the install script" },
+        { value: "remote", label: "Connect to a remote engine instead", hint: "Need URL + API key + task ID" }
+      ]
+    );
+    if (recovery === "restart") {
+      const ready = await waitForEngine(local.url, local.apiKey, { watchDocker: true });
+      if (!ready) {
+        throw new BuzzError("Arthur Engine did not come back online in time. Check Docker logs.");
+      }
+      await verifyAndLogin(local.url, local.apiKey);
+      writeBuzzConfig({ ARTHUR_ENGINE_URL: local.url, ARTHUR_API_KEY: local.apiKey }, state.buzzEnvPath);
+      state.engineUrl = local.url;
+      state.apiKey = local.apiKey;
+      logSuccess(`All systems nominal. Arthur Engine back online at ${local.url}`);
+      return;
+    } else if (recovery === "install") {
+      await handleLocalInstall(state);
+      return;
+    } else {
+      await handleRemoteEngine(state);
+      return;
+    }
+  }
+  if (process.platform !== "darwin") {
+    logError("This mission currently requires Mac OS hardware. Returning to base.");
+    note(
+      'Arthur Engine local installation is currently Mac-only.\nFor a remote engine, re-run Buzz and choose the "Remote" option.',
+      "Mac only"
+    );
+    throw new BuzzError("Local Arthur Engine installation requires macOS.", true);
+  }
+  const choice = await select(
+    "Where should we connect Arthur GenAI Engine?",
+    [
+      { value: "local", label: "Install on this machine (Mac)", hint: "Requires Docker" },
+      { value: "remote", label: "Connect to a remote deployment", hint: "Need URL + API key" }
+    ]
+  );
+  if (choice === "local") {
+    await handleLocalInstall(state);
+  } else {
+    await handleRemoteEngine(state);
+  }
+  const client = new ArthurEngineClient(state.engineUrl, state.apiKey);
+  const loggedIn = await client.login();
+  if (!loggedIn) {
+    throw new BuzzError("Failed to authenticate with Arthur GenAI Engine.");
+  }
+  logSuccess("Login verified. Arthur Engine is go.");
+}
+
+// src/workflow/steps/03-task.ts
+import ora3 from "ora";
+async function step3_EnsureTaskId(state) {
+  const client = new ArthurEngineClient(state.engineUrl, state.apiKey);
+  const buzzCfg = readBuzzConfig(state.buzzEnvPath);
+  if (buzzCfg.ARTHUR_TASK_ID) {
+    const taskId = buzzCfg.ARTHUR_TASK_ID;
+    note(`Existing task ID found:
+  ${taskId}`, "Saved task ID");
+    const confirmed = await confirm(`Is ${taskId} the correct task for this application?`);
+    if (confirmed) {
+      state.taskId = taskId;
+      logSuccess(`Task ID confirmed: ${taskId}`);
+      return;
+    }
+  }
+  const spinner = ora3({ text: buzzSay("Retrieving active tasks from Arthur Engine..."), color: "cyan" }).start();
+  let tasks = [];
+  try {
+    tasks = await client.getTasks();
+    spinner.stop();
+    logSuccess(`Found ${tasks.length} active task(s).`);
+  } catch (err) {
+    spinner.stop();
+    logError(`Failed to retrieve tasks: ${err instanceof Error ? err.message : String(err)}`);
+    throw new BuzzError("Could not retrieve tasks from Arthur Engine.");
+  }
+  if (tasks.length > 0) {
+    const options = tasks.map((t) => ({
+      value: t.id,
+      label: t.name,
+      hint: t.id
+    }));
+    options.push({ value: "__new__", label: "+ Create a new task", hint: "Give your application a name" });
+    const selected = await select("Which Arthur task should we use for this application?", options);
+    if (selected !== "__new__") {
+      writeBuzzConfig({ ARTHUR_TASK_ID: selected }, state.buzzEnvPath);
+      state.taskId = selected;
+      logSuccess(`Task selected: ${selected}`);
+      return;
+    }
+  } else {
+    p.log.info(buzzSay("No active tasks found. Let's create one."));
+  }
+  const taskName = await text(
+    'What should we call this task? (e.g., "My Customer Support Bot"):',
+    "My Agentic Application"
+  );
+  const createSpinner = ora3({ text: buzzSay(`Creating task "${taskName}"...`), color: "cyan" }).start();
+  try {
+    const newTask = await client.createTask(taskName);
+    createSpinner.stop();
+    logSuccess(`Task created: "${newTask.name}" (${newTask.id})`);
+    writeBuzzConfig({ ARTHUR_TASK_ID: newTask.id }, state.buzzEnvPath);
+    state.taskId = newTask.id;
+    note(`Task ID: ${newTask.id}
+This has been saved to ${state.buzzEnvPath}`, "New task created");
+  } catch (err) {
+    createSpinner.stop();
+    logError(`Failed to create task: ${err instanceof Error ? err.message : String(err)}`);
+    throw new BuzzError("Could not create a task in Arthur Engine.");
+  }
+}
+
+// src/claude-code/sdk.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import ora4 from "ora";
+import chalk from "chalk";
+var SYSTEM_PROMPTS = {
+  "python-arthur-sdk": "You are an expert Python developer instrumenting AI/LLM applications with OpenTelemetry-based observability. You write clean, idiomatic Python code.",
+  "mastra-arthur-exporter": "You are an expert TypeScript developer instrumenting Mastra AI agent applications with OpenTelemetry tracing. You write clean, idiomatic TypeScript.",
+  openinference: "You are an expert developer instrumenting AI agent applications with OpenTelemetry and OpenInference. You adapt to the framework in use (Python or TypeScript)."
+};
+function buildPrompt(req) {
+  const base = `
+Arthur Engine URL: ${req.arthurEngineUrl}
+Arthur Task ID: ${req.taskId}
+
+IMPORTANT RULES:
+- Do NOT hardcode API keys in source code. Always read from environment variables (ARTHUR_API_KEY).
+- Add these entries to .env (create if it does not exist; ensure .env is in .gitignore):
+    ARTHUR_API_KEY=$ARTHUR_API_KEY
+    ARTHUR_BASE_URL=${req.arthurEngineUrl}
+    ARTHUR_TASK_ID=${req.taskId}
+- Also add placeholder entries to .env.example:
+    ARTHUR_API_KEY=your-api-key-here
+    ARTHUR_BASE_URL=${req.arthurEngineUrl}
+    ARTHUR_TASK_ID=${req.taskId}
+- Make the smallest possible changes \u2014 instrument, don't refactor.
+- The task is complete only when:
+  1. All dependencies are installed (pip install or npm install).
+  2. An import/syntax check passes (python -c "import <module>" or tsc --noEmit).
+  3. The existing test suite runs (if one exists). Fix any NEW test failures you introduced.
+  4. You print a final JSON result block on the last line of your output.
+
+FINAL OUTPUT FORMAT (print this exact JSON on the last line):
+{"success":true,"testsPassed":true,"summary":"<one sentence>"}
+or
+{"success":false,"testsPassed":false,"summary":"<what went wrong>"}
+`;
+  const typePrompts = {
+    "python-arthur-sdk": `
+Instrument this Python agentic application with the Arthur Python Observability SDK.
+
+Reference SDK: https://github.com/arthur-ai/arthur-engine/tree/main/arthur-observability-sdk
+
+Plan ultrathink \u2014 carefully examine all files first, then implement:
+
+STEP 1 \u2014 ANALYSIS:
+  - List all files to understand the project structure
+  - Read requirements.txt / pyproject.toml to see current dependencies and note the package manager (uv/pip/poetry)
+  - Find the application entry point (main.py, app.py, __main__.py, or similar)
+  - Identify the LLM framework used (openai, langchain, anthropic, crewai, etc.)
+  - Check if arthur_observability_sdk is already installed (skip if yes)
+
+STEP 2 \u2014 IMPLEMENTATION (only if not already instrumented):
+
+PART A \u2014 SDK SETUP (always required):
+  - Add "arthur-observability-sdk[<framework>]" to requirements.txt / pyproject.toml
+    where <framework> matches the detected LLM framework (e.g. langchain, openai, anthropic, crewai)
+  - In the entry point, add:
+      from arthur_observability_sdk import Arthur
+      import os
+      task_id = os.environ.get("ARTHUR_TASK_ID", "${req.taskId}")
+      arthur = Arthur(
+          api_key=os.environ.get("ARTHUR_API_KEY"),
+          base_url=os.environ.get("ARTHUR_BASE_URL", "${req.arthurEngineUrl}"),
+          task_id=task_id,
+          service_name="<app-name>",
+          resource_attributes={"arthur.task": task_id},
+      )
+  - Call arthur.instrument_<framework>() to auto-instrument all LLM API calls
+  - Add to .env (create if needed, ensure .env is in .gitignore):
+      ARTHUR_API_KEY=$ARTHUR_API_KEY
+  - Add to .env.example: ARTHUR_API_KEY=your-api-key-here
+
+PART B \u2014 ROOT SPAN + SESSION ID (CRITICAL \u2014 without this, each LLM call is a SEPARATE trace):
+  The auto-instrumentor creates one span per LLM call. Without a parent span to connect them,
+  one user interaction emits multiple disconnected traces. A root CHAIN span fixes this.
+
+  Add these imports near the top of the file where arthur is initialised (or in a shared module):
+      from opentelemetry import trace
+      from openinference.semconv.trace import SpanAttributes, OpenInferenceSpanKindValues
+      import json, uuid
+      tracer = trace.get_tracer(__name__)
+
+  Find the main request handler \u2014 the function/method that processes one complete user message
+  end-to-end (e.g. a Gradio/FastAPI/Flask chat handler, a process() / answer() / run() method).
+
+  Wrap its body with a root CHAIN span AND a session context manager:
+      # Derive session_id from app state: look for existing session key, conversation ID,
+      # user ID, or generate one: str(uuid.uuid4())
+      session_id = <session_id>
+      with arthur.session(session_id):
+          with tracer.start_as_current_span("<handler_name>") as root_span:
+              root_span.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND,
+                                      OpenInferenceSpanKindValues.CHAIN.value)
+              root_span.set_attribute(SpanAttributes.INPUT_VALUE, <user_input_message>)
+              # all existing processing code runs here; every sub-span becomes a child
+              root_span.set_attribute(SpanAttributes.OUTPUT_VALUE, <final_response_text>)
+
+  IMPORTANT \u2014 streaming / generator handlers: Python async frameworks (Gradio, FastAPI, etc.)
+  may resume a generator in a different async task or thread, which resets the OTel context
+  between iterations. A context-manager-based span (with tracer.start_as_current_span) WILL
+  lose its parent context across yield points. Use explicit attach/detach instead:
+
+      from opentelemetry import context as otel_ctx
+      from opentelemetry.trace import set_span_in_context
+      from opentelemetry.context import set_value as otel_set_value
+
+      def handler(message, ...):
+          yield <initial_update>          # yield BEFORE creating span (fine)
+
+          root_span = tracer.start_span("handler_name")
+          root_span.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND,
+                                  OpenInferenceSpanKindValues.CHAIN.value)
+          root_span.set_attribute(SpanAttributes.INPUT_VALUE, message)
+
+          span_ctx = set_span_in_context(
+              root_span,
+              otel_set_value(SpanAttributes.SESSION_ID, session_id),
+          )
+          token = otel_ctx.attach(span_ctx)
+          try:
+              for chunk in <inner_generator>:
+                  <process chunk>
+                  otel_ctx.detach(token)
+                  yield <chunk_to_caller>
+                  token = otel_ctx.attach(span_ctx)  # re-attach after each yield
+              root_span.set_attribute(SpanAttributes.OUTPUT_VALUE, <final_response>)
+          finally:
+              root_span.end()
+              otel_ctx.detach(token)
+
+PART C \u2014 TOOL SPANS (for LLM tool-calling patterns):
+  If the application uses LLM tool calling \u2014 i.e. the LLM outputs tool-call parameters and
+  then Python code executes the actual function \u2014 wrap each tool execution with a TOOL span:
+      with tracer.start_as_current_span("<tool_name>") as tool_span:
+          tool_span.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND,
+                                  OpenInferenceSpanKindValues.TOOL.value)
+          tool_span.set_attribute(SpanAttributes.TOOL_NAME, "<tool_name>")
+          tool_span.set_attribute(SpanAttributes.INPUT_VALUE, json.dumps(<tool_input_params>))
+          result = <execute_tool(tool_input_params)>
+          tool_span.set_attribute(SpanAttributes.OUTPUT_VALUE,
+                                  json.dumps(result) if not isinstance(result, str) else result)
+
+PART D \u2014 RETRIEVAL SPANS (for RAG / search patterns):
+  If the application performs retrieval (vector search, semantic search, full-text search,
+  document lookup), wrap the retrieval call with a RETRIEVER span. You MUST set BOTH:
+    (a) per-document attributes so Arthur can index individual docs, AND
+    (b) output.value as a JSON list so Arthur Engine displays the retrieved context \u2014 without
+        output.value the retrieval output panel will appear empty in the UI.
+
+      with tracer.start_as_current_span("retrieval") as ret_span:
+          ret_span.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND,
+                                 OpenInferenceSpanKindValues.RETRIEVER.value)
+          ret_span.set_attribute(SpanAttributes.INPUT_VALUE, <search_query_string>)
+          docs = <execute_retrieval(search_query)>
+          retrieved = []
+          for i, doc in enumerate(docs):
+              doc_text = <doc_text_content>
+              ret_span.set_attribute(f"retrieval.documents.{i}.document.content", doc_text)
+              entry = {"document_content": doc_text}
+              # Include score if the retrieval API returns one (float 0\u20131 preferred)
+              if <score_available>:
+                  score = float(<doc_score>)
+                  ret_span.set_attribute(f"retrieval.documents.{i}.document.score", score)
+                  entry["score"] = score
+              retrieved.append(entry)
+          # REQUIRED: set output.value so the retrieval output is visible in Arthur Engine
+          ret_span.set_attribute(SpanAttributes.OUTPUT_VALUE, json.dumps(retrieved))
+
+STEP 3 \u2014 VALIDATION:
+  - Run: pip install 'arthur-observability-sdk[<framework>]'
+    (or: uv sync if using uv)
+  - Run: python -c "from arthur_observability_sdk import Arthur; print('import OK')"
+  - Run the existing test suite if present (pytest, python -m pytest, or similar)
+  - Fix any new test failures you introduced
+  - Print the final JSON result
+
+${base}`,
+    "mastra-arthur-exporter": `
+Instrument this Mastra TypeScript application with the Arthur observability exporter.
+
+Reference: https://mastra.ai/docs/observability/tracing/exporters/arthur
+
+Plan ultrathink \u2014 carefully examine all files first, then implement:
+
+STEP 1 \u2014 ANALYSIS:
+  - List all files to understand the project structure
+  - Read package.json to see current dependencies
+  - Find the Mastra instance initialization file (usually src/mastra/index.ts)
+  - Check if @mastra/arthur is already installed and ArthurExporter is already registered (skip if yes)
+
+STEP 2 \u2014 IMPLEMENTATION (only if not already instrumented):
+  Install the published Arthur exporter package:
+    npm install @mastra/arthur
+
+  Import and register in the Mastra instance initialization file:
+    import { Mastra } from '@mastra/core'
+    import { Observability } from '@mastra/observability'
+    import { ArthurExporter } from '@mastra/arthur'
+
+    export const mastra = new Mastra({
+      observability: new Observability({
+        configs: {
+          arthur: {
+            serviceName: '<app-name>',
+            exporters: [new ArthurExporter()],
+          },
+        },
+      }),
+    })
+
+  The ArthurExporter reads these env vars automatically (no constructor args needed):
+    ARTHUR_API_KEY   \u2014 required
+    ARTHUR_BASE_URL  \u2014 required (set to ${req.arthurEngineUrl})
+    ARTHUR_TASK_ID   \u2014 optional (set to ${req.taskId})
+
+  Add to .env (create if needed, ensure .env is in .gitignore):
+    ARTHUR_BASE_URL=${req.arthurEngineUrl}
+    ARTHUR_API_KEY=$ARTHUR_API_KEY
+    ARTHUR_TASK_ID=${req.taskId}
+  Add to .env.example:
+    ARTHUR_BASE_URL=${req.arthurEngineUrl}
+    ARTHUR_API_KEY=your-api-key-here
+    ARTHUR_TASK_ID=${req.taskId}
+
+STEP 3 \u2014 VALIDATION:
+  - Run: npm install (or yarn install / pnpm install)
+  - Run: npx tsc --noEmit
+  - Run the existing test suite if present (npm test, vitest run, or similar)
+  - Fix any new test failures you introduced
+  - Print the final JSON result
+
+${base}`,
+    openinference: `
+Instrument this agentic application with OpenInference / OpenTelemetry for Arthur GenAI Engine.
+
+Reference examples: https://github.com/arthur-ai/arthur-engine/tree/dev/genai-engine/examples/agents
+
+Plan ultrathink \u2014 carefully examine all files first, then implement:
+
+STEP 1 \u2014 ANALYSIS:
+  - List all files to understand project structure and language
+  - Read dependency manifests (requirements.txt, package.json, pyproject.toml)
+  - Find the entry point and identify the LLM framework (LangChain, OpenAI, CrewAI, etc.)
+  - Check if OpenInference / OpenTelemetry is already configured (skip if yes)
+
+STEP 2 \u2014 IMPLEMENTATION (only if not already instrumented):
+
+  For Python:
+    PART A \u2014 OTel + framework instrumentor setup:
+      Add to requirements.txt:
+        opentelemetry-sdk
+        opentelemetry-exporter-otlp-proto-http
+        openinference-instrumentation-<framework>  (e.g., openinference-instrumentation-langchain)
+        openinference-semantic-conventions
+
+      In the entry point:
+        from opentelemetry import trace
+        from opentelemetry.sdk.trace import TracerProvider
+        from opentelemetry.sdk.trace.export import BatchSpanProcessor
+        from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+        from openinference.instrumentation.<framework> import <Framework>Instrumentor
+        from openinference.semconv.trace import SpanAttributes, OpenInferenceSpanKindValues
+        import os, json, uuid
+
+        provider = TracerProvider()
+        exporter = OTLPSpanExporter(
+            endpoint="${req.arthurEngineUrl}/api/v1/traces",
+            headers={"Authorization": f"Bearer {os.environ.get('ARTHUR_API_KEY', '')}"},
+        )
+        provider.add_span_processor(BatchSpanProcessor(exporter))
+        trace.set_tracer_provider(provider)
+        <Framework>Instrumentor().instrument()
+        tracer = trace.get_tracer(__name__)
+
+    PART B \u2014 ROOT SPAN + SESSION ID (CRITICAL \u2014 without this, each LLM call is a SEPARATE trace):
+      The auto-instrumentor creates one span per LLM call; without a parent span every call
+      becomes its own trace. A root CHAIN span fixes this.
+
+      Find the main request handler \u2014 the function/method that processes one complete user
+      message end-to-end (e.g. a Gradio/FastAPI/Flask chat handler, a process() / answer() /
+      run() / invoke() method).
+
+      Wrap its body with a root CHAIN span AND a session context manager. Use
+      using_session from openinference.instrumentation:
+          from openinference.instrumentation import using_session
+
+          session_id = <get from app state: session key, conversation ID, or str(uuid.uuid4())>
+          with using_session(session_id=session_id):
+              with tracer.start_as_current_span("<handler_name>") as root_span:
+                  root_span.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND,
+                                          OpenInferenceSpanKindValues.CHAIN.value)
+                  root_span.set_attribute(SpanAttributes.INPUT_VALUE, <user_input_message>)
+                  # all existing processing code runs here
+                  root_span.set_attribute(SpanAttributes.OUTPUT_VALUE, <final_response_text>)
+
+      If the handler is a streaming/generator function (uses yield), the session + root span
+      must wrap the generator CONSUMPTION in the caller so spans stay open during streaming.
+
+    PART C \u2014 TOOL SPANS (for LLM tool-calling patterns):
+      If the application uses LLM tool calling (the LLM outputs tool-call params and then Python
+      code executes the actual function), wrap each tool execution:
+          with tracer.start_as_current_span("<tool_name>") as tool_span:
+              tool_span.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND,
+                                      OpenInferenceSpanKindValues.TOOL.value)
+              tool_span.set_attribute(SpanAttributes.TOOL_NAME, "<tool_name>")
+              tool_span.set_attribute(SpanAttributes.INPUT_VALUE, json.dumps(<tool_input_params>))
+              result = <execute_tool(tool_input_params)>
+              tool_span.set_attribute(SpanAttributes.OUTPUT_VALUE,
+                                      json.dumps(result) if not isinstance(result, str) else result)
+
+    PART D \u2014 RETRIEVAL SPANS (for RAG / search patterns):
+      If the application performs retrieval (vector search, semantic search, document lookup),
+      wrap the retrieval call with a RETRIEVER span. You MUST set BOTH per-document attributes
+      AND output.value as a JSON list \u2014 without output.value, Arthur Engine shows empty output:
+          with tracer.start_as_current_span("retrieval") as ret_span:
+              ret_span.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND,
+                                     OpenInferenceSpanKindValues.RETRIEVER.value)
+              ret_span.set_attribute(SpanAttributes.INPUT_VALUE, <search_query_string>)
+              docs = <execute_retrieval(search_query)>
+              retrieved = []
+              for i, doc in enumerate(docs):
+                  doc_text = <doc_text_content>
+                  ret_span.set_attribute(f"retrieval.documents.{i}.document.content", doc_text)
+                  entry = {"document_content": doc_text}
+                  if <score_available>:
+                      score = float(<doc_score>)
+                      ret_span.set_attribute(f"retrieval.documents.{i}.document.score", score)
+                      entry["score"] = score
+                  retrieved.append(entry)
+              # REQUIRED: set output.value so retrieved docs are visible in Arthur Engine
+              ret_span.set_attribute(SpanAttributes.OUTPUT_VALUE, json.dumps(retrieved))
+
+  For TypeScript/JavaScript:
+    Follow the pattern from the customer-support-agent example, creating an OTLP exporter
+    pointing to ${req.arthurEngineUrl}/api/v1/traces with Bearer auth.
+    Also add a root span around the request handler (same concept as Python PART B above).
+
+  Add to .env (create if needed, ensure .env is in .gitignore):
+    ARTHUR_BASE_URL=${req.arthurEngineUrl}
+    ARTHUR_API_KEY=$ARTHUR_API_KEY
+    ARTHUR_TASK_ID=${req.taskId}
+  Add to .env.example:
+    ARTHUR_BASE_URL=${req.arthurEngineUrl}
+    ARTHUR_API_KEY=your-api-key-here
+    ARTHUR_TASK_ID=${req.taskId}
+
+STEP 3 \u2014 VALIDATION:
+  - Install new dependencies
+  - Run an import/syntax check
+  - Run the existing test suite if present and fix any new failures
+  - Print the final JSON result
+
+${base}`
+  };
+  return typePrompts[req.type];
+}
+function parseResult(text2) {
+  const lines = text2.split("\n").reverse();
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("{") && trimmed.includes('"success"')) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+      }
+    }
+  }
+  const failed = /error|fail|exception|traceback/i.test(text2.slice(-500));
+  return {
+    success: !failed,
+    testsPassed: !failed,
+    summary: failed ? "Instrumentation may have issues (no structured result returned)" : "Instrumentation applied"
+  };
+}
+async function instrumentCodeWithClaude(req) {
+  const spinner = ora4({ text: buzzSay("Analyzing codebase and applying instrumentation..."), color: "cyan" }).start();
+  const onProgress = (msg) => {
+    const clean = msg.replace(/\x1B\[[0-9;]*m/g, "").trim();
+    if (clean) {
+      spinner.clear();
+      process.stdout.write(chalk.dim("  \u203A ") + clean + "\n");
+    }
+  };
+  let fullOutput = "";
+  let finalResult = null;
+  try {
+    const stream = query({
+      prompt: buildPrompt(req),
+      options: {
+        cwd: req.repoPath,
+        // Full tool access so Claude can run tests, install deps, fix failures
+        allowedTools: ["Read", "Glob", "Grep", "Edit", "Write", "Bash"],
+        permissionMode: "acceptEdits",
+        systemPrompt: SYSTEM_PROMPTS[req.type],
+        env: {
+          ...process.env,
+          ARTHUR_API_KEY: req.apiKey,
+          ARTHUR_BASE_URL: req.arthurEngineUrl,
+          ARTHUR_TASK_ID: req.taskId
+        }
+      }
+    });
+    for await (const message of stream) {
+      if (message.type === "assistant") {
+        const content = message.message?.content ?? [];
+        for (const block of content) {
+          if (block.type === "text" && block.text) {
+            fullOutput += block.text;
+            const lastLine = block.text.split("\n").filter(Boolean).at(-1);
+            if (lastLine) {
+              onProgress(lastLine);
+            }
+          }
+        }
+      } else if (message.type === "result") {
+        const resultMsg = message;
+        finalResult = parseResult(fullOutput + "\n" + (resultMsg.result ?? ""));
+        if (resultMsg.subtype === "success") {
+          spinner.succeed(buzzSay("Instrumentation task completed."));
+        } else {
+          spinner.fail(buzzSay(`Task ended: ${resultMsg.subtype}`));
+          if (!finalResult.success) {
+            finalResult.success = false;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    spinner.fail(buzzSay("Instrumentation failed."));
+    const errMsg = err instanceof Error ? err.message : String(err);
+    return { success: false, testsPassed: false, summary: errMsg };
+  }
+  return finalResult ?? parseResult(fullOutput);
+}
+
+// src/workflow/steps/04-python.ts
+async function step4_InstrumentPython(state) {
+  const analysis = state.analysis;
+  if (analysis.language !== "python") {
+    p.log.info(buzzSay(`Repository detected as ${analysis.language} \u2014 skipping Python instrumentation.`));
+    return false;
+  }
+  logSuccess(`Python application detected. Framework: ${analysis.framework ?? "unknown"}`);
+  if (analysis.isInstrumented && analysis.instrumentationType === "arthur-sdk") {
+    logSuccess("Arthur Python Observability SDK is already instrumented. All systems go.");
+    return true;
+  }
+  if (analysis.isInstrumented) {
+    logSuccess(`Application is already instrumented (${analysis.instrumentationType}). Proceeding.`);
+    return true;
+  }
+  note(
+    `Buzz will add the Arthur Python Observability SDK to your application.
+
+What will change:
+  \u2022 arthur-observability-sdk added to requirements.txt / pyproject.toml
+  \u2022 Arthur initialization code added to your entry point
+  \u2022 ARTHUR_API_KEY added to .env (with actual key) and .env.example (placeholder)
+
+Arthur Engine URL: ${state.engineUrl}
+Task ID: ${state.taskId}`,
+    "Instrumentation plan"
+  );
+  const approved = await confirm("May Buzz instrument your Python app with the Arthur SDK?");
+  if (!approved) {
+    logSuccess("Instrumentation skipped by user request.");
+    return true;
+  }
+  p.log.info(buzzSay("Initiating Python instrumentation launch sequence..."));
+  console.log();
+  const result = await instrumentCodeWithClaude(
+    {
+      repoPath: state.repoPath,
+      type: "python-arthur-sdk",
+      arthurEngineUrl: state.engineUrl,
+      taskId: state.taskId,
+      apiKey: state.apiKey
+    }
+  );
+  console.log();
+  if (result.success) {
+    logSuccess(`Instrumentation applied. ${result.summary}`);
+  } else {
+    logWarn(`Instrumentation may be incomplete. ${result.summary}`);
+    note(
+      "Review the changes Claude made and verify manually before proceeding.",
+      "Manual verification needed"
+    );
+  }
+  if (!result.testsPassed && result.success) {
+    logWarn("Some tests are not passing. This may be pre-existing failures unrelated to Buzz.");
+    note(result.summary, "Test results");
+  }
+  return true;
+}
+
+// src/workflow/steps/05-mastra.ts
+async function step5_InstrumentMastra(state) {
+  const analysis = state.analysis;
+  if (analysis.framework !== "mastra") {
+    p.log.info(buzzSay(`Framework detected as "${analysis.framework ?? "unknown"}" \u2014 skipping Mastra instrumentation.`));
+    return false;
+  }
+  logSuccess(`Mastra TypeScript application detected.`);
+  if (analysis.isInstrumented && analysis.instrumentationType === "mastra-arthur-exporter") {
+    logSuccess("Mastra Arthur exporter is already configured. All systems go.");
+    return true;
+  }
+  if (analysis.isInstrumented) {
+    logSuccess(`Application is already instrumented (${analysis.instrumentationType}). Proceeding.`);
+    return true;
+  }
+  note(
+    `Buzz will add the Mastra Arthur exporter to your application.
+
+What will change:
+  \u2022 @mastra/arthur package installed (npm install @mastra/arthur)
+  \u2022 ArthurExporter registered in your Mastra instance observability config
+  \u2022 ARTHUR_BASE_URL, ARTHUR_API_KEY, ARTHUR_TASK_ID added to .env (with actual values) and .env.example (placeholders)
+
+Arthur Engine URL: ${state.engineUrl}
+Task ID: ${state.taskId}`,
+    "Instrumentation plan"
+  );
+  const approved = await confirm("May Buzz add the Mastra Arthur exporter to your application?");
+  if (!approved) {
+    logSuccess("Instrumentation skipped by user request.");
+    return true;
+  }
+  p.log.info(buzzSay("Initiating Mastra Arthur exporter launch sequence..."));
+  console.log();
+  const result = await instrumentCodeWithClaude(
+    {
+      repoPath: state.repoPath,
+      type: "mastra-arthur-exporter",
+      arthurEngineUrl: state.engineUrl,
+      taskId: state.taskId,
+      apiKey: state.apiKey
+    }
+  );
+  console.log();
+  if (result.success) {
+    logSuccess(`Mastra exporter configured. ${result.summary}`);
+  } else {
+    logWarn(`Instrumentation may be incomplete. ${result.summary}`);
+    note(
+      "Review the changes Claude made and verify manually before proceeding.",
+      "Manual verification needed"
+    );
+  }
+  if (!result.testsPassed && result.success) {
+    logWarn("Some tests are not passing. This may be pre-existing failures.");
+    note(result.summary, "Test results");
+  }
+  return true;
+}
+
+// src/workflow/steps/06-other.ts
+async function step6_InstrumentOther(state) {
+  const analysis = state.analysis;
+  p.log.info(
+    buzzSay(
+      `Detected: ${analysis.language} application${analysis.framework ? ` (${analysis.framework})` : ""}. Applying OpenInference instrumentation.`
+    )
+  );
+  if (analysis.isInstrumented && analysis.instrumentationType === "openinference") {
+    logSuccess("OpenInference instrumentation is already configured. All systems go.");
+    return true;
+  }
+  if (analysis.isInstrumented) {
+    logSuccess(`Application is already instrumented (${analysis.instrumentationType}). Proceeding.`);
+    return true;
+  }
+  note(
+    `Buzz will instrument your application with OpenInference and OpenTelemetry for Arthur.
+
+What will change:
+  \u2022 OpenTelemetry OTLP exporter configured to send traces to Arthur
+  \u2022 OpenInference instrumentor added for your detected LLM framework
+  \u2022 ARTHUR_BASE_URL, ARTHUR_API_KEY, ARTHUR_TASK_ID added to .env (with actual values) and .env.example (placeholders)
+
+Arthur Engine URL: ${state.engineUrl}
+Task ID: ${state.taskId}
+
+Reference: github.com/arthur-ai/arthur-engine/tree/dev/genai-engine/examples/agents`,
+    "Instrumentation plan (OpenInference)"
+  );
+  const approved = await confirm("May Buzz instrument your application with OpenInference for Arthur?");
+  if (!approved) {
+    logSuccess("Instrumentation skipped by user request.");
+    return true;
+  }
+  p.log.info(buzzSay("Initiating OpenInference instrumentation launch sequence..."));
+  console.log();
+  const result = await instrumentCodeWithClaude(
+    {
+      repoPath: state.repoPath,
+      type: "openinference",
+      arthurEngineUrl: state.engineUrl,
+      taskId: state.taskId,
+      apiKey: state.apiKey
+    }
+  );
+  console.log();
+  if (result.success) {
+    logSuccess(`OpenInference instrumentation applied. ${result.summary}`);
+  } else {
+    logWarn(`Instrumentation may be incomplete. ${result.summary}`);
+    note(
+      "Review the changes Claude made and verify manually.\nYou can also consult the examples at:\ngithub.com/arthur-ai/arthur-engine/tree/dev/genai-engine/examples/agents",
+      "Manual verification needed"
+    );
+  }
+  if (!result.testsPassed && result.success) {
+    logWarn("Some tests are not passing. This may be pre-existing failures.");
+    note(result.summary, "Test results");
+  }
+  return true;
+}
+
+// src/workflow/steps/07-prompts.ts
+import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+import ora5 from "ora";
+var PROVIDER_LABELS = {
+  openai: "OpenAI",
+  anthropic: "Anthropic",
+  gemini: "Google Gemini",
+  bedrock: "AWS Bedrock",
+  vertex_ai: "Google Vertex AI"
+};
+var MODEL_DEFAULTS = {
+  openai: "gpt-4o",
+  anthropic: "claude-3-5-haiku-20241022",
+  gemini: "gemini-1.5-flash",
+  bedrock: "anthropic.claude-3-haiku-20240307-v1:0",
+  vertex_ai: "gemini-1.5-flash"
+};
+function isSupportedProvider(provider) {
+  return provider in MODEL_DEFAULTS;
+}
+var EXTRACTION_INSTRUCTIONS = `You are Buzz's prompt extraction module. Your job is to analyze an agentic
+application's repository and extract all prompt definitions \u2014 system prompts, user prompt templates,
+and agent instructions.
+
+Use your tools to thoroughly examine the codebase:
+1. Glob to see all files
+2. Read manifests and key source files
+3. Grep for prompt patterns: system_prompt, SYSTEM_PROMPT, systemPrompt, messages, ChatCompletion, etc.
+
+Look for:
+- System prompt strings assigned to variables (any language)
+- User prompt templates (strings with {variables} or {{variables}})
+- Multi-turn message arrays in OpenAI format ([{"role": "system", ...}, {"role": "user", ...}])
+- Prompt files (.txt, .md, .jinja2, .j2) that contain prompt templates
+- Agent instruction strings passed to agent/chain initialization
+
+Also detect the LLM model and provider the application uses (e.g. from openai.ChatCompletion calls,
+from anthropic.Anthropic(), from model= parameters, from environment variable names like OPENAI_API_KEY).
+Report the provider exactly as detected (e.g. "azure" if the app uses Azure OpenAI).
+
+Return ONLY a raw JSON object (no markdown, no explanation):
+{
+  "prompts": [
+    {
+      "name": "kebab-case-prompt-name",
+      "messages": [
+        {"role": "system", "content": "..."},
+        {"role": "user", "content": "..."}
+      ],
+      "model_name": "gpt-4o" | null,
+      "model_provider": "openai" | "anthropic" | "gemini" | "bedrock" | "vertex_ai" | "azure" | null
+    }
+  ],
+  "detected_model_name": "gpt-4o" | null,
+  "detected_model_provider": "openai" | "anthropic" | "gemini" | "bedrock" | "vertex_ai" | "azure" | null
+}
+
+Rules:
+- Only include prompts with actual substantive content (not empty strings or placeholders)
+- For user prompt templates with variables, convert ALL template variables to {{double_brace}} format regardless of how they appear in source (e.g. {text} \u2192 {{text}}, %(text)s \u2192 {{text}})
+- The "name" must be unique, lowercase, kebab-case, and descriptive (e.g. "customer-support-agent", "summarization-prompt")
+- If the same prompt appears multiple times (e.g. in tests), include it only once
+- model_name and model_provider at prompt level: use values detected for that specific prompt call if known, else null
+- detected_model_name/detected_model_provider: the primary model the app uses overall
+- If no prompts are found, return {"prompts": [], "detected_model_name": null, "detected_model_provider": null}`;
+function normalizeMessageContent(content) {
+  let result = content.replace(/\n{3,}/g, "\n\n");
+  result = result.replace(/(?<!\{)\{([^{}]+)\}(?!\})/g, "{{$1}}");
+  return result.trim();
+}
+function extractJSON(text2) {
+  const blockMatch = text2.match(/```(?:json)?\s*([\s\S]+?)```/);
+  if (blockMatch) return blockMatch[1].trim();
+  const jsonMatch = text2.match(/\{[\s\S]+\}/);
+  if (jsonMatch) return jsonMatch[0];
+  return text2.trim();
+}
+async function extractPromptsWithClaude(repoPath) {
+  try {
+    const stream = query2({
+      prompt: `Extract all prompts from the agentic application at: ${repoPath}
+
+Use your tools to examine the files thoroughly, then return the JSON result.`,
+      options: {
+        cwd: repoPath,
+        allowedTools: ["Read", "Glob", "Grep"],
+        systemPrompt: EXTRACTION_INSTRUCTIONS,
+        maxTurns: 5
+      }
+    });
+    let fullOutput = "";
+    for await (const message of stream) {
+      if (message.type === "assistant") {
+        const content = message.message?.content ?? [];
+        for (const block of content) {
+          if (block.type === "text" && block.text) {
+            fullOutput += block.text;
+          }
+        }
+      }
+    }
+    const result = JSON.parse(extractJSON(fullOutput));
+    result.prompts = result.prompts.map((prompt) => ({
+      ...prompt,
+      messages: prompt.messages.map((msg) => ({
+        ...msg,
+        content: normalizeMessageContent(msg.content)
+      }))
+    }));
+    return result;
+  } catch {
+    return { prompts: [], detected_model_name: null, detected_model_provider: null };
+  }
+}
+async function ensureProviderConfiguredInEngine(client, provider, model) {
+  const spinner = ora5({ text: buzzSay(`Checking if ${PROVIDER_LABELS[provider] ?? provider} is configured in Arthur Engine...`), color: "cyan" }).start();
+  const providers = await client.getModelProviders();
+  spinner.stop();
+  const isConfigured = providers.some((p3) => p3.provider === provider && p3.enabled);
+  if (isConfigured) {
+    logSuccess(`${PROVIDER_LABELS[provider] ?? provider} is already configured in Arthur Engine.`);
+    note(
+      `Prompts will be registered with model: ${model ?? "default"} (${PROVIDER_LABELS[provider] ?? provider})`,
+      "Prompt model provider"
+    );
+    return;
+  }
+  logWarn(`${PROVIDER_LABELS[provider] ?? provider} is not yet configured in Arthur Engine.`);
+  note(
+    "Arthur Engine needs the API key for this provider to be able to run the prompts.\nYou can skip this and configure it later in the Arthur Engine UI under Settings \u2192 Model Providers.",
+    "Model provider required"
+  );
+  const wantsConfigure = await confirm(
+    `Configure ${PROVIDER_LABELS[provider] ?? provider} in Arthur Engine now?`
+  );
+  if (!wantsConfigure) {
+    logWarn("Skipping provider configuration. Prompts will be registered but cannot be run until a provider is configured.");
+    return;
+  }
+  const apiKey = await password(`Enter your ${PROVIDER_LABELS[provider] ?? provider} API key:`);
+  const configSpinner = ora5({ text: buzzSay(`Configuring ${PROVIDER_LABELS[provider] ?? provider}...`), color: "cyan" }).start();
+  const result = await client.configureModelProvider(provider, { api_key: apiKey });
+  configSpinner.stop();
+  if (!result.success) {
+    logError(`Failed to configure ${PROVIDER_LABELS[provider] ?? provider}: ${result.error}`);
+    logWarn("Prompts will still be registered. Configure the provider manually in Arthur Engine UI.");
+  } else {
+    logSuccess(`${PROVIDER_LABELS[provider] ?? provider} configured in Arthur Engine.`);
+    note(
+      `Prompts will be registered with model: ${model ?? "default"} (${PROVIDER_LABELS[provider] ?? provider})`,
+      "Prompt model provider ready"
+    );
+  }
+}
+async function step7_ExtractAndRegisterPrompts(state) {
+  const spinner = ora5({ text: buzzSay("Scanning codebase for prompts..."), color: "cyan" }).start();
+  const extraction = await extractPromptsWithClaude(state.repoPath);
+  spinner.stop();
+  if (extraction.detected_model_provider && isSupportedProvider(extraction.detected_model_provider)) {
+    state.promptModelProvider = extraction.detected_model_provider;
+    state.promptModelName = extraction.detected_model_name ?? MODEL_DEFAULTS[extraction.detected_model_provider] ?? null;
+  }
+  if (extraction.prompts.length === 0) {
+    p.log.info(buzzSay("No prompts detected in the repository. Skipping prompt registration."));
+    return;
+  }
+  logInfo(`Found ${extraction.prompts.length} prompt(s) in your codebase:`);
+  for (const [i, prompt] of extraction.prompts.entries()) {
+    const rolesSummary = prompt.messages.map((m) => m.role).join(" \u2192 ");
+    p.log.message(`  ${i + 1}. ${prompt.name}  (${rolesSummary})`);
+  }
+  const shouldRegister = await confirm(
+    `Should Buzz register these ${extraction.prompts.length} prompt(s) in Arthur Engine for version tracking?`
+  );
+  if (!shouldRegister) {
+    logInfo("Prompt registration skipped. You can add prompts manually in the Arthur Engine UI.");
+    return;
+  }
+  const detectedRaw = extraction.detected_model_provider;
+  let fallbackProvider = null;
+  let fallbackModel = extraction.detected_model_name;
+  if (detectedRaw && isSupportedProvider(detectedRaw)) {
+    fallbackProvider = detectedRaw;
+  } else if (detectedRaw) {
+    logWarn(`Your app uses ${detectedRaw}, which isn't currently supported by Arthur Engine.`);
+    note(
+      "Arthur Engine supports: OpenAI, Anthropic, Google Gemini, AWS Bedrock, Google Vertex AI.\nTo register prompts you'll need to configure one of these providers.",
+      "Unsupported provider detected"
+    );
+  }
+  if (!fallbackProvider) {
+    const choice = await select(
+      "Which supported provider should Arthur Engine use to run your prompts?",
+      [
+        { value: "openai", label: "OpenAI", hint: "gpt-4o, gpt-4o-mini, ..." },
+        { value: "anthropic", label: "Anthropic", hint: "claude-3-5-haiku, claude-3-5-sonnet, ..." },
+        { value: "gemini", label: "Google Gemini", hint: "gemini-1.5-flash, gemini-1.5-pro, ..." },
+        { value: "bedrock", label: "AWS Bedrock", hint: "anthropic.claude-3-haiku, ..." },
+        { value: "vertex_ai", label: "Google Vertex AI", hint: "gemini-1.5-flash, ..." },
+        { value: "skip", label: "Skip \u2014 I'll set it later", hint: "Prompts will not be registered until a provider is configured" }
+      ]
+    );
+    if (choice !== "skip") {
+      fallbackProvider = choice;
+      fallbackModel = MODEL_DEFAULTS[choice] ?? null;
+      state.promptModelProvider = fallbackProvider;
+      state.promptModelName = fallbackModel;
+    }
+  }
+  if (!fallbackProvider) {
+    note(
+      "Prompt registration requires a model provider.\nConfigure one in the Arthur Engine UI under Settings \u2192 Model Providers, then re-run Buzz to register your prompts.",
+      "Prompt registration skipped"
+    );
+    return;
+  }
+  const client = new ArthurEngineClient(state.engineUrl, state.apiKey);
+  await ensureProviderConfiguredInEngine(client, fallbackProvider, fallbackModel);
+  let created = 0;
+  for (const prompt of extraction.prompts) {
+    const rawProvider = prompt.model_provider ?? fallbackProvider ?? "openai";
+    const provider = isSupportedProvider(rawProvider) ? rawProvider : fallbackProvider ?? "openai";
+    const model = prompt.model_name ?? fallbackModel ?? MODEL_DEFAULTS[provider] ?? "gpt-4o";
+    const promptSpinner = ora5({
+      text: buzzSay(`Registering prompt: ${prompt.name}...`),
+      color: "cyan"
+    }).start();
+    const result = await client.createPrompt(state.taskId, prompt.name, {
+      messages: prompt.messages,
+      model_name: model,
+      model_provider: provider
+    });
+    promptSpinner.stop();
+    if (result.error) {
+      logError(`Failed to register "${prompt.name}": ${result.error}`);
+    } else {
+      logSuccess(`Registered prompt: ${prompt.name} (v${result.prompt?.version ?? 1})`);
+      created++;
+    }
+  }
+  if (created > 0) {
+    logSuccess(`${created} prompt(s) registered in Arthur Engine.`);
+    note(
+      `View and manage your prompts in Arthur Engine:
+  ${state.engineUrl}`,
+      "Prompts registered"
+    );
+  } else {
+    logWarn("No prompts were registered. You can add them manually in the Arthur Engine UI.");
+  }
+}
+
+// src/workflow/steps/08-verify.ts
+import ora6 from "ora";
+var POLL_INTERVAL_MS = 3e3;
+var POLL_MAX_MS = process.env.BUZZ_CI === "true" ? 12e4 : 6e4;
+async function pollForTraces(client, taskId) {
+  const spinner = ora6({ text: buzzSay("Checking for traces in Arthur..."), color: "cyan" }).start();
+  const start = Date.now();
+  let lastError;
+  while (Date.now() - start < POLL_MAX_MS) {
+    const result = await client.getTraces(taskId);
+    if (result.traces.length > 0) {
+      spinner.stop();
+      logSuccess(`We have signal! ${result.traces.length} trace(s) detected.`);
+      return { found: true };
+    }
+    if (result.error) {
+      lastError = result.error;
+    }
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+    spinner.text = buzzSay(`Scanning for traces... (${Math.round((Date.now() - start) / 1e3)}s)`);
+  }
+  spinner.stop();
+  logWarn("No traces detected after 60 seconds.");
+  return { found: false, lastError };
+}
+async function step8_VerifyInstrumentation(state) {
+  const client = new ArthurEngineClient(state.engineUrl, state.apiKey);
+  const isLocal = state.engineUrl?.includes("localhost") || state.engineUrl?.includes("127.0.0.1");
+  note(
+    `To verify instrumentation, run your agentic application now so it sends traces to Arthur.
+
+Make sure to set these environment variables before running:
+  ARTHUR_API_KEY=<your-api-key>
+  ARTHUR_BASE_URL=${state.engineUrl}
+  ARTHUR_TASK_ID=${state.taskId}`,
+    "Run your agent"
+  );
+  const ready = await confirm("Press Enter / confirm when your agent has run at least once");
+  if (!ready) {
+    return;
+  }
+  const { found: traced, lastError } = await pollForTraces(client, state.taskId);
+  if (traced) {
+    const apiKeyHint = isLocal ? `
+
+API key hint (local install):
+  cat ${GENAI_ENGINE_ENV_PATH} | grep GENAI_ENGINE_ADMIN_KEY` : "";
+    note(
+      `Login to Arthur GenAI Engine at:
+  ${state.engineUrl}
+
+Your Task ID: ${state.taskId}${apiKeyHint}`,
+      "Arthur GenAI Engine is ready"
+    );
+    logSuccess("Instrumentation confirmed. Your traces are flowing to Arthur.");
+  } else {
+    logWarn("No traces detected. Instrumentation may not be sending data yet.");
+    const errorHint = lastError ? `
+
+Last error from engine:
+  ${lastError}` : "";
+    note(
+      "Troubleshooting checklist:\n  1. Did your application run and make at least one LLM call?\n  2. Is ARTHUR_API_KEY set correctly in your environment?\n  3. Is ARTHUR_BASE_URL pointing to: " + state.engineUrl + "?\n  4. Is ARTHUR_TASK_ID set to: " + state.taskId + "?\n  5. Check your application logs for any OpenTelemetry export errors." + errorHint,
+      "No traces detected"
+    );
+    const retry = await confirm("Would you like to check for traces again?");
+    if (retry) {
+      const { found: retried, lastError: retryError } = await pollForTraces(client, state.taskId);
+      if (retried) {
+        logSuccess("Instrumentation confirmed. Your traces are flowing to Arthur.");
+        note(
+          `Login at: ${state.engineUrl}
+Task ID: ${state.taskId}`,
+          "Arthur GenAI Engine is ready"
+        );
+      } else {
+        logWarn("Still no traces. Please review the troubleshooting checklist above.");
+        const retryErrorHint = retryError ? `
+
+Last error from engine:
+  ${retryError}` : "";
+        note(
+          `Arthur Engine URL: ${state.engineUrl}
+Task ID: ${state.taskId}` + retryErrorHint,
+          "Manual verification needed"
+        );
+      }
+    }
+  }
+}
+
+// src/workflow/steps/09-model-provider.ts
+import ora7 from "ora";
+var PROVIDER_PRIORITY = ["openai", "anthropic", "gemini", "bedrock", "vertex_ai"];
+var PROVIDER_LABELS2 = {
+  openai: "OpenAI",
+  anthropic: "Anthropic",
+  gemini: "Google Gemini (AI Studio)",
+  bedrock: "AWS Bedrock",
+  vertex_ai: "Google Vertex AI"
+};
+var MODEL_DEFAULTS2 = {
+  openai: "gpt-4o",
+  anthropic: "claude-3-5-haiku-20241022",
+  gemini: "gemini-1.5-flash",
+  bedrock: "anthropic.claude-3-haiku-20240307-v1:0",
+  vertex_ai: "gemini-1.5-flash"
+};
+function pickHighestPriorityProvider(providers) {
+  const enabled = providers.filter((p3) => p3.enabled);
+  for (const name of PROVIDER_PRIORITY) {
+    const match = enabled.find((e) => e.provider === name);
+    if (match && MODEL_DEFAULTS2[name]) {
+      return { provider: name, model: MODEL_DEFAULTS2[name] };
+    }
+  }
+  return null;
+}
+async function configureNewProvider(client) {
+  const provider = await select(
+    "Which LLM provider should Arthur use to run evaluations?",
+    [
+      { value: "openai", label: "OpenAI", hint: "gpt-4o, gpt-4o-mini, ..." },
+      { value: "anthropic", label: "Anthropic", hint: "claude-3-5-haiku, claude-3-5-sonnet, ..." },
+      { value: "gemini", label: "Google Gemini", hint: "gemini-1.5-flash, gemini-1.5-pro, ..." },
+      { value: "bedrock", label: "AWS Bedrock", hint: "anthropic.claude-3-haiku, ..." },
+      { value: "vertex_ai", label: "Google Vertex AI", hint: "gemini-1.5-flash, ..." },
+      { value: "skip", label: "Skip for now", hint: "Configure manually in Arthur Engine UI \u2014 evals will be skipped" }
+    ]
+  );
+  if (provider === "skip") {
+    note(
+      "You can configure a model provider in the Arthur Engine UI under Settings \u2192 Model Providers.",
+      "Eval model provider skipped"
+    );
+    return null;
+  }
+  const apiKey = await password(`Enter your ${PROVIDER_LABELS2[provider]} API key:`);
+  const spinner = ora7({ text: buzzSay(`Configuring ${PROVIDER_LABELS2[provider]}...`), color: "cyan" }).start();
+  const result = await client.configureModelProvider(provider, { api_key: apiKey });
+  spinner.stop();
+  if (!result.success) {
+    logError(`Failed to configure ${PROVIDER_LABELS2[provider]}: ${result.error}`);
+    note(
+      "You can configure a model provider manually in the Arthur Engine UI under Settings \u2192 Model Providers.",
+      "Configuration failed"
+    );
+    return null;
+  }
+  logSuccess(`${PROVIDER_LABELS2[provider]} configured successfully.`);
+  return { provider, model: MODEL_DEFAULTS2[provider] };
+}
+async function step9_SelectEvalModelProvider(state) {
+  const client = new ArthurEngineClient(state.engineUrl, state.apiKey);
+  const spinner = ora7({ text: buzzSay("Checking available model providers for evals..."), color: "cyan" }).start();
+  const providers = await client.getModelProviders();
+  spinner.stop();
+  const auto = pickHighestPriorityProvider(providers);
+  if (auto) {
+    const enabledSupported = providers.filter((p3) => p3.enabled && MODEL_DEFAULTS2[p3.provider]);
+    logInfo(`Model providers configured on this Arthur Engine:`);
+    for (const mp of enabledSupported) {
+      logInfo(`  \u2022 ${PROVIDER_LABELS2[mp.provider] ?? mp.provider}`);
+    }
+    if (enabledSupported.length === 1) {
+      const useAuto = await confirm(
+        `Use ${PROVIDER_LABELS2[auto.provider] ?? auto.provider} (${auto.model}) to run evaluations?`
+      );
+      if (useAuto) {
+        state.evalModelProvider = auto.provider;
+        state.evalModelName = auto.model;
+        logSuccess(`Eval model set: ${auto.model} via ${PROVIDER_LABELS2[auto.provider] ?? auto.provider}`);
+        return;
+      }
+      const result2 = await configureNewProvider(client);
+      if (result2) {
+        state.evalModelProvider = result2.provider;
+        state.evalModelName = result2.model;
+        logSuccess(`Eval model set: ${result2.model} via ${PROVIDER_LABELS2[result2.provider] ?? result2.provider}`);
+      } else {
+        logWarn("No eval model provider selected. Eval recommendations will be skipped.");
+      }
+      return;
+    }
+    const options = enabledSupported.map((p3) => ({
+      value: p3.provider,
+      label: PROVIDER_LABELS2[p3.provider] ?? p3.provider,
+      hint: MODEL_DEFAULTS2[p3.provider]
+    }));
+    options.push({ value: "new", label: "Configure a different provider", hint: "Add API key for a new provider" });
+    const chosen = await select("Which provider should run evaluations?", options);
+    if (chosen === "new") {
+      const result2 = await configureNewProvider(client);
+      if (result2) {
+        state.evalModelProvider = result2.provider;
+        state.evalModelName = result2.model;
+        logSuccess(`Eval model set: ${result2.model} via ${PROVIDER_LABELS2[result2.provider] ?? result2.provider}`);
+      } else {
+        logWarn("No eval model provider selected. Eval recommendations will be skipped.");
+      }
+    } else {
+      state.evalModelProvider = chosen;
+      state.evalModelName = MODEL_DEFAULTS2[chosen] ?? null;
+      logSuccess(`Eval model set: ${state.evalModelName} via ${PROVIDER_LABELS2[chosen] ?? chosen}`);
+    }
+    return;
+  }
+  logWarn("No model providers are configured on this Arthur Engine yet.");
+  const wantsSetup = await confirm(
+    "Would you like to configure one now so Buzz can recommend evals?"
+  );
+  if (!wantsSetup) {
+    note(
+      "Eval recommendations require a model provider.\nConfigure one in the Arthur Engine UI under Settings \u2192 Model Providers, then re-run Buzz.",
+      "No eval model provider"
+    );
+    return;
+  }
+  const result = await configureNewProvider(client);
+  if (result) {
+    state.evalModelProvider = result.provider;
+    state.evalModelName = result.model;
+    logSuccess(`Eval model set: ${result.model} via ${PROVIDER_LABELS2[result.provider] ?? result.provider}`);
+  } else {
+    logWarn("No eval model provider configured. Eval recommendations will be skipped.");
+  }
+}
+
+// src/workflow/steps/10-evals.ts
+import ora8 from "ora";
+
+// src/mastra/eval-recommender.ts
+import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
+var INSTRUCTIONS = `You are an Arthur GenAI Engine eval analyst. Given a sample trace from a user's
+agentic application (input prompts + model outputs) and their framework info, recommend 2-4
+continuous eval configurations that provide the most meaningful quality monitoring.
+
+Each eval uses a Jinja2 template where {{ input }} is the user's prompt and {{ output }} is the
+model's response. Instructions must end with a clear scoring directive asking the evaluator LLM
+to return a JSON object with "score" (0.0-1.0, where 1.0 = fully passes) and "reason" (brief explanation).
+
+IMPORTANT \u2014 Hallucination / Faithfulness evals:
+Only recommend a hallucination or faithfulness eval if the prompt explicitly states
+"Retrieval context available: YES" AND the trace includes reference material (retrieved
+documents, ground truth passages, or source context) that the model output should be faithful to.
+If the trace only shows a user input and a model response with no reference material, do NOT
+recommend hallucination or faithfulness evals \u2014 they cannot be evaluated correctly without a
+reference context to compare against.
+
+If the user already has evals covering the main quality dimensions, it is acceptable to return an empty recommendations array if no additional high-value evals remain.
+
+Consider these common eval types and adapt them to the application's context:
+- Relevance: does the output address what the input asked?
+- Faithfulness / Hallucination: does the output contain unsupported claims? (ONLY if retrieval context is available)
+- Toxicity: does the output contain harmful or offensive content?
+- Conciseness: is the output appropriately concise?
+- Task completion: did the agent accomplish what was asked?
+
+Choose evals that fit the actual use case evident from the trace. For example:
+- Customer support apps \u2192 relevance, tone, task completion
+- RAG / Q&A apps \u2192 faithfulness, relevance (only when retrieval context is confirmed present)
+- Code assistants \u2192 correctness, clarity
+- General chat \u2192 relevance, toxicity
+
+Return ONLY a raw JSON object with no markdown fences, no preamble, no explanation:
+{
+  "recommendations": [
+    {
+      "slug": "kebab-case-slug",
+      "displayName": "Human Readable Name",
+      "rationale": "One sentence explaining why this eval matters for this application",
+      "instructions": "Evaluate the following LLM interaction...
+
+Input: {{ input }}
+Output: {{ output }}
+
+Return a JSON object: {"score": <0.0-1.0>, "reason": "<brief explanation>"}"
+    }
+  ]
+}`;
+function extractJSON2(text2) {
+  const blockMatch = text2.match(/```(?:json)?\s*([\s\S]+?)```/);
+  if (blockMatch) return blockMatch[1].trim();
+  const jsonMatch = text2.match(/\{[\s\S]+\}/);
+  if (jsonMatch) return jsonMatch[0];
+  return text2.trim();
+}
+async function recommendEvals(traceContent, spanName, framework, language, modelProvider, hasRetrievalContext, existingEvals = []) {
+  const frameworkNote = framework ? `Framework: ${framework} (${language})` : `Language: ${language}`;
+  const existingEvalsNote = existingEvals.length > 0 ? `
+Existing evals already configured (DO NOT recommend these or any functionally equivalent eval):
+` + existingEvals.map(
+    (e) => e.instructions ? `- ${e.name}
+  Instructions: ${e.instructions.slice(0, 300)}` : `- ${e.name}`
+  ).join("\n") + "\n" : "";
+  const prompt = `Analyze this trace and recommend the most impactful continuous evals:
+
+${frameworkNote}
+Eval model provider available: ${modelProvider}
+Span name: ${spanName}
+Retrieval context available: ${hasRetrievalContext ? "YES" : "NO"}
+${existingEvalsNote}
+Trace content:
+${traceContent}`;
+  try {
+    const stream = query3({
+      prompt,
+      options: {
+        allowedTools: [],
+        systemPrompt: INSTRUCTIONS,
+        maxTurns: 1
+      }
+    });
+    let fullOutput = "";
+    for await (const message of stream) {
+      if (message.type === "assistant") {
+        const content = message.message?.content ?? [];
+        for (const block of content) {
+          if (block.type === "text" && block.text) {
+            fullOutput += block.text;
+          }
+        }
+      }
+    }
+    const jsonText = extractJSON2(fullOutput);
+    const parsed = JSON.parse(jsonText);
+    if (!Array.isArray(parsed.recommendations)) {
+      return { ok: false, reason: "Claude returned no eval recommendations for this trace." };
+    }
+    return { ok: true, recommendations: parsed };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `Claude API error: ${message}` };
+  }
+}
+
+// src/workflow/steps/10-evals.ts
+var RETRIEVAL_SPAN_PATTERN = /retriev|search|fetch|document|rag/i;
+function isRetrievalSpan(span) {
+  return span.span_kind === "RETRIEVER" || span.span_name != null && RETRIEVAL_SPAN_PATTERN.test(span.span_name);
+}
+function flattenSpans(spans) {
+  const result = [];
+  for (const span of spans) {
+    result.push(span);
+    if (span.children?.length) {
+      result.push(...flattenSpans(span.children));
+    }
+  }
+  return result;
+}
+function extractBestSpan(trace) {
+  const all = flattenSpans(trace.root_spans ?? []);
+  return all.find((s) => s.input_content || s.output_content) ?? null;
+}
+function buildTraceContent(span, trace) {
+  const input = span.input_content ? span.input_content.slice(0, 1500) : "(none)";
+  const output = span.output_content ? span.output_content.slice(0, 1500) : "(none)";
+  const allSpans = flattenSpans(trace.root_spans ?? []);
+  const retrievalSpans = allSpans.filter(isRetrievalSpan);
+  const hasRetrievalContext = retrievalSpans.length > 0;
+  let content = `INPUT:
+${input}
+
+OUTPUT:
+${output}`;
+  if (hasRetrievalContext) {
+    const contextParts = retrievalSpans.map((s) => {
+      const parts = [];
+      if (s.input_content) parts.push(`Query: ${s.input_content.slice(0, 500)}`);
+      if (s.output_content) parts.push(`Retrieved: ${s.output_content.slice(0, 1e3)}`);
+      return parts.join("\n");
+    }).filter(Boolean);
+    if (contextParts.length > 0) {
+      content += `
+
+RETRIEVAL CONTEXT:
+${contextParts.join("\n---\n")}`;
+    }
+  }
+  return { content, hasRetrievalContext };
+}
+async function step10_RecommendEvals(state) {
+  if (!state.engineUrl || !state.apiKey || !state.taskId) {
+    logWarn("Skipping eval recommendations \u2014 engine connection not established.");
+    return;
+  }
+  if (!state.evalModelProvider || !state.evalModelName) {
+    logWarn("Skipping eval recommendations \u2014 no eval model provider configured.");
+    note(
+      "Configure a model provider in the Arthur Engine UI under Settings \u2192 Model Providers,\nthen re-run Buzz to get personalized eval recommendations.",
+      "No eval model provider"
+    );
+    return;
+  }
+  const client = new ArthurEngineClient(state.engineUrl, state.apiKey);
+  const existingSpinner = ora8({
+    text: buzzSay("Checking existing evals..."),
+    color: "cyan"
+  }).start();
+  const [existingContinuousEvals, existingLlmEvals] = await Promise.all([
+    client.getContinuousEvals(state.taskId),
+    client.getLlmEvals(state.taskId)
+  ]);
+  existingSpinner.stop();
+  if (existingContinuousEvals.length > 0) {
+    logInfo(
+      `You already have ${existingContinuousEvals.length} continuous eval(s) configured on this task:`
+    );
+    for (const e of existingContinuousEvals) {
+      p.log.message(`  \u2022 ${e.name}`);
+    }
+    const wantsMore = await confirm(
+      "Would you like Buzz to analyze your traces and recommend additional evals?"
+    );
+    if (!wantsMore) {
+      logSuccess("Your existing evals look great \u2014 no changes needed.");
+      return;
+    }
+  }
+  const existingEvals = existingContinuousEvals.map((ce) => ({
+    name: ce.name,
+    instructions: existingLlmEvals.find((e) => e.name === ce.llm_eval_name)?.instructions
+  }));
+  const modelSelection = { provider: state.evalModelProvider, model: state.evalModelName };
+  const traceSpinner = ora8({
+    text: buzzSay("Fetching trace data for deep scan..."),
+    color: "cyan"
+  }).start();
+  const traceResult = await client.getTraces(state.taskId);
+  if (traceResult.traces.length === 0) {
+    traceSpinner.stop();
+    note(
+      "Once your application has sent traces to Arthur, re-run Buzz\nto get personalized eval recommendations based on your real trace data.",
+      "No traces available for analysis"
+    );
+    return;
+  }
+  const traceDetail = await client.getTraceDetail(traceResult.traces[0].trace_id);
+  traceSpinner.stop();
+  if (!traceDetail) {
+    logWarn("Could not fetch trace details. Skipping eval recommendations.");
+    return;
+  }
+  const bestSpan = extractBestSpan(traceDetail);
+  if (!bestSpan) {
+    logWarn("No span content found in trace. Skipping eval recommendations.");
+    return;
+  }
+  const analysisSpinner = ora8({
+    text: buzzSay("Deep scanning your application traces with Claude..."),
+    color: "cyan"
+  }).start();
+  const { content: traceContent, hasRetrievalContext } = buildTraceContent(bestSpan, traceDetail);
+  const result = await recommendEvals(
+    traceContent,
+    bestSpan.span_name ?? "unknown",
+    state.analysis?.framework ?? null,
+    state.analysis?.language ?? "unknown",
+    modelSelection.provider,
+    hasRetrievalContext,
+    existingEvals
+  );
+  analysisSpinner.stop();
+  if (!result.ok) {
+    logWarn(`Could not generate eval recommendations: ${result.reason}`);
+    return;
+  }
+  const recommendations = result.recommendations;
+  if (recommendations.recommendations.length === 0) {
+    logSuccess(
+      "Your existing evals already cover the key quality dimensions \u2014 no additional evals recommended at this time."
+    );
+    return;
+  }
+  logInfo("Based on your trace data, Buzz recommends these continuous evals:");
+  for (const [i, rec] of recommendations.recommendations.entries()) {
+    p.log.message(`${i + 1}. ${rec.displayName}`);
+    p.log.message(`   ${rec.rationale}`);
+  }
+  const approved = await confirm(
+    "Should Buzz configure these continuous evals on your task now?"
+  );
+  if (!approved) {
+    logInfo(
+      "Eval configuration skipped. You can configure evals manually in the Arthur Engine UI."
+    );
+    return;
+  }
+  const createdEvalSlugs = [];
+  for (const rec of recommendations.recommendations) {
+    const spinner = ora8({
+      text: buzzSay(`Creating LLM eval: ${rec.displayName}...`),
+      color: "cyan"
+    }).start();
+    const result2 = await client.createLlmEval(state.taskId, rec.slug, {
+      model_name: modelSelection.model,
+      model_provider: modelSelection.provider,
+      instructions: rec.instructions
+    });
+    spinner.stop();
+    if (result2.error) {
+      logError(`Failed to create eval "${rec.displayName}": ${result2.error}`);
+    } else {
+      logSuccess(`Created LLM eval: ${rec.displayName}`);
+      createdEvalSlugs.push(rec.slug);
+    }
+  }
+  if (createdEvalSlugs.length === 0) {
+    logWarn("No LLM evals were created. Skipping transform and continuous eval setup.");
+    return;
+  }
+  const transformSpinner = ora8({
+    text: buzzSay("Creating trace transform..."),
+    color: "cyan"
+  }).start();
+  const transformResult = await client.createTransform(state.taskId, {
+    name: "Buzz \u2014 Input/Output Extractor",
+    definition: {
+      variables: [
+        {
+          variable_name: "input",
+          span_name: bestSpan.span_name ?? "",
+          attribute_path: "attributes.input.value",
+          fallback: ""
+        },
+        {
+          variable_name: "output",
+          span_name: bestSpan.span_name ?? "",
+          attribute_path: "attributes.output.value",
+          fallback: ""
+        }
+      ]
+    }
+  });
+  transformSpinner.stop();
+  if (transformResult.error || !transformResult.transform) {
+    logError(`Failed to create transform: ${transformResult.error ?? "unknown error"}`);
+    logWarn("Continuous evals could not be linked without a transform. Configure them manually in the Arthur Engine UI.");
+    return;
+  }
+  logSuccess("Created trace transform");
+  const VARIABLE_MAPPING = [
+    { transform_variable: "input", eval_variable: "input" },
+    { transform_variable: "output", eval_variable: "output" }
+  ];
+  let continuousEvalCount = 0;
+  for (const slug of createdEvalSlugs) {
+    const rec = recommendations.recommendations.find((r) => r.slug === slug);
+    const spinner = ora8({
+      text: buzzSay(`Activating continuous eval: ${rec.displayName}...`),
+      color: "cyan"
+    }).start();
+    const result2 = await client.createContinuousEval(state.taskId, {
+      name: rec.displayName,
+      llm_eval_name: slug,
+      llm_eval_version: "latest",
+      transform_id: transformResult.transform.id,
+      transform_variable_mapping: VARIABLE_MAPPING,
+      enabled: true
+    });
+    spinner.stop();
+    if (result2.error) {
+      logError(`Failed to activate "${rec.displayName}": ${result2.error}`);
+    } else {
+      logSuccess(`Activated: ${rec.displayName}`);
+      continuousEvalCount++;
+    }
+  }
+  if (continuousEvalCount > 0) {
+    logSuccess(
+      `${continuousEvalCount} continuous eval(s) are now monitoring your application.`
+    );
+    note(
+      `View and manage your evals in Arthur Engine:
+  ${state.engineUrl}`,
+      "Continuous evals configured"
+    );
+  } else {
+    logWarn("No continuous evals were activated. Configure them manually in the Arthur Engine UI.");
+  }
+}
+
+// src/mastra/agent.ts
+import { query as query4 } from "@anthropic-ai/claude-agent-sdk";
+import fs3 from "fs";
+import path3 from "path";
+var INSTRUCTIONS2 = `You are Buzz's code analysis module. Your job is to analyze an agentic application's
+repository and return a structured JSON assessment.
+
+Always use your tools to examine the repository before drawing conclusions:
+1. Call Glob first to see all files
+2. Call Read to read manifests (package.json, requirements.txt, pyproject.toml)
+3. Call Grep or Read as needed to verify findings
+
+Return ONLY a JSON object with this exact structure (no markdown, no explanation, just raw JSON):
+{
+  "language": "python" | "typescript" | "javascript" | "other",
+  "framework": "mastra" | "langchain" | "openai" | "anthropic" | "crewai" | "autogen" | "other" | null,
+  "isInstrumented": boolean,
+  "instrumentationType": "arthur-sdk" | "mastra-arthur-exporter" | "openinference" | null,
+  "entryPoint": "<relative path to main entry file>" | null,
+  "details": "<one sentence summary>"
+}
+
+Detection rules:
+- language: "python" if requirements.txt or pyproject.toml exists
+- language: "typescript" if tsconfig.json or .ts files exist
+- language: "javascript" if package.json exists but no tsconfig.json
+- framework: "mastra" if @mastra/core or mastra in package.json dependencies
+- framework: "langchain" if langchain or langchain-* in dependencies
+- framework: "openai" if openai in dependencies and no higher-level framework detected
+- isInstrumented: true if arthur_observability_sdk in Python deps
+  OR ArthurExporter imported in TS files
+  OR @opentelemetry/exporter-trace-otlp-proto configured with Arthur URL
+- instrumentationType: "arthur-sdk" for Python SDK, "mastra-arthur-exporter" for Mastra, "openinference" for OTel/OpenInference`;
+function extractJSON3(text2) {
+  const blockMatch = text2.match(/```(?:json)?\s*([\s\S]+?)```/);
+  if (blockMatch) return blockMatch[1].trim();
+  const jsonMatch = text2.match(/\{[\s\S]+\}/);
+  if (jsonMatch) return jsonMatch[0];
+  return text2.trim();
+}
+function heuristicAnalysis(repoPath) {
+  const hasPyproject = fs3.existsSync(path3.join(repoPath, "pyproject.toml"));
+  const hasRequirements = fs3.existsSync(path3.join(repoPath, "requirements.txt"));
+  const hasTsconfig = fs3.existsSync(path3.join(repoPath, "tsconfig.json"));
+  const hasPackageJson = fs3.existsSync(path3.join(repoPath, "package.json"));
+  let language = "other";
+  if (hasPyproject || hasRequirements) language = "python";
+  else if (hasTsconfig) language = "typescript";
+  else if (hasPackageJson) language = "javascript";
+  let framework = null;
+  let isInstrumented = false;
+  let instrumentationType = null;
+  if (hasPackageJson) {
+    try {
+      const pkg = JSON.parse(fs3.readFileSync(path3.join(repoPath, "package.json"), "utf-8"));
+      const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+      if ("@mastra/core" in deps || "mastra" in deps) framework = "mastra";
+      else if ("langchain" in deps || "@langchain/core" in deps) framework = "langchain";
+      else if ("openai" in deps) framework = "openai";
+      else if ("@anthropic-ai/sdk" in deps) framework = "anthropic";
+      if ("@arizeai/openinference-core" in deps || "openinference-instrumentation" in deps) {
+        isInstrumented = true;
+        instrumentationType = "openinference";
+      }
+    } catch {
+    }
+  }
+  if (hasRequirements) {
+    try {
+      const req = fs3.readFileSync(path3.join(repoPath, "requirements.txt"), "utf-8");
+      if (req.includes("arthur-observability-sdk")) {
+        isInstrumented = true;
+        instrumentationType = "arthur-sdk";
+      }
+      if (!framework) {
+        if (req.includes("langchain")) framework = "langchain";
+        else if (req.includes("openai")) framework = "openai";
+        else if (req.includes("anthropic")) framework = "anthropic";
+      }
+    } catch {
+    }
+  }
+  if (hasPyproject) {
+    try {
+      const toml = fs3.readFileSync(path3.join(repoPath, "pyproject.toml"), "utf-8");
+      if (toml.includes("arthur-observability-sdk")) {
+        isInstrumented = true;
+        instrumentationType = "arthur-sdk";
+      }
+      if (!framework) {
+        if (toml.includes("langchain")) framework = "langchain";
+        else if (toml.includes("openai")) framework = "openai";
+      }
+    } catch {
+    }
+  }
+  return {
+    language,
+    framework,
+    isInstrumented,
+    instrumentationType,
+    entryPoint: null,
+    details: `Heuristic detection: ${language} app${framework ? ` (${framework})` : ""}`
+  };
+}
+async function analyzeRepository(repoPath) {
+  try {
+    const stream = query4({
+      prompt: `Analyze the agentic application repository at: ${repoPath}
+
+Use your tools to examine the files and return the JSON assessment.`,
+      options: {
+        cwd: repoPath,
+        allowedTools: ["Read", "Glob", "Grep"],
+        systemPrompt: INSTRUCTIONS2,
+        maxTurns: 3
+      }
+    });
+    let fullOutput = "";
+    for await (const message of stream) {
+      if (message.type === "assistant") {
+        const content = message.message?.content ?? [];
+        for (const block of content) {
+          if (block.type === "text" && block.text) {
+            fullOutput += block.text;
+          }
+        }
+      }
+    }
+    return JSON.parse(extractJSON3(fullOutput));
+  } catch {
+    return heuristicAnalysis(repoPath);
+  }
+}
+
+// src/workflow/orchestrator.ts
+import ora9 from "ora";
+function stepBanner(n, title) {
+  p.log.info(buzzSay(`Step ${n}/10 \u2014 ${title}`));
+}
+async function runBuzzWorkflow(repoPath) {
+  const state = {
+    repoPath,
+    buzzEnvPath: getBuzzEnvPath(repoPath),
+    engineUrl: null,
+    apiKey: null,
+    taskId: null,
+    analysis: null,
+    promptModelProvider: null,
+    promptModelName: null,
+    evalModelProvider: null,
+    evalModelName: null
+  };
+  stepBanner(1, "Verify pre-requisites");
+  await step1_VerifyPrereqs(state);
+  stepBanner(2, "Ensure Arthur GenAI Engine is available");
+  await step2_EnsureArthurEngine(state);
+  stepBanner(3, "Set up Arthur task ID");
+  await step3_EnsureTaskId(state);
+  const analysisSpinner = ora9({ text: buzzSay("Analyzing repository language and framework..."), color: "cyan" }).start();
+  state.analysis = await analyzeRepository(state.repoPath);
+  analysisSpinner.stop();
+  stepBanner(4, "Instrument your agentic application");
+  const instrumented = await step4_InstrumentPython(state) || await step5_InstrumentMastra(state) || await step6_InstrumentOther(state);
+  if (!instrumented) {
+    p.log.warn(buzzSay("Could not determine application type. Skipping instrumentation."));
+  }
+  stepBanner(7, "Extract & register prompts");
+  try {
+    await step7_ExtractAndRegisterPrompts(state);
+  } catch {
+    p.log.warn(buzzSay("Prompt extraction encountered an error. Skipping."));
+  }
+  stepBanner(8, "Verify instrumentation is working");
+  await step8_VerifyInstrumentation(state);
+  stepBanner(9, "Select model provider for evaluations");
+  await step9_SelectEvalModelProvider(state);
+  stepBanner(10, "Recommend & configure evals");
+  try {
+    await step10_RecommendEvals(state);
+  } catch {
+    p.log.warn(buzzSay("Eval recommendations encountered an error. Skipping."));
+  }
+}
+
+// src/ui/avatar.ts
+import chalk2 from "chalk";
+import boxen from "boxen";
+var HELMET_IDLE_A = [
+  " \u2597\u259B\u2580\u2580\u2580\u2580\u2580\u2599\u2596 ",
+  "\u2590\u2588\u2591     \u2591\u2588\u258C",
+  "\u2590\u2588       \u2588\u258C",
+  "\u2590\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u258C",
+  "\u259D\u259B\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2599\u2598",
+  "  \u2590\u258C   \u2590\u258C  "
+];
+var HELMET_IDLE_B = [
+  " \u2597\u259B\u2580\u2580\u2580\u2580\u2580\u2599\u2596 ",
+  "\u2590\u2588\u2584     \u2584\u2588\u258C",
+  "\u2590\u2588       \u2588\u258C",
+  "\u2590\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u258C",
+  "\u259D\u259B\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2599\u2598",
+  "  \u2590\u258C   \u2590\u258C  "
+];
+async function playStartupAnimation(sideLines) {
+  const frames = [HELMET_IDLE_A, HELMET_IDLE_B, HELMET_IDLE_A, HELMET_IDLE_B, HELMET_IDLE_A];
+  const HEIGHT = HELMET_IDLE_A.length;
+  const GAP = "  ";
+  for (let i = 0; i < frames.length; i++) {
+    if (i > 0) {
+      process.stdout.write(`\x1B[${HEIGHT}A`);
+    }
+    const colorFn = chalk2.hex("#9B59B6");
+    const coloredLines = frames[i].map((l) => colorFn(l));
+    const output = sideLines ? coloredLines.map((l, j) => l + GAP + (sideLines[j] ?? "")).join("\n") : coloredLines.join("\n");
+    process.stdout.write(output + "\n");
+    await new Promise((resolve) => setTimeout(resolve, 350));
+  }
+}
+
+// src/index.ts
+async function main() {
+  const banner = figlet.textSync("BUZZ", { font: "Big" });
+  const bannerLines = banner.split("\n").filter((l) => l.length > 0).map((l) => chalk3.hex("#CE93D8").bold(l));
+  await playStartupAnimation(bannerLines);
+  console.log(chalk3.dim("  Arthur GenAI Engine Onboarding Agent"));
+  const buildTime = true ? "2026-05-12T17:28:43.011Z" : null;
+  if (buildTime) {
+    console.log(chalk3.dim(`  Build: ${new Date(buildTime).toLocaleString()}`));
+  }
+  console.log();
+  intro(chalk3.cyan.bold(" Arthur GenAI Engine \u2014 Onboarding "));
+  const repoPath = process.cwd();
+  try {
+    await runBuzzWorkflow(repoPath);
+    console.log();
+    outro(chalk3.green.bold("Your application is now connected to Arthur GenAI Engine."));
+  } catch (err) {
+    console.log();
+    if (err instanceof BuzzError) {
+      outro(chalk3.red("Mission aborted. Check the messages above for guidance."));
+    } else {
+      outro(chalk3.red("Mission aborted due to an unexpected error."));
+    }
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(chalk3.red("\nFatal error:"), err);
+  process.exit(1);
+});