claude-flow 3.32.26 → 3.32.29

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

@@ -10,6 +10,7 @@ import { runFlywheelGeneration, checkServedChampionDrift } from './harness-flywh
 import { loadFrozenHumanEval } from './harness-frozen-eval.js';
 import { proposeFlywheelCandidates, } from './flywheel-proposer.js';
 import { sha256Ref } from './flywheel-receipt.js';
+import { evaluatePolicyRequest } from './policy-runtime.js';
 /** The human-labeled ADR-081 anchor — the never-regress relevance set. */
 const ANCHOR = [
     ['how was the Opus model alias fixed', ['opus 4.8', 'opus alias', 'opus model alias', '#2232']],
@@ -31,6 +32,18 @@ export async function runFlywheelWorker(projectRoot, opts = {}) {
     try {
         if (!(opts.optInOverride ?? harnessLoopOptedIn()))
             return { ran: false, reason: 'opt-in required (RUFLO_HARNESS_LOOP=1)' };
+        const policy = await evaluatePolicyRequest({
+            identity: { id: process.env.CLAUDE_FLOW_PRINCIPAL_ID ?? 'metaharness-local', type: 'agent', roles: ['optimizer'] },
+            action: {
+                type: 'metaharness.flywheel.run',
+                resource: projectRoot,
+                environment: 'development',
+                concurrency: opts.maxConcurrency ?? 2,
+            },
+        }, projectRoot);
+        if (policy.enforcedOutcome !== 'allowed') {
+            return { ran: false, reason: `policy-${policy.enforcedOutcome}:${policy.reason}; receipt=${policy.receiptId}` };
+        }
         const neural = await import('../mcp-tools/neural-tools.js');
         const applier = await import('../config/harness-feedback-applier.js');
         const tool = neural.neuralTools.find((t) => t.name === 'neural_patterns');
@@ -64,6 +77,7 @@ export async function runFlywheelWorker(projectRoot, opts = {}) {
             maxFailureRate: 0.01,
             maxEvaluationCostMicros: 1_000_000,
         };
+        // CLI flag opts.proposer takes precedence over RUFLO_FLYWHEEL_PROPOSER.
         const proposerMode = opts.proposer
             ?? (process.env.RUFLO_FLYWHEEL_PROPOSER ?? 'auto');
         if (!['auto', 'local', 'darwin'].includes(proposerMode)) {
@@ -86,6 +100,8 @@ export async function runFlywheelWorker(projectRoot, opts = {}) {
             })),
             darwinInvoker: opts.darwinInvoker,
             allowSubstitutionPromotion: opts.allowSubstitutionPromotion,
+            maxConcurrency: Math.max(1, Math.min(opts.maxConcurrency ?? 2, 8)),
+            maxWallTimeMs: opts.evaluationTimeoutMs ?? 120_000,
         });
         const candidatePolicies = archive.paretoCandidates.map((candidate) => candidate.policy);
         if (!candidatePolicies.length)
@@ -109,6 +125,8 @@ export async function runFlywheelWorker(projectRoot, opts = {}) {
             effectiveProposer: archive.effectiveProposer,
             proposerSubstitution: archive.proposerSubstitution,
             candidatePolicies,
+            maxConcurrency: Math.max(1, Math.min(opts.maxConcurrency ?? 2, 8)),
+            evaluationTimeoutMs: opts.evaluationTimeoutMs,
         };
         return await runFlywheelTick(projectRoot, deps);
     }

package/v3/@claude-flow/cli/dist/src/services/harness-flywheel.d.ts

@@ -22,7 +22,7 @@ export interface AnchorTask {
 }
 export interface FlywheelDeps {
     getPatterns: () => HarvestPattern[] | Promise<HarvestPattern[]>;
-    search: (query: string, config: RetrievalConfig) => Promise<RankedItem[]> | RankedItem[];
+    search: (query: string, config: RetrievalConfig, signal?: AbortSignal) => Promise<RankedItem[]> | RankedItem[];
     anchorTasks: AnchorTask[];
     activeParams?: () => Partial<RetrievalConfig> | null;
     sample?: number;
@@ -38,6 +38,9 @@ export interface FlywheelDeps {
     bootstrapIterations?: number;
     /** Candidate policies supplied by an external proposer archive (ADR-322B). */
     candidatePolicies?: RetrievalConfig[];
+    /** ADR-324: hard local cap for concurrent candidate/task evaluation. */
+    maxConcurrency?: number;
+    evaluationTimeoutMs?: number;
 }
 export interface FlywheelResult {
     ran: boolean;

package/v3/@claude-flow/cli/dist/src/services/harness-flywheel.js

@@ -28,6 +28,7 @@ import { applyChampionParams } from '../config/harness-feedback-applier.js';
 import { appendLedger, bootstrapDeltaCILow } from './harness-improvement-ledger.js';
 import { createFlywheelReceipt, sha256Ref, } from './flywheel-receipt.js';
 import { readFlywheelTransactionState, registerFlywheelReceipt, } from './flywheel-transaction.js';
+import { runBoundedPool } from './bounded-worker-pool.js';
 export const DEFAULT_CONFIG = { alpha: 0.5, subjectWeight: 2.0, mmrLambda: 0.7, bodyWeight: 1.0, typePenaltyFactor: 1.0 };
 const EPS = 1e-3;
 const cfgCanon = (c) => JSON.stringify(Object.fromEntries(Object.keys(c).sort().map((k) => [k, c[k]])));
@@ -115,12 +116,32 @@ export async function evaluateFlywheelCandidate(projectRoot, deps) {
         // Precompute retrieval for baseline + all candidates over every task (async
         // I/O up front → the harness scoring stays pure/sync).
         const cache = new Map();
-        const configs = [baseline, ...candidates];
-        for (const cfg of configs) {
-            for (const t of blended.tasks) {
-                const q = t.input.q;
-                cache.set(`${t.id}::${cfgKey(cfg)}`, (await deps.search(q, cfg)) || []);
-            }
+        const configs = [...new Map([baseline, ...candidates].map((config) => [cfgKey(config), config])).values()];
+        const evalTasks = configs.flatMap((cfg) => blended.tasks.map((t) => {
+            const cacheKey = `${t.id}::${cfgKey(cfg)}`;
+            return {
+                id: cacheKey,
+                run: async (signal) => {
+                    if (signal.aborted)
+                        throw signal.reason;
+                    return (await deps.search(t.input.q, cfg, signal)) || [];
+                },
+            };
+        }));
+        const batch = await runBoundedPool(evalTasks, {
+            maxConcurrency: deps.maxConcurrency ?? 2,
+            timeoutMs: deps.evaluationTimeoutMs ?? 120_000,
+        });
+        for (const item of batch.results) {
+            if (item.status === 'fulfilled')
+                cache.set(item.id, item.value ?? []);
+        }
+        const failedEvaluations = batch.results.filter((item) => item.status !== 'fulfilled');
+        if (failedEvaluations.length > 0) {
+            return {
+                ran: false,
+                reason: `candidate evaluation incomplete (${failedEvaluations.length}/${batch.results.length}); peak concurrency ${batch.peakConcurrency}`,
+            };
         }
         const evalFn = (input, cfg) => cache.get(`${input.id}::${cfgKey(cfg)}`) ?? [];
         const gradeFn = (output, expected) => grade(output, expected);

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

@@ -0,0 +1,38 @@
+import { AgenticPolicyEngine, type BudgetLimit, type CapabilityEnvelope, type PolicyApproval, type PolicyDecision, type PolicyRequest, type PolicyRule, type PolicyState } from '@claude-flow/security';
+export declare function loadPolicyState(projectRoot?: string): PolicyState;
+export declare function autoMigratePolicyStateIfNeeded(projectRoot?: string): Promise<{
+    migrated: boolean;
+    statePath?: string;
+    mode?: PolicyState['mode'];
+}>;
+export declare function withPolicyTransaction<T>(projectRoot: string, operation: (engine: AgenticPolicyEngine) => T | Promise<T>, options?: {
+    approvalIssuerVerifier?: (issuer: string) => boolean;
+}): Promise<T>;
+export declare function evaluatePolicyRequest(request: PolicyRequest, projectRoot?: string): Promise<PolicyDecision>;
+export declare function setPolicyMode(mode: PolicyState['mode'], projectRoot?: string): Promise<void>;
+export declare function upsertPolicyRule(rule: PolicyRule, projectRoot?: string): Promise<void>;
+export declare function setPolicyBudget(limit: BudgetLimit, projectRoot?: string): Promise<void>;
+export declare function issuePolicyApproval(approval: Omit<PolicyApproval, 'uses' | 'issuedAt'> & {
+    uses?: number;
+    issuedAt?: number;
+}, projectRoot?: string, approvalIssuerVerifier?: (issuer: string) => boolean): Promise<PolicyApproval>;
+export declare function revokePolicyApproval(id: string, projectRoot?: string): Promise<boolean>;
+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;
+    network?: boolean;
+    destructive?: boolean;
+    namespaceAccess?: 'read' | 'write';
+    envelope?: CapabilityEnvelope;
+    costUsd?: number;
+    tokens?: number;
+    concurrency?: number;
+}>): Promise<PolicyDecision>;
+/** Trusted classification derived from the registered tool name, never input. */
+export declare function classifyMcpTool(toolName: string): {
+    actionType: string;
+    network: boolean;
+    destructive: boolean;
+    namespaceAccess?: 'read' | 'write';
+};
+//# sourceMappingURL=policy-runtime.d.ts.map

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

@@ -0,0 +1,340 @@
+import { AgenticPolicyEngine, createLegacyCompatibleState, } from '@claude-flow/security';
+import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { userInfo } from 'node:os';
+const POLICY_DIR = join('.claude-flow', 'policy');
+const POLICY_FILE = 'state.json';
+const LOCK_FILE = 'state.lock';
+const LOCK_STALE_MS = 30_000;
+const LOCK_WAIT_MS = 5_000;
+function paths(projectRoot) {
+    const root = resolve(projectRoot);
+    const dir = join(root, POLICY_DIR);
+    return { dir, state: join(dir, POLICY_FILE), lock: join(dir, LOCK_FILE) };
+}
+function sleep(ms) {
+    return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+async function acquireLock(lockPath) {
+    const started = Date.now();
+    while (Date.now() - started < LOCK_WAIT_MS) {
+        try {
+            const fd = openSync(lockPath, 'wx', 0o600);
+            writeFileSync(fd, JSON.stringify({ pid: process.pid, acquiredAt: Date.now() }));
+            closeSync(fd);
+            return () => {
+                try {
+                    unlinkSync(lockPath);
+                }
+                catch { /* already released */ }
+            };
+        }
+        catch {
+            try {
+                if (Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS)
+                    unlinkSync(lockPath);
+            }
+            catch { /* another process changed the lock */ }
+            await sleep(10);
+        }
+    }
+    throw new Error('policy-state-lock-timeout');
+}
+function writeJsonAtomic(file, value) {
+    mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    renameSync(temporary, file);
+}
+function trustPaths(projectRoot) {
+    const trustRoot = join(userInfo().homedir, '.config', 'ruflo', 'policy-trust');
+    const projectId = createHash('sha256').update(realpathSync(projectRoot)).digest('hex');
+    const dir = join(trustRoot, projectId);
+    return { key: join(dir, 'anchor.key'), anchor: join(dir, 'state.anchor.json') };
+}
+function trustKey(projectRoot, create) {
+    const { key } = trustPaths(projectRoot);
+    if (!existsSync(key)) {
+        if (!create)
+            return undefined;
+        mkdirSync(dirname(key), { recursive: true, mode: 0o700 });
+        writeFileSync(key, randomBytes(32), { mode: 0o600, flag: 'wx' });
+    }
+    const material = readFileSync(key);
+    if (material.length !== 32)
+        throw new Error('invalid-policy-trust-key');
+    return material;
+}
+function stateAuthentication(state, key) {
+    return createHmac('sha256', key).update(JSON.stringify(state)).digest('hex');
+}
+function verifyStateAnchor(projectRoot, state) {
+    const { anchor } = trustPaths(projectRoot);
+    if (!existsSync(anchor))
+        return;
+    if (!state)
+        throw new Error('policy-state-missing-for-anchored-project');
+    const key = trustKey(projectRoot, false);
+    if (!key)
+        throw new Error('policy-trust-key-missing');
+    const record = JSON.parse(readFileSync(anchor, 'utf8'));
+    const expected = stateAuthentication(state, key);
+    const actual = record.authentication ?? '';
+    if (!/^[a-f0-9]{64}$/.test(actual)
+        || !timingSafeEqual(Buffer.from(expected, 'hex'), Buffer.from(actual, 'hex'))) {
+        throw new Error('policy-state-authentication-failed');
+    }
+}
+function writePolicyState(projectRoot, statePath, state) {
+    const anchorPath = trustPaths(projectRoot).anchor;
+    if (state.mode === 'enforce' || existsSync(anchorPath)) {
+        const key = trustKey(projectRoot, true);
+        const anchor = {
+            version: 1,
+            projectRoot: realpathSync(projectRoot),
+            mode: state.mode,
+            authentication: stateAuthentication(state, key),
+            updatedAt: Date.now(),
+        };
+        // On first enforcement, establish the external trust record first. A
+        // crash then leaves either a valid pair or an anchored mismatch that
+        // fails closed; it can never leave enforce state silently unanchored.
+        if (!existsSync(anchorPath)) {
+            writeJsonAtomic(anchorPath, anchor);
+            writeJsonAtomic(statePath, state);
+            return;
+        }
+        writeJsonAtomic(statePath, state);
+        writeJsonAtomic(anchorPath, anchor);
+        return;
+    }
+    writeJsonAtomic(statePath, state);
+}
+function detectLegacyCapabilities(projectRoot) {
+    const candidates = [
+        '.swarm/memory.db',
+        '.claude-flow/memory.db',
+        '.claude-flow/data/memory.db',
+        'agentdb.rvf',
+        'agentdb-memory.db',
+    ];
+    const found = candidates.filter((candidate) => existsSync(join(projectRoot, candidate)));
+    const flags = [
+        process.env.CLAUDE_FLOW_STRICT_AUTH === 'true' ? 'strict-auth' : null,
+        process.env.CLAUDE_FLOW_STRICT_MEMORY === 'true' ? 'strict-memory' : null,
+    ].filter(Boolean);
+    return `pre-ADR-324; capabilities=${[...found, ...flags].join(',') || 'none-detected'}`;
+}
+function configuredPolicyMode(projectRoot) {
+    let configured;
+    for (const relative of ['.agents/config.toml', '.codex/config.toml']) {
+        const file = join(resolve(projectRoot), relative);
+        if (!existsSync(file))
+            continue;
+        const content = readFileSync(file, 'utf8');
+        const section = content.match(/(?:^|\n)\[policy\]\s*\n([\s\S]*?)(?=\n\[[^\]]+\]|\s*$)/)?.[1];
+        const mode = section?.match(/(?:^|\n)\s*mode\s*=\s*"(legacy|observe|enforce)"/)?.[1];
+        if (mode)
+            configured = mode;
+    }
+    return configured;
+}
+export function loadPolicyState(projectRoot = process.cwd()) {
+    const target = paths(projectRoot);
+    if (!existsSync(target.state)) {
+        verifyStateAnchor(projectRoot, undefined);
+        return createLegacyCompatibleState(detectLegacyCapabilities(projectRoot));
+    }
+    const parsed = JSON.parse(readFileSync(target.state, 'utf8'));
+    if (parsed.version !== 1 || !Array.isArray(parsed.rules) || !Array.isArray(parsed.receipts)) {
+        throw new Error(`unsupported-policy-state-version:${String(parsed.version)}`);
+    }
+    verifyStateAnchor(projectRoot, parsed);
+    return parsed;
+}
+export async function autoMigratePolicyStateIfNeeded(projectRoot = process.cwd()) {
+    const target = paths(projectRoot);
+    if (existsSync(target.state)) {
+        const configured = configuredPolicyMode(projectRoot);
+        const current = loadPolicyState(projectRoot);
+        if (configured && current.configuredMode !== configured) {
+            await withPolicyTransaction(projectRoot, (engine) => engine.setConfiguredMode(configured));
+        }
+        return { migrated: false, statePath: target.state, mode: loadPolicyState(projectRoot).mode };
+    }
+    // Only upgrade existing Ruflo installations. A random directory should not
+    // acquire policy state merely because `ruflo --version` ran there.
+    if (!existsSync(join(resolve(projectRoot), '.claude-flow'))
+        && !existsSync(join(resolve(projectRoot), '.swarm')))
+        return { migrated: false };
+    mkdirSync(target.dir, { recursive: true, mode: 0o700 });
+    const release = await acquireLock(target.lock);
+    try {
+        if (!existsSync(target.state)) {
+            const state = createLegacyCompatibleState(detectLegacyCapabilities(projectRoot));
+            const configured = configuredPolicyMode(projectRoot);
+            if (configured) {
+                state.mode = configured;
+                state.configuredMode = configured;
+            }
+            writePolicyState(projectRoot, target.state, state);
+        }
+    }
+    finally {
+        release();
+    }
+    return { migrated: true, statePath: target.state, mode: loadPolicyState(projectRoot).mode };
+}
+export async function withPolicyTransaction(projectRoot, operation, options = {}) {
+    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,
+            evidenceVerifier: verifyPolicyEvidence,
+            approvalIssuerVerifier: options.approvalIssuerVerifier,
+        });
+        const result = await operation(engine);
+        const nextState = engine.exportState();
+        if (!engine.verifyLedger().valid)
+            throw new Error('policy-ledger-verification-failed');
+        writePolicyState(projectRoot, target.state, nextState);
+        return result;
+    }
+    finally {
+        release();
+    }
+}
+function verifyPolicyEvidence(evidence) {
+    if (!evidence.keyId || !evidence.contentHash || !evidence.signature)
+        return false;
+    let keys;
+    try {
+        keys = JSON.parse(process.env.CLAUDE_FLOW_POLICY_EVIDENCE_KEYS ?? '{}');
+    }
+    catch {
+        return false;
+    }
+    const key = keys[evidence.keyId];
+    if (!key || key.length < 16 || !/^sha256:[a-f0-9]{64}$/i.test(evidence.contentHash))
+        return false;
+    const signedClaims = JSON.stringify({
+        id: evidence.id,
+        provenance: evidence.provenance,
+        attestor: evidence.attestor,
+        observedAt: evidence.observedAt,
+        contentHash: evidence.contentHash,
+        keyId: evidence.keyId,
+    });
+    const expected = createHmac('sha256', key).update(signedClaims).digest('hex');
+    const provided = evidence.signature.replace(/^hmac-sha256:/, '');
+    if (!/^[a-f0-9]{64}$/i.test(provided))
+        return false;
+    return timingSafeEqual(Buffer.from(expected, 'hex'), Buffer.from(provided, 'hex'));
+}
+export async function evaluatePolicyRequest(request, projectRoot = process.cwd()) {
+    return withPolicyTransaction(projectRoot, (engine) => engine.evaluate(request));
+}
+export async function setPolicyMode(mode, projectRoot = process.cwd()) {
+    return withPolicyTransaction(projectRoot, (engine) => engine.setMode(mode));
+}
+export async function upsertPolicyRule(rule, projectRoot = process.cwd()) {
+    return withPolicyTransaction(projectRoot, (engine) => engine.upsertRule(rule));
+}
+export async function setPolicyBudget(limit, projectRoot = process.cwd()) {
+    return withPolicyTransaction(projectRoot, (engine) => engine.setBudget(limit));
+}
+export async function issuePolicyApproval(approval, projectRoot = process.cwd(), approvalIssuerVerifier) {
+    return withPolicyTransaction(projectRoot, (engine) => engine.issueApproval(approval), { approvalIssuerVerifier });
+}
+export async function revokePolicyApproval(id, projectRoot = process.cwd()) {
+    return withPolicyTransaction(projectRoot, (engine) => engine.revokeApproval(id));
+}
+export async function verifyPolicyLedger(projectRoot = process.cwd()) {
+    return withPolicyTransaction(projectRoot, (engine) => engine.verifyLedger());
+}
+export async function authorizeMcpTool(toolName, input, context = {}, attributes = {}) {
+    let projectRoot = typeof context.projectRoot === 'string' ? context.projectRoot : process.cwd();
+    let processEnvelope;
+    if (process.env.CLAUDE_FLOW_CAPABILITY_ENVELOPE) {
+        try {
+            const parsed = JSON.parse(process.env.CLAUDE_FLOW_CAPABILITY_ENVELOPE);
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                throw new Error('not an object');
+            }
+            processEnvelope = parsed;
+        }
+        catch {
+            throw new Error('invalid-worker-capability-envelope');
+        }
+        // Linked git worktrees share one immutable common git directory. Derive
+        // the coordinator checkout from that directory so a worker cannot fall
+        // back to independent legacy policy state in its isolated worktree.
+        try {
+            const cwd = realpathSync(process.cwd());
+            const common = execFileSync('git', ['-C', cwd, 'rev-parse', '--path-format=absolute', '--git-common-dir'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+            projectRoot = dirname(realpathSync(common));
+        }
+        catch {
+            throw new Error('authoritative-worker-policy-root-unavailable');
+        }
+    }
+    return evaluatePolicyRequest({
+        identity: {
+            id: process.env.CLAUDE_FLOW_PRINCIPAL_ID ?? 'legacy-cli',
+            type: process.env.CLAUDE_FLOW_PRINCIPAL_ID ? 'agent' : 'legacy',
+        },
+        action: {
+            type: attributes.actionType ?? 'mcp.tool.call',
+            resource: toolName,
+            tool: toolName,
+            server: typeof context.serverId === 'string' ? context.serverId : 'ruflo',
+            namespace: typeof input.namespace === 'string' ? input.namespace : undefined,
+            environment: typeof context.environment === 'string' ? context.environment : undefined,
+            costUsd: attributes.costUsd,
+            tokens: attributes.tokens,
+            concurrency: attributes.concurrency,
+            network: attributes.network === true,
+            destructive: attributes.destructive === true,
+        },
+        context: {
+            envelope: attributes.envelope ?? processEnvelope,
+            approvalIds: Array.isArray(context.approvalIds) ? context.approvalIds.map(String) : undefined,
+            evidence: Array.isArray(context.evidence) ? context.evidence : undefined,
+            metadata: {
+                inputDigest: `sha256:${createHash('sha256').update(JSON.stringify(input)).digest('hex')}`,
+            },
+        },
+    }, projectRoot);
+}
+/** Trusted classification derived from the registered tool name, never input. */
+export function classifyMcpTool(toolName) {
+    const normalized = toolName.toLowerCase();
+    const policyAdmin = normalized.startsWith('policy_')
+        && !['policy_evaluate', 'policy_status'].includes(normalized);
+    const memoryRead = /^(?:memory|agentdb)_(?:pattern-)?(?:search|query|get|retrieve|list|status|stats)/.test(normalized);
+    const memoryWrite = /^(?:memory|agentdb)_(?:pattern-)?(?:store|insert|update|delete|clear|purge|init)/.test(normalized);
+    const terminal = /^(?:terminal_execute|bash|shell|exec)/.test(normalized);
+    const destructive = policyAdmin
+        || terminal
+        || /(delete|remove|clear|purge|revoke|promote|deploy|integrate|cleanup|terminate|stop)/.test(normalized);
+    const network = terminal
+        || /(github|browser|web_|http_|fetch|managed_agent|federation|ipfs|openrouter|provider)/.test(normalized);
+    return {
+        actionType: policyAdmin
+            ? `policy.admin.${normalized.slice('policy_'.length)}`
+            : memoryRead
+                ? 'memory.read'
+                : memoryWrite
+                    ? 'memory.write'
+                    : 'mcp.tool.call',
+        network,
+        destructive,
+        namespaceAccess: memoryRead ? 'read' : memoryWrite ? 'write' : undefined,
+    };
+}
+//# sourceMappingURL=policy-runtime.js.map

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.32.26",
+  "version": "3.32.29",
   "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",
@@ -105,24 +105,40 @@
     "@claude-flow/mcp": "3.0.0-alpha.8",
     "@claude-flow/neural": "3.0.0-alpha.9",
     "@claude-flow/shared": "3.0.0-alpha.7",
-    "@metaharness/router": "^0.3.2",
     "@noble/ed25519": "2.3.0",
     "@ruvector/rabitq-wasm": "0.1.0",
-    "metaharness": "^0.4.1",
     "semver": "7.7.3",
     "sql.js": "^1.13.0",
     "yaml": "^2.8.0"
   },
   "optionalDependencies": {
     "@claude-flow/memory": "^3.0.0-alpha.21",
-    "@claude-flow/security": "^3.0.0-alpha.12",
-    "@metaharness/darwin": "^0.8.0",
-    "@metaharness/flywheel": "^0.1.7",
+    "@claude-flow/security": "^3.0.0-alpha.14",
     "agentdb": "^3.0.0-alpha.17",
     "agentic-flow": "^3.0.0-alpha.1",
     "better-sqlite3": "^12.9.0",
     "ruvector": "^0.2.27"
   },
+  "peerDependencies": {
+    "@metaharness/darwin": "^0.8.0",
+    "@metaharness/flywheel": "^0.1.7",
+    "@metaharness/router": "^0.3.2",
+    "metaharness": "^0.4.1"
+  },
+  "peerDependenciesMeta": {
+    "@metaharness/darwin": {
+      "optional": true
+    },
+    "@metaharness/flywheel": {
+      "optional": true
+    },
+    "@metaharness/router": {
+      "optional": true
+    },
+    "metaharness": {
+      "optional": true
+    }
+  },
   "publishConfig": {
     "access": "public",
     "tag": "latest"