@cleocode/cleo 2026.3.2-beta.1 → 2026.3.4

package/dist/cli/index.js

@@ -714,8 +714,8 @@ function openNativeDatabase(path, options) {
   return db;
 }
 function createDrizzleCallback(db) {
-  return async (sql4, params, method) => {
-    const stmt = db.prepare(sql4);
+  return async (sql5, params, method) => {
+    const stmt = db.prepare(sql5);
     const p = params;
     switch (method) {
       case "run": {
@@ -5288,9 +5288,9 @@ var init_list = __esm({
 });
 
 // src/core/tasks/find.ts
-function fuzzyScore(query, text2) {
+function fuzzyScore(query, text3) {
   const q = query.toLowerCase();
-  const t = text2.toLowerCase();
+  const t = text3.toLowerCase();
   if (t === q) return 100;
   if (t.includes(q)) return 80;
   const words = t.split(/\s+/);
@@ -6793,6 +6793,51 @@ var init_session_view = __esm({
   }
 });
 
+// src/core/sessions/find.ts
+async function findSessions(accessor, params) {
+  let sessions2 = await accessor.loadSessions();
+  if (params?.status) {
+    sessions2 = sessions2.filter((s) => s.status === params.status);
+  }
+  if (params?.scope) {
+    const scopeParts = params.scope.split(":");
+    const scopeType = scopeParts[0];
+    const scopeId = scopeParts[1];
+    sessions2 = sessions2.filter((s) => {
+      if (s.scope.type !== scopeType) return false;
+      if (scopeId && s.scope.rootTaskId !== scopeId && s.scope.epicId !== scopeId) return false;
+      return true;
+    });
+  }
+  if (params?.query) {
+    const q = params.query.toLowerCase();
+    sessions2 = sessions2.filter(
+      (s) => s.id.toLowerCase().includes(q) || s.name.toLowerCase().includes(q)
+    );
+  }
+  sessions2.sort(
+    (a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime()
+  );
+  if (params?.limit && params.limit > 0) {
+    sessions2 = sessions2.slice(0, params.limit);
+  }
+  return sessions2.map(toMinimal);
+}
+function toMinimal(s) {
+  return {
+    id: s.id,
+    name: s.name,
+    status: s.status,
+    startedAt: s.startedAt,
+    scope: s.scope
+  };
+}
+var init_find2 = __esm({
+  "src/core/sessions/find.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/sessions/index.ts
 var init_sessions = __esm({
   "src/core/sessions/index.ts"() {
@@ -6814,6 +6859,7 @@ var init_sessions = __esm({
     init_handoff();
     init_briefing();
     init_session_view();
+    init_find2();
   }
 });
 
@@ -10308,9 +10354,13 @@ function createAudit() {
       },
       `${entry.metadata.gateway ?? "dispatch"} ${entry.domain}.${entry.operation}`
     );
-    writeToSqlite(entry, req.requestId).catch((err) => {
-      log4.error({ err }, "Failed to persist audit entry to SQLite");
-    });
+    if (isGradeSession) {
+      await writeToSqlite(entry, req.requestId);
+    } else {
+      writeToSqlite(entry, req.requestId).catch((err) => {
+        log4.error({ err }, "Failed to persist audit entry to SQLite");
+      });
+    }
     return response;
   };
 }
@@ -10318,16 +10368,16 @@ async function queryAudit(options) {
   try {
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
-    const { and: and4, eq: eq12, gte, or } = await import("drizzle-orm");
+    const { and: and5, eq: eq13, gte: gte2, or } = await import("drizzle-orm");
     const db = await getDb2(process.cwd());
     const conditions = [];
-    if (options?.sessionId) conditions.push(eq12(auditLog2.sessionId, options.sessionId));
-    if (options?.domain) conditions.push(eq12(auditLog2.domain, options.domain));
-    if (options?.operation) conditions.push(or(eq12(auditLog2.operation, options.operation), eq12(auditLog2.action, options.operation)));
-    if (options?.taskId) conditions.push(eq12(auditLog2.taskId, options.taskId));
-    if (options?.since) conditions.push(gte(auditLog2.timestamp, options.since));
+    if (options?.sessionId) conditions.push(eq13(auditLog2.sessionId, options.sessionId));
+    if (options?.domain) conditions.push(eq13(auditLog2.domain, options.domain));
+    if (options?.operation) conditions.push(or(eq13(auditLog2.operation, options.operation), eq13(auditLog2.action, options.operation)));
+    if (options?.taskId) conditions.push(eq13(auditLog2.taskId, options.taskId));
+    if (options?.since) conditions.push(gte2(auditLog2.timestamp, options.since));
     const limit = options?.limit ?? 1e3;
-    const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and4(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
+    const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and5(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
     return rows.map((row) => ({
       timestamp: row.timestamp,
       sessionId: row.sessionId,
@@ -10459,8 +10509,8 @@ async function gradeSession(sessionId, cwd) {
   );
   let hygieneScore = 20;
   for (const addCall of addCalls) {
-    const desc2 = addCall.params?.description;
-    if (!desc2 || desc2.trim().length === 0) {
+    const desc4 = addCall.params?.description;
+    if (!desc4 || desc4.trim().length === 0) {
       hygieneScore -= 5;
       result.flags.push(
         `tasks.add without description (taskId: ${addCall.metadata?.taskId ?? "unknown"})`
@@ -11484,9 +11534,9 @@ function cliOutput(data, opts) {
     }
     const normalized = normalizeForHuman(opts.command, dataToRender);
     const renderer = fieldExtracted ? renderGeneric : renderers[opts.command] ?? renderGeneric;
-    const text2 = renderer(normalized, ctx.quiet);
-    if (text2) {
-      console.log(text2);
+    const text3 = renderer(normalized, ctx.quiet);
+    if (text3) {
+      console.log(text3);
     }
     return;
   }
@@ -11591,7 +11641,7 @@ __export(session_store_exports, {
   updateSession: () => updateSession,
   workHistory: () => workHistory
 });
-import { eq as eq11, and as and3, desc, isNull as isNull3 } from "drizzle-orm";
+import { eq as eq12, and as and4, desc as desc3, isNull as isNull3 } from "drizzle-orm";
 async function createSession(session, cwd) {
   const db = await getDb(cwd);
   const tw = session.taskWork;
@@ -11613,7 +11663,7 @@ async function createSession(session, cwd) {
 }
 async function getSession(sessionId, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(sessions).where(eq11(sessions.id, sessionId)).all();
+  const rows = await db.select().from(sessions).where(eq12(sessions.id, sessionId)).all();
   if (rows.length === 0) return null;
   return rowToSession(rows[0]);
 }
@@ -11637,16 +11687,16 @@ async function updateSession(sessionId, updates, cwd) {
   if (updates.handoffConsumedBy !== void 0) updateRow.handoffConsumedBy = updates.handoffConsumedBy;
   if (updates.debriefJson !== void 0) updateRow.debriefJson = updates.debriefJson;
   if (updates.handoffJson !== void 0) updateRow.handoffJson = updates.handoffJson;
-  db.update(sessions).set(updateRow).where(eq11(sessions.id, sessionId)).run();
+  db.update(sessions).set(updateRow).where(eq12(sessions.id, sessionId)).run();
   return getSession(sessionId, cwd);
 }
 async function listSessions(filters, cwd) {
   const db = await getDb(cwd);
   const conditions = [];
   if (filters?.active) {
-    conditions.push(eq11(sessions.status, "active"));
+    conditions.push(eq12(sessions.status, "active"));
   }
-  const query = db.select().from(sessions).where(conditions.length > 0 ? and3(...conditions) : void 0).orderBy(desc(sessions.startedAt));
+  const query = db.select().from(sessions).where(conditions.length > 0 ? and4(...conditions) : void 0).orderBy(desc3(sessions.startedAt));
   const rows = filters?.limit ? await query.limit(filters.limit).all() : await query.all();
   return rows.map(rowToSession);
 }
@@ -11667,34 +11717,34 @@ async function endSession(sessionId, note, cwd) {
 async function startTask2(sessionId, taskId, cwd) {
   const db = await getDb(cwd);
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(taskWorkHistory).set({ clearedAt: now }).where(and3(
-    eq11(taskWorkHistory.sessionId, sessionId),
+  db.update(taskWorkHistory).set({ clearedAt: now }).where(and4(
+    eq12(taskWorkHistory.sessionId, sessionId),
     isNull3(taskWorkHistory.clearedAt)
   )).run();
   db.insert(taskWorkHistory).values({ sessionId, taskId, setAt: now }).run();
-  db.update(sessions).set({ currentTask: taskId, taskStartedAt: now }).where(eq11(sessions.id, sessionId)).run();
+  db.update(sessions).set({ currentTask: taskId, taskStartedAt: now }).where(eq12(sessions.id, sessionId)).run();
 }
 async function getCurrentTask(sessionId, cwd) {
   const db = await getDb(cwd);
   const rows = await db.select({
     currentTask: sessions.currentTask,
     taskStartedAt: sessions.taskStartedAt
-  }).from(sessions).where(eq11(sessions.id, sessionId)).all();
+  }).from(sessions).where(eq12(sessions.id, sessionId)).all();
   if (rows.length === 0) return { taskId: null, since: null };
   return { taskId: rows[0].currentTask, since: rows[0].taskStartedAt };
 }
 async function stopTask2(sessionId, cwd) {
   const db = await getDb(cwd);
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(taskWorkHistory).set({ clearedAt: now }).where(and3(
-    eq11(taskWorkHistory.sessionId, sessionId),
+  db.update(taskWorkHistory).set({ clearedAt: now }).where(and4(
+    eq12(taskWorkHistory.sessionId, sessionId),
     isNull3(taskWorkHistory.clearedAt)
   )).run();
-  db.update(sessions).set({ currentTask: null, taskStartedAt: null }).where(eq11(sessions.id, sessionId)).run();
+  db.update(sessions).set({ currentTask: null, taskStartedAt: null }).where(eq12(sessions.id, sessionId)).run();
 }
 async function workHistory(sessionId, limit = 50, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(taskWorkHistory).where(eq11(taskWorkHistory.sessionId, sessionId)).orderBy(desc(taskWorkHistory.setAt)).limit(limit).all();
+  const rows = await db.select().from(taskWorkHistory).where(eq12(taskWorkHistory.sessionId, sessionId)).orderBy(desc3(taskWorkHistory.setAt)).limit(limit).all();
   return rows.map((r) => ({
     taskId: r.taskId,
     setAt: r.setAt,
@@ -11705,18 +11755,18 @@ async function gcSessions(maxAgeDays = 30, cwd) {
   const db = await getDb(cwd);
   const threshold = /* @__PURE__ */ new Date();
   threshold.setDate(threshold.getDate() - maxAgeDays);
-  const before = await db.select({ id: sessions.id }).from(sessions).where(and3(
-    eq11(sessions.status, "ended")
+  const before = await db.select({ id: sessions.id }).from(sessions).where(and4(
+    eq12(sessions.status, "ended")
   )).all();
   const toUpdate = before;
   if (toUpdate.length > 0) {
-    db.update(sessions).set({ status: "orphaned" }).where(eq11(sessions.status, "ended")).run();
+    db.update(sessions).set({ status: "orphaned" }).where(eq12(sessions.status, "ended")).run();
   }
   return toUpdate.length;
 }
 async function getActiveSession(cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(sessions).where(eq11(sessions.status, "active")).orderBy(desc(sessions.startedAt)).limit(1).all();
+  const rows = await db.select().from(sessions).where(eq12(sessions.status, "active")).orderBy(desc3(sessions.startedAt)).limit(1).all();
   if (rows.length === 0) return null;
   return rowToSession(rows[0]);
 }
@@ -11852,8 +11902,8 @@ __export(migration_sqlite_exports, {
 import { existsSync as existsSync63, readFileSync as readFileSync46 } from "node:fs";
 import { join as join67, dirname as dirname17 } from "node:path";
 import { mkdirSync as mkdirSync19 } from "node:fs";
-import { drizzle as drizzle2 } from "drizzle-orm/sqlite-proxy";
-import { migrate as migrate2 } from "drizzle-orm/sqlite-proxy/migrator";
+import { drizzle as drizzle3 } from "drizzle-orm/sqlite-proxy";
+import { migrate as migrate3 } from "drizzle-orm/sqlite-proxy/migrator";
 function topoSortTasks(tasks2) {
   const taskMap = new Map(tasks2.map((t) => [t.id, t]));
   const sorted = [];
@@ -11935,10 +11985,10 @@ async function migrateJsonToSqliteAtomic(cwd, tempDbPath, logger) {
     const nativeDb = openNativeDatabase(tempDbPath, { enableWal: true });
     const drizzleCallback = createDrizzleCallback(nativeDb);
     const batchCallback = createBatchCallback(nativeDb);
-    const db = drizzle2(drizzleCallback, batchCallback, { schema: schema_exports });
+    const db = drizzle3(drizzleCallback, batchCallback, { schema: schema_exports });
     logger?.info("import", "create-tables", "Running drizzle migrations to create tables");
     const migrationsFolder = resolveMigrationsFolder();
-    await migrate2(db, async (queries) => {
+    await migrate3(db, async (queries) => {
       nativeDb.prepare("BEGIN").run();
       try {
         for (const query of queries) {
@@ -12188,10 +12238,10 @@ async function migrateJsonToSqlite(cwd, options) {
   const jsonCounts = countJsonRecords(cleoDir);
   result.jsonCounts = jsonCounts;
   if (dbExists(cwd)) {
-    const { ne: ne3, eq: eq12, count: count2 } = await import("drizzle-orm");
+    const { ne: ne3, eq: eq13, count: count2 } = await import("drizzle-orm");
     const db2 = await getDb(cwd);
     const tasksResult = await db2.select({ count: count2() }).from(tasks).where(ne3(tasks.status, "archived")).get();
-    const archivedResult = await db2.select({ count: count2() }).from(tasks).where(eq12(tasks.status, "archived")).get();
+    const archivedResult = await db2.select({ count: count2() }).from(tasks).where(eq13(tasks.status, "archived")).get();
     const sessionsResult = await db2.select({ count: count2() }).from(sessions).get();
     const existingCounts = {
       tasks: tasksResult?.count ?? 0,
@@ -12391,10 +12441,10 @@ async function migrateJsonToSqlite(cwd, options) {
 async function exportToJson(cwd) {
   const { listTasks: listTasks3 } = await Promise.resolve().then(() => (init_task_store(), task_store_exports));
   const { listSessions: listSessions2 } = await Promise.resolve().then(() => (init_session_store(), session_store_exports));
-  const { eq: eq12 } = await import("drizzle-orm");
+  const { eq: eq13 } = await import("drizzle-orm");
   const tasks2 = await listTasks3(void 0, cwd);
   const db = await getDb(cwd);
-  const archivedRows = await db.select().from(tasks).where(eq12(tasks.status, "archived")).all();
+  const archivedRows = await db.select().from(tasks).where(eq13(tasks.status, "archived")).all();
   const archived = archivedRows.map((row) => ({
     id: row.id,
     title: row.title,
@@ -14151,12 +14201,12 @@ function compose(middlewares) {
     return async (_req, next) => next();
   }
   return async (request, next) => {
-    let index2 = -1;
+    let index3 = -1;
     async function dispatch(i) {
-      if (i <= index2) {
+      if (i <= index3) {
         throw new Error("next() called multiple times in middleware");
       }
-      index2 = i;
+      index3 = i;
       let fn = middlewares[i];
       if (i === middlewares.length) {
         fn = async (_req, nxt) => nxt();
@@ -15594,6 +15644,7 @@ async function sessionStatus(projectRoot) {
     return engineError("E_NOT_INITIALIZED", "Task database not initialized");
   }
 }
+var SESSION_LIST_DEFAULT_LIMIT = 10;
 async function sessionList(projectRoot, params) {
   try {
     const accessor = await getAccessor(projectRoot);
@@ -15603,9 +15654,25 @@ async function sessionList(projectRoot, params) {
     } else if (params?.active === false) {
       result = result.filter((s) => s.status !== "active");
     }
-    if (params?.limit && params.limit > 0) {
-      result = result.slice(0, params.limit);
-    }
+    const total = result.length;
+    const limit = params?.limit && params.limit > 0 ? params.limit : SESSION_LIST_DEFAULT_LIMIT;
+    const truncated = total > limit;
+    result = result.slice(0, limit);
+    return {
+      success: true,
+      data: {
+        sessions: result,
+        _meta: { truncated, total }
+      }
+    };
+  } catch {
+    return engineError("E_NOT_INITIALIZED", "Task database not initialized");
+  }
+}
+async function sessionFind(projectRoot, params) {
+  try {
+    const accessor = await getAccessor(projectRoot);
+    const result = await findSessions(accessor, params);
     return { success: true, data: result };
   } catch {
     return engineError("E_NOT_INITIALIZED", "Task database not initialized");
@@ -15765,6 +15832,7 @@ async function sessionStart(projectRoot, params) {
     if (params.grade) {
       process.env.CLEO_SESSION_GRADE = "true";
       process.env.CLEO_SESSION_ID = sessionId;
+      process.env.CLEO_SESSION_GRADE_ID = sessionId;
     }
     let briefing = null;
     let previousDebrief = null;
@@ -15807,10 +15875,6 @@ async function sessionEnd(projectRoot, notes) {
     const taskData = await accessor.loadTaskFile();
     const sessionId = taskData._meta?.activeSession || "default";
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    if (process.env.CLEO_SESSION_GRADE === "true") {
-      delete process.env.CLEO_SESSION_GRADE;
-      delete process.env.CLEO_SESSION_ID;
-    }
     if (taskData.focus) {
       taskData.focus.currentTask = null;
       if (notes) {
@@ -15972,11 +16036,14 @@ async function sessionHandoff(projectRoot, scope) {
     const result = await getLastHandoff(projectRoot, scope);
     return { success: true, data: result };
   } catch (err) {
-    const message = err.message;
-    return engineError(
-      message.includes("not found") ? "E_NOT_FOUND" : "E_NOT_INITIALIZED",
-      message
-    );
+    if (err instanceof CleoError) {
+      const stringCode = `E_${getExitCodeName(err.code)}`;
+      return engineError(stringCode, err.message, {
+        ...err.fix && { fix: err.fix }
+      });
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return engineError("E_GENERAL", message);
   }
 }
 async function sessionComputeHandoff(projectRoot, sessionId, options) {
@@ -16919,32 +16986,32 @@ async function queryAuditLogSqlite(projectRoot, filters) {
     if (!existsSync68(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));
-    const { sql: sql4 } = await import("drizzle-orm");
+    const { sql: sql5 } = await import("drizzle-orm");
     const db = await getDb2(projectRoot);
     try {
       const conditions = [];
       if (filters?.operation) {
-        conditions.push(sql4`(${auditLog2.action} = ${filters.operation} OR ${auditLog2.operation} = ${filters.operation})`);
+        conditions.push(sql5`(${auditLog2.action} = ${filters.operation} OR ${auditLog2.operation} = ${filters.operation})`);
       }
       if (filters?.taskId) {
-        conditions.push(sql4`${auditLog2.taskId} = ${filters.taskId}`);
+        conditions.push(sql5`${auditLog2.taskId} = ${filters.taskId}`);
       }
       if (filters?.since) {
-        conditions.push(sql4`${auditLog2.timestamp} >= ${filters.since}`);
+        conditions.push(sql5`${auditLog2.timestamp} >= ${filters.since}`);
       }
       if (filters?.until) {
-        conditions.push(sql4`${auditLog2.timestamp} <= ${filters.until}`);
+        conditions.push(sql5`${auditLog2.timestamp} <= ${filters.until}`);
       }
-      const whereClause = conditions.length > 0 ? sql4.join(conditions, sql4` AND `) : sql4`1=1`;
+      const whereClause = conditions.length > 0 ? sql5.join(conditions, sql5` AND `) : sql5`1=1`;
       const countResult = await db.all(
-        sql4`SELECT count(*) as cnt FROM ${auditLog2} WHERE ${whereClause}`
+        sql5`SELECT count(*) as cnt FROM ${auditLog2} WHERE ${whereClause}`
       );
       const total = countResult[0]?.cnt ?? 0;
       if (total === 0) return null;
       const offset = filters?.offset ?? 0;
       const limit = filters?.limit ?? 20;
       const rows = await db.all(
-        sql4`SELECT * FROM ${auditLog2}
+        sql5`SELECT * FROM ${auditLog2}
             WHERE ${whereClause}
             ORDER BY ${auditLog2.timestamp} DESC
             LIMIT ${limit} OFFSET ${offset}`
@@ -19215,7 +19282,7 @@ async function validateSqliteRows(type, projectRoot) {
   const { getDb: getDb2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
   const schemaTable = await Promise.resolve().then(() => (init_schema(), schema_exports));
   const zodSchemas = await Promise.resolve().then(() => (init_validation_schemas(), validation_schemas_exports));
-  const { ne: ne3, eq: eq12 } = await import("drizzle-orm");
+  const { ne: ne3, eq: eq13 } = await import("drizzle-orm");
   const db = await getDb2(projectRoot);
   const errors = [];
   switch (type) {
@@ -19227,7 +19294,7 @@ async function validateSqliteRows(type, projectRoot) {
       break;
     }
     case "archive": {
-      const rows = await db.select().from(schemaTable.tasks).where(eq12(schemaTable.tasks.status, "archived"));
+      const rows = await db.select().from(schemaTable.tasks).where(eq13(schemaTable.tasks.status, "archived"));
       for (const row of rows) {
         errors.push(...collectZodErrors(zodSchemas.selectTaskSchema.safeParse(row), row.id));
       }
@@ -20033,9 +20100,9 @@ function autoDispatch(task) {
     }
   }
   if (task.type === "epic") return "decomposition";
-  const text2 = `${task.title} ${task.description ?? ""}`.toLowerCase();
+  const text3 = `${task.title} ${task.description ?? ""}`.toLowerCase();
   for (const [protocol, config] of Object.entries(DISPATCH_MAP)) {
-    if (config.keywords.some((kw) => text2.includes(kw))) {
+    if (config.keywords.some((kw) => text3.includes(kw))) {
       return protocol;
     }
   }
@@ -21041,37 +21108,110 @@ init_errors();
 init_exit_codes();
 init_paths();
 init_add();
-function filterManifestEntries(entries, filter) {
-  let filtered = entries;
-  if (filter.taskId) {
-    const taskId = filter.taskId;
-    filtered = filtered.filter(
-      (e) => e.id.startsWith(taskId) || e.linked_tasks?.includes(taskId)
-    );
-  }
-  if (filter.status) {
-    filtered = filtered.filter((e) => e.status === filter.status);
-  }
-  if (filter.agent_type) {
-    filtered = filtered.filter((e) => e.agent_type === filter.agent_type);
-  }
-  if (filter.topic) {
-    filtered = filtered.filter((e) => e.topics.includes(filter.topic));
-  }
-  if (filter.actionable !== void 0) {
-    filtered = filtered.filter((e) => e.actionable === filter.actionable);
-  }
-  if (filter.dateAfter) {
-    filtered = filtered.filter((e) => e.date > filter.dateAfter);
-  }
-  if (filter.dateBefore) {
-    filtered = filtered.filter((e) => e.date < filter.dateBefore);
-  }
-  if (filter.limit && filter.limit > 0) {
-    filtered = filtered.slice(0, filter.limit);
-  }
-  return filtered;
-}
+
+// 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
+import { desc as desc2 } from "drizzle-orm";
 
 // src/core/memory/patterns.ts
 import { randomBytes as randomBytes6 } from "node:crypto";
@@ -21324,6 +21464,39 @@ function learningStats(projectRoot) {
   };
 }
 
+// src/core/memory/index.ts
+function filterManifestEntries(entries, filter) {
+  let filtered = entries;
+  if (filter.taskId) {
+    const taskId = filter.taskId;
+    filtered = filtered.filter(
+      (e) => e.id.startsWith(taskId) || e.linked_tasks?.includes(taskId)
+    );
+  }
+  if (filter.status) {
+    filtered = filtered.filter((e) => e.status === filter.status);
+  }
+  if (filter.agent_type) {
+    filtered = filtered.filter((e) => e.agent_type === filter.agent_type);
+  }
+  if (filter.topic) {
+    filtered = filtered.filter((e) => e.topics.includes(filter.topic));
+  }
+  if (filter.actionable !== void 0) {
+    filtered = filtered.filter((e) => e.actionable === filter.actionable);
+  }
+  if (filter.dateAfter) {
+    filtered = filtered.filter((e) => e.date > filter.dateAfter);
+  }
+  if (filter.dateBefore) {
+    filtered = filtered.filter((e) => e.date < filter.dateBefore);
+  }
+  if (filter.limit && filter.limit > 0) {
+    filtered = filtered.slice(0, filter.limit);
+  }
+  return filtered;
+}
+
 // src/core/memory/engine-compat.ts
 function getManifestPath2(projectRoot) {
   return getManifestPath(projectRoot);
@@ -21737,13 +21910,13 @@ async function readReleases(cwd) {
   const data = await readJson(getReleasesPath(cwd));
   return data ?? { releases: [] };
 }
-async function writeReleases(index2, cwd) {
+async function writeReleases(index3, cwd) {
   const releasesPath = getReleasesPath(cwd);
   const dir = dirname13(releasesPath);
   if (!existsSync40(dir)) {
     mkdirSync16(dir, { recursive: true });
   }
-  await saveJson(releasesPath, index2);
+  await saveJson(releasesPath, index3);
 }
 function isValidVersion(version) {
   return /^v?\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/.test(version);
@@ -21759,8 +21932,8 @@ async function prepareRelease(version, tasks2, notes, loadTasksFn, cwd) {
     throw new Error(`Invalid version format: ${version} (expected X.Y.Z or YYYY.M.patch)`);
   }
   const normalizedVersion = normalizeVersion(version);
-  const index2 = await readReleases(cwd);
-  const existing = index2.releases.find((r) => r.version === normalizedVersion);
+  const index3 = await readReleases(cwd);
+  const existing = index3.releases.find((r) => r.version === normalizedVersion);
   if (existing) {
     throw new Error(`Release ${normalizedVersion} already exists (status: ${existing.status})`);
   }
@@ -21781,10 +21954,10 @@ async function prepareRelease(version, tasks2, notes, loadTasksFn, cwd) {
     preparedAt: (/* @__PURE__ */ new Date()).toISOString(),
     tasks: releaseTasks,
     notes,
-    previousVersion: index2.latest
+    previousVersion: index3.latest
   };
-  index2.releases.push(release2);
-  await writeReleases(index2, cwd);
+  index3.releases.push(release2);
+  await writeReleases(index3, cwd);
   return {
     version: normalizedVersion,
     status: "prepared",
@@ -21797,8 +21970,8 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
     throw new Error("version is required");
   }
   const normalizedVersion = normalizeVersion(version);
-  const index2 = await readReleases(cwd);
-  const release2 = index2.releases.find((r) => r.version === normalizedVersion);
+  const index3 = await readReleases(cwd);
+  const release2 = index3.releases.find((r) => r.version === normalizedVersion);
   if (!release2) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
@@ -21869,7 +22042,7 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
   }
   const changelog = sections.join("\n");
   release2.changelog = changelog;
-  await writeReleases(index2, cwd);
+  await writeReleases(index3, cwd);
   return {
     version: normalizedVersion,
     changelog,
@@ -21889,8 +22062,8 @@ async function showManifestRelease(version, cwd) {
     throw new Error("version is required");
   }
   const normalizedVersion = normalizeVersion(version);
-  const index2 = await readReleases(cwd);
-  const release2 = index2.releases.find((r) => r.version === normalizedVersion);
+  const index3 = await readReleases(cwd);
+  const release2 = index3.releases.find((r) => r.version === normalizedVersion);
   if (!release2) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
@@ -21901,8 +22074,8 @@ async function commitRelease(version, cwd) {
     throw new Error("version is required");
   }
   const normalizedVersion = normalizeVersion(version);
-  const index2 = await readReleases(cwd);
-  const release2 = index2.releases.find((r) => r.version === normalizedVersion);
+  const index3 = await readReleases(cwd);
+  const release2 = index3.releases.find((r) => r.version === normalizedVersion);
   if (!release2) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
@@ -21911,7 +22084,7 @@ async function commitRelease(version, cwd) {
   }
   release2.status = "committed";
   release2.committedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeReleases(index2, cwd);
+  await writeReleases(index3, cwd);
   return {
     version: normalizedVersion,
     status: "committed",
@@ -21923,15 +22096,15 @@ async function tagRelease(version, cwd) {
     throw new Error("version is required");
   }
   const normalizedVersion = normalizeVersion(version);
-  const index2 = await readReleases(cwd);
-  const release2 = index2.releases.find((r) => r.version === normalizedVersion);
+  const index3 = await readReleases(cwd);
+  const release2 = index3.releases.find((r) => r.version === normalizedVersion);
   if (!release2) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
   release2.status = "tagged";
   release2.taggedAt = (/* @__PURE__ */ new Date()).toISOString();
-  index2.latest = normalizedVersion;
-  await writeReleases(index2, cwd);
+  index3.latest = normalizedVersion;
+  await writeReleases(index3, cwd);
   return {
     version: normalizedVersion,
     status: "tagged",
@@ -21943,8 +22116,8 @@ async function runReleaseGates(version, loadTasksFn, cwd) {
     throw new Error("version is required");
   }
   const normalizedVersion = normalizeVersion(version);
-  const index2 = await readReleases(cwd);
-  const release2 = index2.releases.find((r) => r.version === normalizedVersion);
+  const index3 = await readReleases(cwd);
+  const release2 = index3.releases.find((r) => r.version === normalizedVersion);
   if (!release2) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
@@ -21988,18 +22161,18 @@ async function rollbackRelease(version, reason, cwd) {
     throw new Error("version is required");
   }
   const normalizedVersion = normalizeVersion(version);
-  const index2 = await readReleases(cwd);
-  const release2 = index2.releases.find((r) => r.version === normalizedVersion);
+  const index3 = await readReleases(cwd);
+  const release2 = index3.releases.find((r) => r.version === normalizedVersion);
   if (!release2) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
   const previousStatus = release2.status;
   release2.status = "rolled_back";
-  if (index2.latest === normalizedVersion) {
-    const otherReleases = index2.releases.filter((r) => r.version !== normalizedVersion && r.status !== "rolled_back").sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-    index2.latest = otherReleases[0]?.version;
+  if (index3.latest === normalizedVersion) {
+    const otherReleases = index3.releases.filter((r) => r.version !== normalizedVersion && r.status !== "rolled_back").sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    index3.latest = otherReleases[0]?.version;
   }
-  await writeReleases(index2, cwd);
+  await writeReleases(index3, cwd);
   return {
     version: normalizedVersion,
     previousStatus,
@@ -22069,12 +22242,12 @@ async function pushRelease(version, remote, cwd, opts) {
 }
 async function markReleasePushed(version, pushedAt, cwd) {
   const normalizedVersion = normalizeVersion(version);
-  const index2 = await readReleases(cwd);
-  const release2 = index2.releases.find((r) => r.version === normalizedVersion);
+  const index3 = await readReleases(cwd);
+  const release2 = index3.releases.find((r) => r.version === normalizedVersion);
   if (release2) {
     release2.status = "pushed";
     release2.pushedAt = pushedAt;
-    await writeReleases(index2, cwd);
+    await writeReleases(index3, cwd);
   }
 }
 
@@ -22841,6 +23014,10 @@ var SessionHandler = class {
           const result = await sessionChainShow(this.projectRoot, chainSessionId);
           return this.wrapEngineResult(result, "query", "session", operation, startTime);
         }
+        case "find": {
+          const result = await sessionFind(this.projectRoot, params);
+          return this.wrapEngineResult(result, "query", "session", operation, startTime);
+        }
         default:
           return this.unsupported("query", "session", operation, startTime);
       }
@@ -22961,7 +23138,7 @@ var SessionHandler = class {
   // -----------------------------------------------------------------------
   getSupportedOperations() {
     return {
-      query: ["status", "list", "show", "history", "decision.log", "context.drift", "handoff.show", "briefing.show", "debrief.show", "chain.show"],
+      query: ["status", "list", "show", "find", "history", "decision.log", "context.drift", "handoff.show", "briefing.show", "debrief.show", "chain.show"],
       mutate: ["start", "end", "resume", "suspend", "gc", "record.decision", "record.assumption"]
     };
   }
@@ -28077,19 +28254,19 @@ function registerCommandsCommand(program2) {
           `Invalid relevance: ${relevance}. Valid: ${VALID_RELEVANCE.join(", ")}`
         );
       }
-      const index2 = await locateCommandsIndex();
+      const index3 = await locateCommandsIndex();
       console.error(
         "[DEPRECATED] cleo commands reads from COMMANDS-INDEX.json which is deprecated.\nThe canonical operations reference is: docs/specs/CLEO-OPERATIONS-REFERENCE.md\nUse cleo_query/cleo_mutate MCP tools for programmatic access.\n"
       );
       if (opts["workflows"]) {
-        cliOutput({ workflows: index2.agentWorkflows ?? {} }, { command: "commands" });
+        cliOutput({ workflows: index3.agentWorkflows ?? {} }, { command: "commands" });
         return;
       }
       if (opts["lookup"]) {
-        cliOutput({ quickLookup: index2.quickLookup ?? {} }, { command: "commands" });
+        cliOutput({ quickLookup: index3.quickLookup ?? {} }, { command: "commands" });
         return;
       }
-      let commands = index2.commands;
+      let commands = index3.commands;
       if (category) {
         commands = commands.filter((c) => c.category === category);
       }
@@ -28143,9 +28320,9 @@ async function getScriptNames(projectRoot) {
 }
 async function getIndexedCommands(projectRoot) {
   const indexPath = join54(projectRoot, "docs", "commands", "COMMANDS-INDEX.json");
-  const index2 = await readJson(indexPath);
-  if (!index2) return [];
-  return index2.commands.map((c) => c.name).sort();
+  const index3 = await readJson(indexPath);
+  if (!index3) return [];
+  return index3.commands.map((c) => c.name).sort();
 }
 async function detectDrift(projectRoot) {
   const scripts = await getScriptNames(projectRoot);
@@ -29994,7 +30171,7 @@ async function discoverRelatedTasks(taskQuery, method, limit) {
   candidates.sort((a, b) => b.score - a.score);
   return candidates.slice(0, limit);
 }
-function extractKeywords(text2) {
+function extractKeywords(text3) {
   const stopWords = /* @__PURE__ */ new Set([
     "the",
     "a",
@@ -30077,7 +30254,7 @@ function extractKeywords(text2) {
     "it",
     "its"
   ]);
-  return text2.replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+  return text3.replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
 }
 async function searchAcrossProjects(pattern, projectFilter, limit = 20) {
   if (/^\*:.+$/.test(pattern)) {