@claude-flow/cli 3.32.34 → 3.32.35

package/dist/src/mcp-tools/swarm-tools.js

@@ -4,13 +4,16 @@
  * Tool definitions for swarm coordination with file-based state persistence.
  * Replaces previous stub implementations with real state tracking.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
 import { validateIdentifier } from './validate-input.js';
+import { createApscState, isApscAgentEligible, normalizeApscConfig, recordApscSignal, } from '../services/pheromone-adaptive.js';
 // Swarm state persistence
 const SWARM_DIR = '.claude-flow/swarm';
 const SWARM_STATE_FILE = 'swarm-state.json';
+const SWARM_STATE_LOCK = 'swarm-state.lock';
+const SWARM_LOCK_STALE_MS = 10_000;
 function getSwarmDir() {
     return join(getProjectCwd(), SWARM_DIR);
 }
@@ -103,12 +106,101 @@ export function loadSwarmStore() {
 }
 export function saveSwarmStore(store) {
     ensureSwarmDir();
-    writeFileSync(getSwarmStatePath(), JSON.stringify(store, null, 2), 'utf-8');
+    const target = getSwarmStatePath();
+    const temporary = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+    try {
+        writeFileSync(temporary, JSON.stringify(store, null, 2), { encoding: 'utf-8', mode: 0o600 });
+        renameSync(temporary, target);
+    }
+    catch (error) {
+        try {
+            unlinkSync(temporary);
+        }
+        catch { /* already renamed or never created */ }
+        throw error;
+    }
+}
+function withSwarmStoreLock(operation) {
+    ensureSwarmDir();
+    const lockPath = join(getSwarmDir(), SWARM_STATE_LOCK);
+    let descriptor;
+    const waiter = new Int32Array(new SharedArrayBuffer(4));
+    for (let attempt = 0; attempt < 100; attempt++) {
+        try {
+            descriptor = openSync(lockPath, 'wx', 0o600);
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            try {
+                if (Date.now() - statSync(lockPath).mtimeMs > SWARM_LOCK_STALE_MS) {
+                    unlinkSync(lockPath);
+                    continue;
+                }
+            }
+            catch { /* another writer released it */ }
+            Atomics.wait(waiter, 0, 0, 10);
+        }
+    }
+    if (descriptor === undefined)
+        throw new Error('swarm state is busy; retry the outcome update');
+    try {
+        return operation();
+    }
+    finally {
+        try {
+            closeSync(descriptor);
+        }
+        catch { /* best effort */ }
+        try {
+            unlinkSync(lockPath);
+        }
+        catch { /* best effort */ }
+    }
 }
 // Input validation
 const VALID_TOPOLOGIES = new Set([
-    'hierarchical', 'mesh', 'hierarchical-mesh', 'ring', 'star', 'hybrid', 'adaptive',
+    'hierarchical', 'mesh', 'hierarchical-mesh', 'ring', 'star', 'hybrid', 'adaptive', 'pheromone-adaptive',
 ]);
+function latestRunningSwarm(store) {
+    return Object.values(store.swarms)
+        .filter((swarm) => swarm.status === 'running')
+        .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())[0];
+}
+function apscStateOf(swarm) {
+    if (!swarm || swarm.topology !== 'pheromone-adaptive')
+        return undefined;
+    const state = swarm.config.apscState;
+    return state?.schemaVersion ? state : undefined;
+}
+/** Shared by hooks_post-task so outcome labels immediately drive APSC. */
+export function recordSwarmPheromoneSignal(signal) {
+    return withSwarmStoreLock(() => {
+        const store = loadSwarmStore();
+        const swarm = latestRunningSwarm(store);
+        const current = apscStateOf(swarm);
+        if (!swarm || !current)
+            return { active: false, reason: 'no running pheromone-adaptive swarm' };
+        const result = recordApscSignal(current, signal);
+        swarm.config.apscState = result.state;
+        swarm.updatedAt = new Date().toISOString();
+        saveSwarmStore(store);
+        return { active: true, swarmId: swarm.swarmId, decision: result.decision };
+    });
+}
+/** Scheduling gate used by agent_execute. Dry-run topologies remain eligible. */
+export function pheromoneAgentEligibility(agentId) {
+    const current = apscStateOf(latestRunningSwarm(loadSwarmStore()));
+    if (!current)
+        return { eligible: true, active: false };
+    const eligible = isApscAgentEligible(current, agentId);
+    return {
+        eligible,
+        active: true,
+        reason: eligible ? undefined : 'agent suspended by pheromone-adaptive scheduling gate',
+    };
+}
 export const swarmTools = [
     {
         name: 'swarm_init',
@@ -117,7 +209,7 @@ export const swarmTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                topology: { type: 'string', description: 'Swarm topology type (hierarchical, mesh, hierarchical-mesh, ring, star, hybrid, adaptive)' },
+                topology: { type: 'string', description: 'Swarm topology type (hierarchical, mesh, hierarchical-mesh, ring, star, hybrid, adaptive, pheromone-adaptive)' },
                 maxAgents: { type: 'number', description: 'Maximum number of agents (1-50)' },
                 strategy: { type: 'string', description: 'Agent strategy (specialized, balanced, adaptive)' },
                 config: { type: 'object', description: 'Additional swarm configuration' },
@@ -145,6 +237,19 @@ export const swarmTools = [
                     error: `Invalid topology: ${topology}. Valid: ${[...VALID_TOPOLOGIES].join(', ')}`,
                 };
             }
+            let apscState;
+            if (topology === 'pheromone-adaptive') {
+                try {
+                    const apscConfig = normalizeApscConfig((config.apsc ?? {}));
+                    if (apscConfig.minActiveAgents > maxAgents) {
+                        return { success: false, error: 'APSC minActiveAgents cannot exceed maxAgents' };
+                    }
+                    apscState = createApscState(apscConfig);
+                }
+                catch (error) {
+                    return { success: false, error: `Invalid APSC config: ${error.message}` };
+                }
+            }
             const swarmId = `swarm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
             const now = new Date().toISOString();
             const swarmState = {
@@ -161,12 +266,14 @@ export const swarmTools = [
                     communicationProtocol: config.communicationProtocol || 'message-bus',
                     autoScaling: config.autoScaling ?? true,
                     consensusMechanism: config.consensusMechanism || 'majority',
+                    ...(apscState ? { apscState } : {}),
                 },
                 createdAt: now,
                 updatedAt: now,
-                // #1799 — record host PID so subsequent loads can detect orphans
-                // when this process exits without a graceful swarm_shutdown.
-                pid: process.pid,
+                // A normal CLI invocation exits immediately after creating this
+                // coordination record; its PID is therefore not the swarm lifetime.
+                // Long-lived hosts may opt into PID ownership explicitly.
+                pid: config.trackHostProcess === true ? process.pid : undefined,
             };
             const store = loadSwarmStore();
             store.swarms[swarmId] = swarmState;
@@ -180,6 +287,62 @@ export const swarmTools = [
                 initializedAt: now,
                 config: swarmState.config,
                 persisted: true,
+                apsc: apscState ? {
+                    dryRun: apscState.config.dryRun,
+                    minActiveAgents: apscState.config.minActiveAgents,
+                    minSamples: apscState.config.minSamples,
+                } : undefined,
+            };
+        },
+    },
+    {
+        name: 'swarm_pheromone_update',
+        description: 'Record a normalized per-agent task outcome for a running pheromone-adaptive swarm. Use when a static agent pool is wrong because repeated task evidence should update role-aware EMA fitness and produce a bounded keep/suspend/reactivate decision; native Task has no persistent swarm eligibility gate.',
+        category: 'swarm',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'Stable tracked agent identifier' },
+                role: { type: 'string', description: 'Agent role used for role-local normalization' },
+                taskSuccess: { type: 'number', description: 'Observed task success in [0,1]' },
+                normalizedLatency: { type: 'number', description: 'Latency divided by the configured budget, clamped to [0,1]' },
+                consensusAlignment: { type: 'number', description: 'Agreement with the accepted consensus in [0,1]' },
+            },
+            required: ['agentId', 'role', 'taskSuccess', 'normalizedLatency', 'consensusAlignment'],
+        },
+        handler: async (input) => {
+            try {
+                return recordSwarmPheromoneSignal({
+                    agentId: String(input.agentId),
+                    role: String(input.role),
+                    taskSuccess: Number(input.taskSuccess),
+                    normalizedLatency: Number(input.normalizedLatency),
+                    consensusAlignment: Number(input.consensusAlignment),
+                });
+            }
+            catch (error) {
+                return { active: false, reason: error.message };
+            }
+        },
+    },
+    {
+        name: 'swarm_pheromone_status',
+        description: 'Inspect the threshold, safety configuration, per-agent EMA scores, and scheduling eligibility of the active pheromone-adaptive swarm. Use when aggregate swarm status is wrong because calibration requires the exact APSC threshold and per-agent evidence before switching from dry-run to live suspension.',
+        category: 'swarm',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            const store = loadSwarmStore();
+            const swarm = latestRunningSwarm(store);
+            const state = apscStateOf(swarm);
+            if (!swarm || !state)
+                return { active: false, reason: 'no running pheromone-adaptive swarm' };
+            return {
+                active: true,
+                swarmId: swarm.swarmId,
+                threshold: state.threshold,
+                round: state.round,
+                config: state.config,
+                agents: Object.values(state.agents).sort((a, b) => a.agentId.localeCompare(b.agentId)),
             };
         },
     },
@@ -212,6 +375,7 @@ export const swarmTools = [
                     agentCount: swarm.agents.length,
                     taskCount: swarm.tasks.length,
                     config: swarm.config,
+                    apsc: apscStateOf(swarm),
                     createdAt: swarm.createdAt,
                     updatedAt: swarm.updatedAt,
                 };
@@ -236,6 +400,7 @@ export const swarmTools = [
                 agentCount: latest.agents.length,
                 taskCount: latest.tasks.length,
                 config: latest.config,
+                apsc: apscStateOf(latest),
                 createdAt: latest.createdAt,
                 updatedAt: latest.updatedAt,
                 totalSwarms: swarmIds.length,

package/dist/src/memory/memory-initializer.d.ts

@@ -36,7 +36,7 @@ export declare function resolveDbPath(cliFlag?: string): string;
  * Vector embeddings enabled for semantic search
  */
 export declare const MEMORY_SCHEMA_V3 = "\n-- RuFlo V3 Memory Database\n-- Version: 3.0.0\n-- Features: Pattern learning, vector embeddings, temporal decay, migration tracking\n\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA foreign_keys = ON;\n\n-- ============================================\n-- CORE MEMORY TABLES\n-- ============================================\n\n-- Memory entries (main storage)\nCREATE TABLE IF NOT EXISTS memory_entries (\n  id TEXT PRIMARY KEY,\n  key TEXT NOT NULL,\n  namespace TEXT DEFAULT 'default',\n  content TEXT NOT NULL,\n  type TEXT DEFAULT 'semantic' CHECK(type IN ('semantic', 'episodic', 'procedural', 'working', 'pattern')),\n\n  -- Vector embedding for semantic search (stored as JSON array)\n  embedding TEXT,\n  embedding_model TEXT DEFAULT 'local',\n  embedding_dimensions INTEGER,\n\n  -- Metadata\n  tags TEXT, -- JSON array\n  metadata TEXT, -- JSON object\n  owner_id TEXT,\n\n  -- ADR-323: who/what produced this entry \u2014 lets shared-namespace retrieval\n  -- filter by trust level instead of conflating a user's stated claim with\n  -- an agent's own output or a raw tool/system observation.\n  provenance_type TEXT DEFAULT 'unknown' CHECK(provenance_type IN (\n    'user_claim', 'agent_output', 'system_observation', 'tool_result', 'unknown'\n  )),\n\n  -- Timestamps\n  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  expires_at INTEGER,\n  last_accessed_at INTEGER,\n\n  -- Access tracking for hot/cold detection\n  access_count INTEGER DEFAULT 0,\n\n  -- Status\n  status TEXT DEFAULT 'active' CHECK(status IN ('active', 'archived', 'deleted')),\n\n  UNIQUE(namespace, key)\n);\n\n-- Indexes for memory entries\nCREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_entries(namespace);\nCREATE INDEX IF NOT EXISTS idx_memory_key ON memory_entries(key);\nCREATE INDEX IF NOT EXISTS idx_memory_type ON memory_entries(type);\nCREATE INDEX IF NOT EXISTS idx_memory_status ON memory_entries(status);\nCREATE INDEX IF NOT EXISTS idx_memory_created ON memory_entries(created_at);\nCREATE INDEX IF NOT EXISTS idx_memory_accessed ON memory_entries(last_accessed_at);\nCREATE INDEX IF NOT EXISTS idx_memory_owner ON memory_entries(owner_id);\n\n-- ============================================\n-- PATTERN LEARNING TABLES\n-- ============================================\n\n-- Learned patterns with confidence scoring and versioning\nCREATE TABLE IF NOT EXISTS patterns (\n  id TEXT PRIMARY KEY,\n\n  -- Pattern identification\n  name TEXT NOT NULL,\n  pattern_type TEXT NOT NULL CHECK(pattern_type IN (\n    'task-routing', 'error-recovery', 'optimization', 'learning',\n    'coordination', 'prediction', 'code-pattern', 'workflow'\n  )),\n\n  -- Pattern definition\n  condition TEXT NOT NULL, -- Regex or semantic match\n  action TEXT NOT NULL, -- What to do when pattern matches\n  description TEXT,\n\n  -- Confidence scoring (0.0 - 1.0)\n  confidence REAL DEFAULT 0.5,\n  success_count INTEGER DEFAULT 0,\n  failure_count INTEGER DEFAULT 0,\n\n  -- Temporal decay\n  decay_rate REAL DEFAULT 0.01, -- How fast confidence decays\n  half_life_days INTEGER DEFAULT 30, -- Days until confidence halves without use\n\n  -- Vector embedding for semantic pattern matching\n  embedding TEXT,\n  embedding_dimensions INTEGER,\n\n  -- Versioning\n  version INTEGER DEFAULT 1,\n  parent_id TEXT REFERENCES patterns(id),\n\n  -- Metadata\n  tags TEXT, -- JSON array\n  metadata TEXT, -- JSON object\n  source TEXT, -- Where the pattern was learned from\n\n  -- Timestamps\n  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  last_matched_at INTEGER,\n  last_success_at INTEGER,\n  last_failure_at INTEGER,\n\n  -- Status\n  status TEXT DEFAULT 'active' CHECK(status IN ('active', 'archived', 'deprecated', 'experimental'))\n);\n\n-- Indexes for patterns\nCREATE INDEX IF NOT EXISTS idx_patterns_type ON patterns(pattern_type);\nCREATE INDEX IF NOT EXISTS idx_patterns_confidence ON patterns(confidence DESC);\nCREATE INDEX IF NOT EXISTS idx_patterns_status ON patterns(status);\nCREATE INDEX IF NOT EXISTS idx_patterns_last_matched ON patterns(last_matched_at);\n\n-- Pattern evolution history (for versioning)\nCREATE TABLE IF NOT EXISTS pattern_history (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  pattern_id TEXT NOT NULL REFERENCES patterns(id),\n  version INTEGER NOT NULL,\n\n  -- Snapshot of pattern state\n  confidence REAL,\n  success_count INTEGER,\n  failure_count INTEGER,\n  condition TEXT,\n  action TEXT,\n\n  -- What changed\n  change_type TEXT CHECK(change_type IN ('created', 'updated', 'success', 'failure', 'decay', 'merged', 'split')),\n  change_reason TEXT,\n\n  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)\n);\n\nCREATE INDEX IF NOT EXISTS idx_pattern_history_pattern ON pattern_history(pattern_id);\n\n-- ============================================\n-- LEARNING & TRAJECTORY TABLES\n-- ============================================\n\n-- Learning trajectories (SONA integration)\nCREATE TABLE IF NOT EXISTS trajectories (\n  id TEXT PRIMARY KEY,\n  session_id TEXT,\n\n  -- Trajectory state\n  status TEXT DEFAULT 'active' CHECK(status IN ('active', 'completed', 'failed', 'abandoned')),\n  verdict TEXT CHECK(verdict IN ('success', 'failure', 'partial', NULL)),\n\n  -- Context\n  task TEXT,\n  context TEXT, -- JSON object\n\n  -- Metrics\n  total_steps INTEGER DEFAULT 0,\n  total_reward REAL DEFAULT 0,\n\n  -- Timestamps\n  started_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  ended_at INTEGER,\n\n  -- Reference to extracted pattern (if any)\n  extracted_pattern_id TEXT REFERENCES patterns(id)\n);\n\n-- Trajectory steps\nCREATE TABLE IF NOT EXISTS trajectory_steps (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  trajectory_id TEXT NOT NULL REFERENCES trajectories(id),\n  step_number INTEGER NOT NULL,\n\n  -- Step data\n  action TEXT NOT NULL,\n  observation TEXT,\n  reward REAL DEFAULT 0,\n\n  -- Metadata\n  metadata TEXT, -- JSON object\n\n  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)\n);\n\nCREATE INDEX IF NOT EXISTS idx_steps_trajectory ON trajectory_steps(trajectory_id);\n\n-- ============================================\n-- MIGRATION STATE TRACKING\n-- ============================================\n\n-- Migration state (for resume capability)\nCREATE TABLE IF NOT EXISTS migration_state (\n  id TEXT PRIMARY KEY,\n  migration_type TEXT NOT NULL, -- 'v2-to-v3', 'pattern', 'memory', etc.\n\n  -- Progress tracking\n  status TEXT DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'completed', 'failed', 'rolled_back')),\n  total_items INTEGER DEFAULT 0,\n  processed_items INTEGER DEFAULT 0,\n  failed_items INTEGER DEFAULT 0,\n  skipped_items INTEGER DEFAULT 0,\n\n  -- Current position (for resume)\n  current_batch INTEGER DEFAULT 0,\n  last_processed_id TEXT,\n\n  -- Source/destination info\n  source_path TEXT,\n  source_type TEXT,\n  destination_path TEXT,\n\n  -- Backup info\n  backup_path TEXT,\n  backup_created_at INTEGER,\n\n  -- Error tracking\n  last_error TEXT,\n  errors TEXT, -- JSON array of errors\n\n  -- Timestamps\n  started_at INTEGER,\n  completed_at INTEGER,\n  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)\n);\n\n-- ============================================\n-- SESSION MANAGEMENT\n-- ============================================\n\n-- Sessions for context persistence\nCREATE TABLE IF NOT EXISTS sessions (\n  id TEXT PRIMARY KEY,\n\n  -- Session state\n  state TEXT NOT NULL, -- JSON object with full session state\n  status TEXT DEFAULT 'active' CHECK(status IN ('active', 'paused', 'completed', 'expired')),\n\n  -- Context\n  project_path TEXT,\n  branch TEXT,\n\n  -- Metrics\n  tasks_completed INTEGER DEFAULT 0,\n  patterns_learned INTEGER DEFAULT 0,\n\n  -- Timestamps\n  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  expires_at INTEGER\n);\n\n-- ============================================\n-- VECTOR INDEX METADATA (for HNSW)\n-- ============================================\n\n-- Track HNSW index state\nCREATE TABLE IF NOT EXISTS vector_indexes (\n  id TEXT PRIMARY KEY,\n  name TEXT NOT NULL UNIQUE,\n\n  -- Index configuration\n  dimensions INTEGER NOT NULL,\n  metric TEXT DEFAULT 'cosine' CHECK(metric IN ('cosine', 'euclidean', 'dot')),\n\n  -- HNSW parameters\n  hnsw_m INTEGER DEFAULT 16,\n  hnsw_ef_construction INTEGER DEFAULT 200,\n  hnsw_ef_search INTEGER DEFAULT 100,\n\n  -- Quantization\n  quantization_type TEXT CHECK(quantization_type IN ('none', 'scalar', 'product')),\n  quantization_bits INTEGER DEFAULT 8,\n\n  -- Statistics\n  total_vectors INTEGER DEFAULT 0,\n  last_rebuild_at INTEGER,\n\n  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)\n);\n\n-- ============================================\n-- GRAPH EDGES (ADR-130 Phase 1)\n-- Unified knowledge graph backend \u2014 sql.js canonical store\n-- ============================================\n\n-- Unified graph edges table (ADR-130)\n-- Node IDs use domain-prefixed format: {domain}:{uuid}\n-- where domain in (mem, agent, task, entity, span, pattern)\nCREATE TABLE IF NOT EXISTS graph_edges (\n  id              TEXT PRIMARY KEY,          -- edge-{uuid}\n  source_id       TEXT NOT NULL,             -- domain-prefixed node ID\n  target_id       TEXT NOT NULL,             -- domain-prefixed node ID\n  relation        TEXT NOT NULL,             -- e.g. \"caused\", \"depends-on\", \"imports\"\n  weight          REAL DEFAULT 1.0,\n  -- Temporal / reliability semantics (ADR-130 \u00A7\"graph that forgets\" property)\n  confidence      REAL DEFAULT 1.0,          -- [0,1]; updated by JUDGE step\n  decay_rate      REAL DEFAULT 0.0,          -- per-day exponential decay applied at read time\n  last_reinforced TEXT,                      -- ISO-8601; set when CONSOLIDATE re-touches edge\n  witness_id      TEXT,                      -- FK to verification/witness-fixes.json (ADR-103)\n  -- Embedding storage: \"inline:{base64}\" | \"vector_indexes:{id}\" | NULL\n  embedding_ref   TEXT,\n  metadata        TEXT,                      -- JSON blob for plugin-specific fields\n  created_at      TEXT NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_graph_edges_source    ON graph_edges (source_id);\nCREATE INDEX IF NOT EXISTS idx_graph_edges_target    ON graph_edges (target_id);\nCREATE INDEX IF NOT EXISTS idx_graph_edges_relation  ON graph_edges (relation);\nCREATE INDEX IF NOT EXISTS idx_graph_edges_reinforced ON graph_edges (last_reinforced);\n\n-- ============================================\n-- SYSTEM METADATA\n-- ============================================\n\nCREATE TABLE IF NOT EXISTS metadata (\n  key TEXT PRIMARY KEY,\n  value TEXT NOT NULL,\n  updated_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)\n);\n";
-interface HNSWEntry {
+export interface HNSWEntry {
     id: string;
     key: string;
     namespace: string;
@@ -57,6 +57,14 @@ export declare function getHNSWIndex(options?: {
     dimensions?: number;
     forceRebuild?: boolean;
 }): Promise<HNSWIndex | null>;
+export declare function removeHNSWEntriesByLogicalKey(entries: Map<string, HNSWEntry>, key: string, namespace: string): number;
+/**
+ * Remove HNSW metadata whose authoritative SQLite row is no longer active.
+ * Persistent graph nodes may remain physically allocated, but without metadata
+ * they cannot resolve into search results; the next rebuild repopulates only
+ * active rows. Returns the number of searchable vectors invalidated.
+ */
+export declare function reconcileHNSWIndex(dbPath?: string): Promise<number>;
 /**
  * Add entry to HNSW index (with automatic persistence)
  */

package/dist/src/memory/memory-initializer.js

@@ -680,6 +680,64 @@ function saveHNSWMetadata() {
         // Silently fail - metadata save is best-effort
     }
 }
+export function removeHNSWEntriesByLogicalKey(entries, key, namespace) {
+    let removed = 0;
+    for (const [id, entry] of entries) {
+        if (entry.key === key && (entry.namespace ?? 'default') === namespace) {
+            entries.delete(id);
+            removed++;
+        }
+    }
+    return removed;
+}
+function removeHNSWEntriesByKey(key, namespace) {
+    if (!hnswIndex?.entries)
+        return 0;
+    const removed = removeHNSWEntriesByLogicalKey(hnswIndex.entries, key, namespace);
+    if (removed > 0) {
+        saveHNSWMetadata();
+        rebuildSearchIndex();
+    }
+    return removed;
+}
+/**
+ * Remove HNSW metadata whose authoritative SQLite row is no longer active.
+ * Persistent graph nodes may remain physically allocated, but without metadata
+ * they cannot resolve into search results; the next rebuild repopulates only
+ * active rows. Returns the number of searchable vectors invalidated.
+ */
+export async function reconcileHNSWIndex(dbPath) {
+    if (!hnswIndex?.entries)
+        return 0;
+    const effectivePath = dbPath
+        ? path.resolve(dbPath)
+        : path.join(getMemoryRoot(), 'memory.db');
+    if (!fs.existsSync(effectivePath))
+        return 0;
+    try {
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const db = new SQL.Database(readFileMaybeEncrypted(effectivePath, null));
+        const rows = db.exec(`SELECT id FROM memory_entries WHERE status = 'active'`);
+        const active = new Set((rows[0]?.values ?? []).map((row) => String(row[0])));
+        db.close();
+        let removed = 0;
+        for (const id of hnswIndex.entries.keys()) {
+            if (!active.has(id)) {
+                hnswIndex.entries.delete(id);
+                removed++;
+            }
+        }
+        if (removed > 0) {
+            saveHNSWMetadata();
+            rebuildSearchIndex();
+        }
+        return removed;
+    }
+    catch {
+        return 0;
+    }
+}
 /**
  * Add entry to HNSW index (with automatic persistence)
  */
@@ -2380,6 +2438,9 @@ export async function storeEntry(options) {
             // Keep HNSW index in sync with bridge-stored entries
             if (bridgeResult.rawEmbedding && bridgeResult.success) {
                 const ns = options.namespace || 'default';
+                // Upsert/resurrection may allocate a new row id. Remove every older
+                // vector for the logical (namespace,key), not merely the newest id.
+                removeHNSWEntriesByKey(options.key, ns);
                 await addToHNSWIndex(bridgeResult.id, bridgeResult.rawEmbedding, {
                     id: bridgeResult.id,
                     key: options.key,
@@ -2485,6 +2546,8 @@ export async function storeEntry(options) {
         // Add to HNSW index for faster future searches
         if (embeddingJson) {
             const embResult = JSON.parse(embeddingJson);
+            if (upsert)
+                removeHNSWEntriesByKey(key, namespace);
             await addToHNSWIndex(id, embResult, {
                 id,
                 key,
@@ -2977,15 +3040,7 @@ export async function deleteEntry(options) {
             // #1122: Bridge path must also invalidate the in-memory HNSW index.
             // Without this, deleted vectors remain as ghost entries in search results.
             if (bridgeResult.deleted && hnswIndex?.entries) {
-                // Remove the entry from the HNSW entries map by key+namespace composite
-                for (const [id, entry] of hnswIndex.entries) {
-                    if (entry?.key === options.key && (entry?.namespace ?? 'default') === (options.namespace ?? 'default')) {
-                        hnswIndex.entries.delete(id);
-                        break;
-                    }
-                }
-                saveHNSWMetadata();
-                rebuildSearchIndex();
+                removeHNSWEntriesByKey(options.key, options.namespace ?? 'default');
             }
             return bridgeResult;
         }
@@ -3052,8 +3107,6 @@ export async function deleteEntry(options) {
                 error: `Key '${key}' not found in namespace '${namespace}'`
             };
         }
-        // Capture the entry ID for HNSW cleanup
-        const entryId = String(checkResult[0].values[0][0]);
         // Delete the entry (soft delete by setting status to 'deleted')
         // Also null out the embedding to clean up vector data from SQLite
         db.run(`
@@ -3075,14 +3128,8 @@ export async function deleteEntry(options) {
         // Clean up in-memory HNSW index so ghost vectors don't appear in searches.
         // Remove the entry from the HNSW entries map and invalidate the index.
         // The next search will rebuild the HNSW index from the remaining DB rows.
-        if (hnswIndex?.entries) {
-            hnswIndex.entries.delete(entryId);
-            saveHNSWMetadata();
-            // Invalidate the HNSW index so it rebuilds from DB on next search.
-            // We can't surgically remove a vector from the HNSW graph, so we
-            // clear the entire index; it will be lazily rebuilt from SQLite.
-            rebuildSearchIndex();
-        }
+        if (hnswIndex?.entries)
+            removeHNSWEntriesByKey(key, namespace);
         return {
             success: true,
             deleted: true,

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

@@ -8,8 +8,9 @@
  *   - single-instance: only starts when no live daemon holds the pidfile, and
  *     the spawned `daemon start` independently enforces single-instance via its
  *     own lock + checkExistingDaemon() — so a race spawns at most one survivor,
- *   - bounded lifetime: the daemon self-terminates on TTL/idle (12h default,
- *     RUFLO_DAEMON_TTL_SECS) — auto-start never means "runs forever",
+ *   - bounded lifetime: the daemon self-terminates on TTL/idle (12h hard TTL,
+ *     30m idle default; RUFLO_DAEMON_TTL_SECS / RUFLO_DAEMON_IDLE_SECS) —
+ *     auto-start never means "runs forever",
  *   - opt-out: RUFLO_DAEMON_AUTOSTART=0|false|no disables it entirely, OR a
  *     project-local `daemon.autostart: false` in claude-flow.config.json —
  *     the file-based opt-out exists because the env var only reaches a
@@ -85,8 +86,10 @@ export function ensureDaemonRunning(projectRoot, opts = {}) {
     try {
         if (autostartDisabled(projectRoot))
             return { started: false, reason: 'disabled (RUFLO_DAEMON_AUTOSTART=0 or project config)' };
-        // Only in an initialized project (avoid scaffolding a daemon in a random dir).
-        if (!fs.existsSync(path.join(projectRoot, '.claude-flow')) && !fs.existsSync(path.join(projectRoot, '.claude'))) {
+        // `.claude/` belongs to Claude Code and is present in many repositories
+        // that have never initialized Ruflo. Only Ruflo's own state directory is
+        // an authorization signal for spawning a detached background process.
+        if (!fs.existsSync(path.join(projectRoot, '.claude-flow'))) {
             return { started: false, reason: 'not a ruflo project' };
         }
         const alive = (opts.isAlive ?? isDaemonAlive)(projectRoot);

package/dist/src/services/flywheel-receipt.d.ts

@@ -56,6 +56,8 @@ export interface FlywheelReceiptPayload {
     gateVersion: string;
     policySchemaVersion: string;
     safetyEnvelopeRef: string;
+    /** Hash-pinned human relevance anchor used for this evaluation (#2840). */
+    anchorRef?: string;
     requestedProposer: 'auto' | ProposerName;
     effectiveProposer: ProposerName;
     proposerSubstitution?: string;
@@ -86,6 +88,7 @@ export interface CreateReceiptInput {
     gateVersion?: string;
     policySchemaVersion?: string;
     safetyEnvelopeRef: string;
+    anchorRef?: string;
     requestedProposer?: 'auto' | ProposerName;
     effectiveProposer?: ProposerName;
     proposerSubstitution?: string;

package/dist/src/services/flywheel-receipt.js

@@ -206,6 +206,7 @@ export function createFlywheelReceipt(input) {
         gateVersion: input.gateVersion ?? statistics.ruleVersion,
         policySchemaVersion: input.policySchemaVersion ?? 'ruflo.retrieval-policy/v1',
         safetyEnvelopeRef: input.safetyEnvelopeRef,
+        ...(input.anchorRef ? { anchorRef: input.anchorRef } : {}),
         requestedProposer: input.requestedProposer ?? 'local',
         effectiveProposer: input.effectiveProposer ?? 'local',
         ...(input.proposerSubstitution ? { proposerSubstitution: input.proposerSubstitution } : {}),

package/dist/src/services/harness-flywheel-runtime.d.ts

@@ -39,6 +39,9 @@ export declare function runFlywheelWorker(projectRoot: string, opts?: {
     allowSubstitutionPromotion?: boolean;
     maxConcurrency?: number;
     evaluationTimeoutMs?: number;
+    anchorPath?: string;
+    anchorHash?: string;
+    anchorManifestPath?: string;
 }): Promise<FlywheelResult>;
 /**
  * Run ONE live COMPOUNDING generation against the persisted lineage (ADR-176
@@ -52,5 +55,8 @@ export declare function runFlywheelGenerationWorker(projectRoot: string, opts?:
     sample?: number;
     optInOverride?: boolean;
     now?: number;
+    anchorPath?: string;
+    anchorHash?: string;
+    anchorManifestPath?: string;
 }): Promise<GenerationResult>;
 //# sourceMappingURL=harness-flywheel-runtime.d.ts.map

package/dist/src/services/harness-flywheel-runtime.js

@@ -7,23 +7,10 @@
 import { harnessLoopOptedIn } from './harness-worker.js';
 import { DEFAULT_CONFIG, retrievalPolicyNeighbors, runFlywheelTick, } from './harness-flywheel.js';
 import { runFlywheelGeneration, checkServedChampionDrift } from './harness-flywheel-generations.js';
-import { loadFrozenHumanEval } from './harness-frozen-eval.js';
+import { loadEffectiveFlywheelAnchor } from './harness-project-anchor.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']],
-    ['self-learning wiring task-completed pretrain', ['self-learning', 'adr-074', 'self learning', '#2245', 'task-completed']],
-    ['deterministic codemod engine var-to-const', ['deterministic tier-1 codemod', 'adr-143', 'codemod', 'var-to-const']],
-    ['MCP server orphan leak parent-death', ['mcp orphan', 'mcp servers orphan', 'parent-death', '#2234', 'orphan on every claude']],
-    ['unified learning stats aggregator', ['unified learning-stats', 'adr-075', 'unified learning stats']],
-    ['structured distillation 4-field schema', ['structured distillation', 'adr-076', '4-field schema']],
-    ['SQL injection migrate.ts table identifier', ['sql injection', 'shell injection', 'migrate.ts', 'agentdb', 'cve']],
-    ['recall@k HNSW benchmark harness', ['hnsw', 'memory-recall', 'benchmark suite', 'recall@k', 'benchmark intelligence']],
-    ['Q-learning encoder keyword block', ['q-state encoder', 'route q-state', 'keyword block', '#2239', 'q-encoder']],
-    ['security hardening crypto random IDs', ['cwe-347', 'crypto.randomuuid', 'security fix', 'random id', 'crypto random']],
-].map(([q, labels], i) => ({ id: `q${String(i).padStart(2, '0')}`, input: { id: `q${String(i).padStart(2, '0')}`, q: q }, expected: labels }));
 /**
  * The ADR-322 retrieval safety envelope.
  *
@@ -99,6 +86,11 @@ export async function runFlywheelWorker(projectRoot, opts = {}) {
             ...(applier.activeChampion(projectRoot)?.params ?? {}),
         };
         const safetyEnvelope = retrievalSafetyEnvelope(opts.safetyEnvelopeRef);
+        const anchor = loadEffectiveFlywheelAnchor(projectRoot, {
+            anchorPath: opts.anchorPath ?? process.env.RUFLO_FLYWHEEL_ANCHOR_PATH,
+            anchorHash: opts.anchorHash ?? process.env.RUFLO_FLYWHEEL_ANCHOR_HASH,
+            manifestPath: opts.anchorManifestPath ?? process.env.RUFLO_FLYWHEEL_ANCHOR_MANIFEST,
+        });
         // CLI flag opts.proposer takes precedence over RUFLO_FLYWHEEL_PROPOSER.
         const proposerMode = opts.proposer
             ?? (process.env.RUFLO_FLYWHEEL_PROPOSER ?? 'auto');
@@ -134,7 +126,8 @@ export async function runFlywheelWorker(projectRoot, opts = {}) {
                 const r = await tool.handler({ action: 'search', query, mode: 'hybrid', limit: 5, rerank: false, ...cfg });
                 return (r.results || []).slice(0, 5).map((m) => ({ id: m?.id ?? '', name: m?.name ?? '' }));
             },
-            anchorTasks: ANCHOR,
+            anchorTasks: anchor.tasks,
+            anchorRef: anchor.anchorRef,
             activeParams: () => baseline,
             sample: opts.sample ?? 40,
             now: opts.now,
@@ -172,16 +165,23 @@ export async function runFlywheelGenerationWorker(projectRoot, opts = {}) {
         const tool = neural.neuralTools.find((t) => t.name === 'neural_patterns');
         if (!tool)
             return { ran: false, reason: 'neural_patterns tool unavailable', generation: 0 };
-        // Load the FROZEN, hashed, public human eval set (throws if it has drifted).
-        const frozen = loadFrozenHumanEval();
+        const anchor = loadEffectiveFlywheelAnchor(projectRoot, {
+            anchorPath: opts.anchorPath ?? process.env.RUFLO_FLYWHEEL_ANCHOR_PATH,
+            anchorHash: opts.anchorHash ?? process.env.RUFLO_FLYWHEEL_ANCHOR_HASH,
+            manifestPath: opts.anchorManifestPath ?? process.env.RUFLO_FLYWHEEL_ANCHOR_MANIFEST,
+        });
         const deps = {
             getPatterns: () => neural.getStorePatterns(),
             search: async (query, cfg) => {
                 const r = await tool.handler({ action: 'search', query, mode: 'hybrid', limit: 5, rerank: false, ...cfg });
                 return (r.results || []).slice(0, 5).map((m) => ({ id: m?.id ?? '', name: m?.name ?? '' }));
             },
-            anchorTasks: frozen.tasks,
-            humanEvalHash: frozen.corpusHash,
+            anchorTasks: anchor.tasks.map((task) => ({
+                id: task.id,
+                q: task.input.q,
+                labels: task.expected,
+            })),
+            humanEvalHash: anchor.anchorRef,
             sample: opts.sample ?? 120,
             now: opts.now ?? Date.now(),
         };

package/dist/src/services/harness-flywheel.d.ts

@@ -30,6 +30,8 @@ export interface FlywheelDeps {
     lineageId?: string;
     evaluationRunId?: string;
     safetyEnvelopeRef?: string;
+    /** Hash of the project-specific human-labelled objective. */
+    anchorRef?: string;
     requestedProposer?: 'auto' | 'local' | 'darwin';
     effectiveProposer?: 'local' | 'darwin';
     proposerSubstitution?: string;

package/dist/src/services/harness-flywheel.js

@@ -210,6 +210,7 @@ export async function evaluateFlywheelCandidate(projectRoot, deps) {
             expectedLedgerHead: txState.ledgerHead,
             candidatePolicy: candidate,
             safetyEnvelopeRef,
+            anchorRef: deps.anchorRef,
             requestedProposer: deps.requestedProposer ?? 'local',
             effectiveProposer: deps.effectiveProposer ?? 'local',
             proposerSubstitution: deps.proposerSubstitution,

package/dist/src/services/harness-project-anchor.d.ts

@@ -0,0 +1,23 @@
+import type { AnchorTask } from './harness-flywheel.js';
+export declare const PROJECT_ANCHOR_SCHEMA = "ruflo.flywheel-anchor/v1";
+export declare const PROJECT_ANCHOR_MANIFEST_SCHEMA = "ruflo.flywheel-anchor-manifest/v1";
+export declare const DEFAULT_PROJECT_ANCHOR_MANIFEST: string;
+export interface ProjectAnchorManifest {
+    schemaVersion: typeof PROJECT_ANCHOR_MANIFEST_SCHEMA;
+    path: string;
+    sha256: string;
+}
+export interface FlywheelAnchorSelection {
+    version: string;
+    anchorRef: string;
+    tasks: AnchorTask[];
+    source: 'project' | 'ruflo-built-in';
+    path?: string;
+}
+export interface LoadFlywheelAnchorOptions {
+    anchorPath?: string;
+    anchorHash?: string;
+    manifestPath?: string;
+}
+export declare function loadEffectiveFlywheelAnchor(projectRoot: string, options?: LoadFlywheelAnchorOptions): FlywheelAnchorSelection;
+//# sourceMappingURL=harness-project-anchor.d.ts.map