@beastmode-develeap/beastmode 0.1.332 → 0.1.334

package/dist/index.js

@@ -1637,11 +1637,36 @@ var init_secret_validator = __esm({
 });
 
 // src/engine/version.ts
-var ENGINE_VERSION, SCHEMA_VERSION;
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join2 } from "path";
+function resolveEngineVersion() {
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 6; i++) {
+      const candidate = join2(dir, "package.json");
+      try {
+        const pkg = JSON.parse(readFileSync2(candidate, "utf-8"));
+        if (pkg.name === PACKAGE_NAME && pkg.version) {
+          return pkg.version;
+        }
+      } catch {
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+  }
+  return FALLBACK_VERSION;
+}
+var FALLBACK_VERSION, PACKAGE_NAME, ENGINE_VERSION, SCHEMA_VERSION;
 var init_version = __esm({
   "src/engine/version.ts"() {
     "use strict";
-    ENGINE_VERSION = "0.1.0";
+    FALLBACK_VERSION = "0.0.0-unknown";
+    PACKAGE_NAME = "@beastmode-develeap/beastmode";
+    ENGINE_VERSION = resolveEngineVersion();
     SCHEMA_VERSION = 1;
   }
 });
@@ -1839,21 +1864,21 @@ var init_template_importer = __esm({
 });
 
 // src/engine/config-validator.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
 function validateFactory(factoryDir, env) {
   const errors = [];
   const warnings = [];
-  const bmDir = join2(factoryDir, ".beastmode");
+  const bmDir = join3(factoryDir, ".beastmode");
   if (!existsSync2(bmDir)) {
     return { valid: false, errors: [`No factory found at ${factoryDir} (.beastmode directory missing)`], warnings };
   }
-  const factoryJsonPath = join2(bmDir, "factory.json");
+  const factoryJsonPath = join3(bmDir, "factory.json");
   if (!existsSync2(factoryJsonPath)) {
     errors.push("Missing .beastmode/factory.json");
   } else {
     try {
-      const raw = JSON.parse(readFileSync2(factoryJsonPath, "utf-8"));
+      const raw = JSON.parse(readFileSync3(factoryJsonPath, "utf-8"));
       const result = FactoryIdentitySchema.safeParse(raw);
       if (!result.success) {
         errors.push(`Invalid factory.json: ${result.error.issues.map((i) => i.message).join(", ")}`);
@@ -1862,12 +1887,12 @@ function validateFactory(factoryDir, env) {
       errors.push("factory.json is not valid JSON");
     }
   }
-  const configPath = join2(bmDir, "config.json");
+  const configPath = join3(bmDir, "config.json");
   if (!existsSync2(configPath)) {
     errors.push("Missing .beastmode/config.json");
   } else {
     try {
-      const raw = JSON.parse(readFileSync2(configPath, "utf-8"));
+      const raw = JSON.parse(readFileSync3(configPath, "utf-8"));
       const result = FactoryConfigSchema.safeParse(raw);
       if (!result.success) {
         for (const issue of result.error.issues) {
@@ -2267,8 +2292,8 @@ var init_plugin_resolver = __esm({
 });
 
 // src/engine/plugin-registry.ts
-import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync3, mkdirSync } from "fs";
-import { join as join3, resolve } from "path";
+import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync3, mkdirSync } from "fs";
+import { join as join4, resolve } from "path";
 function getRegistryUrl() {
   return process.env.BEASTMODE_REGISTRY_URL || DEFAULT_REGISTRY_URL;
 }
@@ -2280,24 +2305,24 @@ function readLocalRegistry(filePath) {
   if (!existsSync3(resolved)) {
     throw new Error(`Local registry file not found: ${resolved}`);
   }
-  const raw = JSON.parse(readFileSync3(resolved, "utf-8"));
+  const raw = JSON.parse(readFileSync4(resolved, "utf-8"));
   return RegistryIndexSchema.parse(raw);
 }
 function getCachePath(factoryDir) {
-  return join3(factoryDir, ".beastmode", ".cache", "registry-index.json");
+  return join4(factoryDir, ".beastmode", ".cache", "registry-index.json");
 }
 function readCache(factoryDir) {
   const cachePath = getCachePath(factoryDir);
   if (!existsSync3(cachePath)) return null;
   try {
-    return JSON.parse(readFileSync3(cachePath, "utf-8"));
+    return JSON.parse(readFileSync4(cachePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeCache(factoryDir, data) {
   const cachePath = getCachePath(factoryDir);
-  const cacheDir = join3(factoryDir, ".beastmode", ".cache");
+  const cacheDir = join4(factoryDir, ".beastmode", ".cache");
   mkdirSync(cacheDir, { recursive: true });
   writeFileSync(
     cachePath,
@@ -2368,20 +2393,20 @@ var init_plugin_registry = __esm({
 });
 
 // src/engine/mcp-manager.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
-import { dirname, join as join4 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2, join as join5 } from "path";
 function getMcpServersPath(factoryDir) {
-  return join4(factoryDir, ".beastmode", "mcp-servers.json");
+  return join5(factoryDir, ".beastmode", "mcp-servers.json");
 }
 function readMcpServers(factoryDir) {
   const filePath = getMcpServersPath(factoryDir);
   if (!existsSync4(filePath)) return {};
-  const raw = JSON.parse(readFileSync4(filePath, "utf-8"));
+  const raw = JSON.parse(readFileSync5(filePath, "utf-8"));
   return raw.servers || {};
 }
 function writeMcpServers(factoryDir, servers) {
   const filePath = getMcpServersPath(factoryDir);
-  const dir = dirname(filePath);
+  const dir = dirname2(filePath);
   if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
   writeFileSync2(filePath, JSON.stringify({ servers }, null, 2) + "\n", "utf-8");
 }
@@ -2413,10 +2438,10 @@ var init_mcp_manager = __esm({
 });
 
 // src/engine/hook-manager.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname2, join as join5 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname3, join as join6 } from "path";
 function getHooksPath(factoryDir) {
-  return join5(factoryDir, ".beastmode", "hooks.json");
+  return join6(factoryDir, ".beastmode", "hooks.json");
 }
 function validateEvent(event) {
   if (!HOOK_EVENTS.includes(event)) {
@@ -2433,12 +2458,12 @@ function emptyHooks() {
 function readHooks(factoryDir) {
   const filePath = getHooksPath(factoryDir);
   if (!existsSync5(filePath)) return emptyHooks();
-  const raw = JSON.parse(readFileSync5(filePath, "utf-8"));
+  const raw = JSON.parse(readFileSync6(filePath, "utf-8"));
   return raw.hooks || emptyHooks();
 }
 function writeHooks(factoryDir, hooks) {
   const filePath = getHooksPath(factoryDir);
-  const dir = dirname2(filePath);
+  const dir = dirname3(filePath);
   if (!existsSync5(dir)) mkdirSync3(dir, { recursive: true });
   writeFileSync3(
     filePath,
@@ -2487,40 +2512,40 @@ var init_hook_manager = __esm({
 // src/engine/plugin-installer.ts
 import {
   existsSync as existsSync6,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   writeFileSync as writeFileSync4,
   cpSync,
   rmSync,
   mkdirSync as mkdirSync4
 } from "fs";
-import { join as join6, resolve as resolve2 } from "path";
+import { join as join7, resolve as resolve2 } from "path";
 function readLock(factoryDir) {
-  const lockPath = join6(factoryDir, ".beastmode", "extensions.lock");
+  const lockPath = join7(factoryDir, ".beastmode", "extensions.lock");
   if (!existsSync6(lockPath)) {
     return { plugins: {}, locked_at: (/* @__PURE__ */ new Date()).toISOString() };
   }
-  return JSON.parse(readFileSync6(lockPath, "utf-8"));
+  return JSON.parse(readFileSync7(lockPath, "utf-8"));
 }
 function writeLock(factoryDir, lock) {
-  const lockPath = join6(factoryDir, ".beastmode", "extensions.lock");
+  const lockPath = join7(factoryDir, ".beastmode", "extensions.lock");
   lock.locked_at = (/* @__PURE__ */ new Date()).toISOString();
   writeFileSync4(lockPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
 }
 function readConfig(factoryDir) {
-  const configPath = join6(factoryDir, ".beastmode", "config.json");
+  const configPath = join7(factoryDir, ".beastmode", "config.json");
   if (!existsSync6(configPath)) return {};
-  return JSON.parse(readFileSync6(configPath, "utf-8"));
+  return JSON.parse(readFileSync7(configPath, "utf-8"));
 }
 function writeConfig(factoryDir, config) {
-  const configPath = join6(factoryDir, ".beastmode", "config.json");
+  const configPath = join7(factoryDir, ".beastmode", "config.json");
   writeFileSync4(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function registerPluginMcps(factoryDir, pluginName, pluginDir, manifest) {
   const mcpNames = manifest.provides?.mcp_servers || [];
   for (const mcpName of mcpNames) {
-    const mcpDefPath = join6(pluginDir, "mcp-servers", `${mcpName}.json`);
+    const mcpDefPath = join7(pluginDir, "mcp-servers", `${mcpName}.json`);
     if (!existsSync6(mcpDefPath)) continue;
-    const mcpDef = JSON.parse(readFileSync6(mcpDefPath, "utf-8"));
+    const mcpDef = JSON.parse(readFileSync7(mcpDefPath, "utf-8"));
     addMcp(factoryDir, mcpName, {
       command: mcpDef.command,
       args: mcpDef.args || [],
@@ -2533,9 +2558,9 @@ function registerPluginMcps(factoryDir, pluginName, pluginDir, manifest) {
 function registerPluginHooks(factoryDir, pluginName, pluginDir, manifest) {
   const hookNames = manifest.provides?.hooks || [];
   for (const hookName of hookNames) {
-    const hookDefPath = join6(pluginDir, "hooks", `${hookName}.json`);
+    const hookDefPath = join7(pluginDir, "hooks", `${hookName}.json`);
     if (!existsSync6(hookDefPath)) continue;
-    const hookDef = JSON.parse(readFileSync6(hookDefPath, "utf-8"));
+    const hookDef = JSON.parse(readFileSync7(hookDefPath, "utf-8"));
     const event = hookDef.event;
     if (!HOOK_EVENTS.includes(event)) continue;
     addHook(factoryDir, event, {
@@ -2569,13 +2594,13 @@ function unregisterPluginHooks(factoryDir, pluginName) {
 }
 async function installPlugin(factoryDir, sourcePath) {
   const resolvedPath = resolve2(sourcePath);
-  const manifestPath = join6(resolvedPath, "plugin.json");
+  const manifestPath = join7(resolvedPath, "plugin.json");
   if (!existsSync6(manifestPath)) {
     throw new Error(
       `plugin.json not found at ${manifestPath}. Is this a BeastMode plugin directory?`
     );
   }
-  const rawManifest = JSON.parse(readFileSync6(manifestPath, "utf-8"));
+  const rawManifest = JSON.parse(readFileSync7(manifestPath, "utf-8"));
   const manifest = parseManifest(rawManifest);
   const compat = checkEngineCompat(manifest.engine_version, ENGINE_VERSION);
   if (!compat.compatible) {
@@ -2589,15 +2614,15 @@ async function installPlugin(factoryDir, sourcePath) {
       `Plugin '${manifest.name}' is already installed. Remove it first with 'beastmode remove plugin ${manifest.name}'.`
     );
   }
-  const destDir = join6(factoryDir, ".beastmode", "plugins", manifest.name);
+  const destDir = join7(factoryDir, ".beastmode", "plugins", manifest.name);
   mkdirSync4(destDir, { recursive: true });
   cpSync(resolvedPath, destDir, { recursive: true });
   registerPluginMcps(factoryDir, manifest.name, destDir, manifest);
   registerPluginHooks(factoryDir, manifest.name, destDir, manifest);
   if (manifest.config_defaults) {
-    const defaultsPath = join6(destDir, manifest.config_defaults);
+    const defaultsPath = join7(destDir, manifest.config_defaults);
     if (existsSync6(defaultsPath)) {
-      const defaults = JSON.parse(readFileSync6(defaultsPath, "utf-8"));
+      const defaults = JSON.parse(readFileSync7(defaultsPath, "utf-8"));
       const currentConfig = readConfig(factoryDir);
       const mergedConfig = mergePluginDefaults(currentConfig, defaults);
       writeConfig(factoryDir, mergedConfig);
@@ -2620,13 +2645,13 @@ function removePlugin(factoryDir, name, options) {
   }
   if (!force) {
     const dependents = [];
-    const pluginsDir = join6(factoryDir, ".beastmode", "plugins");
+    const pluginsDir = join7(factoryDir, ".beastmode", "plugins");
     for (const [pluginName, _entry] of Object.entries(lock.plugins)) {
       if (pluginName === name) continue;
-      const pluginManifestPath = join6(pluginsDir, pluginName, "plugin.json");
+      const pluginManifestPath = join7(pluginsDir, pluginName, "plugin.json");
       if (!existsSync6(pluginManifestPath)) continue;
       try {
-        const pluginManifest = JSON.parse(readFileSync6(pluginManifestPath, "utf-8"));
+        const pluginManifest = JSON.parse(readFileSync7(pluginManifestPath, "utf-8"));
         if (Array.isArray(pluginManifest.dependencies) && pluginManifest.dependencies.includes(name)) {
           dependents.push(pluginName);
         }
@@ -2641,7 +2666,7 @@ function removePlugin(factoryDir, name, options) {
   }
   unregisterPluginMcps(factoryDir, name);
   unregisterPluginHooks(factoryDir, name);
-  const pluginDir = join6(factoryDir, ".beastmode", "plugins", name);
+  const pluginDir = join7(factoryDir, ".beastmode", "plugins", name);
   if (existsSync6(pluginDir)) {
     rmSync(pluginDir, { recursive: true, force: true });
   }
@@ -2665,12 +2690,12 @@ import {
   readdirSync as readdirSync2,
   cpSync as cpSync2,
   rmSync as rmSync2,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   writeFileSync as writeFileSync5,
   mkdirSync as mkdirSync5,
   statSync as statSync2
 } from "fs";
-import { join as join7, basename as basename2 } from "path";
+import { join as join8, basename as basename2 } from "path";
 function parseSkillFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return {};
@@ -2693,14 +2718,14 @@ function addSkill(factoryDir, sourcePath) {
   if (!stat.isDirectory()) {
     throw new Error(`Skill source must be a directory: ${sourcePath}`);
   }
-  const skillMdPath = join7(sourcePath, "SKILL.md");
+  const skillMdPath = join8(sourcePath, "SKILL.md");
   if (!existsSync7(skillMdPath)) {
     throw new Error(
       `SKILL.md not found in ${sourcePath}. Every skill must have a SKILL.md with frontmatter.`
     );
   }
   const skillName = basename2(sourcePath);
-  const destPath = join7(factoryDir, ".beastmode", "skills", skillName);
+  const destPath = join8(factoryDir, ".beastmode", "skills", skillName);
   if (existsSync7(destPath)) {
     throw new Error(
       `Skill '${skillName}' already exists at ${destPath}. Remove it first.`
@@ -2714,7 +2739,7 @@ function createSkill(factoryDir, name, description, body) {
   if (!body.trim()) throw new Error("Skill body is required");
   const slug = name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   if (!slug) throw new Error("Skill name must contain alphanumeric characters");
-  const skillDir = join7(factoryDir, ".beastmode", "skills", slug);
+  const skillDir = join8(factoryDir, ".beastmode", "skills", slug);
   if (existsSync7(skillDir)) {
     throw new Error(
       `Skill '${slug}' already exists. Remove it first or pick a different name.`
@@ -2731,11 +2756,11 @@ description: ${q(description.trim())}
 
 ${body.trim()}
 `;
-  writeFileSync5(join7(skillDir, "SKILL.md"), content, "utf-8");
+  writeFileSync5(join8(skillDir, "SKILL.md"), content, "utf-8");
   return { slug, path: skillDir };
 }
 function removeSkill(factoryDir, name) {
-  const skillPath = join7(factoryDir, ".beastmode", "skills", name);
+  const skillPath = join8(factoryDir, ".beastmode", "skills", name);
   if (!existsSync7(skillPath)) {
     throw new Error(`Skill '${name}' not found at ${skillPath}.`);
   }
@@ -2743,32 +2768,32 @@ function removeSkill(factoryDir, name) {
 }
 function listSkills(factoryDir) {
   const skills = [];
-  const bmDir = join7(factoryDir, ".beastmode");
-  const customSkillsDir = join7(bmDir, "skills");
+  const bmDir = join8(factoryDir, ".beastmode");
+  const customSkillsDir = join8(bmDir, "skills");
   if (existsSync7(customSkillsDir)) {
     for (const entry of readdirSync2(customSkillsDir, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const skillMdPath = join7(customSkillsDir, entry.name, "SKILL.md");
+      const skillMdPath = join8(customSkillsDir, entry.name, "SKILL.md");
       if (!existsSync7(skillMdPath)) continue;
       const frontmatter = parseSkillFrontmatter(
-        readFileSync7(skillMdPath, "utf-8")
+        readFileSync8(skillMdPath, "utf-8")
       );
       skills.push({
         name: frontmatter.name || entry.name,
         description: frontmatter.description || "",
         source: "custom",
-        path: join7(customSkillsDir, entry.name)
+        path: join8(customSkillsDir, entry.name)
       });
     }
   }
-  const pluginsDir = join7(bmDir, "plugins");
+  const pluginsDir = join8(bmDir, "plugins");
   if (existsSync7(pluginsDir)) {
     for (const pluginEntry of readdirSync2(pluginsDir, {
       withFileTypes: true
     })) {
       if (!pluginEntry.isDirectory() || pluginEntry.name.startsWith("."))
         continue;
-      const pluginSkillsDir = join7(
+      const pluginSkillsDir = join8(
         pluginsDir,
         pluginEntry.name,
         "skills"
@@ -2779,20 +2804,20 @@ function listSkills(factoryDir) {
       })) {
         if (!skillEntry.isDirectory() || skillEntry.name.startsWith("."))
           continue;
-        const skillMdPath = join7(
+        const skillMdPath = join8(
           pluginSkillsDir,
           skillEntry.name,
           "SKILL.md"
         );
         if (!existsSync7(skillMdPath)) continue;
         const frontmatter = parseSkillFrontmatter(
-          readFileSync7(skillMdPath, "utf-8")
+          readFileSync8(skillMdPath, "utf-8")
         );
         skills.push({
           name: frontmatter.name || skillEntry.name,
           description: frontmatter.description || "",
           source: `plugin:${pluginEntry.name}`,
-          path: join7(pluginSkillsDir, skillEntry.name)
+          path: join8(pluginSkillsDir, skillEntry.name)
         });
       }
     }
@@ -3223,8 +3248,8 @@ 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, unlinkSync } from "fs";
-import { join as join8, basename as basename3 } from "path";
+import { existsSync as existsSync8, writeFileSync as writeFileSync6, renameSync, readFileSync as readFileSync9, readdirSync as readdirSync3, mkdirSync as mkdirSync6, unlinkSync } from "fs";
+import { join as join9, basename as basename3 } from "path";
 function computeVerifyPort(existingProjects) {
   let port = 3001;
   if (existingProjects) {
@@ -3386,13 +3411,13 @@ function createProjectRecord(input) {
   };
 }
 function writeProjectRecord(projectsDir, name, record) {
-  const dir = join8(projectsDir, name);
+  const dir = join9(projectsDir, name);
   mkdirSync6(dir, { recursive: true });
-  const filePath = join8(dir, "project.json");
+  const filePath = join9(dir, "project.json");
   const tmpPath = `${filePath}.tmp`;
   writeFileSync6(tmpPath, JSON.stringify(record, null, 2) + "\n");
   renameSync(tmpPath, filePath);
-  const extPath = join8(dir, "extensions.json");
+  const extPath = join9(dir, "extensions.json");
   if (!existsSync8(extPath)) {
     writeFileSync6(
       extPath,
@@ -3409,17 +3434,17 @@ function writeProjectRecord(projectsDir, name, record) {
   }
 }
 function readProjectRecord(projectsDir, name) {
-  const subdirPath = join8(projectsDir, name, "project.json");
-  const flatPath = join8(projectsDir, `${name}.json`);
+  const subdirPath = join9(projectsDir, name, "project.json");
+  const flatPath = join9(projectsDir, `${name}.json`);
   let filePath;
   let isFlat = false;
   if (existsSync8(subdirPath)) {
     filePath = subdirPath;
     if (existsSync8(flatPath)) {
       try {
-        const flatParsed = JSON.parse(readFileSync8(flatPath, "utf-8"));
+        const flatParsed = JSON.parse(readFileSync9(flatPath, "utf-8"));
         const flatStack = flatParsed.stack;
-        const subdirParsed = JSON.parse(readFileSync8(filePath, "utf-8"));
+        const subdirParsed = JSON.parse(readFileSync9(filePath, "utf-8"));
         const subdirStack = subdirParsed.stack;
         if (flatStack && flatStack.detected && flatStack.detected !== "unknown" && (!subdirStack || subdirStack.detected === "unknown")) {
           subdirParsed.stack = flatStack;
@@ -3438,7 +3463,7 @@ function readProjectRecord(projectsDir, name) {
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync8(filePath, "utf-8"));
+    parsed = JSON.parse(readFileSync9(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -3463,7 +3488,7 @@ function listProjectRecords(projectsDir) {
   const records = [];
   for (const entry of readdirSync3(projectsDir)) {
     if (entry.startsWith(".")) continue;
-    if (existsSync8(join8(projectsDir, entry, "project.json"))) {
+    if (existsSync8(join9(projectsDir, entry, "project.json"))) {
       if (!seen.has(entry)) {
         seen.add(entry);
         const record = readProjectRecord(projectsDir, entry);
@@ -3629,10 +3654,10 @@ var init_engine = __esm({
 
 // src/cli/utils/file-writer.ts
 import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7, appendFileSync, existsSync as existsSync9 } from "fs";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname4 } from "path";
 function executeFileActions(actions) {
   for (const action of actions) {
-    const dir = dirname3(action.path);
+    const dir = dirname4(action.path);
     mkdirSync7(dir, { recursive: true });
     switch (action.action) {
       case "create":
@@ -3817,21 +3842,21 @@ var init_api_routes = __esm({
 });
 
 // src/cli/ui/archival.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync4, renameSync as renameSync2, readFileSync as readFileSync9, statSync as statSync3, writeFileSync as writeFileSync9, unlinkSync as unlinkSync2 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync4, renameSync as renameSync2, readFileSync as readFileSync10, statSync as statSync3, writeFileSync as writeFileSync9, unlinkSync as unlinkSync2 } from "fs";
+import { join as join11 } from "path";
 function archiveOldRuns(runsDir, archiveAfterDays) {
   if (archiveAfterDays <= 0 || !existsSync12(runsDir)) return { archived: 0 };
-  const archiveDir = join10(runsDir, ".archive");
+  const archiveDir = join11(runsDir, ".archive");
   const cutoff = Date.now() - archiveAfterDays * 24 * 60 * 60 * 1e3;
   let archived = 0;
   for (const entry of readdirSync4(runsDir)) {
     if (entry.startsWith(".") || !entry.startsWith("run-")) continue;
-    const runDir = join10(runsDir, entry);
-    if (existsSync12(join10(runDir, "pinned"))) continue;
-    const cpPath = join10(runDir, "checkpoint.json");
+    const runDir = join11(runsDir, entry);
+    if (existsSync12(join11(runDir, "pinned"))) continue;
+    const cpPath = join11(runDir, "checkpoint.json");
     if (!existsSync12(cpPath)) continue;
     try {
-      const cp = JSON.parse(readFileSync9(cpPath, "utf-8"));
+      const cp = JSON.parse(readFileSync10(cpPath, "utf-8"));
       const stage = (cp.current_stage || "").toLowerCase();
       if (stage !== "done" && stage !== "ship") continue;
     } catch {
@@ -3844,25 +3869,25 @@ function archiveOldRuns(runsDir, archiveAfterDays) {
       continue;
     }
     mkdirSync8(archiveDir, { recursive: true });
-    renameSync2(runDir, join10(archiveDir, entry));
+    renameSync2(runDir, join11(archiveDir, entry));
     archived++;
   }
   return { archived };
 }
 function pinRun(runsDir, runId) {
-  const runDir = join10(runsDir, runId);
+  const runDir = join11(runsDir, runId);
   if (!existsSync12(runDir)) return false;
-  writeFileSync9(join10(runDir, "pinned"), (/* @__PURE__ */ new Date()).toISOString());
+  writeFileSync9(join11(runDir, "pinned"), (/* @__PURE__ */ new Date()).toISOString());
   return true;
 }
 function unpinRun(runsDir, runId) {
-  const pinFile = join10(runsDir, runId, "pinned");
+  const pinFile = join11(runsDir, runId, "pinned");
   if (!existsSync12(pinFile)) return false;
   unlinkSync2(pinFile);
   return true;
 }
 function isRunPinned(runsDir, runId) {
-  return existsSync12(join10(runsDir, runId, "pinned"));
+  return existsSync12(join11(runsDir, runId, "pinned"));
 }
 var init_archival = __esm({
   "src/cli/ui/archival.ts"() {
@@ -3887,17 +3912,17 @@ __export(inception_exports, {
   saveArtifact: () => saveArtifact,
   saveInceptionState: () => saveInceptionState
 });
-import { existsSync as existsSync13, mkdirSync as mkdirSync9, writeFileSync as writeFileSync10, readFileSync as readFileSync10, readdirSync as readdirSync5, unlinkSync as unlinkSync3 } from "fs";
-import { join as join11, dirname as dirname4 } from "path";
-import { fileURLToPath } from "url";
+import { existsSync as existsSync13, mkdirSync as mkdirSync9, writeFileSync as writeFileSync10, readFileSync as readFileSync11, readdirSync as readdirSync5, unlinkSync as unlinkSync3 } from "fs";
+import { join as join12, dirname as dirname5 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function getMethodologiesDir() {
   const candidates = [
-    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")
+    join12(dirname5(fileURLToPath2(import.meta.url)), "methodologies"),
+    join12(dirname5(fileURLToPath2(import.meta.url)), "..", "methodologies"),
+    join12(process.cwd(), "src", "cli", "ui", "methodologies"),
+    join12(process.cwd(), "dist", "methodologies"),
+    join12(process.cwd(), "cli", "src", "cli", "ui", "methodologies"),
+    join12(process.cwd(), "cli", "dist", "methodologies")
   ];
   for (const dir of candidates) {
     if (existsSync13(dir)) return dir;
@@ -3906,18 +3931,18 @@ function getMethodologiesDir() {
 }
 function getMethodology(id) {
   const dir = getMethodologiesDir();
-  const filePath = join11(dir, `${id.replace(/_/g, "-")}.json`);
+  const filePath = join12(dir, `${id.replace(/_/g, "-")}.json`);
   if (!existsSync13(filePath)) {
     throw new Error(`Methodology not found: ${id}`);
   }
-  return JSON.parse(readFileSync10(filePath, "utf-8"));
+  return JSON.parse(readFileSync11(filePath, "utf-8"));
 }
 function listMethodologies() {
   const dir = getMethodologiesDir();
   if (!existsSync13(dir)) return [];
   return readdirSync5(dir).filter((f) => f.endsWith(".json")).map((f) => {
     try {
-      const m = JSON.parse(readFileSync10(join11(dir, f), "utf-8"));
+      const m = JSON.parse(readFileSync11(join12(dir, f), "utf-8"));
       return { id: m.id, name: m.name, description: m.description };
     } catch {
       return null;
@@ -3925,7 +3950,7 @@ function listMethodologies() {
   }).filter(Boolean);
 }
 function getProductDir(factoryDir, productName) {
-  return join11(factoryDir, ".beastmode", "products", productName);
+  return join12(factoryDir, ".beastmode", "products", productName);
 }
 function createInceptionState(factoryDir, opts) {
   const methodology = getMethodology(opts.methodology);
@@ -3947,21 +3972,21 @@ function createInceptionState(factoryDir, opts) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     projectName: null
   };
-  writeFileSync10(join11(productDir, "inception.json"), JSON.stringify(state, null, 2) + "\n");
+  writeFileSync10(join12(productDir, "inception.json"), JSON.stringify(state, null, 2) + "\n");
   return state;
 }
 function loadInception(factoryDir, productName) {
-  const filePath = join11(getProductDir(factoryDir, productName), "inception.json");
+  const filePath = join12(getProductDir(factoryDir, productName), "inception.json");
   if (!existsSync13(filePath)) return null;
   try {
-    return JSON.parse(readFileSync10(filePath, "utf-8"));
+    return JSON.parse(readFileSync11(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveInceptionState(factoryDir, state) {
   const productDir = getProductDir(factoryDir, state.productName);
-  writeFileSync10(join11(productDir, "inception.json"), JSON.stringify(state, null, 2) + "\n");
+  writeFileSync10(join12(productDir, "inception.json"), JSON.stringify(state, null, 2) + "\n");
 }
 function advancePhase(factoryDir, productName) {
   const state = loadInception(factoryDir, productName);
@@ -3982,27 +4007,27 @@ function advancePhase(factoryDir, productName) {
 function saveArtifact(factoryDir, productName, filename, content) {
   const productDir = getProductDir(factoryDir, productName);
   mkdirSync9(productDir, { recursive: true });
-  const filePath = join11(productDir, filename);
-  mkdirSync9(dirname4(filePath), { recursive: true });
+  const filePath = join12(productDir, filename);
+  mkdirSync9(dirname5(filePath), { recursive: true });
   writeFileSync10(filePath, content);
 }
 function loadArtifact(factoryDir, productName, filename) {
-  const filePath = join11(getProductDir(factoryDir, productName), filename);
+  const filePath = join12(getProductDir(factoryDir, productName), filename);
   if (!existsSync13(filePath)) return null;
-  return readFileSync10(filePath, "utf-8");
+  return readFileSync11(filePath, "utf-8");
 }
 function migrateInceptionToSession(factoryDir, productName) {
-  const productDir = join11(factoryDir, ".beastmode", "products", productName);
-  const oldInception = join11(productDir, "inception.json");
+  const productDir = join12(factoryDir, ".beastmode", "products", productName);
+  const oldInception = join12(productDir, "inception.json");
   if (!existsSync13(oldInception)) return false;
-  const sessionsDir = join11(productDir, "sessions");
+  const sessionsDir = join12(productDir, "sessions");
   if (existsSync13(sessionsDir) && readdirSync5(sessionsDir).some((d) => d.startsWith("session-"))) {
     return false;
   }
-  const sessionDir = join11(sessionsDir, "session-001");
+  const sessionDir = join12(sessionsDir, "session-001");
   mkdirSync9(sessionDir, { recursive: true });
-  const content = readFileSync10(oldInception, "utf-8");
-  writeFileSync10(join11(sessionDir, "inception.json"), content);
+  const content = readFileSync11(oldInception, "utf-8");
+  writeFileSync10(join12(sessionDir, "inception.json"), content);
   const artifactFiles = [
     "prd.md",
     "architecture.md",
@@ -4015,9 +4040,9 @@ function migrateInceptionToSession(factoryDir, productName) {
     "project-plan.md"
   ];
   for (const file of artifactFiles) {
-    const src = join11(productDir, file);
+    const src = join12(productDir, file);
     if (existsSync13(src)) {
-      writeFileSync10(join11(sessionDir, file), readFileSync10(src, "utf-8"));
+      writeFileSync10(join12(sessionDir, file), readFileSync11(src, "utf-8"));
       unlinkSync3(src);
     }
   }
@@ -4025,11 +4050,11 @@ function migrateInceptionToSession(factoryDir, productName) {
   return true;
 }
 function listProducts(factoryDir) {
-  const productsDir = join11(factoryDir, ".beastmode", "products");
+  const productsDir = join12(factoryDir, ".beastmode", "products");
   if (!existsSync13(productsDir)) return [];
-  return readdirSync5(productsDir).filter((d) => existsSync13(join11(productsDir, d, "inception.json"))).map((d) => {
+  return readdirSync5(productsDir).filter((d) => existsSync13(join12(productsDir, d, "inception.json"))).map((d) => {
     try {
-      const state = JSON.parse(readFileSync10(join11(productsDir, d, "inception.json"), "utf-8"));
+      const state = JSON.parse(readFileSync11(join12(productsDir, d, "inception.json"), "utf-8"));
       return {
         name: state.productName || d,
         methodology: state.methodology || "unknown",
@@ -4152,13 +4177,13 @@ __export(strategy_exports, {
   saveSessionArtifact: () => saveSessionArtifact,
   saveStrategySession: () => saveStrategySession
 });
-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";
+import { existsSync as existsSync14, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11, readFileSync as readFileSync12, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
+import { join as join13 } from "path";
 function getProductDir2(factoryDir, projectName) {
-  return join12(factoryDir, ".beastmode", "products", projectName);
+  return join13(factoryDir, ".beastmode", "products", projectName);
 }
 function getSessionsDir(factoryDir, projectName) {
-  return join12(getProductDir2(factoryDir, projectName), "sessions");
+  return join13(getProductDir2(factoryDir, projectName), "sessions");
 }
 function nextSessionId(factoryDir, projectName) {
   const sessionsDir = getSessionsDir(factoryDir, projectName);
@@ -4171,7 +4196,7 @@ function nextSessionId(factoryDir, projectName) {
 function createStrategySession(factoryDir, projectName, opts) {
   const methodology = getMethodology(opts.methodology);
   const sessionId = nextSessionId(factoryDir, projectName);
-  const sessionDir = join12(getSessionsDir(factoryDir, projectName), sessionId);
+  const sessionDir = join13(getSessionsDir(factoryDir, projectName), sessionId);
   mkdirSync10(sessionDir, { recursive: true });
   const session = {
     sessionId,
@@ -4193,52 +4218,52 @@ function createStrategySession(factoryDir, projectName, opts) {
     sessionType: opts.sessionType || "free-form",
     approach: opts.approach || "auto"
   };
-  writeFileSync11(join12(sessionDir, "inception.json"), JSON.stringify(session, null, 2) + "\n");
+  writeFileSync11(join13(sessionDir, "inception.json"), JSON.stringify(session, null, 2) + "\n");
   return session;
 }
 function listStrategySessions(factoryDir, projectName) {
   const sessionsDir = getSessionsDir(factoryDir, projectName);
   if (!existsSync14(sessionsDir)) return [];
   return readdirSync6(sessionsDir).filter((d) => d.startsWith("session-")).sort().map((d) => {
-    const file = join12(sessionsDir, d, "inception.json");
+    const file = join13(sessionsDir, d, "inception.json");
     if (!existsSync14(file)) return null;
     try {
-      return JSON.parse(readFileSync11(file, "utf-8"));
+      return JSON.parse(readFileSync12(file, "utf-8"));
     } catch {
       return null;
     }
   }).filter(Boolean);
 }
 function loadStrategySession(factoryDir, projectName, sessionId) {
-  const file = join12(getSessionsDir(factoryDir, projectName), sessionId, "inception.json");
+  const file = join13(getSessionsDir(factoryDir, projectName), sessionId, "inception.json");
   if (!existsSync14(file)) return null;
   try {
-    return JSON.parse(readFileSync11(file, "utf-8"));
+    return JSON.parse(readFileSync12(file, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveStrategySession(factoryDir, projectName, sessionId, session) {
-  const dir = join12(getSessionsDir(factoryDir, projectName), sessionId);
+  const dir = join13(getSessionsDir(factoryDir, projectName), sessionId);
   mkdirSync10(dir, { recursive: true });
   session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync11(join12(dir, "inception.json"), JSON.stringify(session, null, 2) + "\n");
+  writeFileSync11(join13(dir, "inception.json"), JSON.stringify(session, null, 2) + "\n");
 }
 function saveSessionArtifact(factoryDir, projectName, sessionId, filename, content) {
-  const dir = join12(getSessionsDir(factoryDir, projectName), sessionId);
+  const dir = join13(getSessionsDir(factoryDir, projectName), sessionId);
   mkdirSync10(dir, { recursive: true });
-  writeFileSync11(join12(dir, filename), content);
+  writeFileSync11(join13(dir, filename), content);
 }
 function loadSessionArtifact(factoryDir, projectName, sessionId, filename) {
-  const file = join12(getSessionsDir(factoryDir, projectName), sessionId, filename);
+  const file = join13(getSessionsDir(factoryDir, projectName), sessionId, filename);
   if (!existsSync14(file)) return null;
-  return readFileSync11(file, "utf-8");
+  return readFileSync12(file, "utf-8");
 }
 function buildArtifactIndex(factoryDir, projectName) {
   const artifacts = [];
-  const brownfieldPath = join12(factoryDir, ".beastmode", "projects", projectName, "brownfield.md");
+  const brownfieldPath = join13(factoryDir, ".beastmode", "projects", projectName, "brownfield.md");
   if (existsSync14(brownfieldPath)) {
-    const content = readFileSync11(brownfieldPath, "utf-8");
+    const content = readFileSync12(brownfieldPath, "utf-8");
     const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#")) || "";
     artifacts.push({
       type: "brownfield",
@@ -4251,19 +4276,19 @@ function buildArtifactIndex(factoryDir, projectName) {
   for (const session of sessions) {
     artifacts.push({
       type: "strategy_session",
-      path: join12(getSessionsDir(factoryDir, projectName), session.sessionId),
+      path: join13(getSessionsDir(factoryDir, projectName), session.sessionId),
       summary: `${session.name} (${session.methodology}) \u2014 ${session.status}`,
       date: session.createdAt,
       sessionId: session.sessionId
     });
   }
-  const runsDir = join12(factoryDir, "runs", projectName);
+  const runsDir = join13(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 = join12(runsDir, runId, "nlspec.md");
+      const nlspecPath = join13(runsDir, runId, "nlspec.md");
       if (existsSync14(nlspecPath)) {
-        const content = readFileSync11(nlspecPath, "utf-8");
+        const content = readFileSync12(nlspecPath, "utf-8");
         const title = content.split("\n").find((l) => l.startsWith("# ")) || runId;
         artifacts.push({
           type: "nlspec",
@@ -4275,12 +4300,12 @@ function buildArtifactIndex(factoryDir, projectName) {
       }
     }
   }
-  const learningsDir = join12(getProductDir2(factoryDir, projectName), "learnings");
+  const learningsDir = join13(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 = join12(learningsDir, file);
-      const content = readFileSync11(filePath, "utf-8");
+      const filePath = join13(learningsDir, file);
+      const content = readFileSync12(filePath, "utf-8");
       const firstHeading = content.split("\n").find((l) => l.startsWith("## ")) || file;
       artifacts.push({
         type: "learning",
@@ -4311,8 +4336,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 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 { readFileSync as readFileSync13, writeFileSync as writeFileSync12, existsSync as existsSync15, mkdirSync as mkdirSync11, readdirSync as readdirSync7, statSync as statSync5 } from "fs";
+import { join as join14 } from "path";
 import http from "http";
 import { WebSocketServer, WebSocket as WsWebSocket } from "ws";
 function getRecentTokenUsage() {
@@ -4424,17 +4449,17 @@ function getToolDefinitions() {
 function readJsonSafe(filePath) {
   if (!existsSync15(filePath)) return null;
   try {
-    return JSON.parse(readFileSync12(filePath, "utf-8"));
+    return JSON.parse(readFileSync13(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function getBoardUrl(factoryPath) {
   if (process.env.BEASTMODE_BOARD_URL) return process.env.BEASTMODE_BOARD_URL;
-  const configPath = join13(factoryPath, ".beastmode", "config.json");
+  const configPath = join14(factoryPath, ".beastmode", "config.json");
   if (existsSync15(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;
     } catch {
     }
@@ -4445,19 +4470,19 @@ async function executeTool(toolName, toolInput, factoryPath) {
   try {
     switch (toolName) {
       case "factory_status": {
-        const bmDir = join13(factoryPath, ".beastmode");
-        const factory = readJsonSafe(join13(bmDir, "factory.json"));
-        const projectsDir = join13(bmDir, "projects");
+        const bmDir = join14(factoryPath, ".beastmode");
+        const factory = readJsonSafe(join14(bmDir, "factory.json"));
+        const projectsDir = join14(bmDir, "projects");
         let projects = [];
         if (existsSync15(projectsDir)) {
           projects = readdirSync7(projectsDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
         }
-        const runsDir = join13(factoryPath, "runs");
+        const runsDir = join14(factoryPath, "runs");
         let runs = [];
         if (existsSync15(runsDir)) {
           runs = readdirSync7(runsDir).filter((d) => {
             try {
-              return statSync5(join13(runsDir, d)).isDirectory();
+              return statSync5(join14(runsDir, d)).isDirectory();
             } catch {
               return false;
             }
@@ -4465,10 +4490,10 @@ async function executeTool(toolName, toolInput, factoryPath) {
         }
         let daemonStatus = "stopped";
         let daemonPid = null;
-        const pidFile = join13(bmDir, "daemon.pid");
+        const pidFile = join14(bmDir, "daemon.pid");
         if (existsSync15(pidFile)) {
           try {
-            daemonPid = parseInt(readFileSync12(pidFile, "utf-8").trim(), 10);
+            daemonPid = parseInt(readFileSync13(pidFile, "utf-8").trim(), 10);
             process.kill(daemonPid, 0);
             daemonStatus = "running";
           } catch {
@@ -4516,7 +4541,7 @@ async function executeTool(toolName, toolInput, factoryPath) {
         }, null, 2);
       }
       case "factory_config": {
-        const configPath = join13(factoryPath, ".beastmode", "config.json");
+        const configPath = join14(factoryPath, ".beastmode", "config.json");
         const config = readJsonSafe(configPath);
         return config ? JSON.stringify(config, null, 2) : "No config.json found.";
       }
@@ -4571,12 +4596,12 @@ async function executeTool(toolName, toolInput, factoryPath) {
         }
       }
       case "list_runs": {
-        const runsDir = join13(factoryPath, "runs");
+        const runsDir = join14(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(join13(runsDir, id, "checkpoint.json"));
+          const cp = readJsonSafe(join14(runsDir, id, "checkpoint.json"));
           if (cp) {
             const hist = Array.isArray(cp.satisfaction_history) ? cp.satisfaction_history : [];
             results.push({
@@ -4592,15 +4617,15 @@ async function executeTool(toolName, toolInput, factoryPath) {
       case "run_detail": {
         const runId = toolInput.run_id;
         if (runId.includes("..")) return "Invalid run_id.";
-        const runDir = join13(factoryPath, "runs", runId);
+        const runDir = join14(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 manifest = readJsonSafe(join14(runDir, "manifest.json"));
+        const checkpoint = readJsonSafe(join14(runDir, "checkpoint.json"));
+        const iterDir = join14(runDir, "iterations");
         const iterations = [];
         if (existsSync15(iterDir)) {
           for (const d of readdirSync7(iterDir).sort()) {
-            const sat = readJsonSafe(join13(iterDir, d, "satisfaction.json"));
+            const sat = readJsonSafe(join14(iterDir, d, "satisfaction.json"));
             iterations.push({ number: parseInt(d, 10), satisfaction: sat });
           }
         }
@@ -4611,17 +4636,17 @@ async function executeTool(toolName, toolInput, factoryPath) {
         const runId = toolInput.run_id;
         const relPath = toolInput.file_path;
         if (runId.includes("..") || relPath.includes("..")) return "Invalid path.";
-        const fullPath = join13(factoryPath, "runs", runId, relPath);
+        const fullPath = join14(factoryPath, "runs", runId, relPath);
         if (!existsSync15(fullPath)) return `File not found: runs/${runId}/${relPath}`;
-        const content = readFileSync12(fullPath, "utf-8");
+        const content = readFileSync13(fullPath, "utf-8");
         return content.length > 1e4 ? content.slice(0, 1e4) + "\n\n... (truncated at 10KB)" : content;
       }
       case "list_projects": {
-        const projDir = join13(factoryPath, ".beastmode", "projects");
+        const projDir = join14(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(readFileSync12(join13(projDir, f), "utf-8"));
+            return JSON.parse(readFileSync13(join14(projDir, f), "utf-8"));
           } catch {
             return null;
           }
@@ -4631,7 +4656,7 @@ async function executeTool(toolName, toolInput, factoryPath) {
       case "read_file": {
         const relPath = toolInput.path;
         if (relPath.includes("..")) return "Invalid path.";
-        const fullPath = join13(factoryPath, relPath);
+        const fullPath = join14(factoryPath, relPath);
         if (!fullPath.startsWith(factoryPath)) return "Path traversal not allowed.";
         if (!existsSync15(fullPath)) return `File not found: ${relPath}`;
         try {
@@ -4639,13 +4664,13 @@ async function executeTool(toolName, toolInput, factoryPath) {
           return `"${relPath}" is a directory with ${entries.length} entries: ${entries.slice(0, 30).join(", ")}`;
         } catch {
         }
-        const content = readFileSync12(fullPath, "utf-8");
+        const content = readFileSync13(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 = join13(factoryPath, relPath);
+        const fullPath = join14(factoryPath, relPath);
         if (!fullPath.startsWith(factoryPath)) return "Path traversal not allowed.";
         if (!existsSync15(fullPath)) return `Directory not found: ${relPath || "/"}`;
         try {
@@ -4662,7 +4687,7 @@ async function executeTool(toolName, toolInput, factoryPath) {
   }
 }
 function getChatHistoryDir(factoryPath) {
-  const dir = join13(factoryPath, ".beastmode", "chat-history");
+  const dir = join14(factoryPath, ".beastmode", "chat-history");
   if (!existsSync15(dir)) mkdirSync11(dir, { recursive: true });
   return dir;
 }
@@ -4674,13 +4699,13 @@ function saveConversation(factoryPath, sessionId, messages, scope) {
     updated_at: (/* @__PURE__ */ new Date()).toISOString(),
     messages
   };
-  writeFileSync12(join13(dir, `${sessionId}.json`), JSON.stringify(data, null, 2));
+  writeFileSync12(join14(dir, `${sessionId}.json`), JSON.stringify(data, null, 2));
 }
 function listConversations(factoryPath) {
   const dir = getChatHistoryDir(factoryPath);
   return readdirSync7(dir).filter((f) => f.endsWith(".json")).map((f) => {
     try {
-      const data = JSON.parse(readFileSync12(join13(dir, f), "utf-8"));
+      const data = JSON.parse(readFileSync13(join14(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) : "";
@@ -4698,10 +4723,10 @@ function listConversations(factoryPath) {
 }
 function loadConversation(factoryPath, sessionId) {
   if (sessionId.includes("..")) return [];
-  const file = join13(getChatHistoryDir(factoryPath), `${sessionId}.json`);
+  const file = join14(getChatHistoryDir(factoryPath), `${sessionId}.json`);
   if (!existsSync15(file)) return [];
   try {
-    const data = JSON.parse(readFileSync12(file, "utf-8"));
+    const data = JSON.parse(readFileSync13(file, "utf-8"));
     return data.messages || [];
   } catch {
     return [];
@@ -4709,7 +4734,7 @@ function loadConversation(factoryPath, sessionId) {
 }
 function buildSystemPrompt(factoryPath) {
   let factoryName = "BeastMode Factory";
-  const factoryJson = readJsonSafe(join13(factoryPath, ".beastmode", "factory.json"));
+  const factoryJson = readJsonSafe(join14(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}.
@@ -5256,8 +5281,8 @@ var init_chat_handler = __esm({
 });
 
 // src/cli/ui/board-api-routes.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync13, existsSync as existsSync16, readdirSync as readdirSync8, unlinkSync as unlinkSync4, mkdirSync as mkdirSync12, statSync as statSync6 } from "fs";
-import { join as join14, basename as basename5, resolve as resolve4, dirname as dirname5, sep } from "path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync13, existsSync as existsSync16, readdirSync as readdirSync8, unlinkSync as unlinkSync4, mkdirSync as mkdirSync12, statSync as statSync6 } from "fs";
+import { join as join15, basename as basename5, resolve as resolve4, dirname as dirname6, sep } from "path";
 import { homedir } from "os";
 import { randomUUID as randomUUID2 } from "crypto";
 import { execSync as execSync3, spawnSync } from "child_process";
@@ -5301,10 +5326,10 @@ function assertSafeName(name) {
 }
 function getBoardUrl2(factoryDir) {
   if (process.env.BEASTMODE_BOARD_URL) return process.env.BEASTMODE_BOARD_URL;
-  const configPath = join14(factoryDir, ".beastmode", "config.json");
+  const configPath = join15(factoryDir, ".beastmode", "config.json");
   if (existsSync16(configPath)) {
     try {
-      const config = JSON.parse(readFileSync13(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync14(configPath, "utf-8"));
       if (config.task_backend?.config?.url) {
         return config.task_backend.config.url;
       }
@@ -5445,7 +5470,7 @@ function scopedQuery(query) {
 function readJsonFile(filePath) {
   if (!existsSync16(filePath)) return null;
   try {
-    return JSON.parse(readFileSync13(filePath, "utf-8"));
+    return JSON.parse(readFileSync14(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -5486,8 +5511,8 @@ function applyPresetOverrides(current, patch, presetName) {
 }
 function syncToDaemonConfigs(merged, factoryDir) {
   const daemonConfigPaths = [
-    join14(factoryDir, "config", "beastmode.daemon.json"),
-    join14(factoryDir, "config", "beastmode.docker.json")
+    join15(factoryDir, "config", "beastmode.daemon.json"),
+    join15(factoryDir, "config", "beastmode.docker.json")
   ].filter(existsSync16);
   const pipelineToDaemonMap = {
     satisfaction_threshold: ["verification", "satisfaction_threshold"],
@@ -5512,7 +5537,7 @@ function syncToDaemonConfigs(merged, factoryDir) {
   ];
   for (const daemonConfigPath of daemonConfigPaths) {
     try {
-      const daemonConfig = JSON.parse(readFileSync13(daemonConfigPath, "utf-8"));
+      const daemonConfig = JSON.parse(readFileSync14(daemonConfigPath, "utf-8"));
       let changed = false;
       for (const field of daemonFields) {
         if (field in merged && merged[field] !== daemonConfig[field]) {
@@ -5575,25 +5600,25 @@ function syncToDaemonConfigs(merged, factoryDir) {
   }
 }
 function getRunsDir(factoryDir) {
-  const configPath = join14(factoryDir, ".beastmode", "config.json");
+  const configPath = join15(factoryDir, ".beastmode", "config.json");
   if (existsSync16(configPath)) {
     try {
-      const config = JSON.parse(readFileSync13(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync14(configPath, "utf-8"));
       if (config.runs_path) return config.runs_path;
     } catch {
     }
   }
-  return join14(factoryDir, "runs");
+  return join15(factoryDir, "runs");
 }
 function scanStrandedRuns(runsDir, newThreshold) {
   if (!existsSync16(runsDir)) return [];
   const stranded = [];
   const walkRun = (runPath, projectId) => {
-    const ckptPath = join14(runPath, "checkpoint.json");
+    const ckptPath = join15(runPath, "checkpoint.json");
     if (!existsSync16(ckptPath)) return;
     let ckpt;
     try {
-      ckpt = JSON.parse(readFileSync13(ckptPath, "utf-8"));
+      ckpt = JSON.parse(readFileSync14(ckptPath, "utf-8"));
     } catch {
       return;
     }
@@ -5613,7 +5638,7 @@ function scanStrandedRuns(runsDir, newThreshold) {
   try {
     const entries = readdirSync8(runsDir);
     for (const entry of entries) {
-      const entryPath = join14(runsDir, entry);
+      const entryPath = join15(runsDir, entry);
       let stat;
       try {
         stat = statSync6(entryPath);
@@ -5632,7 +5657,7 @@ function scanStrandedRuns(runsDir, newThreshold) {
         }
         for (const sub of subEntries) {
           if (!sub.startsWith("run-")) continue;
-          const subPath = join14(entryPath, sub);
+          const subPath = join15(entryPath, sub);
           try {
             if (statSync6(subPath).isDirectory()) {
               walkRun(subPath, entry);
@@ -5649,10 +5674,10 @@ function scanStrandedRuns(runsDir, newThreshold) {
   return stranded;
 }
 function _readAnalyzeMeta(projectsDir, name) {
-  const metaPath = join14(projectsDir, name, "codebase-guide.meta.json");
+  const metaPath = join15(projectsDir, name, "codebase-guide.meta.json");
   if (!existsSync16(metaPath)) return null;
   try {
-    return JSON.parse(readFileSync13(metaPath, "utf-8"));
+    return JSON.parse(readFileSync14(metaPath, "utf-8"));
   } catch {
     return null;
   }
@@ -5671,7 +5696,7 @@ function getBoardRoutes(factoryDir) {
       method: "GET",
       pattern: "/api/status",
       handler: async () => {
-        const bmDir = join14(factoryDir, ".beastmode");
+        const bmDir = join15(factoryDir, ".beastmode");
         const boardUrl = getBoardUrl2(factoryDir);
         const factoryIdentity = await proxyToBoard(
           boardUrl,
@@ -5680,11 +5705,11 @@ function getBoardRoutes(factoryDir) {
         );
         const projectsResp = await proxyToBoard(boardUrl, "GET", "/api/projects");
         const projectCount = (projectsResp.projects || []).length;
-        const lockPath = join14(bmDir, "extensions.lock");
+        const lockPath = join15(bmDir, "extensions.lock");
         let pluginNames = [];
         if (existsSync16(lockPath)) {
           try {
-            const lock = JSON.parse(readFileSync13(lockPath, "utf-8"));
+            const lock = JSON.parse(readFileSync14(lockPath, "utf-8"));
             pluginNames = Object.keys(lock.plugins || {});
           } catch {
           }
@@ -5704,24 +5729,24 @@ function getBoardRoutes(factoryDir) {
           skillCount = listSkills(factoryDir).length;
         } catch {
         }
-        const runsDir = join14(factoryDir, "runs");
+        const runsDir = join15(factoryDir, "runs");
         let runDirs = [];
         if (existsSync16(runsDir)) {
           runDirs = readdirSync8(runsDir).filter((d) => {
             if (d.startsWith(".")) return false;
             try {
-              return readdirSync8(join14(runsDir, d)).length > 0;
+              return readdirSync8(join15(runsDir, d)).length > 0;
             } catch {
               return false;
             }
           }).sort();
         }
-        const pidFile = join14(factoryDir, ".beastmode", "daemon.pid");
+        const pidFile = join15(factoryDir, ".beastmode", "daemon.pid");
         let daemonPid = null;
         let pidAlive = false;
         if (existsSync16(pidFile)) {
           try {
-            daemonPid = parseInt(readFileSync13(pidFile, "utf-8").trim(), 10);
+            daemonPid = parseInt(readFileSync14(pidFile, "utf-8").trim(), 10);
             process.kill(daemonPid, 0);
             pidAlive = true;
           } catch {
@@ -5778,10 +5803,10 @@ function getBoardRoutes(factoryDir) {
       handler: async () => {
         const boardUrl = getBoardUrl2(factoryDir);
         let ageSecs = null;
-        const heartbeatPath = join14(factoryDir, "daemon", "logs", ".heartbeat");
+        const heartbeatPath = join15(factoryDir, "daemon", "logs", ".heartbeat");
         if (existsSync16(heartbeatPath)) {
           try {
-            const ts = parseInt(readFileSync13(heartbeatPath, "utf-8").trim(), 10);
+            const ts = parseInt(readFileSync14(heartbeatPath, "utf-8").trim(), 10);
             if (!isNaN(ts)) {
               ageSecs = Math.floor(Date.now() / 1e3) - ts;
             }
@@ -5823,11 +5848,11 @@ function getBoardRoutes(factoryDir) {
         let totalSlots = 3;
         let shortPhaseReserve;
         let slotsTimestamp;
-        const slotsPath = join14(factoryDir, "daemon", "logs", ".slots.json");
+        const slotsPath = join15(factoryDir, "daemon", "logs", ".slots.json");
         let usedDaemonSlotsFile = false;
         if (existsSync16(slotsPath)) {
           try {
-            const slots = JSON.parse(readFileSync13(slotsPath, "utf-8"));
+            const slots = JSON.parse(readFileSync14(slotsPath, "utf-8"));
             if (typeof slots.busy === "number" && typeof slots.total === "number") {
               busySlots = slots.busy;
               totalSlots = slots.total;
@@ -5852,10 +5877,10 @@ function getBoardRoutes(factoryDir) {
           } catch {
           }
           for (const name of ["beastmode.docker.json", "beastmode.daemon.json"]) {
-            const configPath = join14(factoryDir, "config", name);
+            const configPath = join15(factoryDir, "config", name);
             if (!existsSync16(configPath)) continue;
             try {
-              const config = JSON.parse(readFileSync13(configPath, "utf-8"));
+              const config = JSON.parse(readFileSync14(configPath, "utf-8"));
               if (typeof config.max_slots === "number") {
                 totalSlots = config.max_slots;
               }
@@ -5872,11 +5897,11 @@ function getBoardRoutes(factoryDir) {
         if (shortPhaseReserve === void 0) {
           shortPhaseReserve = Math.max(0, Math.min(1, totalSlots - 1));
         }
-        const alertsPath = join14(factoryDir, "daemon", "logs", ".alerts.json");
+        const alertsPath = join15(factoryDir, "daemon", "logs", ".alerts.json");
         let alerts = [];
         if (existsSync16(alertsPath)) {
           try {
-            const parsed = JSON.parse(readFileSync13(alertsPath, "utf-8"));
+            const parsed = JSON.parse(readFileSync14(alertsPath, "utf-8"));
             if (Array.isArray(parsed)) alerts = parsed;
           } catch {
           }
@@ -6103,12 +6128,12 @@ function getBoardRoutes(factoryDir) {
       method: "GET",
       pattern: "/api/extensions/plugins",
       handler: () => {
-        const lockPath = join14(factoryDir, ".beastmode", "extensions.lock");
+        const lockPath = join15(factoryDir, ".beastmode", "extensions.lock");
         if (!existsSync16(lockPath)) {
           return { plugins: {} };
         }
         try {
-          const lock = JSON.parse(readFileSync13(lockPath, "utf-8"));
+          const lock = JSON.parse(readFileSync14(lockPath, "utf-8"));
           return { plugins: lock.plugins || {} };
         } catch {
           return { plugins: {} };
@@ -6354,18 +6379,18 @@ function getBoardRoutes(factoryDir) {
         let entries = [];
         try {
           entries = readdirSync8(target, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => {
-            const full = join14(target, d.name);
+            const full = join15(target, d.name);
             return {
               name: d.name,
               path: full,
               is_dir: true,
-              has_git: existsSync16(join14(full, ".git"))
+              has_git: existsSync16(join15(full, ".git"))
             };
           }).sort((a, b) => a.name.localeCompare(b.name));
         } catch {
           entries = [];
         }
-        const parent = dirname5(target);
+        const parent = dirname6(target);
         return {
           path: target,
           parent: parent !== target ? parent : null,
@@ -6387,7 +6412,7 @@ 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) : join14(homedir(), "repos");
+          const baseDir = clone_target ? resolve4(clone_target) : process.env.BEASTMODE_CLONE_DIR ? resolve4(process.env.BEASTMODE_CLONE_DIR) : join15(homedir(), "repos");
           const allowedRoots = _getAllowedRoots();
           if (!_isPathAllowed(baseDir, allowedRoots)) {
             throw new Error(
@@ -6395,7 +6420,7 @@ function getBoardRoutes(factoryDir) {
             );
           }
           if (!existsSync16(baseDir)) mkdirSync12(baseDir, { recursive: true });
-          resolvedPath = join14(baseDir, repoName);
+          resolvedPath = join15(baseDir, repoName);
           if (!_isPathAllowed(resolvedPath, allowedRoots)) {
             throw new Error(
               `clone_target not allowed: ${resolvedPath} is outside the configured allowlist`
@@ -6502,16 +6527,16 @@ function getBoardRoutes(factoryDir) {
       handler: async (body, params, query) => {
         const { name } = params;
         assertSafeName(name);
-        const projectsDir = join14(factoryDir, ".beastmode", "projects");
+        const projectsDir = join15(factoryDir, ".beastmode", "projects");
         const projConfig = readProjectRecord(projectsDir, name);
         if (!projConfig) throw new Error(`Project not found: ${name}`);
         const projectPath = projConfig.path;
-        const subDir = join14(projectsDir, name);
+        const subDir = join15(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 = join14(subDir, "brownfield.md");
+          const brownfieldPath = join15(subDir, "brownfield.md");
           if (!existsSync16(brownfieldPath)) {
             const { detectStack: detectStackFn } = await Promise.resolve().then(() => (init_engine(), engine_exports));
             let stackInfo = "Unknown stack";
@@ -6545,12 +6570,12 @@ Path: ${projectPath}
         if (existingJob && existingJob.status === "running") {
           return { analyzing: true, project: name, job_id: existingJob.job_id, status: "running" };
         }
-        const triggerPath = join14(subDir, ".analyze-request.json");
-        const inProgressPath = join14(subDir, ".analyze-in-progress.json");
+        const triggerPath = join15(subDir, ".analyze-request.json");
+        const inProgressPath = join15(subDir, ".analyze-in-progress.json");
         if (existsSync16(triggerPath) || existsSync16(inProgressPath)) {
           const existingTrigger = existsSync16(triggerPath) ? triggerPath : inProgressPath;
           try {
-            const t = JSON.parse(readFileSync13(existingTrigger, "utf-8"));
+            const t = JSON.parse(readFileSync14(existingTrigger, "utf-8"));
             const job2 = {
               job_id: t.job_id,
               project: name,
@@ -6604,15 +6629,15 @@ Path: ${projectPath}
       handler: (_body, params) => {
         const { name } = params;
         assertSafeName(name);
-        const projectsDir = join14(factoryDir, ".beastmode", "projects");
-        const subDir = join14(projectsDir, name);
-        const triggerPath = join14(subDir, ".analyze-request.json");
-        const inProgressPath = join14(subDir, ".analyze-in-progress.json");
+        const projectsDir = join15(factoryDir, ".beastmode", "projects");
+        const subDir = join15(projectsDir, name);
+        const triggerPath = join15(subDir, ".analyze-request.json");
+        const inProgressPath = join15(subDir, ".analyze-in-progress.json");
         if (existsSync16(triggerPath) || existsSync16(inProgressPath)) {
           const job2 = _analyzeJobs.get(name);
           try {
             const p = existsSync16(triggerPath) ? triggerPath : inProgressPath;
-            const raw = readFileSync13(p, "utf-8");
+            const raw = readFileSync14(p, "utf-8");
             const t = JSON.parse(raw);
             const now = Date.now();
             const startedMs = new Date(t.requested_at).getTime();
@@ -6698,7 +6723,7 @@ Path: ${projectPath}
       handler: (_body, params, query) => {
         const { name } = params;
         assertSafeName(name);
-        const projectsDir = join14(factoryDir, ".beastmode", "projects");
+        const projectsDir = join15(factoryDir, ".beastmode", "projects");
         const meta = _readAnalyzeMeta(projectsDir, name);
         if (!meta || meta.status !== "complete") {
           throw new HttpError(404, {
@@ -6709,11 +6734,11 @@ Path: ${projectPath}
         const levelRaw = query?.level || "l1";
         const level = levelRaw === "l0" || levelRaw === "l2" ? levelRaw : "l1";
         const filename = level === "l0" ? "codebase-guide.l0.txt" : level === "l2" ? "codebase-guide.md" : "codebase-guide.l1.md";
-        const filePath = join14(projectsDir, name, filename);
+        const filePath = join15(projectsDir, name, filename);
         if (!existsSync16(filePath)) {
           throw new HttpError(404, { error: "Guide file not found" });
         }
-        const content = readFileSync13(filePath, "utf-8");
+        const content = readFileSync14(filePath, "utf-8");
         return { level, content, meta };
       }
     },
@@ -6727,7 +6752,7 @@ Path: ${projectPath}
         const runEntries = [];
         for (const entry of readdirSync8(runsDir)) {
           if (entry.startsWith(".")) continue;
-          const entryPath = join14(runsDir, entry);
+          const entryPath = join15(runsDir, entry);
           try {
             const children = readdirSync8(entryPath);
             if (entry.startsWith("run-")) {
@@ -6737,7 +6762,7 @@ Path: ${projectPath}
             } else {
               for (const child of children) {
                 if (!child.startsWith("run-") || child.startsWith(".")) continue;
-                const childPath = join14(entryPath, child);
+                const childPath = join15(entryPath, child);
                 try {
                   const grandchildren = readdirSync8(childPath);
                   if (grandchildren.length > 0) {
@@ -6759,9 +6784,9 @@ Path: ${projectPath}
           }
         }
         const runs = Array.from(deduped.values()).sort((a, b) => b.id.localeCompare(a.id)).map(({ id, dir, projectId }) => {
-          const manifest = readJsonFile(join14(dir, "manifest.json"));
-          const checkpoint = readJsonFile(join14(dir, "checkpoint.json"));
-          const prodVerif = readJsonFile(join14(dir, "prod-verification.json"));
+          const manifest = readJsonFile(join15(dir, "manifest.json"));
+          const checkpoint = readJsonFile(join15(dir, "checkpoint.json"));
+          const prodVerif = readJsonFile(join15(dir, "prod-verification.json"));
           const manifestData = manifest;
           const cpData = checkpoint;
           const prodAcceptFloor = 0.65;
@@ -6789,11 +6814,11 @@ Path: ${projectPath}
       handler: (_body, params, query) => {
         const { id } = params;
         const runsDir = getRunsDir(factoryDir);
-        let runDir = join14(runsDir, id);
+        let runDir = join15(runsDir, id);
         if (!existsSync16(runDir)) {
           for (const proj of readdirSync8(runsDir)) {
             if (proj.startsWith(".") || proj.startsWith("run-")) continue;
-            const candidate = join14(runsDir, proj, id);
+            const candidate = join15(runsDir, proj, id);
             if (existsSync16(candidate)) {
               runDir = candidate;
               break;
@@ -6801,15 +6826,15 @@ Path: ${projectPath}
           }
         }
         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 manifest = readJsonFile(join15(runDir, "manifest.json"));
+        const checkpoint = readJsonFile(join15(runDir, "checkpoint.json"));
+        const iterationsDir = join15(runDir, "iterations");
         const iterations = [];
         if (existsSync16(iterationsDir)) {
           const iterDirs = readdirSync8(iterationsDir).sort();
           for (const iterDir of iterDirs) {
             const satisfaction = readJsonFile(
-              join14(iterationsDir, iterDir, "satisfaction.json")
+              join15(iterationsDir, iterDir, "satisfaction.json")
             );
             iterations.push({
               number: parseInt(iterDir, 10),
@@ -6837,11 +6862,11 @@ Path: ${projectPath}
       pattern: "/api/runs/archive",
       handler: () => {
         const runsDir = getRunsDir(factoryDir);
-        const configPath = join14(factoryDir, ".beastmode", "config.json");
+        const configPath = join15(factoryDir, ".beastmode", "config.json");
         let days = 7;
         if (existsSync16(configPath)) {
           try {
-            days = JSON.parse(readFileSync13(configPath, "utf-8")).archive_after_days || 7;
+            days = JSON.parse(readFileSync14(configPath, "utf-8")).archive_after_days || 7;
           } catch {
           }
         }
@@ -6867,8 +6892,8 @@ Path: ${projectPath}
       method: "GET",
       pattern: "/api/config",
       handler: () => {
-        const configPath = join14(factoryDir, ".beastmode", "config.json");
-        const raw = existsSync16(configPath) ? JSON.parse(readFileSync13(configPath, "utf-8")) : generateDefaults();
+        const configPath = join15(factoryDir, ".beastmode", "config.json");
+        const raw = existsSync16(configPath) ? JSON.parse(readFileSync14(configPath, "utf-8")) : generateDefaults();
         syncToDaemonConfigs(raw, factoryDir);
         delete raw.archive_s3_bucket;
         return raw;
@@ -6888,8 +6913,8 @@ Path: ${projectPath}
         const updatesClean = { ...updates };
         delete updatesClean.force;
         delete updatesClean._force;
-        const configPath = join14(factoryDir, ".beastmode", "config.json");
-        const current = existsSync16(configPath) ? JSON.parse(readFileSync13(configPath, "utf-8")) : generateDefaults();
+        const configPath = join15(factoryDir, ".beastmode", "config.json");
+        const current = existsSync16(configPath) ? JSON.parse(readFileSync14(configPath, "utf-8")) : generateDefaults();
         if (!force) {
           const oldPipeline = current.pipeline || {};
           const newPipeline = updatesClean.pipeline || {};
@@ -6936,8 +6961,8 @@ Path: ${projectPath}
       pattern: "/api/config/reset",
       handler: (body) => {
         const { keyPath } = body || {};
-        const configPath = join14(factoryDir, ".beastmode", "config.json");
-        const current = existsSync16(configPath) ? JSON.parse(readFileSync13(configPath, "utf-8")) : {};
+        const configPath = join15(factoryDir, ".beastmode", "config.json");
+        const current = existsSync16(configPath) ? JSON.parse(readFileSync14(configPath, "utf-8")) : {};
         const result = configReset(current, keyPath);
         writeFileSync13(configPath, JSON.stringify(result, null, 2) + "\n", "utf-8");
         return result;
@@ -7029,12 +7054,12 @@ Path: ${projectPath}
       handler: () => {
         const runsDir = getRunsDir(factoryDir);
         const retroDirs = [];
-        const rootRetroDir = join14(runsDir, ".retrospectives");
+        const rootRetroDir = join15(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 = join14(runsDir, entry, ".retrospectives");
+            const projectRetroDir = join15(runsDir, entry, ".retrospectives");
             if (existsSync16(projectRetroDir)) retroDirs.push(projectRetroDir);
           }
         }
@@ -7046,7 +7071,7 @@ Path: ${projectPath}
         for (const retroDir of retroDirs) {
           const retroFiles = readdirSync8(retroDir).filter((f) => f.startsWith("run-") && f.endsWith(".json")).sort().reverse();
           for (const file of retroFiles) {
-            const data = readJsonFile(join14(retroDir, file));
+            const data = readJsonFile(join15(retroDir, file));
             if (!data) continue;
             const retro = data;
             retrospectives.push(retro);
@@ -7068,10 +7093,10 @@ Path: ${projectPath}
         let wisdom = "";
         let wisdomMeta = {};
         for (const retroDir of retroDirs) {
-          const wisdomPath = join14(retroDir, "wisdom.md");
+          const wisdomPath = join15(retroDir, "wisdom.md");
           if (existsSync16(wisdomPath)) {
-            wisdom = readFileSync13(wisdomPath, "utf-8");
-            wisdomMeta = readJsonFile(join14(retroDir, "wisdom-meta.json")) || {};
+            wisdom = readFileSync14(wisdomPath, "utf-8");
+            wisdomMeta = readJsonFile(join15(retroDir, "wisdom-meta.json")) || {};
             break;
           }
         }
@@ -7083,11 +7108,11 @@ Path: ${projectPath}
       pattern: "/api/learnings/wisdom/refresh",
       handler: () => {
         const runsDir = getRunsDir(factoryDir);
-        const retroDir = join14(runsDir, ".retrospectives");
+        const retroDir = join15(runsDir, ".retrospectives");
         if (!existsSync16(retroDir)) {
           mkdirSync12(retroDir, { recursive: true });
         }
-        writeFileSync13(join14(retroDir, ".refresh-requested"), (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
+        writeFileSync13(join15(retroDir, ".refresh-requested"), (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
         return { success: true };
       }
     },
@@ -7096,23 +7121,23 @@ Path: ${projectPath}
       pattern: "/api/learnings/:runId/:index/dismiss",
       handler: (_body, params) => {
         const runsDir = getRunsDir(factoryDir);
-        const candidateDirs = [join14(runsDir, ".retrospectives")];
+        const candidateDirs = [join15(runsDir, ".retrospectives")];
         if (existsSync16(runsDir)) {
           for (const entry of readdirSync8(runsDir)) {
             if (entry === ".retrospectives" || entry.startsWith(".")) continue;
-            candidateDirs.push(join14(runsDir, entry, ".retrospectives"));
+            candidateDirs.push(join15(runsDir, entry, ".retrospectives"));
           }
         }
         let filePath = null;
         for (const dir of candidateDirs) {
-          const candidate = join14(dir, `${params.runId}.json`);
+          const candidate = join15(dir, `${params.runId}.json`);
           if (existsSync16(candidate)) {
             filePath = candidate;
             break;
           }
         }
         if (!filePath) throw new Error(`Retrospective not found: ${params.runId}`);
-        const data = JSON.parse(readFileSync13(filePath, "utf-8"));
+        const data = JSON.parse(readFileSync14(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}`);
@@ -7127,23 +7152,23 @@ Path: ${projectPath}
       pattern: "/api/learnings/:runId/:index/restore",
       handler: (_body, params) => {
         const runsDir = getRunsDir(factoryDir);
-        const candidateDirs = [join14(runsDir, ".retrospectives")];
+        const candidateDirs = [join15(runsDir, ".retrospectives")];
         if (existsSync16(runsDir)) {
           for (const entry of readdirSync8(runsDir)) {
             if (entry === ".retrospectives" || entry.startsWith(".")) continue;
-            candidateDirs.push(join14(runsDir, entry, ".retrospectives"));
+            candidateDirs.push(join15(runsDir, entry, ".retrospectives"));
           }
         }
         let filePath = null;
         for (const dir of candidateDirs) {
-          const candidate = join14(dir, `${params.runId}.json`);
+          const candidate = join15(dir, `${params.runId}.json`);
           if (existsSync16(candidate)) {
             filePath = candidate;
             break;
           }
         }
         if (!filePath) throw new Error(`Retrospective not found: ${params.runId}`);
-        const data = JSON.parse(readFileSync13(filePath, "utf-8"));
+        const data = JSON.parse(readFileSync14(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}`);
@@ -7292,22 +7317,22 @@ Path: ${projectPath}
         } catch {
         }
         try {
-          const runsDir = join14(factoryDir, "runs", project);
+          const runsDir = join15(factoryDir, "runs", project);
           if (existsSync16(runsDir)) {
             const runDirs = readdirSync8(runsDir).filter((d) => d.startsWith("run-"));
             for (const runId of runDirs) {
-              const ckptPath = join14(runsDir, runId, "checkpoint.json");
+              const ckptPath = join15(runsDir, runId, "checkpoint.json");
               let subtitle = "";
               let timestamp = "";
               try {
-                const st = statSync6(join14(runsDir, runId));
+                const st = statSync6(join15(runsDir, runId));
                 timestamp = st.mtime.toISOString();
               } catch {
                 timestamp = (/* @__PURE__ */ new Date()).toISOString();
               }
               if (existsSync16(ckptPath)) {
                 try {
-                  const ckpt = JSON.parse(readFileSync13(ckptPath, "utf-8"));
+                  const ckpt = JSON.parse(readFileSync14(ckptPath, "utf-8"));
                   const history = ckpt.satisfaction_history;
                   if (history && history.length > 0) {
                     const latest = history[history.length - 1];
@@ -7432,9 +7457,9 @@ __export(server_exports, {
 });
 import { createServer } from "http";
 import { createHmac } from "crypto";
-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 { readFileSync as readFileSync15, existsSync as existsSync17 } from "fs";
+import { join as join16, dirname as dirname7 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { WebSocketServer as WebSocketServer2, WebSocket as WsClient } from "ws";
 function proxyBoardWebSocket(req, socket, head, boardWsUrl) {
   _boardWsProxy.handleUpgrade(req, socket, head, (clientWs) => {
@@ -7475,16 +7500,16 @@ function proxyBoardWebSocket(req, socket, head, boardWsUrl) {
   });
 }
 function resolveStaticDir() {
-  const devPath = join15(__dirname, "static");
-  if (existsSync17(join15(devPath, "index.html"))) {
+  const devPath = join16(__dirname, "static");
+  if (existsSync17(join16(devPath, "index.html"))) {
     return devPath;
   }
-  const distWebPath = join15(__dirname, "web");
-  if (existsSync17(join15(distWebPath, "index.html"))) {
+  const distWebPath = join16(__dirname, "web");
+  if (existsSync17(join16(distWebPath, "index.html"))) {
     return distWebPath;
   }
-  const siblingPath = join15(__dirname, "..", "web");
-  if (existsSync17(join15(siblingPath, "index.html"))) {
+  const siblingPath = join16(__dirname, "..", "web");
+  if (existsSync17(join16(siblingPath, "index.html"))) {
     return siblingPath;
   }
   throw new Error(
@@ -7593,9 +7618,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 = join15(staticDir, "index.html");
+      const indexPath = join16(staticDir, "index.html");
       if (!existsSync17(indexPath)) return fallback;
-      return readFileSync14(indexPath, "utf-8");
+      return readFileSync15(indexPath, "utf-8");
     } catch {
       return fallback;
     }
@@ -7603,9 +7628,9 @@ async function startServer(options = {}) {
   function loadBoardHtml() {
     try {
       const dir = staticDir || resolveStaticDir();
-      const boardPath = join15(dir, "board.html");
+      const boardPath = join16(dir, "board.html");
       if (!existsSync17(boardPath)) return null;
-      return readFileSync14(boardPath, "utf-8");
+      return readFileSync15(boardPath, "utf-8");
     } catch {
       return null;
     }
@@ -7700,13 +7725,13 @@ async function startServer(options = {}) {
       let commit_sha = null;
       try {
         const dir = staticDir || resolveStaticDir();
-        const stampPath = join15(dir, "build-stamp.txt");
+        const stampPath = join16(dir, "build-stamp.txt");
         if (existsSync17(stampPath)) {
-          stamp = readFileSync14(stampPath, "utf-8").trim();
+          stamp = readFileSync15(stampPath, "utf-8").trim();
         }
-        const commitPath = join15(dir, "build-commit.txt");
+        const commitPath = join16(dir, "build-commit.txt");
         if (existsSync17(commitPath)) {
-          commit_sha = readFileSync14(commitPath, "utf-8").trim() || null;
+          commit_sha = readFileSync15(commitPath, "utf-8").trim() || null;
         }
       } catch {
       }
@@ -7784,7 +7809,7 @@ async function startServer(options = {}) {
     }
     if (method === "GET" && url.startsWith("/static/")) {
       const filename = url.slice("/static/".length);
-      const filePath = staticDir ? join15(staticDir, filename) : "";
+      const filePath = staticDir ? join16(staticDir, filename) : "";
       if (filePath && existsSync17(filePath)) {
         const ext = filename.split(".").pop()?.toLowerCase();
         const mimeTypes = {
@@ -7796,7 +7821,7 @@ async function startServer(options = {}) {
           ico: "image/x-icon"
         };
         const contentType = mimeTypes[ext || ""] || "application/octet-stream";
-        const content = readFileSync14(filePath);
+        const content = readFileSync15(filePath);
         res.writeHead(200, {
           "Content-Type": contentType,
           "Content-Length": content.length.toString(),
@@ -7934,8 +7959,8 @@ var init_server = __esm({
     init_board_api_routes();
     init_chat_handler();
     _boardWsProxy = new WebSocketServer2({ noServer: true });
-    __filename = fileURLToPath2(import.meta.url);
-    __dirname = dirname6(__filename);
+    __filename = fileURLToPath3(import.meta.url);
+    __dirname = dirname7(__filename);
     INACTIVITY_TIMEOUT_MS = 30 * 60 * 1e3;
     UI_PASSWORD = process.env.BEASTMODE_UI_PASSWORD || "";
     ALLOW_NO_AUTH = /^(1|true|yes)$/i.test(process.env.BEASTMODE_ALLOW_NO_AUTH || "");
@@ -8046,27 +8071,27 @@ var init_server = __esm({
 
 // src/cli/commands/board.ts
 import { Command } from "commander";
-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 { resolve as resolve5, join as join17 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync16, 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 (existsSync18(join16(dir, ".beastmode", "factory.json"))) {
+    if (existsSync18(join17(dir, ".beastmode", "factory.json"))) {
       return dir;
     }
     const parent = resolve5(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
-  if (existsSync18(join16(dir, ".beastmode", "factory.json"))) {
+  if (existsSync18(join17(dir, ".beastmode", "factory.json"))) {
     return dir;
   }
   return null;
 }
 function inferProjectName(factoryDir) {
-  const projectsDir = join16(factoryDir, ".beastmode", "projects");
+  const projectsDir = join17(factoryDir, ".beastmode", "projects");
   const records = listProjectRecords(projectsDir);
   if (records.length === 1) return records[0].name;
   return null;
@@ -8145,11 +8170,11 @@ async function runBoard(opts) {
   let factoryDir = findFactoryDir();
   if (!factoryDir) {
     factoryDir = process.cwd();
-    const bmDir = join16(factoryDir, ".beastmode");
+    const bmDir = join17(factoryDir, ".beastmode");
     if (!existsSync18(bmDir)) {
       mkdirSync13(bmDir, { recursive: true });
     }
-    const factoryJsonPath2 = join16(bmDir, "factory.json");
+    const factoryJsonPath2 = join17(bmDir, "factory.json");
     if (!existsSync18(factoryJsonPath2)) {
       writeFileSync14(
         factoryJsonPath2,
@@ -8159,8 +8184,8 @@ async function runBoard(opts) {
       info("No factory found \u2014 created minimal stub at .beastmode/factory.json");
     }
   }
-  const factoryJsonPath = join16(factoryDir, ".beastmode", "factory.json");
-  const factoryJson = JSON.parse(readFileSync15(factoryJsonPath, "utf-8"));
+  const factoryJsonPath = join17(factoryDir, ".beastmode", "factory.json");
+  const factoryJson = JSON.parse(readFileSync16(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));
@@ -8233,26 +8258,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 writeFileSync15, readFileSync as readFileSync16, chmodSync, mkdirSync as mkdirSync14, existsSync as existsSync19, unlinkSync as unlinkSync5 } from "fs";
-import { join as join17 } from "path";
+import { writeFileSync as writeFileSync15, readFileSync as readFileSync17, chmodSync, mkdirSync as mkdirSync14, existsSync as existsSync19, unlinkSync as unlinkSync5 } from "fs";
+import { join as join18 } from "path";
 import { homedir as homedir2, platform } from "os";
 function systemdUserDir() {
-  return join17(homedir2(), ".config", "systemd", "user");
+  return join18(homedir2(), ".config", "systemd", "user");
 }
 function systemdServicePath() {
-  return join17(systemdUserDir(), `${SYSTEMD_UNIT_NAME}.service`);
+  return join18(systemdUserDir(), `${SYSTEMD_UNIT_NAME}.service`);
 }
 function systemdTimerPath() {
-  return join17(systemdUserDir(), `${SYSTEMD_UNIT_NAME}.timer`);
+  return join18(systemdUserDir(), `${SYSTEMD_UNIT_NAME}.timer`);
 }
 function linuxCredsPath() {
-  return join17(homedir2(), ".claude", ".credentials.json");
+  return join18(homedir2(), ".claude", ".credentials.json");
 }
 function plistPath() {
-  return join17(homedir2(), "Library", "LaunchAgents", `${LAUNCH_AGENT_LABEL}.plist`);
+  return join18(homedir2(), "Library", "LaunchAgents", `${LAUNCH_AGENT_LABEL}.plist`);
 }
 function agentLogPath() {
-  return join17(homedir2(), ".beastmode", "logs", "sync-claude-creds.log");
+  return join18(homedir2(), ".beastmode", "logs", "sync-claude-creds.log");
 }
 function readKeychainTokenSafe() {
   try {
@@ -8284,9 +8309,9 @@ 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 = join17(homedir2(), ".claude");
+  const claudeDir = join18(homedir2(), ".claude");
   if (!existsSync19(claudeDir)) mkdirSync14(claudeDir, { recursive: true });
-  const credsPath = join17(claudeDir, ".credentials.json");
+  const credsPath = join18(claudeDir, ".credentials.json");
   writeFileSync15(credsPath, rawJson + "\n", "utf-8");
   chmodSync(credsPath, 384);
   if (oauth.expiresAt) {
@@ -8300,7 +8325,7 @@ function writeCredentialsFile(rawJson) {
   return credsPath;
 }
 function urgencyMarkerHostPath(factoryDir) {
-  return join17(factoryDir, "daemon", "logs", ".cred-refresh-needed");
+  return join18(factoryDir, "daemon", "logs", ".cred-refresh-needed");
 }
 function removeUrgencyMarker(factoryDir) {
   if (!factoryDir) return;
@@ -8314,7 +8339,7 @@ function buildPlist(intervalSeconds, factoryDir) {
   const nodePath = process.execPath;
   const cliEntry = process.argv[1];
   const logPath = agentLogPath();
-  const keychainPath = join17(homedir2(), "Library", "Keychains", "login.keychain-db");
+  const keychainPath = join18(homedir2(), "Library", "Keychains", "login.keychain-db");
   const watchPaths = [keychainPath];
   if (factoryDir) {
     watchPaths.push(urgencyMarkerHostPath(factoryDir));
@@ -8354,8 +8379,8 @@ function installAgent(intervalSeconds, {
 } = {}) {
   const plist = plistPath();
   const logPath = agentLogPath();
-  mkdirSync14(join17(homedir2(), "Library", "LaunchAgents"), { recursive: true });
-  mkdirSync14(join17(homedir2(), ".beastmode", "logs"), { recursive: true });
+  mkdirSync14(join18(homedir2(), "Library", "LaunchAgents"), { recursive: true });
+  mkdirSync14(join18(homedir2(), ".beastmode", "logs"), { recursive: true });
   const uid = process.getuid?.();
   if (existsSync19(plist)) {
     spawnSync2("launchctl", ["bootout", `gui/${uid}`, plist], { stdio: "pipe" });
@@ -8451,7 +8476,7 @@ function syncClaudeCredsLinux() {
   }
   let parsed;
   try {
-    const raw = readFileSync16(credsPath, "utf-8");
+    const raw = readFileSync17(credsPath, "utf-8");
     parsed = JSON.parse(raw);
   } catch {
     return {
@@ -8480,7 +8505,7 @@ function syncClaudeCredsLinux() {
         );
       }
       try {
-        const raw2 = readFileSync16(credsPath, "utf-8");
+        const raw2 = readFileSync17(credsPath, "utf-8");
         const parsed2 = JSON.parse(raw2);
         if (parsed2.claudeAiOauth?.expiresAt) {
           const newMinutes = (parsed2.claudeAiOauth.expiresAt - Date.now()) / 6e4;
@@ -8534,10 +8559,10 @@ function installAgentLinux(intervalSeconds, { throwOnError = false } = {}) {
     process.exit(1);
   }
   const unitDir = systemdUserDir();
-  const logDir = join17(homedir2(), ".beastmode", "logs");
+  const logDir = join18(homedir2(), ".beastmode", "logs");
   mkdirSync14(unitDir, { recursive: true });
   mkdirSync14(logDir, { recursive: true });
-  const logPath = join17(logDir, "sync-claude-creds.log");
+  const logPath = join18(logDir, "sync-claude-creds.log");
   const nodePath = process.execPath;
   const cliEntry = process.argv[1];
   writeFileSync15(
@@ -8782,26 +8807,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 readFileSync29, writeFileSync as writeFileSync25, existsSync as existsSync32, readdirSync as readdirSync12 } from "fs";
-import { join as join30, resolve as resolve18, basename as basename7 } from "path";
+import { readFileSync as readFileSync30, writeFileSync as writeFileSync25, existsSync as existsSync32, readdirSync as readdirSync12 } from "fs";
+import { join as join31, resolve as resolve18, basename as basename7 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 function readJsonFile2(filePath) {
   if (!existsSync32(filePath)) return null;
   try {
-    return JSON.parse(readFileSync29(filePath, "utf-8"));
+    return JSON.parse(readFileSync30(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function getFactoryPath() {
   const envPath = process.env.BEASTMODE_FACTORY_PATH;
-  if (envPath && existsSync32(join30(envPath, ".beastmode", "factory.json"))) {
+  if (envPath && existsSync32(join31(envPath, ".beastmode", "factory.json"))) {
     return envPath;
   }
   let dir = process.cwd();
   const root = resolve18("/");
   while (dir !== root) {
-    if (existsSync32(join30(dir, ".beastmode", "factory.json"))) {
+    if (existsSync32(join31(dir, ".beastmode", "factory.json"))) {
       return dir;
     }
     const parent = resolve18(dir, "..");
@@ -8813,17 +8838,17 @@ function getFactoryPath() {
   );
 }
 function readFactoryStatus(factoryDir) {
-  const bmDir = join30(factoryDir, ".beastmode");
+  const bmDir = join31(factoryDir, ".beastmode");
   const factoryIdentity = FactoryIdentitySchema.parse(
-    JSON.parse(readFileSync29(join30(bmDir, "factory.json"), "utf-8"))
+    JSON.parse(readFileSync30(join31(bmDir, "factory.json"), "utf-8"))
   );
-  const projectsDir = join30(bmDir, "projects");
+  const projectsDir = join31(bmDir, "projects");
   const projectCount = listProjectRecords(projectsDir).length;
-  const lockPath = join30(bmDir, "extensions.lock");
+  const lockPath = join31(bmDir, "extensions.lock");
   let pluginNames = [];
   if (existsSync32(lockPath)) {
     try {
-      const lock = JSON.parse(readFileSync29(lockPath, "utf-8"));
+      const lock = JSON.parse(readFileSync30(lockPath, "utf-8"));
       pluginNames = Object.keys(lock.plugins || {});
     } catch {
     }
@@ -8843,23 +8868,23 @@ function readFactoryStatus(factoryDir) {
     skillCount = listSkills(factoryDir).length;
   } catch {
   }
-  const runsDir = join30(factoryDir, "runs");
+  const runsDir = join31(factoryDir, "runs");
   let runDirs = [];
   if (existsSync32(runsDir)) {
     runDirs = readdirSync12(runsDir).filter((d) => {
       try {
-        return readdirSync12(join30(runsDir, d)).length > 0;
+        return readdirSync12(join31(runsDir, d)).length > 0;
       } catch {
         return false;
       }
     }).sort();
   }
-  const pidFile = join30(bmDir, "daemon.pid");
+  const pidFile = join31(bmDir, "daemon.pid");
   let daemonPid = null;
   let pidAlive = false;
   if (existsSync32(pidFile)) {
     try {
-      daemonPid = parseInt(readFileSync29(pidFile, "utf-8").trim(), 10);
+      daemonPid = parseInt(readFileSync30(pidFile, "utf-8").trim(), 10);
       process.kill(daemonPid, 0);
       pidAlive = true;
     } catch {
@@ -8880,17 +8905,17 @@ function readFactoryStatus(factoryDir) {
   return collectStatus(input);
 }
 function readBoardItems(factoryDir) {
-  const filePath = join30(factoryDir, ".beastmode", "board.json");
+  const filePath = join31(factoryDir, ".beastmode", "board.json");
   if (!existsSync32(filePath)) return [];
   try {
-    const raw = JSON.parse(readFileSync29(filePath, "utf-8"));
+    const raw = JSON.parse(readFileSync30(filePath, "utf-8"));
     return Array.isArray(raw.items) ? raw.items : [];
   } catch {
     return [];
   }
 }
 function writeBoardItems(factoryDir, items) {
-  const filePath = join30(factoryDir, ".beastmode", "board.json");
+  const filePath = join31(factoryDir, ".beastmode", "board.json");
   writeFileSync25(filePath, JSON.stringify({ items }, null, 2) + "\n", "utf-8");
 }
 function createMcpServer() {
@@ -8914,8 +8939,8 @@ function createMcpServer() {
     { key_path: z2.string().describe("Dot-notation key path") },
     async ({ key_path }) => {
       const factoryDir = getFactoryPath();
-      const configPath = join30(factoryDir, ".beastmode", "config.json");
-      const config = existsSync32(configPath) ? JSON.parse(readFileSync29(configPath, "utf-8")) : generateDefaults();
+      const configPath = join31(factoryDir, ".beastmode", "config.json");
+      const config = existsSync32(configPath) ? JSON.parse(readFileSync30(configPath, "utf-8")) : generateDefaults();
       try {
         const value = configGet(config, key_path);
         return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
@@ -8933,8 +8958,8 @@ function createMcpServer() {
     },
     async ({ key_path, value }) => {
       const factoryDir = getFactoryPath();
-      const configPath = join30(factoryDir, ".beastmode", "config.json");
-      const config = existsSync32(configPath) ? JSON.parse(readFileSync29(configPath, "utf-8")) : generateDefaults();
+      const configPath = join31(factoryDir, ".beastmode", "config.json");
+      const config = existsSync32(configPath) ? JSON.parse(readFileSync30(configPath, "utf-8")) : generateDefaults();
       const coerced = coerceValue(value);
       const updated = configSet(config, key_path, coerced);
       writeFileSync25(configPath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
@@ -8971,14 +8996,14 @@ function createMcpServer() {
     {},
     async () => {
       const factoryDir = getFactoryPath();
-      const runsDir = join30(factoryDir, "runs");
+      const runsDir = join31(factoryDir, "runs");
       if (!existsSync32(runsDir)) {
         return { content: [{ type: "text", text: "No runs directory found." }] };
       }
       const runDirs = readdirSync12(runsDir).sort().reverse();
       const activeRuns = [];
       for (const id of runDirs.slice(0, 10)) {
-        const cp = readJsonFile2(join30(runsDir, id, "checkpoint.json"));
+        const cp = readJsonFile2(join31(runsDir, id, "checkpoint.json"));
         if (cp) {
           activeRuns.push({ id, checkpoint: cp });
         }
@@ -8992,17 +9017,17 @@ function createMcpServer() {
     { run_id: z2.string().describe("Run ID (directory name)") },
     async ({ run_id }) => {
       const factoryDir = getFactoryPath();
-      const runDir = join30(factoryDir, "runs", run_id);
+      const runDir = join31(factoryDir, "runs", run_id);
       if (!existsSync32(runDir)) {
         return { content: [{ type: "text", text: `Run not found: ${run_id}` }], isError: true };
       }
-      const manifest = readJsonFile2(join30(runDir, "manifest.json"));
-      const checkpoint = readJsonFile2(join30(runDir, "checkpoint.json"));
-      const iterationsDir = join30(runDir, "iterations");
+      const manifest = readJsonFile2(join31(runDir, "manifest.json"));
+      const checkpoint = readJsonFile2(join31(runDir, "checkpoint.json"));
+      const iterationsDir = join31(runDir, "iterations");
       const iterations = [];
       if (existsSync32(iterationsDir)) {
         for (const dir of readdirSync12(iterationsDir).sort()) {
-          const satisfaction = readJsonFile2(join30(iterationsDir, dir, "satisfaction.json"));
+          const satisfaction = readJsonFile2(join31(iterationsDir, dir, "satisfaction.json"));
           iterations.push({ number: parseInt(dir, 10), satisfaction });
         }
       }
@@ -9048,12 +9073,12 @@ function createMcpServer() {
     {},
     async () => {
       const factoryDir = getFactoryPath();
-      const bmDir = join30(factoryDir, ".beastmode");
+      const bmDir = join31(factoryDir, ".beastmode");
       let plugins = {};
-      const lockPath = join30(bmDir, "extensions.lock");
+      const lockPath = join31(bmDir, "extensions.lock");
       if (existsSync32(lockPath)) {
         try {
-          const lock = JSON.parse(readFileSync29(lockPath, "utf-8"));
+          const lock = JSON.parse(readFileSync30(lockPath, "utf-8"));
           plugins = lock.plugins || {};
         } catch {
         }
@@ -9087,7 +9112,7 @@ function createMcpServer() {
     {},
     async () => {
       const factoryDir = getFactoryPath();
-      const projectsDir = join30(factoryDir, ".beastmode", "projects");
+      const projectsDir = join31(factoryDir, ".beastmode", "projects");
       const projects = listProjectRecords(projectsDir);
       return { content: [{ type: "text", text: JSON.stringify(projects, null, 2) }] };
     }
@@ -9104,7 +9129,7 @@ function createMcpServer() {
       }
       const projectName = basename7(resolvedPath);
       const stack = detectStack(resolvedPath);
-      const projectsDir = join30(factoryDir, ".beastmode", "projects");
+      const projectsDir = join31(factoryDir, ".beastmode", "projects");
       let verifyPort = 3001;
       for (const existing of listProjectRecords(projectsDir)) {
         const port = existing.deploy?.verify_port;
@@ -9220,16 +9245,16 @@ init_engine();
 init_file_writer();
 import { Command as Command3 } from "commander";
 import inquirer from "inquirer";
-import { resolve as resolve6, basename as basename6, join as join18 } from "path";
-import { existsSync as existsSync20, writeFileSync as writeFileSync16, mkdirSync as mkdirSync15, readFileSync as readFileSync17 } from "fs";
+import { resolve as resolve6, basename as basename6, join as join19 } from "path";
+import { existsSync as existsSync20, writeFileSync as writeFileSync16, mkdirSync as mkdirSync15, readFileSync as readFileSync18 } from "fs";
 
 // src/cli/utils/docker.ts
 import { existsSync as existsSync10 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { execSync } from "child_process";
 var GHCR_IMAGE_PREFIX = "ghcr.io/develeap/beastmode";
 function findComposeFile(dir) {
-  const path = join9(dir, "docker-compose.yml");
+  const path = join10(dir, "docker-compose.yml");
   return existsSync10(path) ? path : null;
 }
 function requireComposeFile(dir) {
@@ -9293,7 +9318,7 @@ function loginToGhcr(token) {
   }
 }
 function seedConfigFromImage(targetDir, tag) {
-  const configDir = join9(targetDir, "config");
+  const configDir = join10(targetDir, "config");
   const containerName = "bm-config-seed";
   try {
     try {
@@ -9473,7 +9498,7 @@ function collect(val, acc) {
   return acc;
 }
 function readSecretFile(filePath) {
-  return readFileSync17(resolve6(filePath), "utf-8").trim();
+  return readFileSync18(resolve6(filePath), "utf-8").trim();
 }
 function isSourceRepo(dir) {
   return existsSync20(resolve6(dir, "daemon")) && existsSync20(resolve6(dir, "board")) && existsSync20(resolve6(dir, "cli"));
@@ -9519,8 +9544,8 @@ async function runInit(name, opts) {
     throw new Error(`Factory already exists at ./${factoryName}. Use 'beastmode config' to modify.`);
   }
   if (opts.from) {
-    const { readFileSync: readFileSync36 } = await import("fs");
-    const templateContent = readFileSync36(resolve6(opts.from), "utf-8");
+    const { readFileSync: readFileSync37 } = await import("fs");
+    const templateContent = readFileSync37(resolve6(opts.from), "utf-8");
     const { parseTemplate: parseTemplate2 } = await Promise.resolve().then(() => (init_template_importer(), template_importer_exports));
     const template = parseTemplate2(templateContent);
     info(`Importing from template: ${opts.from}`);
@@ -9878,7 +9903,7 @@ async function runImageModeInit(name, opts) {
     success(`Project path: ${projectPath}`);
   } else if (opts.yes) {
     const cwd = resolve6(".");
-    if (!existsSync20(join18(cwd, ".git"))) {
+    if (!existsSync20(join19(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."
       );
@@ -9896,7 +9921,7 @@ async function runImageModeInit(name, opts) {
         validate: (input) => {
           const p = resolve6(input);
           if (!existsSync20(p)) return `Directory not found: ${p}`;
-          if (!existsSync20(join18(p, ".git"))) {
+          if (!existsSync20(join19(p, ".git"))) {
             return `Not a git repo: ${p} (run 'git init' first, or pick a different path)`;
           }
           return true;
@@ -9937,7 +9962,7 @@ async function runImageModeInit(name, opts) {
   step(3, totalSteps, "Generate");
   mkdirSync15(targetDir, { recursive: true });
   const composeContent = generateComposeYaml("latest");
-  writeFileSync16(join18(targetDir, "docker-compose.yml"), composeContent, "utf-8");
+  writeFileSync16(join19(targetDir, "docker-compose.yml"), composeContent, "utf-8");
   success("docker-compose.yml");
   const envLines = [
     "# BeastMode environment \u2014 DO NOT COMMIT",
@@ -9977,10 +10002,10 @@ async function runImageModeInit(name, opts) {
     "# PROJECT_REPO=owner/repo",
     ""
   ];
-  writeFileSync16(join18(targetDir, ".env"), envLines.join("\n"), "utf-8");
+  writeFileSync16(join19(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"]) {
-    mkdirSync15(join18(targetDir, dir), { recursive: true });
+    mkdirSync15(join19(targetDir, dir), { recursive: true });
   }
   step(4, totalSteps, "Pull Images");
   try {
@@ -10069,20 +10094,20 @@ async function runImageModeInit(name, opts) {
 init_export_adapter();
 init_display();
 import { Command as Command4 } from "commander";
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync17, existsSync as existsSync21, readdirSync as readdirSync9 } from "fs";
-import { resolve as resolve7, join as join19 } from "path";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync17, existsSync as existsSync21, readdirSync as readdirSync9 } from "fs";
+import { resolve as resolve7, join as join20 } from "path";
 function exportFactory(factoryDir, outputPath) {
-  const bmDir = join19(factoryDir, ".beastmode");
-  const configPath = join19(bmDir, "config.json");
+  const bmDir = join20(factoryDir, ".beastmode");
+  const configPath = join20(bmDir, "config.json");
   if (!existsSync21(configPath)) {
     throw new Error(`No factory found at ${factoryDir}`);
   }
-  const config = JSON.parse(readFileSync18(configPath, "utf-8"));
-  const identity = JSON.parse(readFileSync18(join19(bmDir, "factory.json"), "utf-8"));
+  const config = JSON.parse(readFileSync19(configPath, "utf-8"));
+  const identity = JSON.parse(readFileSync19(join20(bmDir, "factory.json"), "utf-8"));
   let plugins = [];
-  const lockPath = join19(bmDir, "extensions.lock");
+  const lockPath = join20(bmDir, "extensions.lock");
   if (existsSync21(lockPath)) {
-    const lock = JSON.parse(readFileSync18(lockPath, "utf-8"));
+    const lock = JSON.parse(readFileSync19(lockPath, "utf-8"));
     plugins = Object.keys(lock.plugins || {});
   }
   const template = {
@@ -10113,19 +10138,19 @@ function createArtifactExportCommand(artifact) {
       const runDir = findRunDir(opts.run);
       let sourceContent;
       if (artifact === "scenarios") {
-        const scenariosDir = join19(runDir, "scenarios");
+        const scenariosDir = join20(runDir, "scenarios");
         if (!existsSync21(scenariosDir)) {
           throw new Error(`No scenarios directory found in run ${opts.run}`);
         }
         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");
+        sourceContent = files.map((f) => readFileSync19(join20(scenariosDir, f), "utf-8")).join("\n\n---\n\n");
       } else {
         const artifactFile = artifact === "nlspec" ? "nlspec.md" : "plan.md";
-        const artifactPath = join19(runDir, artifactFile);
+        const artifactPath = join20(runDir, artifactFile);
         if (!existsSync21(artifactPath)) {
           throw new Error(`${artifactFile} not found in run ${opts.run}`);
         }
-        sourceContent = readFileSync18(artifactPath, "utf-8");
+        sourceContent = readFileSync19(artifactPath, "utf-8");
       }
       const result = runExportAdapter(opts.adapter, sourceContent);
       if (opts.output) {
@@ -10353,15 +10378,15 @@ init_presets();
 init_display();
 import { Command as Command8 } from "commander";
 import { resolve as resolve11 } from "path";
-import { readFileSync as readFileSync19, existsSync as existsSync22 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync20, existsSync as existsSync22 } from "fs";
+import { join as join21 } from "path";
 function listPluginsAction(factoryDir) {
-  const lockPath = join20(factoryDir, ".beastmode", "extensions.lock");
+  const lockPath = join21(factoryDir, ".beastmode", "extensions.lock");
   if (!existsSync22(lockPath)) {
     console.log("  No plugins installed (extensions.lock not found).");
     return;
   }
-  const lock = JSON.parse(readFileSync19(lockPath, "utf-8"));
+  const lock = JSON.parse(readFileSync20(lockPath, "utf-8"));
   const plugins = lock.plugins || {};
   const names = Object.keys(plugins);
   if (names.length === 0) {
@@ -10460,8 +10485,8 @@ var listCommand = new Command8("list").description("List installed extensions an
 init_import_adapter();
 init_display();
 import { Command as Command9 } from "commander";
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync18, mkdirSync as mkdirSync16, existsSync as existsSync23 } from "fs";
-import { resolve as resolve12, join as join21 } from "path";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync18, mkdirSync as mkdirSync16, existsSync as existsSync23 } from "fs";
+import { resolve as resolve12, join as join22 } 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) => {
@@ -10470,7 +10495,7 @@ function createArtifactCommand(artifact) {
       if (!existsSync23(sourcePath)) {
         throw new Error(`Source file not found: ${sourcePath}`);
       }
-      const sourceContent = readFileSync20(sourcePath, "utf-8");
+      const sourceContent = readFileSync21(sourcePath, "utf-8");
       const result = runImportAdapter(opts.adapter, sourceContent);
       if (opts.output) {
         const outputPath = resolve12(opts.output);
@@ -10478,7 +10503,7 @@ function createArtifactCommand(artifact) {
           const scenarios = JSON.parse(result);
           mkdirSync16(outputPath, { recursive: true });
           for (const scenario of scenarios) {
-            const filePath = join21(outputPath, `${scenario.name}.md`);
+            const filePath = join22(outputPath, `${scenario.name}.md`);
             writeFileSync18(filePath, scenario.content, "utf-8");
             success(`  ${scenario.name}.md`);
           }
@@ -10508,52 +10533,52 @@ init_engine();
 init_schemas();
 init_display();
 import { Command as Command10 } from "commander";
-import { existsSync as existsSync24, readFileSync as readFileSync21, readdirSync as readdirSync10 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync22, readdirSync as readdirSync10 } from "fs";
 import { execSync as execSync6 } from "child_process";
-import { join as join22, resolve as resolve13 } from "path";
+import { join as join23, resolve as resolve13 } from "path";
 function statusAction(factoryDir, opts) {
-  const bmDir = join22(factoryDir, ".beastmode");
+  const bmDir = join23(factoryDir, ".beastmode");
   if (!existsSync24(bmDir)) {
     throw new Error(`No factory found at ${factoryDir}`);
   }
-  const factoryJsonPath = join22(bmDir, "factory.json");
-  const rawIdentity = JSON.parse(readFileSync21(factoryJsonPath, "utf-8"));
+  const factoryJsonPath = join23(bmDir, "factory.json");
+  const rawIdentity = JSON.parse(readFileSync22(factoryJsonPath, "utf-8"));
   const factoryIdentity = FactoryIdentitySchema.parse(rawIdentity);
-  const projectsDir = join22(bmDir, "projects");
+  const projectsDir = join23(bmDir, "projects");
   const projectCount = listProjectRecords(projectsDir).length;
-  const pluginsDir = join22(bmDir, "plugins");
+  const pluginsDir = join23(bmDir, "plugins");
   const pluginNames = existsSync24(pluginsDir) ? readdirSync10(pluginsDir) : [];
-  const mcpPath = join22(bmDir, "mcp-servers.json");
+  const mcpPath = join23(bmDir, "mcp-servers.json");
   let mcpServers = {};
   if (existsSync24(mcpPath)) {
     try {
-      const raw = JSON.parse(readFileSync21(mcpPath, "utf-8"));
+      const raw = JSON.parse(readFileSync22(mcpPath, "utf-8"));
       mcpServers = raw.servers || {};
     } catch {
     }
   }
-  const hooksPath = join22(bmDir, "hooks.json");
+  const hooksPath = join23(bmDir, "hooks.json");
   let hooks = {};
   if (existsSync24(hooksPath)) {
     try {
-      const raw = JSON.parse(readFileSync21(hooksPath, "utf-8"));
+      const raw = JSON.parse(readFileSync22(hooksPath, "utf-8"));
       hooks = raw.hooks || {};
     } catch {
     }
   }
-  const skillsDir = join22(bmDir, "skills");
+  const skillsDir = join23(bmDir, "skills");
   const skillCount = existsSync24(skillsDir) ? readdirSync10(skillsDir).length : 0;
-  const runsDir = join22(factoryDir, "runs");
+  const runsDir = join23(factoryDir, "runs");
   let runDirs = [];
   if (existsSync24(runsDir)) {
     runDirs = readdirSync10(runsDir).filter((d) => d.startsWith("run-")).sort();
   }
-  const pidPath = join22(bmDir, "daemon.pid");
+  const pidPath = join23(bmDir, "daemon.pid");
   let daemonPid = null;
   let pidAlive = false;
   if (existsSync24(pidPath)) {
     try {
-      daemonPid = parseInt(readFileSync21(pidPath, "utf-8").trim(), 10);
+      daemonPid = parseInt(readFileSync22(pidPath, "utf-8").trim(), 10);
       process.kill(daemonPid, 0);
       pidAlive = true;
     } catch {
@@ -10627,18 +10652,18 @@ var statusCommand = new Command10("status").description("Show factory status ove
 init_config_manager();
 init_display();
 import { Command as Command11 } from "commander";
-import { existsSync as existsSync25, readFileSync as readFileSync22, writeFileSync as writeFileSync19 } from "fs";
-import { join as join23, resolve as resolve14 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync23, writeFileSync as writeFileSync19 } from "fs";
+import { join as join24, resolve as resolve14 } from "path";
 import { execSync as execSync7 } from "child_process";
 function readConfig2(factoryDir) {
-  const configPath = join23(factoryDir, ".beastmode", "config.json");
+  const configPath = join24(factoryDir, ".beastmode", "config.json");
   if (!existsSync25(configPath)) {
     throw new Error("No config.json found. Run beastmode init first.");
   }
-  return JSON.parse(readFileSync22(configPath, "utf-8"));
+  return JSON.parse(readFileSync23(configPath, "utf-8"));
 }
 function writeConfig2(factoryDir, config) {
-  const configPath = join23(factoryDir, ".beastmode", "config.json");
+  const configPath = join24(factoryDir, ".beastmode", "config.json");
   writeFileSync19(configPath, JSON.stringify(config, null, 2) + "\n");
 }
 function configGetAction(factoryDir, key) {
@@ -10682,7 +10707,7 @@ 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 = join23(factoryDir, ".beastmode", "config.json");
+  const configPath = join24(factoryDir, ".beastmode", "config.json");
   if (!existsSync25(configPath)) {
     error("No config.json found. Run beastmode init first.");
     process.exit(1);
@@ -10719,8 +10744,8 @@ init_version();
 init_plugin_resolver();
 init_display();
 import { Command as Command12 } from "commander";
-import { existsSync as existsSync26, readFileSync as readFileSync23, readdirSync as readdirSync11 } from "fs";
-import { join as join24, resolve as resolve15 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync24, readdirSync as readdirSync11 } from "fs";
+import { join as join25, 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";
@@ -10761,7 +10786,7 @@ async function checkClaudeAuth(key) {
     });
   }
   if (claudeInstalled && platform2() === "darwin" && !key) {
-    const credsPath = join24(homedir3(), ".claude", ".credentials.json");
+    const credsPath = join25(homedir3(), ".claude", ".credentials.json");
     if (!existsSync26(credsPath)) {
       results.push({
         label: "Claude creds (Docker)",
@@ -10864,16 +10889,16 @@ async function checkProjectGithubToken(env, factoryDir) {
   }
   let ownerRepo = null;
   if (factoryDir) {
-    const envPath = join24(factoryDir, ".env");
+    const envPath = join25(factoryDir, ".env");
     if (existsSync26(envPath)) {
       try {
-        const content = readFileSync23(envPath, "utf-8");
+        const content = readFileSync24(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 && existsSync26(join24(projectDir, ".git"))) {
+          if (projectDir && existsSync26(join25(projectDir, ".git"))) {
             const remote = tryExec(
               `git -C "${projectDir}" remote get-url origin 2>/dev/null`
             );
@@ -11089,7 +11114,7 @@ function checkProjectDirEnv(factoryDir) {
       detail: "no factory in scope"
     };
   }
-  const envPath = join24(factoryDir, ".env");
+  const envPath = join25(factoryDir, ".env");
   if (!existsSync26(envPath)) {
     return {
       label: "PROJECT_DIR (.env)",
@@ -11100,7 +11125,7 @@ function checkProjectDirEnv(factoryDir) {
   }
   let content;
   try {
-    content = readFileSync23(envPath, "utf-8");
+    content = readFileSync24(envPath, "utf-8");
   } catch {
     return {
       label: "PROJECT_DIR (.env)",
@@ -11137,7 +11162,7 @@ function checkProjectDirEnv(factoryDir) {
       fix: `Clone your project to ${value} or re-run 'beastmode init --project <path>'`
     };
   }
-  if (!existsSync26(join24(value, ".git"))) {
+  if (!existsSync26(join25(value, ".git"))) {
     return {
       label: "PROJECT_DIR (.env)",
       status: "fail",
@@ -11168,7 +11193,7 @@ async function checkFactoryContainers(factoryDir) {
       detail: "no factory in scope"
     };
   }
-  const composePath = join24(factoryDir, "docker-compose.yml");
+  const composePath = join25(factoryDir, "docker-compose.yml");
   if (!existsSync26(composePath)) {
     return {
       label: "Factory containers",
@@ -11451,8 +11476,8 @@ function checkProjectDirectory(factoryDir) {
       fix: "Run beastmode init to create a factory"
     };
   }
-  const bmDir = join24(factoryDir, ".beastmode");
-  const projectsDir = join24(bmDir, "projects");
+  const bmDir = join25(factoryDir, ".beastmode");
+  const projectsDir = join25(bmDir, "projects");
   if (!existsSync26(projectsDir)) {
     return {
       label: "Project directory",
@@ -11480,7 +11505,7 @@ function checkProjectDirectory(factoryDir) {
       anyFail = true;
       continue;
     }
-    const isGit = existsSync26(join24(projPath, ".git"));
+    const isGit = existsSync26(join25(projPath, ".git"));
     const manifests = [
       "package.json",
       "Cargo.toml",
@@ -11491,7 +11516,7 @@ function checkProjectDirectory(factoryDir) {
       "build.gradle",
       "build.gradle.kts"
     ];
-    const manifest = manifests.find((m) => existsSync26(join24(projPath, m)));
+    const manifest = manifests.find((m) => existsSync26(join25(projPath, m)));
     const framework = proj.stack?.detected || manifest?.replace(".json", "") || "unknown";
     results.push(
       `${projName}: ${projPath} (${framework})${isGit ? "" : " [no .git]"}`
@@ -11541,7 +11566,7 @@ function checkStack(factoryDir) {
       detail: "no factory \u2014 run beastmode init"
     };
   }
-  const projectsDir = join24(factoryDir, ".beastmode", "projects");
+  const projectsDir = join25(factoryDir, ".beastmode", "projects");
   if (!existsSync26(projectsDir)) {
     return { label: "Stack", status: "warn", detail: "no projects configured" };
   }
@@ -11593,12 +11618,12 @@ function checkBoardPassword(env, factoryDir) {
     return { label: "Board password", status: "pass", detail: "set" };
   }
   if (factoryDir) {
-    const dotEnv = join24(factoryDir, ".env");
-    const secretsEnv = join24(factoryDir, ".beastmode", "secrets.env.local");
+    const dotEnv = join25(factoryDir, ".env");
+    const secretsEnv = join25(factoryDir, ".beastmode", "secrets.env.local");
     for (const filePath of [dotEnv, secretsEnv]) {
       if (existsSync26(filePath)) {
         try {
-          const content = readFileSync23(filePath, "utf-8");
+          const content = readFileSync24(filePath, "utf-8");
           const lines = content.split("\n");
           const line = lines.find((l) => l.startsWith("BEASTMODE_UI_PASSWORD="));
           if (line) {
@@ -11620,12 +11645,12 @@ function checkBoardPassword(env, factoryDir) {
   };
 }
 function doctorAction(factoryDir, env) {
-  const bmDir = join24(factoryDir, ".beastmode");
+  const bmDir = join25(factoryDir, ".beastmode");
   const factoryDirExists = existsSync26(bmDir);
   let factoryIdentity = null;
   if (factoryDirExists) {
     try {
-      const raw = JSON.parse(readFileSync23(join24(bmDir, "factory.json"), "utf-8"));
+      const raw = JSON.parse(readFileSync24(join25(bmDir, "factory.json"), "utf-8"));
       factoryIdentity = FactoryIdentitySchema.parse(raw);
     } catch {
     }
@@ -11633,10 +11658,10 @@ function doctorAction(factoryDir, env) {
   let config = null;
   let configParseError = null;
   if (factoryDirExists) {
-    const configPath = join24(bmDir, "config.json");
+    const configPath = join25(bmDir, "config.json");
     if (existsSync26(configPath)) {
       try {
-        const raw = JSON.parse(readFileSync23(configPath, "utf-8"));
+        const raw = JSON.parse(readFileSync24(configPath, "utf-8"));
         const result = FactoryConfigSchema.safeParse(raw);
         if (result.success) {
           config = raw;
@@ -11652,7 +11677,7 @@ function doctorAction(factoryDir, env) {
   }
   const projectPaths = [];
   if (factoryDirExists) {
-    const projectsDir = join24(bmDir, "projects");
+    const projectsDir = join25(bmDir, "projects");
     for (const proj of listProjectRecords(projectsDir)) {
       if (proj.path) {
         projectPaths.push({
@@ -11665,13 +11690,13 @@ function doctorAction(factoryDir, env) {
   }
   const installedPlugins = [];
   if (factoryDirExists) {
-    const pluginsDir = join24(bmDir, "plugins");
+    const pluginsDir = join25(bmDir, "plugins");
     if (existsSync26(pluginsDir)) {
       for (const pluginName of readdirSync11(pluginsDir)) {
-        const manifestPath = join24(pluginsDir, pluginName, "manifest.json");
+        const manifestPath = join25(pluginsDir, pluginName, "manifest.json");
         if (existsSync26(manifestPath)) {
           try {
-            const manifest = JSON.parse(readFileSync23(manifestPath, "utf-8"));
+            const manifest = JSON.parse(readFileSync24(manifestPath, "utf-8"));
             installedPlugins.push({
               name: pluginName,
               engine_version: manifest.engine_version || "*"
@@ -11699,7 +11724,7 @@ var SYSTEMD_CREDS_TIMER = "beastmode-claude-creds.timer";
 var LAUNCH_AGENT_LABEL2 = "com.develeap.beastmode.claude-creds";
 function checkCredentialSyncAgent() {
   const results = [];
-  const credsPath = join24(homedir3(), ".claude", ".credentials.json");
+  const credsPath = join25(homedir3(), ".claude", ".credentials.json");
   if (!existsSync26(credsPath)) {
     results.push({
       label: "Claude credentials file",
@@ -11715,7 +11740,7 @@ function checkCredentialSyncAgent() {
     detail: credsPath
   });
   try {
-    const creds = JSON.parse(readFileSync23(credsPath, "utf-8"));
+    const creds = JSON.parse(readFileSync24(credsPath, "utf-8"));
     const expiresAt = creds?.claudeAiOauth?.expiresAt;
     if (typeof expiresAt === "number") {
       const hoursLeft = Math.round((expiresAt - Date.now()) / 36e5);
@@ -12031,7 +12056,7 @@ var doctorCommand = new Command12("doctor").description("Health check \u2014 val
   console.log();
   const env = process.env;
   const factoryDir = findFactoryDir() ?? resolve15(".");
-  const hasFactory = existsSync26(join24(factoryDir, ".beastmode"));
+  const hasFactory = existsSync26(join25(factoryDir, ".beastmode"));
   const checks = [];
   checks.push(...await checkClaudeAuth(env.ANTHROPIC_API_KEY));
   checks.push(...checkCredentialSyncAgent());
@@ -12107,12 +12132,12 @@ init_schemas();
 init_version();
 init_display();
 import { Command as Command13 } from "commander";
-import { existsSync as existsSync28, readFileSync as readFileSync25, writeFileSync as writeFileSync21 } from "fs";
-import { join as join26, resolve as resolve16 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync26, writeFileSync as writeFileSync21 } from "fs";
+import { join as join27, resolve as resolve16 } from "path";
 
 // src/cli/utils/regenerate.ts
-import { existsSync as existsSync27, readFileSync as readFileSync24, writeFileSync as writeFileSync20, copyFileSync } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync25, writeFileSync as writeFileSync20, copyFileSync } from "fs";
+import { join as join26 } from "path";
 var RECOGNIZED_KEYS = /* @__PURE__ */ new Set([
   "PROJECT_DIR",
   "PROJECT_GITHUB_TOKEN",
@@ -12226,8 +12251,8 @@ function buildNewEnv(values) {
   return lines.join("\n");
 }
 function regenerateFactoryFiles(factoryDir, now = /* @__PURE__ */ new Date()) {
-  const envPath = join25(factoryDir, ".env");
-  const composePath = join25(factoryDir, "docker-compose.yml");
+  const envPath = join26(factoryDir, ".env");
+  const composePath = join26(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.`
@@ -12238,7 +12263,7 @@ function regenerateFactoryFiles(factoryDir, now = /* @__PURE__ */ new Date()) {
       `docker-compose.yml not found at ${composePath}. This does not look like a beastmode factory \u2014 run 'beastmode init' first.`
     );
   }
-  const existingEnv = readFileSync24(envPath, "utf-8");
+  const existingEnv = readFileSync25(envPath, "utf-8");
   const values = parseExistingEnv(existingEnv);
   const missing = [];
   if (!values.projectDir) missing.push("PROJECT_DIR");
@@ -12256,7 +12281,7 @@ function regenerateFactoryFiles(factoryDir, now = /* @__PURE__ */ new Date()) {
   }
   const newEnv = buildNewEnv(values);
   const newCompose = generateComposeYaml("latest");
-  const existingCompose = readFileSync24(composePath, "utf-8");
+  const existingCompose = readFileSync25(composePath, "utf-8");
   const envChanged = newEnv !== existingEnv;
   const composeChanged = newCompose !== existingCompose;
   if (!envChanged && !composeChanged) {
@@ -12292,18 +12317,18 @@ function regenerateFactoryFiles(factoryDir, now = /* @__PURE__ */ new Date()) {
 
 // src/cli/commands/upgrade.ts
 function readIdentity(factoryDir) {
-  const path = join26(factoryDir, ".beastmode", "factory.json");
+  const path = join27(factoryDir, ".beastmode", "factory.json");
   if (!existsSync28(path)) {
     throw new Error("No factory.json found. Run beastmode init first.");
   }
-  return FactoryIdentitySchema.parse(JSON.parse(readFileSync25(path, "utf-8")));
+  return FactoryIdentitySchema.parse(JSON.parse(readFileSync26(path, "utf-8")));
 }
 function readConfig3(factoryDir) {
-  const path = join26(factoryDir, ".beastmode", "config.json");
+  const path = join27(factoryDir, ".beastmode", "config.json");
   if (!existsSync28(path)) {
     return {};
   }
-  return JSON.parse(readFileSync25(path, "utf-8"));
+  return JSON.parse(readFileSync26(path, "utf-8"));
 }
 function upgradeCheckAction(factoryDir) {
   const identity = readIdentity(factoryDir);
@@ -12316,11 +12341,11 @@ function upgradeAction(factoryDir, migrateOnly = false) {
   const result = performUpgrade(identity, config, targetVersion, SCHEMA_VERSION);
   if (result.changes.length > 0) {
     writeFileSync21(
-      join26(factoryDir, ".beastmode", "factory.json"),
+      join27(factoryDir, ".beastmode", "factory.json"),
       JSON.stringify(result.updatedIdentity, null, 2) + "\n"
     );
     writeFileSync21(
-      join26(factoryDir, ".beastmode", "config.json"),
+      join27(factoryDir, ".beastmode", "config.json"),
       JSON.stringify(result.updatedConfig, null, 2) + "\n"
     );
   }
@@ -12410,8 +12435,8 @@ init_board();
 init_display();
 init_migrator();
 import { Command as Command14 } from "commander";
-import { resolve as resolve17, join as join27 } from "path";
-import { existsSync as existsSync29, readFileSync as readFileSync26, mkdirSync as mkdirSync17, writeFileSync as writeFileSync22 } from "fs";
+import { resolve as resolve17, join as join28 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync27, 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);
@@ -12431,25 +12456,25 @@ async function runMigrate(opts) {
   }
   header("BeastMode Migrate");
   info(`Reading daemon config from: ${configPath}`);
-  const configContent = readFileSync26(configPath, "utf-8");
+  const configContent = readFileSync27(configPath, "utf-8");
   const daemonConfig = parseDaemonConfig(configContent);
-  const runsDir = join27(cwd, "runs");
+  const runsDir = join28(cwd, "runs");
   let runDirs = [];
   const checkpoints = /* @__PURE__ */ new Map();
   if (existsSync29(runsDir)) {
     const { readdirSync: readdirSync13 } = await import("fs");
     runDirs = readdirSync13(runsDir).filter((d) => {
       try {
-        return readdirSync13(join27(runsDir, d)).length > 0;
+        return readdirSync13(join28(runsDir, d)).length > 0;
       } catch {
         return false;
       }
     });
     for (const dir of runDirs) {
-      const cpPath = join27(runsDir, dir, "checkpoint.json");
+      const cpPath = join28(runsDir, dir, "checkpoint.json");
       if (existsSync29(cpPath)) {
         try {
-          const cp = JSON.parse(readFileSync26(cpPath, "utf-8"));
+          const cp = JSON.parse(readFileSync27(cpPath, "utf-8"));
           checkpoints.set(dir, cp);
         } catch {
         }
@@ -12506,28 +12531,28 @@ async function runMigrate(opts) {
     warn("Dry run \u2014 no files written.");
     return;
   }
-  const bmDir = join27(cwd, ".beastmode");
+  const bmDir = join28(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 = join27(cwd, file.path);
+    const fullPath = join28(cwd, file.path);
     const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
     mkdirSync17(dir, { recursive: true });
     writeFileSync22(fullPath, file.content, "utf-8");
   }
-  const runsSymlinkTarget = join27(cwd, "runs");
-  const bmRunsPath = join27(cwd, "runs");
+  const runsSymlinkTarget = join28(cwd, "runs");
+  const bmRunsPath = join28(cwd, "runs");
   if (existsSync29(runsSymlinkTarget)) {
     info("Existing runs/ directory preserved in-place.");
   }
-  const boardPath = join27(bmDir, "board.json");
+  const boardPath = join28(bmDir, "board.json");
   if (!existsSync29(boardPath)) {
     writeFileSync22(boardPath, JSON.stringify({ items: [] }, null, 2), "utf-8");
   }
-  mkdirSync17(join27(bmDir, ".cache"), { recursive: true });
+  mkdirSync17(join28(bmDir, ".cache"), { recursive: true });
   console.log();
   success("Migration complete!");
   info(`Factory created at: ${bmDir}`);
@@ -12550,8 +12575,8 @@ init_bridge();
 init_schemas();
 init_engine();
 import { Command as Command15 } 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 existsSync30, readFileSync as readFileSync28, 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 {
@@ -12571,17 +12596,17 @@ async function runPipeline(projectName, opts) {
       "No BeastMode factory found. Run 'beastmode init' first."
     );
   }
-  const bmDir = join28(factoryDir, ".beastmode");
+  const bmDir = join29(factoryDir, ".beastmode");
   header("BeastMode Run");
-  const configPath = join28(bmDir, "config.json");
+  const configPath = join29(bmDir, "config.json");
   if (!existsSync30(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");
+  const projectsDir = join29(bmDir, "projects");
   if (projectName) {
     const record = readProjectRecord(projectsDir, projectName);
     if (!record) {
@@ -12595,11 +12620,11 @@ async function runPipeline(projectName, opts) {
       info(`Using project: ${projectConfig.name}`);
     }
   }
-  const boardPath = join28(bmDir, "board.json");
+  const boardPath = join29(bmDir, "board.json");
   let boardItems = [];
   if (existsSync30(boardPath)) {
     try {
-      const raw = JSON.parse(readFileSync27(boardPath, "utf-8"));
+      const raw = JSON.parse(readFileSync28(boardPath, "utf-8"));
       boardItems = Array.isArray(raw.items) ? raw.items : [];
     } catch {
       boardItems = [];
@@ -12618,9 +12643,9 @@ async function runPipeline(projectName, opts) {
   boardItems.push(task);
   writeFileSync23(boardPath, JSON.stringify({ items: boardItems }, null, 2), "utf-8");
   info(`Created task: ${task.title} (${taskId})`);
-  const cacheDir = join28(bmDir, ".cache");
+  const cacheDir = join29(bmDir, ".cache");
   mkdirSync18(cacheDir, { recursive: true });
-  const daemonConfigPath = join28(cacheDir, "daemon.json");
+  const daemonConfigPath = join29(cacheDir, "daemon.json");
   const daemonConfig = generateDaemonConfig(factoryConfig, projectConfig, factoryDir);
   writeFileSync23(daemonConfigPath, JSON.stringify(daemonConfig, null, 2), "utf-8");
   info(`Generated daemon config at: ${daemonConfigPath}`);
@@ -12673,7 +12698,7 @@ async function runPipeline(projectName, opts) {
   const startTime = Date.now();
   const pollInterval = setInterval(() => {
     try {
-      const board = JSON.parse(readFileSync27(boardPath, "utf-8"));
+      const board = JSON.parse(readFileSync28(boardPath, "utf-8"));
       const items = Array.isArray(board.items) ? board.items : [];
       const taskItem = items.find((i) => i.id === taskId);
       if (taskItem) {
@@ -12720,8 +12745,8 @@ init_bridge();
 init_schemas();
 init_engine();
 import { Command as Command16 } from "commander";
-import { join as join29 } from "path";
-import { existsSync as existsSync31, readFileSync as readFileSync28, writeFileSync as writeFileSync24, mkdirSync as mkdirSync19 } from "fs";
+import { join as join30 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync29, 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)",
@@ -12741,25 +12766,25 @@ async function runDaemon(opts) {
       "No BeastMode factory found. Run 'beastmode init' first."
     );
   }
-  const bmDir = join29(factoryDir, ".beastmode");
+  const bmDir = join30(factoryDir, ".beastmode");
   header("BeastMode Daemon");
-  const configPath = join29(bmDir, "config.json");
+  const configPath = join30(bmDir, "config.json");
   if (!existsSync31(configPath)) {
     throw new Error("Factory config not found. Run 'beastmode init' first.");
   }
   const factoryConfig = FactoryConfigSchema.parse(
-    JSON.parse(readFileSync28(configPath, "utf-8"))
+    JSON.parse(readFileSync29(configPath, "utf-8"))
   );
   let projectConfig = null;
-  const projectsDir = join29(bmDir, "projects");
+  const projectsDir = join30(bmDir, "projects");
   const projects = listProjectRecords(projectsDir);
   if (projects.length > 0) {
     projectConfig = projects[0];
     info(`Using project: ${projectConfig.name}`);
   }
-  const cacheDir = join29(bmDir, ".cache");
+  const cacheDir = join30(bmDir, ".cache");
   mkdirSync19(cacheDir, { recursive: true });
-  const daemonConfigPath = join29(cacheDir, "daemon.json");
+  const daemonConfigPath = join30(cacheDir, "daemon.json");
   const daemonConfig = generateDaemonConfig(
     factoryConfig,
     projectConfig,
@@ -12804,7 +12829,7 @@ async function runDaemon(opts) {
   });
   info(`Starting daemon: ${pythonCmd} ${cmd.args.join(" ")}`);
   console.log();
-  const pidFile = join29(bmDir, "daemon.pid");
+  const pidFile = join30(bmDir, "daemon.pid");
   const { spawn: spawn4 } = await import("child_process");
   const child = spawn4(pythonCmd, cmd.args, {
     stdio: "inherit",
@@ -12854,12 +12879,12 @@ 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 join31 } from "path";
-import { existsSync as existsSync33, writeFileSync as writeFileSync26, readFileSync as readFileSync30 } from "fs";
+import { resolve as resolve19, join as join32 } from "path";
+import { existsSync as existsSync33, writeFileSync as writeFileSync26, readFileSync as readFileSync31 } from "fs";
 import { execSync as execSync9 } from "child_process";
 import { randomBytes } from "crypto";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname7 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { dirname as dirname8 } from "path";
 var deployCommand = new Command18("deploy").description("Deploy BeastMode services as systemd services").option("--port <number>", "Port to serve the board UI on", "8420").option("--host <host>", "Host to bind the board UI to", "0.0.0.0").option("--dry-run", "Show what would be done without executing").option("--no-start", "Install services but don't start them").option("--stop", "Stop all 3 BeastMode services").option("--status", "Show status of all 3 BeastMode services").option("--cloud <provider>", "Deploy to cloud (aws)").option("--upgrade", "Update an existing cloud deployment").option("--destroy", "Destroy the cloud deployment (delete CloudFormation stack)").action(async (opts) => {
   try {
     await runDeploy(opts);
@@ -12910,7 +12935,7 @@ async function runDeploy(opts) {
     process.exit(1);
   }
   const factoryDir = resolve19(".");
-  const bmDir = join31(factoryDir, ".beastmode");
+  const bmDir = join32(factoryDir, ".beastmode");
   if (!existsSync33(bmDir)) {
     error(
       "No .beastmode directory found. Run 'beastmode init' or 'beastmode migrate' first."
@@ -12935,18 +12960,18 @@ async function runDeploy(opts) {
       "../../index.js"
     );
   }
-  const boardVenvPython = join31(factoryDir, "board", ".venv", "bin", "python");
-  const daemonVenvPython = join31(factoryDir, "daemon", ".venv", "bin", "python");
+  const boardVenvPython = join32(factoryDir, "board", ".venv", "bin", "python");
+  const daemonVenvPython = join32(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 = 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 dotEnv = join32(factoryDir, ".env");
+  const secretsEnv = join32(bmDir, "secrets.env.local");
+  const envContent = existsSync33(dotEnv) ? readFileSync31(dotEnv, "utf-8") : "";
+  const secretsContent = existsSync33(secretsEnv) ? readFileSync31(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");
@@ -12955,7 +12980,7 @@ async function runDeploy(opts) {
 # Auto-generated board UI password (deploy)
 BEASTMODE_UI_PASSWORD=${generated}
 `;
-    writeFileSync26(target, (existsSync33(target) ? readFileSync30(target, "utf-8") : "") + append, "utf-8");
+    writeFileSync26(target, (existsSync33(target) ? readFileSync31(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.");
@@ -13171,10 +13196,10 @@ async function deployToAWS(opts) {
     error("AWS credentials not configured. Run: aws configure");
     process.exit(1);
   }
-  const __filename2 = fileURLToPath3(import.meta.url);
-  const __dirname2 = dirname7(__filename2);
-  const templatePath = join31(__dirname2, "..", "..", "infra", "cloudformation", "beastmode.yaml");
-  const cwdTemplate = join31(process.cwd(), "infra", "cloudformation", "beastmode.yaml");
+  const __filename2 = fileURLToPath4(import.meta.url);
+  const __dirname2 = dirname8(__filename2);
+  const templatePath = join32(__dirname2, "..", "..", "infra", "cloudformation", "beastmode.yaml");
+  const cwdTemplate = join32(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");
@@ -13429,13 +13454,13 @@ var logsCommand = new Command21("logs").description("Stream BeastMode service lo
 
 // src/cli/commands/update.ts
 import { Command as Command22 } from "commander";
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync27 } from "fs";
+import { readFileSync as readFileSync32, 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 = readFileSync31(composePath, "utf-8");
+    let content = readFileSync32(composePath, "utf-8");
     const tagPattern = new RegExp(
       `(${GHCR_IMAGE_PREFIX.replace(/[/]/g, "\\/")}\\/(?:board|daemon|ui)):([\\w.\\-]+)`,
       "g"
@@ -13468,7 +13493,7 @@ init_display();
 import { Command as Command23 } from "commander";
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync38 } from "fs";
-import { basename as basename8, join as join37, resolve as resolve20 } from "path";
+import { basename as basename8, join as join38, resolve as resolve20 } from "path";
 
 // src/cli/runner-image-builder.ts
 import { execSync as execSync10 } from "child_process";
@@ -13476,14 +13501,14 @@ import { createHash } from "crypto";
 import {
   existsSync as existsSync35,
   mkdirSync as mkdirSync21,
-  readFileSync as readFileSync33,
+  readFileSync as readFileSync34,
   writeFileSync as writeFileSync28
 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 
 // src/cli/stack-detect.ts
-import { existsSync as existsSync34, readFileSync as readFileSync32 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync33 } from "fs";
+import { join as join33 } from "path";
 var NODE_LOCKFILES = [
   "package-lock.json",
   "pnpm-lock.yaml",
@@ -13521,7 +13546,7 @@ var STACK_LOCKFILES = {
 };
 function readFileSafe2(path) {
   try {
-    return readFileSync32(path, "utf-8");
+    return readFileSync33(path, "utf-8");
   } catch {
     return null;
   }
@@ -13534,7 +13559,7 @@ function parseJsonSafe2(content) {
   }
 }
 function detectRunnerStack(projectDir) {
-  const pkgContent = readFileSafe2(join32(projectDir, "package.json"));
+  const pkgContent = readFileSafe2(join33(projectDir, "package.json"));
   if (pkgContent) {
     const pkg = parseJsonSafe2(pkgContent);
     if (pkg) {
@@ -13548,36 +13573,36 @@ function detectRunnerStack(projectDir) {
     }
     return { name: "node", language: "node" };
   }
-  if (existsSync34(join32(projectDir, "manage.py"))) {
+  if (existsSync34(join33(projectDir, "manage.py"))) {
     return { name: "django", language: "python" };
   }
-  const pyproject = readFileSafe2(join32(projectDir, "pyproject.toml"));
+  const pyproject = readFileSafe2(join33(projectDir, "pyproject.toml"));
   if (pyproject) {
     if (pyproject.toLowerCase().includes("fastapi")) {
       return { name: "fastapi", language: "python" };
     }
     return { name: "python", language: "python" };
   }
-  if (existsSync34(join32(projectDir, "requirements.txt"))) {
+  if (existsSync34(join33(projectDir, "requirements.txt"))) {
     return { name: "python", language: "python" };
   }
-  if (existsSync34(join32(projectDir, "go.mod"))) {
+  if (existsSync34(join33(projectDir, "go.mod"))) {
     return { name: "go", language: "go" };
   }
-  if (existsSync34(join32(projectDir, "Cargo.toml"))) {
+  if (existsSync34(join33(projectDir, "Cargo.toml"))) {
     return { name: "rust", language: "rust" };
   }
-  if (existsSync34(join32(projectDir, "pom.xml"))) {
+  if (existsSync34(join33(projectDir, "pom.xml"))) {
     return { name: "java-maven", language: "java" };
   }
-  if (existsSync34(join32(projectDir, "build.gradle")) || existsSync34(join32(projectDir, "build.gradle.kts"))) {
+  if (existsSync34(join33(projectDir, "build.gradle")) || existsSync34(join33(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) => existsSync34(join32(projectDir, f)));
+  return candidates.filter((f) => existsSync34(join33(projectDir, f)));
 }
 
 // src/cli/runner-image-builder.ts
@@ -13679,12 +13704,12 @@ function generateDockerfile(stack, lockfiles) {
 function computeLockfileHash(projectDir, lockfiles) {
   const hash = createHash("sha256");
   for (const lf of lockfiles) {
-    const path = join33(projectDir, lf);
+    const path = join34(projectDir, lf);
     hash.update(lf);
     hash.update("\0");
     if (existsSync35(path)) {
       try {
-        hash.update(readFileSync33(path));
+        hash.update(readFileSync34(path));
       } catch {
         hash.update("<unreadable>");
       }
@@ -13696,10 +13721,10 @@ function computeLockfileHash(projectDir, lockfiles) {
   return hash.digest("hex").slice(0, 16);
 }
 function readLastBuild(projectDir) {
-  const path = join33(projectDir, RUNNER_STATE_DIR, LAST_BUILD_FILE);
+  const path = join34(projectDir, RUNNER_STATE_DIR, LAST_BUILD_FILE);
   if (!existsSync35(path)) return null;
   try {
-    const data = JSON.parse(readFileSync33(path, "utf-8"));
+    const data = JSON.parse(readFileSync34(path, "utf-8"));
     if (data && typeof data === "object" && typeof data.lockfileHash === "string" && typeof data.imageTag === "string" && typeof data.builtAt === "string") {
       return data;
     }
@@ -13718,10 +13743,10 @@ function imageTagFor(projectName, hash) {
   return `beastmode-runner-${safeName}:${hash}`;
 }
 function writeStateFile(projectDir, fileName, payload) {
-  const dir = join33(projectDir, RUNNER_STATE_DIR);
+  const dir = join34(projectDir, RUNNER_STATE_DIR);
   mkdirSync21(dir, { recursive: true });
   writeFileSync28(
-    join33(dir, fileName),
+    join34(dir, fileName),
     JSON.stringify(payload, null, 2) + "\n",
     "utf-8"
   );
@@ -13847,11 +13872,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 join34 } from "path";
+import { join as join35 } from "path";
 init_display();
 async function writeRunnerMeta(dir, meta) {
   await fs.mkdir(dir, { recursive: true });
-  const path = join34(dir, "runner-meta.json");
+  const path = join35(dir, "runner-meta.json");
   await fs.writeFile(path, JSON.stringify(meta, null, 2) + "\n", "utf-8");
 }
 function resolveRepoSlug() {
@@ -14058,7 +14083,7 @@ import {
   writeFileSync as writeFileSync29
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join35, dirname as dirname8 } from "path";
+import { join as join36, dirname as dirname9 } from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 init_display();
@@ -14088,7 +14113,7 @@ 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 = join35(installDir, "run.sh");
+  const runShPath = join36(installDir, "run.sh");
   if (existsSync36(runShPath)) {
     info(
       `Runner binary already present at ${runShPath} \u2014 skipping download.`
@@ -14099,7 +14124,7 @@ async function downloadAndExtractRunner(installDir, os, arch) {
     return;
   }
   const url = runnerDownloadUrl(os, arch);
-  const tarball = join35(installDir, "runner.tar.gz");
+  const tarball = join36(installDir, "runner.tar.gz");
   setupStep(
     `Downloading GitHub Actions runner v${RUNNER_VERSION} (${os}/${arch})...`
   );
@@ -14150,7 +14175,7 @@ async function configureRunner(installDir, repoUrl, token, name, labels) {
     "--unattended",
     "--replace"
   ];
-  const result = spawnSync6(join35(installDir, "config.sh"), args, {
+  const result = spawnSync6(join36(installDir, "config.sh"), args, {
     cwd: installDir,
     stdio: ["ignore", "inherit", "pipe"],
     encoding: "utf-8"
@@ -14178,7 +14203,7 @@ function startRunnerForeground(installDir) {
       "Use --service to install as a launchd agent for persistent operation."
     );
   }
-  spawn2(join35(installDir, "run.sh"), [], {
+  spawn2(join36(installDir, "run.sh"), [], {
     cwd: installDir,
     stdio: "inherit"
   });
@@ -14203,10 +14228,10 @@ WantedBy=default.target
 }
 async function installSystemdService(installDir, name) {
   const unitName = `beastmode-runner-${name}.service`;
-  const unitDir = join35(homedir4(), ".config", "systemd", "user");
+  const unitDir = join36(homedir4(), ".config", "systemd", "user");
   mkdirSync22(unitDir, { recursive: true });
   writeFileSync29(
-    join35(unitDir, unitName),
+    join36(unitDir, unitName),
     systemdUnitContent(installDir, name),
     "utf-8"
   );
@@ -14260,14 +14285,14 @@ function launchdPlistContent(installDir, name) {
 }
 async function installLaunchdService(installDir, name) {
   const label = `com.beastmode.runner.${name}`;
-  const plistPath2 = join35(
+  const plistPath2 = join36(
     homedir4(),
     "Library",
     "LaunchAgents",
     `${label}.plist`
   );
-  mkdirSync22(dirname8(plistPath2), { recursive: true });
-  mkdirSync22(join35(installDir, "logs"), { recursive: true });
+  mkdirSync22(dirname9(plistPath2), { recursive: true });
+  mkdirSync22(join36(installDir, "logs"), { recursive: true });
   writeFileSync29(plistPath2, launchdPlistContent(installDir, name), "utf-8");
   try {
     execSync12(`launchctl load ${plistPath2}`, { stdio: "inherit" });
@@ -14309,7 +14334,7 @@ async function nativeRunnerSetup(opts) {
   }
   const ghConfig = resolveGitHubConfig();
   const repoSlug = opts.repo ?? resolveRepoSlug();
-  const installDir = join35(homedir4(), ".beastmode", "runners", opts.name);
+  const installDir = join36(homedir4(), ".beastmode", "runners", opts.name);
   if (opts.dryRun) {
     info(
       `[dry-run] Would install native runner '${opts.name}' for repo ${repoSlug}`
@@ -14359,11 +14384,11 @@ async function nativeRunnerSetup(opts) {
 import {
   existsSync as existsSync37,
   mkdirSync as mkdirSync23,
-  readFileSync as readFileSync34,
+  readFileSync as readFileSync35,
   unlinkSync as unlinkSync7,
   writeFileSync as writeFileSync30
 } from "fs";
-import { dirname as dirname9, join as join36 } from "path";
+import { dirname as dirname10, join as join37 } from "path";
 var TARGET_LABEL = "[self-hosted, self-hosted-beastmode]";
 var TARGET_WORKFLOWS = [
   ".github/workflows/test.yml",
@@ -14417,7 +14442,7 @@ async function assertOnlineRunnerExists() {
   }
 }
 async function switchWorkflows(projectDir) {
-  const statePath = join36(projectDir, STATE_FILE);
+  const statePath = join37(projectDir, STATE_FILE);
   if (existsSync37(statePath)) {
     return { alreadySwitched: true, files: [], skipped: [] };
   }
@@ -14430,12 +14455,12 @@ async function switchWorkflows(projectDir) {
   const resultFiles = [];
   const skipped = [];
   for (const relPath of TARGET_WORKFLOWS) {
-    const absPath = join36(projectDir, relPath);
+    const absPath = join37(projectDir, relPath);
     if (!existsSync37(absPath)) {
       skipped.push({ relativePath: relPath, reason: "missing" });
       continue;
     }
-    const content = readFileSync34(absPath, "utf-8");
+    const content = readFileSync35(absPath, "utf-8");
     const { newContent, originals } = replaceRunsOn(content, TARGET_LABEL);
     if (originals.length === 0) {
       skipped.push({ relativePath: relPath, reason: "no_runs_on" });
@@ -14451,25 +14476,25 @@ async function switchWorkflows(projectDir) {
     state.files.push({ relativePath: relPath, originals });
     resultFiles.push({ relativePath: relPath, jobCount: originals.length });
   }
-  mkdirSync23(dirname9(statePath), { recursive: true });
+  mkdirSync23(dirname10(statePath), { recursive: true });
   writeFileSync30(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
   return { alreadySwitched: false, files: resultFiles, skipped };
 }
 async function restoreWorkflows(projectDir) {
-  const statePath = join36(projectDir, STATE_FILE);
+  const statePath = join37(projectDir, STATE_FILE);
   if (!existsSync37(statePath)) {
     return { nothingToRestore: true, files: [] };
   }
   const state = JSON.parse(
-    readFileSync34(statePath, "utf-8")
+    readFileSync35(statePath, "utf-8")
   );
   const resultFiles = [];
   for (const fileState of state.files) {
-    const absPath = join36(projectDir, fileState.relativePath);
+    const absPath = join37(projectDir, fileState.relativePath);
     if (!existsSync37(absPath)) {
       throw new Error(`Workflow file not found: ${fileState.relativePath}`);
     }
-    const content = readFileSync34(absPath, "utf-8");
+    const content = readFileSync35(absPath, "utf-8");
     const newContent = restoreRunsOn(content, fileState.originals);
     writeFileSync30(absPath, newContent, "utf-8");
     resultFiles.push({
@@ -14484,7 +14509,7 @@ 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 = join37(projectDir, ".beastmode", "projects");
+  const projectsDir = join38(projectDir, ".beastmode", "projects");
   if (existsSync38(projectsDir)) {
     try {
       const records = listProjectRecords(projectsDir);
@@ -14874,16 +14899,16 @@ runnerCommand.command("build-image").description(
 // src/cli/commands/project-cmd.ts
 init_engine();
 import { Command as Command24 } from "commander";
-import { existsSync as existsSync39, mkdirSync as mkdirSync24, readFileSync as readFileSync35, renameSync as renameSync3 } from "fs";
-import { join as join38, resolve as resolve21, basename as basename9 } from "path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync24, readFileSync as readFileSync36, renameSync as renameSync3 } from "fs";
+import { join as join39, resolve as resolve21, basename as basename9 } from "path";
 import { execSync as execSync13 } from "child_process";
 var DEFAULT_MAX_PROJECTS = 5;
 var MIN_DISK_WARNING_GB = 10;
 function getMaxProjects(factoryDir) {
-  const configPath = join38(factoryDir, ".beastmode", "config.json");
+  const configPath = join39(factoryDir, ".beastmode", "config.json");
   if (existsSync39(configPath)) {
     try {
-      const config = JSON.parse(readFileSync35(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync36(configPath, "utf-8"));
       if (typeof config.max_projects === "number") return config.max_projects;
     } catch {
     }
@@ -14904,8 +14929,8 @@ function projectAddAction(factoryDir, projectPath, opts) {
   const resolvedPath = resolve21(projectPath);
   if (!existsSync39(resolvedPath)) throw new Error(`Directory not found: ${resolvedPath}`);
   const projectName = opts.name || basename9(resolvedPath);
-  const projectsDir = join38(factoryDir, ".beastmode", "projects");
-  if (existsSync39(join38(projectsDir, projectName, "project.json"))) {
+  const projectsDir = join39(factoryDir, ".beastmode", "projects");
+  if (existsSync39(join39(projectsDir, projectName, "project.json"))) {
     throw new Error(`Project already exists: ${projectName}`);
   }
   const currentCount = listProjectRecords(projectsDir).length;
@@ -14956,7 +14981,7 @@ function projectAddAction(factoryDir, projectPath, opts) {
     } : void 0
   });
   writeProjectRecord(projectsDir, projectName, record);
-  const runsDir = join38(factoryDir, "runs", projectName);
+  const runsDir = join39(factoryDir, "runs", projectName);
   if (!existsSync39(runsDir)) mkdirSync24(runsDir, { recursive: true });
   if (!boardId) {
     void (async () => {
@@ -14986,15 +15011,15 @@ function projectAddAction(factoryDir, projectPath, opts) {
   }
 }
 function projectListAction(factoryDir) {
-  const projectsDir = join38(factoryDir, ".beastmode", "projects");
+  const projectsDir = join39(factoryDir, ".beastmode", "projects");
   return listProjectRecords(projectsDir);
 }
 function projectRemoveAction(factoryDir, name) {
-  const projectDir = join38(factoryDir, ".beastmode", "projects", name);
+  const projectDir = join39(factoryDir, ".beastmode", "projects", name);
   if (!existsSync39(projectDir)) throw new Error(`Project not found: ${name}`);
-  const archivedBase = join38(factoryDir, ".beastmode", "projects", ".archived");
+  const archivedBase = join39(factoryDir, ".beastmode", "projects", ".archived");
   mkdirSync24(archivedBase, { recursive: true });
-  renameSync3(projectDir, join38(archivedBase, name));
+  renameSync3(projectDir, join39(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) => {
@@ -15021,7 +15046,7 @@ projectCommand.command("remove <name>").description("Archive a project").action(
 init_display();
 init_board();
 import { Command as Command25 } from "commander";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 import { existsSync as existsSync40, writeFileSync as writeFileSync31, mkdirSync as mkdirSync25 } from "fs";
 var redeployCommand = new Command25("redeploy").description("Trigger a rebuild + restart of a BeastMode service").argument("<service>", "Service to redeploy (currently: daemon)").action(async (service) => {
   try {
@@ -15043,8 +15068,8 @@ async function runRedeploy(service) {
       "No BeastMode factory found. Run 'beastmode init' first."
     );
   }
-  const markerDir = join39(factoryDir, "daemon", "logs");
-  const markerPath = join39(markerDir, ".daemon-rebuild-requested");
+  const markerDir = join40(factoryDir, "daemon", "logs");
+  const markerPath = join40(markerDir, ".daemon-rebuild-requested");
   if (!existsSync40(markerDir)) {
     mkdirSync25(markerDir, { recursive: true });
   }