@cleocode/cleo 2026.3.32 → 2026.3.33

package/dist/cli/index.js

@@ -15285,6 +15285,205 @@ var init_brain_retrieval = __esm({
   }
 });
 
+// src/core/memory/decisions.ts
+import { desc as desc3 } from "drizzle-orm";
+async function nextDecisionId(projectRoot) {
+  const db = await getBrainDb(projectRoot);
+  const rows = await db.select({ id: brainDecisions.id }).from(brainDecisions).orderBy(desc3(brainDecisions.id)).limit(1);
+  if (rows.length === 0) {
+    return "D001";
+  }
+  const lastId = rows[0].id;
+  const num = parseInt(lastId.slice(1), 10);
+  if (Number.isNaN(num)) {
+    return "D001";
+  }
+  return `D${String(num + 1).padStart(3, "0")}`;
+}
+async function storeDecision(projectRoot, params) {
+  if (!params.decision || !params.decision.trim()) {
+    throw new Error("Decision text is required");
+  }
+  if (!params.rationale || !params.rationale.trim()) {
+    throw new Error("Rationale is required");
+  }
+  const accessor = await getBrainAccessor(projectRoot);
+  const existing = await accessor.findDecisions({ type: params.type });
+  const duplicate = existing.find(
+    (d) => d.decision.toLowerCase() === params.decision.toLowerCase()
+  );
+  if (duplicate) {
+    const now2 = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+    await accessor.updateDecision(duplicate.id, {
+      rationale: params.rationale.trim(),
+      confidence: params.confidence,
+      outcome: params.outcome ?? duplicate.outcome,
+      alternativesJson: params.alternatives ? JSON.stringify(params.alternatives) : duplicate.alternativesJson,
+      updatedAt: now2
+    });
+    const updated = await accessor.getDecision(duplicate.id);
+    return updated;
+  }
+  const id = await nextDecisionId(projectRoot);
+  const row = {
+    id,
+    type: params.type,
+    decision: params.decision.trim(),
+    rationale: params.rationale.trim(),
+    confidence: params.confidence,
+    outcome: params.outcome,
+    alternativesJson: params.alternatives ? JSON.stringify(params.alternatives) : void 0,
+    contextEpicId: params.contextEpicId,
+    contextTaskId: params.contextTaskId,
+    contextPhase: params.contextPhase
+  };
+  return accessor.addDecision(row);
+}
+var init_decisions2 = __esm({
+  "src/core/memory/decisions.ts"() {
+    "use strict";
+    init_brain_accessor();
+    init_brain_schema();
+    init_brain_sqlite();
+  }
+});
+
+// src/core/memory/learnings.ts
+import { randomBytes as randomBytes5 } from "node:crypto";
+function generateLearningId() {
+  return `L-${randomBytes5(4).toString("hex")}`;
+}
+async function storeLearning(projectRoot, params) {
+  if (!params.insight || !params.insight.trim()) {
+    throw new Error("Insight text is required");
+  }
+  if (!params.source || !params.source.trim()) {
+    throw new Error("Source is required");
+  }
+  if (params.confidence < 0 || params.confidence > 1) {
+    throw new Error("Confidence must be between 0.0 and 1.0");
+  }
+  const accessor = await getBrainAccessor(projectRoot);
+  const now2 = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  const existingLearnings = await accessor.findLearnings();
+  const duplicate = existingLearnings.find(
+    (e) => e.insight.toLowerCase() === params.insight.toLowerCase()
+  );
+  if (duplicate) {
+  }
+  const entry = {
+    id: generateLearningId(),
+    insight: params.insight.trim(),
+    source: params.source.trim(),
+    confidence: params.confidence,
+    actionable: params.actionable ?? false,
+    application: params.application ?? null,
+    applicableTypesJson: params.applicableTypes ? JSON.stringify(params.applicableTypes) : "[]",
+    extractedAt: now2
+  };
+  const saved = await accessor.addLearning(entry);
+  return {
+    ...saved,
+    applicableTypes: JSON.parse(saved.applicableTypesJson || "[]")
+  };
+}
+async function searchLearnings(projectRoot, params = {}) {
+  const accessor = await getBrainAccessor(projectRoot);
+  let entries = await accessor.findLearnings({
+    minConfidence: params.minConfidence,
+    actionable: params.actionableOnly,
+    limit: params.limit
+  });
+  if (params.applicableType) {
+    entries = entries.filter((e) => {
+      const types = JSON.parse(e.applicableTypesJson || "[]");
+      return types.includes(params.applicableType);
+    });
+  }
+  if (params.query) {
+    const q = params.query.toLowerCase();
+    entries = entries.filter(
+      (e) => e.insight.toLowerCase().includes(q) || e.source.toLowerCase().includes(q) || e.application?.toLowerCase().includes(q)
+    );
+  }
+  entries.sort((a, b) => b.confidence - a.confidence);
+  return entries.map((e) => ({
+    ...e,
+    applicableTypes: JSON.parse(e.applicableTypesJson || "[]")
+  }));
+}
+var init_learnings = __esm({
+  "src/core/memory/learnings.ts"() {
+    "use strict";
+    init_brain_accessor();
+  }
+});
+
+// src/core/memory/patterns.ts
+import { randomBytes as randomBytes6 } from "node:crypto";
+function generatePatternId() {
+  return `P-${randomBytes6(4).toString("hex")}`;
+}
+async function storePattern(projectRoot, params) {
+  if (!params.pattern || !params.pattern.trim()) {
+    throw new Error("Pattern description is required");
+  }
+  if (!params.context || !params.context.trim()) {
+    throw new Error("Pattern context is required");
+  }
+  const accessor = await getBrainAccessor(projectRoot);
+  const existingPatterns = await accessor.findPatterns({ type: params.type });
+  const duplicate = existingPatterns.find(
+    (e) => e.pattern.toLowerCase() === params.pattern.toLowerCase()
+  );
+  const now2 = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  if (duplicate) {
+  }
+  const entry = {
+    id: generatePatternId(),
+    type: params.type,
+    pattern: params.pattern.trim(),
+    context: params.context.trim(),
+    frequency: 1,
+    successRate: params.successRate ?? null,
+    impact: params.impact ?? null,
+    antiPattern: params.antiPattern ?? null,
+    mitigation: params.mitigation ?? null,
+    examplesJson: params.examples ? JSON.stringify(params.examples) : "[]",
+    extractedAt: now2
+  };
+  const saved = await accessor.addPattern(entry);
+  return {
+    ...saved,
+    examples: JSON.parse(saved.examplesJson || "[]")
+  };
+}
+async function searchPatterns(projectRoot, params = {}) {
+  const accessor = await getBrainAccessor(projectRoot);
+  let entries = await accessor.findPatterns({
+    type: params.type,
+    impact: params.impact,
+    minFrequency: params.minFrequency,
+    limit: params.limit
+  });
+  if (params.query) {
+    const q = params.query.toLowerCase();
+    entries = entries.filter(
+      (e) => e.pattern.toLowerCase().includes(q) || e.context.toLowerCase().includes(q) || e.antiPattern?.toLowerCase().includes(q) || e.mitigation?.toLowerCase().includes(q)
+    );
+  }
+  return entries.map((e) => ({
+    ...e,
+    examples: JSON.parse(e.examplesJson || "[]")
+  }));
+}
+var init_patterns = __esm({
+  "src/core/memory/patterns.ts"() {
+    "use strict";
+    init_brain_accessor();
+  }
+});
+
 // src/dispatch/engines/_error.ts
 function logLevel(exitCode) {
   if (exitCode === 0 || exitCode >= 100) return "debug";
@@ -22493,6 +22692,123 @@ var init_session_history = __esm({
   }
 });
 
+// src/core/memory/auto-extract.ts
+var auto_extract_exports = {};
+__export(auto_extract_exports, {
+  extractSessionEndMemory: () => extractSessionEndMemory,
+  extractTaskCompletionMemory: () => extractTaskCompletionMemory,
+  resolveTaskDetails: () => resolveTaskDetails
+});
+async function extractTaskCompletionMemory(projectRoot, task, _parentTask) {
+  try {
+    await storeLearning(projectRoot, {
+      insight: `Completed: ${task.title} \u2014 ${task.description ?? ""}`,
+      source: `task-completion:${task.id}`,
+      confidence: 0.7,
+      actionable: true
+    });
+    const deps = task.depends ?? [];
+    if (deps.length > 0) {
+      await storeLearning(projectRoot, {
+        insight: `Task ${task.id} depended on ${deps.join(", ")} \u2014 dependency chain completed successfully`,
+        source: `task-completion:${task.id}`,
+        confidence: 0.7
+      });
+    }
+    const { getAccessor: getAccessor2 } = await Promise.resolve().then(() => (init_data_accessor(), data_accessor_exports));
+    const accessor = await getAccessor2(projectRoot);
+    let taskFile;
+    try {
+      taskFile = await accessor.loadTaskFile();
+    } finally {
+      await accessor.close();
+    }
+    const recentDone = taskFile.tasks.filter((t) => t.status === "done").slice(-50);
+    const labelCounts = /* @__PURE__ */ new Map();
+    for (const t of recentDone) {
+      for (const label of t.labels ?? []) {
+        const existing = labelCounts.get(label) ?? [];
+        existing.push(t.id);
+        labelCounts.set(label, existing);
+      }
+    }
+    for (const [label, taskIds] of labelCounts.entries()) {
+      if (taskIds.length >= 3) {
+        await storePattern(projectRoot, {
+          type: "success",
+          pattern: `Recurring label "${label}" seen in ${taskIds.length} completed tasks`,
+          context: `Auto-detected from task completion of ${task.id}`,
+          impact: "medium",
+          examples: taskIds
+        });
+      }
+    }
+  } catch {
+  }
+}
+async function extractSessionEndMemory(projectRoot, sessionData, taskDetails) {
+  try {
+    if (taskDetails.length > 0) {
+      await storeDecision(projectRoot, {
+        type: "process",
+        decision: `Session ${sessionData.sessionId} completed ${taskDetails.length} tasks: ${taskDetails.map((t) => t.id).join(", ")}`,
+        rationale: `Session scope: ${sessionData.scope}. Duration: ${Math.round(sessionData.duration / 60)} min.`,
+        confidence: "medium"
+      });
+    }
+    for (const t of taskDetails) {
+      await storeLearning(projectRoot, {
+        insight: `Completed: ${t.title} \u2014 ${t.description ?? ""}`,
+        source: `session-end:${sessionData.sessionId}`,
+        confidence: 0.7,
+        actionable: true
+      });
+    }
+    const labelCounts = /* @__PURE__ */ new Map();
+    for (const t of taskDetails) {
+      for (const label of t.labels ?? []) {
+        const existing = labelCounts.get(label) ?? [];
+        existing.push(t.id);
+        labelCounts.set(label, existing);
+      }
+    }
+    for (const [label, taskIds] of labelCounts.entries()) {
+      if (taskIds.length >= 2) {
+        await storePattern(projectRoot, {
+          type: "workflow",
+          pattern: `Session ${sessionData.sessionId} completed ${taskIds.length} tasks with label "${label}"`,
+          context: `Auto-detected from session end: ${sessionData.sessionId}`,
+          impact: "medium",
+          examples: taskIds
+        });
+      }
+    }
+  } catch {
+  }
+}
+async function resolveTaskDetails(projectRoot, taskIds) {
+  if (taskIds.length === 0) {
+    return [];
+  }
+  const { getAccessor: getAccessor2 } = await Promise.resolve().then(() => (init_data_accessor(), data_accessor_exports));
+  const accessor = await getAccessor2(projectRoot);
+  try {
+    const taskFile = await accessor.loadTaskFile();
+    const idSet = new Set(taskIds);
+    return taskFile.tasks.filter((t) => idSet.has(t.id));
+  } finally {
+    await accessor.close();
+  }
+}
+var init_auto_extract = __esm({
+  "src/core/memory/auto-extract.ts"() {
+    "use strict";
+    init_decisions2();
+    init_learnings();
+    init_patterns();
+  }
+});
+
 // src/core/sessions/session-memory-bridge.ts
 var session_memory_bridge_exports = {};
 __export(session_memory_bridge_exports, {
@@ -22515,6 +22831,12 @@ async function bridgeSessionToMemory(projectRoot, sessionData) {
       sourceSessionId: sessionData.sessionId,
       sourceType: "agent"
     });
+    try {
+      const { extractSessionEndMemory: extractSessionEndMemory2, resolveTaskDetails: resolveTaskDetails2 } = await Promise.resolve().then(() => (init_auto_extract(), auto_extract_exports));
+      const taskDetails = await resolveTaskDetails2(projectRoot, sessionData.tasksCompleted);
+      await extractSessionEndMemory2(projectRoot, sessionData, taskDetails);
+    } catch {
+    }
   } catch {
   }
 }
@@ -25083,6 +25405,10 @@ async function completeTask(options, cwd, accessor) {
   }
   Promise.resolve().then(() => (init_memory_bridge(), memory_bridge_exports)).then(({ refreshMemoryBridge: refreshMemoryBridge2 }) => refreshMemoryBridge2(cwd ?? process.cwd())).catch(() => {
   });
+  Promise.resolve().then(() => (init_auto_extract(), auto_extract_exports)).then(
+    ({ extractTaskCompletionMemory: extractTaskCompletionMemory2 }) => extractTaskCompletionMemory2(cwd ?? process.cwd(), task)
+  ).catch(() => {
+  });
   return {
     task,
     ...autoCompleted.length > 0 && { autoCompleted },
@@ -33359,140 +33685,9 @@ import { join as join25 } from "node:path";
 // src/core/memory/index.ts
 init_brain_retrieval();
 init_brain_search();
-
-// src/core/memory/decisions.ts
-init_brain_accessor();
-init_brain_schema();
-init_brain_sqlite();
-import { desc as desc3 } from "drizzle-orm";
-
-// src/core/memory/learnings.ts
-init_brain_accessor();
-import { randomBytes as randomBytes5 } from "node:crypto";
-function generateLearningId() {
-  return `L-${randomBytes5(4).toString("hex")}`;
-}
-async function storeLearning(projectRoot, params) {
-  if (!params.insight || !params.insight.trim()) {
-    throw new Error("Insight text is required");
-  }
-  if (!params.source || !params.source.trim()) {
-    throw new Error("Source is required");
-  }
-  if (params.confidence < 0 || params.confidence > 1) {
-    throw new Error("Confidence must be between 0.0 and 1.0");
-  }
-  const accessor = await getBrainAccessor(projectRoot);
-  const now2 = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-  const existingLearnings = await accessor.findLearnings();
-  const duplicate = existingLearnings.find(
-    (e) => e.insight.toLowerCase() === params.insight.toLowerCase()
-  );
-  if (duplicate) {
-  }
-  const entry = {
-    id: generateLearningId(),
-    insight: params.insight.trim(),
-    source: params.source.trim(),
-    confidence: params.confidence,
-    actionable: params.actionable ?? false,
-    application: params.application ?? null,
-    applicableTypesJson: params.applicableTypes ? JSON.stringify(params.applicableTypes) : "[]",
-    extractedAt: now2
-  };
-  const saved = await accessor.addLearning(entry);
-  return {
-    ...saved,
-    applicableTypes: JSON.parse(saved.applicableTypesJson || "[]")
-  };
-}
-async function searchLearnings(projectRoot, params = {}) {
-  const accessor = await getBrainAccessor(projectRoot);
-  let entries = await accessor.findLearnings({
-    minConfidence: params.minConfidence,
-    actionable: params.actionableOnly,
-    limit: params.limit
-  });
-  if (params.applicableType) {
-    entries = entries.filter((e) => {
-      const types = JSON.parse(e.applicableTypesJson || "[]");
-      return types.includes(params.applicableType);
-    });
-  }
-  if (params.query) {
-    const q = params.query.toLowerCase();
-    entries = entries.filter(
-      (e) => e.insight.toLowerCase().includes(q) || e.source.toLowerCase().includes(q) || e.application?.toLowerCase().includes(q)
-    );
-  }
-  entries.sort((a, b) => b.confidence - a.confidence);
-  return entries.map((e) => ({
-    ...e,
-    applicableTypes: JSON.parse(e.applicableTypesJson || "[]")
-  }));
-}
-
-// src/core/memory/patterns.ts
-init_brain_accessor();
-import { randomBytes as randomBytes6 } from "node:crypto";
-function generatePatternId() {
-  return `P-${randomBytes6(4).toString("hex")}`;
-}
-async function storePattern(projectRoot, params) {
-  if (!params.pattern || !params.pattern.trim()) {
-    throw new Error("Pattern description is required");
-  }
-  if (!params.context || !params.context.trim()) {
-    throw new Error("Pattern context is required");
-  }
-  const accessor = await getBrainAccessor(projectRoot);
-  const existingPatterns = await accessor.findPatterns({ type: params.type });
-  const duplicate = existingPatterns.find(
-    (e) => e.pattern.toLowerCase() === params.pattern.toLowerCase()
-  );
-  const now2 = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-  if (duplicate) {
-  }
-  const entry = {
-    id: generatePatternId(),
-    type: params.type,
-    pattern: params.pattern.trim(),
-    context: params.context.trim(),
-    frequency: 1,
-    successRate: params.successRate ?? null,
-    impact: params.impact ?? null,
-    antiPattern: params.antiPattern ?? null,
-    mitigation: params.mitigation ?? null,
-    examplesJson: params.examples ? JSON.stringify(params.examples) : "[]",
-    extractedAt: now2
-  };
-  const saved = await accessor.addPattern(entry);
-  return {
-    ...saved,
-    examples: JSON.parse(saved.examplesJson || "[]")
-  };
-}
-async function searchPatterns(projectRoot, params = {}) {
-  const accessor = await getBrainAccessor(projectRoot);
-  let entries = await accessor.findPatterns({
-    type: params.type,
-    impact: params.impact,
-    minFrequency: params.minFrequency,
-    limit: params.limit
-  });
-  if (params.query) {
-    const q = params.query.toLowerCase();
-    entries = entries.filter(
-      (e) => e.pattern.toLowerCase().includes(q) || e.context.toLowerCase().includes(q) || e.antiPattern?.toLowerCase().includes(q) || e.mitigation?.toLowerCase().includes(q)
-    );
-  }
-  return entries.map((e) => ({
-    ...e,
-    examples: JSON.parse(e.examplesJson || "[]")
-  }));
-}
-
-// src/core/memory/index.ts
+init_decisions2();
+init_learnings();
+init_patterns();
 function filterManifestEntries(entries, filter) {
   let filtered = entries;
   if (filter.taskId) {
@@ -34998,6 +35193,8 @@ init_data_accessor();
 init_paths();
 init_brain_links();
 init_brain_retrieval();
+init_learnings();
+init_patterns();
 function resolveRoot(projectRoot) {
   return projectRoot || getProjectRoot();
 }
@@ -53579,7 +53776,7 @@ import { execFileSync as execFileSync14 } from "node:child_process";
 // src/config/build-config.ts
 var BUILD_CONFIG = {
   "name": "@cleocode/cleo",
-  "version": "2026.3.32",
+  "version": "2026.3.33",
   "description": "CLEO V2 - TypeScript task management CLI for AI coding agents",
   "repository": {
     "owner": "kryptobaseddev",
@@ -53588,7 +53785,7 @@ var BUILD_CONFIG = {
     "url": "https://github.com/kryptobaseddev/cleo.git",
     "issuesUrl": "https://github.com/kryptobaseddev/cleo/issues"
   },
-  "buildDate": "2026-03-17T04:37:37.462Z",
+  "buildDate": "2026-03-17T05:12:56.827Z",
   "templates": {
     "issueTemplatesDir": "templates/issue-templates"
   }
@@ -54042,6 +54239,28 @@ function registerMemoryBrainCommand(program2) {
       { command: "memory", operation: "memory.observe" }
     );
   });
+  memory.command("timeline <anchor>").description("Show chronological context around an anchor observation ID").option("--before <n>", "Number of entries before anchor", parseInt).option("--after <n>", "Number of entries after anchor", parseInt).option("--json", "Output as JSON").action(async (anchor, opts) => {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "timeline",
+      {
+        anchor,
+        depthBefore: opts["before"],
+        depthAfter: opts["after"]
+      },
+      { command: "memory", operation: "memory.timeline" }
+    );
+  });
+  memory.command("fetch <ids...>").description("Fetch full details for specific observation IDs").option("--json", "Output as JSON").action(async (ids, _opts) => {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "fetch",
+      { ids },
+      { command: "memory", operation: "memory.fetch" }
+    );
+  });
 }
 
 // src/core/memory/claude-mem-migration.ts
@@ -56963,6 +57182,33 @@ function registerSessionCommand(program2) {
       { command: "session", operation: "session.gc" }
     );
   });
+  session.command("record-decision").description("Record a decision made during the current session").requiredOption("--session-id <sessionId>", "Session ID").requiredOption("--task-id <taskId>", "Task ID the decision relates to").requiredOption("--decision <decision>", "Decision text").requiredOption("--rationale <rationale>", "Rationale for the decision").option("--alternatives <alternatives>", "Alternatives considered").action(async (opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "session",
+      "record.decision",
+      {
+        sessionId: opts["sessionId"],
+        taskId: opts["taskId"],
+        decision: opts["decision"],
+        rationale: opts["rationale"],
+        alternatives: opts["alternatives"]
+      },
+      { command: "session", operation: "session.record.decision" }
+    );
+  });
+  session.command("decision-log").description("Show decisions recorded in a session").option("--session-id <sessionId>", "Session ID to filter by").option("--task-id <taskId>", "Task ID to filter by").action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "session",
+      "decision.log",
+      {
+        sessionId: opts["sessionId"],
+        taskId: opts["taskId"]
+      },
+      { command: "session", operation: "session.decision.log" }
+    );
+  });
 }
 
 // src/cli/commands/show.ts