@cleocode/core 2026.3.69 → 2026.3.71

package/src/cleo.ts

@@ -16,26 +16,26 @@
 
 import path from 'node:path';
 import type {
+  AdminAPI,
+  AgentsAPI,
+  CleoInitOptions,
   DataAccessor,
-  ExternalTask,
-  ExternalTaskLink,
-  ReconcileOptions,
-  ReconcileResult,
-  Task,
-  TaskPriority,
-  TaskSize,
-  TaskStatus,
-  TaskType,
+  IntelligenceAPI,
+  LifecycleAPI,
+  MemoryAPI,
+  NexusAPI,
+  OrchestrationAPI,
+  ReleaseAPI,
+  SessionsAPI,
+  StickyAPI,
+  SyncAPI,
+  TasksAPI,
 } from '@cleocode/contracts';
 // Admin
 import { exportTasks } from './admin/export.js';
-import type { ImportParams } from './admin/import.js';
 import { importTasks } from './admin/import.js';
 // Agents
 import {
-  type AgentCapacity,
-  type AgentHealthStatus,
-  type AgentInstanceRow,
   checkAgentHealth,
   deregisterAgent,
   detectCrashedAgents,
@@ -43,16 +43,10 @@ import {
   heartbeat,
   isOverloaded,
   listAgentInstances,
-  type RegisterAgentOptions,
   registerAgent,
 } from './agents/index.js';
 // Intelligence
-import {
-  type BlastRadius,
-  calculateBlastRadius,
-  type ImpactReport,
-  predictImpact,
-} from './intelligence/index.js';
+import { calculateBlastRadius, predictImpact } from './intelligence/index.js';
 // Lifecycle
 import {
   checkGate,
@@ -66,7 +60,6 @@ import {
   skipStage,
   startStage,
 } from './lifecycle/index.js';
-import type { BrainObservationType } from './memory/brain-retrieval.js';
 // Memory
 import {
   fetchBrainEntries,
@@ -74,7 +67,6 @@ import {
   searchBrainCompact,
   timelineBrain,
 } from './memory/brain-retrieval.js';
-import type { HybridSearchOptions } from './memory/brain-search.js';
 import { hybridSearch, searchBrain } from './memory/brain-search.js';
 // Nexus
 import { discoverRelated, searchAcrossProjects } from './nexus/discover.js';
@@ -162,237 +154,24 @@ import { showTask } from './tasks/show.js';
 import { updateTask } from './tasks/update.js';
 
 // ============================================================================
-// Domain API interfaces
-// ============================================================================
-
-export interface TasksAPI {
-  add(params: {
-    title: string;
-    description: string;
-    parent?: string;
-    priority?: TaskPriority;
-    type?: TaskType;
-    size?: TaskSize;
-    phase?: string;
-    labels?: string[];
-    depends?: string[];
-    notes?: string;
-  }): Promise<unknown>;
-  find(params: {
-    query?: string;
-    id?: string;
-    status?: TaskStatus;
-    limit?: number;
-  }): Promise<unknown>;
-  show(taskId: string): Promise<unknown>;
-  list(params?: {
-    status?: TaskStatus;
-    priority?: TaskPriority;
-    parentId?: string;
-    phase?: string;
-    limit?: number;
-  }): Promise<unknown>;
-  update(params: {
-    taskId: string;
-    title?: string;
-    status?: TaskStatus;
-    priority?: TaskPriority;
-    description?: string;
-    notes?: string;
-  }): Promise<unknown>;
-  complete(params: { taskId: string; notes?: string }): Promise<unknown>;
-  delete(params: { taskId: string; force?: boolean }): Promise<unknown>;
-  archive(params?: { before?: string; taskIds?: string[]; dryRun?: boolean }): Promise<unknown>;
-  /** Start working on a specific task (sets focus). */
-  start(taskId: string): Promise<unknown>;
-  /** Stop working on the current task (clears focus). */
-  stop(): Promise<{ previousTask: string | null }>;
-  /** Get the current task work state. */
-  current(): Promise<unknown>;
-}
-
-export interface SessionsAPI {
-  start(params: {
-    name: string;
-    scope: string;
-    agent?: string;
-    startTask?: string;
-  }): Promise<unknown>;
-  end(params?: { note?: string }): Promise<unknown>;
-  status(): Promise<unknown>;
-  resume(sessionId: string): Promise<unknown>;
-  list(params?: { status?: string; limit?: number }): Promise<unknown>;
-  find(params?: {
-    status?: string;
-    scope?: string;
-    query?: string;
-    limit?: number;
-  }): Promise<unknown>;
-  show(sessionId: string): Promise<unknown>;
-  suspend(sessionId: string, reason?: string): Promise<unknown>;
-  briefing(params?: { maxNextTasks?: number; scope?: string }): Promise<unknown>;
-  handoff(sessionId: string, options?: { note?: string; nextAction?: string }): Promise<unknown>;
-  gc(maxAgeHours?: number): Promise<unknown>;
-  recordDecision(params: {
-    sessionId: string;
-    taskId: string;
-    decision: string;
-    rationale: string;
-    alternatives?: string[];
-  }): Promise<unknown>;
-  recordAssumption(params: {
-    assumption: string;
-    confidence: 'high' | 'medium' | 'low';
-    sessionId?: string;
-    taskId?: string;
-  }): Promise<unknown>;
-  contextDrift(params?: { sessionId?: string }): Promise<unknown>;
-  decisionLog(params?: { sessionId?: string; taskId?: string }): Promise<unknown>;
-  lastHandoff(scope?: { type: string; epicId?: string }): Promise<unknown>;
-}
-
-export interface MemoryAPI {
-  observe(params: { text: string; title?: string; type?: BrainObservationType }): Promise<unknown>;
-  find(params: {
-    query: string;
-    limit?: number;
-    tables?: Array<'decisions' | 'patterns' | 'learnings' | 'observations'>;
-  }): Promise<unknown>;
-  fetch(params: { ids: string[] }): Promise<unknown>;
-  timeline(params: { anchor: string; depthBefore?: number; depthAfter?: number }): Promise<unknown>;
-  search(query: string, options?: { limit?: number }): Promise<unknown>;
-  hybridSearch(query: string, options?: HybridSearchOptions): Promise<unknown>;
-}
-
-export interface OrchestrationAPI {
-  start(epicId: string): Promise<unknown>;
-  analyze(epicId: string): Promise<unknown>;
-  readyTasks(epicId: string): Promise<unknown>;
-  nextTask(epicId: string): Promise<unknown>;
-  context(epicId: string): Promise<unknown>;
-  dependencyGraph(tasks: Task[]): unknown;
-  epicStatus(epicId: string, title: string, children: Task[]): unknown;
-  progress(tasks: Task[]): unknown;
-}
-
-export interface LifecycleAPI {
-  status(epicId: string): Promise<unknown>;
-  startStage(epicId: string, stage: string): Promise<unknown>;
-  completeStage(epicId: string, stage: string, artifacts?: string[]): Promise<unknown>;
-  skipStage(epicId: string, stage: string, reason: string): Promise<unknown>;
-  checkGate(epicId: string, targetStage: string): Promise<unknown>;
-  history(epicId: string): Promise<unknown>;
-  resetStage(epicId: string, stage: string, reason: string): Promise<unknown>;
-  passGate(epicId: string, gateName: string, agent?: string): Promise<unknown>;
-  failGate(epicId: string, gateName: string, reason?: string): Promise<unknown>;
-  stages: readonly string[];
-}
-
-export interface ReleaseAPI {
-  prepare(params: { version: string; tasks?: string[]; notes?: string }): Promise<unknown>;
-  commit(params: { version: string }): Promise<unknown>;
-  tag(params: { version: string }): Promise<unknown>;
-  push(params: { version: string; remote?: string; explicitPush?: boolean }): Promise<unknown>;
-  rollback(params: { version: string; reason?: string }): Promise<unknown>;
-  calculateVersion(current: string, bumpType: string): string;
-  bumpVersion(): Promise<unknown>;
-}
-
-export interface AdminAPI {
-  export(params?: Record<string, unknown>): Promise<unknown>;
-  import(params: Omit<ImportParams, 'cwd'>): Promise<unknown>;
-}
-
-export interface StickyAPI {
-  add(params: {
-    content: string;
-    tags?: string[];
-    priority?: string;
-    color?: string;
-  }): Promise<unknown>;
-  show(stickyId: string): Promise<unknown>;
-  list(params?: {
-    status?: string;
-    color?: string;
-    priority?: string;
-    limit?: number;
-  }): Promise<unknown>;
-  archive(stickyId: string): Promise<unknown>;
-  purge(stickyId: string): Promise<unknown>;
-  convert(params: {
-    stickyId: string;
-    targetType: 'task' | 'memory' | 'task_note' | 'session_note';
-    title?: string;
-    memoryType?: string;
-    taskId?: string;
-  }): Promise<unknown>;
-}
-
-export interface NexusAPI {
-  init(): Promise<unknown>;
-  register(params: { path: string; name?: string; permissions?: string }): Promise<unknown>;
-  unregister(params: { name: string }): Promise<unknown>;
-  list(): Promise<unknown>;
-  show(params: { name: string }): Promise<unknown>;
-  sync(params?: { name?: string }): Promise<unknown>;
-  discover(params: { query: string; method?: string; limit?: number }): Promise<unknown>;
-  search(params: { pattern: string; project?: string; limit?: number }): Promise<unknown>;
-  setPermission(params: { name: string; level: 'read' | 'write' | 'execute' }): Promise<unknown>;
-  sharingStatus(): Promise<unknown>;
-}
-
-export interface SyncAPI {
-  /** Reconcile external tasks with CLEO as SSoT. */
-  reconcile(params: {
-    externalTasks: ExternalTask[];
-    providerId: string;
-    dryRun?: boolean;
-    conflictPolicy?: ReconcileOptions['conflictPolicy'];
-    defaultPhase?: string;
-    defaultLabels?: string[];
-  }): Promise<ReconcileResult>;
-  /** Get all external task links for a provider. */
-  getLinks(providerId: string): Promise<ExternalTaskLink[]>;
-  /** Get all external task links for a CLEO task. */
-  getTaskLinks(taskId: string): Promise<ExternalTaskLink[]>;
-  /** Remove all external task links for a provider. */
-  removeProviderLinks(providerId: string): Promise<number>;
-}
-
-export interface AgentsAPI {
-  /** Register a new agent instance. */
-  register(options: RegisterAgentOptions): Promise<AgentInstanceRow>;
-  /** Deregister an agent instance. */
-  deregister(agentId: string): Promise<AgentInstanceRow | null>;
-  /** Get health status for a specific agent. */
-  health(agentId: string): Promise<AgentHealthStatus | null>;
-  /** Detect agents that have crashed (missed heartbeats). */
-  detectCrashed(thresholdMs?: number): Promise<AgentInstanceRow[]>;
-  /** Record a heartbeat for an agent. */
-  recordHeartbeat(agentId: string): Promise<unknown>;
-  /** Get capacity info for an agent. */
-  capacity(agentId: string): Promise<AgentCapacity | null>;
-  /** Check if system is overloaded (available capacity below threshold). */
-  isOverloaded(threshold?: number): Promise<boolean>;
-  /** List all agent instances with optional filters. */
-  list(params?: { status?: string; agentType?: string }): Promise<AgentInstanceRow[]>;
-}
-
-export interface IntelligenceAPI {
-  /** Predict impact of a change description on related tasks. */
-  predictImpact(change: string): Promise<ImpactReport>;
-  /** Calculate blast radius for a task change. */
-  blastRadius(taskId: string): Promise<BlastRadius>;
-}
-
-// ============================================================================
-// Init options
+// Domain API interfaces — re-exported from @cleocode/contracts/facade
 // ============================================================================
 
-export interface CleoInitOptions {
-  store?: DataAccessor;
-  caamp?: boolean;
-}
+export type {
+  AdminAPI,
+  AgentsAPI,
+  CleoInitOptions,
+  IntelligenceAPI,
+  LifecycleAPI,
+  MemoryAPI,
+  NexusAPI,
+  OrchestrationAPI,
+  ReleaseAPI,
+  SessionsAPI,
+  StickyAPI,
+  SyncAPI,
+  TasksAPI,
+} from '@cleocode/contracts';
 
 // ============================================================================
 // Cleo facade class

package/src/config.ts

@@ -79,6 +79,24 @@ const DEFAULTS: CleoConfig = {
     agentPrefix: 'cleo-',
     privacyTier: 'private',
   },
+  brain: {
+    autoCapture: true,
+    captureFiles: false,
+    captureMcp: false,
+    captureWork: false,
+    embedding: {
+      enabled: true,
+      provider: 'local' as const,
+    },
+    memoryBridge: {
+      autoRefresh: true,
+      contextAware: true,
+      maxTokens: 2000,
+    },
+    summarization: {
+      enabled: true,
+    },
+  },
 };
 
 /** Environment variable to config path mapping. */

package/src/hooks/handlers/file-hooks.ts

@@ -5,7 +5,9 @@
  * Includes 5-second dedup and path-based filtering to avoid noisy writes.
  * Auto-registers on module load.
  *
- * Disabled by default. Set CLEO_BRAIN_CAPTURE_FILES=true to enable.
+ * Disabled by default. Enable via:
+ *   - Config: brain.captureFiles = true  (checked first)
+ *   - Env:    CLEO_BRAIN_CAPTURE_FILES=true  (overrides config)
  */
 
 import { isAbsolute, relative } from 'node:path';
@@ -39,10 +41,34 @@ function shouldSkipPath(relativePath: string): boolean {
   return SKIP_PATTERNS.some((pattern) => pattern.test(relativePath));
 }
 
+/**
+ * Check whether file-change capture is enabled.
+ *
+ * Resolution order (first truthy wins):
+ *   1. CLEO_BRAIN_CAPTURE_FILES env var (explicit override)
+ *   2. brain.captureFiles project config value
+ *
+ * Defaults to false when neither is set.
+ */
+async function isFileCaptureEnabled(projectRoot: string): Promise<boolean> {
+  const envOverride = process.env['CLEO_BRAIN_CAPTURE_FILES'];
+  if (envOverride !== undefined) {
+    return envOverride === 'true';
+  }
+  try {
+    const { loadConfig } = await import('../../config.js');
+    const config = await loadConfig(projectRoot);
+    return config.brain?.captureFiles ?? false;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Handle onFileChange - capture file changes to BRAIN
  *
- * Gated behind CLEO_BRAIN_CAPTURE_FILES=true env var.
+ * Gated behind brain.captureFiles config or CLEO_BRAIN_CAPTURE_FILES env var.
+ * Env var takes precedence over config for backward compatibility.
  * Deduplicates rapid writes to the same file within a 5-second window.
  * Filters out .cleo/ internal files and test temp directories.
  * Converts absolute paths to project-relative paths.
@@ -52,7 +78,7 @@ export async function handleFileChange(
   payload: OnFileChangePayload,
 ): Promise<void> {
   // Opt-in gate: disabled by default to prevent observation noise
-  if (process.env['CLEO_BRAIN_CAPTURE_FILES'] !== 'true') return;
+  if (!(await isFileCaptureEnabled(projectRoot))) return;
 
   // 5-second dedup
   const now = Date.now();

package/src/hooks/handlers/index.ts

@@ -11,6 +11,7 @@ import './task-hooks.js';
 import './error-hooks.js';
 import './file-hooks.js';
 import './mcp-hooks.js';
+import './work-capture-hooks.js';
 
 export { handleError } from './error-hooks.js';
 export { handleFileChange } from './file-hooks.js';
@@ -18,3 +19,4 @@ export { handlePromptSubmit, handleResponseComplete } from './mcp-hooks.js';
 // Re-export handler functions for explicit use
 export { handleSessionEnd, handleSessionStart } from './session-hooks.js';
 export { handleToolComplete, handleToolStart } from './task-hooks.js';
+export { handleWorkPromptSubmit, handleWorkResponseComplete } from './work-capture-hooks.js';

package/src/hooks/handlers/mcp-hooks.ts

@@ -1,9 +1,11 @@
 /**
  * MCP Prompt/Response Hook Handlers - Wave 2 of T5237
  *
- * Handlers for onPromptSubmit and onResponseComplete events.
- * By default, NO brain capture (too noisy). Brain observation is
- * opt-in via CLEO_BRAIN_CAPTURE_MCP=true environment variable.
+ * Handlers for onPromptSubmit and onResponseComplete events that capture
+ * ALL gateway operations (read and write) to BRAIN.
+ * By default, NO brain capture (too noisy). Enable via:
+ *   - Config: brain.captureMcp = true  (checked first)
+ *   - Env:    CLEO_BRAIN_CAPTURE_MCP=true  (overrides config)
  * Auto-registers on module load.
  */
 
@@ -17,23 +19,39 @@ function isMissingBrainSchemaError(err: unknown): boolean {
 }
 
 /**
- * Check if brain capture is enabled for MCP events.
- * Defaults to false (too noisy for normal operation).
+ * Check whether MCP-level brain capture is enabled.
+ *
+ * Resolution order (first truthy wins):
+ *   1. CLEO_BRAIN_CAPTURE_MCP env var (explicit override)
+ *   2. brain.captureMcp project config value
+ *
+ * Defaults to false when neither is set (too noisy for normal operation).
  */
-function isBrainCaptureEnabled(): boolean {
-  return process.env['CLEO_BRAIN_CAPTURE_MCP'] === 'true';
+async function isBrainCaptureEnabled(projectRoot: string): Promise<boolean> {
+  const envOverride = process.env['CLEO_BRAIN_CAPTURE_MCP'];
+  if (envOverride !== undefined) {
+    return envOverride === 'true';
+  }
+  try {
+    const { loadConfig } = await import('../../config.js');
+    const config = await loadConfig(projectRoot);
+    return config.brain?.captureMcp ?? false;
+  } catch {
+    return false;
+  }
 }
 
 /**
- * Handle onPromptSubmit - optionally capture prompt events to BRAIN
+ * Handle onPromptSubmit - optionally capture ALL gateway prompt events to BRAIN.
  *
- * No-op by default. Set CLEO_BRAIN_CAPTURE_MCP=true to enable.
+ * No-op by default. Enable via brain.captureMcp config or CLEO_BRAIN_CAPTURE_MCP env.
+ * For selective mutation-only capture, use work-capture-hooks.ts instead.
  */
 export async function handlePromptSubmit(
   projectRoot: string,
   payload: OnPromptSubmitPayload,
 ): Promise<void> {
-  if (!isBrainCaptureEnabled()) return;
+  if (!(await isBrainCaptureEnabled(projectRoot))) return;
 
   const { observeBrain } = await import('../../memory/brain-retrieval.js');
 
@@ -50,15 +68,16 @@ export async function handlePromptSubmit(
 }
 
 /**
- * Handle onResponseComplete - optionally capture response events to BRAIN
+ * Handle onResponseComplete - optionally capture ALL gateway response events to BRAIN.
  *
- * No-op by default. Set CLEO_BRAIN_CAPTURE_MCP=true to enable.
+ * No-op by default. Enable via brain.captureMcp config or CLEO_BRAIN_CAPTURE_MCP env.
+ * For selective mutation-only capture, use work-capture-hooks.ts instead.
  */
 export async function handleResponseComplete(
   projectRoot: string,
   payload: OnResponseCompletePayload,
 ): Promise<void> {
-  if (!isBrainCaptureEnabled()) return;
+  if (!(await isBrainCaptureEnabled(projectRoot))) return;
 
   const { observeBrain } = await import('../../memory/brain-retrieval.js');
 

package/src/hooks/handlers/memory-bridge-refresh.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared memory bridge refresh helper for hook handlers.
+ *
+ * Provides a config-gated, debounced wrapper around refreshMemoryBridge().
+ * Prevents rapid regeneration of .cleo/memory-bridge.md when multiple
+ * lifecycle events fire in quick succession (e.g. session end + task complete).
+ *
+ * Debounce: max one refresh per 30 seconds across all callers in the process.
+ *
+ * @task T138
+ * @epic T134
+ */
+
+/** Debounce window in milliseconds. */
+const DEBOUNCE_MS = 30_000;
+
+/** Timestamp of the last successful refresh call (module-level singleton). */
+let lastRefreshTime = 0;
+
+/**
+ * Refresh the memory bridge if autoRefresh is enabled and the debounce window
+ * has elapsed. Reads config via loadConfig() (cascaded). Never throws.
+ *
+ * @param projectRoot - Absolute path to the project root directory.
+ */
+export async function maybeRefreshMemoryBridge(projectRoot: string): Promise<void> {
+  try {
+    const { loadConfig } = await import('../../config.js');
+    const config = await loadConfig(projectRoot);
+
+    if (!config.brain?.memoryBridge?.autoRefresh) {
+      return;
+    }
+
+    const now = Date.now();
+    if (now - lastRefreshTime < DEBOUNCE_MS) {
+      return;
+    }
+
+    lastRefreshTime = now;
+
+    const { refreshMemoryBridge } = await import('../../memory/memory-bridge.js');
+    await refreshMemoryBridge(projectRoot);
+  } catch {
+    // Best-effort: never block lifecycle events
+  }
+}

package/src/hooks/handlers/session-hooks.ts

@@ -3,10 +3,15 @@
  *
  * Handlers that capture session lifecycle events to BRAIN via memory.observe.
  * Auto-registers on module load.
+ *
+ * T138: Triggers memory bridge refresh on session start and end.
+ * T139: Regenerates bridge with session scope on start.
+ * T144: Extracts transcript observations on session end.
  */
 
 import { hooks } from '../registry.js';
 import type { OnSessionEndPayload, OnSessionStartPayload } from '../types.js';
+import { maybeRefreshMemoryBridge } from './memory-bridge-refresh.js';
 
 function isMissingBrainSchemaError(err: unknown): boolean {
   if (!(err instanceof Error)) return false;
@@ -16,6 +21,9 @@ function isMissingBrainSchemaError(err: unknown): boolean {
 
 /**
  * Handle onSessionStart - capture initial session context
+ *
+ * T138: Refresh memory bridge on session start.
+ * T139: Regenerate bridge with session scope context.
  */
 export async function handleSessionStart(
   projectRoot: string,
@@ -34,10 +42,16 @@ export async function handleSessionStart(
   } catch (err) {
     if (!isMissingBrainSchemaError(err)) throw err;
   }
+
+  // T138/T139: Refresh memory bridge after session starts (best-effort)
+  await maybeRefreshMemoryBridge(projectRoot);
 }
 
 /**
  * Handle onSessionEnd - capture session summary
+ *
+ * T138: Refresh memory bridge after session ends.
+ * T144: Extract transcript observations via cross-provider adapter.
  */
 export async function handleSessionEnd(
   projectRoot: string,
@@ -64,6 +78,30 @@ export async function handleSessionEnd(
   } catch {
     // Grading must never block session end
   }
+
+  // T144: Cross-provider transcript extraction (best-effort)
+  try {
+    const { loadConfig } = await import('../../config.js');
+    const config = await loadConfig(projectRoot);
+    if (config.brain?.autoCapture) {
+      const { AdapterManager } = await import('../../adapters/index.js');
+      const manager = AdapterManager.getInstance(projectRoot);
+      const activeAdapter = manager.getActive();
+      const hookProvider = activeAdapter?.hooks;
+      if (hookProvider && typeof hookProvider.getTranscript === 'function') {
+        const transcript = await hookProvider.getTranscript(payload.sessionId, projectRoot);
+        if (transcript) {
+          const { extractFromTranscript } = await import('../../memory/auto-extract.js');
+          await extractFromTranscript(projectRoot, payload.sessionId, transcript);
+        }
+      }
+    }
+  } catch {
+    // Graceful no-op: transcript extraction must never block session end
+  }
+
+  // T138: Refresh memory bridge after session ends (best-effort)
+  await maybeRefreshMemoryBridge(projectRoot);
 }
 
 // Register handlers on module load

package/src/hooks/handlers/task-hooks.ts

@@ -3,10 +3,13 @@
  *
  * Handlers that capture task lifecycle events to BRAIN via memory.observe.
  * Auto-registers on module load.
+ *
+ * T138: Triggers memory bridge refresh after task completion.
  */
 
 import { hooks } from '../registry.js';
 import type { OnToolCompletePayload, OnToolStartPayload } from '../types.js';
+import { maybeRefreshMemoryBridge } from './memory-bridge-refresh.js';
 
 function isMissingBrainSchemaError(err: unknown): boolean {
   if (!(err instanceof Error)) return false;
@@ -37,6 +40,8 @@ export async function handleToolStart(
 
 /**
  * Handle onToolComplete (maps to task.complete in CLEO)
+ *
+ * T138: Refresh memory bridge after task completion.
  */
 export async function handleToolComplete(
   projectRoot: string,
@@ -54,6 +59,9 @@ export async function handleToolComplete(
   } catch (err) {
     if (!isMissingBrainSchemaError(err)) throw err;
   }
+
+  // T138: Refresh memory bridge after task completes (best-effort)
+  await maybeRefreshMemoryBridge(projectRoot);
 }
 
 // Register handlers