@claude-flow/cli 3.32.34 → 3.32.35

package/.claude/helpers/helpers.manifest.json

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.32.34",
+    "version": "3.32.35",
     "files": {
       "auto-memory-hook.mjs": "68be7e9a9eba7bf9c4e8a230db7bf61a243b965639f8504842799d6c6ca28762",
       "hook-handler.cjs": "50ea92a72651bdc95634f7588d56a5870963168eef5226f66ed14af3b47c8d9a",
@@ -8,6 +8,6 @@
       "statusline.cjs": "d2a0eac56d1267d8dbed2d70b09feb592299469196ec4b215909f2b052144882"
     }
   },
-  "signature": "i0qilACTabRlI6VORA0QyP0r4EuvJsrvtkucxia3TStgq/la250iesyKjlcHbLV/6fshZiGtPMLq1nmXLf+ZAw==",
+  "signature": "7hAABpKaZablL78ug8UW506P+ppwYlDb2qws0D4BbCeugfGQTdDEOYsndbZMc4+Wzbx10oQbnubqh8jHZnHvBQ==",
   "algorithm": "ed25519"
 }

package/catalog-manifest.json

@@ -1,11 +1,11 @@
 {
   "schemaVersion": 1,
-  "generation": 3,
-  "generatedAt": "2026-07-29T13:29:39.000Z",
-  "gitSha": "c3cf2d0e",
+  "generation": 4,
+  "generatedAt": "2026-07-29T17:56:33.000Z",
+  "gitSha": "3d9bca6d",
   "catalog": {
     "agents": 164,
-    "tools": 395,
+    "tools": 397,
     "skills": 34
   },
   "benchmark": null

package/dist/src/commands/agent.js

@@ -487,6 +487,39 @@ const metricsCommand = {
         const avgSuccessRate = tasksCompleted > 0
             ? `${Math.round(Object.values(typeCounts).reduce((a, d) => a + d.success, 0) / tasksCompleted * 100)}%`
             : 'N/A';
+        // ADR-330: expose the learned scheduling signal where operators already
+        // inspect agent metrics. Old/non-APSC installs simply omit this section.
+        let pheromone;
+        const swarmStatePath = join(process.cwd(), '.claude-flow', 'swarm', 'swarm-state.json');
+        if (existsSync(swarmStatePath)) {
+            try {
+                const store = JSON.parse(readFileSync(swarmStatePath, 'utf-8'));
+                const current = Object.values(store.swarms ?? {})
+                    .filter((swarm) => swarm.status === 'running' && swarm.topology === 'pheromone-adaptive')
+                    .sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)))[0];
+                const apsc = current?.config?.apscState;
+                if (apsc) {
+                    const agents = Object.values(apsc.agents ?? {})
+                        .filter((agent) => !agentId || agent.agentId === agentId)
+                        .sort((a, b) => a.agentId.localeCompare(b.agentId))
+                        .map((agent) => ({
+                        agentId: agent.agentId,
+                        role: agent.role,
+                        pheromoneScore: agent.emaScore,
+                        rawScore: agent.rawScore,
+                        samples: agent.samples,
+                        eligibility: agent.status === 'suspended' ? 'suspended' : 'eligible',
+                    }));
+                    pheromone = {
+                        active: true,
+                        dryRun: apsc.config?.dryRun !== false,
+                        threshold: apsc.threshold ?? 0.5,
+                        agents,
+                    };
+                }
+            }
+            catch { /* malformed/legacy swarm state — preserve existing metrics */ }
+        }
         const metrics = {
             period,
             summary: {
@@ -501,7 +534,8 @@ const metricsCommand = {
             performance: {
                 memoryVectors: `${vectorCount} vectors`,
                 searchBackend: vectorCount > 0 ? 'HNSW-indexed' : 'none'
-            }
+            },
+            pheromone,
         };
         if (ctx.flags.format === 'json') {
             output.printJson(metrics);
@@ -544,6 +578,20 @@ const metricsCommand = {
             `Vectors: ${output.success(metrics.performance.memoryVectors)}`,
             `Backend: ${output.success(metrics.performance.searchBackend)}`
         ]);
+        if (metrics.pheromone) {
+            output.writeln();
+            output.writeln(output.bold(`Pheromone Scheduling (${metrics.pheromone.dryRun ? 'dry run' : 'live'})`));
+            output.printTable({
+                columns: [
+                    { key: 'agentId', header: 'Agent', width: 20 },
+                    { key: 'role', header: 'Role', width: 18 },
+                    { key: 'pheromoneScore', header: 'EMA Score', width: 12, align: 'right' },
+                    { key: 'samples', header: 'Samples', width: 9, align: 'right' },
+                    { key: 'eligibility', header: 'Eligibility', width: 12 },
+                ],
+                data: metrics.pheromone.agents,
+            });
+        }
         return { success: true, data: metrics };
     }
 };

package/dist/src/commands/hooks.js

@@ -1672,6 +1672,26 @@ const postTaskCommand = {
             description: 'Agent that executed the task',
             type: 'string'
         },
+        {
+            name: 'agent-role',
+            description: 'Stable agent role used for role-aware pheromone comparison (for example coder, tester, coordinator)',
+            type: 'string'
+        },
+        {
+            name: 'duration',
+            description: 'Observed task duration in milliseconds for latency fitness',
+            type: 'number'
+        },
+        {
+            name: 'latency-budget-ms',
+            description: 'Expected task duration in milliseconds; paired with --duration to normalize latency fitness',
+            type: 'number'
+        },
+        {
+            name: 'consensus-alignment',
+            description: 'Consensus alignment score from 0 to 1',
+            type: 'number'
+        },
         {
             name: 'task',
             short: 't',
@@ -1716,6 +1736,10 @@ const postTaskCommand = {
                 success,
                 quality: ctx.flags.quality,
                 agent: ctx.flags.agent,
+                agentRole: ctx.flags.agentRole,
+                duration: ctx.flags.duration,
+                latencyBudgetMs: ctx.flags.latencyBudgetMs,
+                consensusAlignment: ctx.flags.consensusAlignment,
                 // #2785: forward the task description so routing outcomes actually persist
                 // (hooks_post-task requires taskText + agent to write the outcome row that
                 // hooks_metrics reads via getIntelligenceStatsFromMemory)

package/dist/src/commands/metaharness.js

@@ -102,12 +102,16 @@ async function dispatchFlywheel(operation, positional, flags) {
                 receiptPublicKeyPem: publicKeyPath ? readFileSync(resolve(publicKeyPath), 'utf8') : undefined,
                 maxConcurrency: Number(flywheelFlag(flags, 'maxConcurrency', 2)),
                 evaluationTimeoutMs: Number(flywheelFlag(flags, 'timeoutMs', 120_000)),
+                anchorPath: flywheelFlag(flags, 'anchorPath'),
+                anchorHash: flywheelFlag(flags, 'anchorHash'),
+                anchorManifestPath: flywheelFlag(flags, 'anchorManifest'),
             });
         }
     }
     else if (operation === 'receipts') {
         data = listFlywheelReceipts(projectRoot).map(({ receipt, state }) => ({
             receiptId: receipt.payload.receiptId,
+            anchorRef: receipt.payload.anchorRef,
             candidateId: receipt.payload.candidateId,
             baselineRef: receipt.payload.baselineRef,
             decision: receipt.payload.decision,

package/dist/src/commands/swarm.js

@@ -271,7 +271,8 @@ const TOPOLOGIES = [
     { value: 'ring', label: 'Ring', hint: 'Circular communication pattern' },
     { value: 'star', label: 'Star', hint: 'Central coordinator with spoke agents' },
     { value: 'hybrid', label: 'Hybrid', hint: 'Hierarchical mesh for maximum flexibility' },
-    { value: 'hierarchical-mesh', label: 'Hierarchical Mesh', hint: 'V3 15-agent queen + peer communication (recommended)' }
+    { value: 'hierarchical-mesh', label: 'Hierarchical Mesh', hint: 'V3 15-agent queen + peer communication (recommended)' },
+    { value: 'pheromone-adaptive', label: 'Pheromone Adaptive', hint: 'Role-aware dynamic eligibility with quorum safety (ADR-330)' }
 ];
 // Swarm strategies
 const STRATEGIES = [
@@ -324,6 +325,19 @@ const initCommand = {
             type: 'boolean',
             default: false
         },
+        {
+            name: 'apsc-live',
+            description: 'Apply APSC suspension decisions (default is calibration-only dry run)',
+            type: 'boolean',
+            default: false
+        },
+        { name: 'apsc-alpha', description: 'Task-success score weight', type: 'number', default: 0.5 },
+        { name: 'apsc-beta', description: 'Latency score weight', type: 'number', default: 0.2 },
+        { name: 'apsc-gamma', description: 'Consensus-alignment score weight', type: 'number', default: 0.3 },
+        { name: 'apsc-pruning-factor', description: 'Fraction of adaptive threshold below which agents are eligible for suspension', type: 'number', default: 0.6 },
+        { name: 'apsc-reactivation-threshold', description: 'Fraction of adaptive threshold required for recovery', type: 'number', default: 0.75 },
+        { name: 'apsc-min-active-agents', description: 'Hard quorum floor', type: 'number', default: 3 },
+        { name: 'apsc-min-samples', description: 'Warm-up observations before pruning', type: 'number', default: 3 },
         {
             // #2768 — dream-cycle SubagentPermissionDelegate. Ships a per-role
             // capability manifest to `.swarm/permissions.jsonl` + an append-only
@@ -366,6 +380,18 @@ const initCommand = {
                     failureHandling: 'retry',
                     loadBalancing: true,
                     autoScaling: ctx.flags.autoScale ?? true,
+                    ...(topology === 'pheromone-adaptive' ? {
+                        apsc: {
+                            alpha: Number(ctx.flags.apscAlpha ?? 0.5),
+                            beta: Number(ctx.flags.apscBeta ?? 0.2),
+                            gamma: Number(ctx.flags.apscGamma ?? 0.3),
+                            pruningFactor: Number(ctx.flags.apscPruningFactor ?? 0.6),
+                            reactivationThreshold: Number(ctx.flags.apscReactivationThreshold ?? 0.75),
+                            minActiveAgents: Number(ctx.flags.apscMinActiveAgents ?? 3),
+                            minSamples: Number(ctx.flags.apscMinSamples ?? 3),
+                            dryRun: ctx.flags.apscLive !== true,
+                        },
+                    } : {}),
                 },
                 metadata: {
                     v3Mode,
@@ -393,7 +419,10 @@ const initCommand = {
                     { property: 'Max Agents', value: result.config.maxAgents },
                     { property: 'Auto Scale', value: result.config.autoScaling ? 'Enabled' : 'Disabled' },
                     { property: 'Protocol', value: result.config.communicationProtocol || 'N/A' },
-                    { property: 'V3 Mode', value: v3Mode ? 'Enabled' : 'Disabled' }
+                    { property: 'V3 Mode', value: v3Mode ? 'Enabled' : 'Disabled' },
+                    ...(topology === 'pheromone-adaptive'
+                        ? [{ property: 'APSC Mode', value: ctx.flags.apscLive === true ? 'Live' : 'Dry run' }]
+                        : [])
                 ]
             });
             output.writeln();
@@ -924,15 +953,41 @@ const compressMessageCommand = {
         return { success: true, data: result };
     },
 };
+const pheromoneCommand = {
+    name: 'pheromone',
+    description: 'Inspect or update ADR-330 pheromone-adaptive scheduling state',
+    options: [
+        { name: 'agent-id', description: 'Agent identifier; omit to show status', type: 'string' },
+        { name: 'role', description: 'Agent role for role-local normalization', type: 'string' },
+        { name: 'task-success', description: 'Task success in [0,1]', type: 'number' },
+        { name: 'normalized-latency', description: 'Latency divided by budget in [0,1]', type: 'number' },
+        { name: 'consensus-alignment', description: 'Consensus alignment in [0,1]', type: 'number' },
+    ],
+    action: async (ctx) => {
+        const agentId = ctx.flags.agentId;
+        const data = agentId
+            ? await callMCPTool('swarm_pheromone_update', {
+                agentId,
+                role: String(ctx.flags.role ?? 'worker'),
+                taskSuccess: Number(ctx.flags.taskSuccess ?? 1),
+                normalizedLatency: Number(ctx.flags.normalizedLatency ?? 0),
+                consensusAlignment: Number(ctx.flags.consensusAlignment ?? 1),
+            })
+            : await callMCPTool('swarm_pheromone_status', {});
+        output.writeln(JSON.stringify(data, null, 2));
+        return { success: data.active !== false, data };
+    },
+};
 export const swarmCommand = {
     name: 'swarm',
     description: 'Swarm coordination commands',
-    subcommands: [initCommand, startCommand, statusCommand, stopCommand, scaleCommand, coordinateCommand, compressMessageCommand],
+    subcommands: [initCommand, startCommand, statusCommand, stopCommand, scaleCommand, coordinateCommand, compressMessageCommand, pheromoneCommand],
     options: [],
     examples: [
         { command: 'claude-flow swarm init --v3-mode', description: 'Initialize V3 swarm' },
         { command: 'claude-flow swarm start -o "Build API" -s development', description: 'Start development swarm' },
-        { command: 'claude-flow swarm coordinate --agents 15', description: 'V3 coordination' }
+        { command: 'claude-flow swarm coordinate --agents 15', description: 'V3 coordination' },
+        { command: 'claude-flow swarm pheromone', description: 'Inspect pheromone-adaptive scheduling state' }
     ],
     action: async (ctx) => {
         output.writeln();
@@ -947,7 +1002,8 @@ export const swarmCommand = {
             `${output.highlight('status')}      - Show swarm status`,
             `${output.highlight('stop')}        - Stop swarm execution`,
             `${output.highlight('scale')}       - Scale swarm agent count`,
-            `${output.highlight('coordinate')}  - V3 15-agent coordination`
+            `${output.highlight('coordinate')}  - V3 15-agent coordination`,
+            `${output.highlight('pheromone')}   - Inspect/update adaptive pheromone state`
         ]);
         return { success: true };
     }

package/dist/src/config-adapter.js

@@ -147,6 +147,7 @@ function normalizeTopology(topology) {
         case 'hierarchical-mesh':
             return topology;
         case 'adaptive':
+        case 'pheromone-adaptive':
             return 'hybrid';
         default:
             return 'hierarchical';

package/dist/src/index.js

@@ -196,8 +196,9 @@ export class CLI {
                     try {
                         const { ensureDaemonRunning } = await import('./services/daemon-autostart.js');
                         const d = ensureDaemonRunning(process.cwd());
-                        if (d.started && this.output.isVerbose())
-                            this.output.printDebug('Started background daemon (auto)');
+                        if (d.started) {
+                            this.output.printInfo(`Started Ruflo background daemon for ${process.cwd()} (stop: ruflo daemon stop)`);
+                        }
                     }
                     catch { /* silent */ }
                 }

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

@@ -9,6 +9,7 @@ import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
 import { validateIdentifier, validateText, validateAgentSpawn } from './validate-input.js';
 import { executeAgentTask } from './agent-execute-core.js';
+import { pheromoneAgentEligibility } from './swarm-tools.js';
 // Storage paths
 const STORAGE_DIR = '.claude-flow';
 const AGENT_DIR = 'agents';
@@ -383,6 +384,15 @@ export const agentTools = [
             const vP = validateText(input.prompt, 'prompt');
             if (!vP.valid)
                 return { success: false, error: `Input validation failed: ${vP.error}` };
+            const pheromone = pheromoneAgentEligibility(input.agentId);
+            if (!pheromone.eligible) {
+                return {
+                    success: false,
+                    agentId: input.agentId,
+                    suspended: true,
+                    error: pheromone.reason,
+                };
+            }
             // Delegate to the shared core (also used by the workflow runtime).
             return executeAgentTask({
                 agentId: input.agentId,

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

@@ -8,6 +8,7 @@ import { dirname, join, resolve } from 'path';
 import { getProjectCwd } from './types.js';
 import { validateIdentifier, validateText, validatePath } from './validate-input.js';
 import { checkCommandLoop, recordCommandOutcome } from './tool-loop-guardrail.js';
+import { buildLearnedRoutingPatterns, } from '../services/learned-routing.js';
 // Real vector search functions - lazy loaded to avoid circular imports
 let searchEntriesFn = null;
 /**
@@ -185,6 +186,13 @@ function saveRoutingOutcomes(outcomes) {
         // Cap at 500 entries to bound file size
         const capped = outcomes.slice(-500);
         writeFileSync(ROUTING_OUTCOMES_PATH, JSON.stringify({ outcomes: capped }, null, 2));
+        // A long-lived MCP process must observe the new label on the next route.
+        // The prior singleton cache made the learned store inert until restart.
+        semanticRouter = null;
+        nativeVectorDb = null;
+        semanticRouterInitialized = false;
+        routerBackend = 'none';
+        TASK_PATTERN_EMBEDDINGS.clear();
     }
     catch { /* non-critical */ }
 }
@@ -194,24 +202,7 @@ function saveRoutingOutcomes(outcomes) {
  * merged into both the native HNSW and pure-JS semantic routers.
  */
 function loadLearnedPatterns() {
-    const outcomes = loadRoutingOutcomes();
-    const byAgent = {};
-    for (const o of outcomes) {
-        if (!o.success || !o.agent || !o.keywords?.length)
-            continue;
-        if (!byAgent[o.agent])
-            byAgent[o.agent] = new Set();
-        for (const kw of o.keywords)
-            byAgent[o.agent].add(kw);
-    }
-    const patterns = {};
-    for (const [agent, kwSet] of Object.entries(byAgent)) {
-        patterns[`learned-${agent}`] = {
-            keywords: [...kwSet].slice(0, 50),
-            agents: [agent],
-        };
-    }
-    return patterns;
+    return buildLearnedRoutingPatterns(loadRoutingOutcomes());
 }
 /**
  * Merge static TASK_PATTERNS with runtime-learned patterns.
@@ -290,46 +281,55 @@ async function getSemanticRouter() {
     // STEP 1: Try native VectorDb from @ruvector/router (HNSW-backed)
     // Note: Native VectorDb uses a persistent database file which can have lock issues
     // in concurrent environments. We try it first but fall back gracefully to pure JS.
-    try {
-        // Use createRequire for ESM compatibility with native modules
-        const { createRequire } = await import('module');
-        const require = createRequire(import.meta.url);
-        const router = require('@ruvector/router');
-        if (router.VectorDb && router.DistanceMetric) {
-            // Try to create VectorDb - may fail with lock error in concurrent envs
-            const db = new router.VectorDb({
-                dimensions: 384,
-                distanceMetric: router.DistanceMetric.Cosine,
-                hnswM: 16,
-                hnswEfConstruction: 200,
-                hnswEfSearch: 100,
-            });
-            // Initialize with static + runtime-learned task patterns
-            for (const [patternName, { keywords }] of Object.entries(getMergedTaskPatterns())) {
-                for (const keyword of keywords) {
-                    const embedding = generateSimpleEmbedding(keyword);
-                    db.insert(`${patternName}:${keyword}`, embedding);
-                    TASK_PATTERN_EMBEDDINGS.set(`${patternName}:${keyword}`, embedding);
+    // Deterministic/test and lock-constrained environments may force the
+    // pure-JS router; production continues to prefer the native backend.
+    if (process.env.CLAUDE_FLOW_DISABLE_NATIVE_ROUTER !== '1')
+        try {
+            // Use createRequire for ESM compatibility with native modules
+            const { createRequire } = await import('module');
+            const require = createRequire(import.meta.url);
+            const router = require('@ruvector/router');
+            if (router.VectorDb && router.DistanceMetric) {
+                // Try to create VectorDb - may fail with lock error in concurrent envs
+                const db = new router.VectorDb({
+                    dimensions: 384,
+                    distanceMetric: router.DistanceMetric.Cosine,
+                    hnswM: 16,
+                    hnswEfConstruction: 200,
+                    hnswEfSearch: 100,
+                });
+                // Initialize with static + runtime-learned task patterns
+                for (const [patternName, { keywords }] of Object.entries(getMergedTaskPatterns())) {
+                    for (const keyword of keywords) {
+                        const embedding = generateSimpleEmbedding(keyword);
+                        db.insert(`${patternName}:${keyword}`, embedding);
+                        TASK_PATTERN_EMBEDDINGS.set(`${patternName}:${keyword}`, embedding);
+                    }
                 }
+                nativeVectorDb = db;
+                routerBackend = 'native';
+                console.log('[hooks] Semantic router initialized: native VectorDb (HNSW, 16k+ routes/s)');
+                return { router: null, backend: routerBackend, native: nativeVectorDb };
             }
-            nativeVectorDb = db;
-            routerBackend = 'native';
-            console.log('[hooks] Semantic router initialized: native VectorDb (HNSW, 16k+ routes/s)');
-            return { router: null, backend: routerBackend, native: nativeVectorDb };
         }
-    }
-    catch (err) {
-        // Native not available or database locked - fall back to pure JS
-        // Common errors: "Database already open. Cannot acquire lock." or "MODULE_NOT_FOUND"
-        // This is expected in concurrent environments or when binary isn't installed
-    }
+        catch (err) {
+            // Native not available or database locked - fall back to pure JS
+            // Common errors: "Database already open. Cannot acquire lock." or "MODULE_NOT_FOUND"
+            // This is expected in concurrent environments or when binary isn't installed
+        }
     // STEP 2: Fall back to pure JS SemanticRouter
     try {
         const { SemanticRouter } = await import('../ruvector/semantic-router.js');
         semanticRouter = new SemanticRouter({ dimension: 384 });
-        for (const [patternName, { keywords, agents }] of Object.entries(getMergedTaskPatterns())) {
+        for (const [patternName, { keywords, agents, source, support, reliability }] of Object.entries(getMergedTaskPatterns())) {
             const embeddings = keywords.map(kw => generateSimpleEmbedding(kw));
-            semanticRouter.addIntentWithEmbeddings(patternName, embeddings, { agents, keywords });
+            semanticRouter.addIntentWithEmbeddings(patternName, embeddings, {
+                agents,
+                keywords,
+                source: source ?? 'static',
+                support,
+                reliability,
+            });
             // Cache embeddings for keywords
             keywords.forEach((kw, i) => {
                 TASK_PATTERN_EMBEDDINGS.set(kw, embeddings[i]);
@@ -946,6 +946,9 @@ export const hooksRoute = {
                         score: 1 - r.score, // Native uses distance (lower is better), convert to similarity
                         metadata: {
                             agents: pattern?.agents || (patternName.startsWith('learned-') ? [patternName.slice(8)] : ['coder']),
+                            source: pattern?.source ?? (patternName.startsWith('learned-') ? 'learned' : 'static'),
+                            support: pattern?.support,
+                            reliability: pattern?.reliability,
                         },
                     };
                 });
@@ -966,8 +969,18 @@ export const hooksRoute = {
         let agents;
         let confidence;
         let matchedPattern = '';
-        if (semanticResult.length > 0 && semanticResult[0].score > 0.4) {
-            const topMatch = semanticResult[0];
+        const eligibleSemantic = semanticResult.find((match) => {
+            if (match.score <= 0.4)
+                return false;
+            const learned = match.intent.startsWith('learned-') || match.metadata.source === 'learned';
+            if (!learned)
+                return true;
+            return match.score >= 0.65
+                && Number(match.metadata.support ?? 0) >= 2
+                && Number(match.metadata.reliability ?? 0) >= 0.75;
+        });
+        if (eligibleSemantic) {
+            const topMatch = eligibleSemantic;
             agents = topMatch.metadata.agents || ['coder', 'researcher'];
             confidence = topMatch.score;
             matchedPattern = topMatch.intent;
@@ -1249,6 +1262,10 @@ export const hooksPostTask = {
             agent: { type: 'string', description: 'Agent that completed the task' },
             quality: { type: 'number', description: 'Quality score (0-1)' },
             task: { type: 'string', description: 'Task description text (used for learning keyword extraction)' },
+            duration: { type: 'number', description: 'Observed task duration in milliseconds (used by pheromone-adaptive topology)' },
+            latencyBudgetMs: { type: 'number', description: 'Latency budget used to normalize duration (default 60000ms)' },
+            consensusAlignment: { type: 'number', description: 'Agreement with accepted swarm consensus in [0,1] (default quality)' },
+            agentRole: { type: 'string', description: 'Role for role-local pheromone normalization (default agent)' },
             storeDecisions: { type: 'boolean', description: 'Also store routing decision in memory DB' },
             // ADR-147 P2: nested-subagent spawn-tree capture
             parentAgentId: { type: 'string', description: 'ID of the parent agent (from Claude Code\'s parent_agent_id OTel span tag / x-claude-code-parent-agent-id header). Omit for top-level work.' },
@@ -1405,6 +1422,22 @@ export const hooksPostTask = {
             }
             catch { /* non-critical */ }
         }
+        let pheromone;
+        if (agent) {
+            try {
+                const { recordSwarmPheromoneSignal } = await import('./swarm-tools.js');
+                const observedDuration = Math.max(0, Number(params.duration ?? (Date.now() - startTime)));
+                const latencyBudgetMs = Math.max(1, Number(params.latencyBudgetMs ?? 60_000));
+                pheromone = recordSwarmPheromoneSignal({
+                    agentId: agent,
+                    role: String(params.agentRole ?? agent),
+                    taskSuccess: success ? 1 : 0,
+                    normalizedLatency: Math.max(0, Math.min(1, observedDuration / latencyBudgetMs)),
+                    consensusAlignment: Math.max(0, Math.min(1, Number(params.consensusAlignment ?? quality))),
+                });
+            }
+            catch { /* no active APSC swarm or optional path unavailable */ }
+        }
         const duration = Date.now() - startTime;
         // Persist to auto-memory-store for statusline visibility
         try {
@@ -1444,6 +1477,7 @@ export const hooksPostTask = {
                 outcomePersisted,
             },
             quality,
+            pheromone,
             feedback: feedbackResult ? {
                 recorded: feedbackResult.success,
                 controller: feedbackResult.controller,

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

@@ -1175,6 +1175,7 @@ export const memoryTools = [
         handler: async (input) => {
             await ensureInitialized();
             const { listEntries, deleteEntry } = await getMemoryFunctions();
+            const startedAt = Date.now();
             const dryRun = input.dryRun !== false; // default true
             const namespace = input.namespace ? String(input.namespace) : undefined;
             if (namespace) {
@@ -1193,6 +1194,7 @@ export const memoryTools = [
             });
             let freedBytes = 0;
             let deleted = 0;
+            let vectorsRemoved = 0;
             if (!dryRun) {
                 for (const e of expired) {
                     try {
@@ -1206,11 +1208,21 @@ export const memoryTools = [
             else {
                 freedBytes = expired.reduce((s, e) => s + (e.size || 0), 0);
             }
+            if (!dryRun) {
+                const { reconcileHNSWIndex } = await import('../memory/memory-initializer.js');
+                vectorsRemoved = await reconcileHNSWIndex();
+            }
+            const formatted = freedBytes < 1024
+                ? `${freedBytes} B`
+                : freedBytes < 1024 * 1024
+                    ? `${(freedBytes / 1024).toFixed(1)} KiB`
+                    : `${(freedBytes / (1024 * 1024)).toFixed(1)} MiB`;
             return {
                 dryRun,
                 candidates: { expired: expired.length, stale: 0, lowQuality: 0, total: expired.length },
-                deleted: { entries: dryRun ? 0 : deleted, vectors: 0, patterns: 0 },
-                freed: { bytes: freedBytes },
+                deleted: { entries: dryRun ? 0 : deleted, vectors: vectorsRemoved, patterns: 0 },
+                freed: { bytes: freedBytes, formatted },
+                duration: Date.now() - startedAt,
                 note: dryRun ? 'dry run — re-run with dryRun:false to delete' : undefined,
             };
         },

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

@@ -700,6 +700,9 @@ export const metaharnessTools = [
                 confirm: { type: 'boolean', description: 'Required for promote; never inferred', default: false },
                 maxConcurrency: { type: 'number', description: 'ADR-324 hard local candidate-evaluation concurrency cap (1-8)', default: 2 },
                 timeoutMs: { type: 'number', description: 'Abort concurrent evaluation after this wall-clock limit', default: 120000 },
+                anchorPath: { type: 'string', description: 'Project-contained human-labelled anchor JSON; requires anchorHash' },
+                anchorHash: { type: 'string', description: 'Pinned sha256 of canonical anchor tasks; requires anchorPath' },
+                anchorManifestPath: { type: 'string', description: 'Project-contained anchor manifest path (default .claude/eval/flywheel-anchor.manifest.json)' },
                 approvalIds: { type: 'array', items: { type: 'string' }, description: 'Scoped ADR-324 approval IDs for privileged promotion' },
             },
             required: ['operation'],
@@ -721,6 +724,7 @@ export const metaharnessTools = [
             if (operation === 'receipts') {
                 const data = listFlywheelReceipts(projectRoot).map(({ receipt, state }) => ({
                     receiptId: receipt.payload.receiptId,
+                    anchorRef: receipt.payload.anchorRef,
                     candidateId: receipt.payload.candidateId,
                     baselineRef: receipt.payload.baselineRef,
                     decision: receipt.payload.decision,
@@ -748,6 +752,9 @@ export const metaharnessTools = [
                     receiptPublicKeyPem: publicKeyPath ? readFileSync(publicKeyPath, 'utf8') : undefined,
                     maxConcurrency: Number(input.maxConcurrency ?? 2),
                     evaluationTimeoutMs: Number(input.timeoutMs ?? 120_000),
+                    anchorPath: input.anchorPath ? String(input.anchorPath) : undefined,
+                    anchorHash: input.anchorHash ? String(input.anchorHash) : undefined,
+                    anchorManifestPath: input.anchorManifestPath ? String(input.anchorManifestPath) : undefined,
                 });
                 return { success: data.ran, data, degraded: false, exitCode: data.ran ? 0 : 1 };
             }

package/dist/src/mcp-tools/swarm-tools.d.ts

@@ -5,6 +5,7 @@
  * Replaces previous stub implementations with real state tracking.
  */
 import { type MCPTool } from './types.js';
+import { type ApscDecision, type ApscSignal } from '../services/pheromone-adaptive.js';
 interface SwarmState {
     swarmId: string;
     topology: string;
@@ -32,6 +33,21 @@ interface SwarmStore {
 }
 export declare function loadSwarmStore(): SwarmStore;
 export declare function saveSwarmStore(store: SwarmStore): void;
+/** Shared by hooks_post-task so outcome labels immediately drive APSC. */
+export declare function recordSwarmPheromoneSignal(signal: ApscSignal): {
+    active: false;
+    reason: string;
+} | {
+    active: true;
+    swarmId: string;
+    decision: ApscDecision;
+};
+/** Scheduling gate used by agent_execute. Dry-run topologies remain eligible. */
+export declare function pheromoneAgentEligibility(agentId: string): {
+    eligible: boolean;
+    active: boolean;
+    reason?: string;
+};
 export declare const swarmTools: MCPTool[];
 export {};
 //# sourceMappingURL=swarm-tools.d.ts.map