@brainforge/core 3.1.5 → 3.1.6

package/dist/index.js

@@ -1,26 +1,189 @@
 // src/state/manager.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+
+// src/project/workspace.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/project/project-config.ts
 import fs from "fs/promises";
 import path from "path";
+var DEFAULT_CONFIG = {
+  version: 2,
+  mode: "simple",
+  runtime: "claude-code",
+  parallelization: {
+    enabled: false,
+    maxAgents: 4
+  },
+  automation: {
+    autoCommit: false,
+    verifyEachPhase: true,
+    shipEachPhase: false,
+    stopOnFailure: true
+  },
+  memory: {
+    contextPacketMaxTokens: 12e3,
+    summarizeAfterEachRun: true,
+    keepRawLogs: true
+  },
+  student: {
+    enabled: false,
+    level: "intermediate",
+    professorMode: true
+  },
+  safety: {
+    redactSecrets: true,
+    requireCleanGit: false,
+    dryRunByDefault: false
+  },
+  dashboard: {
+    enabled: true,
+    port: 3742
+  }
+};
+var CONFIG_FILE = path.join(".brainforge", "config.json");
+async function loadConfig(cwd) {
+  try {
+    const raw = await fs.readFile(path.join(cwd, CONFIG_FILE), "utf-8");
+    const parsed = JSON.parse(raw);
+    return deepMerge(DEFAULT_CONFIG, parsed);
+  } catch {
+    return structuredClone(DEFAULT_CONFIG);
+  }
+}
+async function saveConfig(cwd, config) {
+  const dest = path.join(cwd, CONFIG_FILE);
+  await fs.mkdir(path.dirname(dest), { recursive: true });
+  await fs.writeFile(dest, JSON.stringify(config, null, 2), "utf-8");
+}
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const [key, val] of Object.entries(override)) {
+    if (val !== null && val !== void 0 && typeof val === "object" && !Array.isArray(val) && key in result && typeof result[key] === "object") {
+      result[key] = deepMerge(result[key], val);
+    } else if (val !== void 0) {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+// src/project/workspace.ts
+var BRAINFORGE_DIR = ".brainforge";
+var SUBDIRS = [
+  "memory/context-packets",
+  "codebase",
+  "phases",
+  "runs",
+  "skills",
+  "forensics"
+];
+var Workspace = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+    this.brainforgeDir = path2.join(cwd, BRAINFORGE_DIR);
+  }
+  cwd;
+  brainforgeDir;
+  async ensureDirectories() {
+    await fs2.mkdir(this.brainforgeDir, { recursive: true });
+    for (const rel of SUBDIRS) {
+      await fs2.mkdir(path2.join(this.brainforgeDir, rel), { recursive: true });
+    }
+    await this.ensureInitialFiles();
+  }
+  async loadConfig() {
+    return loadConfig(this.cwd);
+  }
+  async saveConfig(config) {
+    return saveConfig(this.cwd, config);
+  }
+  async initConfig(overrides) {
+    const config = { ...DEFAULT_CONFIG, ...overrides };
+    await saveConfig(this.cwd, config);
+    return config;
+  }
+  async configExists() {
+    return fileExists(path2.join(this.brainforgeDir, "config.json"));
+  }
+  async stateExists() {
+    return fileExists(path2.join(this.brainforgeDir, "core.json"));
+  }
+  phasePath(phaseId) {
+    return path2.join(this.brainforgeDir, "phases", phaseId);
+  }
+  memoryPath() {
+    return path2.join(this.brainforgeDir, "memory");
+  }
+  codebasePath() {
+    return path2.join(this.brainforgeDir, "codebase");
+  }
+  runsPath() {
+    return path2.join(this.brainforgeDir, "runs");
+  }
+  runPath(runId) {
+    return path2.join(this.brainforgeDir, "runs", runId);
+  }
+  skillsPath() {
+    return path2.join(this.brainforgeDir, "skills");
+  }
+  forensicsPath() {
+    return path2.join(this.brainforgeDir, "forensics");
+  }
+  async ensurePhaseDir(phaseId) {
+    const dir = this.phasePath(phaseId);
+    await fs2.mkdir(path2.join(dir, "artifacts"), { recursive: true });
+  }
+  async ensureRunDir(runId) {
+    const dir = this.runPath(runId);
+    await fs2.mkdir(path2.join(dir, "agent-results"), { recursive: true });
+  }
+  async ensureInitialFiles() {
+    const memoryIndex = path2.join(this.brainforgeDir, "memory", "index.json");
+    if (!await fileExists(memoryIndex)) {
+      await fs2.writeFile(
+        memoryIndex,
+        JSON.stringify({ version: 1, createdAt: (/* @__PURE__ */ new Date()).toISOString(), entries: [] }, null, 2),
+        "utf-8"
+      );
+    }
+    const skillsInstalled = path2.join(this.brainforgeDir, "skills", "installed.json");
+    if (!await fileExists(skillsInstalled)) {
+      await fs2.writeFile(
+        skillsInstalled,
+        JSON.stringify({ version: 1, runtimes: [], installedAt: null }, null, 2),
+        "utf-8"
+      );
+    }
+  }
+};
+async function fileExists(p) {
+  return fs2.access(p).then(() => true).catch(() => false);
+}
+
+// src/state/manager.ts
 var STATE_DIR = ".brainforge";
 var STATE_FILE = "core.json";
 var StateManager = class {
   constructor(workingDir) {
     this.workingDir = workingDir;
-    this.statePath = path.join(workingDir, STATE_DIR, STATE_FILE);
+    this.statePath = path3.join(workingDir, STATE_DIR, STATE_FILE);
   }
   workingDir;
   statePath;
   state = null;
   async load() {
-    const raw = await fs.readFile(this.statePath, "utf-8");
+    const raw = await fs3.readFile(this.statePath, "utf-8");
     this.state = JSON.parse(raw);
     return this.state;
   }
   async save() {
     if (!this.state) throw new Error("No state loaded \u2014 call init() or load() first.");
     this.state.metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await fs.mkdir(path.dirname(this.statePath), { recursive: true });
-    await fs.writeFile(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
+    await fs3.mkdir(path3.dirname(this.statePath), { recursive: true });
+    await fs3.writeFile(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
     await this.writeDerivedViews();
   }
   async init(project) {
@@ -36,8 +199,33 @@ var StateManager = class {
       }
     };
     await this.save();
+    try {
+      const workspace = new Workspace(this.workingDir);
+      await workspace.ensureDirectories();
+      if (!await workspace.configExists()) {
+        const modeMap = {
+          student: "student",
+          pro: "pro"
+        };
+        await workspace.initConfig({
+          mode: modeMap[project.type] ?? "simple",
+          student: {
+            enabled: project.type === "student",
+            level: project.studentLevel ?? "intermediate",
+            professorMode: true
+          }
+        });
+      }
+    } catch {
+    }
     return this.state;
   }
+  async loadWorkspaceConfig() {
+    return loadConfig(this.workingDir);
+  }
+  async saveWorkspaceConfig(config) {
+    return saveConfig(this.workingDir, config);
+  }
   get() {
     if (!this.state) throw new Error("State not loaded \u2014 call load() first.");
     return this.state;
@@ -94,7 +282,7 @@ var StateManager = class {
       `---`,
       `*Generated by BrainForge AI v3 \u2014 ${s.metadata.updatedAt}*`
     ].join("\n");
-    await fs.writeFile(path.join(this.workingDir, "PROJECT.md"), content, "utf-8");
+    await fs3.writeFile(path3.join(this.workingDir, "PROJECT.md"), content, "utf-8");
   }
   async writeStateMd() {
     const s = this.state;
@@ -118,13 +306,148 @@ Tasks: ${done}/${p.tasks.length}`;
       "",
       phaseBlocks.length ? phaseBlocks.join("\n\n") : "No phases yet."
     ].join("\n");
-    await fs.writeFile(path.join(this.workingDir, "STATE.md"), content, "utf-8");
+    await fs3.writeFile(path3.join(this.workingDir, "STATE.md"), content, "utf-8");
   }
 };
 
+// src/project/migrations.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+async function detectAndMigrate(cwd) {
+  const workspace = new Workspace(cwd);
+  const actions = [];
+  await workspace.ensureDirectories();
+  if (!await workspace.configExists()) {
+    const config = await inferConfigFromState(cwd);
+    await saveConfig(cwd, config);
+    actions.push("Created .brainforge/config.json");
+  }
+  const oldMap = path4.join(cwd, ".brainforge", "codebase-map.json");
+  if (await fileExists2(oldMap)) {
+    actions.push("Found legacy codebase-map.json (preserved)");
+  }
+  return { ran: actions.length > 0, actions };
+}
+async function inferConfigFromState(cwd) {
+  const config = structuredClone(DEFAULT_CONFIG);
+  try {
+    const raw = await fs4.readFile(path4.join(cwd, ".brainforge", "core.json"), "utf-8");
+    const state = JSON.parse(raw);
+    const type = state.project?.type;
+    if (type === "student") {
+      config.mode = "student";
+      config.student.enabled = true;
+      const level = state.project?.studentLevel;
+      if (level === "beginner" || level === "intermediate" || level === "advanced") {
+        config.student.level = level;
+      }
+    } else if (type === "pro") {
+      config.mode = "pro";
+    }
+  } catch {
+  }
+  return config;
+}
+async function fileExists2(p) {
+  return fs4.access(p).then(() => true).catch(() => false);
+}
+
+// src/project/validators.ts
+var VALID_MODES = ["student", "simple", "pro"];
+var VALID_PHASE_STATUSES = ["pending", "active", "completed", "blocked"];
+var VALID_TASK_STATUSES = ["todo", "in-progress", "done", "skipped"];
+var VALID_PROJECT_TYPES = ["student", "junior", "solo", "personal", "pro"];
+var VALID_LANGUAGES = ["typescript", "javascript", "python", "java", "go", "php", "rust", "csharp", "ruby"];
+function validateConfig(config) {
+  const errors = [];
+  const warnings = [];
+  if (!config || typeof config !== "object") {
+    return { valid: false, errors: ["config must be an object"], warnings };
+  }
+  const c = config;
+  if (c.version !== void 0 && typeof c.version !== "number") {
+    errors.push("config.version must be a number");
+  }
+  if (c.mode && !VALID_MODES.includes(c.mode)) {
+    errors.push(`config.mode must be one of: ${VALID_MODES.join(", ")}`);
+  }
+  if (c.parallelization?.maxAgents !== void 0) {
+    const n = c.parallelization.maxAgents;
+    if (typeof n !== "number" || n < 1 || n > 20) {
+      warnings.push("config.parallelization.maxAgents should be between 1 and 20");
+    }
+  }
+  if (c.dashboard?.port !== void 0) {
+    const p = c.dashboard.port;
+    if (typeof p !== "number" || p < 1024 || p > 65535) {
+      errors.push("config.dashboard.port must be between 1024 and 65535");
+    }
+  }
+  if (c.memory?.contextPacketMaxTokens !== void 0) {
+    const t = c.memory.contextPacketMaxTokens;
+    if (typeof t !== "number" || t < 1e3 || t > 2e5) {
+      warnings.push("config.memory.contextPacketMaxTokens should be between 1000 and 200000");
+    }
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+function validatePhase(phase) {
+  const errors = [];
+  const warnings = [];
+  if (!phase || typeof phase !== "object") {
+    return { valid: false, errors: ["phase must be an object"], warnings };
+  }
+  const p = phase;
+  if (!p.id || typeof p.id !== "string") errors.push("phase.id is required");
+  if (!p.name || typeof p.name !== "string") errors.push("phase.name is required");
+  if (!p.status) {
+    errors.push("phase.status is required");
+  } else if (!VALID_PHASE_STATUSES.includes(p.status)) {
+    errors.push(`phase.status must be one of: ${VALID_PHASE_STATUSES.join(", ")}`);
+  }
+  if (!Array.isArray(p.tasks)) {
+    warnings.push("phase.tasks should be an array");
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+function validateTask(task) {
+  const errors = [];
+  const warnings = [];
+  if (!task || typeof task !== "object") {
+    return { valid: false, errors: ["task must be an object"], warnings };
+  }
+  const t = task;
+  if (!t.id || typeof t.id !== "string") errors.push("task.id is required");
+  if (!t.title || typeof t.title !== "string") errors.push("task.title is required");
+  if (!t.phaseId || typeof t.phaseId !== "string") errors.push("task.phaseId is required");
+  if (t.status && !VALID_TASK_STATUSES.includes(t.status)) {
+    errors.push(`task.status must be one of: ${VALID_TASK_STATUSES.join(", ")}`);
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+function validateProjectConfig(config) {
+  const errors = [];
+  const warnings = [];
+  if (!config || typeof config !== "object") {
+    return { valid: false, errors: ["projectConfig must be an object"], warnings };
+  }
+  const c = config;
+  if (!c.name || typeof c.name !== "string") errors.push("project.name is required");
+  if (!c.description || typeof c.description !== "string") errors.push("project.description is required");
+  if (!c.type || !VALID_PROJECT_TYPES.includes(c.type)) {
+    errors.push(`project.type must be one of: ${VALID_PROJECT_TYPES.join(", ")}`);
+  }
+  if (!c.language || !VALID_LANGUAGES.includes(c.language)) {
+    errors.push(`project.language must be one of: ${VALID_LANGUAGES.join(", ")}`);
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+
 // src/state/state-machine.ts
 function reduce(state, action) {
   switch (action.type) {
+    case "ADD_PHASE":
+      return { ...state, phases: [...state.phases, { description: "", ...action.phase }] };
     case "SET_ACTIVE_PHASE":
       return { ...state, activePhaseId: action.phaseId };
     case "COMPLETE_PHASE": {
@@ -142,6 +465,15 @@ function reduce(state, action) {
       }));
       return { ...state, phases };
     }
+    case "UPDATE_TASK_STATUS": {
+      const phases = state.phases.map((p) => ({
+        ...p,
+        tasks: p.tasks.map(
+          (t) => t.id === action.taskId ? { ...t, status: action.status, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } : t
+        )
+      }));
+      return { ...state, phases };
+    }
     case "SET_CONTEXT":
       return { ...state, context: { ...state.context, [action.key]: action.value } };
     default:
@@ -235,8 +567,8 @@ var PromptEngine = class {
 };
 
 // src/mapper/mapper.ts
-import fs2 from "fs/promises";
-import path2 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 
 // src/mapper/extractors.ts
 function extractFromFile(filePath, content, language) {
@@ -441,14 +773,17 @@ function emptyNode(filePath, language) {
 }
 
 // src/mapper/mapper.ts
-var MAP_FILE = path2.join(".brainforge", "codebase-map.json");
+var MAP_FILE = path5.join(".brainforge", "codebase-map.json");
 var LANGUAGE_EXTENSIONS = {
   typescript: [".ts", ".tsx"],
   javascript: [".js", ".jsx", ".mjs", ".cjs"],
   python: [".py"],
   java: [".java"],
   go: [".go"],
-  php: [".php"]
+  php: [".php"],
+  rust: [".rs"],
+  csharp: [".cs"],
+  ruby: [".rb"]
 };
 var IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".brainforge", "dist", "build", "coverage", "__pycache__", ".venv", "vendor"]);
 var CodebaseMapper = class {
@@ -462,7 +797,7 @@ var CodebaseMapper = class {
     const fileNodes = [];
     for (const filePath of sourceFiles) {
       try {
-        const content = await fs2.readFile(path2.join(this.workingDir, filePath), "utf-8");
+        const content = await fs5.readFile(path5.join(this.workingDir, filePath), "utf-8");
         fileNodes.push(extractFromFile(filePath, content, language));
       } catch {
       }
@@ -482,7 +817,7 @@ var CodebaseMapper = class {
     return map;
   }
   async load() {
-    const raw = await fs2.readFile(path2.join(this.workingDir, MAP_FILE), "utf-8");
+    const raw = await fs5.readFile(path5.join(this.workingDir, MAP_FILE), "utf-8");
     return JSON.parse(raw);
   }
   findRelevantFiles(map, query) {
@@ -507,10 +842,10 @@ var CodebaseMapper = class {
     return results;
   }
   async walk(root, rel, extensions, results) {
-    const dir = rel ? path2.join(root, rel) : root;
+    const dir = rel ? path5.join(root, rel) : root;
     let entries;
     try {
-      entries = await fs2.readdir(dir, { withFileTypes: true });
+      entries = await fs5.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -525,9 +860,9 @@ var CodebaseMapper = class {
     }
   }
   async saveMap(map) {
-    const dest = path2.join(this.workingDir, MAP_FILE);
-    await fs2.mkdir(path2.dirname(dest), { recursive: true });
-    await fs2.writeFile(dest, JSON.stringify(map, null, 2), "utf-8");
+    const dest = path5.join(this.workingDir, MAP_FILE);
+    await fs5.mkdir(path5.dirname(dest), { recursive: true });
+    await fs5.writeFile(dest, JSON.stringify(map, null, 2), "utf-8");
   }
 };
 function tokenize(text) {
@@ -708,8 +1043,8 @@ ${project.type === "student" ? "- Write code you can explain line-by-line \u2014
 };
 
 // src/professor/scanner.ts
-import fs3 from "fs/promises";
-import path3 from "path";
+import fs6 from "fs/promises";
+import path6 from "path";
 
 // src/professor/patterns.ts
 var PATTERNS = [
@@ -860,7 +1195,10 @@ var LANGUAGE_EXTENSIONS2 = {
   python: [".py"],
   java: [".java"],
   go: [".go"],
-  php: [".php"]
+  php: [".php"],
+  rust: [".rs"],
+  csharp: [".cs"],
+  ruby: [".rb"]
 };
 var IGNORED_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
@@ -886,7 +1224,7 @@ var ProfessorScanner = class {
     const files = await this.findFiles(extensions);
     const matches = [];
     for (const relPath of files) {
-      const content = await fs3.readFile(path3.join(this.workingDir, relPath), "utf-8").catch(() => null);
+      const content = await fs6.readFile(path6.join(this.workingDir, relPath), "utf-8").catch(() => null);
       if (!content) continue;
       const lines = content.split("\n");
       for (const pattern of applicable) {
@@ -926,10 +1264,10 @@ var ProfessorScanner = class {
     return results;
   }
   async walk(rel, extensions, results) {
-    const dir = rel ? path3.join(this.workingDir, rel) : this.workingDir;
+    const dir = rel ? path6.join(this.workingDir, rel) : this.workingDir;
     let entries;
     try {
-      entries = await fs3.readdir(dir, { withFileTypes: true });
+      entries = await fs6.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -975,15 +1313,15 @@ var ProfessorScanner = class {
         ""
       );
     }
-    const dest = path3.join(this.workingDir, "PROFESSOR_REPORT.md");
-    await fs3.writeFile(dest, lines.join("\n"), "utf-8");
+    const dest = path6.join(this.workingDir, "PROFESSOR_REPORT.md");
+    await fs6.writeFile(dest, lines.join("\n"), "utf-8");
   }
 };
 
 // src/server/server.ts
 import http from "http";
-import fs4 from "fs/promises";
-import path4 from "path";
+import fs7 from "fs/promises";
+import path7 from "path";
 import { fileURLToPath } from "url";
 import { WebSocketServer, WebSocket } from "ws";
 var MIME = {
@@ -999,8 +1337,8 @@ var BrainForgeServer = class {
   constructor(workingDir, port = 3742, dashboardDir) {
     this.workingDir = workingDir;
     this.port = port;
-    const here = path4.dirname(fileURLToPath(import.meta.url));
-    this.dashboardDir = dashboardDir ?? path4.resolve(here, "../../../dashboard/dist");
+    const here = path7.dirname(fileURLToPath(import.meta.url));
+    this.dashboardDir = dashboardDir ?? path7.resolve(here, "../../../dashboard/dist");
   }
   workingDir;
   port;
@@ -1076,7 +1414,7 @@ var BrainForgeServer = class {
   }
   async fileJson(res, rel) {
     try {
-      const raw = await fs4.readFile(path4.join(this.workingDir, rel), "utf-8");
+      const raw = await fs7.readFile(path7.join(this.workingDir, rel), "utf-8");
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(raw);
     } catch {
@@ -1086,7 +1424,7 @@ var BrainForgeServer = class {
   }
   async fileText(res, rel) {
     try {
-      const raw = await fs4.readFile(path4.join(this.workingDir, rel), "utf-8");
+      const raw = await fs7.readFile(path7.join(this.workingDir, rel), "utf-8");
       res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
       res.end(raw);
     } catch {
@@ -1095,10 +1433,10 @@ var BrainForgeServer = class {
     }
   }
   async static(res, pathname) {
-    let target = path4.join(this.dashboardDir, pathname === "/" ? "index.html" : pathname);
+    let target = path7.join(this.dashboardDir, pathname === "/" ? "index.html" : pathname);
     let found = await exists(target);
     if (!found) {
-      target = path4.join(this.dashboardDir, "index.html");
+      target = path7.join(this.dashboardDir, "index.html");
       found = await exists(target);
     }
     if (!found) {
@@ -1106,13 +1444,13 @@ var BrainForgeServer = class {
       res.end("Dashboard not built. Run: npm run build --workspace=packages/dashboard");
       return;
     }
-    const ext = path4.extname(target);
+    const ext = path7.extname(target);
     res.writeHead(200, { "Content-Type": MIME[ext] ?? "application/octet-stream" });
-    res.end(await fs4.readFile(target));
+    res.end(await fs7.readFile(target));
   }
 };
 async function exists(p) {
-  return fs4.access(p).then(() => true).catch(() => false);
+  return fs7.access(p).then(() => true).catch(() => false);
 }
 function readBody(req) {
   return new Promise((resolve, reject) => {
@@ -1126,8 +1464,8 @@ function readBody(req) {
 }
 
 // src/defense/defense.ts
-import fs5 from "fs/promises";
-import path5 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 
 // src/defense/question-bank.ts
 var STATIC_QUESTIONS = [
@@ -1355,8 +1693,8 @@ var MockDefense = class {
         ""
       );
     }
-    await fs5.writeFile(
-      path5.join(this.workingDir, "DEFENSE_PREP.md"),
+    await fs8.writeFile(
+      path8.join(this.workingDir, "DEFENSE_PREP.md"),
       lines.join("\n"),
       "utf-8"
     );
@@ -1364,8 +1702,8 @@ var MockDefense = class {
 };
 
 // src/skills/registry.ts
-import fs6 from "fs/promises";
-import path6 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 import Handlebars2 from "handlebars";
 
 // src/skills/built-in.ts
@@ -4887,11 +5225,11 @@ var SkillRegistry = class {
   }
   async loadUserSkills(skillsDir) {
     try {
-      const entries = await fs6.readdir(skillsDir, { withFileTypes: true });
+      const entries = await fs9.readdir(skillsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.name.endsWith(".json")) continue;
         try {
-          const raw = await fs6.readFile(path6.join(skillsDir, entry.name), "utf-8");
+          const raw = await fs9.readFile(path9.join(skillsDir, entry.name), "utf-8");
           const skill = JSON.parse(raw);
           this.register(skill);
         } catch {
@@ -4902,7 +5240,7 @@ var SkillRegistry = class {
   }
   async loadSkillsFile(filePath) {
     try {
-      const raw = await fs6.readFile(filePath, "utf-8");
+      const raw = await fs9.readFile(filePath, "utf-8");
       const data = JSON.parse(raw);
       const skills = Array.isArray(data) ? data : [data];
       for (const skill of skills) {
@@ -5141,22 +5479,3450 @@ var AdapterManager = class _AdapterManager {
     return _AdapterManager.create(state.aiConfig);
   }
 };
+
+// src/runtime/runtime-registry.ts
+import os from "os";
+import path10 from "path";
+var HOME = os.homedir();
+var RUNTIME_REGISTRY = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    commandPrefix: "/brg-",
+    globalConfigPath: path10.join(HOME, ".claude", "commands"),
+    localConfigPath: path10.join(".claude", "commands"),
+    commandFileExt: ".md",
+    capabilities: ["slash-commands"],
+    notes: "Full slash command support. Commands appear in /brg-* namespace.",
+    supportLevel: "full"
+  },
+  {
+    id: "codex",
+    name: "OpenAI Codex CLI",
+    commandPrefix: "/brg-",
+    globalConfigPath: path10.join(HOME, ".codex", "prompts"),
+    localConfigPath: path10.join(".codex", "prompts"),
+    commandFileExt: ".md",
+    capabilities: ["slash-commands"],
+    notes: "Partial support \u2014 config path may vary by version.",
+    supportLevel: "partial"
+  },
+  {
+    id: "opencode",
+    name: "OpenCode",
+    commandPrefix: "/brg:",
+    globalConfigPath: path10.join(HOME, ".config", "opencode", "prompts"),
+    localConfigPath: path10.join(".opencode", "prompts"),
+    commandFileExt: ".md",
+    capabilities: ["slash-commands"],
+    notes: "Uses colon syntax: /brg:new. Config path may vary.",
+    supportLevel: "partial"
+  },
+  {
+    id: "gemini-cli",
+    name: "Gemini CLI",
+    commandPrefix: "/brg:",
+    globalConfigPath: path10.join(HOME, ".gemini", "prompts"),
+    localConfigPath: path10.join(".gemini", "prompts"),
+    commandFileExt: ".md",
+    capabilities: ["slash-commands"],
+    notes: "Uses colon syntax: /brg:new.",
+    supportLevel: "partial"
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    commandPrefix: "@brg-",
+    globalConfigPath: path10.join(HOME, ".cursor", "rules"),
+    localConfigPath: path10.join(".cursor", "rules"),
+    commandFileExt: ".mdc",
+    capabilities: ["rules"],
+    notes: "Rules-based approach. Commands are referenced via @brg-* in chat.",
+    supportLevel: "partial"
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    commandPrefix: "@brg-",
+    globalConfigPath: path10.join(HOME, ".codeium", "windsurf", "rules"),
+    localConfigPath: path10.join(".windsurf", "rules"),
+    commandFileExt: ".md",
+    capabilities: ["rules"],
+    notes: "Rules installed in .windsurf/rules/. Reference with @brg-* in chat.",
+    supportLevel: "partial"
+  },
+  {
+    id: "copilot",
+    name: "GitHub Copilot",
+    commandPrefix: "brg-",
+    globalConfigPath: "",
+    localConfigPath: path10.join(".github"),
+    commandFileExt: ".md",
+    capabilities: ["instructions"],
+    notes: "Appends workflow instructions to .github/copilot-instructions.md.",
+    supportLevel: "partial"
+  },
+  {
+    id: "vscode",
+    name: "VS Code",
+    commandPrefix: "brg-",
+    globalConfigPath: "",
+    localConfigPath: path10.join(".vscode"),
+    commandFileExt: ".json",
+    capabilities: ["snippets"],
+    notes: "Writes workspace snippets to .vscode/brainforge.code-snippets.",
+    supportLevel: "partial"
+  },
+  {
+    id: "generic",
+    name: "Generic (Markdown Prompts)",
+    commandPrefix: "brg-",
+    globalConfigPath: "",
+    localConfigPath: path10.join(".brainforge", "prompts"),
+    commandFileExt: ".md",
+    capabilities: ["slash-commands"],
+    notes: "Always works. Writes .md prompt files you can copy-paste into any AI tool.",
+    supportLevel: "fallback"
+  }
+];
+var REGISTRY_MAP = new Map(
+  RUNTIME_REGISTRY.map((r) => [r.id, r])
+);
+function getRuntime(id) {
+  return REGISTRY_MAP.get(id);
+}
+function listRuntimes() {
+  return RUNTIME_REGISTRY;
+}
+
+// src/runtime/runtime-detector.ts
+import fs10 from "fs/promises";
+import path11 from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function detectRuntimes(cwd) {
+  const results = await Promise.all([
+    detectClaudeCode(cwd),
+    detectCodex(cwd),
+    detectOpenCode(cwd),
+    detectGeminiCli(cwd),
+    detectCursor(cwd),
+    detectWindsurf(cwd),
+    detectCopilot(cwd),
+    detectVSCode(cwd),
+    detectGeneric()
+  ]);
+  return results;
+}
+async function detectClaudeCode(cwd) {
+  const rt = RUNTIME_REGISTRY.find((r) => r.id === "claude-code");
+  const [hasGlobal, hasLocal] = await Promise.all([
+    dirExists(rt.globalConfigPath),
+    dirExists(path11.join(cwd, ".claude"))
+  ]);
+  const inPath = await commandExists("claude");
+  const detected = hasGlobal || hasLocal || inPath;
+  return {
+    id: "claude-code",
+    name: rt.name,
+    detected,
+    method: detected ? hasGlobal ? "global config dir" : hasLocal ? "local .claude/" : "PATH" : void 0,
+    configPath: hasGlobal ? rt.globalConfigPath : hasLocal ? path11.join(cwd, ".claude", "commands") : void 0,
+    supportLevel: rt.supportLevel
+  };
+}
+async function detectCodex(cwd) {
+  const rt = RUNTIME_REGISTRY.find((r) => r.id === "codex");
+  const [hasGlobal, hasLocal, inPath] = await Promise.all([
+    dirExists(rt.globalConfigPath),
+    dirExists(path11.join(cwd, ".codex")),
+    commandExists("codex")
+  ]);
+  const detected = hasGlobal || hasLocal || inPath;
+  return { id: "codex", name: rt.name, detected, method: detected ? "detected" : void 0, supportLevel: rt.supportLevel };
+}
+async function detectOpenCode(cwd) {
+  const rt = RUNTIME_REGISTRY.find((r) => r.id === "opencode");
+  const [hasGlobal, inPath] = await Promise.all([
+    dirExists(rt.globalConfigPath),
+    commandExists("opencode")
+  ]);
+  const detected = hasGlobal || inPath;
+  return { id: "opencode", name: rt.name, detected, method: detected ? "detected" : void 0, supportLevel: rt.supportLevel };
+}
+async function detectGeminiCli(cwd) {
+  const rt = RUNTIME_REGISTRY.find((r) => r.id === "gemini-cli");
+  const [hasGlobal, inPath] = await Promise.all([
+    dirExists(rt.globalConfigPath),
+    commandExists("gemini")
+  ]);
+  const detected = hasGlobal || inPath;
+  return { id: "gemini-cli", name: rt.name, detected, method: detected ? "detected" : void 0, supportLevel: rt.supportLevel };
+}
+async function detectCursor(cwd) {
+  const rt = RUNTIME_REGISTRY.find((r) => r.id === "cursor");
+  const [hasLocal, inPath] = await Promise.all([
+    dirExists(path11.join(cwd, ".cursor")),
+    commandExists("cursor")
+  ]);
+  const detected = hasLocal || inPath;
+  return { id: "cursor", name: rt.name, detected, method: detected ? "detected" : void 0, supportLevel: rt.supportLevel };
+}
+async function detectWindsurf(cwd) {
+  const rt = RUNTIME_REGISTRY.find((r) => r.id === "windsurf");
+  const hasLocal = await dirExists(path11.join(cwd, ".windsurf"));
+  const inPath = await commandExists("windsurf");
+  const detected = hasLocal || inPath;
+  return { id: "windsurf", name: rt.name, detected, method: detected ? "detected" : void 0, supportLevel: rt.supportLevel };
+}
+async function detectCopilot(cwd) {
+  const rt = RUNTIME_REGISTRY.find((r) => r.id === "copilot");
+  const hasFile = await fileExists3(path11.join(cwd, ".github", "copilot-instructions.md"));
+  const hasGithub = await dirExists(path11.join(cwd, ".github"));
+  const detected = hasFile || hasGithub;
+  return { id: "copilot", name: rt.name, detected, method: detected ? "detected" : void 0, supportLevel: rt.supportLevel };
+}
+async function detectVSCode(cwd) {
+  const rt = RUNTIME_REGISTRY.find((r) => r.id === "vscode");
+  const [hasLocal, inPath] = await Promise.all([
+    dirExists(path11.join(cwd, ".vscode")),
+    commandExists("code")
+  ]);
+  const detected = hasLocal || inPath;
+  return { id: "vscode", name: rt.name, detected, method: detected ? "detected" : void 0, supportLevel: rt.supportLevel };
+}
+function detectGeneric() {
+  const rt = RUNTIME_REGISTRY.find((r) => r.id === "generic");
+  return { id: "generic", name: rt.name, detected: true, method: "always available", supportLevel: "fallback" };
+}
+async function dirExists(p) {
+  try {
+    const stat = await fs10.stat(p);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function fileExists3(p) {
+  try {
+    await fs10.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function commandExists(cmd) {
+  try {
+    const which = process.platform === "win32" ? "where" : "which";
+    await execAsync(`${which} ${cmd}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/runtime/runtime-installer.ts
+import path21 from "path";
+
+// src/runtime/adapters/command-definitions.ts
+var COMMAND_DEFINITIONS = [
+  {
+    name: "new",
+    description: "Create a new BrainForge AI project brief",
+    cliCommand: "brg new",
+    instruction: `Create a new BrainForge AI project brief for the current project.
+
+Run \`brg new\` in the terminal (or \`brg new --from "[description]"\` if the user described what they want to build).
+
+After completion, read \`.brainforge/phases/*/DISCUSSION.md\` and summarize the brief for the user. Then suggest: \`brg requirements\` to formalize requirements.`
+  },
+  {
+    name: "map",
+    description: "Scan the codebase and generate an architecture map",
+    cliCommand: "brg map",
+    instruction: `Scan the current codebase and generate an architecture map.
+
+Run \`brg map --refresh\` in the terminal. After completion, read \`.brainforge/codebase/MAP.md\` and summarize the detected stack, structure, and any risks for the user.`
+  },
+  {
+    name: "discuss",
+    description: "Generate a discussion prompt for the current phase",
+    cliCommand: "brg discuss",
+    instruction: `Generate a discussion prompt for the current project phase.
+
+Run \`brg discuss\` in the terminal. Read the output prompt and use it to ask the user clarifying questions about their project goals and approach.`
+  },
+  {
+    name: "plan",
+    description: "Plan tasks by scanning the codebase",
+    cliCommand: "brg plan",
+    instruction: `Generate a task plan for the current project phase.
+
+Run \`brg plan\` in the terminal. After completion, show the user the generated tasks and ask if they want to adjust priorities, descriptions, or risk levels before proceeding.`
+  },
+  {
+    name: "execute",
+    description: "Generate execution prompts for the active phase",
+    cliCommand: "brg execute",
+    instruction: `Generate execution prompts for the active phase's tasks.
+
+Run \`brg execute --prompt-only\` in the terminal. After completion:
+1. Read \`.brainforge/phases/*/EXECUTION.md\` and implement the tasks described.
+2. For multi-agent mode, check \`.brainforge/phases/*/artifacts/\` for wave-based prompts.
+3. After implementing, run \`brg verify\` to check your work.`
+  },
+  {
+    name: "verify",
+    description: "Verify the active phase is correctly implemented",
+    cliCommand: "brg verify",
+    instruction: `Verify that the active phase is correctly implemented.
+
+Run \`brg verify\` in the terminal to generate the verification checklist. Then:
+1. Read \`.brainforge/phases/*/VERIFY_PROMPT.md\` and follow the checklist.
+2. Run all verification commands listed.
+3. Report any bugs found. If all checks pass, run \`brg ship\`.`
+  },
+  {
+    name: "ship",
+    description: "Close the active phase and update project memory",
+    cliCommand: "brg ship",
+    instruction: `Close the active phase and update project memory.
+
+First confirm with the user that the phase is verified and all acceptance criteria pass. Then run \`brg ship\` in the terminal.
+
+After shipping, show the user the CHANGELOG entry and suggest the next phase.`
+  },
+  {
+    name: "progress",
+    description: "Show a visual progress overview",
+    cliCommand: "brg progress",
+    instruction: `Show the current project progress.
+
+Run \`brg progress\` in the terminal and summarize the output for the user: how many phases are done, what's the active phase, and what the next action is.`
+  },
+  {
+    name: "resume",
+    description: "Generate a context packet to resume work",
+    cliCommand: "brg resume",
+    instruction: `Generate a context packet to resume work after a session break.
+
+Run \`brg resume --rebuild\` in the terminal to get a fresh context packet. Read the output and use it as your working context to continue where you left off.`
+  },
+  {
+    name: "quick",
+    description: "Generate a targeted mini-task prompt",
+    cliCommand: "brg quick",
+    instruction: `Generate a targeted prompt for a small, focused change.
+
+Ask the user what they want to change (e.g., "Fix the mobile nav menu overflow bug"). Then run \`brg quick "[description]"\` in the terminal and implement the change described in the output file.`
+  },
+  {
+    name: "debug",
+    description: "Diagnose a bug using structured debugging workflow",
+    cliCommand: "brg debug",
+    instruction: `Diagnose a bug using BrainForge's structured debugging workflow.
+
+Ask the user to describe the bug (error message, reproduction steps, expected vs actual behavior). Then run \`brg debug "[description]"\` in the terminal and follow the diagnostic plan in the output.`
+  },
+  {
+    name: "fix",
+    description: "Execute a fix plan for a diagnosed bug",
+    cliCommand: "brg fix",
+    instruction: `Execute a fix plan for a diagnosed bug.
+
+Read \`.brainforge/phases/*/BUGS.md\` to understand the bug. Then run \`brg fix\` in the terminal and implement the minimal fix described. Add a regression test after fixing.`
+  },
+  {
+    name: "auto",
+    description: "Run the full automated workflow pipeline",
+    cliCommand: "brg auto",
+    instruction: `Run the full BrainForge workflow pipeline automatically.
+
+Confirm with the user before proceeding. Run \`brg auto --dry-run\` first to show the plan, then \`brg auto\` to execute. Stop on any verification failure.`
+  },
+  {
+    name: "settings",
+    description: "View or edit BrainForge project settings",
+    cliCommand: "brg settings",
+    instruction: `View or update BrainForge project settings.
+
+Run \`brg settings --show\` to display current settings. Ask the user what they'd like to change, then run \`brg settings\` for interactive editing.`
+  },
+  {
+    name: "forensics",
+    description: "Diagnose broken workflow state",
+    cliCommand: "brg forensics",
+    instruction: `Diagnose and repair a broken BrainForge workflow state.
+
+Run \`brg forensics\` in the terminal. Read the diagnostic report and fix any issues found: missing files, invalid JSON, status mismatches.`
+  },
+  {
+    name: "professor",
+    description: "Explain implemented code for academic defense",
+    cliCommand: "brg discuss --professor",
+    instruction: `Generate a defense-ready explanation of the implemented code.
+
+Ask the user which phase or feature to explain. Generate a clear, structured explanation of: what was built, why these technical choices were made, how the key algorithms work, and anticipated examiner questions.`
+  },
+  {
+    name: "explain",
+    description: "Explain a piece of code in plain language",
+    cliCommand: "brg ask",
+    instruction: `Explain a piece of code in plain language at the user's level.
+
+Ask the user: "Which file or function should I explain?" and "What's your programming experience level?" Then provide a clear, jargon-appropriate explanation with analogies where helpful.`
+  },
+  {
+    name: "ui-phase",
+    description: "Generate a UI design contract before frontend work",
+    cliCommand: "brg new --mode ui",
+    instruction: `Generate a UI design contract before implementing frontend work.
+
+Ask the user about: component layout, color/spacing tokens, responsive breakpoints, accessibility requirements, and interaction states. Write the design contract to \`.brainforge/phases/*/UI_CONTRACT.md\`.`
+  },
+  {
+    name: "ui-review",
+    description: "Audit a UI implementation against the design contract",
+    cliCommand: "brg verify --ui",
+    instruction: `Audit the UI implementation against the design contract.
+
+Read \`.brainforge/phases/*/UI_CONTRACT.md\`. Check the implementation against: layout accuracy, color/spacing consistency, accessibility (contrast, keyboard nav, ARIA), responsive behavior, and error states. Write findings to UI_REVIEW.md.`
+  },
+  {
+    name: "security-review",
+    description: "Run a security audit on the current codebase",
+    cliCommand: "brg verify --security",
+    instruction: `Run a security audit on the current codebase.
+
+Check for OWASP Top 10 vulnerabilities: injection, broken auth, sensitive data exposure, insecure direct object references, security misconfiguration, XSS, insecure deserialization, vulnerable components, insufficient logging. Write findings to SECURITY.md.`
+  },
+  {
+    name: "test-review",
+    description: "Review test coverage and quality",
+    cliCommand: "brg verify --tests",
+    instruction: `Review test coverage and quality for the current phase.
+
+Run the test suite. Check: coverage percentage, missing test cases, tests that only check happy paths, integration vs unit test balance. Suggest specific tests to add for untested paths.`
+  },
+  {
+    name: "agents",
+    description: "List available AI agents and their roles",
+    cliCommand: "brg agents list",
+    instruction: `Show the available BrainForge AI agents and help the user choose the right one.
+
+Run \`brg agents list\` in the terminal. Ask the user what task they need help with and suggest the most appropriate agent. Then run \`brg agents describe [id]\` for the chosen agent.`
+  }
+];
+var COMMANDS_BY_NAME = new Map(
+  COMMAND_DEFINITIONS.map((c) => [c.name, c])
+);
+
+// src/runtime/adapters/claude-code.ts
+import fs11 from "fs/promises";
+import path12 from "path";
+async function installClaudeCode(commands, targetDir) {
+  await fs11.mkdir(targetDir, { recursive: true });
+  const files = [];
+  for (const cmd of commands) {
+    const filename = `brg-${cmd.name}.md`;
+    const filePath = path12.join(targetDir, filename);
+    const content = [
+      `# /brg-${cmd.name}`,
+      "",
+      `> ${cmd.description}`,
+      "",
+      cmd.instruction,
+      "",
+      "---",
+      `*BrainForge AI slash command \u2014 run \`${cmd.cliCommand}\`*`
+    ].join("\n");
+    await fs11.writeFile(filePath, content, "utf-8");
+    files.push(filePath);
+  }
+  return files;
+}
+
+// src/runtime/adapters/codex.ts
+import fs12 from "fs/promises";
+import path13 from "path";
+async function installCodex(commands, targetDir) {
+  await fs12.mkdir(targetDir, { recursive: true });
+  const files = [];
+  for (const cmd of commands) {
+    const filename = `brg-${cmd.name}.md`;
+    const filePath = path13.join(targetDir, filename);
+    const content = [
+      `# /brg-${cmd.name} \u2014 ${cmd.description}`,
+      "",
+      cmd.instruction,
+      "",
+      `CLI: \`${cmd.cliCommand}\``
+    ].join("\n");
+    await fs12.writeFile(filePath, content, "utf-8");
+    files.push(filePath);
+  }
+  return files;
+}
+
+// src/runtime/adapters/opencode.ts
+import fs13 from "fs/promises";
+import path14 from "path";
+async function installOpenCode(commands, targetDir) {
+  await fs13.mkdir(targetDir, { recursive: true });
+  const files = [];
+  for (const cmd of commands) {
+    const filename = `brg-${cmd.name}.md`;
+    const filePath = path14.join(targetDir, filename);
+    const content = [
+      `# /brg:${cmd.name}`,
+      "",
+      `> ${cmd.description}`,
+      "",
+      cmd.instruction,
+      "",
+      `CLI: \`${cmd.cliCommand}\``
+    ].join("\n");
+    await fs13.writeFile(filePath, content, "utf-8");
+    files.push(filePath);
+  }
+  return files;
+}
+
+// src/runtime/adapters/gemini-cli.ts
+import fs14 from "fs/promises";
+import path15 from "path";
+async function installGeminiCli(commands, targetDir) {
+  await fs14.mkdir(targetDir, { recursive: true });
+  const files = [];
+  for (const cmd of commands) {
+    const filename = `brg-${cmd.name}.md`;
+    const filePath = path15.join(targetDir, filename);
+    const content = [
+      `# /brg:${cmd.name}`,
+      "",
+      `> ${cmd.description}`,
+      "",
+      cmd.instruction,
+      "",
+      `CLI: \`${cmd.cliCommand}\``,
+      "",
+      "> Note: Use /brg:" + cmd.name + " in Gemini CLI."
+    ].join("\n");
+    await fs14.writeFile(filePath, content, "utf-8");
+    files.push(filePath);
+  }
+  return files;
+}
+
+// src/runtime/adapters/cursor.ts
+import fs15 from "fs/promises";
+import path16 from "path";
+async function installCursor(commands, targetDir) {
+  await fs15.mkdir(targetDir, { recursive: true });
+  const files = [];
+  for (const cmd of commands) {
+    const filename = `brg-${cmd.name}.mdc`;
+    const filePath = path16.join(targetDir, filename);
+    const content = [
+      "---",
+      `description: BrainForge AI \u2014 ${cmd.description}`,
+      "globs: []",
+      "alwaysApply: false",
+      "---",
+      "",
+      `# BrainForge: ${cmd.name}`,
+      "",
+      cmd.instruction,
+      "",
+      `Run in terminal: \`${cmd.cliCommand}\``
+    ].join("\n");
+    await fs15.writeFile(filePath, content, "utf-8");
+    files.push(filePath);
+  }
+  return files;
+}
+
+// src/runtime/adapters/windsurf.ts
+import fs16 from "fs/promises";
+import path17 from "path";
+async function installWindsurf(commands, targetDir) {
+  await fs16.mkdir(targetDir, { recursive: true });
+  const files = [];
+  for (const cmd of commands) {
+    const filename = `brg-${cmd.name}.md`;
+    const filePath = path17.join(targetDir, filename);
+    const content = [
+      `# BrainForge: ${cmd.name}`,
+      "",
+      `> ${cmd.description}`,
+      "",
+      cmd.instruction,
+      "",
+      `Terminal: \`${cmd.cliCommand}\``
+    ].join("\n");
+    await fs16.writeFile(filePath, content, "utf-8");
+    files.push(filePath);
+  }
+  return files;
+}
+
+// src/runtime/adapters/copilot.ts
+import fs17 from "fs/promises";
+import path18 from "path";
+async function installCopilot(commands, targetDir) {
+  await fs17.mkdir(targetDir, { recursive: true });
+  const instructionsPath = path18.join(targetDir, "copilot-instructions.md");
+  let existing = "";
+  try {
+    existing = await fs17.readFile(instructionsPath, "utf-8");
+  } catch {
+  }
+  const MARKER_START = "<!-- brainforge-start -->";
+  const MARKER_END = "<!-- brainforge-end -->";
+  const block = [
+    MARKER_START,
+    "",
+    "# BrainForge AI Workflow Commands",
+    "",
+    "The following BrainForge CLI commands are available in this project:",
+    "",
+    ...commands.map((c) => `- \`${c.cliCommand}\` \u2014 ${c.description}`),
+    "",
+    "## Usage examples",
+    "",
+    ...commands.slice(0, 5).map(
+      (c) => `### ${c.name}
+${c.instruction.split("\n")[0]}
+
+Run: \`${c.cliCommand}\``
+    ),
+    "",
+    MARKER_END
+  ].join("\n");
+  let newContent;
+  if (existing.includes(MARKER_START)) {
+    newContent = existing.replace(
+      new RegExp(`${MARKER_START}[\\s\\S]*?${MARKER_END}`),
+      block
+    );
+  } else {
+    newContent = existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + block + "\n";
+  }
+  await fs17.writeFile(instructionsPath, newContent, "utf-8");
+  return [instructionsPath];
+}
+
+// src/runtime/adapters/vscode.ts
+import fs18 from "fs/promises";
+import path19 from "path";
+async function installVSCode(commands, targetDir) {
+  await fs18.mkdir(targetDir, { recursive: true });
+  const snippetsPath = path19.join(targetDir, "brainforge.code-snippets");
+  const snippets = {};
+  for (const cmd of commands) {
+    const key = `brg-${cmd.name}`;
+    snippets[key] = {
+      scope: "markdown,plaintext",
+      prefix: `brg-${cmd.name}`,
+      body: [cmd.instruction.split("\n")[0], "", `Run: \`${cmd.cliCommand}\``],
+      description: cmd.description
+    };
+  }
+  await fs18.writeFile(snippetsPath, JSON.stringify(snippets, null, 2), "utf-8");
+  return [snippetsPath];
+}
+
+// src/runtime/adapters/generic.ts
+import fs19 from "fs/promises";
+import path20 from "path";
+async function installGeneric(commands, targetDir) {
+  await fs19.mkdir(targetDir, { recursive: true });
+  const files = [];
+  for (const cmd of commands) {
+    const filename = `brg-${cmd.name}.md`;
+    const filePath = path20.join(targetDir, filename);
+    const content = [
+      `# brg-${cmd.name}`,
+      "",
+      `**${cmd.description}**`,
+      "",
+      "## Instructions",
+      "",
+      cmd.instruction,
+      "",
+      "## CLI command",
+      "",
+      `\`\`\`bash`,
+      cmd.cliCommand,
+      `\`\`\``,
+      "",
+      "---",
+      "*Copy and paste this into your AI tool.*"
+    ].join("\n");
+    await fs19.writeFile(filePath, content, "utf-8");
+    files.push(filePath);
+  }
+  const indexPath = path20.join(targetDir, "INDEX.md");
+  const indexContent = [
+    "# BrainForge AI \u2014 Prompt Library",
+    "",
+    "Copy any of the files below into your AI tool to run that workflow.",
+    "",
+    ...commands.map((c) => `- [brg-${c.name}.md](brg-${c.name}.md) \u2014 ${c.description}`)
+  ].join("\n");
+  await fs19.writeFile(indexPath, indexContent, "utf-8");
+  files.push(indexPath);
+  return files;
+}
+
+// src/runtime/runtime-installer.ts
+async function installRuntime(runtimeId, opts) {
+  const rt = getRuntime(runtimeId);
+  if (!rt) throw new Error(`Unknown runtime: ${runtimeId}`);
+  const targetDir = opts.global && rt.globalConfigPath ? rt.globalConfigPath : path21.join(opts.cwd, rt.localConfigPath);
+  const commands = COMMAND_DEFINITIONS;
+  let filesWritten;
+  switch (runtimeId) {
+    case "claude-code":
+      filesWritten = await installClaudeCode(commands, targetDir);
+      break;
+    case "codex":
+      filesWritten = await installCodex(commands, targetDir);
+      break;
+    case "opencode":
+      filesWritten = await installOpenCode(commands, targetDir);
+      break;
+    case "gemini-cli":
+      filesWritten = await installGeminiCli(commands, targetDir);
+      break;
+    case "cursor":
+      filesWritten = await installCursor(commands, targetDir);
+      break;
+    case "windsurf":
+      filesWritten = await installWindsurf(commands, targetDir);
+      break;
+    case "copilot":
+      filesWritten = await installCopilot(commands, targetDir);
+      break;
+    case "vscode":
+      filesWritten = await installVSCode(commands, targetDir);
+      break;
+    case "generic":
+      filesWritten = await installGeneric(commands, targetDir);
+      break;
+    default:
+      throw new Error(`No adapter for runtime: ${runtimeId}`);
+  }
+  return {
+    runtimeId,
+    runtimeName: rt.name,
+    filesWritten,
+    targetDir,
+    commandCount: commands.length
+  };
+}
+
+// src/agents/agent-registry.ts
+var AGENT_REGISTRY = [
+  {
+    id: "orchestrator",
+    name: "Orchestrator",
+    purpose: "Coordinates all other agents. Reads project goals, assigns tasks, validates wave plan.",
+    inputs: ["PROJECT.md", "STATE.md", "REQUIREMENTS.md", "ROADMAP.md"],
+    outputs: ["AGENTS.json", "wave plan", "task assignments"],
+    forbidden: ["writing source code", "making architectural decisions alone"],
+    qualityChecks: ["all tasks assigned", "no circular dependencies", "wave plan is valid"],
+    taskTypes: ["general"]
+  },
+  {
+    id: "researcher",
+    name: "Researcher",
+    purpose: "Researches domain knowledge, third-party libraries, and technical solutions.",
+    inputs: ["topic", "stack", "constraints"],
+    outputs: ["RESEARCH.md"],
+    forbidden: ["writing production code", "making final technology choices"],
+    qualityChecks: ["sources cited", "trade-offs documented", "recommendation is concrete"],
+    taskTypes: ["general", "docs"]
+  },
+  {
+    id: "codebase-mapper",
+    name: "Codebase Mapper",
+    purpose: "Maps the existing codebase architecture and produces human-readable summaries.",
+    inputs: ["source files", "package.json", "tsconfig.json"],
+    outputs: ["MAP.md", "STACK.json", "CONVENTIONS.md"],
+    forbidden: ["modifying source code", "making architectural changes"],
+    qualityChecks: ["entry points identified", "key modules listed", "stack fully detected"],
+    taskTypes: ["general"]
+  },
+  {
+    id: "requirements-analyst",
+    name: "Requirements Analyst",
+    purpose: "Extracts and structures requirements from DISCUSSION.md into REQUIREMENTS.md.",
+    inputs: ["DISCUSSION.md", "project goals", "constraints"],
+    outputs: ["REQUIREMENTS.md"],
+    forbidden: ["inventing features not discussed", "technical implementation details"],
+    qualityChecks: ["FRs numbered", "NFRs included", "out-of-scope section present", "no ambiguous language"],
+    taskTypes: ["general", "docs"]
+  },
+  {
+    id: "architect",
+    name: "Architect",
+    purpose: "Designs the system structure: modules, data flow, API contracts, database schema.",
+    inputs: ["REQUIREMENTS.md", "MAP.md", "STACK.json"],
+    outputs: ["ARCHITECTURE.md", "API_CONTRACTS.md", "SCHEMA.md"],
+    forbidden: ["writing implementation code", "skipping documentation"],
+    qualityChecks: ["all FRs covered", "data flow described", "external integrations listed"],
+    taskTypes: ["backend", "database", "general"]
+  },
+  {
+    id: "planner",
+    name: "Planner",
+    purpose: "Breaks down a phase into atomic tasks with dependencies and agent assignments.",
+    inputs: ["REQUIREMENTS.md", "ARCHITECTURE.md", "phase goal"],
+    outputs: ["TASKS.json", "AGENTS.json", "dependency graph"],
+    forbidden: ["inventing scope", "assigning more than one agent per task"],
+    qualityChecks: ["each task has clear acceptance criteria", "dependencies are acyclic", "risk levels set"],
+    taskTypes: ["general"]
+  },
+  {
+    id: "backend-engineer",
+    name: "Backend Engineer",
+    purpose: "Implements API endpoints, business logic, services, and backend infrastructure.",
+    inputs: ["PLAN.md", "task object", "ARCHITECTURE.md", "CONVENTIONS.md"],
+    outputs: ["source code", "task completion report"],
+    forbidden: ["modifying frontend code", "skipping error handling", "hardcoding secrets"],
+    qualityChecks: ["tests written", "input validated", "errors handled", "no hardcoded secrets"],
+    taskTypes: ["backend", "general"]
+  },
+  {
+    id: "frontend-engineer",
+    name: "Frontend Engineer",
+    purpose: "Implements UI components, pages, forms, and client-side logic.",
+    inputs: ["PLAN.md", "task object", "UI_CONTRACT.md", "CONVENTIONS.md"],
+    outputs: ["source code", "task completion report"],
+    forbidden: ["modifying backend code", "skipping accessibility", "inline styles without system tokens"],
+    qualityChecks: ["responsive design", "accessible (ARIA)", "error states handled", "no raw API calls from components"],
+    taskTypes: ["frontend", "general"]
+  },
+  {
+    id: "fullstack-engineer",
+    name: "Full-Stack Engineer",
+    purpose: "Implements tasks spanning both frontend and backend in the same feature slice.",
+    inputs: ["PLAN.md", "task object", "ARCHITECTURE.md", "CONVENTIONS.md"],
+    outputs: ["source code", "task completion report"],
+    forbidden: ["skipping tests", "mixing concerns", "leaving TODO comments in shipped code"],
+    qualityChecks: ["both layers implemented", "E2E flow tested", "no dead code"],
+    taskTypes: ["frontend", "backend", "general"]
+  },
+  {
+    id: "database-engineer",
+    name: "Database Engineer",
+    purpose: "Designs and implements database schemas, migrations, indexes, and queries.",
+    inputs: ["SCHEMA.md", "task object", "STACK.json"],
+    outputs: ["migration files", "schema updates", "seed data"],
+    forbidden: ["destructive migrations without backup plan", "N+1 queries", "missing indexes on FK columns"],
+    qualityChecks: ["migration is reversible", "indexes on query-critical columns", "no data loss"],
+    taskTypes: ["database"]
+  },
+  {
+    id: "devops-engineer",
+    name: "DevOps Engineer",
+    purpose: "Implements CI/CD pipelines, Docker configs, deployment scripts, and infrastructure.",
+    inputs: ["PLAN.md", "task object", "STACK.json", "deployment target"],
+    outputs: ["pipeline files", "Docker configs", "deployment scripts"],
+    forbidden: ["hardcoding credentials", "skipping health checks", "deploying untested code"],
+    qualityChecks: ["secrets in env vars", "health check endpoint used", "rollback plan documented"],
+    taskTypes: ["devops", "general"]
+  },
+  {
+    id: "security-reviewer",
+    name: "Security Reviewer",
+    purpose: "Audits code for OWASP Top 10 vulnerabilities, authentication issues, and data exposure.",
+    inputs: ["source code", "PLAN.md", "API_CONTRACTS.md"],
+    outputs: ["SECURITY.md", "security findings with severity"],
+    forbidden: ["introducing new code", "ignoring high/critical findings"],
+    qualityChecks: ["OWASP Top 10 checked", "auth/authz reviewed", "input sanitization verified"],
+    taskTypes: ["security", "backend"]
+  },
+  {
+    id: "test-engineer",
+    name: "Test Engineer",
+    purpose: "Writes unit, integration, and E2E tests with strong coverage.",
+    inputs: ["source code", "task result", "REQUIREMENTS.md"],
+    outputs: ["test files", "test run results"],
+    forbidden: ["mocking the database for integration tests", "testing implementation details", "skipping edge cases"],
+    qualityChecks: ["happy path tested", "error paths tested", "coverage > 80%"],
+    taskTypes: ["test"]
+  },
+  {
+    id: "ui-reviewer",
+    name: "UI Reviewer",
+    purpose: "Audits UI implementation against design contract, accessibility, and visual quality.",
+    inputs: ["source code", "UI_CONTRACT.md", "screenshots"],
+    outputs: ["UI_REVIEW.md", "list of issues with severity"],
+    forbidden: ["rewriting frontend code", "approving inaccessible UIs"],
+    qualityChecks: ["contrast ratio passes", "keyboard navigation works", "responsive on mobile"],
+    taskTypes: ["frontend"]
+  },
+  {
+    id: "debugger",
+    name: "Debugger",
+    purpose: "Diagnoses bugs using scientific method: hypothesis \u2192 test \u2192 fix \u2192 verify.",
+    inputs: ["bug description", "error logs", "source code", "reproduction steps"],
+    outputs: ["BUGS.md", "FIX_PLAN.md", "root cause analysis"],
+    forbidden: ["guessing without evidence", "fixing symptoms without root cause", "introducing new bugs"],
+    qualityChecks: ["root cause identified", "fix is minimal", "regression test added"],
+    taskTypes: ["backend", "frontend", "general"]
+  },
+  {
+    id: "verifier",
+    name: "Verifier",
+    purpose: "Verifies that a phase is truly done: runs acceptance criteria, checks tests, reports bugs.",
+    inputs: ["PLAN.md", "TASKS.json", "source code", "test results"],
+    outputs: ["VERIFY.md", "BUGS.md"],
+    forbidden: ["approving a phase with critical bugs", "skipping any acceptance criterion"],
+    qualityChecks: ["every acceptance criterion checked", "all tests pass", "no regression"],
+    taskTypes: ["general"]
+  },
+  {
+    id: "docs-writer",
+    name: "Docs Writer",
+    purpose: "Updates README, API docs, architecture docs, and CHANGELOG after implementation.",
+    inputs: ["source code", "REQUIREMENTS.md", "SHIP.md"],
+    outputs: ["updated docs", "CHANGELOG entry"],
+    forbidden: ["inventing features not built", "outdated examples"],
+    qualityChecks: ["code examples run", "API docs match implementation", "CHANGELOG entry present"],
+    taskTypes: ["docs"]
+  },
+  {
+    id: "professor",
+    name: "Professor",
+    purpose: "Explains the implemented code for academic defense: how it works, why it was built this way.",
+    inputs: ["source code", "task object", "REQUIREMENTS.md"],
+    outputs: ["DEFENSE.md", "oral defense talking points"],
+    forbidden: ["oversimplifying", "missing connections to course concepts"],
+    qualityChecks: ['explains the "why"', "connects to theory", "anticipates examiner questions"],
+    taskTypes: ["general"]
+  },
+  {
+    id: "student-explainer",
+    name: "Student Explainer",
+    purpose: "Simplifies complex code explanations to match the student's declared knowledge level.",
+    inputs: ["source code", "student level", "task context"],
+    outputs: ["plain-language explanation", "annotated code snippets"],
+    forbidden: ["using advanced jargon without definition", "condescending tone"],
+    qualityChecks: ["level-appropriate vocabulary", "analogy used for complex concepts", 'no unanswered "why" questions'],
+    taskTypes: ["general"]
+  },
+  {
+    id: "ship-manager",
+    name: "Ship Manager",
+    purpose: "Closes a phase safely: verifies VERIFY.md passes, writes SHIP.md, updates CHANGELOG and memory.",
+    inputs: ["VERIFY.md", "PLAN.md", "TASKS.json", "BUGS.md"],
+    outputs: ["SHIP.md", "CHANGELOG entry", "memory summary"],
+    forbidden: ["shipping with open critical bugs", "skipping memory update"],
+    qualityChecks: ["no critical bugs in BUGS.md", "CHANGELOG entry accurate", "memory entry written"],
+    taskTypes: ["general"]
+  }
+];
+var REGISTRY_MAP2 = new Map(
+  AGENT_REGISTRY.map((a) => [a.id, a])
+);
+function getAgent(id) {
+  return REGISTRY_MAP2.get(id);
+}
+function listAgents() {
+  return AGENT_REGISTRY;
+}
+
+// src/agents/wave-planner.ts
+var WavePlanner = class {
+  plan(tasks) {
+    const pending = tasks.filter((t) => t.status !== "done");
+    if (pending.length === 0) return [];
+    const assigned = /* @__PURE__ */ new Set();
+    const waves = [];
+    const grouped = /* @__PURE__ */ new Map();
+    const ungrouped = [];
+    for (const t of pending) {
+      if (t.parallelGroup) {
+        const g = grouped.get(t.parallelGroup) ?? [];
+        g.push(t);
+        grouped.set(t.parallelGroup, g);
+      } else {
+        ungrouped.push(t);
+      }
+    }
+    const sorted = topologicalSort(ungrouped);
+    let waveIndex = 1;
+    const remaining = [...sorted];
+    while (remaining.length > 0) {
+      const waveTasks = [];
+      for (const task of remaining) {
+        const deps = task.dependsOn ?? [];
+        const depsResolved = deps.every((dep) => assigned.has(dep));
+        if (depsResolved) waveTasks.push(task);
+      }
+      if (waveTasks.length === 0) {
+        waveTasks.push(...remaining);
+      }
+      for (const t of waveTasks) {
+        assigned.add(t.id);
+        const idx = remaining.indexOf(t);
+        if (idx !== -1) remaining.splice(idx, 1);
+      }
+      waves.push({
+        index: waveIndex++,
+        label: `Wave ${waveIndex - 1}`,
+        tasks: waveTasks,
+        canParallelize: waveTasks.length > 1
+      });
+    }
+    for (const [group, groupTasks] of grouped) {
+      waves.push({
+        index: waveIndex++,
+        label: `Wave ${waveIndex - 1} (group: ${group})`,
+        tasks: groupTasks,
+        canParallelize: true
+      });
+    }
+    return waves;
+  }
+  assignAgents(tasks) {
+    const assignments = /* @__PURE__ */ new Map();
+    for (const task of tasks) {
+      if (task.agent) {
+        assignments.set(task.id, task.agent);
+        continue;
+      }
+      assignments.set(task.id, inferAgent(task));
+    }
+    return assignments;
+  }
+};
+function inferAgent(task) {
+  const title = task.title.toLowerCase();
+  const desc = (task.description ?? "").toLowerCase();
+  const text = title + " " + desc;
+  if (task.type === "database" || /migrat|schema|model|orm|sequelize|prisma|drizzle/.test(text)) return "database-engineer";
+  if (task.type === "devops" || /ci\/cd|pipeline|docker|deploy|kubernetes|helm|infra/.test(text)) return "devops-engineer";
+  if (task.type === "security" || /auth|jwt|oauth|rbac|permission|security|encrypt/.test(text)) return "security-reviewer";
+  if (task.type === "test" || /test|spec|coverage|vitest|jest|playwright|cypress/.test(text)) return "test-engineer";
+  if (task.type === "docs" || /readme|doc|changelog|comment|jsdoc/.test(text)) return "docs-writer";
+  if (task.type === "frontend" || /component|ui|page|layout|style|css|form|modal|button|nav/.test(text)) return "frontend-engineer";
+  if (task.type === "backend" || /api|endpoint|route|controller|service|handler|webhook|cron/.test(text)) return "backend-engineer";
+  return "fullstack-engineer";
+}
+function topologicalSort(tasks) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  function visit(task) {
+    if (visited.has(task.id)) return;
+    visited.add(task.id);
+    for (const depId of task.dependsOn ?? []) {
+      const dep = taskMap.get(depId);
+      if (dep) visit(dep);
+    }
+    sorted.push(task);
+  }
+  for (const task of tasks) visit(task);
+  return sorted;
+}
+
+// src/agents/parallel-orchestrator.ts
+import fs20 from "fs/promises";
+import path22 from "path";
+
+// src/agents/agent-prompts.ts
+function buildAgentPrompt(agent, task, ctx) {
+  const stackLine = ctx.stack ? `${ctx.stack.language}${ctx.stack.framework ? " / " + ctx.stack.framework : ""}` : "unknown";
+  const lines = [
+    `# Agent: ${agent.name}`,
+    `> Project: ${ctx.projectName}  |  Phase: ${ctx.phaseName}  |  Stack: ${stackLine}`,
+    "",
+    `## Your role`,
+    agent.purpose,
+    "",
+    `## Task`,
+    `**${task.title}**`,
+    "",
+    task.description ? task.description + "\n" : ""
+  ];
+  if (task.acceptanceCriteria?.length) {
+    lines.push("## Acceptance criteria");
+    for (const c of task.acceptanceCriteria) lines.push(`- [ ] ${c}`);
+    lines.push("");
+  }
+  if (task.verificationCommands?.length) {
+    lines.push("## Verification commands");
+    for (const cmd of task.verificationCommands) lines.push(`\`\`\`bash
+${cmd}
+\`\`\``);
+    lines.push("");
+  }
+  lines.push("## Your inputs");
+  for (const input of agent.inputs) lines.push(`- ${input}`);
+  lines.push("");
+  lines.push("## Expected outputs");
+  for (const output of agent.outputs) lines.push(`- ${output}`);
+  lines.push("");
+  lines.push("## What you must NOT do");
+  for (const f of agent.forbidden) lines.push(`- ${f}`);
+  lines.push("");
+  lines.push("## Quality checks before you report done");
+  for (const q of agent.qualityChecks) lines.push(`- [ ] ${q}`);
+  lines.push("");
+  if (task.riskLevel === "high") {
+    lines.push(`> **Risk level: ${task.riskLevel}** \u2014 extra care required. Document trade-offs.`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push(`*BrainForge AI \u2014 Agent: ${agent.id} \u2014 paste into your AI tool.*`);
+  return lines.filter((l) => l !== null && l !== void 0).join("\n");
+}
+function buildWaveSummary(wave, tasks, phase, ctx) {
+  const lines = [
+    `# Wave ${wave} \u2014 ${ctx.phaseName}`,
+    `> ${tasks.length} task(s) can run in parallel in this wave.`,
+    "",
+    "## Tasks in this wave",
+    ""
+  ];
+  for (const t of tasks) {
+    const agentLabel = t.agent ? ` \u2192 agent: ${t.agent}` : "";
+    lines.push(`- **${t.title}**${agentLabel}`);
+    if (t.description) lines.push(`  ${t.description.split("\n")[0]}`);
+  }
+  lines.push("");
+  lines.push("## Parallelization note");
+  lines.push("These tasks are independent and can be worked on simultaneously in separate AI sessions.");
+  lines.push("Each task has its own prompt file in this wave directory.");
+  return lines.join("\n");
+}
+
+// src/agents/parallel-orchestrator.ts
+var ParallelOrchestrator = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+    this.phasesDir = path22.join(cwd, ".brainforge", "phases");
+  }
+  cwd;
+  phasesDir;
+  async orchestrate(phase, stack) {
+    const planner = new WavePlanner();
+    const waves = planner.plan(phase.tasks);
+    const agentMap = planner.assignAgents(phase.tasks);
+    const artifactsDir = path22.join(this.phasesDir, phase.id, "artifacts");
+    await fs20.mkdir(artifactsDir, { recursive: true });
+    const ctx = {
+      projectName: path22.basename(this.cwd),
+      phaseName: phase.name,
+      stack
+    };
+    const writtenFiles = [];
+    for (const wave of waves) {
+      const waveDir = path22.join(artifactsDir, `wave-${String(wave.index).padStart(3, "0")}`);
+      await fs20.mkdir(waveDir, { recursive: true });
+      const summaryContent = buildWaveSummary(wave.index, wave.tasks, phase, ctx);
+      const summaryPath = path22.join(waveDir, "WAVE.md");
+      await fs20.writeFile(summaryPath, summaryContent, "utf-8");
+      writtenFiles.push(path22.relative(this.cwd, summaryPath).replace(/\\/g, "/"));
+      for (const task of wave.tasks) {
+        const agentId = agentMap.get(task.id) ?? "fullstack-engineer";
+        const agent = getAgent(agentId) ?? getAgent("fullstack-engineer");
+        const content = buildAgentPrompt(agent, task, ctx);
+        const slug = task.id.replace(/[^a-z0-9-]/gi, "-").slice(0, 40);
+        const filePath = path22.join(waveDir, `${slug}.md`);
+        await fs20.writeFile(filePath, content, "utf-8");
+        writtenFiles.push(path22.relative(this.cwd, filePath).replace(/\\/g, "/"));
+      }
+    }
+    const indexContent = buildArtifactsIndex(phase, waves, agentMap);
+    const indexPath = path22.join(artifactsDir, "INDEX.md");
+    await fs20.writeFile(indexPath, indexContent, "utf-8");
+    writtenFiles.push(path22.relative(this.cwd, indexPath).replace(/\\/g, "/"));
+    return {
+      waves: waves.length,
+      totalTasks: phase.tasks.filter((t) => t.status !== "done").length,
+      files: writtenFiles,
+      waveDir: path22.relative(this.cwd, artifactsDir).replace(/\\/g, "/")
+    };
+  }
+};
+function buildArtifactsIndex(phase, waves, agentMap) {
+  const lines = [
+    `# Execution Artifacts \u2014 ${phase.name}`,
+    `> ${waves.length} wave(s)  |  ${phase.tasks.filter((t) => t.status !== "done").length} tasks`,
+    "",
+    "## How to use",
+    "1. Start with Wave 1. Open each task file and paste it into your AI tool.",
+    "2. Tasks in the same wave can run in parallel (separate AI sessions or tabs).",
+    "3. Move to the next wave only when all tasks in the current wave are done.",
+    ""
+  ];
+  for (const wave of waves) {
+    lines.push(`## ${wave.label}${wave.canParallelize ? " (parallel)" : ""}`);
+    for (const task of wave.tasks) {
+      const agentId = agentMap.get(task.id) ?? "fullstack-engineer";
+      lines.push(`- [${agentId}] ${task.title}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/agents/conflict-detector.ts
+function detectConflicts(tasks) {
+  const warnings = [];
+  for (let i = 0; i < tasks.length; i++) {
+    for (let j = i + 1; j < tasks.length; j++) {
+      const a = tasks[i];
+      const b = tasks[j];
+      if (a.files?.length && b.files?.length) {
+        const overlap = a.files.filter((f) => b.files.includes(f));
+        if (overlap.length > 0) {
+          warnings.push({
+            taskA: a.id,
+            taskB: b.id,
+            reason: `Both tasks modify the same file(s)`,
+            filePaths: overlap
+          });
+          continue;
+        }
+      }
+      const aText = taskText(a);
+      const bText = taskText(b);
+      if (/schema|migrat|model/.test(aText) && /schema|migrat|model/.test(bText)) {
+        warnings.push({
+          taskA: a.id,
+          taskB: b.id,
+          reason: "Both tasks may modify database schema \u2014 coordinate to avoid migration conflicts"
+        });
+        continue;
+      }
+      if (/\bauth\b/.test(aText) && /\bauth\b/.test(bText)) {
+        warnings.push({
+          taskA: a.id,
+          taskB: b.id,
+          reason: "Both tasks touch authentication \u2014 ensure consistent token/session handling"
+        });
+      }
+    }
+  }
+  return warnings;
+}
+function taskText(task) {
+  return (task.title + " " + (task.description ?? "")).toLowerCase();
+}
+
+// src/agents/result-merger.ts
+function mergeResults(waves, results) {
+  const totalTasks = waves.reduce((n, w) => n + w.tasks.length, 0);
+  let completed = 0;
+  let failed = 0;
+  const allBlockers = [];
+  for (const result of results) {
+    completed += result.completedTaskIds.length;
+    failed += result.failedTaskIds.length;
+    allBlockers.push(...result.blockers);
+  }
+  const blocked = allBlockers.length > 0;
+  const summary = [
+    `${completed}/${totalTasks} tasks completed across ${waves.length} wave(s).`,
+    failed > 0 ? `${failed} task(s) failed.` : "",
+    blocked ? `Blockers: ${allBlockers.join("; ")}` : ""
+  ].filter(Boolean).join(" ");
+  return { totalWaves: waves.length, totalTasks, completed, failed, blocked, summary };
+}
+function buildMergeReport(tasks, results) {
+  const completedIds = new Set(results.flatMap((r) => r.completedTaskIds));
+  const failedIds = new Set(results.flatMap((r) => r.failedTaskIds));
+  const lines = ["# Merge Report", ""];
+  for (const task of tasks) {
+    const icon = completedIds.has(task.id) ? "\u2713" : failedIds.has(task.id) ? "\u2717" : "\u25CB";
+    lines.push(`- [${icon}] ${task.title}`);
+  }
+  const blockers = results.flatMap((r) => r.blockers);
+  if (blockers.length > 0) {
+    lines.push("", "## Blockers");
+    for (const b of blockers) lines.push(`- ${b}`);
+  }
+  return lines.join("\n");
+}
+
+// src/workflow/workflow-engine.ts
+var WorkflowEngine = class {
+  buildCreatePhaseAction(input) {
+    return {
+      type: "ADD_PHASE",
+      phase: {
+        id: input.id,
+        name: input.name,
+        status: "pending",
+        tasks: input.tasks.map((t) => ({ ...t, status: "todo" }))
+      }
+    };
+  }
+  buildSwitchPhaseAction(phaseId) {
+    return { type: "SET_ACTIVE_PHASE", phaseId };
+  }
+  buildStartTaskAction(taskId) {
+    return { type: "UPDATE_TASK_STATUS", taskId, status: "in-progress" };
+  }
+  buildCompleteTaskAction(taskId) {
+    return { type: "UPDATE_TASK_STATUS", taskId, status: "done" };
+  }
+  buildCompletePhaseAction(phaseId) {
+    return { type: "COMPLETE_PHASE", phaseId };
+  }
+  isPhaseComplete(phase) {
+    return phase.tasks.length > 0 && phase.tasks.every((t) => t.status === "done");
+  }
+  getNextAction(state) {
+    if (state.phases.length === 0) return "Run `brg plan` to create your first phase.";
+    const active = state.phases.find((p) => p.id === state.activePhaseId);
+    if (!active) {
+      const pending = state.phases.find((p) => p.status === "pending");
+      return pending ? `Switch to phase "${pending.name}" with \`brg phase switch ${pending.id}\`` : "All phases complete \u2014 run `brg ship` to finalize.";
+    }
+    const inProg = active.tasks.filter((t) => t.status === "in-progress");
+    const todo = active.tasks.filter((t) => t.status === "todo");
+    if (inProg.length > 0) return `Continue ${inProg.length} in-progress task(s) \u2014 run \`brg execute --prompt-only\``;
+    if (todo.length > 0) return `Execute ${todo.length} remaining task(s) \u2014 run \`brg execute --prompt-only\``;
+    return `All tasks done \u2014 run \`brg verify\` to verify phase "${active.name}"`;
+  }
+  slugify(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+  }
+  generatePhaseId(name, existingIds) {
+    const base = this.slugify(name);
+    if (!existingIds.includes(base)) return base;
+    let n = 2;
+    while (existingIds.includes(`${base}-${n}`)) n++;
+    return `${base}-${n}`;
+  }
+};
+
+// src/workflow/phase-engine.ts
+import fs21 from "fs/promises";
+import path23 from "path";
+var PhaseEngine = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  cwd;
+  phaseDir(phaseId) {
+    return path23.join(this.cwd, ".brainforge", "phases", phaseId);
+  }
+  async ensurePhaseDir(phaseId) {
+    await fs21.mkdir(this.phaseDir(phaseId), { recursive: true });
+  }
+  async writeStatus(phaseId, step) {
+    await this.ensurePhaseDir(phaseId);
+    const status = { phaseId, step, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await fs21.writeFile(
+      path23.join(this.phaseDir(phaseId), "STATUS.json"),
+      JSON.stringify(status, null, 2),
+      "utf-8"
+    );
+  }
+  async readStatus(phaseId) {
+    try {
+      const raw = await fs21.readFile(path23.join(this.phaseDir(phaseId), "STATUS.json"), "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async writeArtifact(phaseId, filename, content) {
+    await this.ensurePhaseDir(phaseId);
+    const filePath = path23.join(this.phaseDir(phaseId), filename);
+    await fs21.writeFile(filePath, content, "utf-8");
+    return filePath;
+  }
+  async readArtifact(phaseId, filename) {
+    try {
+      return await fs21.readFile(path23.join(this.phaseDir(phaseId), filename), "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  async listArtifacts(phaseId) {
+    try {
+      const entries = await fs21.readdir(this.phaseDir(phaseId));
+      return entries;
+    } catch {
+      return [];
+    }
+  }
+  relPath(phaseId, filename) {
+    return path23.relative(
+      this.cwd,
+      path23.join(this.phaseDir(phaseId), filename)
+    ).replace(/\\/g, "/");
+  }
+};
+
+// src/workflow/execution-engine.ts
+var ExecutionEngine = class {
+  buildTaskPrompt(phase, task, ctx) {
+    const stackLine = ctx.stack ? `${ctx.stack.language}${ctx.stack.framework ? " / " + ctx.stack.framework : ""}${ctx.stack.runtime ? " on " + ctx.stack.runtime : ""}` : "not detected";
+    const lines = [
+      `# Task: ${task.title}`,
+      `> Project: ${ctx.projectName}  |  Phase: ${phase.name}`,
+      `> Stack: ${stackLine}`,
+      "",
+      "## What to implement",
+      task.description ?? task.title,
+      ""
+    ];
+    if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
+      lines.push("## Acceptance criteria");
+      for (const c of task.acceptanceCriteria) {
+        lines.push(`- [ ] ${c}`);
+      }
+      lines.push("");
+    }
+    if (task.verificationCommands && task.verificationCommands.length > 0) {
+      lines.push("## Verification commands");
+      for (const cmd of task.verificationCommands) {
+        lines.push(`\`\`\`bash
+${cmd}
+\`\`\``);
+      }
+      lines.push("");
+    }
+    if (ctx.conventions) {
+      lines.push("## Code conventions to follow");
+      lines.push(`- Naming: ${ctx.conventions.namingStyle}`);
+      lines.push(`- Module style: ${ctx.conventions.moduleStyle}`);
+      if (ctx.conventions.typescriptStrict) lines.push("- TypeScript strict mode enabled");
+      lines.push("");
+    }
+    lines.push("## Done criteria");
+    lines.push("Mark the task complete when all acceptance criteria pass and tests are green.");
+    lines.push("");
+    lines.push("---");
+    lines.push("*Generated by BrainForge AI \u2014 paste this into your AI tool to implement.*");
+    return {
+      taskId: task.id,
+      taskTitle: task.title,
+      content: lines.join("\n")
+    };
+  }
+  buildPhasePrompt(phase, ctx) {
+    const stackLine = ctx.stack ? `${ctx.stack.language}${ctx.stack.framework ? " / " + ctx.stack.framework : ""}` : "not detected";
+    const pendingTasks = phase.tasks.filter((t) => t.status !== "done");
+    const doneTasks = phase.tasks.filter((t) => t.status === "done");
+    const lines = [
+      `# Execute Phase: ${phase.name}`,
+      `> Project: ${ctx.projectName}  |  Stack: ${stackLine}`,
+      `> Progress: ${doneTasks.length}/${phase.tasks.length} tasks done`,
+      ""
+    ];
+    if (ctx.phaseGoal) {
+      lines.push("## Phase goal");
+      lines.push(ctx.phaseGoal);
+      lines.push("");
+    }
+    if (ctx.conventions) {
+      lines.push("## Conventions");
+      lines.push(`- Naming: ${ctx.conventions.namingStyle}  |  Modules: ${ctx.conventions.moduleStyle}`);
+      if (ctx.conventions.typescriptStrict) lines.push("- TypeScript strict mode");
+      if (ctx.conventions.entryPoint) lines.push(`- Entry point: \`${ctx.conventions.entryPoint}\``);
+      lines.push("");
+    }
+    lines.push(`## Tasks to implement (${pendingTasks.length} remaining)`);
+    lines.push("");
+    for (let i = 0; i < pendingTasks.length; i++) {
+      const t = pendingTasks[i];
+      lines.push(`### Task ${i + 1}: ${t.title}`);
+      if (t.description) lines.push(t.description);
+      if (t.acceptanceCriteria?.length) {
+        lines.push("");
+        lines.push("Acceptance criteria:");
+        for (const c of t.acceptanceCriteria) lines.push(`- [ ] ${c}`);
+      }
+      if (t.riskLevel && t.riskLevel !== "low") {
+        lines.push("");
+        lines.push(`> Risk: ${t.riskLevel} \u2014 implement carefully, test thoroughly.`);
+      }
+      lines.push("");
+    }
+    lines.push("## Instructions for your AI tool");
+    lines.push("1. Implement each task in order unless marked as parallelizable.");
+    lines.push("2. After each task, verify its acceptance criteria before proceeding.");
+    lines.push("3. Run tests after every change: failing tests are a hard stop.");
+    lines.push("4. Report completion with: files changed, tests passing, any blockers.");
+    lines.push("");
+    lines.push("---");
+    lines.push("*Generated by BrainForge AI \u2014 paste into your AI tool to execute the phase.*");
+    return lines.join("\n");
+  }
+  buildDryRunSummary(phase) {
+    const pending = phase.tasks.filter((t) => t.status !== "done");
+    const lines = [
+      `[DRY RUN] Phase: ${phase.name}`,
+      `Tasks to execute: ${pending.length}`,
+      ""
+    ];
+    for (const t of pending) {
+      const risk = t.riskLevel ? ` [${t.riskLevel}]` : "";
+      lines.push(`  \u2022 ${t.title}${risk}`);
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/workflow/verification-engine.ts
+var VerificationEngine = class {
+  buildVerifyPrompt(phase, stack) {
+    const tasksWithCriteria = phase.tasks.filter((t) => t.acceptanceCriteria?.length);
+    const allCriteria = [];
+    for (const t of phase.tasks) {
+      for (const c of t.acceptanceCriteria ?? []) {
+        allCriteria.push({ task: t, criterion: c });
+      }
+    }
+    const lines = [
+      `# Verify Phase: ${phase.name}`,
+      "",
+      "## Objective",
+      "Check that every task in this phase is correctly implemented and all acceptance criteria pass.",
+      "",
+      "## Checklist",
+      ""
+    ];
+    if (allCriteria.length > 0) {
+      for (const { task, criterion } of allCriteria) {
+        lines.push(`- [ ] **[${task.title}]** ${criterion}`);
+      }
+    } else {
+      for (const t of phase.tasks) {
+        lines.push(`- [ ] ${t.title} \u2014 implemented and working`);
+      }
+    }
+    lines.push("");
+    lines.push("## Verification commands to run");
+    const cmds = phase.tasks.flatMap((t) => t.verificationCommands ?? []);
+    if (cmds.length > 0) {
+      for (const cmd of [...new Set(cmds)]) {
+        lines.push(`\`\`\`bash
+${cmd}
+\`\`\``);
+      }
+    } else {
+      lines.push("_(No verification commands defined \u2014 run your test suite manually.)_");
+      if (stack?.runtime === "node" || stack?.runtime === "bun") {
+        lines.push("```bash\nnpm test\n```");
+      }
+    }
+    lines.push("");
+    lines.push("## Instructions for your AI tool");
+    lines.push("1. Run all verification commands. Report pass/fail for each.");
+    lines.push('2. For each checklist item, confirm it is truly done \u2014 not just "the code exists".');
+    lines.push("3. List any bugs found using the format below:");
+    lines.push("");
+    lines.push("```");
+    lines.push("BUG: [title]");
+    lines.push("Severity: critical | major | minor");
+    lines.push("Task: [task name]");
+    lines.push("Description: [what is wrong]");
+    lines.push("```");
+    lines.push("");
+    lines.push("4. If there are **critical** bugs, do NOT mark the phase as verified.");
+    lines.push('5. If all criteria pass, confirm with: "PHASE VERIFIED \u2713"');
+    lines.push("");
+    lines.push("---");
+    lines.push("*Generated by BrainForge AI \u2014 paste into your AI tool to verify the phase.*");
+    return lines.join("\n");
+  }
+  buildVerifyMd(phase, bugs = []) {
+    const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
+    const criticalBugs = bugs.filter((b) => b.severity === "critical");
+    const blocked = criticalBugs.length > 0;
+    const lines = [
+      `# Verification Report \u2014 ${phase.name}`,
+      `> Generated: ${now} UTC`,
+      `> Status: ${blocked ? "\u{1F534} BLOCKED" : bugs.length > 0 ? "\u{1F7E1} ISSUES FOUND" : "\u{1F7E2} VERIFIED"}`,
+      "",
+      "## Tasks"
+    ];
+    for (const t of phase.tasks) {
+      const icon = t.status === "done" ? "\u2713" : "\u25CB";
+      lines.push(`- [${icon}] ${t.title}`);
+    }
+    if (bugs.length > 0) {
+      lines.push("", "## Bugs Found");
+      for (const bug of bugs) {
+        lines.push(`### ${bug.id}: ${bug.title}`);
+        lines.push(`**Severity:** ${bug.severity}`);
+        if (bug.taskId) lines.push(`**Task:** ${bug.taskId}`);
+        if (bug.description) lines.push("", bug.description);
+        lines.push("");
+      }
+    }
+    if (!blocked) {
+      lines.push("", "## Next step");
+      lines.push("Run `brg ship` to close this phase and update project memory.");
+    } else {
+      lines.push("", "## Next step");
+      lines.push("Fix critical bugs then re-run `brg verify` before shipping.");
+    }
+    return lines.join("\n");
+  }
+  buildBugsMd(bugs) {
+    if (bugs.length === 0) return "# Bugs\n\nNo bugs found in this phase.";
+    const lines = ["# Bug Report", ""];
+    for (const bug of bugs) {
+      lines.push(`## [${bug.severity.toUpperCase()}] ${bug.title}`);
+      if (bug.taskId) lines.push(`**Related task:** ${bug.taskId}`);
+      if (bug.description) lines.push("", bug.description);
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/workflow/ship-engine.ts
+var ShipEngine = class {
+  build(phase, verifyPassed) {
+    const shippedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const tasksCompleted = phase.tasks.filter((t) => t.status === "done").length;
+    return {
+      phaseId: phase.id,
+      phaseName: phase.name,
+      shippedAt,
+      tasksCompleted,
+      memorySummary: this.buildMemorySummary(phase, shippedAt),
+      changelogEntry: this.buildChangelogEntry(phase, shippedAt)
+    };
+  }
+  buildShipMd(phase, result) {
+    return [
+      `# Ship Report \u2014 ${phase.name}`,
+      `> Shipped: ${result.shippedAt.slice(0, 16).replace("T", " ")} UTC`,
+      "",
+      `## Summary`,
+      `- **Tasks completed:** ${result.tasksCompleted} / ${phase.tasks.length}`,
+      `- **Phase status:** shipped \u2713`,
+      "",
+      "## Completed tasks",
+      ...phase.tasks.map((t) => `- \u2713 ${t.title}`),
+      "",
+      "## Memory entry",
+      "```",
+      result.memorySummary,
+      "```",
+      "",
+      "## Changelog entry",
+      "```markdown",
+      result.changelogEntry,
+      "```",
+      "",
+      "## Next step",
+      "Run `brg progress` to see the overall project status."
+    ].join("\n");
+  }
+  buildMemorySummary(phase, shippedAt) {
+    const taskList = phase.tasks.map((t) => `  - ${t.title}`).join("\n");
+    return [
+      `Phase "${phase.name}" shipped on ${shippedAt.slice(0, 10)}.`,
+      "",
+      `Completed ${phase.tasks.length} tasks:`,
+      taskList
+    ].join("\n");
+  }
+  buildChangelogEntry(phase, shippedAt) {
+    const date = shippedAt.slice(0, 10);
+    const lines = [`## [${date}] \u2014 ${phase.name}`, ""];
+    for (const t of phase.tasks) {
+      lines.push(`- ${t.title}`);
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/workflow/debug-engine.ts
+var DebugEngine = class {
+  build(ctx, phase, stack) {
+    const bugId = `bug-${Date.now().toString(36)}`;
+    const title = ctx.description.slice(0, 80);
+    const hypotheses = this.generateHypotheses(ctx, phase, stack);
+    const filesToInspect = this.inferRelevantFiles(ctx, phase);
+    const diagnosticCommands = this.buildDiagnosticCommands(stack);
+    return {
+      bugId,
+      title,
+      hypotheses,
+      filesToInspect,
+      diagnosticCommands,
+      prompt: this.buildDebugPrompt(bugId, ctx, hypotheses, filesToInspect, diagnosticCommands, stack),
+      fixPlanPrompt: this.buildFixPlanPrompt(bugId, ctx, phase)
+    };
+  }
+  buildDebugsMd(plans) {
+    if (plans.length === 0) return "# Bugs\n\nNo bugs reported.";
+    const lines = ["# Bug Report", ""];
+    for (const plan of plans) {
+      lines.push(`## ${plan.bugId}: ${plan.title}`);
+      lines.push("");
+      lines.push("**Status:** open");
+      lines.push("");
+      if (plan.hypotheses.length > 0) {
+        lines.push("**Hypotheses:**");
+        for (const h of plan.hypotheses) lines.push(`- ${h}`);
+        lines.push("");
+      }
+      if (plan.filesToInspect.length > 0) {
+        lines.push("**Files to inspect:**");
+        for (const f of plan.filesToInspect) lines.push(`- \`${f}\``);
+        lines.push("");
+      }
+    }
+    return lines.join("\n");
+  }
+  buildDebugPrompt(bugId, ctx, hypotheses, files, cmds, stack) {
+    const lines = [
+      `# Debug Session \u2014 ${bugId}`,
+      "",
+      "## Bug description",
+      ctx.description,
+      ""
+    ];
+    if (ctx.errorMessage) {
+      lines.push("## Error message");
+      lines.push("```");
+      lines.push(ctx.errorMessage);
+      lines.push("```");
+      lines.push("");
+    }
+    if (ctx.reproSteps) {
+      lines.push("## Steps to reproduce");
+      lines.push(ctx.reproSteps);
+      lines.push("");
+    }
+    if (ctx.expectedBehavior || ctx.actualBehavior) {
+      lines.push("## Expected vs actual");
+      if (ctx.expectedBehavior) lines.push(`**Expected:** ${ctx.expectedBehavior}`);
+      if (ctx.actualBehavior) lines.push(`**Actual:** ${ctx.actualBehavior}`);
+      lines.push("");
+    }
+    lines.push("## Scientific debugging method");
+    lines.push("");
+    lines.push("Follow these steps in order:");
+    lines.push("");
+    lines.push("**1. Reproduce** \u2014 confirm the bug exists with the steps above");
+    lines.push("**2. Isolate** \u2014 narrow down which code path triggers it");
+    lines.push("**3. Hypothesize** \u2014 form a specific theory about root cause");
+    lines.push("**4. Test** \u2014 write a failing test or add logging to confirm/refute");
+    lines.push("**5. Fix** \u2014 apply the minimal change that fixes the root cause");
+    lines.push("**6. Verify** \u2014 confirm the bug is gone and no regressions introduced");
+    lines.push("");
+    if (hypotheses.length > 0) {
+      lines.push("## Likely root causes (check in order)");
+      for (let i = 0; i < hypotheses.length; i++) {
+        lines.push(`${i + 1}. ${hypotheses[i]}`);
+      }
+      lines.push("");
+    }
+    if (files.length > 0) {
+      lines.push("## Files most likely to be involved");
+      for (const f of files) lines.push(`- \`${f}\``);
+      lines.push("");
+    }
+    if (cmds.length > 0) {
+      lines.push("## Diagnostic commands to run");
+      for (const cmd of cmds) lines.push(`\`\`\`bash
+${cmd}
+\`\`\``);
+      lines.push("");
+    }
+    lines.push("## Output format");
+    lines.push("");
+    lines.push("Report your findings as:");
+    lines.push("```");
+    lines.push("ROOT CAUSE: [one clear sentence]");
+    lines.push("FILE: [path/to/file.ts]");
+    lines.push("LINE: [approximate line number or function name]");
+    lines.push("FIX: [description of minimal fix]");
+    lines.push("REGRESSION TEST: [what test would catch this in the future]");
+    lines.push("```");
+    lines.push("");
+    lines.push("---");
+    lines.push("*BrainForge AI debug session \u2014 paste into your AI tool.*");
+    return lines.join("\n");
+  }
+  buildFixPlanPrompt(bugId, ctx, phase) {
+    return [
+      `# Fix Plan \u2014 ${bugId}`,
+      "",
+      `## Bug`,
+      ctx.description,
+      "",
+      "## Instructions",
+      "",
+      "1. Apply the minimal fix identified in the debug session.",
+      "2. Do NOT refactor surrounding code \u2014 only fix the root cause.",
+      "3. Add a regression test that would have caught this bug.",
+      "4. Run the full test suite after the fix.",
+      "5. Report: file changed, lines modified, test added, suite status.",
+      "",
+      phase ? `## Context: Phase "${phase.name}"` : "",
+      phase ? `Active tasks: ${phase.tasks.filter((t) => t.status !== "done").map((t) => t.title).join(", ")}` : "",
+      "",
+      "---",
+      "*BrainForge AI fix plan \u2014 paste into your AI tool.*"
+    ].filter((l) => l !== null).join("\n");
+  }
+  generateHypotheses(ctx, phase, stack) {
+    const text = (ctx.description + " " + (ctx.errorMessage ?? "")).toLowerCase();
+    const hypotheses = [];
+    if (/undefined|null|cannot read|typeerror/i.test(text)) {
+      hypotheses.push("Null/undefined value not handled \u2014 check for missing guard clauses");
+    }
+    if (/404|not found/i.test(text)) {
+      hypotheses.push("Route or resource not found \u2014 check URL pattern and handler registration");
+    }
+    if (/403|401|unauthorized|forbidden/i.test(text)) {
+      hypotheses.push("Auth/permissions issue \u2014 check token validation or role check logic");
+    }
+    if (/500|internal server/i.test(text)) {
+      hypotheses.push("Unhandled exception on server \u2014 check error middleware and async try/catch");
+    }
+    if (/cors/i.test(text)) {
+      hypotheses.push("CORS policy mismatch \u2014 check allowed origins and preflight handling");
+    }
+    if (/import|module|cannot find/i.test(text)) {
+      hypotheses.push("Import path wrong or module missing \u2014 check tsconfig paths and package.json exports");
+    }
+    if (/async|await|promise|timeout/i.test(text)) {
+      hypotheses.push("Async/await issue \u2014 check for missing await, unhandled promise rejection, or race condition");
+    }
+    if (/database|query|sql|orm/i.test(text)) {
+      hypotheses.push("Database query issue \u2014 check query parameters, missing JOIN, or stale migration");
+    }
+    if (/type|interface|property does not exist/i.test(text)) {
+      hypotheses.push("TypeScript type mismatch \u2014 check interface definition matches actual data shape");
+    }
+    if (hypotheses.length === 0) {
+      hypotheses.push("Check the stack trace for the exact call site");
+      hypotheses.push("Add logging before the failure point to capture state");
+    }
+    return hypotheses.slice(0, 4);
+  }
+  inferRelevantFiles(ctx, phase) {
+    const files = /* @__PURE__ */ new Set();
+    if (phase) {
+      for (const task of phase.tasks) {
+        if (task.files) task.files.forEach((f) => files.add(f));
+      }
+    }
+    const text = ctx.description.toLowerCase();
+    if (/auth|login|session|token/.test(text)) files.add("src/middleware/auth.*");
+    if (/api|route|endpoint/.test(text)) files.add("src/routes/**");
+    if (/database|model|schema/.test(text)) files.add("src/models/**");
+    if (/component|ui|render/.test(text)) files.add("src/components/**");
+    return [...files].slice(0, 6);
+  }
+  buildDiagnosticCommands(stack) {
+    const cmds = [];
+    if (!stack) return ["npm test", "npm run build"];
+    if (stack.runtime === "node" || stack.runtime === "bun") {
+      cmds.push("npm test -- --reporter=verbose");
+      cmds.push("npm run build 2>&1 | head -50");
+    }
+    if (stack.runtime === "python") {
+      cmds.push("python -m pytest -x -v 2>&1 | head -50");
+    }
+    if (stack.runtime === "go") {
+      cmds.push("go test ./... -v 2>&1 | head -50");
+    }
+    return cmds.length > 0 ? cmds : ["npm test"];
+  }
+};
+
+// src/workflow/auto-engine.ts
+var AutoEngine = class {
+  buildPlan(state, opts) {
+    const blockers = [];
+    if (state.phases.length === 0) {
+      return {
+        steps: [],
+        totalPhases: 0,
+        phasesToRun: 0,
+        canRun: false,
+        blockers: ["No phases defined \u2014 run `brg new` or `brg phase create` first"],
+        estimatedPrompts: 0
+      };
+    }
+    let phases = state.phases.filter((p) => p.status !== "completed");
+    if (opts.fromPhaseId) {
+      const fromIdx = phases.findIndex((p) => p.id === opts.fromPhaseId);
+      if (fromIdx === -1) blockers.push(`Phase "${opts.fromPhaseId}" not found`);
+      else phases = phases.slice(fromIdx);
+    }
+    if (opts.toPhaseId) {
+      const toIdx = phases.findIndex((p) => p.id === opts.toPhaseId);
+      if (toIdx === -1) blockers.push(`Phase "${opts.toPhaseId}" not found`);
+      else phases = phases.slice(0, toIdx + 1);
+    }
+    const steps = [];
+    let stepNum = 1;
+    steps.push({
+      step: stepNum++,
+      phaseId: "",
+      phaseName: "(global)",
+      action: "map",
+      description: "Scan codebase and generate architecture map",
+      blocked: false
+    });
+    for (const phase of phases) {
+      const pendingTasks = phase.tasks.filter((t) => t.status !== "done");
+      const hasTasks = phase.tasks.length > 0;
+      steps.push({
+        step: stepNum++,
+        phaseId: phase.id,
+        phaseName: phase.name,
+        action: "execute",
+        description: `Execute ${pendingTasks.length} task(s) in "${phase.name}"`,
+        blocked: !hasTasks,
+        blockReason: !hasTasks ? "No tasks defined \u2014 run `brg plan` first" : void 0
+      });
+      if (opts.gates.verifyEachPhase) {
+        steps.push({
+          step: stepNum++,
+          phaseId: phase.id,
+          phaseName: phase.name,
+          action: "verify",
+          description: `Verify "${phase.name}" \u2014 check acceptance criteria`,
+          blocked: false
+        });
+      }
+      if (opts.gates.shipEachPhase) {
+        steps.push({
+          step: stepNum++,
+          phaseId: phase.id,
+          phaseName: phase.name,
+          action: "ship",
+          description: `Ship "${phase.name}" \u2014 close phase and update memory`,
+          blocked: false
+        });
+      }
+    }
+    const canRun = blockers.length === 0 && steps.some((s) => !s.blocked);
+    const estimatedPrompts = steps.filter((s) => s.action === "execute").length;
+    return {
+      steps,
+      totalPhases: state.phases.length,
+      phasesToRun: phases.length,
+      canRun,
+      blockers,
+      estimatedPrompts
+    };
+  }
+  buildDryRunOutput(plan) {
+    const lines = [
+      "# Auto Pipeline \u2014 Dry Run",
+      "",
+      `Phases to run: ${plan.phasesToRun}  |  Steps: ${plan.steps.length}  |  Execution prompts: ${plan.estimatedPrompts}`,
+      ""
+    ];
+    if (!plan.canRun) {
+      lines.push("## Blockers (fix before running)");
+      for (const b of plan.blockers) lines.push(`  \u2717 ${b}`);
+      lines.push("");
+    }
+    lines.push("## Steps");
+    lines.push("");
+    for (const step of plan.steps) {
+      const status = step.blocked ? "\u26A0 BLOCKED" : "\u25CB";
+      const phaseLabel = step.phaseId ? ` [${step.phaseName}]` : "";
+      lines.push(`  ${step.step}. ${status}  ${step.action.toUpperCase()}${phaseLabel}`);
+      lines.push(`     ${step.description}`);
+      if (step.blockReason) lines.push(`     \u21B3 ${step.blockReason}`);
+    }
+    lines.push("");
+    lines.push("Remove --dry-run to execute the pipeline.");
+    return lines.join("\n");
+  }
+  buildAutoSummaryPrompt(plan, state) {
+    const executeSteps = plan.steps.filter((s) => s.action === "execute" && !s.blocked);
+    const lines = [
+      "# Auto Pipeline \u2014 Full Execution",
+      "",
+      `This will execute ${executeSteps.length} phase(s) sequentially.`,
+      "",
+      "## Execution order",
+      ""
+    ];
+    let phaseNum = 1;
+    for (const phase of state.phases.filter((p) => p.status !== "completed")) {
+      const tasks = phase.tasks.filter((t) => t.status !== "done");
+      lines.push(`### Phase ${phaseNum++}: ${phase.name}`);
+      lines.push(`${tasks.length} task(s) to execute:`);
+      for (const t of tasks) lines.push(`- ${t.title}`);
+      lines.push("");
+    }
+    lines.push("## Safety gates");
+    lines.push("- Stop on any critical bug in verify step");
+    lines.push("- Do not ship a phase that fails verification");
+    lines.push("- Report all bugs in BUGS.md before proceeding");
+    lines.push("");
+    lines.push("---");
+    lines.push("*BrainForge AI auto pipeline \u2014 execute phases in order.*");
+    return lines.join("\n");
+  }
+};
+
+// src/scanner/codebase-map.ts
+import fs26 from "fs/promises";
+import path29 from "path";
+
+// src/scanner/stack-detector.ts
+import fs22 from "fs/promises";
+import path24 from "path";
+var FRAMEWORK_MARKERS = {
+  "next": ["next"],
+  "nuxt": ["nuxt"],
+  "remix": ["@remix-run/react", "@remix-run/node"],
+  "sveltekit": ["@sveltejs/kit"],
+  "react": ["react"],
+  "vue": ["vue"],
+  "svelte": ["svelte"],
+  "angular": ["@angular/core"],
+  "solid": ["solid-js"],
+  "astro": ["astro"],
+  "express": ["express"],
+  "fastify": ["fastify"],
+  "hono": ["hono"],
+  "nestjs": ["@nestjs/core"],
+  "koa": ["koa"],
+  "elysia": ["elysia"],
+  "django": ["django"],
+  "fastapi": ["fastapi"],
+  "flask": ["flask"],
+  "gin": ["gin-gonic/gin"],
+  "fiber": ["gofiber/fiber"],
+  "actix-web": ["actix-web"],
+  "axum": ["axum"],
+  "laravel": ["laravel/framework"],
+  "spring": ["spring-boot"]
+};
+var BUILD_TOOL_FILES = [
+  ["vite.config.ts", "vite"],
+  ["vite.config.js", "vite"],
+  ["webpack.config.js", "webpack"],
+  ["webpack.config.ts", "webpack"],
+  ["rollup.config.js", "rollup"],
+  ["rollup.config.ts", "rollup"],
+  ["esbuild.config.js", "esbuild"],
+  ["tsup.config.ts", "tsup"],
+  ["tsup.config.js", "tsup"],
+  ["turbo.json", "turborepo"],
+  ["nx.json", "nx"]
+];
+var LINTER_MARKERS = {
+  eslint: ["eslint", "@eslint/js"],
+  biome: ["@biomejs/biome"],
+  oxc: ["oxc-parser"],
+  tslint: ["tslint"],
+  ruff: ["ruff"],
+  flake8: ["flake8"]
+};
+var FORMATTER_MARKERS = {
+  prettier: ["prettier"],
+  biome: ["@biomejs/biome"],
+  black: ["black"]
+};
+var CSS_MARKERS = {
+  tailwindcss: ["tailwindcss"],
+  bootstrap: ["bootstrap"],
+  "mui": ["@mui/material"],
+  "chakra-ui": ["@chakra-ui/react"],
+  "shadcn/ui": ["class-variance-authority", "clsx", "tailwind-merge"],
+  "styled-components": ["styled-components"]
+};
+async function detectStack(cwd) {
+  const allDeps = {};
+  let hasTypeScript = false;
+  let hasPython = false;
+  let hasGo = false;
+  let hasRust = false;
+  let hasJava = false;
+  let hasPHP = false;
+  let hasRuby = false;
+  let runtime;
+  try {
+    const raw = await fs22.readFile(path24.join(cwd, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    Object.assign(allDeps, pkg.dependencies ?? {}, pkg.devDependencies ?? {});
+    if (pkg.engines?.["bun"]) runtime = "bun";
+    else if (pkg.engines?.["deno"]) runtime = "deno";
+  } catch {
+  }
+  const [hasTs, hasPy, hasGoMod, hasCargo, hasPom, hasComposer, hasGemfile] = await Promise.all([
+    fileExists4(cwd, "tsconfig.json"),
+    fileExists4(cwd, "pyproject.toml") || fileExists4(cwd, "requirements.txt") || fileExists4(cwd, "setup.py"),
+    fileExists4(cwd, "go.mod"),
+    fileExists4(cwd, "Cargo.toml"),
+    fileExists4(cwd, "pom.xml"),
+    fileExists4(cwd, "composer.json"),
+    fileExists4(cwd, "Gemfile")
+  ]);
+  if (hasTs || "typescript" in allDeps || "@types/node" in allDeps) hasTypeScript = true;
+  if (hasPy) hasPython = true;
+  if (hasGoMod) hasGo = true;
+  if (hasCargo) hasRust = true;
+  if (hasPom) hasJava = true;
+  if (hasComposer) hasPHP = true;
+  if (hasGemfile) hasRuby = true;
+  let language = "javascript";
+  if (hasTypeScript) language = "typescript";
+  else if (hasPython) language = "python";
+  else if (hasGo) language = "go";
+  else if (hasRust) language = "rust";
+  else if (hasJava) language = "java";
+  else if (hasPHP) language = "php";
+  else if (hasRuby) language = "ruby";
+  const secondaryLanguages = [];
+  if (language !== "typescript" && hasTypeScript) secondaryLanguages.push("typescript");
+  if (language !== "python" && hasPython) secondaryLanguages.push("python");
+  let framework;
+  for (const [name, markers] of Object.entries(FRAMEWORK_MARKERS)) {
+    if (markers.some((m) => m in allDeps)) {
+      framework = name;
+      break;
+    }
+  }
+  if (!runtime) {
+    const [isBun, isDeno] = await Promise.all([
+      fileExists4(cwd, "bun.lockb") || fileExists4(cwd, "bun.lock"),
+      fileExists4(cwd, "deno.json") || fileExists4(cwd, "deno.jsonc")
+    ]);
+    if (isBun) runtime = "bun";
+    else if (isDeno) runtime = "deno";
+    else if (Object.keys(allDeps).length > 0 || hasTypeScript) runtime = "node";
+    else if (hasPython) runtime = "python";
+    else if (hasGo) runtime = "go";
+    else if (hasRust) runtime = "rust";
+    else if (hasJava) runtime = "jvm";
+  }
+  let buildTool;
+  for (const [file, tool] of BUILD_TOOL_FILES) {
+    if (await fileExists4(cwd, file)) {
+      buildTool = tool;
+      break;
+    }
+  }
+  if (!buildTool) {
+    for (const tool of ["tsup", "tsc", "vite", "webpack", "rollup", "esbuild"]) {
+      if (tool in allDeps) {
+        buildTool = tool;
+        break;
+      }
+    }
+  }
+  let linter;
+  for (const [name, markers] of Object.entries(LINTER_MARKERS)) {
+    if (markers.some((m) => m in allDeps)) {
+      linter = name;
+      break;
+    }
+  }
+  let formatter;
+  for (const [name, markers] of Object.entries(FORMATTER_MARKERS)) {
+    if (name !== linter && markers.some((m) => m in allDeps)) {
+      formatter = name;
+      break;
+    }
+  }
+  if (linter === "biome") formatter = "biome";
+  let cssFramework;
+  for (const [name, markers] of Object.entries(CSS_MARKERS)) {
+    if (markers.every((m) => m in allDeps)) {
+      cssFramework = name;
+      break;
+    }
+    if (markers.some((m) => m in allDeps)) {
+      cssFramework = name;
+      break;
+    }
+  }
+  let packageManager;
+  const [hasPnpmLock, hasYarnLock, hasBunLock] = await Promise.all([
+    fileExists4(cwd, "pnpm-lock.yaml"),
+    fileExists4(cwd, "yarn.lock"),
+    fileExists4(cwd, "bun.lockb") || fileExists4(cwd, "bun.lock")
+  ]);
+  if (hasPnpmLock) packageManager = "pnpm";
+  else if (hasYarnLock) packageManager = "yarn";
+  else if (hasBunLock) packageManager = "bun";
+  else if (await fileExists4(cwd, "package-lock.json")) packageManager = "npm";
+  return {
+    language,
+    secondaryLanguages,
+    framework,
+    runtime,
+    buildTool,
+    linter,
+    formatter,
+    packageManager,
+    cssFramework
+  };
+}
+async function fileExists4(cwd, ...parts) {
+  try {
+    await fs22.access(path24.join(cwd, ...parts));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/scanner/dependency-analyzer.ts
+import fs23 from "fs/promises";
+import path25 from "path";
+async function analyzeDependencies(cwd) {
+  const handlers = [
+    () => parseNodePackage(cwd),
+    () => parsePythonRequirements(cwd),
+    () => parseGoMod(cwd),
+    () => parseCargoToml(cwd),
+    () => parseComposerJson(cwd)
+  ];
+  for (const handler of handlers) {
+    const result = await handler();
+    if (result) return result;
+  }
+  return { runtime: [], dev: [], total: 0, manifestType: "unknown", highlights: [] };
+}
+async function parseNodePackage(cwd) {
+  try {
+    const raw = await fs23.readFile(path25.join(cwd, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    const runtime = Object.entries(pkg.dependencies ?? {}).map(([name, version]) => ({
+      name,
+      version,
+      dev: false
+    }));
+    const dev = Object.entries(pkg.devDependencies ?? {}).map(([name, version]) => ({
+      name,
+      version,
+      dev: true
+    }));
+    return {
+      runtime,
+      dev,
+      total: runtime.length + dev.length,
+      manifestType: "package.json",
+      highlights: pickHighlights([...runtime, ...dev])
+    };
+  } catch {
+    return null;
+  }
+}
+async function parsePythonRequirements(cwd) {
+  try {
+    const raw = await fs23.readFile(path25.join(cwd, "pyproject.toml"), "utf-8");
+    const deps = [];
+    const depSection = raw.match(/\[project\][\s\S]*?dependencies\s*=\s*\[([\s\S]*?)\]/);
+    if (depSection?.[1]) {
+      for (const line of depSection[1].split("\n")) {
+        const clean = line.replace(/["',]/g, "").trim();
+        if (clean && !clean.startsWith("#")) {
+          const m = clean.match(/^([a-zA-Z0-9_.-]+)(.*)$/);
+          if (m) deps.push({ name: m[1], version: m[2].trim() || "*", dev: false });
+        }
+      }
+    }
+    if (deps.length > 0) {
+      return { runtime: deps, dev: [], total: deps.length, manifestType: "pyproject.toml", highlights: pickHighlights(deps) };
+    }
+  } catch {
+  }
+  try {
+    const raw = await fs23.readFile(path25.join(cwd, "requirements.txt"), "utf-8");
+    const deps = raw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#") && !l.startsWith("-")).map((l) => {
+      const m = l.match(/^([a-zA-Z0-9_.-]+)([>=<!].+)?$/);
+      return m ? { name: m[1], version: m[2] ?? "*", dev: false } : null;
+    }).filter((d) => d !== null);
+    if (deps.length > 0) {
+      return { runtime: deps, dev: [], total: deps.length, manifestType: "requirements.txt", highlights: pickHighlights(deps) };
+    }
+  } catch {
+  }
+  return null;
+}
+async function parseGoMod(cwd) {
+  try {
+    const raw = await fs23.readFile(path25.join(cwd, "go.mod"), "utf-8");
+    const deps = [];
+    for (const line of raw.split("\n")) {
+      const m = line.trim().match(/^([a-zA-Z0-9_./-]+)\s+(v[\d.]+.*)$/);
+      if (m) deps.push({ name: m[1], version: m[2], dev: false });
+    }
+    return { runtime: deps, dev: [], total: deps.length, manifestType: "go.mod", highlights: pickHighlights(deps) };
+  } catch {
+    return null;
+  }
+}
+async function parseCargoToml(cwd) {
+  try {
+    const raw = await fs23.readFile(path25.join(cwd, "Cargo.toml"), "utf-8");
+    const deps = [];
+    let inDeps = false;
+    let inDevDeps = false;
+    for (const line of raw.split("\n")) {
+      if (line.trim() === "[dependencies]") {
+        inDeps = true;
+        inDevDeps = false;
+        continue;
+      }
+      if (line.trim() === "[dev-dependencies]") {
+        inDevDeps = true;
+        inDeps = false;
+        continue;
+      }
+      if (line.startsWith("[") && line.trim() !== "[dependencies]" && line.trim() !== "[dev-dependencies]") {
+        inDeps = false;
+        inDevDeps = false;
+      }
+      if ((inDeps || inDevDeps) && line.includes("=")) {
+        const m = line.match(/^([a-zA-Z0-9_-]+)\s*=\s*"([^"]+)"/);
+        if (m) deps.push({ name: m[1], version: m[2], dev: inDevDeps });
+      }
+    }
+    return { runtime: deps.filter((d) => !d.dev), dev: deps.filter((d) => d.dev), total: deps.length, manifestType: "Cargo.toml", highlights: pickHighlights(deps) };
+  } catch {
+    return null;
+  }
+}
+async function parseComposerJson(cwd) {
+  try {
+    const raw = await fs23.readFile(path25.join(cwd, "composer.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    const runtime = Object.entries(pkg.require ?? {}).filter(([name]) => name !== "php").map(([name, version]) => ({ name, version, dev: false }));
+    const dev = Object.entries(pkg["require-dev"] ?? {}).map(([name, version]) => ({
+      name,
+      version,
+      dev: true
+    }));
+    return { runtime, dev, total: runtime.length + dev.length, manifestType: "composer.json", highlights: pickHighlights([...runtime, ...dev]) };
+  } catch {
+    return null;
+  }
+}
+var NOTABLE_DEPS = /* @__PURE__ */ new Set([
+  "react",
+  "vue",
+  "next",
+  "nuxt",
+  "svelte",
+  "astro",
+  "angular",
+  "express",
+  "fastify",
+  "hono",
+  "nestjs",
+  "koa",
+  "prisma",
+  "drizzle-orm",
+  "typeorm",
+  "mongoose",
+  "typescript",
+  "vite",
+  "webpack",
+  "esbuild",
+  "tsup",
+  "vitest",
+  "jest",
+  "mocha",
+  "playwright",
+  "cypress",
+  "tailwindcss",
+  "styled-components",
+  "zod",
+  "trpc",
+  "@trpc/server",
+  "fastapi",
+  "django",
+  "flask",
+  "sqlalchemy",
+  "gin",
+  "fiber",
+  "gorm",
+  "axum",
+  "actix-web",
+  "tokio"
+]);
+function pickHighlights(deps) {
+  return deps.filter((d) => NOTABLE_DEPS.has(d.name.toLowerCase())).map((d) => `${d.name}@${d.version}`).slice(0, 8);
+}
+
+// src/scanner/convention-detector.ts
+import fs24 from "fs/promises";
+import path26 from "path";
+async function detectConventions(cwd, files) {
+  const srcFiles = files.filter((f) => /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(f));
+  const namingStyle = detectNamingStyle(srcFiles);
+  const folderPattern = detectFolderPattern(files);
+  const moduleStyle = await detectModuleStyle(cwd);
+  const typescriptStrict = await detectTsStrict(cwd);
+  const entryPoint = detectEntryPoint(files);
+  const [hasEditorConfig, hasHusky, hasLintStaged] = await Promise.all([
+    fileExists5(cwd, ".editorconfig"),
+    fileExists5(cwd, ".husky"),
+    fileExists5(cwd, ".lintstagedrc") || fileExists5(cwd, ".lintstagedrc.json") || fileExists5(cwd, ".lintstagedrc.js")
+  ]);
+  return {
+    namingStyle,
+    folderPattern,
+    moduleStyle,
+    typescriptStrict,
+    hasEditorConfig,
+    hasHusky,
+    hasLintStaged,
+    entryPoint
+  };
+}
+function detectNamingStyle(files) {
+  const basenames = files.map((f) => path26.basename(f, path26.extname(f))).filter((b) => b.length > 2 && !/^index$|^main$|^app$/.test(b));
+  const counts = { camel: 0, snake: 0, kebab: 0, pascal: 0 };
+  for (const b of basenames) {
+    if (/^[A-Z][a-zA-Z0-9]*$/.test(b)) counts.pascal++;
+    else if (/^[a-z][a-zA-Z0-9]*$/.test(b) && /[A-Z]/.test(b)) counts.camel++;
+    else if (b.includes("_")) counts.snake++;
+    else if (b.includes("-")) counts.kebab++;
+  }
+  const max = Math.max(...Object.values(counts));
+  if (max === 0) return "mixed";
+  if (counts.pascal === max) return "PascalCase";
+  if (counts.camel === max) return "camelCase";
+  if (counts.snake === max) return "snake_case";
+  if (counts.kebab === max) return "kebab-case";
+  return "mixed";
+}
+function detectFolderPattern(files) {
+  const topDirs = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    const parts = f.replace(/\\/g, "/").split("/");
+    if (parts.length > 1) topDirs.add(parts[0]);
+  }
+  const patterns = {
+    "monorepo": ["packages", "apps", "libs"],
+    "src-based": ["src"],
+    "app-based": ["app"],
+    "flat": []
+  };
+  for (const [name, markers] of Object.entries(patterns)) {
+    if (markers.some((m) => topDirs.has(m))) return name;
+  }
+  return "flat";
+}
+async function detectModuleStyle(cwd) {
+  try {
+    const raw = await fs24.readFile(path26.join(cwd, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    if (pkg.type === "module") return "esm";
+    if (pkg.type === "commonjs") return "cjs";
+    return "mixed";
+  } catch {
+    return "unknown";
+  }
+}
+async function detectTsStrict(cwd) {
+  try {
+    const raw = await fs24.readFile(path26.join(cwd, "tsconfig.json"), "utf-8");
+    const stripped = raw.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    const tsconfig = JSON.parse(stripped);
+    return tsconfig.compilerOptions?.strict === true;
+  } catch {
+    return false;
+  }
+}
+function detectEntryPoint(files) {
+  const candidates = [
+    "src/index.ts",
+    "src/index.js",
+    "src/main.ts",
+    "src/main.js",
+    "src/app.ts",
+    "src/app.js",
+    "index.ts",
+    "index.js",
+    "main.ts",
+    "main.js",
+    "app.ts",
+    "app.js",
+    "src/App.tsx",
+    "src/App.jsx"
+  ];
+  return candidates.find((c) => files.some((f) => f.replace(/\\/g, "/").endsWith(c)));
+}
+async function fileExists5(cwd, ...parts) {
+  try {
+    await fs24.access(path26.join(cwd, ...parts));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/scanner/risk-detector.ts
+import fs25 from "fs/promises";
+import path27 from "path";
+var LARGE_FILE_THRESHOLD = 500;
+var HUGE_FILE_THRESHOLD = 1e3;
+var SECRET_PATTERNS = [
+  /\.env(\.|$)/i,
+  /secrets?\.(json|yaml|yml|toml)$/i,
+  /credentials?\.(json|yaml|yml)$/i,
+  /private[\w-]*\.(pem|key|p12)$/i,
+  /\.pfx$/i
+];
+var INLINE_SECRET_PATTERNS = [
+  /(?:api_key|apikey|secret|password|passwd|token)\s*[:=]\s*['"][^'"]{8,}/i,
+  /(?:sk-|pk_live_|pk_test_|ghp_|ghs_|xoxb-|xoxp-)/
+];
+var TODO_PATTERN = /\b(TODO|FIXME|HACK|XXX|TEMP|BUG)\b/g;
+async function detectRisks(cwd, files, fileContents) {
+  const items = [];
+  for (const [filePath, content] of fileContents) {
+    const lineCount = content.split("\n").length;
+    if (lineCount > HUGE_FILE_THRESHOLD) {
+      items.push({
+        level: "high",
+        category: "maintainability",
+        message: `File has ${lineCount} lines (>${HUGE_FILE_THRESHOLD} threshold)`,
+        file: filePath
+      });
+    } else if (lineCount > LARGE_FILE_THRESHOLD) {
+      items.push({
+        level: "medium",
+        category: "maintainability",
+        message: `File has ${lineCount} lines (>${LARGE_FILE_THRESHOLD} threshold)`,
+        file: filePath
+      });
+    }
+  }
+  for (const f of files) {
+    const basename = path27.basename(f);
+    if (SECRET_PATTERNS.some((p) => p.test(basename)) && !basename.endsWith(".example")) {
+      items.push({
+        level: "high",
+        category: "security",
+        message: `Potential secrets file committed: ${basename}`,
+        file: f
+      });
+    }
+  }
+  const sourceFiles = [...fileContents.entries()].filter(
+    ([f]) => /\.(ts|tsx|js|jsx|py|go|rs|php|rb)$/.test(f)
+  );
+  for (const [filePath, content] of sourceFiles) {
+    if (content.split("\n").length > 300) continue;
+    for (const pattern of INLINE_SECRET_PATTERNS) {
+      if (pattern.test(content)) {
+        items.push({
+          level: "high",
+          category: "security",
+          message: "Potential hardcoded secret or API key",
+          file: filePath
+        });
+        break;
+      }
+    }
+  }
+  let todoCount = 0;
+  for (const [, content] of fileContents) {
+    const matches = content.match(TODO_PATTERN);
+    if (matches) todoCount += matches.length;
+  }
+  if (todoCount > 20) {
+    items.push({ level: "medium", category: "quality", message: `${todoCount} TODO/FIXME/HACK comments found` });
+  } else if (todoCount > 5) {
+    items.push({ level: "low", category: "quality", message: `${todoCount} TODO/FIXME/HACK comments found` });
+  }
+  if (!files.some((f) => path27.basename(f) === ".gitignore")) {
+    items.push({ level: "medium", category: "hygiene", message: "No .gitignore found" });
+  }
+  const hasTestFiles = files.some(
+    (f) => /\.(test|spec)\.(ts|tsx|js|jsx|py|go|rs)$/.test(f) || f.replace(/\\/g, "/").includes("/__tests__/") || f.replace(/\\/g, "/").includes("/tests/")
+  );
+  if (!hasTestFiles) {
+    items.push({ level: "high", category: "quality", message: "No test files detected" });
+  }
+  if (!files.some((f) => /^readme\.md$/i.test(path27.basename(f)))) {
+    items.push({ level: "low", category: "documentation", message: "No README.md found" });
+  }
+  const hasPackageJson = files.some((f) => path27.basename(f) === "package.json");
+  const hasLockFile = files.some(
+    (f) => ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb", "bun.lock"].includes(path27.basename(f))
+  );
+  if (hasPackageJson && !hasLockFile) {
+    items.push({ level: "medium", category: "hygiene", message: "Node project has no lock file committed" });
+  }
+  const prodFiles = [...fileContents.entries()].filter(
+    ([f]) => /\.(ts|tsx|js|jsx)$/.test(f) && !/\.(test|spec)\.(ts|tsx|js|jsx)$/.test(f) && !f.includes("__tests__")
+  );
+  let consoleLogs = 0;
+  for (const [, content] of prodFiles) {
+    const matches = content.match(/\bconsole\.(log|warn|error|debug)\b/g);
+    if (matches) consoleLogs += matches.length;
+  }
+  if (consoleLogs > 10) {
+    items.push({ level: "low", category: "quality", message: `${consoleLogs} console.log statements in production code` });
+  }
+  const summary = {
+    high: items.filter((i) => i.level === "high").length,
+    medium: items.filter((i) => i.level === "medium").length,
+    low: items.filter((i) => i.level === "low").length
+  };
+  return { items, summary };
+}
+async function loadFileContents(cwd, files, maxLines = 1500) {
+  const map = /* @__PURE__ */ new Map();
+  const readable = files.filter(
+    (f) => /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|php|rb|json|yaml|yml|toml|md|env)$/.test(f) && !f.includes("node_modules") && !f.includes(".brainforge") && !f.includes("dist/") && !f.includes(".git/")
+  );
+  await Promise.all(
+    readable.map(async (rel) => {
+      try {
+        const abs = path27.join(cwd, rel);
+        const raw = await fs25.readFile(abs, "utf-8");
+        const lines = raw.split("\n");
+        map.set(rel, lines.slice(0, maxLines).join("\n"));
+      } catch {
+      }
+    })
+  );
+  return map;
+}
+
+// src/scanner/test-detector.ts
+import path28 from "path";
+var TEST_FRAMEWORK_MARKERS = {
+  vitest: ["vitest"],
+  jest: ["jest", "@jest/core"],
+  mocha: ["mocha"],
+  jasmine: ["jasmine"],
+  ava: ["ava"],
+  tap: ["tap", "node:test"],
+  playwright: ["@playwright/test"],
+  cypress: ["cypress"],
+  pytest: ["pytest"],
+  unittest: ["unittest"],
+  gotest: ["testing"],
+  cargo: ["#[cfg(test)]", "#[test]"]
+};
+var TEST_CONFIG_FILES = [
+  "vitest.config.ts",
+  "vitest.config.js",
+  "jest.config.ts",
+  "jest.config.js",
+  "jest.config.mjs",
+  "mocha.opts",
+  ".mocharc.yml",
+  ".mocharc.json",
+  ".mocharc.js",
+  "playwright.config.ts",
+  "playwright.config.js",
+  "cypress.config.ts",
+  "cypress.config.js",
+  "pytest.ini",
+  "setup.cfg",
+  "pyproject.toml"
+];
+var TEST_FILE_PATTERNS = [
+  /\.(test|spec)\.(ts|tsx|js|jsx|mjs)$/,
+  /\.test\.(go)$/,
+  /\.spec\.(rb)$/,
+  /_test\.(go|rs|py)$/,
+  /test_.*\.(py)$/
+];
+var SOURCE_FILE_PATTERNS = [
+  /\.(ts|tsx|js|jsx|mjs)$/,
+  /\.(py)$/,
+  /\.(go)$/,
+  /\.(rs)$/,
+  /\.(rb)$/
+];
+var SOURCE_EXCLUDES = /\.(test|spec)\.(ts|tsx|js|jsx|mjs)$|__tests__|node_modules|dist\/|\.brainforge/;
+function detectTests(files, deps, scripts) {
+  let framework;
+  for (const [name, markers] of Object.entries(TEST_FRAMEWORK_MARKERS)) {
+    if (markers.some((m) => m in deps)) {
+      framework = name;
+      break;
+    }
+  }
+  const testFiles = files.filter(
+    (f) => TEST_FILE_PATTERNS.some((p) => p.test(f)) || f.replace(/\\/g, "/").includes("/__tests__/") || f.replace(/\\/g, "/").includes("/tests/") || /\/test\//.test(f.replace(/\\/g, "/"))
+  );
+  const sourceFiles = files.filter(
+    (f) => SOURCE_FILE_PATTERNS.some((p) => p.test(f)) && !SOURCE_EXCLUDES.test(f)
+  );
+  const coverageRatio = sourceFiles.length > 0 ? testFiles.length / sourceFiles.length : 0;
+  const hasConfig = files.some(
+    (f) => TEST_CONFIG_FILES.some((c) => path28.basename(f) === c)
+  );
+  const coverageEnabled = "c8" in deps || "@vitest/coverage-v8" in deps || "@vitest/coverage-istanbul" in deps || Boolean(scripts?.["coverage"]) || Boolean(scripts?.["test:coverage"]);
+  const testCommand = scripts?.["test"] ?? scripts?.["test:unit"];
+  return {
+    framework,
+    testFiles,
+    testCount: testFiles.length,
+    sourceFileCount: sourceFiles.length,
+    coverageRatio,
+    hasConfig,
+    coverageEnabled,
+    testCommand
+  };
+}
+
+// src/scanner/codebase-map.ts
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".cache",
+  "coverage",
+  ".brainforge",
+  "__pycache__",
+  ".pytest_cache",
+  "target",
+  ".cargo",
+  "vendor",
+  ".venv",
+  "venv",
+  "env"
+]);
+var IGNORE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".ico",
+  ".webp",
+  ".avif",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".mp4",
+  ".mp3",
+  ".wav",
+  ".ogg",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".7z",
+  ".lock",
+  // skip lockfiles for content
+  ".map"
+  // skip sourcemaps
+]);
+var CodebaseScanner = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+    this.codebaseDir = path29.join(cwd, ".brainforge", "codebase");
+  }
+  cwd;
+  codebaseDir;
+  async scan(deep = false) {
+    const files = await this.walkFiles(this.cwd, deep ? 8 : 5);
+    const relFiles = files.map((f) => path29.relative(this.cwd, f).replace(/\\/g, "/"));
+    const fileContents = await loadFileContents(this.cwd, relFiles);
+    const [stack, dependencies, conventions, risks] = await Promise.all([
+      detectStack(this.cwd),
+      analyzeDependencies(this.cwd),
+      detectConventions(this.cwd, relFiles),
+      detectRisks(this.cwd, relFiles, fileContents)
+    ]);
+    let scripts;
+    try {
+      const raw = await fs26.readFile(path29.join(this.cwd, "package.json"), "utf-8");
+      scripts = JSON.parse(raw).scripts;
+    } catch {
+    }
+    const allDeps = {};
+    for (const d of [...dependencies.runtime, ...dependencies.dev]) {
+      allDeps[d.name] = d.version;
+    }
+    const tests = detectTests(relFiles, allDeps, scripts);
+    const fileEntries = await this.buildFileInventory(files, relFiles, fileContents);
+    const projectName = await this.readProjectName();
+    return {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectName,
+      stack,
+      dependencies,
+      conventions,
+      risks,
+      tests,
+      files: fileEntries,
+      totalFiles: fileEntries.length,
+      totalLines: fileEntries.reduce((n, f) => n + f.lines, 0)
+    };
+  }
+  async save(result) {
+    await fs26.mkdir(this.codebaseDir, { recursive: true });
+    await Promise.all([
+      fs26.writeFile(path29.join(this.codebaseDir, "STACK.json"), JSON.stringify(result.stack, null, 2), "utf-8"),
+      fs26.writeFile(path29.join(this.codebaseDir, "FILES.json"), JSON.stringify(result.files, null, 2), "utf-8"),
+      fs26.writeFile(path29.join(this.codebaseDir, "MAP.md"), this.toMapMd(result), "utf-8"),
+      fs26.writeFile(path29.join(this.codebaseDir, "CONVENTIONS.md"), this.toConventionsMd(result), "utf-8"),
+      fs26.writeFile(path29.join(this.codebaseDir, "RISKS.md"), this.toRisksMd(result), "utf-8"),
+      fs26.writeFile(path29.join(this.codebaseDir, "TESTS.md"), this.toTestsMd(result), "utf-8")
+    ]);
+  }
+  async loadLatest() {
+    try {
+      const stack = JSON.parse(await fs26.readFile(path29.join(this.codebaseDir, "STACK.json"), "utf-8"));
+      const files = JSON.parse(await fs26.readFile(path29.join(this.codebaseDir, "FILES.json"), "utf-8"));
+      return { stack, files };
+    } catch {
+      return null;
+    }
+  }
+  toMapMd(r) {
+    const s = r.stack;
+    const lines = [
+      `# Codebase Architecture \u2014 ${r.projectName}`,
+      `> Generated: ${r.generatedAt.slice(0, 16).replace("T", " ")} UTC`,
+      "",
+      "## Stack",
+      `- **Language:** ${s.language}${s.secondaryLanguages.length ? " + " + s.secondaryLanguages.join(", ") : ""}`,
+      s.framework ? `- **Framework:** ${s.framework}` : "",
+      s.runtime ? `- **Runtime:** ${s.runtime}` : "",
+      s.buildTool ? `- **Build:** ${s.buildTool}` : "",
+      s.packageManager ? `- **Package Manager:** ${s.packageManager}` : "",
+      s.linter ? `- **Linter:** ${s.linter}` : "",
+      s.formatter ? `- **Formatter:** ${s.formatter}` : "",
+      s.cssFramework ? `- **CSS:** ${s.cssFramework}` : "",
+      "",
+      "## Project Size",
+      `- ${r.totalFiles} files  |  ${r.totalLines.toLocaleString()} total lines`,
+      `- Module style: ${r.conventions.moduleStyle}`,
+      r.conventions.entryPoint ? `- Entry point: \`${r.conventions.entryPoint}\`` : "",
+      "",
+      "## Dependencies",
+      `${r.dependencies.total} total (${r.dependencies.runtime.length} runtime, ${r.dependencies.dev.length} dev)`
+    ];
+    if (r.dependencies.highlights.length > 0) {
+      lines.push("", "**Key deps:** " + r.dependencies.highlights.join(", "));
+    }
+    lines.push("", "## Key Directories");
+    const byRole = groupFilesByRole(r.files);
+    for (const [role, fileList] of Object.entries(byRole)) {
+      if (fileList.length > 0) lines.push(`- **${role}:** ${fileList.length} files`);
+    }
+    lines.push("", "## Health Summary");
+    const risks = r.risks.summary;
+    if (risks.high > 0) lines.push(`- ${risks.high} HIGH risk item(s)`);
+    if (risks.medium > 0) lines.push(`- ${risks.medium} MEDIUM risk item(s)`);
+    if (risks.low > 0) lines.push(`- ${risks.low} LOW risk item(s)`);
+    if (risks.high === 0 && risks.medium === 0) lines.push("- No critical risks detected");
+    if (r.tests.framework) {
+      lines.push("", "## Tests");
+      lines.push(`- Framework: ${r.tests.framework}`);
+      lines.push(`- ${r.tests.testCount} test files  |  ${r.tests.sourceFileCount} source files`);
+      if (r.tests.coverageEnabled) lines.push("- Coverage enabled");
+    }
+    return lines.filter((l) => l !== void 0 && l !== null).join("\n");
+  }
+  toConventionsMd(r) {
+    const c = r.conventions;
+    return [
+      `# Conventions \u2014 ${r.projectName}`,
+      "",
+      `- **Naming:** ${c.namingStyle}`,
+      `- **Folder pattern:** ${c.folderPattern}`,
+      `- **Module style:** ${c.moduleStyle}`,
+      `- **TypeScript strict:** ${c.typescriptStrict ? "yes" : "no"}`,
+      `- **EditorConfig:** ${c.hasEditorConfig ? "yes" : "no"}`,
+      `- **Git hooks (Husky):** ${c.hasHusky ? "yes" : "no"}`,
+      `- **Lint-staged:** ${c.hasHusky ? "yes" : "no"}`
+    ].join("\n");
+  }
+  toRisksMd(r) {
+    const s = r.risks.summary;
+    const lines = [
+      `# Risks \u2014 ${r.projectName}`,
+      `> ${s.high} high  |  ${s.medium} medium  |  ${s.low} low`,
+      ""
+    ];
+    const byLevel = { high: [], medium: [], low: [] };
+    for (const item of r.risks.items) byLevel[item.level].push(item);
+    for (const [level, items] of Object.entries(byLevel)) {
+      if (items.length === 0) continue;
+      lines.push(`## ${level.toUpperCase()}`);
+      for (const item of items) {
+        lines.push(`- [${item.category}] ${item.message}${item.file ? `
+  \u2192 \`${item.file}\`` : ""}`);
+      }
+      lines.push("");
+    }
+    if (r.risks.items.length === 0) lines.push("No risks detected.");
+    return lines.join("\n");
+  }
+  toTestsMd(r) {
+    const t = r.tests;
+    const ratio = Math.round(t.coverageRatio * 100);
+    const lines = [
+      `# Tests \u2014 ${r.projectName}`,
+      "",
+      `- **Framework:** ${t.framework ?? "not detected"}`,
+      `- **Test files:** ${t.testCount}`,
+      `- **Source files:** ${t.sourceFileCount}`,
+      `- **Test/Source ratio:** ${ratio}%`,
+      `- **Coverage enabled:** ${t.coverageEnabled ? "yes" : "no"}`,
+      `- **Config file:** ${t.hasConfig ? "yes" : "no"}`
+    ];
+    if (t.testCommand) lines.push(`- **Test command:** \`${t.testCommand}\``);
+    if (t.testCount === 0) lines.push("", "> No test files detected \u2014 consider adding tests.");
+    return lines.join("\n");
+  }
+  async buildFileInventory(absPaths, relPaths, contents) {
+    const entries = [];
+    for (let i = 0; i < absPaths.length; i++) {
+      const rel = relPaths[i];
+      const abs = absPaths[i];
+      let size = 0;
+      let lines = 0;
+      try {
+        const stat = await fs26.stat(abs);
+        size = stat.size;
+        const content = contents.get(rel);
+        lines = content ? content.split("\n").length : 0;
+      } catch {
+      }
+      entries.push({ path: rel, size, lines, role: inferRole(rel) });
+    }
+    return entries;
+  }
+  async walkFiles(dir, maxDepth, depth = 0) {
+    if (depth > maxDepth) return [];
+    const entries = await fs26.readdir(dir, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".gitignore" && entry.name !== ".env.example") {
+        if (IGNORE_DIRS.has(entry.name)) continue;
+      }
+      if (IGNORE_DIRS.has(entry.name)) continue;
+      const full = path29.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await this.walkFiles(full, maxDepth, depth + 1));
+      } else if (entry.isFile()) {
+        const ext = path29.extname(entry.name).toLowerCase();
+        if (!IGNORE_EXTENSIONS.has(ext)) results.push(full);
+      }
+    }
+    return results;
+  }
+  async readProjectName() {
+    try {
+      const raw = await fs26.readFile(path29.join(this.cwd, "package.json"), "utf-8");
+      const pkg = JSON.parse(raw);
+      if (pkg.name) return pkg.name;
+    } catch {
+    }
+    return path29.basename(this.cwd);
+  }
+};
+function inferRole(filePath) {
+  const p = filePath.replace(/\\/g, "/");
+  if (/\.(test|spec)\.(ts|tsx|js|jsx|mjs|py|go|rs)$/.test(p) || p.includes("__tests__")) return "test";
+  if (p.includes("/docs/") || p.endsWith(".md")) return "docs";
+  if (p.includes("/config/") || /\.(config|rc)\.(ts|js|json|yaml|yml)$/.test(p)) return "config";
+  if (p.includes("/scripts/") || p.includes("/bin/")) return "script";
+  if (p.includes("/migrations/") || p.includes("/migrate/")) return "migration";
+  if (p.includes("/public/") || p.includes("/static/") || p.includes("/assets/")) return "asset";
+  if (/\.(ts|tsx|js|jsx|mjs|py|go|rs|php|rb)$/.test(p)) return "source";
+  if (/\.(json|yaml|yml|toml)$/.test(p)) return "config";
+  return "other";
+}
+function groupFilesByRole(files) {
+  const groups = {};
+  for (const f of files) {
+    (groups[f.role] ??= []).push(f);
+  }
+  return groups;
+}
+
+// src/memory/memory-store.ts
+import fs27 from "fs/promises";
+import path30 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+var FILE_FOR = {
+  decision: "decisions.jsonl",
+  summary: "summaries.jsonl",
+  gotcha: "gotchas.jsonl",
+  pattern: "patterns.jsonl"
+};
+var MemoryStore = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+    this.memoryDir = path30.join(cwd, ".brainforge", "memory");
+  }
+  cwd;
+  memoryDir;
+  async append(entry) {
+    const full = {
+      id: entry.id ?? randomUUID2(),
+      createdAt: entry.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      ...entry
+    };
+    await fs27.mkdir(this.memoryDir, { recursive: true });
+    const filePath = path30.join(this.memoryDir, FILE_FOR[full.type]);
+    await fs27.appendFile(filePath, JSON.stringify(full) + "\n", "utf-8");
+    await this.updateIndex(full);
+    return full;
+  }
+  async readAll(type) {
+    const types = type ? [type] : Object.keys(FILE_FOR);
+    const results = [];
+    for (const t of types) {
+      results.push(...await this.readFile(t));
+    }
+    return results.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  async recent(type, limit = 10) {
+    const all = await this.readAll(type);
+    return all.slice(-limit).reverse();
+  }
+  async search(query) {
+    const q = query.toLowerCase();
+    const all = await this.readAll();
+    return all.filter(
+      (e) => e.title.toLowerCase().includes(q) || e.content.toLowerCase().includes(q) || e.tags.some((t) => t.toLowerCase().includes(q))
+    );
+  }
+  async count() {
+    const types = Object.keys(FILE_FOR);
+    const counts = {};
+    for (const t of types) {
+      counts[t] = (await this.readFile(t)).length;
+    }
+    return counts;
+  }
+  async overwrite(type, entries) {
+    const filePath = path30.join(this.memoryDir, FILE_FOR[type]);
+    await fs27.mkdir(this.memoryDir, { recursive: true });
+    const lines = entries.map((e) => JSON.stringify(e)).join("\n");
+    await fs27.writeFile(filePath, lines ? lines + "\n" : "", "utf-8");
+  }
+  async readFile(type) {
+    const filePath = path30.join(this.memoryDir, FILE_FOR[type]);
+    try {
+      const raw = await fs27.readFile(filePath, "utf-8");
+      return raw.split("\n").filter((l) => l.trim()).map((l) => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      }).filter((e) => e !== null);
+    } catch {
+      return [];
+    }
+  }
+  async updateIndex(entry) {
+    const indexPath = path30.join(this.memoryDir, "index.json");
+    let index = {
+      version: 1,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      entries: []
+    };
+    try {
+      const raw = await fs27.readFile(indexPath, "utf-8");
+      index = JSON.parse(raw);
+    } catch {
+    }
+    index.entries.push({ id: entry.id, type: entry.type, title: entry.title, createdAt: entry.createdAt });
+    if (index.entries.length > 200) index.entries = index.entries.slice(-200);
+    await fs27.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+  }
+};
+
+// src/memory/decisions.ts
+var DecisionLogger = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async log(decision) {
+    const lines = [
+      decision.description,
+      "",
+      `**Rationale:** ${decision.rationale}`
+    ];
+    if (decision.consequences) {
+      lines.push(`**Consequences:** ${decision.consequences}`);
+    }
+    return this.store.append({
+      type: "decision",
+      title: decision.title,
+      content: lines.join("\n"),
+      tags: decision.tags ?? [],
+      phaseId: decision.phaseId
+    });
+  }
+  async list() {
+    return this.store.readAll("decision");
+  }
+  async recent(limit = 5) {
+    return this.store.recent("decision", limit);
+  }
+};
+
+// src/memory/gotchas.ts
+var GotchaLogger = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async log(gotcha) {
+    const content = [
+      gotcha.description,
+      "",
+      `**Solution:** ${gotcha.solution}`
+    ].join("\n");
+    return this.store.append({
+      type: "gotcha",
+      title: gotcha.title,
+      content,
+      tags: gotcha.tags ?? [],
+      phaseId: gotcha.phaseId
+    });
+  }
+  async list() {
+    return this.store.readAll("gotcha");
+  }
+  async recent(limit = 5) {
+    return this.store.recent("gotcha", limit);
+  }
+};
+
+// src/memory/compression.ts
+async function compact(store, keepLast = 20) {
+  const types = ["decision", "summary", "gotcha", "pattern"];
+  const results = [];
+  for (const type of types) {
+    const all = await store.readAll(type);
+    if (all.length <= keepLast) {
+      results.push({ type, before: all.length, kept: all.length, compacted: 0 });
+      continue;
+    }
+    const older = all.slice(0, all.length - keepLast);
+    const recent = all.slice(all.length - keepLast);
+    const compactedEntry = {
+      id: `compacted-${type}-${Date.now()}`,
+      type,
+      title: `[Compacted] ${older.length} older ${type} entries`,
+      content: summariseEntries(older),
+      tags: ["compacted"],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await store.overwrite(type, [compactedEntry, ...recent]);
+    results.push({ type, before: all.length, kept: recent.length + 1, compacted: older.length });
+  }
+  return {
+    ranAt: (/* @__PURE__ */ new Date()).toISOString(),
+    results,
+    totalBefore: results.reduce((n, r) => n + r.before, 0),
+    totalAfter: results.reduce((n, r) => n + r.kept, 0)
+  };
+}
+function summariseEntries(entries) {
+  const lines = [`Compacted ${entries.length} entries on ${(/* @__PURE__ */ new Date()).toISOString()}:`, ""];
+  for (const e of entries) {
+    const date = e.createdAt.slice(0, 10);
+    lines.push(`- [${date}] ${e.title}`);
+  }
+  return lines.join("\n");
+}
+
+// src/memory/context-packets.ts
+import fs28 from "fs/promises";
+import path31 from "path";
+var ContextPacketBuilder = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+    this.packetDir = path31.join(cwd, ".brainforge", "memory", "context-packets");
+  }
+  cwd;
+  packetDir;
+  async build() {
+    const manager = new StateManager(this.cwd);
+    await manager.load();
+    const state = manager.get();
+    const config = await loadConfig(this.cwd);
+    const store = new MemoryStore(this.cwd);
+    const activePhase = state.phases.find((p) => p.id === state.activePhaseId);
+    const completedPhases = state.phases.filter((p) => p.status === "completed").length;
+    const pendingPhases = state.phases.filter((p) => p.status !== "completed").length;
+    const recentDecisions = (await store.recent("decision", 3)).map((e) => ({
+      title: e.title,
+      content: e.content,
+      createdAt: e.createdAt
+    }));
+    const knownGotchas = (await store.recent("gotcha", 3)).map((e) => ({
+      title: e.title,
+      content: e.content
+    }));
+    const recentSummaries = (await store.recent("summary", 2)).map((e) => ({
+      title: e.title,
+      content: e.content,
+      createdAt: e.createdAt
+    }));
+    let currentPhase;
+    if (activePhase) {
+      const done = activePhase.tasks.filter((t) => t.status === "done").length;
+      const inProg = activePhase.tasks.filter((t) => t.status === "in-progress").length;
+      const next = activePhase.tasks.find((t) => t.status === "todo");
+      currentPhase = {
+        id: activePhase.id,
+        name: activePhase.name,
+        status: activePhase.status,
+        tasksTotal: activePhase.tasks.length,
+        tasksDone: done,
+        tasksInProgress: inProg,
+        nextTask: next?.title
+      };
+    }
+    const nextActions = deriveNextActions(state, activePhase);
+    const resumeCommands = deriveResumeCommands(state, activePhase);
+    return {
+      version: 1,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      project: {
+        name: state.project.name,
+        language: state.project.language,
+        framework: state.project.framework,
+        type: state.project.type
+      },
+      workflow: {
+        mode: config.mode,
+        runtime: config.runtime
+      },
+      phases: {
+        total: state.phases.length,
+        completed: completedPhases,
+        pending: pendingPhases,
+        activeId: state.activePhaseId,
+        activeName: activePhase?.name
+      },
+      currentPhase,
+      recentDecisions,
+      knownGotchas,
+      recentSummaries,
+      nextActions,
+      resumeCommands
+    };
+  }
+  async save(packet) {
+    await fs28.mkdir(this.packetDir, { recursive: true });
+    const jsonPath = path31.join(this.packetDir, "latest.json");
+    const mdPath = path31.join(this.packetDir, "latest.md");
+    await fs28.writeFile(jsonPath, JSON.stringify(packet, null, 2), "utf-8");
+    await fs28.writeFile(mdPath, this.toMarkdown(packet), "utf-8");
+    const ts = packet.generatedAt.replace(/[:.]/g, "-").slice(0, 19);
+    await fs28.writeFile(
+      path31.join(this.packetDir, `packet-${ts}.json`),
+      JSON.stringify(packet, null, 2),
+      "utf-8"
+    );
+    return { jsonPath, mdPath };
+  }
+  async loadLatest() {
+    try {
+      const raw = await fs28.readFile(path31.join(this.packetDir, "latest.json"), "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  toMarkdown(p) {
+    const lines = [
+      `# BrainForge AI \u2014 Resume Context`,
+      `> Generated: ${p.generatedAt.replace("T", " ").slice(0, 16)} UTC`,
+      `> Paste this into a fresh AI session to resume work immediately.`,
+      "",
+      "## Project",
+      `**Name:** ${p.project.name}`,
+      `**Language:** ${p.project.language}${p.project.framework ? " / " + p.project.framework : ""}`,
+      `**Type:** ${p.project.type}`,
+      `**Mode:** ${p.workflow.mode}  |  **Runtime:** ${p.workflow.runtime}`,
+      "",
+      "## Phase Progress",
+      `Total phases: ${p.phases.total}  |  Completed: ${p.phases.completed}  |  Pending: ${p.phases.pending}`
+    ];
+    if (p.currentPhase) {
+      const cp = p.currentPhase;
+      const pct = cp.tasksTotal > 0 ? Math.round(cp.tasksDone / cp.tasksTotal * 100) : 0;
+      const bar = progressBar(cp.tasksDone, cp.tasksTotal);
+      lines.push(
+        "",
+        `### Active Phase: ${cp.name} (${cp.status})`,
+        `[${bar}] ${pct}% \u2014 ${cp.tasksDone}/${cp.tasksTotal} tasks done`,
+        cp.tasksInProgress > 0 ? `${cp.tasksInProgress} task(s) in progress` : "",
+        cp.nextTask ? `**Next task:** ${cp.nextTask}` : "**All tasks complete \u2014 ready to verify.**"
+      );
+    }
+    if (p.recentDecisions.length > 0) {
+      lines.push("", "## Recent Decisions");
+      for (const d of p.recentDecisions) {
+        const date = d.createdAt.slice(0, 10);
+        lines.push(`- **[${date}] ${d.title}**`);
+        const firstLine = d.content.split("\n")[0]?.trim();
+        if (firstLine) lines.push(`  ${firstLine}`);
+      }
+    }
+    if (p.knownGotchas.length > 0) {
+      lines.push("", "## Known Gotchas");
+      for (const g of p.knownGotchas) {
+        lines.push(`- **${g.title}**`);
+        const solution = g.content.split("**Solution:**")[1]?.trim().split("\n")[0];
+        if (solution) lines.push(`  Fix: ${solution}`);
+      }
+    }
+    if (p.recentSummaries.length > 0) {
+      lines.push("", "## Recent Phase Summaries");
+      for (const s of p.recentSummaries) {
+        const date = s.createdAt.slice(0, 10);
+        lines.push(`- **[${date}] ${s.title}**`);
+      }
+    }
+    lines.push("", "## What To Do Next");
+    for (const action of p.nextActions) {
+      lines.push(`- ${action}`);
+    }
+    lines.push("", "## Quick Commands");
+    for (const cmd of p.resumeCommands) {
+      lines.push(`\`${cmd}\``);
+    }
+    lines.push(
+      "",
+      "---",
+      `*BrainForge AI \u2014 .brainforge/memory/context-packets/latest.md*`
+    );
+    return lines.filter((l) => l !== void 0).join("\n");
+  }
+};
+function deriveNextActions(state, activePhase) {
+  const actions = [];
+  if (state.phases.length === 0) {
+    actions.push("Run `brg plan` to create your first phase and tasks");
+    return actions;
+  }
+  if (!activePhase) {
+    const pending = state.phases.find((p) => p.status === "pending");
+    if (pending) actions.push(`Start phase "${pending.name}" with \`brg phase switch ${pending.id}\``);
+    return actions;
+  }
+  const todo = activePhase.tasks.filter((t) => t.status === "todo");
+  const inProg = activePhase.tasks.filter((t) => t.status === "in-progress");
+  const done = activePhase.tasks.filter((t) => t.status === "done");
+  if (inProg.length > 0) {
+    actions.push(`Continue ${inProg.length} in-progress task(s) with \`brg execute --prompt-only\``);
+  } else if (todo.length > 0) {
+    actions.push(`Execute ${todo.length} remaining task(s) with \`brg execute --phase ${activePhase.id} --prompt-only\``);
+  } else if (done.length === activePhase.tasks.length && activePhase.tasks.length > 0) {
+    actions.push(`All tasks done \u2014 run \`brg verify --phase ${activePhase.id}\` to verify`);
+  }
+  if (activePhase.status === "completed") {
+    const next = state.phases.find((p) => p.status === "pending");
+    if (next) actions.push(`Phase complete \u2014 next phase: "${next.name}"`);
+    else actions.push("All phases complete \u2014 run `brg ship` to close the project");
+  }
+  return actions;
+}
+function deriveResumeCommands(state, activePhase) {
+  const cmds = ["brg progress", "brg memory list"];
+  if (activePhase) {
+    cmds.push(`brg execute --phase ${activePhase.id} --prompt-only`);
+    cmds.push(`brg verify --phase ${activePhase.id}`);
+  } else {
+    cmds.push("brg plan");
+  }
+  return cmds;
+}
+function progressBar(done, total, width = 16) {
+  if (total === 0) return "\u2591".repeat(width);
+  const filled = Math.round(done / total * width);
+  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
 export {
+  AGENT_REGISTRY,
   AdapterManager,
+  AutoEngine,
   BUILT_IN_SKILLS,
   BrainForgeServer,
+  COMMANDS_BY_NAME,
+  COMMAND_DEFINITIONS,
   ClaudeAdapter,
   CodebaseMapper,
+  CodebaseScanner,
+  ContextPacketBuilder,
+  DEFAULT_CONFIG,
+  DebugEngine,
+  DecisionLogger,
   DeepSeekAdapter,
+  ExecutionEngine,
   FileWatcher,
   GeminiAdapter,
+  GotchaLogger,
+  MemoryStore,
   MockDefense,
   OpenAIAdapter,
+  ParallelOrchestrator,
+  PhaseEngine,
   ProfessorScanner,
   PromptEngine,
+  RUNTIME_REGISTRY,
+  ShipEngine,
   SkillRegistry,
   StateManager,
   TaskPlanner,
+  VerificationEngine,
+  WavePlanner,
+  WorkflowEngine,
+  Workspace,
+  analyzeDependencies,
+  buildAgentPrompt,
+  buildMergeReport,
   buildQuestionSet,
-  reduce
+  buildWaveSummary,
+  compact,
+  detectAndMigrate,
+  detectConflicts,
+  detectConventions,
+  detectRisks,
+  detectRuntimes,
+  detectStack,
+  detectTests,
+  getAgent,
+  getRuntime,
+  installRuntime,
+  listAgents,
+  listRuntimes,
+  loadConfig,
+  loadFileContents,
+  mergeResults,
+  reduce,
+  saveConfig,
+  validateConfig,
+  validatePhase,
+  validateProjectConfig,
+  validateTask
 };