monomind 1.11.13 → 1.12.0

package/packages/@monomind/cli/dist/src/mcp-tools/wasm-agent-tools.js

@@ -0,0 +1,230 @@
+/**
+ * WASM Agent MCP Tools
+ *
+ * Exposes @monoes/rvagent-wasm operations via MCP protocol.
+ * All tools gracefully degrade when the WASM package is not installed.
+ */
+async function loadAgentWasm() {
+    const mod = await import('../monovector/agent-wasm.js');
+    return mod;
+}
+export const wasmAgentTools = [
+    {
+        name: 'wasm_agent_create',
+        description: 'Create a sandboxed WASM agent with virtual filesystem (no OS access). Optionally use a gallery template.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                template: { type: 'string', description: 'Gallery template name (coder, researcher, tester, reviewer, security, swarm)' },
+                model: { type: 'string', description: 'Model identifier (default: anthropic:claude-sonnet-4-20250514)' },
+                instructions: { type: 'string', description: 'System instructions for the agent' },
+                maxTurns: { type: 'number', description: 'Max conversation turns (default: 50)' },
+            },
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                if (args.template) {
+                    const info = await wasm.createAgentFromTemplate(args.template);
+                    return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info, source: 'gallery' }, null, 2) }] };
+                }
+                const info = await wasm.createWasmAgent({
+                    model: args.model,
+                    instructions: args.instructions,
+                    maxTurns: args.maxTurns,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_prompt',
+        description: 'Send a prompt to a WASM agent and get a response.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+                input: { type: 'string', description: 'User prompt to send' },
+            },
+            required: ['agentId', 'input'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const result = await wasm.promptWasmAgent(args.agentId, args.input);
+                return { content: [{ type: 'text', text: result }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_tool',
+        description: 'Execute a tool on a WASM agent sandbox. Tools: read_file, write_file, edit_file, write_todos, list_files. Use flat format: {tool, path, content, ...}.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+                toolName: { type: 'string', description: 'Tool name (read_file, write_file, edit_file, write_todos, list_files)' },
+                toolInput: { type: 'object', description: 'Tool parameters (flat: {path, content, old_string, new_string, todos})' },
+            },
+            required: ['agentId', 'toolName'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                // Flat format: {tool: 'write_file', path: '...', content: '...'}
+                const toolCall = {
+                    tool: args.toolName,
+                    ...(args.toolInput ?? {}),
+                };
+                const result = await wasm.executeWasmTool(args.agentId, toolCall);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_list',
+        description: 'List all active WASM agents.',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const wasm = await loadAgentWasm();
+                const agents = wasm.listWasmAgents();
+                return { content: [{ type: 'text', text: JSON.stringify({ agents, count: agents.length }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_terminate',
+        description: 'Terminate a WASM agent and free resources.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const ok = wasm.terminateWasmAgent(args.agentId);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: ok }) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_files',
+        description: 'Get a WASM agent\'s available tools and info.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const tools = wasm.getWasmAgentTools(args.agentId);
+                const info = wasm.getWasmAgent(args.agentId);
+                return { content: [{ type: 'text', text: JSON.stringify({ tools, fileCount: info?.fileCount ?? 0, turnCount: info?.turnCount ?? 0 }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_export',
+        description: 'Export a WASM agent\'s full state (config, filesystem, conversation) as JSON.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const state = wasm.exportWasmState(args.agentId);
+                return { content: [{ type: 'text', text: state }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_gallery_list',
+        description: 'List all available WASM agent gallery templates (Coder, Researcher, Tester, Reviewer, Security, Swarm).',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const wasm = await loadAgentWasm();
+                const templates = await wasm.listGalleryTemplates();
+                return { content: [{ type: 'text', text: JSON.stringify({ templates, count: templates.length }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_gallery_search',
+        description: 'Search WASM agent gallery templates by query.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+            },
+            required: ['query'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const results = await wasm.searchGalleryTemplates(args.query);
+                return { content: [{ type: 'text', text: JSON.stringify({ results, count: results.length }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_gallery_create',
+        description: 'Create a WASM agent from a gallery template.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                template: { type: 'string', description: 'Template name (coder, researcher, tester, reviewer, security, swarm)' },
+            },
+            required: ['template'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const info = await wasm.createAgentFromTemplate(args.template);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info, template: args.template }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+];
+//# sourceMappingURL=wasm-agent-tools.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/workflow-tools.js

@@ -98,7 +98,12 @@ export const workflowTools = [
         handler: async (input) => {
             const store = loadWorkflowStore();
             const template = input.template;
-            const task = input.task;
+            // Cap task description to prevent DoS via unbounded string stored in
+            // workflow record and serialised to disk.
+            const MAX_WORKFLOW_TASK_LEN = 16 * 1024;
+            const rawTask = input.task;
+            const task = typeof rawTask === 'string' && rawTask.length > MAX_WORKFLOW_TASK_LEN
+                ? rawTask.slice(0, MAX_WORKFLOW_TASK_LEN) : rawTask;
             const options = input.options || {};
             const dryRun = options.dryRun;
             // Build workflow from template or inline
@@ -192,7 +197,19 @@ export const workflowTools = [
         handler: async (input) => {
             const store = loadWorkflowStore();
             const workflowId = `workflow-${Date.now()}-${randomBytes(6).toString('hex')}`;
-            const steps = (input.steps || []).map((s, i) => ({
+            // Cap string fields before storing to disk.
+            const MAX_WF_NAME_LEN = 512;
+            const MAX_WF_DESC_LEN = 16 * 1024;
+            const MAX_WF_STEPS = 500;
+            const rawWfName = input.name;
+            const wfName = typeof rawWfName === 'string' && rawWfName.length > MAX_WF_NAME_LEN
+                ? rawWfName.slice(0, MAX_WF_NAME_LEN) : rawWfName;
+            const rawWfDesc = input.description;
+            const wfDesc = typeof rawWfDesc === 'string' && rawWfDesc.length > MAX_WF_DESC_LEN
+                ? rawWfDesc.slice(0, MAX_WF_DESC_LEN) : rawWfDesc;
+            const rawSteps = input.steps || [];
+            const cappedSteps = rawSteps.slice(0, MAX_WF_STEPS);
+            const steps = cappedSteps.map((s, i) => ({
                 stepId: `step-${i + 1}`,
                 name: s.name || `Step ${i + 1}`,
                 type: s.type || 'task',
@@ -201,8 +218,8 @@ export const workflowTools = [
             }));
             const workflow = {
                 workflowId,
-                name: input.name,
-                description: input.description,
+                name: wfName,
+                description: wfDesc,
                 steps,
                 status: steps.length > 0 ? 'ready' : 'draft',
                 currentStep: 0,
@@ -355,8 +372,14 @@ export const workflowTools = [
             }
             // Sort by creation date (newest first)
             workflows.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-            // Apply limit
-            const limit = input.limit || 20;
+            // Apply limit — cap to 1 000 to prevent returning the full (potentially
+            // large) in-memory workflow store in one response, which could cause OOM
+            // or excessive serialisation latency.
+            const MAX_WORKFLOW_LIMIT = 1_000;
+            const rawLimit = typeof input.limit === 'number' ? input.limit : 20;
+            const limit = Number.isFinite(rawLimit) && rawLimit > 0
+                ? Math.min(Math.floor(rawLimit), MAX_WORKFLOW_LIMIT)
+                : 20;
             const totalCount = workflows.length;
             workflows = workflows.slice(0, limit);
             return {

package/packages/@monomind/cli/dist/src/memory/ewc-consolidation.js

@@ -145,7 +145,12 @@ export class EWCConsolidator {
             for (const newPattern of newPatterns) {
                 if (!newPattern.embedding || newPattern.embedding.length === 0)
                     continue;
-                const existingPattern = this.patterns.get(newPattern.id);
+                // Cap pattern ID length: unbounded IDs fill both the Map key and the
+                // modifiedPatterns/protectedPatterns result arrays without any limit.
+                const patternId = typeof newPattern.id === 'string'
+                    ? newPattern.id.slice(0, 256)
+                    : String(newPattern.id).slice(0, 256);
+                const existingPattern = this.patterns.get(patternId);
                 if (existingPattern) {
                     // Calculate EWC penalty for updating existing pattern
                     const penalty = this.getPenalty(existingPattern.weights, newPattern.embedding, fisher);
@@ -153,19 +158,19 @@ export class EWCConsolidator {
                     const importanceScore = this.calculateImportance(existingPattern);
                     if (importanceScore > this.config.importanceThreshold && penalty > this.config.lambda) {
                         // Protect high-importance patterns with high penalty
-                        result.protectedPatterns.push(newPattern.id);
+                        result.protectedPatterns.push(patternId);
                         // Apply constrained update: blend old and new based on importance
                         const blendFactor = 1 - importanceScore;
                         const blendedWeights = this.blendWeights(existingPattern.weights, newPattern.embedding, blendFactor, fisher);
                         existingPattern.weights = blendedWeights;
                         existingPattern.lastUpdated = Date.now();
-                        result.modifiedPatterns.push(newPattern.id);
+                        result.modifiedPatterns.push(patternId);
                     }
                     else {
                         // Low importance or low penalty: allow full update
                         existingPattern.weights = newPattern.embedding.slice(0, this.config.dimensions);
                         existingPattern.lastUpdated = Date.now();
-                        result.modifiedPatterns.push(newPattern.id);
+                        result.modifiedPatterns.push(patternId);
                     }
                     // Update Fisher diagonal for this pattern
                     existingPattern.fisherDiagonal = fisher;
@@ -174,7 +179,7 @@ export class EWCConsolidator {
                 else {
                     // New pattern: add directly
                     const weights = {
-                        id: newPattern.id,
+                        id: patternId,
                         weights: newPattern.embedding.slice(0, this.config.dimensions),
                         fisherDiagonal: fisher,
                         importance: 0.5,
@@ -184,8 +189,8 @@ export class EWCConsolidator {
                         type: newPattern.type,
                         description: newPattern.description
                     };
-                    this.patterns.set(newPattern.id, weights);
-                    result.modifiedPatterns.push(newPattern.id);
+                    this.patterns.set(patternId, weights);
+                    result.modifiedPatterns.push(patternId);
                 }
                 result.patternsConsolidated++;
             }
@@ -209,7 +214,10 @@ export class EWCConsolidator {
             return result;
         }
         catch (error) {
-            result.error = error instanceof Error ? error.message : String(error);
+            // Sanitize: strip filesystem paths and cap length so internal error
+            // messages are not reflected verbatim into CallerResult.error.
+            const rawMsg = error instanceof Error ? error.message : String(error);
+            result.error = rawMsg.replace(/\/[^\s:]+(\/|(?=\s|:|$))/g, '<path>/').slice(0, 500);
             result.duration = performance.now() - startTime;
             return result;
         }
@@ -513,6 +521,10 @@ export class EWCConsolidator {
         if (!fs.existsSync(this.config.storagePath)) {
             throw new Error('No persisted state found');
         }
+        const fileSize = fs.statSync(this.config.storagePath).size;
+        if (fileSize > 50 * 1024 * 1024) {
+            throw new Error(`EWC state file too large (${fileSize} bytes); refusing to load`);
+        }
         const content = fs.readFileSync(this.config.storagePath, 'utf-8');
         const state = JSON.parse(content);
         // Validate version
@@ -551,8 +563,12 @@ export class EWCConsolidator {
                 this.patterns.set(id, pattern);
             }
         }
-        // Restore history
-        this.consolidationHistory = Array.isArray(state.consolidationHistory) ? state.consolidationHistory : [];
+        // Restore history — cap to last 100 entries so a crafted state file cannot
+        // bloat the in-memory array (each entry is a small object, but the array is
+        // summed on every getConsolidationStats() call which is O(n)).
+        this.consolidationHistory = Array.isArray(state.consolidationHistory)
+            ? state.consolidationHistory.slice(-100)
+            : [];
         // Update config from persisted values, clamped to a sensible range to
         // prevent negative/NaN lambda from inverting the regularization sign.
         if (state.config && typeof state.config.lambda === 'number'

package/packages/@monomind/cli/dist/src/memory/intelligence.js

@@ -10,7 +10,7 @@
  *
  * @module v1/cli/intelligence
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, renameSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 // ============================================================================
@@ -332,7 +332,7 @@ class LocalReasoningBank {
     loadFromDisk() {
         try {
             const path = getPatternsPath();
-            if (existsSync(path)) {
+            if (existsSync(path) && statSync(path).size <= 50 * 1024 * 1024) {
                 const data = JSON.parse(readFileSync(path, 'utf-8'));
                 if (Array.isArray(data)) {
                     // Validate each persisted pattern. The patterns file is part of the
@@ -393,9 +393,10 @@ class LocalReasoningBank {
             renameSync(tmp, path);
             this.dirty = false;
         }
-        catch (error) {
+        catch {
             // Log but don't throw - persistence failures shouldn't break training
-            console.error('Failed to persist patterns:', error);
+            // Do not reflect raw error to avoid leaking internal paths
+            console.error('Failed to persist patterns');
         }
     }
     /**
@@ -548,7 +549,7 @@ let globalStats = {
 function loadPersistedStats() {
     try {
         const path = getStatsPath();
-        if (existsSync(path)) {
+        if (existsSync(path) && statSync(path).size <= 10 * 1024 * 1024) {
             const data = JSON.parse(readFileSync(path, 'utf-8'));
             if (data && typeof data === 'object') {
                 globalStats.trajectoriesRecorded = data.trajectoriesRecorded ?? 0;
@@ -599,7 +600,7 @@ async function _doInitializeIntelligence(config) {
         // Seed neural learned patterns from @monomind/neural's LearningBridge flush.
         // This is the A→B bridge reader: connects the automatic learning loop to routing.
         const neuralPatternsPath = join(getDataDir(), 'patterns.json');
-        if (existsSync(neuralPatternsPath)) {
+        if (existsSync(neuralPatternsPath) && statSync(neuralPatternsPath).size <= 50 * 1024 * 1024) {
             try {
                 const { generateEmbedding: genEmb } = await import('./memory-initializer.js').catch(() => ({ generateEmbedding: null }));
                 const raw = readFileSync(neuralPatternsPath, 'utf-8');
@@ -804,6 +805,10 @@ export async function recordTrajectory(steps, verdict) {
     }
 }
 export async function findSimilarPatterns(query, options) {
+    // Cap query length to prevent OOM via embedding generation on unbounded input
+    if (typeof query === 'string' && query.length > 2000) {
+        query = query.slice(0, 2000);
+    }
     if (!reasoningBank) {
         const init = await initializeIntelligence();
         if (!init.success)
@@ -943,9 +948,11 @@ export function benchmarkAdaptation(iterations = 1000) {
     if (!sonaCoordinator) {
         return { totalMs: 0, avgMs: 0, minMs: 0, maxMs: 0, targetMet: false };
     }
+    // Cap iterations to prevent OOM/CPU exhaustion from unbounded caller input
+    const safeIterations = Math.min(Math.max(1, iterations >>> 0), 100_000);
     const times = [];
     const testEmbedding = Array.from({ length: 384 }, () => Math.random());
-    for (let i = 0; i < iterations; i++) {
+    for (let i = 0; i < safeIterations; i++) {
         const start = performance.now();
         sonaCoordinator.recordSignal({
             type: 'test',
@@ -956,7 +963,7 @@ export function benchmarkAdaptation(iterations = 1000) {
         times.push(performance.now() - start);
     }
     const totalMs = times.reduce((a, b) => a + b, 0);
-    const avgMs = totalMs / iterations;
+    const avgMs = totalMs / safeIterations;
     const minMs = Math.min(...times);
     const maxMs = Math.max(...times);
     return {
@@ -980,21 +987,75 @@ function loadSonaRoutingPatterns() {
         const sonaPath = join(process.cwd(), '.swarm', 'sona-patterns.json');
         if (!existsSync(sonaPath))
             return [];
+        if (statSync(sonaPath).size > 10 * 1024 * 1024)
+            return [];
         const raw = JSON.parse(readFileSync(sonaPath, 'utf-8'));
         const persisted = raw;
-        if (!persisted.patterns || typeof persisted.patterns !== 'object')
+        if (!persisted.patterns || typeof persisted.patterns !== 'object' || Array.isArray(persisted.patterns))
             return [];
         const now = Date.now();
-        return Object.entries(persisted.patterns).map(([key, p]) => ({
-            id: `sona:${key}`,
-            type: p.agent ?? 'routing',
-            content: (p.keywords ?? [key]).join(' '),
-            confidence: p.confidence ?? 0.5,
-            usageCount: (p.successCount ?? 0) + (p.failureCount ?? 0),
-            embedding: [],
-            createdAt: p.createdAt ?? now,
-            lastUsedAt: now,
-        }));
+        const results = [];
+        // Cap total entries to prevent DoS via an unbounded patterns map.
+        // sona-patterns.json is written by the SONA optimizer but could be
+        // replaced by a malicious IPFS bundle — validate every field before use.
+        const MAX_SONA_ENTRIES = 500;
+        let entryCount = 0;
+        for (const [key, p] of Object.entries(persisted.patterns)) {
+            // Prototype pollution guard — skip __proto__ / constructor / prototype keys.
+            if (key === '__proto__' || key === 'constructor' || key === 'prototype')
+                continue;
+            if (typeof key !== 'string' || key.length === 0 || key.length > 256)
+                continue;
+            if (entryCount++ >= MAX_SONA_ENTRIES)
+                break;
+            if (!p || typeof p !== 'object')
+                continue;
+            // Validate keywords: must be a bounded array of short strings.
+            const rawKw = p.keywords;
+            let keywords;
+            if (rawKw === undefined) {
+                keywords = [key];
+            }
+            else if (Array.isArray(rawKw) && rawKw.length <= 64
+                && rawKw.every(k => typeof k === 'string' && k.length > 0 && k.length <= 128)) {
+                keywords = rawKw;
+            }
+            else {
+                continue; // malformed keywords — skip entry
+            }
+            // Validate agent string.
+            const agent = p.agent;
+            if (agent !== undefined && (typeof agent !== 'string' || agent.length === 0 || agent.length > 128))
+                continue;
+            // Validate confidence is a finite number in [0, 1].
+            const rawConf = p.confidence;
+            const confidence = rawConf !== undefined ? rawConf : 0.5;
+            if (typeof confidence !== 'number' || !Number.isFinite(confidence) || confidence < 0 || confidence > 1)
+                continue;
+            // Validate usage counts are safe integers.
+            const sc = p.successCount ?? 0;
+            const fc = p.failureCount ?? 0;
+            if (typeof sc !== 'number' || !Number.isFinite(sc) || sc < 0 || sc > 1e9)
+                continue;
+            if (typeof fc !== 'number' || !Number.isFinite(fc) || fc < 0 || fc > 1e9)
+                continue;
+            // Validate createdAt is a reasonable epoch ms value.
+            const rawTs = p.createdAt;
+            const createdAt = (rawTs !== undefined && typeof rawTs === 'number' && Number.isFinite(rawTs) && rawTs >= 0 && rawTs <= 9.9e12)
+                ? rawTs
+                : now;
+            results.push({
+                id: `sona:${key}`,
+                type: agent ?? 'routing',
+                content: keywords.join(' '),
+                confidence,
+                usageCount: sc + fc,
+                embedding: [],
+                createdAt,
+                lastUsedAt: now,
+            });
+        }
+        return results;
     }
     catch {
         return [];

package/packages/@monomind/cli/dist/src/memory/memory-bridge.js

@@ -404,8 +404,12 @@ async function getOrBuildHnswIndex(db) {
     _hnswIndexBuilt = true; // Lock prevents concurrent re-build
     try {
         const memPkg = await import('@monoes/memory');
-        if (!memPkg?.HNSWIndex)
+        if (!memPkg?.HNSWIndex) {
+            // Release the lock so a later retry can succeed if the package becomes available.
+            _hnswIndexBuilt = false;
+            _hnswBuildFailedAt = Date.now();
             return null;
+        }
         const rows = db.prepare(`SELECT id, embedding FROM memory_entries WHERE status = 'active' AND (expires_at IS NULL OR expires_at > ?) AND embedding IS NOT NULL`).all(Date.now());
         const valid = [];
         for (const row of rows) {
@@ -447,7 +451,22 @@ export async function bridgeStoreEntry(options) {
     if (!ctx)
         return null;
     try {
-        const { key, value, namespace = 'default', tags: rawTags = [], ttl } = options;
+        const rawKey = options.key;
+        const rawValue = options.value;
+        // SECURITY: defensive caps so no caller — current or future — can pass an
+        // unbounded string directly into embedder.embed (hash fallback is O(n)) or
+        // inflate the AgentDB row beyond practical limits.
+        // Memory-tools already validates to 1 MB; these caps are a last-resort
+        // backstop for any internal caller that forgets to pre-truncate.
+        const BRIDGE_MAX_KEY_LEN = 4 * 1024; // 4 KB — generous for any realistic key
+        const BRIDGE_MAX_VALUE_LEN = 1024 * 1024; // 1 MB — matches memory-tools validator
+        const key = typeof rawKey === 'string' && rawKey.length > BRIDGE_MAX_KEY_LEN
+            ? rawKey.slice(0, BRIDGE_MAX_KEY_LEN) : rawKey;
+        const value = typeof rawValue === 'string' && rawValue.length > BRIDGE_MAX_VALUE_LEN
+            ? rawValue.slice(0, BRIDGE_MAX_VALUE_LEN) : rawValue;
+        const namespace = options.namespace ?? 'default';
+        const rawTags = options.tags ?? [];
+        const ttl = options.ttl;
         // SECURITY: cap tags array length and per-tag length. Without these, any
         // memory_store caller (every spawned agent) could submit
         // tags: new Array(1e5).fill("x".repeat(1e4)) → ~1GB persisted blob,