claude-flow 3.32.11 → 3.32.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.32.11",
+  "version": "3.32.13",
   "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/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 1,
-  "generatedAt": "2026-07-26T22:48:15.666Z",
-  "gitSha": "2aec43f6",
+  "generatedAt": "2026-07-27T00:32:05.924Z",
+  "gitSha": "a17a597b",
   "catalog": {
     "agents": 164,
     "tools": 387,

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

@@ -644,15 +644,54 @@ const routeCommand = {
             description: 'Number of top agent suggestions',
             type: 'number',
             default: 3
-        }
+        },
+        {
+            // #2778 dream-cycle — Mixture-of-Agents test-time scaling.
+            // When `--mode moa` is set AND the router would have chosen a
+            // Tier-3 model (Sonnet/Opus), swap to N parallel Tier-2 (Haiku)
+            // calls + majority-vote consensus. Grade-A ACL 2026 SRW evidence
+            // (arXiv 2605.01566): +2.7pp accuracy at equal-cost when parallel
+            // generations exceed sequential aggregations.
+            name: 'mode',
+            description: 'Routing mode: single (default) or moa (mixture-of-agents fanout, #2778)',
+            type: 'string',
+            choices: ['single', 'moa'],
+            default: 'single',
+        },
+        {
+            // #2778 — deliberately NOT `parallel` (short 'p'). Both swarm.ts and
+            // workflow.ts declare `--parallel` as a BOOLEAN, and the parser's
+            // global boolean-flag registry pollutes subcommand-scoped numeric
+            // flags with the same name (parseFlag then treats `--parallel 7` as
+            // `parallel:true` and drops the value). Using a distinct name avoids
+            // the collision without touching parser semantics that other
+            // subcommands rely on.
+            name: 'moa-parallel',
+            description: 'MoA fanout width (N parallel calls at Haiku tier; only meaningful when --mode=moa)',
+            type: 'number',
+            default: 3,
+        },
+        {
+            name: 'consensus',
+            description: 'MoA consensus strategy: majority-vote (default) or best-confidence',
+            type: 'string',
+            choices: ['majority-vote', 'best-confidence'],
+            default: 'majority-vote',
+        },
     ],
     examples: [
-        { command: 'claude-flow hooks route -t "Fix authentication bug"', description: 'Route task to optimal agent' },
-        { command: 'claude-flow hooks route -t "Optimize database queries" -K 5', description: 'Get top 5 suggestions' }
+        { command: 'claude-flow hooks route -t "Fix authentication bug"', description: 'Route task to optimal agent (single mode)' },
+        { command: 'claude-flow hooks route -t "Optimize database queries" -K 5', description: 'Get top 5 suggestions' },
+        { command: 'claude-flow hooks route -t "Design payment webhook" --mode moa --moa-parallel 3', description: 'MoA fanout: 3× Haiku + consensus (dream-cycle #2778)' },
     ],
     action: async (ctx) => {
         const task = ctx.flags.task || ctx.args[0];
         const topK = ctx.flags.topK || 3;
+        const mode = ctx.flags.mode || 'single';
+        // #2778 — flag is --moa-parallel (parser normalizes to camelCase moaParallel)
+        // to avoid collision with the boolean --parallel from swarm/workflow.
+        const parallel = Math.max(2, ctx.flags.moaParallel || 3);
+        const consensus = ctx.flags.consensus || 'majority-vote';
         if (!task) {
             output.printError('Task description is required. Use --task or -t flag.');
             return { success: false, exitCode: 1 };
@@ -666,6 +705,35 @@ const routeCommand = {
                 topK,
                 includeEstimates: true,
             });
+            // #2778 — compute the MoA plan BEFORE the JSON output branch so
+            // programmatic callers see `moaPlan` in the JSON result too.
+            let moaPlan = null;
+            if (mode === 'moa') {
+                const complexity = result.estimatedMetrics?.complexity ?? 'medium';
+                const wouldTier3 = complexity === 'high';
+                const primaryAgent = result.primaryAgent.type;
+                const agents = Array.from({ length: parallel }, (_, i) => ({
+                    name: `moa-${primaryAgent}-${i + 1}`,
+                    model: 'haiku',
+                    role: primaryAgent,
+                }));
+                moaPlan = {
+                    mode: 'moa',
+                    parallel,
+                    tier: 'tier2-haiku',
+                    consensus,
+                    rationale: wouldTier3
+                        ? `Complexity=${complexity} would tier-3 (Sonnet/Opus). MoA fanout — ${parallel}× Haiku is typically <1× Sonnet cost (arXiv 2605.01566: +2.7pp at equal cost).`
+                        : `Complexity=${complexity} — MoA still available as a diversity mechanism, but the single-agent path is usually the cost-optimal choice below Tier-3.`,
+                    agents,
+                    synthesizer: {
+                        name: `moa-synth-${primaryAgent}`,
+                        model: 'haiku',
+                        role: 'synthesizer',
+                    },
+                };
+                result.moaPlan = moaPlan;
+            }
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
                 return { success: true, data: result };
@@ -719,6 +787,23 @@ const routeCommand = {
                     `Complexity: ${result.estimatedMetrics.complexity.toUpperCase()}`
                 ]);
             }
+            // #2778 dream-cycle — render the MoA plan to text output. moaPlan
+            // was already spliced into the result above so JSON consumers see it.
+            if (mode === 'moa' && moaPlan) {
+                const primaryAgent = result.primaryAgent.type;
+                output.writeln();
+                output.writeln(output.bold('Mixture-of-Agents Plan (#2778)'));
+                output.printList([
+                    `Mode: moa`,
+                    `Fanout: ${parallel} parallel ${primaryAgent} × Haiku`,
+                    `Consensus: ${consensus}`,
+                    `Synthesizer: 1 Haiku agent (${consensus} over ${parallel} verdicts)`,
+                ]);
+                output.writeln();
+                output.printBox(`Spawn ${parallel} background Task calls with model="haiku" and subagent_type="${primaryAgent}"\n` +
+                    `then a synthesizer Task ("moa-synth-${primaryAgent}") that reads all ${parallel} results and picks the ${consensus === 'majority-vote' ? 'majority answer' : 'highest-confidence answer'}.\n\n` +
+                    `Cost note: ${parallel}× Haiku is typically <1× Sonnet on comparable complexity — see arXiv 2605.01566 for the ACL 2026 evidence.`, 'MoA Execution Directive');
+            }
             return { success: true, data: result };
         }
         catch (error) {

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

@@ -300,12 +300,23 @@ const initCommand = {
             description: 'Enable V3 15-agent hierarchical mesh mode',
             type: 'boolean',
             default: false
-        }
+        },
+        {
+            // #2768 — dream-cycle SubagentPermissionDelegate. Ships a per-role
+            // capability manifest to `.swarm/permissions.jsonl` + an append-only
+            // audit trail. Task-tool prompts can consult the manifest; ruflo
+            // does NOT enforce at the syscall boundary (Claude Code owns that).
+            name: 'with-permissions',
+            description: 'Ship workspace-scoped permission manifest (preset: strict|standard|permissive) — dream-cycle #2768',
+            type: 'string',
+            choices: ['strict', 'standard', 'permissive'],
+        },
     ],
     action: async (ctx) => {
         let topology = ctx.flags.topology;
         const maxAgents = ctx.flags.maxAgents || 15;
         const v3Mode = ctx.flags.v3Mode;
+        const withPermissions = ctx.flags.withPermissions;
         // V3 mode enables hierarchical-mesh hybrid
         if (v3Mode) {
             topology = 'hierarchical-mesh';
@@ -377,6 +388,7 @@ const initCommand = {
                     maxAgents: result.config.maxAgents,
                     strategy: ctx.flags.strategy || 'development',
                     v3Mode,
+                    permissions: withPermissions ?? null,
                     initializedAt: result.initializedAt,
                     status: 'ready'
                 }, null, 2));
@@ -384,6 +396,35 @@ const initCommand = {
             catch {
                 // Ignore errors writing state file
             }
+            // #2768 — write the permission manifest + seed the audit trail.
+            // Optional: only fires when --with-permissions was passed. Missing
+            // module or failed I/O is non-critical; we log a dim warning and
+            // continue so a broken permission layer never blocks swarm init.
+            if (withPermissions) {
+                try {
+                    const [{ resolvePreset }, { writeGrants, appendAuditEvent }] = await Promise.all([
+                        import('../permission/permission-set.js'),
+                        import('../permission/permission-audit.js'),
+                    ]);
+                    const sets = resolvePreset(withPermissions);
+                    writeGrants(sets, swarmDir);
+                    for (const set of sets) {
+                        appendAuditEvent({
+                            agentId: 'swarm-init',
+                            role: set.role,
+                            event: 'granted',
+                            capability: `preset:${withPermissions}`,
+                            swarmId: result.swarmId,
+                            reason: `Initial grant from swarm init --with-permissions ${withPermissions}`,
+                        }, swarmDir);
+                    }
+                    output.writeln(output.dim(`  Wrote permission manifest (preset: ${withPermissions}, ${sets.length} roles) → .swarm/permissions.jsonl`));
+                    output.writeln(output.dim(`  Audit trail seeded → .swarm/permission-audit.jsonl`));
+                }
+                catch (err) {
+                    output.writeln(output.dim(`  ⚠ permission manifest skipped: ${err instanceof Error ? err.message : String(err)}`));
+                }
+            }
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
             }

package/v3/@claude-flow/cli/dist/src/permission/permission-audit.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Append-only permission audit log for swarm subagents (dream-cycle #2768).
+ *
+ * Every grant / check / deny / revoke event is written to
+ * `.swarm/permission-audit.jsonl` — one JSON object per line, no rewrites,
+ * no deletes. Persistence follows the same discipline as ruflo's other
+ * append-only ledgers (routing-outcomes, funnel-events) so downstream
+ * readers can tail without truncation risk.
+ */
+/** A single permission-audit event. */
+export interface AuditEvent {
+    /** ISO-8601 timestamp. */
+    timestamp: string;
+    /** Opaque agent identifier — matches Task tool `name:` or a swarm-assigned slot id. */
+    agentId: string;
+    /** Symbolic role — matches PermissionSet.role. */
+    role: string;
+    /** Event class. */
+    event: 'granted' | 'checked' | 'denied' | 'revoked';
+    /** Free-form capability descriptor (`tool:Bash`, `path:src/**`, `net:api.github.com`). */
+    capability: string;
+    /** Optional swarm-scope identifier. */
+    swarmId?: string;
+    /** Optional human-readable reason. */
+    reason?: string;
+    /** Auto-generated event id for correlation. */
+    eventId: string;
+}
+/** Resolve `.swarm/permission-audit.jsonl` under the given (or cwd's) swarm dir. */
+export declare function auditLogPath(swarmDir?: string): string;
+/** Resolve `.swarm/permissions.jsonl` — the current-grants manifest. */
+export declare function grantsPath(swarmDir?: string): string;
+/** Append a single audit event. Never throws — failures are non-critical. */
+export declare function appendAuditEvent(event: Omit<AuditEvent, 'eventId' | 'timestamp'>, swarmDir?: string): void;
+/** Read every audit event. Used by review tooling. */
+export declare function readAuditLog(swarmDir?: string): AuditEvent[];
+/** Write the current grants manifest (overwrites) — one line per role. */
+export declare function writeGrants(grants: unknown[], swarmDir?: string): void;
+/** Read the current grants manifest. */
+export declare function readGrants(swarmDir?: string): unknown[];
+//# sourceMappingURL=permission-audit.d.ts.map

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

@@ -0,0 +1,88 @@
+/**
+ * Append-only permission audit log for swarm subagents (dream-cycle #2768).
+ *
+ * Every grant / check / deny / revoke event is written to
+ * `.swarm/permission-audit.jsonl` — one JSON object per line, no rewrites,
+ * no deletes. Persistence follows the same discipline as ruflo's other
+ * append-only ledgers (routing-outcomes, funnel-events) so downstream
+ * readers can tail without truncation risk.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { randomBytes } from 'node:crypto';
+/** Resolve `.swarm/permission-audit.jsonl` under the given (or cwd's) swarm dir. */
+export function auditLogPath(swarmDir) {
+    const dir = swarmDir ?? path.join(process.cwd(), '.swarm');
+    return path.join(dir, 'permission-audit.jsonl');
+}
+/** Resolve `.swarm/permissions.jsonl` — the current-grants manifest. */
+export function grantsPath(swarmDir) {
+    const dir = swarmDir ?? path.join(process.cwd(), '.swarm');
+    return path.join(dir, 'permissions.jsonl');
+}
+function ensureDirFor(filePath) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+}
+/** Append a single audit event. Never throws — failures are non-critical. */
+export function appendAuditEvent(event, swarmDir) {
+    const full = {
+        ...event,
+        timestamp: new Date().toISOString(),
+        eventId: `evt-${Date.now()}-${randomBytes(4).toString('hex')}`,
+    };
+    try {
+        const p = auditLogPath(swarmDir);
+        ensureDirFor(p);
+        fs.appendFileSync(p, JSON.stringify(full) + '\n', 'utf-8');
+    }
+    catch {
+        /* audit log unavailable — non-critical, don't crash the caller */
+    }
+}
+/** Read every audit event. Used by review tooling. */
+export function readAuditLog(swarmDir) {
+    const p = auditLogPath(swarmDir);
+    if (!fs.existsSync(p))
+        return [];
+    const raw = fs.readFileSync(p, 'utf-8');
+    return raw
+        .split('\n')
+        .filter((line) => line.length > 0)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((e) => e !== null);
+}
+/** Write the current grants manifest (overwrites) — one line per role. */
+export function writeGrants(grants, swarmDir) {
+    const p = grantsPath(swarmDir);
+    ensureDirFor(p);
+    fs.writeFileSync(p, grants.map((g) => JSON.stringify(g)).join('\n') + '\n', 'utf-8');
+}
+/** Read the current grants manifest. */
+export function readGrants(swarmDir) {
+    const p = grantsPath(swarmDir);
+    if (!fs.existsSync(p))
+        return [];
+    const raw = fs.readFileSync(p, 'utf-8');
+    return raw
+        .split('\n')
+        .filter((line) => line.length > 0)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((g) => g !== null);
+}
+//# sourceMappingURL=permission-audit.js.map

package/v3/@claude-flow/cli/dist/src/permission/permission-set.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Workspace-scoped permission model for swarm subagents (dream-cycle #2768,
+ * ClawArena finding: privilege granting is the #1 orchestration bottleneck,
+ * no LLM > 50% workspace-permission precision as team lead).
+ *
+ * SCOPE (honest): this is a METADATA + AUDIT layer, not a runtime sandbox.
+ * Claude Code's Task tool owns the actual subprocess sandbox; ruflo cannot
+ * enforce at the syscall boundary. What we CAN do:
+ *   1. Publish a per-role capability manifest that Task-tool prompts can
+ *      consult ("your workspace-scoped tools are X, Y, Z; you may not use W").
+ *   2. Record every grant/check/deny/revoke to an append-only audit trail
+ *      so the swarm has a reviewable permission history.
+ *
+ * That is enough to close the "permission-hygiene" half of the ClawArena
+ * finding — the "50% precision as team lead" number is about the LLM's
+ * decision QUALITY, which no runtime layer fixes.
+ */
+import type { PathValidator } from '@claude-flow/security';
+/** A single agent role's capability envelope. */
+export interface PermissionSet {
+    /** Symbolic role name — matches ruflo agent-type names (coder, tester, reviewer, …). */
+    role: string;
+    /** Tools this role MAY use. Empty array = deny-all-tools. */
+    allowedTools: string[];
+    /** Tools this role MUST NOT use (evaluated after allow — deny wins). */
+    deniedTools: string[];
+    /** Glob patterns this role MAY read/write, relative to swarm cwd. */
+    allowedPaths: string[];
+    /** Glob patterns this role MUST NOT touch (deny wins). */
+    deniedPaths: string[];
+    /** Exact-host allowlist for outbound network. Empty = deny-all-network. */
+    allowedNetworkHosts: string[];
+    /** Human-readable note explaining the intent of this envelope. */
+    notes?: string;
+}
+/** Built-in presets, ordered narrow → wide. Each preset ships per-role sets. */
+export declare const PRESETS: Record<'strict' | 'standard' | 'permissive', PermissionSet[]>;
+export type PresetName = keyof typeof PRESETS;
+/**
+ * Resolve a preset name to its per-role sets. Throws on unknown preset —
+ * fail loud so a typo doesn't silently degrade to permissive.
+ */
+export declare function resolvePreset(name: string): PermissionSet[];
+/**
+ * Sanity-check a permission set: role name shape, no null entries.
+ * Path validation is deferred to the enforcement side (PathValidator)
+ * so this module has no @claude-flow/security runtime dep beyond a
+ * type-only import.
+ */
+export declare function validatePermissionSet(set: PermissionSet, _validator?: PathValidator): string[];
+//# sourceMappingURL=permission-set.d.ts.map

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

@@ -0,0 +1,141 @@
+/**
+ * Workspace-scoped permission model for swarm subagents (dream-cycle #2768,
+ * ClawArena finding: privilege granting is the #1 orchestration bottleneck,
+ * no LLM > 50% workspace-permission precision as team lead).
+ *
+ * SCOPE (honest): this is a METADATA + AUDIT layer, not a runtime sandbox.
+ * Claude Code's Task tool owns the actual subprocess sandbox; ruflo cannot
+ * enforce at the syscall boundary. What we CAN do:
+ *   1. Publish a per-role capability manifest that Task-tool prompts can
+ *      consult ("your workspace-scoped tools are X, Y, Z; you may not use W").
+ *   2. Record every grant/check/deny/revoke to an append-only audit trail
+ *      so the swarm has a reviewable permission history.
+ *
+ * That is enough to close the "permission-hygiene" half of the ClawArena
+ * finding — the "50% precision as team lead" number is about the LLM's
+ * decision QUALITY, which no runtime layer fixes.
+ */
+/** Built-in presets, ordered narrow → wide. Each preset ships per-role sets. */
+export const PRESETS = {
+    /**
+     * strict — read-only file access, no network, no bash. Suitable for
+     * research / review / planning agents. Denies every destructive surface.
+     */
+    strict: [
+        {
+            role: 'researcher',
+            allowedTools: ['Read', 'Grep', 'Glob'],
+            deniedTools: ['Bash', 'Edit', 'Write', 'NotebookEdit'],
+            allowedPaths: ['**/*'],
+            deniedPaths: ['**/.env', '**/.env.*', '**/secrets/**', '**/*.key', '**/*.pem'],
+            allowedNetworkHosts: [],
+            notes: 'Read-only research role; no filesystem writes, no network, no shell.',
+        },
+        {
+            role: 'reviewer',
+            allowedTools: ['Read', 'Grep', 'Glob'],
+            deniedTools: ['Bash', 'Edit', 'Write', 'NotebookEdit'],
+            allowedPaths: ['**/*'],
+            deniedPaths: ['**/.env', '**/.env.*', '**/secrets/**', '**/*.key', '**/*.pem'],
+            allowedNetworkHosts: [],
+            notes: 'Read-only code review; findings emitted via return message, not filesystem writes.',
+        },
+        {
+            role: 'planner',
+            allowedTools: ['Read', 'Grep', 'Glob'],
+            deniedTools: ['Bash', 'Edit', 'Write', 'NotebookEdit'],
+            allowedPaths: ['**/*'],
+            deniedPaths: ['**/.env', '**/.env.*', '**/secrets/**', '**/*.key', '**/*.pem'],
+            allowedNetworkHosts: [],
+            notes: 'Read-only planning; produces plan text, no side effects.',
+        },
+    ],
+    /**
+     * standard — the default. Read + edit under cwd, no bash, allowlisted
+     * network hosts for common dev workflows (github, npm registry, docs).
+     * Suitable for implementation agents doing bounded file changes.
+     */
+    standard: [
+        {
+            role: 'coder',
+            allowedTools: ['Read', 'Grep', 'Glob', 'Edit', 'Write', 'NotebookEdit'],
+            deniedTools: ['Bash'],
+            allowedPaths: ['src/**', 'tests/**', '__tests__/**', 'lib/**', 'plugins/**', 'v3/**', 'docs/**', 'CHANGELOG.md', 'package.json'],
+            deniedPaths: ['**/.env', '**/.env.*', '**/secrets/**', '**/*.key', '**/*.pem', '**/.git/**', '**/node_modules/**'],
+            allowedNetworkHosts: ['api.github.com', 'registry.npmjs.org', 'docs.rs', 'crates.io'],
+            notes: 'Bounded code writer; edits under source directories, no shell, allowlist network.',
+        },
+        {
+            role: 'tester',
+            allowedTools: ['Read', 'Grep', 'Glob', 'Edit', 'Write'],
+            deniedTools: ['Bash', 'NotebookEdit'],
+            allowedPaths: ['tests/**', '__tests__/**', '**/*.test.*', '**/*.spec.*'],
+            deniedPaths: ['**/.env', '**/.env.*', '**/secrets/**', '**/*.key', '**/*.pem'],
+            allowedNetworkHosts: [],
+            notes: 'Tests-only writer; scope pinned to test directories and .test/.spec files.',
+        },
+        {
+            role: 'reviewer',
+            allowedTools: ['Read', 'Grep', 'Glob'],
+            deniedTools: ['Bash', 'Edit', 'Write', 'NotebookEdit'],
+            allowedPaths: ['**/*'],
+            deniedPaths: ['**/.env', '**/.env.*', '**/secrets/**', '**/*.key', '**/*.pem'],
+            allowedNetworkHosts: [],
+            notes: 'Read-only reviewer; identical to strict-reviewer.',
+        },
+    ],
+    /**
+     * permissive — the pre-#2768 baseline. Full toolset, no path fencing.
+     * Kept for compatibility so users can opt back in explicitly. NOT a
+     * good default — the entire point of this feature is that the LLM's
+     * unaided permission decisions land under 50% precision.
+     */
+    permissive: [
+        {
+            role: '*',
+            allowedTools: ['*'],
+            deniedTools: [],
+            allowedPaths: ['**/*'],
+            deniedPaths: [],
+            allowedNetworkHosts: ['*'],
+            notes: 'No restriction. Kept for opt-in compatibility; see #2768 for why this is not the default.',
+        },
+    ],
+};
+/**
+ * Resolve a preset name to its per-role sets. Throws on unknown preset —
+ * fail loud so a typo doesn't silently degrade to permissive.
+ */
+export function resolvePreset(name) {
+    if (!(name in PRESETS)) {
+        const valid = Object.keys(PRESETS).join(', ');
+        throw new Error(`Unknown permissions preset: ${name}. Valid presets: ${valid}`);
+    }
+    return PRESETS[name];
+}
+/**
+ * Sanity-check a permission set: role name shape, no null entries.
+ * Path validation is deferred to the enforcement side (PathValidator)
+ * so this module has no @claude-flow/security runtime dep beyond a
+ * type-only import.
+ */
+export function validatePermissionSet(set, _validator) {
+    const errors = [];
+    if (!set.role || typeof set.role !== 'string')
+        errors.push('role must be a non-empty string');
+    const arrays = [
+        ['allowedTools', set.allowedTools],
+        ['deniedTools', set.deniedTools],
+        ['allowedPaths', set.allowedPaths],
+        ['deniedPaths', set.deniedPaths],
+        ['allowedNetworkHosts', set.allowedNetworkHosts],
+    ];
+    for (const [key, val] of arrays) {
+        if (!Array.isArray(val))
+            errors.push(`${String(key)} must be an array`);
+        else if (val.some((v) => typeof v !== 'string'))
+            errors.push(`${String(key)} must contain only strings`);
+    }
+    return errors;
+}
+//# sourceMappingURL=permission-set.js.map

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.32.11",
+  "version": "3.32.13",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",