@claude-flow/cli 3.71.3 → 3.72.0

package/dist/src/mcp-protocol.d.ts

@@ -0,0 +1,90 @@
+/**
+ * MCP protocol-version handling for the stdio servers (ADR-524).
+ *
+ * Ruflo ships three stdio entry points (`bin/cli.js` auto-detect, `bin/mcp-server.js`,
+ * and `MCPServerManager` in mcp-server.ts). All three answered `initialize` with a
+ * hardcoded `2024-11-05` and knew nothing of the 2026-07-28 revision, which drops the
+ * handshake and carries the version on every request. This module is the one place
+ * that decides which revision a message speaks, so the three handlers cannot drift.
+ *
+ * Dual-era behaviour (spec: basic/versioning):
+ *  - `initialize` selects legacy semantics; the requested legacy version is echoed.
+ *  - a request carrying `_meta["io.modelcontextprotocol/protocolVersion"]` is served
+ *    statelessly: `resultType` and `serverInfo` on every result, cache hints on lists,
+ *    `-32602` for an unknown resource, `-32022` for an unsupported version.
+ *  - `server/discover` is always answered, so a dual-era client's stdio probe succeeds.
+ */
+export declare const MODERN_PROTOCOL_VERSIONS: readonly ["2026-07-28"];
+export declare const LEGACY_PROTOCOL_VERSIONS: readonly ["2025-11-25", "2025-06-18", "2024-11-05"];
+export declare const SUPPORTED_PROTOCOL_VERSIONS: readonly string[];
+/** Offered to a legacy client whose requested version we do not know. */
+export declare const LATEST_LEGACY_PROTOCOL_VERSION: "2025-11-25";
+export declare const META_PROTOCOL_VERSION = "io.modelcontextprotocol/protocolVersion";
+export declare const META_CLIENT_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
+export declare const META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
+export declare const ERROR_INVALID_PARAMS = -32602;
+export declare const ERROR_UNSUPPORTED_PROTOCOL_VERSION = -32022;
+/** 2025-11-25 and earlier; replaced by -32602 in 2026-07-28. */
+export declare const ERROR_LEGACY_RESOURCE_NOT_FOUND = -32002;
+/** Tool catalogue is fixed for the life of a stdio process; five minutes is a conservative hint. */
+export declare const TOOLS_LIST_TTL_MS = 300000;
+export declare const DISCOVER_TTL_MS = 3600000;
+export interface ServerIdentity {
+    name: string;
+    version: string;
+}
+export interface ProtocolContext {
+    /** True when the request used 2026-07-28 per-request metadata. */
+    modern: boolean;
+    /** Version the request declared, or undefined for legacy requests. */
+    version?: string;
+    /** Validated W3C traceparent, if the client propagated one. */
+    traceparent?: string;
+    tracestate?: string;
+}
+export interface JsonRpcMessage {
+    jsonrpc?: string;
+    id?: string | number | null;
+    method?: string;
+    params?: unknown;
+}
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id?: string | number | null;
+    result?: Record<string, unknown>;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export type Preflight = {
+    response: JsonRpcResponse;
+    context?: undefined;
+} | {
+    response?: undefined;
+    context: ProtocolContext;
+};
+/** The CLI package version, read once from package.json (dist/src/ → ../../). */
+export declare function rufloPackageVersion(): string;
+export declare function defaultServerIdentity(): ServerIdentity;
+/** Pick the legacy version to answer `initialize` with (spec: echo if supported, else our latest). */
+export declare function negotiateLegacyVersion(requested: unknown): string;
+export declare function isValidTraceparent(value: unknown): value is string;
+/**
+ * Decide how to serve one inbound message before the handler's own switch runs.
+ * Returns a complete response for `initialize`, `server/discover` and protocol
+ * errors; otherwise returns the context the handler passes to `finalizeResponse`.
+ */
+export declare function protocolPreflight(message: JsonRpcMessage, capabilities: Record<string, unknown>, identity?: ServerIdentity): Preflight;
+/** The resource-not-found code the request's revision expects. */
+export declare function resourceNotFoundCode(context: ProtocolContext): number;
+/** Stable, name-ordered copy so `tools/list` is byte-identical across calls (prompt-cache friendly). */
+export declare function sortToolsDeterministically<T extends {
+    name: string;
+}>(tools: readonly T[]): T[];
+/** Tool-call context fields to forward, so handlers and logs can join the caller's trace. */
+export declare function traceContextFields(context: ProtocolContext): Record<string, string>;
+/** Add the 2026-07-28 result fields to a handler's response. Legacy responses pass through untouched. */
+export declare function finalizeResponse(response: JsonRpcResponse | null, method: string | undefined, context: ProtocolContext, identity?: ServerIdentity): JsonRpcResponse | null;
+//# sourceMappingURL=mcp-protocol.d.ts.map

package/dist/src/mcp-protocol.js

@@ -0,0 +1,179 @@
+/**
+ * MCP protocol-version handling for the stdio servers (ADR-524).
+ *
+ * Ruflo ships three stdio entry points (`bin/cli.js` auto-detect, `bin/mcp-server.js`,
+ * and `MCPServerManager` in mcp-server.ts). All three answered `initialize` with a
+ * hardcoded `2024-11-05` and knew nothing of the 2026-07-28 revision, which drops the
+ * handshake and carries the version on every request. This module is the one place
+ * that decides which revision a message speaks, so the three handlers cannot drift.
+ *
+ * Dual-era behaviour (spec: basic/versioning):
+ *  - `initialize` selects legacy semantics; the requested legacy version is echoed.
+ *  - a request carrying `_meta["io.modelcontextprotocol/protocolVersion"]` is served
+ *    statelessly: `resultType` and `serverInfo` on every result, cache hints on lists,
+ *    `-32602` for an unknown resource, `-32022` for an unsupported version.
+ *  - `server/discover` is always answered, so a dual-era client's stdio probe succeeds.
+ */
+import { readFileSync } from 'node:fs';
+export const MODERN_PROTOCOL_VERSIONS = ['2026-07-28'];
+// 2025-03-26 is deliberately absent: it is the one revision that allowed JSON-RPC batching, which these
+// line-at-a-time handlers do not accept. A client asking for it is offered 2025-11-25 instead.
+export const LEGACY_PROTOCOL_VERSIONS = ['2025-11-25', '2025-06-18', '2024-11-05'];
+export const SUPPORTED_PROTOCOL_VERSIONS = [
+    ...MODERN_PROTOCOL_VERSIONS,
+    ...LEGACY_PROTOCOL_VERSIONS,
+];
+/** Offered to a legacy client whose requested version we do not know. */
+export const LATEST_LEGACY_PROTOCOL_VERSION = LEGACY_PROTOCOL_VERSIONS[0];
+export const META_PROTOCOL_VERSION = 'io.modelcontextprotocol/protocolVersion';
+export const META_CLIENT_CAPABILITIES = 'io.modelcontextprotocol/clientCapabilities';
+export const META_SERVER_INFO = 'io.modelcontextprotocol/serverInfo';
+export const ERROR_INVALID_PARAMS = -32602;
+export const ERROR_UNSUPPORTED_PROTOCOL_VERSION = -32022;
+/** 2025-11-25 and earlier; replaced by -32602 in 2026-07-28. */
+export const ERROR_LEGACY_RESOURCE_NOT_FOUND = -32002;
+/** Tool catalogue is fixed for the life of a stdio process; five minutes is a conservative hint. */
+export const TOOLS_LIST_TTL_MS = 300_000;
+export const DISCOVER_TTL_MS = 3_600_000;
+const LIST_METHODS = new Set(['tools/list', 'prompts/list', 'resources/list', 'resources/templates/list']);
+// W3C Trace Context: version-traceid-parentid-flags, lowercase hex, ids not all zero, version != ff.
+const TRACEPARENT = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;
+let cachedVersion;
+/** The CLI package version, read once from package.json (dist/src/ → ../../). */
+export function rufloPackageVersion() {
+    if (cachedVersion)
+        return cachedVersion;
+    for (const rel of ['../../package.json', '../package.json']) {
+        try {
+            const pkg = JSON.parse(readFileSync(new URL(rel, import.meta.url), 'utf8'));
+            if (pkg.name === '@claude-flow/cli' && typeof pkg.version === 'string') {
+                cachedVersion = pkg.version;
+                return cachedVersion;
+            }
+        }
+        catch {
+            // try the next candidate
+        }
+    }
+    cachedVersion = '0.0.0';
+    return cachedVersion;
+}
+export function defaultServerIdentity() {
+    return { name: 'ruflo', version: rufloPackageVersion() };
+}
+/** Pick the legacy version to answer `initialize` with (spec: echo if supported, else our latest). */
+export function negotiateLegacyVersion(requested) {
+    return typeof requested === 'string' && LEGACY_PROTOCOL_VERSIONS.includes(requested)
+        ? requested
+        : LATEST_LEGACY_PROTOCOL_VERSION;
+}
+export function isValidTraceparent(value) {
+    if (typeof value !== 'string')
+        return false;
+    const m = TRACEPARENT.exec(value);
+    if (!m)
+        return false;
+    const [, version, traceId, parentId] = m;
+    return version !== 'ff' && !/^0+$/.test(traceId) && !/^0+$/.test(parentId);
+}
+function metaOf(params) {
+    if (!params || typeof params !== 'object')
+        return undefined;
+    const meta = params._meta;
+    return meta && typeof meta === 'object' && !Array.isArray(meta) ? meta : undefined;
+}
+function error(id, code, message, data) {
+    return { jsonrpc: '2.0', id: id ?? null, error: data === undefined ? { code, message } : { code, message, data } };
+}
+/**
+ * Decide how to serve one inbound message before the handler's own switch runs.
+ * Returns a complete response for `initialize`, `server/discover` and protocol
+ * errors; otherwise returns the context the handler passes to `finalizeResponse`.
+ */
+export function protocolPreflight(message, capabilities, identity = defaultServerIdentity()) {
+    const meta = metaOf(message.params);
+    const traceparent = isValidTraceparent(meta?.traceparent) ? meta.traceparent : undefined;
+    const tracestate = traceparent && typeof meta?.tracestate === 'string' && meta.tracestate.length <= 512
+        ? meta.tracestate
+        : undefined;
+    const declared = meta?.[META_PROTOCOL_VERSION];
+    const isNotification = message.id === undefined || message.id === null;
+    if (message.method === 'initialize') {
+        const requested = message.params?.protocolVersion;
+        return {
+            response: {
+                jsonrpc: '2.0',
+                id: message.id,
+                result: { protocolVersion: negotiateLegacyVersion(requested), serverInfo: identity, capabilities },
+            },
+        };
+    }
+    if (declared !== undefined && !isNotification) {
+        if (typeof declared !== 'string' || !SUPPORTED_PROTOCOL_VERSIONS.includes(declared)) {
+            return {
+                response: error(message.id, ERROR_UNSUPPORTED_PROTOCOL_VERSION, 'Unsupported protocol version', {
+                    supported: [...SUPPORTED_PROTOCOL_VERSIONS],
+                    requested: declared,
+                }),
+            };
+        }
+        const modern = MODERN_PROTOCOL_VERSIONS.includes(declared);
+        if (modern) {
+            const caps = meta?.[META_CLIENT_CAPABILITIES];
+            if (message.method !== 'server/discover' && (!caps || typeof caps !== 'object' || Array.isArray(caps))) {
+                return { response: error(message.id, ERROR_INVALID_PARAMS, `Missing required _meta field: ${META_CLIENT_CAPABILITIES}`) };
+            }
+        }
+        if (message.method === 'server/discover')
+            return { response: discoverResponse(message.id, capabilities, identity) };
+        return { context: { modern, version: declared, traceparent, tracestate } };
+    }
+    if (message.method === 'server/discover')
+        return { response: discoverResponse(message.id, capabilities, identity) };
+    return { context: { modern: false, traceparent, tracestate } };
+}
+function discoverResponse(id, capabilities, identity) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+            resultType: 'complete',
+            supportedVersions: [...SUPPORTED_PROTOCOL_VERSIONS],
+            capabilities,
+            _meta: { [META_SERVER_INFO]: identity },
+            ttlMs: DISCOVER_TTL_MS,
+            cacheScope: 'private',
+        },
+    };
+}
+/** The resource-not-found code the request's revision expects. */
+export function resourceNotFoundCode(context) {
+    return context.modern ? ERROR_INVALID_PARAMS : ERROR_LEGACY_RESOURCE_NOT_FOUND;
+}
+/** Stable, name-ordered copy so `tools/list` is byte-identical across calls (prompt-cache friendly). */
+export function sortToolsDeterministically(tools) {
+    return [...tools].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+/** Tool-call context fields to forward, so handlers and logs can join the caller's trace. */
+export function traceContextFields(context) {
+    const out = {};
+    if (context.traceparent)
+        out.traceparent = context.traceparent;
+    if (context.tracestate)
+        out.tracestate = context.tracestate;
+    return out;
+}
+/** Add the 2026-07-28 result fields to a handler's response. Legacy responses pass through untouched. */
+export function finalizeResponse(response, method, context, identity = defaultServerIdentity()) {
+    if (!response || !context.modern || !response.result)
+        return response;
+    const result = { resultType: 'complete', ...response.result };
+    const priorMeta = result._meta && typeof result._meta === 'object' ? result._meta : {};
+    result._meta = { ...priorMeta, [META_SERVER_INFO]: identity };
+    if (method && LIST_METHODS.has(method)) {
+        result.ttlMs = TOOLS_LIST_TTL_MS;
+        result.cacheScope = 'private';
+    }
+    return { ...response, result };
+}
+//# sourceMappingURL=mcp-protocol.js.map

package/dist/src/mcp-server.d.ts

@@ -182,6 +182,7 @@ export declare class MCPServerManager extends EventEmitter {
      * Handle incoming MCP message
      */
     private handleMCPMessage;
+    private dispatchMCPMessage;
     /**
      * Start HTTP server in-process
      */

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 { defaultServerIdentity, finalizeResponse, protocolPreflight, resourceNotFoundCode, sortToolsDeterministically, traceContextFields, } from './mcp-protocol.js';
 import { isPolicyEnforcementEnabled, loadMcpPolicy, evaluateToolCall, } from './mcp-tools/policy-enforcer.js';
 /** A failed task can be valid data; only an explicit error denotes tool failure. */
 function hasToolError(result) {
@@ -275,6 +276,11 @@ export function assessMcpSchemaOverhead(tools, contextWindowTokens) {
             : 'normal',
     };
 }
+/** Capabilities every ruflo stdio server advertises (initialize and server/discover). */
+const MCP_STDIO_CAPABILITIES = {
+    tools: { listChanged: true },
+    resources: {},
+};
 /**
  * MCP Server Manager
  *
@@ -616,7 +622,7 @@ export class MCPServerManager extends EventEmitter {
         });
         // Import the tool registry
         const { listMCPTools, callMCPTool, hasTool } = await import('./mcp-client.js');
-        const VERSION = '3.0.0';
+        const VERSION = defaultServerIdentity().version;
         const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
         // Log to stderr to not corrupt stdout
         console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Starting in stdio mode`);
@@ -663,10 +669,7 @@ export class MCPServerManager extends EventEmitter {
                 serverInfo: {
                     name: 'ruflo',
                     version: VERSION,
-                    capabilities: {
-                        tools: { listChanged: true },
-                        resources: {},
-                    },
+                    capabilities: MCP_STDIO_CAPABILITIES,
                 },
             },
         });
@@ -722,7 +725,6 @@ export class MCPServerManager extends EventEmitter {
      * Handle incoming MCP message
      */
     async handleMCPMessage(message, sessionId) {
-        const { listMCPTools, callMCPTool, hasTool } = await import('./mcp-client.js');
         if (!message.method) {
             return {
                 jsonrpc: '2.0',
@@ -730,24 +732,20 @@ export class MCPServerManager extends EventEmitter {
                 error: { code: -32600, message: 'Invalid Request: missing method' },
             };
         }
+        // ADR-524: one decision point for which MCP revision this message speaks.
+        const preflight = protocolPreflight(message, MCP_STDIO_CAPABILITIES);
+        if (preflight.response)
+            return preflight.response;
+        const response = await this.dispatchMCPMessage(message, sessionId, preflight.context);
+        return finalizeResponse(response, message.method, preflight.context);
+    }
+    async dispatchMCPMessage(message, sessionId, protocol) {
+        const { listMCPTools, callMCPTool, hasTool } = await import('./mcp-client.js');
         const params = (message.params || {});
         try {
             switch (message.method) {
-                case 'initialize':
-                    return {
-                        jsonrpc: '2.0',
-                        id: message.id,
-                        result: {
-                            protocolVersion: '2024-11-05',
-                            serverInfo: { name: 'ruflo', version: '3.0.0' },
-                            capabilities: {
-                                tools: { listChanged: true },
-                                resources: {},
-                            },
-                        },
-                    };
                 case 'tools/list':
-                    const tools = filterAdvertisedMcpTools(listMCPTools(), this.options.tools);
+                    const tools = sortToolsDeterministically(filterAdvertisedMcpTools(listMCPTools(), this.options.tools));
                     return {
                         jsonrpc: '2.0',
                         id: message.id,
@@ -781,7 +779,7 @@ export class MCPServerManager extends EventEmitter {
                         }
                     }
                     try {
-                        const result = await callMCPTool(toolName, toolParams, { sessionId, transport: 'stdio' });
+                        const result = await callMCPTool(toolName, toolParams, { sessionId, transport: 'stdio', ...traceContextFields(protocol) });
                         const isError = hasToolError(result);
                         trackRequest(toolName, !isError);
                         return {
@@ -808,7 +806,7 @@ export class MCPServerManager extends EventEmitter {
                 case 'resources/templates/list':
                     return { jsonrpc: '2.0', id: message.id, result: { resourceTemplates: [] } };
                 case 'resources/read':
-                    return { jsonrpc: '2.0', id: message.id, error: { code: -32002, message: 'Resource not found' } };
+                    return { jsonrpc: '2.0', id: message.id, error: { code: resourceNotFoundCode(protocol), message: 'Resource not found' } };
                 case 'notifications/initialized':
                     // Client notification - no response needed
                     console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Client initialized`);

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

@@ -147,10 +147,18 @@ export async function callAnthropicMessages(input) {
         // checked in that order — matching callOllamaCompat's own precedence).
         const resolvedBaseUrl = process.env.OLLAMA_BASE_URL || persistedOllama?.baseUrl;
         const isSelfHosted = !!resolvedBaseUrl && !/^https:\/\/ollama\.com\/?$/i.test(resolvedBaseUrl);
+        // The persisted baseUrl comes from project config, which a cloned repo
+        // can commit. Never hand the environment's OLLAMA_API_KEY to an endpoint
+        // the project chose: that endpoint gets only the key saved beside it (or
+        // none). The env key goes to OLLAMA_BASE_URL, or to Ollama Cloud itself.
+        const baseFromProject = !process.env.OLLAMA_BASE_URL && !!persistedOllama?.baseUrl && isSelfHosted;
+        const apiKey = baseFromProject
+            ? persistedOllama?.apiKey || 'local'
+            : ollamaKey || persistedOllama?.apiKey || 'local';
         if (ollamaKey || persistedOllama?.apiKey || isSelfHosted) {
             return callOllamaCompat({
                 ...input,
-                apiKey: ollamaKey || persistedOllama?.apiKey || 'local',
+                apiKey,
                 baseUrl: resolvedBaseUrl,
                 model: input.model,
                 // Local default for tier aliases / Anthropic ids (see

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

@@ -5,5 +5,18 @@
  * Includes model routing integration for intelligent model selection.
  */
 import { type MCPTool } from './types.js';
+/** Live canonical registry members, excluding stale or duplicate swarm IDs. */
+export declare function getLiveAgentIds(agentIds: string[]): string[];
+export declare const AGENT_STATUSES: readonly ["idle", "busy", "terminated"];
+type AgentLifecycleStatus = (typeof AGENT_STATUSES)[number];
+/** Canonical lifecycle status (trimmed, any case, known aliases), or null. */
+export declare function agentStatusOf(value: unknown): AgentLifecycleStatus | null;
+/**
+ * Statuses `agent_list` should keep. `null` means no status filter:
+ * omitted, empty, whitespace, or `all` (any case, including inside a comma list).
+ * The caller still hides terminated agents unless includeTerminated is set.
+ */
+export declare function agentListStatusFilter(status: unknown): string[] | null;
 export declare const agentTools: MCPTool[];
+export {};
 //# sourceMappingURL=agent-tools.d.ts.map

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

@@ -6,7 +6,7 @@
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { readRecordStore } from './record-store.js';
+import { nullPrototypeRecords, readRecordStore } from './record-store.js';
 import { getProjectCwd } from './types.js';
 import { validateIdentifier, validateText, validateAgentSpawn } from './validate-input.js';
 import { executeAgentTask } from './agent-execute-core.js';
@@ -36,6 +36,11 @@ function ensureAgentDir() {
 function loadAgentStore() {
     return readRecordStore(getAgentPath(), 'agents', () => ({ agents: {}, version: '3.0.0' }));
 }
+/** Live canonical registry members, excluding stale or duplicate swarm IDs. */
+export function getLiveAgentIds(agentIds) {
+    const { agents } = loadAgentStore();
+    return [...new Set(agentIds)].filter(id => agents[id] && agents[id].status !== 'terminated');
+}
 function saveAgentStore(store) {
     ensureAgentDir();
     writeFileSync(getAgentPath(), JSON.stringify(store, null, 2), 'utf-8');
@@ -50,14 +55,14 @@ function loadHiveAgents() {
         if (existsSync(path)) {
             const data = JSON.parse(readFileSync(path, 'utf-8'));
             if (data && typeof data.agents === 'object' && data.agents) {
-                return data.agents;
+                return nullPrototypeRecords(data.agents);
             }
         }
     }
     catch {
         // Ignore — hive store is optional/best-effort.
     }
-    return {};
+    return nullPrototypeRecords(undefined);
 }
 /**
  * #1916: merged view of every tracked agent — the canonical agent store
@@ -65,7 +70,41 @@ function loadHiveAgents() {
  * wins (it carries model-routing + lastResult that the hive store omits).
  */
 function loadAllAgents() {
-    return { ...loadHiveAgents(), ...loadAgentStore().agents };
+    return Object.assign(nullPrototypeRecords(undefined), loadHiveAgents(), loadAgentStore().agents);
+}
+export const AGENT_STATUSES = ['idle', 'busy', 'terminated'];
+// Spellings callers write for the three stored states. v2 `agent/list` used
+// "active" for a working agent; hive liveness folds running/working into busy.
+const AGENT_STATUS_ALIASES = {
+    active: 'busy', running: 'busy', working: 'busy',
+    ready: 'idle', waiting: 'idle',
+    stopped: 'terminated', inactive: 'terminated', offline: 'terminated',
+};
+/** Canonical lifecycle status (trimmed, any case, known aliases), or null. */
+export function agentStatusOf(value) {
+    if (typeof value !== 'string')
+        return null;
+    const key = value.trim().toLowerCase();
+    if (AGENT_STATUSES.includes(key))
+        return key;
+    return Object.hasOwn(AGENT_STATUS_ALIASES, key) ? AGENT_STATUS_ALIASES[key] : null;
+}
+/**
+ * Statuses `agent_list` should keep. `null` means no status filter:
+ * omitted, empty, whitespace, or `all` (any case, including inside a comma list).
+ * The caller still hides terminated agents unless includeTerminated is set.
+ */
+export function agentListStatusFilter(status) {
+    if (typeof status !== 'string' || status.trim() === '')
+        return null;
+    const canonical = status.split(',').map(part => part.trim()).filter(Boolean).map(part => {
+        if (part.toLowerCase() === 'all')
+            return 'all';
+        return agentStatusOf(part) ?? part.toLowerCase();
+    });
+    if (canonical.length === 0 || canonical.includes('all'))
+        return null;
+    return canonical;
 }
 // Default model mappings for agent types (can be overridden)
 const AGENT_TYPE_MODEL_DEFAULTS = {
@@ -568,17 +607,24 @@ export const agentTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                status: { type: 'string', description: 'Filter by status' },
+                status: { type: 'string', description: 'Filter by status (idle, busy, terminated; case-insensitive, aliases such as active/running/stopped). "all" or empty applies no status filter. Comma-separated values match any of them.' },
                 domain: { type: 'string', description: 'Filter by domain' },
                 agentType: { type: 'string', description: 'Filter by agent type' },
                 includeTerminated: { type: 'boolean', description: 'Include terminated agents' },
             },
         },
         handler: async (input) => {
-            if (input.status) {
-                const v = validateIdentifier(input.status, 'status');
-                if (!v.valid)
-                    return { agents: [], total: 0, error: `Input validation failed: ${v.error}` };
+            // Validate each status token. Commas separate values (`active,idle`);
+            // the whole string is not one identifier.
+            if (typeof input.status === 'string' && input.status.trim() !== '') {
+                for (const part of input.status.split(',')) {
+                    const token = part.trim();
+                    if (!token || token.toLowerCase() === 'all')
+                        continue;
+                    const v = validateIdentifier(token, 'status');
+                    if (!v.valid)
+                        return { agents: [], total: 0, error: `Input validation failed: ${v.error}` };
+                }
             }
             if (input.domain) {
                 const v = validateIdentifier(input.domain, 'domain');
@@ -591,9 +637,14 @@ export const agentTools = [
                     return { agents: [], total: 0, error: `Input validation failed: ${v.error}` };
             }
             let agents = Object.values(loadAllAgents()); // #1916: includes hive-mind-spawned workers
-            // Filter by status
-            if (input.status) {
-                agents = agents.filter(a => a.status === input.status);
+            // Filter by status. `all` and empty mean no status filter (#4732),
+            // matching task_list: comma-separated, case-insensitive, known aliases.
+            const statuses = agentListStatusFilter(input.status);
+            if (statuses) {
+                agents = agents.filter(a => {
+                    const stored = agentStatusOf(a.status) ?? String(a.status).trim().toLowerCase();
+                    return statuses.includes(stored);
+                });
             }
             else if (!input.includeTerminated) {
                 agents = agents.filter(a => a.status !== 'terminated');

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

@@ -143,6 +143,20 @@ export interface MergeResult {
     skippedUnverified: number;
     skippedOversize: number;
     skippedHopLimit: number;
+    /** Envelopes whose `origin` names a node the signature does not belong to. */
+    skippedForeignOrigin: number;
+    /** Highest `seq` among envelopes merged or already held; the next sync starts after it. */
+    acceptedMaxSeq: number;
+}
+/**
+ * Who may have signed an envelope. `origin` is inside the signature, but a
+ * signature only proves which key signed, not which node the envelope names.
+ * An envelope is accepted only when its origin is the syncing peer itself or
+ * another pinned peer, and it verifies against that origin's pinned key.
+ */
+export interface OriginKeys {
+    peerNodeId: string;
+    pinned: ReadonlyMap<string, string>;
 }
 /**
  * Union-merge verified envelopes from a peer into the local room log.
@@ -150,8 +164,11 @@ export interface MergeResult {
  * Idempotent: `envelopeId` is the merge key, so replaying the same batch is a
  * no-op. Anything that fails verification is dropped and counted rather than
  * quarantined — a receiver has no use for an envelope it cannot attribute.
+ *
+ * `hops` is not signed (relays change it), so it only limits propagation and
+ * is never trusted for anything else.
  */
-export declare function mergeEnvelopes(basePath: string, roomId: string, incoming: SignedEnvelope[], peerPublicKey: string): Promise<MergeResult>;
+export declare function mergeEnvelopes(basePath: string, roomId: string, incoming: SignedEnvelope[], peerPublicKey: string, origins?: OriginKeys): Promise<MergeResult>;
 /** Pull one room from one peer and merge what verifies. */
 export declare function syncRoomFromPeer(basePath: string, peer: FederationPeer, roomId: string, fetchImpl?: typeof fetch): Promise<MergeResult & {
     peerNodeId: string;

package/dist/src/mcp-tools/agentbbs-federation.js

@@ -315,15 +315,19 @@ export function validateRoomId(roomId) {
  * Idempotent: `envelopeId` is the merge key, so replaying the same batch is a
  * no-op. Anything that fails verification is dropped and counted rather than
  * quarantined — a receiver has no use for an envelope it cannot attribute.
+ *
+ * `hops` is not signed (relays change it), so it only limits propagation and
+ * is never trusted for anything else.
  */
-export async function mergeEnvelopes(basePath, roomId, incoming, peerPublicKey) {
+export async function mergeEnvelopes(basePath, roomId, incoming, peerPublicKey, origins) {
     validateRoomId(roomId);
     ensureDir(basePath);
     const result = {
         merged: 0, skippedDuplicate: 0, skippedUnverified: 0, skippedOversize: 0, skippedHopLimit: 0,
+        skippedForeignOrigin: 0, acceptedMaxSeq: 0,
     };
     const existing = readEnvelopes(basePath, roomId);
-    const seen = new Set(existing.map(e => e.envelopeId));
+    const seen = new Map(existing.map(e => [e.envelopeId, Number(e.seq) || 0]));
     const logPath = roomLogPath(basePath, roomId);
     const batch = incoming.slice(0, MAX_ENVELOPES_PER_SYNC);
     for (const env of batch) {
@@ -337,6 +341,7 @@ export async function mergeEnvelopes(basePath, roomId, incoming, peerPublicKey)
         }
         if (seen.has(env.envelopeId)) {
             result.skippedDuplicate++;
+            result.acceptedMaxSeq = Math.max(result.acceptedMaxSeq, seen.get(env.envelopeId) ?? 0);
             continue;
         }
         if (JSON.stringify(env).length > MAX_ENVELOPE_BYTES) {
@@ -347,12 +352,22 @@ export async function mergeEnvelopes(basePath, roomId, incoming, peerPublicKey)
             result.skippedHopLimit++;
             continue;
         }
-        if (!(await verifyEnvelope(env, peerPublicKey))) {
+        let signerKey = peerPublicKey;
+        if (origins) {
+            const key = env.origin === origins.peerNodeId ? peerPublicKey : typeof env.origin === 'string' ? origins.pinned.get(env.origin) : undefined;
+            if (!key) {
+                result.skippedForeignOrigin++;
+                continue;
+            }
+            signerKey = key;
+        }
+        if (!(await verifyEnvelope(env, signerKey))) {
             result.skippedUnverified++;
             continue;
         }
         appendFileSync(logPath, JSON.stringify({ ...env, hops: (env.hops ?? 0) + 1 }) + '\n');
-        seen.add(env.envelopeId);
+        seen.set(env.envelopeId, Number(env.seq) || 0);
+        result.acceptedMaxSeq = Math.max(result.acceptedMaxSeq, Number(env.seq) || 0);
         result.merged++;
     }
     return result;
@@ -378,14 +393,15 @@ export async function syncRoomFromPeer(basePath, peer, roomId, fetchImpl = fetch
         clearTimeout(timer);
     }
     const envelopes = Array.isArray(body?.envelopes) ? body.envelopes : [];
-    const merged = await mergeEnvelopes(basePath, roomId, envelopes, peer.publicKey);
     const peers = readPeers(basePath);
+    const pinned = new Map(peers.filter(p => typeof p.publicKey === 'string').map(p => [p.nodeId, p.publicKey]));
+    const merged = await mergeEnvelopes(basePath, roomId, envelopes, peer.publicKey, { peerNodeId: peer.nodeId, pinned });
     const rec = peers.find(p => p.nodeId === peer.nodeId);
     if (rec) {
         rec.lastSyncedAt = new Date().toISOString();
         rec.lastSeq = rec.lastSeq ?? {};
-        const maxSeq = envelopes.reduce((m, e) => Math.max(m, Number(e.seq) || 0), since);
-        rec.lastSeq[roomId] = maxSeq;
+        // Advance only past envelopes that verified; an unverifiable batch must not skip the cursor forward.
+        rec.lastSeq[roomId] = Math.max(since, merged.acceptedMaxSeq);
         writePeers(basePath, peers);
     }
     return { ...merged, peerNodeId: peer.nodeId, roomId };