claude-flow 3.47.1 → 3.49.0

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

@@ -1,15 +1,4 @@
-/**
- * AgentDB MCP Tools — Phase 6 of ADR-053
- *
- * Exposes AgentDB v3 controller operations as MCP tools.
- * Provides direct access to ReasoningBank, CausalGraph, SkillLibrary,
- * AttestationLog, and bridge health through the MCP protocol.
- *
- * Security: All handlers validate input types, enforce length bounds,
- * and sanitize error messages before returning to MCP callers.
- *
- * @module v3/cli/mcp-tools/agentdb-tools
- */
+import { feedbackPatternsSchema, validateFeedbackPatterns } from '../memory/feedback-patterns.js';
 import { validateIdentifier, validateText } from './validate-input.js';
 // ===== Shared validation helpers =====
 const MAX_STRING_LENGTH = 100_000; // 100KB max for any string input
@@ -66,12 +55,6 @@ async function getBridge() {
 // Lazy-cached modules used by graph-query / graph-pathfinder dispatch.
 // Caching the resolved namespace avoids per-call dynamic-import overhead
 // in the ADR-130 hot path (smoke harness measures elapsedMs of every call).
-let graphBackendMod = null;
-async function getGraphBackend() {
-    if (!graphBackendMod)
-        graphBackendMod = await import('../ruvector/graph-backend.js');
-    return graphBackendMod;
-}
 let graphEdgeWriterMod = null;
 async function getGraphEdgeWriter() {
     if (!graphEdgeWriterMod)
@@ -396,6 +379,7 @@ export const agentdbFeedback = {
         type: 'object',
         properties: {
             taskId: { type: 'string', description: 'Task identifier' },
+            patterns: feedbackPatternsSchema,
             success: { type: 'boolean', description: 'Whether task succeeded' },
             quality: { type: 'number', description: 'Quality score (0-1)' },
             agent: { type: 'string', description: 'Agent that performed the task' },
@@ -415,9 +399,11 @@ export const agentdbFeedback = {
             const taskId = validateString(params.taskId, 'taskId', 500);
             if (!taskId)
                 return { success: false, error: 'taskId is required (non-empty string, max 500 chars)' };
+            const patterns = validateFeedbackPatterns(params.patterns);
             const bridge = await getBridge();
             const result = await bridge.bridgeRecordFeedback({
                 taskId,
+                patterns,
                 success: params.success === true,
                 quality: validateScore(params.quality, 0.85),
                 agent: validateString(params.agent, 'agent', 200) ?? undefined,
@@ -802,21 +788,18 @@ export const agentdbHierarchicalRecall = {
 // ===== agentdb_consolidate — Run memory consolidation =====
 export const agentdbConsolidate = {
     name: 'agentdb_consolidate',
-    description: 'Run memory consolidation to promote entries across tiers and compress old data Use when generic memory_* tools are wrong because you need AgentDB-specific controllers (HNSW vector search, hierarchical tiers, causal-graph links, pattern store/recall, RaBitQ quantization). For simple key-value persistence, memory_store/memory_retrieve are simpler. For unrelated file work, native Read/Write are fine.',
+    description: 'Request memory consolidation. Use when checking whether AgentDB can consolidate retained memories; native file edits cannot perform controller consolidation. Currently returns unsupported when the installed controller is a no-op stub; no entries are promoted or compressed in that case.',
     inputSchema: {
         type: 'object',
-        properties: {
-            minAge: { type: 'number', description: 'Minimum age in hours since store (optional)' },
-            maxEntries: { type: 'number', description: 'Maximum entries to consolidate (optional)' },
-        },
+        properties: {},
     },
     handler: async (params) => {
         try {
+            if (Object.keys(params).length > 0) {
+                return { success: false, status: 'unsupported', error: 'agentdb_consolidate does not support options' };
+            }
             const bridge = await getBridge();
-            const result = await bridge.bridgeConsolidate({
-                minAge: typeof params.minAge === 'number' ? Math.max(0, params.minAge) : undefined,
-                maxEntries: validatePositiveInt(params.maxEntries, 1000, 10_000),
-            });
+            const result = await bridge.bridgeConsolidate({});
             return result ?? { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' };
         }
         catch (error) {
@@ -1060,7 +1043,7 @@ export const agentdbCausalNodeDelete = {
 };
 export const agentdbGraphQuery = {
     name: 'agentdb_graph-query',
-    description: 'Unified graph traversal across the knowledge graph (ADR-130). Native graph-node k-hop cannot filter by relation and returns an explicit unsupported error for that request; the SQL fallback can filter by relation. Inspect appliedDepth/truncated because SQL is bounded at 3 hops. Semantic and PageRank modes use their own backends. Use when you need structured graph traversal beyond flat memory search.',
+    description: 'Unified graph traversal across the knowledge graph (ADR-130). K-hop queries read committed graph_edges relationships through SQL; a separately populated native graph is not evidence of retained-history coverage. Inspect appliedDepth/truncated because SQL is bounded at 3 hops. maxNodesVisited bounds returned rows, not traversal work or elapsed time. Semantic and PageRank modes use their own backends. Use when you need relationship traversal beyond flat memory search.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -1101,53 +1084,38 @@ export const agentdbGraphQuery = {
             }
             const budgetRaw = (params.complexityBudget ?? {});
             const budget = {
-                maxNodesVisited: budgetRaw.maxNodesVisited ?? 10_000,
-                maxDepth: budgetRaw.maxDepth ?? 5,
+                maxNodesVisited: validatePositiveInt(budgetRaw.maxNodesVisited, 10_000, 10_000),
+                maxDepth: validatePositiveInt(budgetRaw.maxDepth, 5, 5),
                 maxMillis: budgetRaw.maxMillis ?? 50,
                 maxMemoryMB: budgetRaw.maxMemoryMB ?? 32,
             };
-            const depth = Math.min(validatePositiveInt(params.depth, 2, budget.maxDepth), budget.maxDepth);
+            const requestedDepth = validatePositiveInt(params.depth, 2, 5);
+            const depth = Math.min(requestedDepth, budget.maxDepth);
             const topK = validatePositiveInt(params.topK, 10, MAX_TOP_K);
             const relation = validateString(params.relation, 'relation', 200) ?? undefined;
             // ── k-hop mode ──────────────────────────────────────────────────────────
             if (mode === 'k-hop') {
-                // graph-node's kHopNeighbors API has no relation parameter. Its graph
-                // and the SQL graph are separate stores, and SQL writes can be async;
-                // switching stores here could report a false negative. Refuse the
-                // unsupported native query instead of silently widening it.
-                try {
-                    const graphBackend = await getGraphBackend();
-                    if (await graphBackend.isGraphBackendAvailable()) {
-                        if (relation) {
-                            return { success: false, error: 'Native graph-node k-hop does not support relation filtering', unsupported: 'relation', mode, nodeId, relation, backend: 'graph-node' };
-                        }
-                        const neighbors = await graphBackend.getNeighbors(nodeId, depth);
-                        return {
-                            success: true, mode, nodeId, depth, appliedDepth: depth,
-                            results: neighbors.map(id => ({ nodeId: id })),
-                            count: neighbors.length,
-                            backend: 'graph-node',
-                            elapsedMs: Date.now() - t0,
-                        };
-                    }
-                }
-                catch { /* fall through to SQL */ }
-                // SQL CTE fallback is bounded at depth 3. Report that bound so callers
-                // cannot mistake an incomplete depth-5 cycle check for a complete one.
+                // #3315: graph-node and retained SQL are populated independently.
+                // Native availability does not establish historical coverage. Query
+                // the committed relationship source, and fail if it cannot be read.
                 try {
                     const { getBridgeDb } = await getGraphEdgeWriter();
                     const db = await getBridgeDb();
                     if (db) {
                         const appliedDepth = Math.min(depth, 3);
-                        const cteSql = buildKHopCTE(nodeId, appliedDepth, relation, budget.maxNodesVisited);
+                        const cteSql = buildKHopCTE(nodeId, appliedDepth, relation, budget.maxNodesVisited + 1);
                         // graph-edge-writer returns a better-sqlite3 Database after #2431.
                         // `db.exec(sql, params)` (sql.js style) is a runner with no result
                         // on better-sqlite3 — use `prepare(sql).raw().all(...)` to get the
                         // same array-of-arrays shape the downstream code expects.
-                        const rows = db.prepare(cteSql).raw().all();
+                        const allRows = db.prepare(cteSql).raw().all();
+                        const resultLimitReached = allRows.length > budget.maxNodesVisited;
+                        const rows = allRows.slice(0, budget.maxNodesVisited);
+                        const depthLimited = appliedDepth < requestedDepth;
                         return {
-                            success: true, mode, nodeId, depth, appliedDepth,
-                            ...(appliedDepth < depth ? { truncated: true } : {}),
+                            success: true, mode, nodeId, depth, requestedDepth, appliedDepth,
+                            depthLimited, resultLimitReached, truncated: depthLimited || resultLimitReached,
+                            resultLimit: budget.maxNodesVisited,
                             results: rows.map((r) => ({ nodeId: r[0], depth: r[1] })),
                             count: rows.length,
                             backend: 'sql-cte',
@@ -1155,11 +1123,10 @@ export const agentdbGraphQuery = {
                         };
                     }
                 }
-                catch { /* db unavailable */ }
-                if (relation) {
-                    return { success: false, error: 'Relation-filtered k-hop query requires the SQL graph_edges backend', mode, nodeId, relation };
+                catch (error) {
+                    return { success: false, error: `Retained SQL graph query failed: ${sanitizeError(error)}`, mode, nodeId };
                 }
-                return { success: false, error: 'No graph backend available for k-hop query', mode, nodeId };
+                return { success: false, error: 'Retained SQL graph_edges backend is unavailable for k-hop query', mode, nodeId };
             }
             // ── semantic mode ────────────────────────────────────────────────────────
             if (mode === 'semantic') {

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

@@ -1,7 +1,3 @@
-/**
- * Hooks MCP Tools
- * Provides intelligent hooks functionality via MCP protocol
- */
 import { type MCPTool } from './types.js';
 import { type RouterEmbedderKind } from '../ruvector/router-embedder.js';
 /**
@@ -16,11 +12,24 @@ import { type RouterEmbedderKind } from '../ruvector/router-embedder.js';
 export declare function scrubReasoningBlocks(text: string): string;
 /** Test hook: drop the cached semantic index so the next route rebuilds it. */
 export declare function resetSemanticRouterForTests(): void;
-/** Exported for tests. */
-export declare function suggestAgentsForTask(task: string): {
+/**
+ * Confidence for a task nothing matched (#3567). It must rank below every real
+ * signal: keyword hits are >= 0.8, learned outcomes >= 0.7, and a semantic
+ * match is only eligible above 0.4. Matches the helper router's 0.3 fall-through.
+ */
+export declare const NO_MATCH_CONFIDENCE = 0.3;
+export interface TaskAgentSuggestion {
     agents: string[];
     confidence: number;
-};
+    /** false when no keyword or learned pattern matched; the agents are a default, not a decision. */
+    matched: boolean;
+    reason?: 'no-match-default';
+    note?: string;
+}
+/** True when the task has at least one letter or digit in any script. */
+export declare function hasRoutableText(task: string): boolean;
+/** Exported for tests. */
+export declare function suggestAgentsForTask(task: string): TaskAgentSuggestion;
 export declare const hooksPreEdit: MCPTool;
 export declare const hooksPostEdit: MCPTool;
 export declare const hooksPreCommand: MCPTool;