@claude-flow/cli 3.21.0 → 3.22.0

package/.claude/helpers/auto-memory-hook.mjs

@@ -27,10 +27,23 @@ const CYAN = '\x1b[0;36m';
 const DIM = '\x1b[2m';
 const RESET = '\x1b[0m';
 
+const YELLOW = '\x1b[0;33m';
 const log = (msg) => console.log(`${CYAN}[AutoMemory] ${msg}${RESET}`);
 const success = (msg) => console.log(`${GREEN}[AutoMemory] ✓ ${msg}${RESET}`);
 const dim = (msg) => console.log(`  ${DIM}${msg}${RESET}`);
 
+// #2545: fail LOUD instead of a silent dim skip. When @claude-flow/memory cannot
+// be resolved, self-learning imports are a no-op — the user must see this and be
+// told exactly how to fix it (on both stdout, so it shows in the Claude Code hook
+// transcript, and stderr, per the issue's requested channel).
+function warnMemoryUnavailable() {
+  const line1 = `[AutoMemory] @claude-flow/memory not resolvable from ${PROJECT_ROOT} — self-learning imports are DISABLED.`;
+  const line2 = '             Fix: npm i -D @claude-flow/memory   (or re-run: npx ruflo@latest init, then npx ruflo@latest doctor --fix)';
+  console.log(`${YELLOW}${line1}${RESET}`);
+  console.log(`${YELLOW}${line2}${RESET}`);
+  process.stderr.write(`${line1}\n${line2}\n`);
+}
+
 const DEBUG = !!(process.env.RUFLO_DEBUG || process.env.DEBUG);
 
 // ── Graceful shutdown (FIX 3) ───────────────────────────────────────────────
@@ -152,6 +165,21 @@ class JsonFileBackend {
 // ============================================================================
 
 async function loadMemoryPackage() {
+  // Strategy 0 (#2545): sidecar recorded by `init` / `doctor --fix`. On the
+  // documented `npx ruflo` path @claude-flow/memory (an optionalDependency of
+  // the CLI) lands in the npx cache, which is NOT on the walk-up path from the
+  // project — so init resolves it from the CLI's own context and records the
+  // absolute path here. This is the only strategy that works on that install.
+  try {
+    const sidecar = join(PROJECT_ROOT, '.claude-flow', 'memory-package.json');
+    if (existsSync(sidecar)) {
+      const rec = JSON.parse(readFileSync(sidecar, 'utf-8'));
+      if (rec?.distPath && existsSync(rec.distPath)) {
+        return await import(`file://${rec.distPath}`);
+      }
+    }
+  } catch { /* fall through */ }
+
   // Strategy 1: Local dev (built dist)
   const localDist = join(PROJECT_ROOT, 'v3/@claude-flow/memory/dist/index.js');
   if (existsSync(localDist)) {
@@ -235,7 +263,7 @@ async function doImport() {
 
   const memPkg = await loadMemoryPackage();
   if (!memPkg || !memPkg.AutoMemoryBridge) {
-    dim('Memory package not available — skipping auto memory import');
+    warnMemoryUnavailable();
     return;
   }
 
@@ -288,7 +316,7 @@ async function doSync() {
 
   const memPkg = await loadMemoryPackage();
   if (!memPkg || !memPkg.AutoMemoryBridge) {
-    dim('Memory package not available — skipping sync');
+    warnMemoryUnavailable();
     return;
   }
 
@@ -346,8 +374,12 @@ async function doStatus() {
   const memPkg = await loadMemoryPackage();
   const config = readConfig();
 
+  const sidecar = join(PROJECT_ROOT, '.claude-flow', 'memory-package.json');
+  const hasSidecar = existsSync(sidecar);
+
   console.log('\n=== Auto Memory Bridge Status ===\n');
-  console.log(`  Package:        ${memPkg ? '✅ Available' : '❌ Not found'}`);
+  console.log(`  Package:        ${memPkg ? '✅ Available' : '❌ Not found — self-learning DISABLED (fix: npm i -D @claude-flow/memory)'}`);
+  console.log(`  Resolver:       ${hasSidecar ? '✅ .claude-flow/memory-package.json' : '⏸ no sidecar (run: npx ruflo@latest doctor --fix)'}`);
   console.log(`  Store:          ${existsSync(STORE_PATH) ? '✅ ' + STORE_PATH : '⏸ Not initialized'}`);
   console.log(`  LearningBridge: ${config.learningBridge.enabled ? '✅ Enabled' : '⏸ Disabled'}`);
   console.log(`  MemoryGraph:    ${config.memoryGraph.enabled ? '✅ Enabled' : '⏸ Disabled'}`);

package/.claude/helpers/helpers.manifest.json

@@ -0,0 +1,12 @@
+{
+  "manifest": {
+    "version": "3.22.0",
+    "files": {
+      "auto-memory-hook.mjs": "68be7e9a9eba7bf9c4e8a230db7bf61a243b965639f8504842799d6c6ca28762",
+      "hook-handler.cjs": "bc4d2d26823d49b3ab1dded2946b66369f1f67bd76b4c30dca9f3b6df3cca8f0",
+      "intelligence.cjs": "760cb82ed2000031abc1ac1fa90a014e7d91d93966e3aa4741b07ab7aff8d066"
+    }
+  },
+  "signature": "sTqZ2JNEoWfS0LKrQVESAqJ+yfNB6/YExxxn5mmsZ/kPuH8u9uURt8J+RPICG1/qwNIOkkDEYJtQtGzpVW0jAw==",
+  "algorithm": "ed25519"
+}

package/.claude/helpers/hook-handler.cjs

@@ -124,6 +124,25 @@ async function main() {
   const prompt = hookInput.prompt || hookInput.command || toolInput.command
     || process.env.PROMPT || process.env.TOOL_INPUT_command || args.join(' ') || '';
 
+  // ADR-174: capture FAILURES so the learning substrate has negative examples.
+  // Claude Code's PostToolUse payload carries the tool result; a failed
+  // Write/Edit/Bash surfaces as tool_response.is_error / an error string /
+  // a non-zero exit code. Conservative — only a positive error signal counts
+  // as failure (mirrors isToolFailure() in helpers-generator.ts).
+  const toolFailed = (function (hi) {
+    if (!hi || typeof hi !== 'object') return false;
+    const tr = hi.tool_response != null ? hi.tool_response : (hi.toolResponse != null ? hi.toolResponse : hi.result);
+    if (tr == null) return false;
+    if (typeof tr === 'string') return /\b(error|failed|failure|exception|not found|no such|permission denied|traceback)\b/i.test(tr);
+    if (typeof tr === 'object') {
+      if (tr.is_error === true || tr.isError === true || tr.success === false || tr.error != null) return true;
+      const code = tr.exit_code != null ? tr.exit_code : (tr.exitCode != null ? tr.exitCode : tr.code);
+      if (typeof code === 'number' && code !== 0) return true;
+      if (Array.isArray(tr.content) && tr.is_error === true) return true;
+    }
+    return false;
+  })(hookInput);
+
 const handlers = {
   'route': () => {
     // Inject ranked intelligence context before routing
@@ -178,10 +197,10 @@ const handlers = {
       try {
         const file = hookInput.file_path || toolInput.file_path
           || process.env.TOOL_INPUT_file_path || args[0] || '';
-        intelligence.recordEdit(file);
+        intelligence.recordEdit(file, !toolFailed);
       } catch (e) { /* non-fatal */ }
     }
-    console.log('[OK] Edit recorded');
+    console.log(toolFailed ? '[LEARN] Edit FAILURE recorded' : '[OK] Edit recorded');
   },
 
   'session-restore': async () => {
@@ -246,13 +265,15 @@ const handlers = {
   },
 
   'post-task': () => {
-    // Implicit success feedback for intelligence
+    // ADR-174: feed the REAL outcome (feedback() boosts confidence on success,
+    // decays it on failure) instead of a hardcoded true — no more all-positive
+    // signal that the substrate can't learn from.
     if (intelligence && intelligence.feedback) {
       try {
-        intelligence.feedback(true);
+        intelligence.feedback(!toolFailed);
       } catch (e) { /* non-fatal */ }
     }
-    console.log('[OK] Task completed');
+    console.log(toolFailed ? '[LEARN] Task FAILURE recorded' : '[OK] Task completed');
   },
 
   'stats': () => {

package/.claude/helpers/intelligence.cjs

@@ -575,11 +575,14 @@ function getContext(prompt) {
  * recordEdit(file) — Called from post-edit. Budget: <2ms.
  * Appends to pending-insights.jsonl.
  */
-function recordEdit(file) {
+function recordEdit(file, success) {
   ensureDataDir();
   const entry = JSON.stringify({
     type: 'edit',
     file: file || 'unknown',
+    // ADR-174: record failures too, not just successes — the learning substrate
+    // needs negative examples. Defaults true; an explicit false is a failed edit.
+    success: success !== false,
     timestamp: Date.now(),
     sessionId: sessionGet('sessionId') || null,
   });

package/dist/src/commands/daemon.js

@@ -14,6 +14,12 @@ const startCommand = {
     description: 'Start the worker daemon with all enabled background workers',
     options: [
         { name: 'workers', short: 'w', type: 'string', description: 'Comma-separated list of workers to enable (default: map,audit,optimize,consolidate,testgaps)' },
+        // ADR-174 M3: consolidate now runs a real memory-distillation pass
+        // (memory_entries -> episodes/reasoning_patterns/causal_edges) instead of
+        // a no-op stub. This opt-out skips just that pass for the life of this
+        // daemon process, without touching persisted worker-enabled state — for
+        // permanently disabling the worker use `daemon enable -w consolidate --disable`.
+        { name: 'no-distill', type: 'boolean', description: 'Disable the consolidate worker\'s memory-distillation pass (ADR-174)' },
         { name: 'quiet', short: 'Q', type: 'boolean', description: 'Suppress output' },
         { name: 'background', short: 'b', type: 'boolean', description: 'Run daemon in background (detached process)', default: true },
         { name: 'foreground', short: 'f', type: 'boolean', description: 'Run daemon in foreground (blocks terminal)' },
@@ -35,10 +41,19 @@ const startCommand = {
         { command: 'claude-flow daemon start --foreground', description: 'Start in foreground (blocks terminal)' },
         { command: 'claude-flow daemon start -w map,audit,optimize', description: 'Start with specific workers' },
         { command: 'claude-flow daemon start --headless --sandbox strict', description: 'Start with headless workers in strict sandbox' },
+        { command: 'claude-flow daemon start --no-distill', description: 'Start with the consolidate worker\'s distillation pass disabled' },
     ],
     action: async (ctx) => {
         const quiet = ctx.flags.quiet;
         const foreground = ctx.flags.foreground;
+        const noDistill = ctx.flags['no-distill'];
+        // ADR-174 M3: honored by WorkerDaemon's consolidate worker directly via
+        // process.env — set it now so the foreground path (which runs in this
+        // same process) picks it up too; the background path forwards it to the
+        // forked child's env explicitly (see startBackgroundDaemon below).
+        if (noDistill) {
+            process.env.RUFLO_DAEMON_NO_DISTILL = '1';
+        }
         // #1914: a forked daemon child receives --workspace <root>; the launcher
         // and interactive invocations have no flag and fall back to cwd.
         const projectRoot = resolveWorkspaceFlag(ctx.flags.workspace) ?? process.cwd();
@@ -208,6 +223,7 @@ const startCommand = {
                     headless: ctx.flags.headless,
                     sandbox: ctx.flags.sandbox,
                     ttl: rawTtl,
+                    noDistill,
                 });
             }
             finally {
@@ -404,7 +420,7 @@ export function extractWorkspaceFromDaemonLine(commandLine) {
     return ws.length > 0 ? ws : null;
 }
 async function startBackgroundDaemon(projectRoot, quiet, forwarded = {}) {
-    const { maxCpuLoad, minFreeMemory, workers, headless, sandbox, ttl } = forwarded;
+    const { maxCpuLoad, minFreeMemory, workers, headless, sandbox, ttl, noDistill } = forwarded;
     // Validate and resolve project root
     const resolvedRoot = resolve(projectRoot);
     validatePath(resolvedRoot, 'Project root');
@@ -493,6 +509,11 @@ async function startBackgroundDaemon(projectRoot, quiet, forwarded = {}) {
     if (typeof sandbox === 'string' && (sandbox === 'strict' || sandbox === 'permissive' || sandbox === 'disabled')) {
         forkArgs.push('--sandbox', sandbox);
     }
+    // ADR-174 M3: forward the distillation opt-out to the forked foreground
+    // child; its own `start` action sets RUFLO_DAEMON_NO_DISTILL from this flag.
+    if (noDistill === true) {
+        forkArgs.push('--no-distill');
+    }
     // #1914: stamp the workspace into argv (kept LAST) so the foreground daemon
     // process is self-identifying and `killStaleDaemons` only reaps daemons
     // belonging to this workspace. resolvedRoot was validatePath()'d above.
@@ -1352,7 +1373,7 @@ export const daemonCommand = {
             `${output.highlight('map')}         - Codebase mapping (5 min interval)`,
             `${output.highlight('audit')}       - Security analysis (10 min interval)`,
             `${output.highlight('optimize')}    - Performance optimization (15 min interval)`,
-            `${output.highlight('consolidate')} - Memory consolidation (30 min interval)`,
+            `${output.highlight('consolidate')} - Memory distillation: memory_entries -> episodes/reasoning_patterns/causal_edges (30 min interval, ADR-174; --no-distill to disable)`,
             `${output.highlight('testgaps')}    - Test coverage analysis (20 min interval)`,
             `${output.highlight('predict')}     - Predictive preloading (2 min, disabled by default)`,
             `${output.highlight('document')}    - Auto-documentation (60 min, disabled by default)`,

package/dist/src/commands/doctor.js

@@ -13,6 +13,7 @@ import { execSync, exec } from 'child_process';
 import { promisify } from 'util';
 import { decodeKey, isEncryptionEnabled } from '../encryption/vault.js';
 import { isEncryptedBlob } from '../encryption/vault.js';
+import { resolveMemoryPackageFromProject, readMemoryPackageVersion, recordMemoryPackagePath, } from '../init/memory-package-resolver.js';
 // Promisified exec with proper shell and env inheritance for cross-platform support
 const execAsync = promisify(exec);
 /**
@@ -244,6 +245,37 @@ async function checkMemoryDatabase() {
     }
     return { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'claude-flow memory configure --backend hybrid' };
 }
+// #2545: Check that the self-learning bridge can actually load @claude-flow/memory
+// the SAME way the SessionStart auto-memory hook does. On the documented `npx ruflo`
+// path the package lands in the npx cache — unreachable from the project — so the
+// hook silently no-op'd with no signal anywhere. This surfaces it.
+async function checkLearningBridge() {
+    const cwd = process.cwd();
+    const hookPath = join(cwd, '.claude', 'helpers', 'auto-memory-hook.mjs');
+    // Only relevant once init has deployed the hook; otherwise stay quiet.
+    if (!existsSync(hookPath)) {
+        return {
+            name: 'Learning Bridge',
+            status: 'pass',
+            message: 'auto-memory hook not installed (run: npx ruflo@latest init)',
+        };
+    }
+    const distPath = resolveMemoryPackageFromProject(cwd);
+    if (distPath) {
+        const version = readMemoryPackageVersion(distPath);
+        return {
+            name: 'Learning Bridge',
+            status: 'pass',
+            message: `@claude-flow/memory resolvable${version ? ` (v${version})` : ''}`,
+        };
+    }
+    return {
+        name: 'Learning Bridge',
+        status: 'fail',
+        message: '@claude-flow/memory NOT resolvable — SessionStart self-learning imports are a silent no-op',
+        fix: 'npx ruflo@latest doctor --fix   (records resolver sidecar) — or: npm i -D @claude-flow/memory',
+    };
+}
 // Check API keys
 async function checkApiKeys() {
     const keys = ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY', 'OPENAI_API_KEY'];
@@ -1036,6 +1068,7 @@ export const doctorCommand = {
             checkStaleSettingsNpx, // #2448 — runaway `npx @latest` in statusLine/hooks
             checkDaemonStatus,
             checkMemoryDatabase,
+            checkLearningBridge, // #2545 — can the auto-memory hook actually load @claude-flow/memory?
             checkApiKeys,
             checkMcpServers,
             checkAIDefence, // #1807
@@ -1057,6 +1090,8 @@ export const doctorCommand = {
             'stale-settings': checkStaleSettingsNpx, // #2448
             'daemon': checkDaemonStatus,
             'memory': checkMemoryDatabase,
+            'learning': checkLearningBridge, // #2545
+            'learning-bridge': checkLearningBridge, // #2545
             'api': checkApiKeys,
             'git': checkGit,
             'mcp': checkMcpServers,
@@ -1107,6 +1142,27 @@ export const doctorCommand = {
             spinner.stop();
             output.writeln(output.error('Failed to run health checks'));
         }
+        // #2545: --fix / --install can actually repair the Learning Bridge by
+        // recording the resolver sidecar. When doctor runs via `npx ruflo`, the CLI
+        // CAN resolve its optional @claude-flow/memory dep (it is in the same npx
+        // cache), so writing the sidecar makes the SessionStart hook find it.
+        if ((showFix || autoInstall)) {
+            const lbResult = results.find(r => r.name === 'Learning Bridge');
+            if (lbResult && lbResult.status === 'fail') {
+                const record = recordMemoryPackagePath(process.cwd(), 'doctor');
+                if (record) {
+                    const newCheck = await checkLearningBridge();
+                    const idx = results.findIndex(r => r.name === 'Learning Bridge');
+                    if (idx !== -1)
+                        results[idx] = newCheck;
+                    const fixIdx = fixes.findIndex(f => f.startsWith('Learning Bridge:'));
+                    if (fixIdx !== -1 && newCheck.status === 'pass')
+                        fixes.splice(fixIdx, 1);
+                    output.writeln(output.success(`Repaired Learning Bridge — wrote .claude-flow/memory-package.json → ${record.distPath}`));
+                    output.writeln(formatCheck(newCheck));
+                }
+            }
+        }
         // Auto-install missing dependencies if requested
         if (autoInstall) {
             const claudeCodeResult = results.find(r => r.name === 'Claude Code CLI');

package/dist/src/commands/memory-distill.d.ts

@@ -0,0 +1,27 @@
+import type { Command, CommandContext } from '../types.js';
+export interface DistillCliConfig {
+    dryRun: boolean;
+    namespaces?: string[];
+    batchSize: number;
+    dedupDistance: number;
+    maxEntries?: number;
+    sinceRowid?: number;
+    budgetUsd: number;
+    judge: 'structural' | 'fable';
+}
+type ResolveResult = {
+    ok: true;
+    config: DistillCliConfig;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Resolve the effective distill config from: built-in defaults, an optional
+ * `--config <path>` JSON file, an `--aggressive`/`--conservative` preset, and
+ * finally explicit CLI flags (highest precedence).
+ */
+export declare function resolveDistillConfig(ctx: CommandContext): ResolveResult;
+export declare const distillCommand: Command;
+export default distillCommand;
+//# sourceMappingURL=memory-distill.d.ts.map