claude-flow 3.47.1 → 3.49.0

package/v3/@claude-flow/cli/dist/src/plugins/trust-policy.js

@@ -0,0 +1,84 @@
+/**
+ * Plugin install trust policy (#3557).
+ *
+ * `plugins install --verify` used to be parsed and never read, and a plugin's
+ * declared `trustLevel`/`permissions` were neither recorded nor enforced.
+ * These pure helpers decide what an install may register.
+ */
+import { createHash } from 'crypto';
+/**
+ * Permissions a plugin may declare and still have its hooks and commands
+ * registered without `--trust`. Anything else (filesystem, network, shell,
+ * secrets, config, privileged, …) needs an explicit `--trust`.
+ */
+export const DEFAULT_PLUGIN_PERMISSIONS = Object.freeze(['memory:read']);
+/** Trust levels that are withheld unless the user passes `--trust`. */
+export const UNTRUSTED_TRUST_LEVELS = Object.freeze(['untrusted', 'unverified']);
+/** Registry trust levels that the registry itself vouches for. */
+export const REGISTRY_VOUCHED_TRUST_LEVELS = Object.freeze(['official', 'verified']);
+function asStringList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((v) => typeof v === 'string' && v.trim() !== '').map((v) => v.trim());
+}
+/**
+ * Read the trust declaration from a plugin's package.json. The `claude-flow`
+ * block wins; top-level fields are accepted as a fallback.
+ */
+export function readDeclaredTrust(pkg) {
+    const block = (pkg['claude-flow'] && typeof pkg['claude-flow'] === 'object'
+        ? pkg['claude-flow']
+        : {});
+    const trustLevel = typeof block.trustLevel === 'string'
+        ? block.trustLevel
+        : typeof pkg.trustLevel === 'string' ? pkg.trustLevel : undefined;
+    const permissions = asStringList(block.permissions).length > 0
+        ? asStringList(block.permissions)
+        : asStringList(pkg.permissions);
+    return { trustLevel, permissions };
+}
+/** Decide whether an install may register the plugin's hooks and commands. */
+export function evaluatePluginTrust(declared, opts) {
+    const excessPermissions = declared.permissions.filter((p) => !DEFAULT_PLUGIN_PERMISSIONS.includes(p));
+    if (!opts.verify) {
+        return { allowed: true, verificationSkipped: true, reasons: [], excessPermissions };
+    }
+    const reasons = [];
+    const registryVouched = opts.registryTrustLevel !== undefined
+        && REGISTRY_VOUCHED_TRUST_LEVELS.includes(opts.registryTrustLevel);
+    if (!registryVouched) {
+        if (declared.trustLevel && UNTRUSTED_TRUST_LEVELS.includes(declared.trustLevel)) {
+            reasons.push(`declares trustLevel "${declared.trustLevel}"`);
+        }
+        if (excessPermissions.length > 0) {
+            reasons.push(`declares permissions beyond the default set (${DEFAULT_PLUGIN_PERMISSIONS.join(', ')}): ${excessPermissions.join(', ')}`);
+        }
+    }
+    if (reasons.length > 0 && !opts.trust) {
+        return { allowed: false, verificationSkipped: false, reasons, excessPermissions };
+    }
+    return { allowed: true, verificationSkipped: false, reasons: [], excessPermissions };
+}
+/**
+ * Whether npm may run the package's lifecycle scripts (preinstall/install/
+ * postinstall, and those of its dependencies). Scripts execute before the
+ * package's own trust declaration can be read, so only an explicit `--trust`
+ * or a registry-vouched entry allows them; everything else installs with
+ * `--ignore-scripts`.
+ */
+export function shouldRunInstallScripts(opts) {
+    if (opts.trust === true)
+        return true;
+    return opts.registryTrustLevel !== undefined && REGISTRY_VOUCHED_TRUST_LEVELS.includes(opts.registryTrustLevel);
+}
+/** A registry checksum we can actually verify: `sha256:` + 64 hex chars. */
+export function parseSha256Checksum(checksum) {
+    if (typeof checksum !== 'string')
+        return null;
+    const m = /^sha256:([0-9a-f]{64})$/i.exec(checksum.trim());
+    return m ? m[1].toLowerCase() : null;
+}
+export function sha256Hex(data) {
+    return createHash('sha256').update(data).digest('hex');
+}
+//# sourceMappingURL=trust-policy.js.map

package/v3/@claude-flow/cli/dist/src/ruvector/graph-analyzer.js

@@ -96,7 +96,10 @@ async function loadRuVector() {
 function extractImports(content, _filePath) {
     const imports = [];
     // ES6 import statements
-    const esImportRegex = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s*,?\s*)*\s*from\s*['"]([^'"]+)['"]/g;
+    // Keep the import clause's shape finite. Repeating an optional separator
+    // around alternatives lets ordinary prose such as "import one two three ..."
+    // backtrack exponentially when no `from` clause follows.
+    const esImportRegex = /\bimport\s+(?:type\s+)?(?:[\w$]+\s*,\s*)?(?:\{[^}]*\}|\*\s+as\s+[\w$]+|[\w$]+)\s+from\s*['"]([^'"]+)['"]/g;
     let match;
     while ((match = esImportRegex.exec(content)) !== null) {
         imports.push({ path: match[1], type: 'import' });

package/v3/@claude-flow/cli/dist/src/services/config-file-manager.js

@@ -80,12 +80,23 @@ export class ConfigFileManager {
         }
         try {
             const content = fs.readFileSync(this.configPath, 'utf-8');
-            this.config = JSON.parse(content);
+            const parsed = JSON.parse(content);
+            if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+                throw new Error('Config file must contain a JSON object');
+            }
+            this.config = parsed;
             return this.config;
         }
-        catch {
+        catch (error) {
             this.config = null;
-            return null;
+            if (error.code === 'ENOENT') {
+                this.configPath = null;
+                return null;
+            }
+            // A parse/read failure is not a missing config. In particular, set()
+            // must never replace a recoverable file with fallback defaults.
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to load config ${this.configPath}: ${detail}`);
         }
     }
     /** Get the current config, loading if needed */
@@ -98,12 +109,23 @@ export class ConfigFileManager {
     /** Get a nested config value by dot-separated key */
     get(cwd, key) {
         const config = this.getConfig(cwd);
-        return getNestedValue(config, key);
+        return Object.hasOwn(config, key) ? config[key] : getNestedValue(config, key);
     }
     /** Set a nested config value by dot-separated key */
     set(cwd, key, value) {
-        const config = this.getConfig(cwd);
-        setNestedValue(config, key, value);
+        // Reject the entire path before touching cached config or disk.
+        if (key.split('.').some(part => part === '__proto__' || part === 'constructor' || part === 'prototype')) {
+            throw new Error(`Unsafe configuration key: ${key}`);
+        }
+        // A targeted update must not persist unrelated defaults (notably the
+        // default memory path, which would relocate an existing memory store).
+        const config = this.config ?? this.load(cwd) ?? {};
+        if (Object.hasOwn(config, key)) {
+            config[key] = value;
+        }
+        else {
+            setNestedValue(config, key, value);
+        }
         this.config = config;
         const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
         this.writeAtomic(targetPath, config);
@@ -181,7 +203,7 @@ function getNestedValue(obj, key) {
     const parts = key.split('.');
     let current = obj;
     for (const part of parts) {
-        if (current === null || current === undefined || typeof current !== 'object') {
+        if (current === null || current === undefined || typeof current !== 'object' || !Object.hasOwn(current, part)) {
             return undefined;
         }
         current = current[part];
@@ -194,7 +216,7 @@ function setNestedValue(obj, key, value) {
     let current = obj;
     for (let i = 0; i < parts.length - 1; i++) {
         const part = parts[i];
-        if (!(part in current) || typeof current[part] !== 'object' || current[part] === null) {
+        if (!Object.hasOwn(current, part) || typeof current[part] !== 'object' || current[part] === null) {
             current[part] = {};
         }
         current = current[part];

package/v3/@claude-flow/cli/dist/src/services/memory-backup.d.ts

@@ -25,7 +25,7 @@ export interface RestoreResult {
     restored: boolean;
     /** The backup file that was restored. */
     from?: string;
-    /** memory_entries count in the restored DB (-1 if it couldn't be verified). */
+    /** Verified memory_entries count in the restored DB. */
     rows?: number;
     /** Where the corrupt live DB was parked before the swap. */
     corruptBackupPath?: string;

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

@@ -14,6 +14,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { readFileMaybeEncrypted } from '../fs-secure.js';
 export function defaultMemoryDbPath(cwd = process.cwd()) {
     return path.join(cwd, '.swarm', 'memory.db');
 }
@@ -21,6 +22,19 @@ export function defaultMemoryDbPath(cwd = process.cwd()) {
 function fileStamp(ms) {
     return new Date(ms).toISOString().replace(/[:.]/g, '-');
 }
+/** Keep legacy memory.db names; give every other basename its own snapshot set. */
+function snapshotPrefix(dbPath) {
+    const name = path.basename(dbPath);
+    // A distinct namespace prevents an extensionless `memory` database from
+    // colliding with the historical `memory.db` prefix. Encoding is injective
+    // within the nondefault namespace, including names that contain `%`.
+    return name === 'memory.db' ? 'memory-' : `store-${encodeURIComponent(name)}-`;
+}
+function isSnapshotFor(file, dbPath) {
+    const prefix = snapshotPrefix(dbPath);
+    return file.startsWith(prefix)
+        && /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z\.db$/.test(file.slice(prefix.length));
+}
 export async function backupMemoryDb(opts = {}) {
     const dbPath = opts.dbPath ?? defaultMemoryDbPath();
     if (!dbPath || !fs.existsSync(dbPath))
@@ -38,7 +52,7 @@ export async function backupMemoryDb(opts = {}) {
         fs.mkdirSync(destDir, { recursive: true });
     }
     catch { /* */ }
-    const destPath = path.join(destDir, `memory-${fileStamp(opts.timestamp ?? Date.now())}.db`);
+    const destPath = path.join(destDir, `${snapshotPrefix(dbPath)}${fileStamp(opts.timestamp ?? Date.now())}.db`);
     // WAL-safe online backup: read-only source, consistent snapshot to destPath.
     let db;
     try {
@@ -68,7 +82,7 @@ export async function backupMemoryDb(opts = {}) {
                 const keep = typeof opts.keep === 'number' && opts.keep > 0 ? opts.keep : 7;
                 const rotatedAway = [];
                 try {
-                    const snaps = fs.readdirSync(destDir).filter(f => /^memory-.*\.db$/.test(f)).sort();
+                    const snaps = fs.readdirSync(destDir).filter(f => isSnapshotFor(f, dbPath)).sort();
                     while (snaps.length > keep) {
                         const old = snaps.shift();
                         try {
@@ -107,7 +121,7 @@ export async function backupMemoryDb(opts = {}) {
     const keep = typeof opts.keep === 'number' && opts.keep > 0 ? opts.keep : 7;
     const rotatedAway = [];
     try {
-        const snaps = fs.readdirSync(destDir).filter(f => /^memory-.*\.db$/.test(f)).sort();
+        const snaps = fs.readdirSync(destDir).filter(f => isSnapshotFor(f, dbPath)).sort();
         while (snaps.length > keep) {
             const old = snaps.shift();
             try {
@@ -136,6 +150,48 @@ export async function backupMemoryDb(opts = {}) {
     }
     return { backedUp: true, path: destPath, sizeBytes, rotatedAway, gcsUri };
 }
+/** Verify a snapshot without modifying it, including RFE1 images and WASM-only hosts. */
+async function verifiedBackupRows(file, Database) {
+    if (Database) {
+        let db;
+        try {
+            db = new Database(file, { readonly: true });
+            if (String(db.pragma('integrity_check', { simple: true })).toLowerCase() !== 'ok')
+                return null;
+            const rows = Number(db.prepare('SELECT COUNT(*) AS c FROM memory_entries').get()?.c ?? 0);
+            return rows > 0 ? rows : null;
+        }
+        catch {
+            // Native SQLite cannot open encrypted RFE1 images. Verify the decrypted
+            // bytes below; a failed native open is never evidence of a good backup.
+        }
+        finally {
+            try {
+                db?.close();
+            }
+            catch { /* best effort */ }
+        }
+    }
+    let db;
+    try {
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        db = new SQL.Database(readFileMaybeEncrypted(file, null));
+        const integrity = db.exec('PRAGMA integrity_check')[0]?.values?.[0]?.[0];
+        const rows = Number(db.exec('SELECT COUNT(*) FROM memory_entries')[0]?.values?.[0]?.[0] ?? 0);
+        return String(integrity).toLowerCase() === 'ok' && rows > 0 ? rows : null;
+    }
+    catch {
+        // No verifier, wrong key, failed authentication, or invalid SQLite image.
+        return null;
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch { /* best effort */ }
+    }
+}
 /**
  * Restore the newest integrity-ok backup over a corrupt/malformed memory DB
  * (issue #2584).
@@ -158,7 +214,7 @@ export async function restoreMemoryDbFromBackup(dbPath, opts = {}) {
     try {
         snaps = fs
             .readdirSync(destDir)
-            .filter(f => /^memory-.*\.db$/.test(f))
+            .filter(f => isSnapshotFor(f, dbPath))
             .map(f => path.join(destDir, f))
             .sort() // ISO-stamped names sort chronologically
             .reverse(); // newest first
@@ -168,39 +224,23 @@ export async function restoreMemoryDbFromBackup(dbPath, opts = {}) {
     }
     if (!snaps.length)
         return { restored: false, skipped: 'no-backups' };
-    // better-sqlite3 verifies a candidate's integrity. Absent (WASM-only host) →
-    // accept the newest non-empty snapshot, flagged rows=-1 (unverified).
+    // Prefer native verification for plaintext snapshots. sql.js verifies
+    // encrypted snapshots and provides the same checks on WASM-only hosts.
     let Database = null;
     try {
         const mod = 'better-sqlite3';
         Database = (await import(mod)).default;
     }
     catch {
-        /* verifier unavailable — trust newest non-empty */
+        /* use the sql.js verifier */
     }
     let chosen = null;
     for (const file of snaps) {
-        try {
-            if (Database) {
-                const db = new Database(file, { readonly: true });
-                const integ = String(db.pragma('integrity_check', { simple: true }) ?? '');
-                let rows = 0;
-                try {
-                    rows = db.prepare('SELECT COUNT(*) AS c FROM memory_entries').get()?.c ?? 0;
-                }
-                catch { /* no entries table — not a usable memory DB */ }
-                db.close();
-                if (integ.toLowerCase() === 'ok' && rows > 0) {
-                    chosen = { file, rows };
-                    break;
-                }
-            }
-            else if (fs.statSync(file).size > 0) {
-                chosen = { file, rows: -1 };
-                break;
-            }
+        const rows = await verifiedBackupRows(file, Database);
+        if (rows !== null) {
+            chosen = { file, rows };
+            break;
         }
-        catch { /* unreadable snapshot — try the next-older one */ }
     }
     if (!chosen)
         return { restored: false, skipped: 'no-integrity-ok-backup' };

package/v3/@claude-flow/cli/dist/src/services/policy-runtime.d.ts

@@ -17,6 +17,12 @@ export declare function issuePolicyApproval(approval: Omit<PolicyApproval, 'uses
     issuedAt?: number;
 }, projectRoot?: string, approvalIssuerVerifier?: (issuer: string) => boolean): Promise<PolicyApproval>;
 export declare function revokePolicyApproval(id: string, projectRoot?: string): Promise<boolean>;
+/**
+ * Read-only verification (#3568). It must not run inside
+ * `withPolicyTransaction`, whose own post-operation check throws a generic
+ * `policy-ledger-verification-failed` and hides which check failed. The only
+ * write is persisting an anchor established for a pre-anchor ledger.
+ */
 export declare function verifyPolicyLedger(projectRoot?: string): Promise<ReturnType<AgenticPolicyEngine['verifyLedger']>>;
 export declare function authorizeMcpTool(toolName: string, input: Record<string, unknown>, context?: Record<string, unknown>, attributes?: Readonly<{
     actionType?: string;

package/v3/@claude-flow/cli/dist/src/services/policy-runtime.js

@@ -338,9 +338,12 @@ export async function withPolicyTransaction(projectRoot, operation, options = {}
             approvalIssuerVerifier: options.approvalIssuerVerifier,
         });
         const result = await operation(engine);
-        const nextState = engine.exportState();
+        // Verify before exporting: verification establishes the ledger anchor
+        // (#3568) on state written before the anchor existed, and that anchor
+        // must be part of what is persisted.
         if (!engine.verifyLedger().valid)
             throw new Error('policy-ledger-verification-failed');
+        const nextState = engine.exportState();
         await writePolicyState(projectRoot, target.state, nextState);
         return result;
     }
@@ -393,8 +396,30 @@ export async function issuePolicyApproval(approval, projectRoot = process.cwd(),
 export async function revokePolicyApproval(id, projectRoot = process.cwd()) {
     return withPolicyTransaction(projectRoot, (engine) => engine.revokeApproval(id));
 }
+/**
+ * Read-only verification (#3568). It must not run inside
+ * `withPolicyTransaction`, whose own post-operation check throws a generic
+ * `policy-ledger-verification-failed` and hides which check failed. The only
+ * write is persisting an anchor established for a pre-anchor ledger.
+ */
 export async function verifyPolicyLedger(projectRoot = process.cwd()) {
-    return withPolicyTransaction(projectRoot, (engine) => engine.verifyLedger());
+    const target = paths(projectRoot);
+    mkdirSync(target.dir, { recursive: true, mode: 0o700 });
+    const release = await acquireLock(target.lock);
+    try {
+        const engine = AgenticPolicyEngine.fromState(loadPolicyState(projectRoot), {
+            signingKey: process.env.CLAUDE_FLOW_POLICY_SIGNING_KEY,
+            keyId: process.env.CLAUDE_FLOW_POLICY_KEY_ID,
+        });
+        const result = engine.verifyLedger();
+        if (result.anchor === 'established-now') {
+            await writePolicyState(projectRoot, target.state, engine.exportState());
+        }
+        return result;
+    }
+    finally {
+        release();
+    }
 }
 /**
  * Resolve the caller identity for `authorizeMcpTool`.

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.d.ts

@@ -124,8 +124,8 @@ export declare class WorkerDaemon extends EventEmitter {
     static isWslEnvironment(): boolean;
     static getEffectiveCpuCount(): number;
     /**
-     * Read daemon-specific config from .claude-flow/config.{json,yaml,yml}.
-     * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'.
+     * Read daemon-specific config from CLI JSON paths or .claude-flow/config.{yaml,yml}.
+     * Supports dotted and nested keys like 'daemon.resourceThresholds.maxCpuLoad'.
      * #1844: prefer JSON when both exist (existing behavior) but fall back
      * to YAML so operators using the v3 canonical YAML format aren't silently
      * ignored. The chosen path (or a parse warning) is returned rather than

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.js

@@ -10,6 +10,7 @@
  *   causal_edges (30 min interval, ADR-174; RUFLO_DAEMON_NO_DISTILL=1 / --no-distill to skip)
  * - testgaps: Test coverage analysis (20 min interval)
  */
+import { ConfigFileManager } from './config-file-manager.js';
 import { EventEmitter } from 'events';
 import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync, unlinkSync } from 'fs';
 import { cpus } from 'os';
@@ -339,8 +340,8 @@ export class WorkerDaemon extends EventEmitter {
         return cpus().length || 1;
     }
     /**
-     * Read daemon-specific config from .claude-flow/config.{json,yaml,yml}.
-     * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'.
+     * Read daemon-specific config from CLI JSON paths or .claude-flow/config.{yaml,yml}.
+     * Supports dotted and nested keys like 'daemon.resourceThresholds.maxCpuLoad'.
      * #1844: prefer JSON when both exist (existing behavior) but fall back
      * to YAML so operators using the v3 canonical YAML format aren't silently
      * ignored. The chosen path (or a parse warning) is returned rather than
@@ -352,13 +353,14 @@ export class WorkerDaemon extends EventEmitter {
      * The caller logs these once `this.config` exists.
      */
     readDaemonConfigFromFile(claudeFlowDir) {
-        const jsonPath = join(claudeFlowDir, 'config.json');
+        // Share the CLI's JSON search order, including root and explicit config files.
+        const jsonPath = new ConfigFileManager().findConfig(join(claudeFlowDir, '..'));
         const yamlPath = join(claudeFlowDir, 'config.yaml');
         const ymlPath = join(claudeFlowDir, 'config.yml');
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let raw;
         let chosenPath;
-        if (existsSync(jsonPath)) {
+        if (jsonPath) {
             try {
                 raw = JSON.parse(readFileSync(jsonPath, 'utf-8'));
                 chosenPath = jsonPath;
@@ -390,21 +392,28 @@ export class WorkerDaemon extends EventEmitter {
             return {};
         }
         try {
-            // Support both flat keys at root and nested under scopes.project
-            const cfg = raw?.scopes?.project ?? raw;
-            const rawCpuLoad = cfg['daemon.resourceThresholds.maxCpuLoad'] ?? raw['daemon.resourceThresholds.maxCpuLoad'];
-            const rawMinMem = cfg['daemon.resourceThresholds.minFreeMemoryPercent'] ?? raw['daemon.resourceThresholds.minFreeMemoryPercent'];
-            const rawMaxConcurrent = cfg['daemon.maxConcurrent'] ?? raw['daemon.maxConcurrent'];
-            const rawTimeout = cfg['daemon.workerTimeoutMs'] ?? raw['daemon.workerTimeoutMs'];
+            // The CLI writes nested objects; legacy files use dotted keys. Scoped
+            // values retain precedence, including explicit false and zero.
+            const read = (obj, key) => {
+                if (!obj)
+                    return undefined;
+                return obj[key] ?? key.split('.').reduce((value, part) => value && typeof value === 'object' && Object.hasOwn(value, part) ? value[part] : undefined, obj);
+            };
+            const get = (key) => read(raw?.scopes?.project, key) ?? read(raw, key);
+            const rawAutoStart = get('daemon.autoStart');
+            const rawCpuLoad = get('daemon.resourceThresholds.maxCpuLoad');
+            const rawMinMem = get('daemon.resourceThresholds.minFreeMemoryPercent');
+            const rawMaxConcurrent = get('daemon.maxConcurrent');
+            const rawTimeout = get('daemon.workerTimeoutMs');
             // #2356 — lifecycle limits are configured in SECONDS in config.json
             // (`daemon.ttlSecs` / `daemon.idleSecs`) for parity with the CLI flag
             // and env var; stored internally as ms. An explicit 0 disables.
-            const rawTtl = cfg['daemon.ttlSecs'] ?? raw['daemon.ttlSecs'];
-            const rawIdle = cfg['daemon.idleSecs'] ?? raw['daemon.idleSecs'];
+            const rawTtl = get('daemon.ttlSecs');
+            const rawIdle = get('daemon.idleSecs');
             // #2661 — explicit opt-in for scheduled AI workers.
-            const rawAiEnabled = cfg['daemon.aiWorkers.enabled'] ?? raw['daemon.aiWorkers.enabled'];
+            const rawAiEnabled = get('daemon.aiWorkers.enabled');
             return {
-                autoStart: typeof raw['daemon.autoStart'] === 'boolean' ? raw['daemon.autoStart'] : undefined,
+                autoStart: typeof rawAutoStart === 'boolean' ? rawAutoStart : undefined,
                 maxConcurrent: (typeof rawMaxConcurrent === 'number' && rawMaxConcurrent > 0) ? rawMaxConcurrent : undefined,
                 workerTimeoutMs: (typeof rawTimeout === 'number' && rawTimeout > 0) ? rawTimeout : undefined,
                 maxCpuLoad: (typeof rawCpuLoad === 'number' && rawCpuLoad > 0 && rawCpuLoad < 1000) ? rawCpuLoad : undefined,

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.47.1",
+  "version": "3.49.0",
   "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",
@@ -98,13 +98,13 @@
     "vitest": "^4.1.0"
   },
   "dependencies": {
-    "@claude-flow/cli-core": "3.7.0-alpha.6",
+    "@claude-flow/cli-core": "3.7.0",
     "@claude-flow/codex": "3.0.3",
-    "@claude-flow/mcp": "3.0.0-alpha.10",
-    "@claude-flow/neural": "3.0.0-alpha.10",
-    "@claude-flow/plugin-agent-federation": "1.0.0-alpha.18",
-    "@claude-flow/security": "3.0.0-alpha.14",
-    "@claude-flow/shared": "3.0.0-alpha.7",
+    "@claude-flow/mcp": "3.0.0",
+    "@claude-flow/neural": "3.0.0",
+    "@claude-flow/plugin-agent-federation": "1.0.0",
+    "@claude-flow/security": "3.0.1",
+    "@claude-flow/shared": "3.0.0",
     "@iarna/toml": "^2.2.5",
     "@noble/ed25519": "2.3.0",
     "@ruvector/rabitq-wasm": "0.1.0",
@@ -125,11 +125,11 @@
     "ws": "^8.21.0",
     "yaml": "^2.8.0",
     "zod": "^3.22.0",
-    "@claude-flow/memory": "3.0.0-alpha.26"
+    "@claude-flow/memory": "3.0.0"
   },
   "optionalDependencies": {
     "@agntcy/slim-bindings": "2.0.0-alpha.5",
-    "@claude-flow/memory": "3.0.0-alpha.26",
+    "@claude-flow/memory": "3.0.0",
     "@metaharness/darwin": "~0.10.2",
     "@metaharness/flywheel": "~0.1.10",
     "@metaharness/radio": "~0.1.0",

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/guidance",
-  "version": "3.0.0-alpha.4",
+  "version": "3.0.0",
   "description": "Guidance Control Plane - Compiles, retrieves, enforces, and evolves guidance rules for Claude Code sessions",
   "type": "module",
   "main": "./dist/index.js",
@@ -140,9 +140,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@claude-flow/hooks": "^3.0.0-alpha.7",
-    "@claude-flow/memory": "^3.0.0-alpha.2",
-    "@claude-flow/shared": "^3.0.0-alpha.1"
+    "@claude-flow/hooks": "^3.0.0",
+    "@claude-flow/memory": "^3.0.0",
+    "@claude-flow/shared": "^3.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
@@ -192,7 +192,6 @@
     "directory": "v3/@claude-flow/guidance"
   },
   "publishConfig": {
-    "access": "public",
-    "tag": "v3alpha"
+    "access": "public"
   }
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/shared",
-  "version": "3.0.0-alpha.8",
+  "version": "3.0.0",
   "type": "module",
   "description": "Shared module - common types, events, utilities, core interfaces",
   "main": "dist/index.js",
@@ -16,6 +16,10 @@
     "./resilience": "./dist/resilience/index.js",
     "./src/plugin-interface.js": "./dist/plugin-interface.js"
   },
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "scripts": {
     "test": "vitest run",
     "build": "tsc"
@@ -37,7 +41,6 @@
     "zod": "^3.22.4"
   },
   "publishConfig": {
-    "access": "public",
-    "tag": "v3alpha"
+    "access": "public"
   }
 }