@claude-flow/cli 3.31.3 → 3.32.1

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

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.31.3",
+    "version": "3.32.1",
     "files": {
       "auto-memory-hook.mjs": "e3e1033b24704992ddef6b31c7fa9dd7fcd9e1af7935dd77ef73402b916b31e6",
       "hook-handler.cjs": "f87ec28684bfc5fd0a54c46bd2a53a3fb037defe71d0ea4b8a5cb88a2cd87a3f",
@@ -8,6 +8,6 @@
       "statusline.cjs": "7d7bdee732e1c75b863e409afb86ce0d712f4919245e990d806da6752015bffa"
     }
   },
-  "signature": "oJ609f8MglONiFAa6Hr2N5yz8RFYPoPWAW9uVOxY880khynj9z3lokBgoFdubtyBqQX7orAVWQ0mHberEth2Ag==",
+  "signature": "CYSsp2OyERA+JF2szVX7ciFLjnZ07biWZDJ0u6rUH06HbQECCHdAmmZwSbYiW2XrdN9G6Zrp8MJA56GLX8I1Ag==",
   "algorithm": "ed25519"
 }

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 1,
-  "generatedAt": "2026-07-15T18:42:59.914Z",
-  "gitSha": "8306ad8f",
+  "generatedAt": "2026-07-16T23:50:36.870Z",
+  "gitSha": "81447ce7",
   "catalog": {
     "agents": 164,
     "tools": 387,

package/dist/src/commands/doctor.js

@@ -1404,6 +1404,20 @@ export const doctorCommand = {
             description: 'Verbose output',
             type: 'boolean',
             default: false
+        },
+        {
+            name: 'fix-handles',
+            // Windows-only mitigation for anthropics/claude-code#67888 — Claude Code's
+            // Bash tool spawns cmd.exe/bash.exe without cleaning up child conhost.exe
+            // handles, so a long session accumulates dozens (observed live: 26+
+            // orphaned conhost.exe after a ~4h session). Each holds a kernel object
+            // + ~1MB, and combined with memory pressure this measurably slows the
+            // machine. This flag kills orphan conhost.exe (safe — Windows respawns
+            // on demand). Deliberately does NOT touch cmd.exe/bash.exe — those can
+            // be the invoking shell, and killing them 255's the caller.
+            description: 'Windows only: kill orphaned conhost.exe processes leaked by Claude Code (mitigation for anthropics/claude-code#67888)',
+            type: 'boolean',
+            default: false
         }
     ],
     examples: [
@@ -1411,13 +1425,78 @@ export const doctorCommand = {
         { command: 'claude-flow doctor --fix', description: 'Print suggested fix commands (does not auto-apply)' },
         { command: 'claude-flow doctor --install', description: 'Auto-install missing dependencies' },
         { command: 'claude-flow doctor -c version', description: 'Check for stale npx cache' },
-        { command: 'claude-flow doctor -c claude', description: 'Check Claude Code CLI only' }
+        { command: 'claude-flow doctor -c claude', description: 'Check Claude Code CLI only' },
+        { command: 'claude-flow doctor --fix-handles', description: 'Windows: kill leaked conhost.exe from Claude Code sessions' }
     ],
     action: async (ctx) => {
         const showFix = ctx.flags.fix;
         const autoInstall = ctx.flags.install;
         const component = ctx.flags.component;
         const verbose = ctx.flags.verbose;
+        // Parser camelCases kebab-case flag names — read via `fixHandles`, not `['fix-handles']`.
+        const fixHandles = ctx.flags.fixHandles;
+        // Early-return short-circuit: `--fix-handles` is a targeted mitigation, not
+        // part of the health-check flow. Runs, reports, exits.
+        if (fixHandles) {
+            output.writeln();
+            output.writeln(output.bold('RuFlo Doctor — fix-handles'));
+            output.writeln(output.dim('─'.repeat(50)));
+            output.writeln();
+            if (process.platform !== 'win32') {
+                output.printInfo('--fix-handles is a Windows-only mitigation. On this platform (' + process.platform + '), no action taken.');
+                return { success: true };
+            }
+            const { spawnSync } = await import('child_process');
+            // PowerShell one-liner: read before-count, kill conhost, read after-count, report delta.
+            const psScript = [
+                "$before = (Get-Process conhost -EA SilentlyContinue).Count",
+                "$mem_before = [math]::Round((Get-CimInstance Win32_OperatingSystem).FreePhysicalMemory / 1MB, 2)",
+                "$killed = 0",
+                "Get-Process conhost -EA SilentlyContinue | ForEach-Object {",
+                "  try { Stop-Process -Id $_.Id -Force -EA Stop; $killed++ } catch {}",
+                "}",
+                "Start-Sleep -Seconds 1",
+                "$after = (Get-Process conhost -EA SilentlyContinue).Count",
+                "$mem_after = [math]::Round((Get-CimInstance Win32_OperatingSystem).FreePhysicalMemory / 1MB, 2)",
+                "Write-Output ('BEFORE_COUNT=' + $before)",
+                "Write-Output ('KILLED=' + $killed)",
+                "Write-Output ('AFTER_COUNT=' + $after)",
+                "Write-Output ('MEM_BEFORE_GB=' + $mem_before)",
+                "Write-Output ('MEM_AFTER_GB=' + $mem_after)",
+            ].join('; ');
+            const res = spawnSync('powershell', ['-NoProfile', '-Command', psScript], {
+                encoding: 'utf-8', timeout: 30000, windowsHide: true,
+            });
+            if (res.status !== 0) {
+                output.printError('PowerShell exited with code ' + res.status);
+                if (res.stderr)
+                    output.writeln(output.dim(res.stderr));
+                return { success: false, exitCode: 1 };
+            }
+            const parse = (key) => {
+                const line = (res.stdout || '').split('\n').find((l) => l.startsWith(key + '='));
+                return line ? line.slice(key.length + 1).trim() : '?';
+            };
+            const before = parse('BEFORE_COUNT');
+            const killed = parse('KILLED');
+            const after = parse('AFTER_COUNT');
+            const memBefore = parse('MEM_BEFORE_GB');
+            const memAfter = parse('MEM_AFTER_GB');
+            output.writeln('conhost.exe processes:');
+            output.writeln('  before:  ' + before);
+            output.writeln('  killed:  ' + output.success(killed));
+            output.writeln('  after:   ' + after);
+            output.writeln('');
+            output.writeln('Free RAM:');
+            output.writeln('  before:  ' + memBefore + ' GB');
+            output.writeln('  after:   ' + memAfter + ' GB');
+            output.writeln('');
+            output.writeln(output.dim('Note: does NOT touch cmd.exe/bash.exe/node.exe — those may be the invoking shell'));
+            output.writeln(output.dim('      or an active MCP server. Kill them manually if you need to.'));
+            output.writeln('');
+            output.writeln(output.dim('Upstream tracking: https://github.com/anthropics/claude-code/issues/67888'));
+            return { success: true };
+        }
         output.writeln();
         output.writeln(output.bold('RuFlo Doctor'));
         output.writeln(output.dim('System diagnostics and health check'));

package/dist/src/commands/init.d.ts

@@ -3,6 +3,11 @@
  * Comprehensive initialization for Claude Flow with Claude Code integration
  */
 import type { Command } from '../types.js';
+export declare function runCodexInitializerCli(cwd: string, options: {
+    template: string;
+    force: boolean;
+    dual: boolean;
+}): boolean;
 export declare const initCommand: Command;
 export default initCommand;
 //# sourceMappingURL=init.d.ts.map

package/dist/src/commands/init.js

@@ -6,6 +6,7 @@ import { output } from '../output.js';
 import { confirm, select, multiSelect, input } from '../prompt.js';
 import * as fs from 'fs';
 import * as path from 'path';
+import { spawnSync } from 'node:child_process';
 import { executeInit, executeUpgrade, executeUpgradeWithMissing, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
 import { ENROLLMENT_SCREEN, recordEnrollmentOutcome, shouldOfferEnrollment, } from '../funnel/enrollment.js';
 import { commandExists } from '../services/harness-hosts.js';
@@ -82,6 +83,27 @@ async function resolveCodexInitializer(cwd) {
     }
     return undefined;
 }
+// Keep Codex out of the CLI dependency graph so cold `npx ruflo --version`
+// remains fast (#2561). An explicit `init --codex` may fetch the small,
+// stable adapter on demand when it is not already installed by an umbrella
+// package, the current project, or the global npm prefix.
+export function runCodexInitializerCli(cwd, options) {
+    const npxArgs = [
+        '-y',
+        '@claude-flow/codex@latest',
+        'init',
+        '--template',
+        options.template,
+        ...(options.force ? ['--force'] : []),
+        ...(options.dual ? ['--dual'] : []),
+    ];
+    const result = process.platform === 'win32'
+        ? spawnSync(process.env.ComSpec || 'cmd.exe', ['/d', '/s', '/c', ['npx', ...npxArgs].join(' ')], { cwd, stdio: 'inherit', windowsHide: true })
+        : spawnSync('npx', npxArgs, { cwd, stdio: 'inherit' });
+    if (result.error)
+        throw result.error;
+    return result.status === 0;
+}
 // #2666-adjacent — quietly wire up Codex too when a plain `ruflo init` (no
 // --codex/--dual) runs on a machine that also has the OpenAI Codex CLI on
 // PATH: registers its MCP server and installs skills alongside the Claude
@@ -194,7 +216,14 @@ async function initCodexAction(ctx, options) {
     try {
         const CodexInitializer = await resolveCodexInitializer(ctx.cwd);
         if (!CodexInitializer) {
-            throw new Error('Cannot find module @claude-flow/codex');
+            spinner.stop();
+            output.printInfo('Fetching the stable Codex adapter for this initialization...');
+            const success = runCodexInitializerCli(ctx.cwd, { template, force, dual: dualMode });
+            if (!success) {
+                output.printError('Codex initialization failed while running @claude-flow/codex@latest.');
+                return { success: false, exitCode: 1 };
+            }
+            return { success: true, data: { adapter: '@claude-flow/codex@latest' } };
         }
         const initializer = new CodexInitializer();
         const result = await initializer.initialize({

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.31.3",
+  "version": "3.32.1",
   "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",
   "types": "dist/src/index.d.ts",
   "sideEffects": false,
   "bin": {
-    "cli": "./bin/cli.js",
-    "claude-flow": "./bin/cli.js",
-    "claude-flow-mcp": "./bin/mcp-server.js"
+    "cli": "bin/cli.js",
+    "claude-flow": "bin/cli.js",
+    "claude-flow-mcp": "bin/mcp-server.js"
   },
   "homepage": "https://github.com/ruvnet/claude-flow#readme",
   "bugs": {
@@ -17,7 +17,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/ruvnet/claude-flow.git",
+    "url": "git+https://github.com/ruvnet/claude-flow.git",
     "directory": "v3/@claude-flow/cli"
   },
   "keywords": [
@@ -90,8 +90,9 @@
     "test:plugin-store": "npx tsx src/plugins/tests/standalone-test.ts",
     "test:pattern-store": "npx tsx src/transfer/store/tests/standalone-test.ts",
     "postinstall": "node ./scripts/postinstall.cjs",
-    "prepublishOnly": "cp ../../../README.md ./README.md && rm -rf plugins && mkdir -p plugins && cp -r ../../../plugins/ruflo-metaharness plugins/ && node scripts/generate-catalog-manifest.mjs && node scripts/sign-helpers.mjs && node scripts/verify-helpers.mjs",
-    "release": "npm version prerelease --preid=alpha && npm run publish:all",
+    "prepublishOnly": "node scripts/prepare-publish.mjs",
+    "release": "npm publish --access public --tag latest",
+    "release:alpha": "npm version prerelease --preid=alpha && npm run publish:all",
     "publish:all": "./scripts/publish.sh"
   },
   "devDependencies": {

package/.claude/.proven-config-version

@@ -1 +0,0 @@
-sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319

package/.claude/proven-config.json

@@ -1,42 +0,0 @@
-{
-  "adoptedAt": 1784038945014,
-  "championId": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
-  "manifest": {
-    "schema": "ruflo.proven-config/v1",
-    "policy": {
-      "ref": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
-      "value": {
-        "alpha": 0.3,
-        "subjectWeight": 1,
-        "mmrLambda": 0.5,
-        "bodyWeight": 1.5,
-        "typePenaltyFactor": 0.5
-      }
-    },
-    "layer": "framework/node-cli",
-    "compatibility": {
-      "ruflo": ">=3.24.0"
-    },
-    "benchmark": {
-      "corpus": "ADR-081-labelled-v1",
-      "corpusHash": "sha256:2f700b5c363e20a3bd88ce2bc9b87bbbbaa61732c6177894c6ec37890f888982"
-    },
-    "receipt": {
-      "heldOutDelta": 0.07381404928570845,
-      "redblue": "PASS",
-      "drift": 0,
-      "canary": {
-        "rollbackRate": 0,
-        "latencyP95": 244.612458000076,
-        "costPerTask": 0
-      },
-      "receiptCoverage": 1
-    },
-    "platform": [
-      "linux",
-      "macOS",
-      "windows"
-    ]
-  },
-  "previous": ""
-}

package/dist/src/ruvector/flash-attention.d.ts

@@ -1,195 +0,0 @@
-/**
- * Flash Attention Implementation for RuVector Intelligence System
- *
- * Implements block-wise attention computation for faster similarity calculations.
- * Achieves O(N) memory instead of O(N^2) through tiling strategy.
- *
- * Key optimizations:
- * - Block-wise computation to fit in L1 cache
- * - Fused softmax-matmul operations
- * - Float32Array for all operations
- * - Online softmax for numerical stability
- *
- * Target: 2-5x speedup on CPU vs naive attention
- *
- * Created with love by ruv.io
- */
-export interface FlashAttentionConfig {
-    /** Block size for tiling (32-64 optimal for CPU L1 cache) */
-    blockSize: number;
-    /** Number of dimensions in embedding vectors */
-    dimensions: number;
-    /** Temperature for softmax scaling */
-    temperature: number;
-    /** Enable numerical stability optimizations */
-    useStableMode: boolean;
-    /** Use optimized CPU path (default: true) */
-    useCPUOptimizations: boolean;
-}
-export interface AttentionResult {
-    /** Output vectors after attention */
-    output: Float32Array[];
-    /** Attention weights (optional, for debugging) */
-    weights?: Float32Array[];
-    /** Computation time in milliseconds */
-    computeTimeMs: number;
-}
-export interface BenchmarkResult {
-    /** Naive attention time in milliseconds */
-    naiveTimeMs: number;
-    /** Flash attention time in milliseconds */
-    flashTimeMs: number;
-    /** Speedup factor (naive / flash) */
-    speedup: number;
-    /** Number of vectors benchmarked */
-    numVectors: number;
-    /** Dimensions of vectors */
-    dimensions: number;
-    /** Memory usage estimate for naive (bytes) */
-    naiveMemoryBytes: number;
-    /** Memory usage estimate for flash (bytes) */
-    flashMemoryBytes: number;
-    /** Memory reduction factor */
-    memoryReduction: number;
-}
-export declare class FlashAttention {
-    private config;
-    private lastSpeedup;
-    private benchmarkHistory;
-    private scoreBuffer;
-    private expBuffer;
-    private accumBuffer;
-    constructor(config?: Partial<FlashAttentionConfig>);
-    /**
-     * Main attention computation using Flash Attention algorithm
-     *
-     * @param queries - Query vectors [N x D]
-     * @param keys - Key vectors [M x D]
-     * @param values - Value vectors [M x D]
-     * @returns Attention output [N x D]
-     */
-    attention(queries: Float32Array[], keys: Float32Array[], values: Float32Array[]): AttentionResult;
-    /**
-     * CPU-optimized attention with aggressive optimizations
-     *
-     * Key optimizations:
-     * - Blocked score computation (better cache utilization)
-     * - Top-K sparse attention (only use most relevant keys)
-     * - Pre-allocated buffers to avoid GC pressure
-     * - 8x loop unrolling for dot products
-     * - Fused max-finding during score computation
-     */
-    private cpuOptimizedAttention;
-    /**
-     * Partial dot product using only first N dimensions (for screening)
-     */
-    private partialDotProduct;
-    /**
-     * Partial sort to get top-K elements (QuickSelect-like)
-     * Only ensures first K elements are the largest, not sorted
-     */
-    private partialSort;
-    /**
-     * Swap two indices in array
-     */
-    private swapIndices;
-    /**
-     * Fast dot product with 8x unrolling
-     */
-    private fastDotProduct;
-    /**
-     * Block-wise attention computation (Flash Attention core algorithm)
-     *
-     * Algorithm:
-     * For each block of queries Q_b:
-     *   For each block of keys K_b:
-     *     S_b = Q_b @ K_b.T / sqrt(d)  // Block scores
-     *     P_b = softmax(S_b)           // Block attention
-     *     O_b += P_b @ V_b             // Accumulate output
-     *
-     * @param Q - Query vectors
-     * @param K - Key vectors
-     * @param V - Value vectors
-     * @param blockSize - Block size for tiling
-     */
-    blockAttention(Q: Float32Array[], K: Float32Array[], V: Float32Array[], blockSize: number): Float32Array[];
-    /**
-     * Get the speedup factor from the last benchmark
-     */
-    getSpeedup(): number;
-    /**
-     * Run benchmark comparing naive vs CPU-optimized attention
-     *
-     * @param numVectors - Number of vectors to test
-     * @param dimensions - Dimensions per vector
-     * @param iterations - Number of iterations for averaging
-     */
-    benchmark(numVectors?: number, dimensions?: number, iterations?: number): BenchmarkResult;
-    /**
-     * Get benchmark history
-     */
-    getBenchmarkHistory(): BenchmarkResult[];
-    /**
-     * Get configuration
-     */
-    getConfig(): FlashAttentionConfig;
-    /**
-     * Update configuration
-     */
-    setConfig(config: Partial<FlashAttentionConfig>): void;
-    /**
-     * Naive O(N^2) attention implementation for comparison
-     */
-    private naiveAttention;
-    /**
-     * Compute block of attention scores
-     */
-    private computeBlockScores;
-    /**
-     * Online softmax with output accumulation (key to Flash Attention)
-     *
-     * Uses the online softmax trick to maintain numerical stability
-     * while processing blocks incrementally.
-     */
-    private onlineSoftmaxAccumulate;
-    /**
-     * Compute dot product of two vectors
-     */
-    private dotProduct;
-    /**
-     * Stable softmax implementation
-     */
-    private softmax;
-    /**
-     * Generate random vectors for benchmarking
-     */
-    private generateRandomVectors;
-    /**
-     * Validate input arrays
-     */
-    private validateInputs;
-}
-/**
- * Get singleton FlashAttention instance
- *
- * @param config - Optional configuration (only used on first call)
- * @returns FlashAttention instance
- */
-export declare function getFlashAttention(config?: Partial<FlashAttentionConfig>): FlashAttention;
-/**
- * Reset singleton (for testing)
- */
-export declare function resetFlashAttention(): void;
-/**
- * Compute attention using Flash Attention
- */
-export declare function computeAttention(queries: Float32Array[], keys: Float32Array[], values: Float32Array[], config?: Partial<FlashAttentionConfig>): AttentionResult;
-/**
- * Run Flash Attention benchmark
- */
-export declare function benchmarkFlashAttention(numVectors?: number, dimensions?: number, iterations?: number): BenchmarkResult;
-/**
- * Get current speedup from last benchmark
- */
-export declare function getFlashAttentionSpeedup(): number;
-//# sourceMappingURL=flash-attention.d.ts.map