@beastmode-develeap/beastmode 0.1.265 → 0.1.267

package/dist/index.js

@@ -95,17 +95,36 @@ var init_schemas = __esm({
     });
     DeployConfigSchema = z.object({
       target: z.string().default("pr-only"),
+      verify_port: z.number().int().default(3001),
       config: z.record(z.unknown()).default({})
     });
     ProjectConfigSchema = z.object({
       name: z.string(),
-      repo: z.string().optional(),
       path: z.string(),
+      github: z.object({
+        repo: z.string().default(""),
+        default_branch: z.string().default("main")
+      }).default({}),
+      board: z.object({
+        id: z.number().nullable().default(null),
+        url: z.string().default("http://127.0.0.1:8080"),
+        auto_created: z.boolean().default(false)
+      }).default({}),
       stack: StackConfigSchema,
       deploy: DeployConfigSchema.default({}),
       pipeline: z.record(z.unknown()).default({}),
       models: z.record(z.string()).default({}),
-      plugins: z.array(z.string()).default([])
+      plugins: z.array(z.string()).default([]),
+      slots: z.object({
+        max: z.number().nullable().default(null)
+      }).default({}),
+      infra: z.object({
+        credentials: z.object({
+          mode: z.string().default("factory")
+        }).default({}),
+        state_backend: z.string().default("auto")
+      }).default({}),
+      registered_at: z.string().default("")
     });
     FactoryIdentitySchema = z.object({
       factory_name: z.string(),
@@ -800,8 +819,8 @@ var init_export_adapter = __esm({
 });
 
 // src/engine/stack-detector.ts
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, relative, basename, extname } from "path";
 function readFileSafe(path) {
   try {
     return readFileSync(path, "utf-8");
@@ -875,11 +894,362 @@ function extractGitRemote(projectDir) {
   if (httpsMatch) return httpsMatch[1].replace(/\.git$/, "");
   return null;
 }
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function listDirs(parent) {
+  try {
+    return readdirSync(parent, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+}
+function hasAnyManifest(dir) {
+  return PACKAGE_MANIFESTS.some((m) => existsSync(join(dir, m)));
+}
+function expandGlob(rootDir, pattern) {
+  let pat = pattern.replace(/^\.\//, "");
+  pat = pat.replace(/\/+$/, "");
+  if (!pat) return [];
+  const parts = pat.split("/");
+  let candidates = [""];
+  for (const part of parts) {
+    const next = [];
+    for (const cand of candidates) {
+      const abs = cand ? join(rootDir, cand) : rootDir;
+      if (part === "*" || part === "**") {
+        const children = listDirs(abs).filter((name) => !IGNORE_DIRS.has(name));
+        for (const child of children) {
+          next.push(cand ? join(cand, child) : child);
+        }
+      } else if (part.includes("*")) {
+        const regex = new RegExp(
+          "^" + part.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$"
+        );
+        const children = listDirs(abs).filter((name) => regex.test(name));
+        for (const child of children) {
+          next.push(cand ? join(cand, child) : child);
+        }
+      } else {
+        const candidate = cand ? join(cand, part) : part;
+        if (isDirectory(join(rootDir, candidate))) {
+          next.push(candidate);
+        }
+      }
+    }
+    candidates = next;
+  }
+  return candidates.filter((c) => hasAnyManifest(join(rootDir, c)));
+}
+function parsePnpmWorkspaceYaml(content) {
+  const lines = content.split(/\r?\n/);
+  const globs = [];
+  let inPackages = false;
+  for (const raw of lines) {
+    const line = raw.replace(/\s+$/, "");
+    if (/^packages\s*:/.test(line)) {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages) {
+      if (line && !/^\s/.test(line) && !line.startsWith("-")) {
+        inPackages = false;
+        continue;
+      }
+      const m = line.match(/^\s*-\s*['"]?([^'"#]+?)['"]?\s*$/);
+      if (m) {
+        const val = m[1].trim();
+        if (val) globs.push(val);
+      }
+    }
+  }
+  return globs;
+}
+function parseGoWorkUseBlock(content) {
+  const dirs = [];
+  const singleLineMatches = content.matchAll(/^\s*use\s+(\S+)\s*$/gm);
+  for (const m of singleLineMatches) {
+    dirs.push(m[1].replace(/^\.\//, ""));
+  }
+  const blockMatch = content.match(/use\s*\(([\s\S]*?)\)/);
+  if (blockMatch) {
+    for (const raw of blockMatch[1].split(/\r?\n/)) {
+      const line = raw.trim();
+      if (!line || line.startsWith("//")) continue;
+      const cleaned = line.replace(/\/\/.*$/, "").trim();
+      if (cleaned) dirs.push(cleaned.replace(/^\.\//, ""));
+    }
+  }
+  return dirs;
+}
+function parseCargoWorkspaceMembers(content) {
+  const wsIdx = content.search(/^\s*\[workspace\]/m);
+  if (wsIdx < 0) return [];
+  const rest = content.slice(wsIdx);
+  const m = rest.match(/members\s*=\s*\[([\s\S]*?)\]/);
+  if (!m) return [];
+  const inner = m[1];
+  const members = [];
+  for (const raw of inner.split(",")) {
+    const cleaned = raw.replace(/#.*$/, "").trim().replace(/^['"]|['"]$/g, "");
+    if (cleaned) members.push(cleaned);
+  }
+  return members;
+}
+function parseGradleInclude(content) {
+  const modules = [];
+  const re = /include\s*(?:\(\s*)?([^)\n]+?)(?:\s*\))?\s*$/gm;
+  let match;
+  while ((match = re.exec(content)) !== null) {
+    const args = match[1];
+    const stringMatches = args.matchAll(/['"]([^'"]+)['"]/g);
+    for (const sm of stringMatches) {
+      const raw = sm[1].trim();
+      const path = raw.replace(/^:+/, "").replace(/:/g, "/");
+      if (path) modules.push(path);
+    }
+  }
+  return modules;
+}
+function parseMavenModules(content) {
+  const modules = [];
+  const re = /<module>\s*([^<\s]+)\s*<\/module>/g;
+  let match;
+  while ((match = re.exec(content)) !== null) {
+    modules.push(match[1].trim());
+  }
+  return modules;
+}
+function detectWorkspaces(projectDir) {
+  const pnpmYaml = readFileSafe(join(projectDir, "pnpm-workspace.yaml"));
+  if (pnpmYaml !== null) {
+    const globs = parsePnpmWorkspaceYaml(pnpmYaml);
+    const packages = [];
+    for (const g of globs) {
+      packages.push(...expandGlob(projectDir, g));
+    }
+    return { type: "pnpm", packages: dedupe(packages) };
+  }
+  if (existsSync(join(projectDir, "nx.json"))) {
+    const packages = [];
+    for (const parent of ["packages", "apps", "libs"]) {
+      const parentDir = join(projectDir, parent);
+      if (!isDirectory(parentDir)) continue;
+      for (const child of listDirs(parentDir)) {
+        const childDir = join(parentDir, child);
+        if (existsSync(join(childDir, "project.json")) || hasAnyManifest(childDir)) {
+          packages.push(join(parent, child));
+        }
+      }
+    }
+    return { type: "nx", packages: dedupe(packages) };
+  }
+  const hasTurbo = existsSync(join(projectDir, "turbo.json"));
+  const pkgContent = readFileSafe(join(projectDir, "package.json"));
+  if (pkgContent) {
+    const pkg = parseJsonSafe(pkgContent);
+    if (pkg) {
+      let workspaces;
+      const ws = pkg.workspaces;
+      if (Array.isArray(ws)) {
+        workspaces = ws.filter((v) => typeof v === "string");
+      } else if (ws && typeof ws === "object" && Array.isArray(ws.packages)) {
+        workspaces = ws.packages.filter(
+          (v) => typeof v === "string"
+        );
+      }
+      if (workspaces && workspaces.length > 0) {
+        const packages = [];
+        for (const g of workspaces) {
+          packages.push(...expandGlob(projectDir, g));
+        }
+        return {
+          type: hasTurbo ? "turbo" : "npm",
+          packages: dedupe(packages)
+        };
+      }
+    }
+  }
+  const goWork = readFileSafe(join(projectDir, "go.work"));
+  if (goWork !== null) {
+    const dirs = parseGoWorkUseBlock(goWork);
+    const packages = dirs.filter(
+      (d) => existsSync(join(projectDir, d, "go.mod"))
+    );
+    return { type: "go", packages: dedupe(packages) };
+  }
+  const cargoToml = readFileSafe(join(projectDir, "Cargo.toml"));
+  if (cargoToml !== null && /^\s*\[workspace\]/m.test(cargoToml)) {
+    const members = parseCargoWorkspaceMembers(cargoToml);
+    const packages = [];
+    for (const m of members) {
+      if (m.includes("*")) {
+        packages.push(...expandGlob(projectDir, m));
+      } else if (existsSync(join(projectDir, m, "Cargo.toml"))) {
+        packages.push(m);
+      }
+    }
+    return { type: "cargo", packages: dedupe(packages) };
+  }
+  const gradleSettings = readFileSafe(join(projectDir, "settings.gradle")) ?? readFileSafe(join(projectDir, "settings.gradle.kts"));
+  if (gradleSettings !== null) {
+    const modules = parseGradleInclude(gradleSettings);
+    const packages = modules.filter((m) => isDirectory(join(projectDir, m)));
+    if (packages.length > 0) {
+      return { type: "gradle", packages: dedupe(packages) };
+    }
+  }
+  const pom = readFileSafe(join(projectDir, "pom.xml"));
+  if (pom !== null) {
+    const modules = parseMavenModules(pom);
+    const packages = modules.filter(
+      (m) => existsSync(join(projectDir, m, "pom.xml"))
+    );
+    if (packages.length > 0) {
+      return { type: "maven", packages: dedupe(packages) };
+    }
+  }
+  return null;
+}
+function dedupe(items) {
+  return Array.from(new Set(items));
+}
+function extractPackageName(packageDir) {
+  const pkgContent = readFileSafe(join(packageDir, "package.json"));
+  if (pkgContent) {
+    const pkg = parseJsonSafe(pkgContent);
+    if (pkg && typeof pkg.name === "string" && pkg.name) return pkg.name;
+  }
+  const cargoToml = readFileSafe(join(packageDir, "Cargo.toml"));
+  if (cargoToml) {
+    const m = cargoToml.match(/\[package\][\s\S]*?name\s*=\s*['"]([^'"]+)['"]/);
+    if (m) return m[1];
+  }
+  const pom = readFileSafe(join(packageDir, "pom.xml"));
+  if (pom) {
+    const m = pom.match(/<artifactId>\s*([^<\s]+)\s*<\/artifactId>/);
+    if (m) return m[1];
+  }
+  const goMod = readFileSafe(join(packageDir, "go.mod"));
+  if (goMod) {
+    const m = goMod.match(/^module\s+(\S+)/m);
+    if (m) {
+      const parts = m[1].split("/");
+      return parts[parts.length - 1];
+    }
+  }
+  return basename(packageDir);
+}
+function detectEntryPoints(packageDir, framework) {
+  const entries = [];
+  const pkgContent = readFileSafe(join(packageDir, "package.json"));
+  if (pkgContent) {
+    const pkg = parseJsonSafe(pkgContent);
+    if (pkg) {
+      if (typeof pkg.main === "string" && pkg.main) entries.push(pkg.main);
+      if (typeof pkg.bin === "string" && pkg.bin) {
+        entries.push(pkg.bin);
+      } else if (pkg.bin && typeof pkg.bin === "object") {
+        for (const v of Object.values(pkg.bin)) {
+          if (typeof v === "string") entries.push(v);
+        }
+      }
+    }
+  }
+  if (framework === "go") {
+    const cmdDir = join(packageDir, "cmd");
+    if (isDirectory(cmdDir)) {
+      for (const sub of listDirs(cmdDir)) {
+        entries.push(join("cmd", sub));
+      }
+    }
+  }
+  if (framework === "rust") {
+    if (existsSync(join(packageDir, "src", "main.rs"))) {
+      entries.push("src/main.rs");
+    }
+  }
+  if (framework === "java-maven" || framework === "java-gradle") {
+    if (isDirectory(join(packageDir, "src", "main", "java"))) {
+      entries.push("src/main/java");
+    }
+  }
+  return dedupe(entries);
+}
+function detectPackageStack(packageDir, rootDir) {
+  const framework = detectFramework(packageDir);
+  const preset = STACK_PRESETS[framework] || STACK_PRESETS.unknown;
+  const pm = ["nextjs", "vite", "react", "node"].includes(framework) ? detectPackageManager(packageDir) : preset.language === "python" ? "pip" : "";
+  const resolved = resolveCommands(preset, pm);
+  const name = extractPackageName(packageDir);
+  const entryPoints = detectEntryPoints(packageDir, framework);
+  const relPath = relative(rootDir, packageDir) || ".";
+  return {
+    relative_path: relPath,
+    name,
+    language: resolved.language,
+    framework,
+    package_manager: pm,
+    build_command: resolved.build,
+    dev_command: resolved.dev,
+    test_command: resolved.test,
+    install_command: resolved.install,
+    dev_port: resolved.port !== 0 ? resolved.port : void 0,
+    entry_points: entryPoints
+  };
+}
+function scanPrimaryLanguages(projectDir) {
+  const counts = {};
+  let total = 0;
+  const MAX_DEPTH = 8;
+  function walk(dir, depth) {
+    if (depth > MAX_DEPTH) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".") {
+        if (IGNORE_DIRS.has(entry.name)) continue;
+      }
+      if (IGNORE_DIRS.has(entry.name)) continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full, depth + 1);
+      } else if (entry.isFile()) {
+        const ext = extname(entry.name).toLowerCase();
+        const lang = EXT_LANG_MAP[ext];
+        if (lang) {
+          counts[lang] = (counts[lang] || 0) + 1;
+          total += 1;
+        }
+      }
+    }
+  }
+  walk(projectDir, 0);
+  if (total === 0) return [];
+  const ranked = Object.entries(counts).map(([language, count]) => ({ language, loc_share: count / total })).sort((a, b) => b.loc_share - a.loc_share).slice(0, 3);
+  return ranked;
+}
 function detectStack(projectDir) {
   const framework = detectFramework(projectDir);
   const preset = STACK_PRESETS[framework] || STACK_PRESETS.unknown;
   const pm = ["nextjs", "vite", "react", "node"].includes(framework) ? detectPackageManager(projectDir) : preset.language === "python" ? "pip" : "";
   const resolved = resolveCommands(preset, pm);
+  const workspace = detectWorkspaces(projectDir);
+  const primaryLanguages = scanPrimaryLanguages(projectDir);
+  let packages;
+  if (workspace && workspace.packages.length > 0) {
+    packages = workspace.packages.map(
+      (pkgRelPath) => detectPackageStack(join(projectDir, pkgRelPath), projectDir)
+    );
+  }
   return {
     language: resolved.language,
     framework,
@@ -896,13 +1266,54 @@ function detectStack(projectDir) {
     dev_port: resolved.port,
     suggested_plugins: resolved.plugins,
     suggested_preset: resolved.preset,
-    suggested_deploy: resolved.deploy
+    suggested_deploy: resolved.deploy,
+    is_monorepo: workspace !== null,
+    total_packages: packages ? packages.length : 0,
+    primary_languages: primaryLanguages,
+    packages
   };
 }
-var STACK_PRESETS;
+var IGNORE_DIRS, EXT_LANG_MAP, PACKAGE_MANIFESTS, STACK_PRESETS;
 var init_stack_detector = __esm({
   "src/engine/stack-detector.ts"() {
     "use strict";
+    IGNORE_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "vendor",
+      "target",
+      "dist",
+      "build",
+      "__pycache__",
+      ".venv",
+      ".next",
+      ".turbo",
+      "coverage"
+    ]);
+    EXT_LANG_MAP = {
+      ".ts": "typescript",
+      ".tsx": "typescript",
+      ".js": "javascript",
+      ".jsx": "javascript",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust",
+      ".java": "java",
+      ".kt": "kotlin",
+      ".swift": "swift",
+      ".rb": "ruby",
+      ".cs": "csharp"
+    };
+    PACKAGE_MANIFESTS = [
+      "package.json",
+      "go.mod",
+      "Cargo.toml",
+      "pom.xml",
+      "build.gradle",
+      "build.gradle.kts",
+      "pyproject.toml",
+      "requirements.txt"
+    ];
     STACK_PRESETS = {
       nextjs: {
         language: "typescript",
@@ -2251,15 +2662,15 @@ var init_plugin_installer = __esm({
 // src/engine/skill-manager.ts
 import {
   existsSync as existsSync7,
-  readdirSync,
+  readdirSync as readdirSync2,
   cpSync as cpSync2,
   rmSync as rmSync2,
   readFileSync as readFileSync7,
   writeFileSync as writeFileSync5,
   mkdirSync as mkdirSync5,
-  statSync
+  statSync as statSync2
 } from "fs";
-import { join as join7, basename } from "path";
+import { join as join7, basename as basename2 } from "path";
 function parseSkillFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return {};
@@ -2278,7 +2689,7 @@ function addSkill(factoryDir, sourcePath) {
   if (!existsSync7(sourcePath)) {
     throw new Error(`Skill source path does not exist: ${sourcePath}`);
   }
-  const stat = statSync(sourcePath);
+  const stat = statSync2(sourcePath);
   if (!stat.isDirectory()) {
     throw new Error(`Skill source must be a directory: ${sourcePath}`);
   }
@@ -2288,7 +2699,7 @@ function addSkill(factoryDir, sourcePath) {
       `SKILL.md not found in ${sourcePath}. Every skill must have a SKILL.md with frontmatter.`
     );
   }
-  const skillName = basename(sourcePath);
+  const skillName = basename2(sourcePath);
   const destPath = join7(factoryDir, ".beastmode", "skills", skillName);
   if (existsSync7(destPath)) {
     throw new Error(
@@ -2335,7 +2746,7 @@ function listSkills(factoryDir) {
   const bmDir = join7(factoryDir, ".beastmode");
   const customSkillsDir = join7(bmDir, "skills");
   if (existsSync7(customSkillsDir)) {
-    for (const entry of readdirSync(customSkillsDir, { withFileTypes: true })) {
+    for (const entry of readdirSync2(customSkillsDir, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       const skillMdPath = join7(customSkillsDir, entry.name, "SKILL.md");
       if (!existsSync7(skillMdPath)) continue;
@@ -2352,7 +2763,7 @@ function listSkills(factoryDir) {
   }
   const pluginsDir = join7(bmDir, "plugins");
   if (existsSync7(pluginsDir)) {
-    for (const pluginEntry of readdirSync(pluginsDir, {
+    for (const pluginEntry of readdirSync2(pluginsDir, {
       withFileTypes: true
     })) {
       if (!pluginEntry.isDirectory() || pluginEntry.name.startsWith("."))
@@ -2363,7 +2774,7 @@ function listSkills(factoryDir) {
         "skills"
       );
       if (!existsSync7(pluginSkillsDir)) continue;
-      for (const skillEntry of readdirSync(pluginSkillsDir, {
+      for (const skillEntry of readdirSync2(pluginSkillsDir, {
         withFileTypes: true
       })) {
         if (!skillEntry.isDirectory() || skillEntry.name.startsWith("."))
@@ -2462,7 +2873,10 @@ function mapDaemonToFactory(daemon) {
     const hasDeployConfig = Object.keys(deployConfig).length > 0;
     const projectRaw = {
       name: repoName,
-      repo: daemon.github?.project_repo || "",
+      github: {
+        repo: daemon.github?.project_repo || "",
+        default_branch: daemon.github?.base_branch || "main"
+      },
       path: daemon.repos?.project || "",
       stack: {
         detected: stack.name || "node",
@@ -2666,7 +3080,7 @@ function generateDaemonConfig(factoryConfig, projectConfig, factoryPath) {
     taskBackendValue = backendAdapter;
   }
   const boardUrl = process.env.BEASTMODE_BOARD_URL || taskBackend.config?.url || "http://127.0.0.1:8080";
-  const projectRepo = projectConfig?.repo || "";
+  const projectRepo = projectConfig?.github?.repo || (projectConfig?.repo ?? "");
   const projectPath = projectConfig?.path || "";
   const projectOrg = projectRepo.split("/")[0] || "beastmode-agent";
   const stack = projectConfig?.stack;
@@ -2808,6 +3222,159 @@ var init_bridge = __esm({
   }
 });
 
+// src/engine/project-record.ts
+import { existsSync as existsSync8, writeFileSync as writeFileSync6, renameSync, readFileSync as readFileSync8, readdirSync as readdirSync3, mkdirSync as mkdirSync6 } from "fs";
+import { join as join8 } from "path";
+function detectShape(parsed) {
+  if (parsed.github && typeof parsed.github === "object" && parsed.slots && typeof parsed.slots === "object") {
+    return "canonical";
+  }
+  if (parsed.github && typeof parsed.github === "object") {
+    return "cli-legacy";
+  }
+  return "http-legacy";
+}
+function normalizeToCanonical(parsed, name) {
+  const shape = detectShape(parsed);
+  if (shape === "canonical") {
+    return parsed;
+  }
+  if (shape === "cli-legacy") {
+    const github = parsed.github;
+    return {
+      name: parsed.name || name,
+      path: parsed.path || "",
+      github: {
+        repo: github.repo || "",
+        default_branch: github.default_branch || "main"
+      },
+      board: parsed.board || {
+        id: null,
+        url: "http://127.0.0.1:8080",
+        auto_created: true
+      },
+      deploy: parsed.deploy || { verify_port: 3001 },
+      pipeline: parsed.pipeline || {},
+      models: parsed.models || {},
+      slots: { max: null },
+      registered_at: parsed.registered_at || (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  return {
+    name: parsed.name || name,
+    path: parsed.path || "",
+    github: {
+      repo: parsed.repo || "",
+      default_branch: "main"
+    },
+    board: { id: null, url: "http://127.0.0.1:8080", auto_created: true },
+    deploy: { verify_port: 3001 },
+    pipeline: parsed.pipeline || {},
+    models: parsed.models || {},
+    slots: { max: null },
+    registered_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createProjectRecord(input) {
+  return {
+    name: input.name,
+    path: input.resolvedPath,
+    github: {
+      repo: input.gitRemote || "",
+      default_branch: "main"
+    },
+    board: {
+      id: input.boardId ?? null,
+      url: process.env.BEASTMODE_BOARD_URL || "http://127.0.0.1:8080",
+      auto_created: !input.boardId
+    },
+    deploy: { verify_port: input.verifyPort ?? 3001 },
+    pipeline: {},
+    models: {},
+    slots: { max: null },
+    registered_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function writeProjectRecord(projectsDir, name, record) {
+  const dir = join8(projectsDir, name);
+  mkdirSync6(dir, { recursive: true });
+  const filePath = join8(dir, "project.json");
+  const tmpPath = `${filePath}.tmp`;
+  writeFileSync6(tmpPath, JSON.stringify(record, null, 2) + "\n");
+  renameSync(tmpPath, filePath);
+  const extPath = join8(dir, "extensions.json");
+  if (!existsSync8(extPath)) {
+    writeFileSync6(
+      extPath,
+      JSON.stringify(
+        {
+          plugins: { add: [], remove: [] },
+          mcps: { add: {}, remove: [] },
+          skills: { add: [], remove: [] }
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  }
+}
+function readProjectRecord(projectsDir, name) {
+  const subdirPath = join8(projectsDir, name, "project.json");
+  const flatPath = join8(projectsDir, `${name}.json`);
+  let filePath;
+  let isFlat = false;
+  if (existsSync8(subdirPath)) {
+    filePath = subdirPath;
+  } else if (existsSync8(flatPath)) {
+    filePath = flatPath;
+    isFlat = true;
+  } else {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync8(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+  const shape = detectShape(parsed);
+  const record = normalizeToCanonical(parsed, name);
+  if (shape !== "canonical" || isFlat) {
+    writeProjectRecord(projectsDir, name, record);
+  }
+  return record;
+}
+function listProjectRecords(projectsDir) {
+  if (!existsSync8(projectsDir)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const records = [];
+  for (const entry of readdirSync3(projectsDir)) {
+    if (entry.startsWith(".")) continue;
+    if (existsSync8(join8(projectsDir, entry, "project.json"))) {
+      if (!seen.has(entry)) {
+        seen.add(entry);
+        const record = readProjectRecord(projectsDir, entry);
+        if (record) records.push(record);
+      }
+      continue;
+    }
+    if (entry.endsWith(".json")) {
+      const name = entry.slice(0, -5);
+      if (!seen.has(name)) {
+        seen.add(name);
+        const record = readProjectRecord(projectsDir, name);
+        if (record) records.push(record);
+      }
+    }
+  }
+  return records;
+}
+var init_project_record = __esm({
+  "src/engine/project-record.ts"() {
+    "use strict";
+  }
+});
+
 // src/engine/index.ts
 var engine_exports = {};
 __export(engine_exports, {
@@ -2851,6 +3418,7 @@ __export(engine_exports, {
   configGet: () => configGet,
   configReset: () => configReset,
   configSet: () => configSet,
+  createProjectRecord: () => createProjectRecord,
   createSkill: () => createSkill,
   detectStack: () => detectStack,
   exportMarkdown: () => exportMarkdown,
@@ -2870,6 +3438,7 @@ __export(engine_exports, {
   listHooks: () => listHooks,
   listMcps: () => listMcps,
   listPresets: () => listPresets,
+  listProjectRecords: () => listProjectRecords,
   listProviders: () => listProviders,
   listSkills: () => listSkills,
   mapDaemonToFactory: () => mapDaemonToFactory,
@@ -2879,6 +3448,7 @@ __export(engine_exports, {
   parseMethodologyManifest: () => parseMethodologyManifest,
   parseTemplate: () => parseTemplate,
   performUpgrade: () => performUpgrade,
+  readProjectRecord: () => readProjectRecord,
   removeHook: () => removeHook,
   removeMcp: () => removeMcp,
   removePlugin: () => removePlugin,
@@ -2895,7 +3465,8 @@ __export(engine_exports, {
   scaffoldFactory: () => scaffoldFactory,
   validateFactory: () => validateFactory,
   validateProvider: () => validateProvider,
-  validateSecrets: () => validateSecrets
+  validateSecrets: () => validateSecrets,
+  writeProjectRecord: () => writeProjectRecord
 });
 var init_engine = __esm({
   "src/engine/index.ts"() {
@@ -2925,25 +3496,26 @@ var init_engine = __esm({
     init_schemas();
     init_migrator();
     init_bridge();
+    init_project_record();
   }
 });
 
 // src/cli/utils/file-writer.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6, appendFileSync, existsSync as existsSync8 } from "fs";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7, appendFileSync, existsSync as existsSync9 } from "fs";
 import { dirname as dirname3 } from "path";
 function executeFileActions(actions) {
   for (const action of actions) {
     const dir = dirname3(action.path);
-    mkdirSync6(dir, { recursive: true });
+    mkdirSync7(dir, { recursive: true });
     switch (action.action) {
       case "create":
-        if (existsSync8(action.path)) {
+        if (existsSync9(action.path)) {
           throw new Error(`File already exists: ${action.path}`);
         }
-        writeFileSync6(action.path, action.content, "utf-8");
+        writeFileSync7(action.path, action.content, "utf-8");
         break;
       case "overwrite":
-        writeFileSync6(action.path, action.content, "utf-8");
+        writeFileSync7(action.path, action.content, "utf-8");
         break;
       case "append":
         appendFileSync(action.path, action.content, "utf-8");
@@ -2988,7 +3560,7 @@ var init_display = __esm({
 
 // src/cli/ui/api-routes.ts
 import { resolve as resolve3 } from "path";
-import { existsSync as existsSync10, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync11, writeFileSync as writeFileSync8 } from "fs";
 function getRoutes() {
   return [
     {
@@ -3003,7 +3575,7 @@ function getRoutes() {
         const { path: projectPath } = body;
         if (!projectPath) throw new Error("Missing required field: path");
         const resolved = resolve3(projectPath);
-        if (!existsSync10(resolved)) throw new Error(`Directory not found: ${resolved}`);
+        if (!existsSync11(resolved)) throw new Error(`Directory not found: ${resolved}`);
         return detectStack(resolved);
       }
     },
@@ -3061,7 +3633,7 @@ function getRoutes() {
         if (!name) throw new Error("Missing required field: name");
         if (!config) throw new Error("Missing required field: config");
         if (!project) throw new Error("Missing required field: project");
-        if (existsSync10(name) && existsSync10(resolve3(name, ".beastmode"))) {
+        if (existsSync11(name) && existsSync11(resolve3(name, ".beastmode"))) {
           throw new Error(`Factory already exists at ./${name}. Use 'beastmode config' to modify.`);
         }
         const resolvedConfig = resolveDefaults(config, project.stack);
@@ -3078,7 +3650,7 @@ function getRoutes() {
           if (secretLines.length > 0) {
             const secretsPath = resolve3(name, ".beastmode", "secrets.env.local");
             const secretsContent = "# BeastMode secrets \u2014 DO NOT COMMIT\n" + secretLines.join("\n") + "\n";
-            writeFileSync7(secretsPath, secretsContent, "utf-8");
+            writeFileSync8(secretsPath, secretsContent, "utf-8");
           }
         }
         const fileList = actions.filter((a) => !a.path.endsWith(".gitkeep")).map((a) => a.path.replace(`${name}/`, ""));
@@ -3118,52 +3690,52 @@ var init_api_routes = __esm({
 });
 
 // src/cli/ui/archival.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readdirSync as readdirSync2, renameSync, readFileSync as readFileSync8, statSync as statSync2, writeFileSync as writeFileSync8, unlinkSync } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync4, renameSync as renameSync2, readFileSync as readFileSync9, statSync as statSync3, writeFileSync as writeFileSync9, unlinkSync } from "fs";
+import { join as join10 } from "path";
 function archiveOldRuns(runsDir, archiveAfterDays) {
-  if (archiveAfterDays <= 0 || !existsSync11(runsDir)) return { archived: 0 };
-  const archiveDir = join9(runsDir, ".archive");
+  if (archiveAfterDays <= 0 || !existsSync12(runsDir)) return { archived: 0 };
+  const archiveDir = join10(runsDir, ".archive");
   const cutoff = Date.now() - archiveAfterDays * 24 * 60 * 60 * 1e3;
   let archived = 0;
-  for (const entry of readdirSync2(runsDir)) {
+  for (const entry of readdirSync4(runsDir)) {
     if (entry.startsWith(".") || !entry.startsWith("run-")) continue;
-    const runDir = join9(runsDir, entry);
-    if (existsSync11(join9(runDir, "pinned"))) continue;
-    const cpPath = join9(runDir, "checkpoint.json");
-    if (!existsSync11(cpPath)) continue;
+    const runDir = join10(runsDir, entry);
+    if (existsSync12(join10(runDir, "pinned"))) continue;
+    const cpPath = join10(runDir, "checkpoint.json");
+    if (!existsSync12(cpPath)) continue;
     try {
-      const cp = JSON.parse(readFileSync8(cpPath, "utf-8"));
+      const cp = JSON.parse(readFileSync9(cpPath, "utf-8"));
       const stage = (cp.current_stage || "").toLowerCase();
       if (stage !== "done" && stage !== "ship") continue;
     } catch {
       continue;
     }
     try {
-      const mtime = statSync2(cpPath).mtimeMs;
+      const mtime = statSync3(cpPath).mtimeMs;
       if (mtime > cutoff) continue;
     } catch {
       continue;
     }
-    mkdirSync7(archiveDir, { recursive: true });
-    renameSync(runDir, join9(archiveDir, entry));
+    mkdirSync8(archiveDir, { recursive: true });
+    renameSync2(runDir, join10(archiveDir, entry));
     archived++;
   }
   return { archived };
 }
 function pinRun(runsDir, runId) {
-  const runDir = join9(runsDir, runId);
-  if (!existsSync11(runDir)) return false;
-  writeFileSync8(join9(runDir, "pinned"), (/* @__PURE__ */ new Date()).toISOString());
+  const runDir = join10(runsDir, runId);
+  if (!existsSync12(runDir)) return false;
+  writeFileSync9(join10(runDir, "pinned"), (/* @__PURE__ */ new Date()).toISOString());
   return true;
 }
 function unpinRun(runsDir, runId) {
-  const pinFile = join9(runsDir, runId, "pinned");
-  if (!existsSync11(pinFile)) return false;
+  const pinFile = join10(runsDir, runId, "pinned");
+  if (!existsSync12(pinFile)) return false;
   unlinkSync(pinFile);
   return true;
 }
 function isRunPinned(runsDir, runId) {
-  return existsSync11(join9(runsDir, runId, "pinned"));
+  return existsSync12(join10(runsDir, runId, "pinned"));
 }
 var init_archival = __esm({
   "src/cli/ui/archival.ts"() {
@@ -3188,37 +3760,37 @@ __export(inception_exports, {
   saveArtifact: () => saveArtifact,
   saveInceptionState: () => saveInceptionState
 });
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9, readFileSync as readFileSync9, readdirSync as readdirSync3, unlinkSync as unlinkSync2 } from "fs";
-import { join as join10, dirname as dirname4 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync9, writeFileSync as writeFileSync10, readFileSync as readFileSync10, readdirSync as readdirSync5, unlinkSync as unlinkSync2 } from "fs";
+import { join as join11, dirname as dirname4 } from "path";
 import { fileURLToPath } from "url";
 function getMethodologiesDir() {
   const candidates = [
-    join10(dirname4(fileURLToPath(import.meta.url)), "methodologies"),
-    join10(dirname4(fileURLToPath(import.meta.url)), "..", "methodologies"),
-    join10(process.cwd(), "src", "cli", "ui", "methodologies"),
-    join10(process.cwd(), "dist", "methodologies"),
-    join10(process.cwd(), "cli", "src", "cli", "ui", "methodologies"),
-    join10(process.cwd(), "cli", "dist", "methodologies")
+    join11(dirname4(fileURLToPath(import.meta.url)), "methodologies"),
+    join11(dirname4(fileURLToPath(import.meta.url)), "..", "methodologies"),
+    join11(process.cwd(), "src", "cli", "ui", "methodologies"),
+    join11(process.cwd(), "dist", "methodologies"),
+    join11(process.cwd(), "cli", "src", "cli", "ui", "methodologies"),
+    join11(process.cwd(), "cli", "dist", "methodologies")
   ];
   for (const dir of candidates) {
-    if (existsSync12(dir)) return dir;
+    if (existsSync13(dir)) return dir;
   }
   return candidates[0];
 }
 function getMethodology(id) {
   const dir = getMethodologiesDir();
-  const filePath = join10(dir, `${id.replace(/_/g, "-")}.json`);
-  if (!existsSync12(filePath)) {
+  const filePath = join11(dir, `${id.replace(/_/g, "-")}.json`);
+  if (!existsSync13(filePath)) {
     throw new Error(`Methodology not found: ${id}`);
   }
-  return JSON.parse(readFileSync9(filePath, "utf-8"));
+  return JSON.parse(readFileSync10(filePath, "utf-8"));
 }
 function listMethodologies() {
   const dir = getMethodologiesDir();
-  if (!existsSync12(dir)) return [];
-  return readdirSync3(dir).filter((f) => f.endsWith(".json")).map((f) => {
+  if (!existsSync13(dir)) return [];
+  return readdirSync5(dir).filter((f) => f.endsWith(".json")).map((f) => {
     try {
-      const m = JSON.parse(readFileSync9(join10(dir, f), "utf-8"));
+      const m = JSON.parse(readFileSync10(join11(dir, f), "utf-8"));
       return { id: m.id, name: m.name, description: m.description };
     } catch {
       return null;
@@ -3226,12 +3798,12 @@ function listMethodologies() {
   }).filter(Boolean);
 }
 function getProductDir(factoryDir, productName) {
-  return join10(factoryDir, ".beastmode", "products", productName);
+  return join11(factoryDir, ".beastmode", "products", productName);
 }
 function createInceptionState(factoryDir, opts) {
   const methodology = getMethodology(opts.methodology);
   const productDir = getProductDir(factoryDir, opts.productName);
-  mkdirSync8(productDir, { recursive: true });
+  mkdirSync9(productDir, { recursive: true });
   const state = {
     productName: opts.productName,
     idea: opts.idea,
@@ -3248,21 +3820,21 @@ function createInceptionState(factoryDir, opts) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     projectName: null
   };
-  writeFileSync9(join10(productDir, "inception.json"), JSON.stringify(state, null, 2) + "\n");
+  writeFileSync10(join11(productDir, "inception.json"), JSON.stringify(state, null, 2) + "\n");
   return state;
 }
 function loadInception(factoryDir, productName) {
-  const filePath = join10(getProductDir(factoryDir, productName), "inception.json");
-  if (!existsSync12(filePath)) return null;
+  const filePath = join11(getProductDir(factoryDir, productName), "inception.json");
+  if (!existsSync13(filePath)) return null;
   try {
-    return JSON.parse(readFileSync9(filePath, "utf-8"));
+    return JSON.parse(readFileSync10(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveInceptionState(factoryDir, state) {
   const productDir = getProductDir(factoryDir, state.productName);
-  writeFileSync9(join10(productDir, "inception.json"), JSON.stringify(state, null, 2) + "\n");
+  writeFileSync10(join11(productDir, "inception.json"), JSON.stringify(state, null, 2) + "\n");
 }
 function advancePhase(factoryDir, productName) {
   const state = loadInception(factoryDir, productName);
@@ -3282,28 +3854,28 @@ function advancePhase(factoryDir, productName) {
 }
 function saveArtifact(factoryDir, productName, filename, content) {
   const productDir = getProductDir(factoryDir, productName);
-  mkdirSync8(productDir, { recursive: true });
-  const filePath = join10(productDir, filename);
-  mkdirSync8(dirname4(filePath), { recursive: true });
-  writeFileSync9(filePath, content);
+  mkdirSync9(productDir, { recursive: true });
+  const filePath = join11(productDir, filename);
+  mkdirSync9(dirname4(filePath), { recursive: true });
+  writeFileSync10(filePath, content);
 }
 function loadArtifact(factoryDir, productName, filename) {
-  const filePath = join10(getProductDir(factoryDir, productName), filename);
-  if (!existsSync12(filePath)) return null;
-  return readFileSync9(filePath, "utf-8");
+  const filePath = join11(getProductDir(factoryDir, productName), filename);
+  if (!existsSync13(filePath)) return null;
+  return readFileSync10(filePath, "utf-8");
 }
 function migrateInceptionToSession(factoryDir, productName) {
-  const productDir = join10(factoryDir, ".beastmode", "products", productName);
-  const oldInception = join10(productDir, "inception.json");
-  if (!existsSync12(oldInception)) return false;
-  const sessionsDir = join10(productDir, "sessions");
-  if (existsSync12(sessionsDir) && readdirSync3(sessionsDir).some((d) => d.startsWith("session-"))) {
+  const productDir = join11(factoryDir, ".beastmode", "products", productName);
+  const oldInception = join11(productDir, "inception.json");
+  if (!existsSync13(oldInception)) return false;
+  const sessionsDir = join11(productDir, "sessions");
+  if (existsSync13(sessionsDir) && readdirSync5(sessionsDir).some((d) => d.startsWith("session-"))) {
     return false;
   }
-  const sessionDir = join10(sessionsDir, "session-001");
-  mkdirSync8(sessionDir, { recursive: true });
-  const content = readFileSync9(oldInception, "utf-8");
-  writeFileSync9(join10(sessionDir, "inception.json"), content);
+  const sessionDir = join11(sessionsDir, "session-001");
+  mkdirSync9(sessionDir, { recursive: true });
+  const content = readFileSync10(oldInception, "utf-8");
+  writeFileSync10(join11(sessionDir, "inception.json"), content);
   const artifactFiles = [
     "prd.md",
     "architecture.md",
@@ -3316,9 +3888,9 @@ function migrateInceptionToSession(factoryDir, productName) {
     "project-plan.md"
   ];
   for (const file of artifactFiles) {
-    const src = join10(productDir, file);
-    if (existsSync12(src)) {
-      writeFileSync9(join10(sessionDir, file), readFileSync9(src, "utf-8"));
+    const src = join11(productDir, file);
+    if (existsSync13(src)) {
+      writeFileSync10(join11(sessionDir, file), readFileSync10(src, "utf-8"));
       unlinkSync2(src);
     }
   }
@@ -3326,11 +3898,11 @@ function migrateInceptionToSession(factoryDir, productName) {
   return true;
 }
 function listProducts(factoryDir) {
-  const productsDir = join10(factoryDir, ".beastmode", "products");
-  if (!existsSync12(productsDir)) return [];
-  return readdirSync3(productsDir).filter((d) => existsSync12(join10(productsDir, d, "inception.json"))).map((d) => {
+  const productsDir = join11(factoryDir, ".beastmode", "products");
+  if (!existsSync13(productsDir)) return [];
+  return readdirSync5(productsDir).filter((d) => existsSync13(join11(productsDir, d, "inception.json"))).map((d) => {
     try {
-      const state = JSON.parse(readFileSync9(join10(productsDir, d, "inception.json"), "utf-8"));
+      const state = JSON.parse(readFileSync10(join11(productsDir, d, "inception.json"), "utf-8"));
       return {
         name: state.productName || d,
         methodology: state.methodology || "unknown",
@@ -3453,18 +4025,18 @@ __export(strategy_exports, {
   saveSessionArtifact: () => saveSessionArtifact,
   saveStrategySession: () => saveStrategySession
 });
-import { existsSync as existsSync13, mkdirSync as mkdirSync9, writeFileSync as writeFileSync10, readFileSync as readFileSync10, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11, readFileSync as readFileSync11, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
+import { join as join12 } from "path";
 function getProductDir2(factoryDir, projectName) {
-  return join11(factoryDir, ".beastmode", "products", projectName);
+  return join12(factoryDir, ".beastmode", "products", projectName);
 }
 function getSessionsDir(factoryDir, projectName) {
-  return join11(getProductDir2(factoryDir, projectName), "sessions");
+  return join12(getProductDir2(factoryDir, projectName), "sessions");
 }
 function nextSessionId(factoryDir, projectName) {
   const sessionsDir = getSessionsDir(factoryDir, projectName);
-  if (!existsSync13(sessionsDir)) return "session-001";
-  const existing = readdirSync4(sessionsDir).filter((d) => d.startsWith("session-")).sort();
+  if (!existsSync14(sessionsDir)) return "session-001";
+  const existing = readdirSync6(sessionsDir).filter((d) => d.startsWith("session-")).sort();
   if (existing.length === 0) return "session-001";
   const lastNum = parseInt(existing[existing.length - 1].replace("session-", ""), 10);
   return `session-${String(lastNum + 1).padStart(3, "0")}`;
@@ -3472,8 +4044,8 @@ function nextSessionId(factoryDir, projectName) {
 function createStrategySession(factoryDir, projectName, opts) {
   const methodology = getMethodology(opts.methodology);
   const sessionId = nextSessionId(factoryDir, projectName);
-  const sessionDir = join11(getSessionsDir(factoryDir, projectName), sessionId);
-  mkdirSync9(sessionDir, { recursive: true });
+  const sessionDir = join12(getSessionsDir(factoryDir, projectName), sessionId);
+  mkdirSync10(sessionDir, { recursive: true });
   const session = {
     sessionId,
     name: opts.name,
@@ -3494,100 +4066,100 @@ function createStrategySession(factoryDir, projectName, opts) {
     sessionType: opts.sessionType || "free-form",
     approach: opts.approach || "auto"
   };
-  writeFileSync10(join11(sessionDir, "inception.json"), JSON.stringify(session, null, 2) + "\n");
+  writeFileSync11(join12(sessionDir, "inception.json"), JSON.stringify(session, null, 2) + "\n");
   return session;
 }
 function listStrategySessions(factoryDir, projectName) {
   const sessionsDir = getSessionsDir(factoryDir, projectName);
-  if (!existsSync13(sessionsDir)) return [];
-  return readdirSync4(sessionsDir).filter((d) => d.startsWith("session-")).sort().map((d) => {
-    const file = join11(sessionsDir, d, "inception.json");
-    if (!existsSync13(file)) return null;
+  if (!existsSync14(sessionsDir)) return [];
+  return readdirSync6(sessionsDir).filter((d) => d.startsWith("session-")).sort().map((d) => {
+    const file = join12(sessionsDir, d, "inception.json");
+    if (!existsSync14(file)) return null;
     try {
-      return JSON.parse(readFileSync10(file, "utf-8"));
+      return JSON.parse(readFileSync11(file, "utf-8"));
     } catch {
       return null;
     }
   }).filter(Boolean);
 }
 function loadStrategySession(factoryDir, projectName, sessionId) {
-  const file = join11(getSessionsDir(factoryDir, projectName), sessionId, "inception.json");
-  if (!existsSync13(file)) return null;
+  const file = join12(getSessionsDir(factoryDir, projectName), sessionId, "inception.json");
+  if (!existsSync14(file)) return null;
   try {
-    return JSON.parse(readFileSync10(file, "utf-8"));
+    return JSON.parse(readFileSync11(file, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveStrategySession(factoryDir, projectName, sessionId, session) {
-  const dir = join11(getSessionsDir(factoryDir, projectName), sessionId);
-  mkdirSync9(dir, { recursive: true });
+  const dir = join12(getSessionsDir(factoryDir, projectName), sessionId);
+  mkdirSync10(dir, { recursive: true });
   session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync10(join11(dir, "inception.json"), JSON.stringify(session, null, 2) + "\n");
+  writeFileSync11(join12(dir, "inception.json"), JSON.stringify(session, null, 2) + "\n");
 }
 function saveSessionArtifact(factoryDir, projectName, sessionId, filename, content) {
-  const dir = join11(getSessionsDir(factoryDir, projectName), sessionId);
-  mkdirSync9(dir, { recursive: true });
-  writeFileSync10(join11(dir, filename), content);
+  const dir = join12(getSessionsDir(factoryDir, projectName), sessionId);
+  mkdirSync10(dir, { recursive: true });
+  writeFileSync11(join12(dir, filename), content);
 }
 function loadSessionArtifact(factoryDir, projectName, sessionId, filename) {
-  const file = join11(getSessionsDir(factoryDir, projectName), sessionId, filename);
-  if (!existsSync13(file)) return null;
-  return readFileSync10(file, "utf-8");
+  const file = join12(getSessionsDir(factoryDir, projectName), sessionId, filename);
+  if (!existsSync14(file)) return null;
+  return readFileSync11(file, "utf-8");
 }
 function buildArtifactIndex(factoryDir, projectName) {
   const artifacts = [];
-  const brownfieldPath = join11(factoryDir, ".beastmode", "projects", projectName, "brownfield.md");
-  if (existsSync13(brownfieldPath)) {
-    const content = readFileSync10(brownfieldPath, "utf-8");
+  const brownfieldPath = join12(factoryDir, ".beastmode", "projects", projectName, "brownfield.md");
+  if (existsSync14(brownfieldPath)) {
+    const content = readFileSync11(brownfieldPath, "utf-8");
     const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#")) || "";
     artifacts.push({
       type: "brownfield",
       path: brownfieldPath,
       summary: firstLine.slice(0, 200),
-      date: statSync3(brownfieldPath).mtime.toISOString()
+      date: statSync4(brownfieldPath).mtime.toISOString()
     });
   }
   const sessions = listStrategySessions(factoryDir, projectName);
   for (const session of sessions) {
     artifacts.push({
       type: "strategy_session",
-      path: join11(getSessionsDir(factoryDir, projectName), session.sessionId),
+      path: join12(getSessionsDir(factoryDir, projectName), session.sessionId),
       summary: `${session.name} (${session.methodology}) \u2014 ${session.status}`,
       date: session.createdAt,
       sessionId: session.sessionId
     });
   }
-  const runsDir = join11(factoryDir, "runs", projectName);
-  if (existsSync13(runsDir)) {
-    const runDirs = readdirSync4(runsDir).filter((d) => d.startsWith("run-")).sort().reverse().slice(0, 10);
+  const runsDir = join12(factoryDir, "runs", projectName);
+  if (existsSync14(runsDir)) {
+    const runDirs = readdirSync6(runsDir).filter((d) => d.startsWith("run-")).sort().reverse().slice(0, 10);
     for (const runId of runDirs) {
-      const nlspecPath = join11(runsDir, runId, "nlspec.md");
-      if (existsSync13(nlspecPath)) {
-        const content = readFileSync10(nlspecPath, "utf-8");
+      const nlspecPath = join12(runsDir, runId, "nlspec.md");
+      if (existsSync14(nlspecPath)) {
+        const content = readFileSync11(nlspecPath, "utf-8");
         const title = content.split("\n").find((l) => l.startsWith("# ")) || runId;
         artifacts.push({
           type: "nlspec",
           path: nlspecPath,
           summary: title.replace("# ", "").slice(0, 200),
-          date: statSync3(nlspecPath).mtime.toISOString(),
+          date: statSync4(nlspecPath).mtime.toISOString(),
           runId
         });
       }
     }
   }
-  const learningsDir = join11(getProductDir2(factoryDir, projectName), "learnings");
-  if (existsSync13(learningsDir)) {
-    const learningFiles = readdirSync4(learningsDir).filter((f) => f.endsWith(".md") && !f.startsWith("."));
+  const learningsDir = join12(getProductDir2(factoryDir, projectName), "learnings");
+  if (existsSync14(learningsDir)) {
+    const learningFiles = readdirSync6(learningsDir).filter((f) => f.endsWith(".md") && !f.startsWith("."));
     for (const file of learningFiles) {
-      const filePath = join11(learningsDir, file);
-      const content = readFileSync10(filePath, "utf-8");
+      const filePath = join12(learningsDir, file);
+      const content = readFileSync11(filePath, "utf-8");
       const firstHeading = content.split("\n").find((l) => l.startsWith("## ")) || file;
       artifacts.push({
         type: "learning",
         path: filePath,
         summary: firstHeading.replace("## ", "").slice(0, 200),
-        date: statSync3(filePath).mtime.toISOString()
+        date: statSync4(filePath).mtime.toISOString()
       });
     }
   }
@@ -3612,8 +4184,8 @@ var init_strategy = __esm({
 // src/cli/ui/chat-handler.ts
 import { randomUUID } from "crypto";
 import { execSync as execSync2 } from "child_process";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync11, existsSync as existsSync14, mkdirSync as mkdirSync10, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync12, existsSync as existsSync15, mkdirSync as mkdirSync11, readdirSync as readdirSync7, statSync as statSync5 } from "fs";
+import { join as join13 } from "path";
 import http from "http";
 import { WebSocketServer, WebSocket as WsWebSocket } from "ws";
 function getRecentTokenUsage() {
@@ -3723,19 +4295,19 @@ function getToolDefinitions() {
   ];
 }
 function readJsonSafe(filePath) {
-  if (!existsSync14(filePath)) return null;
+  if (!existsSync15(filePath)) return null;
   try {
-    return JSON.parse(readFileSync11(filePath, "utf-8"));
+    return JSON.parse(readFileSync12(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function getBoardUrl(factoryPath) {
   if (process.env.BEASTMODE_BOARD_URL) return process.env.BEASTMODE_BOARD_URL;
-  const configPath = join12(factoryPath, ".beastmode", "config.json");
-  if (existsSync14(configPath)) {
+  const configPath = join13(factoryPath, ".beastmode", "config.json");
+  if (existsSync15(configPath)) {
     try {
-      const config = JSON.parse(readFileSync11(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync12(configPath, "utf-8"));
       if (config.task_backend?.config?.url) return config.task_backend.config.url;
     } catch {
     }
@@ -3746,19 +4318,19 @@ async function executeTool(toolName, toolInput, factoryPath) {
   try {
     switch (toolName) {
       case "factory_status": {
-        const bmDir = join12(factoryPath, ".beastmode");
-        const factory = readJsonSafe(join12(bmDir, "factory.json"));
-        const projectsDir = join12(bmDir, "projects");
+        const bmDir = join13(factoryPath, ".beastmode");
+        const factory = readJsonSafe(join13(bmDir, "factory.json"));
+        const projectsDir = join13(bmDir, "projects");
         let projects = [];
-        if (existsSync14(projectsDir)) {
-          projects = readdirSync5(projectsDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+        if (existsSync15(projectsDir)) {
+          projects = readdirSync7(projectsDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
         }
-        const runsDir = join12(factoryPath, "runs");
+        const runsDir = join13(factoryPath, "runs");
         let runs = [];
-        if (existsSync14(runsDir)) {
-          runs = readdirSync5(runsDir).filter((d) => {
+        if (existsSync15(runsDir)) {
+          runs = readdirSync7(runsDir).filter((d) => {
             try {
-              return statSync4(join12(runsDir, d)).isDirectory();
+              return statSync5(join13(runsDir, d)).isDirectory();
             } catch {
               return false;
             }
@@ -3766,10 +4338,10 @@ async function executeTool(toolName, toolInput, factoryPath) {
         }
         let daemonStatus = "stopped";
         let daemonPid = null;
-        const pidFile = join12(bmDir, "daemon.pid");
-        if (existsSync14(pidFile)) {
+        const pidFile = join13(bmDir, "daemon.pid");
+        if (existsSync15(pidFile)) {
           try {
-            daemonPid = parseInt(readFileSync11(pidFile, "utf-8").trim(), 10);
+            daemonPid = parseInt(readFileSync12(pidFile, "utf-8").trim(), 10);
             process.kill(daemonPid, 0);
             daemonStatus = "running";
           } catch {
@@ -3817,7 +4389,7 @@ async function executeTool(toolName, toolInput, factoryPath) {
         }, null, 2);
       }
       case "factory_config": {
-        const configPath = join12(factoryPath, ".beastmode", "config.json");
+        const configPath = join13(factoryPath, ".beastmode", "config.json");
         const config = readJsonSafe(configPath);
         return config ? JSON.stringify(config, null, 2) : "No config.json found.";
       }
@@ -3872,12 +4444,12 @@ async function executeTool(toolName, toolInput, factoryPath) {
         }
       }
       case "list_runs": {
-        const runsDir = join12(factoryPath, "runs");
-        if (!existsSync14(runsDir)) return "No runs directory.";
-        const runDirs = readdirSync5(runsDir).sort().reverse();
+        const runsDir = join13(factoryPath, "runs");
+        if (!existsSync15(runsDir)) return "No runs directory.";
+        const runDirs = readdirSync7(runsDir).sort().reverse();
         const results = [];
         for (const id of runDirs.slice(0, 15)) {
-          const cp = readJsonSafe(join12(runsDir, id, "checkpoint.json"));
+          const cp = readJsonSafe(join13(runsDir, id, "checkpoint.json"));
           if (cp) {
             const hist = Array.isArray(cp.satisfaction_history) ? cp.satisfaction_history : [];
             results.push({
@@ -3893,36 +4465,36 @@ async function executeTool(toolName, toolInput, factoryPath) {
       case "run_detail": {
         const runId = toolInput.run_id;
         if (runId.includes("..")) return "Invalid run_id.";
-        const runDir = join12(factoryPath, "runs", runId);
-        if (!existsSync14(runDir)) return `Run not found: ${runId}`;
-        const manifest = readJsonSafe(join12(runDir, "manifest.json"));
-        const checkpoint = readJsonSafe(join12(runDir, "checkpoint.json"));
-        const iterDir = join12(runDir, "iterations");
+        const runDir = join13(factoryPath, "runs", runId);
+        if (!existsSync15(runDir)) return `Run not found: ${runId}`;
+        const manifest = readJsonSafe(join13(runDir, "manifest.json"));
+        const checkpoint = readJsonSafe(join13(runDir, "checkpoint.json"));
+        const iterDir = join13(runDir, "iterations");
         const iterations = [];
-        if (existsSync14(iterDir)) {
-          for (const d of readdirSync5(iterDir).sort()) {
-            const sat = readJsonSafe(join12(iterDir, d, "satisfaction.json"));
+        if (existsSync15(iterDir)) {
+          for (const d of readdirSync7(iterDir).sort()) {
+            const sat = readJsonSafe(join13(iterDir, d, "satisfaction.json"));
             iterations.push({ number: parseInt(d, 10), satisfaction: sat });
           }
         }
-        const files = readdirSync5(runDir);
+        const files = readdirSync7(runDir);
         return JSON.stringify({ id: runId, files, manifest, checkpoint, iterations }, null, 2);
       }
       case "read_run_file": {
         const runId = toolInput.run_id;
         const relPath = toolInput.file_path;
         if (runId.includes("..") || relPath.includes("..")) return "Invalid path.";
-        const fullPath = join12(factoryPath, "runs", runId, relPath);
-        if (!existsSync14(fullPath)) return `File not found: runs/${runId}/${relPath}`;
-        const content = readFileSync11(fullPath, "utf-8");
+        const fullPath = join13(factoryPath, "runs", runId, relPath);
+        if (!existsSync15(fullPath)) return `File not found: runs/${runId}/${relPath}`;
+        const content = readFileSync12(fullPath, "utf-8");
         return content.length > 1e4 ? content.slice(0, 1e4) + "\n\n... (truncated at 10KB)" : content;
       }
       case "list_projects": {
-        const projDir = join12(factoryPath, ".beastmode", "projects");
-        if (!existsSync14(projDir)) return "No projects registered.";
-        const projects = readdirSync5(projDir).filter((f) => f.endsWith(".json")).map((f) => {
+        const projDir = join13(factoryPath, ".beastmode", "projects");
+        if (!existsSync15(projDir)) return "No projects registered.";
+        const projects = readdirSync7(projDir).filter((f) => f.endsWith(".json")).map((f) => {
           try {
-            return JSON.parse(readFileSync11(join12(projDir, f), "utf-8"));
+            return JSON.parse(readFileSync12(join13(projDir, f), "utf-8"));
           } catch {
             return null;
           }
@@ -3932,25 +4504,25 @@ async function executeTool(toolName, toolInput, factoryPath) {
       case "read_file": {
         const relPath = toolInput.path;
         if (relPath.includes("..")) return "Invalid path.";
-        const fullPath = join12(factoryPath, relPath);
+        const fullPath = join13(factoryPath, relPath);
         if (!fullPath.startsWith(factoryPath)) return "Path traversal not allowed.";
-        if (!existsSync14(fullPath)) return `File not found: ${relPath}`;
+        if (!existsSync15(fullPath)) return `File not found: ${relPath}`;
         try {
-          const entries = readdirSync5(fullPath);
+          const entries = readdirSync7(fullPath);
           return `"${relPath}" is a directory with ${entries.length} entries: ${entries.slice(0, 30).join(", ")}`;
         } catch {
         }
-        const content = readFileSync11(fullPath, "utf-8");
+        const content = readFileSync12(fullPath, "utf-8");
         return content.length > 1e4 ? content.slice(0, 1e4) + "\n\n... (truncated at 10KB)" : content;
       }
       case "list_directory": {
         const relPath = toolInput.path || "";
         if (relPath.includes("..")) return "Invalid path.";
-        const fullPath = join12(factoryPath, relPath);
+        const fullPath = join13(factoryPath, relPath);
         if (!fullPath.startsWith(factoryPath)) return "Path traversal not allowed.";
-        if (!existsSync14(fullPath)) return `Directory not found: ${relPath || "/"}`;
+        if (!existsSync15(fullPath)) return `Directory not found: ${relPath || "/"}`;
         try {
-          return readdirSync5(fullPath).join("\n");
+          return readdirSync7(fullPath).join("\n");
         } catch {
           return `Not a directory: ${relPath}`;
         }
@@ -3963,8 +4535,8 @@ async function executeTool(toolName, toolInput, factoryPath) {
   }
 }
 function getChatHistoryDir(factoryPath) {
-  const dir = join12(factoryPath, ".beastmode", "chat-history");
-  if (!existsSync14(dir)) mkdirSync10(dir, { recursive: true });
+  const dir = join13(factoryPath, ".beastmode", "chat-history");
+  if (!existsSync15(dir)) mkdirSync11(dir, { recursive: true });
   return dir;
 }
 function saveConversation(factoryPath, sessionId, messages, scope) {
@@ -3975,13 +4547,13 @@ function saveConversation(factoryPath, sessionId, messages, scope) {
     updated_at: (/* @__PURE__ */ new Date()).toISOString(),
     messages
   };
-  writeFileSync11(join12(dir, `${sessionId}.json`), JSON.stringify(data, null, 2));
+  writeFileSync12(join13(dir, `${sessionId}.json`), JSON.stringify(data, null, 2));
 }
 function listConversations(factoryPath) {
   const dir = getChatHistoryDir(factoryPath);
-  return readdirSync5(dir).filter((f) => f.endsWith(".json")).map((f) => {
+  return readdirSync7(dir).filter((f) => f.endsWith(".json")).map((f) => {
     try {
-      const data = JSON.parse(readFileSync11(join12(dir, f), "utf-8"));
+      const data = JSON.parse(readFileSync12(join13(dir, f), "utf-8"));
       const msgs = data.messages || [];
       const firstUser = msgs.find((m) => m.role === "user");
       const preview = typeof firstUser?.content === "string" ? firstUser.content.slice(0, 80) : "";
@@ -3999,10 +4571,10 @@ function listConversations(factoryPath) {
 }
 function loadConversation(factoryPath, sessionId) {
   if (sessionId.includes("..")) return [];
-  const file = join12(getChatHistoryDir(factoryPath), `${sessionId}.json`);
-  if (!existsSync14(file)) return [];
+  const file = join13(getChatHistoryDir(factoryPath), `${sessionId}.json`);
+  if (!existsSync15(file)) return [];
   try {
-    const data = JSON.parse(readFileSync11(file, "utf-8"));
+    const data = JSON.parse(readFileSync12(file, "utf-8"));
     return data.messages || [];
   } catch {
     return [];
@@ -4010,7 +4582,7 @@ function loadConversation(factoryPath, sessionId) {
 }
 function buildSystemPrompt(factoryPath) {
   let factoryName = "BeastMode Factory";
-  const factoryJson = readJsonSafe(join12(factoryPath, ".beastmode", "factory.json"));
+  const factoryJson = readJsonSafe(join13(factoryPath, ".beastmode", "factory.json"));
   if (factoryJson?.factory_name) factoryName = factoryJson.factory_name;
   else if (factoryJson?.name) factoryName = factoryJson.name;
   return `You are BeastMode Assistant \u2014 a concise, helpful assistant for the "${factoryName}" factory at ${factoryPath}.
@@ -4557,8 +5129,8 @@ var init_chat_handler = __esm({
 });
 
 // src/cli/ui/board-api-routes.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync12, existsSync as existsSync15, readdirSync as readdirSync6, unlinkSync as unlinkSync3, mkdirSync as mkdirSync11, statSync as statSync5, rmSync as rmSync3 } from "fs";
-import { join as join13, basename as basename3, resolve as resolve4, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync13, existsSync as existsSync16, readdirSync as readdirSync8, unlinkSync as unlinkSync3, mkdirSync as mkdirSync12, statSync as statSync6, rmSync as rmSync3 } from "fs";
+import { join as join14, basename as basename4, resolve as resolve4, dirname as dirname5 } from "path";
 import { homedir } from "os";
 import { randomUUID as randomUUID2 } from "crypto";
 import { execSync as execSync3, spawnSync } from "child_process";
@@ -4570,10 +5142,10 @@ function assertSafeName(name) {
 }
 function getBoardUrl2(factoryDir) {
   if (process.env.BEASTMODE_BOARD_URL) return process.env.BEASTMODE_BOARD_URL;
-  const configPath = join13(factoryDir, ".beastmode", "config.json");
-  if (existsSync15(configPath)) {
+  const configPath = join14(factoryDir, ".beastmode", "config.json");
+  if (existsSync16(configPath)) {
     try {
-      const config = JSON.parse(readFileSync12(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync13(configPath, "utf-8"));
       if (config.task_backend?.config?.url) {
         return config.task_backend.config.url;
       }
@@ -4712,9 +5284,9 @@ function scopedQuery(query) {
   return { board: b };
 }
 function readJsonFile(filePath) {
-  if (!existsSync15(filePath)) return null;
+  if (!existsSync16(filePath)) return null;
   try {
-    return JSON.parse(readFileSync12(filePath, "utf-8"));
+    return JSON.parse(readFileSync13(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -4734,25 +5306,25 @@ function deepMerge2(target, source) {
   return result;
 }
 function getRunsDir(factoryDir) {
-  const configPath = join13(factoryDir, ".beastmode", "config.json");
-  if (existsSync15(configPath)) {
+  const configPath = join14(factoryDir, ".beastmode", "config.json");
+  if (existsSync16(configPath)) {
     try {
-      const config = JSON.parse(readFileSync12(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync13(configPath, "utf-8"));
       if (config.runs_path) return config.runs_path;
     } catch {
     }
   }
-  return join13(factoryDir, "runs");
+  return join14(factoryDir, "runs");
 }
 function scanStrandedRuns(runsDir, newThreshold) {
-  if (!existsSync15(runsDir)) return [];
+  if (!existsSync16(runsDir)) return [];
   const stranded = [];
   const walkRun = (runPath, projectId) => {
-    const ckptPath = join13(runPath, "checkpoint.json");
-    if (!existsSync15(ckptPath)) return;
+    const ckptPath = join14(runPath, "checkpoint.json");
+    if (!existsSync16(ckptPath)) return;
     let ckpt;
     try {
-      ckpt = JSON.parse(readFileSync12(ckptPath, "utf-8"));
+      ckpt = JSON.parse(readFileSync13(ckptPath, "utf-8"));
     } catch {
       return;
     }
@@ -4770,12 +5342,12 @@ function scanStrandedRuns(runsDir, newThreshold) {
     });
   };
   try {
-    const entries = readdirSync6(runsDir);
+    const entries = readdirSync8(runsDir);
     for (const entry of entries) {
-      const entryPath = join13(runsDir, entry);
+      const entryPath = join14(runsDir, entry);
       let stat;
       try {
-        stat = statSync5(entryPath);
+        stat = statSync6(entryPath);
       } catch {
         continue;
       }
@@ -4785,15 +5357,15 @@ function scanStrandedRuns(runsDir, newThreshold) {
       } else if (!entry.startsWith(".")) {
         let subEntries;
         try {
-          subEntries = readdirSync6(entryPath);
+          subEntries = readdirSync8(entryPath);
         } catch {
           continue;
         }
         for (const sub of subEntries) {
           if (!sub.startsWith("run-")) continue;
-          const subPath = join13(entryPath, sub);
+          const subPath = join14(entryPath, sub);
           try {
-            if (statSync5(subPath).isDirectory()) {
+            if (statSync6(subPath).isDirectory()) {
               walkRun(subPath, entry);
             }
           } catch {
@@ -4808,10 +5380,10 @@ function scanStrandedRuns(runsDir, newThreshold) {
   return stranded;
 }
 function _readAnalyzeMeta(projectsDir, name) {
-  const metaPath = join13(projectsDir, name, "codebase-guide.meta.json");
-  if (!existsSync15(metaPath)) return null;
+  const metaPath = join14(projectsDir, name, "codebase-guide.meta.json");
+  if (!existsSync16(metaPath)) return null;
   try {
-    return JSON.parse(readFileSync12(metaPath, "utf-8"));
+    return JSON.parse(readFileSync13(metaPath, "utf-8"));
   } catch {
     return null;
   }
@@ -4838,29 +5410,19 @@ function getBoardRoutes(factoryDir) {
       method: "GET",
       pattern: "/api/status",
       handler: async () => {
-        const bmDir = join13(factoryDir, ".beastmode");
-        const factoryJsonPath = join13(bmDir, "factory.json");
-        if (!existsSync15(factoryJsonPath)) {
+        const bmDir = join14(factoryDir, ".beastmode");
+        const factoryJsonPath = join14(bmDir, "factory.json");
+        if (!existsSync16(factoryJsonPath)) {
           throw new Error("Not a valid factory: factory.json not found");
         }
-        const factoryIdentity = JSON.parse(readFileSync12(factoryJsonPath, "utf-8"));
-        const projectsDir = join13(bmDir, "projects");
-        let projectCount = 0;
-        if (existsSync15(projectsDir)) {
-          for (const entry of readdirSync6(projectsDir)) {
-            if (entry.startsWith(".")) continue;
-            if (existsSync15(join13(projectsDir, entry, "project.json"))) {
-              projectCount++;
-              continue;
-            }
-            if (entry.endsWith(".json")) projectCount++;
-          }
-        }
-        const lockPath = join13(bmDir, "extensions.lock");
+        const factoryIdentity = JSON.parse(readFileSync13(factoryJsonPath, "utf-8"));
+        const projectsDir = join14(bmDir, "projects");
+        const projectCount = listProjectRecords(projectsDir).length;
+        const lockPath = join14(bmDir, "extensions.lock");
         let pluginNames = [];
-        if (existsSync15(lockPath)) {
+        if (existsSync16(lockPath)) {
           try {
-            const lock = JSON.parse(readFileSync12(lockPath, "utf-8"));
+            const lock = JSON.parse(readFileSync13(lockPath, "utf-8"));
             pluginNames = Object.keys(lock.plugins || {});
           } catch {
           }
@@ -4880,24 +5442,24 @@ function getBoardRoutes(factoryDir) {
           skillCount = listSkills(factoryDir).length;
         } catch {
         }
-        const runsDir = join13(factoryDir, "runs");
+        const runsDir = join14(factoryDir, "runs");
         let runDirs = [];
-        if (existsSync15(runsDir)) {
-          runDirs = readdirSync6(runsDir).filter((d) => {
+        if (existsSync16(runsDir)) {
+          runDirs = readdirSync8(runsDir).filter((d) => {
             if (d.startsWith(".")) return false;
             try {
-              return readdirSync6(join13(runsDir, d)).length > 0;
+              return readdirSync8(join14(runsDir, d)).length > 0;
             } catch {
               return false;
             }
           }).sort();
         }
-        const pidFile = join13(factoryDir, ".beastmode", "daemon.pid");
+        const pidFile = join14(factoryDir, ".beastmode", "daemon.pid");
         let daemonPid = null;
         let pidAlive = false;
-        if (existsSync15(pidFile)) {
+        if (existsSync16(pidFile)) {
           try {
-            daemonPid = parseInt(readFileSync12(pidFile, "utf-8").trim(), 10);
+            daemonPid = parseInt(readFileSync13(pidFile, "utf-8").trim(), 10);
             process.kill(daemonPid, 0);
             pidAlive = true;
           } catch {
@@ -4954,10 +5516,10 @@ function getBoardRoutes(factoryDir) {
       handler: async () => {
         const boardUrl = getBoardUrl2(factoryDir);
         let ageSecs = null;
-        const heartbeatPath = join13(factoryDir, "daemon", "logs", ".heartbeat");
-        if (existsSync15(heartbeatPath)) {
+        const heartbeatPath = join14(factoryDir, "daemon", "logs", ".heartbeat");
+        if (existsSync16(heartbeatPath)) {
           try {
-            const ts = parseInt(readFileSync12(heartbeatPath, "utf-8").trim(), 10);
+            const ts = parseInt(readFileSync13(heartbeatPath, "utf-8").trim(), 10);
             if (!isNaN(ts)) {
               ageSecs = Math.floor(Date.now() / 1e3) - ts;
             }
@@ -4999,11 +5561,11 @@ function getBoardRoutes(factoryDir) {
         let totalSlots = 3;
         let shortPhaseReserve;
         let slotsTimestamp;
-        const slotsPath = join13(factoryDir, "daemon", "logs", ".slots.json");
+        const slotsPath = join14(factoryDir, "daemon", "logs", ".slots.json");
         let usedDaemonSlotsFile = false;
-        if (existsSync15(slotsPath)) {
+        if (existsSync16(slotsPath)) {
           try {
-            const slots = JSON.parse(readFileSync12(slotsPath, "utf-8"));
+            const slots = JSON.parse(readFileSync13(slotsPath, "utf-8"));
             if (typeof slots.busy === "number" && typeof slots.total === "number") {
               busySlots = slots.busy;
               totalSlots = slots.total;
@@ -5028,10 +5590,10 @@ function getBoardRoutes(factoryDir) {
           } catch {
           }
           for (const name of ["beastmode.docker.json", "beastmode.daemon.json"]) {
-            const configPath = join13(factoryDir, "config", name);
-            if (!existsSync15(configPath)) continue;
+            const configPath = join14(factoryDir, "config", name);
+            if (!existsSync16(configPath)) continue;
             try {
-              const config = JSON.parse(readFileSync12(configPath, "utf-8"));
+              const config = JSON.parse(readFileSync13(configPath, "utf-8"));
               if (typeof config.max_slots === "number") {
                 totalSlots = config.max_slots;
               }
@@ -5048,11 +5610,11 @@ function getBoardRoutes(factoryDir) {
         if (shortPhaseReserve === void 0) {
           shortPhaseReserve = Math.max(0, Math.min(1, totalSlots - 1));
         }
-        const alertsPath = join13(factoryDir, "daemon", "logs", ".alerts.json");
+        const alertsPath = join14(factoryDir, "daemon", "logs", ".alerts.json");
         let alerts = [];
-        if (existsSync15(alertsPath)) {
+        if (existsSync16(alertsPath)) {
           try {
-            const parsed = JSON.parse(readFileSync12(alertsPath, "utf-8"));
+            const parsed = JSON.parse(readFileSync13(alertsPath, "utf-8"));
             if (Array.isArray(parsed)) alerts = parsed;
           } catch {
           }
@@ -5267,12 +5829,12 @@ function getBoardRoutes(factoryDir) {
       method: "GET",
       pattern: "/api/extensions/plugins",
       handler: () => {
-        const lockPath = join13(factoryDir, ".beastmode", "extensions.lock");
-        if (!existsSync15(lockPath)) {
+        const lockPath = join14(factoryDir, ".beastmode", "extensions.lock");
+        if (!existsSync16(lockPath)) {
           return { plugins: {} };
         }
         try {
-          const lock = JSON.parse(readFileSync12(lockPath, "utf-8"));
+          const lock = JSON.parse(readFileSync13(lockPath, "utf-8"));
           return { plugins: lock.plugins || {} };
         } catch {
           return { plugins: {} };
@@ -5429,27 +5991,8 @@ function getBoardRoutes(factoryDir) {
       method: "GET",
       pattern: "/api/projects",
       handler: () => {
-        const projectsDir = join13(factoryDir, ".beastmode", "projects");
-        if (!existsSync15(projectsDir)) return { projects: [] };
-        const projects = [];
-        for (const entry of readdirSync6(projectsDir)) {
-          if (entry.startsWith(".")) continue;
-          const subDirPath = join13(projectsDir, entry, "project.json");
-          if (existsSync15(subDirPath)) {
-            try {
-              projects.push(JSON.parse(readFileSync12(subDirPath, "utf-8")));
-            } catch {
-            }
-            continue;
-          }
-          if (entry.endsWith(".json")) {
-            try {
-              projects.push(JSON.parse(readFileSync12(join13(projectsDir, entry), "utf-8")));
-            } catch {
-            }
-          }
-        }
-        return { projects };
+        const projectsDir = join14(factoryDir, ".beastmode", "projects");
+        return { projects: listProjectRecords(projectsDir) };
       }
     },
     {
@@ -5458,11 +6001,9 @@ function getBoardRoutes(factoryDir) {
       handler: (_body, params) => {
         const { name } = params;
         assertSafeName(name);
-        const subDirPath = join13(factoryDir, ".beastmode", "projects", name, "project.json");
-        const flatPath = join13(factoryDir, ".beastmode", "projects", `${name}.json`);
-        const filePath = existsSync15(subDirPath) ? subDirPath : flatPath;
-        if (!existsSync15(filePath)) throw new Error(`Project not found: ${name}`);
-        return JSON.parse(readFileSync12(filePath, "utf-8"));
+        const record = readProjectRecord(join14(factoryDir, ".beastmode", "projects"), name);
+        if (!record) throw new Error(`Project not found: ${name}`);
+        return record;
       }
     },
     {
@@ -5471,12 +6012,12 @@ function getBoardRoutes(factoryDir) {
       handler: (_body, params) => {
         const { name } = params;
         assertSafeName(name);
-        const extPath = join13(factoryDir, ".beastmode", "projects", name, "extensions.json");
-        if (!existsSync15(extPath)) {
+        const extPath = join14(factoryDir, ".beastmode", "projects", name, "extensions.json");
+        if (!existsSync16(extPath)) {
           return { plugins: { add: [], remove: [] }, mcps: { add: {}, remove: [] }, skills: { add: [], remove: [] } };
         }
         try {
-          return JSON.parse(readFileSync12(extPath, "utf-8"));
+          return JSON.parse(readFileSync13(extPath, "utf-8"));
         } catch {
           return { plugins: { add: [], remove: [] }, mcps: { add: {}, remove: [] }, skills: { add: [], remove: [] } };
         }
@@ -5498,18 +6039,18 @@ function getBoardRoutes(factoryDir) {
         const { path: queryPath } = body || {};
         const startPath = queryPath || homedir();
         const target = resolve4(startPath);
-        if (!existsSync15(target)) throw new Error(`Path not found: ${target}`);
-        const st = statSync5(target);
+        if (!existsSync16(target)) throw new Error(`Path not found: ${target}`);
+        const st = statSync6(target);
         if (!st.isDirectory()) throw new Error(`Not a directory: ${target}`);
         let entries = [];
         try {
-          entries = readdirSync6(target, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => {
-            const full = join13(target, d.name);
+          entries = readdirSync8(target, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => {
+            const full = join14(target, d.name);
             return {
               name: d.name,
               path: full,
               is_dir: true,
-              has_git: existsSync15(join13(full, ".git"))
+              has_git: existsSync16(join14(full, ".git"))
             };
           }).sort((a, b) => a.name.localeCompare(b.name));
         } catch {
@@ -5528,8 +6069,8 @@ function getBoardRoutes(factoryDir) {
       pattern: "/api/projects",
       handler: (body) => {
         const { path: projectPath, github_url, clone_target } = body;
-        const projectsDir = join13(factoryDir, ".beastmode", "projects");
-        if (!existsSync15(projectsDir)) mkdirSync11(projectsDir, { recursive: true });
+        const projectsDir = join14(factoryDir, ".beastmode", "projects");
+        if (!existsSync16(projectsDir)) mkdirSync12(projectsDir, { recursive: true });
         let resolvedPath;
         if (github_url) {
           const url = github_url.trim();
@@ -5538,10 +6079,10 @@ function getBoardRoutes(factoryDir) {
           }
           const repoName = url.replace(/\.git$/, "").split(/[/:]/).filter(Boolean).pop() || "";
           if (!repoName) throw new Error("Could not derive repo name from URL");
-          const baseDir = clone_target ? resolve4(clone_target) : process.env.BEASTMODE_CLONE_DIR ? resolve4(process.env.BEASTMODE_CLONE_DIR) : join13(homedir(), "repos");
-          if (!existsSync15(baseDir)) mkdirSync11(baseDir, { recursive: true });
-          resolvedPath = join13(baseDir, repoName);
-          if (existsSync15(resolvedPath)) {
+          const baseDir = clone_target ? resolve4(clone_target) : process.env.BEASTMODE_CLONE_DIR ? resolve4(process.env.BEASTMODE_CLONE_DIR) : join14(homedir(), "repos");
+          if (!existsSync16(baseDir)) mkdirSync12(baseDir, { recursive: true });
+          resolvedPath = join14(baseDir, repoName);
+          if (existsSync16(resolvedPath)) {
             throw new Error(`Target path already exists: ${resolvedPath} \u2014 pick a different clone_target or rename the existing folder`);
           }
           const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN || "";
@@ -5573,42 +6114,41 @@ function getBoardRoutes(factoryDir) {
           }
         } else if (projectPath) {
           resolvedPath = resolve4(projectPath);
-          if (!existsSync15(resolvedPath)) throw new Error(`Directory not found: ${resolvedPath}`);
+          if (!existsSync16(resolvedPath)) throw new Error(`Directory not found: ${resolvedPath}`);
         } else {
           throw new Error("Missing required field: provide either `path` (local) or `github_url` (clone)");
         }
-        const projectName = basename3(resolvedPath);
+        const projectName = basename4(resolvedPath);
         const stack = detectStack(resolvedPath);
-        const projectConfig = {
+        let verifyPort = 3001;
+        for (const existing of listProjectRecords(projectsDir)) {
+          const port = existing.deploy?.verify_port;
+          if (typeof port === "number" && port >= verifyPort) verifyPort = port + 1;
+        }
+        const record = createProjectRecord({
           name: projectName,
-          path: resolvedPath,
-          repo: stack.git_remote || void 0,
-          stack: {
-            detected: stack.framework,
-            build_command: stack.suggested_commands.build,
-            dev_command: stack.suggested_commands.dev,
-            test_command: stack.suggested_commands.test,
-            install_command: stack.suggested_commands.install,
-            dev_port: stack.dev_port
-          },
-          deploy: { target: stack.suggested_deploy },
-          plugins: stack.suggested_plugins,
-          infra: {
-            credentials: {
-              mode: "factory"
-            },
-            state_backend: "auto"
-          }
+          resolvedPath,
+          gitRemote: stack.git_remote || void 0,
+          verifyPort
+        });
+        record.stack = {
+          detected: stack.framework,
+          build_command: stack.suggested_commands.build,
+          dev_command: stack.suggested_commands.dev,
+          test_command: stack.suggested_commands.test,
+          install_command: stack.suggested_commands.install,
+          dev_port: stack.dev_port,
+          is_monorepo: stack.is_monorepo,
+          total_packages: stack.total_packages,
+          primary_languages: stack.primary_languages,
+          ...stack.packages ? { packages: stack.packages } : {}
         };
-        const projName = projectName;
-        const projectFile = join13(projectsDir, `${projName}.json`);
-        writeFileSync12(projectFile, JSON.stringify(projectConfig, null, 2) + "\n", "utf-8");
-        const infraDir = join13(projectsDir, projName, "infra");
-        const terraformDir = join13(infraDir, "terraform");
-        const ciDir = join13(infraDir, "ci");
-        mkdirSync11(terraformDir, { recursive: true });
-        mkdirSync11(ciDir, { recursive: true });
-        return projectConfig;
+        record.infra = { credentials: { mode: "factory" }, state_backend: "auto" };
+        writeProjectRecord(projectsDir, projectName, record);
+        const infraDir = join14(projectsDir, projectName, "infra");
+        mkdirSync12(join14(infraDir, "terraform"), { recursive: true });
+        mkdirSync12(join14(infraDir, "ci"), { recursive: true });
+        return record;
       }
     },
     {
@@ -5617,14 +6157,14 @@ function getBoardRoutes(factoryDir) {
       handler: (_body, params) => {
         const { name } = params;
         assertSafeName(name);
-        const projectsDir = join13(factoryDir, ".beastmode", "projects");
-        const subDir = join13(projectsDir, name);
-        const flatPath = join13(projectsDir, `${name}.json`);
-        const hasSubDir = existsSync15(join13(subDir, "project.json"));
-        const hasFlat = existsSync15(flatPath);
+        const projectsDir = join14(factoryDir, ".beastmode", "projects");
+        const subDir = join14(projectsDir, name);
+        const flatPath = join14(projectsDir, `${name}.json`);
+        const hasSubDir = existsSync16(join14(subDir, "project.json"));
+        const hasFlat = existsSync16(flatPath);
         if (!hasSubDir && !hasFlat) throw new Error(`Project not found: ${name}`);
         if (hasSubDir) rmSync3(subDir, { recursive: true, force: true });
-        else if (existsSync15(subDir)) rmSync3(subDir, { recursive: true, force: true });
+        else if (existsSync16(subDir)) rmSync3(subDir, { recursive: true, force: true });
         if (hasFlat) unlinkSync3(flatPath);
         return { success: true };
       }
@@ -5635,20 +6175,17 @@ function getBoardRoutes(factoryDir) {
       handler: async (body, params, query) => {
         const { name } = params;
         assertSafeName(name);
-        const projectsDir = join13(factoryDir, ".beastmode", "projects");
-        const subDirConfigPath = join13(projectsDir, name, "project.json");
-        const flatConfigPath = join13(projectsDir, `${name}.json`);
-        const projPath = existsSync15(subDirConfigPath) ? subDirConfigPath : existsSync15(flatConfigPath) ? flatConfigPath : null;
-        if (!projPath) throw new Error(`Project not found: ${name}`);
-        const projConfig = JSON.parse(readFileSync12(projPath, "utf-8"));
+        const projectsDir = join14(factoryDir, ".beastmode", "projects");
+        const projConfig = readProjectRecord(projectsDir, name);
+        if (!projConfig) throw new Error(`Project not found: ${name}`);
         const projectPath = projConfig.path;
-        const subDir = join13(projectsDir, name);
-        if (!existsSync15(subDir)) mkdirSync11(subDir, { recursive: true });
+        const subDir = join14(projectsDir, name);
+        if (!existsSync16(subDir)) mkdirSync12(subDir, { recursive: true });
         const force = query?.force === "true" || query?.force === "1";
         const tier = body?.tier;
         if (tier === "quick") {
-          const brownfieldPath = join13(subDir, "brownfield.md");
-          if (!existsSync15(brownfieldPath)) {
+          const brownfieldPath = join14(subDir, "brownfield.md");
+          if (!existsSync16(brownfieldPath)) {
             const { detectStack: detectStackFn } = await Promise.resolve().then(() => (init_engine(), engine_exports));
             let stackInfo = "Unknown stack";
             try {
@@ -5659,7 +6196,7 @@ Build: ${cmds?.build || "unknown"}
 Dev: ${cmds?.dev || "unknown"}`;
             } catch {
             }
-            writeFileSync12(brownfieldPath, `# Brownfield Analysis: ${name}
+            writeFileSync13(brownfieldPath, `# Brownfield Analysis: ${name}
 
 ${stackInfo}
 
@@ -5681,8 +6218,8 @@ Path: ${projectPath}
         }
         const writeMeta = (m) => {
           try {
-            writeFileSync12(
-              join13(subDir, "codebase-guide.meta.json"),
+            writeFileSync13(
+              join14(subDir, "codebase-guide.meta.json"),
               JSON.stringify(m, null, 2) + "\n",
               "utf-8"
             );
@@ -5691,8 +6228,8 @@ Path: ${projectPath}
           }
         };
         if (!_hasClaudeCli()) {
-          const brownfieldPath = join13(subDir, "brownfield.md");
-          if (!existsSync15(brownfieldPath)) {
+          const brownfieldPath = join14(subDir, "brownfield.md");
+          if (!existsSync16(brownfieldPath)) {
             const { detectStack: detectStackFn } = await Promise.resolve().then(() => (init_engine(), engine_exports));
             let stackInfo = "Unknown stack";
             try {
@@ -5703,7 +6240,7 @@ Build: ${cmds?.build || "unknown"}
 Dev: ${cmds?.dev || "unknown"}`;
             } catch {
             }
-            writeFileSync12(brownfieldPath, `# Brownfield Analysis: ${name}
+            writeFileSync13(brownfieldPath, `# Brownfield Analysis: ${name}
 
 ${stackInfo}
 
@@ -5737,9 +6274,9 @@ Path: ${projectPath}
               "You are the Brownfield Analyst. Analyze the codebase at the current working directory.",
               `Write your output in pyramid format (L0/L1/L2) to the directory: ${subDir}`,
               "Produce exactly these four files:",
-              `  - ${join13(subDir, "codebase-guide.md")} (full L2 analysis: architecture, conventions, safe modification points, fragile areas)`,
-              `  - ${join13(subDir, "codebase-guide.l1.md")} (paragraph summary only)`,
-              `  - ${join13(subDir, "codebase-guide.l0.txt")} (one-sentence summary only)`,
+              `  - ${join14(subDir, "codebase-guide.md")} (full L2 analysis: architecture, conventions, safe modification points, fragile areas)`,
+              `  - ${join14(subDir, "codebase-guide.l1.md")} (paragraph summary only)`,
+              `  - ${join14(subDir, "codebase-guide.l0.txt")} (one-sentence summary only)`,
               "Do not write anything else outside the BEASTMODE_OUTPUT_DIR."
             ].join("\n");
             const isRoot = process.getuid?.() === 0;
@@ -5772,8 +6309,8 @@ Path: ${projectPath}
             child.on("close", (code) => {
               const durationSeconds = (Date.now() - startMs) / 1e3;
               const sha = _gitHeadSha(projectPath);
-              const guidePath = join13(subDir, "codebase-guide.md");
-              const ok = code === 0 && existsSync15(guidePath);
+              const guidePath = join14(subDir, "codebase-guide.md");
+              const ok = code === 0 && existsSync16(guidePath);
               if (ok) {
                 writeMeta({
                   analyzed_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -5783,8 +6320,8 @@ Path: ${projectPath}
                   duration_seconds: durationSeconds,
                   status: "complete"
                 });
-                const legacy = join13(subDir, "brownfield.md");
-                if (existsSync15(legacy)) {
+                const legacy = join14(subDir, "brownfield.md");
+                if (existsSync16(legacy)) {
                   try {
                     unlinkSync3(legacy);
                   } catch {
@@ -5860,7 +6397,7 @@ Path: ${projectPath}
       handler: (_body, params) => {
         const { name } = params;
         assertSafeName(name);
-        const projectsDir = join13(factoryDir, ".beastmode", "projects");
+        const projectsDir = join14(factoryDir, ".beastmode", "projects");
         const job = _analyzeJobs.get(name);
         const meta = _readAnalyzeMeta(projectsDir, name);
         if (job && job.status === "running") {
@@ -5904,13 +6441,13 @@ Path: ${projectPath}
       pattern: "/api/runs",
       handler: () => {
         const runsDir = getRunsDir(factoryDir);
-        if (!existsSync15(runsDir)) return { runs: [] };
+        if (!existsSync16(runsDir)) return { runs: [] };
         const runEntries = [];
-        for (const entry of readdirSync6(runsDir)) {
+        for (const entry of readdirSync8(runsDir)) {
           if (entry.startsWith(".")) continue;
-          const entryPath = join13(runsDir, entry);
+          const entryPath = join14(runsDir, entry);
           try {
-            const children = readdirSync6(entryPath);
+            const children = readdirSync8(entryPath);
             if (entry.startsWith("run-")) {
               if (children.length > 0) {
                 runEntries.push({ id: entry, dir: entryPath, projectId: "" });
@@ -5918,9 +6455,9 @@ Path: ${projectPath}
             } else {
               for (const child of children) {
                 if (!child.startsWith("run-") || child.startsWith(".")) continue;
-                const childPath = join13(entryPath, child);
+                const childPath = join14(entryPath, child);
                 try {
-                  const grandchildren = readdirSync6(childPath);
+                  const grandchildren = readdirSync8(childPath);
                   if (grandchildren.length > 0) {
                     runEntries.push({ id: child, dir: childPath, projectId: entry });
                   }
@@ -5940,9 +6477,9 @@ Path: ${projectPath}
           }
         }
         const runs = Array.from(deduped.values()).sort((a, b) => b.id.localeCompare(a.id)).map(({ id, dir, projectId }) => {
-          const manifest = readJsonFile(join13(dir, "manifest.json"));
-          const checkpoint = readJsonFile(join13(dir, "checkpoint.json"));
-          const prodVerif = readJsonFile(join13(dir, "prod-verification.json"));
+          const manifest = readJsonFile(join14(dir, "manifest.json"));
+          const checkpoint = readJsonFile(join14(dir, "checkpoint.json"));
+          const prodVerif = readJsonFile(join14(dir, "prod-verification.json"));
           const manifestData = manifest;
           const cpData = checkpoint;
           const prodAcceptFloor = 0.65;
@@ -5970,27 +6507,27 @@ Path: ${projectPath}
       handler: (_body, params, query) => {
         const { id } = params;
         const runsDir = getRunsDir(factoryDir);
-        let runDir = join13(runsDir, id);
-        if (!existsSync15(runDir)) {
-          for (const proj of readdirSync6(runsDir)) {
+        let runDir = join14(runsDir, id);
+        if (!existsSync16(runDir)) {
+          for (const proj of readdirSync8(runsDir)) {
             if (proj.startsWith(".") || proj.startsWith("run-")) continue;
-            const candidate = join13(runsDir, proj, id);
-            if (existsSync15(candidate)) {
+            const candidate = join14(runsDir, proj, id);
+            if (existsSync16(candidate)) {
               runDir = candidate;
               break;
             }
           }
         }
-        if (!existsSync15(runDir)) throw new Error(`Run not found: ${id}`);
-        const manifest = readJsonFile(join13(runDir, "manifest.json"));
-        const checkpoint = readJsonFile(join13(runDir, "checkpoint.json"));
-        const iterationsDir = join13(runDir, "iterations");
+        if (!existsSync16(runDir)) throw new Error(`Run not found: ${id}`);
+        const manifest = readJsonFile(join14(runDir, "manifest.json"));
+        const checkpoint = readJsonFile(join14(runDir, "checkpoint.json"));
+        const iterationsDir = join14(runDir, "iterations");
         const iterations = [];
-        if (existsSync15(iterationsDir)) {
-          const iterDirs = readdirSync6(iterationsDir).sort();
+        if (existsSync16(iterationsDir)) {
+          const iterDirs = readdirSync8(iterationsDir).sort();
           for (const iterDir of iterDirs) {
             const satisfaction = readJsonFile(
-              join13(iterationsDir, iterDir, "satisfaction.json")
+              join14(iterationsDir, iterDir, "satisfaction.json")
             );
             iterations.push({
               number: parseInt(iterDir, 10),
@@ -6018,11 +6555,11 @@ Path: ${projectPath}
       pattern: "/api/runs/archive",
       handler: () => {
         const runsDir = getRunsDir(factoryDir);
-        const configPath = join13(factoryDir, ".beastmode", "config.json");
+        const configPath = join14(factoryDir, ".beastmode", "config.json");
         let days = 7;
-        if (existsSync15(configPath)) {
+        if (existsSync16(configPath)) {
           try {
-            days = JSON.parse(readFileSync12(configPath, "utf-8")).archive_after_days || 7;
+            days = JSON.parse(readFileSync13(configPath, "utf-8")).archive_after_days || 7;
           } catch {
           }
         }
@@ -6048,8 +6585,8 @@ Path: ${projectPath}
       method: "GET",
       pattern: "/api/config",
       handler: () => {
-        const configPath = join13(factoryDir, ".beastmode", "config.json");
-        const raw = existsSync15(configPath) ? JSON.parse(readFileSync12(configPath, "utf-8")) : generateDefaults();
+        const configPath = join14(factoryDir, ".beastmode", "config.json");
+        const raw = existsSync16(configPath) ? JSON.parse(readFileSync13(configPath, "utf-8")) : generateDefaults();
         return raw;
       }
     },
@@ -6067,8 +6604,8 @@ Path: ${projectPath}
         const updatesClean = { ...updates };
         delete updatesClean.force;
         delete updatesClean._force;
-        const configPath = join13(factoryDir, ".beastmode", "config.json");
-        const current = existsSync15(configPath) ? JSON.parse(readFileSync12(configPath, "utf-8")) : generateDefaults();
+        const configPath = join14(factoryDir, ".beastmode", "config.json");
+        const current = existsSync16(configPath) ? JSON.parse(readFileSync13(configPath, "utf-8")) : generateDefaults();
         if (!force) {
           const oldPipeline = current.pipeline || {};
           const newPipeline = updatesClean.pipeline || {};
@@ -6099,11 +6636,11 @@ Path: ${projectPath}
           }
         }
         const merged = deepMerge2(current, updatesClean);
-        writeFileSync12(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        writeFileSync13(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
         const daemonConfigPaths = [
-          join13(factoryDir, "config", "beastmode.daemon.json"),
-          join13(factoryDir, "config", "beastmode.docker.json")
-        ].filter(existsSync15);
+          join14(factoryDir, "config", "beastmode.daemon.json"),
+          join14(factoryDir, "config", "beastmode.docker.json")
+        ].filter(existsSync16);
         const pipelineToDaemonMap = {
           satisfaction_threshold: ["verification", "satisfaction_threshold"],
           prod_accept_floor: ["verification", "prod_accept_floor"],
@@ -6119,7 +6656,7 @@ Path: ${projectPath}
         ];
         for (const daemonConfigPath of daemonConfigPaths) {
           try {
-            const daemonConfig = JSON.parse(readFileSync12(daemonConfigPath, "utf-8"));
+            const daemonConfig = JSON.parse(readFileSync13(daemonConfigPath, "utf-8"));
             let changed = false;
             for (const field of daemonFields) {
               if (field in merged && merged[field] !== daemonConfig[field]) {
@@ -6159,7 +6696,7 @@ Path: ${projectPath}
               }
             }
             if (changed) {
-              writeFileSync12(daemonConfigPath, JSON.stringify(daemonConfig, null, 2) + "\n", "utf-8");
+              writeFileSync13(daemonConfigPath, JSON.stringify(daemonConfig, null, 2) + "\n", "utf-8");
             }
           } catch {
           }
@@ -6172,10 +6709,10 @@ Path: ${projectPath}
       pattern: "/api/config/reset",
       handler: (body) => {
         const { keyPath } = body || {};
-        const configPath = join13(factoryDir, ".beastmode", "config.json");
-        const current = existsSync15(configPath) ? JSON.parse(readFileSync12(configPath, "utf-8")) : {};
+        const configPath = join14(factoryDir, ".beastmode", "config.json");
+        const current = existsSync16(configPath) ? JSON.parse(readFileSync13(configPath, "utf-8")) : {};
         const result = configReset(current, keyPath);
-        writeFileSync12(configPath, JSON.stringify(result, null, 2) + "\n", "utf-8");
+        writeFileSync13(configPath, JSON.stringify(result, null, 2) + "\n", "utf-8");
         return result;
       }
     },
@@ -6265,13 +6802,13 @@ Path: ${projectPath}
       handler: () => {
         const runsDir = getRunsDir(factoryDir);
         const retroDirs = [];
-        const rootRetroDir = join13(runsDir, ".retrospectives");
-        if (existsSync15(rootRetroDir)) retroDirs.push(rootRetroDir);
-        if (existsSync15(runsDir)) {
-          for (const entry of readdirSync6(runsDir)) {
+        const rootRetroDir = join14(runsDir, ".retrospectives");
+        if (existsSync16(rootRetroDir)) retroDirs.push(rootRetroDir);
+        if (existsSync16(runsDir)) {
+          for (const entry of readdirSync8(runsDir)) {
             if (entry === ".retrospectives" || entry.startsWith(".")) continue;
-            const projectRetroDir = join13(runsDir, entry, ".retrospectives");
-            if (existsSync15(projectRetroDir)) retroDirs.push(projectRetroDir);
+            const projectRetroDir = join14(runsDir, entry, ".retrospectives");
+            if (existsSync16(projectRetroDir)) retroDirs.push(projectRetroDir);
           }
         }
         if (retroDirs.length === 0) {
@@ -6280,9 +6817,9 @@ Path: ${projectPath}
         const retrospectives = [];
         const learnings = [];
         for (const retroDir of retroDirs) {
-          const retroFiles = readdirSync6(retroDir).filter((f) => f.startsWith("run-") && f.endsWith(".json")).sort().reverse();
+          const retroFiles = readdirSync8(retroDir).filter((f) => f.startsWith("run-") && f.endsWith(".json")).sort().reverse();
           for (const file of retroFiles) {
-            const data = readJsonFile(join13(retroDir, file));
+            const data = readJsonFile(join14(retroDir, file));
             if (!data) continue;
             const retro = data;
             retrospectives.push(retro);
@@ -6304,10 +6841,10 @@ Path: ${projectPath}
         let wisdom = "";
         let wisdomMeta = {};
         for (const retroDir of retroDirs) {
-          const wisdomPath = join13(retroDir, "wisdom.md");
-          if (existsSync15(wisdomPath)) {
-            wisdom = readFileSync12(wisdomPath, "utf-8");
-            wisdomMeta = readJsonFile(join13(retroDir, "wisdom-meta.json")) || {};
+          const wisdomPath = join14(retroDir, "wisdom.md");
+          if (existsSync16(wisdomPath)) {
+            wisdom = readFileSync13(wisdomPath, "utf-8");
+            wisdomMeta = readJsonFile(join14(retroDir, "wisdom-meta.json")) || {};
             break;
           }
         }
@@ -6319,11 +6856,11 @@ Path: ${projectPath}
       pattern: "/api/learnings/wisdom/refresh",
       handler: () => {
         const runsDir = getRunsDir(factoryDir);
-        const retroDir = join13(runsDir, ".retrospectives");
-        if (!existsSync15(retroDir)) {
-          mkdirSync11(retroDir, { recursive: true });
+        const retroDir = join14(runsDir, ".retrospectives");
+        if (!existsSync16(retroDir)) {
+          mkdirSync12(retroDir, { recursive: true });
         }
-        writeFileSync12(join13(retroDir, ".refresh-requested"), (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
+        writeFileSync13(join14(retroDir, ".refresh-requested"), (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
         return { success: true };
       }
     },
@@ -6332,29 +6869,29 @@ Path: ${projectPath}
       pattern: "/api/learnings/:runId/:index/dismiss",
       handler: (_body, params) => {
         const runsDir = getRunsDir(factoryDir);
-        const candidateDirs = [join13(runsDir, ".retrospectives")];
-        if (existsSync15(runsDir)) {
-          for (const entry of readdirSync6(runsDir)) {
+        const candidateDirs = [join14(runsDir, ".retrospectives")];
+        if (existsSync16(runsDir)) {
+          for (const entry of readdirSync8(runsDir)) {
             if (entry === ".retrospectives" || entry.startsWith(".")) continue;
-            candidateDirs.push(join13(runsDir, entry, ".retrospectives"));
+            candidateDirs.push(join14(runsDir, entry, ".retrospectives"));
           }
         }
         let filePath = null;
         for (const dir of candidateDirs) {
-          const candidate = join13(dir, `${params.runId}.json`);
-          if (existsSync15(candidate)) {
+          const candidate = join14(dir, `${params.runId}.json`);
+          if (existsSync16(candidate)) {
             filePath = candidate;
             break;
           }
         }
         if (!filePath) throw new Error(`Retrospective not found: ${params.runId}`);
-        const data = JSON.parse(readFileSync12(filePath, "utf-8"));
+        const data = JSON.parse(readFileSync13(filePath, "utf-8"));
         const idx = parseInt(params.index, 10);
         if (!Array.isArray(data.learnings) || idx < 0 || idx >= data.learnings.length) {
           throw new Error(`Learning index out of range: ${idx}`);
         }
         data.learnings[idx].dismissed = true;
-        writeFileSync12(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+        writeFileSync13(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
         return { success: true };
       }
     },
@@ -6363,29 +6900,29 @@ Path: ${projectPath}
       pattern: "/api/learnings/:runId/:index/restore",
       handler: (_body, params) => {
         const runsDir = getRunsDir(factoryDir);
-        const candidateDirs = [join13(runsDir, ".retrospectives")];
-        if (existsSync15(runsDir)) {
-          for (const entry of readdirSync6(runsDir)) {
+        const candidateDirs = [join14(runsDir, ".retrospectives")];
+        if (existsSync16(runsDir)) {
+          for (const entry of readdirSync8(runsDir)) {
             if (entry === ".retrospectives" || entry.startsWith(".")) continue;
-            candidateDirs.push(join13(runsDir, entry, ".retrospectives"));
+            candidateDirs.push(join14(runsDir, entry, ".retrospectives"));
           }
         }
         let filePath = null;
         for (const dir of candidateDirs) {
-          const candidate = join13(dir, `${params.runId}.json`);
-          if (existsSync15(candidate)) {
+          const candidate = join14(dir, `${params.runId}.json`);
+          if (existsSync16(candidate)) {
             filePath = candidate;
             break;
           }
         }
         if (!filePath) throw new Error(`Retrospective not found: ${params.runId}`);
-        const data = JSON.parse(readFileSync12(filePath, "utf-8"));
+        const data = JSON.parse(readFileSync13(filePath, "utf-8"));
         const idx = parseInt(params.index, 10);
         if (!Array.isArray(data.learnings) || idx < 0 || idx >= data.learnings.length) {
           throw new Error(`Learning index out of range: ${idx}`);
         }
         data.learnings[idx].dismissed = false;
-        writeFileSync12(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+        writeFileSync13(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
         return { success: true };
       }
     },
@@ -6528,22 +7065,22 @@ Path: ${projectPath}
         } catch {
         }
         try {
-          const runsDir = join13(factoryDir, "runs", project);
-          if (existsSync15(runsDir)) {
-            const runDirs = readdirSync6(runsDir).filter((d) => d.startsWith("run-"));
+          const runsDir = join14(factoryDir, "runs", project);
+          if (existsSync16(runsDir)) {
+            const runDirs = readdirSync8(runsDir).filter((d) => d.startsWith("run-"));
             for (const runId of runDirs) {
-              const ckptPath = join13(runsDir, runId, "checkpoint.json");
+              const ckptPath = join14(runsDir, runId, "checkpoint.json");
               let subtitle = "";
               let timestamp = "";
               try {
-                const st = statSync5(join13(runsDir, runId));
+                const st = statSync6(join14(runsDir, runId));
                 timestamp = st.mtime.toISOString();
               } catch {
                 timestamp = (/* @__PURE__ */ new Date()).toISOString();
               }
-              if (existsSync15(ckptPath)) {
+              if (existsSync16(ckptPath)) {
                 try {
-                  const ckpt = JSON.parse(readFileSync12(ckptPath, "utf-8"));
+                  const ckpt = JSON.parse(readFileSync13(ckptPath, "utf-8"));
                   const history = ckpt.satisfaction_history;
                   if (history && history.length > 0) {
                     const latest = history[history.length - 1];
@@ -6651,8 +7188,8 @@ __export(server_exports, {
 });
 import { createServer } from "http";
 import { createHmac } from "crypto";
-import { readFileSync as readFileSync13, existsSync as existsSync16 } from "fs";
-import { join as join14, dirname as dirname6 } from "path";
+import { readFileSync as readFileSync14, existsSync as existsSync17 } from "fs";
+import { join as join15, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { WebSocketServer as WebSocketServer2, WebSocket as WsClient } from "ws";
 function proxyBoardWebSocket(req, socket, head, boardWsUrl) {
@@ -6694,16 +7231,16 @@ function proxyBoardWebSocket(req, socket, head, boardWsUrl) {
   });
 }
 function resolveStaticDir() {
-  const devPath = join14(__dirname, "static");
-  if (existsSync16(join14(devPath, "index.html"))) {
+  const devPath = join15(__dirname, "static");
+  if (existsSync17(join15(devPath, "index.html"))) {
     return devPath;
   }
-  const distWebPath = join14(__dirname, "web");
-  if (existsSync16(join14(distWebPath, "index.html"))) {
+  const distWebPath = join15(__dirname, "web");
+  if (existsSync17(join15(distWebPath, "index.html"))) {
     return distWebPath;
   }
-  const siblingPath = join14(__dirname, "..", "web");
-  if (existsSync16(join14(siblingPath, "index.html"))) {
+  const siblingPath = join15(__dirname, "..", "web");
+  if (existsSync17(join15(siblingPath, "index.html"))) {
     return siblingPath;
   }
   throw new Error(
@@ -6812,9 +7349,9 @@ async function startServer(options = {}) {
     const fallback = "<html><body><h1>BeastMode Init Wizard</h1><p>Static files not found.</p></body></html>";
     if (!staticDir) return fallback;
     try {
-      const indexPath = join14(staticDir, "index.html");
-      if (!existsSync16(indexPath)) return fallback;
-      return readFileSync13(indexPath, "utf-8");
+      const indexPath = join15(staticDir, "index.html");
+      if (!existsSync17(indexPath)) return fallback;
+      return readFileSync14(indexPath, "utf-8");
     } catch {
       return fallback;
     }
@@ -6822,9 +7359,9 @@ async function startServer(options = {}) {
   function loadBoardHtml() {
     try {
       const dir = staticDir || resolveStaticDir();
-      const boardPath = join14(dir, "board.html");
-      if (!existsSync16(boardPath)) return null;
-      return readFileSync13(boardPath, "utf-8");
+      const boardPath = join15(dir, "board.html");
+      if (!existsSync17(boardPath)) return null;
+      return readFileSync14(boardPath, "utf-8");
     } catch {
       return null;
     }
@@ -6910,13 +7447,13 @@ async function startServer(options = {}) {
       let commit_sha = null;
       try {
         const dir = staticDir || resolveStaticDir();
-        const stampPath = join14(dir, "build-stamp.txt");
-        if (existsSync16(stampPath)) {
-          stamp = readFileSync13(stampPath, "utf-8").trim();
+        const stampPath = join15(dir, "build-stamp.txt");
+        if (existsSync17(stampPath)) {
+          stamp = readFileSync14(stampPath, "utf-8").trim();
         }
-        const commitPath = join14(dir, "build-commit.txt");
-        if (existsSync16(commitPath)) {
-          commit_sha = readFileSync13(commitPath, "utf-8").trim() || null;
+        const commitPath = join15(dir, "build-commit.txt");
+        if (existsSync17(commitPath)) {
+          commit_sha = readFileSync14(commitPath, "utf-8").trim() || null;
         }
       } catch {
       }
@@ -6994,8 +7531,8 @@ async function startServer(options = {}) {
     }
     if (method === "GET" && url.startsWith("/static/")) {
       const filename = url.slice("/static/".length);
-      const filePath = staticDir ? join14(staticDir, filename) : "";
-      if (filePath && existsSync16(filePath)) {
+      const filePath = staticDir ? join15(staticDir, filename) : "";
+      if (filePath && existsSync17(filePath)) {
         const ext = filename.split(".").pop()?.toLowerCase();
         const mimeTypes = {
           png: "image/png",
@@ -7006,7 +7543,7 @@ async function startServer(options = {}) {
           ico: "image/x-icon"
         };
         const contentType = mimeTypes[ext || ""] || "application/octet-stream";
-        const content = readFileSync13(filePath);
+        const content = readFileSync14(filePath);
         res.writeHead(200, {
           "Content-Type": contentType,
           "Content-Length": content.length.toString(),
@@ -7255,30 +7792,29 @@ var init_server = __esm({
 
 // src/cli/commands/board.ts
 import { Command } from "commander";
-import { resolve as resolve5, join as join15 } from "path";
-import { existsSync as existsSync17, readFileSync as readFileSync14, mkdirSync as mkdirSync12, writeFileSync as writeFileSync13, readdirSync as readdirSync7 } from "fs";
+import { resolve as resolve5, join as join16 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync15, mkdirSync as mkdirSync13, writeFileSync as writeFileSync14 } from "fs";
 import { execSync as execSync4 } from "child_process";
 function findFactoryDir(startDir) {
   let dir = startDir || process.cwd();
   const root = resolve5("/");
   while (dir !== root) {
-    if (existsSync17(join15(dir, ".beastmode", "factory.json"))) {
+    if (existsSync18(join16(dir, ".beastmode", "factory.json"))) {
       return dir;
     }
     const parent = resolve5(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
-  if (existsSync17(join15(dir, ".beastmode", "factory.json"))) {
+  if (existsSync18(join16(dir, ".beastmode", "factory.json"))) {
     return dir;
   }
   return null;
 }
 function inferProjectName(factoryDir) {
-  const projectsDir = join15(factoryDir, ".beastmode", "projects");
-  if (!existsSync17(projectsDir)) return null;
-  const files = readdirSync7(projectsDir).filter((f) => f.endsWith(".json"));
-  if (files.length === 1) return files[0].replace(/\.json$/, "");
+  const projectsDir = join16(factoryDir, ".beastmode", "projects");
+  const records = listProjectRecords(projectsDir);
+  if (records.length === 1) return records[0].name;
   return null;
 }
 function tryExecSync(cmd, timeoutMs = 15e3) {
@@ -7355,13 +7891,13 @@ async function runBoard(opts) {
   let factoryDir = findFactoryDir();
   if (!factoryDir) {
     factoryDir = process.cwd();
-    const bmDir = join15(factoryDir, ".beastmode");
-    if (!existsSync17(bmDir)) {
-      mkdirSync12(bmDir, { recursive: true });
+    const bmDir = join16(factoryDir, ".beastmode");
+    if (!existsSync18(bmDir)) {
+      mkdirSync13(bmDir, { recursive: true });
     }
-    const factoryJsonPath2 = join15(bmDir, "factory.json");
-    if (!existsSync17(factoryJsonPath2)) {
-      writeFileSync13(
+    const factoryJsonPath2 = join16(bmDir, "factory.json");
+    if (!existsSync18(factoryJsonPath2)) {
+      writeFileSync14(
         factoryJsonPath2,
         JSON.stringify({ factory_name: "BeastMode", created_at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
         "utf-8"
@@ -7369,8 +7905,8 @@ async function runBoard(opts) {
       info("No factory found \u2014 created minimal stub at .beastmode/factory.json");
     }
   }
-  const factoryJsonPath = join15(factoryDir, ".beastmode", "factory.json");
-  const factoryJson = JSON.parse(readFileSync14(factoryJsonPath, "utf-8"));
+  const factoryJsonPath = join16(factoryDir, ".beastmode", "factory.json");
+  const factoryJson = JSON.parse(readFileSync15(factoryJsonPath, "utf-8"));
   const factoryName = factoryJson.factory_name || "BeastMode Factory";
   header(`BeastMode Board \u2014 ${factoryName}`);
   const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
@@ -7409,6 +7945,7 @@ var init_board = __esm({
   "src/cli/commands/board.ts"() {
     "use strict";
     init_display();
+    init_engine();
     boardCommand = new Command("board").description("Launch the BeastMode Board web UI").option("--port <number>", "Port to serve on", "7669").option("--host <host>", "Host to bind to (use 0.0.0.0 for external access)", "127.0.0.1").action(async (opts) => {
       try {
         await runBoard(opts);
@@ -7442,26 +7979,26 @@ __export(sync_claude_creds_exports, {
 });
 import { Command as Command2 } from "commander";
 import { execSync as execSync5, spawnSync as spawnSync2 } from "child_process";
-import { writeFileSync as writeFileSync14, readFileSync as readFileSync15, chmodSync, mkdirSync as mkdirSync13, existsSync as existsSync18, unlinkSync as unlinkSync4 } from "fs";
-import { join as join16 } from "path";
+import { writeFileSync as writeFileSync15, readFileSync as readFileSync16, chmodSync, mkdirSync as mkdirSync14, existsSync as existsSync19, unlinkSync as unlinkSync4 } from "fs";
+import { join as join17 } from "path";
 import { homedir as homedir2, platform } from "os";
 function systemdUserDir() {
-  return join16(homedir2(), ".config", "systemd", "user");
+  return join17(homedir2(), ".config", "systemd", "user");
 }
 function systemdServicePath() {
-  return join16(systemdUserDir(), `${SYSTEMD_UNIT_NAME}.service`);
+  return join17(systemdUserDir(), `${SYSTEMD_UNIT_NAME}.service`);
 }
 function systemdTimerPath() {
-  return join16(systemdUserDir(), `${SYSTEMD_UNIT_NAME}.timer`);
+  return join17(systemdUserDir(), `${SYSTEMD_UNIT_NAME}.timer`);
 }
 function linuxCredsPath() {
-  return join16(homedir2(), ".claude", ".credentials.json");
+  return join17(homedir2(), ".claude", ".credentials.json");
 }
 function plistPath() {
-  return join16(homedir2(), "Library", "LaunchAgents", `${LAUNCH_AGENT_LABEL}.plist`);
+  return join17(homedir2(), "Library", "LaunchAgents", `${LAUNCH_AGENT_LABEL}.plist`);
 }
 function agentLogPath() {
-  return join16(homedir2(), ".beastmode", "logs", "sync-claude-creds.log");
+  return join17(homedir2(), ".beastmode", "logs", "sync-claude-creds.log");
 }
 function readKeychainTokenSafe() {
   try {
@@ -7493,10 +8030,10 @@ function writeCredentialsFile(rawJson) {
   if (!oauth?.accessToken) {
     throw new Error("Keychain entry missing claudeAiOauth.accessToken. Fix: run `claude login` again to reset the credential.");
   }
-  const claudeDir = join16(homedir2(), ".claude");
-  if (!existsSync18(claudeDir)) mkdirSync13(claudeDir, { recursive: true });
-  const credsPath = join16(claudeDir, ".credentials.json");
-  writeFileSync14(credsPath, rawJson + "\n", "utf-8");
+  const claudeDir = join17(homedir2(), ".claude");
+  if (!existsSync19(claudeDir)) mkdirSync14(claudeDir, { recursive: true });
+  const credsPath = join17(claudeDir, ".credentials.json");
+  writeFileSync15(credsPath, rawJson + "\n", "utf-8");
   chmodSync(credsPath, 384);
   if (oauth.expiresAt) {
     const hoursLeft = Math.round((oauth.expiresAt - Date.now()) / 36e5);
@@ -7509,7 +8046,7 @@ function writeCredentialsFile(rawJson) {
   return credsPath;
 }
 function urgencyMarkerHostPath(factoryDir) {
-  return join16(factoryDir, "daemon", "logs", ".cred-refresh-needed");
+  return join17(factoryDir, "daemon", "logs", ".cred-refresh-needed");
 }
 function removeUrgencyMarker(factoryDir) {
   if (!factoryDir) return;
@@ -7523,7 +8060,7 @@ function buildPlist(intervalSeconds, factoryDir) {
   const nodePath = process.execPath;
   const cliEntry = process.argv[1];
   const logPath = agentLogPath();
-  const keychainPath = join16(homedir2(), "Library", "Keychains", "login.keychain-db");
+  const keychainPath = join17(homedir2(), "Library", "Keychains", "login.keychain-db");
   const watchPaths = [keychainPath];
   if (factoryDir) {
     watchPaths.push(urgencyMarkerHostPath(factoryDir));
@@ -7563,15 +8100,15 @@ function installAgent(intervalSeconds, {
 } = {}) {
   const plist = plistPath();
   const logPath = agentLogPath();
-  mkdirSync13(join16(homedir2(), "Library", "LaunchAgents"), { recursive: true });
-  mkdirSync13(join16(homedir2(), ".beastmode", "logs"), { recursive: true });
+  mkdirSync14(join17(homedir2(), "Library", "LaunchAgents"), { recursive: true });
+  mkdirSync14(join17(homedir2(), ".beastmode", "logs"), { recursive: true });
   const uid = process.getuid?.();
-  if (existsSync18(plist)) {
+  if (existsSync19(plist)) {
     spawnSync2("launchctl", ["bootout", `gui/${uid}`, plist], { stdio: "pipe" });
   }
   const resolvedFactory = factoryDir ?? findFactoryDir() ?? void 0;
-  writeFileSync14(plist, buildPlist(intervalSeconds, resolvedFactory), "utf-8");
-  writeFileSync14(logPath, "", { flag: "a" });
+  writeFileSync15(plist, buildPlist(intervalSeconds, resolvedFactory), "utf-8");
+  writeFileSync15(logPath, "", { flag: "a" });
   const result = spawnSync2("launchctl", ["bootstrap", `gui/${uid}`, plist], {
     stdio: "pipe",
     encoding: "utf-8"
@@ -7609,7 +8146,7 @@ function syncClaudeCredsOnce() {
 function uninstallAgent() {
   const plist = plistPath();
   const uid = process.getuid?.();
-  if (!existsSync18(plist)) {
+  if (!existsSync19(plist)) {
     info("No LaunchAgent installed \u2014 nothing to remove.");
     return;
   }
@@ -7629,7 +8166,7 @@ function uninstallAgent() {
 function showStatus() {
   const plist = plistPath();
   const uid = process.getuid?.();
-  if (!existsSync18(plist)) {
+  if (!existsSync19(plist)) {
     info("LaunchAgent not installed.");
     info("Install with: beastmode sync-claude-creds --install");
     return;
@@ -7653,14 +8190,14 @@ function showStatus() {
 }
 function syncClaudeCredsLinux() {
   const credsPath = linuxCredsPath();
-  if (!existsSync18(credsPath)) {
+  if (!existsSync19(credsPath)) {
     return {
       error: `${credsPath} not found \u2014 run \`claude login\` first`
     };
   }
   let parsed;
   try {
-    const raw = readFileSync15(credsPath, "utf-8");
+    const raw = readFileSync16(credsPath, "utf-8");
     parsed = JSON.parse(raw);
   } catch {
     return {
@@ -7689,7 +8226,7 @@ function syncClaudeCredsLinux() {
         );
       }
       try {
-        const raw2 = readFileSync15(credsPath, "utf-8");
+        const raw2 = readFileSync16(credsPath, "utf-8");
         const parsed2 = JSON.parse(raw2);
         if (parsed2.claudeAiOauth?.expiresAt) {
           const newMinutes = (parsed2.claudeAiOauth.expiresAt - Date.now()) / 6e4;
@@ -7743,18 +8280,18 @@ function installAgentLinux(intervalSeconds, { throwOnError = false } = {}) {
     process.exit(1);
   }
   const unitDir = systemdUserDir();
-  const logDir = join16(homedir2(), ".beastmode", "logs");
-  mkdirSync13(unitDir, { recursive: true });
-  mkdirSync13(logDir, { recursive: true });
-  const logPath = join16(logDir, "sync-claude-creds.log");
+  const logDir = join17(homedir2(), ".beastmode", "logs");
+  mkdirSync14(unitDir, { recursive: true });
+  mkdirSync14(logDir, { recursive: true });
+  const logPath = join17(logDir, "sync-claude-creds.log");
   const nodePath = process.execPath;
   const cliEntry = process.argv[1];
-  writeFileSync14(
+  writeFileSync15(
     systemdServicePath(),
     buildServiceUnit(nodePath, cliEntry, logPath),
     "utf-8"
   );
-  writeFileSync14(
+  writeFileSync15(
     systemdTimerPath(),
     buildTimerUnit(intervalSeconds),
     "utf-8"
@@ -7805,14 +8342,14 @@ function uninstallAgentLinux() {
   const servicePath = systemdServicePath();
   const timerPath = systemdTimerPath();
   let removed = false;
-  if (existsSync18(servicePath)) {
+  if (existsSync19(servicePath)) {
     try {
       unlinkSync4(servicePath);
       removed = true;
     } catch {
     }
   }
-  if (existsSync18(timerPath)) {
+  if (existsSync19(timerPath)) {
     try {
       unlinkSync4(timerPath);
       removed = true;
@@ -7832,7 +8369,7 @@ function statusAgentLinux() {
     error(unavail);
     return;
   }
-  if (!existsSync18(systemdTimerPath())) {
+  if (!existsSync19(systemdTimerPath())) {
     info("Systemd timer not installed.");
     info("Install with: beastmode sync-claude-creds --install");
     return;
@@ -7991,26 +8528,26 @@ var init_sync_claude_creds = __esm({
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z2 } from "zod";
-import { readFileSync as readFileSync28, writeFileSync as writeFileSync24, existsSync as existsSync31, readdirSync as readdirSync11, mkdirSync as mkdirSync19 } from "fs";
-import { join as join29, resolve as resolve18, basename as basename5 } from "path";
+import { readFileSync as readFileSync29, writeFileSync as writeFileSync25, existsSync as existsSync32, readdirSync as readdirSync12 } from "fs";
+import { join as join30, resolve as resolve18, basename as basename6 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 function readJsonFile2(filePath) {
-  if (!existsSync31(filePath)) return null;
+  if (!existsSync32(filePath)) return null;
   try {
-    return JSON.parse(readFileSync28(filePath, "utf-8"));
+    return JSON.parse(readFileSync29(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function getFactoryPath() {
   const envPath = process.env.BEASTMODE_FACTORY_PATH;
-  if (envPath && existsSync31(join29(envPath, ".beastmode", "factory.json"))) {
+  if (envPath && existsSync32(join30(envPath, ".beastmode", "factory.json"))) {
     return envPath;
   }
   let dir = process.cwd();
   const root = resolve18("/");
   while (dir !== root) {
-    if (existsSync31(join29(dir, ".beastmode", "factory.json"))) {
+    if (existsSync32(join30(dir, ".beastmode", "factory.json"))) {
       return dir;
     }
     const parent = resolve18(dir, "..");
@@ -8022,17 +8559,17 @@ function getFactoryPath() {
   );
 }
 function readFactoryStatus(factoryDir) {
-  const bmDir = join29(factoryDir, ".beastmode");
+  const bmDir = join30(factoryDir, ".beastmode");
   const factoryIdentity = FactoryIdentitySchema.parse(
-    JSON.parse(readFileSync28(join29(bmDir, "factory.json"), "utf-8"))
+    JSON.parse(readFileSync29(join30(bmDir, "factory.json"), "utf-8"))
   );
-  const projectsDir = join29(bmDir, "projects");
-  const projectCount = existsSync31(projectsDir) ? readdirSync11(projectsDir).filter((f) => f.endsWith(".json")).length : 0;
-  const lockPath = join29(bmDir, "extensions.lock");
+  const projectsDir = join30(bmDir, "projects");
+  const projectCount = listProjectRecords(projectsDir).length;
+  const lockPath = join30(bmDir, "extensions.lock");
   let pluginNames = [];
-  if (existsSync31(lockPath)) {
+  if (existsSync32(lockPath)) {
     try {
-      const lock = JSON.parse(readFileSync28(lockPath, "utf-8"));
+      const lock = JSON.parse(readFileSync29(lockPath, "utf-8"));
       pluginNames = Object.keys(lock.plugins || {});
     } catch {
     }
@@ -8052,23 +8589,23 @@ function readFactoryStatus(factoryDir) {
     skillCount = listSkills(factoryDir).length;
   } catch {
   }
-  const runsDir = join29(factoryDir, "runs");
+  const runsDir = join30(factoryDir, "runs");
   let runDirs = [];
-  if (existsSync31(runsDir)) {
-    runDirs = readdirSync11(runsDir).filter((d) => {
+  if (existsSync32(runsDir)) {
+    runDirs = readdirSync12(runsDir).filter((d) => {
       try {
-        return readdirSync11(join29(runsDir, d)).length > 0;
+        return readdirSync12(join30(runsDir, d)).length > 0;
       } catch {
         return false;
       }
     }).sort();
   }
-  const pidFile = join29(bmDir, "daemon.pid");
+  const pidFile = join30(bmDir, "daemon.pid");
   let daemonPid = null;
   let pidAlive = false;
-  if (existsSync31(pidFile)) {
+  if (existsSync32(pidFile)) {
     try {
-      daemonPid = parseInt(readFileSync28(pidFile, "utf-8").trim(), 10);
+      daemonPid = parseInt(readFileSync29(pidFile, "utf-8").trim(), 10);
       process.kill(daemonPid, 0);
       pidAlive = true;
     } catch {
@@ -8089,18 +8626,18 @@ function readFactoryStatus(factoryDir) {
   return collectStatus(input);
 }
 function readBoardItems(factoryDir) {
-  const filePath = join29(factoryDir, ".beastmode", "board.json");
-  if (!existsSync31(filePath)) return [];
+  const filePath = join30(factoryDir, ".beastmode", "board.json");
+  if (!existsSync32(filePath)) return [];
   try {
-    const raw = JSON.parse(readFileSync28(filePath, "utf-8"));
+    const raw = JSON.parse(readFileSync29(filePath, "utf-8"));
     return Array.isArray(raw.items) ? raw.items : [];
   } catch {
     return [];
   }
 }
 function writeBoardItems(factoryDir, items) {
-  const filePath = join29(factoryDir, ".beastmode", "board.json");
-  writeFileSync24(filePath, JSON.stringify({ items }, null, 2) + "\n", "utf-8");
+  const filePath = join30(factoryDir, ".beastmode", "board.json");
+  writeFileSync25(filePath, JSON.stringify({ items }, null, 2) + "\n", "utf-8");
 }
 function createMcpServer() {
   const server = new McpServer(
@@ -8123,8 +8660,8 @@ function createMcpServer() {
     { key_path: z2.string().describe("Dot-notation key path") },
     async ({ key_path }) => {
       const factoryDir = getFactoryPath();
-      const configPath = join29(factoryDir, ".beastmode", "config.json");
-      const config = existsSync31(configPath) ? JSON.parse(readFileSync28(configPath, "utf-8")) : generateDefaults();
+      const configPath = join30(factoryDir, ".beastmode", "config.json");
+      const config = existsSync32(configPath) ? JSON.parse(readFileSync29(configPath, "utf-8")) : generateDefaults();
       try {
         const value = configGet(config, key_path);
         return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
@@ -8142,11 +8679,11 @@ function createMcpServer() {
     },
     async ({ key_path, value }) => {
       const factoryDir = getFactoryPath();
-      const configPath = join29(factoryDir, ".beastmode", "config.json");
-      const config = existsSync31(configPath) ? JSON.parse(readFileSync28(configPath, "utf-8")) : generateDefaults();
+      const configPath = join30(factoryDir, ".beastmode", "config.json");
+      const config = existsSync32(configPath) ? JSON.parse(readFileSync29(configPath, "utf-8")) : generateDefaults();
       const coerced = coerceValue(value);
       const updated = configSet(config, key_path, coerced);
-      writeFileSync24(configPath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+      writeFileSync25(configPath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
       return { content: [{ type: "text", text: `Set ${key_path} = ${JSON.stringify(coerced)}` }] };
     }
   );
@@ -8180,14 +8717,14 @@ function createMcpServer() {
     {},
     async () => {
       const factoryDir = getFactoryPath();
-      const runsDir = join29(factoryDir, "runs");
-      if (!existsSync31(runsDir)) {
+      const runsDir = join30(factoryDir, "runs");
+      if (!existsSync32(runsDir)) {
         return { content: [{ type: "text", text: "No runs directory found." }] };
       }
-      const runDirs = readdirSync11(runsDir).sort().reverse();
+      const runDirs = readdirSync12(runsDir).sort().reverse();
       const activeRuns = [];
       for (const id of runDirs.slice(0, 10)) {
-        const cp = readJsonFile2(join29(runsDir, id, "checkpoint.json"));
+        const cp = readJsonFile2(join30(runsDir, id, "checkpoint.json"));
         if (cp) {
           activeRuns.push({ id, checkpoint: cp });
         }
@@ -8201,17 +8738,17 @@ function createMcpServer() {
     { run_id: z2.string().describe("Run ID (directory name)") },
     async ({ run_id }) => {
       const factoryDir = getFactoryPath();
-      const runDir = join29(factoryDir, "runs", run_id);
-      if (!existsSync31(runDir)) {
+      const runDir = join30(factoryDir, "runs", run_id);
+      if (!existsSync32(runDir)) {
         return { content: [{ type: "text", text: `Run not found: ${run_id}` }], isError: true };
       }
-      const manifest = readJsonFile2(join29(runDir, "manifest.json"));
-      const checkpoint = readJsonFile2(join29(runDir, "checkpoint.json"));
-      const iterationsDir = join29(runDir, "iterations");
+      const manifest = readJsonFile2(join30(runDir, "manifest.json"));
+      const checkpoint = readJsonFile2(join30(runDir, "checkpoint.json"));
+      const iterationsDir = join30(runDir, "iterations");
       const iterations = [];
-      if (existsSync31(iterationsDir)) {
-        for (const dir of readdirSync11(iterationsDir).sort()) {
-          const satisfaction = readJsonFile2(join29(iterationsDir, dir, "satisfaction.json"));
+      if (existsSync32(iterationsDir)) {
+        for (const dir of readdirSync12(iterationsDir).sort()) {
+          const satisfaction = readJsonFile2(join30(iterationsDir, dir, "satisfaction.json"));
           iterations.push({ number: parseInt(dir, 10), satisfaction });
         }
       }
@@ -8257,12 +8794,12 @@ function createMcpServer() {
     {},
     async () => {
       const factoryDir = getFactoryPath();
-      const bmDir = join29(factoryDir, ".beastmode");
+      const bmDir = join30(factoryDir, ".beastmode");
       let plugins = {};
-      const lockPath = join29(bmDir, "extensions.lock");
-      if (existsSync31(lockPath)) {
+      const lockPath = join30(bmDir, "extensions.lock");
+      if (existsSync32(lockPath)) {
         try {
-          const lock = JSON.parse(readFileSync28(lockPath, "utf-8"));
+          const lock = JSON.parse(readFileSync29(lockPath, "utf-8"));
           plugins = lock.plugins || {};
         } catch {
         }
@@ -8296,17 +8833,8 @@ function createMcpServer() {
     {},
     async () => {
       const factoryDir = getFactoryPath();
-      const projectsDir = join29(factoryDir, ".beastmode", "projects");
-      if (!existsSync31(projectsDir)) {
-        return { content: [{ type: "text", text: "[]" }] };
-      }
-      const projects = readdirSync11(projectsDir).filter((f) => f.endsWith(".json")).map((f) => {
-        try {
-          return JSON.parse(readFileSync28(join29(projectsDir, f), "utf-8"));
-        } catch {
-          return null;
-        }
-      }).filter(Boolean);
+      const projectsDir = join30(factoryDir, ".beastmode", "projects");
+      const projects = listProjectRecords(projectsDir);
       return { content: [{ type: "text", text: JSON.stringify(projects, null, 2) }] };
     }
   );
@@ -8317,34 +8845,25 @@ function createMcpServer() {
     async ({ path: projectPath }) => {
       const factoryDir = getFactoryPath();
       const resolvedPath = resolve18(projectPath);
-      if (!existsSync31(resolvedPath)) {
+      if (!existsSync32(resolvedPath)) {
         return { content: [{ type: "text", text: `Directory not found: ${resolvedPath}` }], isError: true };
       }
-      const projectName = basename5(resolvedPath);
+      const projectName = basename6(resolvedPath);
       const stack = detectStack(resolvedPath);
-      const projectConfig = {
+      const projectsDir = join30(factoryDir, ".beastmode", "projects");
+      let verifyPort = 3001;
+      for (const existing of listProjectRecords(projectsDir)) {
+        const port = existing.deploy?.verify_port;
+        if (typeof port === "number" && port >= verifyPort) verifyPort = port + 1;
+      }
+      const record = createProjectRecord({
         name: projectName,
-        path: resolvedPath,
-        repo: stack.git_remote || void 0,
-        stack: {
-          detected: stack.framework,
-          build_command: stack.suggested_commands.build,
-          dev_command: stack.suggested_commands.dev,
-          test_command: stack.suggested_commands.test,
-          install_command: stack.suggested_commands.install,
-          dev_port: stack.dev_port
-        },
-        deploy: { target: stack.suggested_deploy },
-        plugins: stack.suggested_plugins
-      };
-      const projectsDir = join29(factoryDir, ".beastmode", "projects");
-      mkdirSync19(projectsDir, { recursive: true });
-      writeFileSync24(
-        join29(projectsDir, `${projectName}.json`),
-        JSON.stringify(projectConfig, null, 2) + "\n",
-        "utf-8"
-      );
-      return { content: [{ type: "text", text: JSON.stringify(projectConfig, null, 2) }] };
+        resolvedPath,
+        gitRemote: stack.git_remote || void 0,
+        verifyPort
+      });
+      writeProjectRecord(projectsDir, projectName, record);
+      return { content: [{ type: "text", text: JSON.stringify(record, null, 2) }] };
     }
   );
   server.tool(
@@ -8447,17 +8966,17 @@ init_engine();
 init_file_writer();
 import { Command as Command3 } from "commander";
 import inquirer from "inquirer";
-import { resolve as resolve6, basename as basename4, join as join17 } from "path";
-import { existsSync as existsSync19, writeFileSync as writeFileSync15, mkdirSync as mkdirSync14, readFileSync as readFileSync16 } from "fs";
+import { resolve as resolve6, basename as basename5, join as join18 } from "path";
+import { existsSync as existsSync20, writeFileSync as writeFileSync16, mkdirSync as mkdirSync15, readFileSync as readFileSync17 } from "fs";
 
 // src/cli/utils/docker.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join9 } from "path";
 import { execSync } from "child_process";
 var GHCR_IMAGE_PREFIX = "ghcr.io/develeap/beastmode";
 function findComposeFile(dir) {
-  const path = join8(dir, "docker-compose.yml");
-  return existsSync9(path) ? path : null;
+  const path = join9(dir, "docker-compose.yml");
+  return existsSync10(path) ? path : null;
 }
 function requireComposeFile(dir) {
   const path = findComposeFile(dir);
@@ -8520,7 +9039,7 @@ function loginToGhcr(token) {
   }
 }
 function seedConfigFromImage(targetDir, tag) {
-  const configDir = join8(targetDir, "config");
+  const configDir = join9(targetDir, "config");
   const containerName = "bm-config-seed";
   try {
     try {
@@ -8700,15 +9219,15 @@ function collect(val, acc) {
   return acc;
 }
 function readSecretFile(filePath) {
-  return readFileSync16(resolve6(filePath), "utf-8").trim();
+  return readFileSync17(resolve6(filePath), "utf-8").trim();
 }
 function isSourceRepo(dir) {
-  return existsSync19(resolve6(dir, "daemon")) && existsSync19(resolve6(dir, "board")) && existsSync19(resolve6(dir, "cli"));
+  return existsSync20(resolve6(dir, "daemon")) && existsSync20(resolve6(dir, "board")) && existsSync20(resolve6(dir, "cli"));
 }
 async function runInit(name, opts) {
   if (opts.ui) {
     const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
-    const factoryName2 = name || basename4(resolve6("."));
+    const factoryName2 = name || basename5(resolve6("."));
     const projectPath2 = opts.project ? resolve6(opts.project) : void 0;
     info("Starting init wizard...");
     const uiServer = await startServer2({
@@ -8741,8 +9260,8 @@ async function runInit(name, opts) {
   const totalSteps = 5;
   header("BeastMode \u2014 Dark Factory Init");
   info("Creating your Custom Dark Factory\n");
-  const factoryName = name || basename4(resolve6("."));
-  if (existsSync19(factoryName) && existsSync19(resolve6(factoryName, ".beastmode"))) {
+  const factoryName = name || basename5(resolve6("."));
+  if (existsSync20(factoryName) && existsSync20(resolve6(factoryName, ".beastmode"))) {
     throw new Error(`Factory already exists at ./${factoryName}. Use 'beastmode config' to modify.`);
   }
   if (opts.from) {
@@ -8757,7 +9276,7 @@ async function runInit(name, opts) {
     }
     const templateProjectPath = resolve6(opts.project);
     const templateStack = detectStack(templateProjectPath);
-    const templateProjectName = basename4(templateProjectPath);
+    const templateProjectName = basename5(templateProjectPath);
     const actions2 = scaffoldFactory(factoryName, template.config, {
       name: templateProjectName,
       repo: templateStack.git_remote || void 0,
@@ -8792,7 +9311,7 @@ async function runInit(name, opts) {
         name: "project",
         message: "Path to your project:",
         default: ".",
-        validate: (input) => existsSync19(resolve6(input)) || `Directory not found: ${input}`
+        validate: (input) => existsSync20(resolve6(input)) || `Directory not found: ${input}`
       }
     ]);
     projectPath = resolve6(answer.project);
@@ -8952,7 +9471,7 @@ async function runInit(name, opts) {
     success("Board UI password set");
   }
   step(5, totalSteps, "Boot");
-  const projectName = basename4(projectPath);
+  const projectName = basename5(projectPath);
   const actions = scaffoldFactory(factoryName, config, {
     name: projectName,
     repo: stack.git_remote || void 0,
@@ -9098,14 +9617,14 @@ async function runImageModeInit(name, opts) {
   let projectPath;
   if (opts.project) {
     projectPath = resolve6(opts.project);
-    if (!existsSync19(projectPath)) {
+    if (!existsSync20(projectPath)) {
       error(`--project path does not exist: ${projectPath}`);
       process.exit(1);
     }
     success(`Project path: ${projectPath}`);
   } else if (opts.yes) {
     const cwd = resolve6(".");
-    if (!existsSync19(join17(cwd, ".git"))) {
+    if (!existsSync20(join18(cwd, ".git"))) {
       error(
         "--project is required in non-interactive mode (--yes) unless you run from inside a git repository. Pass --project <path> or cd into your project clone first."
       );
@@ -9122,8 +9641,8 @@ async function runImageModeInit(name, opts) {
         default: ".",
         validate: (input) => {
           const p = resolve6(input);
-          if (!existsSync19(p)) return `Directory not found: ${p}`;
-          if (!existsSync19(join17(p, ".git"))) {
+          if (!existsSync20(p)) return `Directory not found: ${p}`;
+          if (!existsSync20(join18(p, ".git"))) {
             return `Not a git repo: ${p} (run 'git init' first, or pick a different path)`;
           }
           return true;
@@ -9162,9 +9681,9 @@ async function runImageModeInit(name, opts) {
     success("Authenticated to ghcr.io");
   }
   step(3, totalSteps, "Generate");
-  mkdirSync14(targetDir, { recursive: true });
+  mkdirSync15(targetDir, { recursive: true });
   const composeContent = generateComposeYaml("latest");
-  writeFileSync15(join17(targetDir, "docker-compose.yml"), composeContent, "utf-8");
+  writeFileSync16(join18(targetDir, "docker-compose.yml"), composeContent, "utf-8");
   success("docker-compose.yml");
   const envLines = [
     "# BeastMode environment \u2014 DO NOT COMMIT",
@@ -9204,10 +9723,10 @@ async function runImageModeInit(name, opts) {
     "# PROJECT_REPO=owner/repo",
     ""
   ];
-  writeFileSync15(join17(targetDir, ".env"), envLines.join("\n"), "utf-8");
+  writeFileSync16(join18(targetDir, ".env"), envLines.join("\n"), "utf-8");
   success(`.env (PROJECT_DIR=${projectPath}, two-PAT model)`);
   for (const dir of ["data", "runs", "daemon/logs", ".beastmode", "config"]) {
-    mkdirSync14(join17(targetDir, dir), { recursive: true });
+    mkdirSync15(join18(targetDir, dir), { recursive: true });
   }
   step(4, totalSteps, "Pull Images");
   try {
@@ -9296,20 +9815,20 @@ async function runImageModeInit(name, opts) {
 init_export_adapter();
 init_display();
 import { Command as Command4 } from "commander";
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync16, existsSync as existsSync20, readdirSync as readdirSync8 } from "fs";
-import { resolve as resolve7, join as join18 } from "path";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync17, existsSync as existsSync21, readdirSync as readdirSync9 } from "fs";
+import { resolve as resolve7, join as join19 } from "path";
 function exportFactory(factoryDir, outputPath) {
-  const bmDir = join18(factoryDir, ".beastmode");
-  const configPath = join18(bmDir, "config.json");
-  if (!existsSync20(configPath)) {
+  const bmDir = join19(factoryDir, ".beastmode");
+  const configPath = join19(bmDir, "config.json");
+  if (!existsSync21(configPath)) {
     throw new Error(`No factory found at ${factoryDir}`);
   }
-  const config = JSON.parse(readFileSync17(configPath, "utf-8"));
-  const identity = JSON.parse(readFileSync17(join18(bmDir, "factory.json"), "utf-8"));
+  const config = JSON.parse(readFileSync18(configPath, "utf-8"));
+  const identity = JSON.parse(readFileSync18(join19(bmDir, "factory.json"), "utf-8"));
   let plugins = [];
-  const lockPath = join18(bmDir, "extensions.lock");
-  if (existsSync20(lockPath)) {
-    const lock = JSON.parse(readFileSync17(lockPath, "utf-8"));
+  const lockPath = join19(bmDir, "extensions.lock");
+  if (existsSync21(lockPath)) {
+    const lock = JSON.parse(readFileSync18(lockPath, "utf-8"));
     plugins = Object.keys(lock.plugins || {});
   }
   const template = {
@@ -9318,7 +9837,7 @@ function exportFactory(factoryDir, outputPath) {
     config,
     plugins
   };
-  writeFileSync16(outputPath, JSON.stringify(template, null, 2) + "\n", "utf-8");
+  writeFileSync17(outputPath, JSON.stringify(template, null, 2) + "\n", "utf-8");
 }
 function findRunDir(runId) {
   const candidates = [
@@ -9326,7 +9845,7 @@ function findRunDir(runId) {
     resolve7(".", runId)
   ];
   for (const candidate of candidates) {
-    if (existsSync20(candidate)) {
+    if (existsSync21(candidate)) {
       return candidate;
     }
   }
@@ -9340,23 +9859,23 @@ function createArtifactExportCommand(artifact) {
       const runDir = findRunDir(opts.run);
       let sourceContent;
       if (artifact === "scenarios") {
-        const scenariosDir = join18(runDir, "scenarios");
-        if (!existsSync20(scenariosDir)) {
+        const scenariosDir = join19(runDir, "scenarios");
+        if (!existsSync21(scenariosDir)) {
           throw new Error(`No scenarios directory found in run ${opts.run}`);
         }
-        const files = readdirSync8(scenariosDir).filter((f) => f.endsWith(".md")).sort();
-        sourceContent = files.map((f) => readFileSync17(join18(scenariosDir, f), "utf-8")).join("\n\n---\n\n");
+        const files = readdirSync9(scenariosDir).filter((f) => f.endsWith(".md")).sort();
+        sourceContent = files.map((f) => readFileSync18(join19(scenariosDir, f), "utf-8")).join("\n\n---\n\n");
       } else {
         const artifactFile = artifact === "nlspec" ? "nlspec.md" : "plan.md";
-        const artifactPath = join18(runDir, artifactFile);
-        if (!existsSync20(artifactPath)) {
+        const artifactPath = join19(runDir, artifactFile);
+        if (!existsSync21(artifactPath)) {
           throw new Error(`${artifactFile} not found in run ${opts.run}`);
         }
-        sourceContent = readFileSync17(artifactPath, "utf-8");
+        sourceContent = readFileSync18(artifactPath, "utf-8");
       }
       const result = runExportAdapter(opts.adapter, sourceContent);
       if (opts.output) {
-        writeFileSync16(resolve7(opts.output), result, "utf-8");
+        writeFileSync17(resolve7(opts.output), result, "utf-8");
         header(`Exported ${artifact}`);
         success(`Written to: ${opts.output}`);
       } else {
@@ -9580,15 +10099,15 @@ init_presets();
 init_display();
 import { Command as Command8 } from "commander";
 import { resolve as resolve11 } from "path";
-import { readFileSync as readFileSync18, existsSync as existsSync21 } from "fs";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync19, existsSync as existsSync22 } from "fs";
+import { join as join20 } from "path";
 function listPluginsAction(factoryDir) {
-  const lockPath = join19(factoryDir, ".beastmode", "extensions.lock");
-  if (!existsSync21(lockPath)) {
+  const lockPath = join20(factoryDir, ".beastmode", "extensions.lock");
+  if (!existsSync22(lockPath)) {
     console.log("  No plugins installed (extensions.lock not found).");
     return;
   }
-  const lock = JSON.parse(readFileSync18(lockPath, "utf-8"));
+  const lock = JSON.parse(readFileSync19(lockPath, "utf-8"));
   const plugins = lock.plugins || {};
   const names = Object.keys(plugins);
   if (names.length === 0) {
@@ -9687,31 +10206,31 @@ var listCommand = new Command8("list").description("List installed extensions an
 init_import_adapter();
 init_display();
 import { Command as Command9 } from "commander";
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync17, mkdirSync as mkdirSync15, existsSync as existsSync22 } from "fs";
-import { resolve as resolve12, join as join20 } from "path";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync18, mkdirSync as mkdirSync16, existsSync as existsSync23 } from "fs";
+import { resolve as resolve12, join as join21 } from "path";
 var VALID_ARTIFACTS = ["nlspec", "plan", "scenarios"];
 function createArtifactCommand(artifact) {
   return new Command9(artifact).description(`Import external document as ${artifact}`).requiredOption("--from <path>", "Path to source file").requiredOption("--adapter <id>", "Adapter ID (e.g., generic:prd, bmad:brainstorm)").option("--output <path>", "Output path (default: stdout)").action((opts) => {
     try {
       const sourcePath = resolve12(opts.from);
-      if (!existsSync22(sourcePath)) {
+      if (!existsSync23(sourcePath)) {
         throw new Error(`Source file not found: ${sourcePath}`);
       }
-      const sourceContent = readFileSync19(sourcePath, "utf-8");
+      const sourceContent = readFileSync20(sourcePath, "utf-8");
       const result = runImportAdapter(opts.adapter, sourceContent);
       if (opts.output) {
         const outputPath = resolve12(opts.output);
         if (artifact === "scenarios" && opts.adapter.endsWith(":test-cases")) {
           const scenarios = JSON.parse(result);
-          mkdirSync15(outputPath, { recursive: true });
+          mkdirSync16(outputPath, { recursive: true });
           for (const scenario of scenarios) {
-            const filePath = join20(outputPath, `${scenario.name}.md`);
-            writeFileSync17(filePath, scenario.content, "utf-8");
+            const filePath = join21(outputPath, `${scenario.name}.md`);
+            writeFileSync18(filePath, scenario.content, "utf-8");
             success(`  ${scenario.name}.md`);
           }
           header(`Imported ${scenarios.length} scenarios to ${opts.output}`);
         } else {
-          writeFileSync17(outputPath, result, "utf-8");
+          writeFileSync18(outputPath, result, "utf-8");
           header(`Imported ${artifact}`);
           success(`Written to: ${opts.output}`);
         }
@@ -9732,54 +10251,55 @@ for (const artifact of VALID_ARTIFACTS) {
 // src/cli/commands/status.ts
 init_status_checker();
 init_schemas();
+init_project_record();
 init_display();
 import { Command as Command10 } from "commander";
-import { existsSync as existsSync23, readFileSync as readFileSync20, readdirSync as readdirSync9 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync21, readdirSync as readdirSync10 } from "fs";
 import { execSync as execSync6 } from "child_process";
-import { join as join21, resolve as resolve13 } from "path";
+import { join as join22, resolve as resolve13 } from "path";
 function statusAction(factoryDir, opts) {
-  const bmDir = join21(factoryDir, ".beastmode");
-  if (!existsSync23(bmDir)) {
+  const bmDir = join22(factoryDir, ".beastmode");
+  if (!existsSync24(bmDir)) {
     throw new Error(`No factory found at ${factoryDir}`);
   }
-  const factoryJsonPath = join21(bmDir, "factory.json");
-  const rawIdentity = JSON.parse(readFileSync20(factoryJsonPath, "utf-8"));
+  const factoryJsonPath = join22(bmDir, "factory.json");
+  const rawIdentity = JSON.parse(readFileSync21(factoryJsonPath, "utf-8"));
   const factoryIdentity = FactoryIdentitySchema.parse(rawIdentity);
-  const projectsDir = join21(bmDir, "projects");
-  const projectCount = existsSync23(projectsDir) ? readdirSync9(projectsDir).filter((f) => f.endsWith(".json")).length : 0;
-  const pluginsDir = join21(bmDir, "plugins");
-  const pluginNames = existsSync23(pluginsDir) ? readdirSync9(pluginsDir) : [];
-  const mcpPath = join21(bmDir, "mcp-servers.json");
+  const projectsDir = join22(bmDir, "projects");
+  const projectCount = listProjectRecords(projectsDir).length;
+  const pluginsDir = join22(bmDir, "plugins");
+  const pluginNames = existsSync24(pluginsDir) ? readdirSync10(pluginsDir) : [];
+  const mcpPath = join22(bmDir, "mcp-servers.json");
   let mcpServers = {};
-  if (existsSync23(mcpPath)) {
+  if (existsSync24(mcpPath)) {
     try {
-      const raw = JSON.parse(readFileSync20(mcpPath, "utf-8"));
+      const raw = JSON.parse(readFileSync21(mcpPath, "utf-8"));
       mcpServers = raw.servers || {};
     } catch {
     }
   }
-  const hooksPath = join21(bmDir, "hooks.json");
+  const hooksPath = join22(bmDir, "hooks.json");
   let hooks = {};
-  if (existsSync23(hooksPath)) {
+  if (existsSync24(hooksPath)) {
     try {
-      const raw = JSON.parse(readFileSync20(hooksPath, "utf-8"));
+      const raw = JSON.parse(readFileSync21(hooksPath, "utf-8"));
       hooks = raw.hooks || {};
     } catch {
     }
   }
-  const skillsDir = join21(bmDir, "skills");
-  const skillCount = existsSync23(skillsDir) ? readdirSync9(skillsDir).length : 0;
-  const runsDir = join21(factoryDir, "runs");
+  const skillsDir = join22(bmDir, "skills");
+  const skillCount = existsSync24(skillsDir) ? readdirSync10(skillsDir).length : 0;
+  const runsDir = join22(factoryDir, "runs");
   let runDirs = [];
-  if (existsSync23(runsDir)) {
-    runDirs = readdirSync9(runsDir).filter((d) => d.startsWith("run-")).sort();
+  if (existsSync24(runsDir)) {
+    runDirs = readdirSync10(runsDir).filter((d) => d.startsWith("run-")).sort();
   }
-  const pidPath = join21(bmDir, "daemon.pid");
+  const pidPath = join22(bmDir, "daemon.pid");
   let daemonPid = null;
   let pidAlive = false;
-  if (existsSync23(pidPath)) {
+  if (existsSync24(pidPath)) {
     try {
-      daemonPid = parseInt(readFileSync20(pidPath, "utf-8").trim(), 10);
+      daemonPid = parseInt(readFileSync21(pidPath, "utf-8").trim(), 10);
       process.kill(daemonPid, 0);
       pidAlive = true;
     } catch {
@@ -9853,19 +10373,19 @@ var statusCommand = new Command10("status").description("Show factory status ove
 init_config_manager();
 init_display();
 import { Command as Command11 } from "commander";
-import { existsSync as existsSync24, readFileSync as readFileSync21, writeFileSync as writeFileSync18 } from "fs";
-import { join as join22, resolve as resolve14 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync22, writeFileSync as writeFileSync19 } from "fs";
+import { join as join23, resolve as resolve14 } from "path";
 import { execSync as execSync7 } from "child_process";
 function readConfig2(factoryDir) {
-  const configPath = join22(factoryDir, ".beastmode", "config.json");
-  if (!existsSync24(configPath)) {
+  const configPath = join23(factoryDir, ".beastmode", "config.json");
+  if (!existsSync25(configPath)) {
     throw new Error("No config.json found. Run beastmode init first.");
   }
-  return JSON.parse(readFileSync21(configPath, "utf-8"));
+  return JSON.parse(readFileSync22(configPath, "utf-8"));
 }
 function writeConfig2(factoryDir, config) {
-  const configPath = join22(factoryDir, ".beastmode", "config.json");
-  writeFileSync18(configPath, JSON.stringify(config, null, 2) + "\n");
+  const configPath = join23(factoryDir, ".beastmode", "config.json");
+  writeFileSync19(configPath, JSON.stringify(config, null, 2) + "\n");
 }
 function configGetAction(factoryDir, key) {
   const config = readConfig2(factoryDir);
@@ -9908,8 +10428,8 @@ var configSetCmd = new Command11("set").description("Set a config value by dot-n
 });
 var configEditCmd = new Command11("edit").description("Open config.json in $EDITOR").action(() => {
   const factoryDir = resolve14(".");
-  const configPath = join22(factoryDir, ".beastmode", "config.json");
-  if (!existsSync24(configPath)) {
+  const configPath = join23(factoryDir, ".beastmode", "config.json");
+  if (!existsSync25(configPath)) {
     error("No config.json found. Run beastmode init first.");
     process.exit(1);
   }
@@ -9939,13 +10459,14 @@ var configCommand = new Command11("config").description("Manage factory configur
 
 // src/cli/commands/doctor.ts
 init_doctor();
+init_engine();
 init_schemas();
 init_version();
 init_plugin_resolver();
 init_display();
 import { Command as Command12 } from "commander";
-import { existsSync as existsSync25, readFileSync as readFileSync22, readdirSync as readdirSync10 } from "fs";
-import { join as join23, resolve as resolve15 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync23, readdirSync as readdirSync11 } from "fs";
+import { join as join24, resolve as resolve15 } from "path";
 import { execSync as execSync8, spawnSync as spawnSync3 } from "child_process";
 import { homedir as homedir3, platform as platform2 } from "os";
 import * as http3 from "http";
@@ -9986,8 +10507,8 @@ async function checkClaudeAuth(key) {
     });
   }
   if (claudeInstalled && platform2() === "darwin" && !key) {
-    const credsPath = join23(homedir3(), ".claude", ".credentials.json");
-    if (!existsSync25(credsPath)) {
+    const credsPath = join24(homedir3(), ".claude", ".credentials.json");
+    if (!existsSync26(credsPath)) {
       results.push({
         label: "Claude creds (Docker)",
         status: "warn",
@@ -10089,16 +10610,16 @@ async function checkProjectGithubToken(env, factoryDir) {
   }
   let ownerRepo = null;
   if (factoryDir) {
-    const envPath = join23(factoryDir, ".env");
-    if (existsSync25(envPath)) {
+    const envPath = join24(factoryDir, ".env");
+    if (existsSync26(envPath)) {
       try {
-        const content = readFileSync22(envPath, "utf-8");
+        const content = readFileSync23(envPath, "utf-8");
         const dirLine = content.split("\n").find(
           (l) => l.trim().startsWith("PROJECT_DIR=") && !l.trim().startsWith("#")
         );
         if (dirLine) {
           const projectDir = dirLine.split("=").slice(1).join("=").trim();
-          if (projectDir && existsSync25(join23(projectDir, ".git"))) {
+          if (projectDir && existsSync26(join24(projectDir, ".git"))) {
             const remote = tryExec(
               `git -C "${projectDir}" remote get-url origin 2>/dev/null`
             );
@@ -10314,8 +10835,8 @@ function checkProjectDirEnv(factoryDir) {
       detail: "no factory in scope"
     };
   }
-  const envPath = join23(factoryDir, ".env");
-  if (!existsSync25(envPath)) {
+  const envPath = join24(factoryDir, ".env");
+  if (!existsSync26(envPath)) {
     return {
       label: "PROJECT_DIR (.env)",
       status: "fail",
@@ -10325,7 +10846,7 @@ function checkProjectDirEnv(factoryDir) {
   }
   let content;
   try {
-    content = readFileSync22(envPath, "utf-8");
+    content = readFileSync23(envPath, "utf-8");
   } catch {
     return {
       label: "PROJECT_DIR (.env)",
@@ -10354,7 +10875,7 @@ function checkProjectDirEnv(factoryDir) {
       fix: "Re-run `beastmode init --project <path>` to populate it"
     };
   }
-  if (!existsSync25(value)) {
+  if (!existsSync26(value)) {
     return {
       label: "PROJECT_DIR (.env)",
       status: "fail",
@@ -10362,7 +10883,7 @@ function checkProjectDirEnv(factoryDir) {
       fix: `Clone your project to ${value} or re-run 'beastmode init --project <path>'`
     };
   }
-  if (!existsSync25(join23(value, ".git"))) {
+  if (!existsSync26(join24(value, ".git"))) {
     return {
       label: "PROJECT_DIR (.env)",
       status: "fail",
@@ -10393,8 +10914,8 @@ async function checkFactoryContainers(factoryDir) {
       detail: "no factory in scope"
     };
   }
-  const composePath = join23(factoryDir, "docker-compose.yml");
-  if (!existsSync25(composePath)) {
+  const composePath = join24(factoryDir, "docker-compose.yml");
+  if (!existsSync26(composePath)) {
     return {
       label: "Factory containers",
       status: "warn",
@@ -10676,9 +11197,9 @@ function checkProjectDirectory(factoryDir) {
       fix: "Run beastmode init to create a factory"
     };
   }
-  const bmDir = join23(factoryDir, ".beastmode");
-  const projectsDir = join23(bmDir, "projects");
-  if (!existsSync25(projectsDir)) {
+  const bmDir = join24(factoryDir, ".beastmode");
+  const projectsDir = join24(bmDir, "projects");
+  if (!existsSync26(projectsDir)) {
     return {
       label: "Project directory",
       status: "warn",
@@ -10686,8 +11207,8 @@ function checkProjectDirectory(factoryDir) {
       fix: "Run: beastmode add project <path>"
     };
   }
-  const projectFiles = existsSync25(projectsDir) ? readdirSync10(projectsDir).filter((f) => f.endsWith(".json")) : [];
-  if (projectFiles.length === 0) {
+  const projectRecords = listProjectRecords(projectsDir);
+  if (projectRecords.length === 0) {
     return {
       label: "Project directory",
       status: "warn",
@@ -10697,37 +11218,31 @@ function checkProjectDirectory(factoryDir) {
   }
   const results = [];
   let anyFail = false;
-  for (const file of projectFiles) {
-    try {
-      const proj = JSON.parse(readFileSync22(join23(projectsDir, file), "utf-8"));
-      const projPath = proj.path || "";
-      const projName = proj.name || file.replace(".json", "");
-      if (!projPath || !existsSync25(projPath)) {
-        results.push(`${projName}: path not found`);
-        anyFail = true;
-        continue;
-      }
-      const isGit = existsSync25(join23(projPath, ".git"));
-      const manifests = [
-        "package.json",
-        "Cargo.toml",
-        "go.mod",
-        "pyproject.toml",
-        "requirements.txt",
-        "pom.xml",
-        "build.gradle",
-        "build.gradle.kts"
-      ];
-      const manifest = manifests.find((m) => existsSync25(join23(projPath, m)));
-      const framework = proj.stack?.detected || manifest?.replace(".json", "") || "unknown";
-      results.push(
-        `${projName}: ${projPath} (${framework})${isGit ? "" : " [no .git]"}`
-      );
-      if (!isGit) anyFail = true;
-    } catch {
-      results.push(`${file}: unreadable`);
+  for (const proj of projectRecords) {
+    const projPath = proj.path || "";
+    const projName = proj.name;
+    if (!projPath || !existsSync26(projPath)) {
+      results.push(`${projName}: path not found`);
       anyFail = true;
+      continue;
     }
+    const isGit = existsSync26(join24(projPath, ".git"));
+    const manifests = [
+      "package.json",
+      "Cargo.toml",
+      "go.mod",
+      "pyproject.toml",
+      "requirements.txt",
+      "pom.xml",
+      "build.gradle",
+      "build.gradle.kts"
+    ];
+    const manifest = manifests.find((m) => existsSync26(join24(projPath, m)));
+    const framework = proj.stack?.detected || manifest?.replace(".json", "") || "unknown";
+    results.push(
+      `${projName}: ${projPath} (${framework})${isGit ? "" : " [no .git]"}`
+    );
+    if (!isGit) anyFail = true;
   }
   if (anyFail) {
     return {
@@ -10772,25 +11287,22 @@ function checkStack(factoryDir) {
       detail: "no factory \u2014 run beastmode init"
     };
   }
-  const projectsDir = join23(factoryDir, ".beastmode", "projects");
-  if (!existsSync25(projectsDir)) {
+  const projectsDir = join24(factoryDir, ".beastmode", "projects");
+  if (!existsSync26(projectsDir)) {
     return { label: "Stack", status: "warn", detail: "no projects configured" };
   }
-  const projectFiles = readdirSync10(projectsDir).filter((f) => f.endsWith(".json"));
-  if (projectFiles.length === 0) {
+  const projectRecords = listProjectRecords(projectsDir);
+  if (projectRecords.length === 0) {
     return { label: "Stack", status: "warn", detail: "no projects configured" };
   }
   const stacks = [];
-  for (const file of projectFiles) {
-    try {
-      const proj = JSON.parse(readFileSync22(join23(projectsDir, file), "utf-8"));
-      const name = proj.name || file.replace(".json", "");
-      const detected = proj.stack?.detected || "unknown";
-      const build = proj.stack?.build_command || "";
-      const port = proj.stack?.dev_port || 3e3;
-      stacks.push(`${name}: ${detected} \u2014 ${build}, port ${port}`);
-    } catch {
-    }
+  for (const proj of projectRecords) {
+    const name = proj.name;
+    const stackInfo = proj.stack;
+    const detected = stackInfo?.detected || "unknown";
+    const build = stackInfo?.build_command || "";
+    const port = stackInfo?.dev_port || 3e3;
+    stacks.push(`${name}: ${detected} \u2014 ${build}, port ${port}`);
   }
   if (stacks.length === 0) {
     return { label: "Stack", status: "warn", detail: "no readable project configs" };
@@ -10827,12 +11339,12 @@ function checkBoardPassword(env, factoryDir) {
     return { label: "Board password", status: "pass", detail: "set" };
   }
   if (factoryDir) {
-    const dotEnv = join23(factoryDir, ".env");
-    const secretsEnv = join23(factoryDir, ".beastmode", "secrets.env.local");
+    const dotEnv = join24(factoryDir, ".env");
+    const secretsEnv = join24(factoryDir, ".beastmode", "secrets.env.local");
     for (const filePath of [dotEnv, secretsEnv]) {
-      if (existsSync25(filePath)) {
+      if (existsSync26(filePath)) {
         try {
-          const content = readFileSync22(filePath, "utf-8");
+          const content = readFileSync23(filePath, "utf-8");
           const lines = content.split("\n");
           const line = lines.find((l) => l.startsWith("BEASTMODE_UI_PASSWORD="));
           if (line) {
@@ -10854,12 +11366,12 @@ function checkBoardPassword(env, factoryDir) {
   };
 }
 function doctorAction(factoryDir, env) {
-  const bmDir = join23(factoryDir, ".beastmode");
-  const factoryDirExists = existsSync25(bmDir);
+  const bmDir = join24(factoryDir, ".beastmode");
+  const factoryDirExists = existsSync26(bmDir);
   let factoryIdentity = null;
   if (factoryDirExists) {
     try {
-      const raw = JSON.parse(readFileSync22(join23(bmDir, "factory.json"), "utf-8"));
+      const raw = JSON.parse(readFileSync23(join24(bmDir, "factory.json"), "utf-8"));
       factoryIdentity = FactoryIdentitySchema.parse(raw);
     } catch {
     }
@@ -10867,10 +11379,10 @@ function doctorAction(factoryDir, env) {
   let config = null;
   let configParseError = null;
   if (factoryDirExists) {
-    const configPath = join23(bmDir, "config.json");
-    if (existsSync25(configPath)) {
+    const configPath = join24(bmDir, "config.json");
+    if (existsSync26(configPath)) {
       try {
-        const raw = JSON.parse(readFileSync22(configPath, "utf-8"));
+        const raw = JSON.parse(readFileSync23(configPath, "utf-8"));
         const result = FactoryConfigSchema.safeParse(raw);
         if (result.success) {
           config = raw;
@@ -10886,34 +11398,26 @@ function doctorAction(factoryDir, env) {
   }
   const projectPaths = [];
   if (factoryDirExists) {
-    const projectsDir = join23(bmDir, "projects");
-    if (existsSync25(projectsDir)) {
-      for (const file of readdirSync10(projectsDir)) {
-        if (file.endsWith(".json")) {
-          try {
-            const proj = JSON.parse(readFileSync22(join23(projectsDir, file), "utf-8"));
-            if (proj.path) {
-              projectPaths.push({
-                name: proj.name || file.replace(".json", ""),
-                path: proj.path,
-                exists: existsSync25(proj.path)
-              });
-            }
-          } catch {
-          }
-        }
+    const projectsDir = join24(bmDir, "projects");
+    for (const proj of listProjectRecords(projectsDir)) {
+      if (proj.path) {
+        projectPaths.push({
+          name: proj.name,
+          path: proj.path,
+          exists: existsSync26(proj.path)
+        });
       }
     }
   }
   const installedPlugins = [];
   if (factoryDirExists) {
-    const pluginsDir = join23(bmDir, "plugins");
-    if (existsSync25(pluginsDir)) {
-      for (const pluginName of readdirSync10(pluginsDir)) {
-        const manifestPath = join23(pluginsDir, pluginName, "manifest.json");
-        if (existsSync25(manifestPath)) {
+    const pluginsDir = join24(bmDir, "plugins");
+    if (existsSync26(pluginsDir)) {
+      for (const pluginName of readdirSync11(pluginsDir)) {
+        const manifestPath = join24(pluginsDir, pluginName, "manifest.json");
+        if (existsSync26(manifestPath)) {
           try {
-            const manifest = JSON.parse(readFileSync22(manifestPath, "utf-8"));
+            const manifest = JSON.parse(readFileSync23(manifestPath, "utf-8"));
             installedPlugins.push({
               name: pluginName,
               engine_version: manifest.engine_version || "*"
@@ -10941,8 +11445,8 @@ var SYSTEMD_CREDS_TIMER = "beastmode-claude-creds.timer";
 var LAUNCH_AGENT_LABEL2 = "com.develeap.beastmode.claude-creds";
 function checkCredentialSyncAgent() {
   const results = [];
-  const credsPath = join23(homedir3(), ".claude", ".credentials.json");
-  if (!existsSync25(credsPath)) {
+  const credsPath = join24(homedir3(), ".claude", ".credentials.json");
+  if (!existsSync26(credsPath)) {
     results.push({
       label: "Claude credentials file",
       status: "fail",
@@ -10957,7 +11461,7 @@ function checkCredentialSyncAgent() {
     detail: credsPath
   });
   try {
-    const creds = JSON.parse(readFileSync22(credsPath, "utf-8"));
+    const creds = JSON.parse(readFileSync23(credsPath, "utf-8"));
     const expiresAt = creds?.claudeAiOauth?.expiresAt;
     if (typeof expiresAt === "number") {
       const hoursLeft = Math.round((expiresAt - Date.now()) / 36e5);
@@ -11273,7 +11777,7 @@ var doctorCommand = new Command12("doctor").description("Health check \u2014 val
   console.log();
   const env = process.env;
   const factoryDir = findFactoryDir() ?? resolve15(".");
-  const hasFactory = existsSync25(join23(factoryDir, ".beastmode"));
+  const hasFactory = existsSync26(join24(factoryDir, ".beastmode"));
   const checks = [];
   checks.push(...await checkClaudeAuth(env.ANTHROPIC_API_KEY));
   checks.push(...checkCredentialSyncAgent());
@@ -11349,12 +11853,12 @@ init_schemas();
 init_version();
 init_display();
 import { Command as Command13 } from "commander";
-import { existsSync as existsSync27, readFileSync as readFileSync24, writeFileSync as writeFileSync20 } from "fs";
-import { join as join25, resolve as resolve16 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync25, writeFileSync as writeFileSync21 } from "fs";
+import { join as join26, resolve as resolve16 } from "path";
 
 // src/cli/utils/regenerate.ts
-import { existsSync as existsSync26, readFileSync as readFileSync23, writeFileSync as writeFileSync19, copyFileSync } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync24, writeFileSync as writeFileSync20, copyFileSync } from "fs";
+import { join as join25 } from "path";
 var RECOGNIZED_KEYS = /* @__PURE__ */ new Set([
   "PROJECT_DIR",
   "PROJECT_GITHUB_TOKEN",
@@ -11468,19 +11972,19 @@ function buildNewEnv(values) {
   return lines.join("\n");
 }
 function regenerateFactoryFiles(factoryDir, now = /* @__PURE__ */ new Date()) {
-  const envPath = join24(factoryDir, ".env");
-  const composePath = join24(factoryDir, "docker-compose.yml");
-  if (!existsSync26(envPath)) {
+  const envPath = join25(factoryDir, ".env");
+  const composePath = join25(factoryDir, "docker-compose.yml");
+  if (!existsSync27(envPath)) {
     throw new Error(
       `.env not found at ${envPath}. This does not look like a beastmode factory \u2014 run 'beastmode init' first.`
     );
   }
-  if (!existsSync26(composePath)) {
+  if (!existsSync27(composePath)) {
     throw new Error(
       `docker-compose.yml not found at ${composePath}. This does not look like a beastmode factory \u2014 run 'beastmode init' first.`
     );
   }
-  const existingEnv = readFileSync23(envPath, "utf-8");
+  const existingEnv = readFileSync24(envPath, "utf-8");
   const values = parseExistingEnv(existingEnv);
   const missing = [];
   if (!values.projectDir) missing.push("PROJECT_DIR");
@@ -11498,7 +12002,7 @@ function regenerateFactoryFiles(factoryDir, now = /* @__PURE__ */ new Date()) {
   }
   const newEnv = buildNewEnv(values);
   const newCompose = generateComposeYaml("latest");
-  const existingCompose = readFileSync23(composePath, "utf-8");
+  const existingCompose = readFileSync24(composePath, "utf-8");
   const envChanged = newEnv !== existingEnv;
   const composeChanged = newCompose !== existingCompose;
   if (!envChanged && !composeChanged) {
@@ -11516,12 +12020,12 @@ function regenerateFactoryFiles(factoryDir, now = /* @__PURE__ */ new Date()) {
   if (envChanged) {
     envBackupPath = `${envPath}.backup.${timestamp}`;
     copyFileSync(envPath, envBackupPath);
-    writeFileSync19(envPath, newEnv, "utf-8");
+    writeFileSync20(envPath, newEnv, "utf-8");
   }
   if (composeChanged) {
     composeBackupPath = `${composePath}.backup.${timestamp}`;
     copyFileSync(composePath, composeBackupPath);
-    writeFileSync19(composePath, newCompose, "utf-8");
+    writeFileSync20(composePath, newCompose, "utf-8");
   }
   return {
     envChanged,
@@ -11534,18 +12038,18 @@ function regenerateFactoryFiles(factoryDir, now = /* @__PURE__ */ new Date()) {
 
 // src/cli/commands/upgrade.ts
 function readIdentity(factoryDir) {
-  const path = join25(factoryDir, ".beastmode", "factory.json");
-  if (!existsSync27(path)) {
+  const path = join26(factoryDir, ".beastmode", "factory.json");
+  if (!existsSync28(path)) {
     throw new Error("No factory.json found. Run beastmode init first.");
   }
-  return FactoryIdentitySchema.parse(JSON.parse(readFileSync24(path, "utf-8")));
+  return FactoryIdentitySchema.parse(JSON.parse(readFileSync25(path, "utf-8")));
 }
 function readConfig3(factoryDir) {
-  const path = join25(factoryDir, ".beastmode", "config.json");
-  if (!existsSync27(path)) {
+  const path = join26(factoryDir, ".beastmode", "config.json");
+  if (!existsSync28(path)) {
     return {};
   }
-  return JSON.parse(readFileSync24(path, "utf-8"));
+  return JSON.parse(readFileSync25(path, "utf-8"));
 }
 function upgradeCheckAction(factoryDir) {
   const identity = readIdentity(factoryDir);
@@ -11557,12 +12061,12 @@ function upgradeAction(factoryDir, migrateOnly = false) {
   const targetVersion = migrateOnly ? identity.engine_version : ENGINE_VERSION;
   const result = performUpgrade(identity, config, targetVersion, SCHEMA_VERSION);
   if (result.changes.length > 0) {
-    writeFileSync20(
-      join25(factoryDir, ".beastmode", "factory.json"),
+    writeFileSync21(
+      join26(factoryDir, ".beastmode", "factory.json"),
       JSON.stringify(result.updatedIdentity, null, 2) + "\n"
     );
-    writeFileSync20(
-      join25(factoryDir, ".beastmode", "config.json"),
+    writeFileSync21(
+      join26(factoryDir, ".beastmode", "config.json"),
       JSON.stringify(result.updatedConfig, null, 2) + "\n"
     );
   }
@@ -11652,8 +12156,8 @@ init_board();
 init_display();
 init_migrator();
 import { Command as Command14 } from "commander";
-import { resolve as resolve17, join as join26 } from "path";
-import { existsSync as existsSync28, readFileSync as readFileSync25, mkdirSync as mkdirSync16, writeFileSync as writeFileSync21 } from "fs";
+import { resolve as resolve17, join as join27 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync26, mkdirSync as mkdirSync17, writeFileSync as writeFileSync22 } from "fs";
 var migrateCommand = new Command14("migrate").description("Migrate a daemon config into a .beastmode/ factory").option("--config <path>", "Path to beastmode.daemon.json").option("--dry-run", "Show what would be created without writing files").action(async (opts) => {
   try {
     await runMigrate(opts);
@@ -11665,7 +12169,7 @@ var migrateCommand = new Command14("migrate").description("Migrate a daemon conf
 async function runMigrate(opts) {
   const cwd = process.cwd();
   const configPath = opts.config ? resolve17(opts.config) : resolve17(cwd, "config", "beastmode.daemon.json");
-  if (!existsSync28(configPath)) {
+  if (!existsSync29(configPath)) {
     throw new Error(
       `Daemon config not found at ${configPath}
   Use --config <path> to specify a different location.`
@@ -11673,25 +12177,25 @@ async function runMigrate(opts) {
   }
   header("BeastMode Migrate");
   info(`Reading daemon config from: ${configPath}`);
-  const configContent = readFileSync25(configPath, "utf-8");
+  const configContent = readFileSync26(configPath, "utf-8");
   const daemonConfig = parseDaemonConfig(configContent);
-  const runsDir = join26(cwd, "runs");
+  const runsDir = join27(cwd, "runs");
   let runDirs = [];
   const checkpoints = /* @__PURE__ */ new Map();
-  if (existsSync28(runsDir)) {
-    const { readdirSync: readdirSync14 } = await import("fs");
-    runDirs = readdirSync14(runsDir).filter((d) => {
+  if (existsSync29(runsDir)) {
+    const { readdirSync: readdirSync13 } = await import("fs");
+    runDirs = readdirSync13(runsDir).filter((d) => {
       try {
-        return readdirSync14(join26(runsDir, d)).length > 0;
+        return readdirSync13(join27(runsDir, d)).length > 0;
       } catch {
         return false;
       }
     });
     for (const dir of runDirs) {
-      const cpPath = join26(runsDir, dir, "checkpoint.json");
-      if (existsSync28(cpPath)) {
+      const cpPath = join27(runsDir, dir, "checkpoint.json");
+      if (existsSync29(cpPath)) {
         try {
-          const cp = JSON.parse(readFileSync25(cpPath, "utf-8"));
+          const cp = JSON.parse(readFileSync26(cpPath, "utf-8"));
           checkpoints.set(dir, cp);
         } catch {
         }
@@ -11748,28 +12252,28 @@ async function runMigrate(opts) {
     warn("Dry run \u2014 no files written.");
     return;
   }
-  const bmDir = join26(cwd, ".beastmode");
-  if (existsSync28(bmDir)) {
+  const bmDir = join27(cwd, ".beastmode");
+  if (existsSync29(bmDir)) {
     throw new Error(
       "A .beastmode/ directory already exists. Remove it first to re-migrate."
     );
   }
   for (const file of files) {
-    const fullPath = join26(cwd, file.path);
+    const fullPath = join27(cwd, file.path);
     const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
-    mkdirSync16(dir, { recursive: true });
-    writeFileSync21(fullPath, file.content, "utf-8");
+    mkdirSync17(dir, { recursive: true });
+    writeFileSync22(fullPath, file.content, "utf-8");
   }
-  const runsSymlinkTarget = join26(cwd, "runs");
-  const bmRunsPath = join26(cwd, "runs");
-  if (existsSync28(runsSymlinkTarget)) {
+  const runsSymlinkTarget = join27(cwd, "runs");
+  const bmRunsPath = join27(cwd, "runs");
+  if (existsSync29(runsSymlinkTarget)) {
     info("Existing runs/ directory preserved in-place.");
   }
-  const boardPath = join26(bmDir, "board.json");
-  if (!existsSync28(boardPath)) {
-    writeFileSync21(boardPath, JSON.stringify({ items: [] }, null, 2), "utf-8");
+  const boardPath = join27(bmDir, "board.json");
+  if (!existsSync29(boardPath)) {
+    writeFileSync22(boardPath, JSON.stringify({ items: [] }, null, 2), "utf-8");
   }
-  mkdirSync16(join26(bmDir, ".cache"), { recursive: true });
+  mkdirSync17(join27(bmDir, ".cache"), { recursive: true });
   console.log();
   success("Migration complete!");
   info(`Factory created at: ${bmDir}`);
@@ -11790,9 +12294,10 @@ init_display();
 init_board();
 init_bridge();
 init_schemas();
+init_engine();
 import { Command as Command15 } from "commander";
-import { join as join27 } from "path";
-import { existsSync as existsSync29, readFileSync as readFileSync26, writeFileSync as writeFileSync22, mkdirSync as mkdirSync17 } from "fs";
+import { join as join28 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync27, writeFileSync as writeFileSync23, mkdirSync as mkdirSync18 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
 var runCommand = new Command15("run").description("Run a single pipeline task").argument("[project]", "Project name (defaults to first project)").option("--task <description>", "Task description").action(async (project, opts) => {
   try {
@@ -11812,44 +12317,35 @@ async function runPipeline(projectName, opts) {
       "No BeastMode factory found. Run 'beastmode init' first."
     );
   }
-  const bmDir = join27(factoryDir, ".beastmode");
+  const bmDir = join28(factoryDir, ".beastmode");
   header("BeastMode Run");
-  const configPath = join27(bmDir, "config.json");
-  if (!existsSync29(configPath)) {
+  const configPath = join28(bmDir, "config.json");
+  if (!existsSync30(configPath)) {
     throw new Error("Factory config not found. Run 'beastmode init' first.");
   }
   const factoryConfig = FactoryConfigSchema.parse(
-    JSON.parse(readFileSync26(configPath, "utf-8"))
+    JSON.parse(readFileSync27(configPath, "utf-8"))
   );
   let projectConfig = null;
-  const projectsDir = join27(bmDir, "projects");
-  if (existsSync29(projectsDir)) {
-    const { readdirSync: readdirSync14 } = await import("fs");
-    const projectFiles = readdirSync14(projectsDir).filter(
-      (f) => f.endsWith(".json")
-    );
-    if (projectName) {
-      const file = projectFiles.find(
-        (f) => f === `${projectName}.json`
-      );
-      if (!file) {
-        throw new Error(`Project not found: ${projectName}`);
-      }
-      projectConfig = ProjectConfigSchema.parse(
-        JSON.parse(readFileSync26(join27(projectsDir, file), "utf-8"))
-      );
-    } else if (projectFiles.length > 0) {
-      projectConfig = ProjectConfigSchema.parse(
-        JSON.parse(readFileSync26(join27(projectsDir, projectFiles[0]), "utf-8"))
-      );
+  const projectsDir = join28(bmDir, "projects");
+  if (projectName) {
+    const record = readProjectRecord(projectsDir, projectName);
+    if (!record) {
+      throw new Error(`Project not found: ${projectName}`);
+    }
+    projectConfig = record;
+  } else {
+    const projects = listProjectRecords(projectsDir);
+    if (projects.length > 0) {
+      projectConfig = projects[0];
       info(`Using project: ${projectConfig.name}`);
     }
   }
-  const boardPath = join27(bmDir, "board.json");
+  const boardPath = join28(bmDir, "board.json");
   let boardItems = [];
-  if (existsSync29(boardPath)) {
+  if (existsSync30(boardPath)) {
     try {
-      const raw = JSON.parse(readFileSync26(boardPath, "utf-8"));
+      const raw = JSON.parse(readFileSync27(boardPath, "utf-8"));
       boardItems = Array.isArray(raw.items) ? raw.items : [];
     } catch {
       boardItems = [];
@@ -11866,13 +12362,13 @@ async function runPipeline(projectName, opts) {
     updated_at: now
   };
   boardItems.push(task);
-  writeFileSync22(boardPath, JSON.stringify({ items: boardItems }, null, 2), "utf-8");
+  writeFileSync23(boardPath, JSON.stringify({ items: boardItems }, null, 2), "utf-8");
   info(`Created task: ${task.title} (${taskId})`);
-  const cacheDir = join27(bmDir, ".cache");
-  mkdirSync17(cacheDir, { recursive: true });
-  const daemonConfigPath = join27(cacheDir, "daemon.json");
+  const cacheDir = join28(bmDir, ".cache");
+  mkdirSync18(cacheDir, { recursive: true });
+  const daemonConfigPath = join28(cacheDir, "daemon.json");
   const daemonConfig = generateDaemonConfig(factoryConfig, projectConfig, factoryDir);
-  writeFileSync22(daemonConfigPath, JSON.stringify(daemonConfig, null, 2), "utf-8");
+  writeFileSync23(daemonConfigPath, JSON.stringify(daemonConfig, null, 2), "utf-8");
   info(`Generated daemon config at: ${daemonConfigPath}`);
   const { execSync: execSync14 } = await import("child_process");
   let pythonAvailable = false;
@@ -11896,7 +12392,7 @@ async function runPipeline(projectName, opts) {
   const daemonPaths = findPythonDaemonPaths(envPath, factoryDir);
   let daemonFound = false;
   for (const p of daemonPaths) {
-    if (existsSync29(p)) {
+    if (existsSync30(p)) {
       daemonFound = true;
       break;
     }
@@ -11923,7 +12419,7 @@ async function runPipeline(projectName, opts) {
   const startTime = Date.now();
   const pollInterval = setInterval(() => {
     try {
-      const board = JSON.parse(readFileSync26(boardPath, "utf-8"));
+      const board = JSON.parse(readFileSync27(boardPath, "utf-8"));
       const items = Array.isArray(board.items) ? board.items : [];
       const taskItem = items.find((i) => i.id === taskId);
       if (taskItem) {
@@ -11968,9 +12464,10 @@ init_display();
 init_board();
 init_bridge();
 init_schemas();
+init_engine();
 import { Command as Command16 } from "commander";
-import { join as join28 } from "path";
-import { existsSync as existsSync30, readFileSync as readFileSync27, writeFileSync as writeFileSync23, mkdirSync as mkdirSync18 } from "fs";
+import { join as join29 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync28, writeFileSync as writeFileSync24, mkdirSync as mkdirSync19 } from "fs";
 var daemonCommand = new Command16("daemon").description("Start the BeastMode daemon via bridge").option("--dry-run", "Generate config but don't start daemon").option(
   "--log-level <level>",
   "Log level (DEBUG, INFO, WARNING, ERROR)",
@@ -11990,38 +12487,31 @@ async function runDaemon(opts) {
       "No BeastMode factory found. Run 'beastmode init' first."
     );
   }
-  const bmDir = join28(factoryDir, ".beastmode");
+  const bmDir = join29(factoryDir, ".beastmode");
   header("BeastMode Daemon");
-  const configPath = join28(bmDir, "config.json");
-  if (!existsSync30(configPath)) {
+  const configPath = join29(bmDir, "config.json");
+  if (!existsSync31(configPath)) {
     throw new Error("Factory config not found. Run 'beastmode init' first.");
   }
   const factoryConfig = FactoryConfigSchema.parse(
-    JSON.parse(readFileSync27(configPath, "utf-8"))
+    JSON.parse(readFileSync28(configPath, "utf-8"))
   );
   let projectConfig = null;
-  const projectsDir = join28(bmDir, "projects");
-  if (existsSync30(projectsDir)) {
-    const { readdirSync: readdirSync14 } = await import("fs");
-    const projectFiles = readdirSync14(projectsDir).filter(
-      (f) => f.endsWith(".json")
-    );
-    if (projectFiles.length > 0) {
-      projectConfig = ProjectConfigSchema.parse(
-        JSON.parse(readFileSync27(join28(projectsDir, projectFiles[0]), "utf-8"))
-      );
-      info(`Using project: ${projectConfig.name}`);
-    }
-  }
-  const cacheDir = join28(bmDir, ".cache");
-  mkdirSync18(cacheDir, { recursive: true });
-  const daemonConfigPath = join28(cacheDir, "daemon.json");
+  const projectsDir = join29(bmDir, "projects");
+  const projects = listProjectRecords(projectsDir);
+  if (projects.length > 0) {
+    projectConfig = projects[0];
+    info(`Using project: ${projectConfig.name}`);
+  }
+  const cacheDir = join29(bmDir, ".cache");
+  mkdirSync19(cacheDir, { recursive: true });
+  const daemonConfigPath = join29(cacheDir, "daemon.json");
   const daemonConfig = generateDaemonConfig(
     factoryConfig,
     projectConfig,
     factoryDir
   );
-  writeFileSync23(
+  writeFileSync24(
     daemonConfigPath,
     JSON.stringify(daemonConfig, null, 2),
     "utf-8"
@@ -12060,7 +12550,7 @@ async function runDaemon(opts) {
   });
   info(`Starting daemon: ${pythonCmd} ${cmd.args.join(" ")}`);
   console.log();
-  const pidFile = join28(bmDir, "daemon.pid");
+  const pidFile = join29(bmDir, "daemon.pid");
   const { spawn: spawn4 } = await import("child_process");
   const child = spawn4(pythonCmd, cmd.args, {
     stdio: "inherit",
@@ -12071,7 +12561,7 @@ async function runDaemon(opts) {
     }
   });
   if (child.pid) {
-    writeFileSync23(pidFile, String(child.pid), "utf-8");
+    writeFileSync24(pidFile, String(child.pid), "utf-8");
   }
   const signalHandler = (signal) => {
     info(`Forwarding ${signal} to daemon...`);
@@ -12110,8 +12600,8 @@ var mcpCommand = new Command17("mcp").description("Start the BeastMode MCP serve
 // src/cli/commands/deploy.ts
 init_display();
 import { Command as Command18 } from "commander";
-import { resolve as resolve19, join as join30 } from "path";
-import { existsSync as existsSync32, writeFileSync as writeFileSync25, readFileSync as readFileSync29 } from "fs";
+import { resolve as resolve19, join as join31 } from "path";
+import { existsSync as existsSync33, writeFileSync as writeFileSync26, readFileSync as readFileSync30 } from "fs";
 import { execSync as execSync9 } from "child_process";
 import { randomBytes } from "crypto";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -12166,8 +12656,8 @@ async function runDeploy(opts) {
     process.exit(1);
   }
   const factoryDir = resolve19(".");
-  const bmDir = join30(factoryDir, ".beastmode");
-  if (!existsSync32(bmDir)) {
+  const bmDir = join31(factoryDir, ".beastmode");
+  if (!existsSync33(bmDir)) {
     error(
       "No .beastmode directory found. Run 'beastmode init' or 'beastmode migrate' first."
     );
@@ -12191,33 +12681,33 @@ async function runDeploy(opts) {
       "../../index.js"
     );
   }
-  const boardVenvPython = join30(factoryDir, "board", ".venv", "bin", "python");
-  const daemonVenvPython = join30(factoryDir, "daemon", ".venv", "bin", "python");
-  const boardPython = existsSync32(boardVenvPython) ? boardVenvPython : "python3";
-  const daemonPython = existsSync32(daemonVenvPython) ? daemonVenvPython : "python3";
+  const boardVenvPython = join31(factoryDir, "board", ".venv", "bin", "python");
+  const daemonVenvPython = join31(factoryDir, "daemon", ".venv", "bin", "python");
+  const boardPython = existsSync33(boardVenvPython) ? boardVenvPython : "python3";
+  const daemonPython = existsSync33(daemonVenvPython) ? daemonVenvPython : "python3";
   const user = execSync9("whoami", { encoding: "utf-8" }).trim();
   const home = process.env.HOME || `/home/${user}`;
   const port = opts.port;
   const host = opts.host;
-  const dotEnv = join30(factoryDir, ".env");
-  const secretsEnv = join30(bmDir, "secrets.env.local");
-  const envContent = existsSync32(dotEnv) ? readFileSync29(dotEnv, "utf-8") : "";
-  const secretsContent = existsSync32(secretsEnv) ? readFileSync29(secretsEnv, "utf-8") : "";
+  const dotEnv = join31(factoryDir, ".env");
+  const secretsEnv = join31(bmDir, "secrets.env.local");
+  const envContent = existsSync33(dotEnv) ? readFileSync30(dotEnv, "utf-8") : "";
+  const secretsContent = existsSync33(secretsEnv) ? readFileSync30(secretsEnv, "utf-8") : "";
   const hasPassword = envContent.includes("BEASTMODE_UI_PASSWORD=") && !envContent.includes("BEASTMODE_UI_PASSWORD=\n") || secretsContent.includes("BEASTMODE_UI_PASSWORD=") && !secretsContent.includes("BEASTMODE_UI_PASSWORD=\n") || !!process.env.BEASTMODE_UI_PASSWORD;
   if (!hasPassword && opts.host === "0.0.0.0") {
     const generated = randomBytes(18).toString("base64url");
-    const target = existsSync32(secretsEnv) ? secretsEnv : dotEnv;
+    const target = existsSync33(secretsEnv) ? secretsEnv : dotEnv;
     const append = `
 # Auto-generated board UI password (deploy)
 BEASTMODE_UI_PASSWORD=${generated}
 `;
-    writeFileSync25(target, (existsSync32(target) ? readFileSync29(target, "utf-8") : "") + append, "utf-8");
+    writeFileSync26(target, (existsSync33(target) ? readFileSync30(target, "utf-8") : "") + append, "utf-8");
     info(`Board UI password auto-generated and saved to ${target}`);
     success(`Password: ${generated}`);
     info("Save this password \u2014 you'll need it to access the board UI.");
   }
   const envFileLines = [];
-  if (existsSync32(secretsEnv)) {
+  if (existsSync33(secretsEnv)) {
     envFileLines.push(`EnvironmentFile=${secretsEnv}`);
   } else {
     envFileLines.push(`# No secrets.env.local found at time of deploy`);
@@ -12300,7 +12790,7 @@ BEASTMODE_UI_PASSWORD=${generated}
     info(`Writing service file to ${svc.path}...`);
     try {
       const tmpPath = `/tmp/${svc.name}.service`;
-      writeFileSync25(tmpPath, svc.content, "utf-8");
+      writeFileSync26(tmpPath, svc.content, "utf-8");
       execSync9(`sudo cp ${tmpPath} ${svc.path}`, { stdio: "inherit" });
       success(`${svc.name} service file installed`);
     } catch {
@@ -12429,9 +12919,9 @@ async function deployToAWS(opts) {
   }
   const __filename2 = fileURLToPath3(import.meta.url);
   const __dirname2 = dirname7(__filename2);
-  const templatePath = join30(__dirname2, "..", "..", "infra", "cloudformation", "beastmode.yaml");
-  const cwdTemplate = join30(process.cwd(), "infra", "cloudformation", "beastmode.yaml");
-  const template = existsSync32(templatePath) ? templatePath : existsSync32(cwdTemplate) ? cwdTemplate : null;
+  const templatePath = join31(__dirname2, "..", "..", "infra", "cloudformation", "beastmode.yaml");
+  const cwdTemplate = join31(process.cwd(), "infra", "cloudformation", "beastmode.yaml");
+  const template = existsSync33(templatePath) ? templatePath : existsSync33(cwdTemplate) ? cwdTemplate : null;
   if (!template) {
     error("CloudFormation template not found. Expected at infra/cloudformation/beastmode.yaml");
     process.exit(1);
@@ -12685,19 +13175,19 @@ var logsCommand = new Command21("logs").description("Stream BeastMode service lo
 
 // src/cli/commands/update.ts
 import { Command as Command22 } from "commander";
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync26 } from "fs";
+import { readFileSync as readFileSync31, writeFileSync as writeFileSync27 } from "fs";
 init_display();
 async function runUpdate(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const composePath = requireComposeFile(cwd);
   if (opts.tag) {
-    let content = readFileSync30(composePath, "utf-8");
+    let content = readFileSync31(composePath, "utf-8");
     const tagPattern = new RegExp(
       `(${GHCR_IMAGE_PREFIX.replace(/[/]/g, "\\/")}\\/(?:board|daemon|ui)):([\\w.\\-]+)`,
       "g"
     );
     content = content.replace(tagPattern, `$1:${opts.tag}`);
-    writeFileSync26(composePath, content, "utf-8");
+    writeFileSync27(composePath, content, "utf-8");
   }
   runCompose(["pull"], { cwd, inherit: true });
   runCompose(["up", "-d"], { cwd, inherit: true });
@@ -12719,26 +13209,27 @@ var updateCommand = new Command22("update").description("Pull latest BeastMode i
 });
 
 // src/cli/commands/runner-cmd.ts
+init_engine();
 init_display();
 import { Command as Command23 } from "commander";
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync37, readdirSync as readdirSync12, readFileSync as readFileSync34 } from "fs";
-import { basename as basename6, join as join36, resolve as resolve20 } from "path";
+import { existsSync as existsSync38 } from "fs";
+import { basename as basename7, join as join37, resolve as resolve20 } from "path";
 
 // src/cli/runner-image-builder.ts
 import { execSync as execSync10 } from "child_process";
 import { createHash } from "crypto";
 import {
-  existsSync as existsSync34,
-  mkdirSync as mkdirSync20,
-  readFileSync as readFileSync32,
-  writeFileSync as writeFileSync27
+  existsSync as existsSync35,
+  mkdirSync as mkdirSync21,
+  readFileSync as readFileSync33,
+  writeFileSync as writeFileSync28
 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 
 // src/cli/stack-detect.ts
-import { existsSync as existsSync33, readFileSync as readFileSync31 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync32 } from "fs";
+import { join as join32 } from "path";
 var NODE_LOCKFILES = [
   "package-lock.json",
   "pnpm-lock.yaml",
@@ -12776,7 +13267,7 @@ var STACK_LOCKFILES = {
 };
 function readFileSafe2(path) {
   try {
-    return readFileSync31(path, "utf-8");
+    return readFileSync32(path, "utf-8");
   } catch {
     return null;
   }
@@ -12789,7 +13280,7 @@ function parseJsonSafe2(content) {
   }
 }
 function detectRunnerStack(projectDir) {
-  const pkgContent = readFileSafe2(join31(projectDir, "package.json"));
+  const pkgContent = readFileSafe2(join32(projectDir, "package.json"));
   if (pkgContent) {
     const pkg = parseJsonSafe2(pkgContent);
     if (pkg) {
@@ -12803,36 +13294,36 @@ function detectRunnerStack(projectDir) {
     }
     return { name: "node", language: "node" };
   }
-  if (existsSync33(join31(projectDir, "manage.py"))) {
+  if (existsSync34(join32(projectDir, "manage.py"))) {
     return { name: "django", language: "python" };
   }
-  const pyproject = readFileSafe2(join31(projectDir, "pyproject.toml"));
+  const pyproject = readFileSafe2(join32(projectDir, "pyproject.toml"));
   if (pyproject) {
     if (pyproject.toLowerCase().includes("fastapi")) {
       return { name: "fastapi", language: "python" };
     }
     return { name: "python", language: "python" };
   }
-  if (existsSync33(join31(projectDir, "requirements.txt"))) {
+  if (existsSync34(join32(projectDir, "requirements.txt"))) {
     return { name: "python", language: "python" };
   }
-  if (existsSync33(join31(projectDir, "go.mod"))) {
+  if (existsSync34(join32(projectDir, "go.mod"))) {
     return { name: "go", language: "go" };
   }
-  if (existsSync33(join31(projectDir, "Cargo.toml"))) {
+  if (existsSync34(join32(projectDir, "Cargo.toml"))) {
     return { name: "rust", language: "rust" };
   }
-  if (existsSync33(join31(projectDir, "pom.xml"))) {
+  if (existsSync34(join32(projectDir, "pom.xml"))) {
     return { name: "java-maven", language: "java" };
   }
-  if (existsSync33(join31(projectDir, "build.gradle")) || existsSync33(join31(projectDir, "build.gradle.kts"))) {
+  if (existsSync34(join32(projectDir, "build.gradle")) || existsSync34(join32(projectDir, "build.gradle.kts"))) {
     return { name: "java-gradle", language: "java" };
   }
   return { name: "node", language: "node" };
 }
 function findLockfiles(projectDir, stackName) {
   const candidates = STACK_LOCKFILES[stackName] ?? [];
-  return candidates.filter((f) => existsSync33(join31(projectDir, f)));
+  return candidates.filter((f) => existsSync34(join32(projectDir, f)));
 }
 
 // src/cli/runner-image-builder.ts
@@ -12934,12 +13425,12 @@ function generateDockerfile(stack, lockfiles) {
 function computeLockfileHash(projectDir, lockfiles) {
   const hash = createHash("sha256");
   for (const lf of lockfiles) {
-    const path = join32(projectDir, lf);
+    const path = join33(projectDir, lf);
     hash.update(lf);
     hash.update("\0");
-    if (existsSync34(path)) {
+    if (existsSync35(path)) {
       try {
-        hash.update(readFileSync32(path));
+        hash.update(readFileSync33(path));
       } catch {
         hash.update("<unreadable>");
       }
@@ -12951,10 +13442,10 @@ function computeLockfileHash(projectDir, lockfiles) {
   return hash.digest("hex").slice(0, 16);
 }
 function readLastBuild(projectDir) {
-  const path = join32(projectDir, RUNNER_STATE_DIR, LAST_BUILD_FILE);
-  if (!existsSync34(path)) return null;
+  const path = join33(projectDir, RUNNER_STATE_DIR, LAST_BUILD_FILE);
+  if (!existsSync35(path)) return null;
   try {
-    const data = JSON.parse(readFileSync32(path, "utf-8"));
+    const data = JSON.parse(readFileSync33(path, "utf-8"));
     if (data && typeof data === "object" && typeof data.lockfileHash === "string" && typeof data.imageTag === "string" && typeof data.builtAt === "string") {
       return data;
     }
@@ -12973,17 +13464,17 @@ function imageTagFor(projectName, hash) {
   return `beastmode-runner-${safeName}:${hash}`;
 }
 function writeStateFile(projectDir, fileName, payload) {
-  const dir = join32(projectDir, RUNNER_STATE_DIR);
-  mkdirSync20(dir, { recursive: true });
-  writeFileSync27(
-    join32(dir, fileName),
+  const dir = join33(projectDir, RUNNER_STATE_DIR);
+  mkdirSync21(dir, { recursive: true });
+  writeFileSync28(
+    join33(dir, fileName),
     JSON.stringify(payload, null, 2) + "\n",
     "utf-8"
   );
 }
 function buildRunnerImage(opts) {
   const { projectDir, projectName, stack, lockfiles, force, dryRun } = opts;
-  if (!existsSync34(projectDir)) {
+  if (!existsSync35(projectDir)) {
     throw new Error(`Project directory not found: ${projectDir}`);
   }
   const lockfileHash = computeLockfileHash(projectDir, lockfiles);
@@ -13102,11 +13593,11 @@ function resolveGitHubConfig() {
 // src/cli/runner-helpers.ts
 import { execSync as execSync11, spawn, spawnSync as spawnSync5 } from "child_process";
 import { promises as fs } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 init_display();
 async function writeRunnerMeta(dir, meta) {
   await fs.mkdir(dir, { recursive: true });
-  const path = join33(dir, "runner-meta.json");
+  const path = join34(dir, "runner-meta.json");
   await fs.writeFile(path, JSON.stringify(meta, null, 2) + "\n", "utf-8");
 }
 function resolveRepoSlug() {
@@ -13307,13 +13798,13 @@ import {
 } from "child_process";
 import {
   createWriteStream,
-  existsSync as existsSync35,
-  mkdirSync as mkdirSync21,
+  existsSync as existsSync36,
+  mkdirSync as mkdirSync22,
   unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync28
+  writeFileSync as writeFileSync29
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join34, dirname as dirname8 } from "path";
+import { join as join35, dirname as dirname8 } from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 init_display();
@@ -13343,8 +13834,8 @@ function runnerDownloadUrl(os, arch) {
   return `https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-${ghOs}-${arch}-${RUNNER_VERSION}.tar.gz`;
 }
 async function downloadAndExtractRunner(installDir, os, arch) {
-  const runShPath = join34(installDir, "run.sh");
-  if (existsSync35(runShPath)) {
+  const runShPath = join35(installDir, "run.sh");
+  if (existsSync36(runShPath)) {
     info(
       `Runner binary already present at ${runShPath} \u2014 skipping download.`
     );
@@ -13354,7 +13845,7 @@ async function downloadAndExtractRunner(installDir, os, arch) {
     return;
   }
   const url = runnerDownloadUrl(os, arch);
-  const tarball = join34(installDir, "runner.tar.gz");
+  const tarball = join35(installDir, "runner.tar.gz");
   setupStep(
     `Downloading GitHub Actions runner v${RUNNER_VERSION} (${os}/${arch})...`
   );
@@ -13405,7 +13896,7 @@ async function configureRunner(installDir, repoUrl, token, name, labels) {
     "--unattended",
     "--replace"
   ];
-  const result = spawnSync6(join34(installDir, "config.sh"), args, {
+  const result = spawnSync6(join35(installDir, "config.sh"), args, {
     cwd: installDir,
     stdio: ["ignore", "inherit", "pipe"],
     encoding: "utf-8"
@@ -13433,7 +13924,7 @@ function startRunnerForeground(installDir) {
       "Use --service to install as a launchd agent for persistent operation."
     );
   }
-  spawn2(join34(installDir, "run.sh"), [], {
+  spawn2(join35(installDir, "run.sh"), [], {
     cwd: installDir,
     stdio: "inherit"
   });
@@ -13458,10 +13949,10 @@ WantedBy=default.target
 }
 async function installSystemdService(installDir, name) {
   const unitName = `beastmode-runner-${name}.service`;
-  const unitDir = join34(homedir4(), ".config", "systemd", "user");
-  mkdirSync21(unitDir, { recursive: true });
-  writeFileSync28(
-    join34(unitDir, unitName),
+  const unitDir = join35(homedir4(), ".config", "systemd", "user");
+  mkdirSync22(unitDir, { recursive: true });
+  writeFileSync29(
+    join35(unitDir, unitName),
     systemdUnitContent(installDir, name),
     "utf-8"
   );
@@ -13515,15 +14006,15 @@ function launchdPlistContent(installDir, name) {
 }
 async function installLaunchdService(installDir, name) {
   const label = `com.beastmode.runner.${name}`;
-  const plistPath2 = join34(
+  const plistPath2 = join35(
     homedir4(),
     "Library",
     "LaunchAgents",
     `${label}.plist`
   );
-  mkdirSync21(dirname8(plistPath2), { recursive: true });
-  mkdirSync21(join34(installDir, "logs"), { recursive: true });
-  writeFileSync28(plistPath2, launchdPlistContent(installDir, name), "utf-8");
+  mkdirSync22(dirname8(plistPath2), { recursive: true });
+  mkdirSync22(join35(installDir, "logs"), { recursive: true });
+  writeFileSync29(plistPath2, launchdPlistContent(installDir, name), "utf-8");
   try {
     execSync12(`launchctl load ${plistPath2}`, { stdio: "inherit" });
   } catch (err) {
@@ -13564,7 +14055,7 @@ async function nativeRunnerSetup(opts) {
   }
   const ghConfig = resolveGitHubConfig();
   const repoSlug = opts.repo ?? resolveRepoSlug();
-  const installDir = join34(homedir4(), ".beastmode", "runners", opts.name);
+  const installDir = join35(homedir4(), ".beastmode", "runners", opts.name);
   if (opts.dryRun) {
     info(
       `[dry-run] Would install native runner '${opts.name}' for repo ${repoSlug}`
@@ -13574,7 +14065,7 @@ async function nativeRunnerSetup(opts) {
     info(`[dry-run] Mode: ${opts.service ? "service" : "foreground"}`);
     return;
   }
-  mkdirSync21(installDir, { recursive: true });
+  mkdirSync22(installDir, { recursive: true });
   setupStep("Generating registration token via GitHub API...");
   const { token: regToken } = await createRegistrationToken(ghConfig);
   await downloadAndExtractRunner(installDir, platformOs, arch);
@@ -13612,13 +14103,13 @@ async function nativeRunnerSetup(opts) {
 
 // src/cli/workflow-switcher.ts
 import {
-  existsSync as existsSync36,
-  mkdirSync as mkdirSync22,
-  readFileSync as readFileSync33,
+  existsSync as existsSync37,
+  mkdirSync as mkdirSync23,
+  readFileSync as readFileSync34,
   unlinkSync as unlinkSync6,
-  writeFileSync as writeFileSync29
+  writeFileSync as writeFileSync30
 } from "fs";
-import { dirname as dirname9, join as join35 } from "path";
+import { dirname as dirname9, join as join36 } from "path";
 var TARGET_LABEL = "[self-hosted, beastmode]";
 var TARGET_WORKFLOWS = [
   ".github/workflows/test.yml",
@@ -13657,8 +14148,8 @@ function restoreRunsOn(content, originals) {
   return newLines.join("\n");
 }
 async function switchWorkflows(projectDir) {
-  const statePath = join35(projectDir, STATE_FILE);
-  if (existsSync36(statePath)) {
+  const statePath = join36(projectDir, STATE_FILE);
+  if (existsSync37(statePath)) {
     return { alreadySwitched: true, files: [] };
   }
   const state = {
@@ -13668,40 +14159,40 @@ async function switchWorkflows(projectDir) {
   };
   const resultFiles = [];
   for (const relPath of TARGET_WORKFLOWS) {
-    const absPath = join35(projectDir, relPath);
-    if (!existsSync36(absPath)) {
+    const absPath = join36(projectDir, relPath);
+    if (!existsSync37(absPath)) {
       throw new Error(`Workflow file not found: ${relPath}`);
     }
-    const content = readFileSync33(absPath, "utf-8");
+    const content = readFileSync34(absPath, "utf-8");
     const { newContent, originals } = replaceRunsOn(content, TARGET_LABEL);
     if (originals.length === 0) {
       throw new Error(`No runs-on found in ${relPath}`);
     }
-    writeFileSync29(absPath, newContent, "utf-8");
+    writeFileSync30(absPath, newContent, "utf-8");
     state.files.push({ relativePath: relPath, originals });
     resultFiles.push({ relativePath: relPath, jobCount: originals.length });
   }
-  mkdirSync22(dirname9(statePath), { recursive: true });
-  writeFileSync29(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  mkdirSync23(dirname9(statePath), { recursive: true });
+  writeFileSync30(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
   return { alreadySwitched: false, files: resultFiles };
 }
 async function restoreWorkflows(projectDir) {
-  const statePath = join35(projectDir, STATE_FILE);
-  if (!existsSync36(statePath)) {
+  const statePath = join36(projectDir, STATE_FILE);
+  if (!existsSync37(statePath)) {
     return { nothingToRestore: true, files: [] };
   }
   const state = JSON.parse(
-    readFileSync33(statePath, "utf-8")
+    readFileSync34(statePath, "utf-8")
   );
   const resultFiles = [];
   for (const fileState of state.files) {
-    const absPath = join35(projectDir, fileState.relativePath);
-    if (!existsSync36(absPath)) {
+    const absPath = join36(projectDir, fileState.relativePath);
+    if (!existsSync37(absPath)) {
       throw new Error(`Workflow file not found: ${fileState.relativePath}`);
     }
-    const content = readFileSync33(absPath, "utf-8");
+    const content = readFileSync34(absPath, "utf-8");
     const newContent = restoreRunsOn(content, fileState.originals);
-    writeFileSync29(absPath, newContent, "utf-8");
+    writeFileSync30(absPath, newContent, "utf-8");
     resultFiles.push({
       relativePath: fileState.relativePath,
       jobCount: fileState.originals.length
@@ -13714,25 +14205,19 @@ async function restoreWorkflows(projectDir) {
 // src/cli/commands/runner-cmd.ts
 var runnerCommand = new Command23("runner").description("Manage self-hosted GitHub Actions runners");
 function resolveProjectName(projectDir) {
-  const projectsDir = join36(projectDir, ".beastmode", "projects");
-  if (existsSync37(projectsDir)) {
+  const projectsDir = join37(projectDir, ".beastmode", "projects");
+  if (existsSync38(projectsDir)) {
     try {
-      for (const entry of readdirSync12(projectsDir)) {
-        if (!entry.endsWith(".json")) continue;
-        const file = join36(projectsDir, entry);
-        try {
-          const raw = readFileSync34(file, "utf-8");
-          const data = JSON.parse(raw);
-          if (typeof data.path === "string" && resolve20(data.path) === resolve20(projectDir) && typeof data.name === "string" && data.name.length > 0) {
-            return data.name;
-          }
-        } catch {
-        }
-      }
+      const records = listProjectRecords(projectsDir);
+      const target = resolve20(projectDir);
+      const match = records.find(
+        (r) => typeof r.path === "string" && resolve20(r.path) === target
+      );
+      if (match && match.name) return match.name;
     } catch {
     }
   }
-  return basename6(resolve20(projectDir));
+  return basename7(resolve20(projectDir));
 }
 async function runnerSetupAction(opts) {
   if (opts.service !== void 0 && !opts.native) {
@@ -14057,7 +14542,7 @@ runnerCommand.command("restore-workflows").description("Restore workflows to ori
 });
 async function runnerBuildImageAction(opts) {
   const projectDir = resolve20(opts.projectDir);
-  if (!existsSync37(projectDir)) {
+  if (!existsSync38(projectDir)) {
     throw new Error(`Project directory not found: ${projectDir}`);
   }
   const stack = detectRunnerStack(projectDir);
@@ -14107,25 +14592,14 @@ runnerCommand.command("build-image").description(
 // src/cli/commands/project-cmd.ts
 init_engine();
 import { Command as Command24 } from "commander";
-import { existsSync as existsSync38, mkdirSync as mkdirSync23, writeFileSync as writeFileSync30, readFileSync as readFileSync35, readdirSync as readdirSync13, renameSync as renameSync2 } from "fs";
-import { join as join37, resolve as resolve21, basename as basename7 } from "path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync24, readFileSync as readFileSync35, renameSync as renameSync3 } from "fs";
+import { join as join38, resolve as resolve21, basename as basename8 } from "path";
 import { execSync as execSync13 } from "child_process";
 var DEFAULT_MAX_PROJECTS = 5;
 var MIN_DISK_WARNING_GB = 10;
-function countExistingProjects(factoryDir) {
-  const projectsDir = join37(factoryDir, ".beastmode", "projects");
-  if (!existsSync38(projectsDir)) return 0;
-  let count = 0;
-  for (const entry of readdirSync13(projectsDir)) {
-    if (entry.startsWith(".")) continue;
-    if (existsSync38(join37(projectsDir, entry, "project.json"))) count++;
-    else if (entry.endsWith(".json")) count++;
-  }
-  return count;
-}
 function getMaxProjects(factoryDir) {
-  const configPath = join37(factoryDir, ".beastmode", "config.json");
-  if (existsSync38(configPath)) {
+  const configPath = join38(factoryDir, ".beastmode", "config.json");
+  if (existsSync39(configPath)) {
     try {
       const config = JSON.parse(readFileSync35(configPath, "utf-8"));
       if (typeof config.max_projects === "number") return config.max_projects;
@@ -14146,11 +14620,13 @@ function getFreeDiskGB() {
 }
 function projectAddAction(factoryDir, projectPath, opts) {
   const resolvedPath = resolve21(projectPath);
-  if (!existsSync38(resolvedPath)) throw new Error(`Directory not found: ${resolvedPath}`);
-  const projectName = opts.name || basename7(resolvedPath);
-  const projectsDir = join37(factoryDir, ".beastmode", "projects", projectName);
-  if (existsSync38(projectsDir)) throw new Error(`Project already exists: ${projectName}`);
-  const currentCount = countExistingProjects(factoryDir);
+  if (!existsSync39(resolvedPath)) throw new Error(`Directory not found: ${resolvedPath}`);
+  const projectName = opts.name || basename8(resolvedPath);
+  const projectsDir = join38(factoryDir, ".beastmode", "projects");
+  if (existsSync39(join38(projectsDir, projectName, "project.json"))) {
+    throw new Error(`Project already exists: ${projectName}`);
+  }
+  const currentCount = listProjectRecords(projectsDir).length;
   const maxProjects = getMaxProjects(factoryDir);
   if (currentCount >= maxProjects) {
     throw new Error(
@@ -14163,86 +14639,57 @@ function projectAddAction(factoryDir, projectPath, opts) {
       `Warning: only ${freeGB}GB free disk space. Each project with worktrees may use 1-2GB. Consider freeing space.`
     );
   }
-  mkdirSync23(projectsDir, { recursive: true });
-  let stack = {};
+  let detectedStack = null;
+  let gitRemote;
   try {
-    stack = detectStack(resolvedPath);
+    detectedStack = detectStack(resolvedPath);
+    if (detectedStack.git_remote) gitRemote = detectedStack.git_remote;
   } catch {
   }
   let verifyPort = 3001;
-  const allProjectsDir = join37(factoryDir, ".beastmode", "projects");
-  if (existsSync38(allProjectsDir)) {
-    for (const d of readdirSync13(allProjectsDir)) {
-      if (d.startsWith(".")) continue;
-      if (d === projectName) continue;
-      const pf = join37(allProjectsDir, d, "project.json");
-      if (existsSync38(pf)) {
-        try {
-          const pc = JSON.parse(readFileSync35(pf, "utf-8"));
-          const port = pc?.deploy?.verify_port;
-          if (typeof port === "number" && port >= verifyPort) verifyPort = port + 1;
-        } catch {
-        }
-      }
-    }
+  for (const existing of listProjectRecords(projectsDir)) {
+    const port = existing.deploy?.verify_port;
+    if (typeof port === "number" && port >= verifyPort) verifyPort = port + 1;
+  }
+  const boardId = opts.boardId ? parseInt(opts.boardId, 10) : null;
+  const record = createProjectRecord({ name: projectName, resolvedPath, boardId, verifyPort, gitRemote });
+  if (detectedStack) {
+    record.stack = {
+      detected: detectedStack.framework,
+      build_command: detectedStack.suggested_commands.build,
+      dev_command: detectedStack.suggested_commands.dev,
+      test_command: detectedStack.suggested_commands.test,
+      install_command: detectedStack.suggested_commands.install,
+      dev_port: detectedStack.dev_port,
+      is_monorepo: detectedStack.is_monorepo,
+      total_packages: detectedStack.total_packages,
+      primary_languages: detectedStack.primary_languages,
+      ...detectedStack.packages ? { packages: detectedStack.packages } : {}
+    };
   }
-  const projectConfig = {
-    name: projectName,
-    path: resolvedPath,
-    github: {
-      repo: stack.git_remote || "",
-      default_branch: "main"
-    },
-    board: {
-      id: opts.boardId ? parseInt(opts.boardId, 10) : null,
-      url: "http://127.0.0.1:8080",
-      auto_created: !opts.boardId
-    },
-    deploy: { verify_port: verifyPort },
-    pipeline: {},
-    models: {},
-    slots: { max: null },
-    registered_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeFileSync30(join37(projectsDir, "project.json"), JSON.stringify(projectConfig, null, 2) + "\n");
-  writeFileSync30(join37(projectsDir, "extensions.json"), JSON.stringify({
-    plugins: { add: [], remove: [] },
-    mcps: { add: {}, remove: [] },
-    skills: { add: [], remove: [] }
-  }, null, 2) + "\n");
-  const runsDir = join37(factoryDir, "runs", projectName);
-  if (!existsSync38(runsDir)) mkdirSync23(runsDir, { recursive: true });
-  if (!opts.boardId) {
+  writeProjectRecord(projectsDir, projectName, record);
+  const runsDir = join38(factoryDir, "runs", projectName);
+  if (!existsSync39(runsDir)) mkdirSync24(runsDir, { recursive: true });
+  if (!boardId) {
     void (async () => {
       try {
-        const boardUrl = projectConfig.board.url;
+        const boardUrl = record.board.url;
         const http4 = await import("http");
         const postData = JSON.stringify({ project_name: projectName });
-        await new Promise((resolve22, reject) => {
+        await new Promise((res) => {
           const url = new URL("/api/boards", boardUrl);
-          const req = http4.request(url, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              "Content-Length": Buffer.byteLength(postData).toString()
-            }
-          }, (res) => {
-            let data = "";
-            res.on("data", (chunk) => {
-              data += chunk.toString();
-            });
-            res.on("end", () => {
-              try {
-                const result = JSON.parse(data);
-                if (result.created) {
-                  projectConfig.board.auto_created = true;
-                }
-              } catch {
+          const req = http4.request(
+            url,
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(postData).toString()
               }
-              resolve22();
-            });
-          });
-          req.on("error", () => resolve22());
+            },
+            () => res()
+          );
+          req.on("error", () => res());
           req.end(postData);
         });
       } catch {
@@ -14251,28 +14698,21 @@ function projectAddAction(factoryDir, projectPath, opts) {
   }
 }
 function projectListAction(factoryDir) {
-  const projectsDir = join37(factoryDir, ".beastmode", "projects");
-  if (!existsSync38(projectsDir)) return [];
-  return readdirSync13(projectsDir).filter((d) => !d.startsWith(".") && existsSync38(join37(projectsDir, d, "project.json"))).map((d) => {
-    try {
-      return JSON.parse(readFileSync35(join37(projectsDir, d, "project.json"), "utf-8"));
-    } catch {
-      return null;
-    }
-  }).filter(Boolean);
+  const projectsDir = join38(factoryDir, ".beastmode", "projects");
+  return listProjectRecords(projectsDir);
 }
 function projectRemoveAction(factoryDir, name) {
-  const projectDir = join37(factoryDir, ".beastmode", "projects", name);
-  if (!existsSync38(projectDir)) throw new Error(`Project not found: ${name}`);
-  const archiveDir = join37(factoryDir, ".beastmode", "projects", ".archived", name);
-  mkdirSync23(join37(factoryDir, ".beastmode", "projects", ".archived"), { recursive: true });
-  renameSync2(projectDir, archiveDir);
+  const projectDir = join38(factoryDir, ".beastmode", "projects", name);
+  if (!existsSync39(projectDir)) throw new Error(`Project not found: ${name}`);
+  const archivedBase = join38(factoryDir, ".beastmode", "projects", ".archived");
+  mkdirSync24(archivedBase, { recursive: true });
+  renameSync3(projectDir, join38(archivedBase, name));
 }
 var projectCommand = new Command24("project").description("Manage projects in this factory");
 projectCommand.command("add <path>").description("Register a project").option("--name <name>", "Override project name").option("--board-id <id>", "Link to existing board ID").action((path, opts) => {
   const factoryDir = resolve21(".");
   projectAddAction(factoryDir, path, opts);
-  console.log(`Project registered: ${opts.name || basename7(resolve21(path))}`);
+  console.log(`Project registered: ${opts.name || basename8(resolve21(path))}`);
 });
 projectCommand.command("list").description("List registered projects").action(() => {
   const projects = projectListAction(resolve21("."));
@@ -14281,7 +14721,7 @@ projectCommand.command("list").description("List registered projects").action(()
     return;
   }
   for (const p of projects) {
-    console.log(`  ${p.name} \u2014 ${p.path}`);
+    console.log(`  ${p["name"]} \u2014 ${p["path"]}`);
   }
 });
 projectCommand.command("remove <name>").description("Archive a project").action((name) => {