@claude-flow/cli 3.38.2 → 3.38.4

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

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.38.2",
+    "version": "3.38.4",
     "files": {
       "auto-memory-hook.mjs": "85fe05c757421c52137c0bc8545a0896bab6b4714538c2a11d1d0835bfcc8c1c",
       "hook-handler.cjs": "dae295fb9ae2626b89899c19a20cc911541af82b52d2eeb9b214d618b96e9a86",
@@ -8,6 +8,6 @@
       "statusline.cjs": "0457fe53f8cd2c56458ff178392536a5868efd1a573665fa43bc01d2d95ca677"
     }
   },
-  "signature": "aUyZD8VBc8slPjWIexWvx5vD6cF9ms5YKEDvLl+6WSX8Y0hrtXQgSs42Bmetyqj0LTRW5+W9GF3kUNB6zGiDBw==",
+  "signature": "pebcqTgxAwqxE5P2CeHtJGeddXdUluZcIkdlIrCo9NAjkNEFTiwV/PUltPtEvyYQ5uYu1AaZjbT/2qz3/YIhAg==",
   "algorithm": "ed25519"
 }

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 4,
-  "generatedAt": "2026-08-12T15:41:12.144Z",
-  "gitSha": "87f4f8ab",
+  "generatedAt": "2026-08-12T18:43:20.202Z",
+  "gitSha": "d41af6e4",
   "catalog": {
     "agents": 164,
     "tools": 397,

package/dist/src/commands/hooks.js

@@ -2194,7 +2194,12 @@ const intelligenceCommand = {
                     tokenReduction: 'N/A',
                     sweBenchScore: 'N/A',
                 },
-                lastTrainingMs: lastAdaptation ? Date.now() - lastAdaptation : undefined,
+                // #2940: a training cycle that actually ran this invocation is "now"
+                // — reading the pre-call `lastAdaptation` here would still show the
+                // stale age (the exact "aged instead of reset" symptom reported).
+                lastTrainingMs: mcpResult?.training?.trained
+                    ? 0
+                    : (lastAdaptation ? Date.now() - lastAdaptation : undefined),
                 persistence: {
                     dataDir: persistence.dataDir,
                     patternsFile: persistence.patternsFile,
@@ -2206,10 +2211,34 @@ const intelligenceCommand = {
                     trajectoriesFromDisk,
                 },
             };
+            // #2940: this block used to be a cosmetic 500ms sleep followed by an
+            // unconditional "Training cycle completed" — no training ever ran and
+            // `lastAdaptation` never moved, so `--status` could never report a
+            // training cycle as recent no matter how many times `--train` was
+            // invoked. `hooks_intelligence` now actually distills when asked
+            // (see mcp-tools/hooks-tools.ts); report what it actually did instead
+            // of a canned success message.
+            const trainingResult = mcpResult?.training;
             if (forceTraining) {
-                spinner.setText('Running training cycle...');
-                await new Promise(resolve => setTimeout(resolve, 500));
-                spinner.succeed('Training cycle completed');
+                if (trainingResult?.trained && trainingResult.patternsDistilled) {
+                    spinner.succeed(`Training cycle completed — distilled ${trainingResult.patternsDistilled} pattern${trainingResult.patternsDistilled === 1 ? '' : 's'}`);
+                }
+                else if (trainingResult?.trained) {
+                    // Ran (SONA/EWC++ distillation pass executed, lastAdaptation
+                    // moved) but found zero new patterns — deliberately NOT the same
+                    // message as a real distillation, or this is exactly the "success
+                    // report with no state change behind it" the issue describes.
+                    spinner.stop();
+                    output.printWarning(`Training cycle ran — 0 new patterns to distill (${trainingResult.reason || 'nothing new since the last cycle'})`);
+                }
+                else if (trainingResult?.attempted) {
+                    spinner.stop();
+                    output.printWarning(`Training cycle ran with nothing to do — ${trainingResult.reason || 'no new trajectories to distill'}`);
+                }
+                else {
+                    spinner.stop();
+                    output.printWarning('Training cycle could not run — intelligence MCP tool unavailable');
+                }
             }
             else {
                 spinner.succeed(hasLocalData ? 'Intelligence system active (local data loaded)' : 'Intelligence system active');

package/dist/src/commands/init.js

@@ -496,8 +496,16 @@ const initClaudeAction = async (ctx) => {
     const force = ctx.flags.force;
     const minimal = ctx.flags.minimal;
     const full = ctx.flags.full;
-    const skipClaude = ctx.flags['skip-claude'];
-    const onlyClaude = ctx.flags['only-claude'];
+    // #2952 — every long-flag write path in the parser goes through
+    // normalizeKey() (parser.ts:399-402), which converts kebab-case to
+    // camelCase before storing. `--skip-claude`/`--only-claude`/
+    // `--all-agents`/`--cloud-mcp` land as `flags.skipClaude`/`flags.onlyClaude`/
+    // `flags.allAgents`/`flags.cloudMcp` — there is no code path that ever
+    // stores the literal kebab-case key. Reading `ctx.flags['skip-claude']`
+    // etc. was always undefined, so all four flags were silent no-ops. Same
+    // bug class as #2098A below, just never applied to these siblings.
+    const skipClaude = ctx.flags.skipClaude;
+    const onlyClaude = ctx.flags.onlyClaude;
     // #2098A — the parser handles `--no-foo` by stripping the prefix and
     // storing `flags.foo = false` (parser.ts:291-294), not by storing
     // `flags['no-foo'] = true`. So `--no-global` lands as
@@ -505,8 +513,8 @@ const initClaudeAction = async (ctx) => {
     // was always undefined and silently no-op'd — every user with the flag
     // set still got `~/.claude/CLAUDE.md` modified. Read the real key.
     const noGlobal = ctx.flags['no-global'] === true || ctx.flags['global'] === false;
-    const allAgents = ctx.flags['all-agents'];
-    const cloudMcp = ctx.flags['cloud-mcp'];
+    const allAgents = ctx.flags.allAgents;
+    const cloudMcp = ctx.flags.cloudMcp;
     const cwd = ctx.cwd;
     // Check if already initialized
     const initialized = isInitialized(cwd);

package/dist/src/mcp-tools/hooks-tools.js

@@ -1377,26 +1377,36 @@ export const hooksPostTask = {
         catch {
             // Intelligence module not available — non-fatal
         }
-        // ADR-130 Phase 3: fire-and-forget "reinforced-by" edge on task success
+        // ADR-130 Phase 3: "reinforced-by" edge on task success.
         // Writes: context node → task pattern node (relation: "reinforced-by")
+        //
+        // #2961 — this used to be fire-and-forget (no `await` on the IIFE). That
+        // was invisible from the long-running MCP server, where the process
+        // stays alive long enough for the detached write to finish in the
+        // background. But `hooks post-task` (CLI) is the exact same handler
+        // invoked from a one-shot process that calls `process.exit(0)`
+        // immediately after this action resolves (bin/cli.js, #1552) — the
+        // still-pending dynamic `import(...)` + `insertGraphEdge()` call was
+        // killed before its first tick, so the CLI form dropped this edge on
+        // every single success, not intermittently. Await it — this is a
+        // single fast DB write, not worth losing correctness on one call site
+        // to save latency on the other.
         if (success) {
-            (async () => {
-                try {
-                    const { insertGraphEdge } = await import('../memory/graph-edge-writer.js');
-                    const sessionCtxId = `task:${taskId}`;
-                    const patternId = `pattern:${taskId}`;
-                    await insertGraphEdge({
-                        sourceId: sessionCtxId,
-                        targetId: patternId,
-                        relation: 'reinforced-by',
-                        weight: quality,
-                        confidence: quality,
-                        lastReinforced: new Date().toISOString(),
-                        metadata: { success, agent, taskId },
-                    });
-                }
-                catch { /* non-fatal */ }
-            })().catch(() => { });
+            try {
+                const { insertGraphEdge } = await import('../memory/graph-edge-writer.js');
+                const sessionCtxId = `task:${taskId}`;
+                const patternId = `pattern:${taskId}`;
+                await insertGraphEdge({
+                    sourceId: sessionCtxId,
+                    targetId: patternId,
+                    relation: 'reinforced-by',
+                    weight: quality,
+                    confidence: quality,
+                    lastReinforced: new Date().toISOString(),
+                    metadata: { success, agent, taskId },
+                });
+            }
+            catch { /* non-fatal */ }
         }
         // Persist routing outcome for runtime learning (file-based, always reliable)
         const taskText = params.task || '';
@@ -2360,7 +2370,39 @@ export const hooksIntelligence = {
         const flashAvailable = (await getFlashAttention()) !== null;
         const ewcAvailable = (await getEWCConsolidator()) !== null;
         const loraAvailable = (await getLoRAAdapter()) !== null;
+        // #2940: `forceTraining` (CLI `hooks intelligence --train`) was declared
+        // on this tool's input schema but never read — the handler always
+        // returned the same read-only status dashboard, so `lastAdaptation`
+        // (what `--status` reports as "Last Training") could never move no
+        // matter how many times `--train` ran. Actually distill when asked,
+        // and report honestly rather than always implying success:
+        // `attempted: false` (flag not passed), `trained: true` (real work
+        // happened, lastAdaptation now current), or `trained: false` with a
+        // reason (nothing new to distill, or distillation unavailable).
+        const training = { attempted: false, trained: false };
+        if (params.forceTraining) {
+            training.attempted = true;
+            try {
+                const { distillLearning } = await import('../memory/intelligence.js');
+                const result = await distillLearning();
+                if (result) {
+                    training.trained = true;
+                    training.patternsDistilled = result.patternsDistilled;
+                    training.ewcPenalty = result.ewcPenalty;
+                    if (result.patternsDistilled === 0) {
+                        training.reason = 'no new trajectories to distill since the last training cycle';
+                    }
+                }
+                else {
+                    training.reason = 'intelligence system unavailable — could not initialize SONA/ReasoningBank';
+                }
+            }
+            catch (error) {
+                training.reason = `distillation failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        }
         return {
+            training,
             mode,
             status: 'active',
             components: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.38.2",
+  "version": "3.38.4",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",