@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/brain-273N3FW4.js

@@ -0,0 +1,400 @@
+(() => {
+  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 {
+  cliError,
+  cliOutput,
+  humanInfo,
+  humanProgress
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/brain.ts
+import { getProjectRoot } from "@cleocode/core";
+import {
+  backfillBrainGraph,
+  exportBrainAsGexf,
+  exportBrainAsJson,
+  getMemoryQualityReport,
+  getPlasticityStats,
+  purgeBrainNoise,
+  runBrainMaintenance
+} from "@cleocode/core/memory";
+var maintenanceCommand = defineCommand({
+  meta: {
+    name: "maintenance",
+    description: "Run brain maintenance: temporal decay, consolidation, and embedding backfill"
+  },
+  args: {
+    "skip-decay": {
+      type: "boolean",
+      description: "Skip the temporal decay step (confidence reduction on stale learnings)"
+    },
+    "skip-consolidation": {
+      type: "boolean",
+      description: "Skip the memory consolidation step (merging old observations)"
+    },
+    "skip-reconciliation": {
+      type: "boolean",
+      description: "Skip the cross-DB orphaned reference reconciliation step"
+    },
+    "skip-tier-promotion": {
+      type: "boolean",
+      description: "Skip the tier promotion step (short\u2192medium, medium\u2192long promotion)"
+    },
+    "skip-embeddings": {
+      type: "boolean",
+      description: "Skip the embedding backfill step (vector generation for observations)"
+    },
+    json: { type: "boolean", description: "Output results as JSON" }
+  },
+  async run({ args }) {
+    const root = getProjectRoot();
+    try {
+      const result = await runBrainMaintenance(root, {
+        skipDecay: !!args["skip-decay"],
+        skipConsolidation: !!args["skip-consolidation"],
+        skipReconciliation: !!args["skip-reconciliation"],
+        skipTierPromotion: !!args["skip-tier-promotion"],
+        skipEmbeddings: !!args["skip-embeddings"],
+        onProgress: (step, current, total) => {
+          if (step === "embeddings" && total > 0) {
+            if (process.stdout.isTTY) {
+              humanProgress(`\r  [embeddings] ${current}/${total}...`);
+            } else if (current === 1 || current === total) {
+              humanInfo(`  [embeddings] ${current}/${total}...`);
+            }
+          } else if (current === 0) {
+            humanInfo(`  [${step}] starting...`);
+          } else if (current === total && total > 0) {
+            if (step === "embeddings" && process.stdout.isTTY) {
+              humanProgress("\n");
+            }
+            humanInfo(`  [${step}] done`);
+          }
+        }
+      });
+      const data = {
+        duration: result.duration
+      };
+      if (!args["skip-decay"]) {
+        data["decay"] = result.decay;
+      }
+      if (!args["skip-consolidation"]) {
+        data["consolidation"] = result.consolidation;
+      }
+      if (!args["skip-tier-promotion"]) {
+        data["tierPromotion"] = result.tierPromotion;
+      }
+      if (!args["skip-reconciliation"]) {
+        data["reconciliation"] = result.reconciliation;
+      }
+      if (!args["skip-embeddings"]) {
+        data["embeddings"] = result.embeddings;
+      }
+      cliOutput(data, {
+        command: "brain-maintenance",
+        operation: "brain.maintenance",
+        message: `Maintenance complete in ${result.duration}ms`
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `Brain maintenance failed: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        {
+          operation: "brain.maintenance"
+        }
+      );
+      process.exit(1);
+    }
+  }
+});
+var backfillBrainCommand = defineCommand({
+  meta: {
+    name: "backfill",
+    description: "Back-fill brain_page_nodes and brain_page_edges from all surviving typed table rows (decisions, patterns, learnings, observations, sticky notes). Safe to re-run \u2014 duplicates are silently skipped."
+  },
+  args: {
+    json: { type: "boolean", description: "Output results as JSON" }
+  },
+  async run({ args: _args }) {
+    const root = getProjectRoot();
+    try {
+      const result = await backfillBrainGraph(root);
+      cliOutput(
+        {
+          before: result.before,
+          nodesInserted: result.nodesInserted,
+          stubsCreated: result.stubsCreated,
+          edgesInserted: result.edgesInserted,
+          after: result.after,
+          byType: result.byType
+        },
+        {
+          command: "brain-backfill",
+          operation: "brain.backfill",
+          message: `Back-fill complete: ${result.nodesInserted} nodes, ${result.edgesInserted} edges inserted`
+        }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `Brain backfill failed: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        {
+          operation: "brain.backfill"
+        }
+      );
+      process.exit(1);
+    }
+  }
+});
+var purgeCommand = defineCommand({
+  meta: {
+    name: "purge",
+    description: "Purge noise entries from brain.db \u2014 removes duplicate patterns, all learnings, test decisions, and task-lifecycle observations. TAKE A BACKUP FIRST."
+  },
+  args: {
+    json: { type: "boolean", description: "Output results as JSON" }
+  },
+  async run({ args: _args }) {
+    const root = getProjectRoot();
+    try {
+      const result = await purgeBrainNoise(root);
+      cliOutput(
+        {
+          patternsDeleted: result.patternsDeleted,
+          learningsDeleted: result.learningsDeleted,
+          decisionsDeleted: result.decisionsDeleted,
+          observationsDeleted: result.observationsDeleted,
+          after: result.after,
+          fts5Rebuilt: result.fts5Rebuilt
+        },
+        {
+          command: "brain-purge",
+          operation: "brain.purge",
+          message: "Purge complete"
+        }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `Brain purge failed: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        {
+          operation: "brain.purge"
+        }
+      );
+      process.exit(1);
+    }
+  }
+});
+var plasticityStatsCommand = defineCommand({
+  meta: {
+    name: "stats",
+    description: "Show recent STDP plasticity events: LTP/LTD counts, net weight delta, and most recent events."
+  },
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum recent events to show (default 20)",
+      default: "20"
+    },
+    json: { type: "boolean", description: "Output results as JSON" }
+  },
+  async run({ args }) {
+    const root = getProjectRoot();
+    const limit = Number.parseInt(args.limit, 10) || 20;
+    try {
+      const stats = await getPlasticityStats(root, limit);
+      cliOutput(
+        {
+          totalEvents: stats.totalEvents,
+          ltpCount: stats.ltpCount,
+          ltdCount: stats.ltdCount,
+          netDeltaW: stats.netDeltaW,
+          lastEventAt: stats.lastEventAt,
+          recentEvents: stats.recentEvents,
+          limit
+        },
+        {
+          command: "brain-plasticity-stats",
+          operation: "brain.plasticity.stats",
+          message: `${stats.totalEvents} plasticity event(s) recorded`
+        }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `Brain plasticity stats failed: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        { operation: "brain.plasticity.stats" }
+      );
+      process.exit(1);
+    }
+  }
+});
+var plasticityCommand = defineCommand({
+  meta: {
+    name: "plasticity",
+    description: "STDP timing-dependent plasticity operations (T626 phase 5)"
+  },
+  subCommands: {
+    stats: plasticityStatsCommand
+  }
+});
+var qualityCommand = defineCommand({
+  meta: {
+    name: "quality",
+    description: "Show memory quality metrics: retrieval rates, top/never-retrieved entries, quality distribution, and noise ratio."
+  },
+  args: {
+    json: { type: "boolean", description: "Output results as JSON" }
+  },
+  async run({ args: _args }) {
+    const root = getProjectRoot();
+    try {
+      const report = await getMemoryQualityReport(root);
+      cliOutput(
+        {
+          totalRetrievals: report.totalRetrievals,
+          uniqueEntriesRetrieved: report.uniqueEntriesRetrieved,
+          usageRate: report.usageRate,
+          noiseRatio: report.noiseRatio,
+          qualityDistribution: report.qualityDistribution,
+          tierDistribution: report.tierDistribution,
+          topRetrieved: report.topRetrieved,
+          neverRetrieved: report.neverRetrieved
+        },
+        {
+          command: "brain-quality",
+          operation: "brain.quality",
+          message: `Quality report: ${(report.usageRate * 100).toFixed(1)}% usage rate, ${(report.noiseRatio * 100).toFixed(1)}% noise`
+        }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `Brain quality report failed: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        { operation: "brain.quality" }
+      );
+      process.exit(1);
+    }
+  }
+});
+var exportCommand = defineCommand({
+  meta: {
+    name: "export",
+    description: "Export brain graph as GEXF (Gephi) or JSON format"
+  },
+  args: {
+    format: {
+      type: "string",
+      description: "Export format: gexf (Gephi standard) or json (flat arrays)",
+      default: "gexf"
+    },
+    output: {
+      type: "string",
+      description: "Write to file instead of stdout (optional)"
+    }
+  },
+  async run({ args }) {
+    const root = getProjectRoot();
+    const format = args.format ?? "gexf";
+    if (format !== "gexf" && format !== "json") {
+      cliError(`Invalid format: ${format}. Use 'gexf' or 'json'.`, "E_VALIDATION", {
+        name: "E_VALIDATION"
+      });
+      process.exit(1);
+    }
+    try {
+      let content;
+      let nodeCount;
+      let edgeCount;
+      if (format === "gexf") {
+        const result = await exportBrainAsGexf(root);
+        content = result.content;
+        nodeCount = result.nodeCount;
+        edgeCount = result.edgeCount;
+      } else {
+        const result = await exportBrainAsJson(root);
+        content = JSON.stringify(result, null, 2);
+        nodeCount = result.nodeCount;
+        edgeCount = result.edgeCount;
+      }
+      if (args.output) {
+        const fs = await import("node:fs");
+        fs.writeFileSync(args.output, content, "utf-8");
+        cliOutput(
+          {
+            outputFile: args.output,
+            nodeCount,
+            edgeCount,
+            format
+          },
+          {
+            command: "brain-export",
+            operation: "brain.export",
+            message: `Exported to ${args.output}: ${nodeCount} nodes, ${edgeCount} edges (${format.toUpperCase()})`
+          }
+        );
+      } else {
+        process.stdout.write(content + "\n");
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `Brain export failed: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        {
+          operation: "brain.export"
+        }
+      );
+      process.exit(1);
+    }
+  }
+});
+var brainCommand = defineCommand({
+  meta: { name: "brain", description: "Brain memory optimization operations" },
+  subCommands: {
+    maintenance: maintenanceCommand,
+    backfill: backfillBrainCommand,
+    purge: purgeCommand,
+    plasticity: plasticityCommand,
+    quality: qualityCommand,
+    export: exportCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  brainCommand
+};
+//# sourceMappingURL=brain-273N3FW4.js.map

package/dist/cli/briefing-7H6OLECX.js

@@ -0,0 +1,212 @@
+(() => {
+  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 {
+  isSubCommandDispatch
+} from "./chunk-YY66LFZF.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./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/briefing.ts
+import { pushWarning } from "@cleocode/core";
+var ADAPTER_FORMATS = ["claude", "codex", "gemini", "compact-json"];
+function renderForAdapter(sectionName, content, format) {
+  switch (format) {
+    case "claude":
+    case "gemini":
+      return content;
+    case "codex": {
+      const stripped = content.replace(/\*\*(.*?)\*\*/g, "$1").replace(/\*(.*?)\*/g, "$1").split("\n").filter((line) => !/^\|[-: |]+\|$/.test(line)).join("\n");
+      return stripped;
+    }
+    case "compact-json":
+      return JSON.stringify({ section: sectionName, content }, null, 0);
+  }
+}
+function failInject(message, fix) {
+  pushWarning({ code: "W_TEMPLATE_INJECT_FAILED", message });
+  cliError(message, 1, { name: "E_VALIDATION", fix }, { operation: "briefing.inject" });
+  process.exitCode = 1;
+}
+var briefingInjectCommand = defineCommand({
+  meta: {
+    name: "inject",
+    description: "Print one CLEO protocol section (core or on-demand reference) by name, e.g. --section task-creation"
+  },
+  args: {
+    section: {
+      type: "string",
+      description: "Section name (see the On-demand reference table in CLEO-INJECTION.md)",
+      required: true
+    },
+    format: {
+      type: "string",
+      description: "markdown (default) or adapter:<claude|codex|gemini|compact-json>",
+      default: "markdown"
+    }
+  },
+  async run({ args }) {
+    const { readInjectionSection } = await import("@cleocode/core/injection");
+    const sectionName = String(args.section ?? "");
+    const lookup = readInjectionSection(sectionName);
+    if (lookup.content === null) {
+      const available = lookup.available.join(", ");
+      failInject(
+        lookup.available.length === 0 ? "No CLEO protocol template found (package templates and installed CLEO-INJECTION.md are missing)." : `Section "${sectionName}" not found. Available sections: ${available}`,
+        lookup.available.length === 0 ? "Re-run `cleo init` or reinstall @cleocode/cleo." : `Pass one of: ${available}`
+      );
+      return;
+    }
+    const formatStr = String(args.format ?? "markdown");
+    let output = lookup.content;
+    if (formatStr.startsWith("adapter:")) {
+      const adapterName = formatStr.slice("adapter:".length);
+      if (!ADAPTER_FORMATS.includes(adapterName)) {
+        const supported = ADAPTER_FORMATS.join(", ");
+        failInject(
+          `Unknown adapter format "${adapterName}". Supported: ${supported}`,
+          `Pass one of: ${supported}`
+        );
+        return;
+      }
+      output = renderForAdapter(sectionName, lookup.content, adapterName);
+    }
+    cliOutput(
+      { section: sectionName, source: lookup.source, content: output },
+      { command: "briefing-inject", operation: "briefing.inject" }
+    );
+  }
+});
+var briefingCommand = defineCommand({
+  meta: {
+    name: "briefing",
+    description: "Session resume context: last handoff, current task, next tasks, bugs, blockers, epics, and memory. Use at session start to restore context."
+  },
+  args: {
+    scope: {
+      type: "string",
+      description: "Scope filter (global or epic:T###)",
+      alias: "s"
+    },
+    "max-next": {
+      type: "string",
+      description: "Maximum next tasks to show",
+      default: "3"
+    },
+    "max-bugs": {
+      type: "string",
+      description: "Maximum bugs to show",
+      default: "10"
+    },
+    "max-blocked": {
+      type: "string",
+      description: "Maximum blocked tasks to show",
+      default: "10"
+    },
+    "max-epics": {
+      type: "string",
+      description: "Maximum active epics to show",
+      default: "5"
+    },
+    /**
+     * T1905 / BBTT-W1-3: strict contract mode.
+     *
+     * When set, exit non-zero if the briefing contains any contract violations
+     * (stale data, duplicate IDs, excluded-provenance items). Use in CI to
+     * catch briefing regressions early.
+     */
+    strict: {
+      type: "boolean",
+      description: "Exit non-zero when briefing contract violations are detected (T1905)",
+      alias: "x"
+    },
+    /**
+     * T9974: debug mode — surface peerPatterns and other verbose fields
+     * suppressed by default. Passing --debug --with-profile --max-next 5
+     * restores the ~pre-T9974 output shape.
+     */
+    debug: {
+      type: "boolean",
+      description: "Include verbose debug fields (peerPatterns etc.) suppressed by default",
+      default: false
+    },
+    /**
+     * T9974: include cold.userProfile traits in the bundle.
+     * Off by default — large trait dump rarely needed at session start.
+     */
+    "with-profile": {
+      type: "boolean",
+      description: "Include user profile traits in the bundle (suppressed by default)",
+      default: false
+    },
+    /**
+     * T9964: restore full text fields on peerLearnings and decisions.
+     * By default these are truncated to 80-char previews with a `_next.fetch`
+     * hint. Pass --memory-detail to restore the full `insight` and `decision`
+     * body fields (equivalent to pre-T9964 output for those fields).
+     */
+    "memory-detail": {
+      type: "boolean",
+      description: "Restore full peerLearnings/decisions body text (suppressed by default for token budget)",
+      default: false
+    }
+  },
+  subCommands: {
+    inject: briefingInjectCommand
+  },
+  async run({ args, cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    const result = await dispatchFromCli(
+      "query",
+      "session",
+      "briefing.show",
+      {
+        scope: args.scope,
+        maxNextTasks: parseInt(args["max-next"], 10),
+        maxBugs: parseInt(args["max-bugs"], 10),
+        maxBlocked: parseInt(args["max-blocked"], 10),
+        maxEpics: parseInt(args["max-epics"], 10),
+        debug: args.debug,
+        withProfile: args["with-profile"],
+        memoryDetail: args["memory-detail"]
+      },
+      { command: "briefing" }
+    );
+    if (args.strict) {
+      const data = result?.["data"];
+      const violations = data?.["contractViolations"];
+      if (violations && violations.length > 0) {
+        process.exitCode = 1;
+      }
+    }
+  }
+});
+export {
+  briefingCommand
+};
+//# sourceMappingURL=briefing-7H6OLECX.js.map