@claude-flow/cli 3.71.3 → 3.72.0

package/dist/src/mcp-tools/browser-argv.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Argument checks for the agent-browser bridge.
+ *
+ * agent-browser reads its own options anywhere in argv, and forwards `--args`
+ * to the Chromium it launches. Both are reachable from MCP tool input, so
+ * caller text must never be able to add an option, and launch flags are
+ * limited to a fixed list of plain switches.
+ */
+/** Chromium launch switches a caller may request. Exact matches only; none takes a value. */
+export declare const ALLOWED_LAUNCH_ARGS: ReadonlySet<string>;
+/** Returns an error when a launch-flag list contains anything outside the allowlist. */
+export declare function launchArgsError(value: unknown): string | null;
+/**
+ * Returns an error when argv contains an option the tools did not mean to
+ * pass — for example a selector or typed text of "--executable-path".
+ */
+export declare function commandArgvError(args: readonly string[]): string | null;
+/**
+ * Returns an error when a navigation target is not a web page. The browser
+ * tools return page text to the caller, so a `file:` URL (or `view-source:`,
+ * `chrome:`, `data:` and the like) would read local files or browser state
+ * that `http_fetch` never serves. Only http(s) URLs, `about:blank`, and
+ * scheme-less targets such as `example.com/path` or `localhost:3000` (which
+ * agent-browser opens over http(s)) are accepted.
+ */
+export declare function browserUrlError(value: unknown): string | null;
+//# sourceMappingURL=browser-argv.d.ts.map

package/dist/src/mcp-tools/browser-argv.js

@@ -0,0 +1,92 @@
+/**
+ * Argument checks for the agent-browser bridge.
+ *
+ * agent-browser reads its own options anywhere in argv, and forwards `--args`
+ * to the Chromium it launches. Both are reachable from MCP tool input, so
+ * caller text must never be able to add an option, and launch flags are
+ * limited to a fixed list of plain switches.
+ */
+/** Chromium launch switches a caller may request. Exact matches only; none takes a value. */
+export const ALLOWED_LAUNCH_ARGS = new Set([
+    '--no-sandbox',
+    '--disable-setuid-sandbox',
+    '--disable-gpu',
+    '--disable-dev-shm-usage',
+    '--disable-extensions',
+    '--mute-audio',
+    '--hide-scrollbars',
+    '--incognito',
+]);
+/** The agent-browser options the browser tools themselves emit after a subcommand. */
+const COMMAND_FLAGS = new Set([
+    '--wait-until', '--full', '--button', '--count', '--delay', '--text', '--url',
+    '-i', '-c', '-d', '-s',
+]);
+/** Returns an error when a launch-flag list contains anything outside the allowlist. */
+export function launchArgsError(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (!Array.isArray(value))
+        return 'args must be an array of strings';
+    for (const arg of value) {
+        if (typeof arg !== 'string')
+            return 'args must be an array of strings';
+        if (!ALLOWED_LAUNCH_ARGS.has(arg)) {
+            return `launch arg not allowed: ${JSON.stringify(arg.slice(0, 80))} (allowed: ${[...ALLOWED_LAUNCH_ARGS].join(', ')})`;
+        }
+    }
+    return null;
+}
+/**
+ * Returns an error when argv contains an option the tools did not mean to
+ * pass — for example a selector or typed text of "--executable-path".
+ */
+export function commandArgvError(args) {
+    if (args[0] === 'open') {
+        const urlError = browserUrlError(args[1]);
+        if (urlError)
+            return urlError;
+    }
+    for (const arg of args) {
+        if (typeof arg !== 'string')
+            return 'browser command arguments must be strings';
+        if (arg.startsWith('--')) {
+            const name = arg.split('=', 1)[0];
+            if (!COMMAND_FLAGS.has(name))
+                return `value must not start with "--": ${JSON.stringify(arg.slice(0, 80))}`;
+        }
+        else if (/^-[A-Za-z]$/.test(arg) && !COMMAND_FLAGS.has(arg)) {
+            return `value must not be an option: ${JSON.stringify(arg)}`;
+        }
+    }
+    return null;
+}
+/**
+ * Returns an error when a navigation target is not a web page. The browser
+ * tools return page text to the caller, so a `file:` URL (or `view-source:`,
+ * `chrome:`, `data:` and the like) would read local files or browser state
+ * that `http_fetch` never serves. Only http(s) URLs, `about:blank`, and
+ * scheme-less targets such as `example.com/path` or `localhost:3000` (which
+ * agent-browser opens over http(s)) are accepted.
+ */
+export function browserUrlError(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return 'url must be a non-empty string';
+    // Chromium drops tabs and newlines anywhere in a URL and trims leading
+    // control characters and spaces, so check what it would actually parse.
+    const url = value.replace(/[\t\n\r]/g, '').replace(/^[\u0000- ]+/, '');
+    const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(url);
+    if (!scheme)
+        return null;
+    const name = scheme[1].toLowerCase();
+    if (name === 'http' || name === 'https')
+        return null;
+    if (url.toLowerCase() === 'about:blank')
+        return null;
+    // `host:port` with no scheme, e.g. `localhost:3000/app`. The host must be
+    // `localhost` or contain a dot, so `file:1/...` is not mistaken for one.
+    if ((name === 'localhost' || name.includes('.')) && /^[a-z0-9.-]+:\d{1,5}(?:[/?#]|$)/i.test(url))
+        return null;
+    return `url scheme not allowed: ${JSON.stringify(name.slice(0, 40))} (use http or https)`;
+}
+//# sourceMappingURL=browser-argv.js.map

package/dist/src/mcp-tools/browser-session-tools.js

@@ -22,6 +22,7 @@
  *     rather than a process crash.
  */
 import { validateIdentifier, validateText } from './validate-input.js';
+import { browserUrlError } from './browser-argv.js';
 // Pin matches the version in this package's own dependency tree so the npx
 // fallback never downloads a second ruvector. Subcommand surface verified
 // against ruvector@0.2.27 --help: `rvf create/compact/status/derive/segments`
@@ -144,6 +145,9 @@ export const browserSessionTools = [
             const vUrl = validateText(input.url, 'url');
             if (!vUrl.valid)
                 return fail(vUrl.error || 'invalid url');
+            const urlError = browserUrlError(input.url);
+            if (urlError)
+                return fail(urlError);
             const vTask = validateText(input.task, 'task');
             if (!vTask.valid)
                 return fail(vTask.error || 'invalid task');

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

@@ -12,7 +12,7 @@ import type { MCPTool, MCPToolResult } from './types.js';
  * Exported so browser-intent-tools.ts (ADR-175 `browser_act`) can reuse the same
  * exec + fallback + session-plumbing instead of duplicating it.
  */
-export declare function execBrowserCommand(args: string[], session?: string): Promise<MCPToolResult>;
+export declare function execBrowserCommand(args: string[], session?: string, launchArgs?: readonly string[]): Promise<MCPToolResult>;
 /**
  * Browser MCP Tools
  */

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

@@ -7,6 +7,9 @@
 import { readFileSync, existsSync } from 'node:fs';
 import { validateIdentifier, validateText } from './validate-input.js';
 import { resolveAgentBrowserLaunch, resolveNpxLaunch } from '../runtime/browser-command.js';
+import { commandArgvError, launchArgsError } from './browser-argv.js';
+import { containedWritePath } from './path-containment.js';
+const SCREENSHOT_EXTENSIONS = ['.png', '.jpg', '.jpeg'];
 // Session registry for multi-session support
 const browserSessions = new Map();
 /** Preserve agent-browser's JSON error on non-zero exit without echoing other process output. */
@@ -44,9 +47,14 @@ function browserCommandFailure(error, missingExecutable) {
  * Exported so browser-intent-tools.ts (ADR-175 `browser_act`) can reuse the same
  * exec + fallback + session-plumbing instead of duplicating it.
  */
-export async function execBrowserCommand(args, session = 'default') {
+export async function execBrowserCommand(args, session = 'default', launchArgs = []) {
+    const argvError = commandArgvError(args) ?? launchArgsError(launchArgs);
+    if (argvError)
+        return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: argvError }) }], isError: true };
     const { execFileSync } = await import('child_process');
     const fullArgs = ['--session', session, '--json', ...args];
+    if (launchArgs.length > 0)
+        fullArgs.push('--args', launchArgs.join(','));
     // ADR-401: fullArgs carries tool-supplied text (fill values, eval scripts,
     // selectors), so no spawn here may use a shell. On Windows the npm shims are
     // resolved to the process behind them instead of enabling `shell: true`,
@@ -147,7 +155,7 @@ export const browserTools = [
                 args: {
                     type: 'array',
                     items: { type: 'string' },
-                    description: 'Additional Chrome launch args (e.g., ["--no-sandbox", "--disable-dev-shm-usage"])',
+                    description: 'Additional Chrome launch switches. Only these are accepted: --no-sandbox, --disable-setuid-sandbox, --disable-gpu, --disable-dev-shm-usage, --disable-extensions, --mute-audio, --hide-scrollbars, --incognito',
                 },
             },
             required: ['url'],
@@ -162,15 +170,16 @@ export const browserTools = [
                     return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: vS.error }) }], isError: true };
             }
             const { url, session, waitUntil } = input;
-            const launchArgs = input.args || [];
+            const vArgs = launchArgsError(input.args);
+            if (vArgs)
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: vArgs }) }], isError: true };
+            const launchArgs = [...(input.args || [])];
             if (needsNoSandbox() && !launchArgs.includes('--no-sandbox')) {
                 launchArgs.push('--no-sandbox');
             }
             const args = ['open', url];
             if (waitUntil)
                 args.push('--wait-until', waitUntil);
-            if (launchArgs.length > 0)
-                args.push('--args', launchArgs.join(','));
             // Create session if new
             const sessionId = session || 'default';
             if (!browserSessions.has(sessionId)) {
@@ -180,7 +189,7 @@ export const browserTools = [
                     lastActivity: new Date().toISOString(),
                 });
             }
-            return execBrowserCommand(args, sessionId);
+            return execBrowserCommand(args, sessionId, launchArgs);
         },
     },
     {
@@ -317,8 +326,16 @@ export const browserTools = [
             }
             const { session, path, fullPage } = input;
             const args = ['screenshot'];
-            if (path)
-                args.push(path);
+            if (path) {
+                // The browser writes the image wherever it is told and replaces what
+                // is there, so a caller-named path must stay inside the project.
+                const target = containedWritePath(path, SCREENSHOT_EXTENSIONS);
+                if (!target) {
+                    const error = `path must be a new or regular file inside the project ending in ${SCREENSHOT_EXTENSIONS.join(', ')}`;
+                    return { content: [{ type: 'text', text: JSON.stringify({ success: false, error }) }], isError: true };
+                }
+                args.push(target);
+            }
             if (fullPage)
                 args.push('--full');
             return execBrowserCommand(args, session);

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

@@ -346,11 +346,12 @@ export const coordinationTools = [
             }
             if (action === 'heartbeat') {
                 const nodeId = input.nodeId;
-                if (store.nodes[nodeId]) {
-                    store.nodes[nodeId].lastHeartbeat = new Date().toISOString();
-                    store.nodes[nodeId].status = 'active';
-                    saveCoordStore(store);
+                if (!store.nodes[nodeId]) {
+                    return { success: false, error: 'Node not found' };
                 }
+                store.nodes[nodeId].lastHeartbeat = new Date().toISOString();
+                store.nodes[nodeId].status = 'active';
+                saveCoordStore(store);
                 return {
                     success: true,
                     action: 'heartbeat',

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

@@ -50,11 +50,14 @@ async function getRealEmbeddingFunction() {
     }
     return realEmbeddingFn;
 }
-async function generateRealEmbedding(text, dimension) {
+async function generateRealEmbedding(text, dimension, normalize = true) {
     const realFn = await getRealEmbeddingFunction();
     if (realFn) {
         try {
-            const result = await realFn(text);
+            // Default callers stay a single-argument call so existing mocks and
+            // the unit-norm path are unchanged. Only an explicit opt-out asks the
+            // generator for the pre-L2 vector.
+            const result = normalize ? await realFn(text) : await realFn(text, { normalize: false });
             return {
                 embedding: result.embedding,
                 backend: result.backend ?? 'onnx',
@@ -76,7 +79,10 @@ async function generateRealEmbedding(text, dimension) {
         const seed = hash + i * 1337;
         embedding.push(Math.sin(seed) * Math.cos(seed * 0.5));
     }
-    // L2 normalize
+    // L2 normalize unless the caller opted out (#4724).
+    if (!normalize) {
+        return { embedding, backend: 'mock', model: 'hash-fallback' };
+    }
     const norm = Math.sqrt(embedding.reduce((sum, x) => sum + x * x, 0));
     return {
         embedding: embedding.map(x => x / norm),
@@ -256,8 +262,10 @@ export const embeddingsTools = [
                     return { success: false, error: v.error };
             }
             const useHyperbolic = input.hyperbolic === true && config.hyperbolic.enabled;
+            // Default true: omitted and explicit true keep the historical unit vector.
+            const shouldNormalize = input.normalize !== false;
             // Generate real ONNX embedding
-            const generated = await generateRealEmbedding(text, config.dimension);
+            const generated = await generateRealEmbedding(text, config.dimension, shouldNormalize);
             const embedding = generated.embedding;
             let result;
             let geometry;

package/dist/src/mcp-tools/glob-exclusions.d.ts

@@ -0,0 +1,6 @@
+/** Bounded glob matching for caller-provided memory-import exclusions. */
+export declare const MAX_EXCLUDE_PATTERNS = 64;
+export declare const MAX_EXCLUDE_PATTERN_LENGTH = 1024;
+export declare const MAX_EXCLUDE_WILDCARDS = 32;
+export declare function compileExclusionPatterns(input: unknown): Array<(path: string) => boolean>;
+//# sourceMappingURL=glob-exclusions.d.ts.map

package/dist/src/mcp-tools/glob-exclusions.js

@@ -0,0 +1,81 @@
+/** Bounded glob matching for caller-provided memory-import exclusions. */
+export const MAX_EXCLUDE_PATTERNS = 64;
+export const MAX_EXCLUDE_PATTERN_LENGTH = 1024;
+export const MAX_EXCLUDE_WILDCARDS = 32;
+function tokenize(pattern) {
+    const tokens = [];
+    let wildcards = 0;
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        if (char === '*') {
+            let end = i + 1;
+            while (pattern[end] === '*')
+                end++;
+            tokens.push({ kind: end - i > 1 ? 'globstar' : 'star' });
+            // Preserve the trailing segment-star in odd runs, including its newline behavior.
+            if (end - i > 1 && (end - i) % 2 === 1) {
+                tokens.push({ kind: 'star' });
+                wildcards++;
+            }
+            i = end - 1;
+            wildcards++;
+        }
+        else if (char === '?') {
+            tokens.push({ kind: 'question' });
+            wildcards++;
+        }
+        else {
+            tokens.push({ kind: 'literal', value: char });
+        }
+    }
+    if (wildcards > MAX_EXCLUDE_WILDCARDS) {
+        throw new Error(`excludeFilePatterns entries may contain at most ${MAX_EXCLUDE_WILDCARDS} wildcard operators`);
+    }
+    return tokens;
+}
+function matches(tokens, path) {
+    // Each path character visits each token once; wildcard placement cannot cause backtracking.
+    let previous = new Uint8Array(tokens.length + 1);
+    let current = new Uint8Array(tokens.length + 1);
+    previous[0] = 1;
+    for (let j = 1; j <= tokens.length; j++) {
+        const token = tokens[j - 1];
+        if (token.kind === 'star' || token.kind === 'globstar')
+            previous[j] = previous[j - 1];
+    }
+    for (let i = 0; i < path.length; i++) {
+        current[0] = 0;
+        const char = path[i];
+        const inSegment = char !== '/' && char !== '\\';
+        for (let j = 1; j <= tokens.length; j++) {
+            const token = tokens[j - 1];
+            if (token.kind === 'star' || token.kind === 'globstar') {
+                const canConsume = token.kind === 'globstar'
+                    ? !'\n\r\u2028\u2029'.includes(char)
+                    : inSegment;
+                current[j] = current[j - 1] || (canConsume ? previous[j] : 0);
+            }
+            else {
+                const canConsume = token.kind === 'literal' ? token.value === char : inSegment;
+                current[j] = canConsume ? previous[j - 1] : 0;
+            }
+        }
+        [previous, current] = [current, previous];
+    }
+    return previous[tokens.length] === 1;
+}
+export function compileExclusionPatterns(input) {
+    if (input === undefined)
+        return [];
+    if (!Array.isArray(input) || input.length > MAX_EXCLUDE_PATTERNS) {
+        throw new Error(`excludeFilePatterns must be an array of at most ${MAX_EXCLUDE_PATTERNS} patterns`);
+    }
+    return Array.from(input, (pattern) => {
+        if (typeof pattern !== 'string' || pattern.length > MAX_EXCLUDE_PATTERN_LENGTH) {
+            throw new Error(`excludeFilePatterns entries must be strings of at most ${MAX_EXCLUDE_PATTERN_LENGTH} characters`);
+        }
+        const tokens = tokenize(pattern);
+        return (path) => matches(tokens, path);
+    });
+}
+//# sourceMappingURL=glob-exclusions.js.map

package/dist/src/mcp-tools/hive-mind-tools.js

@@ -8,6 +8,7 @@ import { join } from 'node:path';
 import { randomBytes, createHash, timingSafeEqual } from 'node:crypto';
 import { getProjectCwd } from './types.js';
 import { validateIdentifier, validateText } from './validate-input.js';
+import { readPreservedJsonStore } from './record-store.js';
 // Storage paths
 const STORAGE_DIR = '.claude-flow';
 const HIVE_DIR = 'hive-mind';
@@ -199,17 +200,10 @@ function ensureHiveDir() {
     catch { /* not ours / unsupported */ }
 }
 function loadHiveState() {
-    try {
-        const path = getHivePath();
-        if (existsSync(path)) {
-            const data = readFileSync(path, 'utf-8');
-            return JSON.parse(data);
-        }
-    }
-    catch {
-        // Return default state on error
-    }
-    return {
+    // #4737: a parse error used to return a fresh hive, and the next save
+    // overwrote state.json (including its capability token). Only a missing
+    // file is empty; corrupt bytes are copied aside and the error is reported.
+    return readPreservedJsonStore(getHivePath(), 'hive-mind', () => ({
         initialized: false,
         topology: 'mesh',
         workers: [],
@@ -217,7 +211,7 @@ function loadHiveState() {
         sharedMemory: {},
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
-    };
+    }));
 }
 function saveHiveState(state) {
     ensureHiveDir();
@@ -243,24 +237,50 @@ function saveHiveState(state) {
         throw err;
     }
 }
-// Import agent store helpers for spawn functionality
-import { existsSync as agentStoreExists, readFileSync as readAgentStore, writeFileSync as writeAgentStore, mkdirSync as mkdirAgentStore } from 'node:fs';
-function loadAgentStore() {
-    const storePath = join(getProjectCwd(), '.claude-flow', 'agents.json');
+function getHiveAgentPath() {
+    return join(getProjectCwd(), STORAGE_DIR, 'agents.json');
+}
+function loadAgentStore(storePath = getHiveAgentPath()) {
+    let text;
     try {
-        if (agentStoreExists(storePath)) {
-            return JSON.parse(readAgentStore(storePath, 'utf-8'));
-        }
+        text = readFileSync(storePath, 'utf-8');
     }
-    catch { /* ignore */ }
-    return { agents: {} };
-}
-function saveAgentStore(store) {
-    const storeDir = join(getProjectCwd(), '.claude-flow');
-    if (!agentStoreExists(storeDir)) {
-        mkdirAgentStore(storeDir, { recursive: true });
+    catch (error) {
+        // Only an absent file is empty: never replace corrupt/unreadable data.
+        if (error.code === 'ENOENT')
+            return { agents: {} };
+        throw error;
     }
-    writeAgentStore(join(storeDir, 'agents.json'), JSON.stringify(store, null, 2), 'utf-8');
+    const store = JSON.parse(text);
+    if (!store || typeof store !== 'object' || Array.isArray(store)
+        || !store.agents || typeof store.agents !== 'object'
+        || Object.values(store.agents).some(agent => !agent || typeof agent !== 'object' || Array.isArray(agent))) {
+        throw new Error(`Invalid agent store at ${storePath}; existing data was preserved`);
+    }
+    return store;
+}
+function saveAgentStore(store, storePath = getHiveAgentPath()) {
+    // A new hive store lives directly in STORAGE_DIR; join only writes stores
+    // that already contain its agent, so their parent directories already exist.
+    mkdirSync(join(getProjectCwd(), STORAGE_DIR), { recursive: true });
+    writeFileSync(storePath, JSON.stringify(store, null, 2), 'utf-8');
+}
+function findAgent(store, agentId) {
+    if (Array.isArray(store.agents))
+        return store.agents.find(agent => agent.agentId === agentId);
+    return Object.prototype.hasOwnProperty.call(store.agents, agentId) ? store.agents[agentId] : undefined;
+}
+const HIVE_ROLES = new Set(['worker', 'specialist', 'scout']);
+function capacityError(state, additionalWorkers) {
+    const maxAgents = state.maxAgents ?? 15;
+    if (state.workers.length + additionalWorkers <= maxAgents)
+        return null;
+    return {
+        success: false,
+        error: `Hive-mind capacity exceeded: ${state.workers.length}/${maxAgents} workers; cannot add ${additionalWorkers}. Leave the hive or initialize with a larger maxAgents.`,
+        totalWorkers: state.workers.length,
+        maxAgents,
+    };
 }
 export const hiveMindTools = [
     {
@@ -303,8 +323,19 @@ export const hiveMindTools = [
                 if (!v.valid)
                     return { success: false, error: v.error };
             }
-            const count = Math.min(Math.max(1, input.count || 1), 20); // Cap at 20
+            const requestedCount = input.count === undefined ? 1 : input.count;
+            if (typeof requestedCount !== 'number' || !Number.isInteger(requestedCount) || requestedCount < 1) {
+                return { success: false, error: 'count must be a positive integer' };
+            }
+            const count = Math.min(requestedCount, 20); // Preserve the per-call cap.
+            // Reject the entire batch before creating agents or mutating the roster.
+            const full = capacityError(state, count);
+            if (full)
+                return full;
             const role = input.role || 'worker';
+            if (!HIVE_ROLES.has(role)) {
+                return { success: false, error: `role must be one of: ${[...HIVE_ROLES].join(', ')}` };
+            }
             const agentType = input.agentType || 'worker';
             const prefix = input.prefix || 'hive-worker';
             const agentStore = loadAgentStore();
@@ -312,7 +343,7 @@ export const hiveMindTools = [
             for (let i = 0; i < count; i++) {
                 const agentId = `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
                 // Create agent record (like agent/spawn)
-                agentStore.agents[agentId] = {
+                const agent = {
                     agentId,
                     agentType,
                     status: 'idle',
@@ -322,6 +353,10 @@ export const hiveMindTools = [
                     createdAt: new Date().toISOString(),
                     domain: 'hive-mind',
                 };
+                if (Array.isArray(agentStore.agents))
+                    agentStore.agents.push(agent);
+                else
+                    agentStore.agents[agentId] = agent;
                 // Join to hive-mind (like hive-mind/join)
                 if (!state.workers.includes(agentId)) {
                     state.workers.push(agentId);
@@ -521,7 +556,7 @@ export const hiveMindTools = [
                     term: state.queen.term,
                 } : { id: 'N/A', status: 'offline', load: 0, tasksQueued: 0 },
                 workers: state.workers.map(w => {
-                    const agent = agentStore.agents[w];
+                    const agent = findAgent(agentStore, w);
                     return {
                         id: w,
                         type: agent?.agentType || 'worker',
@@ -601,14 +636,43 @@ export const hiveMindTools = [
             if (tokenError) {
                 return { success: false, agentId, error: tokenError };
             }
-            if (!state.workers.includes(agentId)) {
+            const alreadyJoined = state.workers.includes(agentId);
+            // Retrying a registered member does not consume another slot.
+            if (!alreadyJoined) {
+                const full = capacityError(state, 1);
+                if (full)
+                    return { ...full, agentId };
+            }
+            // Both registration paths are legitimate (#1916). Update each existing
+            // record in place, preserving metadata and map/array representation.
+            const paths = [
+                join(getProjectCwd(), STORAGE_DIR, 'agents', 'store.json'),
+                getHiveAgentPath(),
+            ];
+            const records = paths.flatMap(path => {
+                const store = loadAgentStore(path);
+                const agent = findAgent(store, agentId);
+                return agent ? [{ path, store, agent }] : [];
+            });
+            if (records.length === 0) {
+                return { success: false, agentId, error: 'Agent not found. Register it with agent_spawn or hive-mind_spawn first.' };
+            }
+            const role = input.role || 'worker';
+            if (!HIVE_ROLES.has(role)) {
+                return { success: false, agentId, error: `role must be one of: ${[...HIVE_ROLES].join(', ')}` };
+            }
+            for (const { path, store, agent } of records) {
+                agent.config = { ...agent.config, role, hiveRole: role };
+                saveAgentStore(store, path);
+            }
+            if (!alreadyJoined) {
                 state.workers.push(agentId);
                 saveHiveState(state);
             }
             return {
                 success: true,
                 agentId,
-                role: input.role || 'worker',
+                role,
                 totalWorkers: state.workers.length,
                 joinedAt: new Date().toISOString(),
             };
@@ -1073,9 +1137,14 @@ export const hiveMindTools = [
             }
             // Clear workers from agent store
             const agentStore = loadAgentStore();
-            for (const workerId of state.workers) {
-                if (agentStore.agents[workerId]) {
-                    delete agentStore.agents[workerId];
+            if (Array.isArray(agentStore.agents)) {
+                agentStore.agents = agentStore.agents.filter(agent => !state.workers.includes(agent.agentId));
+            }
+            else {
+                for (const workerId of state.workers) {
+                    if (Object.prototype.hasOwnProperty.call(agentStore.agents, workerId)) {
+                        delete agentStore.agents[workerId];
+                    }
                 }
             }
             saveAgentStore(agentStore);

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

@@ -2288,7 +2288,8 @@ export const hooksTransfer = {
     },
     handler: async (params) => {
         const sourcePath = params.sourcePath;
-        const minConfidence = params.minConfidence || 0.7;
+        // #4728: an explicit 0 must not fall through to 0.7 (`0 || 0.7` is 0.7).
+        const minConfidence = params.minConfidence ?? 0.7;
         const filter = params.filter;
         {
             const v = validatePath(sourcePath, 'sourcePath');
@@ -3474,7 +3475,8 @@ export const hooksPatternStore = {
     handler: async (params) => {
         const pattern = params.pattern;
         const type = params.type || 'general';
-        const confidence = params.confidence || 0.8;
+        // #4728: an explicit 0 must not fall through to 0.8 (`0 || 0.8` is 0.8).
+        const confidence = params.confidence ?? 0.8;
         const metadata = params.metadata;
         const timestamp = new Date().toISOString();
         {
@@ -3559,7 +3561,8 @@ export const hooksPatternSearch = {
     handler: async (params) => {
         const query = params.query;
         const topK = params.topK || 5;
-        const minConfidence = params.minConfidence || 0.3;
+        // #4728: an explicit 0 must not fall through to 0.3 (`0 || 0.3` is 0.3).
+        const minConfidence = params.minConfidence ?? 0.3;
         const namespace = params.namespace || 'pattern';
         const strategy = params.strategy || 'semantic';
         {
@@ -4865,7 +4868,8 @@ export const hooksWorkerDetect = {
     handler: async (params) => {
         const prompt = params.prompt;
         const autoDispatch = params.autoDispatch;
-        const minConfidence = params.minConfidence || 0.5;
+        // #4728: an explicit 0 must not fall through to 0.5 (`0 || 0.5` is 0.5).
+        const minConfidence = params.minConfidence ?? 0.5;
         {
             const v = validateText(prompt, 'prompt');
             if (!v.valid)
@@ -4968,7 +4972,10 @@ export const hooksModelRoute = {
                 implementation: 'fallback',
             };
         }
-        const result = await router.route(task);
+        const result = await router.route(task, undefined, {
+            preferCost: typeof params.preferCost === 'boolean' ? params.preferCost : undefined,
+            preferSpeed: typeof params.preferSpeed === 'boolean' ? params.preferSpeed : undefined,
+        });
         return {
             model: result.model,
             confidence: result.confidence,

package/dist/src/mcp-tools/import-limits.d.ts

@@ -0,0 +1,4 @@
+export declare const MAX_IMPORT_BYTES: number;
+/** Bound allocation and reads even if an import file grows after its size check. */
+export declare function readImportFile(file: string): Buffer;
+//# sourceMappingURL=import-limits.d.ts.map