monomind 1.11.13 → 1.12.0

package/packages/@monomind/cli/dist/src/commands/task.js

@@ -5,6 +5,16 @@
 import { output } from '../output.js';
 import { select, confirm, input, multiSelect } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
+// Input length caps
+const MAX_TASK_ID_LEN = 128;
+const MAX_DESCRIPTION_LEN = 4_000;
+const MAX_REASON_LEN = 512;
+const MAX_TAGS = 20;
+const MAX_TAG_LEN = 64;
+const MAX_DEPS = 50;
+const MAX_DEP_LEN = 128;
+const MAX_ASSIGN_LEN = 128;
+const MAX_LIMIT = 1_000;
 // Task types
 const TASK_TYPES = [
     { value: 'implementation', label: 'Implementation', hint: 'Feature implementation' },
@@ -135,6 +145,8 @@ const createCommand = {
             output.printInfo('Use --type and --description flags, or run in interactive mode');
             return { success: false, exitCode: 1 };
         }
+        // Cap description length
+        description = description.slice(0, MAX_DESCRIPTION_LEN);
         if (!priority && ctx.interactive) {
             priority = await select({
                 message: 'Select priority:',
@@ -142,10 +154,12 @@ const createCommand = {
                 default: 'normal'
             });
         }
-        // Parse tags and dependencies
-        const tags = ctx.flags.tags ? ctx.flags.tags.split(',').map(t => t.trim()) : [];
+        // Parse and cap tags and dependencies
+        const tags = ctx.flags.tags
+            ? ctx.flags.tags.split(',').map(t => t.trim().slice(0, MAX_TAG_LEN)).filter(Boolean).slice(0, MAX_TAGS)
+            : [];
         const dependencies = ctx.flags.dependencies
-            ? ctx.flags.dependencies.split(',').map(d => d.trim())
+            ? ctx.flags.dependencies.split(',').map(d => d.trim().slice(0, MAX_DEP_LEN)).filter(Boolean).slice(0, MAX_DEPS)
             : [];
         output.writeln();
         output.printInfo(`Creating ${taskType} task...`);
@@ -154,7 +168,7 @@ const createCommand = {
                 type: taskType,
                 description,
                 priority: priority || 'normal',
-                assignedTo: ctx.flags.assign ? [ctx.flags.assign] : undefined,
+                assignedTo: ctx.flags.assign ? [ctx.flags.assign.slice(0, MAX_ASSIGN_LEN)] : undefined,
                 parentId: ctx.flags.parent,
                 dependencies,
                 tags,
@@ -246,7 +260,7 @@ const listCommand = {
     ],
     action: async (ctx) => {
         const status = ctx.flags.all ? 'all' : ctx.flags.status || 'pending,running';
-        const limit = ctx.flags.limit;
+        const limit = Math.min(Math.max(1, ctx.flags.limit || 20), MAX_LIMIT);
         try {
             const result = await callMCPTool('task_list', {
                 status,
@@ -321,12 +335,13 @@ const statusCommand = {
         }
     ],
     action: async (ctx) => {
-        let taskId = ctx.args[0] || ctx.flags.id;
+        let taskId = (ctx.args[0] || ctx.flags.id || '').slice(0, MAX_TASK_ID_LEN);
         if (!taskId && ctx.interactive) {
             taskId = await input({
                 message: 'Enter task ID:',
                 validate: (v) => v.length > 0 || 'Task ID is required'
             });
+            taskId = taskId.slice(0, MAX_TASK_ID_LEN);
         }
         if (!taskId) {
             output.printError('Task ID is required');
@@ -448,9 +463,9 @@ const cancelCommand = {
         }
     ],
     action: async (ctx) => {
-        const taskId = ctx.args[0];
+        const taskId = (ctx.args[0] || '').slice(0, MAX_TASK_ID_LEN);
         const force = ctx.flags.force;
-        const reason = ctx.flags.reason;
+        const reason = typeof ctx.flags.reason === 'string' ? ctx.flags.reason.slice(0, MAX_REASON_LEN) : undefined;
         if (!taskId) {
             output.printError('Task ID is required');
             return { success: false, exitCode: 1 };
@@ -508,7 +523,7 @@ const assignCommand = {
         }
     ],
     action: async (ctx) => {
-        const taskId = ctx.args[0];
+        const taskId = (ctx.args[0] || '').slice(0, MAX_TASK_ID_LEN);
         const agentIds = ctx.flags.agent;
         const unassign = ctx.flags.unassign;
         if (!taskId) {
@@ -560,7 +575,7 @@ const assignCommand = {
         try {
             const result = await callMCPTool('task_assign', {
                 taskId,
-                agentIds: unassign ? [] : agentIds.split(',').map(id => id.trim()),
+                agentIds: unassign ? [] : agentIds.split(',').map(id => id.trim().slice(0, MAX_ASSIGN_LEN)).filter(Boolean).slice(0, 20),
                 unassign
             });
             output.writeln();
@@ -600,7 +615,7 @@ const retryCommand = {
         }
     ],
     action: async (ctx) => {
-        const taskId = ctx.args[0];
+        const taskId = (ctx.args[0] || '').slice(0, MAX_TASK_ID_LEN);
         const resetState = ctx.flags['reset-state'];
         if (!taskId) {
             output.printError('Task ID is required');

package/packages/@monomind/cli/dist/src/commands/tokens.js

@@ -15,6 +15,11 @@ function loadTracker() {
     const require = createRequire(import.meta.url);
     return require(getTrackerPath());
 }
+const VALID_PERIODS = new Set(['today', 'week', '30days', 'month']);
+function validatePeriod(raw) {
+    const s = typeof raw === 'string' ? raw : 'today';
+    return VALID_PERIODS.has(s) ? s : 'today';
+}
 const dashboardSubcommand = {
     name: 'dashboard',
     description: 'Launch interactive token usage dashboard',
@@ -23,7 +28,7 @@ const dashboardSubcommand = {
         { name: 'no-interactive', type: 'boolean', description: 'Render once and exit', default: false },
     ],
     action: async (ctx) => {
-        const period = ctx.flags['period'] || 'today';
+        const period = validatePeriod(ctx.flags['period']);
         const noInteractive = ctx.flags['no-interactive'];
         try {
             const tracker = loadTracker();
@@ -49,7 +54,7 @@ const summarySubcommand = {
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
     ],
     action: async (ctx) => {
-        const period = ctx.flags['period'] || 'today';
+        const period = validatePeriod(ctx.flags['period']);
         const asJson = ctx.flags['json'];
         try {
             const tracker = loadTracker();

package/packages/@monomind/cli/dist/src/commands/transfer-store.js

@@ -23,12 +23,12 @@ export const storeListCommand = {
         { command: 'monomind hooks transfer store list --featured', description: 'List featured patterns' },
     ],
     action: async (ctx) => {
-        const registryName = ctx.flags.registry;
-        const category = ctx.flags.category;
+        const registryName = ctx.flags.registry?.slice(0, 128);
+        const category = ctx.flags.category?.slice(0, 128);
         const featured = ctx.flags.featured;
         const trending = ctx.flags.trending;
         const newest = ctx.flags.newest;
-        const limit = ctx.flags.limit || 20;
+        const limit = Math.max(1, Math.min(200, ctx.flags.limit || 20));
         const spinner = output.createSpinner({ text: 'Discovering registry...', spinner: 'dots' });
         spinner.start();
         try {
@@ -120,7 +120,7 @@ export const storeSearchCommand = {
         { command: 'monomind hooks transfer store search -q "react" --language typescript', description: 'Search with filters' },
     ],
     action: async (ctx) => {
-        const query = (ctx.args[0] || ctx.flags.query);
+        const query = (ctx.args[0] || ctx.flags.query)?.slice(0, 256);
         if (!query) {
             output.printError('Search query is required. Use --query or -q flag.');
             return { success: false, exitCode: 1 };
@@ -136,13 +136,13 @@ export const storeSearchCommand = {
             }
             const searchOptions = {
                 query,
-                category: ctx.flags.category,
-                language: ctx.flags.language,
-                framework: ctx.flags.framework,
-                tags: ctx.flags.tags ? ctx.flags.tags.split(',') : undefined,
+                category: ctx.flags.category?.slice(0, 128),
+                language: ctx.flags.language?.slice(0, 64),
+                framework: ctx.flags.framework?.slice(0, 64),
+                tags: ctx.flags.tags ? ctx.flags.tags.slice(0, 512).split(',').map(t => t.trim().slice(0, 64)).slice(0, 20) : undefined,
                 minRating: ctx.flags['min-rating'],
                 verified: ctx.flags.verified,
-                limit: ctx.flags.limit || 20,
+                limit: Math.max(1, Math.min(200, ctx.flags.limit || 20)),
             };
             const searchResult = searchPatterns(result.registry, searchOptions);
             spinner.succeed(`Found ${searchResult.total} patterns`);
@@ -188,7 +188,7 @@ export const storeDownloadCommand = {
         { command: 'monomind hooks transfer store download -n seraphine-genesis --import', description: 'Download and import' },
     ],
     action: async (ctx) => {
-        const patternName = (ctx.args[0] || ctx.flags.name);
+        const patternName = (ctx.args[0] || ctx.flags.name)?.slice(0, 256);
         if (!patternName) {
             output.printError('Pattern name is required. Use --name or -n flag.');
             return { success: false, exitCode: 1 };
@@ -261,8 +261,8 @@ export const storePublishCommand = {
     ],
     action: async (ctx) => {
         const inputPath = ctx.flags.input;
-        const name = ctx.flags.name;
-        const description = ctx.flags.description;
+        const name = ctx.flags.name?.slice(0, 128);
+        const description = ctx.flags.description?.slice(0, 1024);
         if (!inputPath || !name || !description) {
             output.printError('Input path, name, and description are required.');
             return { success: false, exitCode: 1 };
@@ -270,13 +270,27 @@ export const storePublishCommand = {
         const spinner = output.createSpinner({ text: 'Preparing pattern...', spinner: 'dots' });
         spinner.start();
         try {
-            // Read and parse CFP file
+            // Read and parse CFP file with path containment and size cap.
+            // Without this, --input /etc/passwd leaks arbitrary files and a
+            // multi-GB planted CFP OOM-kills the process.
+            const nodePath = await import('node:path');
+            const projectRoot = nodePath.resolve(process.cwd());
+            const fullInputPath = nodePath.resolve(process.cwd(), inputPath);
+            if (!fullInputPath.startsWith(projectRoot + nodePath.sep) && fullInputPath !== projectRoot) {
+                spinner.fail(`Input path must resolve within the project directory: ${projectRoot}`);
+                return { success: false, exitCode: 1 };
+            }
             const fs = await import('fs');
-            if (!fs.existsSync(inputPath)) {
-                spinner.fail(`File not found: ${inputPath}`);
+            if (!fs.existsSync(fullInputPath)) {
+                spinner.fail(`File not found: ${fullInputPath}`);
+                return { success: false, exitCode: 1 };
+            }
+            const stat = fs.statSync(fullInputPath);
+            if (stat.size > 50 * 1024 * 1024) {
+                spinner.fail(`CFP file too large: ${stat.size} bytes (max 50MB)`);
                 return { success: false, exitCode: 1 };
             }
-            const content = fs.readFileSync(inputPath, 'utf-8');
+            const content = fs.readFileSync(fullInputPath, 'utf-8');
             const cfp = JSON.parse(content);
             spinner.setText('Publishing to IPFS...');
             const publisher = createPublisher();
@@ -284,12 +298,12 @@ export const storePublishCommand = {
                 name,
                 displayName: name.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
                 description,
-                categories: ctx.flags.categories.split(',').map(s => s.trim()),
-                tags: ctx.flags.tags.split(',').map(s => s.trim()),
-                license: ctx.flags.license || 'MIT',
+                categories: ctx.flags.categories.slice(0, 512).split(',').map(s => s.trim().slice(0, 64)).slice(0, 20),
+                tags: ctx.flags.tags.slice(0, 512).split(',').map(s => s.trim().slice(0, 64)).slice(0, 20),
+                license: (ctx.flags.license || 'MIT').slice(0, 64),
                 anonymize: ctx.flags.anonymize || 'strict',
-                language: ctx.flags.language,
-                framework: ctx.flags.framework,
+                language: ctx.flags.language?.slice(0, 64),
+                framework: ctx.flags.framework?.slice(0, 64),
             });
             if (!result.success) {
                 spinner.fail('Publish failed');
@@ -326,7 +340,7 @@ export const storeInfoCommand = {
         { command: 'monomind hooks transfer store info -n seraphine-genesis', description: 'Show pattern info' },
     ],
     action: async (ctx) => {
-        const patternName = (ctx.args[0] || ctx.flags.name);
+        const patternName = (ctx.args[0] || ctx.flags.name)?.slice(0, 256);
         if (!patternName) {
             output.printError('Pattern name is required. Use --name or -n flag.');
             return { success: false, exitCode: 1 };

package/packages/@monomind/cli/dist/src/commands/ui.js

@@ -0,0 +1,68 @@
+/**
+ * monomind ui — Live dashboard command
+ * Starts a local HTTP server serving the Neural Control Room dashboard.
+ */
+import * as path from 'path';
+import * as os from 'os';
+
+export const uiCommand = {
+  name: 'ui',
+  description: 'Start the live Monomind dashboard (Neural Control Room)',
+  category: 'core',
+  async action(ctx) {
+    return this.execute(ctx.args || [], ctx.flags || {});
+  },
+  async execute(args = [], options = {}) {
+    const port = parseInt(options.port || options.p || '4242', 10);
+    const noOpen = options['no-open'] || options['no-browser'] || false;
+    const projectDir = options.dir || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+    console.log('\x1b[36m◆ Monomind Neural Control Room\x1b[0m');
+    console.log('\x1b[2mStarting dashboard server...\x1b[0m\n');
+
+    try {
+      const { fileURLToPath } = await import('url');
+      const { dirname } = await import('path');
+      const { createRequire } = await import('module');
+      const serverPath = new URL('../ui/server.mjs', import.meta.url);
+      const { startServer } = await import(serverPath.href);
+
+      const result = await startServer({
+        port,
+        projectDir,
+        openBrowser: !noOpen,
+      });
+
+      console.log(`\x1b[32m✓ Dashboard running at \x1b[1m${result.url}\x1b[0m`);
+      console.log(`\x1b[2m  Project: ${projectDir}\x1b[0m`);
+      console.log(`\x1b[2m  Press Ctrl+C to stop\x1b[0m\n`);
+
+      // Keep alive
+      await new Promise((resolve) => {
+        process.on('SIGINT', resolve);
+        process.on('SIGTERM', resolve);
+      });
+    } catch (err) {
+      console.error(`\x1b[31m✗ Failed to start dashboard: ${err.message}\x1b[0m`);
+      if (process.env.DEBUG) console.error(err.stack);
+      process.exit(1);
+    }
+  },
+  help() {
+    return `
+\x1b[1mUsage:\x1b[0m  monomind ui [options]
+
+\x1b[1mOptions:\x1b[0m
+  --port, -p <number>   Port to listen on (default: 4242)
+  --no-open             Don't open browser automatically
+  --dir <path>          Project directory to monitor (default: cwd)
+
+\x1b[1mExamples:\x1b[0m
+  monomind ui
+  monomind ui --port 8080
+  monomind ui --no-open --dir /path/to/project
+    `.trim();
+  },
+};
+
+export default uiCommand;

package/packages/@monomind/cli/dist/src/commands/update.js

@@ -151,7 +151,11 @@ const allCommand = {
                 output.writeln();
                 output.printError(`${failed.length} package(s) failed:`);
                 for (const r of failed) {
-                    output.writeln(`  ${output.error('✗')} ${r.package}: ${r.error}`);
+                    // Sanitize error: strip filesystem paths and cap length before display
+                    const safeErr = typeof r.error === 'string'
+                        ? r.error.replace(/\/[^\s:]+(\/|(?=\s|:|$))/g, '<path>/').slice(0, 200)
+                        : 'update failed';
+                    output.writeln(`  ${output.error('✗')} ${r.package}: ${safeErr}`);
                 }
             }
             return { success: failed.length === 0 };
@@ -177,7 +181,9 @@ const historyCommand = {
             output.printSuccess('Update history cleared');
             return { success: true };
         }
-        const limit = parseInt(flags.limit || '20', 10);
+        const rawLimit = parseInt(flags.limit || '20', 10);
+        // Cap to prevent unbounded history reads
+        const limit = Number.isFinite(rawLimit) ? Math.max(1, Math.min(rawLimit, 1000)) : 20;
         const history = getUpdateHistory(limit);
         if (history.length === 0) {
             output.printInfo('No update history available');
@@ -218,7 +224,13 @@ const rollbackCommand = {
     ],
     async action(ctx) {
         const { flags } = ctx;
-        const packageName = flags.package;
+        // Cap packageName to 200 chars — npm package names are at most 214 chars
+        // (npm spec), but a malicious value could otherwise flow into rollbackUpdate
+        // which may reflect it in error messages or use it to key lookup tables.
+        const rawPackageName = flags.package;
+        const packageName = typeof rawPackageName === 'string'
+            ? rawPackageName.slice(0, 200)
+            : undefined;
         output.printInfo(packageName ? `Rolling back ${packageName}...` : 'Rolling back last update...');
         const result = await rollbackUpdate(packageName);
         if (result.success) {

package/packages/@monomind/cli/dist/src/commands/workflow.js

@@ -74,12 +74,34 @@ const runCommand = {
     ],
     action: async (ctx) => {
         let template = ctx.flags.template;
-        const file = ctx.flags.file;
-        const task = ctx.flags.task || ctx.args[0];
+        const rawFile = ctx.flags.file;
+        const rawTask = ctx.flags.task || ctx.args[0];
         const parallel = ctx.flags.parallel;
-        const maxAgents = ctx.flags['max-agents'];
-        const timeout = ctx.flags.timeout;
+        const rawMaxAgents = ctx.flags['max-agents'];
+        const rawTimeout = ctx.flags.timeout;
         const dryRun = ctx.flags['dry-run'];
+        // Cap/validate inputs to prevent DoS and injection
+        const task = typeof rawTask === 'string' ? rawTask.slice(0, 4000) : undefined;
+        const maxAgents = typeof rawMaxAgents === 'number' && Number.isFinite(rawMaxAgents)
+            ? Math.max(1, Math.min(Math.floor(rawMaxAgents), 50))
+            : 5;
+        const timeout = typeof rawTimeout === 'number' && Number.isFinite(rawTimeout)
+            ? Math.max(1, Math.min(Math.floor(rawTimeout), 1440))
+            : 30;
+        // Validate file path to prevent path traversal when a file is given
+        let file;
+        if (rawFile) {
+            const pathMod = await import('path');
+            const effectiveCwd = ctx.cwd || process.cwd();
+            const absFile = pathMod.isAbsolute(rawFile) ? rawFile : pathMod.resolve(effectiveCwd, rawFile);
+            const resolvedFile = pathMod.resolve(absFile);
+            const resolvedCwd = pathMod.resolve(effectiveCwd);
+            if (!resolvedFile.startsWith(resolvedCwd + pathMod.sep) && resolvedFile !== resolvedCwd) {
+                output.printError('Workflow file path must be within the working directory.');
+                return { success: false, exitCode: 1 };
+            }
+            file = resolvedFile;
+        }
         if (!template && !file && ctx.interactive) {
             template = await select({
                 message: 'Select workflow template:',
@@ -184,12 +206,23 @@ const validateCommand = {
         { command: 'monomind workflow validate -f ./workflow.json --strict', description: 'Strict validation' }
     ],
     action: async (ctx) => {
-        const file = ctx.flags.file || ctx.args[0];
+        const rawFile = ctx.flags.file || ctx.args[0];
         const strict = ctx.flags.strict;
-        if (!file) {
+        if (!rawFile) {
             output.printError('Workflow file is required. Use --file or -f');
             return { success: false, exitCode: 1 };
         }
+        // Path traversal guard: file must stay within working directory
+        const pathMod = await import('path');
+        const effectiveCwd = ctx.cwd || process.cwd();
+        const absFile = pathMod.isAbsolute(rawFile) ? rawFile : pathMod.resolve(effectiveCwd, rawFile);
+        const resolvedFile = pathMod.resolve(absFile);
+        const resolvedCwd = pathMod.resolve(effectiveCwd);
+        if (!resolvedFile.startsWith(resolvedCwd + pathMod.sep) && resolvedFile !== resolvedCwd) {
+            output.printError('Workflow file path must be within the working directory.');
+            return { success: false, exitCode: 1 };
+        }
+        const file = resolvedFile;
         output.printInfo(`Validating: ${file}`);
         try {
             const result = await callMCPTool('workflow_validate', {

package/packages/@monomind/cli/dist/src/consensus/audit-writer.js

@@ -29,13 +29,22 @@ export class AuditWriter {
      * and persist both the audit record and individual votes to JSONL.
      */
     record(input) {
-        const key = deriveSigningKey(input.swarmId, input.sessionSecret);
+        // Cap string fields to prevent unbounded JSONL writes (OOM)
+        const MAX_STR = 256;
+        const decisionId = String(input.decisionId ?? '').slice(0, MAX_STR);
+        const swarmId = String(input.swarmId ?? '').slice(0, MAX_STR);
+        const topic = String(input.topic ?? '').slice(0, MAX_STR);
+        const sessionSecret = String(input.sessionSecret ?? '').slice(0, MAX_STR);
+        // Cap votes array to prevent JSONL record inflation
+        const MAX_VOTES = 500;
+        const votes = Array.isArray(input.votes) ? input.votes.slice(0, MAX_VOTES) : [];
+        const key = deriveSigningKey(swarmId, sessionSecret);
         // Sign each vote
-        const signedVotes = input.votes.map((v) => ({
+        const signedVotes = votes.map((v) => ({
             agentId: v.agentId,
             agentSlug: v.agentSlug,
             vote: v.vote,
-            signature: signVote(v.agentId, v.vote, input.decisionId, key),
+            signature: signVote(v.agentId, v.vote, decisionId, key),
             votedAt: v.votedAt,
         }));
         // Compute quorum proof
@@ -51,10 +60,10 @@ export class AuditWriter {
         const endMs = new Date(input.completedAt).getTime();
         const durationMs = isNaN(startMs) || isNaN(endMs) ? null : endMs - startMs;
         const recordWithoutSig = {
-            decisionId: input.decisionId,
-            swarmId: input.swarmId,
+            decisionId,
+            swarmId,
             protocol: input.protocol,
-            topic: input.topic,
+            topic,
             decision: input.decision,
             votes: signedVotes,
             quorumProof,
@@ -84,7 +93,9 @@ export class AuditWriter {
     listDecisions(swarmId, limit) {
         const records = this.readLines(this.auditPath);
         const filtered = swarmId ? records.filter((r) => r.swarmId === swarmId) : records;
-        return limit !== undefined ? filtered.slice(0, limit) : filtered;
+        // Cap at 10 000 to prevent unbounded memory return
+        const effectiveLimit = limit !== undefined ? Math.min(Math.max(0, limit), 10_000) : 10_000;
+        return filtered.slice(0, effectiveLimit);
     }
     /**
      * Re-verify all vote signatures in a decision.

package/packages/@monomind/cli/dist/src/consensus/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Consensus module barrel export (Task 36)
+ */
+export { deriveSigningKey, signVote, verifyVote } from './vote-signer.js';
+export { AuditWriter } from './audit-writer.js';
+export type { RecordInput } from './audit-writer.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/consensus/index.js

@@ -0,0 +1,6 @@
+/**
+ * Consensus module barrel export (Task 36)
+ */
+export { deriveSigningKey, signVote, verifyVote } from './vote-signer.js';
+export { AuditWriter } from './audit-writer.js';
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/consensus/vote-signer.js

@@ -4,25 +4,37 @@
  * HMAC-SHA256 signing and verification for consensus votes.
  */
 import { createHmac, timingSafeEqual } from 'crypto';
+/** Max depth for canonicalize() to prevent stack overflow on deeply nested objects. */
+const MAX_CANONICALIZE_DEPTH = 32;
+/** Cap string inputs to prevent OOM when hashing very long strings. */
+const MAX_INPUT_LEN = 1024;
+/** Cap votes array to prevent OOM in weightedTally. */
+const MAX_VOTES = 1000;
 /**
  * Derive a signing key from a swarmId and session secret using HMAC-SHA256.
  */
 export function deriveSigningKey(swarmId, sessionSecret) {
-    return createHmac('sha256', sessionSecret).update(swarmId).digest();
+    return createHmac('sha256', sessionSecret.slice(0, MAX_INPUT_LEN)).update(swarmId.slice(0, MAX_INPUT_LEN)).digest();
 }
 /**
  * Sign a vote, producing a hex-encoded HMAC-SHA256 signature.
  */
-function canonicalize(val) {
+function canonicalize(val, depth = 0) {
+    // Guard against deeply-nested objects that would overflow the call stack.
+    if (depth > MAX_CANONICALIZE_DEPTH)
+        return '"[MaxDepth]"';
     if (val === null || typeof val !== 'object')
         return JSON.stringify(val);
     if (Array.isArray(val))
-        return '[' + val.map(canonicalize).join(',') + ']';
-    const sorted = Object.keys(val).sort().map(k => JSON.stringify(k) + ':' + canonicalize(val[k]));
+        return '[' + val.map(item => canonicalize(item, depth + 1)).join(',') + ']';
+    const sorted = Object.keys(val).sort().map(k => JSON.stringify(k) + ':' + canonicalize(val[k], depth + 1));
     return '{' + sorted.join(',') + '}';
 }
 export function signVote(agentId, vote, decisionId, key) {
-    const payload = JSON.stringify({ agentId, vote: canonicalize(vote), decisionId });
+    // Cap string fields to prevent OOM when hashing attacker-supplied inputs.
+    const safeAgentId = agentId.slice(0, MAX_INPUT_LEN);
+    const safeDecisionId = decisionId.slice(0, MAX_INPUT_LEN);
+    const payload = JSON.stringify({ agentId: safeAgentId, vote: canonicalize(vote), decisionId: safeDecisionId });
     return createHmac('sha256', key).update(payload).digest('hex');
 }
 /**
@@ -35,10 +47,12 @@ export function signVote(agentId, vote, decisionId, key) {
  * Source: https://arxiv.org/abs/2511.10400 (CP-WBFT — AAAI 2026)
  */
 export function weightedTally(votes) {
+    // Cap votes array to prevent OOM from an oversized input.
+    const safeVotes = votes.length > MAX_VOTES ? votes.slice(0, MAX_VOTES) : votes;
     let weightedApproval = 0;
     let weightedRejection = 0;
     let totalWeight = 0;
-    for (const { vote, confidence } of votes) {
+    for (const { vote, confidence } of safeVotes) {
         const w = Math.max(0, Math.min(1, confidence)); // clamp to [0,1]
         totalWeight += w;
         if (vote) {
@@ -49,8 +63,8 @@ export function weightedTally(votes) {
         }
     }
     return {
-        approved: votes.filter(v => v.vote).length,
-        rejected: votes.filter(v => !v.vote).length,
+        approved: safeVotes.filter(v => v.vote).length,
+        rejected: safeVotes.filter(v => !v.vote).length,
         weightedApproval,
         weightedRejection,
         quorum: totalWeight > 0 && weightedApproval / totalWeight > 0.5,
@@ -61,6 +75,9 @@ export function weightedTally(votes) {
  * Returns true when the signature is valid.
  */
 export function verifyVote(agentId, vote, decisionId, signature, key) {
+    // Guard: odd-length or non-hex signature string causes Buffer.from to throw.
+    if (!/^[0-9a-fA-F]{64}$/.test(signature))
+        return false;
     const expected = signVote(agentId, vote, decisionId, key);
     const sigBuf = Buffer.from(signature, 'hex');
     const expBuf = Buffer.from(expected, 'hex');

package/packages/@monomind/cli/dist/src/context/context-provider.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Context Provider — interfaces and base class for dynamic prompt assembly.
+ *
+ * Each provider contributes a named section of context to the assembled prompt.
+ * Providers are prioritised (0-100) and budget-aware via token estimation.
+ */
+export interface RunContext {
+    agentSlug: string;
+    taskDescription: string;
+    sessionId: string;
+    swarmId?: string;
+    workingDir?: string;
+    metadata: Record<string, unknown>;
+}
+export interface ContextSection {
+    name: string;
+    content: string;
+    tokenCount: number;
+    priority: number;
+    required: boolean;
+}
+export interface ContextProvider {
+    readonly name: string;
+    readonly priority: number;
+    readonly maxTokens: number;
+    readonly required: boolean;
+    provide(ctx: RunContext): Promise<string>;
+}
+/**
+ * Convenience base class that implements the ContextProvider contract and
+ * supplies a rough token-truncation helper (approx 4 chars per token).
+ */
+export declare abstract class BaseContextProvider implements ContextProvider {
+    abstract readonly name: string;
+    abstract readonly priority: number;
+    readonly maxTokens: number;
+    readonly required: boolean;
+    /**
+     * Truncate `text` so that it fits within `maxTokens` (4 chars/token).
+     */
+    protected truncateToTokens(text: string, maxTokens: number): string;
+    abstract provide(ctx: RunContext): Promise<string>;
+}
+//# sourceMappingURL=context-provider.d.ts.map

package/packages/@monomind/cli/dist/src/context/context-provider.js

@@ -0,0 +1,25 @@
+/**
+ * Context Provider — interfaces and base class for dynamic prompt assembly.
+ *
+ * Each provider contributes a named section of context to the assembled prompt.
+ * Providers are prioritised (0-100) and budget-aware via token estimation.
+ */
+/**
+ * Convenience base class that implements the ContextProvider contract and
+ * supplies a rough token-truncation helper (approx 4 chars per token).
+ */
+export class BaseContextProvider {
+    maxTokens = 500;
+    required = false;
+    /**
+     * Truncate `text` so that it fits within `maxTokens` (4 chars/token).
+     */
+    truncateToTokens(text, maxTokens) {
+        const maxChars = maxTokens * 4;
+        if (text.length <= maxChars) {
+            return text;
+        }
+        return text.slice(0, maxChars);
+    }
+}
+//# sourceMappingURL=context-provider.js.map