bumblebee-cli 0.1.1 → 0.3.0

package/dist/index.js

@@ -0,0 +1,4214 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command24 } from "commander";
+
+// src/commands/auth.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+import * as p from "@clack/prompts";
+
+// src/api-client.ts
+import { ofetch } from "ofetch";
+
+// src/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import TOML from "@iarna/toml";
+var GLOBAL_CONFIG_DIR = path.join(os.homedir(), ".bumblebee");
+var GLOBAL_CONFIG_FILE = path.join(GLOBAL_CONFIG_DIR, "config.toml");
+var LOCAL_DIR_NAME = ".bumblebee";
+var LOCAL_CONFIG_NAME = "config.toml";
+function ensureConfigDir() {
+  fs.mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+}
+function findProjectRoot(start) {
+  let current = path.resolve(start ?? process.cwd());
+  while (true) {
+    if (fs.existsSync(path.join(current, LOCAL_DIR_NAME))) return current;
+    if (fs.existsSync(path.join(current, ".git"))) return current;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function getLocalConfigDir() {
+  const root = findProjectRoot();
+  if (root) {
+    const dir = path.join(root, LOCAL_DIR_NAME);
+    if (fs.existsSync(dir)) return dir;
+  }
+  return null;
+}
+function isLocalConfigActive() {
+  return getLocalConfigDir() !== null;
+}
+function loadToml(filePath) {
+  if (!fs.existsSync(filePath)) return {};
+  const content = fs.readFileSync(filePath, "utf-8");
+  return TOML.parse(content);
+}
+function loadGlobalConfig() {
+  return loadToml(GLOBAL_CONFIG_FILE);
+}
+function loadLocalConfig() {
+  const dir = getLocalConfigDir();
+  if (dir) {
+    const file = path.join(dir, LOCAL_CONFIG_NAME);
+    return loadToml(file);
+  }
+  return {};
+}
+function saveLocalConfig(data) {
+  const dir = getLocalConfigDir();
+  if (!dir) throw new Error("No .bumblebee/ directory found. Run 'bb init' first.");
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, LOCAL_CONFIG_NAME), TOML.stringify(data));
+}
+function loadConfig() {
+  const globalCfg = loadGlobalConfig();
+  const localCfg = loadLocalConfig();
+  delete localCfg.token;
+  return { ...globalCfg, ...localCfg };
+}
+function saveConfig(data) {
+  ensureConfigDir();
+  fs.writeFileSync(GLOBAL_CONFIG_FILE, TOML.stringify(data));
+}
+function getApiUrl() {
+  const env = process.env.BB_API_URL;
+  if (env) return env;
+  const cfg = loadConfig();
+  return cfg.api_url ?? "http://localhost:8000";
+}
+function getToken() {
+  const cfg = loadGlobalConfig();
+  return cfg.token ?? null;
+}
+function setToken(token) {
+  const cfg = loadGlobalConfig();
+  cfg.token = token;
+  saveConfig(cfg);
+}
+function clearToken() {
+  const cfg = loadGlobalConfig();
+  delete cfg.token;
+  saveConfig(cfg);
+}
+function getCurrentProject() {
+  const cfg = loadConfig();
+  return cfg.current_project ?? null;
+}
+function getProjectPath(slug) {
+  const cfg = loadConfig();
+  const target = slug ?? cfg.current_project;
+  if (!target) return null;
+  const projects = cfg.projects ?? {};
+  return projects[target]?.path ?? null;
+}
+function setProjectPath(slug, projectPath) {
+  const cfg = loadGlobalConfig();
+  if (!cfg.projects) cfg.projects = {};
+  const projects = cfg.projects;
+  if (!projects[slug]) projects[slug] = {};
+  projects[slug].path = projectPath;
+  saveConfig(cfg);
+}
+
+// src/api-client.ts
+function createClient() {
+  return ofetch.create({
+    baseURL: getApiUrl(),
+    headers: (() => {
+      const h = {};
+      const token = getToken();
+      if (token) h.Authorization = `Bearer ${token}`;
+      return h;
+    })(),
+    timeout: 3e4
+  });
+}
+async function apiGet(path9, params) {
+  return createClient()(path9, { method: "GET", query: params });
+}
+async function apiPost(path9, body, params) {
+  return createClient()(path9, {
+    method: "POST",
+    body,
+    query: params
+  });
+}
+async function apiPut(path9, body) {
+  return createClient()(path9, { method: "PUT", body });
+}
+async function apiPatch(path9, body) {
+  return createClient()(path9, { method: "PATCH", body });
+}
+
+// src/lib/utils.ts
+import chalk from "chalk";
+function requireProject() {
+  const slug = getCurrentProject();
+  if (!slug) {
+    console.error(chalk.red("No project selected. Run 'bb project switch <slug>' first."));
+    process.exit(1);
+  }
+  return slug;
+}
+function requireProjectPath(slug) {
+  const p4 = getProjectPath(slug);
+  if (!p4) {
+    console.error(chalk.red("No source code directory linked to this project."));
+    console.error(chalk.yellow("Run 'bb project link <path>' to set it."));
+    process.exit(1);
+  }
+  return p4;
+}
+async function resolveItemId(slug, idOrNumber) {
+  if (idOrNumber.length > 8 && idOrNumber.includes("-") && idOrNumber.match(/^[0-9a-f-]+$/i)) {
+    return apiGet(`/api/work-items/${idOrNumber}`);
+  }
+  const match = idOrNumber.match(/^(?:[A-Za-z]+-)?(\d+)$/);
+  if (match) {
+    const num = parseInt(match[1], 10);
+    return apiGet(`/api/projects/${slug}/work-items/by-number/${num}`);
+  }
+  console.error(
+    chalk.red(`Invalid identifier: ${idOrNumber}. Use UUID, number, or KEY-number (e.g. BB-42).`)
+  );
+  process.exit(1);
+}
+function slugify(text3, maxLen = 48) {
+  let s = text3.toLowerCase().trim();
+  s = s.replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  if (s.length > maxLen) {
+    s = s.slice(0, maxLen);
+    const last = s.lastIndexOf("-");
+    if (last > 0) s = s.slice(0, last);
+  }
+  return s;
+}
+function truncate(text3, max) {
+  return text3.length <= max ? text3 : text3.slice(0, max - 3) + "...";
+}
+async function withErrorHandling(fn) {
+  try {
+    await fn();
+  } catch (err) {
+    if (err?.data?.detail) {
+      console.error(chalk.red(`Error: ${err.data.detail}`));
+    } else if (err?.statusCode === 401) {
+      console.error(chalk.red("Not authenticated. Run 'bb login' first."));
+    } else if (err?.message?.includes("fetch failed") || err?.code === "ECONNREFUSED") {
+      console.error(chalk.red("Cannot connect to the API server."));
+    } else {
+      console.error(chalk.red(`Error: ${err?.message ?? err}`));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/auth.ts
+var authCommand = new Command("auth").description(
+  "Authentication commands"
+);
+authCommand.command("login").description("Log in to Bumblebee API").option("-e, --email <email>", "Email address").option("-p, --password <password>", "Password").action(
+  (opts) => withErrorHandling(async () => {
+    let { email, password: password2 } = opts;
+    if (!email) {
+      const value = await p.text({
+        message: "Email",
+        validate: (v) => v.length === 0 ? "Email is required" : void 0
+      });
+      if (p.isCancel(value)) {
+        console.log(chalk2.yellow("Cancelled."));
+        process.exit(0);
+      }
+      email = value;
+    }
+    if (!password2) {
+      const value = await p.password({
+        message: "Password",
+        validate: (v) => v.length === 0 ? "Password is required" : void 0
+      });
+      if (p.isCancel(value)) {
+        console.log(chalk2.yellow("Cancelled."));
+        process.exit(0);
+      }
+      password2 = value;
+    }
+    const data = await apiPost("/auth/login", {
+      email,
+      password: password2
+    });
+    setToken(data.access_token);
+    console.log(chalk2.green("Logged in successfully."));
+  })
+);
+authCommand.command("register").description("Register a new Bumblebee account").option("-e, --email <email>", "Email address").option("-u, --username <username>", "Username").option("-p, --password <password>", "Password").action(
+  (opts) => withErrorHandling(async () => {
+    let { email, username, password: password2 } = opts;
+    if (!email) {
+      const value = await p.text({
+        message: "Email",
+        validate: (v) => v.length === 0 ? "Email is required" : void 0
+      });
+      if (p.isCancel(value)) {
+        console.log(chalk2.yellow("Cancelled."));
+        process.exit(0);
+      }
+      email = value;
+    }
+    if (!username) {
+      const value = await p.text({
+        message: "Username",
+        validate: (v) => v.length === 0 ? "Username is required" : void 0
+      });
+      if (p.isCancel(value)) {
+        console.log(chalk2.yellow("Cancelled."));
+        process.exit(0);
+      }
+      username = value;
+    }
+    if (!password2) {
+      const value = await p.password({
+        message: "Password",
+        validate: (v) => v.length === 0 ? "Password is required" : void 0
+      });
+      if (p.isCancel(value)) {
+        console.log(chalk2.yellow("Cancelled."));
+        process.exit(0);
+      }
+      password2 = value;
+      const confirm4 = await p.password({ message: "Confirm password" });
+      if (p.isCancel(confirm4)) {
+        console.log(chalk2.yellow("Cancelled."));
+        process.exit(0);
+      }
+      if (confirm4 !== password2) {
+        console.error(chalk2.red("Passwords do not match."));
+        process.exit(1);
+      }
+    }
+    await apiPost("/auth/register", { email, username, password: password2 });
+    console.log(
+      chalk2.green(`Registered! You can now run ${chalk2.bold("bb login")}.`)
+    );
+  })
+);
+authCommand.command("logout").description("Clear saved credentials").action(
+  () => withErrorHandling(async () => {
+    clearToken();
+    console.log(chalk2.yellow("Logged out."));
+  })
+);
+authCommand.command("whoami").description("Show current user info").action(
+  () => withErrorHandling(async () => {
+    const user = await apiGet("/auth/me");
+    console.log(`${chalk2.bold(user.username)} (${user.email})`);
+  })
+);
+authCommand.command("config").description("Show current CLI configuration").action(
+  () => withErrorHandling(async () => {
+    const cfg = loadConfig();
+    const slug = cfg.current_project;
+    const configSource = isLocalConfigActive() ? "local (.bumblebee/)" : "global (~/.bumblebee/)";
+    console.log(`Config source: ${configSource}`);
+    console.log(`API URL: ${getApiUrl()}`);
+    console.log(`Logged in: ${cfg.token ? "Yes" : "No"}`);
+    console.log(`Current project: ${slug ?? "None"}`);
+    if (slug) {
+      const projectPath = getProjectPath(slug);
+      console.log(`Source path: ${projectPath ?? chalk2.dim("not linked")}`);
+    }
+    const projects = cfg.projects ?? {};
+    const projectKeys = Object.keys(projects);
+    if (projectKeys.length > 0) {
+      console.log(`
+${chalk2.bold("Project paths:")}`);
+      for (const name of projectKeys) {
+        console.log(`  ${name} -> ${projects[name]?.path ?? "?"}`);
+      }
+    }
+  })
+);
+
+// src/commands/project.ts
+import { Command as Command2 } from "commander";
+import chalk3 from "chalk";
+import path2 from "path";
+import fs2 from "fs";
+import Table from "cli-table3";
+import * as p2 from "@clack/prompts";
+var projectCommand = new Command2("project").description(
+  "Project management"
+);
+async function selectProjectInteractive() {
+  const projects = await apiGet("/api/projects");
+  if (!projects || projects.length === 0) {
+    console.log(
+      chalk3.yellow(
+        `No projects found. Create one with ${chalk3.bold("bb project create <name>")}.`
+      )
+    );
+    process.exit(1);
+  }
+  const choices = projects.map((proj) => ({
+    value: proj,
+    label: `${proj.slug} - ${proj.name}`
+  }));
+  const selected = await p2.select({
+    message: "Select a project",
+    options: choices
+  });
+  if (p2.isCancel(selected)) {
+    console.log(chalk3.yellow("Cancelled."));
+    process.exit(0);
+  }
+  return selected;
+}
+function setCurrentProject(slug) {
+  if (isLocalConfigActive()) {
+    const localCfg = loadLocalConfig();
+    localCfg.current_project = slug;
+    saveLocalConfig(localCfg);
+  } else {
+    const cfg = loadConfig();
+    cfg.current_project = slug;
+    saveConfig(cfg);
+  }
+}
+projectCommand.command("list").description("List all projects").action(
+  () => withErrorHandling(async () => {
+    const projects = await apiGet("/api/projects");
+    const table = new Table({
+      head: ["Slug", "Name", "Local Path", "Repo"],
+      style: { head: ["cyan"] }
+    });
+    for (const proj of projects) {
+      const localPath = getProjectPath(proj.slug) ?? "-";
+      table.push([
+        proj.slug,
+        proj.name,
+        localPath,
+        proj.repo_url ?? "-"
+      ]);
+    }
+    console.log(table.toString());
+  })
+);
+projectCommand.command("create").description("Create a new project").argument("<name>", "Project name").option("--slug <slug>", "Project slug (defaults to name kebab-cased)").option("--repo-url <url>", "Repository URL").action(
+  (name, opts) => withErrorHandling(async () => {
+    const projectSlug = opts.slug ?? slugify(name);
+    const project = await apiPost("/api/projects", {
+      name,
+      slug: projectSlug,
+      repo_url: opts.repoUrl ?? null
+    });
+    console.log(
+      chalk3.green(`Created project ${chalk3.bold(project.slug)}`)
+    );
+  })
+);
+projectCommand.command("switch").description("Switch to a project as the active context").argument("[slug]", "Project slug (interactive picker if omitted)").option("-p, --path <path>", "Local source code directory").action(
+  (slug, opts) => withErrorHandling(async () => {
+    if (!slug) {
+      const selected = await selectProjectInteractive();
+      slug = selected.slug;
+    } else {
+      await apiGet(`/api/projects/${slug}`);
+    }
+    setCurrentProject(slug);
+    if (opts.path) {
+      const resolved = path2.resolve(opts.path);
+      setProjectPath(slug, resolved);
+      console.log(
+        chalk3.green(`Switched to ${chalk3.bold(slug)} -> ${resolved}`)
+      );
+    } else {
+      const existing = getProjectPath(slug);
+      console.log(chalk3.green(`Switched to project ${chalk3.bold(slug)}`));
+      if (!existing) {
+        console.log(
+          chalk3.dim(
+            `Tip: use ${chalk3.bold("bb project link <path>")} to set the source code directory.`
+          )
+        );
+      }
+    }
+  })
+);
+projectCommand.command("link").description("Link current project to a local source code directory").argument("[path]", "Path to source directory (default: current dir)", ".").action(
+  (linkPath) => withErrorHandling(async () => {
+    const slug = getCurrentProject();
+    if (!slug) {
+      console.error(
+        chalk3.red(
+          `No project selected. Run ${chalk3.bold("bb project switch <slug>")} first.`
+        )
+      );
+      process.exit(1);
+    }
+    const resolved = path2.resolve(linkPath);
+    if (!fs2.existsSync(resolved) || !fs2.statSync(resolved).isDirectory()) {
+      console.error(chalk3.red(`Directory not found: ${resolved}`));
+      process.exit(1);
+    }
+    setProjectPath(slug, resolved);
+    console.log(
+      chalk3.green(`Linked ${chalk3.bold(slug)} -> ${resolved}`)
+    );
+  })
+);
+projectCommand.command("current").description("Show the current active project").action(
+  () => withErrorHandling(async () => {
+    const slug = getCurrentProject();
+    if (!slug) {
+      console.log(
+        chalk3.yellow(
+          `No project selected. Use ${chalk3.bold("bb project switch <slug>")}.`
+        )
+      );
+      process.exit(1);
+    }
+    const project = await apiGet(`/api/projects/${slug}`);
+    console.log(`${chalk3.bold(project.name)} (${project.slug})`);
+    const localPath = getProjectPath(slug);
+    if (localPath) {
+      console.log(`Path: ${localPath}`);
+    } else {
+      console.log(
+        chalk3.dim(
+          `Path: not linked - use ${chalk3.bold("bb project link <path>")}`
+        )
+      );
+    }
+    if (project.repo_url) {
+      console.log(`Repo: ${project.repo_url}`);
+    }
+  })
+);
+projectCommand.command("refresh").description(
+  "Re-pick the active project from the API and link the current directory"
+).action(
+  () => withErrorHandling(async () => {
+    const selected = await selectProjectInteractive();
+    const slug = selected.slug;
+    setCurrentProject(slug);
+    const resolved = path2.resolve(process.cwd());
+    setProjectPath(slug, resolved);
+    console.log(
+      chalk3.green(
+        `Switched to ${chalk3.bold(selected.name)} (${slug}) -> ${resolved}`
+      )
+    );
+  })
+);
+
+// src/commands/item.ts
+import { Command as Command3 } from "commander";
+import chalk4 from "chalk";
+import Table2 from "cli-table3";
+var itemCommand = new Command3("item").description(
+  "Work item management"
+);
+itemCommand.command("list").description("List work items in the current project").option("-t, --type <type>", "Filter by type (story, task, epic, bug...)").option("-s, --status <status>", "Filter by status").option("--parent <parent>", "Filter by parent ID").option("-a, --assignee <assignee>", "Filter by assignee").action(
+  (opts) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const params = {};
+    if (opts.type) params.type = opts.type;
+    if (opts.status) params.status = opts.status;
+    if (opts.parent) params.parent_id = opts.parent;
+    if (opts.assignee) params.assignee = opts.assignee;
+    const items = await apiGet(
+      `/api/projects/${slug}/work-items`,
+      params
+    );
+    const table = new Table2({
+      head: ["#", "Type", "Title", "Status", "Priority", "Assignee"],
+      style: { head: ["cyan"] }
+    });
+    for (const item of items) {
+      const key = item.key ?? String(item.number);
+      table.push([
+        key,
+        item.type,
+        item.title,
+        item.status,
+        item.priority,
+        item.assignee ?? "-"
+      ]);
+    }
+    console.log(table.toString());
+  })
+);
+itemCommand.command("create").description("Create a new work item").argument("<title>", "Item title").option(
+  "-t, --type <type>",
+  "Item type: story, task, epic, bug, feature, chore, spike",
+  "story"
+).option("-d, --description <description>", "Description").option("-p, --priority <priority>", "Priority", "medium").option("--parent <parent>", "Parent item ID or number").action(
+  (title, opts) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const data = {
+      title,
+      type: opts.type,
+      priority: opts.priority
+    };
+    if (opts.description) {
+      data.description = opts.description;
+    }
+    if (opts.parent) {
+      const parentItem = await resolveItemId(slug, opts.parent);
+      data.parent_id = parentItem.id;
+    }
+    const item = await apiPost(
+      `/api/projects/${slug}/work-items`,
+      data
+    );
+    const key = item.key ?? `#${item.number}`;
+    console.log(chalk4.green(`Created ${item.type} ${key}: ${item.title}`));
+  })
+);
+itemCommand.command("show").description("Show work item details").argument("<id>", "UUID, number, or KEY-number (e.g. BB-42)").action(
+  (idOrNumber) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const item = await resolveItemId(slug, idOrNumber);
+    const key = item.key ?? `#${item.number}`;
+    console.log(
+      `${chalk4.bold(key)} [${item.type}] ${item.title}`
+    );
+    console.log(
+      `Status: ${item.status}  |  Priority: ${item.priority}`
+    );
+    if (item.assignee) {
+      console.log(`Assignee: ${item.assignee}`);
+    }
+    if (item.parent_id) {
+      console.log(`Parent: ${item.parent_id}`);
+    }
+    if (item.sprint_id) {
+      console.log(`Sprint: ${item.sprint_id}`);
+    }
+    if (item.story_points) {
+      console.log(`Points: ${item.story_points}`);
+    }
+    if (item.description) {
+      console.log(`
+${item.description}`);
+    }
+    if (item.acceptance_criteria) {
+      console.log(
+        `
+${chalk4.bold("Acceptance Criteria:")}
+${item.acceptance_criteria}`
+      );
+    }
+    if (item.plan) {
+      console.log(`
+${chalk4.bold("Plan:")}
+${item.plan}`);
+    }
+    if (item.ai_summary) {
+      console.log(`
+${chalk4.bold("AI Summary:")}
+${item.ai_summary}`);
+    }
+  })
+);
+itemCommand.command("update").description("Update a work item").argument("<id>", "UUID, number, or KEY-number").option("-s, --status <status>", "New status").option("-a, --assignee <assignee>", "New assignee").option("-p, --priority <priority>", "New priority").option("--title <title>", "New title").option("-t, --type <type>", "New type").action(
+  (idOrNumber, opts) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const item = await resolveItemId(slug, idOrNumber);
+    const data = {};
+    if (opts.status) data.status = opts.status;
+    if (opts.assignee) data.assignee = opts.assignee;
+    if (opts.priority) data.priority = opts.priority;
+    if (opts.title) data.title = opts.title;
+    if (opts.type) data.type = opts.type;
+    if (Object.keys(data).length === 0) {
+      console.log(chalk4.yellow("Nothing to update."));
+      return;
+    }
+    const updated = await apiPut(
+      `/api/work-items/${item.id}`,
+      data
+    );
+    const key = updated.key ?? `#${updated.number}`;
+    console.log(chalk4.green(`Updated ${key}`));
+  })
+);
+itemCommand.command("assign").description("Assign a work item to someone").argument("<id>", "UUID, number, or KEY-number").argument("<assignee>", "Assignee name").action(
+  (idOrNumber, assignee) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const item = await resolveItemId(slug, idOrNumber);
+    const updated = await apiPut(`/api/work-items/${item.id}`, {
+      assignee
+    });
+    const key = updated.key ?? `#${updated.number}`;
+    console.log(chalk4.green(`${key} assigned to ${assignee}`));
+  })
+);
+itemCommand.command("children").description("List children of a work item").argument("<id>", "UUID, number, or KEY-number").action(
+  (idOrNumber) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const item = await resolveItemId(slug, idOrNumber);
+    const kids = await apiGet(
+      `/api/work-items/${item.id}/children`
+    );
+    if (!kids || kids.length === 0) {
+      console.log(chalk4.dim("No children."));
+      return;
+    }
+    const parentKey = item.key ?? `#${item.number}`;
+    const table = new Table2({
+      head: ["#", "Type", "Title", "Status", "Assignee"],
+      style: { head: ["cyan"] }
+    });
+    for (const kid of kids) {
+      const key = kid.key ?? String(kid.number);
+      table.push([
+        key,
+        kid.type,
+        kid.title,
+        kid.status,
+        kid.assignee ?? "-"
+      ]);
+    }
+    console.log(`Children of ${parentKey}`);
+    console.log(table.toString());
+  })
+);
+
+// src/commands/comment.ts
+import { Command as Command4 } from "commander";
+import chalk5 from "chalk";
+var commentCommand = new Command4("comment").description(
+  "Comment management"
+);
+commentCommand.command("list").description("List comments on a work item").argument("<id>", "Work item UUID, number, or KEY-number").action(
+  (idOrNumber) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const item = await resolveItemId(slug, idOrNumber);
+    const comments = await apiGet(
+      `/api/work-items/${item.id}/comments`
+    );
+    if (!comments || comments.length === 0) {
+      console.log(chalk5.dim("No comments yet."));
+      return;
+    }
+    for (const c of comments) {
+      const typeTag = c.type && c.type !== "discussion" ? ` [${c.type}]` : "";
+      console.log(`${chalk5.bold(c.author)}${typeTag}: ${c.body}`);
+    }
+  })
+);
+commentCommand.command("add").description("Add a comment to a work item").argument("<id>", "Work item UUID, number, or KEY-number").argument("<body>", "Comment body").option(
+  "-t, --type <type>",
+  "Comment type: discussion, investigation, proposal, review, agent_output",
+  "discussion"
+).action(
+  (idOrNumber, body, opts) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const item = await resolveItemId(slug, idOrNumber);
+    await apiPost(`/api/work-items/${item.id}/comments`, {
+      body,
+      type: opts.type
+    });
+    console.log(chalk5.green("Comment added."));
+  })
+);
+
+// src/commands/sprint.ts
+import { Command as Command5 } from "commander";
+import chalk6 from "chalk";
+import Table3 from "cli-table3";
+var sprintCommand = new Command5("sprint").description(
+  "Sprint management"
+);
+sprintCommand.command("list").description("List sprints in the current project").action(
+  () => withErrorHandling(async () => {
+    const slug = requireProject();
+    const sprints = await apiGet(
+      `/api/projects/${slug}/sprints`
+    );
+    const table = new Table3({
+      head: ["ID", "Name", "Status", "Start", "End"],
+      style: { head: ["cyan"] }
+    });
+    for (const s of sprints) {
+      table.push([
+        s.id.slice(0, 8),
+        s.name,
+        s.status,
+        s.start_date ?? "-",
+        s.end_date ?? "-"
+      ]);
+    }
+    console.log(table.toString());
+  })
+);
+sprintCommand.command("create").description("Create a new sprint").argument("<name>", "Sprint name").option("-g, --goal <goal>", "Sprint goal").action(
+  (name, opts) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const data = { name };
+    if (opts.goal) {
+      data.goal = opts.goal;
+    }
+    const sprint = await apiPost(
+      `/api/projects/${slug}/sprints`,
+      data
+    );
+    console.log(chalk6.green(`Created sprint: ${sprint.name}`));
+  })
+);
+sprintCommand.command("start").description("Start a sprint (set status to active)").argument("<id>", "Sprint ID").action(
+  (sprintId) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const sprint = await apiPost(
+      `/api/projects/${slug}/sprints/${sprintId}/start`
+    );
+    console.log(
+      chalk6.green(`Sprint ${chalk6.bold(sprint.name)} is now active.`)
+    );
+  })
+);
+sprintCommand.command("close").description("Close an active sprint").argument("<id>", "Sprint ID").action(
+  (sprintId) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const sprint = await apiPost(
+      `/api/projects/${slug}/sprints/${sprintId}/close`
+    );
+    console.log(
+      chalk6.green(`Sprint ${chalk6.bold(sprint.name)} completed.`)
+    );
+  })
+);
+sprintCommand.command("current").description("Show the currently active sprint").action(
+  () => withErrorHandling(async () => {
+    const slug = requireProject();
+    const sprints = await apiGet(
+      `/api/projects/${slug}/sprints`
+    );
+    const active = sprints.filter((s2) => s2.status === "active");
+    if (active.length === 0) {
+      console.log(chalk6.yellow("No active sprint."));
+      return;
+    }
+    const s = active[0];
+    console.log(`${chalk6.bold(s.name)} (${s.status})`);
+    if (s.goal) {
+      console.log(`Goal: ${s.goal}`);
+    }
+    console.log(
+      `Period: ${s.start_date ?? "?"} -> ${s.end_date ?? "?"}`
+    );
+  })
+);
+
+// src/commands/label.ts
+import { Command as Command6 } from "commander";
+import chalk7 from "chalk";
+import Table4 from "cli-table3";
+var labelCommand = new Command6("label").description(
+  "Label management"
+);
+labelCommand.command("list").description("List labels in the current project").action(
+  () => withErrorHandling(async () => {
+    const slug = requireProject();
+    const labels = await apiGet(
+      `/api/projects/${slug}/labels`
+    );
+    const table = new Table4({
+      head: ["Name", "Color"],
+      style: { head: ["cyan"] }
+    });
+    for (const label of labels) {
+      table.push([label.name, label.color ?? "-"]);
+    }
+    console.log(table.toString());
+  })
+);
+labelCommand.command("create").description("Create a label").argument("<name>", "Label name").option("-c, --color <color>", "Hex color e.g. #ff0000").action(
+  (name, opts) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const data = { name };
+    if (opts.color) {
+      data.color = opts.color;
+    }
+    const label = await apiPost(
+      `/api/projects/${slug}/labels`,
+      data
+    );
+    console.log(chalk7.green(`Created label: ${label.name}`));
+  })
+);
+
+// src/commands/board.ts
+import { Command as Command7 } from "commander";
+import chalk8 from "chalk";
+import Table5 from "cli-table3";
+var COLUMNS = ["open", "in_progress", "in_review", "resolved", "closed"];
+var COLUMN_WIDTH = 24;
+var boardCommand = new Command7("board").description("Show kanban board for current project work items").option("-t, --type <type>", "Filter by type (story, task, etc.)").action(
+  (opts) => withErrorHandling(async () => {
+    const slug = requireProject();
+    const params = {};
+    if (opts.type) params.type = opts.type;
+    const items = await apiGet(
+      `/api/projects/${slug}/work-items`,
+      params
+    );
+    const grouped = {};
+    for (const col of COLUMNS) {
+      grouped[col] = [];
+    }
+    for (const item of items) {
+      if (grouped[item.status]) {
+        grouped[item.status].push(item);
+      }
+    }
+    const columnContents = COLUMNS.map((col) => {
+      const colItems = grouped[col];
+      if (colItems.length === 0) {
+        return [chalk8.dim("  (empty)")];
+      }
+      const lines = [];
+      for (const item of colItems) {
+        const key = item.key ?? `#${item.number}`;
+        lines.push(
+          `  ${chalk8.bold(key)} ${chalk8.dim(`[${item.type}]`)}`
+        );
+        lines.push(`  ${truncate(item.title, COLUMN_WIDTH - 2)}`);
+        const meta = [];
+        if (item.priority) meta.push(item.priority);
+        if (item.assignee) meta.push(`-> ${item.assignee}`);
+        if (meta.length > 0) {
+          lines.push(`  ${chalk8.dim(meta.join(" "))}`);
+        }
+        lines.push("");
+      }
+      return lines;
+    });
+    const maxLines = Math.max(...columnContents.map((c) => c.length));
+    for (const col of columnContents) {
+      while (col.length < maxLines) {
+        col.push("");
+      }
+    }
+    const headers = COLUMNS.map(
+      (col) => col.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase())
+    );
+    const table = new Table5({
+      head: headers,
+      style: { head: ["cyan"] },
+      colWidths: COLUMNS.map(() => COLUMN_WIDTH),
+      wordWrap: true
+    });
+    for (let i = 0; i < maxLines; i++) {
+      const row = columnContents.map((col) => col[i] ?? "");
+      table.push(row);
+    }
+    console.log(`
+${chalk8.bold(`Board - ${slug}`)}
+`);
+    console.log(table.toString());
+  })
+);
+
+// src/commands/doctor.ts
+import { Command as Command8 } from "commander";
+import chalk9 from "chalk";
+import Table6 from "cli-table3";
+import { execa } from "execa";
+async function checkBinary(name) {
+  try {
+    const { stdout } = await execa(name, ["--version"]);
+    const version = stdout.trim().split("\n")[0];
+    return { name, status: "pass", detail: version };
+  } catch {
+    return { name, status: "fail", detail: "Not found in PATH" };
+  }
+}
+async function checkNodeVersion() {
+  const version = process.version;
+  const major = parseInt(version.slice(1).split(".")[0], 10);
+  if (major >= 20) {
+    return { name: "Node.js", status: "pass", detail: version };
+  }
+  return {
+    name: "Node.js",
+    status: "warn",
+    detail: `${version} (>= 20 recommended)`
+  };
+}
+async function checkApi() {
+  try {
+    const health = await apiGet("/health");
+    const parts = [health.status];
+    if (health.version) parts.push(`v${health.version}`);
+    if (health.db) parts.push(`db: ${health.db}`);
+    return { name: "API Server", status: "pass", detail: parts.join(", ") };
+  } catch {
+    return {
+      name: "API Server",
+      status: "fail",
+      detail: `Cannot reach ${getApiUrl()}`
+    };
+  }
+}
+async function checkAuth() {
+  const token = getToken();
+  if (!token) {
+    return { name: "Authentication", status: "warn", detail: "Not logged in" };
+  }
+  try {
+    const user = await apiGet("/auth/me");
+    return {
+      name: "Authentication",
+      status: "pass",
+      detail: `${user.username} (${user.email})`
+    };
+  } catch {
+    return {
+      name: "Authentication",
+      status: "fail",
+      detail: "Token is invalid or expired"
+    };
+  }
+}
+function statusIcon(status) {
+  switch (status) {
+    case "pass":
+      return chalk9.green("PASS");
+    case "fail":
+      return chalk9.red("FAIL");
+    case "warn":
+      return chalk9.yellow("WARN");
+  }
+}
+var doctorCommand = new Command8("doctor").description("Check prerequisites and connectivity").action(
+  () => withErrorHandling(async () => {
+    console.log(chalk9.bold("\nBumblebee Doctor\n"));
+    console.log("Checking prerequisites...\n");
+    const results = await Promise.all([
+      checkBinary("claude"),
+      checkBinary("docker"),
+      checkBinary("git"),
+      checkNodeVersion(),
+      checkApi(),
+      checkAuth()
+    ]);
+    const table = new Table6({
+      head: ["Check", "Status", "Details"],
+      style: { head: ["cyan"] },
+      colWidths: [18, 10, 50]
+    });
+    for (const result of results) {
+      table.push([result.name, statusIcon(result.status), result.detail]);
+    }
+    console.log(table.toString());
+    const failures = results.filter((r) => r.status === "fail");
+    const warnings = results.filter((r) => r.status === "warn");
+    console.log("");
+    if (failures.length > 0) {
+      console.log(
+        chalk9.red(
+          `${failures.length} check(s) failed. Please resolve before continuing.`
+        )
+      );
+    } else if (warnings.length > 0) {
+      console.log(
+        chalk9.yellow(
+          `All checks passed with ${warnings.length} warning(s).`
+        )
+      );
+    } else {
+      console.log(chalk9.green("All checks passed!"));
+    }
+  })
+);
+
+// src/commands/init.ts
+import { Command as Command9 } from "commander";
+import chalk11 from "chalk";
+import * as p3 from "@clack/prompts";
+import fs4 from "fs";
+import path4 from "path";
+import TOML2 from "@iarna/toml";
+
+// src/lib/ide-setup.ts
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import chalk10 from "chalk";
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+function templatesDir() {
+  let dir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    const candidate = path3.join(dir, "templates", "skills", "bb-agent");
+    if (fs3.existsSync(candidate)) return candidate;
+    dir = path3.dirname(dir);
+  }
+  return path3.join(__dirname, "..", "..", "templates", "skills", "bb-agent");
+}
+var SKILL_FILES = [
+  "SKILL.md",
+  "references/workflow.md",
+  "references/investigate-workflow.md",
+  "references/bb-commands.md",
+  "references/prompts.md",
+  "references/status-transitions.md",
+  "references/parallel-workflow.md"
+];
+function getTemplateContent(relativePath) {
+  const fullPath = path3.join(templatesDir(), relativePath);
+  return fs3.readFileSync(fullPath, "utf-8");
+}
+function buildMcpConfig(apiUrl, token) {
+  return {
+    type: "http",
+    url: `${apiUrl}/mcp`,
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  };
+}
+function installMcpConfig(projectRoot, targetDir) {
+  const apiUrl = getApiUrl();
+  const token = getToken();
+  if (!token) {
+    console.log(
+      `  ${chalk10.yellow("!")} No auth token - skipping MCP config (run ${chalk10.bold("bb login")} first)`
+    );
+    return false;
+  }
+  const serverEntry = buildMcpConfig(apiUrl, token);
+  let configPath;
+  if (targetDir) {
+    configPath = path3.join(projectRoot, targetDir, "mcp.json");
+    fs3.mkdirSync(path3.dirname(configPath), { recursive: true });
+  } else {
+    configPath = path3.join(projectRoot, ".mcp.json");
+  }
+  let config;
+  if (fs3.existsSync(configPath)) {
+    const existing = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+    if (!existing.mcpServers) existing.mcpServers = {};
+    existing.mcpServers.bumblebee = serverEntry;
+    config = existing;
+  } else {
+    config = { mcpServers: { bumblebee: serverEntry } };
+  }
+  fs3.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  return true;
+}
+function installClaudeSkills(projectRoot) {
+  const target = path3.join(projectRoot, ".claude", "skills", "bb-agent");
+  fs3.mkdirSync(path3.join(target, "references"), { recursive: true });
+  for (const relPath of SKILL_FILES) {
+    const content = getTemplateContent(relPath);
+    const dest = path3.join(target, relPath);
+    fs3.mkdirSync(path3.dirname(dest), { recursive: true });
+    fs3.writeFileSync(dest, content);
+  }
+  installMcpConfig(projectRoot);
+  console.log(`  ${chalk10.green("\u2713")} Installed Claude Code skills + MCP config`);
+}
+function flattenSkillToMarkdown() {
+  const sections = [];
+  let skillContent = getTemplateContent("SKILL.md");
+  if (skillContent.startsWith("---")) {
+    const end = skillContent.indexOf("---", 3);
+    if (end !== -1) {
+      skillContent = skillContent.slice(end + 3).trim();
+    }
+  }
+  sections.push(skillContent);
+  const refFiles = SKILL_FILES.filter((f) => f.startsWith("references/"));
+  for (const relPath of refFiles) {
+    const content = getTemplateContent(relPath);
+    sections.push(`
+---
+
+${content}`);
+  }
+  return sections.join("\n");
+}
+function installCursorRules(projectRoot) {
+  const targetDir = path3.join(projectRoot, ".cursor", "rules");
+  fs3.mkdirSync(targetDir, { recursive: true });
+  const content = flattenSkillToMarkdown();
+  fs3.writeFileSync(path3.join(targetDir, "bb-agent.md"), content);
+  installMcpConfig(projectRoot, ".cursor");
+  console.log(`  ${chalk10.green("\u2713")} Installed Cursor rules + MCP config`);
+}
+function installAntigravityRules(projectRoot) {
+  const targetDir = path3.join(projectRoot, ".antigravity", "rules");
+  fs3.mkdirSync(targetDir, { recursive: true });
+  const content = flattenSkillToMarkdown();
+  fs3.writeFileSync(path3.join(targetDir, "bb-agent.md"), content);
+  installMcpConfig(projectRoot, ".antigravity");
+  console.log(`  ${chalk10.green("\u2713")} Installed Antigravity rules + MCP config`);
+}
+function installSkills(projectRoot, ideList) {
+  const installers = {
+    claude: installClaudeSkills,
+    cursor: installCursorRules,
+    antigravity: installAntigravityRules
+  };
+  for (const ide of ideList) {
+    const installer = installers[ide];
+    if (installer) installer(projectRoot);
+  }
+}
+
+// src/commands/init.ts
+function parseIdesOption(value) {
+  if (value === "none") return [];
+  if (value === "all") return ["claude", "cursor", "antigravity"];
+  const valid = /* @__PURE__ */ new Set(["claude", "cursor", "antigravity"]);
+  const ides = value.split(",").map((s) => s.trim());
+  for (const ide of ides) {
+    if (!valid.has(ide)) {
+      console.error(
+        chalk11.red(
+          `Unknown IDE: ${ide}. Valid: claude, cursor, antigravity, all, none`
+        )
+      );
+      process.exit(1);
+    }
+  }
+  return ides;
+}
+async function promptIdeSelection() {
+  const result = await p3.select({
+    message: "Install AI agent skills for your IDE?",
+    options: [
+      { value: "claude", label: "Claude Code (.claude/skills/)" },
+      { value: "cursor", label: "Cursor (.cursor/rules/)" },
+      { value: "antigravity", label: "Antigravity (.antigravity/rules/)" },
+      { value: "all", label: "All of the above" },
+      { value: "none", label: "Skip" }
+    ],
+    initialValue: "all"
+  });
+  if (p3.isCancel(result) || result === "none") return [];
+  if (result === "all") return ["claude", "cursor", "antigravity"];
+  return [result];
+}
+var initCommand = new Command9("init").description(
+  "Initialize a .bumblebee/ config directory in the project root"
+).option(
+  "-p, --project <slug>",
+  "Set current_project in local config"
+).option("--api-url <url>", "Set api_url in local config").option(
+  "--ides <ides>",
+  "IDEs to install skills for (claude,cursor,antigravity,all,none)"
+).option("-f, --force", "Overwrite existing config").action(
+  (opts) => withErrorHandling(async () => {
+    const root = findProjectRoot() ?? process.cwd();
+    const bbDir = path4.join(root, LOCAL_DIR_NAME);
+    const configFile = path4.join(bbDir, LOCAL_CONFIG_NAME);
+    const gitignoreFile = path4.join(bbDir, ".gitignore");
+    if (fs4.existsSync(configFile) && !opts.force) {
+      console.log(
+        chalk11.yellow(`.bumblebee/ already exists at ${root}`)
+      );
+      console.log(chalk11.dim("Use --force to overwrite."));
+      process.exit(1);
+    }
+    fs4.mkdirSync(bbDir, { recursive: true });
+    let project = opts.project;
+    let selectedName;
+    if (!project) {
+      try {
+        const projects = await apiGet("/api/projects");
+        if (projects && projects.length > 0) {
+          const options = [
+            ...projects.map((proj) => ({
+              value: proj.slug,
+              label: `${proj.slug} - ${proj.name}`
+            })),
+            { value: "__new__", label: "+ Create new project" }
+          ];
+          const selected = await p3.select({
+            message: "Select a project",
+            options
+          });
+          if (p3.isCancel(selected)) {
+          } else if (selected === "__new__") {
+            const name = await p3.text({ message: "Project name" });
+            if (!p3.isCancel(name)) {
+              const defaultSlug = name.toLowerCase().replace(/\s+/g, "-");
+              const slug = await p3.text({
+                message: "Project slug",
+                initialValue: defaultSlug
+              });
+              if (!p3.isCancel(slug)) {
+                const created = await apiPost(
+                  "/api/projects",
+                  { name, slug }
+                );
+                project = created.slug;
+                selectedName = created.name;
+                console.log(
+                  chalk11.green(
+                    `Created project ${chalk11.bold(project)}`
+                  )
+                );
+              }
+            }
+          } else {
+            project = selected;
+            selectedName = projects.find(
+              (proj) => proj.slug === project
+            )?.name;
+          }
+        }
+      } catch {
+      }
+    }
+    const cfg = {};
+    if (project) cfg.current_project = project;
+    if (opts.apiUrl) cfg.api_url = opts.apiUrl;
+    if (Object.keys(cfg).length > 0) {
+      fs4.writeFileSync(configFile, TOML2.stringify(cfg));
+    } else {
+      fs4.writeFileSync(
+        configFile,
+        "# Bumblebee project-local config\n# Settings here override ~/.bumblebee/config.toml\n"
+      );
+    }
+    if (!fs4.existsSync(gitignoreFile) || opts.force) {
+      fs4.writeFileSync(gitignoreFile, "*.local.toml\n");
+    }
+    if (project) {
+      setProjectPath(project, path4.resolve(root));
+    }
+    console.log(chalk11.green(`Initialized .bumblebee/ at ${root}`));
+    if (project) {
+      const display = selectedName ? `${selectedName} (${project})` : project;
+      console.log(`  current_project = ${display}`);
+      console.log(`  linked path = ${path4.resolve(root)}`);
+    }
+    if (opts.apiUrl) {
+      console.log(`  api_url = ${opts.apiUrl}`);
+    }
+    if (!project) {
+      console.log(
+        chalk11.dim(
+          "Tip: Add project-specific settings to .bumblebee/config.toml"
+        )
+      );
+    }
+    let ideList;
+    if (opts.ides) {
+      ideList = parseIdesOption(opts.ides);
+    } else {
+      ideList = await promptIdeSelection();
+    }
+    if (ideList.length > 0) {
+      installSkills(root, ideList);
+    }
+    console.log(chalk11.green.bold("\nDone!"));
+  })
+);
+
+// src/commands/agent/index.ts
+import { Command as Command23 } from "commander";
+
+// src/commands/agent/suggest.ts
+import { Command as Command10 } from "commander";
+import chalk13 from "chalk";
+import pLimit from "p-limit";
+
+// src/lib/claude-runner.ts
+import { execa as execa2 } from "execa";
+import fs5 from "fs";
+import { execSync } from "child_process";
+import { createInterface } from "readline";
+var CLAUDE_PROCESS_TIMEOUT = 30 * 60 * 1e3;
+var CLAUDE_STALL_TIMEOUT = 5 * 60 * 1e3;
+function claudeBin() {
+  try {
+    const cmd = process.platform === "win32" ? "where claude" : "which claude";
+    const resolved = execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).split("\n")[0].trim();
+    if (resolved) return resolved;
+  } catch {
+  }
+  if (process.platform === "win32") {
+    const home = process.env.USERPROFILE ?? process.env.HOME ?? "";
+    const candidates = [
+      `${home}\\.local\\bin\\claude.exe`,
+      `${home}\\AppData\\Roaming\\npm\\claude.cmd`
+    ];
+    for (const candidate of candidates) {
+      if (fs5.existsSync(candidate)) return candidate;
+    }
+  }
+  return "claude";
+}
+function claudeEnv() {
+  const env = { ...process.env };
+  delete env.CLAUDECODE;
+  return env;
+}
+async function runClaude(opts) {
+  const resolvedCmd = [...opts.cmd];
+  if (resolvedCmd[0] === "claude") {
+    resolvedCmd[0] = claudeBin();
+  }
+  const timeout = opts.timeout ?? CLAUDE_PROCESS_TIMEOUT;
+  const stallTimeout = opts.stallTimeout ?? CLAUDE_STALL_TIMEOUT;
+  const stderrChunks = [];
+  let lastOutputTime = Date.now();
+  let timedOut = false;
+  let stalled = false;
+  const controller = new AbortController();
+  const totalTimer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeout);
+  const stallChecker = setInterval(() => {
+    if (Date.now() - lastOutputTime >= stallTimeout) {
+      stalled = true;
+      controller.abort();
+    }
+  }, 3e4);
+  try {
+    const proc = execa2(resolvedCmd[0], resolvedCmd.slice(1), {
+      cwd: opts.cwd,
+      env: claudeEnv(),
+      stdin: opts.stdinData ? "pipe" : void 0,
+      stdout: "pipe",
+      stderr: "pipe",
+      cancelSignal: controller.signal,
+      gracefulCancel: true
+    });
+    if (opts.stdinData && proc.stdin) {
+      proc.stdin.write(opts.stdinData);
+      proc.stdin.end();
+    }
+    proc.stderr?.on("data", (chunk) => {
+      stderrChunks.push(chunk.toString());
+    });
+    if (proc.stdout) {
+      const rl = createInterface({ input: proc.stdout });
+      for await (const line of rl) {
+        lastOutputTime = Date.now();
+        if (opts.onLine) opts.onLine(line);
+      }
+    }
+    const result = await proc;
+    return {
+      returncode: result.exitCode ?? 0,
+      textBlocks: [],
+      stderr: stderrChunks.join("").trim(),
+      timedOut,
+      stalled
+    };
+  } catch (err) {
+    if (!timedOut && (err.exitCode === 137 || err.signal === "SIGKILL")) {
+      stalled = true;
+    }
+    return {
+      returncode: err.exitCode ?? 1,
+      textBlocks: [],
+      stderr: stderrChunks.join("").trim() || err.stderr || err.message,
+      timedOut,
+      stalled
+    };
+  } finally {
+    clearTimeout(totalTimer);
+    clearInterval(stallChecker);
+  }
+}
+
+// src/lib/agent-streamer.ts
+import fs6 from "fs";
+import path5 from "path";
+import os2 from "os";
+function logsDir() {
+  const d = path5.join(os2.homedir(), ".bumblebee", "logs");
+  fs6.mkdirSync(d, { recursive: true });
+  return d;
+}
+var AgentStreamer = class _AgentStreamer {
+  sessionId;
+  textBlocks = [];
+  logPath;
+  logStream;
+  buffer = [];
+  flushTimer = null;
+  callback;
+  static BATCH_SIZE = 20;
+  static FLUSH_INTERVAL = 500;
+  // ms
+  constructor(sessionId) {
+    this.sessionId = sessionId;
+    this.logPath = path5.join(logsDir(), `session-${sessionId}.jsonl`);
+    this.logStream = fs6.createWriteStream(this.logPath, { flags: "a" });
+  }
+  /** All extracted text blocks from assistant messages. */
+  get texts() {
+    return this.textBlocks;
+  }
+  /** Path to the local log file. */
+  get logFile() {
+    return this.logPath;
+  }
+  /**
+   * Set a callback invoked for each parsed event.
+   * Signature: (payload: any, text: string | null) => void
+   */
+  setCallback(cb) {
+    this.callback = cb;
+  }
+  /** Start the periodic flush timer. */
+  start() {
+    this.flushTimer = setInterval(() => this.flush(), _AgentStreamer.FLUSH_INTERVAL);
+  }
+  /**
+   * Feed a raw JSON line from Claude CLI stdout.
+   * Parses JSON, writes to log, extracts text blocks, buffers for relay.
+   */
+  feed(line) {
+    line = line.trim();
+    if (!line) return;
+    let payload;
+    try {
+      payload = JSON.parse(line);
+    } catch {
+      return;
+    }
+    this.logStream.write(line + "\n");
+    let text3 = null;
+    if (payload.type === "assistant") {
+      for (const block of payload.content ?? []) {
+        if (block.type === "text") {
+          text3 = block.text;
+          if (text3) this.textBlocks.push(text3);
+        }
+      }
+    }
+    if (this.callback) {
+      try {
+        this.callback(payload, text3);
+      } catch {
+      }
+    }
+    this.buffer.push(payload);
+    if (this.buffer.length >= _AgentStreamer.BATCH_SIZE) {
+      this.flush();
+    }
+  }
+  /**
+   * Stop streaming, flush remaining events, close log file.
+   * Returns all extracted text blocks.
+   */
+  stop() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush();
+    this.logStream.end();
+    return this.textBlocks;
+  }
+  /** Flush buffered events to the API (fire-and-forget). */
+  flush() {
+    if (this.buffer.length === 0) return;
+    const events = [...this.buffer];
+    this.buffer = [];
+    apiPost(
+      `/api/agent-sessions/${this.sessionId}/relay-batch`,
+      { events }
+    ).catch(() => {
+    });
+  }
+};
+async function updatePhase(sessionId, phase, extra) {
+  try {
+    await apiPatch(`/api/agent-sessions/${sessionId}/phase`, {
+      phase,
+      ...extra
+    });
+  } catch {
+  }
+}
+async function completeSession(sessionId, status, extra) {
+  try {
+    await apiPost(`/api/agent-sessions/${sessionId}/complete`, {
+      status,
+      ...extra
+    });
+  } catch {
+  }
+}
+
+// src/lib/prompt-builder.ts
+import fs7 from "fs";
+import path6 from "path";
+function readKnowledge(projectPath) {
+  const candidates = [
+    "CLAUDE.md",
+    "docs/knowledge.md",
+    ".claude/lessons-learned.md"
+  ];
+  const parts = [];
+  for (const rel of candidates) {
+    const fp = path6.join(projectPath, rel);
+    if (fs7.existsSync(fp)) {
+      try {
+        const text3 = fs7.readFileSync(fp, "utf-8").trim();
+        if (text3) parts.push(`### ${rel}
+
+${text3}`);
+      } catch {
+      }
+    }
+  }
+  return parts.join("\n\n---\n\n");
+}
+async function getItemComments(itemId) {
+  try {
+    return await apiGet(`/api/work-items/${itemId}/comments`);
+  } catch {
+    return [];
+  }
+}
+function formatCommentsContext(comments) {
+  if (!comments.length) return "";
+  const parts = ["## Previous Comments / Progress"];
+  for (const c of comments) {
+    const tag = c.type !== "discussion" ? ` [${c.type}]` : "";
+    parts.push(`
+### ${c.author}${tag} -- ${c.created_at}
+${c.body}`);
+  }
+  return parts.join("\n");
+}
+function truncateOutput(output, maxChars = 4e3) {
+  if (output.length <= maxChars) return output;
+  return `... (truncated, showing last ${maxChars} chars)
+` + output.slice(-maxChars);
+}
+function itemHeader(item, verb, includeStatus = false) {
+  const key = item.key ?? `#${item.number}`;
+  const parts = [`You are ${verb} ${item.type} ${key}: ${item.title}`, ""];
+  if (includeStatus) {
+    parts.push(
+      `Type: ${item.type}  |  Priority: ${item.priority}  |  Status: ${item.status}`
+    );
+  } else {
+    parts.push(`Type: ${item.type}  |  Priority: ${item.priority}`);
+  }
+  return parts;
+}
+function appendContext(parts, item, knowledge, commentsCtx, planHeading = "## Existing Plan") {
+  if (item.description) {
+    parts.push("", "## Description", item.description);
+  }
+  if (item.acceptance_criteria) {
+    parts.push("", "## Acceptance Criteria", item.acceptance_criteria);
+  }
+  if (item.plan) {
+    parts.push("", planHeading, item.plan);
+  }
+  if (commentsCtx) {
+    parts.push("", commentsCtx);
+  }
+  if (knowledge) {
+    parts.push("", "## Project Knowledge Base", knowledge);
+  }
+}
+function buildSuggestPrompt(item, knowledge, commentsCtx) {
+  const parts = itemHeader(
+    item,
+    "analysing",
+    /* includeStatus */
+    true
+  );
+  appendContext(parts, item, knowledge, commentsCtx, "## Existing Plan");
+  parts.push(
+    "",
+    "## Your Task",
+    "",
+    "Analyse this work item **and** the project source code. Return a Markdown plan:",
+    "",
+    "1. **Root Cause / Analysis** -- what needs to change and why",
+    "2. **Files to Modify** -- list every file with a short description of the change",
+    "3. **Implementation Steps** -- numbered, concrete steps",
+    "4. **Testing Strategy** -- how to verify the changes",
+    "5. **Risks & Considerations** -- edge cases, breaking changes",
+    "",
+    "IMPORTANT: Do NOT modify any files. Only analyse and produce the plan."
+  );
+  parts.push(
+    "",
+    "## Split Analysis (Required)",
+    "",
+    "Analyze which packages (api/, web/, cli/) this item affects.",
+    "Output in exact format at the end of your response:",
+    "",
+    "### SPLIT_RESULT",
+    "NEEDS_SPLIT: true|false",
+    "ITEMS:",
+    "- SCOPE: <package>",
+    "  TITLE: <task title>",
+    "  DESCRIPTION: <what to do>",
+    "  ACCEPTANCE_CRITERIA: <testable criteria>",
+    "",
+    "If the item only affects one package, set NEEDS_SPLIT: false and omit ITEMS."
+  );
+  return parts.join("\n");
+}
+function buildExecutePrompt(item, knowledge, commentsCtx) {
+  const parts = itemHeader(item, "implementing");
+  appendContext(parts, item, knowledge, commentsCtx, "## Implementation Plan");
+  parts.push(
+    "",
+    "## Instructions",
+    "",
+    "Implement the changes described in the plan / comments above.",
+    "",
+    "1. Follow the project's existing coding conventions and patterns",
+    "2. Work through changes one file at a time",
+    "3. Run existing tests after your changes and fix any failures",
+    "4. Add new tests where appropriate",
+    "5. Commit your work with a clear, descriptive commit message",
+    "6. If you hit a blocker, document it clearly so the next run can continue"
+  );
+  return parts.join("\n");
+}
+function buildTestPrompt(item, knowledge, commentsCtx) {
+  const parts = itemHeader(item, "verifying the implementation of");
+  if (item.description) {
+    parts.push("", "## Description", item.description);
+  }
+  if (item.acceptance_criteria) {
+    parts.push("", "## Acceptance Criteria", item.acceptance_criteria);
+  }
+  if (commentsCtx) {
+    parts.push("", commentsCtx);
+  }
+  if (knowledge) {
+    parts.push("", "## Project Knowledge Base", knowledge);
+  }
+  parts.push(
+    "",
+    "## Your Task",
+    "",
+    "Run ALL relevant tests and verify the implementation. Follow these steps:",
+    "",
+    "1. Identify test commands from CLAUDE.md or project config (pytest, vitest, npm test, etc.)",
+    "2. Run all relevant test suites",
+    "3. Check acceptance criteria from the work item (if any)",
+    "4. Review the git diff for obvious issues",
+    "",
+    "Return a structured test report in this format:",
+    "",
+    "## Test Report",
+    "",
+    "### Results",
+    "- **Status**: PASS or FAIL",
+    "- **Tests run**: <count>",
+    "- **Passed**: <count>",
+    "- **Failed**: <count>",
+    "",
+    "### Failing Tests (if any)",
+    "- Test name: reason for failure",
+    "",
+    "### Acceptance Criteria Check",
+    "- [x] or [ ] for each criterion",
+    "",
+    "### Root Cause Analysis (if failures)",
+    "Brief analysis of why tests are failing.",
+    "",
+    "IMPORTANT: Do NOT fix any code. Only run tests and report results."
+  );
+  return parts.join("\n");
+}
+function buildReimplementPrompt(item, knowledge, commentsCtx, dockerOutput = "") {
+  const key = item.key ?? `#${item.number}`;
+  const parts = [
+    `You are RE-IMPLEMENTING ${item.type} ${key}: ${item.title}`,
+    "",
+    `Type: ${item.type}  |  Priority: ${item.priority}`,
+    "",
+    "**IMPORTANT: A previous implementation attempt had test failures.**",
+    "Read the comments below carefully \u2014 they contain the original plan,",
+    "execution report, and test failure details. Fix the issues identified",
+    "in the test report."
+  ];
+  appendContext(parts, item, knowledge, commentsCtx, "## Implementation Plan");
+  if (dockerOutput) {
+    const truncated = truncateOutput(dockerOutput, 3e3);
+    parts.push(
+      "",
+      "## Docker Test Output (from last run)",
+      "",
+      "The following is the raw Docker test output. Use this to identify exact failures:",
+      "",
+      `\`\`\`
+${truncated}
+\`\`\``
+    );
+  }
+  parts.push(
+    "",
+    "## Instructions",
+    "",
+    "1. Read the test report and failure reasons from previous comments AND the Docker output above",
+    "2. Identify what went wrong in the previous implementation",
+    "3. Fix the issues \u2014 focus on the root causes identified in the test report",
+    "4. Ensure all tests pass after your changes",
+    "5. Run the full test suite to verify no regressions",
+    "6. Commit your fixes with a clear message referencing the re-implementation",
+    "7. If you hit a blocker, document it clearly"
+  );
+  return parts.join("\n");
+}
+function buildVerifyPrompt(item, knowledge, commentsCtx) {
+  const parts = itemHeader(
+    item,
+    "verifying requirements for",
+    /* includeStatus */
+    true
+  );
+  appendContext(parts, item, knowledge, commentsCtx, "## Existing Plan");
+  parts.push(
+    "",
+    "## Your Task",
+    "",
+    "Analyse this work item's requirements AND the project source code. Determine if the item is ready for implementation.",
+    "",
+    "Check the following:",
+    "1. Are the requirements clear and specific enough to implement?",
+    "2. Do acceptance criteria exist and are they testable?",
+    "3. Is the requested change feasible given the current codebase?",
+    "4. Are there any blockers, missing dependencies, or unclear areas?",
+    "",
+    "Return a structured analysis:",
+    "",
+    "## Requirement Analysis",
+    "",
+    "### Clarity",
+    "- Are requirements clear? What's ambiguous?",
+    "",
+    "### Feasibility",
+    "- What files need to change?",
+    "- Is the architecture compatible?",
+    "- Any technical blockers?",
+    "",
+    "### Solution Approach",
+    "- Proposed approach (high-level)",
+    "- Files to modify with brief description",
+    "- Estimated complexity (low/medium/high)",
+    "",
+    "### Blockers & Missing Information",
+    "- List anything that would prevent implementation",
+    "",
+    "### VERDICT: READY",
+    "or",
+    "### VERDICT: NEEDS_INFO",
+    "- If NEEDS_INFO, list exactly what information is missing",
+    "",
+    "IMPORTANT:",
+    "- You MUST include exactly one verdict line: `VERDICT: READY` or `VERDICT: NEEDS_INFO`",
+    "- Do NOT modify any files. Only analyse and produce the assessment."
+  );
+  return parts.join("\n");
+}
+
+// src/lib/progress-tracker.ts
+import logUpdate from "log-update";
+import chalk12 from "chalk";
+var AgentProgressTracker = class {
+  data = /* @__PURE__ */ new Map();
+  startTime = Date.now();
+  completed = 0;
+  total = 0;
+  timer = null;
+  /** Register an item before work starts. */
+  register(itemKey) {
+    this.data.set(itemKey, {
+      phase: "pending",
+      status: "waiting",
+      lastLine: "",
+      start: Date.now()
+    });
+    this.total++;
+  }
+  /** Update progress for an item. */
+  update(itemKey, phase, status, lastLine) {
+    const existing = this.data.get(itemKey);
+    const start = existing?.start ?? Date.now();
+    this.data.set(itemKey, { phase, status, lastLine, start });
+    this.render();
+  }
+  /** Mark an item as completed or failed. */
+  complete(itemKey, success, message = "") {
+    const existing = this.data.get(itemKey);
+    if (existing) {
+      existing.status = success ? "done" : "failed";
+      existing.lastLine = message.slice(0, 60);
+    }
+    this.completed++;
+    this.render();
+  }
+  /** Start periodic render updates (every 500ms). */
+  start() {
+    this.timer = setInterval(() => this.render(), 500);
+  }
+  /** Stop updates and persist final output. */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.render();
+    logUpdate.done();
+  }
+  /** Render the progress table to the terminal using log-update. */
+  render() {
+    const lines = [];
+    lines.push(
+      chalk12.bold.cyan(
+        "  Item         Phase          Status     Last Output"
+      )
+    );
+    lines.push(chalk12.dim("  " + "\u2500".repeat(70)));
+    for (const [key, info] of this.data) {
+      const statusColor = info.status === "running" ? chalk12.yellow : info.status === "done" ? chalk12.green : info.status === "failed" ? chalk12.red : chalk12.dim;
+      lines.push(
+        `  ${chalk12.bold(key.padEnd(12))} ${info.phase.padEnd(14)} ${statusColor(info.status.padEnd(10))} ${chalk12.dim(info.lastLine.slice(0, 50))}`
+      );
+    }
+    const elapsed = Math.floor((Date.now() - this.startTime) / 1e3);
+    const mins = Math.floor(elapsed / 60);
+    const secs = elapsed % 60;
+    lines.push("");
+    lines.push(
+      chalk12.dim(
+        `  Elapsed: ${mins}m ${secs.toString().padStart(2, "0")}s | ${this.completed}/${this.total} complete | Ctrl+C to abort`
+      )
+    );
+    logUpdate(lines.join("\n"));
+  }
+};
+
+// src/commands/agent/suggest.ts
+async function suggestOne(slug, projectPath, idOrNumber, tracker) {
+  let item;
+  try {
+    item = await resolveItemId(slug, idOrNumber);
+  } catch (e) {
+    return { key: idOrNumber, status: "failed", error: `Resolve failed: ${e.message}` };
+  }
+  const itemId = item.id;
+  const key = item.key ?? `#${item.number}`;
+  let sessionId = null;
+  try {
+    const session = await apiPost("/api/agent-sessions/start", {
+      work_item_id: itemId,
+      origin: "cli",
+      phase: "suggest"
+    }, { project_slug: slug });
+    sessionId = session.id;
+  } catch {
+  }
+  if (tracker && sessionId) {
+    tracker.update(key, "suggest", "running", "Starting analysis...");
+  }
+  const knowledge = readKnowledge(projectPath);
+  const comments = await getItemComments(itemId);
+  const commentsCtx = formatCommentsContext(comments);
+  const prompt = buildSuggestPrompt(item, knowledge, commentsCtx);
+  let streamer = null;
+  if (sessionId) {
+    streamer = new AgentStreamer(sessionId);
+    if (tracker) {
+      streamer.setCallback((_p, t) => {
+        if (t) tracker.update(key, "suggest", "running", t.slice(0, 60));
+      });
+    }
+    streamer.start();
+    await updatePhase(sessionId, "suggest");
+  }
+  const result = await runClaude({
+    cmd: ["claude", "-p", prompt, "--output-format", "stream-json"],
+    cwd: projectPath,
+    onLine: (line) => streamer?.feed(line)
+  });
+  const textBlocks = streamer?.stop() ?? [];
+  if (result.returncode !== 0) {
+    if (sessionId) await completeSession(sessionId, "failed", { error: result.stderr.slice(0, 500) });
+    return { key, status: "failed", error: result.stderr.slice(0, 500) || `Exit code ${result.returncode}` };
+  }
+  const suggestion = textBlocks.join("\n\n");
+  if (!suggestion) {
+    if (sessionId) await completeSession(sessionId, "failed", { error: "Empty response" });
+    return { key, status: "failed", error: "Empty response" };
+  }
+  await apiPost(`/api/work-items/${itemId}/comments`, {
+    body: suggestion,
+    author: "bb-agent",
+    type: "proposal"
+  });
+  if (item.status === "open") {
+    await apiPut(`/api/work-items/${itemId}`, { status: "confirmed" });
+  }
+  if (sessionId) await completeSession(sessionId, "completed");
+  return { key, status: "ok", suggestion: suggestion.slice(0, 200) };
+}
+var suggestCommand = new Command10("suggest").description("Phase 1: Analyse a work item and post a solution plan").argument("<id>", "Work item ID, number, or KEY-number").action(async (id) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    console.log(chalk13.cyan(`Fetching work item ${id}...`));
+    const item = await resolveItemId(slug, id);
+    const itemId = item.id;
+    const key = item.key ?? `#${item.number}`;
+    const knowledge = readKnowledge(projectPath);
+    const comments = await getItemComments(itemId);
+    const commentsCtx = formatCommentsContext(comments);
+    const prompt = buildSuggestPrompt(item, knowledge, commentsCtx);
+    console.log(chalk13.cyan(`Running Claude Code analysis in ${projectPath}...`));
+    const result = await runClaude({
+      cmd: ["claude", "-p", prompt, "--output-format", "stream-json"],
+      cwd: projectPath,
+      onLine: (line) => {
+        try {
+          const payload = JSON.parse(line);
+          if (payload.type === "assistant") {
+            for (const block of payload.content ?? []) {
+              if (block.type === "text") process.stdout.write(block.text);
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    if (result.returncode !== 0) {
+      console.error(chalk13.red(`Claude analysis failed:
+${result.stderr}`));
+      process.exit(1);
+    }
+    const suggestion = result.textBlocks.join("\n\n");
+    if (!suggestion) {
+      console.error(chalk13.red("Claude returned an empty response."));
+      process.exit(1);
+    }
+    await apiPost(`/api/work-items/${itemId}/comments`, {
+      body: suggestion,
+      author: "bb-agent",
+      type: "proposal"
+    });
+    console.log(chalk13.green("Suggestion posted as comment on the work item."));
+    await apiPut(`/api/work-items/${itemId}`, { plan: suggestion });
+    console.log(chalk13.green("Plan saved to work item."));
+    if (item.status === "open") {
+      await apiPut(`/api/work-items/${itemId}`, { status: "confirmed" });
+      console.log(chalk13.dim("Status -> confirmed"));
+    }
+  });
+});
+var batchSuggestCommand = new Command10("batch-suggest").description("Analyse multiple work items in parallel").argument("[items...]", "Work item IDs/numbers").option("-A, --all", "Suggest all open items").option("-P, --parallel <n>", "Max parallel analyses", "3").action(async (items, opts) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    const maxParallel = parseInt(opts.parallel, 10);
+    if (opts.all) {
+      const openItems = await apiGet(`/api/projects/${slug}/work-items`, { status: "open" });
+      const filtered = openItems.filter((i) => i.type !== "epic");
+      if (!filtered.length) {
+        console.log(chalk13.yellow("No open items found."));
+        return;
+      }
+      items = filtered.map((i) => i.key ?? String(i.number));
+      console.log(chalk13.cyan(`Found ${items.length} open items: ${items.join(", ")}`));
+    } else if (!items.length) {
+      console.error(chalk13.red("Provide item IDs or use --all flag."));
+      process.exit(1);
+    }
+    console.log(chalk13.cyan(`Suggesting ${items.length} items (max ${maxParallel} parallel)...
+`));
+    const tracker = new AgentProgressTracker();
+    for (const ref of items) tracker.register(ref);
+    tracker.start();
+    const limit = pLimit(maxParallel);
+    const results = await Promise.all(
+      items.map(
+        (ref) => limit(async () => {
+          const r = await suggestOne(slug, projectPath, ref, tracker);
+          tracker.complete(ref, r.status === "ok", r.error ?? "Done");
+          return r;
+        })
+      )
+    );
+    tracker.stop();
+    const ok = results.filter((r) => r.status === "ok").length;
+    console.log(chalk13.bold(`
+Done: ${ok}/${items.length} succeeded.`));
+    if (ok > 0) {
+      const suggested = results.filter((r) => r.status === "ok").map((r) => r.key);
+      console.log(chalk13.dim(`
+Review suggestions, then run:`));
+      console.log(chalk13.dim(`  bb agent batch-execute ${suggested.join(" ")}`));
+    }
+  });
+});
+
+// src/commands/agent/execute.ts
+import { Command as Command11 } from "commander";
+import chalk14 from "chalk";
+import pLimit2 from "p-limit";
+
+// src/lib/git-worktree.ts
+import fs8 from "fs";
+import path7 from "path";
+import os3 from "os";
+import { execa as execa3 } from "execa";
+var WORKTREES_DIR = path7.join(os3.homedir(), ".bumblebee", "worktrees");
+var TYPE_BRANCH_PREFIX = {
+  epic: "epic",
+  story: "feat",
+  task: "task",
+  bug: "fix",
+  feature: "feat",
+  chore: "chore",
+  spike: "spike"
+};
+function buildBranchName(item) {
+  const prefix = TYPE_BRANCH_PREFIX[item.type] ?? "task";
+  const key = (item.key ?? `item-${item.number}`).toLowerCase();
+  const titleSlug = slugify(item.title);
+  return `${prefix}/${key}_${titleSlug}`;
+}
+function worktreePath(slug, itemNumber, title) {
+  if (title) {
+    const shortSlug = slugify(title, 40);
+    return path7.join(WORKTREES_DIR, slug, `item-${itemNumber}-${shortSlug}`);
+  }
+  return path7.join(WORKTREES_DIR, slug, `item-${itemNumber}`);
+}
+function findWorktree(slug, itemNumber) {
+  const parent = path7.join(WORKTREES_DIR, slug);
+  if (fs8.existsSync(parent)) {
+    const entries = fs8.readdirSync(parent).sort().reverse();
+    for (const name of entries) {
+      const full = path7.join(parent, name);
+      if (fs8.statSync(full).isDirectory() && (name === `item-${itemNumber}` || name.startsWith(`item-${itemNumber}-`))) {
+        return full;
+      }
+    }
+  }
+  return path7.join(WORKTREES_DIR, slug, `item-${itemNumber}`);
+}
+async function createWorktree(projectPath, slug, item) {
+  const branch = buildBranchName(item);
+  const itemNumber = item.number;
+  let wt = findWorktree(slug, itemNumber);
+  if (!fs8.existsSync(wt)) {
+    wt = worktreePath(slug, itemNumber, item.title);
+  }
+  fs8.mkdirSync(path7.dirname(wt), { recursive: true });
+  if (fs8.existsSync(wt)) {
+    const { stdout } = await execa3("git", ["worktree", "list", "--porcelain"], {
+      cwd: projectPath
+    });
+    const wtNorm = wt.replace(/\\/g, "/");
+    if (stdout.split("\n").some((ln) => ln.replace(/\\/g, "/").includes(wtNorm))) {
+      return { worktreePath: wt, branchName: branch };
+    }
+    await execa3("git", ["worktree", "prune"], {
+      cwd: projectPath,
+      reject: false
+    });
+    if (fs8.existsSync(wt)) {
+      fs8.rmSync(wt, { recursive: true, force: true });
+    }
+  }
+  const check = await execa3(
+    "git",
+    ["rev-parse", "--verify", branch],
+    { cwd: projectPath, reject: false }
+  );
+  if (check.exitCode === 0) {
+    await execa3("git", ["worktree", "add", wt, branch], {
+      cwd: projectPath
+    });
+  } else {
+    await execa3("git", ["worktree", "add", "-b", branch, wt], {
+      cwd: projectPath
+    });
+  }
+  return { worktreePath: wt, branchName: branch };
+}
+async function removeWorktree(projectPath, wtPath) {
+  await execa3("git", ["worktree", "remove", "--force", wtPath], {
+    cwd: projectPath,
+    reject: false
+  });
+  await execa3("git", ["worktree", "prune"], {
+    cwd: projectPath,
+    reject: false
+  });
+}
+async function detectWorktreeBranch(projectPath, wtPath) {
+  const { stdout } = await execa3(
+    "git",
+    ["worktree", "list", "--porcelain"],
+    { cwd: projectPath }
+  );
+  const wtNorm = wtPath.replace(/\\/g, "/");
+  const lines = stdout.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].replace(/\\/g, "/").includes(wtNorm)) {
+      for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+        if (lines[j].startsWith("branch ")) {
+          return lines[j].replace("branch refs/heads/", "");
+        }
+      }
+      break;
+    }
+  }
+  return null;
+}
+async function listAgentBranches(projectPath) {
+  const prefixes = [...new Set(Object.values(TYPE_BRANCH_PREFIX))];
+  const all = [];
+  for (const prefix of prefixes) {
+    const { stdout: stdout2 } = await execa3(
+      "git",
+      ["branch", "--list", `${prefix}/*`],
+      { cwd: projectPath, reject: false }
+    );
+    all.push(
+      ...stdout2.split("\n").map((b) => b.trim().replace(/^\*\s*/, "")).filter(Boolean)
+    );
+  }
+  const { stdout } = await execa3(
+    "git",
+    ["branch", "--list", "bb/item-*"],
+    { cwd: projectPath, reject: false }
+  );
+  all.push(
+    ...stdout.split("\n").map((b) => b.trim().replace(/^\*\s*/, "")).filter(Boolean)
+  );
+  return [...new Set(all)].sort();
+}
+function extractItemNumberFromBranch(branch) {
+  if (branch.startsWith("bb/item-")) {
+    const n = parseInt(branch.replace("bb/item-", ""), 10);
+    return isNaN(n) ? null : n;
+  }
+  const m = branch.match(/\/(?:[a-z]+-)?(\d+)/);
+  return m ? parseInt(m[1], 10) : null;
+}
+
+// src/commands/agent/execute.ts
+function buildMcpConfig2() {
+  const apiUrl = getApiUrl();
+  const token = getToken();
+  return JSON.stringify({
+    mcpServers: {
+      bumblebee: {
+        url: `${apiUrl}/mcp`,
+        headers: token ? { Authorization: `Bearer ${token}` } : {}
+      }
+    }
+  });
+}
+async function executeOne(slug, projectPath, idOrNumber, tracker) {
+  let item;
+  try {
+    item = await resolveItemId(slug, idOrNumber);
+  } catch (e) {
+    return { key: idOrNumber, status: "failed", error: `Resolve failed: ${e.message}` };
+  }
+  const itemId = item.id;
+  const key = item.key ?? `#${item.number}`;
+  const knowledge = readKnowledge(projectPath);
+  const comments = await getItemComments(itemId);
+  const commentsCtx = formatCommentsContext(comments);
+  const prompt = buildExecutePrompt(item, knowledge, commentsCtx);
+  let workDir;
+  let branchName;
+  try {
+    const wt = await createWorktree(projectPath, slug, item);
+    workDir = wt.worktreePath;
+    branchName = wt.branchName;
+  } catch (e) {
+    return { key, status: "failed", error: `Worktree failed: ${e.message}` };
+  }
+  let sessionId;
+  try {
+    const session = await apiPost("/api/agent-sessions/start", {
+      work_item_id: itemId,
+      origin: "cli",
+      phase: "execute"
+    }, { project_slug: slug });
+    sessionId = session.id;
+  } catch (e) {
+    return { key, status: "failed", error: `Session start failed: ${e.message}`, branch: branchName };
+  }
+  await updatePhase(sessionId, "execute", { branch_name: branchName, worktree_path: workDir });
+  if (["open", "confirmed", "approved"].includes(item.status)) {
+    await apiPut(`/api/work-items/${itemId}`, { status: "in_progress" });
+  }
+  if (tracker) tracker.update(key, "execute", "running", "Starting implementation...");
+  const streamer = new AgentStreamer(sessionId);
+  if (tracker) {
+    streamer.setCallback((_p, t) => {
+      if (t) tracker.update(key, "execute", "running", t.slice(0, 60));
+    });
+  }
+  streamer.start();
+  const result = await runClaude({
+    cmd: [
+      "claude",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--permission-mode",
+      "bypassPermissions",
+      "--mcp-config",
+      "-",
+      "-p",
+      prompt
+    ],
+    cwd: workDir,
+    onLine: (line) => streamer.feed(line),
+    stdinData: buildMcpConfig2()
+  });
+  const textBlocks = streamer.stop();
+  const tail = textBlocks.slice(-3).join("\n\n") || "No text output captured.";
+  let extra = "";
+  if (result.timedOut) extra = "\n**Reason**: Process timed out\n";
+  else if (result.stalled) extra = "\n**Reason**: Process stalled (no output)\n";
+  else if (result.stderr) extra = `
+**Stderr**: ${result.stderr.slice(0, 300)}
+`;
+  const body = [
+    "## Agent Execution Report\n",
+    `**Branch**: \`${branchName}\`
+`,
+    `**Exit code**: \`${result.returncode}\`
+`,
+    extra,
+    `
+### Output (last messages)
+
+${tail}`
+  ].join("\n");
+  await apiPost(`/api/work-items/${itemId}/comments`, {
+    body,
+    author: "bb-agent",
+    type: "agent_output"
+  });
+  if (result.returncode === 0) {
+    await apiPut(`/api/work-items/${itemId}`, { status: "in_review" });
+    await completeSession(sessionId, "completed");
+    return { key, status: "ok", branch: branchName, worktree: workDir };
+  } else {
+    await completeSession(sessionId, "failed", { error: result.stderr.slice(0, 500) });
+    return { key, status: "failed", error: result.stderr.slice(0, 500) || `Exit code ${result.returncode}`, branch: branchName };
+  }
+}
+var executeCommand = new Command11("execute").description("Phase 2: Create a worktree and implement with Claude Code").argument("<id>", "Work item ID, number, or KEY-number").option("--no-worktree", "Work in main directory").option("--cleanup", "Remove worktree after completion").action(async (id, opts) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    const item = await resolveItemId(slug, id);
+    const itemId = item.id;
+    const key = item.key ?? `#${item.number}`;
+    const knowledge = readKnowledge(projectPath);
+    const comments = await getItemComments(itemId);
+    const commentsCtx = formatCommentsContext(comments);
+    const prompt = buildExecutePrompt(item, knowledge, commentsCtx);
+    let workDir = projectPath;
+    let branchName = null;
+    if (opts.worktree !== false) {
+      console.log(chalk14.cyan(`Creating worktree for ${key}...`));
+      const wt = await createWorktree(projectPath, slug, item);
+      workDir = wt.worktreePath;
+      branchName = wt.branchName;
+      console.log(chalk14.green(`Worktree: ${workDir}`));
+      console.log(chalk14.green(`Branch:   ${branchName}`));
+    }
+    const session = await apiPost("/api/agent-sessions/start", {
+      work_item_id: itemId,
+      origin: "cli"
+    }, { project_slug: slug });
+    const sessionId = session.id;
+    console.log(chalk14.green(`Session:  ${sessionId}`));
+    if (["open", "confirmed", "approved"].includes(item.status)) {
+      await apiPut(`/api/work-items/${itemId}`, { status: "in_progress" });
+      console.log(chalk14.dim("Status -> in_progress"));
+    }
+    const streamer = new AgentStreamer(sessionId);
+    streamer.setCallback((_p, text3) => {
+      if (text3) process.stdout.write(text3);
+    });
+    streamer.start();
+    console.log(chalk14.cyan(`
+Spawning Claude Code agent in ${workDir}...
+`));
+    const result = await runClaude({
+      cmd: [
+        "claude",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--permission-mode",
+        "bypassPermissions",
+        "--mcp-config",
+        "-",
+        "-p",
+        prompt
+      ],
+      cwd: workDir,
+      onLine: (line) => streamer.feed(line),
+      stdinData: buildMcpConfig2()
+    });
+    const textBlocks = streamer.stop();
+    const tail = textBlocks.slice(-3).join("\n\n") || "No text output captured.";
+    const bodyLines = ["## Agent Execution Report\n"];
+    if (branchName) bodyLines.push(`**Branch**: \`${branchName}\`
+`);
+    bodyLines.push(`**Exit code**: \`${result.returncode}\`
+`);
+    if (result.timedOut) bodyLines.push("**Reason**: Process timed out\n");
+    else if (result.stalled) bodyLines.push("**Reason**: Process stalled (no output)\n");
+    else if (result.stderr) bodyLines.push(`**Stderr**: ${result.stderr.slice(0, 300)}
+`);
+    bodyLines.push(`
+### Output (last messages)
+
+${tail}`);
+    await apiPost(`/api/work-items/${itemId}/comments`, {
+      body: bodyLines.join("\n"),
+      author: "bb-agent",
+      type: "agent_output"
+    });
+    if (result.returncode === 0) {
+      console.log(chalk14.green("\nAgent completed successfully."));
+      await apiPut(`/api/work-items/${itemId}`, { status: "in_review" });
+      console.log(chalk14.dim("Status -> in_review"));
+    } else {
+      if (result.timedOut) console.log(chalk14.yellow(`
+Agent timed out.`));
+      else if (result.stalled) console.log(chalk14.yellow(`
+Agent stalled.`));
+      else console.log(chalk14.yellow(`
+Agent exited with code ${result.returncode}.`));
+    }
+    if (branchName && workDir !== projectPath) {
+      if (opts.cleanup) {
+        await removeWorktree(projectPath, workDir);
+        console.log(chalk14.dim("Worktree removed."));
+      } else {
+        console.log(chalk14.dim(`
+Worktree: ${workDir}`));
+        console.log(chalk14.dim(`Cleanup:  bb agent cleanup ${item.number}`));
+      }
+    }
+  });
+});
+var batchExecuteCommand = new Command11("batch-execute").description("Implement multiple work items in parallel").argument("<items...>", "Work item IDs/numbers").option("-P, --parallel <n>", "Max parallel agents", "2").action(async (items, opts) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    const maxParallel = parseInt(opts.parallel, 10);
+    console.log(chalk14.cyan(`Executing ${items.length} items (max ${maxParallel} parallel)...
+`));
+    const tracker = new AgentProgressTracker();
+    for (const ref of items) tracker.register(ref);
+    tracker.start();
+    const limit = pLimit2(maxParallel);
+    const results = await Promise.all(
+      items.map(
+        (ref) => limit(async () => {
+          const r = await executeOne(slug, projectPath, ref, tracker);
+          tracker.complete(ref, r.status === "ok", (r.branch ?? r.error ?? "Done").slice(0, 60));
+          return r;
+        })
+      )
+    );
+    tracker.stop();
+    const ok = results.filter((r) => r.status === "ok").length;
+    console.log(chalk14.bold(`
+Done: ${ok}/${items.length} succeeded.`));
+    const branches = results.filter((r) => r.branch);
+    if (branches.length) {
+      console.log(chalk14.dim(`
+Merge all with: bb agent merge --target release/dev`));
+    }
+  });
+});
+
+// src/commands/agent/test.ts
+import { Command as Command12 } from "commander";
+import chalk15 from "chalk";
+import fs9 from "fs";
+async function testOne(slug, projectPath, idOrNumber, tracker) {
+  let item;
+  try {
+    item = await resolveItemId(slug, idOrNumber);
+  } catch (e) {
+    return { key: idOrNumber, status: "failed", error: `Resolve failed: ${e.message}` };
+  }
+  const itemId = item.id;
+  const itemNumber = item.number;
+  const key = item.key ?? `#${itemNumber}`;
+  const wt = findWorktree(slug, itemNumber);
+  if (!fs9.existsSync(wt)) {
+    return { key, status: "failed", error: "No worktree found (execute first)" };
+  }
+  const workDir = wt;
+  const knowledge = readKnowledge(projectPath);
+  const comments = await getItemComments(itemId);
+  const commentsCtx = formatCommentsContext(comments);
+  const prompt = buildTestPrompt(item, knowledge, commentsCtx);
+  if (tracker) {
+    tracker.update(key, "test", "running", "Starting tests...");
+  }
+  let sessionId = null;
+  try {
+    const session = await apiPost("/api/agent-sessions/start", {
+      work_item_id: itemId,
+      origin: "cli",
+      phase: "test"
+    }, { project_slug: slug });
+    sessionId = session.id;
+  } catch {
+  }
+  let streamer = null;
+  if (sessionId) {
+    streamer = new AgentStreamer(sessionId);
+    if (tracker) {
+      streamer.setCallback((_p, t) => {
+        if (t) tracker.update(key, "test", "running", t.slice(0, 60));
+      });
+    }
+    streamer.start();
+    await updatePhase(sessionId, "test");
+  }
+  const result = await runClaude({
+    cmd: ["claude", "-p", prompt, "--output-format", "stream-json"],
+    cwd: workDir,
+    onLine: (line) => streamer?.feed(line)
+  });
+  const textBlocks = streamer?.stop() ?? [];
+  if (result.returncode !== 0) {
+    if (sessionId) await completeSession(sessionId, "failed", { error: result.stderr.slice(0, 500) });
+    return { key, status: "failed", error: result.stderr.slice(0, 500) || `Exit code ${result.returncode}` };
+  }
+  const report = textBlocks.join("\n\n");
+  if (!report) {
+    if (sessionId) await completeSession(sessionId, "failed", { error: "Empty test report" });
+    return { key, status: "failed", error: "Empty test report" };
+  }
+  const reportLower = report.toLowerCase();
+  const testsPassed = reportLower.includes("**status**: pass") || reportLower.includes("status: pass") || reportLower.includes("all tests pass") && !reportLower.split("all tests pass")[0].slice(-50).includes("fail");
+  await apiPost(`/api/work-items/${itemId}/comments`, {
+    body: report,
+    author: "bb-agent",
+    type: "test_report"
+  });
+  if (testsPassed) {
+    if (sessionId) await completeSession(sessionId, "completed");
+    return { key, status: "ok", report: report.slice(0, 200) };
+  } else {
+    await apiPut(`/api/work-items/${itemId}`, { status: "failed" });
+    if (sessionId) await completeSession(sessionId, "failed", { error: "Tests failed" });
+    return { key, status: "failed", error: "Tests failed", report: report.slice(0, 200) };
+  }
+}
+var testCommand = new Command12("test").description("Phase 3: Run tests in the worktree and report results").argument("<id>", "Work item ID, number, or KEY-number to test").action(async (id) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    console.log(chalk15.cyan(`Fetching work item ${id}...`));
+    const item = await resolveItemId(slug, id);
+    const itemId = item.id;
+    const itemNumber = item.number;
+    const key = item.key ?? `#${itemNumber}`;
+    const wt = findWorktree(slug, itemNumber);
+    if (!fs9.existsSync(wt)) {
+      console.error(chalk15.red(`No worktree found for ${key}. Run 'bb agent execute ${id}' first.`));
+      process.exit(1);
+    }
+    const workDir = wt;
+    const knowledge = readKnowledge(projectPath);
+    const comments = await getItemComments(itemId);
+    const commentsCtx = formatCommentsContext(comments);
+    const prompt = buildTestPrompt(item, knowledge, commentsCtx);
+    console.log(chalk15.cyan(`Running tests in ${workDir}...`));
+    const result = await runClaude({
+      cmd: ["claude", "-p", prompt, "--output-format", "stream-json"],
+      cwd: workDir,
+      onLine: (line) => {
+        try {
+          const payload = JSON.parse(line);
+          if (payload.type === "assistant") {
+            for (const block of payload.content ?? []) {
+              if (block.type === "text") process.stdout.write(block.text);
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    if (result.returncode !== 0) {
+      console.error(chalk15.red(`Claude test runner failed:
+${result.stderr}`));
+      process.exit(1);
+    }
+    const report = result.textBlocks.join("\n\n");
+    if (!report) {
+      console.error(chalk15.red("Empty test report."));
+      process.exit(1);
+    }
+    await apiPost(`/api/work-items/${itemId}/comments`, {
+      body: report,
+      author: "bb-agent",
+      type: "test_report"
+    });
+    console.log(chalk15.green("Test report posted as comment."));
+    const reportLower = report.toLowerCase();
+    const testsPassed = reportLower.includes("**status**: pass") || reportLower.includes("status: pass") || reportLower.includes("all tests pass") && !reportLower.split("all tests pass")[0].slice(-50).includes("fail");
+    if (testsPassed) {
+      console.log(chalk15.green("All tests passed!"));
+    } else {
+      await apiPut(`/api/work-items/${itemId}`, { status: "failed" });
+      console.log(chalk15.red("Tests failed. Status -> failed"));
+      console.log(chalk15.dim(`Fix with: bb agent reimplement ${id}`));
+      process.exit(1);
+    }
+  });
+});
+
+// src/commands/agent/verify.ts
+import { Command as Command13 } from "commander";
+import chalk16 from "chalk";
+var verifyCommand = new Command13("verify").description("Phase 0: Verify requirements -- analyse feasibility and return READY or NEEDS_INFO verdict").argument("<id>", "Work item ID, number, or KEY-number to verify").action(async (id) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    console.log(chalk16.cyan(`Fetching work item ${id}...`));
+    const item = await resolveItemId(slug, id);
+    const itemId = item.id;
+    const key = item.key ?? `#${item.number}`;
+    const knowledge = readKnowledge(projectPath);
+    const comments = await getItemComments(itemId);
+    const commentsCtx = formatCommentsContext(comments);
+    const prompt = buildVerifyPrompt(item, knowledge, commentsCtx);
+    console.log(chalk16.cyan(`Running requirement analysis for ${key}...`));
+    let sessionId = null;
+    try {
+      const session = await apiPost("/api/agent-sessions/start", {
+        work_item_id: itemId,
+        origin: "cli",
+        phase: "verify"
+      }, { project_slug: slug });
+      sessionId = session.id;
+    } catch {
+    }
+    let streamer = null;
+    if (sessionId) {
+      streamer = new AgentStreamer(sessionId);
+      streamer.start();
+      await updatePhase(sessionId, "verify");
+    }
+    const result = await runClaude({
+      cmd: ["claude", "-p", prompt, "--output-format", "stream-json"],
+      cwd: projectPath,
+      onLine: (line) => {
+        streamer?.feed(line);
+        try {
+          const payload = JSON.parse(line);
+          if (payload.type === "assistant") {
+            for (const block of payload.content ?? []) {
+              if (block.type === "text") process.stdout.write(block.text);
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    const textBlocks = streamer?.stop() ?? result.textBlocks;
+    if (result.returncode !== 0) {
+      console.error(chalk16.red(`Claude analysis failed:
+${result.stderr}`));
+      if (sessionId) await completeSession(sessionId, "failed", { error: result.stderr.slice(0, 500) });
+      process.exit(1);
+    }
+    const analysis = textBlocks.join("\n\n");
+    if (!analysis) {
+      console.error(chalk16.red("Claude returned an empty response."));
+      if (sessionId) await completeSession(sessionId, "failed", { error: "Empty response" });
+      process.exit(1);
+    }
+    const analysisUpper = analysis.toUpperCase();
+    let verdict;
+    if (analysisUpper.includes("VERDICT: READY")) {
+      verdict = "ready";
+    } else if (analysisUpper.includes("VERDICT: NEEDS_INFO")) {
+      verdict = "needs_info";
+    } else {
+      console.log(chalk16.yellow("No explicit verdict found in analysis. Defaulting to READY."));
+      verdict = "ready";
+    }
+    if (verdict === "ready") {
+      await apiPost(`/api/work-items/${itemId}/comments`, {
+        body: analysis,
+        author: "bb-agent",
+        type: "proposal"
+      });
+      console.log(chalk16.green("Analysis posted as proposal comment."));
+      await apiPut(`/api/work-items/${itemId}`, { plan: analysis });
+      console.log(chalk16.green("Plan saved to work item."));
+      if (item.status === "open") {
+        await apiPut(`/api/work-items/${itemId}`, { status: "confirmed" });
+        console.log(chalk16.dim("Status -> confirmed"));
+      }
+      if (sessionId) await completeSession(sessionId, "completed");
+      console.log(chalk16.green(`
+VERDICT: READY -- ${key} is ready for implementation.`));
+    } else {
+      await apiPost(`/api/work-items/${itemId}/comments`, {
+        body: analysis,
+        author: "bb-agent",
+        type: "analysis"
+      });
+      console.log(chalk16.yellow("Analysis posted as comment."));
+      await apiPut(`/api/work-items/${itemId}`, { status: "needs_info" });
+      console.log(chalk16.dim("Status -> needs_info"));
+      if (sessionId) await completeSession(sessionId, "failed", { error: "NEEDS_INFO" });
+      console.log(chalk16.yellow(`
+VERDICT: NEEDS_INFO -- ${key} requires clarification before implementation.`));
+      process.exit(1);
+    }
+  });
+});
+
+// src/commands/agent/reimplement.ts
+import { Command as Command14 } from "commander";
+import chalk17 from "chalk";
+import fs11 from "fs";
+
+// src/lib/docker-runner.ts
+import fs10 from "fs";
+import path8 from "path";
+import { execa as execa4 } from "execa";
+var COMPOSE_FILES = [
+  "docker-compose.test.yml",
+  "Dockerfile.api-test",
+  "Dockerfile.web-test"
+];
+function ensureComposeFiles(workDir, projectPath) {
+  for (const name of COMPOSE_FILES) {
+    const src = path8.join(projectPath, name);
+    const dst = path8.join(workDir, name);
+    if (fs10.existsSync(src) && !fs10.existsSync(dst)) {
+      fs10.copyFileSync(src, dst);
+    }
+  }
+}
+function truncateOutput2(output, maxChars = 4e3) {
+  if (output.length <= maxChars) return output;
+  return `... (truncated, showing last ${maxChars} chars)
+` + output.slice(-maxChars);
+}
+async function runDockerTests(workDir, timeout = 6e5) {
+  const composeCmd = ["docker", "compose", "-f", "docker-compose.test.yml"];
+  try {
+    const result = await execa4(
+      composeCmd[0],
+      [...composeCmd.slice(1), "up", "--build", "--abort-on-container-exit"],
+      {
+        cwd: workDir,
+        timeout,
+        reject: false
+      }
+    );
+    const raw = (result.stdout ?? "") + "\n" + (result.stderr ?? "");
+    const exitCode = result.exitCode ?? 1;
+    const ps = await execa4(
+      composeCmd[0],
+      [
+        ...composeCmd.slice(1),
+        "ps",
+        "-a",
+        "--format",
+        "{{.Service}}	{{.ExitCode}}"
+      ],
+      {
+        cwd: workDir,
+        reject: false
+      }
+    );
+    const serviceResults = {};
+    for (const line of (ps.stdout ?? "").split("\n")) {
+      const parts = line.split("	");
+      if (parts.length === 2) {
+        const [svc, code] = parts;
+        serviceResults[svc] = parseInt(code, 10);
+        if (isNaN(serviceResults[svc])) {
+          serviceResults[svc] = -1;
+        }
+      }
+    }
+    const lines = [];
+    let allPass = true;
+    for (const svc of ["api-test", "web-build"]) {
+      const code = serviceResults[svc];
+      if (code === void 0) {
+        lines.push(`- **${svc}**: unknown (container not found)`);
+        allPass = false;
+      } else if (code === 0) {
+        lines.push(`- **${svc}**: passed`);
+      } else {
+        lines.push(`- **${svc}**: FAILED (exit code ${code})`);
+        allPass = false;
+      }
+    }
+    return {
+      success: exitCode === 0 && allPass,
+      rawOutput: raw,
+      details: lines.join("\n")
+    };
+  } catch (err) {
+    if (err.timedOut) {
+      return {
+        success: false,
+        rawOutput: "",
+        details: `- Docker tests timed out after ${timeout / 1e3}s`
+      };
+    }
+    return {
+      success: false,
+      rawOutput: "",
+      details: "- `docker` command not found. Is Docker installed?"
+    };
+  } finally {
+    await execa4(
+      composeCmd[0],
+      [...composeCmd.slice(1), "down", "-v", "--remove-orphans"],
+      {
+        cwd: workDir,
+        reject: false,
+        timeout: 6e4
+      }
+    ).catch(() => {
+    });
+  }
+}
+async function doSingleMerge(projectPath, branch, target) {
+  const { stdout: current } = await execa4(
+    "git",
+    ["rev-parse", "--abbrev-ref", "HEAD"],
+    { cwd: projectPath }
+  );
+  const check = await execa4(
+    "git",
+    ["rev-parse", "--verify", target],
+    { cwd: projectPath, reject: false }
+  );
+  if (check.exitCode !== 0) {
+    await execa4("git", ["branch", target], {
+      cwd: projectPath,
+      reject: false
+    });
+  }
+  await execa4("git", ["worktree", "prune"], {
+    cwd: projectPath,
+    reject: false
+  });
+  const co = await execa4("git", ["checkout", target], {
+    cwd: projectPath,
+    reject: false
+  });
+  if (co.exitCode !== 0) return false;
+  const merge = await execa4(
+    "git",
+    [
+      "merge",
+      branch,
+      "--no-ff",
+      "-m",
+      `Merge ${branch} into ${target}`
+    ],
+    {
+      cwd: projectPath,
+      reject: false
+    }
+  );
+  const ok = merge.exitCode === 0;
+  if (!ok) {
+    await execa4("git", ["merge", "--abort"], {
+      cwd: projectPath,
+      reject: false
+    });
+  }
+  await execa4("git", ["checkout", current.trim()], {
+    cwd: projectPath,
+    reject: false
+  });
+  return ok;
+}
+
+// src/commands/agent/reimplement.ts
+function buildMcpConfig3() {
+  const apiUrl = getApiUrl();
+  const token = getToken();
+  return JSON.stringify({
+    mcpServers: {
+      bumblebee: {
+        url: `${apiUrl}/mcp`,
+        headers: token ? { Authorization: `Bearer ${token}` } : {}
+      }
+    }
+  });
+}
+async function reimplementOne(slug, projectPath, idOrNumber, dockerOutput = "", tracker) {
+  let item;
+  try {
+    item = await resolveItemId(slug, idOrNumber);
+  } catch (e) {
+    return { key: idOrNumber, status: "failed", error: `Resolve failed: ${e.message}` };
+  }
+  const itemId = item.id;
+  const itemNumber = item.number;
+  const key = item.key ?? `#${itemNumber}`;
+  const wt = findWorktree(slug, itemNumber);
+  if (!fs11.existsSync(wt)) {
+    return { key, status: "failed", error: "No worktree found (execute first)" };
+  }
+  const workDir = wt;
+  const branchName = await detectWorktreeBranch(projectPath, wt);
+  const knowledge = readKnowledge(projectPath);
+  const comments = await getItemComments(itemId);
+  const commentsCtx = formatCommentsContext(comments);
+  const prompt = buildReimplementPrompt(item, knowledge, commentsCtx, dockerOutput);
+  await apiPut(`/api/work-items/${itemId}`, { status: "in_progress" });
+  if (tracker) {
+    tracker.update(key, "reimplement", "running", "Re-implementing...");
+  }
+  let sessionId = null;
+  try {
+    const session = await apiPost("/api/agent-sessions/start", {
+      work_item_id: itemId,
+      origin: "cli",
+      phase: "reimplement"
+    }, { project_slug: slug });
+    sessionId = session.id;
+  } catch {
+  }
+  let streamer = null;
+  if (sessionId) {
+    streamer = new AgentStreamer(sessionId);
+    if (tracker) {
+      streamer.setCallback((_p, t) => {
+        if (t) tracker.update(key, "reimplement", "running", t.slice(0, 60));
+      });
+    }
+    streamer.start();
+    await updatePhase(sessionId, "reimplement", {
+      branch_name: branchName ?? "",
+      worktree_path: workDir
+    });
+  }
+  const result = await runClaude({
+    cmd: [
+      "claude",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--permission-mode",
+      "bypassPermissions",
+      "--mcp-config",
+      "-",
+      "-p",
+      prompt
+    ],
+    cwd: workDir,
+    onLine: (line) => streamer?.feed(line),
+    stdinData: buildMcpConfig3()
+  });
+  const textBlocks = streamer?.stop() ?? [];
+  const tail = textBlocks.slice(-3).join("\n\n") || "No text output captured.";
+  let extra = "";
+  if (result.timedOut) extra = "\n**Reason**: Process timed out\n";
+  else if (result.stalled) extra = "\n**Reason**: Process stalled (no output)\n";
+  else if (result.stderr) extra = `
+**Stderr**: ${result.stderr.slice(0, 300)}
+`;
+  const body = [
+    "## Re-implementation Report\n",
+    `**Branch**: \`${branchName ?? "unknown"}\`
+`,
+    `**Exit code**: \`${result.returncode}\`
+`,
+    extra,
+    `
+### Output (last messages)
+
+${tail}`
+  ].join("\n");
+  await apiPost(`/api/work-items/${itemId}/comments`, {
+    body,
+    author: "bb-agent",
+    type: "agent_output"
+  });
+  if (result.returncode === 0) {
+    if (sessionId) await completeSession(sessionId, "completed");
+    return { key, status: "ok", branch: branchName, worktree: workDir };
+  } else {
+    if (sessionId) await completeSession(sessionId, "failed", { error: result.stderr.slice(0, 500) });
+    return { key, status: "failed", error: result.stderr.slice(0, 500) || `Exit code ${result.returncode}`, branch: branchName };
+  }
+}
+var reimplementCommand = new Command14("reimplement").description("Re-implement a failed work item using previous feedback").argument("<id>", "Work item ID, number, or KEY-number to re-implement").option("--test", "Run tests after re-implementation (default)", true).option("--no-test", "Skip tests after re-implementation").option("--auto-merge", "Auto-merge to target on test pass").option("-t, --target <branch>", "Target branch for auto-merge", "release/dev").action(async (id, opts) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    console.log(chalk17.cyan(`Fetching work item ${id}...`));
+    const item = await resolveItemId(slug, id);
+    const itemId = item.id;
+    const itemNumber = item.number;
+    const key = item.key ?? `#${itemNumber}`;
+    const wt = findWorktree(slug, itemNumber);
+    if (!fs11.existsSync(wt)) {
+      console.error(chalk17.red(`No worktree found for ${key}. Run 'bb agent execute ${id}' first.`));
+      process.exit(1);
+    }
+    const workDir = wt;
+    const branchName = await detectWorktreeBranch(projectPath, wt);
+    const knowledge = readKnowledge(projectPath);
+    const comments = await getItemComments(itemId);
+    const commentsCtx = formatCommentsContext(comments);
+    const prompt = buildReimplementPrompt(item, knowledge, commentsCtx);
+    await apiPut(`/api/work-items/${itemId}`, { status: "in_progress" });
+    console.log(chalk17.dim("Status -> in_progress"));
+    const session = await apiPost("/api/agent-sessions/start", {
+      work_item_id: itemId,
+      origin: "cli"
+    }, { project_slug: slug });
+    const sessionId = session.id;
+    console.log(chalk17.green(`Session:  ${sessionId}`));
+    console.log(chalk17.cyan(`
+Re-implementing in ${workDir}...
+`));
+    const streamer = new AgentStreamer(sessionId);
+    streamer.setCallback((_p, text3) => {
+      if (text3) process.stdout.write(text3);
+    });
+    streamer.start();
+    const result = await runClaude({
+      cmd: [
+        "claude",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--permission-mode",
+        "bypassPermissions",
+        "--mcp-config",
+        "-",
+        "-p",
+        prompt
+      ],
+      cwd: workDir,
+      onLine: (line) => streamer.feed(line),
+      stdinData: buildMcpConfig3()
+    });
+    const textBlocks = streamer.stop();
+    const tail = textBlocks.slice(-3).join("\n\n") || "No text output captured.";
+    const bodyLines = ["## Re-implementation Report\n"];
+    if (branchName) bodyLines.push(`**Branch**: \`${branchName}\`
+`);
+    bodyLines.push(`**Exit code**: \`${result.returncode}\`
+`);
+    if (result.timedOut) bodyLines.push("**Reason**: Process timed out\n");
+    else if (result.stalled) bodyLines.push("**Reason**: Process stalled (no output)\n");
+    else if (result.stderr) bodyLines.push(`**Stderr**: ${result.stderr.slice(0, 300)}
+`);
+    bodyLines.push(`
+### Output (last messages)
+
+${tail}`);
+    await apiPost(`/api/work-items/${itemId}/comments`, {
+      body: bodyLines.join("\n"),
+      author: "bb-agent",
+      type: "agent_output"
+    });
+    if (result.returncode !== 0) {
+      if (result.timedOut) console.log(chalk17.yellow(`
+Agent timed out.`));
+      else if (result.stalled) console.log(chalk17.yellow(`
+Agent stalled.`));
+      else console.log(chalk17.yellow(`
+Agent exited with code ${result.returncode}.`));
+      if (result.stderr) console.log(chalk17.dim(result.stderr.slice(0, 300)));
+      return;
+    }
+    console.log(chalk17.green("\nRe-implementation completed."));
+    if (opts.test !== false) {
+      console.log(chalk17.cyan("\nRunning tests..."));
+      const testResult = await testOne(slug, projectPath, id);
+      if (testResult.status === "ok") {
+        console.log(chalk17.green("All tests passed!"));
+        if (opts.autoMerge && branchName) {
+          console.log(chalk17.cyan(`
+Merging ${branchName} into ${opts.target}...`));
+          const mergeOk = await doSingleMerge(projectPath, branchName, opts.target);
+          if (mergeOk) {
+            console.log(chalk17.green(`Merged into ${opts.target}.`));
+            await apiPut(`/api/work-items/${itemId}`, { status: "resolved" });
+            console.log(chalk17.dim("Status -> resolved"));
+          } else {
+            console.log(chalk17.red("Merge failed. Resolve conflicts manually."));
+            await apiPut(`/api/work-items/${itemId}`, { status: "in_review" });
+          }
+        } else {
+          await apiPut(`/api/work-items/${itemId}`, { status: "in_review" });
+          console.log(chalk17.dim("Status -> in_review"));
+        }
+      } else {
+        console.log(chalk17.red("Tests still failing after re-implementation."));
+        console.log(chalk17.dim(`Try again: bb agent reimplement ${id}`));
+      }
+    } else {
+      await apiPut(`/api/work-items/${itemId}`, { status: "in_review" });
+      console.log(chalk17.dim("Status -> in_review"));
+    }
+  });
+});
+
+// src/commands/agent/run.ts
+import { Command as Command15 } from "commander";
+import chalk18 from "chalk";
+import fs12 from "fs";
+import readline from "readline";
+import pLimit3 from "p-limit";
+async function confirm(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question + " (y/N) ", (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function dockerTestOne(slug, projectPath, idOrNumber, timeout = 600) {
+  let item;
+  try {
+    item = await resolveItemId(slug, idOrNumber);
+  } catch (e) {
+    return { key: idOrNumber, status: "failed", output: "", details: `Resolve failed: ${e.message}` };
+  }
+  const itemId = item.id;
+  const itemNumber = item.number;
+  const key = item.key ?? `#${itemNumber}`;
+  const wt = findWorktree(slug, itemNumber);
+  if (!fs12.existsSync(wt)) {
+    return { key, status: "failed", output: "", details: "No worktree found (execute first)" };
+  }
+  const workDir = wt;
+  ensureComposeFiles(workDir, projectPath);
+  const result = await runDockerTests(workDir, timeout * 1e3);
+  let body;
+  let commentType;
+  if (result.success) {
+    body = `## Docker Test Report
+
+**Status**: PASS
+
+${result.details}`;
+    commentType = "test_report";
+  } else {
+    const truncated = truncateOutput2(result.rawOutput, 4e3);
+    body = `## Docker Test Report
+
+**Status**: FAIL
+
+${result.details}
+
+### Docker Output
+
+\`\`\`
+${truncated}
+\`\`\``;
+    commentType = "test_failure";
+  }
+  await apiPost(`/api/work-items/${itemId}/comments`, {
+    body,
+    author: "bb-agent",
+    type: commentType
+  });
+  const status = result.success ? "ok" : "failed";
+  return { key, status, output: result.rawOutput, details: result.details };
+}
+var runCommand = new Command15("run").description("Full autonomous loop: verify -> execute -> Docker test -> reimplement retry -> merge").argument("<id>", "Work item ID, number, or KEY-number").option("--skip-verify", "Skip the requirement verification phase").option("-y, --yes", "Auto-confirm after verification").option("--auto-merge", "Auto-merge to target branch on test pass (default)", true).option("--no-auto-merge", "Disable auto-merge").option("-t, --target <branch>", "Target branch for auto-merge", "release/dev").option("--max-retries <n>", "Max re-implementation attempts on test failure", "3").option("--timeout <seconds>", "Docker test timeout in seconds", "600").option("--auto-split", "Auto-split multi-package items (default)", true).option("--no-auto-split", "Disable auto-split").action(async (id, opts) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    const maxRetries = parseInt(opts.maxRetries, 10);
+    const timeout = parseInt(opts.timeout, 10);
+    if (!opts.skipVerify) {
+      console.log(chalk18.bold.cyan("Phase 1: Verifying requirements...\n"));
+      const item = await resolveItemId(slug, id);
+      const itemId = item.id;
+      const key = item.key ?? `#${item.number}`;
+      const knowledge = readKnowledge(projectPath);
+      const comments = await getItemComments(itemId);
+      const commentsCtx = formatCommentsContext(comments);
+      const prompt = buildVerifyPrompt(item, knowledge, commentsCtx);
+      let sessionId = null;
+      try {
+        const session = await apiPost("/api/agent-sessions/start", {
+          work_item_id: itemId,
+          origin: "cli",
+          phase: "verify"
+        }, { project_slug: slug });
+        sessionId = session.id;
+      } catch {
+      }
+      let streamer = null;
+      if (sessionId) {
+        streamer = new AgentStreamer(sessionId);
+        streamer.start();
+        await updatePhase(sessionId, "verify");
+      }
+      const verifyResult = await runClaude({
+        cmd: ["claude", "-p", prompt, "--output-format", "stream-json"],
+        cwd: projectPath,
+        onLine: (line) => streamer?.feed(line)
+      });
+      const textBlocks = streamer?.stop() ?? verifyResult.textBlocks;
+      if (verifyResult.returncode !== 0) {
+        console.error(chalk18.red(`Claude analysis failed:
+${verifyResult.stderr}`));
+        if (sessionId) await completeSession(sessionId, "failed", { error: verifyResult.stderr.slice(0, 500) });
+        console.log(chalk18.red("\nVerification failed -- aborting run."));
+        process.exit(1);
+      }
+      const analysis = textBlocks.join("\n\n");
+      if (!analysis) {
+        console.error(chalk18.red("Claude returned an empty response."));
+        if (sessionId) await completeSession(sessionId, "failed", { error: "Empty response" });
+        process.exit(1);
+      }
+      const analysisUpper = analysis.toUpperCase();
+      let verdict;
+      if (analysisUpper.includes("VERDICT: READY")) {
+        verdict = "ready";
+      } else if (analysisUpper.includes("VERDICT: NEEDS_INFO")) {
+        verdict = "needs_info";
+      } else {
+        verdict = "ready";
+      }
+      if (verdict === "ready") {
+        await apiPost(`/api/work-items/${itemId}/comments`, {
+          body: analysis,
+          author: "bb-agent",
+          type: "proposal"
+        });
+        await apiPut(`/api/work-items/${itemId}`, { plan: analysis });
+        if (item.status === "open") {
+          await apiPut(`/api/work-items/${itemId}`, { status: "confirmed" });
+        }
+        if (sessionId) await completeSession(sessionId, "completed");
+        console.log(chalk18.green(`VERDICT: READY -- ${key} is ready for implementation.`));
+      } else {
+        await apiPost(`/api/work-items/${itemId}/comments`, {
+          body: analysis,
+          author: "bb-agent",
+          type: "analysis"
+        });
+        await apiPut(`/api/work-items/${itemId}`, { status: "needs_info" });
+        if (sessionId) await completeSession(sessionId, "failed", { error: "NEEDS_INFO" });
+        console.log(chalk18.yellow(`VERDICT: NEEDS_INFO -- ${key} requires clarification.`));
+        console.log(chalk18.red("\nVerification failed -- aborting run."));
+        process.exit(1);
+      }
+      if (!opts.yes) {
+        console.log();
+        const ok = await confirm("Proceed with implementation?");
+        if (!ok) {
+          console.log(chalk18.yellow(`Aborted. Run bb agent execute ${id} when ready.`));
+          return;
+        }
+      }
+    } else {
+      console.log(chalk18.dim("Skipping verification phase."));
+    }
+    if (opts.autoSplit !== false) {
+      console.log(chalk18.bold.cyan("\nPhase 1.5: Checking for split...\n"));
+      const itemForSplit = await resolveItemId(slug, id);
+      const commentsForSplit = await getItemComments(itemForSplit.id);
+      let proposal = null;
+      for (let i = commentsForSplit.length - 1; i >= 0; i--) {
+        if (commentsForSplit[i].type === "proposal") {
+          proposal = commentsForSplit[i].body;
+          break;
+        }
+      }
+      if (proposal && /NEEDS_SPLIT:\s*true/i.test(proposal)) {
+        console.log(chalk18.cyan("Item needs splitting into sub-items."));
+        console.log(chalk18.dim("Use 'bb agent split' to split, then 'bb agent batch-run' for children."));
+      }
+    }
+    console.log(chalk18.bold.cyan("\nPhase 2: Implementing...\n"));
+    const execResult = await executeOne(slug, projectPath, id);
+    if (execResult.status !== "ok") {
+      console.error(chalk18.red(`Execution failed: ${execResult.error ?? "unknown error"}`));
+      process.exit(1);
+    }
+    console.log(chalk18.green("Execution completed."));
+    console.log(chalk18.bold.cyan("\nPhase 3: Docker testing..."));
+    let dockerResult = await dockerTestOne(slug, projectPath, id, timeout);
+    if (dockerResult.status === "ok") {
+      console.log(chalk18.green("Docker tests passed!"));
+    } else {
+      console.log(chalk18.red("Docker tests failed."));
+      let dockerOutput = dockerResult.output ?? "";
+      let retriesDone = 0;
+      while (retriesDone < maxRetries) {
+        retriesDone++;
+        console.log(chalk18.bold.cyan(`
+Retry ${retriesDone}/${maxRetries}: Re-implementing...`));
+        const reimplResult = await reimplementOne(slug, projectPath, id, dockerOutput);
+        if (reimplResult.status !== "ok") {
+          console.log(chalk18.red(`Re-implementation failed: ${reimplResult.error ?? "?"}`));
+          continue;
+        }
+        console.log(chalk18.cyan("Re-testing with Docker..."));
+        dockerResult = await dockerTestOne(slug, projectPath, id, timeout);
+        if (dockerResult.status === "ok") {
+          console.log(chalk18.green("Docker tests passed after re-implementation!"));
+          break;
+        }
+        dockerOutput = dockerResult.output ?? "";
+      }
+      if (dockerResult.status !== "ok") {
+        const itemFailed = await resolveItemId(slug, id);
+        await apiPut(`/api/work-items/${itemFailed.id}`, { status: "failed" });
+        console.log(chalk18.dim("Status -> failed"));
+        await apiPost(`/api/work-items/${itemFailed.id}/comments`, {
+          body: `## Agent Run Failed
+
+All ${maxRetries} re-implementation retries exhausted.
+
+### Last Docker Output
+
+${dockerResult.details ?? "No details"}
+
+Manual intervention required.`,
+          author: "bb-agent",
+          type: "test_failure"
+        });
+        console.log(chalk18.red(`
+All ${maxRetries} retries exhausted.`));
+        console.log(chalk18.dim(`Status -> failed. Manual fix: bb agent continue ${id}`));
+        return;
+      }
+    }
+    if (opts.autoMerge !== false) {
+      const itemForMerge = await resolveItemId(slug, id);
+      const itemNumber = itemForMerge.number;
+      const wt = findWorktree(slug, itemNumber);
+      const branchName = await detectWorktreeBranch(projectPath, wt);
+      if (branchName) {
+        console.log(chalk18.bold.cyan(`
+Phase 4: Merging ${branchName} into ${opts.target}...`));
+        const mergeOk = await doSingleMerge(projectPath, branchName, opts.target);
+        if (mergeOk) {
+          console.log(chalk18.green(`Merged into ${opts.target}.`));
+          await apiPut(`/api/work-items/${itemForMerge.id}`, { status: "resolved" });
+          console.log(chalk18.dim("Status -> resolved"));
+          await removeWorktree(projectPath, wt);
+          console.log(chalk18.dim("Worktree cleaned up."));
+        } else {
+          console.log(chalk18.red("Merge failed -- conflicts detected."));
+          await apiPut(`/api/work-items/${itemForMerge.id}`, { status: "in_review" });
+          console.log(chalk18.dim("Status -> in_review (manual merge needed)"));
+        }
+      } else {
+        console.log(chalk18.yellow("Could not detect branch -- skipping merge."));
+      }
+    } else {
+      console.log(chalk18.dim("Auto-merge disabled. Merge manually when ready."));
+    }
+  });
+});
+var batchRunCommand = new Command15("batch-run").description("Execute -> test -> merge for multiple items").argument("<items...>", "Work item IDs/numbers for full loop").option("-P, --parallel <n>", "Max parallel agents", "2").option("--auto-merge", "Auto-merge passing items to target").option("-t, --target <branch>", "Target branch for auto-merge", "release/dev").action(async (items, opts) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    const maxParallel = parseInt(opts.parallel, 10);
+    const target = opts.target;
+    console.log(chalk18.bold.cyan(`Phase 1: Implementing ${items.length} items (max ${maxParallel} parallel)...
+`));
+    const execTracker = new AgentProgressTracker();
+    for (const ref of items) execTracker.register(ref);
+    execTracker.start();
+    const limit = pLimit3(maxParallel);
+    const execResults = await Promise.all(
+      items.map(
+        (ref) => limit(async () => {
+          const r = await executeOne(slug, projectPath, ref, execTracker);
+          execTracker.complete(ref, r.status === "ok", (r.branch ?? r.error ?? "").slice(0, 60));
+          return r;
+        })
+      )
+    );
+    execTracker.stop();
+    const executed = execResults.filter((r) => r.status === "ok").map((r) => r.key);
+    console.log(chalk18.bold(`
+Execute done: ${executed.length}/${items.length} succeeded.`));
+    if (!executed.length) return;
+    console.log(chalk18.bold.cyan("\nPhase 2: Docker testing...\n"));
+    const testTracker = new AgentProgressTracker();
+    for (const ref of executed) testTracker.register(ref);
+    testTracker.start();
+    const testResults = await Promise.all(
+      executed.map(
+        (ref) => limit(async () => {
+          const r = await dockerTestOne(slug, projectPath, ref);
+          testTracker.complete(ref, r.status === "ok", (r.details ?? "").slice(0, 60));
+          return r;
+        })
+      )
+    );
+    testTracker.stop();
+    const passed = testResults.filter((r) => r.status === "ok").map((r) => r.key);
+    const failedItems = testResults.filter((r) => r.status !== "ok").map((r) => r.key);
+    console.log(chalk18.bold(`
+Test done: ${passed.length}/${executed.length} passed.`));
+    if (opts.autoMerge && passed.length) {
+      console.log(chalk18.bold.cyan(`
+Phase 3: Merging to ${target}...
+`));
+      for (const itemKey of passed) {
+        try {
+          const mergeItem = await resolveItemId(slug, itemKey);
+          const wt = findWorktree(slug, mergeItem.number);
+          const branchName = await detectWorktreeBranch(projectPath, wt);
+          if (branchName) {
+            const mergeOk = await doSingleMerge(projectPath, branchName, target);
+            if (mergeOk) {
+              console.log(chalk18.green(`  ${itemKey.padStart(8)} -- merged`));
+              await apiPut(`/api/work-items/${mergeItem.id}`, { status: "resolved" });
+              await removeWorktree(projectPath, wt);
+            } else {
+              console.log(chalk18.red(`  ${itemKey.padStart(8)} -- merge conflict`));
+            }
+          }
+        } catch (e) {
+          console.log(chalk18.red(`  ${itemKey.padStart(8)} -- merge error: ${e.message}`));
+        }
+      }
+    } else if (!opts.autoMerge && passed.length) {
+      console.log(chalk18.dim("Merge with: bb agent merge --target release/dev"));
+    }
+    if (failedItems.length) {
+      console.log(chalk18.yellow(`
+Failed items: ${failedItems.join(" ")}`));
+      console.log(chalk18.dim("Re-implement: bb agent reimplement <item>"));
+    }
+  });
+});
+
+// src/commands/agent/continue.ts
+import { Command as Command16 } from "commander";
+import chalk19 from "chalk";
+function buildMcpConfig4() {
+  const apiUrl = getApiUrl();
+  const token = getToken();
+  return JSON.stringify({
+    mcpServers: {
+      bumblebee: {
+        url: `${apiUrl}/mcp`,
+        headers: token ? { Authorization: `Bearer ${token}` } : {}
+      }
+    }
+  });
+}
+var continueCommand = new Command16("continue").description("Continue a previous agent run (reads prior comments for context)").argument("<id>", "Work item ID, number, or KEY-number to continue").action(async (id) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    const item = await resolveItemId(slug, id);
+    const itemId = item.id;
+    const key = item.key ?? `#${item.number}`;
+    const knowledge = readKnowledge(projectPath);
+    const comments = await getItemComments(itemId);
+    const commentsCtx = formatCommentsContext(comments);
+    const prompt = buildExecutePrompt(item, knowledge, commentsCtx);
+    console.log(chalk19.cyan(`Creating worktree for ${key}...`));
+    const wt = await createWorktree(projectPath, slug, item);
+    const workDir = wt.worktreePath;
+    const branchName = wt.branchName;
+    console.log(chalk19.green(`Worktree: ${workDir}`));
+    console.log(chalk19.green(`Branch:   ${branchName}`));
+    const session = await apiPost("/api/agent-sessions/start", {
+      work_item_id: itemId,
+      origin: "cli"
+    }, { project_slug: slug });
+    const sessionId = session.id;
+    console.log(chalk19.green(`Session:  ${sessionId}`));
+    if (["open", "confirmed", "approved"].includes(item.status)) {
+      await apiPut(`/api/work-items/${itemId}`, { status: "in_progress" });
+      console.log(chalk19.dim("Status -> in_progress"));
+    }
+    const streamer = new AgentStreamer(sessionId);
+    streamer.setCallback((_p, text3) => {
+      if (text3) process.stdout.write(text3);
+    });
+    streamer.start();
+    console.log(chalk19.cyan(`
+Spawning Claude Code agent in ${workDir}...
+`));
+    const result = await runClaude({
+      cmd: [
+        "claude",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--permission-mode",
+        "bypassPermissions",
+        "--mcp-config",
+        "-",
+        "-p",
+        prompt
+      ],
+      cwd: workDir,
+      onLine: (line) => streamer.feed(line),
+      stdinData: buildMcpConfig4()
+    });
+    const textBlocks = streamer.stop();
+    const tail = textBlocks.slice(-3).join("\n\n") || "No text output captured.";
+    const bodyLines = ["## Agent Execution Report\n"];
+    bodyLines.push(`**Branch**: \`${branchName}\`
+`);
+    bodyLines.push(`**Exit code**: \`${result.returncode}\`
+`);
+    if (result.timedOut) bodyLines.push("**Reason**: Process timed out\n");
+    else if (result.stalled) bodyLines.push("**Reason**: Process stalled (no output)\n");
+    else if (result.stderr) bodyLines.push(`**Stderr**: ${result.stderr.slice(0, 300)}
+`);
+    bodyLines.push(`
+### Output (last messages)
+
+${tail}`);
+    await apiPost(`/api/work-items/${itemId}/comments`, {
+      body: bodyLines.join("\n"),
+      author: "bb-agent",
+      type: "agent_output"
+    });
+    if (result.returncode === 0) {
+      console.log(chalk19.green("\nAgent completed successfully."));
+      await apiPut(`/api/work-items/${itemId}`, { status: "in_review" });
+      console.log(chalk19.dim("Status -> in_review"));
+    } else {
+      if (result.timedOut) console.log(chalk19.yellow(`
+Agent timed out.`));
+      else if (result.stalled) console.log(chalk19.yellow(`
+Agent stalled.`));
+      else console.log(chalk19.yellow(`
+Agent exited with code ${result.returncode}.`));
+    }
+    console.log(chalk19.dim(`
+Worktree: ${workDir}`));
+    console.log(chalk19.dim(`Cleanup:  bb agent cleanup ${item.number}`));
+  });
+});
+
+// src/commands/agent/split.ts
+import { Command as Command17 } from "commander";
+import chalk20 from "chalk";
+import readline2 from "readline";
+async function confirm2(question) {
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question + " (y/N) ", (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+var splitCommand = new Command17("split").description("Split a work item into sub-items based on the latest proposal's SPLIT_RESULT").argument("<id>", "Parent work item ID or number").option("-y, --yes", "Auto-confirm split").action(async (id, opts) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const item = await resolveItemId(slug, id);
+    const itemId = item.id;
+    const key = item.key ?? `#${item.number}`;
+    const comments = await getItemComments(itemId);
+    let proposal = null;
+    for (let i = comments.length - 1; i >= 0; i--) {
+      if (comments[i].type === "proposal") {
+        proposal = comments[i].body;
+        break;
+      }
+    }
+    if (!proposal) {
+      console.error(chalk20.red(`No proposal comment found for ${key}. Run 'bb agent suggest ${id}' first.`));
+      process.exit(1);
+    }
+    const splitMatch = proposal.match(/### SPLIT_RESULT\s*\n([\s\S]*?)(?:\n###|\Z|$)/);
+    if (!splitMatch) {
+      console.log(chalk20.yellow(`No SPLIT_RESULT block found in proposal for ${key}.`));
+      console.log(chalk20.dim("The suggest prompt may not have included split analysis."));
+      process.exit(1);
+    }
+    const block = splitMatch[1].trim();
+    const needsSplitMatch = block.match(/NEEDS_SPLIT:\s*(true|false)/i);
+    if (!needsSplitMatch || needsSplitMatch[1].toLowerCase() === "false") {
+      console.log(chalk20.green(`${key} does not need splitting (single-package scope).`));
+      return;
+    }
+    const subItems = [];
+    let currentItem = {};
+    for (const line of block.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("- SCOPE:")) {
+        if (currentItem.title) {
+          subItems.push({ ...currentItem });
+        }
+        currentItem = { scope: trimmed.split(":").slice(1).join(":").trim() };
+      } else if (trimmed.startsWith("TITLE:")) {
+        currentItem.title = trimmed.split(":").slice(1).join(":").trim();
+      } else if (trimmed.startsWith("DESCRIPTION:")) {
+        currentItem.description = trimmed.split(":").slice(1).join(":").trim();
+      } else if (trimmed.startsWith("ACCEPTANCE_CRITERIA:")) {
+        currentItem.acceptance_criteria = trimmed.split(":").slice(1).join(":").trim();
+      }
+    }
+    if (currentItem.title) {
+      subItems.push({ ...currentItem });
+    }
+    if (!subItems.length) {
+      console.log(chalk20.yellow("SPLIT_RESULT block found but no items could be parsed."));
+      process.exit(1);
+    }
+    console.log(chalk20.bold(`
+Proposed sub-items for ${key}:
+`));
+    console.log("  #  Scope           Title                          Description");
+    console.log("  " + "-".repeat(70));
+    for (let i = 0; i < subItems.length; i++) {
+      const si = subItems[i];
+      const desc = (si.description ?? "").length > 60 ? (si.description ?? "").slice(0, 60) + "..." : si.description ?? "";
+      console.log(
+        `  ${String(i + 1).padEnd(2)} ${(si.scope ?? "?").padEnd(15)} ${(si.title ?? "?").padEnd(30)} ${desc}`
+      );
+    }
+    if (!opts.yes) {
+      const ok = await confirm2(`
+Create ${subItems.length} sub-items under ${key}?`);
+      if (!ok) {
+        console.log(chalk20.yellow("Aborted."));
+        return;
+      }
+    }
+    const createdKeys = [];
+    for (const si of subItems) {
+      const payload = {
+        title: si.title ?? "Untitled",
+        type: "task",
+        description: si.description ?? "",
+        acceptance_criteria: si.acceptance_criteria ?? "",
+        parent_id: itemId,
+        priority: item.priority ?? "medium",
+        status: "open"
+      };
+      const child = await apiPost(`/api/projects/${slug}/work-items`, payload);
+      const childKey = child.key ?? `#${child.number}`;
+      createdKeys.push(childKey);
+      console.log(chalk20.green(`  Created ${childKey}: ${si.title ?? ""}`));
+    }
+    const summaryLines = [`## Split into ${createdKeys.length} sub-items
+`];
+    for (let i = 0; i < createdKeys.length; i++) {
+      const si = subItems[i];
+      summaryLines.push(`- **${createdKeys[i]}** [${si.scope ?? "?"}]: ${si.title ?? "?"}`);
+    }
+    await apiPost(`/api/work-items/${itemId}/comments`, {
+      body: summaryLines.join("\n"),
+      author: "bb-agent",
+      type: "agent_output"
+    });
+    console.log(chalk20.green(`
+Split complete! Created ${createdKeys.length} sub-items.`));
+    console.log(chalk20.dim(`
+Next step:`));
+    console.log(chalk20.dim(`  bb agent batch-run ${createdKeys.join(" ")}`));
+  });
+});
+
+// src/commands/agent/integrate.ts
+import { Command as Command18 } from "commander";
+import chalk21 from "chalk";
+import fs13 from "fs";
+import readline3 from "readline";
+import { execa as execa5 } from "execa";
+async function confirm3(question) {
+  const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question + " (y/N) ", (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+var integrateCommand = new Command18("integrate").description("Integrate all child branches: merge into integration branch, Docker test, merge to target").argument("<id>", "Parent work item ID or number").option("-t, --target <branch>", "Target branch for integration", "release/dev").option("--cleanup", "Remove worktrees after successful integration").option("--timeout <seconds>", "Docker test timeout in seconds", "600").option("-y, --yes", "Auto-confirm integration").action(async (id, opts) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    const timeout = parseInt(opts.timeout, 10) * 1e3;
+    const target = opts.target;
+    const item = await resolveItemId(slug, id);
+    const itemId = item.id;
+    const key = item.key ?? `#${item.number}`;
+    const children = await apiGet(`/api/work-items/${itemId}/children`);
+    if (!children || children.length === 0) {
+      console.error(chalk21.red(`No child items found for ${key}.`));
+      process.exit(1);
+    }
+    const notReady = children.filter((c) => !["resolved", "in_review"].includes(c.status));
+    if (notReady.length) {
+      console.log(chalk21.yellow("Some children are not ready for integration:"));
+      for (const c of notReady) {
+        const ck = c.key ?? `#${c.number}`;
+        console.log(chalk21.yellow(`  ${ck}: ${c.status}`));
+      }
+      if (!opts.yes) {
+        const ok = await confirm3("Proceed anyway?");
+        if (!ok) return;
+      }
+    }
+    const childBranches = [];
+    for (const c of children) {
+      if (["resolved", "in_review"].includes(c.status)) {
+        const wt = findWorktree(slug, c.number);
+        if (fs13.existsSync(wt)) {
+          const branch = await detectWorktreeBranch(projectPath, wt);
+          if (branch) {
+            childBranches.push({
+              key: c.key ?? `#${c.number}`,
+              branch,
+              worktree: wt,
+              id: c.id
+            });
+          } else {
+            console.log(chalk21.yellow(`  Could not detect branch for #${c.number}`));
+          }
+        }
+      }
+    }
+    if (!childBranches.length) {
+      console.error(chalk21.red("No child branches found. Children may not have worktrees."));
+      process.exit(1);
+    }
+    console.log(chalk21.bold(`
+Integrating ${childBranches.length} branches for ${key}:`));
+    for (const cb of childBranches) {
+      console.log(`  ${cb.key}: ${cb.branch}`);
+    }
+    const integrationBranch = `integrate/${key.toLowerCase()}`;
+    console.log(chalk21.cyan(`
+Creating integration branch: ${integrationBranch}`));
+    const { stdout: currentRaw } = await execa5("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: projectPath
+    });
+    const current = currentRaw.trim();
+    await execa5("git", ["worktree", "prune"], { cwd: projectPath, reject: false });
+    await execa5("git", ["branch", "-D", integrationBranch], { cwd: projectPath, reject: false });
+    await execa5("git", ["branch", integrationBranch, target], { cwd: projectPath, reject: false });
+    const co = await execa5("git", ["checkout", integrationBranch], { cwd: projectPath, reject: false });
+    if (co.exitCode !== 0) {
+      console.error(chalk21.red(`Failed to checkout integration branch: ${co.stderr}`));
+      process.exit(1);
+    }
+    const mergeFailures = [];
+    for (const cb of childBranches) {
+      process.stdout.write(`  Merging ${cb.branch}... `);
+      const mergeResult = await execa5(
+        "git",
+        ["merge", cb.branch, "--no-ff", "-m", `Merge ${cb.branch} into ${integrationBranch}`],
+        { cwd: projectPath, reject: false }
+      );
+      if (mergeResult.exitCode === 0) {
+        console.log(chalk21.green("ok"));
+      } else {
+        console.log(chalk21.red("CONFLICT"));
+        await execa5("git", ["merge", "--abort"], { cwd: projectPath, reject: false });
+        mergeFailures.push(cb);
+      }
+    }
+    if (mergeFailures.length) {
+      console.log(chalk21.red(`
+Merge conflicts in ${mergeFailures.length} branch(es):`));
+      for (const mf of mergeFailures) {
+        console.log(chalk21.red(`  ${mf.key}: ${mf.branch}`));
+      }
+      await execa5("git", ["checkout", current], { cwd: projectPath, reject: false });
+      await execa5("git", ["branch", "-D", integrationBranch], { cwd: projectPath, reject: false });
+      await apiPost(`/api/work-items/${itemId}/comments`, {
+        body: `## Integration Failed
+
+Merge conflicts in: ${mergeFailures.map((mf) => mf.key).join(", ")}`,
+        author: "bb-agent",
+        type: "test_failure"
+      });
+      process.exit(1);
+    }
+    console.log(chalk21.green(`
+All branches merged into ${integrationBranch}.`));
+    console.log(chalk21.cyan("\nRunning Docker tests on integration branch..."));
+    ensureComposeFiles(projectPath, projectPath);
+    const dockerResult = await runDockerTests(projectPath, timeout);
+    if (dockerResult.success) {
+      console.log(chalk21.green(`Docker tests passed!
+${dockerResult.details}`));
+      console.log(chalk21.cyan(`
+Merging ${integrationBranch} into ${target}...`));
+      await execa5("git", ["checkout", target], { cwd: projectPath, reject: false });
+      const ffResult = await execa5(
+        "git",
+        ["merge", integrationBranch, "--ff-only"],
+        { cwd: projectPath, reject: false }
+      );
+      if (ffResult.exitCode !== 0) {
+        await execa5(
+          "git",
+          ["merge", integrationBranch, "--no-ff", "-m", `Merge ${integrationBranch} into ${target}`],
+          { cwd: projectPath, reject: false }
+        );
+      }
+      await apiPut(`/api/work-items/${itemId}`, { status: "resolved" });
+      console.log(chalk21.dim("Parent status -> resolved"));
+      for (const cb of childBranches) {
+        await apiPut(`/api/work-items/${cb.id}`, { status: "resolved" });
+      }
+      if (opts.cleanup) {
+        for (const cb of childBranches) {
+          await removeWorktree(projectPath, cb.worktree);
+        }
+        console.log(chalk21.dim("Worktrees cleaned up."));
+      }
+      await execa5("git", ["branch", "-D", integrationBranch], { cwd: projectPath, reject: false });
+      await apiPost(`/api/work-items/${itemId}/comments`, {
+        body: `## Integration Successful
+
+All ${childBranches.length} branches merged and Docker tests passed.
+Merged to \`${target}\`.`,
+        author: "bb-agent",
+        type: "agent_output"
+      });
+      console.log(chalk21.green(`
+Integration complete! All branches merged to ${target}.`));
+    } else {
+      console.log(chalk21.red(`Docker tests failed!
+${dockerResult.details}`));
+      await execa5("git", ["checkout", current], { cwd: projectPath, reject: false });
+      await execa5("git", ["branch", "-D", integrationBranch], { cwd: projectPath, reject: false });
+      const truncated = truncateOutput2(dockerResult.rawOutput, 4e3);
+      await apiPost(`/api/work-items/${itemId}/comments`, {
+        body: `## Integration Failed
+
+**Docker tests failed.**
+
+${dockerResult.details}
+
+### Docker Output
+
+\`\`\`
+${truncated}
+\`\`\``,
+        author: "bb-agent",
+        type: "test_failure"
+      });
+      console.log(chalk21.red("\nIntegration failed. See Docker test output above."));
+      process.exit(1);
+    }
+    await execa5("git", ["checkout", current], { cwd: projectPath, reject: false });
+  });
+});
+
+// src/commands/agent/merge.ts
+import { Command as Command19 } from "commander";
+import chalk22 from "chalk";
+import fs14 from "fs";
+import { execa as execa6 } from "execa";
+var mergeCommand = new Command19("merge").description("Merge agent branches into a target branch (e.g. release/dev)").argument("[items...]", "Specific item numbers (default: all agent branches)").option("-t, --target <branch>", "Target branch to merge into", "release/dev").option("--cleanup", "Remove worktrees + branches after successful merge").option("--agent", "Use Claude to resolve merge conflicts").action(async (items, opts) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    const { stdout: currentRaw } = await execa6("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: projectPath
+    });
+    const current = currentRaw.trim();
+    const allBranches = await listAgentBranches(projectPath);
+    let branches;
+    if (items && items.length > 0) {
+      const wantedNums = new Set(items.map((n) => parseInt(n, 10)));
+      branches = allBranches.filter((b) => {
+        const num = extractItemNumberFromBranch(b);
+        return num !== null && wantedNums.has(num);
+      });
+    } else {
+      branches = allBranches;
+    }
+    if (!branches.length) {
+      console.log(chalk22.yellow("No agent branches found to merge."));
+      return;
+    }
+    const target = opts.target;
+    console.log(chalk22.cyan(`Merging ${branches.length} branches into ${target}...
+`));
+    for (const b of branches) {
+      console.log(`  ${b}`);
+    }
+    console.log();
+    const check = await execa6("git", ["rev-parse", "--verify", target], {
+      cwd: projectPath,
+      reject: false
+    });
+    if (check.exitCode !== 0) {
+      console.log(chalk22.yellow(`Branch '${target}' does not exist. Creating from HEAD...`));
+      await execa6("git", ["branch", target], { cwd: projectPath });
+    }
+    await execa6("git", ["worktree", "prune"], { cwd: projectPath, reject: false });
+    const co = await execa6("git", ["checkout", target], { cwd: projectPath, reject: false });
+    if (co.exitCode !== 0) {
+      console.error(chalk22.red(`Failed to checkout ${target}: ${co.stderr}`));
+      return;
+    }
+    const merged = [];
+    const failed = [];
+    for (const branch of branches) {
+      process.stdout.write(`  Merging ${branch}... `);
+      const mergeResult = await execa6(
+        "git",
+        ["merge", branch, "--no-ff", "-m", `Merge ${branch} into ${target}`],
+        { cwd: projectPath, reject: false }
+      );
+      if (mergeResult.exitCode === 0) {
+        console.log(chalk22.green("ok"));
+        merged.push(branch);
+      } else {
+        if (opts.agent) {
+          console.log(chalk22.yellow("conflict -> resolving with Claude..."));
+          await runClaude({
+            cmd: [
+              "claude",
+              "-p",
+              `Resolve all merge conflicts in this git repo. The merge of '${branch}' into '${target}' has conflicts. Use 'git diff' to find conflicts, resolve them keeping both sets of changes where possible, then stage and commit. Do NOT abort the merge.`,
+              "--output-format",
+              "text",
+              "--permission-mode",
+              "bypassPermissions"
+            ],
+            cwd: projectPath,
+            timeout: 3e5
+          });
+          const statusCheck = await execa6(
+            "git",
+            ["diff", "--name-only", "--diff-filter=U"],
+            { cwd: projectPath, reject: false }
+          );
+          if (statusCheck.stdout.trim() === "") {
+            console.log(chalk22.green("    Conflict resolved by agent"));
+            merged.push(branch);
+          } else {
+            console.log(chalk22.red("    Agent could not resolve all conflicts"));
+            await execa6("git", ["merge", "--abort"], { cwd: projectPath, reject: false });
+            failed.push([branch, "conflict (agent failed)"]);
+          }
+        } else {
+          console.log(chalk22.red("CONFLICT"));
+          await execa6("git", ["merge", "--abort"], { cwd: projectPath, reject: false });
+          failed.push([branch, "conflict"]);
+        }
+      }
+    }
+    console.log();
+    console.log(chalk22.bold(`Merge Results -> ${target}`));
+    console.log("-".repeat(50));
+    for (const b of merged) {
+      console.log(`  ${b.padEnd(40)} ${chalk22.green("merged")}`);
+    }
+    for (const [b, reason] of failed) {
+      console.log(`  ${b.padEnd(40)} ${chalk22.red(reason)}`);
+    }
+    if (opts.cleanup && merged.length) {
+      for (const branch of merged) {
+        const num = extractItemNumberFromBranch(branch);
+        if (num !== null) {
+          try {
+            const wt = findWorktree(slug, num);
+            if (fs14.existsSync(wt)) {
+              await removeWorktree(projectPath, wt);
+            }
+          } catch {
+          }
+        }
+        await execa6("git", ["branch", "-D", branch], {
+          cwd: projectPath,
+          reject: false
+        });
+      }
+      console.log(chalk22.dim("Cleaned up merged worktrees and branches."));
+    }
+    if (failed.length) {
+      console.log(chalk22.yellow("\nFailed branches can be retried:"));
+      console.log(chalk22.dim("  bb agent merge --agent  (use Claude to resolve conflicts)"));
+      console.log(chalk22.dim(`  or resolve manually: git checkout ${target} && git merge <branch>`));
+    }
+    await execa6("git", ["checkout", current], { cwd: projectPath, reject: false });
+  });
+});
+
+// src/commands/agent/status.ts
+import { Command as Command20 } from "commander";
+import chalk23 from "chalk";
+var statusCommand = new Command20("status").description("Show agent sessions for the current project").action(async () => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const sessions = await apiGet("/api/agent-sessions", { project_slug: slug });
+    if (!sessions || sessions.length === 0) {
+      console.log(chalk23.dim("No agent sessions."));
+      return;
+    }
+    for (const s of sessions) {
+      const colorFn = s.status === "running" ? chalk23.yellow : s.status === "completed" ? chalk23.green : s.status === "failed" ? chalk23.red : chalk23.white;
+      const sid = String(s.id).slice(0, 8);
+      const itemId = s.work_item_id ?? "--";
+      console.log(`  ${colorFn(s.status.padStart(10))}  ${sid}  item: ${itemId}`);
+    }
+  });
+});
+var abortCommand = new Command20("abort").description("Abort a running agent session").argument("<session-id>", "Session ID to abort").action(async (sessionId) => {
+  await withErrorHandling(async () => {
+    await apiPost(`/api/agent-sessions/${sessionId}/abort`);
+    console.log(chalk23.yellow(`Session ${sessionId.slice(0, 8)} aborted.`));
+  });
+});
+
+// src/commands/agent/worktree.ts
+import { Command as Command21 } from "commander";
+import chalk24 from "chalk";
+import fs15 from "fs";
+import { execa as execa7 } from "execa";
+var worktreesCommand = new Command21("worktrees").description("List active agent worktrees for the current project").action(async () => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    const result = await execa7("git", ["worktree", "list"], {
+      cwd: projectPath,
+      reject: false
+    });
+    if (result.exitCode !== 0) {
+      console.error(chalk24.red("Failed to list worktrees."));
+      process.exit(1);
+    }
+    const wtDir = WORKTREES_DIR.replace(/\\/g, "/") + "/" + slug;
+    const lines = result.stdout.trim().split("\n");
+    const bbLines = lines.filter((ln) => ln.replace(/\\/g, "/").includes(wtDir));
+    if (!bbLines.length) {
+      console.log(chalk24.dim("No agent worktrees."));
+      return;
+    }
+    console.log(chalk24.bold("Agent worktrees:"));
+    for (const ln of bbLines) {
+      console.log(`  ${ln}`);
+    }
+  });
+});
+var cleanupCommand = new Command21("cleanup").description("Remove the worktree created for a work item").argument("<item-number>", "Work item number whose worktree to remove").option("-D, --delete-branch", "Also delete the git branch").action(async (itemNumberStr, opts) => {
+  await withErrorHandling(async () => {
+    const slug = requireProject();
+    const projectPath = requireProjectPath(slug);
+    const itemNumber = parseInt(itemNumberStr, 10);
+    if (isNaN(itemNumber)) {
+      console.error(chalk24.red("Invalid item number."));
+      process.exit(1);
+    }
+    const wt = findWorktree(slug, itemNumber);
+    if (!fs15.existsSync(wt)) {
+      console.log(chalk24.yellow(`No worktree found for item #${itemNumber}.`));
+      return;
+    }
+    const branch = await detectWorktreeBranch(projectPath, wt);
+    await removeWorktree(projectPath, wt);
+    console.log(chalk24.green(`Worktree removed: ${wt}`));
+    if (opts.deleteBranch && branch) {
+      await execa7("git", ["branch", "-D", branch], {
+        cwd: projectPath,
+        reject: false
+      });
+      console.log(chalk24.green(`Branch deleted: ${branch}`));
+    } else if (branch) {
+      console.log(chalk24.dim(`Branch '${branch}' kept. Delete with: git branch -D ${branch}`));
+    } else {
+      console.log(chalk24.dim("Could not detect branch name (worktree may have been stale)."));
+    }
+  });
+});
+
+// src/commands/agent/daemon.ts
+import { Command as Command22 } from "commander";
+import chalk25 from "chalk";
+import os4 from "os";
+function daemonId() {
+  return `${os4.hostname()}-${process.pid}`;
+}
+async function pollPendingSessions(slug) {
+  try {
+    const sessions = await apiGet("/api/agent-sessions", { project_slug: slug });
+    return sessions.filter((s) => s.status === "pending" && !s.claimed_by);
+  } catch {
+    return [];
+  }
+}
+async function claimSession(sessionId, dId) {
+  try {
+    return await apiPost(`/api/agent-sessions/${sessionId}/claim`, void 0, { daemon_id: dId });
+  } catch {
+    return null;
+  }
+}
+async function runSession(slug, projectPath, session) {
+  const sessionId = session.id;
+  const workItemId = session.work_item_id;
+  const phase = session.phase ?? "execute";
+  if (!workItemId) {
+    console.log(chalk25.yellow(`  Session ${sessionId}: no work_item_id, skipping.`));
+    await apiPost(`/api/agent-sessions/${sessionId}/complete`, {
+      status: "failed",
+      error: "No work item specified"
+    });
+    return;
+  }
+  let idOrNumber;
+  try {
+    const item = await apiGet(`/api/work-items/${workItemId}`);
+    idOrNumber = item.key ?? String(item.number);
+  } catch (e) {
+    console.log(chalk25.red(`  Session ${sessionId}: failed to resolve item ${workItemId}: ${e.message}`));
+    await apiPost(`/api/agent-sessions/${sessionId}/complete`, {
+      status: "failed",
+      error: String(e.message)
+    });
+    return;
+  }
+  console.log(chalk25.cyan(`  Running ${phase} for ${idOrNumber}...`));
+  let result;
+  if (phase === "suggest" || phase === "verify") {
+    result = await suggestOne(slug, projectPath, idOrNumber);
+  } else {
+    result = await executeOne(slug, projectPath, idOrNumber);
+  }
+  const status = result.status === "ok" ? "ok" : "failed";
+  const color = status === "ok" ? chalk25.green : chalk25.red;
+  const suffix = status !== "ok" ? ` -- ${result.error ?? ""}` : "";
+  console.log(color(`  ${idOrNumber}: ${status}${suffix}`));
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var daemonCommand = new Command22("daemon").description("Start the agent daemon -- polls for web-initiated sessions and executes them").option("-p, --poll <seconds>", "Polling interval in seconds", "5").action(async (opts) => {
+  await withErrorHandling(async () => {
+    const slug = getCurrentProject();
+    if (!slug) {
+      console.error(chalk25.red("No project configured. Run 'bb init' or 'bb project use <slug>' first."));
+      process.exit(1);
+    }
+    const projectPath = getProjectPath(slug);
+    if (!projectPath) {
+      console.error(chalk25.red("No project path configured. Run 'bb init' first."));
+      process.exit(1);
+    }
+    const token = getToken();
+    if (!token) {
+      console.error(chalk25.red("Not authenticated. Run 'bb login' first."));
+      process.exit(1);
+    }
+    const dId = daemonId();
+    const apiUrl = getApiUrl();
+    const pollInterval = parseInt(opts.poll, 10) * 1e3;
+    console.log(chalk25.bold.green("Bumblebee Agent Daemon"));
+    console.log(`  Project: ${chalk25.cyan(slug)}`);
+    console.log(`  Path:    ${chalk25.cyan(projectPath)}`);
+    console.log(`  API:     ${chalk25.cyan(apiUrl)}`);
+    console.log(`  Daemon:  ${chalk25.cyan(dId)}`);
+    console.log(`  Poll:    every ${opts.poll}s`);
+    console.log(chalk25.dim("\nListening for web-initiated agent requests... (Ctrl+C to stop)\n"));
+    let running = true;
+    const shutdown = () => {
+      console.log(chalk25.yellow("\nShutting down daemon..."));
+      running = false;
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    while (running) {
+      const pending = await pollPendingSessions(slug);
+      for (const session of pending) {
+        const claimed = await claimSession(session.id, dId);
+        if (claimed) {
+          console.log(chalk25.cyan(`Claimed session ${session.id}`));
+          try {
+            await runSession(slug, projectPath, claimed);
+          } catch (e) {
+            console.log(chalk25.red(`Session ${session.id} failed: ${e.message}`));
+            try {
+              await apiPost(`/api/agent-sessions/${session.id}/complete`, {
+                status: "failed",
+                error: String(e.message)
+              });
+            } catch {
+            }
+          }
+        }
+      }
+      await sleep(pollInterval);
+    }
+    console.log(chalk25.dim("Daemon stopped."));
+  });
+});
+
+// src/commands/agent/index.ts
+var agentCommand = new Command23("agent").description("Agent session management").addCommand(suggestCommand).addCommand(executeCommand).addCommand(testCommand).addCommand(verifyCommand).addCommand(reimplementCommand).addCommand(runCommand).addCommand(continueCommand).addCommand(splitCommand).addCommand(integrateCommand).addCommand(mergeCommand).addCommand(statusCommand).addCommand(abortCommand).addCommand(worktreesCommand).addCommand(cleanupCommand).addCommand(batchSuggestCommand).addCommand(batchExecuteCommand).addCommand(batchRunCommand).addCommand(daemonCommand);
+
+// src/index.ts
+var program = new Command24();
+program.name("bb").description("Bumblebee \u2014 Dev Task Management + Claude Code Automation CLI").version("0.3.0");
+program.addCommand(authCommand);
+program.addCommand(projectCommand);
+program.addCommand(itemCommand);
+program.addCommand(commentCommand);
+program.addCommand(sprintCommand);
+program.addCommand(labelCommand);
+program.addCommand(boardCommand);
+program.addCommand(doctorCommand);
+program.addCommand(initCommand);
+program.addCommand(agentCommand);
+program.command("login").description("Log in (alias for auth login)").option("-e, --email <email>", "Email address").option("-p, --password <password>", "Password").action(async (opts) => {
+  await program.parseAsync(["auth", "login", ...opts.email ? ["-e", opts.email] : [], ...opts.password ? ["-p", opts.password] : []], { from: "user" });
+});
+program.command("logout").description("Log out (alias for auth logout)").action(async () => {
+  await program.parseAsync(["auth", "logout"], { from: "user" });
+});
+process.on("unhandledRejection", (err) => {
+  console.error(`Error: ${err?.message ?? err}`);
+  process.exit(1);
+});
+program.parse();
+//# sourceMappingURL=index.js.map