@cleocode/cleo 2026.3.29 → 2026.3.30

package/dist/cli/index.js

@@ -4439,6 +4439,118 @@ var init_sqlite = __esm({
   }
 });
 
+// src/core/metrics/provider-detection.ts
+var provider_detection_exports = {};
+__export(provider_detection_exports, {
+  detectRuntimeProviderContext: () => detectRuntimeProviderContext,
+  resetRuntimeProviderContextCache: () => resetRuntimeProviderContextCache,
+  selectRuntimeProviderContext: () => selectRuntimeProviderContext
+});
+import { basename as basename3 } from "node:path";
+import {
+  detectProjectProviders,
+  getProvider,
+  resolveAlias
+} from "@cleocode/caamp";
+function inferProviderFromVendor(vendor) {
+  const value = (vendor ?? "").trim().toLowerCase();
+  if (!value) return void 0;
+  if (value.includes("anthropic") || value.includes("claude")) return "anthropic";
+  if (value.includes("openai") || value.includes("codex") || value.includes("chatgpt"))
+    return "openai";
+  if (value.includes("google") || value.includes("gemini")) return "google";
+  if (value.includes("xai") || value.includes("grok")) return "xai";
+  return void 0;
+}
+function getRuntimeHints(snapshot) {
+  const argv = snapshot.argv ?? process.argv;
+  const env = snapshot.env ?? process.env;
+  const hints = /* @__PURE__ */ new Set();
+  const bin = basename3(argv[1] ?? argv[0] ?? "").replace(/\.[^.]+$/, "");
+  if (bin) hints.add(bin);
+  if (env["CLAUDE_CODE_ENABLE_TELEMETRY"] || env["CLAUDE_CODE_ENTRYPOINT"]) {
+    hints.add("claude-code");
+    hints.add("claude");
+  }
+  if (env["OPENCODE_AGENT"] || env["OPENCODE"]) {
+    hints.add("opencode");
+  }
+  if (env["CURSOR_TRACE_ID"] || env["CURSOR_AGENT"]) {
+    hints.add("cursor");
+  }
+  return Array.from(hints);
+}
+function pickDetectionByHint(detections, hints) {
+  for (const hint of hints) {
+    const resolved = resolveAlias(hint);
+    const direct = detections.find(
+      (entry) => entry.provider.id === resolved || entry.provider.id === hint
+    );
+    if (direct) return direct;
+    const byAlias = detections.find(
+      (entry) => entry.provider.aliases.includes(hint) || entry.provider.agentFlag === hint || entry.provider.toolName.toLowerCase() === hint.toLowerCase()
+    );
+    if (byAlias) return byAlias;
+    const provider = getProvider(resolved);
+    if (provider) {
+      return {
+        provider,
+        installed: true,
+        methods: [],
+        projectDetected: false
+      };
+    }
+  }
+  return null;
+}
+function selectRuntimeProviderContext(detections, snapshot = {}) {
+  const hints = getRuntimeHints(snapshot);
+  const hinted = pickDetectionByHint(detections, hints);
+  const projectMatches = detections.filter((entry) => entry.projectDetected);
+  const installed = detections.filter((entry) => entry.installed);
+  const selected = hinted ?? (projectMatches.length === 1 ? projectMatches[0] : null) ?? (installed.length === 1 ? installed[0] : null);
+  if (!selected) {
+    return {
+      runtimeCandidates: installed.map((entry) => entry.provider.id)
+    };
+  }
+  return {
+    runtimeProviderId: selected.provider.id,
+    runtimeToolName: selected.provider.toolName,
+    runtimeVendor: selected.provider.vendor,
+    runtimeInstructionFile: selected.provider.instructFile,
+    runtimeProjectDetected: selected.projectDetected,
+    runtimeDetectionMethods: selected.methods,
+    runtimeCandidates: installed.map((entry) => entry.provider.id),
+    inferredModelProvider: inferProviderFromVendor(selected.provider.vendor)
+  };
+}
+function detectRuntimeProviderContext(snapshot = {}) {
+  if (!snapshot.cwd && !snapshot.argv && !snapshot.env && cachedRuntimeProvider) {
+    return cachedRuntimeProvider;
+  }
+  try {
+    const detections = detectProjectProviders(snapshot.cwd ?? process.cwd());
+    const context = selectRuntimeProviderContext(detections, snapshot);
+    if (!snapshot.cwd && !snapshot.argv && !snapshot.env) {
+      cachedRuntimeProvider = context;
+    }
+    return context;
+  } catch {
+    return {};
+  }
+}
+function resetRuntimeProviderContextCache() {
+  cachedRuntimeProvider = null;
+}
+var cachedRuntimeProvider;
+var init_provider_detection = __esm({
+  "src/core/metrics/provider-detection.ts"() {
+    "use strict";
+    cachedRuntimeProvider = null;
+  }
+});
+
 // src/store/parsers.ts
 function safeParseJson(str) {
   if (!str) return void 0;
@@ -8482,14 +8594,16 @@ async function writeMemoryBridge(projectRoot, config) {
     }
     writeFileSync4(bridgePath, content, "utf-8");
     return { path: bridgePath, written: true };
-  } catch {
+  } catch (err) {
+    console.error("[CLEO] Failed to write memory bridge:", err instanceof Error ? err.message : String(err));
     return { path: bridgePath, written: false };
   }
 }
 async function refreshMemoryBridge(projectRoot) {
   try {
     await writeMemoryBridge(projectRoot);
-  } catch {
+  } catch (err) {
+    console.error("[CLEO] Memory bridge refresh failed:", err instanceof Error ? err.message : String(err));
   }
 }
 async function getLastHandoffSafe(projectRoot) {
@@ -9914,6 +10028,10 @@ async function ensureInjection(projectRoot) {
   if (existsSync26(projectContextPath)) {
     agentsMdLines.push("@.cleo/project-context.json");
   }
+  const memoryBridgePath = join28(projectRoot, ".cleo", "memory-bridge.md");
+  if (existsSync26(memoryBridgePath)) {
+    agentsMdLines.push("@.cleo/memory-bridge.md");
+  }
   const contributorBlock = buildContributorInjectionBlock(projectRoot);
   if (contributorBlock) {
     agentsMdLines.push(contributorBlock);
@@ -10114,6 +10232,7 @@ __export(scaffold_exports, {
   CLEO_GITIGNORE_FALLBACK: () => CLEO_GITIGNORE_FALLBACK,
   REQUIRED_CLEO_SUBDIRS: () => REQUIRED_CLEO_SUBDIRS,
   REQUIRED_GLOBAL_SUBDIRS: () => REQUIRED_GLOBAL_SUBDIRS,
+  checkBrainDb: () => checkBrainDb,
   checkCleoGitRepo: () => checkCleoGitRepo,
   checkCleoStructure: () => checkCleoStructure,
   checkConfig: () => checkConfig,
@@ -10121,10 +10240,12 @@ __export(scaffold_exports, {
   checkGlobalHome: () => checkGlobalHome,
   checkGlobalTemplates: () => checkGlobalTemplates,
   checkLogDir: () => checkLogDir,
+  checkMemoryBridge: () => checkMemoryBridge,
   checkProjectContext: () => checkProjectContext,
   checkProjectInfo: () => checkProjectInfo,
   checkSqliteDb: () => checkSqliteDb,
   createDefaultConfig: () => createDefaultConfig,
+  ensureBrainDb: () => ensureBrainDb,
   ensureCleoGitRepo: () => ensureCleoGitRepo,
   ensureCleoStructure: () => ensureCleoStructure,
   ensureConfig: () => ensureConfig,
@@ -10739,6 +10860,79 @@ function checkSqliteDb(projectRoot) {
     fix: null
   };
 }
+async function ensureBrainDb(projectRoot) {
+  const cleoDir = getCleoDirAbsolute(projectRoot);
+  const dbPath = join29(cleoDir, "brain.db");
+  if (existsSync27(dbPath)) {
+    return { action: "skipped", path: dbPath, details: "brain.db already exists" };
+  }
+  try {
+    const { getBrainDb: getBrainDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+    await getBrainDb2(projectRoot);
+    return { action: "created", path: dbPath, details: "Brain database initialized" };
+  } catch (err) {
+    return {
+      action: "skipped",
+      path: dbPath,
+      details: `Failed to initialize brain.db: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function checkBrainDb(projectRoot) {
+  const cleoDir = getCleoDirAbsolute(projectRoot);
+  const dbPath = join29(cleoDir, "brain.db");
+  if (!existsSync27(dbPath)) {
+    return {
+      id: "brain_db",
+      category: "scaffold",
+      status: "failed",
+      message: "brain.db not found",
+      details: { path: dbPath, exists: false },
+      fix: "cleo init"
+    };
+  }
+  const stat5 = statSync4(dbPath);
+  if (stat5.size === 0) {
+    return {
+      id: "brain_db",
+      category: "scaffold",
+      status: "warning",
+      message: "brain.db exists but is empty (0 bytes)",
+      details: { path: dbPath, exists: true, size: 0 },
+      fix: "cleo upgrade"
+    };
+  }
+  return {
+    id: "brain_db",
+    category: "scaffold",
+    status: "passed",
+    message: `brain.db exists (${stat5.size} bytes)`,
+    details: { path: dbPath, exists: true, size: stat5.size },
+    fix: null
+  };
+}
+function checkMemoryBridge(projectRoot) {
+  const cleoDir = getCleoDirAbsolute(projectRoot);
+  const bridgePath = join29(cleoDir, "memory-bridge.md");
+  if (!existsSync27(bridgePath)) {
+    return {
+      id: "memory_bridge",
+      category: "scaffold",
+      status: "warning",
+      message: "memory-bridge.md not found",
+      details: { path: bridgePath, exists: false },
+      fix: "cleo init or cleo refresh-memory"
+    };
+  }
+  return {
+    id: "memory_bridge",
+    category: "scaffold",
+    status: "passed",
+    message: "memory-bridge.md exists",
+    details: { path: bridgePath, exists: true },
+    fix: null
+  };
+}
 async function ensureGlobalHome() {
   const cleoHome = getCleoHome();
   const alreadyExists = existsSync27(cleoHome);
@@ -11924,6 +12118,28 @@ var init_registry2 = __esm({
   }
 });
 
+// src/core/adapters/adapter-registry.ts
+var ADAPTER_REGISTRY;
+var init_adapter_registry = __esm({
+  "src/core/adapters/adapter-registry.ts"() {
+    "use strict";
+    ADAPTER_REGISTRY = {
+      "claude-code": async () => {
+        const { ClaudeCodeAdapter } = await import("@cleocode/adapter-claude-code");
+        return new ClaudeCodeAdapter();
+      },
+      "opencode": async () => {
+        const { OpenCodeAdapter } = await import("@cleocode/adapter-opencode");
+        return new OpenCodeAdapter();
+      },
+      "cursor": async () => {
+        const { CursorAdapter } = await import("@cleocode/adapter-cursor");
+        return new CursorAdapter();
+      }
+    };
+  }
+});
+
 // src/core/adapters/discovery.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync31, readdirSync as readdirSync13, readFileSync as readFileSync22 } from "node:fs";
@@ -11993,13 +12209,16 @@ var log4, AdapterManager;
 var init_manager = __esm({
   "src/core/adapters/manager.ts"() {
     "use strict";
+    init_registry();
     init_logger();
+    init_adapter_registry();
     init_discovery();
     log4 = getLogger("adapter-manager");
     AdapterManager = class _AdapterManager {
       static instance = null;
       adapters = /* @__PURE__ */ new Map();
       manifests = /* @__PURE__ */ new Map();
+      hookCleanups = /* @__PURE__ */ new Map();
       activeId = null;
       projectRoot;
       constructor(projectRoot) {
@@ -12043,7 +12262,7 @@ var init_manager = __esm({
       }
       /**
        * Load and initialize an adapter by manifest ID.
-       * The adapter module is dynamically imported from the manifest's entryPoint.
+       * Uses the static adapter registry for reliable bundled operation.
        */
       async activate(adapterId) {
         const manifest = this.manifests.get(adapterId);
@@ -12055,20 +12274,18 @@ var init_manager = __esm({
           this.activeId = adapterId;
           return existing;
         }
-        const { resolve: resolve12 } = await import("node:path");
-        const entryPath = resolve12(
-          this.projectRoot,
-          "packages",
-          "adapters",
-          manifest.provider,
-          manifest.entryPoint
-        );
+        const factory = ADAPTER_REGISTRY[adapterId];
+        if (!factory) {
+          throw new Error(`No adapter registered in static registry: ${adapterId}`);
+        }
         try {
-          const mod = await import(entryPath);
-          const adapter = typeof mod.default === "function" ? new mod.default() : typeof mod.createAdapter === "function" ? await mod.createAdapter() : mod.default;
+          const adapter = await factory();
           await adapter.initialize(this.projectRoot);
           this.adapters.set(adapterId, adapter);
           this.activeId = adapterId;
+          if (adapter.hooks) {
+            await this.wireAdapterHooks(adapterId, adapter);
+          }
           log4.info({ adapterId, provider: manifest.provider }, "Adapter activated");
           return adapter;
         } catch (err) {
@@ -12150,6 +12367,7 @@ var init_manager = __esm({
       async dispose() {
         for (const [id, adapter] of this.adapters) {
           try {
+            await this.cleanupAdapterHooks(id, adapter);
             await adapter.dispose();
             log4.info({ adapterId: id }, "Adapter disposed");
           } catch (err) {
@@ -12157,6 +12375,7 @@ var init_manager = __esm({
           }
         }
         this.adapters.clear();
+        this.hookCleanups.clear();
         this.activeId = null;
       }
       /** Dispose a single adapter. */
@@ -12164,6 +12383,7 @@ var init_manager = __esm({
         const adapter = this.adapters.get(adapterId);
         if (!adapter) return;
         try {
+          await this.cleanupAdapterHooks(adapterId, adapter);
           await adapter.dispose();
         } catch (err) {
           log4.error({ adapterId, err }, "Failed to dispose adapter");
@@ -12173,6 +12393,51 @@ var init_manager = __esm({
           this.activeId = null;
         }
       }
+      /**
+       * Wire an adapter's hook event map into CLEO's HookRegistry.
+       * Creates bridging handlers at priority 50 for each mapped event.
+       */
+      async wireAdapterHooks(adapterId, adapter) {
+        if (!adapter.hooks) return;
+        try {
+          await adapter.hooks.registerNativeHooks(this.projectRoot);
+        } catch (err) {
+          log4.error({ adapterId, err }, "Failed to register native hooks");
+        }
+        const eventMap = adapter.hooks.getEventMap?.();
+        if (!eventMap) return;
+        const cleanups = [];
+        for (const [_providerEvent, caampEvent] of Object.entries(eventMap)) {
+          const hookId = `adapter-${adapterId}-${caampEvent}`;
+          const unregister = hooks.register({
+            id: hookId,
+            event: caampEvent,
+            priority: 50,
+            handler: async (_projectRoot, payload) => {
+              log4.debug({ adapterId, event: caampEvent, payload }, "Adapter hook dispatched");
+            }
+          });
+          cleanups.push(unregister);
+        }
+        this.hookCleanups.set(adapterId, cleanups);
+      }
+      /**
+       * Clean up hook registrations for an adapter.
+       */
+      async cleanupAdapterHooks(adapterId, adapter) {
+        const cleanups = this.hookCleanups.get(adapterId);
+        if (cleanups) {
+          for (const fn of cleanups) {
+            fn();
+          }
+          this.hookCleanups.delete(adapterId);
+        }
+        try {
+          await adapter.hooks?.unregisterNativeHooks();
+        } catch (err) {
+          log4.error({ adapterId, err }, "Failed to unregister native hooks");
+        }
+      }
     };
   }
 });
@@ -12180,6 +12445,7 @@ var init_manager = __esm({
 // src/core/adapters/index.ts
 var adapters_exports = {};
 __export(adapters_exports, {
+  ADAPTER_REGISTRY: () => ADAPTER_REGISTRY,
   AdapterManager: () => AdapterManager,
   detectProvider: () => detectProvider,
   discoverAdapterManifests: () => discoverAdapterManifests
@@ -12187,6 +12453,7 @@ __export(adapters_exports, {
 var init_adapters = __esm({
   "src/core/adapters/index.ts"() {
     "use strict";
+    init_adapter_registry();
     init_manager();
     init_discovery();
   }
@@ -12410,6 +12677,14 @@ async function initProject(opts = {}) {
   } catch (err) {
     created.push(`tasks.db (deferred: ${err instanceof Error ? err.message : String(err)})`);
   }
+  try {
+    const brainResult = await ensureBrainDb(projRoot);
+    if (brainResult.action === "created") {
+      created.push("brain.db");
+    }
+  } catch (err) {
+    created.push(`brain.db (deferred: ${err instanceof Error ? err.message : String(err)})`);
+  }
   if (force) {
     const gitignoreResult = await ensureGitignore(projRoot);
     if (gitignoreResult.action === "skipped") {
@@ -12532,11 +12807,34 @@ async function initProject(opts = {}) {
       const detected = mgr.detectActive();
       if (detected.length > 0) {
         created.push(`adapters: active provider detected (${detected.join(", ")})`);
+        for (const adapterId of detected) {
+          try {
+            const adapter = await mgr.activate(adapterId);
+            const installResult = await adapter.install.install({
+              projectDir: projRoot
+            });
+            if (installResult.success) {
+              created.push(`adapter install (${adapterId}): installed`);
+            } else {
+              warnings.push(`adapter install (${adapterId}): failed`);
+            }
+          } catch (err) {
+            warnings.push(`adapter activate/install (${adapterId}): ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
       }
     }
   } catch (err) {
     warnings.push(`Adapter discovery: ${err instanceof Error ? err.message : String(err)}`);
   }
+  try {
+    const bridgeResult = await writeMemoryBridge(projRoot);
+    if (bridgeResult.written) {
+      created.push("memory-bridge.md");
+    }
+  } catch (err) {
+    warnings.push(`Memory bridge: ${err instanceof Error ? err.message : String(err)}`);
+  }
   const rootGitignoreResult = await removeCleoFromRootGitignore(projRoot);
   if (rootGitignoreResult.removed) {
     warnings.push(
@@ -12598,6 +12896,7 @@ var init_init = __esm({
     init_paths();
     init_scaffold();
     init_schema_management();
+    init_memory_bridge();
   }
 });
 
@@ -14546,6 +14845,13 @@ async function startSession(options, cwd, accessor) {
       );
     }
   }
+  let detectedProviderId = null;
+  try {
+    const { detectRuntimeProviderContext: detectRuntimeProviderContext2 } = await Promise.resolve().then(() => (init_provider_detection(), provider_detection_exports));
+    const ctx = detectRuntimeProviderContext2();
+    detectedProviderId = ctx.runtimeProviderId ?? null;
+  } catch {
+  }
   const session = {
     id: generateSessionId(),
     name: options.name,
@@ -14560,7 +14866,7 @@ async function startSession(options, cwd, accessor) {
     notes: [],
     tasksCompleted: [],
     tasksCreated: [],
-    providerId: options.providerId ?? null
+    providerId: options.providerId ?? detectedProviderId ?? null
   };
   if (options.grade) {
     session.notes = ["[grade-mode:enabled]", ...session.notes ?? []];
@@ -14570,13 +14876,22 @@ async function startSession(options, cwd, accessor) {
   }
   sessions2.push(session);
   await saveSessions(sessions2, cwd, accessor);
+  if (session.providerId) {
+    Promise.resolve().then(() => (init_adapters(), adapters_exports)).then(({ AdapterManager: AdapterManager2 }) => {
+      const mgr = AdapterManager2.getInstance(cwd ?? process.cwd());
+      mgr.discover();
+      return mgr.activate(session.providerId);
+    }).catch(() => {
+    });
+  }
   const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
   hooks2.dispatch("onSessionStart", cwd ?? process.cwd(), {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     sessionId: session.id,
     name: options.name,
     scope,
-    agent: options.agent
+    agent: options.agent,
+    providerId: session.providerId ?? void 0
   }).catch(() => {
   });
   return session;
@@ -14612,7 +14927,8 @@ async function endSession(options = {}, cwd, accessor) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     sessionId: session.id,
     duration,
-    tasksCompleted: session.tasksCompleted || []
+    tasksCompleted: session.tasksCompleted || [],
+    providerId: session.providerId ?? void 0
   }).catch(() => {
   });
   const { bridgeSessionToMemory: bridgeSessionToMemory2 } = await Promise.resolve().then(() => (init_session_memory_bridge(), session_memory_bridge_exports));
@@ -15130,7 +15446,7 @@ async function initializeDefaultAdapters() {
   }
 }
 var SpawnAdapterRegistry, spawnRegistry;
-var init_adapter_registry = __esm({
+var init_adapter_registry2 = __esm({
   "src/core/spawn/adapter-registry.ts"() {
     "use strict";
     SpawnAdapterRegistry = class {
@@ -16359,6 +16675,18 @@ async function startupHealthCheck(projectRoot) {
   } else {
     checks.push({ check: "log_dir", status: "pass", message: "Log directory present" });
   }
+  const brainDbCheck = checkBrainDb(root);
+  checks.push({
+    check: "brain_db",
+    status: brainDbCheck.status === "passed" ? "pass" : "warn",
+    message: brainDbCheck.message
+  });
+  const memBridgeCheck = checkMemoryBridge(root);
+  checks.push({
+    check: "memory_bridge",
+    status: memBridgeCheck.status === "passed" ? "pass" : "warn",
+    message: memBridgeCheck.message
+  });
   const hasFailures = failures.length > 0;
   const state = hasFailures && !projectHealthy ? "needs_upgrade" : "healthy";
   return {
@@ -20625,104 +20953,8 @@ async function resolveProviderFromModelRegistry(model) {
   return resolveProviderFromModelIndex(index5, model);
 }
 
-// src/core/metrics/provider-detection.ts
-import { basename as basename3 } from "node:path";
-import {
-  detectProjectProviders,
-  getProvider,
-  resolveAlias
-} from "@cleocode/caamp";
-function inferProviderFromVendor(vendor) {
-  const value = (vendor ?? "").trim().toLowerCase();
-  if (!value) return void 0;
-  if (value.includes("anthropic") || value.includes("claude")) return "anthropic";
-  if (value.includes("openai") || value.includes("codex") || value.includes("chatgpt"))
-    return "openai";
-  if (value.includes("google") || value.includes("gemini")) return "google";
-  if (value.includes("xai") || value.includes("grok")) return "xai";
-  return void 0;
-}
-function getRuntimeHints(snapshot) {
-  const argv = snapshot.argv ?? process.argv;
-  const env = snapshot.env ?? process.env;
-  const hints = /* @__PURE__ */ new Set();
-  const bin = basename3(argv[1] ?? argv[0] ?? "").replace(/\.[^.]+$/, "");
-  if (bin) hints.add(bin);
-  if (env["CLAUDE_CODE_ENABLE_TELEMETRY"] || env["CLAUDE_CODE_ENTRYPOINT"]) {
-    hints.add("claude-code");
-    hints.add("claude");
-  }
-  if (env["OPENCODE_AGENT"] || env["OPENCODE"]) {
-    hints.add("opencode");
-  }
-  if (env["CURSOR_TRACE_ID"] || env["CURSOR_AGENT"]) {
-    hints.add("cursor");
-  }
-  return Array.from(hints);
-}
-function pickDetectionByHint(detections, hints) {
-  for (const hint of hints) {
-    const resolved = resolveAlias(hint);
-    const direct = detections.find(
-      (entry) => entry.provider.id === resolved || entry.provider.id === hint
-    );
-    if (direct) return direct;
-    const byAlias = detections.find(
-      (entry) => entry.provider.aliases.includes(hint) || entry.provider.agentFlag === hint || entry.provider.toolName.toLowerCase() === hint.toLowerCase()
-    );
-    if (byAlias) return byAlias;
-    const provider = getProvider(resolved);
-    if (provider) {
-      return {
-        provider,
-        installed: true,
-        methods: [],
-        projectDetected: false
-      };
-    }
-  }
-  return null;
-}
-function selectRuntimeProviderContext(detections, snapshot = {}) {
-  const hints = getRuntimeHints(snapshot);
-  const hinted = pickDetectionByHint(detections, hints);
-  const projectMatches = detections.filter((entry) => entry.projectDetected);
-  const installed = detections.filter((entry) => entry.installed);
-  const selected = hinted ?? (projectMatches.length === 1 ? projectMatches[0] : null) ?? (installed.length === 1 ? installed[0] : null);
-  if (!selected) {
-    return {
-      runtimeCandidates: installed.map((entry) => entry.provider.id)
-    };
-  }
-  return {
-    runtimeProviderId: selected.provider.id,
-    runtimeToolName: selected.provider.toolName,
-    runtimeVendor: selected.provider.vendor,
-    runtimeInstructionFile: selected.provider.instructFile,
-    runtimeProjectDetected: selected.projectDetected,
-    runtimeDetectionMethods: selected.methods,
-    runtimeCandidates: installed.map((entry) => entry.provider.id),
-    inferredModelProvider: inferProviderFromVendor(selected.provider.vendor)
-  };
-}
-var cachedRuntimeProvider = null;
-function detectRuntimeProviderContext(snapshot = {}) {
-  if (!snapshot.cwd && !snapshot.argv && !snapshot.env && cachedRuntimeProvider) {
-    return cachedRuntimeProvider;
-  }
-  try {
-    const detections = detectProjectProviders(snapshot.cwd ?? process.cwd());
-    const context = selectRuntimeProviderContext(detections, snapshot);
-    if (!snapshot.cwd && !snapshot.argv && !snapshot.env) {
-      cachedRuntimeProvider = context;
-    }
-    return context;
-  } catch {
-    return {};
-  }
-}
-
 // src/core/metrics/token-service.ts
+init_provider_detection();
 function normalizeProvider(provider, model, runtimeProvider) {
   const value = (provider ?? "").trim().toLowerCase();
   const modelValue = (model ?? "").trim().toLowerCase();
@@ -28570,7 +28802,7 @@ async function orchestrateValidate(taskId, projectRoot) {
 async function orchestrateSpawnExecute(taskId, adapterId, protocolType, projectRoot, _tier) {
   const cwd = projectRoot ?? process.cwd();
   try {
-    const { initializeDefaultAdapters: initializeDefaultAdapters2, spawnRegistry: spawnRegistry2 } = await Promise.resolve().then(() => (init_adapter_registry(), adapter_registry_exports));
+    const { initializeDefaultAdapters: initializeDefaultAdapters2, spawnRegistry: spawnRegistry2 } = await Promise.resolve().then(() => (init_adapter_registry2(), adapter_registry_exports));
     await initializeDefaultAdapters2();
     let adapter;
     if (adapterId) {
@@ -29699,7 +29931,10 @@ async function checkEpicCompleteness(releaseTaskIds, cwd, accessor) {
     if (!epic) continue;
     const allChildren = data.tasks.filter((t) => t.parentId === epicId && t.id !== epicId);
     const includedSet = new Set(includedTasks);
-    const missingChildren = allChildren.filter((t) => !includedSet.has(t.id) && !releaseSet.has(t.id)).map((t) => ({ id: t.id, title: t.title, status: t.status }));
+    const parentIds = new Set(data.tasks.filter((t) => t.parentId).map((t) => t.parentId));
+    const missingChildren = allChildren.filter(
+      (t) => t.status === "done" && !parentIds.has(t.id) && !includedSet.has(t.id) && !releaseSet.has(t.id)
+    ).map((t) => ({ id: t.id, title: t.title, status: t.status }));
     if (missingChildren.length > 0) hasIncomplete = true;
     epics.push({
       epicId,
@@ -29856,9 +30091,9 @@ init_tasks_schema();
 init_pagination();
 init_paths();
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { existsSync as existsSync42, renameSync as renameSync7 } from "node:fs";
+import { existsSync as existsSync43, renameSync as renameSync7 } from "node:fs";
 import { readFile as readFile11 } from "node:fs/promises";
-import { join as join43 } from "node:path";
+import { join as join44 } from "node:path";
 import { and as and6, count as count4, desc as desc5, eq as eq15 } from "drizzle-orm";
 
 // src/core/release/changelog-writer.ts
@@ -29952,6 +30187,170 @@ function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/core/release/version-bump.ts
+init_exit_codes();
+init_errors();
+init_paths();
+import { existsSync as existsSync42, readFileSync as readFileSync29, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join43 } from "node:path";
+function readConfigValueSync2(path, defaultValue, cwd) {
+  try {
+    const configPath = join43(getCleoDir(cwd), "config.json");
+    if (!existsSync42(configPath)) return defaultValue;
+    const config = JSON.parse(readFileSync29(configPath, "utf-8"));
+    const keys = path.split(".");
+    let value = config;
+    for (const key of keys) {
+      if (value == null || typeof value !== "object") return defaultValue;
+      value = value[key];
+    }
+    return value ?? defaultValue;
+  } catch {
+    return defaultValue;
+  }
+}
+var VERSION_WITH_PRERELEASE = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/;
+function validateVersionFormat(version) {
+  return VERSION_WITH_PRERELEASE.test(version);
+}
+function getVersionBumpConfig(cwd) {
+  try {
+    const raw = readConfigValueSync2("release.versionBump.files", [], cwd);
+    return raw.map((entry) => ({
+      file: entry.path ?? entry.file ?? "",
+      strategy: entry.strategy,
+      field: entry.jsonPath?.replace(/^\./, "") ?? entry.field,
+      key: entry.key,
+      section: entry.section,
+      pattern: entry.sedPattern ?? entry.pattern
+    })).filter((t) => t.file !== "");
+  } catch {
+    return [];
+  }
+}
+function bumpFile(target, newVersion, projectRoot) {
+  const filePath = join43(projectRoot, target.file);
+  if (!existsSync42(filePath)) {
+    return {
+      file: target.file,
+      strategy: target.strategy,
+      success: false,
+      error: `File not found: ${target.file}`
+    };
+  }
+  try {
+    const content = readFileSync29(filePath, "utf-8");
+    let previousVersion;
+    let newContent;
+    switch (target.strategy) {
+      case "plain": {
+        previousVersion = content.trim();
+        newContent = newVersion + "\n";
+        break;
+      }
+      case "json": {
+        const field = target.field ?? "version";
+        const json = JSON.parse(content);
+        previousVersion = getNestedField(json, field);
+        setNestedField(json, field, newVersion);
+        newContent = JSON.stringify(json, null, 2) + "\n";
+        break;
+      }
+      case "toml": {
+        const key = target.key ?? "version";
+        const versionRegex = new RegExp(`^(${key}\\s*=\\s*")([^"]+)(")`, "m");
+        const match = content.match(versionRegex);
+        previousVersion = match?.[2];
+        newContent = content.replace(versionRegex, `$1${newVersion}$3`);
+        break;
+      }
+      case "sed": {
+        const pattern = target.pattern ?? "";
+        if (!pattern.includes("{{VERSION}}")) {
+          return {
+            file: target.file,
+            strategy: target.strategy,
+            success: false,
+            error: "sed strategy requires {{VERSION}} placeholder in pattern"
+          };
+        }
+        const regex = new RegExp(pattern.replace("{{VERSION}}", "([\\d.]+)"));
+        const match = content.match(regex);
+        previousVersion = match?.[1];
+        newContent = content.replace(regex, pattern.replace("{{VERSION}}", newVersion));
+        break;
+      }
+      default:
+        return {
+          file: target.file,
+          strategy: target.strategy,
+          success: false,
+          error: `Unknown strategy: ${target.strategy}`
+        };
+    }
+    writeFileSync7(filePath, newContent, "utf-8");
+    return {
+      file: target.file,
+      strategy: target.strategy,
+      success: true,
+      previousVersion,
+      newVersion
+    };
+  } catch (err) {
+    return {
+      file: target.file,
+      strategy: target.strategy,
+      success: false,
+      error: String(err)
+    };
+  }
+}
+function bumpVersionFromConfig(newVersion, options = {}, cwd) {
+  if (!validateVersionFormat(newVersion)) {
+    throw new CleoError(
+      6 /* VALIDATION_ERROR */,
+      `Invalid version: '${newVersion}' (expected X.Y.Z or YYYY.M.patch)`
+    );
+  }
+  const targets = getVersionBumpConfig(cwd);
+  if (targets.length === 0) {
+    throw new CleoError(
+      1 /* GENERAL_ERROR */,
+      "No version bump targets configured. Add release.versionBump.files to .cleo/config.json"
+    );
+  }
+  const projectRoot = getProjectRoot(cwd);
+  const results = [];
+  if (options.dryRun) {
+    for (const target of targets) {
+      results.push({
+        file: target.file,
+        strategy: target.strategy,
+        success: true,
+        newVersion
+      });
+    }
+    return { results, allSuccess: true };
+  }
+  for (const target of targets) {
+    results.push(bumpFile(target, newVersion, projectRoot));
+  }
+  const allSuccess = results.every((r) => r.success);
+  return { results, allSuccess };
+}
+function getNestedField(obj, path) {
+  return path.split(".").reduce((acc, key) => acc?.[key], obj);
+}
+function setNestedField(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (typeof current[parts[i]] !== "object") current[parts[i]] = {};
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+
 // src/core/release/release-manifest.ts
 function normalizeLimit2(limit) {
   return typeof limit === "number" && limit > 0 ? limit : void 0;
@@ -30177,7 +30576,7 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
   }
   const changelog = sections.join("\n");
   await db.update(releaseManifests).set({ changelog }).where(eq15(releaseManifests.version, normalizedVersion)).run();
-  const changelogPath = join43(cwd ?? process.cwd(), "CHANGELOG.md");
+  const changelogPath = join44(cwd ?? process.cwd(), "CHANGELOG.md");
   let existingChangelogContent = "";
   try {
     existingChangelogContent = await readFile11(changelogPath, "utf8");
@@ -30291,13 +30690,13 @@ async function runReleaseGates(version, loadTasksFn, cwd, opts) {
     message: incompleteTasks.length === 0 ? "All tasks completed" : `${incompleteTasks.length} tasks not completed: ${incompleteTasks.join(", ")}`
   });
   const projectRoot = cwd ?? getProjectRoot();
-  const distPath = join43(projectRoot, "dist", "cli", "index.js");
-  const isNodeProject = existsSync42(join43(projectRoot, "package.json"));
+  const distPath = join44(projectRoot, "dist", "cli", "index.js");
+  const isNodeProject = existsSync43(join44(projectRoot, "package.json"));
   if (isNodeProject) {
     gates.push({
       name: "build_artifact",
-      status: existsSync42(distPath) ? "passed" : "failed",
-      message: existsSync42(distPath) ? "dist/cli/index.js present" : "dist/ not built \u2014 run: npm run build"
+      status: existsSync43(distPath) ? "passed" : "failed",
+      message: existsSync43(distPath) ? "dist/cli/index.js present" : "dist/ not built \u2014 run: npm run build"
     });
   }
   if (opts?.dryRun) {
@@ -30307,6 +30706,8 @@ async function runReleaseGates(version, loadTasksFn, cwd, opts) {
       message: "Skipped in dry-run mode"
     });
   } else {
+    const bumpTargets = getVersionBumpConfig(cwd);
+    const allowedDirty = /* @__PURE__ */ new Set(["CHANGELOG.md", ...bumpTargets.map((t) => t.file)]);
     let workingTreeClean = true;
     let dirtyFiles = [];
     try {
@@ -30315,14 +30716,15 @@ async function runReleaseGates(version, loadTasksFn, cwd, opts) {
         encoding: "utf-8",
         stdio: "pipe"
       });
-      dirtyFiles = porcelain.split("\n").filter((l) => l.trim()).filter((l) => !l.startsWith("?? ")).map((l) => l.slice(3).trim()).filter((f) => f !== "CHANGELOG.md" && f !== "VERSION" && f !== "package.json");
+      dirtyFiles = porcelain.split("\n").filter((l) => l.trim()).filter((l) => !l.startsWith("?? ")).map((l) => l.slice(3).trim()).filter((f) => !allowedDirty.has(f));
       workingTreeClean = dirtyFiles.length === 0;
     } catch {
     }
+    const excludeList = [...allowedDirty].join(", ");
     gates.push({
       name: "clean_working_tree",
       status: workingTreeClean ? "passed" : "failed",
-      message: workingTreeClean ? "Working tree clean (excluding CHANGELOG.md, VERSION, package.json)" : `Uncommitted changes in: ${dirtyFiles.slice(0, 5).join(", ")}${dirtyFiles.length > 5 ? ` (+${dirtyFiles.length - 5} more)` : ""}`
+      message: workingTreeClean ? `Working tree clean (excluding ${excludeList})` : `Uncommitted changes in: ${dirtyFiles.slice(0, 5).join(", ")}${dirtyFiles.length > 5 ? ` (+${dirtyFiles.length - 5} more)` : ""}`
     });
   }
   const isPreRelease = normalizedVersion.includes("-");
@@ -30437,7 +30839,7 @@ async function rollbackRelease(version, reason, cwd) {
   };
 }
 async function readPushPolicy(cwd) {
-  const configPath = join43(getCleoDirAbsolute(cwd), "config.json");
+  const configPath = join44(getCleoDirAbsolute(cwd), "config.json");
   const config = await readJson(configPath);
   if (!config) return void 0;
   const release2 = config.release;
@@ -30535,170 +30937,6 @@ async function markReleasePushed(version, pushedAt, cwd, provenance) {
   }).where(eq15(releaseManifests.version, normalizedVersion)).run();
 }
 
-// src/core/release/version-bump.ts
-init_exit_codes();
-init_errors();
-init_paths();
-import { existsSync as existsSync43, readFileSync as readFileSync29, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join44 } from "node:path";
-function readConfigValueSync2(path, defaultValue, cwd) {
-  try {
-    const configPath = join44(getCleoDir(cwd), "config.json");
-    if (!existsSync43(configPath)) return defaultValue;
-    const config = JSON.parse(readFileSync29(configPath, "utf-8"));
-    const keys = path.split(".");
-    let value = config;
-    for (const key of keys) {
-      if (value == null || typeof value !== "object") return defaultValue;
-      value = value[key];
-    }
-    return value ?? defaultValue;
-  } catch {
-    return defaultValue;
-  }
-}
-var VERSION_WITH_PRERELEASE = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/;
-function validateVersionFormat(version) {
-  return VERSION_WITH_PRERELEASE.test(version);
-}
-function getVersionBumpConfig(cwd) {
-  try {
-    const raw = readConfigValueSync2("release.versionBump.files", [], cwd);
-    return raw.map((entry) => ({
-      file: entry.path ?? entry.file ?? "",
-      strategy: entry.strategy,
-      field: entry.jsonPath?.replace(/^\./, "") ?? entry.field,
-      key: entry.key,
-      section: entry.section,
-      pattern: entry.sedPattern ?? entry.pattern
-    })).filter((t) => t.file !== "");
-  } catch {
-    return [];
-  }
-}
-function bumpFile(target, newVersion, projectRoot) {
-  const filePath = join44(projectRoot, target.file);
-  if (!existsSync43(filePath)) {
-    return {
-      file: target.file,
-      strategy: target.strategy,
-      success: false,
-      error: `File not found: ${target.file}`
-    };
-  }
-  try {
-    const content = readFileSync29(filePath, "utf-8");
-    let previousVersion;
-    let newContent;
-    switch (target.strategy) {
-      case "plain": {
-        previousVersion = content.trim();
-        newContent = newVersion + "\n";
-        break;
-      }
-      case "json": {
-        const field = target.field ?? "version";
-        const json = JSON.parse(content);
-        previousVersion = getNestedField(json, field);
-        setNestedField(json, field, newVersion);
-        newContent = JSON.stringify(json, null, 2) + "\n";
-        break;
-      }
-      case "toml": {
-        const key = target.key ?? "version";
-        const versionRegex = new RegExp(`^(${key}\\s*=\\s*")([^"]+)(")`, "m");
-        const match = content.match(versionRegex);
-        previousVersion = match?.[2];
-        newContent = content.replace(versionRegex, `$1${newVersion}$3`);
-        break;
-      }
-      case "sed": {
-        const pattern = target.pattern ?? "";
-        if (!pattern.includes("{{VERSION}}")) {
-          return {
-            file: target.file,
-            strategy: target.strategy,
-            success: false,
-            error: "sed strategy requires {{VERSION}} placeholder in pattern"
-          };
-        }
-        const regex = new RegExp(pattern.replace("{{VERSION}}", "([\\d.]+)"));
-        const match = content.match(regex);
-        previousVersion = match?.[1];
-        newContent = content.replace(regex, pattern.replace("{{VERSION}}", newVersion));
-        break;
-      }
-      default:
-        return {
-          file: target.file,
-          strategy: target.strategy,
-          success: false,
-          error: `Unknown strategy: ${target.strategy}`
-        };
-    }
-    writeFileSync7(filePath, newContent, "utf-8");
-    return {
-      file: target.file,
-      strategy: target.strategy,
-      success: true,
-      previousVersion,
-      newVersion
-    };
-  } catch (err) {
-    return {
-      file: target.file,
-      strategy: target.strategy,
-      success: false,
-      error: String(err)
-    };
-  }
-}
-function bumpVersionFromConfig(newVersion, options = {}, cwd) {
-  if (!validateVersionFormat(newVersion)) {
-    throw new CleoError(
-      6 /* VALIDATION_ERROR */,
-      `Invalid version: '${newVersion}' (expected X.Y.Z or YYYY.M.patch)`
-    );
-  }
-  const targets = getVersionBumpConfig(cwd);
-  if (targets.length === 0) {
-    throw new CleoError(
-      1 /* GENERAL_ERROR */,
-      "No version bump targets configured. Add release.versionBump.files to .cleo/config.json"
-    );
-  }
-  const projectRoot = getProjectRoot(cwd);
-  const results = [];
-  if (options.dryRun) {
-    for (const target of targets) {
-      results.push({
-        file: target.file,
-        strategy: target.strategy,
-        success: true,
-        newVersion
-      });
-    }
-    return { results, allSuccess: true };
-  }
-  for (const target of targets) {
-    results.push(bumpFile(target, newVersion, projectRoot));
-  }
-  const allSuccess = results.every((r) => r.success);
-  return { results, allSuccess };
-}
-function getNestedField(obj, path) {
-  return path.split(".").reduce((acc, key) => acc?.[key], obj);
-}
-function setNestedField(obj, path, value) {
-  const parts = path.split(".");
-  let current = obj;
-  for (let i = 0; i < parts.length - 1; i++) {
-    if (typeof current[parts[i]] !== "object") current[parts[i]] = {};
-    current = current[parts[i]];
-  }
-  current[parts[parts.length - 1]] = value;
-}
-
 // src/dispatch/engines/release-engine.ts
 init_data_accessor();
 init_error();
@@ -45215,7 +45453,7 @@ import { execFileSync as execFileSync13 } from "node:child_process";
 // src/config/build-config.ts
 var BUILD_CONFIG = {
   "name": "@cleocode/cleo",
-  "version": "2026.3.29",
+  "version": "2026.3.30",
   "description": "CLEO V2 - TypeScript task management CLI for AI coding agents",
   "repository": {
     "owner": "kryptobaseddev",
@@ -45224,7 +45462,7 @@ var BUILD_CONFIG = {
     "url": "https://github.com/kryptobaseddev/cleo.git",
     "issuesUrl": "https://github.com/kryptobaseddev/cleo/issues"
   },
-  "buildDate": "2026-03-16T14:27:12.409Z",
+  "buildDate": "2026-03-16T17:27:58.735Z",
   "templates": {
     "issueTemplatesDir": "templates/issue-templates"
   }
@@ -47933,6 +48171,30 @@ async function runUpgrade(options = {}) {
       }
     } catch {
     }
+    try {
+      const { ensureBrainDb: ensureBrainDb2 } = await Promise.resolve().then(() => (init_scaffold(), scaffold_exports));
+      const brainResult = await ensureBrainDb2(projectRootForMaint);
+      if (brainResult.action !== "skipped") {
+        actions.push({
+          action: "ensure_brain_db",
+          status: "applied",
+          details: brainResult.details ?? "brain.db initialized"
+        });
+      }
+    } catch {
+    }
+    try {
+      const { writeMemoryBridge: writeMemoryBridge2 } = await Promise.resolve().then(() => (init_memory_bridge(), memory_bridge_exports));
+      const bridgeResult = await writeMemoryBridge2(projectRootForMaint);
+      if (bridgeResult.written) {
+        actions.push({
+          action: "memory_bridge",
+          status: "applied",
+          details: "memory-bridge.md regenerated"
+        });
+      }
+    } catch {
+    }
     try {
       const rootGitignoreResult = await removeCleoFromRootGitignore(projectRootForMaint);
       if (rootGitignoreResult.removed) {