claude-flow 3.7.0-alpha.3 → 3.7.0-alpha.30

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

@@ -39,8 +39,16 @@ import { agentdbTools } from './mcp-tools/agentdb-tools.js';
 // RuVector WASM tools
 import { ruvllmWasmTools } from './mcp-tools/ruvllm-tools.js';
 import { wasmAgentTools } from './mcp-tools/wasm-agent-tools.js';
+// ADR-115: Anthropic Claude Managed Agents — a cloud agent runtime alongside
+// the local WASM-sandboxed `wasm_agent_*` (rvagent) tools. Lives in the
+// `ruflo-agent` plugin.
+import { managedAgentTools } from './mcp-tools/managed-agent-tools.js';
 import { guidanceTools } from './mcp-tools/guidance-tools.js';
 import { autopilotTools } from './mcp-tools/autopilot-tools.js';
+// #1916: coverage-aware routing tools — defined in ruvector/coverage-tools.ts
+// but were never registered, so the `ruflo hooks coverage-*` CLI subcommands
+// failed with `Tool not found: hooks_coverage-route`.
+import { coverageRouterTools } from './ruvector/coverage-tools.js';
 // #1605: Only register browser tools if agent-browser is available
 let _browserAvailable = null;
 function getBrowserTools() {
@@ -107,10 +115,14 @@ registerTools([
     // RuVector WASM tools
     ...ruvllmWasmTools,
     ...wasmAgentTools,
+    // ADR-115: Anthropic Claude Managed Agents (cloud agent runtime)
+    ...managedAgentTools,
     // Guidance & discovery tools
     ...guidanceTools,
     // Autopilot persistent completion tools
     ...autopilotTools,
+    // #1916: coverage-aware routing (hooks_coverage-route / -suggest / -gaps)
+    ...coverageRouterTools,
 ]);
 /**
  * MCP Client Error

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

@@ -21,6 +21,7 @@ export interface AgentRecord {
     modelRoutedBy?: 'explicit' | 'router' | 'agent-booster' | 'default';
     lastResult?: Record<string, unknown>;
 }
+export declare const DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-6";
 export interface AnthropicCallInput {
     prompt: string;
     systemPrompt?: string;
@@ -58,8 +59,8 @@ export declare function callAnthropicMessages(input: AnthropicCallInput): Promis
 /**
  * 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'
+ * - prefixed: 'anthropic:claude-sonnet-4-6'
+ * - direct: 'claude-sonnet-4-6'
  */
 export declare function resolveAnthropicModel(input: string | undefined): string;
 export interface AgentExecuteInput {

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

@@ -32,11 +32,18 @@ function saveAgentStore(store) {
     ensureAgentDir();
     writeFileSync(getAgentPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
+// #1906 — these were stuck on Claude-3.x ids that the Anthropic API now
+// 404s. Current model ids (Claude 4.x family):
+//   Opus 4.7    → claude-opus-4-7
+//   Sonnet 4.6  → claude-sonnet-4-6
+//   Haiku 4.5   → claude-haiku-4-5-20251001
+// `inherit` and the various defaults below all map to Sonnet 4.6.
+export const DEFAULT_ANTHROPIC_MODEL = 'claude-sonnet-4-6';
 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',
+    haiku: 'claude-haiku-4-5-20251001',
+    sonnet: 'claude-sonnet-4-6',
+    opus: 'claude-opus-4-7',
+    inherit: DEFAULT_ANTHROPIC_MODEL,
 };
 /**
  * Generic Anthropic Messages API call. No agent registry coupling — used
@@ -63,7 +70,7 @@ export async function callAnthropicMessages(input) {
             error: 'No LLM provider configured. Set ANTHROPIC_API_KEY (Tier-3) or OLLAMA_API_KEY (Tier-2 Ollama Cloud — see issue #1725).',
         };
     }
-    const model = input.model || 'claude-3-5-sonnet-latest';
+    const model = input.model || DEFAULT_ANTHROPIC_MODEL;
     const startedAt = Date.now();
     try {
         const controller = new AbortController();
@@ -212,12 +219,12 @@ function resolveOllamaModel(input) {
 /**
  * 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'
+ * - prefixed: 'anthropic:claude-sonnet-4-6'
+ * - direct: 'claude-sonnet-4-6'
  */
 export function resolveAnthropicModel(input) {
     if (!input)
-        return 'claude-3-5-sonnet-latest';
+        return DEFAULT_ANTHROPIC_MODEL;
     if (input in MODEL_MAP)
         return MODEL_MAP[input];
     if (input.startsWith('anthropic:'))
@@ -240,7 +247,7 @@ export async function executeAgentTask(input) {
         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 anthropicModel = MODEL_MAP[agent.model || 'sonnet'] || DEFAULT_ANTHROPIC_MODEL;
     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'}. ` +

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

@@ -13,6 +13,11 @@ import { executeAgentTask } from './agent-execute-core.js';
 const STORAGE_DIR = '.claude-flow';
 const AGENT_DIR = 'agents';
 const AGENT_FILE = 'store.json';
+// #1916: hive-mind_spawn writes its workers to `.claude-flow/agents.json`
+// (a *different* file from the canonical `.claude-flow/agents/store.json`
+// used here). agent_status / agent_list / agent_logs merge that store so a
+// hive-spawned worker is resolvable instead of returning `not_found`.
+const HIVE_AGENT_FILE = 'agents.json';
 function getAgentDir() {
     return join(getProjectCwd(), STORAGE_DIR, AGENT_DIR);
 }
@@ -42,6 +47,33 @@ function saveAgentStore(store) {
     ensureAgentDir();
     writeFileSync(getAgentPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
+// #1916: read hive-mind-spawned workers from `.claude-flow/agents.json`.
+function getHiveAgentPath() {
+    return join(getProjectCwd(), STORAGE_DIR, HIVE_AGENT_FILE);
+}
+function loadHiveAgents() {
+    try {
+        const path = getHiveAgentPath();
+        if (existsSync(path)) {
+            const data = JSON.parse(readFileSync(path, 'utf-8'));
+            if (data && typeof data.agents === 'object' && data.agents) {
+                return data.agents;
+            }
+        }
+    }
+    catch {
+        // Ignore — hive store is optional/best-effort.
+    }
+    return {};
+}
+/**
+ * #1916: merged view of every tracked agent — the canonical agent store
+ * plus hive-mind-spawned workers. On an id collision the canonical record
+ * wins (it carries model-routing + lastResult that the hive store omits).
+ */
+function loadAllAgents() {
+    return { ...loadHiveAgents(), ...loadAgentStore().agents };
+}
 // Default model mappings for agent types (can be overridden)
 const AGENT_TYPE_MODEL_DEFAULTS = {
     // Complex agents → opus
@@ -228,7 +260,7 @@ export const agentTools = [
         // 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.',
+        description: 'Run a task on a previously-spawned agent_spawn record via the Anthropic Messages API with that agent\'s configured model. Use when native Task tool is wrong because (a) you need the spawned agent\'s persistent config (model, instructions, cost-tracking attribution) to apply to this turn, (b) the result needs to feed back into the agent\'s lifecycle (taskCount, lastResult, swarm-coordinated state), or (c) you want explicit model routing via the spawn record\'s `model` field instead of inheriting. For one-shot Claude prompts without a tracked agent, native Task is fine. Requires ANTHROPIC_API_KEY in env.',
         category: 'agent',
         inputSchema: {
             type: 'object',
@@ -261,7 +293,7 @@ export const agentTools = [
     },
     {
         name: 'agent_terminate',
-        description: 'Terminate an agent',
+        description: 'Remove a Ruflo-tracked agent from the registry and free its swarm slot. Use when you need to (a) clean up a spawned agent so its cost-tracking row finalizes, (b) reclaim a swarm-topology slot for another agent, or (c) end a stuck agent without restarting the whole swarm. For one-shot Task tool invocations that already self-terminate, this tool is not needed. Pair with agent_list first to confirm the agentId.',
         category: 'agent',
         inputSchema: {
             type: 'object',
@@ -296,7 +328,7 @@ export const agentTools = [
     },
     {
         name: 'agent_status',
-        description: 'Get agent status',
+        description: 'Read the lifecycle state of a single tracked agent: idle/running/stopped, current taskCount, lastResult, model, health score. Use when native Task tool is wrong because you need agent-level state (status across turns, accumulated taskCount, last error, swarm coordination) rather than a one-shot response. For inspecting a Task you just ran, native Task output is fine. Pair with agent_list to find the agentId first.',
         category: 'agent',
         inputSchema: {
             type: 'object',
@@ -309,9 +341,8 @@ export const agentTools = [
             const v = validateIdentifier(input.agentId, 'agentId');
             if (!v.valid)
                 return { agentId: input.agentId, status: 'not_found', error: `Input validation failed: ${v.error}` };
-            const store = loadAgentStore();
             const agentId = input.agentId;
-            const agent = store.agents[agentId];
+            const agent = loadAllAgents()[agentId]; // #1916: includes hive-mind-spawned workers
             if (agent) {
                 return {
                     agentId: agent.agentId,
@@ -333,7 +364,7 @@ export const agentTools = [
     },
     {
         name: 'agent_list',
-        description: 'List all agents',
+        description: 'List every Ruflo-tracked agent in the registry with its type, model, status, and taskCount. Use when native Task tool is wrong because you need to see the swarm-wide agent inventory across turns (which agents exist, their roles, their cost-tracking handles) rather than spawn a new one-shot Task. Filter by status/domain/agentType if needed. For starting a fresh single-shot subagent, native Task is fine.',
         category: 'agent',
         inputSchema: {
             type: 'object',
@@ -354,8 +385,7 @@ export const agentTools = [
                 if (!v.valid)
                     return { agents: [], total: 0, error: `Input validation failed: ${v.error}` };
             }
-            const store = loadAgentStore();
-            let agents = Object.values(store.agents);
+            let agents = Object.values(loadAllAgents()); // #1916: includes hive-mind-spawned workers
             // Filter by status
             if (input.status) {
                 agents = agents.filter(a => a.status === input.status);
@@ -388,7 +418,7 @@ export const agentTools = [
     },
     {
         name: 'agent_pool',
-        description: 'Manage agent pool',
+        description: 'Manage a fixed-size warm pool of pre-spawned agents to skip cold-start cost on bursty workloads. Use when native Task is wrong because (a) you have a queue of similar tasks and want to amortize spawn latency, (b) cost-tracking wants stable agentIds across requests, or (c) swarm topology requires a known agent count at all times. For one-shot work, just call agent_spawn or native Task. Pool sizes and warm/idle thresholds are set per-pool.',
         category: 'agent',
         inputSchema: {
             type: 'object',
@@ -505,7 +535,7 @@ export const agentTools = [
     },
     {
         name: 'agent_health',
-        description: 'Check agent health',
+        description: 'Compute an agent\'s rolling health score (0-1) from recent task success ratio + response-latency p50/p95 + error rate. Use when native Task tool is wrong because you\'re running a long-lived agent (autonomous loop / hive-mind worker / federation peer) and need to detect degradation before the breaker trips it. For one-shot Task invocations there is no history to score. Pair with hooks_post-task so the scores stay current.',
         category: 'agent',
         inputSchema: {
             type: 'object',
@@ -580,7 +610,7 @@ export const agentTools = [
     },
     {
         name: 'agent_update',
-        description: 'Update agent status or config',
+        description: 'Mutate a tracked agent\'s config (model, instructions, status, health) without re-spawning. Use when native Task tool is wrong because the agent already has accumulated state (taskCount, swarm membership, cost-tracking attribution) and you only need to tweak one field — for example, promoting an idle agent to running on a new task, or rotating its model from haiku to sonnet mid-loop. For a brand-new subagent, agent_spawn (or native Task) is the right call.',
         category: 'agent',
         inputSchema: {
             type: 'object',
@@ -635,5 +665,52 @@ export const agentTools = [
             };
         },
     },
+    {
+        // #1916 — the `ruflo agent logs <id>` CLI subcommand and the guidance
+        // surface both reference an `agent_logs` MCP tool that was never
+        // registered, so it errored with `MCP tool not found: agent_logs`.
+        // This is the registered handler. Note: agents don't yet keep a
+        // structured per-agent activity log (that lands with hive worker
+        // execution wiring — see #1916), so for now we surface the agent's
+        // last task result as a single synthetic entry, or an explicit empty
+        // response. The shape matches what the CLI `logs` subcommand expects:
+        // `{ agentId, entries: [{timestamp,level,message,context?}], total }`.
+        name: 'agent_logs',
+        description: 'Return recorded activity-log entries for a tracked agent (idle/running history, last task result). Use when native Task tool is wrong because you need the agent\'s log across turns (what it did, last error/result, swarm context) rather than a one-shot Task transcript. For a Task you just ran, native Task output is fine. Pair with agent_list to find the agentId. (Hive-mind-spawned workers are resolved here too.) Today this returns the last task result as a synthetic entry — full per-agent activity logs land with hive worker execution wiring (ruvnet/ruflo#1916).',
+        category: 'agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'ID of agent' },
+                tail: { type: 'number', description: 'Max recent entries to return (default 50)' },
+                level: { type: 'string', enum: ['debug', 'info', 'warn', 'error'], description: 'Minimum log level (currently advisory — entries are synthetic)' },
+                since: { type: 'string', description: 'Show logs since, e.g. "1h" / "30m" (currently advisory)' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (input) => {
+            const v = validateIdentifier(input.agentId, 'agentId');
+            if (!v.valid)
+                return { agentId: input.agentId, entries: [], total: 0, error: `Input validation failed: ${v.error}` };
+            const agentId = input.agentId;
+            const agent = loadAllAgents()[agentId]; // #1916: includes hive-mind-spawned workers
+            if (!agent) {
+                return { agentId, entries: [], total: 0, error: 'Agent not found' };
+            }
+            const entries = [];
+            entries.push({ timestamp: agent.createdAt, level: 'info', message: `agent created (type=${agent.agentType}, status=${agent.status})` });
+            if (agent.lastResult) {
+                entries.push({ timestamp: agent.createdAt, level: 'info', message: 'last task result', context: agent.lastResult });
+            }
+            const tail = typeof input.tail === 'number' && input.tail > 0 ? Math.floor(input.tail) : 50;
+            const sliced = entries.slice(-tail);
+            return {
+                agentId: agent.agentId,
+                entries: sliced,
+                total: entries.length,
+                note: 'per-agent activity logging is not yet wired; entries are synthetic (ruvnet/ruflo#1916)',
+            };
+        },
+    },
 ];
 //# sourceMappingURL=agent-tools.js.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/agentdb-tools.d.ts

@@ -26,5 +26,8 @@ export declare const agentdbConsolidate: MCPTool;
 export declare const agentdbBatch: MCPTool;
 export declare const agentdbContextSynthesize: MCPTool;
 export declare const agentdbSemanticRoute: MCPTool;
+export declare const agentdbHierarchicalDelete: MCPTool;
+export declare const agentdbCausalEdgeDelete: MCPTool;
+export declare const agentdbCausalNodeDelete: MCPTool;
 export declare const agentdbTools: MCPTool[];
 //# sourceMappingURL=agentdb-tools.d.ts.map