claude-flow 3.58.1 → 3.59.0

package/v3/@claude-flow/cli/dist/src/mcp-tools/memory-tools.js

@@ -818,6 +818,11 @@ export const memoryTools = [
             type: 'object',
             properties: {
                 namespace: { type: 'string', description: 'Filter by namespace' },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Require entries to include all of these tags (AND). Matches the description claim "optionally filtered by namespace/tags".',
+                },
                 limit: { type: 'number', description: 'Maximum results (default: 50)' },
                 offset: { type: 'number', description: 'Offset for pagination (default: 0)' },
             },
@@ -826,6 +831,9 @@ export const memoryTools = [
             await ensureInitialized();
             const { listEntries } = await getMemoryFunctions();
             const namespace = input.namespace;
+            const tags = Array.isArray(input.tags)
+                ? input.tags.filter((t) => typeof t === 'string' && t.length > 0)
+                : undefined;
             const limit = input.limit || 50;
             const offset = input.offset || 0;
             if (namespace) {
@@ -836,12 +844,14 @@ export const memoryTools = [
             try {
                 const result = await listEntries({
                     namespace,
+                    tags,
                     limit,
                     offset,
                 });
                 const entries = result.entries.map(e => ({
                     key: e.key,
                     namespace: e.namespace,
+                    tags: e.tags ?? [],
                     storedAt: e.createdAt,
                     updatedAt: e.updatedAt,
                     accessCount: e.accessCount,
@@ -1639,7 +1649,9 @@ export const memoryTools = [
             }
             const all = { entries: [...merged.values()] };
             const payload = {
-                schema: 'ruflo-memory-export/v1',
+                // ruflo-memory-export/v1.1: tags round-trip with export/import.
+                // v1 importers ignore unknown fields; v1.1 importers restore tags.
+                schema: 'ruflo-memory-export/v1.1',
                 exportedAt: new Date().toISOString(),
                 namespace: namespace ?? null,
                 count: all.entries.length,
@@ -1650,6 +1662,8 @@ export const memoryTools = [
                     // never-populated alias. Fall back to null only if content is
                     // missing for backward-compat with the schema.
                     value: typeof e.content === 'string' ? e.content : (e.value ?? null),
+                    // Preserve tags so memory_import is lossless for tag sets.
+                    tags: Array.isArray(e.tags) ? e.tags : [],
                     createdAt: e.createdAt, updatedAt: e.updatedAt, accessCount: e.accessCount, hasEmbedding: e.hasEmbedding, size: e.size,
                 })),
             };
@@ -1674,8 +1688,9 @@ export const memoryTools = [
     {
         // #1916: `ruflo memory import <file>` referenced an unregistered tool.
         // Reads a ruflo-memory-export JSON and re-stores each entry.
+        // Honour `tags` on each entry (export v1.1+; ignored if absent).
         name: 'memory_import',
-        description: 'Import memory entries from a JSON export file (produced by memory_export) into .swarm/memory.db, re-embedding values. Use when native Read is wrong because the data must be re-stored as memory rows (with new embeddings), not just read. For importing Claude Code\'s own memory files use memory_import_claude. Pair with memory_export on the source.',
+        description: 'Import memory entries from a JSON export file (produced by memory_export) into .swarm/memory.db, re-embedding values. Preserves tags when present in the export (ruflo-memory-export/v1.1+). Use when native Read is wrong because the data must be re-stored as memory rows (with new embeddings), not just read. For importing Claude Code\'s own memory files use memory_import_claude. Pair with memory_export on the source.',
         category: 'memory',
         inputSchema: {
             type: 'object',
@@ -1735,6 +1750,7 @@ export const memoryTools = [
             let imported = 0;
             let skipped = 0;
             let failed = 0;
+            let withTags = 0;
             const errors = [];
             for (const e of entries) {
                 if (!e || typeof e.key !== 'string') {
@@ -1742,11 +1758,33 @@ export const memoryTools = [
                     continue;
                 }
                 const value = typeof e.value === 'string' ? e.value : JSON.stringify(e.value ?? null);
+                // Restore tags from export. Accept array or JSON/comma string
+                // for robustness with hand-edited fidelity manifests.
+                let tags = [];
+                if (Array.isArray(e.tags)) {
+                    tags = e.tags.filter((t) => typeof t === 'string' && t.length > 0);
+                }
+                else if (typeof e.tags === 'string' && e.tags.trim()) {
+                    try {
+                        const parsed = JSON.parse(e.tags);
+                        if (Array.isArray(parsed)) {
+                            tags = parsed.filter((t) => typeof t === 'string' && t.length > 0);
+                        }
+                        else {
+                            tags = e.tags.split(',').map(s => s.trim()).filter(Boolean);
+                        }
+                    }
+                    catch {
+                        tags = e.tags.split(',').map(s => s.trim()).filter(Boolean);
+                    }
+                }
                 try {
-                    const result = await storeEntry({ key: e.key, value, namespace: nsOverride ?? e.namespace ?? 'default', upsert: input.merge !== false, dbPath });
+                    const result = await storeEntry({ key: e.key, value, namespace: nsOverride ?? e.namespace ?? 'default', tags, upsert: input.merge !== false, dbPath });
                     if (!result.success)
                         throw new Error(result.error || 'Memory write was rejected');
                     imported++;
+                    if (tags.length > 0)
+                        withTags++;
                     if (result.embedding)
                         vectors++;
                 }
@@ -1761,7 +1799,7 @@ export const memoryTools = [
                 error: failed > 0 ? `${failed} memory write(s) failed: ${errors.join('; ')}` : undefined,
                 failed,
                 inputPath,
-                imported: { entries: imported, vectors, patterns: 0 },
+                imported: { entries: imported, vectors, patterns: 0, withTags },
                 skipped,
                 duration: Date.now() - t0,
             };

package/v3/@claude-flow/cli/dist/src/mcp-tools/task-tools.js

@@ -207,9 +207,11 @@ export const taskTools = [
             let tasks = Object.values(store.tasks);
             // Apply filters
             if (input.status) {
-                // Support comma-separated status values
+                // Support comma-separated status values. 'all' (sent by `status tasks`) means no status filter.
                 const statuses = input.status.split(',').map(s => s.trim());
-                tasks = tasks.filter(t => statuses.includes(t.status));
+                if (!statuses.includes('all')) {
+                    tasks = tasks.filter(t => statuses.includes(t.status));
+                }
             }
             if (input.type) {
                 tasks = tasks.filter(t => t.type === input.type);
@@ -222,6 +224,8 @@ export const taskTools = [
             }
             // Sort by creation date (newest first)
             tasks.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+            // Count matches before applying the limit so callers can tell when the list was truncated
+            const total = tasks.length;
             // Apply limit
             const limit = input.limit || 50;
             tasks = tasks.slice(0, limit);
@@ -236,7 +240,7 @@ export const taskTools = [
                     assignedTo: t.assignedTo,
                     createdAt: t.createdAt,
                 })),
-                total: tasks.length,
+                total,
                 filters: {
                     status: input.status,
                     type: input.type,

package/v3/@claude-flow/cli/dist/src/mcp-tools/team-tools.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Host-agnostic Agent Teams MCP tools (ADR-402).
+ *
+ * Comms live in Ruflo (filesystem under .claude-flow/teams/), not host
+ * SendMessage. team_spawn returns a host spawn plan (Grok spawn_subagent /
+ * Claude Task adapter).
+ *
+ * The store itself is templates/grok/scripts/grok-team-bus.mjs — the same file
+ * `init --grok` copies into a project as a CLI — so the MCP tools, the CLI and
+ * the SubagentStop hook share one implementation (locking, per-team mailboxes,
+ * atomic writes). This module validates MCP input and maps errors to results.
+ */
+import { type MCPTool } from './types.js';
+export declare const teamTools: MCPTool[];
+//# sourceMappingURL=team-tools.d.ts.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/team-tools.js

@@ -0,0 +1,244 @@
+/**
+ * Host-agnostic Agent Teams MCP tools (ADR-402).
+ *
+ * Comms live in Ruflo (filesystem under .claude-flow/teams/), not host
+ * SendMessage. team_spawn returns a host spawn plan (Grok spawn_subagent /
+ * Claude Task adapter).
+ *
+ * The store itself is templates/grok/scripts/grok-team-bus.mjs — the same file
+ * `init --grok` copies into a project as a CLI — so the MCP tools, the CLI and
+ * the SubagentStop hook share one implementation (locking, per-team mailboxes,
+ * atomic writes). This module validates MCP input and maps errors to results.
+ */
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { getProjectCwd } from './types.js';
+import { validateText } from './validate-input.js';
+import { grokTemplatesRoot } from '../init/grok-templates.js';
+let busPromise = null;
+function loadBus() {
+    if (!busPromise) {
+        const file = join(grokTemplatesRoot(), 'scripts', 'grok-team-bus.mjs');
+        busPromise = import(pathToFileURL(file).href);
+        busPromise.catch(() => {
+            busPromise = null;
+        });
+    }
+    return busPromise;
+}
+async function run(op, opts) {
+    try {
+        const bus = await loadBus();
+        // Some ops (create/spawn/send) hold the team lock, which now waits via a
+        // non-blocking async poll rather than Atomics.wait (ADR-402 round-2
+        // review, N3) — always await, whether or not this particular op returns
+        // a promise.
+        return { success: true, ...(await bus[op](getProjectCwd(), opts)) };
+    }
+    catch (e) {
+        return { success: false, error: e.message || String(e) };
+    }
+}
+function textError(value, field, max) {
+    if (value === undefined || value === null)
+        return null;
+    const v = validateText(String(value), field, max);
+    return v.valid ? null : v.error || `Invalid ${field}`;
+}
+const teamProp = { type: 'string', description: 'Team id (alphanumeric, dash, underscore)' };
+export const teamTools = [
+    {
+        name: 'team_create',
+        description: 'Create a host-agnostic Agent Team (ADR-402). State under .claude-flow/teams/<team>/. Use when native SendMessage/Task teammate bus is wrong or unavailable (Grok, Codex, multi-host). Pair with team_spawn for spawn plans and team_send/team_inbox for handoffs.',
+        category: 'team',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: teamProp,
+                topology: {
+                    type: 'string',
+                    description: 'Team topology (hierarchical, mesh, star, ring)',
+                },
+                maxAgents: { type: 'number', description: 'Max members (1-50, default 8); team_spawn refuses beyond it' },
+                host: { type: 'string', description: 'Host label (grok, claude, codex)' },
+                force: { type: 'boolean', description: 'Overwrite existing team metadata (reopens a shut-down team)' },
+            },
+            required: ['name'],
+        },
+        handler: async (input) => run('createTeam', {
+            name: input.name,
+            topology: input.topology,
+            maxAgents: input.maxAgents,
+            host: input.host,
+            force: input.force === true,
+        }),
+    },
+    {
+        name: 'team_spawn',
+        description: 'Register a teammate and return a host spawn plan (Grok spawn_subagent / Claude Task adapter) — does not execute the agent. Use when native Task has no way to register a teammate into the host-agnostic team roster (ADR-402); the host lead still spawns using the returned plan. Refused once the team is shut down or has maxAgents members. Pair with team_create first.',
+        category: 'team',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team: teamProp,
+                agent: { type: 'string', description: 'Agent name' },
+                role: { type: 'string', description: 'Role (architect, developer, tester, reviewer, …)' },
+                prompt: { type: 'string', description: 'Task body embedded in spawn plan prompt' },
+                next: {
+                    type: 'array',
+                    description: 'Next agent name(s) for handoff',
+                    items: { type: 'string' },
+                },
+            },
+            required: ['team', 'agent'],
+        },
+        handler: async (input) => {
+            const err = textError(input.prompt, 'prompt', 100_000);
+            if (err)
+                return { success: false, error: err };
+            return run('spawnMember', {
+                team: input.team,
+                agent: input.agent,
+                role: input.role,
+                prompt: input.prompt,
+                next: input.next,
+            });
+        },
+    },
+    {
+        name: 'team_send',
+        description: 'Enqueue a message to a named agent mailbox on one team (or broadcast to every member with to="*"). Use when native SendMessage is wrong because the recipient may be on a different host (Grok, Codex) with no SendMessage equivalent — the message persists under .claude-flow/teams/<team>/mailbox/ instead of an in-memory channel. Pair with team_inbox to read it. Refused once the team is shut down.',
+        category: 'team',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team: teamProp,
+                to: { type: 'string', description: 'Recipient agent name, or * to broadcast to current members' },
+                message: { type: 'string', description: 'Message body' },
+                summary: { type: 'string', description: 'Short summary' },
+                from: { type: 'string', description: 'Sender name (default: lead)' },
+                type: { type: 'string', description: 'Message type (handoff, status, …)' },
+                priority: { type: 'number', description: 'Integer 0-999, lower is read first (default 2)' },
+            },
+            required: ['team', 'to', 'message'],
+        },
+        handler: async (input) => {
+            const err = textError(input.message ?? input.content, 'message', 500_000) ||
+                textError(input.summary, 'summary', 1_000) ||
+                textError(input.type, 'type', 64);
+            if (err)
+                return { success: false, error: err };
+            return run('sendMessage', {
+                team: input.team,
+                to: input.to,
+                message: input.message ?? input.content,
+                summary: input.summary,
+                from: input.from,
+                type: input.type,
+                priority: input.priority,
+            });
+        },
+    },
+    {
+        name: 'team_inbox',
+        description: 'Drain (default) or peek one agent\'s mailbox on one team. Drained messages move to mailbox/<agent>/archive; concurrent drains never return the same message twice. Use when native SendMessage is wrong because there is no host-agnostic inbox to read from — this is the Grok/Codex-side counterpart to team_send for hosts without a live message channel.',
+        category: 'team',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team: teamProp,
+                agent: { type: 'string', description: 'Agent name whose inbox to read' },
+                peek: { type: 'boolean', description: 'If true, do not archive/drain messages' },
+            },
+            required: ['team', 'agent'],
+        },
+        handler: async (input) => run('readInbox', { team: input.team, agent: input.agent, peek: input.peek === true }),
+    },
+    {
+        name: 'team_broadcast',
+        description: 'Fan-out a message to all registered members of one team (alias of team_send with to="*"; refused while the team has no members). Use when native SendMessage is wrong because it can\'t reach every teammate on a non-Claude host in one call; each recipient reads back via team_inbox on its own host.',
+        category: 'team',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team: teamProp,
+                message: { type: 'string', description: 'Message body' },
+                summary: { type: 'string', description: 'Short summary' },
+                from: { type: 'string', description: 'Sender (default: lead)' },
+            },
+            required: ['team', 'message'],
+        },
+        handler: async (input) => {
+            const send = teamTools.find((t) => t.name === 'team_send');
+            if (!send)
+                return { success: false, error: 'team_send not registered' };
+            return send.handler({
+                team: input.team,
+                to: '*',
+                message: input.message,
+                summary: input.summary,
+                from: input.from,
+                type: 'broadcast',
+            });
+        },
+    },
+    {
+        name: 'team_plan',
+        description: 'Set pipeline steps for a team (ordered agents); the first step becomes ready. Use when native TodoWrite is wrong because it can\'t drive multi-host agent sequencing — this pipeline advances via team_on_stop instead of a single host\'s task list.',
+        category: 'team',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team: teamProp,
+                steps: {
+                    type: 'array',
+                    description: 'Ordered agent names or {id,agent} objects',
+                    items: {},
+                },
+            },
+            required: ['team', 'steps'],
+        },
+        handler: async (input) => run('setPlan', { team: input.team, steps: input.steps }),
+    },
+    {
+        name: 'team_status',
+        description: 'Team members, plan progress, and pending mailbox counts for this team only. Use when native Task is wrong because it has no cross-host visibility into a team\'s roster or pipeline state — reads the same .claude-flow/teams/ state that team_plan and team_send write.',
+        category: 'team',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team: teamProp,
+            },
+            required: ['team'],
+        },
+        handler: async (input) => run('teamStatus', { team: input.team }),
+    },
+    {
+        name: 'team_on_stop',
+        description: 'Mark agent idle, advance the team_plan pipeline, and return the next assignment hint. Use when native Task has no cross-host equivalent to SubagentStop-driven pipeline advancement; wire this from SubagentStop / post-task hooks instead of polling team_status.',
+        category: 'team',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team: teamProp,
+                agent: { type: 'string', description: 'Agent that stopped' },
+            },
+            required: ['team', 'agent'],
+        },
+        handler: async (input) => run('onStop', { team: input.team, agent: input.agent }),
+    },
+    {
+        name: 'team_shutdown',
+        description: 'Close a team: marks it and its members shutdown, after which team_spawn, team_send, team_plan and team_on_stop refuse (team_inbox and team_status still work, to drain remaining mail). Use when native Task is wrong because it has no host-agnostic team lifecycle to close out.',
+        category: 'team',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team: teamProp,
+            },
+            required: ['team'],
+        },
+        handler: async (input) => run('shutdownTeam', { team: input.team }),
+    },
+];
+//# sourceMappingURL=team-tools.js.map

package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.d.ts

@@ -144,6 +144,8 @@ export declare function bridgeListEntries(options: {
     includeEmbedding?: boolean;
     /** #4056: also return rows whose TTL has passed (with `expiresAt`). For cleanup only. */
     includeExpired?: boolean;
+    /** Require entries to include all of these tags (AND). */
+    tags?: string[];
 }): Promise<{
     success: boolean;
     entries: {
@@ -165,6 +167,8 @@ export declare function bridgeListEntries(options: {
             scale: number;
             b64: string;
         };
+        /** Tag set stored with the entry (empty array when none). */
+        tags?: string[];
     }[];
     total: number;
     error?: string;
@@ -263,6 +267,10 @@ export declare function bridgeGetVectorSearchStatus(dbPath?: string): Promise<{
  * Search AgentDB v3's embedder + SQLite entries via a full-table scan and
  * brute-force cosine similarity. NOT HNSW-accelerated — see #2922. Returns
  * null if unavailable.
+ *
+ * #4203: when a RaBitQ index is available the Hamming-scan candidate set is
+ * reranked exactly instead of scanning the whole table; the exhaustive loop
+ * below stays the fallback, so results and scores keep their meaning.
  */
 export declare function bridgeSearchBruteForceCosine(queryEmbedding: number[], options?: {
     k?: number;
@@ -650,6 +658,17 @@ export declare function bridgeGetAllEmbeddings(options?: {
     namespace: string;
     embedding: number[];
 }> | null>;
+/**
+ * Count the embeddings `bridgeGetAllEmbeddings()` would export (#4203).
+ * RaBitQ's auto-build uses this as its cheap "has the corpus drifted?" probe —
+ * a COUNT instead of re-reading every embedding blob. With `dimensions` it
+ * counts only rows build() would keep, so the drift ratio compares like with
+ * like. Returns null if the bridge is unavailable.
+ */
+export declare function bridgeCountEmbeddings(options?: {
+    dimensions?: number;
+    dbPath?: string;
+}): Promise<number | null>;
 /**
  * Public helper for the unified learning-stats aggregator: counts of entries
  * per namespace + the top-level total. Best-effort — if the bridge isn't