@cleocode/cleo 2026.3.2-beta.1 → 2026.3.4

package/dist/mcp/index.js

@@ -895,8 +895,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": {
@@ -6963,9 +6963,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;
   };
 }
@@ -6973,16 +6977,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: and3, eq: eq11, gte, or } = await import("drizzle-orm");
+    const { and: and4, eq: eq12, gte: gte2, or } = await import("drizzle-orm");
     const db = await getDb2(process.cwd());
     const conditions = [];
-    if (options?.sessionId) conditions.push(eq11(auditLog2.sessionId, options.sessionId));
-    if (options?.domain) conditions.push(eq11(auditLog2.domain, options.domain));
-    if (options?.operation) conditions.push(or(eq11(auditLog2.operation, options.operation), eq11(auditLog2.action, options.operation)));
-    if (options?.taskId) conditions.push(eq11(auditLog2.taskId, options.taskId));
-    if (options?.since) conditions.push(gte(auditLog2.timestamp, options.since));
+    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(gte2(auditLog2.timestamp, options.since));
     const limit = options?.limit ?? 1e3;
-    const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and3(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
+    const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and4(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
     return rows.map((row) => ({
       timestamp: row.timestamp,
       sessionId: row.sessionId,
@@ -7114,8 +7118,8 @@ async function gradeSession(sessionId, cwd) {
   );
   let hygieneScore = 20;
   for (const addCall of addCalls) {
-    const desc = addCall.params?.description;
-    if (!desc || desc.trim().length === 0) {
+    const desc3 = addCall.params?.description;
+    if (!desc3 || desc3.trim().length === 0) {
       hygieneScore -= 5;
       result.flags.push(
         `tasks.add without description (taskId: ${addCall.metadata?.taskId ?? "unknown"})`
@@ -7276,6 +7280,8 @@ var QUERY_OPERATIONS = {
     // List all sessions
     "show",
     // Session details
+    "find",
+    // Lightweight session discovery (T5119)
     "history",
     // Session history
     "decision.log",
@@ -10053,12 +10059,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();
@@ -12255,9 +12261,9 @@ init_json();
 init_errors();
 init_exit_codes();
 init_paths();
-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+/);
@@ -14054,6 +14060,46 @@ function computePipelineStage(current) {
   return void 0;
 }
 
+// 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
+  };
+}
+
 // src/core/sessions/session-id.ts
 import { randomBytes as randomBytes5 } from "node:crypto";
 function generateSessionId() {
@@ -14183,6 +14229,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);
@@ -14192,9 +14239,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");
@@ -14354,6 +14417,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;
@@ -14396,10 +14460,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) {
@@ -14561,11 +14621,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) {
@@ -15508,32 +15571,32 @@ async function queryAuditLogSqlite(projectRoot, filters) {
     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));
-    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}`
@@ -17806,7 +17869,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: eq11 } = await import("drizzle-orm");
+  const { ne: ne3, eq: eq12 } = await import("drizzle-orm");
   const db = await getDb2(projectRoot);
   const errors = [];
   switch (type) {
@@ -17818,7 +17881,7 @@ async function validateSqliteRows(type, projectRoot) {
       break;
     }
     case "archive": {
-      const rows = await db.select().from(schemaTable.tasks).where(eq11(schemaTable.tasks.status, "archived"));
+      const rows = await db.select().from(schemaTable.tasks).where(eq12(schemaTable.tasks.status, "archived"));
       for (const row of rows) {
         errors.push(...collectZodErrors(zodSchemas.selectTaskSchema.safeParse(row), row.id));
       }
@@ -18624,9 +18687,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;
     }
   }
@@ -19631,37 +19694,110 @@ init_atomic();
 init_errors();
 init_exit_codes();
 init_paths();
-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 randomBytes7 } from "node:crypto";
@@ -19914,6 +20050,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);
@@ -20327,13 +20496,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 = dirname12(releasesPath);
   if (!existsSync41(dir)) {
     mkdirSync15(dir, { recursive: true });
   }
-  await saveJson(releasesPath, index2);
+  await saveJson(releasesPath, index3);
 }
 function isValidVersion(version) {
   return /^v?\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/.test(version);
@@ -20349,8 +20518,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})`);
   }
@@ -20371,10 +20540,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",
@@ -20387,8 +20556,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`);
   }
@@ -20459,7 +20628,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,
@@ -20479,8 +20648,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`);
   }
@@ -20491,8 +20660,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`);
   }
@@ -20501,7 +20670,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",
@@ -20513,15 +20682,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",
@@ -20533,8 +20702,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`);
   }
@@ -20578,18 +20747,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,
@@ -20659,12 +20828,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);
   }
 }
 
@@ -21431,6 +21600,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);
       }
@@ -21551,7 +21724,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"]
     };
   }
@@ -25626,8 +25799,8 @@ var DECOMPOSITION_RULES = [
     validate: (entry) => {
       const title = entry.title;
       const description = entry.description;
-      const text2 = `${title} ${description}`;
-      return !/\b\d+\s*(hour|day|week|minute|hr|min)s?\b/i.test(text2);
+      const text3 = `${title} ${description}`;
+      return !/\b\d+\s*(hour|day|week|minute|hr|min)s?\b/i.test(text3);
     }
   },
   {
@@ -25636,9 +25809,9 @@ var DECOMPOSITION_RULES = [
     message: "Must include acceptance criteria in task description",
     fix: "Add clear acceptance criteria: what must be true when the task is done",
     validate: (entry) => {
-      const desc = entry.description;
-      if (!desc) return false;
-      return /\b(must|should|acceptance|criteria|verify|test|passes when|done when|complete when)\b/i.test(desc);
+      const desc3 = entry.description;
+      if (!desc3) return false;
+      return /\b(must|should|acceptance|criteria|verify|test|passes when|done when|complete when)\b/i.test(desc3);
     }
   },
   {