monomind 1.11.13 → 1.12.0

package/packages/@monomind/cli/dist/src/monovector/coverage-router.js

@@ -10,7 +10,7 @@
  *
  * @module @monomind/cli/monovector/coverage-router
  */
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, statSync } from 'fs';
 import { join } from 'path';
 import { getProjectCwd } from '../mcp-tools/types.js';
 // ============================================================================
@@ -28,6 +28,10 @@ const EMPTY = {
         overallStatementCoverage: 0,
     },
 };
+/** Maximum bytes for a JSON coverage summary (20 MB). */
+const MAX_COVERAGE_JSON_BYTES = 20 * 1024 * 1024;
+/** Maximum bytes for an lcov.info file (50 MB). */
+const MAX_COVERAGE_LCOV_BYTES = 50 * 1024 * 1024;
 /**
  * Read coverage data from disk. Checks, in order:
  *  1. coverage/coverage-summary.json  (Jest/Istanbul)
@@ -39,7 +43,7 @@ const EMPTY = {
 export function readCoverage(cwd = getProjectCwd()) {
     for (const rel of ['coverage/coverage-summary.json', 'coverage-summary.json']) {
         const p = join(cwd, rel);
-        if (existsSync(p)) {
+        if (existsSync(p) && statSync(p).size <= MAX_COVERAGE_JSON_BYTES) {
             try {
                 return parseSummaryJson(JSON.parse(readFileSync(p, 'utf-8')), rel);
             }
@@ -50,7 +54,7 @@ export function readCoverage(cwd = getProjectCwd()) {
     }
     for (const rel of ['coverage/lcov.info', 'lcov.info']) {
         const p = join(cwd, rel);
-        if (existsSync(p)) {
+        if (existsSync(p) && statSync(p).size <= MAX_COVERAGE_LCOV_BYTES) {
             try {
                 return parseLcov(readFileSync(p, 'utf-8'), rel);
             }
@@ -60,7 +64,7 @@ export function readCoverage(cwd = getProjectCwd()) {
         }
     }
     const nyc = join(cwd, '.nyc_output', 'out.json');
-    if (existsSync(nyc)) {
+    if (existsSync(nyc) && statSync(nyc).size <= MAX_COVERAGE_JSON_BYTES) {
         try {
             return parseSummaryJson(JSON.parse(readFileSync(nyc, 'utf-8')), '.nyc_output/out.json');
         }

package/packages/@monomind/cli/dist/src/monovector/coverage-tools.js

@@ -35,7 +35,8 @@ export const coverageRouterTools = [
         },
         handler: async (input) => {
             try {
-                const result = await coverageRoute(input.path || '', { threshold: input.threshold ?? 80 });
+                const rawPath = typeof input.path === 'string' ? input.path.slice(0, 512) : '';
+                const result = await coverageRoute(rawPath, { threshold: input.threshold ?? 80 });
                 if (!result.found) {
                     return text('No coverage report found. Run your test suite with coverage enabled (e.g. `vitest run --coverage`), then retry.');
                 }
@@ -66,7 +67,7 @@ export const coverageRouterTools = [
             try {
                 const result = await coverageGaps({
                     threshold: input.threshold ?? 80,
-                    path: input.path || undefined,
+                    path: typeof input.path === 'string' ? input.path.slice(0, 512) : undefined,
                     groupByAgent: true,
                 });
                 if (!result.found)
@@ -96,7 +97,9 @@ export const coverageRouterTools = [
         },
         handler: async (input) => {
             try {
-                const result = await coverageSuggest(input.path || '.', { threshold: input.threshold ?? 80, limit: input.limit ?? 20 });
+                const rawPath = typeof input.path === 'string' ? input.path.slice(0, 512) : '.';
+                const rawLimit = typeof input.limit === 'number' ? Math.min(Math.max(1, input.limit), 200) : 20;
+                const result = await coverageSuggest(rawPath, { threshold: input.threshold ?? 80, limit: rawLimit });
                 if (!result.found) {
                     return text('No coverage report found. Run your test suite with coverage enabled, then retry.');
                 }

package/packages/@monomind/cli/dist/src/monovector/diff-classifier.js

@@ -626,8 +626,11 @@ export function suggestReviewers(files, fileRisks) {
     return Array.from(reviewers).slice(0, 5);
 }
 // Analysis result cache
+// FIFO eviction cap matches diffCache. Without a cap, repeated calls to analyzeDiff
+// with unique refs (e.g. HEAD~0...HEAD~N) would grow this Map to GBs.
 const analysisCache = new Map();
 const ANALYSIS_CACHE_TTL_MS = 3000; // 3 seconds
+const ANALYSIS_CACHE_MAX_ENTRIES = 50;
 /**
  * Analyze a diff with full analysis (optimized with caching)
  */
@@ -662,6 +665,11 @@ export async function analyzeDiff(options) {
         recommendedReviewers,
     };
     // Cache the result
+    if (analysisCache.size >= ANALYSIS_CACHE_MAX_ENTRIES) {
+        const oldestKey = analysisCache.keys().next().value;
+        if (oldestKey !== undefined)
+            analysisCache.delete(oldestKey);
+    }
     analysisCache.set(ref, { result, timestamp: Date.now() });
     return result;
 }
@@ -692,6 +700,11 @@ export function analyzeDiffSync(options) {
         fileRisks,
         recommendedReviewers,
     };
+    if (analysisCache.size >= ANALYSIS_CACHE_MAX_ENTRIES) {
+        const oldestKey = analysisCache.keys().next().value;
+        if (oldestKey !== undefined)
+            analysisCache.delete(oldestKey);
+    }
     analysisCache.set(ref, { result, timestamp: Date.now() });
     return result;
 }

package/packages/@monomind/cli/dist/src/monovector/route-outcomes.d.ts

@@ -10,7 +10,8 @@ export interface RouteOutcomeRecord {
     measuredSuccess?: boolean;
     quality?: number;
 }
-/** Append a route recommendation (pre-outcome). */
+/** Append a route recommendation (pre-outcome). Opportunistically trims the
+ *  file to MAX_ROUTE_RECORDS lines to prevent unbounded growth. */
 export declare function recordRoute(baseDir: string, rec: RouteOutcomeRecord): Promise<void>;
 /** Join outcome data onto the most recent matching route record by routeId. */
 export declare function joinOutcome(baseDir: string, routeId: string, outcome: {

package/packages/@monomind/cli/dist/src/monovector/route-outcomes.js

@@ -3,16 +3,42 @@
  * what actually happened. This is the foundation for routing-accuracy metrics
  * and for giving SONA a real training label.
  */
-import { promises as fs } from 'node:fs';
+import { promises as fs, statSync } from 'node:fs';
 import { join } from 'node:path';
+/** Refuse to read files larger than this to prevent OOM. */
+const MAX_FILE_BYTES = 50 * 1024 * 1024; // 50 MB
+/** Cap string fields stored in each record to prevent file bloat. */
+const MAX_FIELD_LEN = 500;
 function storePath(baseDir) {
     return join(baseDir, 'route-outcomes.jsonl');
 }
-/** Append a route recommendation (pre-outcome). */
+/** Maximum number of records to keep in route-outcomes.jsonl.
+ *  computeRoutingAccuracy only ever reads the last 100 records, so anything
+ *  older is dead weight. Keeping 500 gives a comfortable buffer while bounding
+ *  the file size and keeping joinOutcome's full-file rewrite cheap. */
+const MAX_ROUTE_RECORDS = 500;
+/** Append a route recommendation (pre-outcome). Opportunistically trims the
+ *  file to MAX_ROUTE_RECORDS lines to prevent unbounded growth. */
 export async function recordRoute(baseDir, rec) {
     try {
         await fs.mkdir(baseDir, { recursive: true });
-        await fs.appendFile(storePath(baseDir), JSON.stringify(rec) + '\n', 'utf8');
+        const path = storePath(baseDir);
+        // Cap string fields to prevent individual records from bloating the file.
+        const safeRec = {
+            ...rec,
+            routeId: rec.routeId.slice(0, MAX_FIELD_LEN),
+            task: rec.task.slice(0, MAX_FIELD_LEN),
+            recommendedAgent: rec.recommendedAgent.slice(0, MAX_FIELD_LEN),
+            routingMethod: rec.routingMethod.slice(0, 64),
+        };
+        await fs.appendFile(path, JSON.stringify(safeRec) + '\n', 'utf8');
+        // Opportunistic trim: rewrite only when the file exceeds the cap.
+        // Avoids an extra stat() on every call by catching the overcount lazily.
+        const content = await fs.readFile(path, 'utf8').catch(() => '');
+        const lines = content.trim().split('\n').filter(Boolean);
+        if (lines.length > MAX_ROUTE_RECORDS) {
+            await fs.writeFile(path, lines.slice(-MAX_ROUTE_RECORDS).join('\n') + '\n', 'utf8');
+        }
     }
     catch {
         // Non-fatal — telemetry must never break routing
@@ -22,6 +48,11 @@ export async function recordRoute(baseDir, rec) {
 export async function joinOutcome(baseDir, routeId, outcome) {
     try {
         const path = storePath(baseDir);
+        try {
+            if (statSync(path).size > MAX_FILE_BYTES)
+                return;
+        }
+        catch { /* file absent */ }
         const content = await fs.readFile(path, 'utf8').catch(() => '');
         if (!content)
             return;
@@ -52,6 +83,11 @@ export async function joinLatestUnresolved(baseDir, outcome, maxAgeMs = 600_000
 ) {
     try {
         const path = storePath(baseDir);
+        try {
+            if (statSync(path).size > MAX_FILE_BYTES)
+                return null;
+        }
+        catch { /* file absent */ }
         const content = await fs.readFile(path, 'utf8').catch(() => '');
         if (!content)
             return null;
@@ -81,7 +117,13 @@ export async function joinLatestUnresolved(baseDir, outcome, maxAgeMs = 600_000
 /** Read all outcome records (for metrics). */
 export async function readOutcomes(baseDir) {
     try {
-        const content = await fs.readFile(storePath(baseDir), 'utf8').catch(() => '');
+        const p = storePath(baseDir);
+        try {
+            if (statSync(p).size > MAX_FILE_BYTES)
+                return [];
+        }
+        catch { /* file absent */ }
+        const content = await fs.readFile(p, 'utf8').catch(() => '');
         if (!content)
             return [];
         return content.trim().split('\n').map(l => {

package/packages/@monomind/cli/dist/src/observability/replay-reader.d.ts

@@ -20,7 +20,7 @@ export interface SessionReplay extends SessionSummary {
 }
 export declare class ReplayReader {
     private sessionsDir;
-    constructor(cwd?: any);
+    constructor(cwd?: string);
     /**
      * Find and return the session data for a given session ID.
      * The ID may be a bare ID (e.g. "session-1234567890") or a timestamp number.

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

@@ -0,0 +1,7 @@
+/**
+ * Orchestration — barrel exports for Three-Mode Team Routing (Task 22)
+ */
+export { RouteModeExecutor, CoordinateModeExecutor, CollaborateModeExecutor, parsePlan, } from './routing-modes.js';
+export type { OrchestrationMode, RouteModeConfig, CoordinateModeConfig, CollaborateModeConfig, ModeResult, AgentDispatcher, ModeExecutor, } from './routing-modes.js';
+export { ModeDispatcher } from './mode-dispatcher.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,6 @@
+/**
+ * Orchestration — barrel exports for Three-Mode Team Routing (Task 22)
+ */
+export { RouteModeExecutor, CoordinateModeExecutor, CollaborateModeExecutor, parsePlan, } from './routing-modes.js';
+export { ModeDispatcher } from './mode-dispatcher.js';
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/orchestration/mode-dispatcher.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ModeDispatcher — selects and executes the correct mode executor
+ * based on the requested OrchestrationMode.
+ */
+import type { AgentDispatcher, CollaborateModeConfig, CoordinateModeConfig, ModeResult, OrchestrationMode, RouteModeConfig } from './routing-modes.js';
+export declare class ModeDispatcher {
+    private readonly dispatcher;
+    constructor(dispatcher: AgentDispatcher);
+    dispatchWithMode(mode: OrchestrationMode | undefined, config: RouteModeConfig | CoordinateModeConfig | CollaborateModeConfig): Promise<ModeResult>;
+}
+//# sourceMappingURL=mode-dispatcher.d.ts.map

package/packages/@monomind/cli/dist/src/orchestration/mode-dispatcher.js

@@ -0,0 +1,31 @@
+/**
+ * ModeDispatcher — selects and executes the correct mode executor
+ * based on the requested OrchestrationMode.
+ */
+import { CollaborateModeExecutor, CoordinateModeExecutor, RouteModeExecutor, } from './routing-modes.js';
+export class ModeDispatcher {
+    dispatcher;
+    constructor(dispatcher) {
+        this.dispatcher = dispatcher;
+    }
+    async dispatchWithMode(mode = 'route', config) {
+        switch (mode) {
+            case 'route': {
+                const executor = new RouteModeExecutor(this.dispatcher);
+                return executor.execute(config);
+            }
+            case 'coordinate': {
+                const executor = new CoordinateModeExecutor(this.dispatcher);
+                return executor.execute(config);
+            }
+            case 'collaborate': {
+                const executor = new CollaborateModeExecutor(this.dispatcher);
+                return executor.execute(config);
+            }
+            default: {
+                throw new Error(`Unknown orchestration mode: ${mode}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=mode-dispatcher.js.map

package/packages/@monomind/cli/dist/src/orchestration/routing-modes.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Three-Mode Team Routing — Task 22
+ *
+ * Provides three orchestration modes:
+ *  - route:       single-agent dispatch
+ *  - coordinate:  planner → fan-out → synthesizer
+ *  - collaborate: iterative A↔B with shared scratchpad
+ */
+export type OrchestrationMode = 'route' | 'coordinate' | 'collaborate';
+export interface RouteModeConfig {
+    agentSlug: string;
+    task: string;
+}
+export interface CoordinateModeConfig {
+    plannerSlug?: string;
+    synthesizerSlug?: string;
+    task: string;
+    maxSubtasks?: number;
+}
+export interface CollaborateModeConfig {
+    agentA: string;
+    agentB: string;
+    task: string;
+    maxIterations?: number;
+    convergencePhrase?: string;
+}
+export interface ModeResult {
+    mode: OrchestrationMode;
+    output: unknown;
+    agentsInvolved: string[];
+    iterationCount: number;
+    tokenUsage: {
+        input: number;
+        output: number;
+    };
+    latencyMs: number;
+}
+export interface AgentDispatcher {
+    dispatch(agentSlug: string, task: string, context?: string): Promise<{
+        output: unknown;
+        tokenUsage?: {
+            input: number;
+            output: number;
+        };
+    }>;
+}
+export declare abstract class ModeExecutor<TConfig> {
+    protected readonly dispatcher: AgentDispatcher;
+    constructor(dispatcher: AgentDispatcher);
+    abstract execute(config: TConfig): Promise<ModeResult>;
+}
+export declare class RouteModeExecutor extends ModeExecutor<RouteModeConfig> {
+    execute(config: RouteModeConfig): Promise<ModeResult>;
+}
+/**
+ * Extract a subtasks array from the planner output.
+ * Accepts either a raw array or JSON containing a `subtasks` key.
+ */
+export declare function parsePlan(output: unknown): string[];
+export declare class CoordinateModeExecutor extends ModeExecutor<CoordinateModeConfig> {
+    execute(config: CoordinateModeConfig): Promise<ModeResult>;
+    private addTokens;
+}
+export declare class CollaborateModeExecutor extends ModeExecutor<CollaborateModeConfig> {
+    execute(config: CollaborateModeConfig): Promise<ModeResult>;
+    private addTokens;
+}
+//# sourceMappingURL=routing-modes.d.ts.map

package/packages/@monomind/cli/dist/src/orchestration/routing-modes.js

@@ -0,0 +1,180 @@
+/**
+ * Three-Mode Team Routing — Task 22
+ *
+ * Provides three orchestration modes:
+ *  - route:       single-agent dispatch
+ *  - coordinate:  planner → fan-out → synthesizer
+ *  - collaborate: iterative A↔B with shared scratchpad
+ */
+import { SharedScratchpad } from '../../../shared/src/scratchpad.js';
+// ---------------------------------------------------------------------------
+// Abstract executor
+// ---------------------------------------------------------------------------
+const SLUG_RE = /^[a-z0-9][a-z0-9\-]{0,63}$/;
+const MAX_TASK_BYTES = 64 * 1024;
+function assertSlug(value, name) {
+    if (!SLUG_RE.test(value))
+        throw new Error(`Invalid agent slug for ${name}: ${JSON.stringify(value)}`);
+}
+function assertTask(task) {
+    if (!task || task.trim().length === 0)
+        throw new Error('task must not be empty');
+    if (task.length > MAX_TASK_BYTES)
+        throw new Error(`task exceeds maximum length (${MAX_TASK_BYTES} bytes)`);
+}
+export class ModeExecutor {
+    dispatcher;
+    constructor(dispatcher) {
+        this.dispatcher = dispatcher;
+    }
+}
+// ---------------------------------------------------------------------------
+// Route mode — single dispatch
+// ---------------------------------------------------------------------------
+export class RouteModeExecutor extends ModeExecutor {
+    async execute(config) {
+        assertSlug(config.agentSlug, 'agentSlug');
+        assertTask(config.task);
+        const start = Date.now();
+        const result = await this.dispatcher.dispatch(config.agentSlug, config.task);
+        return {
+            mode: 'route',
+            output: result.output,
+            agentsInvolved: [config.agentSlug],
+            iterationCount: 1,
+            tokenUsage: result.tokenUsage ?? { input: 0, output: 0 },
+            latencyMs: Date.now() - start,
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Coordinate mode — planner → fan-out → synthesizer
+// ---------------------------------------------------------------------------
+/**
+ * Extract a subtasks array from the planner output.
+ * Accepts either a raw array or JSON containing a `subtasks` key.
+ */
+export function parsePlan(output) {
+    if (Array.isArray(output))
+        return output.map(String);
+    const raw = typeof output === 'string' ? output : JSON.stringify(output);
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed.map(String);
+        if (parsed !== null && typeof parsed === 'object' && Array.isArray(parsed.subtasks))
+            return parsed.subtasks.map(String);
+    }
+    catch {
+        // not JSON — treat the whole string as a single subtask
+    }
+    return [raw];
+}
+export class CoordinateModeExecutor extends ModeExecutor {
+    async execute(config) {
+        assertTask(config.task);
+        const start = Date.now();
+        const plannerSlug = config.plannerSlug ?? 'planner';
+        const synthesizerSlug = config.synthesizerSlug ?? 'hierarchical-coordinator';
+        assertSlug(plannerSlug, 'plannerSlug');
+        assertSlug(synthesizerSlug, 'synthesizerSlug');
+        const maxSubtasks = config.maxSubtasks ?? 8;
+        const totalTokens = { input: 0, output: 0 };
+        const agents = [plannerSlug];
+        // 1. Call planner
+        const planResult = await this.dispatcher.dispatch(plannerSlug, config.task);
+        this.addTokens(totalTokens, planResult.tokenUsage);
+        // 2. Parse subtasks & cap
+        const subtasks = parsePlan(planResult.output).slice(0, maxSubtasks);
+        // 3. Fan-out
+        const fanOutResults = await Promise.all(subtasks.map((subtask, i) => {
+            const workerSlug = `worker-${i}`;
+            agents.push(workerSlug);
+            return this.dispatcher.dispatch(workerSlug, subtask);
+        }));
+        for (const r of fanOutResults)
+            this.addTokens(totalTokens, r.tokenUsage);
+        // 4. Synthesize
+        agents.push(synthesizerSlug);
+        const synthesisContext = JSON.stringify(fanOutResults.map((r) => r.output));
+        const synthResult = await this.dispatcher.dispatch(synthesizerSlug, 'Synthesize the following results', synthesisContext);
+        this.addTokens(totalTokens, synthResult.tokenUsage);
+        return {
+            mode: 'coordinate',
+            output: synthResult.output,
+            agentsInvolved: agents,
+            iterationCount: 1 + subtasks.length + 1, // planner + workers + synthesizer
+            tokenUsage: totalTokens,
+            latencyMs: Date.now() - start,
+        };
+    }
+    addTokens(total, usage) {
+        if (usage) {
+            total.input += usage.input;
+            total.output += usage.output;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Collaborate mode — iterative A↔B with shared scratchpad
+// ---------------------------------------------------------------------------
+export class CollaborateModeExecutor extends ModeExecutor {
+    async execute(config) {
+        assertTask(config.task);
+        assertSlug(config.agentA, 'agentA');
+        assertSlug(config.agentB, 'agentB');
+        const start = Date.now();
+        // Cap iterations: each iteration costs 2 LLM dispatches; an unbounded value
+        // turns this into an unbounded token-cost / OOM vector.
+        const maxIterations = Math.max(1, Math.min(config.maxIterations ?? 5, 20));
+        // Reject empty/short convergence phrase — empty string would make
+        // String(bResult.output).includes('') return true on iteration 1, bypassing
+        // the entire iterative review and locking in whatever Agent B produced.
+        const rawPhrase = (config.convergencePhrase ?? 'APPROVED').trim();
+        const convergencePhrase = rawPhrase.length >= 3 ? rawPhrase : 'APPROVED';
+        const pad = new SharedScratchpad();
+        const totalTokens = { input: 0, output: 0 };
+        let lastOutput;
+        for (let i = 0; i < maxIterations; i++) {
+            // Agent A
+            const aResult = await this.dispatcher.dispatch(config.agentA, config.task, pad.read());
+            pad.append(config.agentA, String(aResult.output));
+            this.addTokens(totalTokens, aResult.tokenUsage);
+            // Agent B
+            const bResult = await this.dispatcher.dispatch(config.agentB, config.task, pad.read());
+            pad.append(config.agentB, String(bResult.output));
+            this.addTokens(totalTokens, bResult.tokenUsage);
+            lastOutput = bResult.output;
+            // Convergence check — require the phrase as a stand-alone token so that
+            // an attacker who controls Agent A's output cannot embed `APPROVED` in
+            // prose and force premature convergence on iteration 1.
+            const escaped = convergencePhrase.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const convergenceRe = new RegExp(`(^|\\W)${escaped}(\\W|$)`);
+            if (convergenceRe.test(String(bResult.output))) {
+                return {
+                    mode: 'collaborate',
+                    output: lastOutput,
+                    agentsInvolved: [config.agentA, config.agentB],
+                    iterationCount: i + 1,
+                    tokenUsage: totalTokens,
+                    latencyMs: Date.now() - start,
+                };
+            }
+        }
+        return {
+            mode: 'collaborate',
+            output: lastOutput,
+            agentsInvolved: [config.agentA, config.agentB],
+            iterationCount: maxIterations,
+            tokenUsage: totalTokens,
+            latencyMs: Date.now() - start,
+        };
+    }
+    addTokens(total, usage) {
+        if (usage) {
+            total.input += usage.input;
+            total.output += usage.output;
+        }
+    }
+}
+//# sourceMappingURL=routing-modes.js.map

package/packages/@monomind/cli/dist/src/plugins/manager.js

@@ -73,7 +73,8 @@ export class PluginManager {
     }
     async loadManifest() {
         try {
-            if (fs.existsSync(this.config.manifestPath)) {
+            const MAX_MANIFEST_BYTES = 10 * 1024 * 1024; // 10 MB
+            if (fs.existsSync(this.config.manifestPath) && fs.statSync(this.config.manifestPath).size <= MAX_MANIFEST_BYTES) {
                 const content = fs.readFileSync(this.config.manifestPath, 'utf-8');
                 const parsed = JSON.parse(content);
                 if (Object.prototype.hasOwnProperty.call(parsed, '__proto__') ||
@@ -148,7 +149,8 @@ export class PluginManager {
             let installedVersion = version || 'latest';
             let commands = [];
             let hooks = [];
-            if (fs.existsSync(packageJsonPath)) {
+            const MAX_PKG_JSON_BYTES = 1024 * 1024; // 1 MB
+            if (fs.existsSync(packageJsonPath) && fs.statSync(packageJsonPath).size <= MAX_PKG_JSON_BYTES) {
                 const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
                 installedVersion = pkg.version;
                 // Check for monomind plugin metadata
@@ -205,6 +207,9 @@ export class PluginManager {
             if (!fs.existsSync(packageJsonPath)) {
                 return { success: false, error: 'No package.json found at path' };
             }
+            if (fs.statSync(packageJsonPath).size > 1024 * 1024) {
+                return { success: false, error: 'package.json exceeds size limit' };
+            }
             const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
             const packageName = pkg.name;
             if (!isValidPluginKey(packageName)) {
@@ -423,7 +428,7 @@ export class PluginManager {
             // Update manifest
             const installDir = path.join(this.config.pluginsDir, 'node_modules');
             const packageJsonPath = path.join(installDir, packageName, 'package.json');
-            if (fs.existsSync(packageJsonPath)) {
+            if (fs.existsSync(packageJsonPath) && fs.statSync(packageJsonPath).size <= 1024 * 1024) {
                 const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
                 existing.version = pkg.version;
                 existing.commands = pkg['monomind']?.commands || existing.commands;

package/packages/@monomind/cli/dist/src/plugins/store/discovery.js

@@ -5,23 +5,67 @@
  */
 import * as crypto from 'crypto';
 import { resolveIPNS, fetchFromIPFS } from '../../transfer/ipfs/client.js';
+/** Maximum bytes accepted from npm API responses to prevent OOM. */
+const NPM_RESPONSE_MAX_BYTES = 256 * 1024; // 256 KB
+/**
+ * Read a fetch Response body up to maxBytes.  AbortSignal.timeout() only
+ * bounds wall-clock time, NOT response body size; a slow-drip or large
+ * response would otherwise buffer unbounded memory here.
+ */
+async function readBoundedJson(res, maxBytes) {
+    const lenHdr = res.headers.get('content-length');
+    if (lenHdr) {
+        const declared = parseInt(lenHdr, 10);
+        if (Number.isFinite(declared) && declared > maxBytes) {
+            throw new Error(`npm response too large: ${declared} bytes`);
+        }
+    }
+    if (!res.body)
+        return JSON.parse('');
+    const reader = res.body.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (value) {
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel();
+                throw new Error(`npm response exceeded ${maxBytes} bytes`);
+            }
+            chunks.push(value);
+        }
+    }
+    const buf = new Uint8Array(total);
+    let off = 0;
+    for (const c of chunks) {
+        buf.set(c, off);
+        off += c.byteLength;
+    }
+    return JSON.parse(new TextDecoder('utf-8').decode(buf));
+}
 /**
  * Fetch real npm download stats for a package
  */
 async function fetchNpmStats(packageName) {
+    // Validate package name length to avoid constructing huge URLs
+    if (!packageName || packageName.length > 214)
+        return null;
     try {
         // Fetch last week downloads
         const downloadsUrl = `https://api.npmjs.org/downloads/point/last-week/${encodeURIComponent(packageName)}`;
         const downloadsRes = await fetch(downloadsUrl, { signal: AbortSignal.timeout(3000) });
         if (!downloadsRes.ok)
             return null;
-        const downloadsData = await downloadsRes.json();
+        const downloadsData = await readBoundedJson(downloadsRes, NPM_RESPONSE_MAX_BYTES);
         // Fetch package info for version
         const packageUrl = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
         const packageRes = await fetch(packageUrl, { signal: AbortSignal.timeout(3000) });
         let version = 'unknown';
         if (packageRes.ok) {
-            const packageData = await packageRes.json();
+            const packageData = await readBoundedJson(packageRes, NPM_RESPONSE_MAX_BYTES);
             version = packageData.version || 'unknown';
         }
         return {

package/packages/@monomind/cli/dist/src/plugins/store/search.js

@@ -9,7 +9,7 @@ export function searchPlugins(registry, options = {}) {
     let plugins = [...registry.plugins];
     // Text search (name, displayName, description, tags)
     if (options.query) {
-        const query = options.query.toLowerCase();
+        const query = options.query.slice(0, 256).toLowerCase();
         plugins = plugins.filter(p => p.name.toLowerCase().includes(query) ||
             p.displayName.toLowerCase().includes(query) ||
             p.description.toLowerCase().includes(query) ||
@@ -88,8 +88,8 @@ export function searchPlugins(registry, options = {}) {
     });
     // Pagination
     const total = plugins.length;
-    const limit = options.limit || 20;
-    const offset = options.offset || 0;
+    const limit = Math.min(Math.max(1, options.limit || 20), 200);
+    const offset = Math.max(0, Math.min(options.offset || 0, 100_000));
     const page = Math.floor(offset / limit) + 1;
     plugins = plugins.slice(offset, offset + limit);
     return {
@@ -105,7 +105,8 @@ export function searchPlugins(registry, options = {}) {
  * Get search suggestions based on partial query
  */
 export function getPluginSearchSuggestions(registry, partialQuery, limit = 10) {
-    const query = partialQuery.toLowerCase();
+    const query = partialQuery.slice(0, 256).toLowerCase();
+    limit = Math.min(Math.max(1, limit), 100);
     const suggestions = new Set();
     // Search in plugin names
     for (const plugin of registry.plugins) {