claude-flow 3.6.21 → 3.6.23

package/.claude/scheduled_tasks.lock

@@ -1 +1 @@
-{"sessionId":"36428a63-dfb2-42a4-a159-cf8be916193e","pid":86429,"procStart":"Sun May  3 19:17:47 2026","acquiredAt":1777840775529}
+{"sessionId":"36428a63-dfb2-42a4-a159-cf8be916193e","pid":71027,"procStart":"Sun May  3 23:00:23 2026","acquiredAt":1777849234814}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.6.21",
+  "version": "3.6.23",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/mcp-tools/agent-execute-core.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Shared agent-execution core.
+ *
+ * Both the agent_execute MCP tool and the workflow runtime (G3) need
+ * to dispatch a prompt to an agent's configured Anthropic model. This
+ * module factors that path out so it's testable and reusable, and
+ * keeps the wire from agent_spawn → ProviderManager (real) in one
+ * place rather than duplicated.
+ */
+type ClaudeModel = 'haiku' | 'sonnet' | 'opus' | 'inherit';
+export interface AgentRecord {
+    agentId: string;
+    agentType: string;
+    status: 'idle' | 'busy' | 'terminated';
+    health: number;
+    taskCount: number;
+    config: Record<string, unknown>;
+    createdAt: string;
+    domain?: string;
+    model?: ClaudeModel;
+    modelRoutedBy?: 'explicit' | 'router' | 'agent-booster' | 'default';
+    lastResult?: Record<string, unknown>;
+}
+export interface AnthropicCallInput {
+    prompt: string;
+    systemPrompt?: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    timeoutMs?: number;
+}
+export interface AnthropicCallResult {
+    success: boolean;
+    model?: string;
+    messageId?: string;
+    stopReason?: string;
+    output?: string;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    durationMs?: number;
+    error?: string;
+}
+/**
+ * Generic Anthropic Messages API call. No agent registry coupling — used
+ * by agent_execute (with the agent's configured model) and by the WASM
+ * agent runtime (G4) when the bundled WASM only echoes input.
+ */
+export declare function callAnthropicMessages(input: AnthropicCallInput): Promise<AnthropicCallResult>;
+/**
+ * Resolve a model identifier to an Anthropic model ID. Accepts:
+ * - logical names: 'haiku', 'sonnet', 'opus', 'inherit'
+ * - prefixed: 'anthropic:claude-3-5-sonnet-latest'
+ * - direct: 'claude-3-5-sonnet-latest'
+ */
+export declare function resolveAnthropicModel(input: string | undefined): string;
+export interface AgentExecuteInput {
+    agentId: string;
+    prompt: string;
+    systemPrompt?: string;
+    maxTokens?: number;
+    temperature?: number;
+    timeoutMs?: number;
+}
+export interface AgentExecuteResult {
+    success: boolean;
+    agentId: string;
+    model?: string;
+    messageId?: string;
+    stopReason?: string;
+    output?: string;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    durationMs?: number;
+    error?: string;
+    remediation?: string;
+}
+export declare function executeAgentTask(input: AgentExecuteInput): Promise<AgentExecuteResult>;
+export {};
+//# sourceMappingURL=agent-execute-core.d.ts.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/agent-execute-core.js

@@ -0,0 +1,214 @@
+/**
+ * Shared agent-execution core.
+ *
+ * Both the agent_execute MCP tool and the workflow runtime (G3) need
+ * to dispatch a prompt to an agent's configured Anthropic model. This
+ * module factors that path out so it's testable and reusable, and
+ * keeps the wire from agent_spawn → ProviderManager (real) in one
+ * place rather than duplicated.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getProjectCwd } from './types.js';
+const STORAGE_DIR = '.claude-flow';
+const AGENT_DIR = 'agents';
+const AGENT_FILE = 'store.json';
+function getAgentDir() { return join(getProjectCwd(), STORAGE_DIR, AGENT_DIR); }
+function getAgentPath() { return join(getAgentDir(), AGENT_FILE); }
+function ensureAgentDir() {
+    const dir = getAgentDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+function loadAgentStore() {
+    try {
+        if (existsSync(getAgentPath()))
+            return JSON.parse(readFileSync(getAgentPath(), 'utf-8'));
+    }
+    catch { /* fall through */ }
+    return { agents: {}, version: '3.0.0' };
+}
+function saveAgentStore(store) {
+    ensureAgentDir();
+    writeFileSync(getAgentPath(), JSON.stringify(store, null, 2), 'utf-8');
+}
+const MODEL_MAP = {
+    haiku: 'claude-3-5-haiku-latest',
+    sonnet: 'claude-3-5-sonnet-latest',
+    opus: 'claude-3-opus-latest',
+    inherit: 'claude-3-5-sonnet-latest',
+};
+/**
+ * Generic Anthropic Messages API call. No agent registry coupling — used
+ * by agent_execute (with the agent's configured model) and by the WASM
+ * agent runtime (G4) when the bundled WASM only echoes input.
+ */
+export async function callAnthropicMessages(input) {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        return { success: false, error: 'ANTHROPIC_API_KEY not set in environment' };
+    }
+    const model = input.model || 'claude-3-5-sonnet-latest';
+    const startedAt = Date.now();
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), input.timeoutMs || 60000);
+        const res = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: input.maxTokens || 1024,
+                temperature: typeof input.temperature === 'number' ? input.temperature : 0.7,
+                ...(input.systemPrompt ? { system: input.systemPrompt } : {}),
+                messages: [{ role: 'user', content: input.prompt }],
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok) {
+            const errText = await res.text().catch(() => '<unreadable error body>');
+            return { success: false, model, error: `Anthropic API error ${res.status}: ${errText.slice(0, 400)}` };
+        }
+        const data = await res.json();
+        const textOut = data.content
+            .filter(c => c.type === 'text' && typeof c.text === 'string')
+            .map(c => c.text)
+            .join('');
+        return {
+            success: true,
+            model: data.model,
+            messageId: data.id,
+            stopReason: data.stop_reason,
+            output: textOut,
+            usage: {
+                inputTokens: data.usage.input_tokens,
+                outputTokens: data.usage.output_tokens,
+                totalTokens: data.usage.input_tokens + data.usage.output_tokens,
+            },
+            durationMs: Date.now() - startedAt,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            model,
+            error: err instanceof Error ? err.message : String(err),
+            durationMs: Date.now() - startedAt,
+        };
+    }
+}
+/**
+ * Resolve a model identifier to an Anthropic model ID. Accepts:
+ * - logical names: 'haiku', 'sonnet', 'opus', 'inherit'
+ * - prefixed: 'anthropic:claude-3-5-sonnet-latest'
+ * - direct: 'claude-3-5-sonnet-latest'
+ */
+export function resolveAnthropicModel(input) {
+    if (!input)
+        return 'claude-3-5-sonnet-latest';
+    if (input in MODEL_MAP)
+        return MODEL_MAP[input];
+    if (input.startsWith('anthropic:'))
+        return input.slice('anthropic:'.length);
+    return input;
+}
+export async function executeAgentTask(input) {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        return {
+            success: false,
+            agentId: input.agentId,
+            error: 'ANTHROPIC_API_KEY not set in environment',
+            remediation: 'Set the env var and re-run. The key is read at call time.',
+        };
+    }
+    const store = loadAgentStore();
+    const agent = store.agents[input.agentId];
+    if (!agent)
+        return { success: false, agentId: input.agentId, error: 'Agent not found' };
+    if (agent.status === 'terminated')
+        return { success: false, agentId: input.agentId, error: 'Agent has been terminated' };
+    const anthropicModel = MODEL_MAP[agent.model || 'sonnet'] || 'claude-3-5-sonnet-latest';
+    const systemPrompt = input.systemPrompt ||
+        `You are a ${agent.agentType} agent operating as part of a Ruflo swarm. ` +
+            `Agent ID: ${input.agentId}. Domain: ${agent.domain ?? 'general'}. ` +
+            `Respond directly and stay focused on the task. If you need information you don't have, state that explicitly.`;
+    agent.status = 'busy';
+    agent.taskCount = (agent.taskCount || 0) + 1;
+    saveAgentStore(store);
+    const startedAt = Date.now();
+    try {
+        const controller = new AbortController();
+        const timeoutMs = input.timeoutMs || 60000;
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        const res = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: anthropicModel,
+                max_tokens: input.maxTokens || 1024,
+                temperature: typeof input.temperature === 'number' ? input.temperature : 0.7,
+                system: systemPrompt,
+                messages: [{ role: 'user', content: input.prompt }],
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok) {
+            const errText = await res.text().catch(() => '<unreadable error body>');
+            agent.status = 'idle';
+            saveAgentStore(store);
+            return {
+                success: false,
+                agentId: input.agentId,
+                model: anthropicModel,
+                error: `Anthropic API error ${res.status}: ${errText.slice(0, 400)}`,
+            };
+        }
+        const data = await res.json();
+        const textOut = data.content
+            .filter(c => c.type === 'text' && typeof c.text === 'string')
+            .map(c => c.text)
+            .join('');
+        const result = {
+            success: true,
+            agentId: input.agentId,
+            messageId: data.id,
+            model: data.model,
+            stopReason: data.stop_reason,
+            output: textOut,
+            usage: {
+                inputTokens: data.usage.input_tokens,
+                outputTokens: data.usage.output_tokens,
+                totalTokens: data.usage.input_tokens + data.usage.output_tokens,
+            },
+            durationMs: Date.now() - startedAt,
+        };
+        agent.status = 'idle';
+        agent.lastResult = result;
+        saveAgentStore(store);
+        return result;
+    }
+    catch (err) {
+        agent.status = 'idle';
+        saveAgentStore(store);
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            success: false,
+            agentId: input.agentId,
+            model: anthropicModel,
+            error: `agent_execute failed: ${msg}`,
+            durationMs: Date.now() - startedAt,
+        };
+    }
+}
+//# sourceMappingURL=agent-execute-core.js.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/agent-tools.js

@@ -7,7 +7,8 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
-import { validateIdentifier, validateAgentSpawn } from './validate-input.js';
+import { validateIdentifier, validateText, validateAgentSpawn } from './validate-input.js';
+import { executeAgentTask } from './agent-execute-core.js';
 // Storage paths
 const STORAGE_DIR = '.claude-flow';
 const AGENT_DIR = 'agents';
@@ -199,7 +200,10 @@ export const agentTools = [
                 modelRoutedBy: routingResult.routedBy,
                 status: 'registered',
                 createdAt: agent.createdAt,
-                note: 'Agent registered for coordination. Use Claude Code Task tool or claude -p to execute work.',
+                note: 'Agent registered for coordination. Three execution paths: ' +
+                    '(1) call agent_execute(agentId, prompt) — direct LLM call via Anthropic Messages API (requires ANTHROPIC_API_KEY); ' +
+                    '(2) Claude Code Task tool — spawns a real subagent; ' +
+                    '(3) claude -p — headless background instance.',
             };
             // Add Agent Booster info if task can skip LLM
             if (routingResult.canSkipLLM) {
@@ -214,6 +218,47 @@ export const agentTools = [
             return response;
         },
     },
+    {
+        // ADR-095 G1: real LLM execution via the agent registry. Previously
+        // agent_spawn registered metadata but nothing dispatched work to a
+        // provider — the wire between AnthropicProvider and the agent
+        // registry was missing, as the April audit (@roman-rr) called out.
+        // agent_execute closes that wire by reading the agent's configured
+        // model, calling the Anthropic Messages API directly via fetch, and
+        // updating the agent record with lastResult / taskCount / status.
+        // No mock — actual HTTP request to api.anthropic.com.
+        name: 'agent_execute',
+        description: 'Execute a task on a spawned agent — calls the Anthropic Messages API with the agent\'s configured model. Requires ANTHROPIC_API_KEY in env.',
+        category: 'agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'ID of the spawned agent' },
+                prompt: { type: 'string', description: 'Task / prompt for the agent to execute' },
+                systemPrompt: { type: 'string', description: 'Optional system prompt (overrides agent default)' },
+                maxTokens: { type: 'number', description: 'Max output tokens (default 1024)' },
+                temperature: { type: 'number', description: 'Sampling temperature 0..1 (default 0.7)' },
+            },
+            required: ['agentId', 'prompt'],
+        },
+        handler: async (input) => {
+            const vId = validateIdentifier(input.agentId, 'agentId');
+            if (!vId.valid)
+                return { success: false, error: `Input validation failed: ${vId.error}` };
+            const vP = validateText(input.prompt, 'prompt');
+            if (!vP.valid)
+                return { success: false, error: `Input validation failed: ${vP.error}` };
+            // Delegate to the shared core (also used by the workflow runtime).
+            return executeAgentTask({
+                agentId: input.agentId,
+                prompt: input.prompt,
+                systemPrompt: input.systemPrompt,
+                maxTokens: input.maxTokens,
+                temperature: input.temperature,
+                timeoutMs: input.timeoutMs,
+            });
+        },
+    },
     {
         name: 'agent_terminate',
         description: 'Terminate an agent',

package/v3/@claude-flow/cli/dist/src/mcp-tools/workflow-tools.js

@@ -7,6 +7,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
 import { validateIdentifier, validatePath, validateText } from './validate-input.js';
+import { executeAgentTask } from './agent-execute-core.js';
 // Storage paths
 const STORAGE_DIR = '.claude-flow';
 const WORKFLOW_DIR = 'workflows';
@@ -247,25 +248,156 @@ export const workflowTools = [
             workflow.status = 'running';
             workflow.startedAt = new Date().toISOString();
             workflow.currentStep = input.startFromStep || 0;
-            // Set steps to pending — actual execution requires agent assignment via task tools
-            const results = [];
-            for (let i = workflow.currentStep; i < workflow.steps.length; i++) {
-                const step = workflow.steps[i];
-                step.status = 'pending';
-                results.push({
-                    stepId: step.stepId,
-                    status: step.status,
-                    _note: 'Workflow execution tracks state. Actual step execution requires agent assignment via task tools.',
+            saveWorkflowStore(store);
+            // ADR-095 G3: real workflow runtime. Walk the steps in order;
+            // dispatch each by type. Persist progress after each step so a
+            // crash or pause can resume cleanly. No mock — task steps make
+            // real LLM calls via agent_execute (G1's wire).
+            const stepResults = [];
+            // Variable substitution: {{name}} → workflow.variables[name] OR steps[stepId].output
+            const interp = (text) => {
+                return text.replace(/\{\{\s*([a-zA-Z_][\w.]*)\s*\}\}/g, (_, key) => {
+                    // Direct variable
+                    if (key in workflow.variables)
+                        return String(workflow.variables[key]);
+                    // Step-output reference: stepId.output
+                    const dot = key.indexOf('.');
+                    if (dot > 0) {
+                        const stepId = key.slice(0, dot);
+                        const field = key.slice(dot + 1);
+                        const prior = stepResults.find(s => s.stepId === stepId);
+                        if (prior && field === 'output' && typeof prior.output === 'string')
+                            return prior.output;
+                    }
+                    return '';
                 });
+            };
+            const startedAt = Date.now();
+            let i = workflow.currentStep;
+            while (i < workflow.steps.length) {
+                // Honor pause/cancel signals between steps.
+                const live = loadWorkflowStore().workflows[workflowId];
+                if (!live || live.status === 'paused') {
+                    workflow.status = 'paused';
+                    workflow.currentStep = i;
+                    saveWorkflowStore(store);
+                    break;
+                }
+                if (live.status === 'failed') {
+                    workflow.status = 'failed';
+                    saveWorkflowStore(store);
+                    break;
+                }
+                const step = workflow.steps[i];
+                step.status = 'running';
+                step.startedAt = new Date().toISOString();
+                const stepStart = Date.now();
+                saveWorkflowStore(store);
+                let stepEntry = { stepId: step.stepId, type: step.type, status: 'running' };
+                try {
+                    if (step.type === 'task') {
+                        const cfg = step.config;
+                        const agentId = cfg.agentId || workflow.variables.defaultAgentId;
+                        const promptTpl = cfg.prompt || step.name;
+                        if (!agentId)
+                            throw new Error(`task step ${step.stepId} requires config.agentId or workflow.variables.defaultAgentId`);
+                        const prompt = interp(promptTpl);
+                        const result = await executeAgentTask({
+                            agentId,
+                            prompt,
+                            systemPrompt: cfg.systemPrompt ? interp(String(cfg.systemPrompt)) : undefined,
+                            maxTokens: cfg.maxTokens,
+                            temperature: cfg.temperature,
+                            timeoutMs: cfg.timeoutMs,
+                        });
+                        if (!result.success)
+                            throw new Error(result.error || 'agent_execute failed');
+                        step.result = result;
+                        workflow.variables[`${step.stepId}.output`] = result.output;
+                        workflow.variables.lastStepOutput = result.output;
+                        stepEntry = { stepId: step.stepId, type: 'task', status: 'completed', durationMs: result.durationMs, output: result.output };
+                    }
+                    else if (step.type === 'wait') {
+                        const cfg = step.config;
+                        const ms = Math.min(Math.max(0, cfg.ms || 0), 60000);
+                        await new Promise(r => setTimeout(r, ms));
+                        step.result = { waitedMs: ms };
+                        stepEntry = { stepId: step.stepId, type: 'wait', status: 'completed', durationMs: ms };
+                    }
+                    else if (step.type === 'condition') {
+                        // Simple condition: config.when is a JS expression evaluated against workflow.variables.
+                        // For safety, we only support `var === 'value'` or `var === number`.
+                        const cfg = step.config;
+                        const expr = String(cfg.when || 'true').trim();
+                        const m = expr.match(/^([a-zA-Z_][\w]*)\s*===?\s*(['\"])?([^'\"]*)\2?$/);
+                        let truthy = false;
+                        if (m) {
+                            const v = workflow.variables[m[1]];
+                            const expected = m[2] ? m[3] : Number(m[3]);
+                            truthy = v === expected;
+                        }
+                        else if (expr === 'true')
+                            truthy = true;
+                        step.result = { conditionExpr: expr, truthy };
+                        // condition can declare a target step index to jump to via cfg.thenStep / cfg.elseStep
+                        if (typeof cfg.thenStep === 'number' && truthy)
+                            i = cfg.thenStep - 1;
+                        if (typeof cfg.elseStep === 'number' && !truthy)
+                            i = cfg.elseStep - 1;
+                        stepEntry = { stepId: step.stepId, type: 'condition', status: 'completed' };
+                    }
+                    else {
+                        // parallel/loop are deferred — mark skipped honestly rather than mock-completing.
+                        step.result = { _note: `step type '${step.type}' not yet implemented in runtime` };
+                        stepEntry = { stepId: step.stepId, type: step.type, status: 'skipped' };
+                    }
+                    step.status = stepEntry.status === 'skipped' ? 'skipped' : 'completed';
+                    step.completedAt = new Date().toISOString();
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    step.status = 'failed';
+                    step.result = { error: msg };
+                    step.completedAt = new Date().toISOString();
+                    stepEntry = { stepId: step.stepId, type: step.type, status: 'failed', durationMs: Date.now() - stepStart, error: msg };
+                    stepResults.push(stepEntry);
+                    workflow.status = 'failed';
+                    workflow.error = msg;
+                    workflow.completedAt = new Date().toISOString();
+                    saveWorkflowStore(store);
+                    return {
+                        workflowId,
+                        status: 'failed',
+                        error: msg,
+                        failedStep: step.stepId,
+                        stepsCompleted: stepResults.filter(s => s.status === 'completed').length,
+                        results: stepResults,
+                        durationMs: Date.now() - startedAt,
+                    };
+                }
+                if (typeof stepEntry.durationMs !== 'number')
+                    stepEntry.durationMs = Date.now() - stepStart;
+                stepResults.push(stepEntry);
+                workflow.currentStep = i + 1;
+                saveWorkflowStore(store);
+                i++;
+            }
+            if (workflow.status === 'running') {
+                workflow.status = 'completed';
+                workflow.completedAt = new Date().toISOString();
+                saveWorkflowStore(store);
             }
-            saveWorkflowStore(store);
             return {
                 workflowId,
                 status: workflow.status,
-                totalSteps: results.length,
-                results,
+                totalSteps: workflow.steps.length,
+                stepsCompleted: stepResults.filter(s => s.status === 'completed').length,
+                stepsSkipped: stepResults.filter(s => s.status === 'skipped').length,
+                stepsFailed: stepResults.filter(s => s.status === 'failed').length,
+                results: stepResults,
                 startedAt: workflow.startedAt,
-                _note: 'Workflow is now running. Steps are in pending state and must be executed via task tools.',
+                completedAt: workflow.completedAt,
+                durationMs: Date.now() - startedAt,
             };
         },
     },

package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.js

@@ -186,20 +186,108 @@ async function getRegistry(dbPath) {
                             }
                         }
                         catch { /* router optional */ }
+                        // ADR-095 G7: load disabled-by-default controllers via direct
+                        // file:// URLs from the bundled agentdb. agentdb's exports
+                        // field doesn't expose these subpaths and we can't reliably
+                        // patch it across pnpm-hoisted multi-version trees, so we
+                        // sidestep the exports field entirely and import the file
+                        // by absolute URL. Only loads controllers whose constructor
+                        // is safe with no special prerequisites — others remain off
+                        // pending per-controller activation ADRs.
+                        try {
+                            const { createRequire } = await import('node:module');
+                            const { pathToFileURL } = await import('node:url');
+                            const path = await import('node:path');
+                            const fs = await import('node:fs');
+                            const cjsRequire = createRequire(import.meta.url);
+                            let adbPkgJsonPath = null;
+                            try {
+                                adbPkgJsonPath = cjsRequire.resolve('agentdb/package.json');
+                            }
+                            catch {
+                                adbPkgJsonPath = null;
+                            }
+                            if (adbPkgJsonPath) {
+                                const adbDir = path.dirname(adbPkgJsonPath);
+                                const candidates = [
+                                    // GNNService and RVFOptimizer can construct with no args
+                                    // in current agentdb — safe to activate as-is.
+                                    { name: 'gnnService', relPath: 'dist/src/services/GNNService.js', configurable: false },
+                                    { name: 'rvfOptimizer', relPath: 'dist/src/optimizations/RVFOptimizer.js', configurable: false },
+                                    // ADR-095 G7 follow-up: MutationGuard constructs cleanly
+                                    // with no args and exposes WASM-backed proof generation.
+                                    // No external deps; safe-default activation.
+                                    { name: 'mutationGuard', relPath: 'dist/src/security/MutationGuard.js', configurable: false },
+                                    // AttestationLog needs a sqlite db handle — wired below
+                                    // separately because we have to construct a db too.
+                                    // GuardedVectorBackend needs key material — leave for
+                                    // follow-up ADR.
+                                ];
+                                for (const cand of candidates) {
+                                    if (reg.get(cand.name))
+                                        continue;
+                                    const abs = path.join(adbDir, cand.relPath);
+                                    if (!fs.existsSync(abs))
+                                        continue;
+                                    try {
+                                        const url = pathToFileURL(abs).href;
+                                        const mod = await import(url);
+                                        // Look for a default export, named export matching the
+                                        // file basename, or any class-typed export.
+                                        const baseName = path.basename(cand.relPath, '.js');
+                                        const Ctor = (mod[baseName] || mod.default ||
+                                            Object.values(mod).find(v => typeof v === 'function'));
+                                        if (typeof Ctor !== 'function')
+                                            continue;
+                                        const inst = new Ctor();
+                                        if (typeof reg.set === 'function')
+                                            reg.set(cand.name, inst);
+                                        else
+                                            reg._controllers = { ...(reg._controllers || {}), [cand.name]: inst };
+                                    }
+                                    catch { /* skip controllers that fail to construct */ }
+                                }
+                                // AttestationLog activation — needs a better-sqlite3
+                                // database. We open a dedicated file at .swarm/attestation.db
+                                // (separate from the main memory.db so the audit trail
+                                // is isolated). Best-effort: if better-sqlite3 isn't
+                                // resolvable in this env, skip cleanly.
+                                if (!reg.get('attestationLog')) {
+                                    try {
+                                        const attestationFile = path.join(adbDir, 'dist/src/security/AttestationLog.js');
+                                        if (fs.existsSync(attestationFile)) {
+                                            const Database = cjsRequire('better-sqlite3');
+                                            const swarmDir = path.resolve(process.cwd(), '.swarm');
+                                            if (!fs.existsSync(swarmDir))
+                                                fs.mkdirSync(swarmDir, { recursive: true });
+                                            const dbPath = path.join(swarmDir, 'attestation.db');
+                                            const db = new Database(dbPath);
+                                            const url = pathToFileURL(attestationFile).href;
+                                            const mod = await import(url);
+                                            const Ctor = mod.AttestationLog;
+                                            if (typeof Ctor === 'function') {
+                                                const inst = new Ctor({ db });
+                                                if (typeof reg.set === 'function')
+                                                    reg.set('attestationLog', inst);
+                                                else
+                                                    reg._controllers = { ...(reg._controllers || {}), attestationLog: inst };
+                                            }
+                                        }
+                                    }
+                                    catch { /* better-sqlite3 missing or schema init failed — skip silently */ }
+                                }
+                            }
+                        }
+                        catch { /* G7 wiring optional */ }
                     })();
                     // Run both in parallel; settle either way so a single failing
                     // path doesn't tear down the rest of the post-init wiring.
                     await Promise.allSettled([intelligencePromise, agentdbPromise]);
-                    // Other disabled controllers remain disabled and tracked in
-                    // ADR-093 F9 for future enablement:
-                    //   - mutationGuard (write protection — needs config)
-                    //   - attestationLog (needs sqlite db handle the registry does
-                    //     not currently expose)
-                    //   - gnnService (graph neural net — heavy deps, needs WASM/CUDA)
-                    //   - guardedVectorBackend (secured vector backend variant —
-                    //     needs key material)
-                    //   - rvfOptimizer (RVF format optimizer — needs RVF storage)
-                    //   - graphAdapter (graph DB adapter — needs graph DB)
+                    // Remaining disabled controllers tracked in ADR-095 G7 for
+                    // per-controller activation ADRs (each needs config / key
+                    // material that we don't pass blindly):
+                    //   - guardedVectorBackend (secured backend — needs key material)
+                    //   - graphAdapter (graph DB adapter — needs graph DB connection)
                 }
                 catch {
                     // Top-level catch — registry stays usable even if post-init wiring fails wholesale.

package/v3/@claude-flow/cli/dist/src/ruvector/agent-wasm.d.ts

@@ -84,7 +84,18 @@ export declare function initAgentWasm(): Promise<void>;
  */
 export declare function createWasmAgent(config?: WasmAgentConfig): Promise<WasmAgentInfo>;
 /**
- * Send a prompt to a WASM agent. Requires a model provider to be set.
+ * Send a prompt to a WASM agent.
+ *
+ * ADR-095 G4: the bundled @ruvector/rvagent-wasm doesn't actually run an
+ * LLM — its prompt() method echoes input back as `"echo: <input>"`. We
+ * detect that stub output and route the prompt through Anthropic's
+ * Messages API so users get a real response. The WASM agent's sandbox
+ * (virtual filesystem, tool execution) still works for non-LLM ops via
+ * executeWasmTool — we're just patching the "talk to a model" hole.
+ *
+ * If ANTHROPIC_API_KEY is not set, returns the stub output verbatim so
+ * the failure mode is obvious to the caller (matches the previous
+ * behaviour rather than throwing for users without keys configured).
  */
 export declare function promptWasmAgent(agentId: string, input: string): Promise<string>;
 export declare function executeWasmTool(agentId: string, toolCall: Record<string, unknown>): Promise<ToolResult>;

package/v3/@claude-flow/cli/dist/src/ruvector/agent-wasm.js

@@ -80,7 +80,18 @@ export async function createWasmAgent(config = {}) {
     return info;
 }
 /**
- * Send a prompt to a WASM agent. Requires a model provider to be set.
+ * Send a prompt to a WASM agent.
+ *
+ * ADR-095 G4: the bundled @ruvector/rvagent-wasm doesn't actually run an
+ * LLM — its prompt() method echoes input back as `"echo: <input>"`. We
+ * detect that stub output and route the prompt through Anthropic's
+ * Messages API so users get a real response. The WASM agent's sandbox
+ * (virtual filesystem, tool execution) still works for non-LLM ops via
+ * executeWasmTool — we're just patching the "talk to a model" hole.
+ *
+ * If ANTHROPIC_API_KEY is not set, returns the stub output verbatim so
+ * the failure mode is obvious to the caller (matches the previous
+ * behaviour rather than throwing for users without keys configured).
  */
 export async function promptWasmAgent(agentId, input) {
     const entry = agents.get(agentId);
@@ -88,10 +99,34 @@ export async function promptWasmAgent(agentId, input) {
         throw new Error(`WASM agent not found: ${agentId}`);
     entry.info.state = 'running';
     try {
-        const result = await entry.agent.prompt(input);
+        const wasmResult = await entry.agent.prompt(input);
         entry.info.state = 'idle';
         syncAgentInfo(entry);
-        return result;
+        // Detect the WASM echo stub.
+        const isEchoStub = typeof wasmResult === 'string' &&
+            (wasmResult === `echo: ${input}` || /^echo: /.test(wasmResult.slice(0, 12)));
+        if (!isEchoStub) {
+            return wasmResult;
+        }
+        // Echo stub detected — route through a real LLM call.
+        if (!process.env.ANTHROPIC_API_KEY) {
+            // No key configured; surface the stub honestly with a hint.
+            return `${wasmResult}\n[NOTE: bundled WASM agent has no LLM; set ANTHROPIC_API_KEY to enable real responses via Anthropic Messages API]`;
+        }
+        const { callAnthropicMessages, resolveAnthropicModel } = await import('../mcp-tools/agent-execute-core.js');
+        const model = resolveAnthropicModel(entry.info.config.model);
+        const systemPrompt = entry.info.config.instructions || 'You are a helpful coding assistant running in a Ruflo WASM agent sandbox.';
+        const result = await callAnthropicMessages({
+            prompt: input,
+            systemPrompt,
+            model,
+            maxTokens: 2048,
+        });
+        if (!result.success) {
+            return `${wasmResult}\n[NOTE: bundled WASM agent has no LLM; Anthropic fallback failed: ${result.error}]`;
+        }
+        // Return the real LLM output, not the echo stub.
+        return result.output ?? '';
     }
     catch (err) {
         entry.info.state = 'error';

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.6.21",
+  "version": "3.6.23",
   "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",
@@ -76,6 +76,7 @@
   "files": [
     "dist",
     "bin",
+    "scripts",
     ".claude",
     "README.md"
   ],
@@ -84,7 +85,7 @@
     "test": "vitest run",
     "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 -e \"const{existsSync,cpSync,readdirSync,statSync}=require('fs');const{join,dirname}=require('path');try{const r=require.resolve('agentdb');const base=r.includes('dist/src')?join(dirname(r),'..','..'):(r.includes('dist')?join(dirname(r),'..'):dirname(r));const srcDist=join(base,'dist','src');if(!existsSync(srcDist))process.exit(0);for(const e of readdirSync(srcDist)){const s=join(srcDist,e);const t=join(base,'dist',e);try{if(statSync(s).isDirectory()&&!existsSync(t)){cpSync(s,t,{recursive:true});}}catch{}}}catch{}\"",
+    "postinstall": "node ./scripts/postinstall.cjs",
     "prepublishOnly": "cp ../../../README.md ./README.md",
     "release": "npm version prerelease --preid=alpha && npm run publish:all",
     "publish:all": "./scripts/publish.sh"