@cleocode/cleo 2026.10.21 → 2026.10.22

package/dist/cli/{memory-VF44IXEA.js → memory-SJBDMOYJ.js}

@@ -17,7 +17,7 @@ import {
   dispatchFromCli,
   dispatchRaw,
   handleRawError
-} from "./chunk-L3W2NVWA.js";
+} from "./chunk-VBTCULVY.js";
 import {
   CLEO_DIR_NAME,
   MIGRATE_MEMORY_HASHES_JSON
@@ -31,12 +31,13 @@ import "./chunk-QKMBWYAS.js";
 import {
   cliError,
   cliOutput
-} from "./chunk-4RGSNUUP.js";
+} from "./chunk-6UGBRRKY.js";
 import "./chunk-6JSJNYH2.js";
 import "./chunk-D7BAQNV2.js";
-import "./chunk-GAMCDPPS.js";
+import "./chunk-BFRYJSL5.js";
 
 // packages/cleo/src/cli/commands/memory.ts
+import { existsSync, readFileSync } from "node:fs";
 import { runConsolidation } from "@cleocode/core/memory/brain-lifecycle";
 import { getDreamStatus, triggerManualDream } from "@cleocode/core/memory/dream-cycle";
 import { importMemoryFiles } from "@cleocode/core/memory/import-from-provider.js";
@@ -276,7 +277,7 @@ var observeCommand = defineCommand({
     },
     type: {
       type: "string",
-      description: "Category: discovery (found something new), decision (choice made), bugfix (bug found/fixed), refactor (code restructured), feature (feature added), change (general change), diary (journal entry), session-summary (end-of-session recap auto-created by cleo session end)"
+      description: "Category: discovery (found something new), decision (choice made), bugfix (bug found/fixed), refactor (code restructured), feature (feature added), change (general change), diary (journal entry), session-summary (end-of-session recap auto-created by cleo session end), lesson (--title is the one-line rule, the text is why; defaults to --scope global)"
     },
     agent: {
       type: "string",
@@ -1064,6 +1065,170 @@ var reflectCommand = defineCommand({
     }
   }
 });
+var quarantineAutoRowsCommand = defineCommand({
+  meta: {
+    name: "quarantine-auto-rows",
+    description: "Report (default), quarantine (--apply --expect \u2026 --expect-digest \u2026) or restore (--restore <receipt>) auto-generated BRAIN rows: dispatch traces, Doc attached records and task stubs. Sets invalid_at only; nothing is deleted."
+  },
+  args: {
+    apply: {
+      type: "boolean",
+      description: "Quarantine the matched rows (requires --expect and --expect-digest)"
+    },
+    expect: {
+      type: "string",
+      description: "Counts from the approved dry run: project:patterns=N,project:observations=N,global:patterns=N,global:observations=N"
+    },
+    "expect-digest": {
+      type: "string",
+      description: "Id-set digest from the approved dry run"
+    },
+    restore: {
+      type: "string",
+      description: "Restore the rows recorded in this receipt file"
+    }
+  },
+  async run({ args }) {
+    const output = {
+      command: "memory-quarantine-auto-rows",
+      operation: "memory.quarantine-auto-rows"
+    };
+    const restore = typeof args.restore === "string" ? args.restore : void 0;
+    const expectText = typeof args.expect === "string" ? args.expect : void 0;
+    const expectDigest = typeof args["expect-digest"] === "string" ? args["expect-digest"] : void 0;
+    if (restore !== void 0 && args.apply) {
+      cliError("--restore and --apply cannot be combined", 6, { name: "E_INVALID_INPUT" });
+      return;
+    }
+    if (!args.apply && (expectText !== void 0 || expectDigest !== void 0)) {
+      cliError("--expect and --expect-digest only apply with --apply", 6, {
+        name: "E_INVALID_INPUT"
+      });
+      return;
+    }
+    const root = getProjectRoot();
+    const q = await import("@cleocode/core/memory/auto-row-quarantine");
+    const now = /* @__PURE__ */ new Date();
+    const receiptPath = q.defaultQuarantineReceiptPath(root, now.toISOString());
+    try {
+      const stores = await q.openQuarantineStores(root);
+      if (restore !== void 0) {
+        const restored = await q.restoreAutoRowQuarantine(stores, restore);
+        cliOutput({ receipt: restore, restored }, output);
+        return;
+      }
+      if (!args.apply) {
+        const { counts, predicates, digest } = q.planAutoRowQuarantine(stores);
+        cliOutput({ dryRun: true, counts, digest, predicates }, output);
+        return;
+      }
+      if (expectText === void 0 || expectDigest === void 0) {
+        cliError("--apply needs --expect and --expect-digest from the approved dry run", 6, {
+          name: "E_INVALID_INPUT"
+        });
+        return;
+      }
+      const expect = q.parseQuarantineExpect(expectText);
+      const receipt = await q.applyAutoRowQuarantine(stores, expect, expectDigest, receiptPath, {
+        now
+      });
+      cliOutput({ receipt: receiptPath, ...receipt, ids: void 0 }, output);
+    } catch (err) {
+      const code = err instanceof q.AutoRowQuarantineError ? err.code : "E_QUARANTINE";
+      const details = existsSync(receiptPath) ? { receiptPath } : void 0;
+      cliError(err instanceof Error ? err.message : String(err), 6, { name: code, details });
+    }
+  }
+});
+var importLessonsCommand = defineCommand({
+  meta: {
+    name: "import-lessons",
+    description: "Plan (default) or apply (--apply --expect-digest \u2026) a one-time import of a Claude Code memory directory as lessons in the main brain: feedback and project memories become lessons (description = rule, body = why), with source provenance per row. Never deletes or edits a source file."
+  },
+  args: {
+    from: {
+      type: "string",
+      description: "Memory directory (default: ~/.claude/projects/<this project root>/memory)"
+    },
+    apply: {
+      type: "boolean",
+      description: "Write the planned lessons (requires --expect-digest)"
+    },
+    "expect-digest": {
+      type: "string",
+      description: "Plan digest from the approved dry run"
+    },
+    exclude: {
+      type: "string",
+      description: "Comma-separated memory file names to leave out (applied before the digest)"
+    },
+    "exclude-from": {
+      type: "string",
+      description: "File listing memory file names to leave out, one per line (# comments)"
+    }
+  },
+  async run({ args }) {
+    const output = { command: "memory-import-lessons", operation: "memory.import-lessons" };
+    const exclude = [
+      ...typeof args.exclude === "string" ? args.exclude.split(",") : [],
+      ...typeof args["exclude-from"] === "string" ? readFileSync(args["exclude-from"], "utf-8").split("\n") : []
+    ].map((line) => line.replace(/#.*$/, "").trim()).filter((line) => line.length > 0);
+    const expectDigest = typeof args["expect-digest"] === "string" ? args["expect-digest"] : void 0;
+    if (!args.apply && expectDigest !== void 0) {
+      cliError("--expect-digest only applies with --apply", 6, { name: "E_INVALID_INPUT" });
+      return;
+    }
+    const root = getProjectRoot();
+    const lessons = await import("@cleocode/core/memory/lessons-import");
+    const sourceDir = typeof args.from === "string" ? args.from : lessons.defaultLessonImportDir(root);
+    try {
+      if (!args.apply) {
+        const plan = lessons.planLessonImport(sourceDir, { exclude });
+        cliOutput(
+          {
+            dryRun: true,
+            sourceDir: plan.sourceDir,
+            digest: plan.digest,
+            excluded: exclude,
+            lessons: plan.candidates.length,
+            globalLessons: plan.candidates.filter((c) => c.scope === "global").length,
+            projectLessons: plan.candidates.filter((c) => c.scope === "project").length,
+            skipped: plan.skipped.length,
+            candidates: plan.candidates.map(({ text: _text, ...rest }) => rest),
+            skippedFiles: plan.skipped
+          },
+          output
+        );
+        return;
+      }
+      if (expectDigest === void 0) {
+        cliError("--apply needs --expect-digest from the approved dry run", 6, {
+          name: "E_INVALID_INPUT"
+        });
+        return;
+      }
+      const now = /* @__PURE__ */ new Date();
+      const receiptPath = lessons.defaultLessonImportReceiptPath(root, now.toISOString());
+      const receipt = await lessons.applyLessonImport(root, sourceDir, expectDigest, receiptPath, {
+        exclude,
+        now
+      });
+      cliOutput(
+        {
+          receipt: receiptPath,
+          digest: receipt.digest,
+          stored: receipt.written.filter((w) => w.stored).length,
+          alreadyPresent: receipt.written.filter((w) => !w.stored).length,
+          written: receipt.written
+        },
+        output
+      );
+    } catch (err) {
+      const code = err instanceof lessons.LessonImportError ? err.code : "E_LESSON_IMPORT";
+      cliError(err instanceof Error ? err.message : String(err), 6, { name: code });
+    }
+  }
+});
 var pruneStubsCommand = defineCommand({
   meta: {
     name: "prune-stubs",
@@ -1222,7 +1387,9 @@ var importCommand = defineCommand({
         projectRoot,
         cleoDirName: CLEO_DIR_NAME,
         hasheFileName: MIGRATE_MEMORY_HASHES_JSON,
-        dispatch: dispatchFromCli
+        // dispatchRaw: one failing (or duplicate) entry must not print an
+        // envelope or exit the whole import (T13949).
+        dispatch: dispatchRaw
       });
       cliOutput(
         {
@@ -1750,6 +1917,27 @@ var diaryWriteCommand = makeMemorySubcommand({
     ...args["agent"] !== void 0 && { agent: args["agent"] }
   })
 });
+var lessonsCommand = makeMemorySubcommand({
+  name: "lessons",
+  description: 'List lessons (one-line rule + why) newest first, superseded hidden. Write one with: cleo memory observe "<why>" --type lesson --title "<rule>"',
+  args: {
+    scope: {
+      type: "string",
+      description: "Store to read: project, global (the main brain) or all (default)"
+    },
+    limit: {
+      type: "string",
+      description: "Maximum number of lessons to return (default: 50)."
+    }
+  },
+  gateway: "query",
+  operation: "lessons",
+  output: { command: "memory-lessons", operation: "memory.lessons" },
+  paramBuilder: (args) => ({
+    ...args["scope"] !== void 0 && { scope: args["scope"] },
+    ...args["limit"] !== void 0 && { limit: parseInt(args["limit"], 10) }
+  })
+});
 var diaryCommand = defineCommand({
   meta: {
     name: "diary",
@@ -1932,6 +2120,9 @@ var memoryCommand = defineCommand({
     reflect: reflectCommand,
     "dedup-scan": dedupScanCommand,
     "prune-stubs": pruneStubsCommand,
+    lessons: lessonsCommand,
+    "quarantine-auto-rows": quarantineAutoRowsCommand,
+    "import-lessons": importLessonsCommand,
     "prune-traits": pruneTraitsCommand,
     "set-trait-scope": setTraitScopeCommand,
     import: importCommand,
@@ -1959,4 +2150,4 @@ var memoryCommand = defineCommand({
 export {
   memoryCommand
 };
-//# sourceMappingURL=memory-VF44IXEA.js.map
+//# sourceMappingURL=memory-SJBDMOYJ.js.map

package/dist/cli/{memory-CYS36LY4.js → memory-T3YAA2OK.js}

@@ -15,7 +15,7 @@
 })();
 import {
   lazyOperation
-} from "./chunk-GAMCDPPS.js";
+} from "./chunk-BFRYJSL5.js";
 import {
   errorResult,
   handleErrorResult,
@@ -52,6 +52,9 @@ var generateMemoryBridgeContent = lazyOperation(
 var getBrainDb = lazyOperation(
   async () => (await import("@cleocode/core/store/memory-sqlite")).getBrainDb
 );
+var listLessons = lazyOperation(
+  async () => (await import("@cleocode/core/memory/lessons")).listLessons
+);
 var memoryDecisionFind = lazyOperation(
   async () => (await import("@cleocode/core/memory/engine-compat")).memoryDecisionFind
 );
@@ -741,18 +744,19 @@ var MemoryHandler = class {
                 startTime
               );
             }
+            const { autoRowExclusionClause } = await import("@cleocode/core/memory/eligibility");
             let rows = [];
             try {
               const rawRows = nativeDb.prepare(
                 `SELECT id,
                           title,
-                          text,
+                          narrative AS text,
                           citation_count,
                           quality_score,
                           memory_tier,
                           created_at
                    FROM brain_observations
-                   WHERE invalid_at IS NULL
+                   WHERE invalid_at IS NULL${autoRowExclusionClause("observations")}
                    ORDER BY citation_count DESC, quality_score DESC
                    LIMIT ?`
               ).all(limitVal);
@@ -884,6 +888,45 @@ var MemoryHandler = class {
             return handleErrorResult("query", "memory", operation, dbErr, startTime);
           }
         }
+        // T13949 — curated lessons index, newest first, superseded hidden
+        case "lessons": {
+          const scopeParam = paramString(params, "scope") ?? "all";
+          if (scopeParam !== "project" && scopeParam !== "global" && scopeParam !== "all") {
+            return errorResult(
+              "query",
+              "memory",
+              operation,
+              // @sync-invariant none:input-shape an unknown lessons scope is refused; a read writes nothing
+              "E_INVALID_INPUT",
+              `scope must be project, global or all (got '${scopeParam}')`,
+              startTime
+            );
+          }
+          const limit = paramNumber(params, "limit") ?? 50;
+          if (!Number.isInteger(limit) || limit < 1) {
+            return errorResult(
+              "query",
+              "memory",
+              operation,
+              // @sync-invariant none:input-shape an invalid lessons limit is refused; a read writes nothing
+              "E_INVALID_INPUT",
+              "limit must be a positive integer",
+              startTime
+            );
+          }
+          try {
+            const lessons = await listLessons(projectRoot, { scope: scopeParam, limit });
+            return wrapResult(
+              { success: true, data: { count: lessons.length, scope: scopeParam, lessons } },
+              "query",
+              "memory",
+              operation,
+              startTime
+            );
+          } catch (err) {
+            return handleErrorResult("query", "memory", operation, err, startTime);
+          }
+        }
         // T1006 — read diary-typed observations
         case "diary": {
           const limitVal = paramNumber(params, "limit") ?? 20;
@@ -1264,6 +1307,34 @@ var MemoryHandler = class {
             },
             projectRoot
           );
+          const observed = result.success ? result.data : void 0;
+          if (observed?.stored === false) {
+            const action = observed.gateAction ?? "declined";
+            const into = observed.gateAction === "merged" ? ` into ${observed.id}` : "";
+            const why = observed.gateReason ? ` (${observed.gateReason})` : "";
+            const refused = errorResult(
+              "mutate",
+              "memory",
+              operation,
+              // @sync-invariant none:input-shape the gate stored nothing; this only reports it
+              "E_OBSERVE_NOT_STORED",
+              `Nothing stored: the extraction gate ${action} the observation${into}${why}`,
+              startTime
+            );
+            return {
+              ...refused,
+              error: {
+                // @sync-invariant none:input-shape the gate stored nothing; this only reports it
+                code: "E_OBSERVE_NOT_STORED",
+                message: refused.error?.message ?? "Nothing stored",
+                details: {
+                  id: observed.id,
+                  ...observed.gateAction ? { gateAction: observed.gateAction } : {},
+                  ...observed.gateReason ? { gateReason: observed.gateReason } : {}
+                }
+              }
+            };
+          }
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
         case "decision.store": {
@@ -1717,81 +1788,18 @@ var MemoryHandler = class {
         // which already handles all sweep sub-commands via a unified case block.
         case "sweep":
           return this.query(operation, params);
-        // T9976 — backfill: emit memory observations for existing doc attachments
-        // that do not yet have a corresponding brain observation.
+        // T9976/T13985 (D11180) — backfill: write the `llmtxt --documents--> owner`
+        // edge for existing doc attachments that do not have it yet.
         case "backfill-docs": {
           try {
-            const store = createAttachmentStore();
-            const allAttachments = await store.listAllInProject();
-            await getBrainDb(projectRoot);
-            const nativeDb = getBrainNativeDb(projectRoot);
-            const existingAttachmentIds = /* @__PURE__ */ new Set();
-            if (nativeDb) {
-              try {
-                const existing = nativeDb.prepare(
-                  `SELECT narrative FROM brain_observations
-                     WHERE narrative LIKE '%"kind":"doc-attachment"%'
-                       AND invalid_at IS NULL`
-                ).all();
-                for (const row of existing) {
-                  if (!row.narrative) continue;
-                  try {
-                    const p = JSON.parse(row.narrative);
-                    if (p.kind === "doc-attachment" && typeof p.attachmentId === "string") {
-                      existingAttachmentIds.add(p.attachmentId);
-                    }
-                  } catch {
-                  }
-                }
-              } catch {
-              }
-            }
-            let emitted = 0;
-            let skipped = 0;
-            const emittedIds = [];
-            for (const item of allAttachments) {
-              const attId = item.metadata.id;
-              if (existingAttachmentIds.has(attId)) {
-                skipped++;
-                continue;
-              }
-              const extras = await store.getExtras(attId);
-              const slug = extras?.slug ?? void 0;
-              const type = extras?.type ?? void 0;
-              const payload = {
-                kind: "doc-attachment",
-                attachmentId: attId,
-                ownerId: item.ownerId,
-                addedAt: item.metadata.createdAt,
-                ...slug !== void 0 ? { slug } : {},
-                ...type !== void 0 ? { type } : {}
-              };
-              const { memoryObserve: brainObserve } = await import("@cleocode/core/memory/engine-compat");
-              await brainObserve(
-                {
-                  text: JSON.stringify(payload),
-                  title: `Doc attached: ${slug ?? attId}`,
-                  type: "feature",
-                  // sourceType: 'manual' avoids the mental-model queue (5s flush interval).
-                  // The mental-model queue is only entered when `agent` is set + type is in
-                  // MENTAL_MODEL_TYPES. Using 'manual' bypasses this path entirely.
-                  sourceType: "manual"
-                },
-                projectRoot
-              ).catch(() => {
-              });
-              emittedIds.push(attId);
-              emitted++;
-            }
+            const { backfillDocumentEdges } = await import("@cleocode/core/docs/document-edges");
+            const backfill = await backfillDocumentEdges(projectRoot);
             return wrapResult(
               {
                 success: true,
                 data: {
-                  total: allAttachments.length,
-                  emitted,
-                  skipped,
-                  emittedAttachmentIds: emittedIds,
-                  hint: emitted === 0 ? "All existing attachments already have memory observations \u2014 nothing to backfill." : `Emitted ${emitted} new doc-attachment observations. Use 'cleo memory find <slug>' to verify.`
+                  ...backfill,
+                  hint: backfill.written === 0 ? "Every attachment already has its documents edge \u2014 nothing to backfill." : `Wrote ${backfill.written} missing documents edge(s).`
                 }
               },
               "mutate",
@@ -1858,6 +1866,8 @@ var MemoryHandler = class {
         "recent",
         // T1006 — diary-typed observations (requires diary enum from T1005)
         "diary",
+        // T13949 — curated lessons index
+        "lessons",
         // T1006 — long-poll stream of recent brain writes (SSE-style polling stub)
         "watch",
         // T1003 — list staged backfill runs
@@ -1894,4 +1904,4 @@ var MemoryHandler = class {
 export {
   MemoryHandler
 };
-//# sourceMappingURL=memory-CYS36LY4.js.map
+//# sourceMappingURL=memory-T3YAA2OK.js.map

package/dist/cli/{migrate-agents-v2-A52QIYNJ.js → migrate-agents-v2-RGJ63UHD.js}

@@ -19,9 +19,9 @@ import {
   readMigrationConflicts,
   runMigrateAgentsV2,
   walkAgentsDir
-} from "./chunk-IIOGUY3B.js";
+} from "./chunk-LLIRCDQX.js";
 import "./chunk-PKKZPOOP.js";
-import "./chunk-4RGSNUUP.js";
+import "./chunk-6UGBRRKY.js";
 import "./chunk-6JSJNYH2.js";
 export {
   extractAgentName,
@@ -30,4 +30,4 @@ export {
   runMigrateAgentsV2,
   walkAgentsDir
 };
-//# sourceMappingURL=migrate-agents-v2-A52QIYNJ.js.map
+//# sourceMappingURL=migrate-agents-v2-RGJ63UHD.js.map

package/dist/cli/{migrate-claude-mem-VC4GOHLG.js → migrate-claude-mem-GI75LXGS.js}

@@ -15,10 +15,10 @@
 })();
 import {
   migrateAgentsV2Command
-} from "./chunk-IIOGUY3B.js";
+} from "./chunk-LLIRCDQX.js";
 import {
   dispatchFromCli
-} from "./chunk-L3W2NVWA.js";
+} from "./chunk-VBTCULVY.js";
 import "./chunk-6N6WGLXE.js";
 import "./chunk-4VASFLUW.js";
 import {
@@ -30,10 +30,10 @@ import {
   cliError,
   cliOutput,
   humanLine
-} from "./chunk-4RGSNUUP.js";
+} from "./chunk-6UGBRRKY.js";
 import "./chunk-6JSJNYH2.js";
 import "./chunk-D7BAQNV2.js";
-import "./chunk-GAMCDPPS.js";
+import "./chunk-BFRYJSL5.js";
 
 // packages/cleo/src/cli/commands/migrate-claude-mem.ts
 import { migrateClaudeMem } from "@cleocode/core/memory/claude-mem-migration";
@@ -203,4 +203,4 @@ var migrateClaudeMemCommand = defineCommand({
 export {
   migrateClaudeMemCommand
 };
-//# sourceMappingURL=migrate-claude-mem-VC4GOHLG.js.map
+//# sourceMappingURL=migrate-claude-mem-GI75LXGS.js.map

package/dist/cli/{next-HZVSZRHJ.js → next-24SKEZYV.js}

@@ -15,17 +15,17 @@
 })();
 import {
   dispatchFromCli
-} from "./chunk-L3W2NVWA.js";
+} from "./chunk-VBTCULVY.js";
 import "./chunk-6N6WGLXE.js";
 import "./chunk-4VASFLUW.js";
 import {
   defineCommand
 } from "./chunk-PKKZPOOP.js";
 import "./chunk-QKMBWYAS.js";
-import "./chunk-4RGSNUUP.js";
+import "./chunk-6UGBRRKY.js";
 import "./chunk-6JSJNYH2.js";
 import "./chunk-D7BAQNV2.js";
-import "./chunk-GAMCDPPS.js";
+import "./chunk-BFRYJSL5.js";
 
 // packages/cleo/src/cli/commands/next.ts
 var nextCommand = defineCommand({
@@ -54,4 +54,4 @@ var nextCommand = defineCommand({
 export {
   nextCommand
 };
-//# sourceMappingURL=next-HZVSZRHJ.js.map
+//# sourceMappingURL=next-24SKEZYV.js.map