@claude-flow/cli 3.41.4 → 3.42.1

package/.claude/helpers/.helpers-version

@@ -1 +1 @@
-3.38.20
+3.42.0

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

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.41.4",
+    "version": "3.42.1",
     "files": {
       "auto-memory-hook.mjs": "85fe05c757421c52137c0bc8545a0896bab6b4714538c2a11d1d0835bfcc8c1c",
       "hook-handler.cjs": "209d9fafe10e17d1be0866727f6f9cf9ac66f9a0793f1c793a4f58319e8e4583",
@@ -8,6 +8,6 @@
       "statusline.cjs": "4a48353b4f1566fa4379b00fd0321b6676a22b6cc91fbbd8380ac5183d619468"
     }
   },
-  "signature": "QbsQi7C+pl+Nam2mKSa0FmTWyFKbZnNzLGltRMREMq/BGR4U6klP43oN0eYzVHQCwQiUKz4YOsPo1CEfjVCcDA==",
+  "signature": "dp+TQNrg1n2wi3wjdGNFDBLjRnKSN7vuEvm4z8IC6Vmzlfh4DaTHX4sozhmxAt5GeVcLxjEq6urtK8s0vUADCQ==",
   "algorithm": "ed25519"
 }

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 6,
-  "generatedAt": "2026-09-14T18:42:55.817Z",
-  "gitSha": "dfd65965",
+  "generatedAt": "2026-09-16T02:31:10.655Z",
+  "gitSha": "6debd741",
   "catalog": {
     "agents": 167,
     "tools": 418,

package/dist/src/commands/doctor.d.ts

@@ -5,6 +5,13 @@
  * Created with ruv.io
  */
 import type { Command } from '../types.js';
+interface HealthCheck {
+    name: string;
+    status: 'pass' | 'warn' | 'fail';
+    message: string;
+    fix?: string;
+}
+export declare function checkMemoryPersistenceDriver(): Promise<HealthCheck>;
 export declare const doctorCommand: Command;
 export default doctorCommand;
 //# sourceMappingURL=doctor.d.ts.map

package/dist/src/commands/doctor.js

@@ -506,23 +506,13 @@ async function checkMemoryStructuralIntegrity() {
         catch { /* best-effort */ }
     }
 }
-// #2968 option 1 — read-only doctor check for the active SQLite driver.
-//
-// Native better-sqlite3 (durable, WAL-capable) can silently degrade to the
-// sql.js WASM fallback (non-durable — `wal_checkpoint` calls are rejected
-// and the write is lost) when a postinstall script is skipped. `memory
-// store` still printed "Data stored successfully" before the persistWarning
-// fix in #2983/3.38.1 (see memory-store-persist-warning-2968.test.ts); this
-// check gives a standing, read-only signal so the driver split is visible
-// any time doctor runs, independent of any single store call.
-//
-// Table count in the on-disk memory.db is the cheap, reliable signal from
-// the issue report: the native driver's schema produces 47 tables, the
-// sql.js fallback's produces only 10. Deliberately does NOT change install
-// behavior (that's option 2 from #2968, explicitly out of scope here) —
-// this only reports, it never repairs.
-const MEMORY_DRIVER_NATIVE_TABLE_FLOOR = 20; // roughly midpoint of sql.js's ~10 and native's ~47
-async function checkMemoryPersistenceDriver() {
+// #2968/#3321 — read-only native SQLite capability probe. A skipped
+// postinstall can leave the wrapper importable but its binding unavailable.
+// Schema size cannot identify the runtime driver or the database's history:
+// memory init creates its schema with sql.js even when native is available.
+// This probe does not verify schema compatibility or cross-process writes;
+// integrity checks and memory store's persistWarning retain their own roles.
+export async function checkMemoryPersistenceDriver() {
     const NAME = 'Memory Persistence Driver';
     const dbPath = await resolveMemoryDbPath();
     if (!dbPath) {
@@ -549,6 +539,7 @@ async function checkMemoryPersistenceDriver() {
     let tableCount = null;
     let nativeUnavailableReason = null;
     let nativeOpenOtherError = null;
+    let nativeQueryError = null;
     if (Database) {
         let db;
         try {
@@ -566,10 +557,15 @@ async function checkMemoryPersistenceDriver() {
         if (db) {
             try {
                 const row = db.prepare("SELECT count(*) AS c FROM sqlite_master WHERE type='table'").get();
-                tableCount = Number(row?.c ?? 0);
+                if (typeof row?.c === 'number' && Number.isSafeInteger(row.c) && row.c >= 0) {
+                    tableCount = row.c;
+                }
+                else {
+                    nativeQueryError = 'query returned no reliable table count';
+                }
             }
-            catch {
-                // leave null — Memory Integrity above already reports open/query failures
+            catch (e) {
+                nativeQueryError = e.message || String(e);
             }
             finally {
                 try {
@@ -589,7 +585,10 @@ async function checkMemoryPersistenceDriver() {
         if (sdb) {
             try {
                 const res = sdb.exec("SELECT count(*) FROM sqlite_master WHERE type='table'");
-                tableCount = Number(res[0]?.values?.[0]?.[0] ?? 0);
+                const count = res[0]?.values?.[0]?.[0];
+                if (typeof count === 'number' && Number.isSafeInteger(count) && count >= 0) {
+                    tableCount = count;
+                }
             }
             catch {
                 // leave null
@@ -604,12 +603,12 @@ async function checkMemoryPersistenceDriver() {
     }
     const tableSummary = tableCount === null
         ? 'table count unavailable'
-        : `${tableCount} tables (native schema ~47, sql.js-fallback schema ~10 — #2968)`;
+        : `${tableCount} tables`;
     if (nativeUnavailableReason) {
         return {
             name: NAME,
             status: 'warn',
-            message: `${dbPath} — active driver: sql.js (WASM fallback, non-durable) — native better-sqlite3 binding unavailable: ${nativeUnavailableReason} — wal_checkpoint calls silently no-op, writes may not persist across processes (#2968/#2867/#2219) [${tableSummary}]`,
+            message: `${dbPath} — native better-sqlite3 binding unavailable: ${nativeUnavailableReason} — native read-only probe unavailable; runtime driver and write persistence not verified (#2968) [${tableSummary}; sql.js main-image-only fallback]`,
             fix: 'reinstall with npm install scripts enabled, or run `npm rebuild better-sqlite3`; then rerun this check',
         };
     }
@@ -620,18 +619,17 @@ async function checkMemoryPersistenceDriver() {
             message: `${dbPath} — native better-sqlite3 module loadable, but could not open this database (${nativeOpenOtherError}) — see Memory Integrity above for the corruption/encryption diagnosis [${tableSummary}]`,
         };
     }
-    if (tableCount !== null && tableCount < MEMORY_DRIVER_NATIVE_TABLE_FLOOR) {
+    if (nativeQueryError || tableCount === null) {
         return {
             name: NAME,
             status: 'warn',
-            message: `${dbPath} — active driver: native better-sqlite3, but this database has only ${tableCount} tables — that matches the sql.js-fallback schema shape (~10), not the native schema (~47); it was likely created before the native binding became available, and durable writes made before then may be missing`,
-            fix: 'back up .swarm/memory.db then `claude-flow memory init --force` to rebuild under the native driver',
+            message: `${dbPath} — native better-sqlite3 opened read-only, but table count unavailable: ${nativeQueryError ?? 'query returned no reliable result'}; runtime driver and write persistence not verified`,
         };
     }
     return {
         name: NAME,
         status: 'pass',
-        message: `${dbPath} — active driver: native better-sqlite3 (durable, WAL-capable) [${tableSummary}]`,
+        message: `${dbPath} — native better-sqlite3 read-only open and schema query succeeded [${tableSummary}]; runtime driver, schema compatibility, and write persistence not verified`,
     };
 }
 // Check 1 (--component memory, deep path) — #2737 part 2 strengthens this:
@@ -2011,20 +2009,45 @@ async function checkMetaharnessDeclaredPackages() {
 }
 async function checkMetaharness() {
     try {
-        const version = await runCommand('npx -y metaharness@latest --version 2>&1', 15000);
-        // metaharness emits multi-line stdout; parse a version-shaped line.
-        const versionMatch = version.match(/(\d+\.\d+\.\d+)/);
-        if (!versionMatch) {
+        // `metaharness` has no --version flag (it falls through to the usage
+        // banner, which never matches a version regex) and shelling out via
+        // `npx metaharness@latest` ignores the installed version and hits the
+        // network every run. Resolve the version from the installed package's
+        // own package.json instead. `import.meta.resolve` is the reliable route:
+        // `require('metaharness/package.json')` is blocked by the package's
+        // `exports` map, and `createRequire().resolve()` fails on its ESM-only
+        // entry point.
+        const resolved = import.meta.resolve('metaharness');
+        let dir = dirname(fileURLToPath(resolved));
+        let version = null;
+        for (let i = 0; i < 8; i++) {
+            const pj = join(dir, 'package.json');
+            if (existsSync(pj)) {
+                try {
+                    const j = JSON.parse(readFileSync(pj, 'utf-8'));
+                    if (j.name === 'metaharness') {
+                        version = j.version ?? null;
+                        break;
+                    }
+                }
+                catch { /* keep walking */ }
+            }
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        if (!version) {
             return {
                 name: 'MetaHarness (ADR-150)',
                 status: 'warn',
-                message: 'Installed but version-string not parseable; integration may still work',
+                message: 'Installed but its package.json was not found while walking up from the resolved module; integration may still work',
             };
         }
         return {
             name: 'MetaHarness (ADR-150)',
             status: 'pass',
-            message: `v${versionMatch[1]} — run \`npx ruflo metaharness score\` for the full scorecard`,
+            message: `v${version} — run \`npx ruflo metaharness score\` for the full scorecard`,
         };
     }
     catch {
@@ -2348,7 +2371,7 @@ export const doctorCommand = {
             checkDaemonStatus,
             checkMemoryDatabase,
             checkMemoryStructuralIntegrity, // #2737 — bounded, native quick_check on every default run
-            checkMemoryPersistenceDriver, // #2968 — native better-sqlite3 vs sql.js fallback, read-only
+            checkMemoryPersistenceDriver, // #2968/#3321 — read-only native capability probe
             checkLearningBridge, // #2545 — can the auto-memory hook actually load @claude-flow/memory?
             checkApiKeys,
             checkMcpServers,
@@ -2386,7 +2409,7 @@ export const doctorCommand = {
             'memory': [
                 checkMemoryDatabase, // existing: exists + statable (unchanged)
                 checkMemoryIntegrity, // #2677 check 1: sql.js open + PRAGMA integrity_check
-                checkMemoryPersistenceDriver, // #2968: native better-sqlite3 vs sql.js fallback
+                checkMemoryPersistenceDriver, // #2968/#3321: read-only native capability probe
                 checkMemoryContent, // #2677 check 2: memory_entries content coverage
                 checkMemoryEmbeddingCoverage, // #2677 check 3: vector coverage on populated rows
                 checkMemoryReflexionCoverage, // #2677 check 6: episodes are retrievable

package/dist/src/commands/hive-mind.js

@@ -13,6 +13,7 @@ import { mkdir, writeFile } from 'fs/promises';
 import { existsSync } from 'fs';
 import { join } from 'path';
 import { resolveClaudeLaunchCommand } from '../runtime/claude-command.js';
+import { getHiveTokenForCli } from '../mcp-tools/hive-mind-tools.js';
 // Hive topologies
 const TOPOLOGIES = [
     { value: 'hierarchical', label: 'Hierarchical', hint: 'Queen-led with worker agents' },
@@ -977,7 +978,7 @@ const joinCommand = {
             return { success: false, exitCode: 1 };
         }
         try {
-            const result = await callMCPTool('hive-mind_join', { agentId, role: ctx.flags.role });
+            const result = await callMCPTool('hive-mind_join', { agentId, role: ctx.flags.role, hiveToken: getHiveTokenForCli() });
             if (!result.success) {
                 output.printError(result.error || 'Failed');
                 return { success: false, exitCode: 1 };
@@ -1003,7 +1004,7 @@ const leaveCommand = {
             return { success: false, exitCode: 1 };
         }
         try {
-            const result = await callMCPTool('hive-mind_leave', { agentId });
+            const result = await callMCPTool('hive-mind_leave', { agentId, hiveToken: getHiveTokenForCli() });
             if (!result.success) {
                 output.printError(result.error || 'Failed');
                 return { success: false, exitCode: 1 };
@@ -1032,7 +1033,7 @@ const consensusCommand = {
     action: async (ctx) => {
         const action = ctx.flags.action || 'list';
         try {
-            const result = await callMCPTool('hive-mind_consensus', { action, proposalId: ctx.flags.proposalId, type: ctx.flags.type, value: ctx.flags.value, vote: ctx.flags.vote === 'yes', voterId: ctx.flags.voterId });
+            const result = await callMCPTool('hive-mind_consensus', { action, proposalId: ctx.flags.proposalId, type: ctx.flags.type, value: ctx.flags.value, vote: ctx.flags.vote === 'yes', voterId: ctx.flags.voterId, hiveToken: getHiveTokenForCli() });
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
                 return { success: true, data: result };

package/dist/src/commands/swarm.js

@@ -8,6 +8,56 @@ import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { swarmJoinCommand } from './agntcy/swarm-join.js';
 import * as fs from 'fs';
 import * as path from 'path';
+// Read the CLI-side swarm state file (`.swarm/state.json`), written by
+// `swarm init` and rewritten by `swarm start` / `swarm stop`.
+function readLocalSwarmState() {
+    const swarmStateFile = path.join(process.cwd(), '.swarm', 'state.json');
+    if (!fs.existsSync(swarmStateFile))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(swarmStateFile, 'utf-8'));
+    }
+    catch {
+        // Ignore parse errors
+        return null;
+    }
+}
+// Resolve the id of the current swarm. Three writers persist it, under two
+// different keys and in two different files:
+//
+//   `.swarm/state.json`                    `id`                 ← `swarm init`
+//   `.swarm/state.json`                    `swarmId`            ← `swarm start`
+//   `.claude-flow/swarm/swarm-state.json`  `swarms[id].swarmId` ← MCP `swarm_init`
+//
+// The status payload used to read only the first key of the first file, so a
+// Claude Code session (which drives the MCP path) reported an active swarm
+// with agents but no usable id. Check every writer, most local first.
+function resolveSwarmId(swarmState) {
+    // A state file left behind by a previous `swarm stop` must not shadow a
+    // swarm that is still live in the MCP store — otherwise `stop` names the
+    // dead id while `swarm_shutdown`'s own "most recent running" fallback
+    // terminates a different swarm.
+    if (swarmState?.status !== 'stopped') {
+        const fromState = swarmState?.id ?? swarmState?.swarmId;
+        if (typeof fromState === 'string' && fromState)
+            return fromState;
+    }
+    try {
+        const storePath = path.join(process.cwd(), '.claude-flow', 'swarm', 'swarm-state.json');
+        if (!fs.existsSync(storePath))
+            return null;
+        const store = JSON.parse(fs.readFileSync(storePath, 'utf-8'));
+        // Most recently updated swarm that has not been shut down.
+        const live = Object.values(store.swarms ?? {})
+            .filter(swarm => swarm.status !== 'terminated')
+            .sort((a, b) => new Date(b.updatedAt ?? 0).getTime() - new Date(a.updatedAt ?? 0).getTime());
+        return live[0]?.swarmId ?? null;
+    }
+    catch {
+        // Ignore — an unreadable MCP store just means no id to resolve.
+        return null;
+    }
+}
 // Get dynamic swarm status from memory/session files
 function getSwarmStatus(swarmId) {
     const swarmDir = path.join(process.cwd(), '.swarm');
@@ -17,16 +67,7 @@ function getSwarmStatus(swarmId) {
         path.join(process.cwd(), '.claude', 'memory.db'),
     ];
     // Check for active swarm state file
-    const swarmStateFile = path.join(swarmDir, 'state.json');
-    let swarmState = null;
-    if (fs.existsSync(swarmStateFile)) {
-        try {
-            swarmState = JSON.parse(fs.readFileSync(swarmStateFile, 'utf-8'));
-        }
-        catch {
-            // Ignore parse errors
-        }
-    }
+    const swarmState = readLocalSwarmState();
     // Count active agents from process files
     let activeAgents = 0;
     let totalAgents = 0;
@@ -175,10 +216,22 @@ function getSwarmStatus(swarmId) {
         status = 'completed';
     }
     else if (swarmState) {
-        status = 'ready';
+        // The file's own lifecycle state wins over the "a file exists, so we are
+        // ready" default — a swarm explicitly recorded as stopped is not ready.
+        // Live agents still win above: they are observed reality, whereas the file
+        // records an intent that may be stale.
+        status = swarmState.status === 'stopped' ? 'stopped' : 'ready';
     }
+    // Resolve once — the id also settles whether there is a swarm to report.
+    // An MCP `swarm_init` with no agents spawned yet leaves no `.swarm/state.json`
+    // and no agent store, so without this the payload contradicted itself:
+    // a real `id` alongside `hasActiveSwarm: false`.
+    const resolvedId = swarmId || resolveSwarmId(swarmState);
     return {
-        id: swarmId || swarmState?.id || 'no-active-swarm',
+        // `null` when genuinely unknown — never a sentinel string. `status` and
+        // `hasActiveSwarm` already carry the "no active swarm" fact, and a
+        // consumer reading `.id` must get an id or nothing.
+        id: resolvedId,
         topology: swarmState?.topology || 'none',
         status,
         objective: swarmState?.objective || 'No active objective',
@@ -290,7 +343,13 @@ function getSwarmStatus(swarmId) {
             }
             return { consensusRounds, messagesSent, conflictsResolved };
         })(),
-        hasActiveSwarm: !!swarmState || totalAgents > 0
+        // A state file left behind by `swarm stop` is not an active swarm — without
+        // this it claimed one it could not name (`id: null`, zero agents), which is
+        // the same contradiction from the other side. Live agents or a resolvable
+        // id still count, so a stopped file never masks real activity.
+        hasActiveSwarm: (!!swarmState && swarmState.status !== 'stopped')
+            || totalAgents > 0
+            || resolvedId !== null
     };
 }
 // Swarm topologies
@@ -630,6 +689,9 @@ const startCommand = {
         if (!fs.existsSync(swarmDir))
             fs.mkdirSync(swarmDir, { recursive: true });
         const executionState = {
+            // `id` mirrors what `swarm init` writes so both files share one key;
+            // `swarmId` stays for existing files and readers.
+            id: swarmId,
             swarmId,
             objective,
             strategy,
@@ -673,7 +735,7 @@ const statusCommand = {
             output.writeln();
             return { success: true, data: status };
         }
-        output.writeln(output.bold(`Swarm Status: ${status.id}`));
+        output.writeln(output.bold(`Swarm Status: ${status.id ?? output.dim('unknown id')}`));
         output.writeln();
         // Progress bar
         output.writeln(`Overall Progress: ${output.progressBar(status.progress, 100, 40)}`);
@@ -747,10 +809,16 @@ const stopCommand = {
         }
     ],
     action: async (ctx) => {
-        const swarmId = ctx.args[0];
+        // Bare `swarm stop` used to hard-fail, and no CLI surface handed out an
+        // id to pass (there is no `swarm list`). Default to the persisted swarm;
+        // an explicit argument still wins.
+        const swarmId = ctx.args[0] || resolveSwarmId(readLocalSwarmState());
         const force = ctx.flags.force;
         if (!swarmId) {
-            output.printError('Swarm ID is required');
+            output.printError('No swarm found to stop');
+            output.writeln(output.dim('  Find an id with: claude-flow swarm status --format json   (the "id" field)'));
+            output.writeln(output.dim('  Or pass one:     claude-flow swarm stop <swarm-id>'));
+            output.writeln(output.dim('  Or start one:    claude-flow swarm init'));
             return { success: false, exitCode: 1 };
         }
         if (ctx.interactive && !force) {
@@ -810,11 +878,14 @@ const scaleCommand = {
         }
     ],
     action: async (ctx) => {
-        const swarmId = ctx.args[0];
+        // Same resolution as `stop` — the id is persisted, so don't demand it.
+        const swarmId = ctx.args[0] || resolveSwarmId(readLocalSwarmState());
         const targetAgents = ctx.flags.agents;
         const agentType = ctx.flags.type;
         if (!swarmId) {
-            output.printError('Swarm ID is required');
+            output.printError('No swarm found to scale');
+            output.writeln(output.dim('  Find an id with: claude-flow swarm status --format json   (the "id" field)'));
+            output.writeln(output.dim('  Or pass one:     claude-flow swarm scale <swarm-id> --agents N'));
             return { success: false, exitCode: 1 };
         }
         if (!targetAgents) {

package/dist/src/init/claudemd-generator.js

@@ -258,7 +258,7 @@ function performanceSection() {
 
 - Always benchmark before AND after optimization
 - Always profile before optimizing — never guess bottlenecks
-- Use HNSW/DiskANN for vector search, Int8 quantization for memory reduction
+- Use HNSW for vector search, Int8 quantization for memory reduction — measure the actual speedup/recall on your own corpus via \`node scripts/benchmark-intelligence.mjs --only=hnsw\` rather than trusting a hardcoded multiplier (recall@10 varies by corpus size — 0.99 at N=5k, 0.92 at N=20k on the reference host, dream-cycle 2026-08-30)
 
 \`\`\`bash
 npx @claude-flow/cli@latest performance benchmark --suite all
@@ -293,7 +293,7 @@ function intelligenceSystem() {
 Pipeline: **RETRIEVE** (vector search) → **JUDGE** (success/failure) → **DISTILL** (extract patterns) → **CONSOLIDATE** (persist)
 
 - **ONNX Embeddings**: all-MiniLM-L6-v2, 384-dim
-- **HNSW/DiskANN**: 150x-12,500x faster search
+- **HNSW**: faster than brute-force search, magnitude scales with corpus size — reproduce with \`node scripts/benchmark-intelligence.mjs --only=hnsw\` rather than a hardcoded multiplier
 - **SONA**: Sub-millisecond pattern adaptation
 - **Claude Bridge**: Auto-imports \`~/.claude/projects/*/memory/*.md\` into AgentDB`;
 }

package/dist/src/mcp-server.js

@@ -26,6 +26,7 @@ import * as os from 'os';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { trackRequest } from './mcp-tools/request-tracker.js';
+import { isPolicyEnforcementEnabled, loadMcpPolicy, evaluateToolCall, } from './mcp-tools/policy-enforcer.js';
 // ESM-compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -503,6 +504,17 @@ export class MCPServerManager extends EventEmitter {
                             error: { code: -32601, message: `Tool not found: ${toolName}` },
                         };
                     }
+                    if (isPolicyEnforcementEnabled()) {
+                        const check = evaluateToolCall(loadMcpPolicy(), sessionId, toolName);
+                        if (!check.allowed) {
+                            trackRequest(toolName, false);
+                            return {
+                                jsonrpc: '2.0',
+                                id: message.id,
+                                error: { code: -32001, message: `Policy denied: ${check.reason}` },
+                            };
+                        }
+                    }
                     try {
                         const result = await callMCPTool(toolName, toolParams, { sessionId });
                         trackRequest(toolName, true);

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

@@ -35,5 +35,20 @@
  * @module @claude-flow/cli/mcp-tools/agentbbs
  */
 import type { MCPTool } from './types.js';
+/** Last envelope's seq by scanning only the file tail; full-read fallback keeps it exact. */
+export declare function nextSeq(path: string): number;
+/** Timestamp (ms) of the most recent PeerHello for a room, or -Infinity if none. */
+export declare function lastPeerHelloMs(logPath: string): number;
+/**
+ * Whether a `register` call should append a PeerHello: only for a genuinely new
+ * registration, or once the heartbeat window has elapsed since the last one.
+ * A re-register within the window is a retry and must NOT spam a near-identical
+ * hello. Pure — the decision the handler makes, exported for test.
+ */
+export declare function shouldEmitHello(alreadyRegistered: boolean, nowMs: number, lastHelloMs: number, windowSecs: number): boolean;
+/** Collapse duplicate envelopeIds, preserving order (first occurrence wins). Pure. */
+export declare function dedupEnvelopes<T extends {
+    envelopeId: string;
+}>(list: T[]): T[];
 export declare const agentbbsTools: MCPTool[];
 //# sourceMappingURL=agentbbs-tools.d.ts.map