claude-flow 3.56.8 → 3.56.10

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

@@ -0,0 +1,37 @@
+/**
+ * Default relevance floor for memory search (#4129).
+ *
+ * The bundled 384-dim embedding model scores a correct paraphrase match at
+ * roughly 0.25-0.5 and unrelated text at 0.0-0.15, so the old 0.3 floor sent
+ * back an empty list for natural-language queries whose right answer was
+ * clearly the best match (0.28 in the report). 0.2 sits between the two
+ * populations. An explicit `threshold` always wins, including 0.
+ *
+ * #2558 constraint stays: the fused recall score of a full-coverage exact
+ * keyword hit with semantic cosine <= 0 tops out at 0.40, so this must stay
+ * well below 0.4.
+ */
+export const DEFAULT_SEARCH_THRESHOLD = 0.2;
+/** How many below-threshold matches an empty default search reports as hints. */
+export const NEAR_MISS_LIMIT = 3;
+/**
+ * When a search that used the DEFAULT threshold returns nothing, say what was
+ * close instead of leaving the caller to assume the store has no answer
+ * (#4129). One extra, cheap query at threshold 0; never throws; absent when
+ * nothing at all matched.
+ */
+export async function nearMisses(search, req) {
+    try {
+        const r = await search({ ...req, limit: NEAR_MISS_LIMIT, threshold: 0 });
+        if (!r?.success || !r.results?.length)
+            return undefined;
+        return {
+            nearMisses: r.results.map(e => ({ key: e.key, namespace: e.namespace, similarity: e.score })),
+            hint: `No result reached the default threshold (${DEFAULT_SEARCH_THRESHOLD}); the closest matches are in nearMisses. Pass threshold: 0 to include them in results.`,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=search-defaults.js.map

package/v3/@claude-flow/cli/dist/src/memory/sona-optimizer.d.ts

@@ -93,6 +93,8 @@ export interface SONAStats {
         agents: number;
     } | 'unavailable';
 }
+/** The routing gate in getRoutingSuggestion: confidence x matchRatio must reach this for a learned pattern to be used. */
+export declare const SONA_ROUTING_GATE = 0.6;
 /** Agent roles supported by the SONA routing optimizer. */
 export declare function isSupportedSonaAgent(agent: string): boolean;
 /**
@@ -101,6 +103,17 @@ export declare function isSupportedSonaAgent(agent: string): boolean;
  * Learns from past task outcomes to improve future routing decisions.
  * Integrates with Q-learning router for hybrid routing strategy.
  */
+/**
+ * How close a pattern's confidence is to the routing gate. `successesNeeded`
+ * assumes a perfect keyword match (matchRatio 1) and the 0.1 success increment;
+ * a partial match needs more.
+ */
+export declare function routingGateStatus(confidence: number): {
+    threshold: number;
+    confidence: number;
+    reached: boolean;
+    successesNeeded: number;
+};
 export declare class SONAOptimizer {
     private patterns;
     private trajectoriesProcessed;
@@ -140,6 +153,15 @@ export declare class SONAOptimizer {
         patternKey: string;
         confidence: number;
         keywordsExtracted: string[];
+        /** True when this trajectory reinforced an existing near-identical pattern instead of creating a new one (#4134). */
+        reinforcedNeighbour?: boolean;
+        /** How far the pattern is from influencing routing, so a user can see learning has not kicked in yet (#4134). */
+        routingGate?: {
+            threshold: number;
+            confidence: number;
+            reached: boolean;
+            successesNeeded: number;
+        };
     };
     /**
      * Get routing suggestion based on learned patterns.
@@ -202,6 +224,12 @@ export declare class SONAOptimizer {
      * Create a unique pattern key from keywords and agent
      */
     private createPatternKey;
+    /**
+     * The key of the existing pattern for `agent` whose keyword set overlaps
+     * `keywords` the most, if that overlap (Jaccard) reaches NEIGHBOUR_MIN_JACCARD.
+     * Ties go to the more confident pattern. Linear in the pattern count (<= 1000).
+     */
+    private findNeighbourPattern;
     /**
      * Find the best matching pattern for given keywords
      */

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

@@ -26,6 +26,10 @@ const CONFIDENCE_INCREMENT = 0.1;
 const CONFIDENCE_DECREMENT = 0.15;
 const DECAY_RATE = 0.01; // Per day
 const MAX_PATTERNS = 1000;
+/** #4134: a trajectory reinforces an existing pattern of the same agent whose keyword set overlaps at least this much (Jaccard). */
+const NEIGHBOUR_MIN_JACCARD = 0.6;
+/** The routing gate in getRoutingSuggestion: confidence x matchRatio must reach this for a learned pattern to be used. */
+export const SONA_ROUTING_GATE = 0.6;
 // ============================================================================
 // Contrastive Trainer (lazy-loaded from @ruvector/ruvllm)
 // ============================================================================
@@ -119,6 +123,18 @@ const KEYWORD_CATEGORIES = {
  * Learns from past task outcomes to improve future routing decisions.
  * Integrates with Q-learning router for hybrid routing strategy.
  */
+/**
+ * How close a pattern's confidence is to the routing gate. `successesNeeded`
+ * assumes a perfect keyword match (matchRatio 1) and the 0.1 success increment;
+ * a partial match needs more.
+ */
+export function routingGateStatus(confidence) {
+    const reached = confidence >= SONA_ROUTING_GATE;
+    const successesNeeded = reached || confidence >= MAX_CONFIDENCE
+        ? 0
+        : Math.ceil(Math.log((1 - SONA_ROUTING_GATE) / (1 - confidence)) / Math.log(1 - CONFIDENCE_INCREMENT));
+    return { threshold: SONA_ROUTING_GATE, confidence, reached, successesNeeded };
+}
 export class SONAOptimizer {
     patterns = new Map();
     trajectoriesProcessed = 0;
@@ -210,7 +226,18 @@ export class SONAOptimizer {
             };
         }
         // Create pattern key from sorted keywords
-        const patternKey = this.createPatternKey(keywords, agent);
+        let patternKey = this.createPatternKey(keywords, agent);
+        // #4134: near-identical tasks ("Verify the X plugin ..." / "Verify the Y plugin ...")
+        // used to create a separate pattern each at confidence 0.5, so none ever reached
+        // the routing gate. Reinforce the closest existing pattern of the same agent instead.
+        let reinforcedNeighbour = false;
+        if (!this.patterns.has(patternKey)) {
+            const neighbour = this.findNeighbourPattern(keywords, agent);
+            if (neighbour) {
+                patternKey = neighbour;
+                reinforcedNeighbour = true;
+            }
+        }
         // Get or create pattern
         let pattern = this.patterns.get(patternKey);
         if (!pattern) {
@@ -264,6 +291,8 @@ export class SONAOptimizer {
             patternKey,
             confidence: pattern.confidence,
             keywordsExtracted: keywords,
+            reinforcedNeighbour,
+            routingGate: routingGateStatus(pattern.confidence),
         };
     }
     /**
@@ -305,7 +334,7 @@ export class SONAOptimizer {
         const keywords = this.extractKeywords(task);
         // Priority 2: Try SONA learned pattern matching
         const sonaResult = this.findBestPatternMatch(keywords);
-        if (sonaResult && sonaResult.confidence >= 0.6) {
+        if (sonaResult && sonaResult.confidence >= SONA_ROUTING_GATE) {
             return {
                 agent: sonaResult.agent,
                 confidence: sonaResult.confidence,
@@ -532,6 +561,34 @@ export class SONAOptimizer {
         const sortedKeywords = [...keywords].sort();
         return `${agent}:${sortedKeywords.join('+')}`;
     }
+    /**
+     * The key of the existing pattern for `agent` whose keyword set overlaps
+     * `keywords` the most, if that overlap (Jaccard) reaches NEIGHBOUR_MIN_JACCARD.
+     * Ties go to the more confident pattern. Linear in the pattern count (<= 1000).
+     */
+    findNeighbourPattern(keywords, agent) {
+        const wanted = new Set(keywords);
+        let bestKey = null;
+        let bestJaccard = 0;
+        let bestConfidence = -1;
+        for (const [key, pattern] of this.patterns) {
+            if (pattern.agent !== agent)
+                continue;
+            let shared = 0;
+            for (const k of pattern.keywords)
+                if (wanted.has(k))
+                    shared++;
+            const union = wanted.size + pattern.keywords.length - shared;
+            const jaccard = union === 0 ? 0 : shared / union;
+            if (jaccard >= NEIGHBOUR_MIN_JACCARD &&
+                (jaccard > bestJaccard || (jaccard === bestJaccard && pattern.confidence > bestConfidence))) {
+                bestKey = key;
+                bestJaccard = jaccard;
+                bestConfidence = pattern.confidence;
+            }
+        }
+        return bestKey;
+    }
     /**
      * Find the best matching pattern for given keywords
      */

package/v3/@claude-flow/cli/dist/src/mods/command-registry/schema.d.ts

@@ -63,19 +63,19 @@ export declare const commandDefinitionSchema: z.ZodEffects<z.ZodObject<{
         path: z.ZodString;
     }, "strict", z.ZodTypeAny, {
         path: string;
-        commit: string;
         repository: string;
+        commit: string;
     }, {
         path: string;
-        commit: string;
         repository: string;
+        commit: string;
     }>;
 }, "strict", z.ZodTypeAny, {
     id: string;
     source: {
         path: string;
-        commit: string;
         repository: string;
+        commit: string;
     };
     schemaVersion: 1;
     kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -100,8 +100,8 @@ export declare const commandDefinitionSchema: z.ZodEffects<z.ZodObject<{
     id: string;
     source: {
         path: string;
-        commit: string;
         repository: string;
+        commit: string;
     };
     schemaVersion: 1;
     kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -126,8 +126,8 @@ export declare const commandDefinitionSchema: z.ZodEffects<z.ZodObject<{
     id: string;
     source: {
         path: string;
-        commit: string;
         repository: string;
+        commit: string;
     };
     schemaVersion: 1;
     kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -152,8 +152,8 @@ export declare const commandDefinitionSchema: z.ZodEffects<z.ZodObject<{
     id: string;
     source: {
         path: string;
-        commit: string;
         repository: string;
+        commit: string;
     };
     schemaVersion: 1;
     kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -244,19 +244,19 @@ export declare const catalogEntrySchema: z.ZodObject<{
             path: z.ZodString;
         }, "strict", z.ZodTypeAny, {
             path: string;
-            commit: string;
             repository: string;
+            commit: string;
         }, {
             path: string;
-            commit: string;
             repository: string;
+            commit: string;
         }>;
     }, "strict", z.ZodTypeAny, {
         id: string;
         source: {
             path: string;
-            commit: string;
             repository: string;
+            commit: string;
         };
         schemaVersion: 1;
         kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -281,8 +281,8 @@ export declare const catalogEntrySchema: z.ZodObject<{
         id: string;
         source: {
             path: string;
-            commit: string;
             repository: string;
+            commit: string;
         };
         schemaVersion: 1;
         kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -307,8 +307,8 @@ export declare const catalogEntrySchema: z.ZodObject<{
         id: string;
         source: {
             path: string;
-            commit: string;
             repository: string;
+            commit: string;
         };
         schemaVersion: 1;
         kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -333,8 +333,8 @@ export declare const catalogEntrySchema: z.ZodObject<{
         id: string;
         source: {
             path: string;
-            commit: string;
             repository: string;
+            commit: string;
         };
         schemaVersion: 1;
         kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -404,8 +404,8 @@ export declare const catalogEntrySchema: z.ZodObject<{
         id: string;
         source: {
             path: string;
-            commit: string;
             repository: string;
+            commit: string;
         };
         schemaVersion: 1;
         kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -445,8 +445,8 @@ export declare const catalogEntrySchema: z.ZodObject<{
         id: string;
         source: {
             path: string;
-            commit: string;
             repository: string;
+            commit: string;
         };
         schemaVersion: 1;
         kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -510,19 +510,19 @@ export declare const commandCatalogSchema: z.ZodObject<{
                 path: z.ZodString;
             }, "strict", z.ZodTypeAny, {
                 path: string;
-                commit: string;
                 repository: string;
+                commit: string;
             }, {
                 path: string;
-                commit: string;
                 repository: string;
+                commit: string;
             }>;
         }, "strict", z.ZodTypeAny, {
             id: string;
             source: {
                 path: string;
-                commit: string;
                 repository: string;
+                commit: string;
             };
             schemaVersion: 1;
             kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -547,8 +547,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
             id: string;
             source: {
                 path: string;
-                commit: string;
                 repository: string;
+                commit: string;
             };
             schemaVersion: 1;
             kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -573,8 +573,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
             id: string;
             source: {
                 path: string;
-                commit: string;
                 repository: string;
+                commit: string;
             };
             schemaVersion: 1;
             kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -599,8 +599,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
             id: string;
             source: {
                 path: string;
-                commit: string;
                 repository: string;
+                commit: string;
             };
             schemaVersion: 1;
             kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -670,8 +670,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
             id: string;
             source: {
                 path: string;
-                commit: string;
                 repository: string;
+                commit: string;
             };
             schemaVersion: 1;
             kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -711,8 +711,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
             id: string;
             source: {
                 path: string;
-                commit: string;
                 repository: string;
+                commit: string;
             };
             schemaVersion: 1;
             kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -754,8 +754,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
             id: string;
             source: {
                 path: string;
-                commit: string;
                 repository: string;
+                commit: string;
             };
             schemaVersion: 1;
             kind: "help" | "query" | "prompt" | "workflow" | "mutation";
@@ -800,8 +800,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
             id: string;
             source: {
                 path: string;
-                commit: string;
                 repository: string;
+                commit: string;
             };
             schemaVersion: 1;
             kind: "help" | "query" | "prompt" | "workflow" | "mutation";

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

@@ -134,7 +134,6 @@ export class CommandParser {
         // command, because that's what caused `daemon start` to resolve as `start`
         // with `daemon` left as a positional.
         let resolvedCmd;
-        let resolvedSub;
         const resolvedCommands = [];
         let sawFirstPositional = false;
         for (let index = 0; index < args.length; index++) {
@@ -173,16 +172,16 @@ export class CommandParser {
                 const child = parent.subcommands.find(sc => sc.name === arg || sc.aliases?.includes(arg));
                 if (child) {
                     resolvedCommands.push(child);
-                    resolvedSub ??= child;
                     continue;
                 }
             }
             // A positional that is not the next subcommand ends the command path.
             break;
         }
-        const { aliases, booleanFlags, stringFlags } = this.getFlagScope(resolvedCommands);
+        const { aliases, booleanFlags, stringFlags, arrayFlags } = this.getFlagScope(resolvedCommands);
         let i = 0;
         let parsingFlags = true;
+        let commandSlotAvailable = true;
         while (i < args.length) {
             const arg = args[i];
             // Check for end of flags marker
@@ -194,8 +193,17 @@ export class CommandParser {
             // Handle flags
             if (parsingFlags && arg.startsWith('-')) {
                 const parseResult = this.parseFlag(args, i, aliases, booleanFlags, stringFlags);
+                // Array declarations retain text and accumulate repeated occurrences.
+                for (const key of arrayFlags) {
+                    const value = parseResult.flags[key];
+                    if (value !== undefined && value !== true && value !== false) {
+                        const previous = result.flags[key];
+                        parseResult.flags[key] = [...(Array.isArray(previous) ? previous : []), String(value)];
+                    }
+                }
                 // Apply to result flags
-                Object.assign(result.flags, parseResult.flags);
+                const { _: ignoredPositionals, ...parsedFlags } = parseResult.flags;
+                Object.assign(result.flags, parsedFlags);
                 i = parseResult.nextIndex;
                 continue;
             }
@@ -203,7 +211,9 @@ export class CommandParser {
             // Fix for #1596: treat lazy command names as commands here too so that
             // downstream dispatch sees `commandPath = ['daemon', 'start']` instead of
             // `commandPath = ['start'], positional = ['daemon']`.
-            if (result.command.length === 0 && this.isKnownCommandName(arg)) {
+            const isCommandSlot = commandSlotAvailable && parsingFlags;
+            commandSlotAvailable = false;
+            if (isCommandSlot && this.isKnownCommandName(arg)) {
                 // This is a command
                 result.command.push(arg);
                 // Check for subcommand (level 1) — only possible for sync commands
@@ -248,7 +258,7 @@ export class CommandParser {
         // `default: true` silently dropped and reached the action handler as
         // `undefined`. That trapped `memory store --upsert` and every other
         // subcommand that leaned on a per-flag default.
-        this.applyDefaults(result.flags, resolvedCmd, resolvedSub);
+        this.applyDefaults(result.flags, resolvedCommands);
         return result;
     }
     parseFlag(args, index, aliases, booleanFlags, stringFlags) {
@@ -472,11 +482,18 @@ export class CommandParser {
                     aliases[option.short] = option.name;
             }
         }
+        const arrayFlags = new Set((this.options.arrayFlags ?? []).map(flag => this.normalizeKey(flag)));
+        for (const flag of arrayFlags)
+            stringFlags.add(flag);
         const layers = [this.globalOptions, ...commands.map(command => command.options ?? [])];
         for (const options of layers) {
             for (const option of options) {
                 const key = this.normalizeKey(option.name);
-                if (option.type === 'string')
+                if (option.type === 'array')
+                    arrayFlags.add(key);
+                else if (option.type)
+                    arrayFlags.delete(key);
+                if (option.type === 'string' || option.type === 'array')
                     stringFlags.add(key);
                 else if (option.type)
                     stringFlags.delete(key);
@@ -488,7 +505,7 @@ export class CommandParser {
         }
         for (const flag of stringFlags)
             booleanFlags.delete(flag);
-        return { aliases, booleanFlags, stringFlags };
+        return { aliases, booleanFlags, stringFlags, arrayFlags };
     }
     getBooleanFlags() {
         const flags = new Set();
@@ -526,23 +543,16 @@ export class CommandParser {
         }
         return flags;
     }
-    applyDefaults(flags, command, subcommand) {
-        // #2775: apply defaults from globals AND the resolved command/subcommand.
-        // Subcommand > command > global (later writes lose to earlier — because
-        // we only set when `undefined`, so the FIRST option definition that
-        // supplies a default wins; walk narrow-to-broad so subcommand options
-        // apply before broader ones do).
-        const layers = [];
-        if (subcommand?.options)
-            layers.push(subcommand.options);
-        if (command?.options)
-            layers.push(command.options);
+    applyDefaults(flags, commands) {
+        // Walk every resolved command from narrow to broad so nested defaults
+        // have the same precedence as their declared flag types.
+        const layers = [...commands].reverse().map(command => command.options ?? []);
         layers.push(this.globalOptions);
         for (const layer of layers) {
             for (const opt of layer) {
                 const key = this.normalizeKey(opt.name);
                 if (flags[key] === undefined && opt.default !== undefined) {
-                    flags[key] = opt.default;
+                    flags[key] = (Array.isArray(opt.default) ? [...opt.default] : opt.default);
                 }
             }
         }
@@ -551,7 +561,7 @@ export class CommandParser {
             for (const [key, value] of Object.entries(this.options.defaults)) {
                 const normalizedKey = this.normalizeKey(key);
                 if (flags[normalizedKey] === undefined) {
-                    flags[normalizedKey] = value;
+                    flags[normalizedKey] = (Array.isArray(value) ? [...value] : value);
                 }
             }
         }
@@ -572,7 +582,7 @@ export class CommandParser {
             // followed by another flag) is parsed as boolean `true`. Commands then treat `true` as
             // the value: `hooks route --task` crashed with "task.trim is not a function" and
             // `memory retrieve --key` looked up the key "true". Report it instead.
-            if ((opt.type === 'string' || opt.type === 'number') && flags[key] === true) {
+            if ((opt.type === 'string' || opt.type === 'number' || opt.type === 'array') && flags[key] === true) {
                 errors.push(`Option --${opt.name} needs a value`);
             }
             // Check choices

package/v3/@claude-flow/cli/dist/src/production/monitoring.d.ts

@@ -71,6 +71,7 @@ export declare class MonitoringHooks {
     private healthStatus;
     private startTime;
     private activeRequests;
+    private requestGeneration;
     private requestCount;
     private errorCount;
     private healthChecks;

package/v3/@claude-flow/cli/dist/src/production/monitoring.js

@@ -37,6 +37,7 @@ export class MonitoringHooks {
     healthStatus;
     startTime = Date.now();
     activeRequests = 0;
+    requestGeneration = 0;
     requestCount = 0;
     errorCount = 0;
     healthChecks = new Map();
@@ -101,9 +102,14 @@ export class MonitoringHooks {
         this.activeRequests++;
         this.requestCount++;
         const startTime = Date.now();
+        const generation = this.requestGeneration;
+        let completed = false;
         this.counter('request_started', 1, { requestId });
         // Return end function
         return () => {
+            if (completed || generation !== this.requestGeneration)
+                return;
+            completed = true;
             this.activeRequests--;
             const duration = Date.now() - startTime;
             this.responseTimes.push(duration);
@@ -156,7 +162,7 @@ export class MonitoringHooks {
             catch (error) {
                 checks[name] = {
                     status: 'unhealthy',
-                    message: error.message,
+                    message: error instanceof Error ? error.message : String(error),
                     lastCheck: Date.now(),
                     responseTimeMs: Date.now() - startTime,
                 };
@@ -168,13 +174,13 @@ export class MonitoringHooks {
             checks,
             timestamp: Date.now(),
         };
-        return this.healthStatus;
+        return structuredClone(this.healthStatus);
     }
     /**
      * Get current health status
      */
     getHealthStatus() {
-        return this.healthStatus;
+        return structuredClone(this.healthStatus);
     }
     // ============================================================================
     // Performance Metrics
@@ -217,7 +223,7 @@ export class MonitoringHooks {
         if (level) {
             filtered = filtered.filter(a => a.level === level);
         }
-        return filtered;
+        return filtered.map(alert => ({ ...alert }));
     }
     /**
      * Acknowledge an alert
@@ -248,7 +254,7 @@ export class MonitoringHooks {
         if (since) {
             filtered = filtered.filter(m => m.timestamp >= since);
         }
-        return filtered;
+        return filtered.map(metric => ({ ...metric, labels: { ...metric.labels } }));
     }
     /**
      * Get all metrics summary
@@ -278,6 +284,7 @@ export class MonitoringHooks {
      * Reset all metrics
      */
     reset() {
+        this.requestGeneration++;
         this.metrics = [];
         this.responseTimes = [];
         this.alerts = [];
@@ -308,7 +315,13 @@ export class MonitoringHooks {
             const recentAlert = this.alerts.find(a => a.metric === name &&
                 !a.acknowledged &&
                 Date.now() - a.timestamp < 60000);
-            if (!recentAlert) {
+            if (recentAlert && level === 'critical' && recentAlert.level !== 'critical') {
+                Object.assign(recentAlert, {
+                    level, value, threshold, timestamp: Date.now(),
+                    message: `${name} exceeded ${level} threshold: ${value} >= ${threshold}`,
+                });
+            }
+            else if (!recentAlert) {
                 this.alerts.push({
                     id: `alert_${Date.now()}_${Math.random().toString(36).substring(7)}`,
                     level,

package/v3/@claude-flow/cli/dist/src/production/rate-limiter.js

@@ -90,6 +90,7 @@ export class RateLimiter {
      */
     getStatus(operation, userId) {
         const limits = this.getLimits(operation);
+        const capacity = Math.floor(limits.maxRequests * this.config.burstMultiplier);
         const bucketKey = userId && this.config.perUserLimits
             ? `${operation}:${userId}`
             : `global:${operation}`;
@@ -98,8 +99,8 @@ export class RateLimiter {
         if (!bucket) {
             return {
                 current: 0,
-                limit: limits.maxRequests,
-                remaining: limits.maxRequests,
+                limit: capacity,
+                remaining: capacity,
                 resetAt: now + limits.windowMs,
             };
         }
@@ -107,8 +108,8 @@ export class RateLimiter {
         const validRequests = bucket.requests.filter(t => t > now - limits.windowMs);
         return {
             current: validRequests.length,
-            limit: limits.maxRequests,
-            remaining: Math.max(0, limits.maxRequests - validRequests.length),
+            limit: capacity,
+            remaining: Math.max(0, capacity - validRequests.length),
             resetAt: validRequests.length > 0
                 ? validRequests[0] + limits.windowMs
                 : now + limits.windowMs,