monomind 1.11.13 → 1.12.0

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

@@ -1,5 +1,5 @@
 import { getProjectCwd } from './types.js';
-import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 // Storage paths
 const STORAGE_DIR = '.monomind';
@@ -17,10 +17,11 @@ function ensureCoordDir() {
         mkdirSync(dir, { recursive: true });
     }
 }
+const MAX_COORD_STORE_BYTES = 10 * 1024 * 1024; // 10 MB
 function loadCoordStore() {
     try {
         const path = getCoordPath();
-        if (existsSync(path)) {
+        if (existsSync(path) && statSync(path).size <= MAX_COORD_STORE_BYTES) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
@@ -417,6 +418,10 @@ export const coordinationTools = [
             }
             if (action === 'status') {
                 if (args.proposalId) {
+                    // Validate proposalId length before O(n) .find() scan.
+                    if (typeof args.proposalId !== 'string' || args.proposalId.length > 256) {
+                        return { success: false, error: 'proposalId must be a string (max 256 chars)' };
+                    }
                     // Status for specific proposal
                     const p = consensus.pending.find(x => x.proposalId === args.proposalId);
                     if (p) {
@@ -513,10 +518,34 @@ export const coordinationTools = [
                 };
             }
             if (action === 'vote') {
-                const p = consensus.pending.find(x => x.proposalId === args.proposalId);
+                // Validate proposalId before using it in .find() to prevent DoS via
+                // oversized string comparisons across all pending proposals.
+                const rawProposalIdVote = args.proposalId;
+                if (typeof rawProposalIdVote !== 'string' || rawProposalIdVote.length === 0 || rawProposalIdVote.length > 256) {
+                    return { success: false, error: 'proposalId must be a non-empty string (max 256 chars)' };
+                }
+                const p = consensus.pending.find(x => x.proposalId === rawProposalIdVote);
                 if (!p)
                     return { success: false, error: 'Proposal not found or already resolved' };
-                const voterId = args.voterId;
+                const rawVoterId = args.voterId;
+                // Validate voterId — it becomes a key in p.votes (a plain object).
+                // Without these checks an attacker can supply "__proto__", "constructor",
+                // or "prototype" to corrupt the object's inherited properties, or supply
+                // a very long string to cause O(n) comparisons, or flood the votes dict
+                // with thousands of unique IDs to inflate store.json indefinitely.
+                const FORBIDDEN_VOTER_IDS = new Set(['__proto__', 'constructor', 'prototype']);
+                const MAX_VOTER_ID_LEN = 256;
+                const MAX_VOTERS_PER_PROPOSAL = 10_000;
+                if (!rawVoterId || typeof rawVoterId !== 'string' || rawVoterId.length > MAX_VOTER_ID_LEN) {
+                    return { success: false, error: `voterId must be a non-empty string (max ${MAX_VOTER_ID_LEN} chars)` };
+                }
+                if (FORBIDDEN_VOTER_IDS.has(rawVoterId)) {
+                    return { success: false, error: 'Forbidden voterId' };
+                }
+                if (!Object.hasOwn(p.votes, rawVoterId) && Object.keys(p.votes).length >= MAX_VOTERS_PER_PROPOSAL) {
+                    return { success: false, error: `Voter limit per proposal (${MAX_VOTERS_PER_PROPOSAL}) reached` };
+                }
+                const voterId = rawVoterId;
                 if (!voterId)
                     return { success: false, error: 'voterId is required' };
                 const voteValue = args.vote === 'accept';
@@ -616,6 +645,10 @@ export const coordinationTools = [
             if (action === 'commit') {
                 // Commit is a no-op confirmation for already-resolved proposals
                 if (args.proposalId) {
+                    // Validate proposalId length before O(n) .find() scan.
+                    if (typeof args.proposalId !== 'string' || args.proposalId.length > 256) {
+                        return { success: false, error: 'proposalId must be a string (max 256 chars)' };
+                    }
                     const h = consensus.history.find(x => x.proposalId === args.proposalId);
                     if (h) {
                         return {

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

@@ -73,16 +73,41 @@ export const daaTools = [
         },
         handler: async (input) => {
             const store = loadDAAStore();
-            const id = input.id;
+            // Cap all string inputs before storing to disk and before they flow into
+            // bridgeStoreEntry → generateEmbedding (hash fallback is O(n)).
+            const MAX_DAA_ID_LEN = 256;
+            const MAX_DAA_NAME_LEN = 512;
+            const MAX_DAA_TYPE_LEN = 128;
+            const MAX_DAA_CAPABILITIES = 50;
+            const MAX_DAA_CAPABILITY_LEN = 128;
+            const MAX_DAA_AGENTS = 10_000;
+            const rawId = input.id;
+            const id = typeof rawId === 'string' && rawId.length > MAX_DAA_ID_LEN
+                ? rawId.slice(0, MAX_DAA_ID_LEN) : rawId;
+            if (Object.keys(store.agents ?? {}).length >= MAX_DAA_AGENTS && !Object.hasOwn(store.agents, id)) {
+                return { success: false, error: `Agent store full (max ${MAX_DAA_AGENTS})` };
+            }
+            const rawName = input.name || `DAA-${id}`;
+            const agentName = typeof rawName === 'string' && rawName.length > MAX_DAA_NAME_LEN
+                ? rawName.slice(0, MAX_DAA_NAME_LEN) : rawName;
+            const rawType = input.type || 'autonomous';
+            const agentType = typeof rawType === 'string' && rawType.length > MAX_DAA_TYPE_LEN
+                ? rawType.slice(0, MAX_DAA_TYPE_LEN) : rawType;
+            const rawCaps = input.capabilities || ['reasoning', 'learning'];
+            const capabilities = Array.isArray(rawCaps)
+                ? rawCaps
+                    .slice(0, MAX_DAA_CAPABILITIES)
+                    .map(c => typeof c === 'string' && c.length > MAX_DAA_CAPABILITY_LEN ? c.slice(0, MAX_DAA_CAPABILITY_LEN) : c)
+                : ['reasoning', 'learning'];
             const agent = {
                 id,
-                name: input.name || `DAA-${id}`,
-                type: input.type || 'autonomous',
+                name: agentName,
+                type: agentType,
                 status: 'active',
                 cognitivePattern: input.cognitivePattern || 'adaptive',
                 learningRate: input.learningRate || 0.01,
                 memory: input.enableMemory ?? true,
-                capabilities: input.capabilities || ['reasoning', 'learning'],
+                capabilities,
                 metrics: {
                     tasksCompleted: 0,
                     successRate: 1.0,
@@ -202,12 +227,19 @@ export const daaTools = [
                 ['__proto__', 'constructor', 'prototype'].includes(id)) {
                 return { success: false, error: 'Invalid workflow id' };
             }
+            const MAX_DAA_WF_NAME_LEN = 512;
+            const MAX_DAA_WF_STEPS = 500;
             const store = loadDAAStore();
+            const rawWfName = input.name;
+            const wfName = typeof rawWfName === 'string' && rawWfName.length > MAX_DAA_WF_NAME_LEN
+                ? rawWfName.slice(0, MAX_DAA_WF_NAME_LEN) : rawWfName;
+            const rawSteps = input.steps || [];
+            const cappedSteps = Array.isArray(rawSteps) ? rawSteps.slice(0, MAX_DAA_WF_STEPS) : [];
             const workflow = {
                 id,
-                name: input.name,
+                name: wfName,
                 status: 'pending',
-                steps: (input.steps || []).map((s, i) => ({
+                steps: cappedSteps.map((s, i) => ({
                     name: typeof s === 'string' ? s : `Step ${i + 1}`,
                     status: 'pending',
                 })),
@@ -292,7 +324,17 @@ export const daaTools = [
         handler: async (input) => {
             const store = loadDAAStore();
             const sourceId = input.sourceAgentId;
-            const targetIds = input.targetAgentIds;
+            // Cap targetIds to prevent a large array from inflating the JSON store
+            // entry and the AgentDB tags blob.  100 target agents is already very
+            // generous for any realistic swarm configuration.
+            const MAX_TARGET_IDS = 100;
+            const MAX_TARGET_ID_LEN = 256;
+            const rawTargetIds = input.targetAgentIds;
+            const targetIds = Array.isArray(rawTargetIds)
+                ? rawTargetIds
+                    .slice(0, MAX_TARGET_IDS)
+                    .map(id => (typeof id === 'string' && id.length > MAX_TARGET_ID_LEN ? id.slice(0, MAX_TARGET_ID_LEN) : id))
+                : [];
             const domain = input.knowledgeDomain || 'general';
             const knowledgeId = `knowledge-${Date.now()}`;
             const knowledgeEntry = {

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

@@ -4,7 +4,7 @@
  * Tool definitions for ONNX embeddings with hyperbolic support and neural substrate.
  * Implements ADR-024: Embeddings MCP Tools
  */
-import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'fs';
+import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
 // Configuration paths
 const CONFIG_DIR = '.monomind';
@@ -45,10 +45,11 @@ function ensureConfigDir() {
         mkdirSync(dir, { recursive: true });
     }
 }
+const MAX_EMBEDDINGS_CONFIG_BYTES = 10 * 1024 * 1024; // 10 MB
 function loadConfig() {
     try {
         const path = getConfigPath();
-        if (existsSync(path)) {
+        if (existsSync(path) && statSync(path).size <= MAX_EMBEDDINGS_CONFIG_BYTES) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
@@ -413,8 +414,20 @@ export const embeddingsTools = [
                     error: 'Embeddings not initialized. Run embeddings/init first.',
                 };
             }
-            const query = input.query;
-            const topK = input.topK || 5;
+            // Cap query length: generateRealEmbedding has a hash-fallback that is
+            // O(n) over the text length, so an unbounded query is a DoS vector.
+            // Cap topK to prevent requesting a huge result set from searchEntries.
+            let query;
+            try {
+                query = validateText(input.query, 'query');
+            }
+            catch (e) {
+                return { success: false, error: e.message };
+            }
+            const MAX_SEARCH_TOP_K = 100;
+            const rawTopK = input.topK || 5;
+            const topK = Number.isFinite(rawTopK) && rawTopK > 0
+                ? Math.min(Math.floor(rawTopK), MAX_SEARCH_TOP_K) : 5;
             const threshold = input.threshold || 0.5;
             const namespace = input.namespace;
             const startTime = performance.now();
@@ -711,10 +724,15 @@ export const embeddingsTools = [
             const action = input.action || 'status';
             const curvature = config.hyperbolic.curvature;
             switch (action) {
-                case 'convert':
-                    const embedding = input.embedding;
-                    if (!embedding || !Array.isArray(embedding)) {
-                        return { success: false, error: 'Embedding array required for convert action' };
+                case 'convert': {
+                    // validateVector caps at MAX_VECTOR_DIM (8192) — prevents O(n) DoS
+                    // in toPoincare (reduce + map over the full array).
+                    let embedding;
+                    try {
+                        embedding = validateVector(input.embedding, 'embedding');
+                    }
+                    catch (e) {
+                        return { success: false, error: e.message };
                     }
                     const poincare = toPoincare(embedding, curvature);
                     return {
@@ -725,11 +743,15 @@ export const embeddingsTools = [
                         curvature,
                         poincareNorm: Math.sqrt(poincare.reduce((sum, x) => sum + x * x, 0)),
                     };
-                case 'distance':
-                    const emb1 = input.embedding1;
-                    const emb2 = input.embedding2;
-                    if (!emb1 || !emb2) {
-                        return { success: false, error: 'embedding1 and embedding2 required for distance action' };
+                }
+                case 'distance': {
+                    let emb1, emb2;
+                    try {
+                        emb1 = validateVector(input.embedding1, 'embedding1');
+                        emb2 = validateVector(input.embedding2, 'embedding2');
+                    }
+                    catch (e) {
+                        return { success: false, error: e.message };
                     }
                     const dist = poincareDistance(emb1, emb2, curvature);
                     return {
@@ -739,11 +761,15 @@ export const embeddingsTools = [
                         curvature,
                         interpretation: dist < 1 ? 'close' : dist < 2 ? 'moderate' : 'far',
                     };
-                case 'midpoint':
-                    const e1 = input.embedding1;
-                    const e2 = input.embedding2;
-                    if (!e1 || !e2) {
-                        return { success: false, error: 'embedding1 and embedding2 required for midpoint action' };
+                }
+                case 'midpoint': {
+                    let e1, e2;
+                    try {
+                        e1 = validateVector(input.embedding1, 'embedding1');
+                        e2 = validateVector(input.embedding2, 'embedding2');
+                    }
+                    catch (e) {
+                        return { success: false, error: e.message };
                     }
                     // Simplified midpoint (proper Möbius midpoint is more complex)
                     const mid = e1.map((_, i) => (e1[i] + e2[i]) / 2);
@@ -755,6 +781,7 @@ export const embeddingsTools = [
                         midpoint: scaledMid,
                         curvature,
                     };
+                }
                 default: // status
                     return {
                         success: true,

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

@@ -64,6 +64,21 @@ function runSafe(cmd, args, cwd) {
 function hasGhCli() {
     return run('gh --version') !== null;
 }
+/**
+ * Validate that a MCP input value is a safe positive integer suitable for use
+ * as a GitHub PR/issue number in CLI arguments.  Returns the integer value on
+ * success, or null if the input is missing, non-finite, negative, zero, or
+ * non-integer.  Using this guard before string-interpolating the value into a
+ * command template prevents argument-injection attacks where an MCP client
+ * sends a non-numeric string (e.g. "1 --label evil") that gets split into
+ * extra CLI flags when `run()` tokenises the command on whitespace.
+ */
+function safeGitHubNumber(raw) {
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isFinite(n) || n <= 0 || n !== Math.floor(n))
+        return null;
+    return n;
+}
 export const githubTools = [
     {
         name: 'github_repo_analyze',
@@ -179,11 +194,21 @@ export const githubTools = [
                 return { success: true, source: 'local-store', pullRequests: prs, total: prs.length, open: prs.filter(pr => pr.status === 'open').length };
             }
             if (action === 'create') {
+                // Cap PR fields: title/branch/baseBranch are passed as CLI args to gh
+                // (runSafe — no injection risk) and stored in the local JSON store on
+                // disk; body is also stored and can be very large.
+                const MAX_PR_TITLE_LEN = 256;
+                const MAX_PR_BRANCH_LEN = 256;
+                const MAX_PR_BODY_LEN = 64 * 1024; // 64 KB — typical PR body limit
+                const rawPrTitle = input.title || 'New PR';
+                const title = rawPrTitle.length > MAX_PR_TITLE_LEN ? rawPrTitle.slice(0, MAX_PR_TITLE_LEN) : rawPrTitle;
+                const rawHeadBranch = input.branch || run('git rev-parse --abbrev-ref HEAD') || 'feature';
+                const headBranch = rawHeadBranch.length > MAX_PR_BRANCH_LEN ? rawHeadBranch.slice(0, MAX_PR_BRANCH_LEN) : rawHeadBranch;
+                const rawBaseBranch = input.baseBranch || 'main';
+                const baseBranch = rawBaseBranch.length > MAX_PR_BRANCH_LEN ? rawBaseBranch.slice(0, MAX_PR_BRANCH_LEN) : rawBaseBranch;
+                const rawPrBody = input.body || '';
+                const body = rawPrBody.length > MAX_PR_BODY_LEN ? rawPrBody.slice(0, MAX_PR_BODY_LEN) : rawPrBody;
                 if (gh) {
-                    const title = input.title || 'New PR';
-                    const headBranch = input.branch || run('git rev-parse --abbrev-ref HEAD') || 'feature';
-                    const baseBranch = input.baseBranch || 'main';
-                    const body = input.body || '';
                     const result = runSafe('gh', ['pr', 'create', '--title', title, '--base', baseBranch, '--head', headBranch, '--body', body]);
                     if (result) {
                         return { success: true, _real: true, action: 'created', url: result };
@@ -191,15 +216,17 @@ export const githubTools = [
                 }
                 // Fallback: local store
                 const prId = `pr-${Date.now()}`;
-                const pr = { id: prId, title: input.title || 'New PR', status: 'open', branch: input.branch || 'feature', baseBranch: input.baseBranch || 'main', createdAt: new Date().toISOString() };
+                const pr = { id: prId, title, status: 'open', branch: headBranch, baseBranch, createdAt: new Date().toISOString() };
                 store.prs[prId] = pr;
                 saveGitHubStore(store);
                 return { success: true, source: 'local-store', action: 'created', pullRequest: pr };
             }
             if (action === 'review') {
-                const prNumber = input.prNumber;
-                if (gh && prNumber) {
-                    const raw = run(`gh pr view ${prNumber} --json number,title,state,body,additions,deletions,changedFiles,reviews,mergeable,statusCheckRollup`);
+                const prNumber = safeGitHubNumber(input.prNumber);
+                if (!prNumber)
+                    return { success: false, error: 'prNumber is required and must be a positive integer for review.' };
+                if (gh) {
+                    const raw = runSafe('gh', ['pr', 'view', String(prNumber), '--json', 'number,title,state,body,additions,deletions,changedFiles,reviews,mergeable,statusCheckRollup']);
                     if (raw) {
                         try {
                             return { success: true, _real: true, action: 'review', pullRequest: JSON.parse(raw) };
@@ -207,12 +234,14 @@ export const githubTools = [
                         catch { /* fall through */ }
                     }
                 }
-                return { success: false, error: prNumber ? 'gh CLI not available or PR not found. Install gh: https://cli.github.com' : 'prNumber is required for review.' };
+                return { success: false, error: 'gh CLI not available or PR not found. Install gh: https://cli.github.com' };
             }
             if (action === 'merge') {
-                const prNumber = input.prNumber;
-                if (gh && prNumber) {
-                    const result = run(`gh pr merge ${prNumber} --merge`);
+                const prNumber = safeGitHubNumber(input.prNumber);
+                if (!prNumber)
+                    return { success: false, error: 'prNumber is required and must be a positive integer for merge.' };
+                if (gh) {
+                    const result = runSafe('gh', ['pr', 'merge', String(prNumber), '--merge']);
                     if (result !== null) {
                         return { success: true, _real: true, action: 'merged', prNumber, mergedAt: new Date().toISOString() };
                     }
@@ -226,9 +255,11 @@ export const githubTools = [
                 return { success: true, source: 'local-store', action: 'merged', prNumber, mergedAt: new Date().toISOString() };
             }
             if (action === 'close') {
-                const prNumber = input.prNumber;
-                if (gh && prNumber) {
-                    const result = run(`gh pr close ${prNumber}`);
+                const prNumber = safeGitHubNumber(input.prNumber);
+                if (!prNumber)
+                    return { success: false, error: 'prNumber is required and must be a positive integer for close.' };
+                if (gh) {
+                    const result = runSafe('gh', ['pr', 'close', String(prNumber)]);
                     if (result !== null) {
                         return { success: true, _real: true, action: 'closed', prNumber, closedAt: new Date().toISOString() };
                     }
@@ -279,9 +310,20 @@ export const githubTools = [
                 return { success: true, source: 'local-store', issues, total: issues.length, open: issues.filter(i => i.status === 'open').length };
             }
             if (action === 'create') {
-                const title = input.title || 'New Issue';
-                const body = input.body || '';
-                const labels = input.labels || [];
+                // Cap issue fields: stored in local JSON store and passed as CLI args
+                // to gh (runSafe — no injection risk).
+                const MAX_ISSUE_TITLE_LEN = 256;
+                const MAX_ISSUE_BODY_LEN = 64 * 1024;
+                const MAX_ISSUE_LABELS = 20;
+                const MAX_ISSUE_LABEL_LEN = 128;
+                const rawIssueTitle = input.title || 'New Issue';
+                const title = rawIssueTitle.length > MAX_ISSUE_TITLE_LEN ? rawIssueTitle.slice(0, MAX_ISSUE_TITLE_LEN) : rawIssueTitle;
+                const rawIssueBody = input.body || '';
+                const body = rawIssueBody.length > MAX_ISSUE_BODY_LEN ? rawIssueBody.slice(0, MAX_ISSUE_BODY_LEN) : rawIssueBody;
+                const rawLabels = input.labels || [];
+                const labels = Array.isArray(rawLabels)
+                    ? rawLabels.slice(0, MAX_ISSUE_LABELS).map(l => typeof l === 'string' && l.length > MAX_ISSUE_LABEL_LEN ? l.slice(0, MAX_ISSUE_LABEL_LEN) : l)
+                    : [];
                 if (gh) {
                     const issueArgs = ['issue', 'create', '--title', title, '--body', body];
                     if (labels.length > 0)
@@ -301,8 +343,12 @@ export const githubTools = [
                 const issueNumber = input.issueNumber;
                 if (gh && issueNumber) {
                     const editArgs = ['issue', 'edit', String(issueNumber)];
-                    if (input.title)
-                        editArgs.push('--title', input.title);
+                    // Cap title and labels to prevent inflating args and local store
+                    const MAX_UPDATE_TITLE_LEN = 256;
+                    if (input.title) {
+                        const t = input.title;
+                        editArgs.push('--title', t.length > MAX_UPDATE_TITLE_LEN ? t.slice(0, MAX_UPDATE_TITLE_LEN) : t);
+                    }
                     if (input.labels)
                         editArgs.push('--add-label', input.labels.join(','));
                     if (editArgs.length > 3) {
@@ -313,8 +359,10 @@ export const githubTools = [
                 }
                 const issueKey = Object.keys(store.issues).find(k => k.includes(String(issueNumber)));
                 if (issueKey && store.issues[issueKey]) {
-                    if (input.title)
-                        store.issues[issueKey].title = input.title;
+                    if (input.title) {
+                        const t = input.title;
+                        store.issues[issueKey].title = t.length > 256 ? t.slice(0, 256) : t;
+                    }
                     if (input.labels)
                         store.issues[issueKey].labels = input.labels;
                     saveGitHubStore(store);
@@ -322,9 +370,11 @@ export const githubTools = [
                 return { success: true, source: 'local-store', action: 'updated', issueNumber };
             }
             if (action === 'close') {
-                const issueNumber = input.issueNumber;
-                if (gh && issueNumber) {
-                    const result = run(`gh issue close ${issueNumber}`);
+                const issueNumber = safeGitHubNumber(input.issueNumber);
+                if (!issueNumber)
+                    return { success: false, error: 'issueNumber is required and must be a positive integer for close.' };
+                if (gh) {
+                    const result = runSafe('gh', ['issue', 'close', String(issueNumber)]);
                     if (result !== null)
                         return { success: true, _real: true, action: 'closed', issueNumber, closedAt: new Date().toISOString() };
                 }

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

@@ -7,7 +7,7 @@
  * @module @monomind/cli/mcp-tools/guidance
  */
 import { getProjectCwd } from './types.js';
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, statSync, readdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const __filename = fileURLToPath(import.meta.url);
@@ -298,6 +298,8 @@ function discoverAgents() {
                     walk(full, depth + 1);
                 }
                 else if (entry.isFile() && entry.name.endsWith('.md') && entry.name !== 'MIGRATION_SUMMARY.md') {
+                    if (statSync(full).size > 512 * 1024)
+                        continue; // skip files > 512 KB
                     const content = readFileSync(full, 'utf-8');
                     const nameMatch = content.match(/^name:\s*(.+)$/m);
                     if (nameMatch)
@@ -350,13 +352,18 @@ const guidanceCapabilities = {
         },
     },
     handler: async (params) => {
-        const area = params.area;
+        // Cap area before any use — reflected verbatim in the error JSON if the
+        // key is unknown, which would allow a caller to embed an arbitrarily long
+        // string in the MCP response body.
+        const MAX_AREA_LEN = 128;
+        const rawArea = params.area;
+        const area = typeof rawArea === 'string' && rawArea.length <= MAX_AREA_LEN ? rawArea : undefined;
         const format = params.format || 'summary';
         if (area) {
             const cap = CAPABILITY_CATALOG[area];
             if (!cap) {
                 const available = Object.keys(CAPABILITY_CATALOG).join(', ');
-                return { content: [{ type: 'text', text: JSON.stringify({ error: `Unknown area: ${area}`, available }, null, 2) }], isError: true };
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'Unknown capability area', available }, null, 2) }], isError: true };
             }
             return { content: [{ type: 'text', text: JSON.stringify(cap, null, 2) }] };
         }
@@ -389,7 +396,14 @@ const guidanceRecommend = {
         required: ['task'],
     },
     handler: async (params) => {
-        const task = params.task;
+        // Cap task: iterated through 14 regex patterns via route.pattern.test(task).
+        // Each .test() call is O(n) on the input string; without a cap an attacker
+        // can make every routing call O(14n) on an arbitrary-length string.
+        const MAX_GUIDANCE_TASK_LEN = 16 * 1024;
+        const rawTask = params.task;
+        const task = typeof rawTask === 'string' && rawTask.length > MAX_GUIDANCE_TASK_LEN
+            ? rawTask.slice(0, MAX_GUIDANCE_TASK_LEN)
+            : rawTask;
         const matches = [];
         for (const route of TASK_ROUTES) {
             if (route.pattern.test(task)) {
@@ -495,14 +509,18 @@ const guidanceWorkflow = {
         required: ['type'],
     },
     handler: async (params) => {
-        const type = params.type;
-        const template = WORKFLOW_TEMPLATES[type];
+        // Cap type before any use — reflected in the error JSON when the key is
+        // unknown, allowing an attacker to embed an arbitrarily long string.
+        const MAX_TYPE_LEN = 128;
+        const rawType = params.type;
+        const type = typeof rawType === 'string' && rawType.length <= MAX_TYPE_LEN ? rawType : '';
+        const template = type ? WORKFLOW_TEMPLATES[type] : undefined;
         if (!template) {
             return {
                 content: [{
                         type: 'text',
                         text: JSON.stringify({
-                            error: `Unknown workflow: ${type}`,
+                            error: 'Unknown workflow type',
                             available: Object.keys(WORKFLOW_TEMPLATES),
                         }, null, 2),
                     }],
@@ -541,7 +559,11 @@ const guidanceQuickRef = {
         required: ['domain'],
     },
     handler: async (params) => {
-        const domain = params.domain;
+        // Cap domain before any use — reflected in the error JSON when the key is
+        // unknown, allowing an attacker to embed an arbitrarily long string.
+        const MAX_DOMAIN_LEN = 128;
+        const rawDomain = params.domain;
+        const domain = typeof rawDomain === 'string' && rawDomain.length <= MAX_DOMAIN_LEN ? rawDomain : '';
         const refs = {
             'getting-started': {
                 title: 'Getting Started',
@@ -601,9 +623,9 @@ const guidanceQuickRef = {
                 ],
             },
         };
-        const ref = refs[domain];
+        const ref = domain ? refs[domain] : undefined;
         if (!ref) {
-            return { content: [{ type: 'text', text: JSON.stringify({ error: `Unknown domain: ${domain}`, available: Object.keys(refs) }, null, 2) }], isError: true };
+            return { content: [{ type: 'text', text: JSON.stringify({ error: 'Unknown quick-ref domain', available: Object.keys(refs) }, null, 2) }], isError: true };
         }
         return { content: [{ type: 'text', text: JSON.stringify(ref, null, 2) }] };
     },