@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/memory-UHYIVGVM.js

@@ -0,0 +1,1956 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli,
+  dispatchRaw,
+  handleRawError
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import {
+  CLEO_DIR_NAME,
+  MIGRATE_MEMORY_HASHES_JSON
+} from "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/memory.ts
+import { getProjectRoot } from "@cleocode/core";
+import {
+  getBrainDb,
+  getDreamStatus,
+  getTierStats,
+  runConsolidation,
+  scanDuplicateEntries,
+  setEntryTier,
+  triggerManualDream
+} from "@cleocode/core/memory";
+import { importMemoryFiles } from "@cleocode/core/memory/import-from-provider.js";
+import { streamMemoryWatchEvents } from "@cleocode/core/memory/watch-stream.js";
+var storeCommand = defineCommand({
+  meta: { name: "store", description: "Store a pattern or learning to BRAIN memory" },
+  args: {
+    type: {
+      type: "string",
+      description: "Memory type: pattern or learning",
+      required: true
+    },
+    content: {
+      type: "string",
+      description: "Content of the memory entry",
+      required: true
+    },
+    context: {
+      type: "string",
+      description: "Context in which the pattern/learning was observed"
+    },
+    source: {
+      type: "string",
+      description: "Source of the learning"
+    },
+    "pattern-type": {
+      type: "string",
+      description: "Pattern type: workflow, blocker, success, failure, optimization"
+    },
+    impact: {
+      type: "string",
+      description: "Impact level: low, medium, high"
+    },
+    confidence: {
+      type: "string",
+      description: "Confidence score 0.0-1.0 (for learnings)"
+    },
+    actionable: {
+      type: "boolean",
+      description: "Mark learning as actionable"
+    },
+    "linked-task": {
+      type: "string",
+      description: "Task ID to link this memory to"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const memType = args.type;
+    if (memType === "pattern") {
+      await dispatchFromCli(
+        "mutate",
+        "memory",
+        "pattern.store",
+        {
+          type: args["pattern-type"] || "workflow",
+          pattern: args.content,
+          context: args.context || "Unspecified context",
+          impact: args.impact,
+          examples: args["linked-task"] ? [args["linked-task"]] : []
+        },
+        { command: "memory", operation: "memory.pattern.store" }
+      );
+    } else if (memType === "learning") {
+      await dispatchFromCli(
+        "mutate",
+        "memory",
+        "learning.store",
+        {
+          insight: args.content,
+          source: args.source || "manual",
+          confidence: args.confidence !== void 0 ? parseFloat(args.confidence) : 0.5,
+          actionable: !!args.actionable,
+          applicableTypes: args["linked-task"] ? [args["linked-task"]] : []
+        },
+        { command: "memory", operation: "memory.learning.store" }
+      );
+    } else {
+      cliError(`Unknown memory type: ${memType}. Use 'pattern' or 'learning'.`, "E_VALIDATION", {
+        name: "E_VALIDATION"
+      });
+      process.exit(1);
+    }
+  }
+});
+var findCommand = defineCommand({
+  meta: {
+    name: "find",
+    description: "Search BRAIN memory (all tables, or filter by --type decision|pattern|learning|observation)"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Search query",
+      required: true
+    },
+    type: {
+      type: "string",
+      description: "Filter by memory type: decision, pattern, learning, or observation (default: all)"
+    },
+    history: {
+      type: "boolean",
+      description: "Include superseded and invalidated memory as historical evidence"
+    },
+    "pattern-type": {
+      type: "string",
+      description: "Filter patterns by type: workflow, blocker, success, failure, optimization"
+    },
+    "min-confidence": {
+      type: "string",
+      description: "Minimum confidence for learnings"
+    },
+    actionable: {
+      type: "boolean",
+      description: "Only show actionable learnings"
+    },
+    limit: {
+      type: "string",
+      description: "Maximum results"
+    },
+    // T418: agent filter for per-agent mental model retrieval
+    agent: {
+      type: "string",
+      description: "Filter observations by agent provenance name (Wave 8 mental models)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const query = args.query;
+    const memType = args.type;
+    if (memType !== void 0 && !["decision", "pattern", "learning", "observation"].includes(memType)) {
+      cliError(
+        `Unknown memory type: ${memType}. Use decision, pattern, learning, or observation.`,
+        "E_VALIDATION",
+        { name: "E_VALIDATION" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (args.agent !== void 0 && memType !== void 0 && memType !== "observation") {
+      cliError("--agent can only be combined with --type observation.", "E_VALIDATION", {
+        name: "E_VALIDATION"
+      });
+      process.exitCode = 1;
+      return;
+    }
+    if (memType === "pattern" && !args.history) {
+      await dispatchFromCli(
+        "query",
+        "memory",
+        "pattern.find",
+        {
+          query,
+          type: args["pattern-type"],
+          limit: args.limit !== void 0 ? parseInt(args.limit, 10) : void 0
+        },
+        { command: "memory", operation: "memory.find" }
+      );
+    } else if (memType === "learning" && !args.history) {
+      await dispatchFromCli(
+        "query",
+        "memory",
+        "learning.find",
+        {
+          query,
+          minConfidence: args["min-confidence"] !== void 0 ? parseFloat(args["min-confidence"]) : void 0,
+          actionableOnly: !!args.actionable,
+          limit: args.limit !== void 0 ? parseInt(args.limit, 10) : void 0
+        },
+        { command: "memory", operation: "memory.find" }
+      );
+    } else {
+      await dispatchFromCli(
+        "query",
+        "memory",
+        "find",
+        {
+          query,
+          limit: args.limit !== void 0 ? parseInt(args.limit, 10) : void 0,
+          includeHistory: args.history,
+          ...memType === "pattern" && { tables: ["patterns"] },
+          ...memType === "learning" && { tables: ["learnings"] },
+          ...memType === "decision" && { tables: ["decisions"] },
+          ...memType === "observation" && { tables: ["observations"] },
+          // T418: forward agent filter when provided
+          ...args.agent !== void 0 && { agent: args.agent }
+        },
+        { command: "memory", operation: "memory.find" }
+      );
+    }
+  }
+});
+var statsCommand = defineCommand({
+  meta: { name: "stats", description: "Show BRAIN memory statistics" },
+  async run() {
+    const pResponse = await dispatchRaw("query", "memory", "pattern.find", {
+      query: "",
+      limit: 0
+    });
+    const lResponse = await dispatchRaw("query", "memory", "learning.find", {
+      query: "",
+      limit: 0
+    });
+    const result = {};
+    if (pResponse.success) result["patterns"] = pResponse.data;
+    if (lResponse.success) result["learnings"] = lResponse.data;
+    if (!pResponse.success && !lResponse.success) {
+      handleRawError(pResponse, { command: "memory-stats", operation: "memory.stats" });
+      return;
+    }
+    cliOutput(result, { command: "memory-stats", operation: "memory.stats" });
+  }
+});
+var observeCommand = defineCommand({
+  meta: {
+    name: "observe",
+    description: "Save an observation to brain.db \u2014 captures facts, decisions, and discoveries for cross-session memory"
+  },
+  args: {
+    text: {
+      type: "positional",
+      description: "Observation text",
+      required: true
+    },
+    title: {
+      type: "string",
+      description: "Short title for the observation (defaults to first 120 chars of text)"
+    },
+    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)"
+    },
+    agent: {
+      type: "string",
+      description: "Name of the agent producing this observation (enables per-agent memory retrieval)"
+    },
+    "source-type": {
+      type: "string",
+      description: "How this observation was captured: manual (typed by human/agent), auto (lifecycle hook), transcript (extracted from session)"
+    },
+    attach: {
+      type: "string",
+      description: "SHA-256 of an attachment to link to this observation (comma-separated for multiple)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "memory",
+      "observe",
+      {
+        text: args.text,
+        title: args.title,
+        ...args.agent !== void 0 && { agent: args.agent },
+        ...args.type !== void 0 && { type: args.type },
+        sourceType: args["source-type"] ?? "manual",
+        // T799: pass attachment refs
+        ...args.attach !== void 0 && { attach: args.attach }
+      },
+      { command: "memory", operation: "memory.observe" }
+    );
+  }
+});
+var timelineCommand = defineCommand({
+  meta: {
+    name: "timeline",
+    description: "Show chronological context around an anchor observation ID"
+  },
+  args: {
+    // Output format is controlled by the global --json/--human flags (format-context).
+    anchor: {
+      type: "positional",
+      description: "Anchor observation ID",
+      required: true
+    },
+    before: {
+      type: "string",
+      description: "Number of entries before anchor"
+    },
+    after: {
+      type: "string",
+      description: "Number of entries after anchor"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "timeline",
+      {
+        anchor: args.anchor,
+        depthBefore: args.before !== void 0 ? parseInt(args.before, 10) : void 0,
+        depthAfter: args.after !== void 0 ? parseInt(args.after, 10) : void 0
+      },
+      { command: "memory-timeline", operation: "memory.timeline" }
+    );
+  }
+});
+var fetchCommand = defineCommand({
+  meta: { name: "fetch", description: "Fetch full details for specific observation IDs" },
+  args: {
+    // Note: citty doesn't support variadic positional args, so we accept a single
+    // positional and split on commas/spaces to support: `cleo memory fetch ID1,ID2`
+    // Output format is controlled by the global --json/--human flags (format-context).
+    ids: {
+      type: "positional",
+      description: "Comma- or space-separated observation IDs",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const ids = args.ids.split(/[,\s]+/).map((s) => s.trim()).filter(Boolean);
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "fetch",
+      { ids },
+      { command: "memory-fetch", operation: "memory.fetch" }
+    );
+  }
+});
+var decisionFindCommand = defineCommand({
+  meta: {
+    name: "decision-find",
+    description: "Search architectural decisions (use BEFORE grep or ledger files)"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Search query",
+      required: false
+    },
+    limit: {
+      type: "string",
+      description: "Maximum results"
+    },
+    "include-agent-dispatch": {
+      type: "boolean",
+      description: "Include AGT-* agent dispatch rows (excluded by default \u2014 use to surface execution history)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "decision.find",
+      {
+        query: args.query ?? "",
+        limit: args.limit !== void 0 ? parseInt(args.limit, 10) : void 0,
+        // T1830: pass flag so the engine can filter by decision_category
+        includeAgentDispatch: args["include-agent-dispatch"] === true
+      },
+      { command: "memory", operation: "memory.decision.find" }
+    );
+  }
+});
+var decisionStoreCommand = defineCommand({
+  meta: {
+    name: "decision-store",
+    description: "Store an architectural decision \u2014 supports --linked-task, --confirmation-state, --supersedes, --superseded-by, --decided-by"
+  },
+  args: {
+    decision: {
+      type: "string",
+      description: "The decision that was made",
+      required: true
+    },
+    rationale: {
+      type: "string",
+      description: "Rationale behind the decision",
+      required: true
+    },
+    alternatives: {
+      type: "string",
+      description: "Alternatives that were considered"
+    },
+    "linked-task": {
+      type: "string",
+      description: "Task ID to associate with this decision"
+    },
+    "adr-path": {
+      type: "string",
+      description: "Path to the ADR document on disk (e.g. docs/adr/ADR-027.md)"
+    },
+    supersedes: {
+      type: "string",
+      description: "Decision ID that this decision supersedes (e.g. D001)"
+    },
+    "superseded-by": {
+      type: "string",
+      description: "Decision ID that has superseded this decision (e.g. D002)"
+    },
+    "confirmation-state": {
+      type: "string",
+      description: "Lifecycle state: proposed | accepted | superseded (default: proposed)"
+    },
+    "decided-by": {
+      type: "string",
+      description: "Who originated this decision: owner | council | agent (default: agent)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "memory",
+      "decision.store",
+      {
+        decision: args.decision,
+        rationale: args.rationale,
+        ...args.alternatives !== void 0 && { alternatives: args.alternatives },
+        ...args["linked-task"] !== void 0 && { taskId: args["linked-task"] },
+        ...args["adr-path"] !== void 0 && { adrPath: args["adr-path"] },
+        ...args.supersedes !== void 0 && { supersedes: args.supersedes },
+        ...args["superseded-by"] !== void 0 && { supersededBy: args["superseded-by"] },
+        ...args["confirmation-state"] !== void 0 && {
+          confirmationState: args["confirmation-state"]
+        },
+        ...args["decided-by"] !== void 0 && { decidedBy: args["decided-by"] }
+      },
+      { command: "memory", operation: "memory.decision.store" }
+    );
+  }
+});
+var linkCommand = defineCommand({
+  meta: {
+    name: "link",
+    description: "Connect a BRAIN decision/observation to a task (example: cleo memory link T10520 D012)"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID",
+      required: true
+    },
+    entryId: {
+      type: "positional",
+      description: "Brain entry ID",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "memory",
+      "link",
+      { taskId: args.taskId, entryId: args.entryId },
+      { command: "memory", operation: "memory.link" }
+    );
+  }
+});
+var traceCommand = defineCommand({
+  meta: {
+    name: "trace",
+    description: "BFS traversal of the brain knowledge graph from a seed node"
+  },
+  args: {
+    nodeId: {
+      type: "positional",
+      description: "Seed node ID",
+      required: true
+    },
+    depth: {
+      type: "string",
+      description: "Maximum traversal depth (default: 3)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "graph.trace",
+      {
+        nodeId: args.nodeId,
+        ...args.depth !== void 0 && { maxDepth: parseInt(args.depth, 10) }
+      },
+      { command: "memory-trace", operation: "memory.graph.trace" }
+    );
+  }
+});
+var relatedCommand = defineCommand({
+  meta: {
+    name: "related",
+    description: "Return immediate (1-hop) neighbours of a brain graph node"
+  },
+  args: {
+    nodeId: {
+      type: "positional",
+      description: "Node ID",
+      required: true
+    },
+    type: {
+      type: "string",
+      description: "Filter by edge type (e.g. applies_to, supports, derived_from)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "graph.related",
+      {
+        nodeId: args.nodeId,
+        ...args.type !== void 0 && { edgeType: args.type }
+      },
+      { command: "memory-related", operation: "memory.graph.related" }
+    );
+  }
+});
+var contextCommand = defineCommand({
+  meta: {
+    name: "context",
+    description: "360-degree context view of a brain graph node: node + all edges + neighbours"
+  },
+  args: {
+    nodeId: {
+      type: "positional",
+      description: "Node ID",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "graph.context",
+      { nodeId: args.nodeId },
+      { command: "memory-context", operation: "memory.graph.context" }
+    );
+  }
+});
+var graphStatsCommand = defineCommand({
+  meta: {
+    name: "graph-stats",
+    description: "Show brain knowledge graph statistics: node and edge counts by type"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run() {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "graph.stats",
+      {},
+      { command: "memory-graph-stats", operation: "memory.graph.stats" }
+    );
+  }
+});
+var graphShowCommand = defineCommand({
+  meta: { name: "graph-show", description: "Get a PageIndex graph node and its edges" },
+  args: {
+    nodeId: {
+      type: "positional",
+      description: "Node ID",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "graph.show",
+      { nodeId: args.nodeId },
+      { command: "memory", operation: "memory.graph.show" }
+    );
+  }
+});
+var graphNeighborsCommand = defineCommand({
+  meta: {
+    name: "graph-neighbors",
+    description: "Get neighbor nodes from the PageIndex graph"
+  },
+  args: {
+    nodeId: {
+      type: "positional",
+      description: "Node ID",
+      required: true
+    },
+    depth: {
+      type: "string",
+      description: "Traversal depth"
+    },
+    limit: {
+      type: "string",
+      description: "Maximum neighbors"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "graph.neighbors",
+      {
+        nodeId: args.nodeId,
+        ...args.depth !== void 0 && { depth: parseInt(args.depth, 10) },
+        ...args.limit !== void 0 && { limit: parseInt(args.limit, 10) }
+      },
+      { command: "memory", operation: "memory.graph.neighbors" }
+    );
+  }
+});
+var graphAddCommand = defineCommand({
+  meta: { name: "graph-add", description: "Add a node or edge to the PageIndex graph" },
+  args: {
+    "node-id": {
+      type: "string",
+      description: "Node ID to add"
+    },
+    "node-type": {
+      type: "string",
+      description: "Node type (e.g. concept, task, file)"
+    },
+    label: {
+      type: "string",
+      description: "Label for the node"
+    },
+    from: {
+      type: "string",
+      description: "Source node ID for an edge"
+    },
+    to: {
+      type: "string",
+      description: "Target node ID for an edge"
+    },
+    "edge-type": {
+      type: "string",
+      description: "Edge relationship type"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "memory",
+      "graph.add",
+      {
+        ...args["node-id"] !== void 0 && { nodeId: args["node-id"] },
+        ...args["node-type"] !== void 0 && { nodeType: args["node-type"] },
+        ...args.label !== void 0 && { label: args.label },
+        ...args.from !== void 0 && { fromId: args.from },
+        ...args.to !== void 0 && { toId: args.to },
+        ...args["edge-type"] !== void 0 && { edgeType: args["edge-type"] }
+      },
+      { command: "memory", operation: "memory.graph.add" }
+    );
+  }
+});
+var graphRemoveCommand = defineCommand({
+  meta: { name: "graph-remove", description: "Remove a node or edge from the PageIndex graph" },
+  args: {
+    "node-id": {
+      type: "string",
+      description: "Node ID to remove"
+    },
+    from: {
+      type: "string",
+      description: "Source node ID of the edge to remove"
+    },
+    to: {
+      type: "string",
+      description: "Target node ID of the edge to remove"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "memory",
+      "graph.remove",
+      {
+        ...args["node-id"] !== void 0 && { nodeId: args["node-id"] },
+        ...args.from !== void 0 && { fromId: args.from },
+        ...args.to !== void 0 && { toId: args.to }
+      },
+      { command: "memory", operation: "memory.graph.remove" }
+    );
+  }
+});
+var reasonWhyCommand = defineCommand({
+  meta: { name: "reason-why", description: "Causal trace through task dependency chains" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID",
+      required: true
+    },
+    depth: {
+      type: "string",
+      description: "Maximum trace depth"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "reason.why",
+      {
+        taskId: args.taskId,
+        ...args.depth !== void 0 && { depth: parseInt(args.depth, 10) }
+      },
+      { command: "memory", operation: "memory.reason.why" }
+    );
+  }
+});
+var reasonSimilarCommand = defineCommand({
+  meta: { name: "reason-similar", description: "Find semantically similar brain entries" },
+  args: {
+    entryId: {
+      type: "positional",
+      description: "Entry ID",
+      required: true
+    },
+    limit: {
+      type: "string",
+      description: "Maximum results"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "reason.similar",
+      {
+        entryId: args.entryId,
+        ...args.limit !== void 0 && { limit: parseInt(args.limit, 10) }
+      },
+      { command: "memory", operation: "memory.reason.similar" }
+    );
+  }
+});
+var searchHybridCommand = defineCommand({
+  meta: {
+    name: "search-hybrid",
+    description: "Hybrid search across FTS5, vector, and graph indexes"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Search query",
+      required: true
+    },
+    limit: {
+      type: "string",
+      description: "Maximum results"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "search.hybrid",
+      {
+        query: args.query,
+        ...args.limit !== void 0 && { limit: parseInt(args.limit, 10) }
+      },
+      { command: "memory", operation: "memory.search.hybrid" }
+    );
+  }
+});
+var codeLinksCommand = defineCommand({
+  meta: {
+    name: "code-links",
+    description: "Show code \u2194 memory connections (code_reference edges between brain and nexus)"
+  },
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum entries to return (default 100)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "code.links",
+      {
+        ...args.limit !== void 0 && { limit: parseInt(args.limit, 10) }
+      },
+      { command: "memory", operation: "memory.code.links" }
+    );
+  }
+});
+var codeAutoLinkCommand = defineCommand({
+  meta: {
+    name: "code-auto-link",
+    description: "Scan brain memory nodes for entity references and auto-link to nexus code nodes"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run() {
+    await dispatchFromCli(
+      "mutate",
+      "memory",
+      "code.auto-link",
+      {},
+      { command: "memory", operation: "memory.code.auto-link" }
+    );
+  }
+});
+var codeMemoriesForCodeCommand = defineCommand({
+  meta: {
+    name: "code-memories-for-code",
+    description: "Find brain memory nodes that reference a given nexus code symbol"
+  },
+  args: {
+    symbol: {
+      type: "positional",
+      description: "Code symbol name",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "code.memories-for-code",
+      { symbol: args.symbol },
+      { command: "memory", operation: "memory.code.memories-for-code" }
+    );
+  }
+});
+var codeForMemoryCommand = defineCommand({
+  meta: {
+    name: "code-for-memory",
+    description: "Find nexus code nodes referenced by a given brain memory entry"
+  },
+  args: {
+    memoryId: {
+      type: "positional",
+      description: "Memory entry ID",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "code.for-memory",
+      { memoryId: args.memoryId },
+      { command: "memory", operation: "memory.code.for-memory" }
+    );
+  }
+});
+var consolidateCommand = defineCommand({
+  meta: {
+    name: "consolidate",
+    description: "Run the full brain consolidation pipeline: dedup, quality recompute, tier promotion, contradiction detection, soft eviction, graph strengthening, summary generation. Equivalent to the session-end sleep-time consolidation but triggered on demand."
+  },
+  args: {},
+  async run() {
+    const root = getProjectRoot();
+    try {
+      const result = await runConsolidation(root);
+      cliOutput(result, { command: "memory-consolidate", operation: "memory.consolidate" });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`Memory consolidation failed: ${message}`, "E_INTERNAL", { name: "E_INTERNAL" });
+      process.exit(1);
+    }
+  }
+});
+var dreamCommand = defineCommand({
+  meta: {
+    name: "dream",
+    description: "Manually trigger the full auto-dream cycle: consolidation pipeline including R-STDP reward backfill (Step 9a), STDP plasticity (Step 9b), and homeostatic decay (Step 9c). Equivalent to autonomous nightly consolidation but triggered on demand. Idempotent \u2014 safe to run multiple times. Use --status to check engine liveness without triggering consolidation."
+  },
+  args: {
+    status: {
+      type: "boolean",
+      description: "Return engine liveness status as JSON instead of triggering a dream cycle. Fields: lastConsolidatedAt, observationsSinceLastConsolidation, idleMinutesSinceLastRetrieval, tickLoopAlive, lastTickAt, dreamInFlight, lastError, isOverdue. Exits with code 1 when isOverdue=true.",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const root = getProjectRoot();
+    if (args.status) {
+      try {
+        const status = await getDreamStatus(root);
+        cliOutput(status, { command: "memory-dream-status", operation: "memory.dream.status" });
+        if (status.isOverdue) {
+          process.exit(1);
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        cliError(`Dream status check failed: ${message}`, "E_INTERNAL", { name: "E_INTERNAL" });
+        process.exit(1);
+      }
+      return;
+    }
+    try {
+      const result = await triggerManualDream(root);
+      cliOutput(result, { command: "memory-dream", operation: "memory.dream" });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`Dream cycle failed: ${message}`, "E_INTERNAL", { name: "E_INTERNAL" });
+      process.exit(1);
+    }
+  }
+});
+var reflectCommand = defineCommand({
+  meta: {
+    name: "reflect",
+    description: "Manually trigger the LLM Observer + Reflector pipeline for the most recent session. Observer compresses session observations; Reflector synthesizes patterns and learnings. Requires ANTHROPIC_API_KEY to be set."
+  },
+  args: {
+    session: {
+      type: "string",
+      description: "Run against a specific session ID (default: most recent session)"
+    }
+  },
+  async run({ args }) {
+    const root = getProjectRoot();
+    try {
+      const { runObserver, runReflector } = await import("@cleocode/core/memory");
+      const observerResult = await runObserver(root, args.session, {
+        thresholdOverride: 1
+      });
+      const reflectorResult = await runReflector(root, args.session);
+      const data = {
+        observer: {
+          ran: observerResult.ran,
+          stored: observerResult.stored,
+          compressedIds: observerResult.compressedIds
+        },
+        reflector: {
+          ran: reflectorResult.ran,
+          patternsStored: reflectorResult.patternsStored,
+          learningsStored: reflectorResult.learningsStored,
+          supersededIds: reflectorResult.supersededIds
+        }
+      };
+      cliOutput(data, { command: "memory-reflect", operation: "memory.reflect" });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`Reflect failed: ${message}`, "E_INTERNAL", { name: "E_INTERNAL" });
+      process.exit(1);
+    }
+  }
+});
+var pruneStubsCommand = defineCommand({
+  meta: {
+    name: "prune-stubs",
+    description: 'Report (and with --apply, quarantine) content-free BRAIN observation stubs \u2014 auto-hook task-start/complete records and the "status: undefined" artefact of T12071. These are short enough that BM25 length-normalisation ranks them ABOVE substantive memories, so they actively degrade recall. Dry-run by default.'
+  },
+  args: {
+    apply: {
+      type: "boolean",
+      description: "Quarantine matched rows and return a recovery receipt (default: report only)"
+    }
+  },
+  async run({ args }) {
+    const root = getProjectRoot();
+    await getBrainDb(root);
+    const { getBrainNativeDb } = await import("@cleocode/core/internal");
+    const nativeDb = getBrainNativeDb();
+    if (!nativeDb) {
+      cliError("BRAIN database is not open");
+      return;
+    }
+    const { pruneObservationStubs } = await import("@cleocode/core/internal");
+    const result = pruneObservationStubs(nativeDb, Boolean(args.apply));
+    cliOutput(result, { command: "memory prune-stubs", operation: "memory.prune-stubs" });
+  }
+});
+var pruneTraitsCommand = defineCommand({
+  meta: {
+    name: "prune-traits",
+    description: `Report (and with --apply, remove) user-profile traits that are operation receipts or status lines ("Operation succeeded in domain 'check'", "gate set to true for T123"). --envelope-derived also matches every legacy dialectic trait with no project stamp: those were minted from operation envelopes. Apply backs rows up first; --restore <backup> reverses it. Dry-run by default.`
+  },
+  args: {
+    apply: {
+      type: "boolean",
+      description: "Back up, then delete matched rows and return a receipt (default: report only)"
+    },
+    "envelope-derived": {
+      type: "boolean",
+      description: "Also match legacy dialectic:* traits with no project stamp"
+    },
+    restore: {
+      type: "string",
+      description: "Re-insert the rows from a prune-traits backup file (never overwrites)"
+    },
+    sha256: {
+      type: "string",
+      description: "With --restore: the receipt backupSha256; a mismatching backup is refused"
+    }
+  },
+  async run({ args }) {
+    const core = await import("@cleocode/core/internal");
+    const nexusDb = await core.getNexusDb(getProjectRoot());
+    const result = args.restore ? await core.restorePrunedTraits(
+      nexusDb,
+      String(args.restore),
+      args.sha256 ? String(args.sha256) : void 0
+    ) : await core.pruneReceiptTraits(nexusDb, {
+      apply: Boolean(args.apply),
+      includeEnvelopeDerived: Boolean(args["envelope-derived"])
+    });
+    cliOutput(result, { command: "memory prune-traits", operation: "memory.prune-traits" });
+  }
+});
+var setTraitScopeCommand = defineCommand({
+  meta: {
+    name: "set-trait-scope",
+    description: `Set a user-profile trait scope: "user" = user-global, injected into every project's agent prompts; "project" = only the project it was derived in.`
+  },
+  args: {
+    key: { type: "positional", description: "Trait key", required: true },
+    scope: { type: "positional", description: "project | user", required: true }
+  },
+  async run({ args }) {
+    const scope = String(args.scope);
+    if (scope !== "project" && scope !== "user") {
+      cliError(`scope must be "project" or "user", got "${scope}"`, "E_VALIDATION", {
+        name: "E_VALIDATION"
+      });
+      return;
+    }
+    const core = await import("@cleocode/core/internal");
+    const nexusDb = await core.getNexusDb(getProjectRoot());
+    const previous = await core.setUserProfileTraitScope(nexusDb, String(args.key), scope);
+    if (previous === null) {
+      cliError(`No user-profile trait "${args.key}"`, "E_NOT_FOUND", { name: "E_NOT_FOUND" });
+      return;
+    }
+    cliOutput(
+      { traitKey: args.key, previousScope: previous, scope },
+      { command: "memory set-trait-scope", operation: "memory.set-trait-scope" }
+    );
+  }
+});
+var dedupScanCommand = defineCommand({
+  meta: {
+    name: "dedup-scan",
+    description: "Scan brain.db for potential duplicate entries by content-hash and keyword similarity. Reports duplicates per table without modifying any data. Use --apply to merge confirmed duplicates via the consolidation pipeline."
+  },
+  args: {
+    apply: {
+      type: "boolean",
+      description: "Run full consolidation to merge duplicates (calls cleo memory consolidate internally)"
+    }
+  },
+  async run({ args }) {
+    const root = getProjectRoot();
+    try {
+      await getBrainDb(root);
+      const { totalDuplicateRows, groups } = await scanDuplicateEntries();
+      if (args.apply) {
+        const result = await runConsolidation(root);
+        cliOutput(
+          {
+            totalDuplicateRows,
+            groups,
+            applied: true,
+            consolidation: { deduplicated: result.deduplicated }
+          },
+          { command: "memory-dedup-scan", operation: "memory.dedup-scan" }
+        );
+      } else {
+        cliOutput(
+          { totalDuplicateRows, groups, applied: false },
+          { command: "memory-dedup-scan", operation: "memory.dedup-scan" }
+        );
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`Dedup scan failed: ${message}`, "E_INTERNAL", { name: "E_INTERNAL" });
+      process.exit(1);
+    }
+  }
+});
+var importCommand = defineCommand({
+  meta: {
+    name: "import",
+    description: "Import memory files from a provider-specific directory (e.g. ~/.claude/projects/*/memory/) into brain.db. Enables provider-agnostic memory via CLEO CLI instead of Claude Code MEMORY.md."
+  },
+  args: {
+    from: {
+      type: "string",
+      description: "Source directory containing *.md memory files (default: ~/.claude/projects/-mnt-projects-cleocode/memory)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Print what would be imported without writing to brain.db"
+    }
+  },
+  async run({ args }) {
+    const sourceDir = args.from;
+    const isDryRun = !!args["dry-run"];
+    const projectRoot = getProjectRoot();
+    try {
+      const result = await importMemoryFiles({
+        sourceDir,
+        dryRun: isDryRun,
+        projectRoot,
+        cleoDirName: CLEO_DIR_NAME,
+        hasheFileName: MIGRATE_MEMORY_HASHES_JSON,
+        dispatch: dispatchFromCli
+      });
+      cliOutput(
+        {
+          total: result.total,
+          imported: result.imported,
+          skipped: result.skipped,
+          errors: result.errors,
+          dryRun: isDryRun,
+          importedEntries: result.importedEntries,
+          skippedEntries: result.skippedEntries,
+          errorEntries: result.errorEntries
+        },
+        { command: "memory-import", operation: "memory.import" }
+      );
+      if (result.errors > 0) process.exit(1);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(message, "E_NOT_FOUND", { name: "E_NOT_FOUND" });
+      process.exit(1);
+    }
+  }
+});
+var doctorCommand = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Read-only brain noise scan: detects duplicate-content, missing-type, missing-provenance, orphan-edge, low-confidence, and stale-unverified patterns. Use --assert-clean as the M7 entry gate before enabling Sentient v1 (`cleo sentient propose enable`)."
+  },
+  args: {
+    "assert-clean": {
+      type: "boolean",
+      description: "Exit non-zero when any noise patterns are detected (M7 gate for Sentient v1)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "doctor",
+      { "assert-clean": args["assert-clean"] },
+      { command: "memory-doctor", operation: "memory.doctor" }
+    );
+  }
+});
+var llmStatusCommand = defineCommand({
+  meta: {
+    name: "llm-status",
+    description: "Report LLM backend resolution status and extraction readiness. Shows which source resolved the Anthropic API key (env/config/oauth/none), whether LLM extraction is enabled, and when extraction last ran."
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run() {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "llm-status",
+      {},
+      { command: "memory-llm-status", operation: "memory.llm-status" }
+    );
+  }
+});
+var verifyCommand = defineCommand({
+  meta: {
+    name: "verify",
+    description: "Promote a brain memory entry to verified=true. Requires caller identity of cleo-prime or owner. Flips the verified flag in brain_observations (or typed table), enabling long-tier promotion and ground-truth retrieval weighting."
+  },
+  args: {
+    id: {
+      type: "positional",
+      description: "Brain entry ID to verify",
+      required: true
+    },
+    agent: {
+      type: "string",
+      description: "Caller identity ('cleo-prime' or 'owner'). Omit when calling from the owner terminal (no identity required)."
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "memory",
+      "verify",
+      {
+        id: args.id,
+        ...args.agent !== void 0 && { agent: args.agent }
+      },
+      { command: "memory-verify", operation: "memory.verify" }
+    );
+  }
+});
+var pendingVerifyCommand = defineCommand({
+  meta: {
+    name: "pending-verify",
+    description: "List brain memory entries that are unverified (verified=false) but highly cited (citation_count >= threshold). These are strong candidates for manual verification via 'cleo memory verify <id>'."
+  },
+  args: {
+    "min-citations": {
+      type: "string",
+      description: "Minimum citation count threshold (default: 5)"
+    },
+    limit: {
+      type: "string",
+      description: "Maximum entries to return (default: 50)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "pending-verify",
+      {
+        ...args["min-citations"] !== void 0 && {
+          minCitations: parseInt(args["min-citations"], 10)
+        },
+        ...args.limit !== void 0 && { limit: parseInt(args.limit, 10) }
+      },
+      { command: "memory-pending-verify", operation: "memory.pending-verify" }
+    );
+  }
+});
+var tierStatsCommand = defineCommand({
+  meta: {
+    name: "stats",
+    description: "Show tier distribution across all brain tables + countdown to next long-tier promotions (top-10)"
+  },
+  args: {},
+  async run() {
+    const root = getProjectRoot();
+    try {
+      await getBrainDb(root);
+      const result = await getTierStats(root);
+      const distribution = {};
+      for (const t of result.tables) {
+        distribution[t.table] = { short: t.short, medium: t.medium, long: t.long };
+      }
+      const top10 = result.upcomingLongPromotions.slice(0, 10);
+      cliOutput(
+        { distribution, upcomingLongPromotions: top10 },
+        { command: "memory-tier-stats", operation: "memory.tier.stats" }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`Tier stats failed: ${message}`, "E_INTERNAL", { name: "E_INTERNAL" });
+      process.exit(1);
+    }
+  }
+});
+var tierPromoteCommand = defineCommand({
+  meta: {
+    name: "promote",
+    description: "Manually promote a memory entry to a higher tier (bypasses age gate)"
+  },
+  args: {
+    id: {
+      type: "positional",
+      description: "Brain entry ID",
+      required: true
+    },
+    to: {
+      type: "string",
+      description: "Target tier: medium or long",
+      required: true
+    },
+    reason: {
+      type: "string",
+      description: "Reason for manual promotion (required)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const root = getProjectRoot();
+    const targetTier = args.to;
+    const reason = args.reason;
+    const validTiers = ["medium", "long"];
+    if (!validTiers.includes(targetTier)) {
+      cliError(
+        `Invalid target tier: ${targetTier}. Must be one of: ${validTiers.join(", ")}`,
+        "E_VALIDATION",
+        { name: "E_VALIDATION" }
+      );
+      process.exit(1);
+      return;
+    }
+    try {
+      await getBrainDb(root);
+      const result = await setEntryTier(args.id, targetTier, "promote");
+      cliOutput(
+        {
+          id: result.id,
+          table: result.table,
+          fromTier: result.fromTier,
+          toTier: result.toTier,
+          reason,
+          promotedAt: result.updatedAt
+        },
+        { command: "memory-tier-promote", operation: "memory.tier.promote" }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const isValidation = message.includes("already at tier") || message.includes("Cannot promote") || message.includes("not found");
+      if (isValidation) {
+        cliError(message, "E_VALIDATION", { name: "E_VALIDATION" });
+      } else {
+        cliError(`Tier promote failed: ${message}`, "E_INTERNAL", { name: "E_INTERNAL" });
+      }
+      process.exit(1);
+    }
+  }
+});
+var tierDemoteCommand = defineCommand({
+  meta: {
+    name: "demote",
+    description: "Manually demote a memory entry to a lower tier"
+  },
+  args: {
+    id: {
+      type: "positional",
+      description: "Brain entry ID",
+      required: true
+    },
+    to: {
+      type: "string",
+      description: "Target tier: short or medium",
+      required: true
+    },
+    reason: {
+      type: "string",
+      description: "Reason for manual demotion (required)",
+      required: true
+    },
+    force: {
+      type: "boolean",
+      description: "Required when demoting from long tier"
+    }
+  },
+  async run({ args }) {
+    const root = getProjectRoot();
+    const targetTier = args.to;
+    const reason = args.reason;
+    const validTiers = ["short", "medium"];
+    if (!validTiers.includes(targetTier)) {
+      cliError(
+        `Invalid target tier for demotion: ${targetTier}. Must be one of: ${validTiers.join(", ")}`,
+        "E_VALIDATION",
+        { name: "E_VALIDATION" }
+      );
+      process.exit(1);
+      return;
+    }
+    try {
+      await getBrainDb(root);
+      const result = await setEntryTier(args.id, targetTier, "demote", { force: !!args.force });
+      cliOutput(
+        {
+          id: result.id,
+          table: result.table,
+          fromTier: result.fromTier,
+          toTier: result.toTier,
+          reason,
+          demotedAt: result.updatedAt
+        },
+        { command: "memory-tier-demote", operation: "memory.tier.demote" }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const isValidation = message.includes("already at tier") || message.includes("Cannot demote") || message.includes("not found") || message.includes("long tier") || message.includes("Long-tier");
+      if (isValidation) {
+        cliError(message, "E_VALIDATION", { name: "E_VALIDATION" });
+      } else {
+        cliError(`Tier demote failed: ${message}`, "E_INTERNAL", { name: "E_INTERNAL" });
+      }
+      process.exit(1);
+    }
+  }
+});
+function makeMemorySubcommand(opts) {
+  const mergedArgs = {
+    ...opts.args,
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  };
+  return defineCommand({
+    meta: { name: opts.name, description: opts.description },
+    args: mergedArgs,
+    async run({ args }) {
+      const params = opts.paramBuilder(args);
+      await dispatchFromCli(opts.gateway, "memory", opts.operation, params, opts.output);
+    }
+  });
+}
+var precompactFlushCommand = makeMemorySubcommand({
+  name: "precompact-flush",
+  description: "Flush in-flight observations to brain.db and checkpoint the SQLite WAL before context compaction (T1004).",
+  args: {},
+  gateway: "mutate",
+  operation: "precompact-flush",
+  output: { command: "memory-precompact-flush", operation: "memory.precompact-flush" },
+  paramBuilder: () => ({})
+});
+var backfillRunCommand = makeMemorySubcommand({
+  name: "run",
+  description: "Stage a brain-graph backfill run (pending approval). Pass --source to tag the run with a human-readable descriptor.",
+  args: {
+    source: {
+      type: "string",
+      description: "Human-readable descriptor for the backfill source (file path, session ID, etc)."
+    },
+    kind: {
+      type: "string",
+      description: "Backfill kind (default: 'graph-backfill')."
+    },
+    "node-ids": {
+      type: "string",
+      description: "Comma-separated exact qualified graph node IDs to stage; every ID must be eligible and missing."
+    },
+    "target-table": {
+      type: "string",
+      description: "Target table (default: 'brain_page_nodes')."
+    }
+  },
+  gateway: "mutate",
+  operation: "backfill.run",
+  output: { command: "memory-backfill-run", operation: "memory.backfill.run" },
+  paramBuilder: (args) => ({
+    ...args["node-ids"] !== void 0 && {
+      nodeIds: String(args["node-ids"]).split(",").map((id) => id.trim())
+    },
+    ...args["source"] !== void 0 && { source: args["source"] },
+    ...args["kind"] !== void 0 && { kind: args["kind"] },
+    ...args["target-table"] !== void 0 && { targetTable: args["target-table"] }
+  })
+});
+var backfillApproveCommand = makeMemorySubcommand({
+  name: "approve",
+  description: "Approve a staged backfill run (commits rows to brain_page_nodes). Idempotent \u2014 re-approval returns alreadySettled=true.",
+  args: {
+    runId: {
+      type: "positional",
+      description: "Backfill run ID to approve",
+      required: true
+    },
+    "approved-by": {
+      type: "string",
+      description: "Identity of the approver (default: 'cli')."
+    }
+  },
+  gateway: "mutate",
+  operation: "backfill.approve",
+  output: { command: "memory-backfill-approve", operation: "memory.backfill.approve" },
+  paramBuilder: (args) => ({
+    runId: args["runId"],
+    ...args["approved-by"] !== void 0 && { approvedBy: args["approved-by"] }
+  })
+});
+var backfillRollbackCommand = makeMemorySubcommand({
+  name: "rollback",
+  description: "Rollback a staged or committed backfill run. Removes any rows written to brain_page_nodes.",
+  args: {
+    runId: {
+      type: "positional",
+      description: "Backfill run ID to rollback",
+      required: true
+    }
+  },
+  gateway: "mutate",
+  operation: "backfill.rollback",
+  output: { command: "memory-backfill-rollback", operation: "memory.backfill.rollback" },
+  paramBuilder: (args) => ({
+    runId: args["runId"]
+  })
+});
+var backfillCommand = defineCommand({
+  meta: {
+    name: "backfill",
+    description: "Staged brain-graph backfill operations: run, approve, rollback (T1003)."
+  },
+  subCommands: {
+    run: backfillRunCommand,
+    approve: backfillApproveCommand,
+    rollback: backfillRollbackCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+var digestCommand = defineCommand({
+  meta: {
+    name: "digest",
+    description: "Summarized top-N brain observations for session briefing (T1006). Pass --hygiene to show latest hygiene scan results from the sentient background loop (T1636)."
+  },
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum number of observations to include (default: 10)."
+    },
+    hygiene: {
+      type: "boolean",
+      description: "Show only hygiene observations (hygiene:orphan, hygiene:top-level-orphan, hygiene:content-defect, hygiene:premature-close-leak) from the sentient background loop (T1636)."
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    if (args.hygiene) {
+      await dispatchFromCli(
+        "query",
+        "memory",
+        "find",
+        {
+          query: "hygiene:",
+          limit: args.limit !== void 0 ? parseInt(args.limit, 10) : 20
+        },
+        { command: "memory-hygiene-digest", operation: "memory.find" }
+      );
+    } else {
+      await dispatchFromCli(
+        "query",
+        "memory",
+        "digest",
+        {
+          ...args["limit"] !== void 0 && { limit: parseInt(args["limit"], 10) }
+        },
+        { command: "memory-digest", operation: "memory.digest" }
+      );
+    }
+  }
+});
+var recentCommand = makeMemorySubcommand({
+  name: "recent",
+  description: "Tail recent brain observations with optional filters (T1006). --since accepts 30m / 24h / 7d or an ISO timestamp.",
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum number of observations to return (default: 20)."
+    },
+    type: {
+      type: "string",
+      description: "Filter by observation type (discovery, decision, bugfix, refactor, feature, change, diary, session-summary)."
+    },
+    since: {
+      type: "string",
+      description: "Duration (e.g. 24h, 7d, 30m) or ISO timestamp lower bound."
+    },
+    session: {
+      type: "string",
+      description: "Filter by source session ID."
+    },
+    tier: {
+      type: "string",
+      description: "Filter by memory tier ('short', 'medium', 'long')."
+    }
+  },
+  gateway: "query",
+  operation: "recent",
+  output: { command: "memory-recent", operation: "memory.recent" },
+  paramBuilder: (args) => ({
+    ...args["limit"] !== void 0 && { limit: parseInt(args["limit"], 10) },
+    ...args["type"] !== void 0 && { type: args["type"] },
+    ...args["since"] !== void 0 && { since: args["since"] },
+    ...args["session"] !== void 0 && { session: args["session"] },
+    ...args["tier"] !== void 0 && { tier: args["tier"] }
+  })
+});
+var diaryReadCommand = makeMemorySubcommand({
+  name: "read",
+  description: "Read recent diary-typed observations (T1006).",
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum number of diary entries to return (default: 20)."
+    }
+  },
+  gateway: "query",
+  operation: "diary",
+  output: { command: "memory-diary-read", operation: "memory.diary" },
+  paramBuilder: (args) => ({
+    ...args["limit"] !== void 0 && { limit: parseInt(args["limit"], 10) }
+  })
+});
+var diaryWriteCommand = makeMemorySubcommand({
+  name: "write",
+  description: "Write a diary-typed observation to brain.db (T1006).",
+  args: {
+    text: {
+      type: "positional",
+      description: "Diary entry text",
+      required: true
+    },
+    title: {
+      type: "string",
+      description: "Optional diary entry title (defaults to first 120 chars of text)."
+    },
+    agent: {
+      type: "string",
+      description: "Optional agent provenance (e.g. cleo-prime, historian)."
+    }
+  },
+  gateway: "mutate",
+  operation: "diary.write",
+  output: { command: "memory-diary-write", operation: "memory.diary.write" },
+  paramBuilder: (args) => ({
+    text: args["text"],
+    ...args["title"] !== void 0 && { title: args["title"] },
+    ...args["agent"] !== void 0 && { agent: args["agent"] }
+  })
+});
+var diaryCommand = defineCommand({
+  meta: {
+    name: "diary",
+    description: "Read or write diary-typed brain observations (T1006)."
+  },
+  subCommands: {
+    read: diaryReadCommand,
+    write: diaryWriteCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+var watchCommand = defineCommand({
+  meta: {
+    name: "watch",
+    description: "Long-poll stream of recent brain writes. Use --follow to stream continuously as SSE-style events."
+  },
+  args: {
+    cursor: {
+      type: "string",
+      description: "Resume cursor (created_at lower bound) from a previous watch call."
+    },
+    limit: {
+      type: "string",
+      description: "Maximum events per poll (default: 10)."
+    },
+    follow: {
+      type: "boolean",
+      description: "Stream continuously; polls every --interval ms until interrupted."
+    },
+    interval: {
+      type: "string",
+      description: "Poll interval in milliseconds when --follow is set (default: 1000)."
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON (non-follow mode only)."
+    }
+  },
+  async run({ args }) {
+    const buildParams = (cursor) => ({
+      ...cursor !== void 0 && { cursor },
+      ...args.limit !== void 0 && { limit: parseInt(args.limit, 10) }
+    });
+    if (!args.follow) {
+      await dispatchFromCli(
+        "query",
+        "memory",
+        "watch",
+        buildParams(args.cursor),
+        { command: "memory-watch", operation: "memory.watch" }
+      );
+      return;
+    }
+    const abortController = new AbortController();
+    const onSignal = () => abortController.abort();
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+    const stream = streamMemoryWatchEvents({
+      cursor: args.cursor,
+      limit: args.limit !== void 0 ? parseInt(args.limit, 10) : void 0,
+      intervalMs: args.interval !== void 0 ? parseInt(args.interval, 10) : 1e3,
+      dispatchRaw,
+      signal: abortController.signal
+    });
+    for await (const item of stream) {
+      if (item.kind === "ping") {
+        process.stdout.write(`event: ping
+data: ${JSON.stringify({ ts: item.ts })}
+
+`);
+      } else if (item.kind === "events") {
+        for (const event of item.events) {
+          process.stdout.write(`event: observation
+data: ${JSON.stringify(event)}
+
+`);
+        }
+      } else if (item.kind === "error") {
+        cliError(item.message, 1, { name: item.code }, { operation: "memory.watch" });
+        process.exit(1);
+        return;
+      } else if (item.kind === "close") {
+        process.stdout.write(`event: close
+data: ${JSON.stringify({ ts: item.ts })}
+
+`);
+      }
+    }
+  }
+});
+var tierCommand = defineCommand({
+  meta: { name: "tier", description: "Memory tier management: stats, promote, demote" },
+  subCommands: {
+    stats: tierStatsCommand,
+    promote: tierPromoteCommand,
+    demote: tierDemoteCommand
+  }
+});
+var sweepCommand = defineCommand({
+  meta: {
+    name: "sweep",
+    description: "T1147 W7 BRAIN noise sweep. --dry-run: detect noise candidates. --approve <runId>: apply to live tables. --status: list runs. --rollback <runId>: discard staged run."
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Detect noise candidates without staging DB writes."
+    },
+    approve: {
+      type: "string",
+      description: "Run ID to approve and apply to live tables."
+    },
+    status: {
+      type: "boolean",
+      description: "List recent noise-sweep-2440 runs."
+    },
+    rollback: {
+      type: "string",
+      description: "Run ID to roll back without applying changes."
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({
+    args
+  }) {
+    const gateway = args.approve || args.rollback ? "mutate" : "query";
+    await dispatchFromCli(
+      gateway,
+      "memory",
+      "sweep",
+      {
+        "dry-run": args["dry-run"],
+        approve: args.approve,
+        status: args.status,
+        rollback: args.rollback
+      },
+      { command: "memory-sweep", operation: "memory.sweep" }
+    );
+  }
+});
+var memoryCommand = defineCommand({
+  meta: {
+    name: "memory",
+    description: "BRAIN memory operations (patterns, learnings, decisions \u2014 use decision-store/-find for architectural decisions)"
+  },
+  subCommands: {
+    store: storeCommand,
+    find: findCommand,
+    stats: statsCommand,
+    observe: observeCommand,
+    timeline: timelineCommand,
+    fetch: fetchCommand,
+    "decision-find": decisionFindCommand,
+    "decision-store": decisionStoreCommand,
+    link: linkCommand,
+    trace: traceCommand,
+    related: relatedCommand,
+    context: contextCommand,
+    "graph-stats": graphStatsCommand,
+    "graph-show": graphShowCommand,
+    "graph-neighbors": graphNeighborsCommand,
+    "graph-add": graphAddCommand,
+    "graph-remove": graphRemoveCommand,
+    "reason-why": reasonWhyCommand,
+    "reason-similar": reasonSimilarCommand,
+    "search-hybrid": searchHybridCommand,
+    "code-links": codeLinksCommand,
+    "code-auto-link": codeAutoLinkCommand,
+    "code-memories-for-code": codeMemoriesForCodeCommand,
+    "code-for-memory": codeForMemoryCommand,
+    consolidate: consolidateCommand,
+    dream: dreamCommand,
+    reflect: reflectCommand,
+    "dedup-scan": dedupScanCommand,
+    "prune-stubs": pruneStubsCommand,
+    "prune-traits": pruneTraitsCommand,
+    "set-trait-scope": setTraitScopeCommand,
+    import: importCommand,
+    doctor: doctorCommand,
+    "llm-status": llmStatusCommand,
+    verify: verifyCommand,
+    "pending-verify": pendingVerifyCommand,
+    tier: tierCommand,
+    // T1013 — new memory subcommands
+    "precompact-flush": precompactFlushCommand,
+    backfill: backfillCommand,
+    digest: digestCommand,
+    recent: recentCommand,
+    diary: diaryCommand,
+    watch: watchCommand,
+    // T1147 W7 — BRAIN noise sweep
+    sweep: sweepCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  memoryCommand
+};
+//# sourceMappingURL=memory-UHYIVGVM.js.map