@cleocode/cleo 2026.4.131 → 2026.4.133

package/dist/cli/index.js

@@ -5148,6 +5148,43 @@ var init_registry = __esm({
           }
         ]
       },
+      // T1147 W7 — BRAIN noise sweep (shadow-write envelope, self-healing gate)
+      {
+        gateway: "query",
+        domain: "memory",
+        operation: "sweep",
+        description: "memory.sweep (query/mutate) \u2014 T1147 W7 BRAIN noise sweep. dry-run: detect noise candidates and write sample JSON to agent-outputs. approve <runId>: apply sweep to live brain tables (sets killSwitch during tx). status: list all noise-sweep-2440 runs. rollback <runId>: discard a staged run without applying changes.",
+        tier: 0,
+        idempotent: false,
+        sessionRequired: false,
+        requiredParams: [],
+        params: [
+          {
+            name: "dry-run",
+            type: "boolean",
+            required: false,
+            description: "Detect noise candidates without staging DB writes."
+          },
+          {
+            name: "approve",
+            type: "string",
+            required: false,
+            description: "Run ID to approve and apply to live tables."
+          },
+          {
+            name: "status",
+            type: "boolean",
+            required: false,
+            description: "List recent noise-sweep-2440 runs."
+          },
+          {
+            name: "rollback",
+            type: "string",
+            required: false,
+            description: "Run ID to roll back without applying changes."
+          }
+        ]
+      },
       // T791 — LLM extraction backend status
       {
         gateway: "query",
@@ -19015,19 +19052,141 @@ var init_memory2 = __esm({
               const { scanBrainNoise } = await import("@cleocode/core/memory/brain-doctor.js");
               const result = await scanBrainNoise(projectRoot);
               const assertClean = params?.["assert-clean"];
-              if (assertClean && !result.isClean) {
-                return errorResult(
+              if (assertClean) {
+                let pendingCandidates = 0;
+                try {
+                  const { getBrainNativeDb: _getDoctorNativeDb } = await import("@cleocode/core/store/memory-sqlite.js");
+                  const doctorNativeDb = _getDoctorNativeDb();
+                  if (doctorNativeDb) {
+                    const tableExists = doctorNativeDb.prepare(
+                      `SELECT name FROM sqlite_master WHERE type='table' AND name='brain_v2_candidate'`
+                    ).get();
+                    if (tableExists) {
+                      const countRow = doctorNativeDb.prepare(
+                        `SELECT COUNT(*) AS cnt FROM brain_v2_candidate WHERE validation_status = 'pending'`
+                      ).get();
+                      pendingCandidates = countRow?.cnt ?? 0;
+                    }
+                  }
+                } catch {
+                }
+                if (!result.isClean) {
+                  return errorResult(
+                    "query",
+                    "memory",
+                    operation,
+                    "E_BRAIN_NOISE_DETECTED",
+                    `Brain noise detected: ${result.findings.length} pattern(s) across ${result.totalScanned} entries. ` + result.findings.map((f) => `${f.pattern}(${f.count})`).join(", ") + ". Run `cleo memory doctor` for details. Fix noise before enabling Sentient v1 (M7 gate).",
+                    startTime
+                  );
+                }
+                if (pendingCandidates > 0) {
+                  return errorResult(
+                    "query",
+                    "memory",
+                    operation,
+                    "E_SWEEP_PENDING",
+                    `Staged sweep has ${pendingCandidates} pending brain_v2_candidate rows. Run \`cleo memory sweep --status\` to review, then \`cleo memory sweep --approve <runId>\` to apply.`,
+                    startTime
+                  );
+                }
+              } else if (!result.isClean) {
+              }
+              return wrapResult(
+                { success: true, data: { ...result, pendingCandidates: 0 } },
+                "query",
+                "memory",
+                operation,
+                startTime
+              );
+            }
+            // T1147 W7 — BRAIN noise sweep (shadow-write envelope, self-healing gate)
+            case "sweep": {
+              const dryRun = params?.["dry-run"] === true || params?.dryRun === true;
+              const approveRunId = params?.approve;
+              const statusQuery = params?.status === true;
+              const rollbackRunId = params?.rollback;
+              if (statusQuery) {
+                const { getBrainDb: _getBrainDb2, getBrainNativeDb: _getNativeDb2 } = await import("@cleocode/core/store/memory-sqlite.js");
+                const sweepDb = await _getBrainDb2(projectRoot);
+                const nativeDb2 = _getNativeDb2();
+                if (!nativeDb2) {
+                  return errorResult(
+                    "query",
+                    "memory",
+                    operation,
+                    "E_DB_UNAVAILABLE",
+                    "brain.db not available",
+                    startTime
+                  );
+                }
+                const rows = nativeDb2.prepare(
+                  `SELECT id, status, rows_affected, created_at, approved_at, approved_by
+                 FROM brain_backfill_runs
+                 WHERE kind = 'noise-sweep-2440'
+                 ORDER BY created_at DESC
+                 LIMIT 20`
+                ).all();
+                void sweepDb;
+                return wrapResult(
+                  { success: true, data: { runs: rows } },
                   "query",
                   "memory",
                   operation,
-                  "E_BRAIN_NOISE_DETECTED",
-                  `Brain noise detected: ${result.findings.length} pattern(s) across ${result.totalScanned} entries. ` + result.findings.map((f) => `${f.pattern}(${f.count})`).join(", ") + ". Run `cleo memory doctor` for details. Fix noise before enabling Sentient v1 (M7 gate).",
                   startTime
                 );
               }
+              if (approveRunId) {
+                const { executeSweep } = await import("@cleocode/core/memory/brain-sweep-executor.js");
+                const result = await executeSweep({
+                  projectRoot,
+                  runId: approveRunId,
+                  approvedBy: "cleo-cli"
+                });
+                if (!result.success) {
+                  return errorResult(
+                    "mutate",
+                    "memory",
+                    operation,
+                    "E_SWEEP_FAILED",
+                    result.errorMessage ?? "Sweep failed",
+                    startTime
+                  );
+                }
+                return wrapResult(
+                  { success: true, data: result },
+                  "mutate",
+                  "memory",
+                  operation,
+                  startTime
+                );
+              }
+              if (rollbackRunId) {
+                const { rollbackSweep } = await import("@cleocode/core/memory/brain-sweep-executor.js");
+                const rolled = await rollbackSweep(projectRoot, rollbackRunId);
+                if (!rolled) {
+                  return errorResult(
+                    "mutate",
+                    "memory",
+                    operation,
+                    "E_SWEEP_ROLLBACK_FAILED",
+                    `Run '${rollbackRunId}' not found or not in staged status`,
+                    startTime
+                  );
+                }
+                return wrapResult(
+                  { success: true, data: { rolledBack: rollbackRunId } },
+                  "mutate",
+                  "memory",
+                  operation,
+                  startTime
+                );
+              }
+              const { detectNoiseCandidates } = await import("@cleocode/core/memory/brain-noise-detector.js");
+              const detectResult = await detectNoiseCandidates(projectRoot, { dryRun });
               return wrapResult(
-                { success: true, data: result },
-                "query",
+                { success: true, data: detectResult },
+                dryRun ? "query" : "mutate",
                 "memory",
                 operation,
                 startTime
@@ -20131,8 +20290,10 @@ var init_memory2 = __esm({
             "code.links",
             "code.memories-for-code",
             "code.for-memory",
-            // T1262 — brain noise detector (E1-parallel, read-only)
+            // T1262 — brain noise detector (E1-parallel, read-only) + assert-clean gate
             "doctor",
+            // T1147 W7 — sweep status query (dry-run mode)
+            "sweep",
             // T791 — LLM extraction backend status
             "llm-status",
             // T792 — pending verification queue
@@ -29465,8 +29626,31 @@ var init_sentient = __esm({
       }
       /**
        * Enable or disable Tier-2 proposal generation.
+       *
+       * When `enabled=true`, enforces the M7 gate (T-COUNCIL-RECONCILIATION-2026-04-24):
+       * `cleo memory doctor --assert-clean` must pass before Tier-2 is activated.
+       * Returns `E_M7_GATE_FAILED` if the brain corpus is not clean.
+       *
+       * @task T1148 W8-7
        */
       async setTier2Enabled(projectRoot, enabled) {
+        if (enabled) {
+          try {
+            const { scanBrainNoise } = await import("@cleocode/core/memory/brain-doctor.js");
+            const doctorResult = await scanBrainNoise(projectRoot);
+            if (!doctorResult.isClean) {
+              return {
+                success: false,
+                error: {
+                  code: "E_M7_GATE_FAILED",
+                  message: `M7 gate blocked: brain corpus has ${doctorResult.findings.length} noise pattern(s) across ${doctorResult.totalScanned} entries. Run \`cleo memory doctor\` for details, then \`cleo memory sweep --approve\` to clean before enabling Sentient v1.`,
+                  details: { findings: doctorResult.findings, totalScanned: doctorResult.totalScanned }
+                }
+              };
+            }
+          } catch {
+          }
+        }
         const { patchSentientState: patchSentientState2 } = await import("@cleocode/core/sentient/state.js");
         const { SENTIENT_STATE_FILE: SENTIENT_STATE_FILE2 } = await import("@cleocode/core/sentient/daemon.js");
         const statePath = join6(projectRoot, SENTIENT_STATE_FILE2);
@@ -47171,6 +47355,51 @@ var tierCommand = defineCommand({
     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)" },
   subCommands: {
@@ -47214,7 +47443,9 @@ var memoryCommand = defineCommand({
     digest: digestCommand,
     recent: recentCommand,
     diary: diaryCommand,
-    watch: watchCommand2
+    watch: watchCommand2,
+    // T1147 W7 — BRAIN noise sweep
+    sweep: sweepCommand
   },
   async run({ cmd, rawArgs }) {
     const firstArg = rawArgs?.find((a) => !a.startsWith("-"));