claude-flow 3.5.58 → 3.5.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.58",
+  "version": "3.5.59",
   "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-server.js

@@ -23,6 +23,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
+import { trackRequest } from './mcp-tools/request-tracker.js';
 // ESM-compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -389,6 +390,7 @@ export class MCPServerManager extends EventEmitter {
                     }
                     try {
                         const result = await callMCPTool(toolName, toolParams, { sessionId });
+                        trackRequest(toolName, true);
                         return {
                             jsonrpc: '2.0',
                             id: message.id,
@@ -396,6 +398,7 @@ export class MCPServerManager extends EventEmitter {
                         };
                     }
                     catch (error) {
+                        trackRequest(toolName, false);
                         return {
                             jsonrpc: '2.0',
                             id: message.id,

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

@@ -83,6 +83,17 @@ export const daaTools = [
             };
             store.agents[id] = agent;
             saveDAAStore(store);
+            // Store agent in AgentDB for searchable agent registry
+            try {
+                const bridge = await import('../memory/memory-bridge.js');
+                await bridge.bridgeStoreEntry({
+                    key: `daa-agent-${id}`,
+                    value: JSON.stringify({ id: agent.id, name: agent.name, type: agent.type, cognitivePattern: agent.cognitivePattern }),
+                    namespace: 'daa-agents',
+                    tags: [agent.type, agent.cognitivePattern],
+                });
+            }
+            catch { /* AgentDB not available */ }
             return {
                 success: true,
                 agent: {
@@ -215,6 +226,20 @@ export const daaTools = [
             }
             workflow.status = 'running';
             saveDAAStore(store);
+            // Store workflow state in AgentDB for tracking
+            try {
+                const bridge = await import('../memory/memory-bridge.js');
+                await bridge.bridgeStoreEntry({
+                    key: `workflow-${workflowId}`,
+                    value: JSON.stringify({
+                        id: workflowId, status: 'running',
+                        steps: workflow.steps.length, strategy: workflow.strategy,
+                        startedAt: new Date().toISOString(),
+                    }),
+                    namespace: 'daa-workflows',
+                });
+            }
+            catch { /* AgentDB not available */ }
             return {
                 success: true,
                 workflowId,

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

@@ -1,12 +1,8 @@
 /**
  * GitHub MCP Tools for CLI
  *
- * V2 Compatibility - GitHub integration tools
- *
- * ⚠️ IMPORTANT: These tools provide LOCAL STATE MANAGEMENT only.
- * - NO actual GitHub API calls are made
- * - Data is stored locally for workflow coordination
- * - For real GitHub operations, use `gh` CLI or GitHub MCP server
+ * Real GitHub integration via `gh` CLI and `git` commands.
+ * Falls back to local state management when CLI tools are unavailable.
  */
 import { type MCPTool } from './types.js';
 export declare const githubTools: MCPTool[];

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

@@ -1,16 +1,13 @@
 /**
  * GitHub MCP Tools for CLI
  *
- * V2 Compatibility - GitHub integration tools
- *
- * ⚠️ IMPORTANT: These tools provide LOCAL STATE MANAGEMENT only.
- * - NO actual GitHub API calls are made
- * - Data is stored locally for workflow coordination
- * - For real GitHub operations, use `gh` CLI or GitHub MCP server
+ * Real GitHub integration via `gh` CLI and `git` commands.
+ * Falls back to local state management when CLI tools are unavailable.
  */
 import { getProjectCwd } from './types.js';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { execSync } from 'node:child_process';
 // Storage paths
 const STORAGE_DIR = '.claude-flow';
 const GITHUB_DIR = 'github';
@@ -43,6 +40,19 @@ function saveGitHubStore(store) {
     ensureGitHubDir();
     writeFileSync(getGitHubPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
+/** Run a shell command, return stdout or null on failure */
+function run(cmd, cwd) {
+    try {
+        return execSync(cmd, { encoding: 'utf-8', timeout: 15000, cwd: cwd || getProjectCwd(), stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/** Check if gh CLI is available */
+function hasGhCli() {
+    return run('gh --version') !== null;
+}
 export const githubTools = [
     {
         name: 'github_repo_analyze',
@@ -59,28 +69,66 @@ export const githubTools = [
         },
         handler: async (input) => {
             const store = loadGitHubStore();
-            const owner = input.owner || 'owner';
-            const repo = input.repo || 'repo';
             const branch = input.branch || 'main';
-            const repoKey = `${owner}/${repo}`;
-            const repoInfo = {
-                owner,
-                name: repo,
-                branch,
-                lastAnalyzed: new Date().toISOString(),
-            };
-            store.repos[repoKey] = repoInfo;
-            saveGitHubStore(store);
-            return {
-                success: false,
-                _stub: true,
-                message: 'GitHub tools are local-only stubs. For real GitHub operations, use the gh CLI or GitHub MCP server directly.',
-                localData: {
+            const cwd = getProjectCwd();
+            // Try real git analysis first
+            const commitCount = run('git rev-list --count HEAD', cwd);
+            const branchCount = run('git branch -a --no-color | wc -l', cwd);
+            const contributors = run('git shortlog -sn --no-merges HEAD | wc -l', cwd);
+            const currentBranch = run('git rev-parse --abbrev-ref HEAD', cwd);
+            const remoteUrl = run('git remote get-url origin', cwd);
+            // Parse owner/repo from remote URL
+            let owner = input.owner || '';
+            let repo = input.repo || '';
+            if (remoteUrl && (!owner || !repo)) {
+                const m = remoteUrl.match(/[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/);
+                if (m) {
+                    owner = owner || m[1];
+                    repo = repo || m[2];
+                }
+            }
+            const repoKey = `${owner || 'local'}/${repo || 'repo'}`;
+            if (commitCount !== null) {
+                // Real git data available
+                const repoInfo = {
+                    owner: owner || 'local',
+                    name: repo || 'repo',
+                    branch: currentBranch || branch,
+                    lastAnalyzed: new Date().toISOString(),
+                    metrics: {
+                        commits: parseInt(commitCount, 10) || 0,
+                        branches: parseInt(branchCount || '0', 10) || 0,
+                        contributors: parseInt(contributors || '0', 10) || 0,
+                        openIssues: 0,
+                        openPRs: 0,
+                    },
+                };
+                // Try gh CLI for issue/PR counts
+                if (hasGhCli()) {
+                    const issueCount = run(`gh issue list --state open --limit 1000 --json number --jq 'length'`);
+                    const prCount = run(`gh pr list --state open --limit 1000 --json number --jq 'length'`);
+                    if (issueCount !== null)
+                        repoInfo.metrics.openIssues = parseInt(issueCount, 10) || 0;
+                    if (prCount !== null)
+                        repoInfo.metrics.openPRs = parseInt(prCount, 10) || 0;
+                }
+                store.repos[repoKey] = repoInfo;
+                saveGitHubStore(store);
+                return {
+                    success: true,
+                    _real: true,
                     repository: repoKey,
-                    branch,
+                    branch: repoInfo.branch,
+                    metrics: repoInfo.metrics,
+                    remoteUrl: remoteUrl || null,
                     lastAnalyzed: repoInfo.lastAnalyzed,
-                    storedRepos: Object.keys(store.repos),
-                },
+                };
+            }
+            // No git — return local store data
+            return {
+                success: false,
+                error: 'Not a git repository or git not available.',
+                localData: { storedRepos: Object.keys(store.repos) },
             };
         },
     },
@@ -104,73 +152,82 @@ export const githubTools = [
         handler: async (input) => {
             const store = loadGitHubStore();
             const action = input.action || 'list';
-            const owner = input.owner || 'owner';
-            const repo = input.repo || 'repo';
+            const gh = hasGhCli();
             if (action === 'list') {
+                if (gh) {
+                    const raw = run('gh pr list --state all --limit 20 --json number,title,state,headRefName,createdAt');
+                    if (raw) {
+                        try {
+                            const prs = JSON.parse(raw);
+                            return { success: true, _real: true, source: 'gh-cli', pullRequests: prs, total: prs.length };
+                        }
+                        catch { /* fall through */ }
+                    }
+                }
                 const prs = Object.values(store.prs);
-                return {
-                    success: true,
-                    pullRequests: prs,
-                    total: prs.length,
-                    open: prs.filter(pr => pr.status === 'open').length,
-                };
+                return { success: true, source: 'local-store', pullRequests: prs, total: prs.length, open: prs.filter(pr => pr.status === 'open').length };
             }
             if (action === 'create') {
+                if (gh) {
+                    const title = input.title || 'New PR';
+                    const headBranch = input.branch || run('git rev-parse --abbrev-ref HEAD') || 'feature';
+                    const baseBranch = input.baseBranch || 'main';
+                    const body = input.body || '';
+                    const result = run(`gh pr create --title "${title.replace(/"/g, '\\"')}" --base "${baseBranch}" --head "${headBranch}" --body "${body.replace(/"/g, '\\"')}"`);
+                    if (result) {
+                        return { success: true, _real: true, action: 'created', url: result };
+                    }
+                }
+                // Fallback: local store
                 const prId = `pr-${Date.now()}`;
-                const pr = {
-                    id: prId,
-                    title: input.title || 'New PR',
-                    status: 'open',
-                    branch: input.branch || 'feature',
-                    baseBranch: input.baseBranch || 'main',
-                    createdAt: new Date().toISOString(),
-                };
+                const pr = { id: prId, title: input.title || 'New PR', status: 'open', branch: input.branch || 'feature', baseBranch: input.baseBranch || 'main', createdAt: new Date().toISOString() };
                 store.prs[prId] = pr;
                 saveGitHubStore(store);
-                return {
-                    success: true,
-                    action: 'created',
-                    pullRequest: pr,
-                    url: `https://github.com/${owner}/${repo}/pull/${prId}`,
-                };
+                return { success: true, source: 'local-store', action: 'created', pullRequest: pr };
             }
             if (action === 'review') {
-                return {
-                    success: false,
-                    _stub: true,
-                    message: 'GitHub tools are local-only stubs. PR review requires actual GitHub API access. Use the gh CLI or GitHub MCP server directly.',
-                    localData: {
-                        prNumber: input.prNumber,
-                    },
-                };
+                const prNumber = input.prNumber;
+                if (gh && prNumber) {
+                    const raw = run(`gh pr view ${prNumber} --json number,title,state,body,additions,deletions,changedFiles,reviews,mergeable,statusCheckRollup`);
+                    if (raw) {
+                        try {
+                            return { success: true, _real: true, action: 'review', pullRequest: JSON.parse(raw) };
+                        }
+                        catch { /* fall through */ }
+                    }
+                }
+                return { success: false, error: prNumber ? 'gh CLI not available or PR not found. Install gh: https://cli.github.com' : 'prNumber is required for review.' };
             }
             if (action === 'merge') {
                 const prNumber = input.prNumber;
+                if (gh && prNumber) {
+                    const result = run(`gh pr merge ${prNumber} --merge`);
+                    if (result !== null) {
+                        return { success: true, _real: true, action: 'merged', prNumber, mergedAt: new Date().toISOString() };
+                    }
+                }
+                // Fallback: local store
                 const prKey = Object.keys(store.prs).find(k => k.includes(String(prNumber)));
                 if (prKey && store.prs[prKey]) {
                     store.prs[prKey].status = 'merged';
                     saveGitHubStore(store);
                 }
-                return {
-                    success: true,
-                    action: 'merged',
-                    prNumber,
-                    mergedAt: new Date().toISOString(),
-                };
+                return { success: true, source: 'local-store', action: 'merged', prNumber, mergedAt: new Date().toISOString() };
             }
             if (action === 'close') {
                 const prNumber = input.prNumber;
+                if (gh && prNumber) {
+                    const result = run(`gh pr close ${prNumber}`);
+                    if (result !== null) {
+                        return { success: true, _real: true, action: 'closed', prNumber, closedAt: new Date().toISOString() };
+                    }
+                }
                 const prKey = Object.keys(store.prs).find(k => k.includes(String(prNumber)));
                 if (prKey && store.prs[prKey]) {
                     store.prs[prKey].status = 'closed';
                     saveGitHubStore(store);
                 }
-                return {
-                    success: true,
-                    action: 'closed',
-                    prNumber,
-                    closedAt: new Date().toISOString(),
-                };
+                return { success: true, source: 'local-store', action: 'closed', prNumber, closedAt: new Date().toISOString() };
             }
             return { success: false, error: 'Unknown action' };
         },
@@ -195,34 +252,52 @@ export const githubTools = [
         handler: async (input) => {
             const store = loadGitHubStore();
             const action = input.action || 'list';
+            const gh = hasGhCli();
             if (action === 'list') {
+                if (gh) {
+                    const raw = run('gh issue list --state all --limit 20 --json number,title,state,labels,createdAt');
+                    if (raw) {
+                        try {
+                            const issues = JSON.parse(raw);
+                            return { success: true, _real: true, source: 'gh-cli', issues, total: issues.length };
+                        }
+                        catch { /* fall through */ }
+                    }
+                }
                 const issues = Object.values(store.issues);
-                return {
-                    success: true,
-                    issues,
-                    total: issues.length,
-                    open: issues.filter(i => i.status === 'open').length,
-                };
+                return { success: true, source: 'local-store', issues, total: issues.length, open: issues.filter(i => i.status === 'open').length };
             }
             if (action === 'create') {
+                const title = input.title || 'New Issue';
+                const body = input.body || '';
+                const labels = input.labels || [];
+                if (gh) {
+                    const labelArg = labels.length > 0 ? ` --label "${labels.join(',')}"` : '';
+                    const result = run(`gh issue create --title "${title.replace(/"/g, '\\"')}" --body "${body.replace(/"/g, '\\"')}"${labelArg}`);
+                    if (result) {
+                        return { success: true, _real: true, action: 'created', url: result };
+                    }
+                }
                 const issueId = `issue-${Date.now()}`;
-                const issue = {
-                    id: issueId,
-                    title: input.title || 'New Issue',
-                    status: 'open',
-                    labels: input.labels || [],
-                    createdAt: new Date().toISOString(),
-                };
+                const issue = { id: issueId, title, status: 'open', labels, createdAt: new Date().toISOString() };
                 store.issues[issueId] = issue;
                 saveGitHubStore(store);
-                return {
-                    success: true,
-                    action: 'created',
-                    issue,
-                };
+                return { success: true, source: 'local-store', action: 'created', issue };
             }
             if (action === 'update') {
                 const issueNumber = input.issueNumber;
+                if (gh && issueNumber) {
+                    const parts = [];
+                    if (input.title)
+                        parts.push(`--title "${input.title.replace(/"/g, '\\"')}"`);
+                    if (input.labels)
+                        parts.push(`--add-label "${input.labels.join(',')}"`);
+                    if (parts.length > 0) {
+                        const result = run(`gh issue edit ${issueNumber} ${parts.join(' ')}`);
+                        if (result !== null)
+                            return { success: true, _real: true, action: 'updated', issueNumber };
+                    }
+                }
                 const issueKey = Object.keys(store.issues).find(k => k.includes(String(issueNumber)));
                 if (issueKey && store.issues[issueKey]) {
                     if (input.title)
@@ -231,25 +306,21 @@ export const githubTools = [
                         store.issues[issueKey].labels = input.labels;
                     saveGitHubStore(store);
                 }
-                return {
-                    success: true,
-                    action: 'updated',
-                    issueNumber,
-                };
+                return { success: true, source: 'local-store', action: 'updated', issueNumber };
             }
             if (action === 'close') {
                 const issueNumber = input.issueNumber;
+                if (gh && issueNumber) {
+                    const result = run(`gh issue close ${issueNumber}`);
+                    if (result !== null)
+                        return { success: true, _real: true, action: 'closed', issueNumber, closedAt: new Date().toISOString() };
+                }
                 const issueKey = Object.keys(store.issues).find(k => k.includes(String(issueNumber)));
                 if (issueKey && store.issues[issueKey]) {
                     store.issues[issueKey].status = 'closed';
                     saveGitHubStore(store);
                 }
-                return {
-                    success: true,
-                    action: 'closed',
-                    issueNumber,
-                    closedAt: new Date().toISOString(),
-                };
+                return { success: true, source: 'local-store', action: 'closed', issueNumber, closedAt: new Date().toISOString() };
             }
             return { success: false, error: 'Unknown action' };
         },
@@ -270,16 +341,66 @@ export const githubTools = [
         },
         handler: async (input) => {
             const action = input.action || 'list';
-            return {
-                success: false,
-                _stub: true,
-                message: 'GitHub tools are local-only stubs. Workflow operations require actual GitHub API access. Use the gh CLI or GitHub MCP server directly.',
-                localData: {
-                    requestedAction: action,
-                    workflowId: input.workflowId || null,
-                    ref: input.ref || null,
-                },
-            };
+            const gh = hasGhCli();
+            if (!gh) {
+                return { success: false, error: 'gh CLI not available. Install: https://cli.github.com' };
+            }
+            if (action === 'list') {
+                const raw = run('gh run list --limit 10 --json databaseId,displayTitle,status,conclusion,headBranch,createdAt');
+                if (raw) {
+                    try {
+                        return { success: true, _real: true, runs: JSON.parse(raw) };
+                    }
+                    catch { /* fall through */ }
+                }
+                const workflows = run('gh workflow list --json id,name,state');
+                if (workflows) {
+                    try {
+                        return { success: true, _real: true, workflows: JSON.parse(workflows) };
+                    }
+                    catch { /* fall through */ }
+                }
+            }
+            if (action === 'status') {
+                const workflowId = input.workflowId;
+                if (workflowId) {
+                    const raw = run(`gh run view ${workflowId} --json databaseId,displayTitle,status,conclusion,jobs`);
+                    if (raw) {
+                        try {
+                            return { success: true, _real: true, run: JSON.parse(raw) };
+                        }
+                        catch { /* fall through */ }
+                    }
+                }
+                // List recent runs as fallback
+                const recent = run('gh run list --limit 5 --json databaseId,displayTitle,status,conclusion');
+                if (recent) {
+                    try {
+                        return { success: true, _real: true, recentRuns: JSON.parse(recent) };
+                    }
+                    catch { /* fall through */ }
+                }
+            }
+            if (action === 'trigger') {
+                const workflowId = input.workflowId;
+                const ref = input.ref || 'main';
+                if (workflowId) {
+                    const result = run(`gh workflow run "${workflowId}" --ref "${ref}"`);
+                    if (result !== null)
+                        return { success: true, _real: true, action: 'triggered', workflowId, ref };
+                }
+                return { success: false, error: 'workflowId is required to trigger a workflow.' };
+            }
+            if (action === 'cancel') {
+                const workflowId = input.workflowId;
+                if (workflowId) {
+                    const result = run(`gh run cancel ${workflowId}`);
+                    if (result !== null)
+                        return { success: true, _real: true, action: 'cancelled', runId: workflowId };
+                }
+                return { success: false, error: 'workflowId (run ID) is required to cancel.' };
+            }
+            return { success: false, error: `Unknown action: ${action}` };
         },
     },
     {
@@ -292,24 +413,59 @@ export const githubTools = [
                 owner: { type: 'string', description: 'Repository owner' },
                 repo: { type: 'string', description: 'Repository name' },
                 metric: { type: 'string', enum: ['all', 'commits', 'contributors', 'traffic', 'releases'], description: 'Metric type' },
-                timeRange: { type: 'string', description: 'Time range' },
+                timeRange: { type: 'string', description: 'Time range (e.g., "7d", "30d", "90d")' },
             },
         },
         handler: async (input) => {
-            const store = loadGitHubStore();
-            return {
-                success: false,
-                _stub: true,
-                message: 'GitHub tools are local-only stubs. Repository metrics require actual GitHub API access. Use the gh CLI or GitHub MCP server directly.',
-                localData: {
-                    owner: input.owner || 'owner',
-                    repo: input.repo || 'repo',
-                    requestedMetric: input.metric || 'all',
-                    storedRepos: Object.keys(store.repos),
-                    localIssueCount: Object.keys(store.issues).length,
-                    localPrCount: Object.keys(store.prs).length,
-                },
-            };
+            const metric = input.metric || 'all';
+            const timeRange = input.timeRange || '30d';
+            const cwd = getProjectCwd();
+            // Parse time range
+            const days = parseInt(timeRange, 10) || 30;
+            const since = new Date(Date.now() - days * 86400000).toISOString().split('T')[0];
+            const result = { _real: true, timeRange: `${days}d`, since };
+            const wantAll = metric === 'all';
+            if (wantAll || metric === 'commits') {
+                const total = run(`git rev-list --count HEAD`, cwd);
+                const recent = run(`git rev-list --count --since="${since}" HEAD`, cwd);
+                result.commits = {
+                    total: parseInt(total || '0', 10),
+                    sincePeriod: parseInt(recent || '0', 10),
+                };
+            }
+            if (wantAll || metric === 'contributors') {
+                const allContrib = run('git shortlog -sn --no-merges HEAD', cwd);
+                if (allContrib) {
+                    const lines = allContrib.split('\n').filter(Boolean);
+                    result.contributors = {
+                        total: lines.length,
+                        top: lines.slice(0, 10).map(l => {
+                            const m = l.trim().match(/^(\d+)\t(.+)$/);
+                            return m ? { commits: parseInt(m[1], 10), name: m[2].trim() } : null;
+                        }).filter(Boolean),
+                    };
+                }
+            }
+            if (wantAll || metric === 'releases') {
+                if (hasGhCli()) {
+                    const raw = run('gh release list --limit 10 --json tagName,name,publishedAt,isPrerelease');
+                    if (raw) {
+                        try {
+                            result.releases = JSON.parse(raw);
+                        }
+                        catch { /* skip */ }
+                    }
+                }
+                if (!result.releases) {
+                    const tags = run('git tag --sort=-creatordate | head -10', cwd);
+                    result.releases = tags ? tags.split('\n').filter(Boolean).map(t => ({ tagName: t })) : [];
+                }
+            }
+            // Always include branch info
+            const branchCount = run('git branch -a --no-color | wc -l', cwd);
+            const currentBranch = run('git rev-parse --abbrev-ref HEAD', cwd);
+            result.branches = { total: parseInt(branchCount || '0', 10), current: currentBranch };
+            return { success: true, ...result };
         },
     },
 ];

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

@@ -574,6 +574,26 @@ export const hiveMindTools = [
                     state.consensus.pending = state.consensus.pending.filter(p => p.proposalId !== proposal.proposalId);
                 }
                 saveHiveState(state);
+                // Persist consensus result in AgentDB for searchable history
+                if (resolved) {
+                    try {
+                        const bridge = await import('../memory/memory-bridge.js');
+                        await bridge.bridgeStoreEntry({
+                            key: `consensus-${proposal.proposalId}`,
+                            value: JSON.stringify({
+                                proposalId: proposal.proposalId,
+                                type: proposal.type,
+                                strategy: proposalStrategy,
+                                status: proposal.status,
+                                votes: proposal.votes,
+                                resolvedAt: new Date().toISOString(),
+                            }),
+                            namespace: 'hive-consensus',
+                            tags: [proposal.type, proposalStrategy || 'raft', proposal.status],
+                        });
+                    }
+                    catch { /* AgentDB not available — JSON store is primary */ }
+                }
                 return {
                     action,
                     proposalId: proposal.proposalId,
@@ -779,6 +799,16 @@ export const hiveMindTools = [
                     return { action, error: 'Key required' };
                 state.sharedMemory[key] = input.value;
                 saveHiveState(state);
+                // Also store in AgentDB for searchable hive memory
+                try {
+                    const bridge = await import('../memory/memory-bridge.js');
+                    await bridge.bridgeStoreEntry({
+                        key: `hive-memory-${key}`,
+                        value: JSON.stringify(input.value),
+                        namespace: 'hive-memory',
+                    });
+                }
+                catch { /* AgentDB not available */ }
                 return {
                     action,
                     key,