@jaabiri/bmad-studio 0.2.1

package/dist/index.js

@@ -0,0 +1,1996 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { Command } from "commander";
+
+// src/instances.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { createServer as createNetServer } from "net";
+import { homedir } from "os";
+import { join, resolve } from "path";
+function getLockfileDir() {
+  return join(homedir(), ".bmad-studio");
+}
+function getLockfilePath() {
+  return join(getLockfileDir(), "instances.json");
+}
+function lockfilePath() {
+  const dir = getLockfileDir();
+  mkdirSync(dir, { recursive: true });
+  return getLockfilePath();
+}
+function isValidEntry(entry) {
+  if (typeof entry !== "object" || entry === null) return false;
+  const e = entry;
+  return typeof e.port === "number" && typeof e.pid === "number" && typeof e.projectPath === "string" && typeof e.startTime === "string";
+}
+function readInstances() {
+  try {
+    const raw = readFileSync(lockfilePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isValidEntry);
+  } catch {
+    return [];
+  }
+}
+function writeInstances(entries) {
+  const dir = getLockfileDir();
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(getLockfilePath(), JSON.stringify(entries, null, 2) + "\n", "utf-8");
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cleanStaleEntries(entries) {
+  return entries.filter((entry) => isProcessAlive(entry.pid));
+}
+function registerInstance(entry) {
+  const entries = readInstances();
+  const cleaned = cleanStaleEntries(entries);
+  cleaned.push(entry);
+  writeInstances(cleaned);
+}
+function unregisterInstance(port) {
+  const entries = readInstances();
+  const filtered = entries.filter((entry) => entry.port !== port);
+  writeInstances(filtered);
+}
+function findInstanceByProject(projectPath) {
+  const entries = readInstances();
+  const cleaned = cleanStaleEntries(entries);
+  const resolved = resolve(projectPath);
+  return cleaned.find((entry) => entry.projectPath === resolved);
+}
+function isPortAvailable(port) {
+  return new Promise((resolve4) => {
+    const server = createNetServer();
+    server.once("error", () => {
+      resolve4(false);
+    });
+    server.once("listening", () => {
+      server.close(() => resolve4(true));
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+var PORT_MIN = 5400;
+var PORT_MAX = 5499;
+async function findAvailablePort(startPort) {
+  const entries = readInstances();
+  const cleaned = cleanStaleEntries(entries);
+  const usedPorts = new Set(cleaned.map((e) => e.port));
+  const rangeStart = startPort ?? PORT_MIN;
+  for (let port = rangeStart; port <= PORT_MAX; port++) {
+    if (!usedPorts.has(port) && await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new Error(`All ports in range ${PORT_MIN}-${PORT_MAX} are occupied`);
+}
+
+// src/launcher.ts
+import { resolve as resolve3, dirname as dirname3 } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync2 } from "fs";
+
+// ../server/dist/index.js
+import http from "http";
+import { existsSync } from "fs";
+import { join as join8, dirname as dirname2 } from "path";
+import express from "express";
+import debugFactory6 from "debug";
+
+// ../server/dist/routes/api.js
+import { Router } from "express";
+import { stat as stat2, readdir, readFile as readFile3 } from "fs/promises";
+import { join as join4, isAbsolute, normalize } from "path";
+
+// ../server/dist/config-file.js
+import { readFile, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+import debugFactory from "debug";
+var debug = debugFactory("bmad-studio:config-file");
+var CONFIG_FILENAME = ".bmad-studio.json";
+function configPath(projectRoot) {
+  return join2(projectRoot, CONFIG_FILENAME);
+}
+async function readConfig(projectRoot) {
+  const filePath = configPath(projectRoot);
+  try {
+    const raw = await readFile(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!isValidConfig(parsed)) {
+      debug("Invalid config at %s", filePath);
+      return null;
+    }
+    return parsed;
+  } catch {
+    debug("No config file at %s", filePath);
+    return null;
+  }
+}
+async function writeConfig(projectRoot, config) {
+  const filePath = configPath(projectRoot);
+  const content = JSON.stringify(config, null, 2) + "\n";
+  await writeFile(filePath, content, "utf-8");
+  debug("Wrote config to %s", filePath);
+}
+function isValidConfig(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  return obj["version"] === 1 && typeof obj["outputDir"] === "string";
+}
+
+// ../server/dist/sprint-parser.js
+import { readFile as readFile2, stat } from "fs/promises";
+import { join as join3 } from "path";
+import { parse as parseYaml } from "yaml";
+var EPIC_STATUS_REGEX = /^epic-(\d+)$/;
+var RETRO_REGEX = /^epic-(\d+)-retrospective$/;
+var STORY_REGEX = /^(\d+)-(\d+)-(.+)$/;
+var EPIC_TITLE_REGEX = /# Epic (\d+): (.+)/g;
+function slugToTitle(slug) {
+  return slug.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+async function fileExists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findSprintFile(outputDir) {
+  const candidates = [
+    join3(outputDir, "implementation-artifacts", "sprint-status.yaml"),
+    join3(outputDir, "sprint-status.yaml")
+  ];
+  for (const candidate of candidates) {
+    if (await fileExists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function extractEpicTitles(rawText) {
+  const titles = /* @__PURE__ */ new Map();
+  let match;
+  while ((match = EPIC_TITLE_REGEX.exec(rawText)) !== null) {
+    titles.set(parseInt(match[1]), match[2].trim());
+  }
+  EPIC_TITLE_REGEX.lastIndex = 0;
+  return titles;
+}
+function computeStats(epics) {
+  const allStories = epics.flatMap((e) => e.stories);
+  const totalStories = allStories.length;
+  const totalEpics = epics.length;
+  const byStoryStatus = {
+    backlog: 0,
+    "ready-for-dev": 0,
+    "in-progress": 0,
+    review: 0,
+    done: 0
+  };
+  for (const story of allStories) {
+    byStoryStatus[story.status]++;
+  }
+  const byEpicStatus = {
+    backlog: 0,
+    "in-progress": 0,
+    done: 0
+  };
+  for (const epic of epics) {
+    byEpicStatus[epic.status]++;
+  }
+  const doneCount = byStoryStatus["done"];
+  const overallProgress = totalStories > 0 ? Math.round(doneCount / totalStories * 100) : 0;
+  return { totalStories, totalEpics, byStoryStatus, byEpicStatus, overallProgress };
+}
+async function parseSprintStatus(outputDir) {
+  const filePath = await findSprintFile(outputDir);
+  if (!filePath) {
+    return null;
+  }
+  const rawText = await readFile2(filePath, "utf-8");
+  const epicTitles = extractEpicTitles(rawText);
+  const parsed = parseYaml(rawText);
+  const developmentStatus = parsed.development_status ?? {};
+  const storyLocation = String(parsed.story_location ?? "");
+  const metadata = {
+    generated: String(parsed.generated ?? ""),
+    lastUpdated: String(parsed.last_updated ?? ""),
+    project: String(parsed.project ?? ""),
+    projectKey: String(parsed.project_key ?? ""),
+    storyLocation
+  };
+  const epicMap = /* @__PURE__ */ new Map();
+  const ensureEpic = (epicNum) => {
+    if (!epicMap.has(epicNum)) {
+      epicMap.set(epicNum, { status: "backlog", retrospective: "optional", stories: [] });
+    }
+    return epicMap.get(epicNum);
+  };
+  const storyBasePath = storyLocation.startsWith("_bmad-output/") ? join3(outputDir, storyLocation.replace(/^_bmad-output\//, "")) : join3(outputDir, "..", storyLocation);
+  for (const [key, value] of Object.entries(developmentStatus)) {
+    let match;
+    match = EPIC_STATUS_REGEX.exec(key);
+    if (match) {
+      const epicNum = parseInt(match[1]);
+      ensureEpic(epicNum).status = value;
+      continue;
+    }
+    match = RETRO_REGEX.exec(key);
+    if (match) {
+      const epicNum = parseInt(match[1]);
+      ensureEpic(epicNum).retrospective = value;
+      continue;
+    }
+    match = STORY_REGEX.exec(key);
+    if (match) {
+      const epicNum = parseInt(match[1]);
+      const storyNum = parseInt(match[2]);
+      const remainingSlug = match[3];
+      const id = `${epicNum}-${storyNum}`;
+      const epicId = `epic-${epicNum}`;
+      const title = slugToTitle(remainingSlug);
+      const hasFile = await fileExists(join3(storyBasePath, `${key}.md`));
+      ensureEpic(epicNum).stories.push({
+        id,
+        slug: key,
+        title,
+        status: value,
+        hasFile,
+        epicId
+      });
+    }
+  }
+  const epicNumbers = Array.from(epicMap.keys()).sort((a, b) => a - b);
+  const epics = epicNumbers.map((num) => {
+    const data = epicMap.get(num);
+    data.stories.sort((a, b) => {
+      const [aEpic, aStory] = a.id.split("-").map(Number);
+      const [bEpic, bStory] = b.id.split("-").map(Number);
+      return aEpic !== bEpic ? aEpic - bEpic : aStory - bStory;
+    });
+    return {
+      id: `epic-${num}`,
+      number: num,
+      title: epicTitles.get(num) ?? `Epic ${num}`,
+      status: data.status,
+      stories: data.stories,
+      retrospective: data.retrospective
+    };
+  });
+  const stats = computeStats(epics);
+  return { metadata, epics, stats };
+}
+
+// ../server/dist/routes/api.js
+function createApiRouter(options) {
+  const router = Router();
+  let currentOutputDir = options.outputDir;
+  router.get("/capabilities", (_req, res) => {
+    const capabilities = {
+      git: false,
+      pty: false,
+      version: "0.1.0"
+    };
+    res.json(capabilities);
+  });
+  router.get("/state", async (_req, res) => {
+    if (!currentOutputDir) {
+      const suggestions = await findSuggestions(options.rootDir);
+      res.json({
+        status: "unconfigured",
+        rootDir: options.rootDir,
+        suggestions
+      });
+      return;
+    }
+    const cached = options.getCachedState();
+    if (cached) {
+      res.json(cached);
+      return;
+    }
+    try {
+      const state = await options.scanner.scan(currentOutputDir, options.rootDir);
+      res.json(state);
+    } catch {
+      res.status(500).json({
+        error: { code: "SCAN_FAILED", message: "Failed to scan project" }
+      });
+    }
+  });
+  router.post("/configure", async (req, res) => {
+    const { outputDir } = req.body;
+    if (!outputDir || typeof outputDir !== "string") {
+      res.status(400).json({
+        error: { code: "INVALID_INPUT", message: "outputDir is required" }
+      });
+      return;
+    }
+    const resolvedDir = join4(options.rootDir, outputDir);
+    try {
+      const s = await stat2(resolvedDir);
+      if (!s.isDirectory()) {
+        res.status(400).json({
+          error: {
+            code: "NOT_A_DIRECTORY",
+            message: `${outputDir} is not a directory`
+          }
+        });
+        return;
+      }
+    } catch {
+      res.status(404).json({
+        error: {
+          code: "NOT_FOUND",
+          message: `Directory not found: ${outputDir}`
+        }
+      });
+      return;
+    }
+    try {
+      await writeConfig(options.rootDir, { version: 1, outputDir });
+      currentOutputDir = resolvedDir;
+      res.json({ success: true, outputDir: resolvedDir });
+    } catch {
+      res.status(500).json({
+        error: {
+          code: "WRITE_FAILED",
+          message: "Failed to write configuration file"
+        }
+      });
+    }
+  });
+  router.get("/document/*path", async (req, res) => {
+    if (!currentOutputDir) {
+      res.status(400).json({
+        error: { code: "NOT_CONFIGURED", message: "Output directory not configured" }
+      });
+      return;
+    }
+    const rawPath = req.params.path;
+    const docPath = decodeURIComponent(Array.isArray(rawPath) ? rawPath.join("/") : rawPath);
+    if (docPath.includes("..") || isAbsolute(docPath)) {
+      res.status(400).json({
+        error: { code: "INVALID_PATH", message: "Path must be relative and cannot contain .." }
+      });
+      return;
+    }
+    const fullPath = normalize(join4(currentOutputDir, docPath));
+    if (!fullPath.startsWith(normalize(currentOutputDir))) {
+      res.status(400).json({
+        error: { code: "INVALID_PATH", message: "Path escapes output directory" }
+      });
+      return;
+    }
+    try {
+      const fileStat = await stat2(fullPath);
+      if (!fileStat.isFile()) {
+        res.status(404).json({
+          error: { code: "DOCUMENT_NOT_FOUND", message: "Path is not a file" }
+        });
+        return;
+      }
+      const content = await readFile3(fullPath, "utf-8");
+      res.setHeader("Content-Type", "application/json");
+      res.json({
+        content,
+        size: fileStat.size,
+        lastModified: fileStat.mtime.toISOString()
+      });
+    } catch {
+      res.status(404).json({
+        error: { code: "DOCUMENT_NOT_FOUND", message: `Document not found: ${docPath}` }
+      });
+    }
+  });
+  router.get("/sprint", async (_req, res) => {
+    if (!currentOutputDir) {
+      res.status(400).json({
+        error: { code: "NOT_CONFIGURED", message: "Output directory not configured" }
+      });
+      return;
+    }
+    try {
+      const sprintStatus = await parseSprintStatus(currentOutputDir);
+      if (!sprintStatus) {
+        res.json({ status: "no-sprint-data", message: "No sprint-status.yaml found" });
+        return;
+      }
+      res.json(sprintStatus);
+    } catch {
+      res.status(500).json({
+        error: { code: "SPRINT_PARSE_FAILED", message: "Failed to parse sprint status" }
+      });
+    }
+  });
+  router.get("/git/history/:path", (_req, res) => {
+    res.status(501).json({ error: "Not implemented" });
+  });
+  router.get("/git/diff/:path/:hash", (_req, res) => {
+    res.status(501).json({ error: "Not implemented" });
+  });
+  return router;
+}
+async function findSuggestions(rootDir) {
+  const suggestions = [];
+  try {
+    const entries = await readdir(rootDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith("."))
+        continue;
+      const dirPath = join4(rootDir, entry.name);
+      try {
+        const contents = await readdir(dirPath);
+        if (contents.some((f) => f.endsWith(".md"))) {
+          suggestions.push(entry.name);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return suggestions;
+}
+
+// ../server/dist/detection.js
+import { readFile as readFile4, stat as stat3, glob } from "fs/promises";
+import { join as join5, resolve as resolve2, dirname } from "path";
+import debugFactory2 from "debug";
+var debug2 = debugFactory2("bmad-studio:detection");
+var BMAD_ARTIFACT_PATTERNS = [
+  "**/prd.md",
+  "**/PRD.md",
+  "**/architecture.md",
+  "**/epics.md",
+  "**/sprint-status.yaml",
+  "**/product-brief.md"
+];
+async function detectOutputDir(cwd, cliFlag) {
+  if (cliFlag) {
+    const resolved = resolve2(cwd, cliFlag);
+    debug2("Step 1: CLI flag \u2192 %s", resolved);
+    return resolved;
+  }
+  const config = await readConfig(cwd);
+  if (config?.outputDir) {
+    const resolved = resolve2(cwd, config.outputDir);
+    debug2("Step 2: .bmad-studio.json \u2192 %s", resolved);
+    return resolved;
+  }
+  const agentsResult = await parseAgentsMd(cwd);
+  if (agentsResult) {
+    debug2("Step 3: AGENTS.md \u2192 %s", agentsResult);
+    return agentsResult;
+  }
+  const bmadConfigResult = await parseBmadConfigYaml(cwd);
+  if (bmadConfigResult) {
+    debug2("Step 4: _bmad/core/config.yaml \u2192 %s", bmadConfigResult);
+    return bmadConfigResult;
+  }
+  const defaultDir = join5(cwd, "_bmad-output");
+  if (await directoryExists(defaultDir)) {
+    debug2("Step 5: _bmad-output/ exists \u2192 %s", defaultDir);
+    return defaultDir;
+  }
+  const globResult = await scanForArtifacts(cwd);
+  if (globResult) {
+    debug2("Step 6: Glob scan \u2192 %s", globResult);
+    return globResult;
+  }
+  debug2("Step 7: No BMAD output directory detected");
+  return null;
+}
+async function resolveOutputDir(cwd, cliFlag) {
+  const outputDir = await detectOutputDir(cwd, cliFlag);
+  if (outputDir) {
+    try {
+      await writeConfig(cwd, { version: 1, outputDir });
+      debug2("Persisted detected outputDir to .bmad-studio.json");
+    } catch (err) {
+      debug2("Failed to persist config: %O", err);
+    }
+  }
+  return outputDir;
+}
+async function parseAgentsMd(cwd) {
+  const agentsPath = join5(cwd, "AGENTS.md");
+  try {
+    const content = await readFile4(agentsPath, "utf-8");
+    const outputFolderMatch = content.match(/output_folder\s*[:=]\s*["']?([^\s"']+)["']?/);
+    if (outputFolderMatch) {
+      const resolved = resolve2(cwd, outputFolderMatch[1]);
+      if (await directoryExists(resolved))
+        return resolved;
+    }
+    const pathRefMatch = content.match(/\{project-root\}\/([^\s"'}\]]+)/);
+    if (pathRefMatch) {
+      const candidate = pathRefMatch[1].split("/")[0];
+      const resolved = resolve2(cwd, candidate);
+      if (await directoryExists(resolved))
+        return resolved;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function parseBmadConfigYaml(cwd) {
+  const candidates = [
+    join5(cwd, "_bmad", "core", "config.yaml"),
+    join5(cwd, "_bmad", "bmm", "config.yaml")
+  ];
+  for (const configPath2 of candidates) {
+    const result = await tryParseBmadConfig(cwd, configPath2);
+    if (result)
+      return result;
+  }
+  return null;
+}
+async function tryParseBmadConfig(cwd, configPath2) {
+  try {
+    const content = await readFile4(configPath2, "utf-8");
+    const match = content.match(/output_folder\s*:\s*["']?([^\s"'#]+)["']?/);
+    if (match) {
+      const rawPath = match[1].replace(/\{project-root\}/g, cwd);
+      const resolved = resolve2(cwd, rawPath);
+      if (await directoryExists(resolved))
+        return resolved;
+    }
+    const altMatch = content.match(/output_folder\s*:\s*["']?\{project-root\}\/([^\s"'#]+)["']?/);
+    if (altMatch) {
+      const resolved = resolve2(cwd, altMatch[1]);
+      if (await directoryExists(resolved))
+        return resolved;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function scanForArtifacts(cwd) {
+  for (const pattern of BMAD_ARTIFACT_PATTERNS) {
+    try {
+      for await (const match of glob(pattern, { cwd })) {
+        const absPath = resolve2(cwd, match);
+        return dirname(absPath);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function directoryExists(dirPath) {
+  try {
+    const s = await stat3(dirPath);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// ../server/dist/scanner.js
+import { readdir as readdir2, stat as stat4, readFile as readFile5 } from "fs/promises";
+import { join as join6, relative } from "path";
+import picomatch from "picomatch";
+import debugFactory3 from "debug";
+
+// ../shared/dist/definitions/phases.js
+var phaseDefinitions = [
+  {
+    id: "analysis",
+    label: "Analysis",
+    accentColor: "#F59E0B"
+  },
+  {
+    id: "planning",
+    label: "Planning",
+    accentColor: "#3B82F6"
+  },
+  {
+    id: "solutioning",
+    label: "Solutioning",
+    accentColor: "#8B5CF6"
+  },
+  {
+    id: "implementation",
+    label: "Implementation",
+    accentColor: "#10B981"
+  }
+];
+
+// ../shared/dist/definitions/workflows.js
+var workflowDefinitions = [
+  // Phase 1 — Analysis (6 stations)
+  {
+    id: "brainstorming",
+    label: "Brainstorming",
+    phase: "analysis",
+    command: "bmad-brainstorming",
+    triggerCode: "brainstorm",
+    agent: { name: "Mary", role: "Business Analyst", skillId: "bmad-brainstorming" },
+    outputs: [{ glob: "**/brainstorming-report.md", description: "Brainstorming report" }],
+    inputs: [],
+    learn: {
+      title: "Brainstorming",
+      whatItDoes: "Facilitate interactive brainstorming sessions using diverse creative techniques and ideation methods.",
+      whenToUse: "At the start of a project when exploring ideas, or when you need fresh perspectives on a problem.",
+      whatItNeeds: "A topic or problem statement to brainstorm around. No prior documents required.",
+      whatItProduces: "A brainstorming report with organized ideas, themes, and potential directions.",
+      proTip: "Run multiple brainstorming sessions with different techniques for richer results."
+    }
+  },
+  {
+    id: "domain-research",
+    label: "Domain Research",
+    phase: "analysis",
+    command: "bmad-domain-research",
+    triggerCode: "domain",
+    agent: { name: "Mary", role: "Business Analyst", skillId: "bmad-domain-research" },
+    outputs: [{ glob: "**/domain-research*.md", description: "Domain research findings" }],
+    inputs: [],
+    learn: {
+      title: "Domain Research",
+      whatItDoes: "Conduct domain and industry research to understand the problem space and key concepts.",
+      whenToUse: "When entering an unfamiliar domain or needing to validate assumptions about an industry.",
+      whatItNeeds: "A domain or industry topic to research. No prior documents required.",
+      whatItProduces: "A domain research report with key findings, terminology, and industry context.",
+      proTip: "Combine with market research for a complete picture of the competitive landscape."
+    }
+  },
+  {
+    id: "market-research",
+    label: "Market Research",
+    phase: "analysis",
+    command: "bmad-market-research",
+    triggerCode: "market",
+    agent: { name: "Mary", role: "Business Analyst", skillId: "bmad-market-research" },
+    outputs: [{ glob: "**/market-research*.md", description: "Market research findings" }],
+    inputs: [],
+    learn: {
+      title: "Market Research",
+      whatItDoes: "Conduct market research on competition, customers, and market positioning.",
+      whenToUse: "When you need to understand competitors, target audience, or market opportunities.",
+      whatItNeeds: "A market or product category to research. No prior documents required.",
+      whatItProduces: "A market research report covering competitors, customer segments, and opportunities.",
+      proTip: "Feed market research findings into your product brief for stronger positioning."
+    }
+  },
+  {
+    id: "technical-research",
+    label: "Technical Research",
+    phase: "analysis",
+    command: "bmad-technical-research",
+    triggerCode: "techresearch",
+    agent: { name: "Winston", role: "Architect", skillId: "bmad-technical-research" },
+    outputs: [{ glob: "**/technical-research*.md", description: "Technical research report" }],
+    inputs: [],
+    learn: {
+      title: "Technical Research",
+      whatItDoes: "Conduct technical research on technologies, frameworks, and architecture options.",
+      whenToUse: "When evaluating technology choices or exploring technical approaches for your solution.",
+      whatItNeeds: "A technical topic or set of technologies to evaluate. No prior documents required.",
+      whatItProduces: "A technical research report with comparisons, recommendations, and trade-offs.",
+      proTip: "Run this before architecture design to make informed technology decisions."
+    }
+  },
+  {
+    id: "product-brief",
+    label: "Product Brief",
+    phase: "analysis",
+    command: "bmad-product-brief",
+    triggerCode: "brief",
+    agent: { name: "Mary", role: "Business Analyst", skillId: "bmad-product-brief" },
+    outputs: [{ glob: "**/product-brief.md", description: "Product brief document" }],
+    inputs: [],
+    learn: {
+      title: "Product Brief",
+      whatItDoes: "Create or update product briefs through guided or autonomous discovery.",
+      whenToUse: "When starting a new product or feature and need to capture the core vision and goals.",
+      whatItNeeds: "Your product idea or concept. Optionally, prior research documents for richer context.",
+      whatItProduces: "A structured product brief defining the problem, solution, target users, and success metrics.",
+      proTip: "The product brief is the foundation for everything \u2014 invest time getting it right."
+    }
+  },
+  {
+    id: "prfaq",
+    label: "PRFAQ",
+    phase: "analysis",
+    command: "bmad-prfaq",
+    triggerCode: "prfaq",
+    agent: { name: "Mary", role: "Business Analyst", skillId: "bmad-prfaq" },
+    outputs: [{ glob: "**/prfaq-*.md", description: "PRFAQ document" }],
+    inputs: [],
+    learn: {
+      title: "PRFAQ",
+      whatItDoes: "Create a press release / FAQ document to crystallize the product vision.",
+      whenToUse: "When you want to work backwards from the customer experience to define what to build.",
+      whatItNeeds: "A product concept or product brief. Works best after initial research is complete.",
+      whatItProduces: "A PRFAQ document with a mock press release and frequently asked questions.",
+      proTip: "The PRFAQ format forces clarity \u2014 if you cannot write a compelling press release, refine your vision."
+    }
+  },
+  // Phase 2 — Planning (2 stations)
+  {
+    id: "create-prd",
+    label: "Create PRD",
+    phase: "planning",
+    command: "bmad-create-prd",
+    triggerCode: "prd",
+    agent: { name: "John", role: "Product Manager", skillId: "bmad-create-prd" },
+    outputs: [{ glob: "**/{PRD,prd}.md", description: "Product Requirements Document" }],
+    inputs: [{ workflowId: "product-brief", outputPattern: "**/product-brief.md", required: true }],
+    validation: "prd-validator",
+    learn: {
+      title: "Product Requirements",
+      whatItDoes: "Create a comprehensive PRD from the product brief with detailed requirements.",
+      whenToUse: "After the product brief is finalized and you are ready to define detailed requirements.",
+      whatItNeeds: "A completed product brief document.",
+      whatItProduces: "A Product Requirements Document with functional requirements, user stories, and constraints.",
+      proTip: "Run PRD validation afterward to catch gaps before moving to design and architecture."
+    }
+  },
+  {
+    id: "ux-design",
+    label: "UX Design",
+    phase: "planning",
+    command: "bmad-create-ux-design",
+    triggerCode: "ux",
+    agent: { name: "Sally", role: "UX Designer", skillId: "bmad-create-ux-design" },
+    outputs: [{ glob: "**/{ux-spec,ux-design-specification}.md", description: "UX design specification" }],
+    inputs: [{ workflowId: "create-prd", outputPattern: "**/{PRD,prd}.md", required: true }],
+    learn: {
+      title: "UX Design",
+      whatItDoes: "Plan UX patterns, wireframes, and design specifications from the PRD.",
+      whenToUse: "After the PRD is complete and you need to define the user experience and interface.",
+      whatItNeeds: "A completed PRD document.",
+      whatItProduces: "A UX design specification with component patterns, layouts, and interaction flows.",
+      proTip: "UX specs inform both architecture decisions and developer implementation \u2014 do not skip this step."
+    }
+  },
+  // Phase 3 — Solutioning (3 stations)
+  {
+    id: "architecture",
+    label: "Architecture",
+    phase: "solutioning",
+    command: "bmad-create-architecture",
+    triggerCode: "arch",
+    agent: { name: "Winston", role: "Architect", skillId: "bmad-create-architecture" },
+    outputs: [{ glob: "**/architecture.md", description: "Architecture design document" }],
+    inputs: [
+      { workflowId: "create-prd", outputPattern: "**/{PRD,prd}.md", required: true },
+      { workflowId: "ux-design", outputPattern: "**/{ux-spec,ux-design-specification}.md", required: false }
+    ],
+    learn: {
+      title: "Architecture",
+      whatItDoes: "Create architecture and solution design decisions for consistent AI agent implementation.",
+      whenToUse: "After PRD and optionally UX design are complete, before breaking work into epics.",
+      whatItNeeds: "A completed PRD. UX design specification is optional but recommended.",
+      whatItProduces: "An architecture document with ADRs, system design, and technical specifications.",
+      proTip: "Architecture decisions recorded here guide every developer agent in the implementation phase."
+    }
+  },
+  {
+    id: "epics-and-stories",
+    label: "Epics & Stories",
+    phase: "solutioning",
+    command: "bmad-create-epics-and-stories",
+    triggerCode: "epics",
+    agent: { name: "John", role: "Product Manager", skillId: "bmad-create-epics-and-stories" },
+    outputs: [{ glob: "**/epics.md", description: "Epic and story breakdown" }],
+    inputs: [
+      { workflowId: "create-prd", outputPattern: "**/{PRD,prd}.md", required: true },
+      { workflowId: "architecture", outputPattern: "**/architecture.md", required: true }
+    ],
+    learn: {
+      title: "Epics & Stories",
+      whatItDoes: "Break requirements into epics and user stories with acceptance criteria.",
+      whenToUse: "After architecture is defined and you are ready to plan the implementation work.",
+      whatItNeeds: "Completed PRD and architecture documents.",
+      whatItProduces: "An epics document with stories, acceptance criteria, and dependency ordering.",
+      proTip: "Well-written stories with clear ACs are the single biggest factor in implementation quality."
+    }
+  },
+  {
+    id: "implementation-readiness",
+    label: "Implementation Readiness",
+    phase: "solutioning",
+    command: "bmad-check-implementation-readiness",
+    triggerCode: "ready",
+    agent: { name: "Bob", role: "Scrum Master", skillId: "bmad-check-implementation-readiness" },
+    outputs: [{ glob: "**/readiness-check*.md", description: "Readiness check results" }],
+    inputs: [
+      { workflowId: "create-prd", outputPattern: "**/{PRD,prd}.md", required: true },
+      { workflowId: "architecture", outputPattern: "**/architecture.md", required: true },
+      { workflowId: "epics-and-stories", outputPattern: "**/epics.md", required: true }
+    ],
+    validation: "readiness-validator",
+    learn: {
+      title: "Implementation Readiness",
+      whatItDoes: "Validate that PRD, UX, Architecture, and Epics are complete and consistent.",
+      whenToUse: "Before starting implementation \u2014 this is your final quality gate.",
+      whatItNeeds: "Completed PRD, architecture, and epics documents.",
+      whatItProduces: "A readiness check report identifying gaps, inconsistencies, and blockers.",
+      proTip: "Catching issues here saves 10x the effort compared to discovering them during development."
+    }
+  },
+  // Phase 4 — Implementation (7 stations)
+  {
+    id: "sprint-planning",
+    label: "Sprint Planning",
+    phase: "implementation",
+    command: "bmad-sprint-planning",
+    triggerCode: "sprint",
+    agent: { name: "Bob", role: "Scrum Master", skillId: "bmad-sprint-planning" },
+    outputs: [{ glob: "**/sprint-status.yaml", description: "Sprint status tracking" }],
+    inputs: [{ workflowId: "epics-and-stories", outputPattern: "**/epics.md", required: true }],
+    learn: {
+      title: "Sprint Planning",
+      whatItDoes: "Generate sprint status tracking from epics to organize implementation work.",
+      whenToUse: "After implementation readiness is confirmed and you are ready to start building.",
+      whatItNeeds: "A completed epics document with story definitions.",
+      whatItProduces: "A sprint-status.yaml file tracking story progress through the sprint.",
+      proTip: "Sprint planning creates the backbone for all dev-story and status tracking workflows."
+    }
+  },
+  {
+    id: "create-story",
+    label: "Create Story",
+    phase: "implementation",
+    command: "bmad-create-story",
+    triggerCode: "story",
+    agent: { name: "Bob", role: "Scrum Master", skillId: "bmad-create-story" },
+    outputs: [{ glob: "**/story-*.md", description: "Story specification file" }],
+    inputs: [
+      { workflowId: "sprint-planning", outputPattern: "**/sprint-status.yaml", required: true },
+      { workflowId: "epics-and-stories", outputPattern: "**/epics.md", required: true }
+    ],
+    learn: {
+      title: "Create Story",
+      whatItDoes: "Create a dedicated story file with all the context an agent needs for implementation.",
+      whenToUse: "When the next story in the sprint is ready to be developed.",
+      whatItNeeds: "Sprint status file and epics document with the story to be created.",
+      whatItProduces: "A detailed story spec file with tasks, subtasks, acceptance criteria, and dev notes.",
+      proTip: "Stories created here are self-contained \u2014 the dev agent should not need to look elsewhere."
+    }
+  },
+  {
+    id: "dev-story",
+    label: "Dev Story",
+    phase: "implementation",
+    command: "bmad-dev-story",
+    triggerCode: "dev",
+    agent: { name: "Amelia", role: "Developer", skillId: "bmad-dev-story" },
+    outputs: [{ glob: "**/*.{ts,tsx,js,jsx}", description: "Working code and tests" }],
+    inputs: [{ workflowId: "create-story", outputPattern: "**/story-*.md", required: true }],
+    learn: {
+      title: "Dev Story",
+      whatItDoes: "Execute story implementation following a context-filled story spec file.",
+      whenToUse: "When a story file is created and marked ready-for-dev in the sprint status.",
+      whatItNeeds: "A completed story specification file with tasks and acceptance criteria.",
+      whatItProduces: "Working code, tests, and an updated story file with completion notes.",
+      proTip: "Use a different LLM for code review than the one that implemented the story."
+    }
+  },
+  {
+    id: "code-review",
+    label: "Code Review",
+    phase: "implementation",
+    command: "bmad-code-review",
+    triggerCode: "review",
+    agent: { name: "Amelia", role: "Developer", skillId: "bmad-code-review" },
+    outputs: [{ glob: "**/review-*.md", description: "Code review results" }],
+    inputs: [{ workflowId: "dev-story", outputPattern: "**/*.{ts,tsx}", required: true }],
+    learn: {
+      title: "Code Review",
+      whatItDoes: "Review code changes adversarially using parallel review layers for thorough analysis.",
+      whenToUse: "After dev-story completes and the story is in review status.",
+      whatItNeeds: "Completed story implementation with code changes and tests.",
+      whatItProduces: "A code review report with findings categorized by severity and actionable items.",
+      proTip: "Run code review with a different LLM than the one that wrote the code for unbiased findings."
+    }
+  },
+  {
+    id: "correct-course",
+    label: "Correct Course",
+    phase: "implementation",
+    command: "bmad-correct-course",
+    triggerCode: "course",
+    agent: { name: "Bob", role: "Scrum Master", skillId: "bmad-correct-course" },
+    outputs: [{ glob: "**/course-correction*.md", description: "Course correction plan" }],
+    inputs: [
+      { workflowId: "sprint-planning", outputPattern: "**/sprint-status.yaml", required: true }
+    ],
+    learn: {
+      title: "Correct Course",
+      whatItDoes: "Manage significant changes during sprint execution when priorities shift.",
+      whenToUse: "When requirements change, blockers arise, or sprint priorities need adjustment.",
+      whatItNeeds: "Current sprint status file and description of the change needed.",
+      whatItProduces: "A course correction plan with updated priorities and adjusted sprint scope.",
+      proTip: "Course corrections are normal \u2014 it is better to adjust early than to deliver the wrong thing."
+    }
+  },
+  {
+    id: "sprint-status",
+    label: "Sprint Status",
+    phase: "implementation",
+    command: "bmad-sprint-status",
+    triggerCode: "status",
+    agent: { name: "Bob", role: "Scrum Master", skillId: "bmad-sprint-status" },
+    outputs: [{ glob: "**/sprint-status.yaml", description: "Updated sprint status" }],
+    inputs: [
+      { workflowId: "sprint-planning", outputPattern: "**/sprint-status.yaml", required: true }
+    ],
+    learn: {
+      title: "Sprint Status",
+      whatItDoes: "Summarize sprint status and surface risks across all in-flight stories.",
+      whenToUse: "When you want a quick overview of sprint progress or need to identify blockers.",
+      whatItNeeds: "Current sprint status file.",
+      whatItProduces: "An updated sprint status summary with risk indicators and progress metrics.",
+      proTip: "Check sprint status regularly to catch drift before it becomes a problem."
+    }
+  },
+  {
+    id: "retrospective",
+    label: "Retrospective",
+    phase: "implementation",
+    command: "bmad-retrospective",
+    triggerCode: "retro",
+    agent: { name: "Bob", role: "Scrum Master", skillId: "bmad-retrospective" },
+    outputs: [{ glob: "**/retrospective*.md", description: "Retrospective findings" }],
+    inputs: [
+      { workflowId: "sprint-planning", outputPattern: "**/sprint-status.yaml", required: true }
+    ],
+    learn: {
+      title: "Retrospective",
+      whatItDoes: "Post-epic review to extract lessons learned and assess what went well or poorly.",
+      whenToUse: "After completing an epic to capture insights before starting the next one.",
+      whatItNeeds: "Sprint status file and completed epic stories for review.",
+      whatItProduces: "A retrospective report with lessons learned, improvements, and team insights.",
+      proTip: "Retrospectives improve every subsequent epic \u2014 do not skip them even when time is tight."
+    }
+  },
+  // Express Line (1 station)
+  {
+    id: "quick-dev",
+    label: "Quick Dev",
+    phase: "implementation",
+    command: "bmad-quick-dev",
+    triggerCode: "quick",
+    agent: { name: "Barry", role: "Quick Flow Solo Dev", skillId: "bmad-quick-dev" },
+    outputs: [
+      { glob: "**/spec-*.md", description: "Quick spec document" },
+      { glob: "**/*.{ts,tsx,js,jsx}", description: "Implementation code" }
+    ],
+    inputs: [],
+    isExpress: true,
+    learn: {
+      title: "Quick Dev",
+      whatItDoes: "Rapid spec and implementation for smaller tasks following existing project patterns.",
+      whenToUse: "For quick fixes, small features, or changes that do not warrant full sprint planning.",
+      whatItNeeds: "A description of what to build or fix. No prior documents required.",
+      whatItProduces: "A quick spec document and working implementation code with tests.",
+      proTip: "Quick Dev is for tasks that fit in a single session \u2014 use the full pipeline for larger work."
+    }
+  }
+];
+
+// ../shared/dist/definitions/dependencies.js
+var inputDependencyGraph = {
+  // Analysis — no upstream dependencies
+  brainstorming: [],
+  "domain-research": [],
+  "market-research": [],
+  "technical-research": [],
+  "product-brief": [],
+  prfaq: [],
+  // Planning — depends on analysis outputs
+  "create-prd": [
+    { workflowId: "product-brief", outputPattern: "**/product-brief.md", required: true }
+  ],
+  "ux-design": [{ workflowId: "create-prd", outputPattern: "**/{PRD,prd}.md", required: true }],
+  // Solutioning — depends on planning outputs
+  architecture: [
+    { workflowId: "create-prd", outputPattern: "**/{PRD,prd}.md", required: true },
+    { workflowId: "ux-design", outputPattern: "**/{ux-spec,ux-design-specification}.md", required: false }
+  ],
+  "epics-and-stories": [
+    { workflowId: "create-prd", outputPattern: "**/{PRD,prd}.md", required: true },
+    { workflowId: "architecture", outputPattern: "**/architecture.md", required: true }
+  ],
+  "implementation-readiness": [
+    { workflowId: "create-prd", outputPattern: "**/{PRD,prd}.md", required: true },
+    { workflowId: "architecture", outputPattern: "**/architecture.md", required: true },
+    { workflowId: "epics-and-stories", outputPattern: "**/epics.md", required: true }
+  ],
+  // Implementation — depends on solutioning outputs
+  "sprint-planning": [
+    { workflowId: "epics-and-stories", outputPattern: "**/epics.md", required: true }
+  ],
+  "create-story": [
+    { workflowId: "sprint-planning", outputPattern: "**/sprint-status.yaml", required: true },
+    { workflowId: "epics-and-stories", outputPattern: "**/epics.md", required: true }
+  ],
+  "dev-story": [{ workflowId: "create-story", outputPattern: "**/story-*.md", required: true }],
+  "code-review": [{ workflowId: "dev-story", outputPattern: "**/*.{ts,tsx}", required: true }],
+  "correct-course": [
+    { workflowId: "sprint-planning", outputPattern: "**/sprint-status.yaml", required: true }
+  ],
+  "sprint-status": [
+    { workflowId: "sprint-planning", outputPattern: "**/sprint-status.yaml", required: true }
+  ],
+  retrospective: [
+    { workflowId: "sprint-planning", outputPattern: "**/sprint-status.yaml", required: true }
+  ],
+  // Express — no dependencies
+  "quick-dev": []
+};
+
+// ../shared/dist/definitions/validators.js
+function createValidator(workflowId, rules) {
+  return {
+    workflowId,
+    rules: rules.map(({ id, description, severity }) => ({ id, description, severity })),
+    validate(content) {
+      const checks = rules.map((rule) => {
+        const passed = rule.test(content);
+        return {
+          ruleId: rule.id,
+          passed,
+          message: passed ? rule.description : `Missing: ${rule.description}`,
+          severity: rule.severity
+        };
+      });
+      return {
+        documentPath: "",
+        workflowId,
+        checks,
+        passed: checks.every((c) => c.passed),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  };
+}
+var heading = (text) => new RegExp(`^##\\s+(?:\\d+\\.?\\s+)?${text}`, "mi");
+var prdRules = [
+  {
+    id: "prd-exec-summary",
+    description: "Executive summary present",
+    severity: "error",
+    test: (content) => heading("Executive Summary").test(content)
+  },
+  {
+    id: "prd-functional-reqs",
+    description: "Functional requirements section",
+    severity: "error",
+    test: (content) => heading("Functional Requirements").test(content)
+  },
+  {
+    id: "prd-nonfunctional-reqs",
+    description: "Non-functional requirements section",
+    severity: "error",
+    test: (content) => heading("Non-?[Ff]unctional Requirements").test(content)
+  },
+  {
+    id: "prd-user-stories",
+    description: "User stories or use cases",
+    severity: "error",
+    test: (content) => heading("(User Stories|Use Cases|Acceptance Criteria|Stakeholders)").test(content)
+  },
+  {
+    id: "prd-success-metrics",
+    description: "Success metrics",
+    severity: "warning",
+    test: (content) => heading("(Success Metrics|Acceptance Criteria|Constraints)").test(content)
+  },
+  {
+    id: "prd-out-of-scope",
+    description: "Out of scope section",
+    severity: "warning",
+    test: (content) => heading("(Out of Scope|Non-?Goals|Constraints|Open Questions)").test(content)
+  }
+];
+var prdValidator = createValidator("prd-validator", prdRules);
+var architectureRules = [
+  {
+    id: "arch-tech-stack",
+    description: "Technology stack",
+    severity: "error",
+    test: (content) => heading("(Technology Stack|Tech Stack|Architecture.*Tech)").test(content) || /technology\s+stack/i.test(content)
+  },
+  {
+    id: "arch-adrs",
+    description: "ADRs present",
+    severity: "error",
+    test: (content) => /^###?\s+ADR-\d/mi.test(content) || heading("(Architecture Decision Records|Architectural Decisions|Core Architectural Decisions)").test(content)
+  },
+  {
+    id: "arch-system-components",
+    description: "System components",
+    severity: "error",
+    test: (content) => heading("(System Components?|Package Structure|Monorepo Structure)").test(content)
+  },
+  {
+    id: "arch-data-model",
+    description: "Data model",
+    severity: "warning",
+    test: (content) => heading("(Data Model|Data Flow|State Management)").test(content)
+  },
+  {
+    id: "arch-api-contracts",
+    description: "API contracts",
+    severity: "warning",
+    test: (content) => heading("(API Contracts?|API Design|Communication)").test(content) || /^###?\s+ADR-\d+.*API/mi.test(content)
+  },
+  {
+    id: "arch-deployment",
+    description: "Deployment architecture",
+    severity: "warning",
+    test: (content) => heading("(Deployment|Distribution|Packaging|Infrastructure)").test(content) || /^###?\s+ADR-\d+.*Packag/mi.test(content)
+  }
+];
+var architectureValidator = createValidator("architecture-validator", architectureRules);
+var storyRules = [
+  {
+    id: "story-acceptance-criteria",
+    description: "Acceptance criteria",
+    severity: "error",
+    test: (content) => heading("Acceptance Criteria").test(content)
+  },
+  {
+    id: "story-dependencies",
+    description: "Dependencies",
+    severity: "warning",
+    test: (content) => heading("Dependencies").test(content) || /dependencies:/mi.test(content)
+  },
+  {
+    id: "story-points",
+    description: "Story points",
+    severity: "info",
+    test: (content) => /story\s*points?\s*[:=]\s*\d/mi.test(content) || heading("Story Points").test(content)
+  }
+];
+var storyValidator = createValidator("story-validator", storyRules);
+var readinessRules = [
+  {
+    id: "readiness-prd-check",
+    description: "PRD review completed",
+    severity: "error",
+    test: (content) => /PRD/i.test(content) && /\b(pass|complete|review)/i.test(content)
+  },
+  {
+    id: "readiness-arch-check",
+    description: "Architecture review completed",
+    severity: "error",
+    test: (content) => /architecture/i.test(content) && /\b(pass|complete|review)/i.test(content)
+  },
+  {
+    id: "readiness-epics-check",
+    description: "Epics review completed",
+    severity: "error",
+    test: (content) => /epics?/i.test(content) && /\b(pass|complete|review)/i.test(content)
+  }
+];
+var readinessValidator = createValidator("readiness-validator", readinessRules);
+var documentValidators = [
+  prdValidator,
+  architectureValidator,
+  storyValidator,
+  readinessValidator
+];
+function getValidator(validatorId) {
+  return documentValidators.find((v) => v.workflowId === validatorId);
+}
+
+// ../server/dist/scanner.js
+var debug3 = debugFactory3("bmad-studio:scanner");
+var ProjectScanner = class {
+  mtimeCache = /* @__PURE__ */ new Map();
+  /**
+   * Full project scan — iterates all workflow definitions and computes status.
+   */
+  async scan(outputDir, rootDir) {
+    debug3("Starting full scan: outputDir=%s rootDir=%s", outputDir, rootDir);
+    const allFiles = await this.walkDir(outputDir, outputDir);
+    debug3("Found %d files in output directory", allFiles.length);
+    const workflows = {};
+    for (const wf of workflowDefinitions) {
+      workflows[wf.id] = await this.computeWorkflowState(wf, allFiles, outputDir);
+    }
+    for (const wf of workflowDefinitions) {
+      workflows[wf.id].dependenciesSatisfied = this.checkDependencies(wf.id, workflows);
+    }
+    const expressLine = workflowDefinitions.filter((wf) => wf.isExpress).map((wf) => wf.id);
+    const gitAvailable = await this.checkGitAvailable(rootDir);
+    const recommendation = this.getNextRecommendation(workflows);
+    const projectName = rootDir.split("/").pop() ?? "unknown";
+    const state = {
+      projectName,
+      projectRoot: rootDir,
+      outputDir,
+      workflows,
+      phases: [...phaseDefinitions],
+      expressLine,
+      gitAvailable,
+      recommendation,
+      lastScanned: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    debug3("Scan complete: %d workflows evaluated", Object.keys(workflows).length);
+    return state;
+  }
+  /**
+   * Incremental single-workflow rescan.
+   */
+  async scanWorkflow(workflowId, outputDir, currentState) {
+    const wfDef = workflowDefinitions.find((w) => w.id === workflowId);
+    if (!wfDef) {
+      debug3("Unknown workflow: %s", workflowId);
+      return currentState;
+    }
+    const allFiles = await this.walkDir(outputDir, outputDir);
+    const newState = await this.computeWorkflowState(wfDef, allFiles, outputDir);
+    newState.dependenciesSatisfied = this.checkDependencies(workflowId, {
+      ...currentState.workflows,
+      [workflowId]: newState
+    });
+    const workflows = { ...currentState.workflows, [workflowId]: newState };
+    for (const wf of workflowDefinitions) {
+      const deps = inputDependencyGraph[wf.id] ?? [];
+      if (deps.some((d) => d.workflowId === workflowId)) {
+        workflows[wf.id] = {
+          ...workflows[wf.id],
+          dependenciesSatisfied: this.checkDependencies(wf.id, workflows)
+        };
+      }
+    }
+    return {
+      ...currentState,
+      workflows,
+      recommendation: this.getNextRecommendation(workflows),
+      lastScanned: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Compute the status of a single workflow based on its output glob patterns.
+   */
+  async computeWorkflowState(wfDef, allFiles, outputDir) {
+    const outputs = [];
+    let matchedCount = 0;
+    const totalPatterns = wfDef.outputs.length;
+    for (const outputPattern of wfDef.outputs) {
+      const matcher = picomatch(outputPattern.glob);
+      let patternMatched = false;
+      for (const filePath of allFiles) {
+        const relPath = filePath;
+        if (matcher(relPath)) {
+          patternMatched = true;
+          const absPath = join6(outputDir, filePath);
+          const fileStat = await this.statFile(absPath);
+          outputs.push({
+            path: filePath,
+            exists: true,
+            lastModified: fileStat?.mtime,
+            sizeBytes: fileStat?.size
+          });
+        }
+      }
+      if (patternMatched) {
+        matchedCount++;
+      }
+    }
+    let status;
+    let progress = 0;
+    if (matchedCount === 0) {
+      status = "not-started";
+      progress = 0;
+    } else if (wfDef.validation) {
+      if (matchedCount === totalPatterns) {
+        status = "completed";
+        progress = 100;
+      } else {
+        status = "in-progress";
+        progress = Math.round(matchedCount / totalPatterns * 100);
+      }
+    } else {
+      if (matchedCount === totalPatterns) {
+        status = "completed";
+        progress = 100;
+      } else {
+        status = "in-progress";
+        progress = Math.round(matchedCount / totalPatterns * 100);
+      }
+    }
+    let validation;
+    if (wfDef.validation && outputs.length > 0) {
+      const validator = getValidator(wfDef.validation);
+      if (validator) {
+        const firstOutput = outputs.find((o) => o.exists);
+        if (firstOutput) {
+          const absPath = join6(outputDir, firstOutput.path);
+          const content = await this.readFileCached(absPath);
+          if (content) {
+            const result = validator.validate(content);
+            const totalChecks = result.checks.length;
+            const passingChecks = result.checks.filter((c) => c.passed).length;
+            const score = totalChecks > 0 ? Math.round(passingChecks / totalChecks * 100) : 0;
+            validation = { checks: result.checks, score };
+          }
+        }
+      }
+    }
+    return {
+      workflowId: wfDef.id,
+      status,
+      outputs,
+      dependenciesSatisfied: true,
+      // computed later
+      progress,
+      validation
+    };
+  }
+  /**
+   * Check if all required upstream dependencies are satisfied for a workflow.
+   */
+  checkDependencies(workflowId, workflows) {
+    const deps = inputDependencyGraph[workflowId] ?? [];
+    for (const dep of deps) {
+      if (!dep.required)
+        continue;
+      const upstream = workflows[dep.workflowId];
+      if (!upstream || upstream.status === "not-started") {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Deterministic next-step recommendation algorithm.
+   * Phase order: planning → solutioning → implementation (skip analysis).
+   */
+  getNextRecommendation(workflows) {
+    const phaseOrder = [
+      "planning",
+      "solutioning",
+      "implementation"
+    ];
+    for (const phaseId of phaseOrder) {
+      for (const wfDef of workflowDefinitions) {
+        if (wfDef.phase !== phaseId || wfDef.isExpress)
+          continue;
+        const state = workflows[wfDef.id];
+        if (!state)
+          continue;
+        if (state.status === "in-progress" && state.dependenciesSatisfied) {
+          return wfDef.id;
+        }
+      }
+    }
+    for (const phaseId of phaseOrder) {
+      for (const wfDef of workflowDefinitions) {
+        if (wfDef.phase !== phaseId || wfDef.isExpress)
+          continue;
+        const state = workflows[wfDef.id];
+        if (!state)
+          continue;
+        if (state.status === "not-started" && state.dependenciesSatisfied) {
+          return wfDef.id;
+        }
+      }
+    }
+    for (const wfDef of workflowDefinitions) {
+      if (!wfDef.isExpress)
+        continue;
+      const state = workflows[wfDef.id];
+      if (!state)
+        continue;
+      if ((state.status === "in-progress" || state.status === "not-started") && state.dependenciesSatisfied) {
+        return wfDef.id;
+      }
+    }
+    return null;
+  }
+  /**
+   * Recursively walk a directory and return all file paths relative to baseDir.
+   */
+  async walkDir(dir, baseDir) {
+    const files = [];
+    try {
+      const entries = await readdir2(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join6(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (entry.name.startsWith("."))
+            continue;
+          const subFiles = await this.walkDir(fullPath, baseDir);
+          files.push(...subFiles);
+        } else if (entry.isFile()) {
+          files.push(relative(baseDir, fullPath));
+        }
+      }
+    } catch (err) {
+      debug3("Error walking directory %s: %O", dir, err);
+    }
+    return files;
+  }
+  /**
+   * Stat a file with mtime caching — skip re-read if mtime unchanged.
+   */
+  async statFile(absPath) {
+    try {
+      const s = await stat4(absPath);
+      const mtime = s.mtime.toISOString();
+      return { mtime, size: s.size };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Read a file with mtime-based caching. Returns cached content if mtime unchanged.
+   */
+  async readFileCached(absPath) {
+    try {
+      const s = await stat4(absPath);
+      const mtime = s.mtime.toISOString();
+      const cached = this.mtimeCache.get(absPath);
+      if (cached && cached.mtime === mtime) {
+        debug3("Cache hit: %s", absPath);
+        return cached.content;
+      }
+      debug3("Cache miss: %s", absPath);
+      const content = await readFile5(absPath, "utf-8");
+      this.mtimeCache.set(absPath, { mtime, content });
+      return content;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if .git directory exists at the project root.
+   */
+  async checkGitAvailable(rootDir) {
+    try {
+      const s = await stat4(join6(rootDir, ".git"));
+      return s.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+};
+
+// ../server/dist/websocket.js
+import { WebSocketServer, WebSocket } from "ws";
+import debugFactory4 from "debug";
+var debug4 = debugFactory4("bmad-studio:websocket");
+var WebSocketBroadcaster = class {
+  scanner;
+  outputDir;
+  rootDir;
+  getState;
+  wss;
+  constructor(server, scanner, outputDir, rootDir, getState) {
+    this.scanner = scanner;
+    this.outputDir = outputDir;
+    this.rootDir = rootDir;
+    this.getState = getState;
+    this.wss = new WebSocketServer({ server, path: "/ws" });
+    this.wss.on("connection", (ws) => {
+      debug4("Client connected (total: %d)", this.wss.clients.size);
+      void this.sendInitialState(ws);
+      ws.on("error", (err) => {
+        debug4("Client error: %O", err);
+      });
+      ws.on("close", () => {
+        debug4("Client disconnected (remaining: %d)", this.wss.clients.size);
+      });
+    });
+    this.wss.on("error", (err) => {
+      debug4("WebSocketServer error: %O", err);
+    });
+  }
+  async sendInitialState(ws) {
+    try {
+      let state = this.getState();
+      if (!state) {
+        state = await this.scanner.scan(this.outputDir, this.rootDir);
+      }
+      const event = { type: "project:state", payload: state };
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(event));
+        debug4("Sent project:state to new client");
+      }
+    } catch (err) {
+      debug4("Error sending initial state: %O", err);
+    }
+  }
+  broadcast(event) {
+    const data = JSON.stringify(event);
+    let sent = 0;
+    for (const client of this.wss.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data);
+        sent++;
+      }
+    }
+    debug4("Broadcast %s to %d clients", event.type, sent);
+  }
+  broadcastWorkflowUpdate(workflowState) {
+    this.broadcast({ type: "workflow:updated", payload: workflowState });
+  }
+  broadcastMapRefresh(workflows) {
+    this.broadcast({ type: "map:refresh", payload: workflows });
+  }
+  broadcastSprintUpdate(sprintStatus) {
+    this.broadcast({ type: "sprint:updated", payload: sprintStatus });
+  }
+  close() {
+    debug4("Closing WebSocket server");
+    for (const client of this.wss.clients) {
+      client.close();
+    }
+    this.wss.close();
+  }
+};
+
+// ../server/dist/watcher.js
+import { join as join7, relative as relative2 } from "path";
+import picomatch2 from "picomatch";
+import debugFactory5 from "debug";
+var debug5 = debugFactory5("bmad-studio:watcher");
+async function watchDir(path) {
+  const { watch } = await import("chokidar");
+  return watch(path, {
+    ignoreInitial: true,
+    ignored: /(^|[/\\])\../,
+    // ignore dotfiles
+    persistent: true
+  });
+}
+var FileWatcher = class {
+  outputDir;
+  rootDir;
+  scanner;
+  broadcaster;
+  watcher = null;
+  workflowDebounceTimers = /* @__PURE__ */ new Map();
+  mapDebounceTimer = null;
+  heartbeatTimer = null;
+  sprintDebounceTimer = null;
+  workflowMatchers;
+  currentState = null;
+  constructor(outputDir, rootDir, scanner, broadcaster) {
+    this.outputDir = outputDir;
+    this.rootDir = rootDir;
+    this.scanner = scanner;
+    this.broadcaster = broadcaster;
+    this.workflowMatchers = workflowDefinitions.map((wf) => ({
+      id: wf.id,
+      matchers: wf.outputs.map((o) => picomatch2(o.glob))
+    }));
+  }
+  async start() {
+    debug5("Starting file watcher on %s", this.outputDir);
+    this.currentState = await this.scanner.scan(this.outputDir, this.rootDir);
+    debug5("Initial scan complete: %d workflows", Object.keys(this.currentState.workflows).length);
+    this.watcher = await watchDir(this.outputDir);
+    this.watcher.on("add", (path) => this.handleFileEvent(path));
+    this.watcher.on("change", (path) => this.handleFileEvent(path));
+    this.watcher.on("unlink", (path) => this.handleFileEvent(path));
+    this.watcher.on("error", (err) => debug5("Watcher error: %O", err));
+    this.startHeartbeat();
+  }
+  async stop() {
+    debug5("Stopping file watcher");
+    for (const timer of this.workflowDebounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.workflowDebounceTimers.clear();
+    if (this.mapDebounceTimer) {
+      clearTimeout(this.mapDebounceTimer);
+      this.mapDebounceTimer = null;
+    }
+    if (this.sprintDebounceTimer) {
+      clearTimeout(this.sprintDebounceTimer);
+      this.sprintDebounceTimer = null;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+  }
+  getState() {
+    return this.currentState;
+  }
+  handleFileEvent(absPath) {
+    const relPath = relative2(this.outputDir, absPath);
+    debug5("File event: %s", relPath);
+    if (relPath === join7("implementation-artifacts", "sprint-status.yaml") || relPath === "sprint-status.yaml") {
+      this.debounceSprintUpdate();
+    }
+    const affectedWorkflows = this.identifyWorkflows(relPath);
+    if (affectedWorkflows.length === 0) {
+      debug5("No workflow matched for %s", relPath);
+      return;
+    }
+    debug5("Affected workflows: %o", affectedWorkflows);
+    for (const workflowId of affectedWorkflows) {
+      this.debounceWorkflow(workflowId);
+    }
+  }
+  identifyWorkflows(relPath) {
+    return this.workflowMatchers.filter((wm) => wm.matchers.some((m) => m(relPath))).map((wm) => wm.id);
+  }
+  debounceWorkflow(workflowId) {
+    const existing = this.workflowDebounceTimers.get(workflowId);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const timer = setTimeout(() => {
+      this.workflowDebounceTimers.delete(workflowId);
+      void this.rescanWorkflow(workflowId);
+    }, 500);
+    this.workflowDebounceTimers.set(workflowId, timer);
+  }
+  async rescanWorkflow(workflowId) {
+    if (!this.currentState)
+      return;
+    debug5("Rescanning workflow: %s", workflowId);
+    const previousStatus = this.currentState.workflows[workflowId]?.status;
+    this.currentState = await this.scanner.scanWorkflow(workflowId, this.outputDir, this.currentState);
+    const newStatus = this.currentState.workflows[workflowId]?.status;
+    if (newStatus !== previousStatus) {
+      debug5("Workflow %s status changed: %s \u2192 %s", workflowId, previousStatus, newStatus);
+      this.broadcaster.broadcastWorkflowUpdate(this.currentState.workflows[workflowId]);
+    }
+    this.resetHeartbeat();
+    this.debounceMapRefresh();
+  }
+  debounceSprintUpdate() {
+    if (this.sprintDebounceTimer) {
+      clearTimeout(this.sprintDebounceTimer);
+    }
+    this.sprintDebounceTimer = setTimeout(() => {
+      this.sprintDebounceTimer = null;
+      void this.rescanSprint();
+    }, 500);
+  }
+  async rescanSprint() {
+    debug5("Rescanning sprint status");
+    try {
+      const sprintStatus = await parseSprintStatus(this.outputDir);
+      if (sprintStatus) {
+        this.broadcaster.broadcastSprintUpdate(sprintStatus);
+      }
+    } catch (err) {
+      debug5("Sprint status rescan failed: %O", err);
+    }
+  }
+  debounceMapRefresh() {
+    if (this.mapDebounceTimer) {
+      clearTimeout(this.mapDebounceTimer);
+    }
+    this.mapDebounceTimer = setTimeout(() => {
+      this.mapDebounceTimer = null;
+      if (this.currentState) {
+        debug5("Map-wide debounce fired, broadcasting map:refresh");
+        this.broadcaster.broadcastMapRefresh(this.currentState.workflows);
+      }
+    }, 2e3);
+  }
+  startHeartbeat() {
+    this.heartbeatTimer = setInterval(() => {
+      void this.heartbeatScan();
+    }, 3e4);
+  }
+  resetHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+    }
+    this.startHeartbeat();
+  }
+  async heartbeatScan() {
+    debug5("Heartbeat: running full scan");
+    this.currentState = await this.scanner.scan(this.outputDir, this.rootDir);
+    this.broadcaster.broadcastMapRefresh(this.currentState.workflows);
+  }
+};
+
+// ../server/dist/index.js
+var debug6 = debugFactory6("bmad-studio:server");
+function findProjectRoot(startDir) {
+  let dir = startDir;
+  let bmadOutputCandidate = null;
+  while (dir !== dirname2(dir)) {
+    if (existsSync(join8(dir, ".git"))) {
+      return dir;
+    }
+    if (!bmadOutputCandidate && existsSync(join8(dir, "_bmad-output"))) {
+      bmadOutputCandidate = dir;
+    }
+    dir = dirname2(dir);
+  }
+  return bmadOutputCandidate ?? startDir;
+}
+async function createServer(config) {
+  const port = config.port ?? 5400;
+  const rootDir = findProjectRoot(process.cwd());
+  debug6("Project root: %s", rootDir);
+  const outputDir = await resolveOutputDir(rootDir, config.outputDir);
+  debug6("Detected outputDir: %s", outputDir ?? "(unconfigured)");
+  const scanner = new ProjectScanner();
+  let cachedState = null;
+  const app = express();
+  app.use(express.json());
+  app.use("/api", createApiRouter({
+    outputDir,
+    rootDir,
+    scanner,
+    getCachedState: () => cachedState
+  }));
+  if (config.uiDistPath && existsSync(config.uiDistPath)) {
+    debug6("Serving UI from %s", config.uiDistPath);
+    app.use(express.static(config.uiDistPath));
+    app.use((_req, res) => {
+      res.sendFile(join8(config.uiDistPath, "index.html"));
+    });
+  }
+  const server = http.createServer(app);
+  let watcher;
+  let broadcaster;
+  return new Promise((resolve4, reject) => {
+    server.on("error", reject);
+    server.listen(port, "127.0.0.1", async () => {
+      debug6("Server listening on http://127.0.0.1:%d", port);
+      if (outputDir) {
+        try {
+          cachedState = await scanner.scan(outputDir, rootDir);
+          debug6("Initial scan complete: %d workflows", Object.keys(cachedState.workflows).length);
+        } catch (err) {
+          debug6("Initial scan failed: %O", err);
+        }
+        broadcaster = new WebSocketBroadcaster(server, scanner, outputDir, rootDir, () => cachedState);
+        watcher = new FileWatcher(outputDir, rootDir, scanner, broadcaster);
+        watcher.start();
+        debug6("FileWatcher and WebSocketBroadcaster started");
+      }
+      resolve4({
+        server,
+        watcher,
+        broadcaster,
+        close: async () => {
+          watcher?.stop();
+          broadcaster?.close();
+          return new Promise((res, rej) => {
+            server.close((err) => err ? rej(err) : res());
+          });
+        }
+      });
+    });
+  });
+}
+
+// src/cleanup.ts
+function registerCleanupHandlers(port) {
+  let cleaned = false;
+  function cleanup() {
+    if (cleaned) return;
+    cleaned = true;
+    unregisterInstance(port);
+  }
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+  process.on("exit", cleanup);
+  process.on("uncaughtException", (err) => {
+    console.error("Uncaught exception:", err);
+    cleanup();
+    process.exit(1);
+  });
+}
+
+// src/launcher.ts
+async function pingInstance(port) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 1e3);
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/api/capabilities`, {
+      signal: controller.signal
+    });
+    return response.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function killInstance(entry) {
+  try {
+    process.kill(entry.pid, "SIGTERM");
+  } catch {
+  }
+  unregisterInstance(entry.port);
+}
+async function openBrowser(port) {
+  const { default: open } = await import("open");
+  await open(`http://localhost:${port}`);
+}
+async function launch(opts) {
+  const cwd = resolve3(process.cwd());
+  const theme = opts.dark ? "dark" : opts.light ? "light" : void 0;
+  let port;
+  if (opts.port) {
+    port = Number(opts.port);
+  } else {
+    port = await findAvailablePort();
+  }
+  const existing = findInstanceByProject(cwd);
+  if (existing) {
+    if (opts.new) {
+      killInstance(existing);
+    } else {
+      const alive = await pingInstance(existing.port);
+      if (alive) {
+        console.log(`Reusing existing BMAD Studio instance on port ${existing.port}`);
+        if (opts.open) {
+          await openBrowser(existing.port);
+        } else {
+          console.log(`BMAD Studio: http://localhost:${existing.port}`);
+        }
+        return;
+      } else {
+        unregisterInstance(existing.port);
+      }
+    }
+  }
+  const __dirname = dirname3(fileURLToPath(import.meta.url));
+  const uiDistCandidate = resolve3(__dirname, "..", "ui-dist");
+  const uiDistPath = existsSync2(uiDistCandidate) ? uiDistCandidate : void 0;
+  const config = {
+    port,
+    outputDir: opts.outputDir,
+    noOpen: !opts.open,
+    theme,
+    isNew: opts.new,
+    uiDistPath
+  };
+  try {
+    await createServer(config);
+    registerInstance({
+      port,
+      pid: process.pid,
+      projectPath: cwd,
+      startTime: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    registerCleanupHandlers(port);
+    if (opts.open) {
+      await openBrowser(port);
+    } else {
+      console.log(`BMAD Studio: http://localhost:${port}`);
+    }
+  } catch (err) {
+    console.error("Failed to start BMAD Studio:", err);
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var pkg = JSON.parse(
+  readFileSync2(new URL("../package.json", import.meta.url), "utf-8")
+);
+function formatUptime(startTime) {
+  const diff = Date.now() - new Date(startTime).getTime();
+  const minutes = Math.floor(diff / 6e4);
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  if (hours > 0) return `${hours}h ${remainingMinutes}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return "<1m";
+}
+var program = new Command();
+program.name("bmad-studio").version(pkg.version).description("BMAD Studio \u2014 Visual workflow dashboard for the BMAD Method").option("--port <number>", "server port").option("--no-open", "skip opening the browser").option("--dark", "use dark theme").option("--light", "use light theme").option("--output-dir <path>", "output directory path").option("--new", "kill existing instance and start fresh").action(async (opts) => {
+  await launch(opts);
+});
+program.command("list").description("List running BMAD Studio instances").action(() => {
+  const entries = cleanStaleEntries(readInstances());
+  if (entries.length === 0) {
+    console.log("No running BMAD Studio instances");
+    return;
+  }
+  console.log("\nBMAD Studio Instances:\n");
+  console.log("  PORT   PID       PROJECT                                    UPTIME");
+  for (const entry of entries) {
+    const port = String(entry.port).padEnd(5);
+    const pid = String(entry.pid).padEnd(8);
+    const project = entry.projectPath.padEnd(40);
+    const uptime = formatUptime(entry.startTime);
+    console.log(`  ${port}  ${pid}  ${project}  ${uptime}`);
+  }
+  console.log(`
+Total: ${entries.length} running instance${entries.length === 1 ? "" : "s"}`);
+});
+program.command("stop [port]").description('Stop a running BMAD Studio instance (use "all" to stop all)').action((portArg) => {
+  if (portArg === "all") {
+    const entries2 = cleanStaleEntries(readInstances());
+    if (entries2.length === 0) {
+      console.log("No running BMAD Studio instances to stop");
+      return;
+    }
+    for (const entry2 of entries2) {
+      try {
+        process.kill(entry2.pid, "SIGTERM");
+        console.log(`Stopped instance on port ${entry2.port} (PID ${entry2.pid})`);
+      } catch {
+        console.log(`Instance on port ${entry2.port} (PID ${entry2.pid}) already stopped`);
+      }
+      unregisterInstance(entry2.port);
+    }
+    console.log(`Stopped ${entries2.length} instance${entries2.length === 1 ? "" : "s"}`);
+    return;
+  }
+  if (!portArg) {
+    console.error("Usage: bmad-studio stop <port> or bmad-studio stop all");
+    process.exit(1);
+  }
+  const port = Number(portArg);
+  if (Number.isNaN(port)) {
+    console.error(`Invalid port: ${portArg}`);
+    process.exit(1);
+  }
+  const entries = cleanStaleEntries(readInstances());
+  const entry = entries.find((e) => e.port === port);
+  if (!entry) {
+    console.log(`No instance found on port ${port}`);
+    return;
+  }
+  try {
+    process.kill(entry.pid, "SIGTERM");
+    console.log(`Stopped instance on port ${port} (PID ${entry.pid})`);
+  } catch {
+    console.log(`Instance on port ${port} (PID ${entry.pid}) already stopped`);
+  }
+  unregisterInstance(port);
+});
+program.parse();
+export {
+  program
+};