@claude-flow/cli 3.47.0 → 3.48.0

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

@@ -12,12 +12,16 @@
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const PROJECT_ROOT = join(__dirname, '../..');
+// Home-level helpers can serve a different project. Keep the memory writer on
+// the same project root as intelligence.cjs, which reads CLAUDE_PROJECT_DIR.
+const PROJECT_ROOT = process.env.CLAUDE_PROJECT_DIR
+  ? resolve(process.env.CLAUDE_PROJECT_DIR)
+  : join(__dirname, '../..');
 const DATA_DIR = join(PROJECT_ROOT, '.claude-flow', 'data');
 const STORE_PATH = join(DATA_DIR, 'auto-memory-store.json');
 

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

@@ -1,14 +1,14 @@
 {
   "manifest": {
-    "version": "3.47.0",
+    "version": "3.48.0",
     "files": {
-      "auto-memory-hook.mjs": "85fe05c757421c52137c0bc8545a0896bab6b4714538c2a11d1d0835bfcc8c1c",
+      "auto-memory-hook.mjs": "c8d218526a3c34034c2a69de23f507f0eb0f70d59c16426a8edc849e6ac22529",
       "hook-handler.cjs": "209d9fafe10e17d1be0866727f6f9cf9ac66f9a0793f1c793a4f58319e8e4583",
       "intelligence.cjs": "30e42ed7ec4ca5a94ac54fdb1330d2d47ac5f3fdeeef207753574723a9e77b5c",
       "statusline.cjs": "4a48353b4f1566fa4379b00fd0321b6676a22b6cc91fbbd8380ac5183d619468",
       "router.js": "b6998397e7883191b62229ccdc66fb87f1ccca1d5b2039ecb8c1e686d1ad81f8"
     }
   },
-  "signature": "Dt6+NVWu0FDiQVMr0HjwdVCJc3H4WfcUcOVHX4y0HnhoQA2Qj0lAWjU5jKpv2RGX74/jnwfHGRpyIsT1jlXLBA==",
+  "signature": "Y5fY+vJvnledNFp6edS2V1gxJ9P7llOQuq860/gCMvxr9DAzrlDuuKMuGgVP/Tb/25FStYm9+WyBVuOTDos0BQ==",
   "algorithm": "ed25519"
 }

package/.claude/helpers/learning-service.mjs

@@ -19,14 +19,16 @@
 
 import { createRequire } from 'module';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync, spawn } from 'child_process';
 import Database from 'better-sqlite3';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const PROJECT_ROOT = join(__dirname, '../..');
+const PROJECT_ROOT = process.env.CLAUDE_PROJECT_DIR
+  ? resolve(process.env.CLAUDE_PROJECT_DIR)
+  : join(__dirname, '../..');
 const DATA_DIR = join(PROJECT_ROOT, '.claude-flow/learning');
 const DB_PATH = join(DATA_DIR, 'patterns.db');
 const METRICS_PATH = join(DATA_DIR, 'learning-metrics.json');

package/.claude/helpers/metrics-db.mjs

@@ -7,12 +7,14 @@
 
 import initSqlJs from 'sql.js';
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, openSync, writeSync, fsyncSync, closeSync, renameSync, rmSync } from 'fs';
-import { dirname, join, basename } from 'path';
+import { dirname, join, basename, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const PROJECT_ROOT = join(__dirname, '../..');
+const PROJECT_ROOT = process.env.CLAUDE_PROJECT_DIR
+  ? resolve(process.env.CLAUDE_PROJECT_DIR)
+  : join(__dirname, '../..');
 const V3_DIR = join(PROJECT_ROOT, 'v3');
 const DB_PATH = join(PROJECT_ROOT, '.claude-flow', 'metrics.db');
 

package/bin/cli.js

@@ -302,10 +302,13 @@ if (isMCPMode) {
 
         try {
           const result = await callMCPTool(toolName, toolParams, { sessionId });
+          // Failed task outcomes are data; an explicit handler error is a tool failure.
+          const isError = result !== null && typeof result === 'object'
+            && typeof result.error === 'string' && result.error.trim().length > 0;
           return {
             jsonrpc: '2.0',
             id: message.id,
-            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
+            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], isError },
           };
         } catch (error) {
           return {

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 6,
-  "generatedAt": "2026-09-27T19:39:37.000Z",
-  "gitSha": "09595b70",
+  "generatedAt": "2026-09-28T23:12:33.113Z",
+  "gitSha": "bd42d873",
   "catalog": {
     "agents": 167,
     "tools": 418,

package/dist/src/commands/analyze.js

@@ -1480,7 +1480,7 @@ const boundariesCommand = {
                 output.writeln();
                 for (const cycle of result.circularDependencies.slice(0, 5)) {
                     const severityColor = cycle.severity === 'high' ? output.error : cycle.severity === 'medium' ? output.warning : output.dim;
-                    output.writeln(`${severityColor(`[${cycle.severity.toUpperCase()}]`)} ${cycle.cycle.join(' -> ')}`);
+                    output.writeln(`${severityColor.call(output, `[${cycle.severity.toUpperCase()}]`)} ${cycle.cycle.join(' -> ')}`);
                     output.writeln(output.dim(`  ${cycle.suggestion}`));
                     output.writeln();
                 }
@@ -1905,7 +1905,7 @@ const circularCommand = {
                 if (items.length === 0)
                     continue;
                 const color = severity === 'high' ? output.error : severity === 'medium' ? output.warning : output.dim;
-                output.writeln(color(output.bold(`${severity.toUpperCase()} SEVERITY (${items.length})`)));
+                output.writeln(color.call(output, output.bold(`${severity.toUpperCase()} SEVERITY (${items.length})`)));
                 output.writeln();
                 for (const cycle of items.slice(0, 5)) {
                     output.writeln(`  ${cycle.cycle.join(' -> ')}`);

package/dist/src/commands/config.js

@@ -124,15 +124,13 @@ const setCommand = {
             name: 'key',
             short: 'k',
             description: 'Configuration key',
-            type: 'string',
-            required: true
+            type: 'string'
         },
         {
             name: 'value',
             short: 'v',
             description: 'Configuration value',
-            type: 'string',
-            required: true
+            type: 'string'
         }
     ],
     examples: [
@@ -140,14 +138,14 @@ const setCommand = {
         { command: 'claude-flow config set -k memory.backend -v agentdb', description: 'Set memory backend' }
     ],
     action: async (ctx) => {
-        const key = ctx.flags.key || ctx.args[0];
-        const value = ctx.flags.value || ctx.args[1];
+        const key = (ctx.flags.key ?? ctx.args[0]);
+        const value = ctx.flags.value ?? ctx.args[1];
         if (!key || value === undefined) {
             output.printError('Both key and value are required');
             return { success: false, exitCode: 1 };
         }
         try {
-            const parsedValue = parseConfigValue(value);
+            const parsedValue = parseConfigValue(String(value));
             configManager.set(ctx.cwd, key, parsedValue);
             output.writeln(`Set ${key} = ${value}`);
             return { success: true };

package/dist/src/commands/hive-mind-worker.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Hive-mind worker execution: the MCP config handed to a spawned Claude, and
+ * `hive-mind work`, which actually runs a queued task.
+ *
+ * Before this, `hive-mind task` only wrote a `pending` row to the task store.
+ * Workers are records, not processes, and nothing ever claimed the row: the
+ * task stayed pending and the worker stayed idle forever. `work` is the missing
+ * consumer — claim one task, assign it to an idle hive worker, run it through
+ * `claude -p`, and record the outcome.
+ */
+import type { Command } from '../types.js';
+export interface WorkerMcpConfigOptions {
+    /** `--mcp-config` from the caller; used verbatim when given. */
+    explicit?: string;
+    cwd: string;
+    home: string;
+    /** Where the generated config is written (e.g. `.hive-mind/sessions`). */
+    outDir: string;
+    swarmId: string;
+    /** The ruflo MCP server to register when no source config provides one. */
+    rufloServer: {
+        command: string;
+        args: string[];
+    };
+}
+/**
+ * The MCP config file to pass to a spawned Claude.
+ *
+ * A source file is never passed through as-is. `~/.claude.json` is Claude
+ * Code's whole state file; on a machine where it has no top-level
+ * `mcpServers` (a fresh desktop), Claude exits at startup with "Invalid MCP
+ * configuration: mcpServers: Invalid input", before any task can run. And a
+ * config lacking a `ruflo` server leaves the worker without the tools its
+ * prompt names. So the servers are extracted, a `ruflo` server is guaranteed,
+ * and the result is written as a config Claude is known to accept.
+ */
+export declare function resolveWorkerMcpConfig(opts: WorkerMcpConfigOptions): string;
+/**
+ * The ruflo MCP server as launched by THIS cli, so a worker and the CLI that
+ * dispatched it share one version and one store format. `@latest` could
+ * resolve to a different release mid-session.
+ */
+export declare function currentRufloServer(): {
+    command: string;
+    args: string[];
+};
+export interface RunOutcome {
+    ok: boolean;
+    output: string;
+    exitCode: number | null;
+    sessionId?: string;
+    costUsd?: number;
+    durationMs: number;
+}
+export type TaskRunner = (prompt: string, opts: {
+    mcpConfig: string;
+    timeoutMs: number;
+    cwd: string;
+}) => Promise<RunOutcome>;
+/** Run one prompt through `claude -p` and parse its JSON result. */
+export declare const runWithClaude: TaskRunner;
+export interface WorkOnceOptions {
+    cwd: string;
+    mcpConfig: string;
+    runner: TaskRunner;
+    taskId?: string;
+    workerId?: string;
+    defaultTimeoutMs?: number;
+}
+export type WorkOnceResult = {
+    dispatched: false;
+    reason: string;
+} | {
+    dispatched: true;
+    taskId: string;
+    workerId: string;
+    status: 'completed' | 'failed';
+    outcome: RunOutcome;
+};
+/**
+ * One dispatch cycle: the oldest pending hive task goes to an idle hive worker,
+ * runs, and its outcome is recorded on the task. Every state change goes
+ * through the MCP task tools, so the store is the same one `hive-mind status`
+ * and `task status` read.
+ */
+export declare function workOnce(opts: WorkOnceOptions): Promise<WorkOnceResult>;
+export declare const workCommand: Command;
+//# sourceMappingURL=hive-mind-worker.d.ts.map

package/dist/src/commands/hive-mind-worker.js

@@ -0,0 +1,242 @@
+/**
+ * Hive-mind worker execution: the MCP config handed to a spawned Claude, and
+ * `hive-mind work`, which actually runs a queued task.
+ *
+ * Before this, `hive-mind task` only wrote a `pending` row to the task store.
+ * Workers are records, not processes, and nothing ever claimed the row: the
+ * task stayed pending and the worker stayed idle forever. `work` is the missing
+ * consumer — claim one task, assign it to an idle hive worker, run it through
+ * `claude -p`, and record the outcome.
+ */
+import { output } from '../output.js';
+import { callMCPTool, MCPClientError } from '../mcp-client.js';
+import { spawn as childSpawn } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { resolveClaudeLaunchCommand } from '../runtime/claude-command.js';
+/** The server key the hive-mind prompt addresses (`mcp__ruflo__*`). */
+const RUFLO_SERVER = 'ruflo';
+function readServers(path, cwd) {
+    try {
+        if (!existsSync(path))
+            return null;
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        const isMap = (v) => !!v && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length > 0;
+        if (isMap(parsed.mcpServers))
+            return parsed.mcpServers;
+        // ~/.claude.json keeps project-scoped servers under projects[<cwd>].
+        const project = parsed.projects?.[cwd];
+        if (isMap(project?.mcpServers))
+            return project.mcpServers;
+    }
+    catch {
+        // Unreadable or not JSON: not a usable config.
+    }
+    return null;
+}
+/**
+ * The MCP config file to pass to a spawned Claude.
+ *
+ * A source file is never passed through as-is. `~/.claude.json` is Claude
+ * Code's whole state file; on a machine where it has no top-level
+ * `mcpServers` (a fresh desktop), Claude exits at startup with "Invalid MCP
+ * configuration: mcpServers: Invalid input", before any task can run. And a
+ * config lacking a `ruflo` server leaves the worker without the tools its
+ * prompt names. So the servers are extracted, a `ruflo` server is guaranteed,
+ * and the result is written as a config Claude is known to accept.
+ */
+export function resolveWorkerMcpConfig(opts) {
+    if (opts.explicit)
+        return opts.explicit;
+    const candidates = [join(opts.cwd, '.mcp.json')];
+    if (opts.home)
+        candidates.push(join(opts.home, '.claude.json'), join(opts.home, '.claude', 'mcp.json'));
+    let servers = {};
+    for (const c of candidates) {
+        const found = readServers(c, opts.cwd);
+        if (found) {
+            servers = found;
+            break;
+        }
+    }
+    if (!servers[RUFLO_SERVER]) {
+        servers = {
+            ...servers,
+            [RUFLO_SERVER]: {
+                command: opts.rufloServer.command,
+                args: opts.rufloServer.args,
+                // The MCP server keys its stores off this, so the worker's tool calls
+                // land in the same task/agent stores as the CLI that dispatched it.
+                env: { CLAUDE_FLOW_CWD: opts.cwd },
+            },
+        };
+    }
+    mkdirSync(opts.outDir, { recursive: true });
+    const path = join(opts.outDir, `mcp-${opts.swarmId}.json`);
+    writeFileSync(path, JSON.stringify({ mcpServers: servers }, null, 2), 'utf-8');
+    return path;
+}
+/**
+ * The ruflo MCP server as launched by THIS cli, so a worker and the CLI that
+ * dispatched it share one version and one store format. `@latest` could
+ * resolve to a different release mid-session.
+ */
+export function currentRufloServer() {
+    const entry = process.argv[1];
+    return entry
+        ? { command: process.execPath, args: [entry, 'mcp', 'start'] }
+        : { command: 'npx', args: ['-y', '@claude-flow/cli@latest', 'mcp', 'start'] };
+}
+/** Run one prompt through `claude -p` and parse its JSON result. */
+export const runWithClaude = (prompt, opts) => new Promise((resolve) => {
+    const started = Date.now();
+    const launch = resolveClaudeLaunchCommand();
+    if (!launch) {
+        resolve({ ok: false, output: 'Claude Code CLI not found in PATH', exitCode: null, durationMs: 0 });
+        return;
+    }
+    // The prompt goes on stdin, not argv: a task description has no length
+    // bound and `--mcp-config` is variadic (#1780).
+    const child = childSpawn(launch.command, [...launch.argsPrefix, '-p', '--output-format', 'json', `--mcp-config=${opts.mcpConfig}`], { cwd: opts.cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (d) => (stdout += d));
+    child.stderr.on('data', (d) => (stderr += d));
+    const timer = setTimeout(() => child.kill('SIGTERM'), opts.timeoutMs);
+    child.on('error', (e) => {
+        clearTimeout(timer);
+        resolve({ ok: false, output: e.message, exitCode: null, durationMs: Date.now() - started });
+    });
+    child.on('close', (code, signal) => {
+        clearTimeout(timer);
+        const durationMs = Date.now() - started;
+        try {
+            const r = JSON.parse(stdout);
+            resolve({
+                ok: code === 0 && !r.is_error,
+                output: r.result ?? '',
+                exitCode: code,
+                sessionId: r.session_id,
+                costUsd: r.total_cost_usd,
+                durationMs,
+            });
+        }
+        catch {
+            const why = signal === 'SIGTERM' ? `timed out after ${opts.timeoutMs}ms` : (stderr || stdout).trim().slice(-2000);
+            resolve({ ok: false, output: why, exitCode: code, durationMs });
+        }
+    });
+    child.stdin.end(prompt);
+});
+function timeoutFromTags(tags, fallback) {
+    const tag = tags?.find((t) => /^timeout:\d+s$/.test(t));
+    return tag ? Number(tag.slice('timeout:'.length, -1)) * 1000 : fallback;
+}
+/**
+ * One dispatch cycle: the oldest pending hive task goes to an idle hive worker,
+ * runs, and its outcome is recorded on the task. Every state change goes
+ * through the MCP task tools, so the store is the same one `hive-mind status`
+ * and `task status` read.
+ */
+export async function workOnce(opts) {
+    let taskId = opts.taskId;
+    if (!taskId) {
+        const listed = await callMCPTool('task_list', { status: 'pending', type: 'hive-mind', limit: 1000 });
+        const oldest = [...(listed.tasks ?? [])].sort((a, b) => a.createdAt.localeCompare(b.createdAt))[0];
+        if (!oldest)
+            return { dispatched: false, reason: 'No pending hive-mind tasks' };
+        taskId = oldest.taskId;
+    }
+    const task = await callMCPTool('task_status', { taskId });
+    if (task.status !== 'pending') {
+        return { dispatched: false, reason: `Task ${taskId} is ${task.status}, not pending` };
+    }
+    let workerId = opts.workerId;
+    if (!workerId) {
+        const hive = await callMCPTool('hive-mind_status', {});
+        workerId = hive.workers?.find((w) => w.status === 'idle')?.id;
+        if (!workerId)
+            return { dispatched: false, reason: 'No idle hive worker — run "hive-mind spawn" first' };
+    }
+    await callMCPTool('task_assign', { taskId, agentIds: [workerId] });
+    const prompt = `You are hive-mind worker ${workerId}. Complete this task, then reply with ` +
+        `the result only.\n\nTask ${taskId}:\n${task.description}`;
+    const outcome = await opts.runner(prompt, {
+        mcpConfig: opts.mcpConfig,
+        timeoutMs: timeoutFromTags(task.tags, opts.defaultTimeoutMs ?? 300_000),
+        cwd: opts.cwd,
+    });
+    const result = {
+        worker: workerId,
+        output: outcome.output,
+        exitCode: outcome.exitCode,
+        durationMs: outcome.durationMs,
+        ...(outcome.sessionId ? { sessionId: outcome.sessionId } : {}),
+        ...(outcome.costUsd !== undefined ? { costUsd: outcome.costUsd } : {}),
+    };
+    if (outcome.ok) {
+        await callMCPTool('task_complete', { taskId, result });
+        return { dispatched: true, taskId, workerId, status: 'completed', outcome };
+    }
+    await callMCPTool('task_update', { taskId, status: 'failed', result });
+    return { dispatched: true, taskId, workerId, status: 'failed', outcome };
+}
+export const workCommand = {
+    name: 'work',
+    description: 'Run the next pending hive task on an idle worker via Claude Code and record the result',
+    options: [
+        { name: 'task', description: 'Run this task id instead of the oldest pending one', type: 'string' },
+        { name: 'worker', description: 'Assign to this worker id instead of the first idle one', type: 'string' },
+        { name: 'mcp-config', description: 'MCP config for the worker (default: generated, with the ruflo server)', type: 'string' },
+    ],
+    examples: [
+        { command: 'claude-flow hive-mind work', description: 'Run the oldest pending hive task' },
+        { command: 'claude-flow hive-mind work --task task-123', description: 'Run a specific task' },
+    ],
+    action: async (ctx) => {
+        const cwd = ctx.cwd || process.cwd();
+        try {
+            const mcpConfig = resolveWorkerMcpConfig({
+                explicit: ctx.flags.mcpConfig,
+                cwd,
+                home: process.env.HOME || process.env.USERPROFILE || '',
+                outDir: join(cwd, '.hive-mind', 'sessions'),
+                swarmId: 'worker',
+                rufloServer: currentRufloServer(),
+            });
+            const r = await workOnce({
+                cwd,
+                mcpConfig,
+                runner: runWithClaude,
+                taskId: ctx.flags.task,
+                workerId: ctx.flags.worker,
+            });
+            if (ctx.flags.format === 'json') {
+                output.printJson(r);
+            }
+            else if (!r.dispatched) {
+                output.printInfo(r.reason);
+            }
+            else {
+                output.printBox([
+                    `Task ID: ${r.taskId}`,
+                    `Worker: ${r.workerId}`,
+                    `Status: ${r.status}`,
+                    `Duration: ${r.outcome.durationMs}ms`,
+                    '',
+                    r.outcome.output.slice(0, 2000),
+                ].join('\n'), r.status === 'completed' ? 'Task Completed' : 'Task Failed');
+                output.writeln(output.dim(`  Full record: claude-flow task status ${r.taskId}`));
+            }
+            // Nothing to do is not an error; a task that ran and failed is.
+            const failed = r.dispatched && r.status === 'failed';
+            return { success: !failed, exitCode: failed ? 1 : 0, data: r };
+        }
+        catch (error) {
+            const msg = error instanceof MCPClientError ? error.message : String(error);
+            output.printError(`Work error: ${msg}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+//# sourceMappingURL=hive-mind-worker.js.map

package/dist/src/commands/hive-mind.js

@@ -10,7 +10,7 @@ import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { spawn as childSpawn } from 'child_process';
 import { mkdir, writeFile } from 'fs/promises';
-import { existsSync } from 'fs';
+import { resolveWorkerMcpConfig, currentRufloServer, workCommand } from './hive-mind-worker.js';
 import { join } from 'path';
 import { resolveClaudeLaunchCommand } from '../runtime/claude-command.js';
 import { getHiveTokenForCli } from '../mcp-tools/hive-mind-tools.js';
@@ -202,44 +202,25 @@ async function spawnClaudeCodeInstance(swarmId, swarmName, objective, workers, f
             // Build arguments - flags first, then prompt
             const claudeArgs = [];
             // #1748 Issue 2 — pass --mcp-config so the spawned worker actually has
-            // mcp__ruflo__* tools registered. Before this, the coordination prompt
-            // referenced tools the worker didn't know about and exited silently.
-            // Resolution order:
-            //   1. explicit --mcp-config <path> flag passed by the caller
-            //   2. ./.mcp.json in cwd (project-local Ruflo MCP config)
-            //   3. ~/.claude.json or ~/.claude/mcp.json (user-global)
-            // If none found, we still spawn but warn — that's the pre-fix behavior
-            // and the user's debug log will surface the missing tools.
-            const explicitMcpConfig = flags['mcp-config'];
-            let mcpConfigPath = explicitMcpConfig;
-            if (!mcpConfigPath) {
-                const candidates = [
-                    join(process.cwd(), '.mcp.json'),
-                    join(process.env.HOME || process.env.USERPROFILE || '', '.claude.json'),
-                    join(process.env.HOME || process.env.USERPROFILE || '', '.claude', 'mcp.json'),
-                ];
-                for (const c of candidates) {
-                    try {
-                        if (c && existsSync(c)) {
-                            mcpConfigPath = c;
-                            break;
-                        }
-                    }
-                    catch { /* continue */ }
-                }
-            }
-            if (mcpConfigPath) {
-                // #1780 — Claude Code's `--mcp-config` is variadic; passing it as two
-                // argv tokens (`--mcp-config`, `<path>`) lets a later positional (the
-                // hive-mind prompt) be slurped as a second config file, producing
-                // `ENAMETOOLONG: name too long, open` once the prompt exceeds PATH_MAX.
-                // Use `=`-syntax so the flag stays attached to its single value.
-                claudeArgs.push(`--mcp-config=${mcpConfigPath}`);
-                output.printInfo(`Spawned worker MCP config: ${mcpConfigPath}`);
-            }
-            else {
-                output.printWarning('No .mcp.json or ~/.claude.json found — spawned worker will not have mcp__ruflo__* tools (#1748 Issue 2). Pass --mcp-config <path> or run "ruflo init" to generate one.');
-            }
+            // mcp__ruflo__* tools registered. The config is always a generated file
+            // that Claude accepts; see resolveWorkerMcpConfig for why a source
+            // config (notably ~/.claude.json) is never passed through as-is.
+            // The parser stores flags camelCased (#2269), so read both forms.
+            const mcpConfigPath = resolveWorkerMcpConfig({
+                explicit: (flags['mcp-config'] ?? flags.mcpConfig),
+                cwd: process.cwd(),
+                home: process.env.HOME || process.env.USERPROFILE || '',
+                outDir: sessionsDir,
+                swarmId,
+                rufloServer: currentRufloServer(),
+            });
+            // #1780 — Claude Code's `--mcp-config` is variadic; passing it as two
+            // argv tokens (`--mcp-config`, `<path>`) lets a later positional (the
+            // hive-mind prompt) be slurped as a second config file, producing
+            // `ENAMETOOLONG: name too long, open` once the prompt exceeds PATH_MAX.
+            // Use `=`-syntax so the flag stays attached to its single value.
+            claudeArgs.push(`--mcp-config=${mcpConfigPath}`);
+            output.printInfo(`Spawned worker MCP config: ${mcpConfigPath}`);
             // Check for non-interactive mode
             const isNonInteractive = flags['non-interactive'] || flags.nonInteractive;
             if (isNonInteractive) {
@@ -882,7 +863,8 @@ const taskCommand = {
             ].join('\n'), 'Task Submitted');
             output.writeln();
             output.printSuccess('Task submitted to hive');
-            output.writeln(output.dim(`  Track with: claude-flow hive-mind task-status ${result.taskId}`));
+            output.writeln(output.dim(`  Run it with: claude-flow hive-mind work --task ${result.taskId}`));
+            output.writeln(output.dim(`  Track with:  claude-flow task status ${result.taskId}`));
             return { success: true, data: result };
         }
         catch (error) {
@@ -1210,7 +1192,7 @@ export const hiveMindCommand = {
     name: 'hive-mind',
     aliases: ['hive'],
     description: 'Queen-led consensus-based multi-agent coordination',
-    subcommands: [initCommand, spawnCommand, statusCommand, taskCommand, joinCommand, leaveCommand, consensusCommand, broadcastCommand, memorySubCommand, optimizeMemoryCommand, shutdownCommand],
+    subcommands: [initCommand, spawnCommand, statusCommand, taskCommand, workCommand, joinCommand, leaveCommand, consensusCommand, broadcastCommand, memorySubCommand, optimizeMemoryCommand, shutdownCommand],
     options: [],
     examples: [
         { command: 'claude-flow hive-mind init -t hierarchical-mesh', description: 'Initialize hive' },
@@ -1230,6 +1212,7 @@ export const hiveMindCommand = {
             `${output.highlight('spawn')}           - Spawn worker agents (use --claude to launch Claude Code)`,
             `${output.highlight('status')}          - Show hive status`,
             `${output.highlight('task')}            - Submit task to hive`,
+            `${output.highlight('work')}            - Run the next pending task on an idle worker`,
             `${output.highlight('join')}            - Join an agent to the hive`,
             `${output.highlight('leave')}           - Remove an agent from the hive`,
             `${output.highlight('consensus')}       - Manage consensus proposals`,

package/dist/src/commands/hooks.js

@@ -1,7 +1,4 @@
-/**
- * V3 CLI Hooks Command
- * Self-learning hooks system for intelligent workflow automation
- */
+import { validateFeedbackPatterns } from '../memory/feedback-patterns.js';
 import { output } from '../output.js';
 import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
@@ -572,6 +569,11 @@ const postCommandCommand = {
             short: 'd',
             description: 'Execution duration in milliseconds',
             type: 'number'
+        },
+        {
+            name: 'ttl',
+            description: 'Command history lifetime in seconds (default: 30 days)',
+            type: 'number'
         }
     ],
     examples: [
@@ -594,11 +596,16 @@ const postCommandCommand = {
                 success,
                 exitCode: ctx.flags.exitCode || 0,
                 duration: ctx.flags.duration,
+                ttl: ctx.flags.ttl,
                 timestamp: Date.now(),
             });
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
-                return { success: true, data: result };
+                return { success: result.recorded, exitCode: result.recorded ? 0 : 1, data: result };
+            }
+            if (!result.recorded) {
+                output.printError('Command outcome could not be recorded');
+                return { success: false, exitCode: 1, data: result };
             }
             output.writeln();
             output.printSuccess('Command outcome recorded');
@@ -1699,6 +1706,7 @@ const postTaskCommand = {
     name: 'post-task',
     description: 'Record task completion for learning',
     options: [
+        { name: 'patterns', description: 'JSON array of learned pattern strings for feedback and skill creation', type: 'string' },
         {
             name: 'task-id',
             short: 'i',
@@ -1784,8 +1792,10 @@ const postTaskCommand = {
         const success = ctx.flags.success !== undefined ? ctx.flags.success : true;
         output.printInfo(`Recording outcome for task: ${output.highlight(taskId)}`);
         try {
+            const patterns = validateFeedbackPatterns(ctx.flags.patterns === undefined ? undefined : JSON.parse(ctx.flags.patterns));
             const result = await callMCPTool('hooks_post-task', {
                 taskId,
+                patterns,
                 success,
                 quality: ctx.flags.quality,
                 agent: ctx.flags.agent,