@claude-flow/cli 3.56.3 → 3.56.4

package/dist/src/plugins/manager.d.ts

@@ -134,10 +134,12 @@ export declare class PluginManager {
     /**
      * Upgrade a plugin to a new version
      */
-    upgrade(packageName: string, version?: string): Promise<{
+    upgrade(packageName: string, version?: string, opts?: Pick<PluginInstallOptions, 'verify' | 'trust'>): Promise<{
         success: boolean;
         error?: string;
         plugin?: InstalledPlugin;
+        decision?: TrustDecision;
+        warnings?: string[];
     }>;
     /**
      * Update plugin config

package/dist/src/plugins/manager.js

@@ -411,7 +411,7 @@ export class PluginManager {
     /**
      * Upgrade a plugin to a new version
      */
-    async upgrade(packageName, version) {
+    async upgrade(packageName, version, opts = {}) {
         if (!this.manifest) {
             await this.initialize();
         }
@@ -427,24 +427,45 @@ export class PluginManager {
             // Validate package name to prevent injection (S-3)
             validatePackageName(versionSpec);
             // Reinstall with new version (array form prevents shell injection).
-            // An install recorded with scriptsRun:false stays script-free on upgrade;
-            // legacy entries (no field) keep their pre-#3557 behaviour.
+            // #3557: the new version's lifecycle scripts run only with an explicit
+            // --trust for this upgrade. A recorded scriptsRun:true from an earlier
+            // install is not enough: it may come from registry vouching that was
+            // never verified, and the new version's scripts were never reviewed.
+            const warnings = [];
+            const scriptsRun = opts.trust === true;
             const upgradeArgs = ['install', '--prefix', this.config.pluginsDir, versionSpec];
-            if (existing.scriptsRun === false)
+            if (!scriptsRun) {
                 upgradeArgs.push('--ignore-scripts');
+                warnings.push(`Install scripts were skipped for ${packageName} (--ignore-scripts). Upgrade with --trust to run them.`);
+            }
             await runNpm(upgradeArgs, 120000);
             // Update manifest
             const installDir = path.join(this.config.pluginsDir, 'node_modules');
             const packageJsonPath = path.join(installDir, packageName, 'package.json');
-            if (fs.existsSync(packageJsonPath)) {
-                const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-                existing.version = pkg.version;
-                existing.commands = pkg['claude-flow']?.commands || existing.commands;
-                existing.hooks = pkg['claude-flow']?.hooks || existing.hooks;
+            if (!fs.existsSync(packageJsonPath)) {
+                return { success: false, error: `Upgraded package.json not found for ${packageName}` };
+            }
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            // #3557: re-run the trust policy on the NEW version's declaration, so
+            // hooks and commands withheld at install (or newly declared, or newly
+            // needing elevated permissions) are not registered without --trust.
+            const trusted = applyTrustPolicy(pkg, { verify: opts.verify, trust: opts.trust });
+            existing.version = String(pkg.version ?? existing.version);
+            existing.commands = trusted.commands;
+            existing.hooks = trusted.hooks;
+            existing.trustLevel = trusted.trustLevel;
+            existing.permissions = trusted.permissions;
+            existing.verification = opts.verify === false ? 'skipped' : 'npm-integrity';
+            existing.scriptsRun = scriptsRun;
+            if (trusted.withheld) {
+                existing.withheld = trusted.withheld;
+            }
+            else {
+                delete existing.withheld;
             }
             await this.saveManifest();
             console.log(`[PluginManager] Upgraded ${packageName} to ${existing.version}`);
-            return { success: true, plugin: existing };
+            return { success: true, plugin: existing, decision: trusted.decision, warnings };
         }
         catch (error) {
             const errorMsg = error instanceof Error ? error.message : String(error);

package/dist/src/plugins/own-install.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Directories from `startDir` upward that still belong to the package's own
+ * install: `startDir` and its ancestors, up to but excluding the first
+ * `node_modules` directory. In a source checkout (no `node_modules` between the
+ * module and the repo root) this reaches the repo root, as monorepo dev needs.
+ */
+export declare function ownInstallAncestors(startDir: string, maxDepth?: number): string[];
+/**
+ * Candidate `<ancestor>/plugins/<plugin>/<...sub>` directories inside the
+ * package's own install (see {@link ownInstallAncestors}). The `<ancestor>/../plugins`
+ * form (the sibling of a package root) is only produced when that sibling is itself
+ * still inside the own-install boundary.
+ */
+export declare function ownPluginDirs(startDir: string, plugin: string, ...sub: string[]): string[];
+//# sourceMappingURL=own-install.d.ts.map

package/dist/src/plugins/own-install.js

@@ -0,0 +1,51 @@
+/**
+ * Where the CLI may load executable plugin code from: its OWN install only.
+ *
+ * Several callers walk up from their own module location to find a bundled
+ * plugin directory (`plugins/ruflo-*`) whose scripts they then import or spawn.
+ * A project-local install lives at `<project>/node_modules/@claude-flow/cli/...`,
+ * so an unbounded walk-up leaves the package, crosses `node_modules`, and lands in
+ * `<project>` itself, where `<project>/plugins/ruflo-*` is whatever the opened
+ * repository ships. The walk must therefore stop at the `node_modules` boundary:
+ * everything above it belongs to whoever installed the package (a project, a
+ * global prefix, an npx cache), not to the package.
+ */
+import { basename, dirname, join, resolve } from 'node:path';
+/**
+ * Directories from `startDir` upward that still belong to the package's own
+ * install: `startDir` and its ancestors, up to but excluding the first
+ * `node_modules` directory. In a source checkout (no `node_modules` between the
+ * module and the repo root) this reaches the repo root, as monorepo dev needs.
+ */
+export function ownInstallAncestors(startDir, maxDepth = 8) {
+    const dirs = [];
+    let p = resolve(startDir);
+    for (let i = 0; i < maxDepth; i++) {
+        if (basename(p) === 'node_modules')
+            break;
+        dirs.push(p);
+        const parent = dirname(p);
+        if (parent === p)
+            break;
+        p = parent;
+    }
+    return dirs;
+}
+/**
+ * Candidate `<ancestor>/plugins/<plugin>/<...sub>` directories inside the
+ * package's own install (see {@link ownInstallAncestors}). The `<ancestor>/../plugins`
+ * form (the sibling of a package root) is only produced when that sibling is itself
+ * still inside the own-install boundary.
+ */
+export function ownPluginDirs(startDir, plugin, ...sub) {
+    const ancestors = ownInstallAncestors(startDir);
+    const inside = new Set(ancestors);
+    const out = [];
+    for (const p of ancestors) {
+        out.push(join(p, 'plugins', plugin, ...sub));
+        if (inside.has(dirname(p)))
+            out.push(join(p, '..', 'plugins', plugin, ...sub));
+    }
+    return out;
+}
+//# sourceMappingURL=own-install.js.map

package/dist/src/plugins/store/discovery.d.ts

@@ -38,7 +38,21 @@ export interface PluginDiscoveryResult {
      * is NOT the verified registry, and callers must say so rather than report a discovery.
      */
     demo?: boolean;
+    /**
+     * True only when the registry's signature verified against the pinned key. Entries of an
+     * unverified registry carry no registry trust: their trustLevel is reported as
+     * 'unverified', so nothing downstream can treat them as registry-vouched.
+     */
+    verified?: boolean;
+    /** Why the registry is not verified (set whenever `verified` is not true). */
+    unverifiedReason?: string;
 }
+/** Registry-level verification status, for callers that report registry data. */
+export declare function registryStatus(result: PluginDiscoveryResult): {
+    verified: boolean;
+    unverifiedReason?: string;
+    source?: string;
+};
 /**
  * Plugin Discovery Service
  */
@@ -46,10 +60,20 @@ export declare class PluginDiscoveryService {
     private config;
     private cache;
     constructor(config?: Partial<PluginStoreConfig>);
+    /**
+     * Whether an unverified registry may be replaced by the built-in list. Off under
+     * `CLAUDE_FLOW_STRICT_PLUGINS=true` (ADR-145) unless the config says otherwise.
+     */
+    private allowsUnverifiedFallback;
     /**
      * Discover plugin registry via IPNS
      */
     discoverRegistry(registryName?: string): Promise<PluginDiscoveryResult>;
+    /**
+     * The signed registry is unavailable or unverified. Outside strict mode, use the built-in
+     * list, labelled as such and stripped of registry trust; in strict mode, fail.
+     */
+    private fallbackToBuiltIn;
     /**
      * Create demo plugin registry with real npm stats
      */
@@ -63,7 +87,7 @@ export declare class PluginDiscoveryService {
      */
     private getDemoPluginsWithStats;
     /**
-     * Verify registry Ed25519 signature.
+     * Verify the registry Ed25519 signature; returns why it failed, or null when it verified.
      *
      * Mirrors the signing scheme in scripts/publish-registry.ts: the signer
      * removes registrySignature + registryPublicKey from the registry object
@@ -73,7 +97,7 @@ export declare class PluginDiscoveryService {
      * whoever served the registry and can be swapped by a compromised
      * gateway / on-path attacker.
      */
-    private verifyRegistrySignature;
+    private registrySignatureFailure;
     /**
      * List available registries
      */

package/dist/src/plugins/store/discovery.js

@@ -4,6 +4,7 @@
  * Parallel implementation to pattern store for plugins
  */
 import { resolveIPNS, fetchFromIPFS, verifyEd25519Signature } from '../../transfer/ipfs/client.js';
+import { isPlaceholderSigningKey, isStrictPluginMode } from '../trust-policy.js';
 /**
  * Fetch real npm download stats for a package
  */
@@ -84,6 +85,32 @@ export const DEFAULT_PLUGIN_STORE_CONFIG = {
     allowedPermissions: ['network', 'filesystem', 'memory', 'hooks'],
     requirePermissionPrompt: true,
 };
+/**
+ * Strip registry-asserted trust from a registry that was not verified. Its trust labels, its
+ * `official` list and its author verification are just claims made by whoever served (or
+ * hardcoded) the list.
+ */
+function withoutRegistryTrust(registry) {
+    return {
+        ...registry,
+        plugins: registry.plugins.map((p) => ({
+            ...p,
+            trustLevel: 'unverified',
+            verified: false,
+            ...(p.author ? { author: { ...p.author, verified: false } } : {}),
+        })),
+        official: [],
+        authors: (registry.authors ?? []).map((a) => ({ ...a, verified: false })),
+    };
+}
+/** Registry-level verification status, for callers that report registry data. */
+export function registryStatus(result) {
+    return {
+        verified: result.verified === true,
+        ...(result.verified === true ? {} : { unverifiedReason: result.unverifiedReason ?? 'registry not verified' }),
+        ...(result.source ? { source: result.source } : {}),
+    };
+}
 /**
  * Plugin Discovery Service
  */
@@ -93,6 +120,13 @@ export class PluginDiscoveryService {
     constructor(config = {}) {
         this.config = { ...DEFAULT_PLUGIN_STORE_CONFIG, ...config };
     }
+    /**
+     * Whether an unverified registry may be replaced by the built-in list. Off under
+     * `CLAUDE_FLOW_STRICT_PLUGINS=true` (ADR-145) unless the config says otherwise.
+     */
+    allowsUnverifiedFallback() {
+        return this.config.allowUnverifiedFallback ?? !isStrictPluginMode();
+    }
     /**
      * Discover plugin registry via IPNS
      */
@@ -112,11 +146,13 @@ export class PluginDiscoveryService {
             console.log(`[PluginDiscovery] Cache hit for ${registry.name}`);
             return {
                 success: true,
-                registry: cached.registry,
+                registry: cached.verified ? cached.registry : withoutRegistryTrust(cached.registry),
                 fromCache: true,
                 // A cached fallback is still the fallback: never relabel it as the real registry.
                 source: cached.demo ? `${registry.name} (demo)` : registry.name,
                 ...(cached.demo ? { demo: true } : {}),
+                verified: cached.verified === true,
+                ...(cached.verified ? {} : { unverifiedReason: cached.unverifiedReason ?? 'registry not verified' }),
             };
         }
         try {
@@ -132,15 +168,14 @@ export class PluginDiscoveryService {
                 // Resolve IPNS to get current CID
                 cid = await resolveIPNS(registry.ipnsName, registry.gateway);
                 if (!cid) {
-                    // Fallback to demo registry
-                    return this.createDemoRegistryAsync(registry);
+                    return this.fallbackToBuiltIn(registry, `could not resolve IPNS name ${registry.ipnsName}`);
                 }
                 console.log(`[PluginDiscovery] Resolved IPNS to CID: ${cid}`);
             }
             // Fetch registry from IPFS
             const registryData = await fetchFromIPFS(cid, registry.gateway);
             if (!registryData) {
-                return this.createDemoRegistryAsync(registry);
+                return this.fallbackToBuiltIn(registry, `could not fetch registry CID ${cid}`);
             }
             // Verify registry signature when required.
             // Fail closed on missing/invalid signature — silently warning and using
@@ -148,17 +183,35 @@ export class PluginDiscoveryService {
             // on-path attacker) swap in attacker-mapped plugin entries that the
             // installer would then load unsandboxed.
             if (this.config.requireVerification) {
-                const verified = await this.verifyRegistrySignature(registryData, registry.publicKey);
-                if (!verified) {
-                    console.warn(`[PluginDiscovery] Registry signature verification failed for ` +
-                        `${registry.name} (CID ${cid}); falling back to demo registry.`);
-                    return this.createDemoRegistryAsync(registry);
+                const failure = await this.registrySignatureFailure(registryData, registry.publicKey);
+                if (failure) {
+                    return this.fallbackToBuiltIn(registry, `${failure}, CID ${cid}`);
                 }
             }
+            else {
+                // Verification disabled by config: usable, but it vouches for nothing.
+                const unverifiedReason = 'signature verification disabled (requireVerification: false)';
+                this.cache.set(registry.ipnsName, {
+                    registry: registryData,
+                    timestamp: Date.now(),
+                    verified: false,
+                    unverifiedReason,
+                });
+                return {
+                    success: true,
+                    registry: withoutRegistryTrust(registryData),
+                    cid,
+                    source: registry.name,
+                    fromCache: false,
+                    verified: false,
+                    unverifiedReason,
+                };
+            }
             // Cache the result
             this.cache.set(registry.ipnsName, {
                 registry: registryData,
                 timestamp: Date.now(),
+                verified: true,
             });
             return {
                 success: true,
@@ -166,14 +219,43 @@ export class PluginDiscoveryService {
                 cid,
                 source: registry.name,
                 fromCache: false,
+                verified: true,
             };
         }
         catch (error) {
             console.error(`[PluginDiscovery] Failed to discover registry:`, error);
-            // Return demo registry on error
-            return this.createDemoRegistryAsync(registry);
+            return this.fallbackToBuiltIn(registry, `discovery error: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * The signed registry is unavailable or unverified. Outside strict mode, use the built-in
+     * list, labelled as such and stripped of registry trust; in strict mode, fail.
+     */
+    async fallbackToBuiltIn(registry, reason) {
+        if (!this.allowsUnverifiedFallback()) {
+            return {
+                success: false,
+                verified: false,
+                unverifiedReason: reason,
+                error: `Plugin registry ${registry.name} is not verified (${reason}). ` +
+                    'Not falling back to the built-in plugin list because CLAUDE_FLOW_STRICT_PLUGINS=true.',
+            };
+        }
+        console.warn(`[PluginDiscovery] Registry ${registry.name} is not verified (${reason}); ` +
+            'using the built-in plugin list, which is unverified and confers no registry trust.');
+        const result = await this.createDemoRegistryAsync(registry);
+        const cached = this.cache.get(registry.ipnsName);
+        if (cached) {
+            cached.verified = false;
+            cached.unverifiedReason = reason;
+        }
+        return {
+            ...result,
+            ...(result.registry ? { registry: withoutRegistryTrust(result.registry) } : {}),
+            verified: false,
+            unverifiedReason: reason,
+        };
+    }
     /**
      * Create demo plugin registry with real npm stats
      */
@@ -211,10 +293,10 @@ export class PluginDiscoveryService {
             totalPlugins: plugins.length,
             totalDownloads: plugins.reduce((sum, p) => sum + p.downloads, 0),
             totalAuthors: 1,
-            featured: ['@claude-flow/plugin-iot-cognitum', '@claude-flow/plugin-agent-federation', '@claude-flow/plugin-agentic-qe', '@claude-flow/plugin-prime-radiant', '@claude-flow/security', '@claude-flow/claims', '@claude-flow/teammate-plugin'],
-            trending: ['@claude-flow/plugin-iot-cognitum', '@claude-flow/plugin-agent-federation', '@claude-flow/plugin-agentic-qe', '@claude-flow/plugin-prime-radiant'],
-            newest: ['@claude-flow/plugin-iot-cognitum', '@claude-flow/plugin-agent-federation', '@claude-flow/plugin-agentic-qe', '@claude-flow/plugin-prime-radiant'],
-            official: ['@claude-flow/plugin-iot-cognitum', '@claude-flow/plugin-agent-federation', '@claude-flow/plugin-agentic-qe', '@claude-flow/plugin-prime-radiant', '@claude-flow/security', '@claude-flow/claims'],
+            featured: ['@claude-flow/plugin-iot-cognitum', '@claude-flow/plugin-agent-federation', '@claude-flow/plugin-prime-radiant', '@claude-flow/security', '@claude-flow/claims', '@claude-flow/teammate-plugin'],
+            trending: ['@claude-flow/plugin-iot-cognitum', '@claude-flow/plugin-agent-federation', '@claude-flow/plugin-prime-radiant'],
+            newest: ['@claude-flow/plugin-iot-cognitum', '@claude-flow/plugin-agent-federation', '@claude-flow/plugin-prime-radiant'],
+            official: ['@claude-flow/plugin-iot-cognitum', '@claude-flow/plugin-agent-federation', '@claude-flow/plugin-prime-radiant', '@claude-flow/security', '@claude-flow/claims'],
             compatibilityMatrix: [
                 { pluginId: '@claude-flow/neural', pluginVersion: '3.0.0', claudeFlowVersions: ['3.x'], tested: true },
                 { pluginId: '@claude-flow/security', pluginVersion: '3.0.0', claudeFlowVersions: ['3.x'], tested: true },
@@ -548,66 +630,6 @@ export class PluginDiscoveryService {
                 verified: true,
                 trustLevel: 'official',
             },
-            // Agentic QE - AI-powered quality engineering
-            {
-                id: '@claude-flow/plugin-agentic-qe',
-                name: '@claude-flow/plugin-agentic-qe',
-                displayName: 'Agentic Quality Engineering',
-                description: 'AI-powered quality engineering with 58 agents that write tests, find bugs, predict defects, scan security, and perform chaos engineering safely.',
-                version: '3.0.0-alpha.5',
-                cid: 'bafybeiagenticqeplugin2024',
-                size: 285000,
-                checksum: 'sha256:agenticqe2024xyz',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['ai-ml', 'devops', 'security'],
-                tags: ['testing', 'qe', 'tdd', 'security', 'chaos-engineering', 'coverage', 'defect-prediction', 'agents'],
-                keywords: ['quality', 'testing', 'agents', 'tdd', 'security'],
-                downloads: 1200,
-                rating: 4.8,
-                ratingCount: 24,
-                lastUpdated: baseTime,
-                createdAt: '2026-01-20T00:00:00Z',
-                minClaudeFlowVersion: '3.0.0',
-                dependencies: [
-                    { name: '@claude-flow/core', version: '^3.0.0' },
-                ],
-                type: 'integration',
-                hooks: [
-                    'aqe:generate-tests',
-                    'aqe:analyze-coverage',
-                    'aqe:security-scan',
-                    'aqe:predict-defects',
-                    'aqe:chaos-inject',
-                ],
-                commands: [
-                    'aqe generate-tests',
-                    'aqe tdd-cycle',
-                    'aqe security-scan',
-                    'aqe predict-defects',
-                    'aqe chaos-inject',
-                    'aqe quality-gate',
-                    'aqe visual-regression',
-                ],
-                permissions: ['filesystem', 'network', 'memory'],
-                exports: [
-                    'TestGenerator',
-                    'CoverageAnalyzer',
-                    'SecurityScanner',
-                    'DefectPredictor',
-                    'ChaosInjector',
-                    'QualityGate',
-                ],
-                verified: true,
-                trustLevel: 'official',
-                securityAudit: {
-                    auditor: 'claude-flow-security-team',
-                    auditDate: '2026-01-20T00:00:00Z',
-                    auditVersion: '3.0.0-alpha.3',
-                    passed: true,
-                    issues: [],
-                },
-            },
             // Prime Radiant - Mathematical coherence and consensus verification
             {
                 id: '@claude-flow/plugin-prime-radiant',
@@ -1093,7 +1115,6 @@ export class PluginDiscoveryService {
         const basePlugins = this.getDemoPlugins();
         // Only fetch stats for real npm packages
         const realNpmPackages = [
-            '@claude-flow/plugin-agentic-qe',
             '@claude-flow/plugin-prime-radiant',
             '@claude-flow/claims',
             '@claude-flow/security',
@@ -1158,7 +1179,7 @@ export class PluginDiscoveryService {
         });
     }
     /**
-     * Verify registry Ed25519 signature.
+     * Verify the registry Ed25519 signature; returns why it failed, or null when it verified.
      *
      * Mirrors the signing scheme in scripts/publish-registry.ts: the signer
      * removes registrySignature + registryPublicKey from the registry object
@@ -1168,9 +1189,14 @@ export class PluginDiscoveryService {
      * whoever served the registry and can be swapped by a compromised
      * gateway / on-path attacker.
      */
-    async verifyRegistrySignature(registry, expectedPublicKey) {
-        if (!registry.registrySignature || !expectedPublicKey) {
-            return false;
+    async registrySignatureFailure(registry, expectedPublicKey) {
+        // A placeholder pin (e.g. the all-zero key) can't vouch for anything, and the all-zero
+        // key accepts a forged signature under ZIP-215 verification. Never verify against it.
+        if (isPlaceholderSigningKey(expectedPublicKey)) {
+            return 'pinned registry signing key is missing or a placeholder';
+        }
+        if (!registry.registrySignature) {
+            return 'registry is unsigned';
         }
         // Object spread preserves insertion order; delete drops a key without
         // re-ordering the rest, matching the signer's view of the registry.
@@ -1178,7 +1204,8 @@ export class PluginDiscoveryService {
         delete registryToVerify.registrySignature;
         delete registryToVerify.registryPublicKey;
         const message = JSON.stringify(registryToVerify);
-        return verifyEd25519Signature(message, registry.registrySignature, expectedPublicKey);
+        const ok = await verifyEd25519Signature(message, registry.registrySignature, expectedPublicKey);
+        return ok ? null : 'registry signature does not verify against the pinned key';
     }
     /**
      * List available registries

package/dist/src/plugins/store/index.d.ts

@@ -9,7 +9,7 @@
  * - Publish with signing
  */
 export * from './types.js';
-export { PluginDiscoveryService, createPluginDiscoveryService, DEFAULT_PLUGIN_STORE_CONFIG, type PluginDiscoveryResult, } from './discovery.js';
+export { PluginDiscoveryService, createPluginDiscoveryService, DEFAULT_PLUGIN_STORE_CONFIG, registryStatus, type PluginDiscoveryResult, } from './discovery.js';
 export { searchPlugins, getPluginSearchSuggestions, getPluginTagCloud, getPluginCategoryStats, findSimilarPlugins, getFeaturedPlugins, getTrendingPlugins, getNewestPlugins, getOfficialPlugins, getPluginsByPermission, } from './search.js';
 import type { PluginRegistry, PluginEntry, PluginSearchOptions, PluginSearchResult, PluginStoreConfig } from './types.js';
 import { PluginDiscoveryService } from './discovery.js';

package/dist/src/plugins/store/index.js

@@ -11,7 +11,7 @@
 // Re-export types
 export * from './types.js';
 // Re-export discovery
-export { PluginDiscoveryService, createPluginDiscoveryService, DEFAULT_PLUGIN_STORE_CONFIG, } from './discovery.js';
+export { PluginDiscoveryService, createPluginDiscoveryService, DEFAULT_PLUGIN_STORE_CONFIG, registryStatus, } from './discovery.js';
 // Re-export search
 export { searchPlugins, getPluginSearchSuggestions, getPluginTagCloud, getPluginCategoryStats, findSimilarPlugins, getFeaturedPlugins, getTrendingPlugins, getNewestPlugins, getOfficialPlugins, getPluginsByPermission, } from './search.js';
 import { PluginDiscoveryService } from './discovery.js';

package/dist/src/plugins/store/types.d.ts

@@ -249,6 +249,11 @@ export interface PluginStoreConfig {
     cacheDir: string;
     cacheExpiry: number;
     requireVerification: boolean;
+    /**
+     * Fall back to the built-in (unverified) plugin list when the signed registry can't be
+     * verified. Defaults to true, or false under `CLAUDE_FLOW_STRICT_PLUGINS=true`.
+     */
+    allowUnverifiedFallback?: boolean;
     requireSecurityAudit: boolean;
     minTrustLevel: TrustLevel;
     trustedAuthors: string[];

package/dist/src/plugins/trust-policy.d.ts

@@ -58,4 +58,17 @@ export declare function shouldRunInstallScripts(opts: {
 /** A registry checksum we can actually verify: `sha256:` + 64 hex chars. */
 export declare function parseSha256Checksum(checksum: unknown): string | null;
 export declare function sha256Hex(data: Buffer): string;
+/**
+ * Whether `CLAUDE_FLOW_STRICT_PLUGINS=true` (ADR-145): an unverified plugin
+ * registry is then an error, not a warning.
+ */
+export declare function isStrictPluginMode(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * A signing key that cannot vouch for anything: missing, not 32 bytes of hex,
+ * not a curve point, or a small-order point — which includes the all-zero
+ * placeholder in `trust/trust-anchors.json`. Signatures can be forged against
+ * small-order keys under ZIP-215 verification, so such a key must never be
+ * handed to a verifier.
+ */
+export declare function isPlaceholderSigningKey(key: unknown): boolean;
 //# sourceMappingURL=trust-policy.d.ts.map

package/dist/src/plugins/trust-policy.js

@@ -6,6 +6,7 @@
  * These pure helpers decide what an install may register.
  */
 import { createHash } from 'crypto';
+import { ExtendedPoint } from '@noble/ed25519';
 /**
  * Permissions a plugin may declare and still have its hooks and commands
  * registered without `--trust`. Anything else (filesystem, network, shell,
@@ -81,4 +82,32 @@ export function parseSha256Checksum(checksum) {
 export function sha256Hex(data) {
     return createHash('sha256').update(data).digest('hex');
 }
+/**
+ * Whether `CLAUDE_FLOW_STRICT_PLUGINS=true` (ADR-145): an unverified plugin
+ * registry is then an error, not a warning.
+ */
+export function isStrictPluginMode(env = process.env) {
+    return (env.CLAUDE_FLOW_STRICT_PLUGINS ?? '').trim().toLowerCase() === 'true';
+}
+/**
+ * A signing key that cannot vouch for anything: missing, not 32 bytes of hex,
+ * not a curve point, or a small-order point — which includes the all-zero
+ * placeholder in `trust/trust-anchors.json`. Signatures can be forged against
+ * small-order keys under ZIP-215 verification, so such a key must never be
+ * handed to a verifier.
+ */
+export function isPlaceholderSigningKey(key) {
+    if (typeof key !== 'string')
+        return true;
+    const hex = key.trim().replace(/^ed25519:/i, '');
+    if (!/^[0-9a-f]{64}$/i.test(hex))
+        return true;
+    try {
+        // zip215=true decodes every encoding a lenient verifier would accept.
+        return ExtendedPoint.fromHex(hex, true).isSmallOrder();
+    }
+    catch {
+        return true;
+    }
+}
 //# sourceMappingURL=trust-policy.js.map

package/dist/src/ruvector/graph-analyzer.js

@@ -494,6 +494,17 @@ function fallbackLouvain(nodes, edges) {
     let improved = true;
     const maxIterations = 10;
     let iteration = 0;
+    // Community total weighted degree. Maintained incrementally (±nodeDegree on
+    // each accepted move) rather than rebuilt from a full scan of `community`
+    // inside the per-node loop below — the rebuild was O(n) per node (O(n^2) per
+    // pass), matching neither the reference Louvain implementations (networkx's
+    // `Stot`, python-louvain's `status.degrees`, both updated in O(1) per move)
+    // nor the algorithm's own linear-on-sparse-data design intent.
+    const communityTotal = new Map();
+    for (const node of nodes) {
+        const c = community.get(node);
+        communityTotal.set(c, (communityTotal.get(c) || 0) + (degree.get(node) || 0));
+    }
     while (improved && iteration < maxIterations) {
         improved = false;
         iteration++;
@@ -507,17 +518,16 @@ function fallbackLouvain(nodes, edges) {
                 const neighborCommunity = community.get(neighbor);
                 communityWeights.set(neighborCommunity, (communityWeights.get(neighborCommunity) || 0) + weight);
             }
-            // Calculate community totals
-            const communityTotal = new Map();
-            for (const [n, c] of Array.from(community.entries())) {
-                communityTotal.set(c, (communityTotal.get(c) || 0) + (degree.get(n) || 0));
-            }
             let bestCommunity = currentCommunity;
             let bestGain = 0;
             for (const [targetCommunity, edgeWeight] of Array.from(communityWeights.entries())) {
                 if (targetCommunity === currentCommunity)
                     continue;
-                // Calculate modularity gain
+                // Calculate modularity gain. `currentTotal` still includes this
+                // node's own degree (not yet removed) — the `+ nodeDegree` term
+                // below backs it out, so `communityTotal` must stay un-patched for
+                // `node` until after the move decision, matching the pre-existing
+                // formula this complexity fix leaves unchanged.
                 const currentTotal = communityTotal.get(currentCommunity) || 0;
                 const targetTotal = communityTotal.get(targetCommunity) || 0;
                 const currentEdges = communityWeights.get(currentCommunity) || 0;
@@ -530,6 +540,8 @@ function fallbackLouvain(nodes, edges) {
             }
             if (bestCommunity !== currentCommunity) {
                 community.set(node, bestCommunity);
+                communityTotal.set(currentCommunity, (communityTotal.get(currentCommunity) || 0) - nodeDegree);
+                communityTotal.set(bestCommunity, (communityTotal.get(bestCommunity) || 0) + nodeDegree);
                 improved = true;
             }
         }