@claude-flow/cli 3.32.34 → 3.32.35

package/dist/src/services/harness-project-anchor.js

@@ -0,0 +1,129 @@
+/**
+ * Project-local, hash-pinned flywheel anchors (#2840).
+ *
+ * Downstream repositories must be evaluated against their own labelled
+ * retrieval tasks. Silently using Ruflo's development-history benchmark makes
+ * the objective flat and indistinguishable from "already optimal", so foreign
+ * projects fail closed unless they supply a pinned anchor manifest.
+ */
+import { existsSync, readFileSync, realpathSync, } from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve, sep, } from 'node:path';
+import { FROZEN_HUMAN_EVAL_HASH, loadFrozenHumanEval, humanEvalHash, } from './harness-frozen-eval.js';
+export const PROJECT_ANCHOR_SCHEMA = 'ruflo.flywheel-anchor/v1';
+export const PROJECT_ANCHOR_MANIFEST_SCHEMA = 'ruflo.flywheel-anchor-manifest/v1';
+export const DEFAULT_PROJECT_ANCHOR_MANIFEST = join('.claude', 'eval', 'flywheel-anchor.manifest.json');
+function normalizeHash(value) {
+    const trimmed = value.trim().toLowerCase();
+    return trimmed.startsWith('sha256:') ? trimmed : `sha256:${trimmed}`;
+}
+function containedPath(projectRoot, requested) {
+    const root = realpathSync(resolve(projectRoot));
+    const absolute = isAbsolute(requested) ? resolve(requested) : resolve(root, requested);
+    const lexical = relative(root, absolute);
+    if (lexical === '..' || lexical.startsWith(`..${sep}`) || isAbsolute(lexical)) {
+        throw new Error('flywheel anchor path must stay inside project root');
+    }
+    const actual = realpathSync(absolute);
+    const physical = relative(root, actual);
+    if (physical === '..' || physical.startsWith(`..${sep}`) || isAbsolute(physical)) {
+        throw new Error('flywheel anchor symlink escapes project root');
+    }
+    return actual;
+}
+function parseTasks(path) {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (parsed.schemaVersion && parsed.schemaVersion !== PROJECT_ANCHOR_SCHEMA) {
+        throw new Error(`unsupported flywheel anchor schema: ${parsed.schemaVersion}`);
+    }
+    if (!Array.isArray(parsed.tasks) || parsed.tasks.length < 4) {
+        throw new Error('project flywheel anchor requires at least 4 labelled tasks');
+    }
+    const ids = new Set();
+    for (const [index, task] of parsed.tasks.entries()) {
+        if (!task || typeof task.id !== 'string' || !/^[A-Za-z0-9._-]{1,128}$/.test(task.id)) {
+            throw new Error(`invalid anchor task id at index ${index}`);
+        }
+        if (ids.has(task.id))
+            throw new Error(`duplicate anchor task id: ${task.id}`);
+        ids.add(task.id);
+        if (typeof task.q !== 'string' || task.q.trim().length === 0) {
+            throw new Error(`anchor task ${task.id} has no query`);
+        }
+        if (!Array.isArray(task.labels) || task.labels.length === 0 || task.labels.some((label) => typeof label !== 'string' || !label.trim())) {
+            throw new Error(`anchor task ${task.id} requires non-empty string labels`);
+        }
+    }
+    return { version: parsed.version ?? 'project-anchor-v1', tasks: parsed.tasks };
+}
+function toSelection(path, expectedHash) {
+    const parsed = parseTasks(path);
+    const actualHash = humanEvalHash(parsed.tasks);
+    if (actualHash !== normalizeHash(expectedHash)) {
+        throw new Error(`project flywheel anchor hash mismatch (got ${actualHash}, pinned ${normalizeHash(expectedHash)})`);
+    }
+    return {
+        version: parsed.version,
+        anchorRef: actualHash,
+        source: 'project',
+        path,
+        tasks: parsed.tasks.map((task) => ({
+            id: task.id,
+            input: { id: task.id, q: task.q },
+            expected: task.labels,
+        })),
+    };
+}
+function isRufloRepository(projectRoot) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(projectRoot, 'package.json'), 'utf8'));
+        const repository = typeof pkg.repository === 'string' ? pkg.repository : pkg.repository?.url;
+        return ['claude-flow', 'ruflo', '@claude-flow/cli'].includes(pkg.name ?? '')
+            && /github\.com[/:]ruvnet\/(?:ruflo|claude-flow)(?:\.git)?$/i.test(repository ?? '');
+    }
+    catch {
+        return false;
+    }
+}
+export function loadEffectiveFlywheelAnchor(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    if (!!options.anchorPath !== !!options.anchorHash) {
+        throw new Error('anchorPath and anchorHash must be supplied together');
+    }
+    if (options.anchorPath && options.anchorHash) {
+        return toSelection(containedPath(root, options.anchorPath), options.anchorHash);
+    }
+    const manifestCandidate = options.manifestPath ?? DEFAULT_PROJECT_ANCHOR_MANIFEST;
+    const manifestPath = isAbsolute(manifestCandidate)
+        ? manifestCandidate
+        : resolve(root, manifestCandidate);
+    if (existsSync(manifestPath)) {
+        const containedManifest = containedPath(root, manifestPath);
+        const manifest = JSON.parse(readFileSync(containedManifest, 'utf8'));
+        if (manifest.schemaVersion !== PROJECT_ANCHOR_MANIFEST_SCHEMA) {
+            throw new Error(`unsupported flywheel anchor manifest schema: ${manifest.schemaVersion}`);
+        }
+        if (typeof manifest.path !== 'string' || typeof manifest.sha256 !== 'string') {
+            throw new Error('flywheel anchor manifest requires path and sha256');
+        }
+        // Manifest-relative paths are easier to relocate while remaining
+        // repository-contained; project-relative paths remain supported.
+        const manifestRelative = resolve(dirname(containedManifest), manifest.path);
+        const requested = existsSync(manifestRelative) ? manifestRelative : resolve(root, manifest.path);
+        return toSelection(containedPath(root, requested), manifest.sha256);
+    }
+    if (isRufloRepository(root) || process.env.RUFLO_FLYWHEEL_ALLOW_BUILTIN_ANCHOR === '1') {
+        const frozen = loadFrozenHumanEval();
+        return {
+            version: frozen.version,
+            anchorRef: FROZEN_HUMAN_EVAL_HASH,
+            source: 'ruflo-built-in',
+            tasks: frozen.tasks.map((task) => ({
+                id: task.id,
+                input: { id: task.id, q: task.q },
+                expected: task.labels,
+            })),
+        };
+    }
+    throw new Error(`project-local flywheel anchor required; create ${DEFAULT_PROJECT_ANCHOR_MANIFEST} or pass anchorPath + anchorHash`);
+}
+//# sourceMappingURL=harness-project-anchor.js.map

package/dist/src/services/learned-routing.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Discriminative routing-pattern learner (#2839).
+ *
+ * Outcomes are labelled by the agent that actually completed the task. The
+ * previous implementation collapsed every successful task for an agent into
+ * one insertion-ordered Set and kept the first 50 words forever. This module
+ * ranks terms by within-agent support, cross-agent rarity, outcome quality,
+ * and discriminative share. Generic terms therefore lose to stable,
+ * agent-specific evidence, and later outcomes can replace earlier noise.
+ */
+export interface LearnedRoutingOutcome {
+    task: string;
+    agent: string;
+    success: boolean;
+    quality: number;
+    keywords: string[];
+    timestamp: string;
+}
+export interface LearnedRoutingPattern {
+    keywords: string[];
+    agents: string[];
+    source: 'learned';
+    support: number;
+    reliability: number;
+}
+export interface LearnedRoutingOptions {
+    maxKeywords?: number;
+    minAgentOutcomes?: number;
+    minKeywordSupport?: number;
+    minOutcomeQuality?: number;
+    minDiscriminativeShare?: number;
+}
+export declare function buildLearnedRoutingPatterns(outcomes: LearnedRoutingOutcome[], options?: LearnedRoutingOptions): Record<string, LearnedRoutingPattern>;
+//# sourceMappingURL=learned-routing.d.ts.map

package/dist/src/services/learned-routing.js

@@ -0,0 +1,85 @@
+/**
+ * Discriminative routing-pattern learner (#2839).
+ *
+ * Outcomes are labelled by the agent that actually completed the task. The
+ * previous implementation collapsed every successful task for an agent into
+ * one insertion-ordered Set and kept the first 50 words forever. This module
+ * ranks terms by within-agent support, cross-agent rarity, outcome quality,
+ * and discriminative share. Generic terms therefore lose to stable,
+ * agent-specific evidence, and later outcomes can replace earlier noise.
+ */
+const finiteUnit = (value) => Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0;
+export function buildLearnedRoutingPatterns(outcomes, options = {}) {
+    const maxKeywords = Math.max(1, Math.min(options.maxKeywords ?? 50, 100));
+    const minAgentOutcomes = Math.max(1, options.minAgentOutcomes ?? 2);
+    const minKeywordSupport = Math.max(1, options.minKeywordSupport ?? 2);
+    const minOutcomeQuality = finiteUnit(options.minOutcomeQuality ?? 0.65);
+    const minDiscriminativeShare = finiteUnit(options.minDiscriminativeShare ?? 0.6);
+    const accepted = outcomes.filter((outcome) => outcome.success
+        && typeof outcome.agent === 'string'
+        && outcome.agent.length > 0
+        && finiteUnit(outcome.quality) >= minOutcomeQuality
+        && Array.isArray(outcome.keywords)
+        && outcome.keywords.length > 0);
+    const agents = [...new Set(accepted.map((outcome) => outcome.agent))].sort();
+    if (agents.length === 0)
+        return {};
+    const agentOutcomes = new Map();
+    const evidence = new Map();
+    const globalSupport = new Map();
+    const agentDocumentFrequency = new Map();
+    for (const agent of agents) {
+        const rows = accepted.filter((outcome) => outcome.agent === agent);
+        agentOutcomes.set(agent, rows);
+        const perKeyword = new Map();
+        for (const row of rows) {
+            const unique = new Set(row.keywords.map((keyword) => keyword.trim().toLowerCase()).filter(Boolean));
+            for (const keyword of unique) {
+                const current = perKeyword.get(keyword) ?? { support: 0, qualityTotal: 0 };
+                current.support++;
+                current.qualityTotal += finiteUnit(row.quality);
+                perKeyword.set(keyword, current);
+                globalSupport.set(keyword, (globalSupport.get(keyword) ?? 0) + 1);
+            }
+        }
+        evidence.set(agent, perKeyword);
+        for (const keyword of perKeyword.keys()) {
+            agentDocumentFrequency.set(keyword, (agentDocumentFrequency.get(keyword) ?? 0) + 1);
+        }
+    }
+    const patterns = {};
+    for (const agent of agents) {
+        const rows = agentOutcomes.get(agent) ?? [];
+        if (rows.length < minAgentOutcomes)
+            continue;
+        const ranked = [...(evidence.get(agent) ?? new Map()).entries()]
+            .filter(([, item]) => item.support >= minKeywordSupport)
+            .map(([keyword, item]) => {
+            const totalSupport = globalSupport.get(keyword) ?? item.support;
+            const discriminativeShare = item.support / Math.max(1, totalSupport);
+            const documentFrequency = agentDocumentFrequency.get(keyword) ?? 1;
+            const idf = Math.log(1 + agents.length / documentFrequency);
+            const withinAgentSupport = item.support / rows.length;
+            const meanQuality = item.qualityTotal / item.support;
+            return {
+                keyword,
+                discriminativeShare,
+                score: withinAgentSupport * meanQuality * idf * discriminativeShare,
+            };
+        })
+            .filter((item) => item.discriminativeShare >= minDiscriminativeShare)
+            .sort((a, b) => b.score - a.score || a.keyword.localeCompare(b.keyword))
+            .slice(0, maxKeywords);
+        if (ranked.length === 0)
+            continue;
+        patterns[`learned-${agent}`] = {
+            keywords: ranked.map((item) => item.keyword),
+            agents: [agent],
+            source: 'learned',
+            support: rows.length,
+            reliability: rows.reduce((sum, row) => sum + finiteUnit(row.quality), 0) / rows.length,
+        };
+    }
+    return patterns;
+}
+//# sourceMappingURL=learned-routing.js.map

package/dist/src/services/pheromone-adaptive.d.ts

@@ -0,0 +1,71 @@
+/**
+ * ADR-330 — Adaptive Pheromone Swarm Consensus.
+ *
+ * This is a scheduling eligibility layer, not an agent terminator. It learns a
+ * bounded EMA signal per agent, compares agents against role-local baselines,
+ * and may suspend them from future dispatch. Coordinators and other protected
+ * roles remain eligible, quorum is never crossed, pruning per round is capped,
+ * and exploration periodically reactivates a suspended agent.
+ */
+export declare const APSC_SCHEMA = "ruflo.apsc-state/v1";
+export interface ApscConfig {
+    alpha: number;
+    beta: number;
+    gamma: number;
+    emaDecay: number;
+    pruningFactor: number;
+    reactivationThreshold: number;
+    minActiveAgents: number;
+    minSamples: number;
+    maxSuspendFraction: number;
+    explorationRate: number;
+    dryRun: boolean;
+    protectedRoles: string[];
+}
+export interface ApscAgentState {
+    agentId: string;
+    role: string;
+    status: 'active' | 'suspended';
+    samples: number;
+    rawScore: number;
+    normalizedScore: number;
+    emaScore: number;
+    lastUpdatedAt: string;
+    lastDecision?: 'keep' | 'would-suspend' | 'suspend' | 'reactivate' | 'explore';
+}
+export interface ApscState {
+    schemaVersion: typeof APSC_SCHEMA;
+    config: ApscConfig;
+    round: number;
+    threshold: number;
+    roleBaselines: Record<string, number>;
+    agents: Record<string, ApscAgentState>;
+}
+export interface ApscSignal {
+    agentId: string;
+    role: string;
+    taskSuccess: number;
+    normalizedLatency: number;
+    consensusAlignment: number;
+}
+export interface ApscDecision {
+    agentId: string;
+    score: number;
+    normalizedScore: number;
+    emaScore: number;
+    threshold: number;
+    action: 'keep' | 'would-suspend' | 'suspend' | 'reactivate' | 'explore';
+    applied: boolean;
+    reason: string;
+    activeAgents: number;
+    suspendedAgents: number;
+}
+export declare const DEFAULT_APSC_CONFIG: ApscConfig;
+export declare function normalizeApscConfig(input?: Partial<ApscConfig>): ApscConfig;
+export declare function createApscState(config?: Partial<ApscConfig>): ApscState;
+export declare function recordApscSignal(current: ApscState, signal: ApscSignal, now?: number): {
+    state: ApscState;
+    decision: ApscDecision;
+};
+export declare function isApscAgentEligible(state: ApscState | undefined, agentId: string): boolean;
+//# sourceMappingURL=pheromone-adaptive.d.ts.map

package/dist/src/services/pheromone-adaptive.js

@@ -0,0 +1,214 @@
+/**
+ * ADR-330 — Adaptive Pheromone Swarm Consensus.
+ *
+ * This is a scheduling eligibility layer, not an agent terminator. It learns a
+ * bounded EMA signal per agent, compares agents against role-local baselines,
+ * and may suspend them from future dispatch. Coordinators and other protected
+ * roles remain eligible, quorum is never crossed, pruning per round is capped,
+ * and exploration periodically reactivates a suspended agent.
+ */
+export const APSC_SCHEMA = 'ruflo.apsc-state/v1';
+export const DEFAULT_APSC_CONFIG = {
+    alpha: 0.5,
+    beta: 0.2,
+    gamma: 0.3,
+    emaDecay: 0.85,
+    pruningFactor: 0.6,
+    reactivationThreshold: 0.75,
+    minActiveAgents: 3,
+    minSamples: 3,
+    maxSuspendFraction: 0.25,
+    explorationRate: 0.1,
+    dryRun: true,
+    protectedRoles: ['coordinator', 'queen', 'security-architect', 'security-auditor'],
+};
+const unit = (value, field) => {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new Error(`${field} must be a finite number in [0,1]`);
+    }
+    return value;
+};
+export function normalizeApscConfig(input = {}) {
+    const alpha = unit(input.alpha ?? DEFAULT_APSC_CONFIG.alpha, 'alpha');
+    const beta = unit(input.beta ?? DEFAULT_APSC_CONFIG.beta, 'beta');
+    const gamma = unit(input.gamma ?? DEFAULT_APSC_CONFIG.gamma, 'gamma');
+    const weight = alpha + beta + gamma;
+    if (weight <= 0)
+        throw new Error('at least one APSC score weight must be positive');
+    const minActiveAgents = input.minActiveAgents ?? DEFAULT_APSC_CONFIG.minActiveAgents;
+    const minSamples = input.minSamples ?? DEFAULT_APSC_CONFIG.minSamples;
+    if (!Number.isInteger(minActiveAgents) || minActiveAgents < 1 || minActiveAgents > 50) {
+        throw new Error('minActiveAgents must be an integer in [1,50]');
+    }
+    if (!Number.isInteger(minSamples) || minSamples < 1 || minSamples > 1000) {
+        throw new Error('minSamples must be an integer in [1,1000]');
+    }
+    const protectedRoles = [...new Set((input.protectedRoles ?? DEFAULT_APSC_CONFIG.protectedRoles)
+            .map((role) => role.trim().toLowerCase())
+            .filter(Boolean))].sort();
+    return {
+        alpha: alpha / weight,
+        beta: beta / weight,
+        gamma: gamma / weight,
+        emaDecay: unit(input.emaDecay ?? DEFAULT_APSC_CONFIG.emaDecay, 'emaDecay'),
+        pruningFactor: unit(input.pruningFactor ?? DEFAULT_APSC_CONFIG.pruningFactor, 'pruningFactor'),
+        reactivationThreshold: unit(input.reactivationThreshold ?? DEFAULT_APSC_CONFIG.reactivationThreshold, 'reactivationThreshold'),
+        minActiveAgents,
+        minSamples,
+        maxSuspendFraction: unit(input.maxSuspendFraction ?? DEFAULT_APSC_CONFIG.maxSuspendFraction, 'maxSuspendFraction'),
+        explorationRate: unit(input.explorationRate ?? DEFAULT_APSC_CONFIG.explorationRate, 'explorationRate'),
+        dryRun: input.dryRun ?? DEFAULT_APSC_CONFIG.dryRun,
+        protectedRoles,
+    };
+}
+export function createApscState(config = {}) {
+    return {
+        schemaVersion: APSC_SCHEMA,
+        config: normalizeApscConfig(config),
+        round: 0,
+        threshold: 0.5,
+        roleBaselines: {},
+        agents: {},
+    };
+}
+function counts(state) {
+    const values = Object.values(state.agents);
+    return {
+        activeAgents: values.filter((agent) => agent.status === 'active').length,
+        suspendedAgents: values.filter((agent) => agent.status === 'suspended').length,
+    };
+}
+function protectedRole(state, role) {
+    return state.config.protectedRoles.includes(role.toLowerCase());
+}
+export function recordApscSignal(current, signal, now = Date.now()) {
+    if (!/^[A-Za-z0-9._:-]{1,160}$/.test(signal.agentId))
+        throw new Error('invalid APSC agentId');
+    if (!/^[A-Za-z0-9._:-]{1,100}$/.test(signal.role))
+        throw new Error('invalid APSC role');
+    const config = normalizeApscConfig(current.config);
+    const state = {
+        ...current,
+        config,
+        round: current.round + 1,
+        roleBaselines: { ...current.roleBaselines },
+        agents: Object.fromEntries(Object.entries(current.agents).map(([id, agent]) => [id, { ...agent }])),
+    };
+    const success = unit(signal.taskSuccess, 'taskSuccess');
+    const latency = unit(signal.normalizedLatency, 'normalizedLatency');
+    const alignment = unit(signal.consensusAlignment, 'consensusAlignment');
+    const rawScore = config.alpha * success + config.beta * (1 - latency) + config.gamma * alignment;
+    const role = signal.role.toLowerCase();
+    // Compare against peers in the same role, excluding the current agent.
+    // Letting an agent update its own baseline before normalization caused a
+    // persistently weak agent to redefine "normal" downward and reactivate
+    // without any recovery.
+    const rolePeers = Object.values(state.agents)
+        .filter((item) => item.agentId !== signal.agentId && item.role === role && item.samples > 0);
+    const peerMean = rolePeers.length
+        ? rolePeers.reduce((sum, item) => sum + item.rawScore, 0) / rolePeers.length
+        : undefined;
+    const priorRoleBaseline = peerMean ?? state.roleBaselines[role] ?? rawScore;
+    // A common absolute scale unfairly prunes coordinators/specialists whose
+    // observable task signal differs by role. Center each score on its role EMA.
+    const normalizedScore = Math.max(0, Math.min(1, 0.5 + rawScore - priorRoleBaseline));
+    const previous = state.agents[signal.agentId];
+    const agent = {
+        agentId: signal.agentId,
+        role,
+        status: previous?.status ?? 'active',
+        samples: (previous?.samples ?? 0) + 1,
+        rawScore,
+        normalizedScore,
+        emaScore: previous
+            ? config.emaDecay * previous.emaScore + (1 - config.emaDecay) * normalizedScore
+            : normalizedScore,
+        lastUpdatedAt: new Date(now).toISOString(),
+        lastDecision: 'keep',
+    };
+    state.agents[signal.agentId] = agent;
+    const allRoleAgents = Object.values(state.agents).filter((item) => item.role === role);
+    const observedRoleMean = allRoleAgents.reduce((sum, item) => sum + item.rawScore, 0) / allRoleAgents.length;
+    state.roleBaselines[role] = config.emaDecay * priorRoleBaseline + (1 - config.emaDecay) * observedRoleMean;
+    const mature = Object.values(state.agents).filter((item) => item.samples >= config.minSamples);
+    const observedMean = mature.length
+        ? mature.reduce((sum, item) => sum + item.emaScore, 0) / mature.length
+        : state.threshold;
+    state.threshold = config.emaDecay * state.threshold + (1 - config.emaDecay) * observedMean;
+    let action = 'keep';
+    let applied = false;
+    let reason = agent.samples < config.minSamples
+        ? `warm-up ${agent.samples}/${config.minSamples}`
+        : 'within adaptive envelope';
+    if (agent.status === 'suspended' && agent.emaScore >= state.threshold * config.reactivationThreshold) {
+        action = 'reactivate';
+        reason = 'score recovered above reactivation threshold';
+        if (!config.dryRun) {
+            agent.status = 'active';
+            applied = true;
+        }
+    }
+    else if (agent.status === 'active'
+        && agent.samples >= config.minSamples
+        && !protectedRole(state, agent.role)
+        && agent.emaScore < state.threshold * config.pruningFactor) {
+        const before = counts(state);
+        const maxThisRound = Math.floor(before.activeAgents * config.maxSuspendFraction);
+        const quorumCapacity = Math.max(0, before.activeAgents - config.minActiveAgents);
+        if (maxThisRound < 1 || quorumCapacity < 1) {
+            reason = 'safety floor prevents suspension';
+        }
+        else {
+            action = config.dryRun ? 'would-suspend' : 'suspend';
+            reason = 'score below adaptive pruning threshold';
+            if (!config.dryRun) {
+                agent.status = 'suspended';
+                applied = true;
+            }
+        }
+    }
+    else if (protectedRole(state, agent.role)) {
+        reason = 'protected role remains eligible';
+    }
+    // Deterministic exploration: at a bounded cadence, reactivate the stalest
+    // suspended agent so a transient failure cannot permanently exclude it.
+    if (!config.dryRun && config.explorationRate > 0) {
+        const cadence = Math.max(1, Math.round(1 / config.explorationRate));
+        if (state.round % cadence === 0) {
+            const explorer = Object.values(state.agents)
+                .filter((item) => item.status === 'suspended')
+                .sort((a, b) => a.lastUpdatedAt.localeCompare(b.lastUpdatedAt) || a.agentId.localeCompare(b.agentId))[0];
+            if (explorer) {
+                explorer.status = 'active';
+                explorer.lastDecision = 'explore';
+                if (explorer.agentId === agent.agentId) {
+                    action = 'explore';
+                    applied = true;
+                    reason = 'bounded exploration reactivation';
+                }
+            }
+        }
+    }
+    agent.lastDecision = action;
+    const after = counts(state);
+    return {
+        state,
+        decision: {
+            agentId: agent.agentId,
+            score: rawScore,
+            normalizedScore,
+            emaScore: agent.emaScore,
+            threshold: state.threshold,
+            action,
+            applied,
+            reason,
+            ...after,
+        },
+    };
+}
+export function isApscAgentEligible(state, agentId) {
+    if (!state || state.config.dryRun)
+        return true;
+    return state.agents[agentId]?.status !== 'suspended';
+}
+//# sourceMappingURL=pheromone-adaptive.js.map

package/dist/src/services/worker-daemon.js

@@ -70,7 +70,10 @@ const NO_DISTILL_ENV = 'RUFLO_DAEMON_NO_DISTILL';
 // half a day; set RUFLO_DAEMON_TTL_SECS=0 (or `--ttl 0`) to opt out. Idle
 // shutdown is opt-in (0 = disabled) since a legitimately quiet daemon is not a leak.
 const DEFAULT_DAEMON_TTL_MS = 12 * 60 * 60 * 1000;
-const DEFAULT_DAEMON_IDLE_SHUTDOWN_MS = 0;
+// #2834 — an auto-started daemon must not remain alive for the full 12h TTL
+// after its workspace goes idle. Explicit 0 via config/env still disables the
+// idle cap for operators who intentionally want a resident daemon.
+const DEFAULT_DAEMON_IDLE_SHUTDOWN_MS = 30 * 60 * 1000;
 /**
  * Read a non-negative seconds value from an env var and return it as ms.
  * Unlike the `parseInt(x) || default` idiom used elsewhere, an explicit `0`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.32.34",
+  "version": "3.32.35",
   "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",