claude-flow 3.63.6 → 3.63.8

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

@@ -214,7 +214,7 @@ export const agentTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                agentType: { type: 'string', description: 'Type of agent to spawn' },
+                agentType: { type: 'string', description: 'Type of agent to spawn (a legacy `type` key is accepted as an alias)' },
                 agentId: { type: 'string', description: 'Optional custom agent ID' },
                 name: { type: 'string', description: 'Optional display name for the agent (shown by agent_list, agent_status and ruflo-console)' },
                 // #2085 — accept swarmId so spawned agents register in the
@@ -234,7 +234,19 @@ export const agentTools = [
             },
             required: ['agentType'],
         },
-        handler: async (input) => {
+        handler: async (rawInput) => {
+            // #4542: agent and command docs that `init` installed before 3.63.7 call
+            // agent_spawn with `type`. Accept it as an alias for `agentType`, and
+            // name the missing key ourselves: validateAgentSpawn maps agentType onto
+            // the security schema's `type` field and would report "type: Required".
+            let input = rawInput;
+            if (input.agentType === undefined && typeof input.type === 'string') {
+                const { type, ...rest } = input;
+                input = { ...rest, agentType: type };
+            }
+            if (typeof input.agentType !== 'string' || input.agentType === '') {
+                return { success: false, error: 'Input validation failed: agentType is required and must be a non-empty string (for example agentType: "coder")' };
+            }
             // Validate user-provided input (#1425: wire security validators to runtime)
             const validation = await validateAgentSpawn(input);
             if (!validation.valid) {
@@ -606,7 +618,7 @@ export const agentTools = [
             type: 'object',
             properties: {
                 action: { type: 'string', enum: ['status', 'scale', 'drain', 'fill'], description: 'Pool action' },
-                targetSize: { type: 'number', description: 'Target pool size (for scale action)' },
+                targetSize: { type: 'number', description: 'Target pool size (scale: grow or shrink to it; fill: grow to it, never shrink)' },
                 agentType: { type: 'string', description: 'Agent type filter' },
             },
             required: ['action'],
@@ -653,7 +665,9 @@ export const agentTools = [
                     avgHealth: agents.length > 0 ? agents.reduce((sum, a) => sum + a.health, 0) / agents.length : 0,
                 };
             }
-            if (action === 'scale') {
+            // #4555: fill was advertised in the enum but had no branch. It is scale
+            // without the shrink step: grow agentType's pool to targetSize, never terminate.
+            if (action === 'scale' || action === 'fill') {
                 const targetSize = input.targetSize === undefined ? 5 : input.targetSize;
                 if (typeof targetSize !== 'number' || !Number.isSafeInteger(targetSize) || targetSize < 0) {
                     return { action, error: 'targetSize must be a non-negative safe integer' };
@@ -678,7 +692,7 @@ export const agentTools = [
                         added.push(agentId);
                     }
                 }
-                else if (delta < 0) {
+                else if (delta < 0 && action === 'scale') {
                     const toRemove = agents.filter(a => a.agentType === agentType && a.status === 'idle').slice(0, -delta);
                     for (const agent of toRemove) {
                         store.agents[agent.agentId].status = 'terminated';

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

@@ -225,8 +225,8 @@ export const coordinationTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', enum: ['status', 'trigger', 'resolve'], description: 'Action to perform' },
-                force: { type: 'boolean', description: 'Force synchronization' },
+                action: { type: 'string', enum: ['status', 'trigger', 'resolve'], description: 'Action to perform. `trigger` is unavailable: nodes are local records with no sync backend, so it is refused (#4557)' },
+                force: { type: 'boolean', description: 'Unused: `trigger` is refused regardless (#4557)' },
                 conflictResolution: { type: 'string', enum: ['latest', 'merge', 'manual'], description: 'Conflict resolution strategy' },
             },
         },
@@ -243,18 +243,16 @@ export const coordinationTools = [
                 };
             }
             if (action === 'trigger') {
-                store.sync.syncCount++;
-                store.sync.lastSync = new Date().toISOString();
-                store.sync.pendingChanges = 0;
-                // Simulate sync
-                await new Promise(resolve => setTimeout(resolve, 50));
-                saveCoordStore(store);
+                // #4557: this waited on a simulated 50ms "sync", bumped syncCount/lastSync
+                // and reported every node synchronized, but no state moves between
+                // nodes. Refuse without touching the stored sync record, as
+                // neural_compress quantize/prune do (#4195, #4423).
                 return {
-                    success: true,
-                    action: 'synchronized',
+                    success: false,
+                    action: 'trigger',
+                    error: 'Synchronization is unavailable: coordination nodes are local records with no sync backend, so nothing would be transferred.',
                     syncCount: store.sync.syncCount,
-                    syncedAt: store.sync.lastSync,
-                    nodesSync: Object.keys(store.nodes).length,
+                    lastSync: store.sync.lastSync,
                 };
             }
             if (action === 'resolve') {

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

@@ -2212,7 +2212,14 @@ export const hooksBuildAgents = {
         },
     },
     handler: async (params) => {
-        const outputDir = resolve(params.outputDir || './agents');
+        // #4558: outputDir was never validated and resolved against the process
+        // cwd, so a default call from another directory overwrote files there.
+        if (params.outputDir !== undefined) {
+            const v = validatePath(params.outputDir, 'outputDir');
+            if (!v.valid)
+                return { success: false, error: v.error };
+        }
+        const outputDir = resolve(getProjectCwd(), params.outputDir || './agents');
         const focus = params.focus || 'all';
         const format = params.format || 'yaml';
         const persist = params.persist !== false; // Default to true
@@ -2255,9 +2262,11 @@ export const hooksBuildAgents = {
             agents: filteredAgents,
             stats: {
                 configsGenerated: filteredAgents.length,
-                patternsApplied: filteredAgents.length * 3,
+                // #4558: was agents * 3; no pretrain data is read, the configs are templates.
+                patternsApplied: 0,
                 optimizationsIncluded: filteredAgents.reduce((acc, a) => acc + a.optimizations.length, 0),
             },
+            _note: 'Configs are built-in templates; pretrain data is not read.',
         };
     },
 };

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

@@ -612,6 +612,14 @@ export const performanceTools = [
             };
             const cpuStats = calcStats(cpuHistory, cpuPercent);
             const memStats = calcStats(memHistory, memUsedMB);
+            // #4554: latency/throughput used to be fixed literals (45ms, 1250 ops/s).
+            // Report the samples performance_report records (ADR-093 F8), or say none exist.
+            const sampled = (values, unit) => {
+                const real = values.filter(n => Number.isFinite(n));
+                return real.length === 0
+                    ? { available: false, unit, samples: 0, _real: false, _note: 'No samples recorded yet: run performance_report to record one.' }
+                    : { ...calcStats(real, real[real.length - 1]), unit, samples: real.length, _real: true };
+            };
             const allMetrics = {
                 cpu: {
                     ...cpuStats,
@@ -630,30 +638,12 @@ export const performanceTools = [
                     unit: 'MB',
                     _real: true,
                 },
-                latency: {
-                    current: 45,
-                    avg: 52,
-                    min: 15,
-                    max: 250,
-                    p50: 48,
-                    p95: 150,
-                    p99: 220,
-                    unit: 'ms',
-                },
-                throughput: {
-                    current: 1250,
-                    avg: 1100,
-                    min: 500,
-                    max: 2000,
-                    p50: 1050,
-                    p95: 1800,
-                    p99: 1950,
-                    unit: 'ops/s',
-                },
+                latency: sampled(history.map(m => m.latency?.avg), 'ms'),
+                throughput: sampled(history.map(m => m.throughput?.operations), 'ops/s'),
             };
             if (metric === 'all') {
                 return {
-                    _real: true,
+                    _real: Object.values(allMetrics).every(m => m._real),
                     metrics: allMetrics,
                     aggregation,
                     historySize: history.length,
@@ -662,9 +652,9 @@ export const performanceTools = [
             }
             const selectedMetric = allMetrics[metric];
             return {
-                _real: ['cpu', 'memory'].includes(metric),
+                _real: selectedMetric._real,
                 metric,
-                value: selectedMetric[aggregation],
+                value: selectedMetric[aggregation] ?? null,
                 unit: selectedMetric.unit,
                 details: selectedMetric,
                 timestamp: new Date().toISOString(),

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

@@ -54,6 +54,21 @@ function ensureSessionDir() {
         mkdirRestricted(dir);
     }
 }
+/**
+ * The session hook (`session.js` from init/helpers-generator.ts) writes its
+ * records into this same directory: `current.json` and `session-<n>.json`
+ * archives shaped `{ id, startedAt, ... }` rather than session_save's
+ * `{ sessionId, name, savedAt, stats }`. Read the id and time from either shape
+ * (ADR-093 F6), falling back to the file's own id.
+ */
+function sessionIdentity(session, fileId) {
+    const raw = session;
+    const pick = (...values) => values.find((v) => typeof v === 'string' && v !== '');
+    return {
+        sessionId: pick(raw.sessionId, raw.id) ?? fileId,
+        savedAt: pick(raw.savedAt, raw.startedAt) ?? '',
+    };
+}
 function loadSession(sessionId) {
     try {
         const path = getSessionPath(sessionId);
@@ -583,12 +598,13 @@ export const sessionTools = [
             if (session) {
                 const path = getSessionPath(sessionId);
                 const stat = statSync(path);
+                const identity = sessionIdentity(session, sessionId);
                 return {
-                    sessionId: session.sessionId,
-                    name: session.name,
+                    sessionId: identity.sessionId,
+                    name: session.name ?? identity.sessionId,
                     description: session.description,
-                    savedAt: session.savedAt,
-                    stats: session.stats,
+                    savedAt: identity.savedAt,
+                    stats: session.stats ?? null,
                     fileSize: stat.size,
                     path,
                     hasData: {
@@ -631,12 +647,13 @@ export const sessionTools = [
             const session = loadSession(sessionId);
             if (!session)
                 return { sessionId, status: 'unknown', startedAt: '', error: 'Session file unreadable' };
+            const identity = sessionIdentity(session, sessionId);
             return {
-                sessionId: session.sessionId,
-                name: session.name,
+                sessionId: identity.sessionId,
+                name: session.name ?? identity.sessionId,
                 status: 'active',
-                startedAt: session.savedAt,
-                stats: session.stats,
+                startedAt: identity.savedAt,
+                stats: session.stats ?? null,
             };
         },
     },

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

@@ -2316,6 +2316,41 @@ export async function bridgeStorePattern(options) {
                 controller: 'reasoningBank',
             };
         }
+        // The intelligence module's LocalReasoningBank (registered when agentdb's
+        // own ReasoningBank is unavailable) has store()/findSimilar() but no
+        // storePattern(). bridgeSearchPatterns reads it through findSimilar(), so
+        // the write must land there too, with an embedding from the same
+        // generateEmbedding() the search uses. Otherwise store and search split
+        // across two backends and a stored pattern is never found.
+        if (reasoningBank && typeof reasoningBank.store === 'function' && typeof reasoningBank.findSimilar === 'function') {
+            let embedding = [];
+            try {
+                const { generateEmbedding } = await import('./memory-initializer.js');
+                const emb = await generateEmbedding(options.pattern);
+                if (emb && Array.isArray(emb.embedding))
+                    embedding = emb.embedding;
+            }
+            catch { /* no embedder — findSimilar misses it, the getAll() substring scan still finds it */ }
+            // store() returns false when it merges into an existing pattern with the
+            // same content; that is still a successful write.
+            reasoningBank.store({
+                id: patternId,
+                type: options.type,
+                content: options.pattern,
+                confidence: options.confidence,
+                embedding,
+                metadata: options.metadata,
+            });
+            // Saves are debounced; a short-lived CLI process can exit first.
+            if (typeof reasoningBank.flushToDisk === 'function')
+                reasoningBank.flushToDisk();
+            return {
+                success: true,
+                patternId,
+                controller: 'reasoningBank',
+                hasEmbedding: embedding.length > 0,
+            };
+        }
         // Fallback: store via bridge SQL
         const patternValue = JSON.stringify({ pattern: options.pattern, type: options.type, confidence: options.confidence, metadata: options.metadata });
         const result = await bridgeStoreEntry({
@@ -2447,7 +2482,11 @@ export async function bridgeSearchPatterns(options) {
                     .slice(0, k)
                     .map((p) => ({ id: p.id ?? '', content: p.content ?? '', score: p.confidence ?? 0 }));
             }
-            return { results: mapped, controller: 'reasoningBank' };
+            // Nothing in the bank: patterns written by the SQL fallback path (before
+            // the bank was registered, or by a process without it) live in the
+            // `pattern` namespace, so search that instead of returning empty.
+            if (mapped.length > 0)
+                return { results: mapped, controller: 'reasoningBank' };
         }
         // Fallback: search via bridge
         const result = await bridgeSearchEntries({