@cleocode/cleo 2026.3.4 → 2026.3.6

package/dist/mcp/index.js

@@ -3850,6 +3850,1338 @@ var init_handoff = __esm({
   }
 });
 
+// src/store/brain-schema.ts
+var brain_schema_exports = {};
+__export(brain_schema_exports, {
+  BRAIN_CONFIDENCE_LEVELS: () => BRAIN_CONFIDENCE_LEVELS,
+  BRAIN_DECISION_TYPES: () => BRAIN_DECISION_TYPES,
+  BRAIN_IMPACT_LEVELS: () => BRAIN_IMPACT_LEVELS,
+  BRAIN_LINK_TYPES: () => BRAIN_LINK_TYPES,
+  BRAIN_MEMORY_TYPES: () => BRAIN_MEMORY_TYPES,
+  BRAIN_OBSERVATION_SOURCE_TYPES: () => BRAIN_OBSERVATION_SOURCE_TYPES,
+  BRAIN_OBSERVATION_TYPES: () => BRAIN_OBSERVATION_TYPES,
+  BRAIN_OUTCOME_TYPES: () => BRAIN_OUTCOME_TYPES,
+  BRAIN_PATTERN_TYPES: () => BRAIN_PATTERN_TYPES,
+  brainDecisions: () => brainDecisions,
+  brainLearnings: () => brainLearnings,
+  brainMemoryLinks: () => brainMemoryLinks,
+  brainObservations: () => brainObservations,
+  brainPatterns: () => brainPatterns,
+  brainSchemaMeta: () => brainSchemaMeta
+});
+import {
+  sqliteTable as sqliteTable2,
+  text as text2,
+  integer as integer2,
+  real,
+  index as index2,
+  primaryKey as primaryKey2
+} from "drizzle-orm/sqlite-core";
+import { sql as sql3 } from "drizzle-orm";
+var BRAIN_DECISION_TYPES, BRAIN_CONFIDENCE_LEVELS, BRAIN_OUTCOME_TYPES, BRAIN_PATTERN_TYPES, BRAIN_IMPACT_LEVELS, BRAIN_LINK_TYPES, BRAIN_OBSERVATION_TYPES, BRAIN_OBSERVATION_SOURCE_TYPES, BRAIN_MEMORY_TYPES, brainDecisions, brainPatterns, brainLearnings, brainObservations, brainMemoryLinks, brainSchemaMeta;
+var init_brain_schema = __esm({
+  "src/store/brain-schema.ts"() {
+    "use strict";
+    BRAIN_DECISION_TYPES = ["architecture", "technical", "process", "strategic", "tactical"];
+    BRAIN_CONFIDENCE_LEVELS = ["low", "medium", "high"];
+    BRAIN_OUTCOME_TYPES = ["success", "failure", "mixed", "pending"];
+    BRAIN_PATTERN_TYPES = ["workflow", "blocker", "success", "failure", "optimization"];
+    BRAIN_IMPACT_LEVELS = ["low", "medium", "high"];
+    BRAIN_LINK_TYPES = ["produced_by", "applies_to", "informed_by", "contradicts"];
+    BRAIN_OBSERVATION_TYPES = ["discovery", "change", "feature", "bugfix", "decision", "refactor"];
+    BRAIN_OBSERVATION_SOURCE_TYPES = ["agent", "session-debrief", "claude-mem", "manual"];
+    BRAIN_MEMORY_TYPES = ["decision", "pattern", "learning", "observation"];
+    brainDecisions = sqliteTable2("brain_decisions", {
+      id: text2("id").primaryKey(),
+      type: text2("type", { enum: BRAIN_DECISION_TYPES }).notNull(),
+      decision: text2("decision").notNull(),
+      rationale: text2("rationale").notNull(),
+      confidence: text2("confidence", { enum: BRAIN_CONFIDENCE_LEVELS }).notNull(),
+      outcome: text2("outcome", { enum: BRAIN_OUTCOME_TYPES }),
+      alternativesJson: text2("alternatives_json"),
+      contextEpicId: text2("context_epic_id"),
+      // soft FK to tasks.id in tasks.db
+      contextTaskId: text2("context_task_id"),
+      // soft FK to tasks.id in tasks.db
+      contextPhase: text2("context_phase"),
+      createdAt: text2("created_at").notNull().default(sql3`(datetime('now'))`),
+      updatedAt: text2("updated_at")
+    }, (table) => [
+      index2("idx_brain_decisions_type").on(table.type),
+      index2("idx_brain_decisions_confidence").on(table.confidence),
+      index2("idx_brain_decisions_outcome").on(table.outcome),
+      index2("idx_brain_decisions_context_epic").on(table.contextEpicId),
+      index2("idx_brain_decisions_context_task").on(table.contextTaskId)
+    ]);
+    brainPatterns = sqliteTable2("brain_patterns", {
+      id: text2("id").primaryKey(),
+      type: text2("type", { enum: BRAIN_PATTERN_TYPES }).notNull(),
+      pattern: text2("pattern").notNull(),
+      context: text2("context").notNull(),
+      frequency: integer2("frequency").notNull().default(1),
+      successRate: real("success_rate"),
+      impact: text2("impact", { enum: BRAIN_IMPACT_LEVELS }),
+      antiPattern: text2("anti_pattern"),
+      mitigation: text2("mitigation"),
+      examplesJson: text2("examples_json").default("[]"),
+      extractedAt: text2("extracted_at").notNull().default(sql3`(datetime('now'))`),
+      updatedAt: text2("updated_at")
+    }, (table) => [
+      index2("idx_brain_patterns_type").on(table.type),
+      index2("idx_brain_patterns_impact").on(table.impact),
+      index2("idx_brain_patterns_frequency").on(table.frequency)
+    ]);
+    brainLearnings = sqliteTable2("brain_learnings", {
+      id: text2("id").primaryKey(),
+      insight: text2("insight").notNull(),
+      source: text2("source").notNull(),
+      confidence: real("confidence").notNull(),
+      // 0.0-1.0
+      actionable: integer2("actionable", { mode: "boolean" }).notNull().default(false),
+      application: text2("application"),
+      applicableTypesJson: text2("applicable_types_json"),
+      createdAt: text2("created_at").notNull().default(sql3`(datetime('now'))`),
+      updatedAt: text2("updated_at")
+    }, (table) => [
+      index2("idx_brain_learnings_confidence").on(table.confidence),
+      index2("idx_brain_learnings_actionable").on(table.actionable)
+    ]);
+    brainObservations = sqliteTable2("brain_observations", {
+      id: text2("id").primaryKey(),
+      type: text2("type", { enum: BRAIN_OBSERVATION_TYPES }).notNull(),
+      title: text2("title").notNull(),
+      subtitle: text2("subtitle"),
+      narrative: text2("narrative"),
+      factsJson: text2("facts_json"),
+      // JSON array of fact strings
+      conceptsJson: text2("concepts_json"),
+      // JSON array of concept strings
+      project: text2("project"),
+      filesReadJson: text2("files_read_json"),
+      // JSON array of file paths
+      filesModifiedJson: text2("files_modified_json"),
+      // JSON array of file paths
+      sourceSessionId: text2("source_session_id"),
+      // soft FK to sessions
+      sourceType: text2("source_type", { enum: BRAIN_OBSERVATION_SOURCE_TYPES }).notNull().default("agent"),
+      contentHash: text2("content_hash"),
+      // SHA-256 prefix for dedup
+      discoveryTokens: integer2("discovery_tokens"),
+      // cost to produce this observation
+      createdAt: text2("created_at").notNull().default(sql3`(datetime('now'))`),
+      updatedAt: text2("updated_at")
+    }, (table) => [
+      index2("idx_brain_observations_type").on(table.type),
+      index2("idx_brain_observations_project").on(table.project),
+      index2("idx_brain_observations_created_at").on(table.createdAt),
+      index2("idx_brain_observations_source_type").on(table.sourceType),
+      index2("idx_brain_observations_source_session").on(table.sourceSessionId),
+      index2("idx_brain_observations_content_hash").on(table.contentHash)
+    ]);
+    brainMemoryLinks = sqliteTable2("brain_memory_links", {
+      memoryType: text2("memory_type", { enum: BRAIN_MEMORY_TYPES }).notNull(),
+      memoryId: text2("memory_id").notNull(),
+      taskId: text2("task_id").notNull(),
+      // soft FK to tasks.id in tasks.db
+      linkType: text2("link_type", { enum: BRAIN_LINK_TYPES }).notNull(),
+      createdAt: text2("created_at").notNull().default(sql3`(datetime('now'))`)
+    }, (table) => [
+      primaryKey2({ columns: [table.memoryType, table.memoryId, table.taskId, table.linkType] }),
+      index2("idx_brain_links_task").on(table.taskId),
+      index2("idx_brain_links_memory").on(table.memoryType, table.memoryId)
+    ]);
+    brainSchemaMeta = sqliteTable2("brain_schema_meta", {
+      key: text2("key").primaryKey(),
+      value: text2("value").notNull()
+    });
+  }
+});
+
+// src/store/brain-sqlite.ts
+import { mkdirSync as mkdirSync6 } from "node:fs";
+import { dirname as dirname6, join as join11 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { readMigrationFiles as readMigrationFiles2 } from "drizzle-orm/migrator";
+import { drizzle as drizzle2 } from "drizzle-orm/sqlite-proxy";
+import { migrate as migrate2 } from "drizzle-orm/sqlite-proxy/migrator";
+function getBrainDbPath(cwd) {
+  return join11(getCleoDirAbsolute(cwd), DB_FILENAME2);
+}
+function resolveBrainMigrationsFolder() {
+  const __filename = fileURLToPath2(import.meta.url);
+  const __dirname = dirname6(__filename);
+  return join11(__dirname, "..", "..", "drizzle-brain");
+}
+function tableExists2(nativeDb, tableName) {
+  const result = nativeDb.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name=?"
+  ).get(tableName);
+  return !!result;
+}
+async function runBrainMigrations(nativeDb, db) {
+  const migrationsFolder = resolveBrainMigrationsFolder();
+  if (tableExists2(nativeDb, "brain_decisions") && !tableExists2(nativeDb, "__drizzle_migrations")) {
+    const migrations = readMigrationFiles2({ migrationsFolder });
+    const baseline = migrations[0];
+    if (baseline) {
+      nativeDb.exec(`
+        CREATE TABLE IF NOT EXISTS "__drizzle_migrations" (
+          id SERIAL PRIMARY KEY,
+          hash text NOT NULL,
+          created_at numeric
+        )
+      `);
+      nativeDb.exec(
+        `INSERT INTO "__drizzle_migrations" ("hash", "created_at") VALUES ('${baseline.hash}', ${baseline.folderMillis})`
+      );
+    }
+  }
+  await migrate2(db, async (queries) => {
+    nativeDb.prepare("BEGIN IMMEDIATE").run();
+    try {
+      for (const query of queries) {
+        nativeDb.prepare(query).run();
+      }
+      nativeDb.prepare("COMMIT").run();
+    } catch (err) {
+      nativeDb.prepare("ROLLBACK").run();
+      throw err;
+    }
+  }, { migrationsFolder });
+}
+async function getBrainDb(cwd) {
+  const requestedPath = getBrainDbPath(cwd);
+  if (_db2 && _dbPath2 !== requestedPath) {
+    resetBrainDbState();
+  }
+  if (_db2) return _db2;
+  if (_initPromise2) return _initPromise2;
+  _initPromise2 = (async () => {
+    const dbPath = requestedPath;
+    _dbPath2 = dbPath;
+    mkdirSync6(dirname6(dbPath), { recursive: true });
+    const nativeDb = openNativeDatabase(dbPath);
+    _nativeDb2 = nativeDb;
+    const callback = createDrizzleCallback(nativeDb);
+    const batchCb = createBatchCallback(nativeDb);
+    const db = drizzle2(callback, batchCb, { schema: brain_schema_exports });
+    await runBrainMigrations(nativeDb, db);
+    nativeDb.exec(
+      `INSERT OR IGNORE INTO brain_schema_meta (key, value) VALUES ('schemaVersion', '${BRAIN_SCHEMA_VERSION}')`
+    );
+    _db2 = db;
+    return db;
+  })();
+  try {
+    return await _initPromise2;
+  } finally {
+    _initPromise2 = null;
+  }
+}
+function resetBrainDbState() {
+  if (_nativeDb2) {
+    try {
+      if (_nativeDb2.isOpen) {
+        _nativeDb2.close();
+      }
+    } catch {
+    }
+    _nativeDb2 = null;
+  }
+  _db2 = null;
+  _dbPath2 = null;
+  _initPromise2 = null;
+}
+function getBrainNativeDb() {
+  return _nativeDb2;
+}
+var DB_FILENAME2, BRAIN_SCHEMA_VERSION, _db2, _nativeDb2, _dbPath2, _initPromise2;
+var init_brain_sqlite = __esm({
+  "src/store/brain-sqlite.ts"() {
+    "use strict";
+    init_brain_schema();
+    init_paths();
+    init_node_sqlite_adapter();
+    DB_FILENAME2 = "brain.db";
+    BRAIN_SCHEMA_VERSION = "1.0.0";
+    _db2 = null;
+    _nativeDb2 = null;
+    _dbPath2 = null;
+    _initPromise2 = null;
+  }
+});
+
+// src/core/memory/brain-search.ts
+function checkFts5Available(nativeDb) {
+  if (_fts5Available !== null) return _fts5Available;
+  try {
+    nativeDb.prepare("CREATE VIRTUAL TABLE IF NOT EXISTS _fts5_check USING fts5(test)").run();
+    nativeDb.prepare("DROP TABLE IF EXISTS _fts5_check").run();
+    _fts5Available = true;
+  } catch {
+    _fts5Available = false;
+  }
+  return _fts5Available;
+}
+function execDDL(nativeDb, sql5) {
+  nativeDb.prepare(sql5).run();
+}
+function ensureFts5Tables(nativeDb) {
+  if (!checkFts5Available(nativeDb)) {
+    return false;
+  }
+  execDDL(nativeDb, `
+    CREATE VIRTUAL TABLE IF NOT EXISTS brain_decisions_fts
+    USING fts5(id, decision, rationale, content=brain_decisions, content_rowid=rowid)
+  `);
+  execDDL(nativeDb, `
+    CREATE VIRTUAL TABLE IF NOT EXISTS brain_patterns_fts
+    USING fts5(id, pattern, context, content=brain_patterns, content_rowid=rowid)
+  `);
+  execDDL(nativeDb, `
+    CREATE VIRTUAL TABLE IF NOT EXISTS brain_learnings_fts
+    USING fts5(id, insight, source, content=brain_learnings, content_rowid=rowid)
+  `);
+  execDDL(nativeDb, `
+    CREATE TRIGGER IF NOT EXISTS brain_decisions_ai AFTER INSERT ON brain_decisions BEGIN
+      INSERT INTO brain_decisions_fts(rowid, id, decision, rationale)
+      VALUES (new.rowid, new.id, new.decision, new.rationale);
+    END
+  `);
+  execDDL(nativeDb, `
+    CREATE TRIGGER IF NOT EXISTS brain_decisions_ad AFTER DELETE ON brain_decisions BEGIN
+      INSERT INTO brain_decisions_fts(brain_decisions_fts, rowid, id, decision, rationale)
+      VALUES('delete', old.rowid, old.id, old.decision, old.rationale);
+    END
+  `);
+  execDDL(nativeDb, `
+    CREATE TRIGGER IF NOT EXISTS brain_decisions_au AFTER UPDATE ON brain_decisions BEGIN
+      INSERT INTO brain_decisions_fts(brain_decisions_fts, rowid, id, decision, rationale)
+      VALUES('delete', old.rowid, old.id, old.decision, old.rationale);
+      INSERT INTO brain_decisions_fts(rowid, id, decision, rationale)
+      VALUES (new.rowid, new.id, new.decision, new.rationale);
+    END
+  `);
+  execDDL(nativeDb, `
+    CREATE TRIGGER IF NOT EXISTS brain_patterns_ai AFTER INSERT ON brain_patterns BEGIN
+      INSERT INTO brain_patterns_fts(rowid, id, pattern, context)
+      VALUES (new.rowid, new.id, new.pattern, new.context);
+    END
+  `);
+  execDDL(nativeDb, `
+    CREATE TRIGGER IF NOT EXISTS brain_patterns_ad AFTER DELETE ON brain_patterns BEGIN
+      INSERT INTO brain_patterns_fts(brain_patterns_fts, rowid, id, pattern, context)
+      VALUES('delete', old.rowid, old.id, old.pattern, old.context);
+    END
+  `);
+  execDDL(nativeDb, `
+    CREATE TRIGGER IF NOT EXISTS brain_patterns_au AFTER UPDATE ON brain_patterns BEGIN
+      INSERT INTO brain_patterns_fts(brain_patterns_fts, rowid, id, pattern, context)
+      VALUES('delete', old.rowid, old.id, old.pattern, old.context);
+      INSERT INTO brain_patterns_fts(rowid, id, pattern, context)
+      VALUES (new.rowid, new.id, new.pattern, new.context);
+    END
+  `);
+  execDDL(nativeDb, `
+    CREATE TRIGGER IF NOT EXISTS brain_learnings_ai AFTER INSERT ON brain_learnings BEGIN
+      INSERT INTO brain_learnings_fts(rowid, id, insight, source)
+      VALUES (new.rowid, new.id, new.insight, new.source);
+    END
+  `);
+  execDDL(nativeDb, `
+    CREATE TRIGGER IF NOT EXISTS brain_learnings_ad AFTER DELETE ON brain_learnings BEGIN
+      INSERT INTO brain_learnings_fts(brain_learnings_fts, rowid, id, insight, source)
+      VALUES('delete', old.rowid, old.id, old.insight, old.source);
+    END
+  `);
+  execDDL(nativeDb, `
+    CREATE TRIGGER IF NOT EXISTS brain_learnings_au AFTER UPDATE ON brain_learnings BEGIN
+      INSERT INTO brain_learnings_fts(brain_learnings_fts, rowid, id, insight, source)
+      VALUES('delete', old.rowid, old.id, old.insight, old.source);
+      INSERT INTO brain_learnings_fts(rowid, id, insight, source)
+      VALUES (new.rowid, new.id, new.insight, new.source);
+    END
+  `);
+  execDDL(nativeDb, `
+    CREATE VIRTUAL TABLE IF NOT EXISTS brain_observations_fts
+    USING fts5(id, title, narrative, content=brain_observations, content_rowid=rowid)
+  `);
+  execDDL(nativeDb, `
+    CREATE TRIGGER IF NOT EXISTS brain_observations_ai AFTER INSERT ON brain_observations BEGIN
+      INSERT INTO brain_observations_fts(rowid, id, title, narrative)
+      VALUES (new.rowid, new.id, new.title, new.narrative);
+    END
+  `);
+  execDDL(nativeDb, `
+    CREATE TRIGGER IF NOT EXISTS brain_observations_ad AFTER DELETE ON brain_observations BEGIN
+      INSERT INTO brain_observations_fts(brain_observations_fts, rowid, id, title, narrative)
+      VALUES('delete', old.rowid, old.id, old.title, old.narrative);
+    END
+  `);
+  execDDL(nativeDb, `
+    CREATE TRIGGER IF NOT EXISTS brain_observations_au AFTER UPDATE ON brain_observations BEGIN
+      INSERT INTO brain_observations_fts(brain_observations_fts, rowid, id, title, narrative)
+      VALUES('delete', old.rowid, old.id, old.title, old.narrative);
+      INSERT INTO brain_observations_fts(rowid, id, title, narrative)
+      VALUES (new.rowid, new.id, new.title, new.narrative);
+    END
+  `);
+  return true;
+}
+function rebuildFts5Index(nativeDb) {
+  if (!checkFts5Available(nativeDb)) {
+    return;
+  }
+  nativeDb.prepare("INSERT INTO brain_decisions_fts(brain_decisions_fts) VALUES('rebuild')").run();
+  nativeDb.prepare("INSERT INTO brain_patterns_fts(brain_patterns_fts) VALUES('rebuild')").run();
+  nativeDb.prepare("INSERT INTO brain_learnings_fts(brain_learnings_fts) VALUES('rebuild')").run();
+  try {
+    nativeDb.prepare("INSERT INTO brain_observations_fts(brain_observations_fts) VALUES('rebuild')").run();
+  } catch {
+  }
+}
+async function searchBrain(projectRoot, query, options) {
+  if (!query || !query.trim()) {
+    return { decisions: [], patterns: [], learnings: [], observations: [] };
+  }
+  await getBrainDb(projectRoot);
+  const nativeDb = getBrainNativeDb();
+  if (!nativeDb) {
+    return { decisions: [], patterns: [], learnings: [], observations: [] };
+  }
+  const limit = options?.limit ?? 10;
+  const tables = options?.tables ?? ["decisions", "patterns", "learnings", "observations"];
+  const ftsAvailable = ensureFts5Tables(nativeDb);
+  if (ftsAvailable) {
+    if (!_fts5Initialized) {
+      _fts5Initialized = true;
+      rebuildFts5Index(nativeDb);
+    }
+    return searchWithFts5(nativeDb, query, tables, limit);
+  }
+  return searchWithLike(nativeDb, query, tables, limit);
+}
+function searchWithFts5(nativeDb, query, tables, limit) {
+  const result = {
+    decisions: [],
+    patterns: [],
+    learnings: [],
+    observations: []
+  };
+  const safeQuery = escapeFts5Query(query);
+  if (tables.includes("decisions")) {
+    try {
+      const rows = nativeDb.prepare(`
+        SELECT d.*
+        FROM brain_decisions_fts fts
+        JOIN brain_decisions d ON d.rowid = fts.rowid
+        WHERE brain_decisions_fts MATCH ?
+        ORDER BY bm25(brain_decisions_fts)
+        LIMIT ?
+      `).all(safeQuery, limit);
+      result.decisions = rows;
+    } catch {
+      result.decisions = likeSearchDecisions(nativeDb, query, limit);
+    }
+  }
+  if (tables.includes("patterns")) {
+    try {
+      const rows = nativeDb.prepare(`
+        SELECT p.*
+        FROM brain_patterns_fts fts
+        JOIN brain_patterns p ON p.rowid = fts.rowid
+        WHERE brain_patterns_fts MATCH ?
+        ORDER BY bm25(brain_patterns_fts)
+        LIMIT ?
+      `).all(safeQuery, limit);
+      result.patterns = rows;
+    } catch {
+      result.patterns = likeSearchPatterns(nativeDb, query, limit);
+    }
+  }
+  if (tables.includes("learnings")) {
+    try {
+      const rows = nativeDb.prepare(`
+        SELECT l.*
+        FROM brain_learnings_fts fts
+        JOIN brain_learnings l ON l.rowid = fts.rowid
+        WHERE brain_learnings_fts MATCH ?
+        ORDER BY bm25(brain_learnings_fts)
+        LIMIT ?
+      `).all(safeQuery, limit);
+      result.learnings = rows;
+    } catch {
+      result.learnings = likeSearchLearnings(nativeDb, query, limit);
+    }
+  }
+  if (tables.includes("observations")) {
+    try {
+      const rows = nativeDb.prepare(`
+        SELECT o.*
+        FROM brain_observations_fts fts
+        JOIN brain_observations o ON o.rowid = fts.rowid
+        WHERE brain_observations_fts MATCH ?
+        ORDER BY bm25(brain_observations_fts)
+        LIMIT ?
+      `).all(safeQuery, limit);
+      result.observations = rows;
+    } catch {
+      result.observations = likeSearchObservations(nativeDb, query, limit);
+    }
+  }
+  return result;
+}
+function searchWithLike(nativeDb, query, tables, limit) {
+  const result = {
+    decisions: [],
+    patterns: [],
+    learnings: [],
+    observations: []
+  };
+  if (tables.includes("decisions")) {
+    result.decisions = likeSearchDecisions(nativeDb, query, limit);
+  }
+  if (tables.includes("patterns")) {
+    result.patterns = likeSearchPatterns(nativeDb, query, limit);
+  }
+  if (tables.includes("learnings")) {
+    result.learnings = likeSearchLearnings(nativeDb, query, limit);
+  }
+  if (tables.includes("observations")) {
+    result.observations = likeSearchObservations(nativeDb, query, limit);
+  }
+  return result;
+}
+function likeSearchDecisions(nativeDb, query, limit) {
+  const likePattern = `%${query}%`;
+  return nativeDb.prepare(`
+    SELECT * FROM brain_decisions
+    WHERE decision LIKE ? OR rationale LIKE ?
+    ORDER BY created_at DESC
+    LIMIT ?
+  `).all(likePattern, likePattern, limit);
+}
+function likeSearchPatterns(nativeDb, query, limit) {
+  const likePattern = `%${query}%`;
+  return nativeDb.prepare(`
+    SELECT * FROM brain_patterns
+    WHERE pattern LIKE ? OR context LIKE ?
+    ORDER BY frequency DESC
+    LIMIT ?
+  `).all(likePattern, likePattern, limit);
+}
+function likeSearchLearnings(nativeDb, query, limit) {
+  const likePattern = `%${query}%`;
+  return nativeDb.prepare(`
+    SELECT * FROM brain_learnings
+    WHERE insight LIKE ? OR source LIKE ?
+    ORDER BY confidence DESC
+    LIMIT ?
+  `).all(likePattern, likePattern, limit);
+}
+function likeSearchObservations(nativeDb, query, limit) {
+  const likePattern = `%${query}%`;
+  return nativeDb.prepare(`
+    SELECT * FROM brain_observations
+    WHERE title LIKE ? OR narrative LIKE ?
+    ORDER BY created_at DESC
+    LIMIT ?
+  `).all(likePattern, likePattern, limit);
+}
+function escapeFts5Query(query) {
+  const tokens = query.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) return '""';
+  return tokens.map((t) => `"${t.replace(/"/g, '""')}"`).join(" ");
+}
+var _fts5Available, _fts5Initialized;
+var init_brain_search = __esm({
+  "src/core/memory/brain-search.ts"() {
+    "use strict";
+    init_brain_sqlite();
+    _fts5Available = null;
+    _fts5Initialized = false;
+  }
+});
+
+// src/store/brain-accessor.ts
+import { eq as eq7, and as and2, gte, desc, asc as asc2 } from "drizzle-orm";
+async function getBrainAccessor(cwd) {
+  const db = await getBrainDb(cwd);
+  return new BrainDataAccessor(db);
+}
+var BrainDataAccessor;
+var init_brain_accessor = __esm({
+  "src/store/brain-accessor.ts"() {
+    "use strict";
+    init_brain_sqlite();
+    init_brain_schema();
+    BrainDataAccessor = class {
+      constructor(db) {
+        this.db = db;
+      }
+      // =========================================================================
+      // Decisions CRUD
+      // =========================================================================
+      async addDecision(row) {
+        await this.db.insert(brainDecisions).values(row);
+        const result = await this.db.select().from(brainDecisions).where(eq7(brainDecisions.id, row.id));
+        return result[0];
+      }
+      async getDecision(id) {
+        const result = await this.db.select().from(brainDecisions).where(eq7(brainDecisions.id, id));
+        return result[0] ?? null;
+      }
+      async findDecisions(params = {}) {
+        const conditions = [];
+        if (params.type) {
+          conditions.push(eq7(brainDecisions.type, params.type));
+        }
+        if (params.confidence) {
+          conditions.push(eq7(brainDecisions.confidence, params.confidence));
+        }
+        if (params.outcome) {
+          conditions.push(eq7(brainDecisions.outcome, params.outcome));
+        }
+        if (params.contextTaskId) {
+          conditions.push(eq7(brainDecisions.contextTaskId, params.contextTaskId));
+        }
+        let query = this.db.select().from(brainDecisions).orderBy(desc(brainDecisions.createdAt));
+        if (conditions.length > 0) {
+          query = query.where(and2(...conditions));
+        }
+        if (params.limit) {
+          query = query.limit(params.limit);
+        }
+        return query;
+      }
+      async updateDecision(id, updates) {
+        await this.db.update(brainDecisions).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq7(brainDecisions.id, id));
+      }
+      // =========================================================================
+      // Patterns CRUD
+      // =========================================================================
+      async addPattern(row) {
+        await this.db.insert(brainPatterns).values(row);
+        const result = await this.db.select().from(brainPatterns).where(eq7(brainPatterns.id, row.id));
+        return result[0];
+      }
+      async getPattern(id) {
+        const result = await this.db.select().from(brainPatterns).where(eq7(brainPatterns.id, id));
+        return result[0] ?? null;
+      }
+      async findPatterns(params = {}) {
+        const conditions = [];
+        if (params.type) {
+          conditions.push(eq7(brainPatterns.type, params.type));
+        }
+        if (params.impact) {
+          conditions.push(eq7(brainPatterns.impact, params.impact));
+        }
+        if (params.minFrequency !== void 0) {
+          conditions.push(gte(brainPatterns.frequency, params.minFrequency));
+        }
+        let query = this.db.select().from(brainPatterns).orderBy(desc(brainPatterns.frequency));
+        if (conditions.length > 0) {
+          query = query.where(and2(...conditions));
+        }
+        if (params.limit) {
+          query = query.limit(params.limit);
+        }
+        return query;
+      }
+      async updatePattern(id, updates) {
+        await this.db.update(brainPatterns).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq7(brainPatterns.id, id));
+      }
+      // =========================================================================
+      // Learnings CRUD
+      // =========================================================================
+      async addLearning(row) {
+        await this.db.insert(brainLearnings).values(row);
+        const result = await this.db.select().from(brainLearnings).where(eq7(brainLearnings.id, row.id));
+        return result[0];
+      }
+      async getLearning(id) {
+        const result = await this.db.select().from(brainLearnings).where(eq7(brainLearnings.id, id));
+        return result[0] ?? null;
+      }
+      async findLearnings(params = {}) {
+        const conditions = [];
+        if (params.minConfidence !== void 0) {
+          conditions.push(gte(brainLearnings.confidence, params.minConfidence));
+        }
+        if (params.actionable !== void 0) {
+          conditions.push(eq7(brainLearnings.actionable, params.actionable));
+        }
+        let query = this.db.select().from(brainLearnings).orderBy(desc(brainLearnings.confidence));
+        if (conditions.length > 0) {
+          query = query.where(and2(...conditions));
+        }
+        if (params.limit) {
+          query = query.limit(params.limit);
+        }
+        return query;
+      }
+      async updateLearning(id, updates) {
+        await this.db.update(brainLearnings).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq7(brainLearnings.id, id));
+      }
+      // =========================================================================
+      // Observations CRUD
+      // =========================================================================
+      async addObservation(row) {
+        await this.db.insert(brainObservations).values(row);
+        const result = await this.db.select().from(brainObservations).where(eq7(brainObservations.id, row.id));
+        return result[0];
+      }
+      async getObservation(id) {
+        const result = await this.db.select().from(brainObservations).where(eq7(brainObservations.id, id));
+        return result[0] ?? null;
+      }
+      async findObservations(params = {}) {
+        const conditions = [];
+        if (params.type) {
+          conditions.push(eq7(brainObservations.type, params.type));
+        }
+        if (params.project) {
+          conditions.push(eq7(brainObservations.project, params.project));
+        }
+        if (params.sourceType) {
+          conditions.push(eq7(brainObservations.sourceType, params.sourceType));
+        }
+        if (params.sourceSessionId) {
+          conditions.push(eq7(brainObservations.sourceSessionId, params.sourceSessionId));
+        }
+        let query = this.db.select().from(brainObservations).orderBy(desc(brainObservations.createdAt));
+        if (conditions.length > 0) {
+          query = query.where(and2(...conditions));
+        }
+        if (params.limit) {
+          query = query.limit(params.limit);
+        }
+        return query;
+      }
+      async updateObservation(id, updates) {
+        await this.db.update(brainObservations).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq7(brainObservations.id, id));
+      }
+      // =========================================================================
+      // Memory Links CRUD
+      // =========================================================================
+      async addLink(row) {
+        await this.db.insert(brainMemoryLinks).values(row);
+      }
+      async getLinksForMemory(memoryType, memoryId) {
+        return this.db.select().from(brainMemoryLinks).where(
+          and2(
+            eq7(brainMemoryLinks.memoryType, memoryType),
+            eq7(brainMemoryLinks.memoryId, memoryId)
+          )
+        ).orderBy(asc2(brainMemoryLinks.createdAt));
+      }
+      async getLinksForTask(taskId) {
+        return this.db.select().from(brainMemoryLinks).where(eq7(brainMemoryLinks.taskId, taskId)).orderBy(asc2(brainMemoryLinks.createdAt));
+      }
+      async removeLink(memoryType, memoryId, taskId, linkType) {
+        await this.db.delete(brainMemoryLinks).where(
+          and2(
+            eq7(brainMemoryLinks.memoryType, memoryType),
+            eq7(brainMemoryLinks.memoryId, memoryId),
+            eq7(brainMemoryLinks.taskId, taskId),
+            eq7(brainMemoryLinks.linkType, linkType)
+          )
+        );
+      }
+    };
+  }
+});
+
+// src/core/memory/brain-retrieval.ts
+var brain_retrieval_exports = {};
+__export(brain_retrieval_exports, {
+  fetchBrainEntries: () => fetchBrainEntries,
+  observeBrain: () => observeBrain,
+  searchBrainCompact: () => searchBrainCompact,
+  timelineBrain: () => timelineBrain
+});
+import { createHash as createHash3 } from "node:crypto";
+async function searchBrainCompact(projectRoot, params) {
+  const { query, limit, tables, dateStart, dateEnd } = params;
+  if (!query || !query.trim()) {
+    return { results: [], total: 0, tokensEstimated: 0 };
+  }
+  const searchResult = await searchBrain(projectRoot, query, {
+    limit: limit ?? 10,
+    tables
+  });
+  let results = [];
+  for (const d of searchResult.decisions) {
+    const raw = d;
+    results.push({
+      id: d.id,
+      type: "decision",
+      title: d.decision.slice(0, 80),
+      date: (d.createdAt ?? raw["created_at"]) || ""
+    });
+  }
+  for (const p of searchResult.patterns) {
+    const raw = p;
+    results.push({
+      id: p.id,
+      type: "pattern",
+      title: p.pattern.slice(0, 80),
+      date: (p.extractedAt ?? raw["extracted_at"]) || ""
+    });
+  }
+  for (const l of searchResult.learnings) {
+    const raw = l;
+    results.push({
+      id: l.id,
+      type: "learning",
+      title: l.insight.slice(0, 80),
+      date: (l.createdAt ?? raw["created_at"]) || ""
+    });
+  }
+  for (const o of searchResult.observations) {
+    const raw = o;
+    results.push({
+      id: o.id,
+      type: "observation",
+      title: o.title.slice(0, 80),
+      date: (o.createdAt ?? raw["created_at"]) || ""
+    });
+  }
+  if (dateStart) {
+    results = results.filter((r) => r.date >= dateStart);
+  }
+  if (dateEnd) {
+    results = results.filter((r) => r.date <= dateEnd);
+  }
+  return {
+    results,
+    total: results.length,
+    tokensEstimated: results.length * 50
+  };
+}
+function parseIdPrefix(id) {
+  if (id.startsWith("D-") || /^D\d/.test(id)) return "decision";
+  if (id.startsWith("P-") || /^P\d/.test(id)) return "pattern";
+  if (id.startsWith("L-") || /^L\d/.test(id)) return "learning";
+  if (id.startsWith("O-") || id.startsWith("O") || id.startsWith("CM-")) return "observation";
+  return null;
+}
+async function timelineBrain(projectRoot, params) {
+  const { anchor: anchorId, depthBefore = 3, depthAfter = 3 } = params;
+  await getBrainDb(projectRoot);
+  const nativeDb = getBrainNativeDb();
+  if (!nativeDb) {
+    return { anchor: null, before: [], after: [] };
+  }
+  const anchorType = parseIdPrefix(anchorId);
+  if (!anchorType) {
+    return { anchor: null, before: [], after: [] };
+  }
+  const accessor = await getBrainAccessor(projectRoot);
+  let anchorData = null;
+  let anchorDate = null;
+  switch (anchorType) {
+    case "decision": {
+      const row = await accessor.getDecision(anchorId);
+      if (row) {
+        anchorData = row;
+        anchorDate = row.createdAt;
+      }
+      break;
+    }
+    case "pattern": {
+      const row = await accessor.getPattern(anchorId);
+      if (row) {
+        anchorData = row;
+        anchorDate = row.extractedAt;
+      }
+      break;
+    }
+    case "learning": {
+      const row = await accessor.getLearning(anchorId);
+      if (row) {
+        anchorData = row;
+        anchorDate = row.createdAt;
+      }
+      break;
+    }
+    case "observation": {
+      const row = await accessor.getObservation(anchorId);
+      if (row) {
+        anchorData = row;
+        anchorDate = row.createdAt;
+      }
+      break;
+    }
+  }
+  if (!anchorData || !anchorDate) {
+    return { anchor: null, before: [], after: [] };
+  }
+  const beforeRows = nativeDb.prepare(`
+    SELECT id, 'decision' AS type, created_at AS date FROM brain_decisions WHERE created_at < ? AND id != ?
+    UNION ALL
+    SELECT id, 'pattern' AS type, extracted_at AS date FROM brain_patterns WHERE extracted_at < ? AND id != ?
+    UNION ALL
+    SELECT id, 'learning' AS type, created_at AS date FROM brain_learnings WHERE created_at < ? AND id != ?
+    UNION ALL
+    SELECT id, 'observation' AS type, created_at AS date FROM brain_observations WHERE created_at < ? AND id != ?
+    ORDER BY date DESC
+    LIMIT ?
+  `).all(
+    anchorDate,
+    anchorId,
+    anchorDate,
+    anchorId,
+    anchorDate,
+    anchorId,
+    anchorDate,
+    anchorId,
+    depthBefore
+  );
+  const afterRows = nativeDb.prepare(`
+    SELECT id, 'decision' AS type, created_at AS date FROM brain_decisions WHERE created_at > ? AND id != ?
+    UNION ALL
+    SELECT id, 'pattern' AS type, extracted_at AS date FROM brain_patterns WHERE extracted_at > ? AND id != ?
+    UNION ALL
+    SELECT id, 'learning' AS type, created_at AS date FROM brain_learnings WHERE created_at > ? AND id != ?
+    UNION ALL
+    SELECT id, 'observation' AS type, created_at AS date FROM brain_observations WHERE created_at > ? AND id != ?
+    ORDER BY date ASC
+    LIMIT ?
+  `).all(
+    anchorDate,
+    anchorId,
+    anchorDate,
+    anchorId,
+    anchorDate,
+    anchorId,
+    anchorDate,
+    anchorId,
+    depthAfter
+  );
+  return {
+    anchor: { id: anchorId, type: anchorType, data: anchorData },
+    before: beforeRows.map((r) => ({ id: r.id, type: r.type, date: r.date })),
+    after: afterRows.map((r) => ({ id: r.id, type: r.type, date: r.date }))
+  };
+}
+async function fetchBrainEntries(projectRoot, params) {
+  const { ids } = params;
+  if (!ids || ids.length === 0) {
+    return { results: [], notFound: [], tokensEstimated: 0 };
+  }
+  const accessor = await getBrainAccessor(projectRoot);
+  const decisionIds = [];
+  const patternIds = [];
+  const learningIds = [];
+  const observationIds = [];
+  const unknownIds = [];
+  for (const id of ids) {
+    const type = parseIdPrefix(id);
+    switch (type) {
+      case "decision":
+        decisionIds.push(id);
+        break;
+      case "pattern":
+        patternIds.push(id);
+        break;
+      case "learning":
+        learningIds.push(id);
+        break;
+      case "observation":
+        observationIds.push(id);
+        break;
+      default:
+        unknownIds.push(id);
+    }
+  }
+  const results = [];
+  const notFound = [...unknownIds];
+  for (const id of decisionIds) {
+    const row = await accessor.getDecision(id);
+    if (row) {
+      results.push({ id, type: "decision", data: row });
+    } else {
+      notFound.push(id);
+    }
+  }
+  for (const id of patternIds) {
+    const row = await accessor.getPattern(id);
+    if (row) {
+      results.push({ id, type: "pattern", data: row });
+    } else {
+      notFound.push(id);
+    }
+  }
+  for (const id of learningIds) {
+    const row = await accessor.getLearning(id);
+    if (row) {
+      results.push({ id, type: "learning", data: row });
+    } else {
+      notFound.push(id);
+    }
+  }
+  for (const id of observationIds) {
+    const row = await accessor.getObservation(id);
+    if (row) {
+      results.push({ id, type: "observation", data: row });
+    } else {
+      notFound.push(id);
+    }
+  }
+  return {
+    results,
+    notFound,
+    tokensEstimated: results.length * 500
+  };
+}
+function classifyObservationType(text3) {
+  const lower = text3.toLowerCase();
+  for (const { keywords, type } of TYPE_KEYWORDS) {
+    for (const keyword of keywords) {
+      if (lower.includes(keyword)) {
+        return type;
+      }
+    }
+  }
+  return "discovery";
+}
+async function observeBrain(projectRoot, params) {
+  const { text: text3, title: titleParam, type: typeParam, project, sourceSessionId, sourceType } = params;
+  if (!text3 || !text3.trim()) {
+    throw new Error("Observation text is required");
+  }
+  const type = typeParam ?? classifyObservationType(text3);
+  const title = titleParam ?? text3.slice(0, 120);
+  const now = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  const contentHash = createHash3("sha256").update(title + text3).digest("hex").slice(0, 16);
+  const nativeDb = getBrainNativeDb();
+  if (nativeDb) {
+    const cutoff = new Date(Date.now() - 3e4).toISOString().replace("T", " ").slice(0, 19);
+    const existing = nativeDb.prepare(
+      "SELECT id, type, created_at FROM brain_observations WHERE content_hash = ? AND created_at > ?"
+    ).all(contentHash, cutoff);
+    if (existing.length > 0) {
+      return {
+        id: existing[0].id,
+        type: existing[0].type,
+        createdAt: existing[0].created_at
+      };
+    }
+  }
+  const id = `O-${Date.now().toString(36)}`;
+  const accessor = await getBrainAccessor(projectRoot);
+  const row = await accessor.addObservation({
+    id,
+    type,
+    title,
+    narrative: text3,
+    contentHash,
+    project: project ?? null,
+    sourceSessionId: sourceSessionId ?? null,
+    sourceType: sourceType ?? "agent",
+    createdAt: now
+  });
+  return {
+    id: row.id,
+    type: row.type,
+    createdAt: row.createdAt
+  };
+}
+var TYPE_KEYWORDS;
+var init_brain_retrieval = __esm({
+  "src/core/memory/brain-retrieval.ts"() {
+    "use strict";
+    init_brain_search();
+    init_brain_accessor();
+    init_brain_sqlite();
+    TYPE_KEYWORDS = [
+      { keywords: ["bug", "fix", "error", "crash"], type: "bugfix" },
+      { keywords: ["refactor", "rename", "extract", "move"], type: "refactor" },
+      { keywords: ["add", "create", "implement", "new"], type: "feature" },
+      { keywords: ["decide", "chose", "pick", "instead"], type: "decision" },
+      { keywords: ["update", "change", "modify", "upgrade"], type: "change" }
+    ];
+  }
+});
+
+// src/core/memory/brain-links.ts
+var brain_links_exports = {};
+__export(brain_links_exports, {
+  bulkLink: () => bulkLink,
+  getLinkedDecisions: () => getLinkedDecisions,
+  getLinkedLearnings: () => getLinkedLearnings,
+  getLinkedPatterns: () => getLinkedPatterns,
+  getMemoryLinks: () => getMemoryLinks,
+  getTaskLinks: () => getTaskLinks,
+  linkMemoryToTask: () => linkMemoryToTask,
+  unlinkMemoryFromTask: () => unlinkMemoryFromTask
+});
+async function linkMemoryToTask(projectRoot, memoryType, memoryId, taskId, linkType) {
+  if (!memoryId || !taskId) {
+    throw new Error("memoryId and taskId are required");
+  }
+  const accessor = await getBrainAccessor(projectRoot);
+  const existingLinks = await accessor.getLinksForMemory(memoryType, memoryId);
+  const duplicate = existingLinks.find(
+    (l) => l.taskId === taskId && l.linkType === linkType
+  );
+  if (duplicate) {
+    return duplicate;
+  }
+  await accessor.addLink({
+    memoryType,
+    memoryId,
+    taskId,
+    linkType
+  });
+  const links = await accessor.getLinksForMemory(memoryType, memoryId);
+  return links.find(
+    (l) => l.taskId === taskId && l.linkType === linkType
+  );
+}
+async function unlinkMemoryFromTask(projectRoot, memoryType, memoryId, taskId, linkType) {
+  const accessor = await getBrainAccessor(projectRoot);
+  await accessor.removeLink(memoryType, memoryId, taskId, linkType);
+}
+async function getTaskLinks(projectRoot, taskId) {
+  const accessor = await getBrainAccessor(projectRoot);
+  return accessor.getLinksForTask(taskId);
+}
+async function getMemoryLinks(projectRoot, memoryType, memoryId) {
+  const accessor = await getBrainAccessor(projectRoot);
+  return accessor.getLinksForMemory(memoryType, memoryId);
+}
+async function bulkLink(projectRoot, links) {
+  const accessor = await getBrainAccessor(projectRoot);
+  let created = 0;
+  let skipped = 0;
+  for (const link of links) {
+    const existing = await accessor.getLinksForMemory(link.memoryType, link.memoryId);
+    const duplicate = existing.find(
+      (l) => l.taskId === link.taskId && l.linkType === link.linkType
+    );
+    if (duplicate) {
+      skipped++;
+      continue;
+    }
+    await accessor.addLink({
+      memoryType: link.memoryType,
+      memoryId: link.memoryId,
+      taskId: link.taskId,
+      linkType: link.linkType
+    });
+    created++;
+  }
+  return { created, skipped };
+}
+async function getLinkedDecisions(projectRoot, taskId) {
+  const accessor = await getBrainAccessor(projectRoot);
+  const links = await accessor.getLinksForTask(taskId);
+  const decisionLinks = links.filter((l) => l.memoryType === "decision");
+  const decisions = [];
+  for (const link of decisionLinks) {
+    const decision = await accessor.getDecision(link.memoryId);
+    if (decision) {
+      decisions.push(decision);
+    }
+  }
+  return decisions;
+}
+async function getLinkedPatterns(projectRoot, taskId) {
+  const accessor = await getBrainAccessor(projectRoot);
+  const links = await accessor.getLinksForTask(taskId);
+  const patternLinks = links.filter((l) => l.memoryType === "pattern");
+  const patterns = [];
+  for (const link of patternLinks) {
+    const pattern = await accessor.getPattern(link.memoryId);
+    if (pattern) {
+      patterns.push(pattern);
+    }
+  }
+  return patterns;
+}
+async function getLinkedLearnings(projectRoot, taskId) {
+  const accessor = await getBrainAccessor(projectRoot);
+  const links = await accessor.getLinksForTask(taskId);
+  const learningLinks = links.filter((l) => l.memoryType === "learning");
+  const learnings = [];
+  for (const link of learningLinks) {
+    const learning = await accessor.getLearning(link.memoryId);
+    if (learning) {
+      learnings.push(learning);
+    }
+  }
+  return learnings;
+}
+var init_brain_links = __esm({
+  "src/core/memory/brain-links.ts"() {
+    "use strict";
+    init_brain_accessor();
+  }
+});
+
+// src/core/memory/session-memory.ts
+var session_memory_exports = {};
+__export(session_memory_exports, {
+  extractMemoryItems: () => extractMemoryItems,
+  getSessionMemoryContext: () => getSessionMemoryContext,
+  persistSessionMemory: () => persistSessionMemory
+});
+function extractMemoryItems(sessionId, debrief) {
+  if (!debrief) return [];
+  const items = [];
+  if (Array.isArray(debrief.decisions)) {
+    for (const d of debrief.decisions) {
+      const decision = d;
+      if (!decision.decision) continue;
+      const text3 = `Decision: ${decision.decision}
+Rationale: ${decision.rationale ?? "N/A"}`;
+      items.push({
+        text: text3,
+        title: decision.decision.slice(0, 120),
+        type: "decision",
+        sourceSessionId: sessionId,
+        sourceType: "session-debrief",
+        linkTaskId: decision.taskId || void 0
+      });
+    }
+  }
+  const tasksCompleted = debrief.handoff?.tasksCompleted;
+  if (Array.isArray(tasksCompleted) && tasksCompleted.length > 0) {
+    const taskList2 = tasksCompleted.join(", ");
+    const nextSuggested = debrief.handoff?.nextSuggested;
+    const nextPart = Array.isArray(nextSuggested) && nextSuggested.length > 0 ? ` Next suggested: ${nextSuggested.join(", ")}` : "";
+    const text3 = `Session ${sessionId} completed ${tasksCompleted.length} tasks: ${taskList2}.${nextPart}`;
+    items.push({
+      text: text3,
+      title: `Session ${sessionId} summary: ${tasksCompleted.length} tasks completed`.slice(0, 120),
+      type: "change",
+      sourceSessionId: sessionId,
+      sourceType: "session-debrief"
+    });
+  }
+  const note = debrief.handoff?.note;
+  if (typeof note === "string" && note.trim()) {
+    items.push({
+      text: note,
+      title: `Session note: ${note.slice(0, 100)}`.slice(0, 120),
+      type: "discovery",
+      sourceSessionId: sessionId,
+      sourceType: "session-debrief"
+    });
+  }
+  return items;
+}
+async function persistSessionMemory(projectRoot, sessionId, debrief) {
+  const result = {
+    observationsCreated: 0,
+    linksCreated: 0,
+    observationIds: [],
+    errors: []
+  };
+  if (!debrief) return result;
+  const items = extractMemoryItems(sessionId, debrief);
+  if (items.length === 0) return result;
+  let observeBrain2;
+  let linkMemoryToTask2;
+  try {
+    const retrieval = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
+    observeBrain2 = retrieval.observeBrain;
+    const links = await Promise.resolve().then(() => (init_brain_links(), brain_links_exports));
+    linkMemoryToTask2 = links.linkMemoryToTask;
+  } catch (err) {
+    result.errors.push(`Failed to load brain modules: ${err instanceof Error ? err.message : String(err)}`);
+    return result;
+  }
+  for (const item of items) {
+    let obsResult = null;
+    try {
+      obsResult = await observeBrain2(projectRoot, {
+        text: item.text,
+        title: item.title,
+        type: item.type,
+        sourceSessionId: item.sourceSessionId,
+        sourceType: item.sourceType
+      });
+      result.observationsCreated++;
+      result.observationIds.push(obsResult.id);
+    } catch (err) {
+      result.errors.push(`Failed to create observation: ${err instanceof Error ? err.message : String(err)}`);
+      continue;
+    }
+    if (item.linkTaskId && obsResult) {
+      try {
+        await linkMemoryToTask2(
+          projectRoot,
+          "observation",
+          obsResult.id,
+          item.linkTaskId,
+          "produced_by"
+        );
+        result.linksCreated++;
+      } catch (err) {
+        result.errors.push(`Failed to link observation ${obsResult.id} to task ${item.linkTaskId}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  return result;
+}
+async function getSessionMemoryContext(projectRoot, scope, options) {
+  const emptyContext = {
+    recentDecisions: [],
+    relevantPatterns: [],
+    recentObservations: [],
+    tokensEstimated: 0
+  };
+  let searchBrainCompact2;
+  try {
+    const retrieval = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
+    searchBrainCompact2 = retrieval.searchBrainCompact;
+  } catch {
+    return emptyContext;
+  }
+  const limit = options?.limit ?? 5;
+  const scopeQuery = scope?.rootTaskId ?? scope?.epicId ?? "";
+  try {
+    const [decisionsResult, patternsResult, observationsResult] = await Promise.all([
+      // Decisions: scope-filtered if we have a task ID, otherwise recent
+      scopeQuery ? searchBrainCompact2(projectRoot, {
+        query: scopeQuery,
+        limit,
+        tables: ["decisions"]
+      }) : Promise.resolve({ results: [], total: 0, tokensEstimated: 0 }),
+      // Patterns: recent patterns
+      searchBrainCompact2(projectRoot, {
+        query: scopeQuery || "pattern",
+        limit: Math.min(limit, 3),
+        tables: ["patterns"]
+      }),
+      // Observations: recent session-debrief observations
+      searchBrainCompact2(projectRoot, {
+        query: scopeQuery || "session",
+        limit,
+        tables: ["observations"]
+      })
+    ]);
+    const tokensEstimated = decisionsResult.tokensEstimated + patternsResult.tokensEstimated + observationsResult.tokensEstimated;
+    return {
+      recentDecisions: decisionsResult.results,
+      relevantPatterns: patternsResult.results,
+      recentObservations: observationsResult.results,
+      tokensEstimated
+    };
+  } catch {
+    return emptyContext;
+  }
+}
+var init_session_memory = __esm({
+  "src/core/memory/session-memory.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/platform.ts
 var platform_exports = {};
 __export(platform_exports, {
@@ -3877,9 +5209,9 @@ __export(platform_exports, {
 });
 import { execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 import { existsSync as existsSync11, statSync as statSync2 } from "node:fs";
-import { createHash as createHash3, randomBytes as randomBytes6 } from "node:crypto";
+import { createHash as createHash4, randomBytes as randomBytes6 } from "node:crypto";
 function detectPlatform() {
   switch (process.platform) {
     case "linux":
@@ -3948,11 +5280,11 @@ function generateRandomHex(bytes = 6) {
   return randomBytes6(bytes).toString("hex");
 }
 function sha256(data) {
-  return createHash3("sha256").update(data).digest("hex");
+  return createHash4("sha256").update(data).digest("hex");
 }
 function createTempFilePath(prefix = "cleo-", suffix = ".tmp") {
   const random = generateRandomHex(8);
-  return join11(tmpdir(), `${prefix}${random}${suffix}`);
+  return join12(tmpdir(), `${prefix}${random}${suffix}`);
 }
 function getNodeVersionInfo() {
   const version = process.version.replace("v", "");
@@ -4021,7 +5353,7 @@ var init_platform = __esm({
 
 // src/core/migration/preflight.ts
 import { existsSync as existsSync13, readFileSync as readFileSync7, statSync as statSync3 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function checkStorageMigration(cwd) {
   const cleoDir = getCleoDirAbsolute(cwd);
   const details = {
@@ -4036,7 +5368,7 @@ function checkStorageMigration(cwd) {
     tasksDbSize: 0,
     configEngine: null
   };
-  const configPath = join13(cleoDir, "config.json");
+  const configPath = join14(cleoDir, "config.json");
   if (existsSync13(configPath)) {
     try {
       const config = JSON.parse(readFileSync7(configPath, "utf-8"));
@@ -4044,7 +5376,7 @@ function checkStorageMigration(cwd) {
     } catch {
     }
   }
-  const todoPath = join13(cleoDir, "todo.json");
+  const todoPath = join14(cleoDir, "todo.json");
   if (existsSync13(todoPath)) {
     details.todoJsonExists = true;
     try {
@@ -4053,7 +5385,7 @@ function checkStorageMigration(cwd) {
     } catch {
     }
   }
-  const archivePath = join13(cleoDir, "todo-archive.json");
+  const archivePath = join14(cleoDir, "todo-archive.json");
   if (existsSync13(archivePath)) {
     details.archiveJsonExists = true;
     try {
@@ -4062,7 +5394,7 @@ function checkStorageMigration(cwd) {
     } catch {
     }
   }
-  const sessionsPath = join13(cleoDir, "sessions.json");
+  const sessionsPath = join14(cleoDir, "sessions.json");
   if (existsSync13(sessionsPath)) {
     details.sessionsJsonExists = true;
     try {
@@ -4071,11 +5403,11 @@ function checkStorageMigration(cwd) {
     } catch {
     }
   }
-  const tasksJsonPath = join13(cleoDir, "tasks.json");
+  const tasksJsonPath = join14(cleoDir, "tasks.json");
   if (existsSync13(tasksJsonPath)) {
     details.tasksJsonExists = true;
   }
-  const dbPath = join13(cleoDir, "tasks.db");
+  const dbPath = join14(cleoDir, "tasks.db");
   if (existsSync13(dbPath)) {
     details.tasksDbExists = true;
     try {
@@ -4123,17 +5455,17 @@ import {
   existsSync as existsSync14,
   readFileSync as readFileSync8,
   writeFileSync as writeFileSync2,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   readdirSync as readdirSync3,
   copyFileSync as copyFileSync2,
   statSync as statSync4,
   rmSync
 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 function detectLegacyAgentOutputs(projectRoot, cleoDir) {
-  const hasResearchOutputs = existsSync14(join14(projectRoot, "claudedocs", "research-outputs"));
-  const hasLegacyAgentOutputs = existsSync14(join14(projectRoot, "claudedocs", "agent-outputs"));
-  const hasCanonical = existsSync14(join14(cleoDir, "agent-outputs"));
+  const hasResearchOutputs = existsSync14(join15(projectRoot, "claudedocs", "research-outputs"));
+  const hasLegacyAgentOutputs = existsSync14(join15(projectRoot, "claudedocs", "agent-outputs"));
+  const hasCanonical = existsSync14(join15(cleoDir, "agent-outputs"));
   const legacyPaths = [];
   if (hasResearchOutputs) legacyPaths.push("claudedocs/research-outputs/");
   if (hasLegacyAgentOutputs) legacyPaths.push("claudedocs/agent-outputs/");
@@ -4156,15 +5488,15 @@ function migrateAgentOutputs(projectRoot, cleoDir) {
       summary: "No legacy output directories found"
     };
   }
-  const newDir = join14(cleoDir, "agent-outputs");
+  const newDir = join15(cleoDir, "agent-outputs");
   const hadCanonical = detection.hasCanonical;
-  mkdirSync6(newDir, { recursive: true });
+  mkdirSync7(newDir, { recursive: true });
   let totalCopied = 0;
   const mergedManifestLines = [];
   const copiedFiles = /* @__PURE__ */ new Set();
   const legacySources = [
-    { path: join14(projectRoot, "claudedocs", "research-outputs"), exists: detection.hasResearchOutputs },
-    { path: join14(projectRoot, "claudedocs", "agent-outputs"), exists: detection.hasLegacyAgentOutputs }
+    { path: join15(projectRoot, "claudedocs", "research-outputs"), exists: detection.hasResearchOutputs },
+    { path: join15(projectRoot, "claudedocs", "agent-outputs"), exists: detection.hasLegacyAgentOutputs }
   ];
   for (const source of legacySources) {
     if (!source.exists) continue;
@@ -4189,19 +5521,19 @@ function copyDirContents(srcDir, dstDir, manifestLines, copiedFiles) {
   const entries = readdirSync3(srcDir);
   for (const entry of entries) {
     if (entry === "MANIFEST.jsonl") {
-      collectManifestLines(join14(srcDir, entry), manifestLines);
+      collectManifestLines(join15(srcDir, entry), manifestLines);
       continue;
     }
-    const srcPath = join14(srcDir, entry);
-    const dstPath = join14(dstDir, entry);
+    const srcPath = join15(srcDir, entry);
+    const dstPath = join15(dstDir, entry);
     try {
       const st = statSync4(srcPath);
       if (st.isDirectory()) {
-        mkdirSync6(dstPath, { recursive: true });
+        mkdirSync7(dstPath, { recursive: true });
         for (const sf of readdirSync3(srcPath)) {
           if (!copiedFiles.has(sf)) {
             try {
-              copyFileSync2(join14(srcPath, sf), join14(dstPath, sf));
+              copyFileSync2(join15(srcPath, sf), join15(dstPath, sf));
               copiedFiles.add(sf);
               count2++;
             } catch {
@@ -4233,7 +5565,7 @@ function collectManifestLines(manifestPath, out) {
   }
 }
 function mergeManifests(newDir, hadCanonical, legacyLines) {
-  const manifestPath = join14(newDir, "MANIFEST.jsonl");
+  const manifestPath = join15(newDir, "MANIFEST.jsonl");
   const existingLines = [];
   if (hadCanonical && existsSync14(manifestPath)) {
     try {
@@ -4269,7 +5601,7 @@ function mergeManifests(newDir, hadCanonical, legacyLines) {
   return finalLines.length;
 }
 function updateConfigPaths(cleoDir) {
-  const configPath = join14(cleoDir, "config.json");
+  const configPath = join15(cleoDir, "config.json");
   if (!existsSync14(configPath)) return;
   try {
     const config = JSON.parse(readFileSync8(configPath, "utf-8"));
@@ -4295,19 +5627,19 @@ function removeLegacyDirs(projectRoot, detection) {
   const removed = [];
   if (detection.hasResearchOutputs) {
     try {
-      rmSync(join14(projectRoot, "claudedocs", "research-outputs"), { recursive: true, force: true });
+      rmSync(join15(projectRoot, "claudedocs", "research-outputs"), { recursive: true, force: true });
       removed.push("claudedocs/research-outputs/");
     } catch {
     }
   }
   if (detection.hasLegacyAgentOutputs) {
     try {
-      rmSync(join14(projectRoot, "claudedocs", "agent-outputs"), { recursive: true, force: true });
+      rmSync(join15(projectRoot, "claudedocs", "agent-outputs"), { recursive: true, force: true });
       removed.push("claudedocs/agent-outputs/");
     } catch {
     }
   }
-  const claudedocsDir = join14(projectRoot, "claudedocs");
+  const claudedocsDir = join15(projectRoot, "claudedocs");
   if (existsSync14(claudedocsDir)) {
     try {
       if (readdirSync3(claudedocsDir).length === 0) {
@@ -4413,15 +5745,15 @@ __export(schema_management_exports, {
   listInstalledSchemas: () => listInstalledSchemas,
   resolveSchemaPath: () => resolveSchemaPath
 });
-import { existsSync as existsSync15, readFileSync as readFileSync9, readdirSync as readdirSync4, mkdirSync as mkdirSync7, copyFileSync as copyFileSync3, renameSync as renameSync5, statSync as statSync5 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync9, readdirSync as readdirSync4, mkdirSync as mkdirSync8, copyFileSync as copyFileSync3, renameSync as renameSync5, statSync as statSync5 } from "node:fs";
+import { join as join16 } from "node:path";
 function resolveSchemaPath(schemaName) {
-  const globalPath = join15(getCleoSchemasDir(), schemaName);
+  const globalPath = join16(getCleoSchemasDir(), schemaName);
   if (existsSync15(globalPath)) {
     return globalPath;
   }
   const packageRoot = getPackageRoot();
-  const bundledPath = join15(packageRoot, "schemas", schemaName);
+  const bundledPath = join16(packageRoot, "schemas", schemaName);
   if (existsSync15(bundledPath)) {
     return bundledPath;
   }
@@ -4445,7 +5777,7 @@ function getSchemaVersion2(schemaName) {
 }
 function listBundledSchemas() {
   const packageRoot = getPackageRoot();
-  const schemasDir = join15(packageRoot, "schemas");
+  const schemasDir = join16(packageRoot, "schemas");
   if (!existsSync15(schemasDir)) return [];
   try {
     return readdirSync4(schemasDir).filter((f) => f.endsWith(".schema.json"));
@@ -4469,7 +5801,7 @@ function readVersionFromPath(schemaPath) {
 }
 function ensureGlobalSchemas(_opts) {
   const packageRoot = getPackageRoot();
-  const bundledDir = join15(packageRoot, "schemas");
+  const bundledDir = join16(packageRoot, "schemas");
   const globalDir = getCleoSchemasDir();
   const bundledFiles = listBundledSchemas();
   let installed = 0;
@@ -4478,11 +5810,11 @@ function ensureGlobalSchemas(_opts) {
     return { installed: 0, updated: 0, total: 0 };
   }
   if (!existsSync15(globalDir)) {
-    mkdirSync7(globalDir, { recursive: true });
+    mkdirSync8(globalDir, { recursive: true });
   }
   for (const file of bundledFiles) {
-    const source = join15(bundledDir, file);
-    const target = join15(globalDir, file);
+    const source = join16(bundledDir, file);
+    const target = join16(globalDir, file);
     if (!existsSync15(target)) {
       copyFileSync3(source, target);
       installed++;
@@ -4508,15 +5840,15 @@ function checkGlobalSchemas() {
   const stale = [];
   let installedCount = 0;
   const packageRoot = getPackageRoot();
-  const bundledDir = join15(packageRoot, "schemas");
+  const bundledDir = join16(packageRoot, "schemas");
   for (const file of bundledFiles) {
-    const globalPath = join15(globalDir, file);
+    const globalPath = join16(globalDir, file);
     if (!existsSync15(globalPath)) {
       missing.push(file);
       continue;
     }
     installedCount++;
-    const bundledVersion = readVersionFromPath(join15(bundledDir, file));
+    const bundledVersion = readVersionFromPath(join16(bundledDir, file));
     const globalVersion = readVersionFromPath(globalPath);
     if (bundledVersion !== null && bundledVersion !== globalVersion) {
       stale.push(file);
@@ -4537,14 +5869,14 @@ function checkSchemaStaleness() {
   const current = [];
   const missing = [];
   const packageRoot = getPackageRoot();
-  const bundledDir = join15(packageRoot, "schemas");
+  const bundledDir = join16(packageRoot, "schemas");
   for (const file of bundledFiles) {
-    const globalPath = join15(globalDir, file);
+    const globalPath = join16(globalDir, file);
     if (!existsSync15(globalPath)) {
       missing.push(file);
       continue;
     }
-    const bundledVersion = readVersionFromPath(join15(bundledDir, file));
+    const bundledVersion = readVersionFromPath(join16(bundledDir, file));
     const globalVersion = readVersionFromPath(globalPath);
     if (bundledVersion !== null && bundledVersion !== globalVersion) {
       stale.push(file);
@@ -4564,7 +5896,7 @@ function listInstalledSchemas() {
     return [];
   }
   return files.map((name) => {
-    const fullPath = join15(globalDir, name);
+    const fullPath = join16(globalDir, name);
     return {
       name,
       path: fullPath,
@@ -4573,7 +5905,7 @@ function listInstalledSchemas() {
   });
 }
 async function cleanProjectSchemas(projectRoot) {
-  const projectSchemasDir = join15(projectRoot, ".cleo", "schemas");
+  const projectSchemasDir = join16(projectRoot, ".cleo", "schemas");
   if (!existsSync15(projectSchemasDir)) {
     return { cleaned: false };
   }
@@ -4586,10 +5918,10 @@ async function cleanProjectSchemas(projectRoot) {
     return { cleaned: false };
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const backupDir = join15(projectRoot, ".cleo", "backups", "schemas");
-  const backupTarget = join15(backupDir, `schemas-${timestamp}`);
+  const backupDir = join16(projectRoot, ".cleo", "backups", "schemas");
+  const backupTarget = join16(backupDir, `schemas-${timestamp}`);
   if (!existsSync15(backupDir)) {
-    mkdirSync7(backupDir, { recursive: true });
+    mkdirSync8(backupDir, { recursive: true });
   }
   renameSync5(projectSchemasDir, backupTarget);
   return { cleaned: true };
@@ -4609,7 +5941,7 @@ __export(schema_integrity_exports, {
   readSchemaVersionFromFile: () => readSchemaVersionFromFile
 });
 import { existsSync as existsSync16, readFileSync as readFileSync10 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function readSchemaVersionFromFile(schemaName) {
   return getSchemaVersion2(schemaName);
 }
@@ -4710,28 +6042,28 @@ var init_schema_integrity = __esm({
     INTEGRITY_TARGETS = [
       {
         label: "config.json",
-        filePath: (d) => join16(d, "config.json"),
+        filePath: (d) => join17(d, "config.json"),
         schemaName: "config.schema.json",
         required: true,
         versionKey: "schemaVersion"
       },
       {
         label: "project-info.json",
-        filePath: (d) => join16(d, "project-info.json"),
+        filePath: (d) => join17(d, "project-info.json"),
         schemaName: "project-info.schema.json",
         required: false,
         versionKey: "schemaVersion"
       },
       {
         label: "project-context.json",
-        filePath: (d) => join16(d, "project-context.json"),
+        filePath: (d) => join17(d, "project-context.json"),
         schemaName: "project-context.schema.json",
         required: false,
         versionKey: "schemaVersion"
       },
       {
         label: ".context-state.json",
-        filePath: (d) => join16(d, ".context-state.json"),
+        filePath: (d) => join17(d, ".context-state.json"),
         schemaName: "context-state.schema.json",
         required: false,
         versionKey: "version"
@@ -4746,9 +6078,9 @@ __export(project_detect_exports, {
   detectProjectType: () => detectProjectType
 });
 import { existsSync as existsSync17, readdirSync as readdirSync5 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function detectProjectType(projectDir) {
-  const exists = (f) => existsSync17(join17(projectDir, f));
+  const exists = (f) => existsSync17(join18(projectDir, f));
   const info = {
     type: "unknown",
     testFramework: "unknown",
@@ -4837,9 +6169,9 @@ __export(scaffold_exports, {
 });
 import { mkdir as mkdir4, access, writeFile as writeFile3, readFile as readFile3 } from "node:fs/promises";
 import { constants as fsConstants, existsSync as existsSync18, readFileSync as readFileSync11, statSync as statSync6 } from "node:fs";
-import { join as join18, resolve as resolve5, dirname as dirname6 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { createHash as createHash4 } from "node:crypto";
+import { join as join19, resolve as resolve5, dirname as dirname7 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { createHash as createHash5 } from "node:crypto";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 async function fileExists(path) {
@@ -4860,7 +6192,7 @@ async function stripCLEOBlocks(filePath) {
   if (stripped !== content) await writeFile3(filePath, stripped, "utf8");
 }
 async function removeCleoFromRootGitignore(projectRoot) {
-  const rootGitignorePath = join18(projectRoot, ".gitignore");
+  const rootGitignorePath = join19(projectRoot, ".gitignore");
   if (!await fileExists(rootGitignorePath)) {
     return { removed: false };
   }
@@ -4877,16 +6209,16 @@ async function removeCleoFromRootGitignore(projectRoot) {
   return { removed: true };
 }
 function generateProjectHash(projectPath) {
-  return createHash4("sha256").update(projectPath).digest("hex").substring(0, 12);
+  return createHash5("sha256").update(projectPath).digest("hex").substring(0, 12);
 }
 function getPackageRoot() {
-  const thisFile = fileURLToPath2(import.meta.url);
-  return resolve5(dirname6(thisFile), "..", "..");
+  const thisFile = fileURLToPath3(import.meta.url);
+  return resolve5(dirname7(thisFile), "..", "..");
 }
 function getGitignoreContent() {
   try {
     const packageRoot = getPackageRoot();
-    const templatePath = join18(packageRoot, "templates", "cleo-gitignore");
+    const templatePath = join19(packageRoot, "templates", "cleo-gitignore");
     if (existsSync18(templatePath)) {
       return readFileSync11(templatePath, "utf-8");
     }
@@ -4896,7 +6228,7 @@ function getGitignoreContent() {
 }
 function getCleoVersion() {
   try {
-    const pkgPath = join18(getPackageRoot(), "package.json");
+    const pkgPath = join19(getPackageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -4934,7 +6266,7 @@ async function ensureCleoStructure(projectRoot) {
   const alreadyExists = existsSync18(cleoDir);
   await mkdir4(cleoDir, { recursive: true });
   for (const subdir of REQUIRED_CLEO_SUBDIRS) {
-    await mkdir4(join18(cleoDir, subdir), { recursive: true });
+    await mkdir4(join19(cleoDir, subdir), { recursive: true });
   }
   return {
     action: alreadyExists ? "skipped" : "created",
@@ -4944,7 +6276,7 @@ async function ensureCleoStructure(projectRoot) {
 }
 async function ensureGitignore(projectRoot) {
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const gitignorePath = join18(cleoDir, ".gitignore");
+  const gitignorePath = join19(cleoDir, ".gitignore");
   const templateContent = getGitignoreContent();
   if (existsSync18(gitignorePath)) {
     const existing = readFileSync11(gitignorePath, "utf-8");
@@ -4971,7 +6303,7 @@ async function ensureConfig(projectRoot, opts) {
 }
 async function ensureProjectInfo(projectRoot, opts) {
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const projectInfoPath = join18(cleoDir, "project-info.json");
+  const projectInfoPath = join19(cleoDir, "project-info.json");
   if (existsSync18(projectInfoPath) && !opts?.force) {
     return { action: "skipped", path: projectInfoPath, details: "Already exists" };
   }
@@ -5012,7 +6344,7 @@ async function ensureProjectInfo(projectRoot, opts) {
 }
 async function ensureProjectContext(projectRoot, opts) {
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const contextPath = join18(cleoDir, "project-context.json");
+  const contextPath = join19(cleoDir, "project-context.json");
   const staleDays = opts?.staleDays ?? 30;
   if (existsSync18(contextPath) && !opts?.force) {
     try {
@@ -5042,7 +6374,7 @@ async function ensureProjectContext(projectRoot, opts) {
 }
 async function ensureCleoGitRepo(projectRoot) {
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const cleoGitDir = join18(cleoDir, ".git");
+  const cleoGitDir = join19(cleoDir, ".git");
   if (existsSync18(cleoGitDir)) {
     return { action: "skipped", path: cleoGitDir, details: "Already initialized" };
   }
@@ -5058,7 +6390,7 @@ async function ensureCleoGitRepo(projectRoot) {
 }
 async function ensureSqliteDb(projectRoot) {
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const dbPath = join18(cleoDir, "tasks.db");
+  const dbPath = join19(cleoDir, "tasks.db");
   if (existsSync18(dbPath)) {
     return { action: "skipped", path: dbPath, details: "tasks.db already exists" };
   }
@@ -5088,7 +6420,7 @@ function checkCleoStructure(projectRoot) {
     };
   }
   for (const subdir of REQUIRED_CLEO_SUBDIRS) {
-    if (!existsSync18(join18(cleoDir, subdir))) {
+    if (!existsSync18(join19(cleoDir, subdir))) {
       missing.push(subdir);
     }
   }
@@ -5113,7 +6445,7 @@ function checkCleoStructure(projectRoot) {
 }
 function checkGitignore(projectRoot) {
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const gitignorePath = join18(cleoDir, ".gitignore");
+  const gitignorePath = join19(cleoDir, ".gitignore");
   if (!existsSync18(gitignorePath)) {
     return {
       id: "cleo_gitignore",
@@ -5172,7 +6504,7 @@ function checkConfig(projectRoot) {
 }
 function checkProjectInfo(projectRoot) {
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join18(cleoDir, "project-info.json");
+  const infoPath = join19(cleoDir, "project-info.json");
   if (!existsSync18(infoPath)) {
     return {
       id: "cleo_project_info",
@@ -5218,7 +6550,7 @@ function checkProjectInfo(projectRoot) {
 }
 function checkProjectContext(projectRoot, staleDays = 30) {
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const contextPath = join18(cleoDir, "project-context.json");
+  const contextPath = join19(cleoDir, "project-context.json");
   if (!existsSync18(contextPath)) {
     return {
       id: "cleo_project_context",
@@ -5275,7 +6607,7 @@ function checkProjectContext(projectRoot, staleDays = 30) {
 }
 function checkCleoGitRepo(projectRoot) {
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const cleoGitDir = join18(cleoDir, ".git");
+  const cleoGitDir = join19(cleoDir, ".git");
   if (!existsSync18(cleoGitDir)) {
     return {
       id: "cleo_git_repo",
@@ -5297,7 +6629,7 @@ function checkCleoGitRepo(projectRoot) {
 }
 function checkSqliteDb(projectRoot) {
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const dbPath = join18(cleoDir, "tasks.db");
+  const dbPath = join19(cleoDir, "tasks.db");
   if (!existsSync18(dbPath)) {
     return {
       id: "sqlite_db",
@@ -5390,11 +6722,11 @@ backups/
 // src/core/validation/doctor/checks.ts
 import { existsSync as existsSync19, readFileSync as readFileSync12, accessSync, constants, statSync as statSync7 } from "node:fs";
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 function checkCleoGitignore(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitignorePath = join19(root, ".cleo", ".gitignore");
+  const gitignorePath = join20(root, ".cleo", ".gitignore");
   if (!existsSync19(gitignorePath)) {
     return {
       id: "cleo_gitignore",
@@ -5424,8 +6756,8 @@ function checkCleoGitignore(projectRoot) {
   } catch {
     try {
       const templatePaths = [
-        join19(root, "templates", "cleo-gitignore"),
-        join19(homedir2(), ".cleo", "templates", "cleo-gitignore")
+        join20(root, "templates", "cleo-gitignore"),
+        join20(homedir2(), ".cleo", "templates", "cleo-gitignore")
       ];
       for (const tp of templatePaths) {
         if (existsSync19(tp)) {
@@ -5466,7 +6798,7 @@ function detectStorageEngine(_projectRoot) {
 }
 function checkVitalFilesTracked(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitDir = join19(root, ".git");
+  const gitDir = join20(root, ".git");
   if (!existsSync19(gitDir)) {
     return {
       id: "vital_files_tracked",
@@ -5481,7 +6813,7 @@ function checkVitalFilesTracked(projectRoot) {
   const vitalFiles = CORE_PROTECTED_FILES.map((f) => `.cleo/${f}`);
   const untracked = [];
   for (const file of vitalFiles) {
-    const fullPath = join19(root, file);
+    const fullPath = join20(root, file);
     if (!existsSync19(fullPath)) continue;
     try {
       execFileSync2("git", ["ls-files", "--error-unmatch", file], {
@@ -5513,7 +6845,7 @@ function checkVitalFilesTracked(projectRoot) {
 }
 function checkCoreFilesNotIgnored(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitDir = join19(root, ".git");
+  const gitDir = join20(root, ".git");
   if (!existsSync19(gitDir)) {
     return {
       id: "core_files_not_ignored",
@@ -5527,7 +6859,7 @@ function checkCoreFilesNotIgnored(projectRoot) {
   const ignoredFiles = [];
   for (const file of CORE_PROTECTED_FILES) {
     const relPath = `.cleo/${file}`;
-    const fullPath = join19(root, relPath);
+    const fullPath = join20(root, relPath);
     if (!existsSync19(fullPath)) continue;
     try {
       execFileSync2("git", ["check-ignore", "-q", relPath], {
@@ -5559,7 +6891,7 @@ function checkCoreFilesNotIgnored(projectRoot) {
 }
 function checkLegacyAgentOutputs(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const cleoDir = join19(root, ".cleo");
+  const cleoDir = join20(root, ".cleo");
   const detection = detectLegacyAgentOutputs(root, cleoDir);
   if (detection.hasLegacy) {
     return {
@@ -5632,10 +6964,10 @@ __export(hooks_exports, {
 });
 import { chmod, mkdir as mkdir5, copyFile as copyFile2, readFile as readFile4 } from "node:fs/promises";
 import { existsSync as existsSync20 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 async function ensureGitHooks(projectRoot, opts) {
-  const gitDir = join20(projectRoot, ".git");
-  const gitHooksDir = join20(gitDir, "hooks");
+  const gitDir = join21(projectRoot, ".git");
+  const gitHooksDir = join21(gitDir, "hooks");
   if (!existsSync20(gitDir)) {
     return {
       action: "skipped",
@@ -5644,7 +6976,7 @@ async function ensureGitHooks(projectRoot, opts) {
     };
   }
   const packageRoot = getPackageRoot();
-  const sourceDir = join20(packageRoot, "templates", "git-hooks");
+  const sourceDir = join21(packageRoot, "templates", "git-hooks");
   if (!existsSync20(sourceDir)) {
     return {
       action: "skipped",
@@ -5657,8 +6989,8 @@ async function ensureGitHooks(projectRoot, opts) {
   let installedCount = 0;
   const errors = [];
   for (const hook of MANAGED_HOOKS) {
-    const sourcePath = join20(sourceDir, hook);
-    const destPath = join20(gitHooksDir, hook);
+    const sourcePath = join21(sourceDir, hook);
+    const destPath = join21(gitHooksDir, hook);
     if (!existsSync20(sourcePath)) {
       continue;
     }
@@ -5694,13 +7026,13 @@ async function ensureGitHooks(projectRoot, opts) {
   };
 }
 async function checkGitHooks(projectRoot) {
-  const gitHooksDir = join20(projectRoot, ".git", "hooks");
+  const gitHooksDir = join21(projectRoot, ".git", "hooks");
   const packageRoot = getPackageRoot();
-  const sourceDir = join20(packageRoot, "templates", "git-hooks");
+  const sourceDir = join21(packageRoot, "templates", "git-hooks");
   const results = [];
   for (const hook of MANAGED_HOOKS) {
-    const sourcePath = join20(sourceDir, hook);
-    const installedPath = join20(gitHooksDir, hook);
+    const sourcePath = join21(sourceDir, hook);
+    const installedPath = join21(gitHooksDir, hook);
     const result = {
       hook,
       installed: false,
@@ -5748,18 +7080,18 @@ __export(injection_exports, {
 });
 import { mkdir as mkdir6, writeFile as writeFile4, rm } from "node:fs/promises";
 import { existsSync as existsSync21, readFileSync as readFileSync13 } from "node:fs";
-import { join as join21, basename as basename3 } from "node:path";
+import { join as join22, basename as basename3 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 function getInjectionTemplateContent() {
   const packageRoot = getPackageRoot();
-  const packageTemplatePath = join21(packageRoot, "templates", "CLEO-INJECTION.md");
+  const packageTemplatePath = join22(packageRoot, "templates", "CLEO-INJECTION.md");
   if (existsSync21(packageTemplatePath)) {
     return readFileSync13(packageTemplatePath, "utf-8");
   }
   return null;
 }
 async function removeStaleAgentInjection(projectRoot) {
-  const stalePath = join21(projectRoot, ".cleo", "templates", "AGENT-INJECTION.md");
+  const stalePath = join22(projectRoot, ".cleo", "templates", "AGENT-INJECTION.md");
   if (!existsSync21(stalePath)) return false;
   await rm(stalePath, { force: true });
   return true;
@@ -5771,7 +7103,7 @@ async function ensureInjection(projectRoot) {
   } catch {
     return {
       action: "skipped",
-      path: join21(projectRoot, "AGENTS.md"),
+      path: join22(projectRoot, "AGENTS.md"),
       details: "@cleocode/caamp not installed, skipping injection"
     };
   }
@@ -5780,16 +7112,16 @@ async function ensureInjection(projectRoot) {
   if (providers.length === 0) {
     return {
       action: "skipped",
-      path: join21(projectRoot, "AGENTS.md"),
+      path: join22(projectRoot, "AGENTS.md"),
       details: "No AI agent providers detected, skipping injection"
     };
   }
   const actions = [];
   for (const provider of providers) {
-    const instructFile = join21(projectRoot, provider.pathProject, provider.instructFile);
+    const instructFile = join22(projectRoot, provider.pathProject, provider.instructFile);
     await stripCLEOBlocks(instructFile);
   }
-  await stripCLEOBlocks(join21(projectRoot, "AGENTS.md"));
+  await stripCLEOBlocks(join22(projectRoot, "AGENTS.md"));
   const removedStale = await removeStaleAgentInjection(projectRoot);
   if (removedStale) {
     actions.push("removed deprecated AGENT-INJECTION.md");
@@ -5800,9 +7132,9 @@ async function ensureInjection(projectRoot) {
     const fileName = basename3(filePath);
     actions.push(`${fileName} (${action})`);
   }
-  const agentsMdPath = join21(projectRoot, "AGENTS.md");
+  const agentsMdPath = join22(projectRoot, "AGENTS.md");
   const agentsMdLines = ["@~/.cleo/templates/CLEO-INJECTION.md"];
-  const projectContextPath = join21(projectRoot, ".cleo", "project-context.json");
+  const projectContextPath = join22(projectRoot, ".cleo", "project-context.json");
   if (existsSync21(projectContextPath)) {
     agentsMdLines.push("@.cleo/project-context.json");
   }
@@ -5810,17 +7142,17 @@ async function ensureInjection(projectRoot) {
   actions.push(`AGENTS.md CLEO content (${agentsAction})`);
   const content = getInjectionTemplateContent();
   if (content) {
-    const globalTemplatesDir = join21(getCleoHome(), "templates");
+    const globalTemplatesDir = join22(getCleoHome(), "templates");
     await mkdir6(globalTemplatesDir, { recursive: true });
-    const globalPath = join21(globalTemplatesDir, "CLEO-INJECTION.md");
+    const globalPath = join22(globalTemplatesDir, "CLEO-INJECTION.md");
     if (!existsSync21(globalPath)) {
       await writeFile4(globalPath, content);
       actions.push("installed global CLEO-INJECTION.md");
     }
   }
   try {
-    const globalAgentsDir = join21(homedir3(), ".agents");
-    const globalAgentsMd = join21(globalAgentsDir, "AGENTS.md");
+    const globalAgentsDir = join22(homedir3(), ".agents");
+    const globalAgentsMd = join22(globalAgentsDir, "AGENTS.md");
     await mkdir6(globalAgentsDir, { recursive: true });
     await inject(globalAgentsMd, "@~/.cleo/templates/CLEO-INJECTION.md");
   } catch {
@@ -5832,7 +7164,7 @@ async function ensureInjection(projectRoot) {
   };
 }
 function checkInjection(projectRoot) {
-  const agentsMdPath = join21(projectRoot, "AGENTS.md");
+  const agentsMdPath = join22(projectRoot, "AGENTS.md");
   if (!existsSync21(agentsMdPath)) {
     return {
       id: "injection_health",
@@ -5885,7 +7217,7 @@ function checkInjection(projectRoot) {
     const missing = [];
     for (const ref of refs) {
       const rawPath = ref.slice(1).trim();
-      const resolvedPath = rawPath.startsWith("~/") ? join21(homedir3(), rawPath.slice(2)) : join21(projectRoot, rawPath);
+      const resolvedPath = rawPath.startsWith("~/") ? join22(homedir3(), rawPath.slice(2)) : join22(projectRoot, rawPath);
       if (!existsSync21(resolvedPath)) {
         missing.push(rawPath);
       }
@@ -5901,7 +7233,7 @@ function checkInjection(projectRoot) {
       };
     }
   }
-  const claudeMdPath = join21(projectRoot, "CLAUDE.md");
+  const claudeMdPath = join22(projectRoot, "CLAUDE.md");
   if (existsSync21(claudeMdPath)) {
     try {
       const claudeContent = readFileSync13(claudeMdPath, "utf-8");
@@ -5956,19 +7288,19 @@ __export(health_exports, {
   runDoctorFixes: () => runDoctorFixes
 });
 import { existsSync as existsSync22, readFileSync as readFileSync14, statSync as statSync8 } from "node:fs";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 import { homedir as homedir4 } from "node:os";
 function getSystemHealth(projectRoot, opts) {
-  const cleoDir = join22(projectRoot, ".cleo");
+  const cleoDir = join23(projectRoot, ".cleo");
   const checks = [];
   if (existsSync22(cleoDir)) {
     checks.push({ name: "cleo_dir", status: "pass", message: ".cleo directory exists" });
   } else {
     checks.push({ name: "cleo_dir", status: "fail", message: ".cleo directory not found" });
   }
-  const dbPath = join22(cleoDir, "tasks.db");
+  const dbPath = join23(cleoDir, "tasks.db");
   if (existsSync22(dbPath)) {
     try {
       const dbSize = statSync8(dbPath).size;
@@ -5983,7 +7315,7 @@ function getSystemHealth(projectRoot, opts) {
   } else {
     checks.push({ name: "tasks_db", status: "fail", message: "tasks.db not found" });
   }
-  const configPath = join22(cleoDir, "config.json");
+  const configPath = join23(cleoDir, "config.json");
   if (existsSync22(configPath)) {
     try {
       JSON.parse(readFileSync14(configPath, "utf-8"));
@@ -5995,7 +7327,7 @@ function getSystemHealth(projectRoot, opts) {
     checks.push({ name: "config_json", status: "warn", message: "config.json not found" });
   }
   if (existsSync22(dbPath)) {
-    const staleFiles = STALE_JSON_FILES.filter((f) => existsSync22(join22(cleoDir, f)));
+    const staleFiles = STALE_JSON_FILES.filter((f) => existsSync22(join23(cleoDir, f)));
     if (staleFiles.length > 0) {
       checks.push({
         name: "stale_json",
@@ -6005,13 +7337,13 @@ function getSystemHealth(projectRoot, opts) {
     }
   }
   if (opts?.detailed) {
-    const logPath = join22(cleoDir, "todo-log.jsonl");
+    const logPath = join23(cleoDir, "todo-log.jsonl");
     if (existsSync22(logPath)) {
       checks.push({ name: "log_file", status: "pass", message: "todo-log.jsonl exists" });
     } else {
       checks.push({ name: "log_file", status: "warn", message: "todo-log.jsonl not found" });
     }
-    const backupDir = join22(cleoDir, ".backups");
+    const backupDir = join23(cleoDir, ".backups");
     if (existsSync22(backupDir)) {
       checks.push({ name: "backups_dir", status: "pass", message: ".backups directory exists" });
     } else {
@@ -6020,7 +7352,7 @@ function getSystemHealth(projectRoot, opts) {
   }
   let version = "unknown";
   try {
-    const pkgPath = join22(projectRoot, "package.json");
+    const pkgPath = join23(projectRoot, "package.json");
     if (existsSync22(pkgPath)) {
       const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
       version = pkg.version || "unknown";
@@ -6056,8 +7388,8 @@ async function getSystemDiagnostics(projectRoot, opts) {
       details: preflight.summary
     });
   }
-  const cleoDir = join22(projectRoot, ".cleo");
-  const dbPath = join22(cleoDir, "tasks.db");
+  const cleoDir = join23(projectRoot, ".cleo");
+  const dbPath = join23(cleoDir, "tasks.db");
   if (existsSync22(dbPath)) {
     try {
       const accessor = await getAccessor(projectRoot);
@@ -6181,14 +7513,14 @@ async function coreDoctorReport(projectRoot) {
     status: gitPath ? "ok" : "warning",
     message: gitPath ? `git found: ${gitPath}` : "git not found (optional, needed for version control features)"
   });
-  const cleoDir = join22(projectRoot, ".cleo");
+  const cleoDir = join23(projectRoot, ".cleo");
   const dirExists = existsSync22(cleoDir);
   checks.push({
     check: "project_dir",
     status: dirExists ? "ok" : "error",
     message: dirExists ? `Project dir: ${cleoDir}` : `Project dir not found: ${cleoDir}. Run: cleo init`
   });
-  const dbPath = join22(cleoDir, "tasks.db");
+  const dbPath = join23(cleoDir, "tasks.db");
   const dbExists2 = existsSync22(dbPath);
   const dbSize = await fileSize(dbPath);
   checks.push({
@@ -6232,14 +7564,14 @@ async function coreDoctorReport(projectRoot) {
     } catch {
     }
   }
-  const configPath = join22(cleoDir, "config.json");
+  const configPath = join23(cleoDir, "config.json");
   const configExists = existsSync22(configPath);
   checks.push({
     check: "config_file",
     status: configExists ? "ok" : "warning",
     message: configExists ? "config.json present" : "config.json not found (using defaults)"
   });
-  const staleJsonFiles = STALE_JSON_FILES.filter((f) => existsSync22(join22(cleoDir, f)));
+  const staleJsonFiles = STALE_JSON_FILES.filter((f) => existsSync22(join23(cleoDir, f)));
   if (dbExists2 && staleJsonFiles.length > 0) {
     checks.push({
       check: "stale_json",
@@ -6248,14 +7580,14 @@ async function coreDoctorReport(projectRoot) {
       details: { files: staleJsonFiles }
     });
   }
-  const logPath = join22(cleoDir, "todo-log.jsonl");
+  const logPath = join23(cleoDir, "todo-log.jsonl");
   const logExists = existsSync22(logPath);
   checks.push({
     check: "log_file",
     status: logExists ? "ok" : "warning",
     message: logExists ? "log file present" : "log file not found"
   });
-  const rootGitignorePath = join22(projectRoot, ".gitignore");
+  const rootGitignorePath = join23(projectRoot, ".gitignore");
   if (existsSync22(rootGitignorePath)) {
     try {
       const gitignoreContent = readFileSync14(rootGitignorePath, "utf-8");
@@ -6277,7 +7609,7 @@ async function coreDoctorReport(projectRoot) {
   checks.push(mapCheckResult(checkVitalFilesTracked(projectRoot)));
   checks.push(mapCheckResult(checkCoreFilesNotIgnored(projectRoot)));
   checks.push(mapCheckResult(checkLegacyAgentOutputs(projectRoot)));
-  const cleoGitHeadExists = existsSync22(join22(cleoDir, ".git", "HEAD"));
+  const cleoGitHeadExists = existsSync22(join23(cleoDir, ".git", "HEAD"));
   checks.push({
     check: "cleo_git_repo",
     status: cleoGitHeadExists ? "ok" : "warning",
@@ -6289,7 +7621,7 @@ async function coreDoctorReport(projectRoot) {
   checks.push(mapCheckResult(checkProjectInfo(projectRoot)));
   checks.push(mapCheckResult(checkProjectContext(projectRoot)));
   checks.push(mapCheckResult(checkInjection(projectRoot)));
-  const agentDefPath = join22(homedir4(), ".agents", "agents", "cleo-subagent");
+  const agentDefPath = join23(homedir4(), ".agents", "agents", "cleo-subagent");
   checks.push({
     check: "agent_definition",
     status: existsSync22(agentDefPath) ? "ok" : "warning",
@@ -6397,11 +7729,11 @@ __export(mcp_exports, {
   generateMcpServerEntry: () => generateMcpServerEntry
 });
 import { readFileSync as readFileSync20 } from "node:fs";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 function detectEnvMode() {
-  const versionPath = join29(
-    process.env["CLEO_HOME"] ?? join29(homedir6(), ".cleo"),
+  const versionPath = join30(
+    process.env["CLEO_HOME"] ?? join30(homedir6(), ".cleo"),
     "VERSION"
   );
   let content;
@@ -6429,7 +7761,7 @@ function generateMcpServerEntry(env) {
   if (env.mode === "dev-ts" && env.source) {
     return {
       command: "node",
-      args: [join29(env.source, "dist", "mcp", "index.js")],
+      args: [join30(env.source, "dist", "mcp", "index.js")],
       env: {}
     };
   }
@@ -6467,21 +7799,21 @@ __export(registry_exports, {
   readRegistry: () => readRegistry,
   readRegistryRequired: () => readRegistryRequired
 });
-import { createHash as createHash5 } from "node:crypto";
-import { join as join30 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { join as join31 } from "node:path";
 import { mkdir as mkdir7, access as access2, readFile as readFile6 } from "node:fs/promises";
 import { z } from "zod";
 function getNexusHome() {
-  return process.env["NEXUS_HOME"] ?? join30(getCleoHome(), "nexus");
+  return process.env["NEXUS_HOME"] ?? join31(getCleoHome(), "nexus");
 }
 function getNexusCacheDir() {
-  return process.env["NEXUS_CACHE_DIR"] ?? join30(getNexusHome(), "cache");
+  return process.env["NEXUS_CACHE_DIR"] ?? join31(getNexusHome(), "cache");
 }
 function getRegistryPath() {
-  return process.env["NEXUS_REGISTRY_FILE"] ?? join30(getCleoHome(), "projects-registry.json");
+  return process.env["NEXUS_REGISTRY_FILE"] ?? join31(getCleoHome(), "projects-registry.json");
 }
 function generateProjectHash2(projectPath) {
-  const hash = createHash5("sha256").update(projectPath).digest("hex");
+  const hash = createHash6("sha256").update(projectPath).digest("hex");
   return hash.substring(0, 12);
 }
 async function readRegistry() {
@@ -6520,7 +7852,7 @@ async function nexusInit() {
 }
 async function isCleoProject(projectPath) {
   try {
-    await access2(join30(projectPath, ".cleo", "todo.json"));
+    await access2(join31(projectPath, ".cleo", "todo.json"));
     return true;
   } catch {
     return false;
@@ -6530,9 +7862,9 @@ async function readProjectMeta(projectPath) {
   try {
     let raw;
     try {
-      raw = await readFile6(join30(projectPath, ".cleo", "tasks.json"), "utf-8");
+      raw = await readFile6(join31(projectPath, ".cleo", "tasks.json"), "utf-8");
     } catch {
-      raw = await readFile6(join30(projectPath, ".cleo", "todo.json"), "utf-8");
+      raw = await readFile6(join31(projectPath, ".cleo", "todo.json"), "utf-8");
     }
     const data = JSON.parse(raw);
     const tasks2 = data.tasks ?? [];
@@ -7025,7 +8357,7 @@ __export(session_grade_exports, {
   gradeSession: () => gradeSession,
   readGrades: () => readGrades
 });
-import { join as join48 } from "node:path";
+import { join as join49 } from "node:path";
 import { existsSync as existsSync47 } from "node:fs";
 import { readFile as readFile9, appendFile, mkdir as mkdir9 } from "node:fs/promises";
 async function gradeSession(sessionId, cwd) {
@@ -7206,9 +8538,9 @@ function detectDuplicateCreates(entries) {
 async function appendGradeResult(result, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const metricsDir = join48(cleoDir, "metrics");
+    const metricsDir = join49(cleoDir, "metrics");
     await mkdir9(metricsDir, { recursive: true });
-    const gradesPath = join48(metricsDir, "GRADES.jsonl");
+    const gradesPath = join49(metricsDir, "GRADES.jsonl");
     const line = JSON.stringify({ ...result, evaluator: "auto" }) + "\n";
     await appendFile(gradesPath, line, "utf8");
   } catch {
@@ -7217,7 +8549,7 @@ async function appendGradeResult(result, cwd) {
 async function readGrades(sessionId, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const gradesPath = join48(cleoDir, "metrics", "GRADES.jsonl");
+    const gradesPath = join49(cleoDir, "metrics", "GRADES.jsonl");
     if (!existsSync47(gradesPath)) return [];
     const content = await readFile9(gradesPath, "utf8");
     const results = content.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
@@ -7341,8 +8673,14 @@ var QUERY_OPERATIONS = {
     // Pattern memory statistics
     "learning.search",
     // Search BRAIN learning memory
-    "learning.stats"
+    "learning.stats",
     // Learning memory statistics
+    "brain.search",
+    // 3-layer retrieval step 1: search index
+    "brain.timeline",
+    // 3-layer retrieval step 2: context around anchor
+    "brain.fetch"
+    // 3-layer retrieval step 3: full details for filtered IDs
   ],
   // ── Canonical: check (validate alias) ──────────────────────────────
   check: [
@@ -7681,8 +9019,10 @@ var MUTATE_OPERATIONS = {
     // Archive old entries
     "pattern.store",
     // Store BRAIN pattern memory
-    "learning.store"
+    "learning.store",
     // Store BRAIN learning memory
+    "brain.observe"
+    // Save observation to brain.db
   ],
   // ── Canonical: check (validate alias) ──────────────────────────────
   check: [
@@ -13798,6 +15138,12 @@ async function computeBriefing(projectRoot, options = {}) {
     scopeTaskIds
   });
   const pipelineStage = computePipelineStage(current);
+  let memoryContext;
+  try {
+    const { getSessionMemoryContext: getSessionMemoryContext2 } = await Promise.resolve().then(() => (init_session_memory(), session_memory_exports));
+    memoryContext = await getSessionMemoryContext2(projectRoot, scopeFilter);
+  } catch {
+  }
   const warnings = [];
   if (currentTaskInfo?.blockedBy?.length) {
     warnings.push(
@@ -13812,7 +15158,8 @@ async function computeBriefing(projectRoot, options = {}) {
     blockedTasks,
     activeEpics,
     ...pipelineStage && { pipelineStage },
-    ...warnings.length > 0 && { warnings }
+    ...warnings.length > 0 && { warnings },
+    ...memoryContext && { memoryContext }
   };
 }
 function parseScope(scopeStr, current) {
@@ -14518,7 +15865,23 @@ async function sessionResume(projectRoot, sessionId) {
     taskData.lastUpdated = now;
     await accessor.saveTaskFile(taskData);
     await accessor.saveSessions(sessions2);
-    return { success: true, data: session };
+    let memoryContext;
+    try {
+      const { getSessionMemoryContext: getSessionMemoryContext2 } = await Promise.resolve().then(() => (init_session_memory(), session_memory_exports));
+      const scopeType = session.scope?.type;
+      const rootTaskId = session.scope?.rootTaskId;
+      memoryContext = await getSessionMemoryContext2(projectRoot, {
+        type: scopeType ?? "global",
+        rootTaskId,
+        epicId: rootTaskId
+      });
+    } catch {
+    }
+    const enrichedSession = {
+      ...session,
+      ...memoryContext && { memoryContext }
+    };
+    return { success: true, data: enrichedSession };
   } catch {
     return engineError("E_NOT_INITIALIZED", "Task database not initialized");
   }
@@ -14768,7 +16131,7 @@ async function sessionChainShow(projectRoot, sessionId) {
 init_platform();
 init_data_accessor();
 import { readFileSync as readFileSync19, existsSync as existsSync28, readdirSync as readdirSync7 } from "node:fs";
-import { join as join28, basename as basename5 } from "node:path";
+import { join as join29, basename as basename5 } from "node:path";
 
 // src/core/stats/index.ts
 init_json();
@@ -14897,11 +16260,11 @@ init_paths();
 init_json();
 init_paths();
 import { readFileSync as readFileSync6, existsSync as existsSync12 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 async function generateInjection(projectRoot, accessor) {
   let version = "unknown";
   try {
-    const pkgPath = join12(projectRoot, "package.json");
+    const pkgPath = join13(projectRoot, "package.json");
     if (existsSync12(pkgPath)) {
       const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
       version = pkg.version || "unknown";
@@ -15009,23 +16372,23 @@ init_paths();
 // src/core/system/backup.ts
 init_errors();
 init_exit_codes();
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync3, existsSync as existsSync23, mkdirSync as mkdirSync8 } from "node:fs";
-import { join as join23 } from "node:path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync3, existsSync as existsSync23, mkdirSync as mkdirSync9 } from "node:fs";
+import { join as join24 } from "node:path";
 function createBackup2(projectRoot, opts) {
-  const cleoDir = join23(projectRoot, ".cleo");
+  const cleoDir = join24(projectRoot, ".cleo");
   const btype = opts?.type || "snapshot";
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const backupId = `${btype}-${timestamp.replace(/[:.]/g, "-")}`;
-  const backupDir = join23(cleoDir, "backups", btype);
+  const backupDir = join24(cleoDir, "backups", btype);
   if (!existsSync23(backupDir)) {
-    mkdirSync8(backupDir, { recursive: true });
+    mkdirSync9(backupDir, { recursive: true });
   }
   const filesToBackup = ["todo.json", "todo-archive.json", "sessions.json", "config.json", "todo-log.jsonl"];
   const backedUp = [];
   for (const file of filesToBackup) {
-    const src = join23(cleoDir, file);
+    const src = join24(cleoDir, file);
     if (existsSync23(src)) {
-      const dest = join23(backupDir, `${file}.${backupId}`);
+      const dest = join24(backupDir, `${file}.${backupId}`);
       try {
         const content = readFileSync15(src, "utf-8");
         writeFileSync3(dest, content, "utf-8");
@@ -15034,7 +16397,7 @@ function createBackup2(projectRoot, opts) {
       }
     }
   }
-  const metaPath = join23(backupDir, `${backupId}.meta.json`);
+  const metaPath = join24(backupDir, `${backupId}.meta.json`);
   try {
     writeFileSync3(metaPath, JSON.stringify({
       backupId,
@@ -15051,15 +16414,15 @@ function restoreBackup(projectRoot, params) {
   if (!params.backupId) {
     throw new CleoError(2 /* INVALID_INPUT */, "backupId is required");
   }
-  const cleoDir = join23(projectRoot, ".cleo");
+  const cleoDir = join24(projectRoot, ".cleo");
   const backupTypes = ["snapshot", "safety", "migration"];
   let metaPath = null;
   let backupDir = null;
   for (const btype of backupTypes) {
-    const candidateMeta = join23(cleoDir, "backups", btype, `${params.backupId}.meta.json`);
+    const candidateMeta = join24(cleoDir, "backups", btype, `${params.backupId}.meta.json`);
     if (existsSync23(candidateMeta)) {
       metaPath = candidateMeta;
-      backupDir = join23(cleoDir, "backups", btype);
+      backupDir = join24(cleoDir, "backups", btype);
       break;
     }
   }
@@ -15074,11 +16437,11 @@ function restoreBackup(projectRoot, params) {
   }
   const restored = [];
   for (const file of meta.files ?? []) {
-    const backupFile = join23(backupDir, `${file}.${params.backupId}`);
+    const backupFile = join24(backupDir, `${file}.${params.backupId}`);
     if (existsSync23(backupFile)) {
       try {
         const content = readFileSync15(backupFile, "utf-8");
-        writeFileSync3(join23(cleoDir, file), content, "utf-8");
+        writeFileSync3(join24(cleoDir, file), content, "utf-8");
         restored.push(file);
       } catch {
       }
@@ -15096,9 +16459,9 @@ function restoreBackup(projectRoot, params) {
 init_errors();
 init_exit_codes();
 import { readFileSync as readFileSync16, existsSync as existsSync24 } from "node:fs";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 function getMigrationStatus(projectRoot, opts) {
-  const taskPath = join24(projectRoot, ".cleo", "tasks.json");
+  const taskPath = join25(projectRoot, ".cleo", "tasks.json");
   let currentVersion = "unknown";
   if (existsSync24(taskPath)) {
     try {
@@ -15123,17 +16486,17 @@ function getMigrationStatus(projectRoot, opts) {
 init_errors();
 init_exit_codes();
 import { readFileSync as readFileSync17, writeFileSync as writeFileSync4, existsSync as existsSync25, readdirSync as readdirSync6, unlinkSync as unlinkSync4 } from "node:fs";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 function cleanupSystem(projectRoot, params) {
   if (!params.target) {
     throw new CleoError(2 /* INVALID_INPUT */, "target is required (sessions|backups|logs|archive)");
   }
-  const cleoDir = join25(projectRoot, ".cleo");
+  const cleoDir = join26(projectRoot, ".cleo");
   const dryRun = params.dryRun ?? false;
   const items = [];
   switch (params.target) {
     case "sessions": {
-      const sessPath = join25(cleoDir, "sessions.json");
+      const sessPath = join26(cleoDir, "sessions.json");
       if (existsSync25(sessPath)) {
         try {
           const data = JSON.parse(readFileSync17(sessPath, "utf-8"));
@@ -15160,14 +16523,14 @@ function cleanupSystem(projectRoot, params) {
       break;
     }
     case "backups": {
-      const backupBaseDir = join25(cleoDir, "backups");
+      const backupBaseDir = join26(cleoDir, "backups");
       if (existsSync25(backupBaseDir)) {
         for (const typeDir of readdirSync6(backupBaseDir)) {
-          const fullDir = join25(backupBaseDir, typeDir);
+          const fullDir = join26(backupBaseDir, typeDir);
           try {
             for (const file of readdirSync6(fullDir)) {
               if (file.endsWith(".meta.json")) {
-                const metaFilePath = join25(fullDir, file);
+                const metaFilePath = join26(fullDir, file);
                 try {
                   const meta = JSON.parse(readFileSync17(metaFilePath, "utf-8"));
                   if (params.olderThan && meta.timestamp < params.olderThan) {
@@ -15177,7 +16540,7 @@ function cleanupSystem(projectRoot, params) {
                       for (const bf of readdirSync6(fullDir)) {
                         if (bf.includes(meta.backupId)) {
                           try {
-                            unlinkSync4(join25(fullDir, bf));
+                            unlinkSync4(join26(fullDir, bf));
                           } catch {
                           }
                         }
@@ -15202,7 +16565,7 @@ function cleanupSystem(projectRoot, params) {
             items.push(file);
             if (!dryRun) {
               try {
-                unlinkSync4(join25(cleoDir, file));
+                unlinkSync4(join26(cleoDir, file));
               } catch {
               }
             }
@@ -15221,13 +16584,13 @@ function cleanupSystem(projectRoot, params) {
 init_errors();
 init_exit_codes();
 import { readFileSync as readFileSync18, writeFileSync as writeFileSync5, existsSync as existsSync26 } from "node:fs";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 function safestop(projectRoot, opts) {
   const dryRun = opts?.dryRun ?? false;
   const reason = opts?.reason ?? "Manual safestop";
   let sessionEnded = false;
   if (!dryRun && !opts?.noSessionEnd) {
-    const sessPath = join26(projectRoot, ".cleo", "sessions.json");
+    const sessPath = join27(projectRoot, ".cleo", "sessions.json");
     if (existsSync26(sessPath)) {
       try {
         const data = JSON.parse(readFileSync18(sessPath, "utf-8"));
@@ -15258,7 +16621,7 @@ init_sequence();
 // src/core/system/runtime.ts
 import { existsSync as existsSync27 } from "node:fs";
 import { readFile as readFile5 } from "node:fs/promises";
-import { basename as basename4, join as join27 } from "node:path";
+import { basename as basename4, join as join28 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
@@ -15292,7 +16655,7 @@ function getExpectedNaming(channel) {
   }
 }
 async function parseVersionFile(dataRoot) {
-  const versionPath = join27(dataRoot, "VERSION");
+  const versionPath = join28(dataRoot, "VERSION");
   if (!existsSync27(versionPath)) return null;
   let content;
   try {
@@ -15322,9 +16685,9 @@ async function parseVersionFile(dataRoot) {
 async function getPackageInfo(sourceDir) {
   const candidates = [];
   if (sourceDir && sourceDir !== "unknown" && sourceDir !== "npm") {
-    candidates.push(join27(sourceDir, "package.json"));
+    candidates.push(join28(sourceDir, "package.json"));
   }
-  candidates.push(join27(process.cwd(), "package.json"));
+  candidates.push(join28(process.cwd(), "package.json"));
   for (const candidate of candidates) {
     try {
       const raw = await readFile5(candidate, "utf-8");
@@ -15350,7 +16713,7 @@ async function getRuntimeDiagnostics(options) {
   const scriptPath = process.argv[1] ?? "";
   const invocationName = basename4(scriptPath || process.argv0 || "cleo");
   const envChannel = normalizeChannel(process.env["CLEO_CHANNEL"]);
-  const dataRoot = process.env["CLEO_HOME"] ?? join27(homedir5(), ".cleo");
+  const dataRoot = process.env["CLEO_HOME"] ?? join28(homedir5(), ".cleo");
   const versionInfo = await parseVersionFile(dataRoot);
   const packageInfo = await getPackageInfo(versionInfo?.source);
   const channel = envChannel ?? detectFromInvocation(invocationName) ?? normalizeChannel(versionInfo?.version.includes("-beta") ? "beta" : void 0) ?? detectFromDataRoot(dataRoot) ?? normalizeChannel(versionInfo?.mode.startsWith("dev") ? "dev" : void 0) ?? "stable";
@@ -15565,9 +16928,9 @@ async function systemLog(projectRoot, filters) {
 }
 async function queryAuditLogSqlite(projectRoot, filters) {
   try {
-    const { join: join52 } = await import("node:path");
+    const { join: join53 } = await import("node:path");
     const { existsSync: existsSync51 } = await import("node:fs");
-    const dbPath = join52(projectRoot, ".cleo", "tasks.db");
+    const dbPath = join53(projectRoot, ".cleo", "tasks.db");
     if (!existsSync51(dbPath)) return null;
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
@@ -15663,32 +17026,32 @@ function queryAuditLogJsonl(projectRoot, filters) {
 }
 function systemContext(projectRoot, params) {
   try {
-    const cleoDir = join28(projectRoot, ".cleo");
+    const cleoDir = join29(projectRoot, ".cleo");
     let stateFile;
     if (params?.session) {
-      const sessionFile = join28(cleoDir, "context-states", `context-state-${params.session}.json`);
-      stateFile = existsSync28(sessionFile) ? sessionFile : join28(cleoDir, ".context-state.json");
+      const sessionFile = join29(cleoDir, "context-states", `context-state-${params.session}.json`);
+      stateFile = existsSync28(sessionFile) ? sessionFile : join29(cleoDir, ".context-state.json");
     } else {
-      const currentSessionPath = join28(cleoDir, ".current-session");
+      const currentSessionPath = join29(cleoDir, ".current-session");
       if (existsSync28(currentSessionPath)) {
         const currentSession = readFileSync19(currentSessionPath, "utf-8").trim();
         if (currentSession) {
-          const sessionFile = join28(cleoDir, "context-states", `context-state-${currentSession}.json`);
-          stateFile = existsSync28(sessionFile) ? sessionFile : join28(cleoDir, ".context-state.json");
+          const sessionFile = join29(cleoDir, "context-states", `context-state-${currentSession}.json`);
+          stateFile = existsSync28(sessionFile) ? sessionFile : join29(cleoDir, ".context-state.json");
         } else {
-          stateFile = join28(cleoDir, ".context-state.json");
+          stateFile = join29(cleoDir, ".context-state.json");
         }
       } else {
-        stateFile = join28(cleoDir, ".context-state.json");
+        stateFile = join29(cleoDir, ".context-state.json");
       }
     }
     const sessions2 = [];
-    const statesDir = join28(cleoDir, "context-states");
+    const statesDir = join29(cleoDir, "context-states");
     if (existsSync28(statesDir)) {
       for (const file of readdirSync7(statesDir)) {
         if (file.startsWith("context-state-") && file.endsWith(".json")) {
           try {
-            const state = JSON.parse(readFileSync19(join28(statesDir, file), "utf-8"));
+            const state = JSON.parse(readFileSync19(join29(statesDir, file), "utf-8"));
             sessions2.push({
               file: basename5(file),
               sessionId: state.sessionId ?? null,
@@ -15701,7 +17064,7 @@ function systemContext(projectRoot, params) {
         }
       }
     }
-    const singletonFile = join28(cleoDir, ".context-state.json");
+    const singletonFile = join29(cleoDir, ".context-state.json");
     if (existsSync28(singletonFile)) {
       try {
         const state = JSON.parse(readFileSync19(singletonFile, "utf-8"));
@@ -15949,18 +17312,18 @@ init_schema_management();
 init_injection();
 import { mkdir as mkdir8, copyFile as copyFile3, symlink, lstat, unlink as unlink3 } from "node:fs/promises";
 import { existsSync as existsSync29, readFileSync as readFileSync21, readdirSync as readdirSync8 } from "node:fs";
-import { join as join31, dirname as dirname7, basename as basename6 } from "node:path";
+import { join as join32, dirname as dirname8, basename as basename6 } from "node:path";
 import { readFile as readFile7 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
 async function initAgentDefinition(created, warnings) {
   const packageRoot = getPackageRoot();
-  const agentSourceDir = join31(packageRoot, "agents", "cleo-subagent");
+  const agentSourceDir = join32(packageRoot, "agents", "cleo-subagent");
   if (!existsSync29(agentSourceDir)) {
     warnings.push("agents/cleo-subagent/ not found in package, skipping agent definition install");
     return;
   }
-  const globalAgentsDir = join31(homedir7(), ".agents", "agents", "cleo-subagent");
-  await mkdir8(dirname7(globalAgentsDir), { recursive: true });
+  const globalAgentsDir = join32(homedir7(), ".agents", "agents", "cleo-subagent");
+  await mkdir8(dirname8(globalAgentsDir), { recursive: true });
   try {
     try {
       const stat2 = await lstat(globalAgentsDir);
@@ -15976,7 +17339,7 @@ async function initAgentDefinition(created, warnings) {
       await mkdir8(globalAgentsDir, { recursive: true });
       const files = readdirSync8(agentSourceDir);
       for (const file of files) {
-        await copyFile3(join31(agentSourceDir, file), join31(globalAgentsDir, file));
+        await copyFile3(join32(agentSourceDir, file), join32(globalAgentsDir, file));
       }
       created.push("agent: cleo-subagent (copied)");
     } catch (copyErr) {
@@ -16028,12 +17391,12 @@ async function initCoreSkills(created, warnings) {
     const packageRoot = getPackageRoot();
     let ctSkillsRoot = null;
     try {
-      const bundledPath = join31(packageRoot, "packages", "ct-skills");
-      if (existsSync29(join31(bundledPath, "skills.json"))) {
+      const bundledPath = join32(packageRoot, "packages", "ct-skills");
+      if (existsSync29(join32(bundledPath, "skills.json"))) {
         ctSkillsRoot = bundledPath;
       } else {
-        const ctSkillsPath = join31(packageRoot, "node_modules", "@cleocode", "ct-skills");
-        if (existsSync29(join31(ctSkillsPath, "skills.json"))) {
+        const ctSkillsPath = join32(packageRoot, "node_modules", "@cleocode", "ct-skills");
+        if (existsSync29(join32(ctSkillsPath, "skills.json"))) {
           ctSkillsRoot = ctSkillsPath;
         }
       }
@@ -16048,13 +17411,13 @@ async function initCoreSkills(created, warnings) {
     } catch {
       warnings.push("Failed to register skill library with CAAMP");
     }
-    const catalogPath = join31(ctSkillsRoot, "skills.json");
+    const catalogPath = join32(ctSkillsRoot, "skills.json");
     const catalog2 = JSON.parse(readFileSync21(catalogPath, "utf-8"));
     const skills = catalog2.skills ?? [];
     const coreSkills = skills.filter((s) => s.tier <= 2);
     const installed = [];
     for (const skill of coreSkills) {
-      const skillSourceDir = dirname7(join31(ctSkillsRoot, skill.path));
+      const skillSourceDir = dirname8(join32(ctSkillsRoot, skill.path));
       if (!existsSync29(skillSourceDir)) {
         continue;
       }
@@ -16131,7 +17494,7 @@ async function initProject(opts = {}) {
   }
   try {
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
-    await getDb2(join31(cleoDir, ".."));
+    await getDb2(join32(cleoDir, ".."));
     created.push("tasks.db");
   } catch (err) {
     created.push(`tasks.db (deferred: ${err instanceof Error ? err.message : String(err)})`);
@@ -16144,7 +17507,7 @@ async function initProject(opts = {}) {
       created.push(".gitignore");
     }
   } else {
-    const gitignorePath = join31(cleoDir, ".gitignore");
+    const gitignorePath = join32(cleoDir, ".gitignore");
     if (existsSync29(gitignorePath)) {
       skipped.push(".gitignore");
     } else {
@@ -16156,12 +17519,12 @@ async function initProject(opts = {}) {
       }
     }
   }
-  const legacySequencePath = join31(cleoDir, ".sequence");
+  const legacySequencePath = join32(cleoDir, ".sequence");
   try {
     await unlink3(legacySequencePath);
   } catch {
   }
-  const legacySequenceJsonPath = join31(cleoDir, ".sequence.json");
+  const legacySequenceJsonPath = join32(cleoDir, ".sequence.json");
   try {
     await unlink3(legacySequenceJsonPath);
   } catch {
@@ -16256,8 +17619,8 @@ async function initProject(opts = {}) {
 async function getVersion(projectRoot) {
   const root = projectRoot ?? getProjectRoot();
   const versionPaths = [
-    join31(root, "VERSION"),
-    join31(root, "..", "VERSION")
+    join32(root, "VERSION"),
+    join32(root, "..", "VERSION")
   ];
   for (const versionPath of versionPaths) {
     try {
@@ -16269,7 +17632,7 @@ async function getVersion(projectRoot) {
     } catch {
     }
   }
-  const pkg = await readJson(join31(root, "package.json"));
+  const pkg = await readJson(join32(root, "package.json"));
   if (pkg?.version) {
     return { version: pkg.version };
   }
@@ -16316,17 +17679,17 @@ init_paths();
 init_schema();
 init_sqlite();
 init_schema();
-import { eq as eq10 } from "drizzle-orm";
+import { eq as eq11 } from "drizzle-orm";
 
 // src/core/lifecycle/stage-artifacts.ts
 import { existsSync as existsSync31 } from "node:fs";
 import { readFile as readFile8, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname8, join as join33, relative } from "node:path";
+import { dirname as dirname9, join as join34, relative } from "node:path";
 
 // src/core/lifecycle/rcasd-paths.ts
 init_paths();
-import { join as join32 } from "node:path";
-import { existsSync as existsSync30, mkdirSync as mkdirSync9, readdirSync as readdirSync9 } from "node:fs";
+import { join as join33 } from "node:path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync10, readdirSync as readdirSync9 } from "node:fs";
 var STAGE_SUBDIRS = {
   research: "research",
   consensus: "consensus",
@@ -16343,16 +17706,16 @@ function normalizeEpicId(dirName) {
 }
 function getEpicDir(epicId, cwd) {
   const normalized = normalizeEpicId(epicId);
-  return join32(getCleoDirAbsolute(cwd), DEFAULT_DIR, normalized);
+  return join33(getCleoDirAbsolute(cwd), DEFAULT_DIR, normalized);
 }
 function getStagePath(epicId, stage, cwd) {
   const subdir = STAGE_SUBDIRS[stage] ?? stage;
-  return join32(getEpicDir(epicId, cwd), subdir);
+  return join33(getEpicDir(epicId, cwd), subdir);
 }
 function ensureStagePath(epicId, stage, cwd) {
   const path = getStagePath(epicId, stage, cwd);
   if (!existsSync30(path)) {
-    mkdirSync9(path, { recursive: true });
+    mkdirSync10(path, { recursive: true });
   }
   return path;
 }
@@ -16728,10 +18091,10 @@ function toWorkspaceRelative(path, cwd) {
 function buildRelatedLinks(epicId, stage, absolutePath, cwd) {
   const prereqs = STAGE_PREREQUISITES[stage] ?? [];
   const related = [{ type: "task", id: epicId }];
-  const artifactDir = dirname8(absolutePath);
+  const artifactDir = dirname9(absolutePath);
   for (const prereq of prereqs) {
     const prereqDir = getStagePath(epicId, prereq, cwd);
-    const prereqFile = join33(prereqDir, `${epicId}-${stageSlug(prereq)}.md`);
+    const prereqFile = join34(prereqDir, `${epicId}-${stageSlug(prereq)}.md`);
     if (!existsSync31(prereqFile)) {
       continue;
     }
@@ -16745,7 +18108,7 @@ function buildRelatedLinks(epicId, stage, absolutePath, cwd) {
 async function ensureStageArtifact(epicId, stage, cwd) {
   const stageDir = ensureStagePath(epicId, stage, cwd);
   const fileName = `${epicId}-${stageSlug(stage)}.md`;
-  const absolutePath = join33(stageDir, fileName);
+  const absolutePath = join34(stageDir, fileName);
   const outputFile = toWorkspaceRelative(absolutePath, cwd);
   const currentContent = existsSync31(absolutePath) ? await readFile8(absolutePath, "utf-8") : buildDefaultBody(epicId, stage);
   const related = buildRelatedLinks(epicId, stage, absolutePath, cwd);
@@ -16766,7 +18129,7 @@ async function ensureStageArtifact(epicId, stage, cwd) {
 init_sqlite();
 init_schema();
 init_paths();
-import { eq as eq7, like } from "drizzle-orm";
+import { eq as eq8, like } from "drizzle-orm";
 import { relative as relative2, basename as basename7 } from "node:path";
 async function recordEvidence(epicId, stage, uri, type, options) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -16811,12 +18174,12 @@ async function linkProvenance(epicId, stage, filePath, cwd) {
 init_sqlite();
 init_schema();
 import { readFileSync as readFileSync23, readdirSync as readdirSync10, writeFileSync as writeFileSync6, existsSync as existsSync32 } from "node:fs";
-import { join as join35 } from "node:path";
-import { eq as eq8 } from "drizzle-orm";
+import { join as join36 } from "node:path";
+import { eq as eq9 } from "drizzle-orm";
 
 // src/core/adrs/parse.ts
 import { readFileSync as readFileSync22 } from "node:fs";
-import { join as join34 } from "node:path";
+import { join as join35 } from "node:path";
 function extractAdrId(filename) {
   const match = filename.match(/^(ADR-\d+)/);
   return match ? match[1] : filename.replace(".md", "");
@@ -16838,7 +18201,7 @@ function extractTitle(content) {
   return match ? match[1].trim() : "Untitled";
 }
 function parseAdrFile(filePath, projectRoot) {
-  const absolutePath = filePath.startsWith("/") ? filePath : join34(projectRoot, filePath);
+  const absolutePath = filePath.startsWith("/") ? filePath : join35(projectRoot, filePath);
   const content = readFileSync22(absolutePath, "utf-8");
   const filename = filePath.split("/").pop();
   return {
@@ -16861,7 +18224,7 @@ function collectAdrFiles(dir) {
   const results = [];
   for (const entry of readdirSync10(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      const sub = join35(dir, entry.name);
+      const sub = join36(dir, entry.name);
       for (const f of readdirSync10(sub)) {
         if (f.endsWith(".md") && /^ADR-\d+/.test(f)) {
           results.push({ file: f, relPath: `${entry.name}/${f}` });
@@ -16874,7 +18237,7 @@ function collectAdrFiles(dir) {
   return results.sort((a, b) => a.file.localeCompare(b.file));
 }
 async function syncAdrsToDb(projectRoot) {
-  const adrsDir = join35(projectRoot, ".cleo", "adrs");
+  const adrsDir = join36(projectRoot, ".cleo", "adrs");
   const result = { inserted: 0, updated: 0, skipped: 0, errors: [] };
   if (!existsSync32(adrsDir)) {
     return result;
@@ -16886,7 +18249,7 @@ async function syncAdrsToDb(projectRoot) {
   const manifestEntries2 = [];
   for (const { file, relPath } of activeFiles) {
     try {
-      const filePath = join35(adrsDir, relPath);
+      const filePath = join36(adrsDir, relPath);
       const record = parseAdrFile(filePath, projectRoot);
       const fm = record.frontmatter;
       const dbRelPath = `.cleo/adrs/${relPath}`;
@@ -16912,15 +18275,15 @@ async function syncAdrsToDb(projectRoot) {
         topics: fm.Topics ?? null,
         updatedAt: now
       };
-      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq8(architectureDecisions.id, record.id)).all();
+      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq9(architectureDecisions.id, record.id)).all();
       if (existing.length > 0) {
-        await db.update(architectureDecisions).set(rowBase).where(eq8(architectureDecisions.id, record.id));
+        await db.update(architectureDecisions).set(rowBase).where(eq9(architectureDecisions.id, record.id));
         result.updated++;
       } else {
         await db.insert(architectureDecisions).values({ ...rowBase, createdAt: now });
         result.inserted++;
       }
-      await db.delete(adrTaskLinks).where(eq8(adrTaskLinks.adrId, record.id));
+      await db.delete(adrTaskLinks).where(eq9(adrTaskLinks.adrId, record.id));
       if (fm["Related Tasks"]) {
         for (const taskId of parseTaskIds(fm["Related Tasks"])) {
           await db.insert(adrTaskLinks).values({ adrId: record.id, taskId, linkType: "related" });
@@ -16932,7 +18295,7 @@ async function syncAdrsToDb(projectRoot) {
   }
   for (const { relPath } of allFiles) {
     try {
-      const filePath = join35(adrsDir, relPath);
+      const filePath = join36(adrsDir, relPath);
       const record = parseAdrFile(filePath, projectRoot);
       const fm = record.frontmatter;
       const entry = {
@@ -16960,7 +18323,7 @@ async function syncAdrsToDb(projectRoot) {
     }
   }
   writeFileSync6(
-    join35(adrsDir, "MANIFEST.jsonl"),
+    join36(adrsDir, "MANIFEST.jsonl"),
     manifestEntries2.map((e) => JSON.stringify(e)).join("\n") + "\n",
     "utf-8"
   );
@@ -16971,8 +18334,8 @@ async function syncAdrsToDb(projectRoot) {
 init_sqlite();
 init_schema();
 import { readdirSync as readdirSync11, readFileSync as readFileSync24, existsSync as existsSync33 } from "node:fs";
-import { join as join36 } from "node:path";
-import { eq as eq9, and as and2 } from "drizzle-orm";
+import { join as join37 } from "node:path";
+import { eq as eq10, and as and3 } from "drizzle-orm";
 function parseTaskIds2(raw) {
   if (!raw) return [];
   return raw.split(",").map((t) => t.trim()).filter((t) => /^T\d{1,5}$/.test(t));
@@ -16981,7 +18344,7 @@ function findAdrsForTask(adrsDir, taskId) {
   if (!existsSync33(adrsDir)) return [];
   return readdirSync11(adrsDir).filter((f) => f.endsWith(".md") && /^ADR-\d+/.test(f)).filter((file) => {
     try {
-      const content = readFileSync24(join36(adrsDir, file), "utf-8");
+      const content = readFileSync24(join37(adrsDir, file), "utf-8");
       const relatedTasksMatch = content.match(/^\*\*Related Tasks\*\*:\s*(.+)$/m);
       if (!relatedTasksMatch) return false;
       const taskIds = parseTaskIds2(relatedTasksMatch[1]);
@@ -16989,7 +18352,7 @@ function findAdrsForTask(adrsDir, taskId) {
     } catch {
       return false;
     }
-  }).map((f) => join36(adrsDir, f));
+  }).map((f) => join37(adrsDir, f));
 }
 async function linkPipelineAdr(projectRoot, taskId) {
   const result = {
@@ -16998,7 +18361,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
     skipped: 0,
     errors: []
   };
-  const adrsDir = join36(projectRoot, ".cleo", "adrs");
+  const adrsDir = join37(projectRoot, ".cleo", "adrs");
   const matchingFiles = findAdrsForTask(adrsDir, taskId);
   if (matchingFiles.length === 0) {
     return result;
@@ -17012,7 +18375,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
       const fm = record.frontmatter;
       const content = readFileSync24(filePath, "utf-8");
       const relativePath = `.cleo/adrs/${filename}`;
-      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq9(architectureDecisions.id, record.id)).all();
+      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq10(architectureDecisions.id, record.id)).all();
       const rowBase = {
         id: record.id,
         title: record.title,
@@ -17032,15 +18395,15 @@ async function linkPipelineAdr(projectRoot, taskId) {
         updatedAt: now
       };
       if (existing.length > 0) {
-        await db.update(architectureDecisions).set(rowBase).where(eq9(architectureDecisions.id, record.id));
+        await db.update(architectureDecisions).set(rowBase).where(eq10(architectureDecisions.id, record.id));
       } else {
         await db.insert(architectureDecisions).values({ ...rowBase, createdAt: now });
       }
       result.synced++;
       await db.delete(adrTaskLinks).where(
-        and2(
-          eq9(adrTaskLinks.adrId, record.id),
-          eq9(adrTaskLinks.taskId, taskId)
+        and3(
+          eq10(adrTaskLinks.adrId, record.id),
+          eq10(adrTaskLinks.taskId, taskId)
         )
       );
       await db.insert(adrTaskLinks).values({ adrId: record.id, taskId, linkType: "implements" });
@@ -17049,7 +18412,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
         const relatedIds = fm["Related ADRs"].split(",").map((r) => r.trim()).filter((r) => /^ADR-\d+$/.test(r));
         for (const toId of relatedIds) {
           try {
-            const targetExists = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq9(architectureDecisions.id, toId)).all();
+            const targetExists = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq10(architectureDecisions.id, toId)).all();
             if (targetExists.length > 0) {
               await db.insert(adrRelations).values({ fromAdrId: record.id, toAdrId: toId, relationType: "related" }).onConflictDoNothing();
             }
@@ -17071,7 +18434,7 @@ async function getLifecycleStatus(epicId, cwd) {
   const pipelineResult = await db.select({
     pipeline: lifecyclePipelines,
     task: tasks
-  }).from(lifecyclePipelines).innerJoin(tasks, eq10(lifecyclePipelines.taskId, tasks.id)).where(eq10(lifecyclePipelines.taskId, epicId)).limit(1);
+  }).from(lifecyclePipelines).innerJoin(tasks, eq11(lifecyclePipelines.taskId, tasks.id)).where(eq11(lifecyclePipelines.taskId, epicId)).limit(1);
   if (pipelineResult.length === 0) {
     return {
       epicId,
@@ -17084,7 +18447,7 @@ async function getLifecycleStatus(epicId, cwd) {
   }
   const task = pipelineResult[0].task;
   const pipelineId = `pipeline-${epicId}`;
-  const stageRows = await db.select().from(lifecycleStages).where(eq10(lifecycleStages.pipelineId, pipelineId)).orderBy(lifecycleStages.sequence);
+  const stageRows = await db.select().from(lifecycleStages).where(eq11(lifecycleStages.pipelineId, pipelineId)).orderBy(lifecycleStages.sequence);
   const stageDataMap = /* @__PURE__ */ new Map();
   for (const row of stageRows) {
     let parsedChain;
@@ -17154,7 +18517,7 @@ async function getLifecycleStatus(epicId, cwd) {
 async function getLifecycleHistory(epicId, cwd) {
   const db = await getDb(cwd);
   const pipelineId = `pipeline-${epicId}`;
-  const stages = await db.select().from(lifecycleStages).where(eq10(lifecycleStages.pipelineId, pipelineId));
+  const stages = await db.select().from(lifecycleStages).where(eq11(lifecycleStages.pipelineId, pipelineId));
   if (stages.length === 0) {
     return { epicId, history: [] };
   }
@@ -17184,7 +18547,7 @@ async function getLifecycleHistory(epicId, cwd) {
   }
   const stageIds = stages.map((s) => s.id);
   if (stageIds.length > 0) {
-    const gateResults = await db.select().from(lifecycleGateResults).where(eq10(lifecycleGateResults.stageId, stageIds[0]));
+    const gateResults = await db.select().from(lifecycleGateResults).where(eq11(lifecycleGateResults.stageId, stageIds[0]));
     for (const gate of gateResults) {
       const stageName = stageIdToName.get(gate.stageId);
       if (stageName) {
@@ -17197,7 +18560,7 @@ async function getLifecycleHistory(epicId, cwd) {
       }
     }
     for (let i = 1; i < stageIds.length; i++) {
-      const additionalGates = await db.select().from(lifecycleGateResults).where(eq10(lifecycleGateResults.stageId, stageIds[i]));
+      const additionalGates = await db.select().from(lifecycleGateResults).where(eq11(lifecycleGateResults.stageId, stageIds[i]));
       for (const gate of additionalGates) {
         const stageName = stageIdToName.get(gate.stageId);
         if (stageName) {
@@ -17217,13 +18580,13 @@ async function getLifecycleHistory(epicId, cwd) {
 async function getLifecycleGates(epicId, cwd) {
   const db = await getDb(cwd);
   const pipelineId = `pipeline-${epicId}`;
-  const stages = await db.select().from(lifecycleStages).where(eq10(lifecycleStages.pipelineId, pipelineId));
+  const stages = await db.select().from(lifecycleStages).where(eq11(lifecycleStages.pipelineId, pipelineId));
   if (stages.length === 0) {
     return {};
   }
   const gates = {};
   for (const stage of stages) {
-    const gateRows = await db.select().from(lifecycleGateResults).where(eq10(lifecycleGateResults.stageId, stage.id));
+    const gateRows = await db.select().from(lifecycleGateResults).where(eq11(lifecycleGateResults.stageId, stage.id));
     if (gateRows.length > 0) {
       gates[stage.stageName] = {};
       for (const gateRow of gateRows) {
@@ -17295,7 +18658,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
   getNativeDb2().prepare(
     `INSERT OR IGNORE INTO tasks (id, title, status, priority, created_at) VALUES (?, ?, 'pending', 'medium', datetime('now'))`
   ).run(epicId, `Task ${epicId}`);
-  const existingPipeline = await db.select().from(lifecyclePipelines).where(eq10(lifecyclePipelines.id, pipelineId)).limit(1).all();
+  const existingPipeline = await db.select().from(lifecyclePipelines).where(eq11(lifecyclePipelines.id, pipelineId)).limit(1).all();
   if (existingPipeline.length === 0) {
     await db.insert(lifecyclePipelines).values({
       id: pipelineId,
@@ -17305,7 +18668,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
       startedAt: options.now
     }).run();
   }
-  const existingStage = await db.select().from(lifecycleStages).where(eq10(lifecycleStages.id, stageId)).limit(1).all();
+  const existingStage = await db.select().from(lifecycleStages).where(eq11(lifecycleStages.id, stageId)).limit(1).all();
   if (existingStage.length === 0) {
     const sequence = isValidStage(stageName) ? STAGE_ORDER[stageName] : 0;
     await db.insert(lifecycleStages).values({
@@ -17318,7 +18681,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
     }).run();
   }
   if (options.updateCurrentStage) {
-    await db.update(lifecyclePipelines).set({ currentStageId: stageId }).where(eq10(lifecyclePipelines.id, pipelineId)).run();
+    await db.update(lifecyclePipelines).set({ currentStageId: stageId }).where(eq11(lifecyclePipelines.id, pipelineId)).run();
   }
   return { db, pipelineId, stageId };
 }
@@ -17348,7 +18711,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
     status,
     related: artifact.related
   };
-  const existingStage = await db.select().from(lifecycleStages).where(eq10(lifecycleStages.id, stageId)).limit(1).all();
+  const existingStage = await db.select().from(lifecycleStages).where(eq11(lifecycleStages.id, stageId)).limit(1).all();
   const sequence = STAGE_ORDER[stage];
   const stageValues = {
     status,
@@ -17375,7 +18738,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
       provenanceChainJson: JSON.stringify(provenanceChain)
     }).run();
   } else {
-    await db.update(lifecycleStages).set(stageValues).where(eq10(lifecycleStages.id, stageId)).run();
+    await db.update(lifecycleStages).set(stageValues).where(eq11(lifecycleStages.id, stageId)).run();
   }
   if (status === "completed") {
     await linkProvenance(epicId, stageName, artifact.absolutePath, cwd);
@@ -17407,7 +18770,7 @@ async function resetStage(epicId, stage, reason, cwd) {
     skippedAt: null,
     skipReason: null,
     notesJson: JSON.stringify([`Reset: ${reason}`])
-  }).where(eq10(lifecycleStages.id, stageId)).run();
+  }).where(eq11(lifecycleStages.id, stageId)).run();
   return { epicId, stage, reason };
 }
 async function passGate(epicId, gateName, agent, notes, cwd) {
@@ -17419,7 +18782,7 @@ async function passGate(epicId, gateName, agent, notes, cwd) {
     stageStatusOnCreate: "in_progress",
     updateCurrentStage: true
   });
-  const existingGate = await db.select().from(lifecycleGateResults).where(eq10(lifecycleGateResults.id, gateId)).limit(1).all();
+  const existingGate = await db.select().from(lifecycleGateResults).where(eq11(lifecycleGateResults.id, gateId)).limit(1).all();
   const gateValues = {
     id: gateId,
     stageId,
@@ -17431,7 +18794,7 @@ async function passGate(epicId, gateName, agent, notes, cwd) {
     reason: null
   };
   if (existingGate.length > 0) {
-    await db.update(lifecycleGateResults).set(gateValues).where(eq10(lifecycleGateResults.id, gateId)).run();
+    await db.update(lifecycleGateResults).set(gateValues).where(eq11(lifecycleGateResults.id, gateId)).run();
   } else {
     await db.insert(lifecycleGateResults).values(gateValues).run();
   }
@@ -17446,7 +18809,7 @@ async function failGate(epicId, gateName, reason, cwd) {
     stageStatusOnCreate: "in_progress",
     updateCurrentStage: true
   });
-  const existingGate = await db.select().from(lifecycleGateResults).where(eq10(lifecycleGateResults.id, gateId)).limit(1).all();
+  const existingGate = await db.select().from(lifecycleGateResults).where(eq11(lifecycleGateResults.id, gateId)).limit(1).all();
   const gateValues = {
     id: gateId,
     stageId,
@@ -17458,7 +18821,7 @@ async function failGate(epicId, gateName, reason, cwd) {
     reason: reason ?? null
   };
   if (existingGate.length > 0) {
-    await db.update(lifecycleGateResults).set(gateValues).where(eq10(lifecycleGateResults.id, gateId)).run();
+    await db.update(lifecycleGateResults).set(gateValues).where(eq11(lifecycleGateResults.id, gateId)).run();
   } else {
     await db.insert(lifecycleGateResults).values(gateValues).run();
   }
@@ -17607,9 +18970,9 @@ init_platform();
 // src/core/validation/validate-ops.ts
 init_paths();
 init_data_accessor();
-import { readFileSync as readFileSync26, existsSync as existsSync34, appendFileSync as appendFileSync3, mkdirSync as mkdirSync10 } from "node:fs";
+import { readFileSync as readFileSync26, existsSync as existsSync34, appendFileSync as appendFileSync3, mkdirSync as mkdirSync11 } from "node:fs";
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { join as join37, dirname as dirname9, resolve as resolve6 } from "node:path";
+import { join as join38, dirname as dirname10, resolve as resolve6 } from "node:path";
 
 // src/core/validation/schema-validator.ts
 init_validation_schemas();
@@ -17826,7 +19189,7 @@ init_json();
 init_status_registry();
 
 // src/core/repair.ts
-import { isNull as isNull2, sql as sql3 } from "drizzle-orm";
+import { isNull as isNull2, sql as sql4 } from "drizzle-orm";
 
 // src/core/validation/validate-ops.ts
 function readJsonFile2(filePath) {
@@ -17846,7 +19209,7 @@ async function coreValidateSchema(type, data, projectRoot) {
     throw new Error(`Unknown schema type: ${type}. Valid types: ${validTypes.join(", ")}`);
   }
   if (type === "config") {
-    const filePath = join37(projectRoot, ".cleo", "config.json");
+    const filePath = join38(projectRoot, ".cleo", "config.json");
     if (!existsSync34(filePath)) {
       throw new Error("File not found: .cleo/config.json");
     }
@@ -18058,7 +19421,7 @@ function coreValidateOutput(filePath, taskId, projectRoot) {
   };
 }
 function parseComplianceEntries(projectRoot) {
-  const compliancePath = join37(projectRoot, ".cleo", "metrics", "COMPLIANCE.jsonl");
+  const compliancePath = join38(projectRoot, ".cleo", "metrics", "COMPLIANCE.jsonl");
   if (!existsSync34(compliancePath)) {
     return [];
   }
@@ -18122,10 +19485,10 @@ function coreComplianceRecord(taskId, result, protocol, violations, projectRoot)
   if (!validResults.includes(result)) {
     throw new Error(`Invalid result: ${result}. Valid: ${validResults.join(", ")}`);
   }
-  const compliancePath = join37(projectRoot, ".cleo", "metrics", "COMPLIANCE.jsonl");
-  const dir = dirname9(compliancePath);
+  const compliancePath = join38(projectRoot, ".cleo", "metrics", "COMPLIANCE.jsonl");
+  const dir = dirname10(compliancePath);
   if (!existsSync34(dir)) {
-    mkdirSync10(dir, { recursive: true });
+    mkdirSync11(dir, { recursive: true });
   }
   const entry = {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18144,8 +19507,8 @@ function coreComplianceRecord(taskId, result, protocol, violations, projectRoot)
   };
 }
 function coreTestStatus(projectRoot) {
-  const testDir = join37(projectRoot, "tests");
-  const mcpTestDir = join37(projectRoot, "src", "mcp", "__tests__");
+  const testDir = join38(projectRoot, "tests");
+  const mcpTestDir = join38(projectRoot, "src", "mcp", "__tests__");
   const hasBatsTests = existsSync34(testDir);
   const hasMcpTests = existsSync34(mcpTestDir);
   return {
@@ -18289,8 +19652,8 @@ async function coreCoherenceCheck(projectRoot) {
   };
 }
 function coreTestRun(params, projectRoot) {
-  const hasVitest = existsSync34(join37(projectRoot, "node_modules", ".bin", "vitest"));
-  const hasBats = existsSync34(join37(projectRoot, "tests"));
+  const hasVitest = existsSync34(join38(projectRoot, "node_modules", ".bin", "vitest"));
+  const hasBats = existsSync34(join38(projectRoot, "tests"));
   if (!hasVitest && !hasBats) {
     return {
       ran: false,
@@ -18336,7 +19699,7 @@ function coreTestRun(params, projectRoot) {
   }
 }
 function coreTestCoverage(projectRoot) {
-  const coveragePath = join37(projectRoot, "coverage", "coverage-summary.json");
+  const coveragePath = join38(projectRoot, "coverage", "coverage-summary.json");
   if (!existsSync34(coveragePath)) {
     return {
       available: false,
@@ -18985,12 +20348,12 @@ async function getUnblockOpportunities(cwd, accessor) {
 // src/core/orchestration/parallel.ts
 init_errors();
 init_exit_codes();
-import { readFileSync as readFileSync27, writeFileSync as writeFileSync7, existsSync as existsSync35, mkdirSync as mkdirSync11 } from "node:fs";
-import { join as join38, dirname as dirname10 } from "node:path";
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync7, existsSync as existsSync35, mkdirSync as mkdirSync12 } from "node:fs";
+import { join as join39, dirname as dirname11 } from "node:path";
 init_json();
 init_paths();
 function getParallelStatePath(projectRoot) {
-  return join38(projectRoot, ".cleo", "parallel-state.json");
+  return join39(projectRoot, ".cleo", "parallel-state.json");
 }
 function readParallelState(projectRoot) {
   const statePath = getParallelStatePath(projectRoot);
@@ -19003,8 +20366,8 @@ function readParallelState(projectRoot) {
 }
 function writeParallelState(state, projectRoot) {
   const statePath = getParallelStatePath(projectRoot);
-  const dir = dirname10(statePath);
-  if (!existsSync35(dir)) mkdirSync11(dir, { recursive: true });
+  const dir = dirname11(statePath);
+  if (!existsSync35(dir)) mkdirSync12(dir, { recursive: true });
   writeFileSync7(statePath, JSON.stringify(state, null, 2), "utf-8");
 }
 async function startParallelExecution(epicId, wave, cwd, accessor) {
@@ -19141,7 +20504,7 @@ async function validateSpawnReadiness(taskId, cwd, accessor) {
 init_json();
 init_paths();
 import { readFileSync as readFileSync28, existsSync as existsSync36 } from "node:fs";
-import { join as join39 } from "node:path";
+import { join as join40 } from "node:path";
 async function buildBrainState(projectRoot, opts, accessor) {
   const speed = opts?.speed || "fast";
   const brain = {
@@ -19209,7 +20572,7 @@ async function buildBrainState(projectRoot, opts, accessor) {
       blockedBy: b.depends || []
     }));
     try {
-      const decisionLogPath = join39(projectRoot, ".cleo", "decision-log.jsonl");
+      const decisionLogPath = join40(projectRoot, ".cleo", "decision-log.jsonl");
       if (existsSync36(decisionLogPath)) {
         const content = readFileSync28(decisionLogPath, "utf-8").trim();
         if (content) {
@@ -19231,7 +20594,7 @@ async function buildBrainState(projectRoot, opts, accessor) {
     } catch {
     }
     try {
-      const contextStatePath = join39(projectRoot, ".cleo", ".context-state.json");
+      const contextStatePath = join40(projectRoot, ".cleo", ".context-state.json");
       if (existsSync36(contextStatePath)) {
         const state = JSON.parse(readFileSync28(contextStatePath, "utf-8"));
         const percentage = state.contextWindow?.percentage ?? 0;
@@ -19685,8 +21048,8 @@ async function orchestrateCheck(projectRoot) {
 
 // src/core/memory/engine-compat.ts
 init_paths();
-import { readFileSync as readFileSync32, writeFileSync as writeFileSync10, appendFileSync as appendFileSync6, existsSync as existsSync40, mkdirSync as mkdirSync14 } from "node:fs";
-import { resolve as resolve7, dirname as dirname11 } from "node:path";
+import { readFileSync as readFileSync32, writeFileSync as writeFileSync10, appendFileSync as appendFileSync6, existsSync as existsSync40, mkdirSync as mkdirSync15 } from "node:fs";
+import { resolve as resolve7, dirname as dirname12 } from "node:path";
 
 // src/core/memory/index.ts
 init_json();
@@ -19695,123 +21058,32 @@ init_errors();
 init_exit_codes();
 init_paths();
 
-// src/store/brain-accessor.ts
-import { eq as eq11, and as and3, gte, desc, asc as asc2 } from "drizzle-orm";
-
-// src/store/brain-sqlite.ts
-import { readMigrationFiles as readMigrationFiles2 } from "drizzle-orm/migrator";
-import { drizzle as drizzle2 } from "drizzle-orm/sqlite-proxy";
-import { migrate as migrate2 } from "drizzle-orm/sqlite-proxy/migrator";
-
-// src/store/brain-schema.ts
-import {
-  sqliteTable as sqliteTable2,
-  text as text2,
-  integer as integer2,
-  real,
-  index as index2,
-  primaryKey as primaryKey2
-} from "drizzle-orm/sqlite-core";
-import { sql as sql4 } from "drizzle-orm";
-var BRAIN_DECISION_TYPES = ["architecture", "technical", "process", "strategic", "tactical"];
-var BRAIN_CONFIDENCE_LEVELS = ["low", "medium", "high"];
-var BRAIN_OUTCOME_TYPES = ["success", "failure", "mixed", "pending"];
-var BRAIN_PATTERN_TYPES = ["workflow", "blocker", "success", "failure", "optimization"];
-var BRAIN_IMPACT_LEVELS = ["low", "medium", "high"];
-var BRAIN_LINK_TYPES = ["produced_by", "applies_to", "informed_by", "contradicts"];
-var BRAIN_MEMORY_TYPES = ["decision", "pattern", "learning"];
-var brainDecisions = sqliteTable2("brain_decisions", {
-  id: text2("id").primaryKey(),
-  type: text2("type", { enum: BRAIN_DECISION_TYPES }).notNull(),
-  decision: text2("decision").notNull(),
-  rationale: text2("rationale").notNull(),
-  confidence: text2("confidence", { enum: BRAIN_CONFIDENCE_LEVELS }).notNull(),
-  outcome: text2("outcome", { enum: BRAIN_OUTCOME_TYPES }),
-  alternativesJson: text2("alternatives_json"),
-  contextEpicId: text2("context_epic_id"),
-  // soft FK to tasks.id in tasks.db
-  contextTaskId: text2("context_task_id"),
-  // soft FK to tasks.id in tasks.db
-  contextPhase: text2("context_phase"),
-  createdAt: text2("created_at").notNull().default(sql4`(datetime('now'))`),
-  updatedAt: text2("updated_at")
-}, (table) => [
-  index2("idx_brain_decisions_type").on(table.type),
-  index2("idx_brain_decisions_confidence").on(table.confidence),
-  index2("idx_brain_decisions_outcome").on(table.outcome),
-  index2("idx_brain_decisions_context_epic").on(table.contextEpicId),
-  index2("idx_brain_decisions_context_task").on(table.contextTaskId)
-]);
-var brainPatterns = sqliteTable2("brain_patterns", {
-  id: text2("id").primaryKey(),
-  type: text2("type", { enum: BRAIN_PATTERN_TYPES }).notNull(),
-  pattern: text2("pattern").notNull(),
-  context: text2("context").notNull(),
-  frequency: integer2("frequency").notNull().default(1),
-  successRate: real("success_rate"),
-  impact: text2("impact", { enum: BRAIN_IMPACT_LEVELS }),
-  antiPattern: text2("anti_pattern"),
-  mitigation: text2("mitigation"),
-  examplesJson: text2("examples_json").default("[]"),
-  extractedAt: text2("extracted_at").notNull().default(sql4`(datetime('now'))`),
-  updatedAt: text2("updated_at")
-}, (table) => [
-  index2("idx_brain_patterns_type").on(table.type),
-  index2("idx_brain_patterns_impact").on(table.impact),
-  index2("idx_brain_patterns_frequency").on(table.frequency)
-]);
-var brainLearnings = sqliteTable2("brain_learnings", {
-  id: text2("id").primaryKey(),
-  insight: text2("insight").notNull(),
-  source: text2("source").notNull(),
-  confidence: real("confidence").notNull(),
-  // 0.0-1.0
-  actionable: integer2("actionable", { mode: "boolean" }).notNull().default(false),
-  application: text2("application"),
-  applicableTypesJson: text2("applicable_types_json"),
-  createdAt: text2("created_at").notNull().default(sql4`(datetime('now'))`),
-  updatedAt: text2("updated_at")
-}, (table) => [
-  index2("idx_brain_learnings_confidence").on(table.confidence),
-  index2("idx_brain_learnings_actionable").on(table.actionable)
-]);
-var brainMemoryLinks = sqliteTable2("brain_memory_links", {
-  memoryType: text2("memory_type", { enum: BRAIN_MEMORY_TYPES }).notNull(),
-  memoryId: text2("memory_id").notNull(),
-  taskId: text2("task_id").notNull(),
-  // soft FK to tasks.id in tasks.db
-  linkType: text2("link_type", { enum: BRAIN_LINK_TYPES }).notNull(),
-  createdAt: text2("created_at").notNull().default(sql4`(datetime('now'))`)
-}, (table) => [
-  primaryKey2({ columns: [table.memoryType, table.memoryId, table.taskId, table.linkType] }),
-  index2("idx_brain_links_task").on(table.taskId),
-  index2("idx_brain_links_memory").on(table.memoryType, table.memoryId)
-]);
-var brainSchemaMeta = sqliteTable2("brain_schema_meta", {
-  key: text2("key").primaryKey(),
-  value: text2("value").notNull()
-});
-
-// src/store/brain-sqlite.ts
-init_paths();
-init_node_sqlite_adapter();
-
 // src/core/memory/decisions.ts
+init_brain_accessor();
+init_brain_sqlite();
+init_brain_schema();
 import { desc as desc2 } from "drizzle-orm";
 
+// src/core/memory/brain-migration.ts
+init_brain_accessor();
+
+// src/core/memory/index.ts
+init_brain_search();
+init_brain_links();
+
 // src/core/memory/patterns.ts
 import { randomBytes as randomBytes7 } from "node:crypto";
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync8, appendFileSync as appendFileSync4, mkdirSync as mkdirSync12, existsSync as existsSync38 } from "node:fs";
-import { join as join40 } from "node:path";
+import { readFileSync as readFileSync30, writeFileSync as writeFileSync8, appendFileSync as appendFileSync4, mkdirSync as mkdirSync13, existsSync as existsSync38 } from "node:fs";
+import { join as join41 } from "node:path";
 function getMemoryDir(projectRoot) {
-  const memDir = join40(projectRoot, ".cleo", "memory");
+  const memDir = join41(projectRoot, ".cleo", "memory");
   if (!existsSync38(memDir)) {
-    mkdirSync12(memDir, { recursive: true });
+    mkdirSync13(memDir, { recursive: true });
   }
   return memDir;
 }
 function getPatternsPath(projectRoot) {
-  return join40(getMemoryDir(projectRoot), "patterns.jsonl");
+  return join41(getMemoryDir(projectRoot), "patterns.jsonl");
 }
 function generatePatternId() {
   return `P${randomBytes7(4).toString("hex")}`;
@@ -19928,17 +21200,17 @@ function patternStats(projectRoot) {
 
 // src/core/memory/learnings.ts
 import { randomBytes as randomBytes8 } from "node:crypto";
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync9, appendFileSync as appendFileSync5, mkdirSync as mkdirSync13, existsSync as existsSync39 } from "node:fs";
-import { join as join41 } from "node:path";
+import { readFileSync as readFileSync31, writeFileSync as writeFileSync9, appendFileSync as appendFileSync5, mkdirSync as mkdirSync14, existsSync as existsSync39 } from "node:fs";
+import { join as join42 } from "node:path";
 function getMemoryDir2(projectRoot) {
-  const memDir = join41(projectRoot, ".cleo", "memory");
+  const memDir = join42(projectRoot, ".cleo", "memory");
   if (!existsSync39(memDir)) {
-    mkdirSync13(memDir, { recursive: true });
+    mkdirSync14(memDir, { recursive: true });
   }
   return memDir;
 }
 function getLearningsPath(projectRoot) {
-  return join41(getMemoryDir2(projectRoot), "learnings.jsonl");
+  return join42(getMemoryDir2(projectRoot), "learnings.jsonl");
 }
 function generateLearningId() {
   return `L${randomBytes8(4).toString("hex")}`;
@@ -20051,6 +21323,7 @@ function learningStats(projectRoot) {
 }
 
 // src/core/memory/index.ts
+init_brain_retrieval();
 function filterManifestEntries(entries, filter) {
   let filtered = entries;
   if (filter.taskId) {
@@ -20084,6 +21357,7 @@ function filterManifestEntries(entries, filter) {
 }
 
 // src/core/memory/engine-compat.ts
+init_brain_retrieval();
 function getManifestPath2(projectRoot) {
   return getManifestPath(projectRoot);
 }
@@ -20278,9 +21552,9 @@ function memoryManifestAppend(entry, projectRoot) {
     return { success: false, error: { code: "E_VALIDATION_FAILED", message: `Invalid manifest entry: ${errors.join(", ")}` } };
   }
   const manifestPath = getManifestPath2(projectRoot);
-  const dir = dirname11(manifestPath);
+  const dir = dirname12(manifestPath);
   if (!existsSync40(dir)) {
-    mkdirSync14(dir, { recursive: true });
+    mkdirSync15(dir, { recursive: true });
   }
   const serialized = JSON.stringify(entry);
   appendFileSync6(manifestPath, serialized + "\n", "utf-8");
@@ -20299,9 +21573,9 @@ function memoryManifestArchive(beforeDate, projectRoot) {
   if (toArchive.length === 0) {
     return { success: true, data: { archived: 0, remaining: entries.length, message: "No entries found before the specified date" } };
   }
-  const archiveDir = dirname11(archivePath);
+  const archiveDir = dirname12(archivePath);
   if (!existsSync40(archiveDir)) {
-    mkdirSync14(archiveDir, { recursive: true });
+    mkdirSync15(archiveDir, { recursive: true });
   }
   const archiveContent = toArchive.map((e) => JSON.stringify(e)).join("\n") + "\n";
   appendFileSync6(archivePath, archiveContent, "utf-8");
@@ -20408,7 +21682,7 @@ function memoryInject(protocolType, params, projectRoot) {
   if (!protocolContent) {
     return {
       success: false,
-      error: { code: "E_NOT_FOUND", message: `Protocol '${protocolType}' not found in protocols/, skills/_shared/, or agents/cleo-subagent/protocols/` }
+      error: { code: "E_NOT_FOUND", message: `Protocol '${protocolType}' not found in src/protocols/, skills/_shared/, or agents/cleo-subagent/protocols/` }
     };
   }
   return {
@@ -20478,6 +21752,59 @@ function memoryLearningStats(projectRoot) {
     return { success: false, error: { code: "E_LEARNING_STATS", message: error instanceof Error ? error.message : String(error) } };
   }
 }
+async function memoryBrainSearch(params, projectRoot) {
+  try {
+    const root = resolveRoot(projectRoot);
+    const result = await searchBrainCompact(root, {
+      query: params.query,
+      limit: params.limit,
+      tables: params.tables,
+      dateStart: params.dateStart,
+      dateEnd: params.dateEnd
+    });
+    return { success: true, data: result };
+  } catch (error) {
+    return { success: false, error: { code: "E_BRAIN_SEARCH", message: error instanceof Error ? error.message : String(error) } };
+  }
+}
+async function memoryBrainTimeline(params, projectRoot) {
+  try {
+    const root = resolveRoot(projectRoot);
+    const result = await timelineBrain(root, {
+      anchor: params.anchor,
+      depthBefore: params.depthBefore,
+      depthAfter: params.depthAfter
+    });
+    return { success: true, data: result };
+  } catch (error) {
+    return { success: false, error: { code: "E_BRAIN_TIMELINE", message: error instanceof Error ? error.message : String(error) } };
+  }
+}
+async function memoryBrainFetch(params, projectRoot) {
+  try {
+    const root = resolveRoot(projectRoot);
+    const result = await fetchBrainEntries(root, { ids: params.ids });
+    return { success: true, data: result };
+  } catch (error) {
+    return { success: false, error: { code: "E_BRAIN_FETCH", message: error instanceof Error ? error.message : String(error) } };
+  }
+}
+async function memoryBrainObserve(params, projectRoot) {
+  try {
+    const root = resolveRoot(projectRoot);
+    const result = await observeBrain(root, {
+      text: params.text,
+      title: params.title,
+      type: params.type,
+      project: params.project,
+      sourceSessionId: params.sourceSessionId,
+      sourceType: params.sourceType
+    });
+    return { success: true, data: result };
+  } catch (error) {
+    return { success: false, error: { code: "E_BRAIN_OBSERVE", message: error instanceof Error ? error.message : String(error) } };
+  }
+}
 
 // src/dispatch/engines/release-engine.ts
 init_platform();
@@ -20486,11 +21813,11 @@ init_data_accessor();
 // src/core/release/release-manifest.ts
 init_json();
 init_paths();
-import { existsSync as existsSync41, mkdirSync as mkdirSync15 } from "node:fs";
+import { existsSync as existsSync41, mkdirSync as mkdirSync16 } from "node:fs";
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { dirname as dirname12, join as join42 } from "node:path";
+import { dirname as dirname13, join as join43 } from "node:path";
 function getReleasesPath(cwd) {
-  return join42(getCleoDirAbsolute(cwd), "releases.json");
+  return join43(getCleoDirAbsolute(cwd), "releases.json");
 }
 async function readReleases(cwd) {
   const data = await readJson(getReleasesPath(cwd));
@@ -20498,9 +21825,9 @@ async function readReleases(cwd) {
 }
 async function writeReleases(index3, cwd) {
   const releasesPath = getReleasesPath(cwd);
-  const dir = dirname12(releasesPath);
+  const dir = dirname13(releasesPath);
   if (!existsSync41(dir)) {
-    mkdirSync15(dir, { recursive: true });
+    mkdirSync16(dir, { recursive: true });
   }
   await saveJson(releasesPath, index3);
 }
@@ -20767,7 +22094,7 @@ async function rollbackRelease(version, reason, cwd) {
   };
 }
 async function readPushPolicy(cwd) {
-  const configPath = join42(getCleoDirAbsolute(cwd), "config.json");
+  const configPath = join43(getCleoDirAbsolute(cwd), "config.json");
   const config = await readJson(configPath);
   if (!config) return void 0;
   const release2 = config.release;
@@ -20983,7 +22310,7 @@ async function releasePush(version, remote, projectRoot, opts) {
 // src/dispatch/engines/template-parser.ts
 init_platform();
 import { readFileSync as readFileSync33, readdirSync as readdirSync12, existsSync as existsSync42 } from "fs";
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 import { parse as parseYaml } from "yaml";
 var SUFFIX_PATTERNS = ["_report", "_request", "_question"];
 function deriveSubcommand(filename) {
@@ -20998,7 +22325,7 @@ function deriveSubcommand(filename) {
   return firstWord.toLowerCase();
 }
 function parseTemplateFile(templateDir, filename) {
-  const filePath = join43(templateDir, filename);
+  const filePath = join44(templateDir, filename);
   const raw = readFileSync33(filePath, "utf-8");
   const parsed = parseYaml(raw);
   const name = typeof parsed.name === "string" ? parsed.name : filename;
@@ -21048,7 +22375,7 @@ function parseTemplateFile(templateDir, filename) {
   };
 }
 function parseIssueTemplates(projectRoot) {
-  const templateDir = join43(projectRoot, ".github", "ISSUE_TEMPLATE");
+  const templateDir = join44(projectRoot, ".github", "ISSUE_TEMPLATE");
   if (!existsSync42(templateDir)) {
     return engineError("E_NOT_FOUND", `Issue template directory not found: ${templateDir}`);
   }
@@ -21654,8 +22981,9 @@ var SessionHandler = class {
           if (endResult.success && endResult.data) {
             const sessionId = endResult.data.sessionId;
             if (sessionId) {
+              let debriefResult = null;
               try {
-                await sessionComputeDebrief(this.projectRoot, sessionId, {
+                debriefResult = await sessionComputeDebrief(this.projectRoot, sessionId, {
                   note: params?.note,
                   nextAction: params?.nextAction
                 });
@@ -21668,6 +22996,13 @@ var SessionHandler = class {
                 } catch {
                 }
               }
+              if (debriefResult?.success && debriefResult.data) {
+                try {
+                  const { persistSessionMemory: persistSessionMemory2 } = await Promise.resolve().then(() => (init_session_memory(), session_memory_exports));
+                  await persistSessionMemory2(this.projectRoot, sessionId, debriefResult.data);
+                } catch {
+                }
+              }
             }
             unbindSession();
           }
@@ -21956,12 +23291,12 @@ init_logger();
 
 // src/core/adrs/validate.ts
 import { readFileSync as readFileSync34, readdirSync as readdirSync13, existsSync as existsSync43 } from "node:fs";
-import { join as join44 } from "node:path";
+import { join as join45 } from "node:path";
 import AjvModule3 from "ajv";
 var Ajv3 = AjvModule3.default ?? AjvModule3;
 async function validateAllAdrs(projectRoot) {
-  const adrsDir = join44(projectRoot, ".cleo", "adrs");
-  const schemaPath = join44(projectRoot, "schemas", "adr-frontmatter.schema.json");
+  const adrsDir = join45(projectRoot, ".cleo", "adrs");
+  const schemaPath = join45(projectRoot, "schemas", "adr-frontmatter.schema.json");
   if (!existsSync43(schemaPath)) {
     return {
       valid: false,
@@ -21975,7 +23310,7 @@ async function validateAllAdrs(projectRoot) {
   const schema = JSON.parse(readFileSync34(schemaPath, "utf-8"));
   const ajv = new Ajv3({ allErrors: true });
   const validate = ajv.compile(schema);
-  const files = readdirSync13(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).map((f) => join44(adrsDir, f));
+  const files = readdirSync13(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).map((f) => join45(adrsDir, f));
   const errors = [];
   for (const filePath of files) {
     const record = parseAdrFile(filePath, projectRoot);
@@ -21995,14 +23330,14 @@ async function validateAllAdrs(projectRoot) {
 
 // src/core/adrs/list.ts
 import { readdirSync as readdirSync14, existsSync as existsSync44 } from "node:fs";
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 async function listAdrs(projectRoot, opts) {
-  const adrsDir = join45(projectRoot, ".cleo", "adrs");
+  const adrsDir = join46(projectRoot, ".cleo", "adrs");
   if (!existsSync44(adrsDir)) {
     return { adrs: [], total: 0 };
   }
   const files = readdirSync14(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).sort();
-  const records = files.map((f) => parseAdrFile(join45(adrsDir, f), projectRoot));
+  const records = files.map((f) => parseAdrFile(join46(adrsDir, f), projectRoot));
   const filtered = records.filter((r) => {
     if (opts?.status && r.frontmatter.Status !== opts.status) return false;
     if (opts?.since && r.frontmatter.Date < opts.since) return false;
@@ -22022,19 +23357,19 @@ async function listAdrs(projectRoot, opts) {
 
 // src/core/adrs/show.ts
 import { existsSync as existsSync45, readdirSync as readdirSync15 } from "node:fs";
-import { join as join46 } from "node:path";
+import { join as join47 } from "node:path";
 async function showAdr(projectRoot, adrId) {
-  const adrsDir = join46(projectRoot, ".cleo", "adrs");
+  const adrsDir = join47(projectRoot, ".cleo", "adrs");
   if (!existsSync45(adrsDir)) return null;
   const files = readdirSync15(adrsDir).filter((f) => f.startsWith(adrId) && f.endsWith(".md"));
   if (files.length === 0) return null;
-  const filePath = join46(adrsDir, files[0]);
+  const filePath = join47(adrsDir, files[0]);
   return parseAdrFile(filePath, projectRoot);
 }
 
 // src/core/adrs/find.ts
 import { readdirSync as readdirSync16, existsSync as existsSync46 } from "node:fs";
-import { join as join47 } from "node:path";
+import { join as join48 } from "node:path";
 function normalise(s) {
   return s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -22051,7 +23386,7 @@ function matchedTerms(target, terms) {
   return terms.filter((term) => t.includes(term));
 }
 async function findAdrs(projectRoot, query, opts) {
-  const adrsDir = join47(projectRoot, ".cleo", "adrs");
+  const adrsDir = join48(projectRoot, ".cleo", "adrs");
   if (!existsSync46(adrsDir)) {
     return { adrs: [], query, total: 0 };
   }
@@ -22061,7 +23396,7 @@ async function findAdrs(projectRoot, query, opts) {
   const filterKeywords = opts?.keywords ? parseTags(opts.keywords) : null;
   const results = [];
   for (const file of files) {
-    const record = parseAdrFile(join47(adrsDir, file), projectRoot);
+    const record = parseAdrFile(join48(adrsDir, file), projectRoot);
     const fm = record.frontmatter;
     if (opts?.status && fm.Status !== opts.status) continue;
     if (filterTopics && filterTopics.length > 0) {
@@ -22613,6 +23948,47 @@ var MemoryHandler = class {
           const result = memoryLearningStats(this.projectRoot);
           return this.wrapEngineResult(result, "query", "memory", operation, startTime);
         }
+        // BRAIN retrieval query operations (T5131-T5135)
+        case "brain.search": {
+          const query = params?.query;
+          if (!query) {
+            return this.errorResponse("query", "memory", operation, "E_INVALID_INPUT", "query is required", startTime);
+          }
+          const result = await memoryBrainSearch(
+            {
+              query,
+              limit: params?.limit,
+              tables: params?.tables,
+              dateStart: params?.dateStart,
+              dateEnd: params?.dateEnd
+            },
+            this.projectRoot
+          );
+          return this.wrapEngineResult(result, "query", "memory", operation, startTime);
+        }
+        case "brain.timeline": {
+          const anchor = params?.anchor;
+          if (!anchor) {
+            return this.errorResponse("query", "memory", operation, "E_INVALID_INPUT", "anchor is required", startTime);
+          }
+          const result = await memoryBrainTimeline(
+            {
+              anchor,
+              depthBefore: params?.depthBefore,
+              depthAfter: params?.depthAfter
+            },
+            this.projectRoot
+          );
+          return this.wrapEngineResult(result, "query", "memory", operation, startTime);
+        }
+        case "brain.fetch": {
+          const ids = params?.ids;
+          if (!ids || !Array.isArray(ids) || ids.length === 0) {
+            return this.errorResponse("query", "memory", operation, "E_INVALID_INPUT", "ids is required (non-empty array)", startTime);
+          }
+          const result = await memoryBrainFetch({ ids }, this.projectRoot);
+          return this.wrapEngineResult(result, "query", "memory", operation, startTime);
+        }
         default:
           return this.unsupported("query", "memory", operation, startTime);
       }
@@ -22705,6 +24081,25 @@ var MemoryHandler = class {
           );
           return this.wrapEngineResult(result, "mutate", "memory", operation, startTime);
         }
+        // BRAIN retrieval mutate operations (T5131-T5135)
+        case "brain.observe": {
+          const text3 = params?.text;
+          if (!text3) {
+            return this.errorResponse("mutate", "memory", operation, "E_INVALID_INPUT", "text is required", startTime);
+          }
+          const result = await memoryBrainObserve(
+            {
+              text: text3,
+              title: params?.title,
+              type: params?.type,
+              project: params?.project,
+              sourceSessionId: params?.sourceSessionId,
+              sourceType: params?.sourceType
+            },
+            this.projectRoot
+          );
+          return this.wrapEngineResult(result, "mutate", "memory", operation, startTime);
+        }
         default:
           return this.unsupported("mutate", "memory", operation, startTime);
       }
@@ -22717,8 +24112,8 @@ var MemoryHandler = class {
   // -----------------------------------------------------------------------
   getSupportedOperations() {
     return {
-      query: ["show", "list", "find", "pending", "stats", "manifest.read", "contradictions", "superseded", "pattern.search", "pattern.stats", "learning.search", "learning.stats"],
-      mutate: ["inject", "link", "manifest.append", "manifest.archive", "pattern.store", "learning.store"]
+      query: ["show", "list", "find", "pending", "stats", "manifest.read", "contradictions", "superseded", "pattern.search", "pattern.stats", "learning.search", "learning.stats", "brain.search", "brain.timeline", "brain.fetch"],
+      mutate: ["inject", "link", "manifest.append", "manifest.archive", "pattern.store", "learning.store", "brain.observe"]
     };
   }
   // -----------------------------------------------------------------------
@@ -23519,7 +24914,7 @@ import { execFileSync as execFileSync6 } from "node:child_process";
 // src/core/issue/template-parser.ts
 init_paths();
 import { existsSync as existsSync48, readFileSync as readFileSync35, readdirSync as readdirSync17, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join49, basename as basename8 } from "node:path";
+import { join as join50, basename as basename8 } from "node:path";
 var TEMPLATE_DIR = ".github/ISSUE_TEMPLATE";
 var CACHE_FILE = "issue-templates.json";
 var SUBCOMMAND_MAP = {
@@ -23594,12 +24989,12 @@ function parseTemplateFile2(filePath) {
 }
 function parseIssueTemplates2(projectDir) {
   const dir = projectDir ?? getProjectRoot();
-  const templateDir = join49(dir, TEMPLATE_DIR);
+  const templateDir = join50(dir, TEMPLATE_DIR);
   if (!existsSync48(templateDir)) return [];
   const templates = [];
   for (const file of readdirSync17(templateDir)) {
     if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
-    const template = parseTemplateFile2(join49(templateDir, file));
+    const template = parseTemplateFile2(join50(templateDir, file));
     if (template) templates.push(template);
   }
   return templates;
@@ -23608,7 +25003,7 @@ function getTemplateConfig(cwd) {
   const projectDir = cwd ?? getProjectRoot();
   const liveTemplates = parseIssueTemplates2(projectDir);
   if (liveTemplates.length > 0) return liveTemplates;
-  const cachePath = join49(getCleoDir(cwd), CACHE_FILE);
+  const cachePath = join50(getCleoDir(cwd), CACHE_FILE);
   if (existsSync48(cachePath)) {
     try {
       const cached = JSON.parse(readFileSync35(cachePath, "utf-8"));
@@ -24418,7 +25813,7 @@ init_logger();
 // src/core/sharing/index.ts
 import { readFile as readFile10, writeFile as writeFile6 } from "node:fs/promises";
 import { existsSync as existsSync49, readdirSync as readdirSync18, statSync as statSync9 } from "node:fs";
-import { join as join50, relative as relative3 } from "node:path";
+import { join as join51, relative as relative3 } from "node:path";
 init_paths();
 var GITIGNORE_START = "# CLEO:SHARING:START - Auto-managed by cleo sharing sync";
 var GITIGNORE_END = "# CLEO:SHARING:END";
@@ -24446,7 +25841,7 @@ function collectCleoFiles(cleoDir) {
     const entries = readdirSync18(dir);
     for (const entry of entries) {
       if (entry === ".git") continue;
-      const fullPath = join50(dir, entry);
+      const fullPath = join51(dir, entry);
       const relPath = relative3(cleoDir, fullPath);
       try {
         const stat2 = statSync9(fullPath);
@@ -24506,7 +25901,7 @@ function generateGitignoreEntries(sharing) {
 async function syncGitignore(cwd) {
   const config = await loadConfig2(cwd);
   const projectRoot = getProjectRoot(cwd);
-  const gitignorePath = join50(projectRoot, ".gitignore");
+  const gitignorePath = join51(projectRoot, ".gitignore");
   const entries = generateGitignoreEntries(config.sharing);
   const managedSection = [
     "",
@@ -24539,10 +25934,10 @@ async function syncGitignore(cwd) {
 // src/core/snapshot/index.ts
 init_data_accessor();
 init_paths();
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { readFile as readFile11, writeFile as writeFile7, mkdir as mkdir10 } from "node:fs/promises";
 import { existsSync as existsSync50 } from "node:fs";
-import { join as join51, dirname as dirname13 } from "node:path";
+import { join as join52, dirname as dirname14 } from "node:path";
 var SNAPSHOT_FORMAT_VERSION = "1.0.0";
 function toSnapshotTask(task) {
   return {
@@ -24563,7 +25958,7 @@ function toSnapshotTask(task) {
   };
 }
 function computeChecksum2(tasks2) {
-  const hash = createHash6("sha256");
+  const hash = createHash7("sha256");
   hash.update(JSON.stringify(tasks2));
   return hash.digest("hex").slice(0, 16);
 }
@@ -24595,7 +25990,7 @@ async function exportSnapshot(cwd) {
   };
 }
 async function writeSnapshot(snapshot, outputPath) {
-  const dir = dirname13(outputPath);
+  const dir = dirname14(outputPath);
   if (!existsSync50(dir)) {
     await mkdir10(dir, { recursive: true });
   }
@@ -24612,7 +26007,7 @@ async function readSnapshot(inputPath) {
 function getDefaultSnapshotPath(cwd) {
   const cleoDir = getCleoDirAbsolute(cwd);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  return join51(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
+  return join52(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
 }
 async function importSnapshot(snapshot, cwd) {
   const accessor = await getAccessor(cwd);