@cleocode/core 2026.4.48 → 2026.4.49

package/dist/index.js

@@ -730,15 +730,15 @@ function getLogDir() {
   return currentLogDir;
 }
 function closeLogger() {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     if (rootLogger) {
       rootLogger.flush(() => {
         rootLogger = null;
         currentLogDir = null;
-        resolve11();
+        resolve12();
       });
     } else {
-      resolve11();
+      resolve12();
     }
   });
 }
@@ -1546,10 +1546,10 @@ var init_subquery = __esm({
     init_entity();
     Subquery = class {
       static [entityKind] = "Subquery";
-      constructor(sql12, fields, alias, isWith = false, usedTables = []) {
+      constructor(sql14, fields, alias, isWith = false, usedTables = []) {
         this._ = {
           brand: "Subquery",
-          sql: sql12,
+          sql: sql14,
           selectedFields: fields,
           alias,
           isWith,
@@ -1900,7 +1900,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       _sql.raw = raw;
-      function join107(chunks, separator) {
+      function join109(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) result.push(separator);
@@ -1908,7 +1908,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      _sql.join = join107;
+      _sql.join = join109;
       function identifier(value) {
         return new Name(value);
       }
@@ -1929,8 +1929,8 @@ var init_sql = __esm({
         isSelectionField = false;
         /** @internal */
         origin;
-        constructor(sql12, fieldAlias) {
-          this.sql = sql12;
+        constructor(sql14, fieldAlias) {
+          this.sql = sql14;
           this.fieldAlias = fieldAlias;
         }
         getSQL() {
@@ -2634,17 +2634,17 @@ var init_custom = __esm({
       mapFromJsonValue(value) {
         return typeof this.mapJson === "function" ? this.mapJson(value) : this.mapFromDriverValue(value);
       }
-      jsonSelectIdentifier(identifier, sql12) {
-        if (typeof this.forJsonSelect === "function") return this.forJsonSelect(identifier, sql12);
+      jsonSelectIdentifier(identifier, sql14) {
+        if (typeof this.forJsonSelect === "function") return this.forJsonSelect(identifier, sql14);
         const rawType = this.getSQLType().toLowerCase();
         const parenPos = rawType.indexOf("(");
         switch (parenPos + 1 ? rawType.slice(0, parenPos) : rawType) {
           case "numeric":
           case "decimal":
           case "bigint":
-            return sql12`cast(${identifier} as text)`;
+            return sql14`cast(${identifier} as text)`;
           case "blob":
-            return sql12`hex(${identifier})`;
+            return sql14`hex(${identifier})`;
           default:
             return identifier;
         }
@@ -3812,8 +3812,8 @@ var init_custom2 = __esm({
       mapFromJsonValue(value) {
         return typeof this.mapJson === "function" ? this.mapJson(value) : this.mapFromDriverValue(value);
       }
-      jsonSelectIdentifier(identifier, sql12, arrayDimensions) {
-        if (typeof this.forJsonSelect === "function") return this.forJsonSelect(identifier, sql12, arrayDimensions);
+      jsonSelectIdentifier(identifier, sql14, arrayDimensions) {
+        if (typeof this.forJsonSelect === "function") return this.forJsonSelect(identifier, sql14, arrayDimensions);
         const rawType = this.getSQLType().toLowerCase();
         const parenPos = rawType.indexOf("(");
         switch (parenPos + 1 ? rawType.slice(0, parenPos) : rawType) {
@@ -3823,7 +3823,7 @@ var init_custom2 = __esm({
           case "numeric":
           case "bigint": {
             const arrVal = "[]".repeat(arrayDimensions ?? 0);
-            return sql12`${identifier}::text${sql12.raw(arrVal).if(arrayDimensions)}`;
+            return sql14`${identifier}::text${sql14.raw(arrVal).if(arrayDimensions)}`;
           }
           default:
             return identifier;
@@ -6682,7 +6682,7 @@ var init_select2 = __esm({
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table)) this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join107) => join107.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins?.some((join109) => join109.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
           if (!this.isPartialSelect) {
             if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") this.config.fields = { [baseTableName]: this.config.fields };
             if (typeof tableName === "string" && !is(table, SQL)) {
@@ -7704,8 +7704,8 @@ var init_dialect = __esm({
         const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
         return sql`${withSql}insert into ${table} ${insertOrder} ${valuesSql}${onConflict?.length ? sql.join(onConflict) : void 0}${returningSql}`;
       }
-      sqlToQuery(sql12, invokeSource) {
-        return sql12.toQuery({
+      sqlToQuery(sql14, invokeSource) {
+        return sql14.toQuery({
           casing: this.casing,
           escapeName: this.escapeName,
           escapeParam: this.escapeParam,
@@ -7967,7 +7967,7 @@ var init_dialect = __esm({
           if (!joins2) return;
           const withEntries = Object.entries(joins2).filter(([_, v]) => v);
           if (!withEntries.length) return;
-          return sql.join(withEntries.map(([k, join107]) => {
+          return sql.join(withEntries.map(([k, join109]) => {
             const relation = tableConfig.relations[k];
             const isSingle2 = is(relation, One3);
             const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -7978,7 +7978,7 @@ var init_dialect = __esm({
               table: targetTable,
               mode: isSingle2 ? "first" : "many",
               schema,
-              queryConfig: join107,
+              queryConfig: join109,
               tableConfig: schema[relation.targetTableName],
               relationWhere: filter,
               isNested: true,
@@ -7992,7 +7992,7 @@ var init_dialect = __esm({
               key: k,
               selection: innerQuery.selection,
               isArray: !isSingle2,
-              isOptional: (relation.optional ?? false) || join107 !== true && !!join107.where
+              isOptional: (relation.optional ?? false) || join109 !== true && !!join109.where
             });
             const jsonColumns = sql.join(innerQuery.selection.map((s) => {
               return sql`${sql.raw(this.escapeString(s.key))}, ${s.selection ? sql`${jsonb2}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
@@ -8391,7 +8391,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return ((table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join107) => join107.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins.some((join109) => join109.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
           if (typeof on === "function") {
             const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : void 0 : void 0;
             on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
@@ -8802,8 +8802,8 @@ var init_db = __esm({
 });
 
 // node_modules/.pnpm/drizzle-orm@1.0.0-beta.19-d95b7a4_@sinclair+typebox@0.34.49_@types+mssql@9.1.9_@azure+c_7d603f9dc53f6bedf2f8e8db5954b691/node_modules/drizzle-orm/cache/core/cache.js
-async function hashQuery(sql12, params) {
-  const dataToHash = `${sql12}-${JSON.stringify(params, (_, v) => typeof v === "bigint" ? `${v}n` : v)}`;
+async function hashQuery(sql14, params) {
+  const dataToHash = `${sql14}-${JSON.stringify(params, (_, v) => typeof v === "bigint" ? `${v}n` : v)}`;
   const data = new TextEncoder().encode(dataToHash);
   const hashBuffer = await crypto.subtle.digest("SHA-256", data);
   return [...new Uint8Array(hashBuffer)].map((b) => b.toString(16).padStart(2, "0")).join("");
@@ -8982,8 +8982,8 @@ var init_session3 = __esm({
       values(query) {
         return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), void 0, "run", false).values();
       }
-      async count(sql12) {
-        return (await this.values(sql12))[0][0];
+      async count(sql14) {
+        return (await this.values(sql14))[0][0];
       }
       /** @internal */
       extractRawValuesValueFromBatchResult(_result) {
@@ -11670,12 +11670,12 @@ function detachAgentFromProject(db, agentId) {
 }
 function listProjectAgentRefs(db, opts) {
   const enabledOnly = opts?.enabledOnly ?? true;
-  const sql12 = enabledOnly ? `SELECT agent_id, attached_at, role, capabilities_override, last_used_at, enabled
+  const sql14 = enabledOnly ? `SELECT agent_id, attached_at, role, capabilities_override, last_used_at, enabled
        FROM project_agent_refs WHERE enabled = 1
        ORDER BY attached_at DESC` : `SELECT agent_id, attached_at, role, capabilities_override, last_used_at, enabled
        FROM project_agent_refs
        ORDER BY attached_at DESC`;
-  const rows = db.prepare(sql12).all();
+  const rows = db.prepare(sql14).all();
   return rows.map((r) => ({
     agentId: r.agent_id,
     attachedAt: r.attached_at,
@@ -12020,12 +12020,21 @@ var init_nexus_schema = __esm({
         permissions: text("permissions").notNull().default("read"),
         lastSync: text("last_sync").notNull().default(sql3`(datetime('now'))`),
         taskCount: integer("task_count").notNull().default(0),
-        labelsJson: text("labels_json").notNull().default("[]")
+        labelsJson: text("labels_json").notNull().default("[]"),
+        /** Absolute path to the project's brain.db file. */
+        brainDbPath: text("brain_db_path"),
+        /** Absolute path to the project's tasks.db file. */
+        tasksDbPath: text("tasks_db_path"),
+        /** ISO 8601 timestamp of the last successful code intelligence index run. */
+        lastIndexed: text("last_indexed"),
+        /** JSON object with per-project code intelligence stats (node_count, relation_count, file_count). */
+        statsJson: text("stats_json").notNull().default("{}")
       },
       (table) => [
         index("idx_project_registry_hash").on(table.projectHash),
         index("idx_project_registry_health").on(table.healthStatus),
-        index("idx_project_registry_name").on(table.name)
+        index("idx_project_registry_name").on(table.name),
+        index("idx_project_registry_last_indexed").on(table.lastIndexed)
       ]
     );
     nexusAuditLog = sqliteTable(
@@ -16529,7 +16538,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
     return result;
   }
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { and: and10, eq: eq13 } = await import("drizzle-orm");
+  const { and: and11, eq: eq13 } = await import("drizzle-orm");
   const db = await getDb3(projectRoot);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const filePath of matchingFiles) {
@@ -16564,7 +16573,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
         await db.insert(architectureDecisions).values({ ...rowBase, createdAt: now });
       }
       result.synced++;
-      await db.delete(adrTaskLinks).where(and10(eq13(adrTaskLinks.adrId, record2.id), eq13(adrTaskLinks.taskId, taskId)));
+      await db.delete(adrTaskLinks).where(and11(eq13(adrTaskLinks.adrId, record2.id), eq13(adrTaskLinks.taskId, taskId)));
       await db.insert(adrTaskLinks).values({ adrId: record2.id, taskId, linkType: "implements" });
       result.linked.push({ adrId: record2.id, taskId });
       if (fm["Related ADRs"]) {
@@ -17362,7 +17371,7 @@ async function withRetry(fn, policy) {
       if (!shouldRetry(err, attempt, effectivePolicy)) break;
       const delay = calculateDelay(attempt, effectivePolicy);
       totalDelayMs += delay;
-      await new Promise((resolve11) => setTimeout(resolve11, delay));
+      await new Promise((resolve12) => setTimeout(resolve12, delay));
     }
   }
   const error48 = lastError instanceof Error ? lastError : new Error(String(lastError));
@@ -18058,7 +18067,7 @@ function analyzeStructure(projectRoot) {
 }
 function countFiles(dir, depth = 0) {
   if (depth > 5) return 0;
-  let count2 = 0;
+  let count3 = 0;
   const entries = safeReaddir2(dir);
   for (const entry of entries) {
     if (EXCLUDED_DIRS.has(entry) || entry.startsWith(".")) continue;
@@ -18066,14 +18075,14 @@ function countFiles(dir, depth = 0) {
     try {
       const stat2 = statSync3(entryPath);
       if (stat2.isDirectory()) {
-        count2 += countFiles(entryPath, depth + 1);
+        count3 += countFiles(entryPath, depth + 1);
       } else {
-        count2++;
+        count3++;
       }
     } catch {
     }
   }
-  return count2;
+  return count3;
 }
 function safeReaddir2(dir) {
   try {
@@ -19432,8 +19441,8 @@ function checkFts5Available(nativeDb) {
   }
   return _fts5Available;
 }
-function execDDL(nativeDb, sql12) {
-  nativeDb.prepare(sql12).run();
+function execDDL(nativeDb, sql14) {
+  nativeDb.prepare(sql14).run();
 }
 function ensureFts5Tables(nativeDb) {
   if (!checkFts5Available(nativeDb)) {
@@ -20266,8 +20275,8 @@ __export(memory_bridge_exports, {
 });
 import { existsSync as existsSync27, mkdirSync as mkdirSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join30 } from "node:path";
-function typedAll2(db, sql12, ...params) {
-  return db.prepare(sql12).all(...params);
+function typedAll2(db, sql14, ...params) {
+  return db.prepare(sql14).all(...params);
 }
 async function generateMemoryBridgeContent(projectRoot, config2) {
   const cfg = { ...DEFAULT_CONFIG, ...config2 };
@@ -20589,7 +20598,7 @@ async function queryAudit(options) {
   try {
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
-    const { and: and10, eq: eq13, gte: gte3, or: or5 } = await import("drizzle-orm");
+    const { and: and11, eq: eq13, gte: gte3, or: or5 } = await import("drizzle-orm");
     const db = await getDb3(process.cwd());
     const conditions = [];
     if (options?.sessionId) conditions.push(eq13(auditLog2.sessionId, options.sessionId));
@@ -20601,7 +20610,7 @@ async function queryAudit(options) {
     if (options?.taskId) conditions.push(eq13(auditLog2.taskId, options.taskId));
     if (options?.since) conditions.push(gte3(auditLog2.timestamp, options.since));
     const limit = options?.limit ?? 1e3;
-    const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and10(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
+    const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and11(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
     return rows.map((row) => ({
       timestamp: row.timestamp,
       sessionId: row.sessionId,
@@ -20729,8 +20738,8 @@ async function gradeSession(sessionId, cwd) {
   );
   let hygieneScore = 20;
   for (const addCall of addCalls) {
-    const desc5 = addCall.params?.description;
-    if (!desc5 || desc5.trim().length === 0) {
+    const desc6 = addCall.params?.description;
+    if (!desc6 || desc6.trim().length === 0) {
       hygieneScore -= 5;
       result.flags.push(
         `tasks.add without description (taskId: ${addCall.metadata?.taskId ?? "unknown"})`
@@ -20959,9 +20968,9 @@ __export(decisions_exports, {
 async function nextDecisionId(projectRoot) {
   const { getBrainDb: getBrainDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
   const { brainDecisions: brainDecisions2 } = await Promise.resolve().then(() => (init_brain_schema(), brain_schema_exports));
-  const { desc: desc5 } = await import("drizzle-orm");
+  const { desc: desc6 } = await import("drizzle-orm");
   const db = await getBrainDb2(projectRoot);
-  const rows = await db.select({ id: brainDecisions2.id }).from(brainDecisions2).orderBy(desc5(brainDecisions2.id)).limit(1);
+  const rows = await db.select({ id: brainDecisions2.id }).from(brainDecisions2).orderBy(desc6(brainDecisions2.id)).limit(1);
   if (rows.length === 0) {
     return "D001";
   }
@@ -21387,7 +21396,7 @@ var init_values = __esm({
 var sleep;
 var init_sleep = __esm({
   "node_modules/.pnpm/@anthropic-ai+sdk@0.88.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/internal/utils/sleep.mjs"() {
-    sleep = (ms) => new Promise((resolve11) => setTimeout(resolve11, ms));
+    sleep = (ms) => new Promise((resolve12) => setTimeout(resolve12, ms));
   }
 });
 
@@ -22165,8 +22174,8 @@ var init_api_promise = __esm({
     init_parse2();
     APIPromise = class _APIPromise extends Promise {
       constructor(client, responsePromise, parseResponse = defaultParseResponse) {
-        super((resolve11) => {
-          resolve11(null);
+        super((resolve12) => {
+          resolve12(null);
         });
         this.responsePromise = responsePromise;
         this.parseResponse = parseResponse;
@@ -23602,12 +23611,12 @@ var init_BetaMessageStream = __esm({
           }
           return this._emit("error", new AnthropicError(String(error48)));
         });
-        __classPrivateFieldSet(this, _BetaMessageStream_connectedPromise, new Promise((resolve11, reject) => {
-          __classPrivateFieldSet(this, _BetaMessageStream_resolveConnectedPromise, resolve11, "f");
+        __classPrivateFieldSet(this, _BetaMessageStream_connectedPromise, new Promise((resolve12, reject) => {
+          __classPrivateFieldSet(this, _BetaMessageStream_resolveConnectedPromise, resolve12, "f");
           __classPrivateFieldSet(this, _BetaMessageStream_rejectConnectedPromise, reject, "f");
         }), "f");
-        __classPrivateFieldSet(this, _BetaMessageStream_endPromise, new Promise((resolve11, reject) => {
-          __classPrivateFieldSet(this, _BetaMessageStream_resolveEndPromise, resolve11, "f");
+        __classPrivateFieldSet(this, _BetaMessageStream_endPromise, new Promise((resolve12, reject) => {
+          __classPrivateFieldSet(this, _BetaMessageStream_resolveEndPromise, resolve12, "f");
           __classPrivateFieldSet(this, _BetaMessageStream_rejectEndPromise, reject, "f");
         }), "f");
         __classPrivateFieldGet(this, _BetaMessageStream_connectedPromise, "f").catch(() => {
@@ -23777,11 +23786,11 @@ var init_BetaMessageStream = __esm({
        *   const message = await stream.emitted('message') // rejects if the stream errors
        */
       emitted(event) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           __classPrivateFieldSet(this, _BetaMessageStream_catchingPromiseCreated, true, "f");
           if (event !== "error")
             this.once("error", reject);
-          this.once(event, resolve11);
+          this.once(event, resolve12);
         });
       }
       async done() {
@@ -24124,7 +24133,7 @@ var init_BetaMessageStream = __esm({
               if (done) {
                 return { value: void 0, done: true };
               }
-              return new Promise((resolve11, reject) => readQueue.push({ resolve: resolve11, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+              return new Promise((resolve12, reject) => readQueue.push({ resolve: resolve12, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
             }
             const chunk = pushQueue.shift();
             return { value: chunk, done: false };
@@ -24195,13 +24204,13 @@ Wrap your summary in <summary></summary> tags.`;
 
 // node_modules/.pnpm/@anthropic-ai+sdk@0.88.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/lib/tools/BetaToolRunner.mjs
 function promiseWithResolvers() {
-  let resolve11;
+  let resolve12;
   let reject;
   const promise2 = new Promise((res, rej) => {
-    resolve11 = res;
+    resolve12 = res;
     reject = rej;
   });
-  return { promise: promise2, resolve: resolve11, reject };
+  return { promise: promise2, resolve: resolve12, reject };
 }
 async function generateToolResponse(params, lastMessage = params.messages.at(-1), requestOptions) {
   if (!lastMessage || lastMessage.role !== "assistant" || !lastMessage.content || typeof lastMessage.content === "string") {
@@ -26021,12 +26030,12 @@ var init_MessageStream = __esm({
           }
           return this._emit("error", new AnthropicError(String(error48)));
         });
-        __classPrivateFieldSet(this, _MessageStream_connectedPromise, new Promise((resolve11, reject) => {
-          __classPrivateFieldSet(this, _MessageStream_resolveConnectedPromise, resolve11, "f");
+        __classPrivateFieldSet(this, _MessageStream_connectedPromise, new Promise((resolve12, reject) => {
+          __classPrivateFieldSet(this, _MessageStream_resolveConnectedPromise, resolve12, "f");
           __classPrivateFieldSet(this, _MessageStream_rejectConnectedPromise, reject, "f");
         }), "f");
-        __classPrivateFieldSet(this, _MessageStream_endPromise, new Promise((resolve11, reject) => {
-          __classPrivateFieldSet(this, _MessageStream_resolveEndPromise, resolve11, "f");
+        __classPrivateFieldSet(this, _MessageStream_endPromise, new Promise((resolve12, reject) => {
+          __classPrivateFieldSet(this, _MessageStream_resolveEndPromise, resolve12, "f");
           __classPrivateFieldSet(this, _MessageStream_rejectEndPromise, reject, "f");
         }), "f");
         __classPrivateFieldGet(this, _MessageStream_connectedPromise, "f").catch(() => {
@@ -26196,11 +26205,11 @@ var init_MessageStream = __esm({
        *   const message = await stream.emitted('message') // rejects if the stream errors
        */
       emitted(event) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           __classPrivateFieldSet(this, _MessageStream_catchingPromiseCreated, true, "f");
           if (event !== "error")
             this.once("error", reject);
-          this.once(event, resolve11);
+          this.once(event, resolve12);
         });
       }
       async done() {
@@ -26518,7 +26527,7 @@ var init_MessageStream = __esm({
               if (done) {
                 return { value: void 0, done: true };
               }
-              return new Promise((resolve11, reject) => readQueue.push({ resolve: resolve11, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+              return new Promise((resolve12, reject) => readQueue.push({ resolve: resolve12, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
             }
             const chunk = pushQueue.shift();
             return { value: chunk, done: false };
@@ -30286,8 +30295,8 @@ var init_schemas = __esm({
     });
     $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def2) => {
       $ZodType.init(inst, def2);
-      const desc5 = Object.getOwnPropertyDescriptor(def2, "shape");
-      if (!desc5?.get) {
+      const desc6 = Object.getOwnPropertyDescriptor(def2, "shape");
+      if (!desc6?.get) {
         const sh = def2.shape;
         Object.defineProperty(def2, "shape", {
           get: () => {
@@ -31529,8 +31538,8 @@ var init_az = __esm({
 });
 
 // node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count2, one, few, many) {
-  const absCount = Math.abs(count2);
+function getBelarusianPlural(count3, one, few, many) {
+  const absCount = Math.abs(count3);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -33444,8 +33453,8 @@ var init_hu = __esm({
 });
 
 // node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/hy.js
-function getArmenianPlural(count2, one, many) {
-  return Math.abs(count2) === 1 ? one : many;
+function getArmenianPlural(count3, one, many) {
+  return Math.abs(count3) === 1 ? one : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -35560,8 +35569,8 @@ var init_pt = __esm({
 });
 
 // node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count2, one, few, many) {
-  const absCount = Math.abs(count2);
+function getRussianPlural(count3, one, few, many) {
+  const absCount = Math.abs(count3);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -43275,8 +43284,8 @@ async function strengthenCoRetrievedEdges(projectRoot) {
     }
   }
   let strengthened = 0;
-  for (const [pair, count2] of coOccurrence) {
-    if (count2 < 3) continue;
+  for (const [pair, count3] of coOccurrence) {
+    if (count3 < 3) continue;
     const [fromId, toId] = pair.split("|");
     if (!fromId || !toId) continue;
     const nodeFrom = `observation:${fromId}`;
@@ -43624,8 +43633,8 @@ async function runObserver(projectRoot, sessionId) {
   } catch {
     return empty;
   }
-  const count2 = countSessionObservations(sessionId);
-  if (count2 < cfg.threshold) return empty;
+  const count3 = countSessionObservations(sessionId);
+  if (count3 < cfg.threshold) return empty;
   const observations = fetchSessionObservations(sessionId, OBSERVER_BATCH_LIMIT);
   if (observations.length < 2) return empty;
   const observationList = observations.map(
@@ -50661,14 +50670,14 @@ async function validateEpicCreation(options, cwd) {
   const mode = await getLifecycleMode(cwd);
   if (mode === "off") return { valid: true };
   const ac = options.acceptance ?? [];
-  const desc5 = (options.description ?? "").trim();
+  const desc6 = (options.description ?? "").trim();
   const violations = [];
   if (ac.length < EPIC_MIN_AC) {
     violations.push(
       `Epic requires at least ${EPIC_MIN_AC} acceptance criteria (${ac.length} provided). Regular tasks need ${TASK_MIN_AC}.`
     );
   }
-  if (!desc5) {
+  if (!desc6) {
     violations.push("Epic must have a non-empty description (used as completion criteria).");
   }
   if (violations.length === 0) return { valid: true };
@@ -51589,7 +51598,7 @@ function migrateAgentOutputs(projectRoot, cleoDir) {
   };
 }
 function copyDirContents(srcDir, dstDir, manifestLines, copiedFiles) {
-  let count2 = 0;
+  let count3 = 0;
   const entries = readdirSync21(srcDir);
   for (const entry of entries) {
     if (entry === "MANIFEST.jsonl") {
@@ -51607,7 +51616,7 @@ function copyDirContents(srcDir, dstDir, manifestLines, copiedFiles) {
             try {
               copyFileSync6(join55(srcPath, sf), join55(dstPath, sf));
               copiedFiles.add(sf);
-              count2++;
+              count3++;
             } catch {
             }
           }
@@ -51615,12 +51624,12 @@ function copyDirContents(srcDir, dstDir, manifestLines, copiedFiles) {
       } else if (!copiedFiles.has(entry)) {
         copyFileSync6(srcPath, dstPath);
         copiedFiles.add(entry);
-        count2++;
+        count3++;
       }
     } catch {
     }
   }
-  return count2;
+  return count3;
 }
 function collectManifestLines(manifestPath, out) {
   try {
@@ -51840,13 +51849,14 @@ __export(registry_exports3, {
   nexusSync: () => nexusSync,
   nexusSyncAll: () => nexusSyncAll,
   nexusUnregister: () => nexusUnregister,
+  nexusUpdateIndexStats: () => nexusUpdateIndexStats,
   readRegistry: () => readRegistry,
   readRegistryRequired: () => readRegistryRequired,
   resetNexusDbState: () => resetNexusDbState
 });
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { mkdir as mkdir12 } from "node:fs/promises";
-import { basename as basename9, join as join62 } from "node:path";
+import { basename as basename9, join as join62, resolve as resolve7 } from "node:path";
 function getNexusHome() {
   return process.env["NEXUS_HOME"] ?? join62(getCleoHome(), "nexus");
 }
@@ -51863,6 +51873,17 @@ function rowToProject(row) {
   } catch {
     labels = [];
   }
+  let stats2 = { nodeCount: 0, relationCount: 0, fileCount: 0 };
+  try {
+    const parsed = JSON.parse(row.statsJson ?? "{}");
+    stats2 = {
+      nodeCount: parsed.nodeCount ?? 0,
+      relationCount: parsed.relationCount ?? 0,
+      fileCount: parsed.fileCount ?? 0
+    };
+  } catch {
+    stats2 = { nodeCount: 0, relationCount: 0, fileCount: 0 };
+  }
   return {
     hash: row.projectHash,
     projectId: row.projectId,
@@ -51875,7 +51896,11 @@ function rowToProject(row) {
     permissions: row.permissions,
     lastSync: row.lastSync,
     taskCount: row.taskCount,
-    labels
+    labels,
+    brainDbPath: row.brainDbPath ?? null,
+    tasksDbPath: row.tasksDbPath ?? null,
+    lastIndexed: row.lastIndexed ?? null,
+    stats: stats2
   };
 }
 async function writeNexusAudit(fields) {
@@ -51971,10 +51996,10 @@ async function readProjectMeta(projectPath) {
 }
 async function readProjectId(projectPath) {
   try {
-    const { readFileSync: readFileSync78, existsSync: existsSync108 } = await import("node:fs");
+    const { readFileSync: readFileSync79, existsSync: existsSync109 } = await import("node:fs");
     const infoPath = join62(projectPath, ".cleo", "project-info.json");
-    if (!existsSync108(infoPath)) return "";
-    const data = JSON.parse(readFileSync78(infoPath, "utf-8"));
+    if (!existsSync109(infoPath)) return "";
+    const data = JSON.parse(readFileSync79(infoPath, "utf-8"));
     return typeof data.projectId === "string" ? data.projectId : "";
   } catch {
     return "";
@@ -52015,13 +52040,18 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
   const meta3 = await readProjectMeta(projectPath);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   let projectId = await readProjectId(projectPath);
+  const resolvedPath = resolve7(projectPath);
+  const brainDbPath = join62(resolvedPath, ".cleo", "brain.db");
+  const tasksDbPath = join62(resolvedPath, ".cleo", "tasks.db");
   if (existing) {
     await db.update(projectRegistry).set({
       permissions,
       lastSync: now,
       taskCount: meta3.taskCount,
       labelsJson: JSON.stringify(meta3.labels),
-      lastSeen: now
+      lastSeen: now,
+      brainDbPath,
+      tasksDbPath
     }).where(eq13(projectRegistry.projectHash, projectHash));
   } else {
     if (!projectId) {
@@ -52039,7 +52069,10 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
       permissions,
       lastSync: now,
       taskCount: meta3.taskCount,
-      labelsJson: JSON.stringify(meta3.labels)
+      labelsJson: JSON.stringify(meta3.labels),
+      brainDbPath,
+      tasksDbPath,
+      statsJson: "{}"
     });
   }
   await writeNexusAudit({
@@ -52155,6 +52188,41 @@ async function nexusSyncAll() {
   });
   return { synced, failed };
 }
+async function nexusUpdateIndexStats(projectPath, stats2) {
+  if (!projectPath) return;
+  const projectHash = generateProjectHash(projectPath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
+    const { eq: eq13 } = await import("drizzle-orm");
+    const db = await getNexusDb2();
+    const rows = await db.select().from(projectRegistry).where(eq13(projectRegistry.projectHash, projectHash));
+    if (rows.length === 0) {
+      try {
+        await nexusRegister(projectPath);
+      } catch {
+      }
+    }
+    await db.update(projectRegistry).set({
+      lastIndexed: now,
+      statsJson: JSON.stringify(stats2),
+      lastSeen: now
+    }).where(eq13(projectRegistry.projectHash, projectHash));
+    await writeNexusAudit({
+      action: "update-index-stats",
+      projectHash,
+      operation: "update-index-stats",
+      success: true,
+      details: {
+        nodeCount: stats2.nodeCount,
+        relationCount: stats2.relationCount,
+        fileCount: stats2.fileCount
+      }
+    });
+  } catch (err) {
+    getLogger("nexus").warn({ err }, "nexus: failed to update index stats");
+  }
+}
 async function nexusSetPermission(nameOrHash, permission) {
   const project = await nexusGetProject(nameOrHash);
   if (!project) {
@@ -54147,29 +54215,29 @@ var init_dependencies = __esm({
 });
 
 // packages/core/src/discovery.ts
-import { existsSync as existsSync104, readdirSync as readdirSync34, statSync as statSync20 } from "node:fs";
-import { join as join103, resolve as resolve10 } from "node:path";
+import { existsSync as existsSync105, readdirSync as readdirSync34, statSync as statSync20 } from "node:fs";
+import { join as join105, resolve as resolve11 } from "node:path";
 function countMeaningfulTopLevelFiles(directory) {
-  if (!existsSync104(directory)) return 0;
+  if (!existsSync105(directory)) return 0;
   try {
     const entries = readdirSync34(directory);
-    let count2 = 0;
+    let count3 = 0;
     for (const entry of entries) {
       if (entry.startsWith(".") || entry === ".cleo" || entry === "node_modules" || entry === "target" || entry === "dist" || entry === "build") {
         continue;
       }
-      count2 += 1;
+      count3 += 1;
     }
-    return count2;
+    return count3;
   } catch {
     return 0;
   }
 }
 function classifyProject(directory) {
-  const root = resolve10(directory ?? process.cwd());
+  const root = resolve11(directory ?? process.cwd());
   const signals = [];
-  const gitPath = join103(root, ".git");
-  const hasGit = existsSync104(gitPath);
+  const gitPath = join105(root, ".git");
+  const hasGit = existsSync105(gitPath);
   if (hasGit) {
     signals.push({
       id: "git-dir",
@@ -54178,8 +54246,8 @@ function classifyProject(directory) {
     });
   }
   for (const manifest of MANIFESTS) {
-    const manifestPath = join103(root, manifest.file);
-    if (existsSync104(manifestPath)) {
+    const manifestPath = join105(root, manifest.file);
+    if (existsSync105(manifestPath)) {
       signals.push({
         id: manifest.signal,
         description: manifest.description,
@@ -54188,8 +54256,8 @@ function classifyProject(directory) {
     }
   }
   for (const dir of SOURCE_DIRS) {
-    const srcPath = join103(root, dir);
-    if (existsSync104(srcPath) && isNonEmptyDir(srcPath)) {
+    const srcPath = join105(root, dir);
+    if (existsSync105(srcPath) && isNonEmptyDir(srcPath)) {
       signals.push({
         id: "source-dir",
         description: `Source directory ${dir}/ contains files`,
@@ -54199,8 +54267,8 @@ function classifyProject(directory) {
     }
   }
   for (const marker of DOCS_MARKERS) {
-    const markerPath = join103(root, marker.path);
-    if (existsSync104(markerPath)) {
+    const markerPath = join105(root, marker.path);
+    if (existsSync105(markerPath)) {
       signals.push({
         id: marker.signal,
         description: `${marker.path} present`,
@@ -54273,18 +54341,18 @@ __export(init_exports, {
   resolveSeedAgentsDir: () => resolveSeedAgentsDir,
   updateDocs: () => updateDocs
 });
-import { existsSync as existsSync105, readdirSync as readdirSync35, readFileSync as readFileSync75 } from "node:fs";
+import { existsSync as existsSync106, readdirSync as readdirSync35, readFileSync as readFileSync76 } from "node:fs";
 import { copyFile as copyFile4, lstat, mkdir as mkdir16, readFile as readFile19, symlink, unlink as unlink4, writeFile as writeFile11 } from "node:fs/promises";
 import { platform as platform4 } from "node:os";
-import { basename as basename17, dirname as dirname22, join as join104 } from "node:path";
+import { basename as basename17, dirname as dirname23, join as join106 } from "node:path";
 async function resolveSeedAgentsDir() {
   try {
     const { createRequire: createRequire10 } = await import("node:module");
     const req = createRequire10(import.meta.url);
     const agentsPkgMain = req.resolve("@cleocode/agents/package.json");
-    const agentsPkgRoot = dirname22(agentsPkgMain);
-    const candidate = join104(agentsPkgRoot, "seed-agents");
-    if (existsSync105(candidate)) {
+    const agentsPkgRoot = dirname23(agentsPkgMain);
+    const candidate = join106(agentsPkgRoot, "seed-agents");
+    if (existsSync106(candidate)) {
       return candidate;
     }
   } catch {
@@ -54292,17 +54360,17 @@ async function resolveSeedAgentsDir() {
   const packageRoot = getPackageRoot();
   const candidates = [
     // Workspace fallback: bundled alongside core under packages/agents/seed-agents
-    join104(packageRoot, "agents", "seed-agents"),
+    join106(packageRoot, "agents", "seed-agents"),
     // Sibling-package layout (e.g. node_modules/@cleocode/core -> ../agents)
-    join104(packageRoot, "..", "agents", "seed-agents"),
+    join106(packageRoot, "..", "agents", "seed-agents"),
     // Bundled CLI: packages/cleo/dist -> ../../agents/seed-agents
-    join104(packageRoot, "..", "..", "agents", "seed-agents"),
+    join106(packageRoot, "..", "..", "agents", "seed-agents"),
     // Bundled CLI dist subdir: packages/cleo/dist/cli -> ../../../packages/agents
-    join104(packageRoot, "..", "..", "packages", "agents", "seed-agents"),
+    join106(packageRoot, "..", "..", "packages", "agents", "seed-agents"),
     // Monorepo workspace from repo root
-    join104(packageRoot, "..", "..", "..", "packages", "agents", "seed-agents")
+    join106(packageRoot, "..", "..", "..", "packages", "agents", "seed-agents")
   ];
-  return candidates.find((p) => existsSync105(p)) ?? null;
+  return candidates.find((p) => existsSync106(p)) ?? null;
 }
 async function initAgentDefinition(created, warnings) {
   let agentSourceDir = null;
@@ -54310,17 +54378,17 @@ async function initAgentDefinition(created, warnings) {
     const { createRequire: createRequire10 } = await import("node:module");
     const req = createRequire10(import.meta.url);
     const agentsPkgMain = req.resolve("@cleocode/agents/package.json");
-    const agentsPkgRoot = dirname22(agentsPkgMain);
-    const candidate = join104(agentsPkgRoot, "cleo-subagent");
-    if (existsSync105(candidate)) {
+    const agentsPkgRoot = dirname23(agentsPkgMain);
+    const candidate = join106(agentsPkgRoot, "cleo-subagent");
+    if (existsSync106(candidate)) {
       agentSourceDir = candidate;
     }
   } catch {
   }
   if (!agentSourceDir) {
     const packageRoot = getPackageRoot();
-    const bundled = join104(packageRoot, "agents", "cleo-subagent");
-    if (existsSync105(bundled)) {
+    const bundled = join106(packageRoot, "agents", "cleo-subagent");
+    if (existsSync106(bundled)) {
       agentSourceDir = bundled;
     }
   }
@@ -54328,8 +54396,8 @@ async function initAgentDefinition(created, warnings) {
     warnings.push("agents/cleo-subagent/ not found in package, skipping agent definition install");
     return;
   }
-  const globalAgentsDir = join104(getAgentsHome(), "agents", "cleo-subagent");
-  await mkdir16(dirname22(globalAgentsDir), { recursive: true });
+  const globalAgentsDir = join106(getAgentsHome(), "agents", "cleo-subagent");
+  await mkdir16(dirname23(globalAgentsDir), { recursive: true });
   try {
     try {
       const stat2 = await lstat(globalAgentsDir);
@@ -54352,7 +54420,7 @@ async function initAgentDefinition(created, warnings) {
       await mkdir16(globalAgentsDir, { recursive: true });
       const files = readdirSync35(agentSourceDir);
       for (const file2 of files) {
-        await copyFile4(join104(agentSourceDir, file2), join104(globalAgentsDir, file2));
+        await copyFile4(join106(agentSourceDir, file2), join106(globalAgentsDir, file2));
       }
       created.push("agent: cleo-subagent (copied)");
     } catch (copyErr) {
@@ -54377,20 +54445,20 @@ async function initCoreSkills(created, warnings) {
       const { createRequire: createRequire10 } = await import("node:module");
       const req = createRequire10(import.meta.url);
       const skillsPkgMain = req.resolve("@cleocode/skills/package.json");
-      const skillsPkgRoot = dirname22(skillsPkgMain);
-      if (existsSync105(join104(skillsPkgRoot, "skills.json"))) {
+      const skillsPkgRoot = dirname23(skillsPkgMain);
+      if (existsSync106(join106(skillsPkgRoot, "skills.json"))) {
         ctSkillsRoot = skillsPkgRoot;
       }
     } catch {
     }
     if (!ctSkillsRoot) {
       try {
-        const bundledPath = join104(packageRoot, "packages", "skills");
-        if (existsSync105(join104(bundledPath, "skills.json"))) {
+        const bundledPath = join106(packageRoot, "packages", "skills");
+        if (existsSync106(join106(bundledPath, "skills.json"))) {
           ctSkillsRoot = bundledPath;
         } else {
-          const ctSkillsPath = join104(packageRoot, "node_modules", "@cleocode", "skills");
-          if (existsSync105(join104(ctSkillsPath, "skills.json"))) {
+          const ctSkillsPath = join106(packageRoot, "node_modules", "@cleocode", "skills");
+          if (existsSync106(join106(ctSkillsPath, "skills.json"))) {
             ctSkillsRoot = ctSkillsPath;
           }
         }
@@ -54406,14 +54474,14 @@ async function initCoreSkills(created, warnings) {
     } catch {
       warnings.push("Failed to register skill library with CAAMP");
     }
-    const catalogPath = join104(ctSkillsRoot, "skills.json");
-    const catalog3 = JSON.parse(readFileSync75(catalogPath, "utf-8"));
+    const catalogPath = join106(ctSkillsRoot, "skills.json");
+    const catalog3 = JSON.parse(readFileSync76(catalogPath, "utf-8"));
     const skills = catalog3.skills ?? [];
     const coreSkills = skills.filter((s) => s.tier <= 2);
     const installed = [];
     for (const skill of coreSkills) {
-      const skillSourceDir = dirname22(join104(ctSkillsRoot, skill.path));
-      if (!existsSync105(skillSourceDir)) {
+      const skillSourceDir = dirname23(join106(ctSkillsRoot, skill.path));
+      if (!existsSync106(skillSourceDir)) {
         continue;
       }
       try {
@@ -54456,38 +54524,38 @@ async function initNexusRegistration(projectRoot, created, warnings) {
   }
 }
 async function installGitHubTemplates(projectRoot, created, skipped) {
-  if (!existsSync105(join104(projectRoot, ".git"))) {
+  if (!existsSync106(join106(projectRoot, ".git"))) {
     return;
   }
-  const githubDir = join104(projectRoot, ".github");
-  const issueTemplateDir = join104(githubDir, "ISSUE_TEMPLATE");
+  const githubDir = join106(projectRoot, ".github");
+  const issueTemplateDir = join106(githubDir, "ISSUE_TEMPLATE");
   const packageRoot = getPackageRoot();
-  const templateSrcDir = join104(packageRoot, "templates", "github");
-  if (!existsSync105(templateSrcDir)) {
+  const templateSrcDir = join106(packageRoot, "templates", "github");
+  if (!existsSync106(templateSrcDir)) {
     return;
   }
   await mkdir16(issueTemplateDir, { recursive: true });
-  const issueSrcDir = join104(templateSrcDir, "ISSUE_TEMPLATE");
-  if (existsSync105(issueSrcDir)) {
+  const issueSrcDir = join106(templateSrcDir, "ISSUE_TEMPLATE");
+  if (existsSync106(issueSrcDir)) {
     const issueFiles = readdirSync35(issueSrcDir);
     for (const file2 of issueFiles) {
-      const dest = join104(issueTemplateDir, file2);
-      if (existsSync105(dest)) {
+      const dest = join106(issueTemplateDir, file2);
+      if (existsSync106(dest)) {
         skipped.push(`.github/ISSUE_TEMPLATE/${file2}`);
         continue;
       }
-      const content = readFileSync75(join104(issueSrcDir, file2), "utf-8");
+      const content = readFileSync76(join106(issueSrcDir, file2), "utf-8");
       await writeFile11(dest, content, "utf-8");
       created.push(`.github/ISSUE_TEMPLATE/${file2}`);
     }
   }
-  const prTemplateSrc = join104(templateSrcDir, "pull_request_template.md");
-  const prTemplateDest = join104(githubDir, "pull_request_template.md");
-  if (existsSync105(prTemplateSrc)) {
-    if (existsSync105(prTemplateDest)) {
+  const prTemplateSrc = join106(templateSrcDir, "pull_request_template.md");
+  const prTemplateDest = join106(githubDir, "pull_request_template.md");
+  if (existsSync106(prTemplateSrc)) {
+    if (existsSync106(prTemplateDest)) {
       skipped.push(".github/pull_request_template.md");
     } else {
-      const content = readFileSync75(prTemplateSrc, "utf-8");
+      const content = readFileSync76(prTemplateSrc, "utf-8");
       await writeFile11(prTemplateDest, content, "utf-8");
       created.push(".github/pull_request_template.md");
     }
@@ -54517,8 +54585,8 @@ async function updateDocs() {
 }
 async function initProject(opts = {}) {
   const cleoDir = getCleoDirAbsolute();
-  const projRoot = dirname22(cleoDir);
-  const alreadyInitialized = existsSync105(cleoDir) && (existsSync105(join104(cleoDir, "tasks.db")) || existsSync105(join104(cleoDir, "config.json")));
+  const projRoot = dirname23(cleoDir);
+  const alreadyInitialized = existsSync106(cleoDir) && (existsSync106(join106(cleoDir, "tasks.db")) || existsSync106(join106(cleoDir, "config.json")));
   if (alreadyInitialized && !opts.force) {
     throw new CleoError(
       1 /* GENERAL_ERROR */,
@@ -54550,7 +54618,7 @@ async function initProject(opts = {}) {
   }
   try {
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-    await getDb3(join104(cleoDir, ".."));
+    await getDb3(join106(cleoDir, ".."));
     created.push("tasks.db");
   } catch (err) {
     created.push(`tasks.db (deferred: ${err instanceof Error ? err.message : String(err)})`);
@@ -54580,8 +54648,8 @@ async function initProject(opts = {}) {
       created.push(".gitignore");
     }
   } else {
-    const gitignorePath = join104(cleoDir, ".gitignore");
-    if (existsSync105(gitignorePath)) {
+    const gitignorePath = join106(cleoDir, ".gitignore");
+    if (existsSync106(gitignorePath)) {
       skipped.push(".gitignore");
     } else {
       const gitignoreResult = await ensureGitignore(projRoot);
@@ -54592,12 +54660,12 @@ async function initProject(opts = {}) {
       }
     }
   }
-  const legacySequencePath = join104(cleoDir, ".sequence");
+  const legacySequencePath = join106(cleoDir, ".sequence");
   try {
     await unlink4(legacySequencePath);
   } catch {
   }
-  const legacySequenceJsonPath = join104(cleoDir, ".sequence.json");
+  const legacySequenceJsonPath = join106(cleoDir, ".sequence.json");
   try {
     await unlink4(legacySequenceJsonPath);
   } catch {
@@ -54753,15 +54821,15 @@ async function initProject(opts = {}) {
   if (opts.installSeedAgents) {
     try {
       const seedDir = await resolveSeedAgentsDir();
-      if (seedDir && existsSync105(seedDir)) {
-        const targetDir = join104(projRoot, ".cleo", "agents");
+      if (seedDir && existsSync106(seedDir)) {
+        const targetDir = join106(projRoot, ".cleo", "agents");
         await mkdir16(targetDir, { recursive: true });
         const seeds = readdirSync35(seedDir).filter((f) => f.endsWith(".cant"));
         let installed = 0;
         for (const seed of seeds) {
-          const dst = join104(targetDir, seed);
-          if (!existsSync105(dst)) {
-            await copyFile4(join104(seedDir, seed), dst);
+          const dst = join106(targetDir, seed);
+          if (!existsSync106(dst)) {
+            await copyFile4(join106(seedDir, seed), dst);
             installed++;
           }
         }
@@ -54844,8 +54912,8 @@ function isAutoInitEnabled() {
 }
 async function ensureInitialized(projectRoot) {
   const root = projectRoot ?? getProjectRoot();
-  const cleoDir = join104(root, ".cleo");
-  const isInit = existsSync105(cleoDir) && (existsSync105(join104(cleoDir, "tasks.db")) || existsSync105(join104(cleoDir, "config.json")));
+  const cleoDir = join106(root, ".cleo");
+  const isInit = existsSync106(cleoDir) && (existsSync106(join106(cleoDir, "tasks.db")) || existsSync106(join106(cleoDir, "config.json")));
   if (isInit) {
     return { initialized: true };
   }
@@ -54857,7 +54925,7 @@ async function ensureInitialized(projectRoot) {
 }
 async function getVersion2(projectRoot) {
   const root = projectRoot ?? getProjectRoot();
-  const versionPaths = [join104(root, "VERSION"), join104(root, "..", "VERSION")];
+  const versionPaths = [join106(root, "VERSION"), join106(root, "..", "VERSION")];
   for (const versionPath of versionPaths) {
     try {
       const content = await readFile19(versionPath, "utf-8");
@@ -54868,16 +54936,16 @@ async function getVersion2(projectRoot) {
     } catch {
     }
   }
-  const pkg = await readJson(join104(root, "package.json"));
+  const pkg = await readJson(join106(root, "package.json"));
   if (pkg?.version) {
     return { version: pkg.version };
   }
   return { version: "0.0.0" };
 }
 async function deployStarterBundle(cleoDir, created, warnings) {
-  const cantDir = join104(cleoDir, "cant");
-  const cantAgentsDir = join104(cantDir, "agents");
-  const hasCantFiles = existsSync105(cantDir) && readdirSync35(cantDir, { recursive: true }).some(
+  const cantDir = join106(cleoDir, "cant");
+  const cantAgentsDir = join106(cantDir, "agents");
+  const hasCantFiles = existsSync106(cantDir) && readdirSync35(cantDir, { recursive: true }).some(
     (f) => typeof f === "string" && f.endsWith(".cant")
   );
   if (hasCantFiles) return;
@@ -54886,9 +54954,9 @@ async function deployStarterBundle(cleoDir, created, warnings) {
     const { createRequire: createRequire10 } = await import("node:module");
     const req = createRequire10(import.meta.url);
     const cleoOsPkgMain = req.resolve("@cleocode/cleo-os/package.json");
-    const cleoOsPkgRoot = dirname22(cleoOsPkgMain);
-    const candidate = join104(cleoOsPkgRoot, "starter-bundle");
-    if (existsSync105(candidate)) {
+    const cleoOsPkgRoot = dirname23(cleoOsPkgMain);
+    const candidate = join106(cleoOsPkgRoot, "starter-bundle");
+    if (existsSync106(candidate)) {
       starterBundleSrc = candidate;
     }
   } catch {
@@ -54896,10 +54964,10 @@ async function deployStarterBundle(cleoDir, created, warnings) {
   if (!starterBundleSrc) {
     const packageRoot = getPackageRoot();
     const fallbacks = [
-      join104(packageRoot, "..", "cleo-os", "starter-bundle"),
-      join104(packageRoot, "..", "..", "packages", "cleo-os", "starter-bundle")
+      join106(packageRoot, "..", "cleo-os", "starter-bundle"),
+      join106(packageRoot, "..", "..", "packages", "cleo-os", "starter-bundle")
     ];
-    starterBundleSrc = fallbacks.find((p) => existsSync105(p)) ?? null;
+    starterBundleSrc = fallbacks.find((p) => existsSync106(p)) ?? null;
   }
   if (!starterBundleSrc) {
     warnings.push(
@@ -54909,30 +54977,30 @@ async function deployStarterBundle(cleoDir, created, warnings) {
   }
   await mkdir16(cantDir, { recursive: true });
   await mkdir16(cantAgentsDir, { recursive: true });
-  const teamSrc = join104(starterBundleSrc, "team.cant");
-  const teamDst = join104(cantDir, "team.cant");
-  if (existsSync105(teamSrc) && !existsSync105(teamDst)) {
+  const teamSrc = join106(starterBundleSrc, "team.cant");
+  const teamDst = join106(cantDir, "team.cant");
+  if (existsSync106(teamSrc) && !existsSync106(teamDst)) {
     await copyFile4(teamSrc, teamDst);
   }
-  const agentsSrc = join104(starterBundleSrc, "agents");
-  if (existsSync105(agentsSrc)) {
+  const agentsSrc = join106(starterBundleSrc, "agents");
+  if (existsSync106(agentsSrc)) {
     const agentFiles = readdirSync35(agentsSrc).filter((f) => f.endsWith(".cant"));
     for (const agentFile of agentFiles) {
-      const dst = join104(cantAgentsDir, agentFile);
-      if (!existsSync105(dst)) {
-        await copyFile4(join104(agentsSrc, agentFile), dst);
+      const dst = join106(cantAgentsDir, agentFile);
+      if (!existsSync106(dst)) {
+        await copyFile4(join106(agentsSrc, agentFile), dst);
       }
     }
   }
-  const identitySrc = join104(starterBundleSrc, "CLEOOS-IDENTITY.md");
-  const identityDst = join104(cleoDir, "CLEOOS-IDENTITY.md");
-  if (existsSync105(identitySrc) && !existsSync105(identityDst)) {
+  const identitySrc = join106(starterBundleSrc, "CLEOOS-IDENTITY.md");
+  const identityDst = join106(cleoDir, "CLEOOS-IDENTITY.md");
+  if (existsSync106(identitySrc) && !existsSync106(identityDst)) {
     await copyFile4(identitySrc, identityDst);
   }
   try {
     const { getCleoHome: getCleoHome2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
-    const globalIdentityDst = join104(getCleoHome2(), "CLEOOS-IDENTITY.md");
-    if (existsSync105(identitySrc) && !existsSync105(globalIdentityDst)) {
+    const globalIdentityDst = join106(getCleoHome2(), "CLEOOS-IDENTITY.md");
+    if (existsSync106(identitySrc) && !existsSync106(globalIdentityDst)) {
       await copyFile4(identitySrc, globalIdentityDst);
     }
   } catch {
@@ -56483,8 +56551,8 @@ function providerInstalled() {
 }
 function providerCount() {
   try {
-    const count2 = getProviderCount();
-    return { success: true, data: { count: count2 } };
+    const count3 = getProviderCount();
+    return { success: true, data: { count: count3 } };
   } catch (err) {
     return {
       success: false,
@@ -57292,7 +57360,7 @@ var SseTransport = class {
   // --------------------------------------------------------------------------
   /** Establish SSE connection. Resolves when open, rejects on error. */
   connectSse() {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       if (!this.state) {
         reject(new Error("No state"));
         return;
@@ -57308,7 +57376,7 @@ var SseTransport = class {
         clearTimeout(timeout);
         this.state.connected = true;
         this.state.reconnectAttempts = 0;
-        resolve11();
+        resolve12();
       });
       es.addEventListener("message", (event) => {
         this.handleSseMessage(event);
@@ -58290,16 +58358,16 @@ function collectTransitiveDependents(taskId, dependentsMap) {
   return visited;
 }
 function countBlockedWork(taskId, transitiveDependents, taskMap) {
-  let count2 = 0;
+  let count3 = 0;
   for (const depId of transitiveDependents) {
     if (depId === taskId) continue;
     const task = taskMap.get(depId);
     if (!task) continue;
     if (task.status !== "done" && task.status !== "cancelled") {
-      count2++;
+      count3++;
     }
   }
-  return count2;
+  return count3;
 }
 function findAffectedPipelines(taskId, transitiveDependents, tasks2) {
   const affectedEpicIds = /* @__PURE__ */ new Set();
@@ -58908,19 +58976,19 @@ async function extractWorkflowPatterns(accessor, minFrequency) {
         depTargetCounts.set(dep, (depTargetCounts.get(dep) || 0) + 1);
       }
     }
-    for (const [taskId, count2] of depTargetCounts) {
-      if (count2 >= minFrequency) {
+    for (const [taskId, count3] of depTargetCounts) {
+      if (count3 >= minFrequency) {
         const hubTask = allTasks.find((t) => t.id === taskId);
         const title = hubTask?.title ?? taskId;
         patterns.push({
           type: "workflow",
-          pattern: `Task "${title}" (${taskId}) is a dependency hub with ${count2} dependents`,
+          pattern: `Task "${title}" (${taskId}) is a dependency hub with ${count3} dependents`,
           context: "Dependency graph analysis \u2014 hub tasks are critical path candidates",
-          frequency: count2,
+          frequency: count3,
           successRate: hubTask?.status === "done" ? 1 : null,
-          impact: count2 >= 5 ? "high" : "medium",
-          antiPattern: count2 >= 8 ? `Task ${taskId} may be an overly-centralized bottleneck` : null,
-          mitigation: count2 >= 8 ? "Consider decomposing this task to reduce coupling" : null,
+          impact: count3 >= 5 ? "high" : "medium",
+          antiPattern: count3 >= 8 ? `Task ${taskId} may be an overly-centralized bottleneck` : null,
+          mitigation: count3 >= 8 ? "Consider decomposing this task to reduce coupling" : null,
           examples: allTasks.filter((t) => t.depends?.includes(taskId)).slice(0, 10).map((t) => t.id),
           confidence: 0.7
         });
@@ -58962,18 +59030,18 @@ async function extractObservationPatterns(brainAccessor, minFrequency) {
     for (const obs of observations) {
       typeCounts.set(obs.type, (typeCounts.get(obs.type) || 0) + 1);
     }
-    for (const [type, count2] of typeCounts) {
-      if (count2 >= minFrequency) {
+    for (const [type, count3] of typeCounts) {
+      if (count3 >= minFrequency) {
         const patternType = observationTypeToPatternType(type);
         patterns.push({
           type: patternType,
-          pattern: `${count2} "${type}" observations recorded`,
+          pattern: `${count3} "${type}" observations recorded`,
           context: "Brain observation frequency analysis",
-          frequency: count2,
+          frequency: count3,
           successRate: type === "feature" || type === "refactor" ? 0.8 : null,
-          impact: count2 >= 10 ? "high" : count2 >= 5 ? "medium" : "low",
-          antiPattern: type === "bugfix" && count2 >= 5 ? "High number of bugfix observations may indicate quality issues" : null,
-          mitigation: type === "bugfix" && count2 >= 5 ? "Consider adding more automated tests and code review" : null,
+          impact: count3 >= 10 ? "high" : count3 >= 5 ? "medium" : "low",
+          antiPattern: type === "bugfix" && count3 >= 5 ? "High number of bugfix observations may indicate quality issues" : null,
+          mitigation: type === "bugfix" && count3 >= 5 ? "Consider adding more automated tests and code review" : null,
           examples: observations.filter((o) => o.type === type).slice(0, 5).map((o) => o.id),
           confidence: 0.5
         });
@@ -58985,13 +59053,13 @@ async function extractObservationPatterns(brainAccessor, minFrequency) {
         projectCounts.set(obs.project, (projectCounts.get(obs.project) || 0) + 1);
       }
     }
-    for (const [project, count2] of projectCounts) {
-      if (count2 >= minFrequency * 2) {
+    for (const [project, count3] of projectCounts) {
+      if (count3 >= minFrequency * 2) {
         patterns.push({
           type: "workflow",
-          pattern: `Project "${project}" has ${count2} observations \u2014 high activity area`,
+          pattern: `Project "${project}" has ${count3} observations \u2014 high activity area`,
           context: "Cross-project observation density analysis",
-          frequency: count2,
+          frequency: count3,
           successRate: null,
           impact: "medium",
           antiPattern: null,
@@ -59505,7 +59573,7 @@ function augmentError(err, context) {
   }
 }
 function sleep2(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 
 // packages/core/src/lib/index.ts
@@ -64969,6 +65037,7 @@ __export(nexus_exports, {
   nexusSync: () => nexusSync,
   nexusSyncAll: () => nexusSyncAll,
   nexusUnregister: () => nexusUnregister,
+  nexusUpdateIndexStats: () => nexusUpdateIndexStats,
   orphanDetection: () => orphanDetection,
   parseDirective: () => parseDirective,
   parseQuery: () => parseQuery,
@@ -65118,8 +65187,8 @@ async function resolveProjectPath2(projectName) {
   if (projectName === ".") {
     try {
       const accessor = await getAccessor(process.cwd());
-      const count2 = await accessor.countTasks();
-      if (count2 >= 0) return process.cwd();
+      const count3 = await accessor.countTasks();
+      if (count3 >= 0) return process.cwd();
       throw new Error("No task data");
     } catch {
       throw new CleoError(
@@ -69887,17 +69956,17 @@ async function generateReleaseChangelog(version2, loadTasksFn, cwd) {
   function buildEntry(task) {
     const cleanTitle = capitalize(stripConventionalPrefix(task.title));
     const safeDesc = task.description?.replace(/\r?\n/g, " ").replace(/\s{2,}/g, " ").trim();
-    const desc5 = safeDesc;
+    const desc6 = safeDesc;
     const shouldIncludeDesc = (() => {
-      if (!desc5 || desc5.length === 0) return false;
+      if (!desc6 || desc6.length === 0) return false;
       const titleNorm = cleanTitle.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim();
-      const descNorm = desc5.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim();
+      const descNorm = desc6.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim();
       if (titleNorm === descNorm) return false;
       if (descNorm.startsWith(titleNorm) && descNorm.length < titleNorm.length * 1.3) return false;
-      return desc5.length >= 20;
+      return desc6.length >= 20;
     })();
     if (shouldIncludeDesc) {
-      const descDisplay = desc5.length > 150 ? desc5.slice(0, 147) + "..." : desc5;
+      const descDisplay = desc6.length > 150 ? desc6.slice(0, 147) + "..." : desc6;
       return `- **${cleanTitle}**: ${descDisplay} (${task.id})`;
     }
     return `- ${cleanTitle} (${task.id})`;
@@ -70463,11 +70532,11 @@ __export(remote_exports, {
 init_paths();
 init_git_checkpoint();
 import { execFile as execFile5 } from "node:child_process";
-import { resolve as resolve7 } from "node:path";
+import { resolve as resolve8 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 var execFileAsync5 = promisify5(execFile5);
 async function cleoGitExec(args, cleoDir) {
-  const abs = resolve7(cleoDir);
+  const abs = resolve8(cleoDir);
   const result = await execFileAsync5("git", args, {
     cwd: abs,
     env: makeCleoGitEnv(cleoDir),
@@ -72334,7 +72403,7 @@ __export(security_exports, {
 // packages/core/src/security/input-sanitization.ts
 init_src();
 init_tasks_schema();
-import { isAbsolute as isAbsolute2, normalize, relative as relative6, resolve as resolve8 } from "path";
+import { isAbsolute as isAbsolute2, normalize, relative as relative6, resolve as resolve9 } from "path";
 
 // packages/core/src/tasks/id-generator.ts
 function normalizeTaskId(input) {
@@ -72396,12 +72465,12 @@ function sanitizePath(path4, projectRoot) {
   if (trimmedPath.includes("\0")) {
     throw new SecurityError("Path contains null bytes", "E_PATH_TRAVERSAL", "path");
   }
-  const normalizedRoot = resolve8(projectRoot);
+  const normalizedRoot = resolve9(projectRoot);
   let resolvedPath;
   if (isAbsolute2(trimmedPath)) {
     resolvedPath = normalize(trimmedPath);
   } else {
-    resolvedPath = resolve8(normalizedRoot, trimmedPath);
+    resolvedPath = resolve9(normalizedRoot, trimmedPath);
   }
   const relativePath = relative6(normalizedRoot, resolvedPath);
   if (relativePath.startsWith("..") || isAbsolute2(relativePath)) {
@@ -74289,7 +74358,7 @@ async function validateOrchestratorCompliance(epicId, cwd) {
 
 // packages/core/src/skills/skill-paths.ts
 import { existsSync as existsSync80, lstatSync, readlinkSync as readlinkSync2, realpathSync } from "node:fs";
-import { delimiter, join as join81, resolve as resolve9 } from "node:path";
+import { delimiter, join as join81, resolve as resolve10 } from "node:path";
 import { getCanonicalSkillsDir as getCanonicalSkillsDir2 } from "@cleocode/caamp";
 function getCaampCanonical() {
   return getCanonicalSkillsDir2();
@@ -74406,7 +74475,7 @@ function getSkillSourceType(skillDir, projectRoot) {
     }
   } catch {
   }
-  if (normalizedDir.startsWith(resolve9(embeddedDir)) || normalizedDir.startsWith(join81(root, "skills"))) {
+  if (normalizedDir.startsWith(resolve10(embeddedDir)) || normalizedDir.startsWith(join81(root, "skills"))) {
     return "embedded";
   }
   if (normalizedDir.startsWith(caampDir)) {
@@ -74937,8 +75006,8 @@ async function initializeSpawnAdapters(manifests) {
     if (!manifest.capabilities?.supportsSpawn) continue;
     if (spawnRegistry.hasAdapterForProvider(manifest.provider)) continue;
     try {
-      const { join: join107 } = await import("node:path");
-      const modulePath = join107(manifest.packagePath, manifest.entryPoint);
+      const { join: join109 } = await import("node:path");
+      const modulePath = join109(manifest.packagePath, manifest.entryPoint);
       const adapterModule = await import(modulePath);
       let SpawnProviderClass;
       for (const [exportName, exportValue] of Object.entries(adapterModule)) {
@@ -75040,7 +75109,7 @@ async function queryTasks(cwd, since) {
   try {
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { tasks: tasks2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
-    const { and: and10, gte: gte3 } = await import("drizzle-orm");
+    const { and: and11, gte: gte3 } = await import("drizzle-orm");
     const db = await getDb3(cwd);
     const conditions = [];
     if (since) {
@@ -75054,7 +75123,7 @@ async function queryTasks(cwd, since) {
       sessionId: tasks2.sessionId,
       completedAt: tasks2.completedAt,
       createdAt: tasks2.createdAt
-    }).from(tasks2).where(conditions.length > 0 ? and10(...conditions) : void 0).all();
+    }).from(tasks2).where(conditions.length > 0 ? and11(...conditions) : void 0).all();
     return rows;
   } catch (err) {
     log9.warn({ err }, "Failed to query tasks for workflow telemetry");
@@ -75065,7 +75134,7 @@ async function queryCompletionAuditRows(cwd, since) {
   try {
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
-    const { and: and10, gte: gte3 } = await import("drizzle-orm");
+    const { and: and11, gte: gte3 } = await import("drizzle-orm");
     const db = await getDb3(cwd);
     const conditions = [];
     if (since) conditions.push(gte3(auditLog2.timestamp, since));
@@ -75077,7 +75146,7 @@ async function queryCompletionAuditRows(cwd, since) {
       afterJson: auditLog2.afterJson,
       operation: auditLog2.operation,
       domain: auditLog2.domain
-    }).from(auditLog2).where(conditions.length > 0 ? and10(...conditions) : void 0).orderBy(auditLog2.timestamp).all();
+    }).from(auditLog2).where(conditions.length > 0 ? and11(...conditions) : void 0).orderBy(auditLog2.timestamp).all();
     return allRows.filter((row) => {
       const isComplete = row.action === "task_completed" || row.action === "complete" || row.operation === "complete" && row.domain === "tasks";
       if (!isComplete && row.afterJson) {
@@ -75532,7 +75601,7 @@ async function getDashboard(opts, accessor) {
       labelMap[label] = (labelMap[label] ?? 0) + 1;
     }
   }
-  const topLabels = Object.entries(labelMap).map(([label, count2]) => ({ label, count: count2 })).sort((a, b) => b.count - a.count).slice(0, 8);
+  const topLabels = Object.entries(labelMap).map(([label, count3]) => ({ label, count: count3 })).sort((a, b) => b.count - a.count).slice(0, 8);
   return {
     project,
     currentPhase,
@@ -75570,7 +75639,7 @@ async function getCompletionHistory(opts) {
     const date6 = c.timestamp.split("T")[0];
     byDate[date6] = (byDate[date6] ?? 0) + 1;
   }
-  const dailyCounts = Object.entries(byDate).sort(([a], [b]) => a.localeCompare(b)).map(([date6, count2]) => ({ date: date6, count: count2 }));
+  const dailyCounts = Object.entries(byDate).sort(([a], [b]) => a.localeCompare(b)).map(([date6, count3]) => ({ date: date6, count: count3 }));
   const totalCompletions = completions.length;
   const avgPerDay = days > 0 ? Math.round(totalCompletions / days * 100) / 100 : 0;
   const peakDay = dailyCounts.reduce((max, d) => d.count > max.count ? d : max, {
@@ -76067,7 +76136,7 @@ function byLabelReport(tasks2) {
       counts[label] = (counts[label] ?? 0) + 1;
     }
   }
-  return Object.entries(counts).map(([label, count2]) => ({ label, count: count2 })).sort((a, b) => b.count - a.count);
+  return Object.entries(counts).map(([label, count3]) => ({ label, count: count3 })).sort((a, b) => b.count - a.count);
 }
 function byPriorityReport(tasks2) {
   const PRIO_ORDER = ["critical", "high", "medium", "low", "unset"];
@@ -76127,15 +76196,15 @@ function trendsReport(tasks2) {
     const date6 = t.archive.archivedAt.slice(0, 10);
     byDay[date6] = (byDay[date6] ?? 0) + 1;
   }
-  const dailyEntries = Object.entries(byDay).map(([date6, count2]) => ({ date: date6, count: count2 })).sort((a, b) => a.date.localeCompare(b.date));
+  const dailyEntries = Object.entries(byDay).map(([date6, count3]) => ({ date: date6, count: count3 })).sort((a, b) => a.date.localeCompare(b.date));
   const byMonth = {};
-  for (const { date: date6, count: count2 } of dailyEntries) {
+  for (const { date: date6, count: count3 } of dailyEntries) {
     const month = date6.slice(0, 7);
-    byMonth[month] = (byMonth[month] ?? 0) + count2;
+    byMonth[month] = (byMonth[month] ?? 0) + count3;
   }
-  const monthlyEntries = Object.entries(byMonth).map(([month, count2]) => ({
+  const monthlyEntries = Object.entries(byMonth).map(([month, count3]) => ({
     month,
-    count: count2
+    count: count3
   }));
   const totalPeriod = dailyEntries.reduce((sum, d) => sum + d.count, 0);
   return {
@@ -79078,6 +79147,304 @@ async function showTask(taskId, cwd, accessor) {
 // packages/core/src/tasks/index.ts
 init_update2();
 
+// packages/core/src/telemetry/index.ts
+var telemetry_exports = {};
+__export(telemetry_exports, {
+  buildDiagnosticsReport: () => buildDiagnosticsReport,
+  disableTelemetry: () => disableTelemetry,
+  enableTelemetry: () => enableTelemetry,
+  exportTelemetryEvents: () => exportTelemetryEvents,
+  getTelemetryConfigPath: () => getTelemetryConfigPath,
+  getTelemetryDb: () => getTelemetryDb,
+  getTelemetryDbPath: () => getTelemetryDbPath,
+  isTelemetryEnabled: () => isTelemetryEnabled,
+  loadTelemetryConfig: () => loadTelemetryConfig,
+  recordTelemetryEvent: () => recordTelemetryEvent,
+  saveTelemetryConfig: () => saveTelemetryConfig,
+  telemetryEvents: () => telemetryEvents,
+  telemetrySchemaMeta: () => telemetrySchemaMeta
+});
+init_paths();
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { existsSync as existsSync96, mkdirSync as mkdirSync24, readFileSync as readFileSync68, writeFileSync as writeFileSync16 } from "node:fs";
+import { join as join99 } from "node:path";
+import { and as and10, count as count2, desc as desc5, gt as gt2, sql as sql13 } from "drizzle-orm";
+
+// packages/core/src/telemetry/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  telemetryEvents: () => telemetryEvents,
+  telemetrySchemaMeta: () => telemetrySchemaMeta
+});
+init_sqlite_core();
+import { sql as sql12 } from "drizzle-orm";
+var telemetryEvents = sqliteTable(
+  "telemetry_events",
+  {
+    /** UUID primary key. */
+    id: text("id").primaryKey(),
+    /** Anonymous install identifier (UUIDv4, generated once on first enable). */
+    anonymousId: text("anonymous_id").notNull(),
+    /** Canonical domain (e.g. "tasks", "session", "memory", "admin"). */
+    domain: text("domain").notNull(),
+    /** CQRS gateway ("query" or "mutate"). */
+    gateway: text("gateway").notNull(),
+    /** Operation name (e.g. "show", "add", "complete"). */
+    operation: text("operation").notNull(),
+    /** Composed command string "{domain}.{operation}" for easy grouping. */
+    command: text("command").notNull(),
+    /** LAFS exit code (0 = success, non-zero = failure). */
+    exitCode: integer("exit_code").notNull().default(0),
+    /** Wall-clock duration in milliseconds. */
+    durationMs: integer("duration_ms").notNull(),
+    /** Machine-readable error code when exit_code != 0. NULL on success. */
+    errorCode: text("error_code"),
+    /** ISO-8601 timestamp of the invocation. */
+    timestamp: text("timestamp").notNull().default(sql12`(datetime('now'))`)
+  },
+  (table) => [
+    index("idx_telemetry_command").on(table.command),
+    index("idx_telemetry_domain").on(table.domain),
+    index("idx_telemetry_exit_code").on(table.exitCode),
+    index("idx_telemetry_timestamp").on(table.timestamp),
+    index("idx_telemetry_duration").on(table.durationMs)
+  ]
+);
+var telemetrySchemaMeta = sqliteTable("telemetry_schema_meta", {
+  /** Config key. */
+  key: text("key").primaryKey(),
+  /** Config value. */
+  value: text("value").notNull()
+});
+
+// packages/core/src/telemetry/sqlite.ts
+init_node_sqlite();
+init_paths();
+init_migration_manager();
+init_sqlite2();
+import { mkdirSync as mkdirSync23 } from "node:fs";
+import { dirname as dirname20, join as join98 } from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
+var DB_FILENAME4 = "telemetry.db";
+var TELEMETRY_SCHEMA_VERSION = "1.0.0";
+var _db3 = null;
+var _nativeDb3 = null;
+var _dbPath3 = null;
+var _initPromise3 = null;
+function getTelemetryDbPath() {
+  return join98(getCleoHome(), DB_FILENAME4);
+}
+function resolveTelemetryMigrationsFolder() {
+  const __filename = fileURLToPath6(import.meta.url);
+  const __dir = dirname20(__filename);
+  const isBundled = __dir.endsWith("/dist") || __dir.endsWith("\\dist");
+  const pkgRoot = isBundled ? join98(__dir, "..") : join98(__dir, "..", "..");
+  return join98(pkgRoot, "migrations", "drizzle-telemetry");
+}
+function runTelemetryMigrations(nativeDb, db) {
+  const migrationsFolder = resolveTelemetryMigrationsFolder();
+  reconcileJournal(nativeDb, migrationsFolder, "telemetry_events", "telemetry");
+  migrateWithRetry(db, migrationsFolder, nativeDb, "telemetry_events", "telemetry");
+  ensureColumns(
+    nativeDb,
+    "telemetry_events",
+    [
+      { name: "anonymous_id", ddl: "text NOT NULL DEFAULT ''" },
+      { name: "domain", ddl: "text NOT NULL DEFAULT ''" },
+      { name: "gateway", ddl: "text NOT NULL DEFAULT 'query'" },
+      { name: "operation", ddl: "text NOT NULL DEFAULT ''" },
+      { name: "command", ddl: "text NOT NULL DEFAULT ''" },
+      { name: "exit_code", ddl: "integer NOT NULL DEFAULT 0" },
+      { name: "duration_ms", ddl: "integer NOT NULL DEFAULT 0" },
+      { name: "error_code", ddl: "text" }
+    ],
+    "telemetry"
+  );
+}
+function resetTelemetryDbState() {
+  try {
+    _nativeDb3?.close();
+  } catch {
+  }
+  _db3 = null;
+  _nativeDb3 = null;
+  _dbPath3 = null;
+  _initPromise3 = null;
+}
+async function getTelemetryDb() {
+  const requestedPath = getTelemetryDbPath();
+  if (_db3 && _dbPath3 !== requestedPath) {
+    resetTelemetryDbState();
+  }
+  if (_db3) return _db3;
+  if (_initPromise3) return _initPromise3;
+  _initPromise3 = (async () => {
+    const dbPath = requestedPath;
+    _dbPath3 = dbPath;
+    mkdirSync23(dirname20(dbPath), { recursive: true });
+    const nativeDb = openNativeDatabase(dbPath);
+    _nativeDb3 = nativeDb;
+    const db = drizzle({ client: nativeDb, schema: schema_exports });
+    runTelemetryMigrations(nativeDb, db);
+    nativeDb.prepare(
+      `INSERT OR IGNORE INTO telemetry_schema_meta (key, value) VALUES ('schemaVersion', '${TELEMETRY_SCHEMA_VERSION}')`
+    ).run();
+    _db3 = db;
+    return db;
+  })();
+  return _initPromise3;
+}
+
+// packages/core/src/telemetry/index.ts
+var TELEMETRY_CONFIG_FILENAME = "telemetry-config.json";
+function getTelemetryConfigPath() {
+  return join99(getCleoHome(), TELEMETRY_CONFIG_FILENAME);
+}
+function loadTelemetryConfig() {
+  const path4 = getTelemetryConfigPath();
+  if (!existsSync96(path4)) {
+    return { enabled: false, anonymousId: "" };
+  }
+  try {
+    return JSON.parse(readFileSync68(path4, "utf-8"));
+  } catch {
+    return { enabled: false, anonymousId: "" };
+  }
+}
+function saveTelemetryConfig(config2) {
+  const path4 = getTelemetryConfigPath();
+  mkdirSync24(join99(path4, ".."), { recursive: true });
+  writeFileSync16(path4, JSON.stringify(config2, null, 2), "utf-8");
+}
+function isTelemetryEnabled() {
+  return loadTelemetryConfig().enabled;
+}
+function enableTelemetry() {
+  const existing = loadTelemetryConfig();
+  const config2 = {
+    enabled: true,
+    anonymousId: existing.anonymousId || randomUUID7()
+  };
+  saveTelemetryConfig(config2);
+  return config2;
+}
+function disableTelemetry() {
+  const existing = loadTelemetryConfig();
+  const config2 = { ...existing, enabled: false };
+  saveTelemetryConfig(config2);
+  return config2;
+}
+async function recordTelemetryEvent(event) {
+  const config2 = loadTelemetryConfig();
+  if (!config2.enabled || !config2.anonymousId) return;
+  try {
+    const db = await getTelemetryDb();
+    const command = `${event.domain}.${event.operation}`;
+    await db.insert(telemetryEvents).values({
+      id: randomUUID7(),
+      anonymousId: config2.anonymousId,
+      domain: event.domain,
+      gateway: event.gateway,
+      operation: event.operation,
+      command,
+      exitCode: event.exitCode,
+      durationMs: event.durationMs,
+      errorCode: event.errorCode ?? null,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }).run();
+  } catch {
+  }
+}
+function daysAgo(n) {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() - n);
+  return d.toISOString();
+}
+async function buildDiagnosticsReport(days = 30) {
+  const config2 = loadTelemetryConfig();
+  if (!config2.enabled) return null;
+  const db = await getTelemetryDb();
+  const from = daysAgo(days);
+  const to = (/* @__PURE__ */ new Date()).toISOString();
+  const [totalRow] = await db.select({ n: count2(telemetryEvents.id) }).from(telemetryEvents).where(gt2(telemetryEvents.timestamp, from)).all();
+  const totalEvents = totalRow?.n ?? 0;
+  if (totalEvents === 0)
+    return {
+      period: { from, to },
+      totalEvents: 0,
+      topFailing: [],
+      topSlow: [],
+      rareCommands: [],
+      observations: []
+    };
+  const rows = await db.select({
+    command: telemetryEvents.command,
+    total: count2(telemetryEvents.id),
+    failures: sql13`SUM(CASE WHEN ${telemetryEvents.exitCode} != 0 THEN 1 ELSE 0 END)`,
+    avgMs: sql13`AVG(${telemetryEvents.durationMs})`,
+    maxMs: sql13`MAX(${telemetryEvents.durationMs})`
+  }).from(telemetryEvents).where(gt2(telemetryEvents.timestamp, from)).groupBy(telemetryEvents.command).all();
+  const errorCodeRows = await db.select({
+    command: telemetryEvents.command,
+    errorCode: telemetryEvents.errorCode,
+    n: count2(telemetryEvents.id)
+  }).from(telemetryEvents).where(and10(gt2(telemetryEvents.timestamp, from), sql13`${telemetryEvents.errorCode} IS NOT NULL`)).groupBy(telemetryEvents.command, telemetryEvents.errorCode).orderBy(desc5(count2(telemetryEvents.id))).all();
+  const topErrorMap = /* @__PURE__ */ new Map();
+  for (const r of errorCodeRows) {
+    if (!topErrorMap.has(r.command)) {
+      topErrorMap.set(r.command, r.errorCode ?? "");
+    }
+  }
+  const stats2 = rows.map((r) => {
+    const failures = Number(r.failures) || 0;
+    const total = Number(r.total) || 0;
+    return {
+      command: r.command,
+      count: total,
+      failureCount: failures,
+      failureRate: total > 0 ? failures / total : 0,
+      avgDurationMs: Math.round(Number(r.avgMs) || 0),
+      maxDurationMs: Math.round(Number(r.maxMs) || 0),
+      topErrorCode: topErrorMap.get(r.command) ?? null
+    };
+  });
+  const topFailing = stats2.filter((s) => s.count >= 5 && s.failureRate > 0).sort((a, b) => b.failureRate - a.failureRate).slice(0, 10);
+  const topSlow = [...stats2].sort((a, b) => b.avgDurationMs - a.avgDurationMs).slice(0, 10);
+  const rareCommands = stats2.filter((s) => s.count === 1).map((s) => s.command);
+  const observations = [];
+  for (const s of topFailing.slice(0, 5)) {
+    const pct = Math.round(s.failureRate * 100);
+    const errPart = s.topErrorCode ? ` (most common error: ${s.topErrorCode})` : "";
+    observations.push(
+      `Command '${s.command}' fails ${pct}% of the time across ${s.count} invocations${errPart}. Investigate root cause.`
+    );
+  }
+  const sortedAvg = stats2.map((s) => s.avgDurationMs).sort((a, b) => a - b);
+  const median = sortedAvg[Math.floor(sortedAvg.length / 2)] ?? 0;
+  for (const s of topSlow.slice(0, 5)) {
+    if (median > 0 && s.avgDurationMs > median * 2) {
+      observations.push(
+        `Command '${s.command}' averages ${s.avgDurationMs}ms \u2014 ${Math.round(s.avgDurationMs / median)}x slower than the ${median}ms median. Profile for performance improvement.`
+      );
+    }
+  }
+  return { period: { from, to }, totalEvents, topFailing, topSlow, rareCommands, observations };
+}
+async function exportTelemetryEvents(days) {
+  const config2 = loadTelemetryConfig();
+  if (!config2.enabled) return [];
+  const db = await getTelemetryDb();
+  const rows = days ? await db.select().from(telemetryEvents).where(gt2(telemetryEvents.timestamp, daysAgo(days))).orderBy(desc5(telemetryEvents.timestamp)).all() : await db.select().from(telemetryEvents).orderBy(desc5(telemetryEvents.timestamp)).all();
+  return rows.map((r) => ({
+    domain: r.domain,
+    gateway: r.gateway,
+    operation: r.operation,
+    durationMs: r.durationMs,
+    exitCode: r.exitCode,
+    errorCode: r.errorCode
+  }));
+}
+
 // packages/core/src/templates/index.ts
 var templates_exports = {};
 __export(templates_exports, {
@@ -79089,8 +79456,8 @@ __export(templates_exports, {
 
 // packages/core/src/templates/parser.ts
 init_platform();
-import { existsSync as existsSync96, readdirSync as readdirSync30, readFileSync as readFileSync68 } from "fs";
-import { join as join98 } from "path";
+import { existsSync as existsSync97, readdirSync as readdirSync30, readFileSync as readFileSync69 } from "fs";
+import { join as join100 } from "path";
 import { parse as parseYaml } from "yaml";
 var SUFFIX_PATTERNS = ["_report", "_request", "_question"];
 function deriveSubcommand(filename) {
@@ -79105,8 +79472,8 @@ function deriveSubcommand(filename) {
   return firstWord.toLowerCase();
 }
 function parseTemplateFile2(templateDir, filename) {
-  const filePath = join98(templateDir, filename);
-  const raw = readFileSync68(filePath, "utf-8");
+  const filePath = join100(templateDir, filename);
+  const raw = readFileSync69(filePath, "utf-8");
   const parsed = parseYaml(raw);
   const name2 = typeof parsed.name === "string" ? parsed.name : filename;
   const titlePrefix = typeof parsed.title === "string" ? parsed.title : "";
@@ -79155,8 +79522,8 @@ function parseTemplateFile2(templateDir, filename) {
   };
 }
 function parseIssueTemplates2(projectRoot) {
-  const templateDir = join98(projectRoot, ".github", "ISSUE_TEMPLATE");
-  if (!existsSync96(templateDir)) {
+  const templateDir = join100(projectRoot, ".github", "ISSUE_TEMPLATE");
+  if (!existsSync97(templateDir)) {
     return {
       success: false,
       error: { code: "E_NOT_FOUND", message: `Issue template directory not found: ${templateDir}` }
@@ -79303,9 +79670,9 @@ __export(ui_exports, {
 });
 
 // packages/core/src/ui/aliases.ts
-import { existsSync as existsSync97, readFileSync as readFileSync69, writeFileSync as writeFileSync16 } from "node:fs";
+import { existsSync as existsSync98, readFileSync as readFileSync70, writeFileSync as writeFileSync17 } from "node:fs";
 import { homedir as homedir6, platform as platform3 } from "node:os";
-import { join as join99 } from "node:path";
+import { join as join101 } from "node:path";
 var MARKER_START = "# CLEO-CLAUDE-ALIASES:START";
 var MARKER_END = "# CLEO-CLAUDE-ALIASES:END";
 var ALIASES_VERSION = "1.0.0";
@@ -79327,22 +79694,22 @@ function getRcFilePath(shell) {
   const sh = shell ?? getCurrentShell();
   switch (sh) {
     case "bash":
-      return join99(home, ".bashrc");
+      return join101(home, ".bashrc");
     case "zsh":
-      return join99(home, ".zshrc");
+      return join101(home, ".zshrc");
     case "powershell":
-      return join99(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
+      return join101(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
     case "cmd":
       return "";
     // CMD doesn't have a standard RC
     default:
-      return join99(home, ".bashrc");
+      return join101(home, ".bashrc");
   }
 }
 function detectAvailableShells() {
   const shells = [];
-  if (existsSync97(getRcFilePath("bash")) || existsSync97("/bin/bash")) shells.push("bash");
-  if (existsSync97(getRcFilePath("zsh")) || existsSync97("/bin/zsh")) shells.push("zsh");
+  if (existsSync98(getRcFilePath("bash")) || existsSync98("/bin/bash")) shells.push("bash");
+  if (existsSync98(getRcFilePath("zsh")) || existsSync98("/bin/zsh")) shells.push("zsh");
   if (platform3() === "win32") shells.push("powershell");
   return shells;
 }
@@ -79374,47 +79741,47 @@ function generatePowershellAliases(cleoPath) {
   ].join("\n");
 }
 function hasAliasBlock(filePath) {
-  if (!existsSync97(filePath)) return false;
-  const content = readFileSync69(filePath, "utf-8");
+  if (!existsSync98(filePath)) return false;
+  const content = readFileSync70(filePath, "utf-8");
   return content.includes(MARKER_START) && content.includes(MARKER_END);
 }
 function getInstalledVersion(filePath) {
-  if (!existsSync97(filePath)) return null;
-  const content = readFileSync69(filePath, "utf-8");
+  if (!existsSync98(filePath)) return null;
+  const content = readFileSync70(filePath, "utf-8");
   const match = content.match(/CLEO CLI aliases \(v([^)]+)\)/);
   return match?.[1] ?? null;
 }
 function injectAliases(filePath, shell = "bash", cleoPath) {
   const content = shell === "powershell" ? generatePowershellAliases(cleoPath) : generateBashAliases(cleoPath);
-  if (!existsSync97(filePath)) {
-    writeFileSync16(filePath, content + "\n", "utf-8");
+  if (!existsSync98(filePath)) {
+    writeFileSync17(filePath, content + "\n", "utf-8");
     return { action: "created", version: ALIASES_VERSION };
   }
-  const existing = readFileSync69(filePath, "utf-8");
+  const existing = readFileSync70(filePath, "utf-8");
   if (hasAliasBlock(filePath)) {
     const startIdx = existing.indexOf(MARKER_START);
     const endIdx = existing.indexOf(MARKER_END) + MARKER_END.length;
     const updated = existing.slice(0, startIdx) + content + existing.slice(endIdx);
-    writeFileSync16(filePath, updated, "utf-8");
+    writeFileSync17(filePath, updated, "utf-8");
     return { action: "updated", version: ALIASES_VERSION };
   }
-  writeFileSync16(filePath, existing + "\n" + content + "\n", "utf-8");
+  writeFileSync17(filePath, existing + "\n" + content + "\n", "utf-8");
   return { action: "added", version: ALIASES_VERSION };
 }
 function removeAliases(filePath) {
-  if (!existsSync97(filePath) || !hasAliasBlock(filePath)) return false;
-  const existing = readFileSync69(filePath, "utf-8");
+  if (!existsSync98(filePath) || !hasAliasBlock(filePath)) return false;
+  const existing = readFileSync70(filePath, "utf-8");
   const startIdx = existing.indexOf(MARKER_START);
   const endIdx = existing.indexOf(MARKER_END) + MARKER_END.length;
   const before = existing.slice(0, startIdx).replace(/\n+$/, "\n");
   const after = existing.slice(endIdx).replace(/^\n+/, "\n");
-  writeFileSync16(filePath, before + after, "utf-8");
+  writeFileSync17(filePath, before + after, "utf-8");
   return true;
 }
 function checkAliasesStatus(shell) {
   const sh = shell ?? getCurrentShell();
   const rcFile = getRcFilePath(sh);
-  if (!rcFile || !existsSync97(rcFile)) {
+  if (!rcFile || !existsSync98(rcFile)) {
     return { shell: sh, rcFile, installed: false, version: null, needsUpdate: false };
   }
   const installed = hasAliasBlock(rcFile);
@@ -79425,7 +79792,7 @@ function checkAliasesStatus(shell) {
 
 // packages/core/src/ui/changelog.ts
 init_data_accessor();
-import { appendFileSync as appendFileSync9, existsSync as existsSync98, readFileSync as readFileSync70, writeFileSync as writeFileSync17 } from "node:fs";
+import { appendFileSync as appendFileSync9, existsSync as existsSync99, readFileSync as readFileSync71, writeFileSync as writeFileSync18 } from "node:fs";
 var LABEL_CATEGORIES = {
   feature: "Features",
   feat: "Features",
@@ -79526,21 +79893,21 @@ function formatChangelogJson(version2, date6, sections) {
   };
 }
 function writeChangelogFile(filePath, content) {
-  writeFileSync17(filePath, content, "utf-8");
+  writeFileSync18(filePath, content, "utf-8");
 }
 function appendToChangelog(filePath, newContent) {
-  if (!existsSync98(filePath)) {
-    writeFileSync17(filePath, `# Changelog
+  if (!existsSync99(filePath)) {
+    writeFileSync18(filePath, `# Changelog
 
 ${newContent}`, "utf-8");
     return;
   }
-  const existing = readFileSync70(filePath, "utf-8");
+  const existing = readFileSync71(filePath, "utf-8");
   const headerMatch = existing.match(/^# .+\n/m);
   if (headerMatch) {
     const insertPos = (headerMatch.index ?? 0) + headerMatch[0].length;
     const updated = existing.slice(0, insertPos) + "\n" + newContent + existing.slice(insertPos);
-    writeFileSync17(filePath, updated, "utf-8");
+    writeFileSync18(filePath, updated, "utf-8");
   } else {
     appendFileSync9(filePath, "\n" + newContent);
   }
@@ -79575,13 +79942,13 @@ ${markdown}`);
 }
 
 // packages/core/src/ui/command-registry.ts
-import { existsSync as existsSync99, readdirSync as readdirSync31, readFileSync as readFileSync71 } from "node:fs";
-import { basename as basename16, join as join100 } from "node:path";
+import { existsSync as existsSync100, readdirSync as readdirSync31, readFileSync as readFileSync72 } from "node:fs";
+import { basename as basename16, join as join102 } from "node:path";
 var CLEO_HEADER_START = "###CLEO";
 var CLEO_HEADER_END = "###END";
 function parseCommandHeader(scriptPath) {
-  if (!existsSync99(scriptPath)) return null;
-  const content = readFileSync71(scriptPath, "utf-8");
+  if (!existsSync100(scriptPath)) return null;
+  const content = readFileSync72(scriptPath, "utf-8");
   const lines = content.split("\n");
   let inHeader = false;
   const headerLines = [];
@@ -79659,10 +80026,10 @@ function parseCommandHeader(scriptPath) {
 }
 function scanAllCommands(scriptsDir) {
   const registry2 = /* @__PURE__ */ new Map();
-  if (!existsSync99(scriptsDir)) return registry2;
+  if (!existsSync100(scriptsDir)) return registry2;
   for (const file2 of readdirSync31(scriptsDir)) {
     if (!file2.endsWith(".sh") && !file2.endsWith(".ts")) continue;
-    const meta3 = parseCommandHeader(join100(scriptsDir, file2));
+    const meta3 = parseCommandHeader(join102(scriptsDir, file2));
     if (meta3) {
       registry2.set(meta3.command, meta3);
     }
@@ -80605,10 +80972,10 @@ function calculateOrchestrationOverhead(orchestratorTokens, totalSubagentTokens,
 }
 
 // packages/core/src/validation/docs-sync.ts
-import { existsSync as existsSync100, readdirSync as readdirSync32, readFileSync as readFileSync72 } from "node:fs";
-import { join as join101 } from "node:path";
+import { existsSync as existsSync101, readdirSync as readdirSync32, readFileSync as readFileSync73 } from "node:fs";
+import { join as join103 } from "node:path";
 function getScriptCommands(scriptsDir) {
-  if (!existsSync100(scriptsDir)) return [];
+  if (!existsSync101(scriptsDir)) return [];
   try {
     return readdirSync32(scriptsDir).filter((f) => f.endsWith(".sh")).map((f) => f.replace(/\.sh$/, "")).sort();
   } catch {
@@ -80616,9 +80983,9 @@ function getScriptCommands(scriptsDir) {
   }
 }
 function getIndexScripts(indexPath) {
-  if (!existsSync100(indexPath)) return [];
+  if (!existsSync101(indexPath)) return [];
   try {
-    const content = readFileSync72(indexPath, "utf-8");
+    const content = readFileSync73(indexPath, "utf-8");
     const index2 = JSON.parse(content);
     return index2.commands.map((cmd) => cmd.script ?? "").filter((s) => s).map((s) => s.replace(/\.sh$/, "")).sort();
   } catch {
@@ -80626,9 +80993,9 @@ function getIndexScripts(indexPath) {
   }
 }
 function getIndexCommands(indexPath) {
-  if (!existsSync100(indexPath)) return [];
+  if (!existsSync101(indexPath)) return [];
   try {
-    const content = readFileSync72(indexPath, "utf-8");
+    const content = readFileSync73(indexPath, "utf-8");
     const index2 = JSON.parse(content);
     return index2.commands.map((cmd) => cmd.name).sort();
   } catch {
@@ -80662,11 +81029,11 @@ function checkCommandsSync(scriptsDir, indexPath) {
   return issues;
 }
 function checkWrapperSync(wrapperPath, indexPath) {
-  if (!existsSync100(wrapperPath) || !existsSync100(indexPath)) return [];
+  if (!existsSync101(wrapperPath) || !existsSync101(indexPath)) return [];
   const issues = [];
   try {
-    const wrapperContent = readFileSync72(wrapperPath, "utf-8");
-    const indexContent = readFileSync72(indexPath, "utf-8");
+    const wrapperContent = readFileSync73(wrapperPath, "utf-8");
+    const indexContent = readFileSync73(indexPath, "utf-8");
     const index2 = JSON.parse(indexContent);
     const match = wrapperContent.match(/_get_all_commands\(\)\s*\{[^}]*echo\s+"([^"]+)"/);
     const wrapperCmds = new Set(match ? match[1].split(/\s+/).filter(Boolean) : []);
@@ -80699,16 +81066,16 @@ var CRITICAL_COMMANDS = [
 ];
 function detectDrift(mode = "full", projectRoot = ".") {
   const issues = [];
-  const scriptsDir = join101(projectRoot, "scripts");
-  const indexPath = join101(projectRoot, "docs/commands/COMMANDS-INDEX.json");
+  const scriptsDir = join103(projectRoot, "scripts");
+  const indexPath = join103(projectRoot, "docs/commands/COMMANDS-INDEX.json");
   issues.push(...checkCommandsSync(scriptsDir, indexPath));
-  const wrapperPath = join101(projectRoot, "installer/lib/link.sh");
+  const wrapperPath = join103(projectRoot, "installer/lib/link.sh");
   issues.push(...checkWrapperSync(wrapperPath, indexPath));
   if (mode === "full") {
-    const readmePath = join101(projectRoot, "README.md");
-    if (existsSync100(readmePath)) {
+    const readmePath = join103(projectRoot, "README.md");
+    if (existsSync101(readmePath)) {
       try {
-        const readme = readFileSync72(readmePath, "utf-8");
+        const readme = readFileSync73(readmePath, "utf-8");
         const readmeCmds = new Set(
           (readme.match(/cleo [a-z-]+/g) ?? []).map((m) => m.replace("cleo ", ""))
         );
@@ -80742,14 +81109,14 @@ function shouldRunDriftDetection(enabled = true, autoCheck = false, command, cri
 // packages/core/src/validation/doctor/project-cache.ts
 init_paths();
 import { createHash as createHash12 } from "node:crypto";
-import { existsSync as existsSync101, mkdirSync as mkdirSync23, readFileSync as readFileSync73, unlinkSync as unlinkSync8, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname20, join as join102 } from "node:path";
+import { existsSync as existsSync102, mkdirSync as mkdirSync25, readFileSync as readFileSync74, unlinkSync as unlinkSync8, writeFileSync as writeFileSync19 } from "node:fs";
+import { dirname as dirname21, join as join104 } from "node:path";
 var CACHE_VERSION = "1.0.0";
 var CACHE_TTL_SECONDS = 300;
 var CACHE_FILE2 = "doctor-project-cache.json";
 function getCacheFilePath(cleoHome) {
   const home = cleoHome ?? getCleoHome();
-  return join102(home, CACHE_FILE2);
+  return join104(home, CACHE_FILE2);
 }
 function initCacheFile(cacheFile) {
   const cache = {
@@ -80757,26 +81124,26 @@ function initCacheFile(cacheFile) {
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
     projects: {}
   };
-  const dir = dirname20(cacheFile);
-  if (!existsSync101(dir)) {
-    mkdirSync23(dir, { recursive: true });
+  const dir = dirname21(cacheFile);
+  if (!existsSync102(dir)) {
+    mkdirSync25(dir, { recursive: true });
   }
-  writeFileSync18(cacheFile, JSON.stringify(cache, null, 2));
+  writeFileSync19(cacheFile, JSON.stringify(cache, null, 2));
   return cache;
 }
 function loadCache(cacheFile) {
-  if (!existsSync101(cacheFile)) return null;
+  if (!existsSync102(cacheFile)) return null;
   try {
-    const content = readFileSync73(cacheFile, "utf-8");
+    const content = readFileSync74(cacheFile, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function getFileHash(filePath) {
-  if (!existsSync101(filePath)) return "";
+  if (!existsSync102(filePath)) return "";
   try {
-    const content = readFileSync73(filePath);
+    const content = readFileSync74(filePath);
     return createHash12("sha256").update(content).digest("hex");
   } catch {
     return "";
@@ -80793,8 +81160,8 @@ function getCachedValidation(projectHash, projectPath, cacheFile) {
   const now = Date.now();
   const age = (now - lastValidated) / 1e3;
   if (age > (entry.ttl || CACHE_TTL_SECONDS)) return null;
-  const currentTasksDbHash = getFileHash(join102(projectPath, ".cleo", "tasks.db"));
-  const currentConfigHash = getFileHash(join102(projectPath, ".cleo", "config.json"));
+  const currentTasksDbHash = getFileHash(join104(projectPath, ".cleo", "tasks.db"));
+  const currentConfigHash = getFileHash(join104(projectPath, ".cleo", "config.json"));
   if (currentTasksDbHash !== (entry.fileHashes["tasks.db"] ?? "")) return null;
   if (currentConfigHash !== (entry.fileHashes["config.json"] ?? "")) return null;
   return entry;
@@ -80805,8 +81172,8 @@ function cacheValidationResult(projectHash, projectPath, validationStatus, issue
   if (!cache) {
     cache = initCacheFile(cachePath);
   }
-  const tasksDbHash = getFileHash(join102(projectPath, ".cleo", "tasks.db"));
-  const configHash = getFileHash(join102(projectPath, ".cleo", "config.json"));
+  const tasksDbHash = getFileHash(join104(projectPath, ".cleo", "tasks.db"));
+  const configHash = getFileHash(join104(projectPath, ".cleo", "config.json"));
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
   cache.projects[projectHash] = {
     path: projectPath,
@@ -80821,18 +81188,18 @@ function cacheValidationResult(projectHash, projectPath, validationStatus, issue
     ttl: CACHE_TTL_SECONDS
   };
   cache.lastUpdated = timestamp2;
-  writeFileSync18(cachePath, JSON.stringify(cache, null, 2));
+  writeFileSync19(cachePath, JSON.stringify(cache, null, 2));
 }
 function clearProjectCache(projectHash, cacheFile) {
   const cachePath = cacheFile ?? getCacheFilePath();
   const cache = loadCache(cachePath);
   if (!cache) return;
   delete cache.projects[projectHash];
-  writeFileSync18(cachePath, JSON.stringify(cache, null, 2));
+  writeFileSync19(cachePath, JSON.stringify(cache, null, 2));
 }
 function clearEntireCache(cacheFile) {
   const cachePath = cacheFile ?? getCacheFilePath();
-  if (existsSync101(cachePath)) {
+  if (existsSync102(cachePath)) {
     unlinkSync8(cachePath);
   }
   initCacheFile(cachePath);
@@ -81101,15 +81468,15 @@ function validateTitle2(title) {
   }
   return { valid: errors.length === 0, errors, warnings };
 }
-function validateDescription(desc5) {
-  if (!desc5) return { valid: true, errors: [], warnings: [] };
-  if (desc5.length > FIELD_LIMITS.MAX_DESCRIPTION_LENGTH) {
+function validateDescription(desc6) {
+  if (!desc6) return { valid: true, errors: [], warnings: [] };
+  if (desc6.length > FIELD_LIMITS.MAX_DESCRIPTION_LENGTH) {
     return {
       valid: false,
       errors: [
         {
           field: "description",
-          message: `Description exceeds ${FIELD_LIMITS.MAX_DESCRIPTION_LENGTH} characters (${desc5.length} provided)`,
+          message: `Description exceeds ${FIELD_LIMITS.MAX_DESCRIPTION_LENGTH} characters (${desc6.length} provided)`,
           severity: "error"
         }
       ],
@@ -81818,9 +82185,9 @@ function formatGapReport(report) {
 
 // packages/core/src/validation/manifest.ts
 init_paths();
-import { existsSync as existsSync102 } from "node:fs";
+import { existsSync as existsSync103 } from "node:fs";
 import { appendFile as appendFile3, mkdir as mkdir15, readFile as readFile18 } from "node:fs/promises";
-import { dirname as dirname21 } from "node:path";
+import { dirname as dirname22 } from "node:path";
 var DEFAULT_MANIFEST_PATH = ".cleo/agent-outputs/MANIFEST.jsonl";
 var DEFAULT_COMPLIANCE_PATH = ".cleo/metrics/COMPLIANCE.jsonl";
 async function findManifestEntry(taskId, manifestPath) {
@@ -81831,7 +82198,7 @@ async function findManifestEntry(taskId, manifestPath) {
       manifestPath = DEFAULT_MANIFEST_PATH;
     }
   }
-  if (!existsSync102(manifestPath)) return null;
+  if (!existsSync103(manifestPath)) return null;
   const content = await readFile18(manifestPath, "utf-8");
   const lines = content.split("\n").filter((l) => l.trim());
   for (let i = lines.length - 1; i >= 0; i--) {
@@ -81943,7 +82310,7 @@ async function validateManifestEntry(taskId, manifestEntry, manifestPath = DEFAU
   };
 }
 async function logRealCompliance(taskId, validationResult, agentType = "unknown", compliancePath = DEFAULT_COMPLIANCE_PATH) {
-  const metricsDir = dirname21(compliancePath);
+  const metricsDir = dirname22(compliancePath);
   await mkdir15(metricsDir, { recursive: true });
   const { score, pass, violations } = validationResult;
   const violationCount = violations.length;
@@ -82003,9 +82370,9 @@ async function validateAndLog(taskId, manifestPath = DEFAULT_MANIFEST_PATH, comp
 
 // packages/core/src/validation/protocol-common.ts
 init_src();
-import { existsSync as existsSync103, readdirSync as readdirSync33, readFileSync as readFileSync74 } from "node:fs";
+import { existsSync as existsSync104, readdirSync as readdirSync33, readFileSync as readFileSync75 } from "node:fs";
 function checkOutputFileExists(taskId, expectedDir, pattern) {
-  if (!existsSync103(expectedDir)) return false;
+  if (!existsSync104(expectedDir)) return false;
   const filePattern = pattern ?? `${taskId}`;
   try {
     const files = readdirSync33(expectedDir);
@@ -82015,9 +82382,9 @@ function checkOutputFileExists(taskId, expectedDir, pattern) {
   }
 }
 function checkDocumentationSections(filePath, sections) {
-  if (!existsSync103(filePath)) return false;
+  if (!existsSync104(filePath)) return false;
   try {
-    const content = readFileSync74(filePath, "utf-8");
+    const content = readFileSync75(filePath, "utf-8");
     return sections.every((section) => {
       const regex = new RegExp(`^#+ .*${escapeRegex3(section)}`, "m");
       return regex.test(content);
@@ -82110,9 +82477,9 @@ function checkLinkedTasksPresent(entry, requiredIds) {
   return requiredIds.every((id) => linkedTasks.includes(id));
 }
 function checkProvenanceTags(filePath, taskId) {
-  if (!existsSync103(filePath)) return false;
+  if (!existsSync104(filePath)) return false;
   try {
-    const content = readFileSync74(filePath, "utf-8");
+    const content = readFileSync75(filePath, "utf-8");
     if (taskId) {
       return content.includes(`@task ${taskId}`);
     }
@@ -82771,17 +83138,17 @@ init_logger();
 
 // packages/core/src/output.ts
 init_errors3();
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 
 // packages/core/src/sessions/context-alert.ts
 init_paths();
-import { existsSync as existsSync106, readFileSync as readFileSync76, writeFileSync as writeFileSync19 } from "node:fs";
-import { join as join105 } from "node:path";
+import { existsSync as existsSync107, readFileSync as readFileSync77, writeFileSync as writeFileSync20 } from "node:fs";
+import { join as join107 } from "node:path";
 function getCurrentSessionId(cwd) {
   if (process.env.CLEO_SESSION) return process.env.CLEO_SESSION;
-  const sessionFile = join105(getCleoDir(cwd), ".current-session");
-  if (existsSync106(sessionFile)) {
-    return readFileSync76(sessionFile, "utf-8").trim() || null;
+  const sessionFile = join107(getCleoDir(cwd), ".current-session");
+  if (existsSync107(sessionFile)) {
+    return readFileSync77(sessionFile, "utf-8").trim() || null;
   }
   return null;
 }
@@ -82801,7 +83168,7 @@ function createCliMeta(operation, duration_ms = 0) {
   const warnings = drainWarnings();
   const meta3 = {
     operation,
-    requestId: randomUUID7(),
+    requestId: randomUUID8(),
     duration_ms,
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -82864,10 +83231,10 @@ init_adapters();
 // packages/core/src/bootstrap.ts
 init_paths();
 init_scaffold();
-import { existsSync as existsSync107, readFileSync as readFileSync77 } from "node:fs";
+import { existsSync as existsSync108, readFileSync as readFileSync78 } from "node:fs";
 import { mkdir as mkdir17, readFile as readFile20, writeFile as writeFile12 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { join as join106 } from "node:path";
+import { join as join108 } from "node:path";
 async function bootstrapGlobalCleo(options) {
   const ctx = {
     created: [],
@@ -82888,8 +83255,8 @@ async function bootstrapGlobalCleo(options) {
 }
 async function writeTemplateTo(content, destPath, isDryRun) {
   if (isDryRun) return false;
-  const { dirname: dirname23 } = await import("node:path");
-  await mkdir17(dirname23(destPath), { recursive: true });
+  const { dirname: dirname24 } = await import("node:path");
+  await mkdir17(dirname24(destPath), { recursive: true });
   await writeFile12(destPath, content);
   return true;
 }
@@ -82901,9 +83268,9 @@ async function ensureGlobalTemplatesBootstrap(ctx, packageRootOverride) {
   let templateContent = null;
   try {
     const pkgRoot = packageRootOverride ?? getPackageRoot();
-    const templatePath = join106(pkgRoot, "templates", "CLEO-INJECTION.md");
-    if (existsSync107(templatePath)) {
-      templateContent = readFileSync77(templatePath, "utf-8");
+    const templatePath = join108(pkgRoot, "templates", "CLEO-INJECTION.md");
+    if (existsSync108(templatePath)) {
+      templateContent = readFileSync78(templatePath, "utf-8");
     }
   } catch {
   }
@@ -82920,15 +83287,15 @@ async function ensureGlobalTemplatesBootstrap(ctx, packageRootOverride) {
     ctx.warnings.push("Could not refresh CLEO-INJECTION.md template");
     return;
   }
-  const xdgDest = join106(globalTemplatesDir, "CLEO-INJECTION.md");
+  const xdgDest = join108(globalTemplatesDir, "CLEO-INJECTION.md");
   const xdgWritten = await writeTemplateTo(templateContent, xdgDest, ctx.isDryRun);
   ctx.created.push(
     `${getCleoTemplatesTildePath()}/CLEO-INJECTION.md (${xdgWritten ? "refreshed" : "would refresh"})`
   );
   const home = homedir7();
-  const legacyTemplatesDir = join106(home, ".cleo", "templates");
-  if (legacyTemplatesDir !== globalTemplatesDir && existsSync107(join106(home, ".cleo"))) {
-    const legacyDest = join106(legacyTemplatesDir, "CLEO-INJECTION.md");
+  const legacyTemplatesDir = join108(home, ".cleo", "templates");
+  if (legacyTemplatesDir !== globalTemplatesDir && existsSync108(join108(home, ".cleo"))) {
+    const legacyDest = join108(legacyTemplatesDir, "CLEO-INJECTION.md");
     const legacyWritten = await writeTemplateTo(templateContent, legacyDest, ctx.isDryRun);
     if (legacyWritten) {
       ctx.created.push("~/.cleo/templates/CLEO-INJECTION.md (legacy sync)");
@@ -82947,12 +83314,12 @@ function sanitizeCaampFile(content) {
 }
 async function injectAgentsHub(ctx) {
   const globalAgentsDir = getAgentsHome();
-  const globalAgentsMd = join106(globalAgentsDir, "AGENTS.md");
+  const globalAgentsMd = join108(globalAgentsDir, "AGENTS.md");
   try {
     const { inject: inject2, getInstalledProviders: getInstalledProviders3, injectAll: injectAll2, buildInjectionContent } = await import("@cleocode/caamp");
     if (!ctx.isDryRun) {
       await mkdir17(globalAgentsDir, { recursive: true });
-      if (existsSync107(globalAgentsMd)) {
+      if (existsSync108(globalAgentsMd)) {
         const content = await readFile20(globalAgentsMd, "utf8");
         const stripped = content.replace(
           /\n?<!-- CLEO:START[^>]*-->[\s\S]*?<!-- CLEO:END -->\n?/g,
@@ -82987,8 +83354,8 @@ async function injectAgentsHub(ctx) {
       });
       if (!ctx.isDryRun) {
         for (const provider of providers) {
-          const instructFilePath = join106(provider.pathGlobal, provider.instructFile);
-          if (existsSync107(instructFilePath)) {
+          const instructFilePath = join108(provider.pathGlobal, provider.instructFile);
+          if (existsSync108(instructFilePath)) {
             const fileContent = await readFile20(instructFilePath, "utf8");
             const stripped = fileContent.replace(
               /\n?<!-- CLEO:START[^>]*-->[\s\S]*?<!-- CLEO:END -->\n?/g,
@@ -83006,7 +83373,7 @@ async function injectAgentsHub(ctx) {
         }
       } else {
         for (const p of providers) {
-          const displayPath = join106(p.pathGlobal, p.instructFile).replace(homedir7(), "~");
+          const displayPath = join108(p.pathGlobal, p.instructFile).replace(homedir7(), "~");
           ctx.created.push(`${displayPath} (would update CAAMP block)`);
         }
       }
@@ -83080,17 +83447,17 @@ async function installProviderAdapters(ctx, packageRootOverride) {
 async function verifyBootstrapHealth(ctx) {
   if (ctx.isDryRun) return;
   try {
-    const xdgTemplatePath = join106(getCleoTemplatesDir(), "CLEO-INJECTION.md");
-    const agentsMd = join106(getAgentsHome(), "AGENTS.md");
-    if (!existsSync107(xdgTemplatePath)) {
+    const xdgTemplatePath = join108(getCleoTemplatesDir(), "CLEO-INJECTION.md");
+    const agentsMd = join108(getAgentsHome(), "AGENTS.md");
+    if (!existsSync108(xdgTemplatePath)) {
       ctx.warnings.push("Health: XDG template missing after bootstrap");
       return;
     }
     const xdgContent = await readFile20(xdgTemplatePath, "utf8");
     const xdgVersion = xdgContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
     const home = homedir7();
-    const legacyTemplatePath = join106(home, ".cleo", "templates", "CLEO-INJECTION.md");
-    if (existsSync107(legacyTemplatePath)) {
+    const legacyTemplatePath = join108(home, ".cleo", "templates", "CLEO-INJECTION.md");
+    if (existsSync108(legacyTemplatePath)) {
       const legacyContent = await readFile20(legacyTemplatePath, "utf8");
       const legacyVersion = legacyContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
       if (legacyVersion !== xdgVersion) {
@@ -83099,7 +83466,7 @@ async function verifyBootstrapHealth(ctx) {
         );
       }
     }
-    if (existsSync107(agentsMd)) {
+    if (existsSync108(agentsMd)) {
       const agentsContent = await readFile20(agentsMd, "utf8");
       const expectedRef = `@${getCleoTemplatesTildePath()}/CLEO-INJECTION.md`;
       if (!agentsContent.includes(expectedRef)) {
@@ -83183,13 +83550,13 @@ async function serializeSession(projectRoot, options = {}, accessor) {
       const { tasks: tasks2 } = await acc.queryTasks({});
       const task = tasks2.find((t) => t.id === session.taskWork?.taskId);
       if (task) {
-        const desc5 = task.description ?? "";
+        const desc6 = task.description ?? "";
         activeTask = {
           taskId: task.id,
           title: task.title,
           status: task.status,
           priority: task.priority ?? "medium",
-          description: desc5.length > maxDescLen ? desc5.slice(0, maxDescLen) + "..." : desc5,
+          description: desc6.length > maxDescLen ? desc6.slice(0, maxDescLen) + "..." : desc6,
           acceptance: Array.isArray(task.acceptance) ? task.acceptance.join("\n") : task.acceptance ?? void 0
         };
       }
@@ -83820,6 +84187,7 @@ export {
   taskTypeSchema,
   task_work_exports as taskWork,
   tasks_exports as tasks,
+  telemetry_exports as telemetry,
   templates_exports as templates,
   timelineBrain,
   tokenUsageConfidenceSchema,