claude-flow 3.32.34 → 3.32.36

package/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/dist/src/services/memory-distillation.d.ts

@@ -20,6 +20,7 @@ export interface DistillOptions {
 export interface DistillReport {
     processed: number;
     episodes: number;
+    episodeEmbeddings: number;
     patterns: number;
     patternEmbeddings: number;
     causalEdges: number;

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

@@ -3,7 +3,8 @@
  *
  * Turns raw `memory_entries` (what ruflo has been RECORDING for thousands of
  * commits) into the structured intelligence substrate it has never populated:
- * `episodes` → `reasoning_patterns` (+ `pattern_embeddings`) → `causal_edges`.
+ * `episodes` (+ `episode_embeddings`) → `reasoning_patterns`
+ * (+ `pattern_embeddings`) → `causal_edges`.
  * This is the DISTILL/CONSOLIDATE half of the RETRIEVE→JUDGE→DISTILL→CONSOLIDATE
  * pipeline; RETRIEVE (embeddings) was already populated, the rest was empty
  * because the daemon's `consolidate` worker was a stub (see ADR-174 root cause).
@@ -28,7 +29,8 @@ import * as path from 'path';
 import { distillTrajectoryContent, serialiseDistilled } from '../memory/structured-distill.js';
 function emptyReport(dryRun, extra = {}) {
     return {
-        processed: 0, episodes: 0, patterns: 0, patternEmbeddings: 0, causalEdges: 0,
+        processed: 0, episodes: 0, episodeEmbeddings: 0,
+        patterns: 0, patternEmbeddings: 0, causalEdges: 0,
         promoted: 0, byProvenance: {}, namespaces: [], dryRun, spendUsd: 0, ...extra,
     };
 }
@@ -74,6 +76,20 @@ function judgeFeedback(content) {
     catch { /* not JSON — treat as neutral */ }
     return { success: true, reward: 0.5 };
 }
+/** Preserve an execution-observed lesson for Reflexion without presenting
+ * proxy/structural summaries as genuine self-critique. */
+function feedbackCritique(content) {
+    try {
+        const value = JSON.parse(content);
+        for (const key of ['critique', 'error', 'message', 'summary', 'stderr']) {
+            if (typeof value[key] === 'string' && value[key].trim()) {
+                return value[key].trim().slice(0, 2000);
+            }
+        }
+    }
+    catch { /* retain the original execution feedback below */ }
+    return `Observed execution feedback: ${content}`.slice(0, 2000);
+}
 /**
  * Distill accumulated memory into the structured intelligence tables.
  * Incremental, $0, transactional, provenance-tagged.
@@ -115,6 +131,17 @@ export async function runDistillation(options) {
             db.close();
             return { ...report, corrupt: true, skipped: 'memory DB reports corruption — run recoverMemoryDatabase first' };
         }
+        // #2677 — older AgentDB stores may have episodes but no embedding table.
+        // Create the stable AgentDB v1 table only after the corruption gate, and
+        // never create it during a dry-run.
+        if (!dryRun && !tableExists('episode_embeddings')) {
+            db.exec(`CREATE TABLE episode_embeddings (
+        episode_id INTEGER PRIMARY KEY,
+        embedding BLOB NOT NULL,
+        embedding_model TEXT DEFAULT 'all-MiniLM-L6-v2',
+        FOREIGN KEY(episode_id) REFERENCES episodes(id) ON DELETE CASCADE
+      )`);
+        }
         // M0: incremental cursor table (per namespace, by monotonic rowid).
         db.exec(`CREATE TABLE IF NOT EXISTS distill_state (
       namespace TEXT PRIMARY KEY,
@@ -128,10 +155,54 @@ export async function runDistillation(options) {
         const getCursor = db.prepare('SELECT last_rowid FROM distill_state WHERE namespace = ?');
         const setCursor = db.prepare('INSERT INTO distill_state (namespace, last_rowid, last_run_at) VALUES (?, ?, ?) ' +
             'ON CONFLICT(namespace) DO UPDATE SET last_rowid = excluded.last_rowid, last_run_at = excluded.last_run_at');
-        const insEpisode = db.prepare('INSERT INTO episodes (session_id, task, input, output, reward, success, tags, metadata) VALUES (?,?,?,?,?,?,?,?)');
+        const insEpisode = db.prepare('INSERT INTO episodes (session_id, task, input, output, critique, reward, success, tags, metadata) VALUES (?,?,?,?,?,?,?,?,?)');
+        const insEpisodeEmbedding = dryRun ? null : db.prepare('INSERT OR REPLACE INTO episode_embeddings (episode_id, embedding) VALUES (?, ?)');
         const insPattern = db.prepare('INSERT INTO reasoning_patterns (task_type, approach, success_rate, uses, avg_reward, tags, metadata) VALUES (?,?,?,?,?,?,?)');
         const insPatEmb = db.prepare('INSERT OR REPLACE INTO pattern_embeddings (pattern_id, embedding) VALUES (?, ?)');
         const insEdge = db.prepare('INSERT INTO causal_edges (from_memory_id, from_memory_type, to_memory_id, to_memory_type, similarity, confidence, mechanism, metadata) VALUES (?,?,?,?,?,?,?,?)');
+        // Repair episodes produced by older distillation releases. Their metadata
+        // records sourceIds; if that provenance is absent, exact input matching is
+        // a conservative fallback. Never invent a vector or call a model.
+        if (!dryRun) {
+            const missingEpisodes = db.prepare(`
+        SELECT e.id, e.input, e.metadata
+        FROM episodes e
+        LEFT JOIN episode_embeddings ee ON ee.episode_id = e.id
+        WHERE ee.episode_id IS NULL AND e.session_id LIKE 'distill:%'
+      `).all();
+            const embeddingById = db.prepare('SELECT embedding FROM memory_entries WHERE id = ? AND embedding IS NOT NULL');
+            const embeddingByContent = db.prepare('SELECT embedding FROM memory_entries WHERE content = ? AND embedding IS NOT NULL LIMIT 1');
+            const missingCritiques = db.prepare(`
+        SELECT id, input FROM episodes
+        WHERE session_id LIKE 'distill:feedback%'
+          AND length(trim(coalesce(critique,''))) = 0
+      `).all();
+            const updateCritique = db.prepare('UPDATE episodes SET critique = ? WHERE id = ?');
+            const backfill = db.transaction(() => {
+                for (const episode of missingEpisodes) {
+                    let sourceId;
+                    try {
+                        const metadata = JSON.parse(episode.metadata ?? '{}');
+                        if (Array.isArray(metadata.sourceIds) && typeof metadata.sourceIds[0] === 'string') {
+                            sourceId = metadata.sourceIds[0];
+                        }
+                    }
+                    catch { /* use exact-content fallback */ }
+                    let raw = sourceId ? embeddingById.get(sourceId)?.embedding : undefined;
+                    if (!raw)
+                        raw = embeddingByContent.get(episode.input ?? '')?.embedding;
+                    const vector = parseEmbedding(raw);
+                    if (!vector)
+                        continue;
+                    insEpisodeEmbedding.run(episode.id, Buffer.from(Float32Array.from(vector).buffer));
+                    report.episodeEmbeddings++;
+                }
+                for (const episode of missingCritiques) {
+                    updateCritique.run(feedbackCritique(episode.input ?? ''), episode.id);
+                }
+            });
+            backfill();
+        }
         let remaining = typeof maxEntries === 'number' ? maxEntries : Infinity;
         for (const ns of nsList) {
             if (remaining <= 0)
@@ -200,8 +271,14 @@ export async function runDistillation(options) {
                                 sourceIds: cl.members.map(m => m.id).slice(0, 25),
                                 paths: distilled.paths.slice(0, 10), namespace: ns, distilledBy: 'structural',
                             };
-                            const epInfo = insEpisode.run(`distill:${ns}`, approach, cl.rep.content.slice(0, 2000), '', avgReward, promoted && cl.successCount > 0 ? 1 : 0, JSON.stringify(distilled.labels), JSON.stringify(provMeta));
+                            const epInfo = insEpisode.run(`distill:${ns}`, approach, cl.rep.content.slice(0, 2000), '', cl.provenance === 'oracle:test-exec' ? feedbackCritique(cl.rep.content) : null, avgReward, promoted && cl.successCount > 0 ? 1 : 0, JSON.stringify(distilled.labels), JSON.stringify(provMeta));
                             report.episodes++;
+                            const epId = Number(epInfo.lastInsertRowid);
+                            // ReflexionMemory.retrieveRelevant() INNER JOINs this table.
+                            // Reuse the source embedding so every distilled episode is
+                            // immediately retrievable without an embedding-model call.
+                            insEpisodeEmbedding.run(epId, Buffer.from(Float32Array.from(embVec).buffer));
+                            report.episodeEmbeddings++;
                             const patInfo = insPattern.run(taskType, approach, successRate, uses, avgReward, JSON.stringify(distilled.labels), JSON.stringify(provMeta));
                             const patternId = Number(patInfo.lastInsertRowid);
                             report.patterns++;
@@ -217,7 +294,6 @@ export async function runDistillation(options) {
                             // rowids). Explicitly typed co-occurrence / proxy-tier / non-
                             // promoted: may rank retrieval, must NOT justify autonomous action
                             // (ADR-174 edge contract).
-                            const epId = Number(epInfo.lastInsertRowid);
                             if (prevEpId !== null) {
                                 insEdge.run(prevEpId, 'episode', epId, 'episode', 0, 0.3, 'co-occurrence', JSON.stringify({
                                     edge_type: 'cooccurrence',

package/v3/@claude-flow/cli/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