monomind 1.8.0 → 1.9.1

package/packages/@monomind/cli/dist/src/workflow/condition-evaluator.js

@@ -1,4 +1,31 @@
-import { substitute } from './template-engine.js';
+/**
+ * Substitute context values into a condition expression, JSON-encoding string
+ * values to prevent quote injection via user-controlled context data.
+ */
+function substituteCondition(expression, context) {
+    return expression.replace(/\{\{([\w./-]+)\}\}/g, (_match, path) => {
+        const segments = path.split('.');
+        let current = context;
+        for (const seg of segments) {
+            if (current === null || current === undefined || typeof current !== 'object') {
+                current = undefined;
+                break;
+            }
+            if (seg === '__proto__' || seg === 'constructor' || seg === 'prototype') {
+                current = undefined;
+                break;
+            }
+            current = current[seg];
+        }
+        if (current === undefined)
+            return `{{${path}}}`;
+        if (typeof current === 'string')
+            return JSON.stringify(current);
+        if (typeof current === 'number' || typeof current === 'boolean')
+            return String(current);
+        return JSON.stringify(current);
+    });
+}
 /**
  * Dangerous patterns that must never appear in condition expressions.
  */
@@ -28,8 +55,15 @@ const SAFE_TOKEN = /^(\s*('([^']*)'|"([^"]*)"|-?\d+(\.\d+)?|true|false|null|unde
  * 4. Evaluate using `new Function` with strict mode.
  */
 export function evaluateCondition(expression, context) {
-    // Step 1: substitute variables
-    const resolved = substitute(expression, context);
+    if (expression.length > 500) {
+        throw new Error('Condition expression too long (max 500 characters)');
+    }
+    // Step 1: substitute variables (string values JSON-encoded to prevent quote injection)
+    const resolved = substituteCondition(expression, context);
+    // Re-check length after substitution — injected values can expand the expression
+    if (resolved.length > 500) {
+        throw new Error('Condition expression too long after variable substitution (max 500 characters)');
+    }
     // Step 2: reject dangerous patterns
     for (const pattern of DANGEROUS_PATTERNS) {
         if (pattern.test(resolved)) {

package/packages/@monomind/cli/dist/src/workflow/dag-builder.js

@@ -41,28 +41,44 @@ export function detectCycles(dag) {
         color.set(id, WHITE);
         parent.set(id, null);
     }
-    function dfs(u) {
-        color.set(u, GRAY);
-        const neighbors = dag.edges.get(u) ?? new Set();
-        for (const v of neighbors) {
-            if (color.get(v) === GRAY) {
+    // Iterative DFS to avoid call-stack overflow on deep linear DAGs
+    function dfs(start) {
+        const stack = [
+            { u: start, neighbors: (dag.edges.get(start) ?? new Set()).values(), entered: false },
+        ];
+        while (stack.length > 0) {
+            const frame = stack[stack.length - 1];
+            if (!frame.entered) {
+                frame.entered = true;
+                color.set(frame.u, GRAY);
+            }
+            const { value: v, done } = frame.neighbors.next();
+            if (done) {
+                color.set(frame.u, BLACK);
+                stack.pop();
+                continue;
+            }
+            const vColor = color.get(v);
+            if (vColor === GRAY) {
                 // Found a cycle — reconstruct it
                 const cycle = [v];
-                let curr = u;
+                let curr = frame.u;
                 while (curr !== v) {
                     cycle.push(curr);
-                    curr = parent.get(curr);
+                    const next = parent.get(curr);
+                    if (next == null)
+                        break;
+                    curr = next;
                 }
                 cycle.push(v);
                 cycle.reverse();
                 cycles.push(cycle);
             }
-            else if (color.get(v) === WHITE) {
-                parent.set(v, u);
-                dfs(v);
+            else if (vColor === WHITE) {
+                parent.set(v, frame.u);
+                stack.push({ u: v, neighbors: (dag.edges.get(v) ?? new Set()).values(), entered: false });
             }
         }
-        color.set(u, BLACK);
     }
     for (const id of dag.tasks.keys()) {
         if (color.get(id) === WHITE) {

package/packages/@monomind/cli/dist/src/workflow/dag-executor.js

@@ -1,5 +1,16 @@
 import { buildDAG, detectCycles, topologicalSort } from './dag-builder.js';
 import { resolveContext } from './context-resolver.js';
+import { getMonitor } from '../production/monitoring.js';
+function classifyError(err) {
+    const msg = err.message.toLowerCase();
+    if (msg.includes('rate limit') || msg.includes('429') || msg.includes('too many requests'))
+        return 'RATE_LIMIT';
+    if (msg.includes('timed out') || msg.includes('timeout'))
+        return 'TIMEOUT';
+    if (msg.includes('validation') || msg.includes('invalid') || msg.includes('schema'))
+        return 'VALIDATION';
+    return 'UNKNOWN';
+}
 export class DAGExecutor {
     runner;
     constructor(runner) {
@@ -17,20 +28,37 @@ export class DAGExecutor {
             const levelResults = await Promise.all(level.map(async (task) => {
                 const context = resolveContext(task, results);
                 const timeoutMs = task.timeoutMs ?? 300_000;
+                let timeoutHandle;
+                const timeoutPromise = new Promise((_, reject) => {
+                    timeoutHandle = setTimeout(() => reject(new Error(`Task "${task.id}" timed out after ${timeoutMs}ms`)), timeoutMs);
+                });
                 const result = await Promise.race([
                     this.runWithRetry(task, context),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error(`Task "${task.id}" timed out after ${timeoutMs}ms`)), timeoutMs)),
-                ]).catch((err) => ({
-                    taskId: task.id,
-                    agentSlug: task.agentSlug,
-                    output: null,
-                    outputRaw: '',
-                    latencyMs: 0,
-                    retryCount: 0,
-                    completedAt: Date.now(),
-                    status: String(err).includes('timed out') ? 'timeout' : 'error',
-                    error: String(err),
-                }));
+                    timeoutPromise,
+                ]).finally(() => {
+                    if (timeoutHandle)
+                        clearTimeout(timeoutHandle);
+                }).catch((err) => {
+                    const isTimeout = String(err).includes('timed out');
+                    if (isTimeout) {
+                        // Visible in monomind control — leaked task still running in background
+                        getMonitor().counter('dag.task.timeout_leak', 1, {
+                            taskId: task.id,
+                            agentSlug: task.agentSlug,
+                        });
+                    }
+                    return {
+                        taskId: task.id,
+                        agentSlug: task.agentSlug,
+                        output: null,
+                        outputRaw: '',
+                        latencyMs: 0,
+                        retryCount: 0,
+                        completedAt: Date.now(),
+                        status: isTimeout ? 'timeout' : 'error',
+                        error: String(err),
+                    };
+                });
                 return result;
             }));
             for (const result of levelResults) {
@@ -48,12 +76,22 @@ export class DAGExecutor {
             retryOn: [],
         };
         let lastError;
+        let actualAttempts = 0;
         for (let attempt = 0; attempt < policy.maxAttempts; attempt++) {
+            actualAttempts = attempt + 1;
             try {
                 return await this.runner(task, context);
             }
             catch (err) {
                 lastError = err;
+                // If retryOn is non-empty, check whether this error category matches.
+                // Unmatched errors consume the attempt but do not get retried further.
+                if (policy.retryOn.length > 0) {
+                    const category = classifyError(lastError);
+                    if (!policy.retryOn.includes(category)) {
+                        break;
+                    }
+                }
                 if (attempt < policy.maxAttempts - 1) {
                     const delay = policy.initialDelayMs *
                         Math.pow(policy.backoffMultiplier, attempt) +
@@ -68,7 +106,7 @@ export class DAGExecutor {
             output: null,
             outputRaw: '',
             latencyMs: 0,
-            retryCount: policy.maxAttempts,
+            retryCount: actualAttempts,
             completedAt: Date.now(),
             status: 'error',
             error: lastError?.message ?? 'Unknown error',

package/packages/@monomind/cli/dist/src/workflow/dsl-schema.d.ts

@@ -45,6 +45,7 @@ export declare const mapReduceStepSchema: z.ZodObject<{
     map_task: z.ZodString;
     reduce_agent: z.ZodString;
     reduce_task: z.ZodString;
+    concurrent: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const loopStepSchema: z.ZodObject<{
     id: z.ZodString;
@@ -95,6 +96,7 @@ export declare const workflowStepSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     map_task: z.ZodString;
     reduce_agent: z.ZodString;
     reduce_task: z.ZodString;
+    concurrent: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"loop">;
@@ -150,6 +152,7 @@ export declare const workflowDefinitionSchema: z.ZodObject<{
         map_task: z.ZodString;
         reduce_agent: z.ZodString;
         reduce_task: z.ZodString;
+        concurrent: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
         id: z.ZodString;
         type: z.ZodLiteral<"loop">;

package/packages/@monomind/cli/dist/src/workflow/dsl-schema.js

@@ -26,7 +26,7 @@ export const agentStepSchema = z.object({
 export const parallelStepSchema = z.object({
     id: z.string().min(1),
     type: z.literal('parallel'),
-    steps: z.array(lazyStep).min(2),
+    steps: z.array(lazyStep).min(2).max(50),
 });
 export const sequenceStepSchema = z.object({
     id: z.string().min(1),
@@ -48,6 +48,7 @@ export const mapReduceStepSchema = z.object({
     map_task: z.string().min(1),
     reduce_agent: z.string().min(1),
     reduce_task: z.string().min(1),
+    concurrent: z.number().int().min(1).max(500).optional(),
 });
 export const loopStepSchema = z.object({
     id: z.string().min(1),
@@ -74,5 +75,8 @@ export const workflowDefinitionSchema = z.object({
     description: z.string().optional(),
     variables: z.record(z.string(), z.unknown()).optional(),
     steps: z.array(workflowStepSchema).min(1),
-});
+}).refine((def) => {
+    const ids = def.steps.map((s) => s.id);
+    return ids.length === new Set(ids).size;
+}, { message: 'Workflow step IDs must be unique', path: ['steps'] });
 //# sourceMappingURL=dsl-schema.js.map

package/packages/@monomind/cli/dist/src/workflow/template-engine.js

@@ -16,6 +16,7 @@ export function substitute(template, context) {
         return String(value);
     });
 }
+const BLOCKED_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 function resolvePath(obj, path) {
     const segments = path.split('.');
     let current = obj;
@@ -26,6 +27,12 @@ function resolvePath(obj, path) {
         if (typeof current !== 'object') {
             return undefined;
         }
+        if (BLOCKED_KEYS.has(segment)) {
+            return undefined;
+        }
+        if (!Object.prototype.hasOwnProperty.call(current, segment)) {
+            return undefined;
+        }
         current = current[segment];
     }
     return current;

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

@@ -1,5 +1,45 @@
 import { substitute } from './template-engine.js';
 import { evaluateCondition } from './condition-evaluator.js';
+const DEFAULT_MAP_CONCURRENCY = 10;
+function classifyWorkflowError(err) {
+    const msg = err.message.toLowerCase();
+    if (msg.includes('rate limit') || msg.includes('429') || msg.includes('too many requests'))
+        return 'RATE_LIMIT';
+    if (msg.includes('timed out') || msg.includes('timeout'))
+        return 'TIMEOUT';
+    if (msg.includes('validation') || msg.includes('invalid') || msg.includes('schema'))
+        return 'VALIDATION';
+    return 'UNKNOWN';
+}
+async function mapWithConcurrency(items, concurrency, fn) {
+    const results = new Array(items.length);
+    const controller = new AbortController();
+    let next = 0;
+    async function worker() {
+        while (next < items.length) {
+            if (controller.signal.aborted)
+                return;
+            const idx = next++;
+            results[idx] = await fn(items[idx], idx, controller.signal);
+        }
+    }
+    try {
+        await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker));
+    }
+    catch (err) {
+        controller.abort();
+        throw err;
+    }
+    return results;
+}
+const BLOCKED_CONTEXT_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+const SAFE_KEY_RE = /^[a-zA-Z_$][a-zA-Z0-9_$.\-]*$/;
+function safeContextWrite(context, key, value) {
+    if (!SAFE_KEY_RE.test(key) || BLOCKED_CONTEXT_KEYS.has(key)) {
+        throw new Error(`Unsafe workflow context key rejected: "${key}"`);
+    }
+    context[key] = value;
+}
 // ---------- Executor ----------
 export class WorkflowExecutor {
     dispatcher;
@@ -59,14 +99,45 @@ export class WorkflowExecutor {
     // ---- Handlers ----
     async executeAgent(step, context) {
         const resolvedTask = substitute(step.task, context);
-        const output = await this.dispatcher.dispatch(step.agent, resolvedTask, context);
-        // Store output in context if output_key is set
-        if (step.output_key) {
-            context[step.output_key] = output;
+        const maxAttempts = step.retry_policy?.maxAttempts ?? 1;
+        const initialDelayMs = step.retry_policy?.initialDelayMs ?? 500;
+        const backoffMultiplier = step.retry_policy?.backoffMultiplier ?? 2;
+        const jitterMs = step.retry_policy?.jitterMs ?? 0;
+        const retryOn = step.retry_policy?.retryOn;
+        let lastError;
+        let delayMs = initialDelayMs;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                let dispatchPromise = this.dispatcher.dispatch(step.agent, resolvedTask, context);
+                if (step.timeout_ms) {
+                    dispatchPromise = Promise.race([
+                        dispatchPromise,
+                        new Promise((_, reject) => setTimeout(() => reject(new Error(`Agent step "${step.id}" timed out after ${step.timeout_ms}ms`)), step.timeout_ms)),
+                    ]);
+                }
+                const output = await dispatchPromise;
+                if (step.output_key) {
+                    safeContextWrite(context, step.output_key, output);
+                }
+                safeContextWrite(context, step.id, output);
+                return { stepId: step.id, output, status: 'success' };
+            }
+            catch (err) {
+                lastError = err;
+                if (attempt >= maxAttempts)
+                    break;
+                // Only retry for configured error categories (default: retry all)
+                if (retryOn && retryOn.length > 0) {
+                    const category = classifyWorkflowError(err instanceof Error ? err : new Error(String(err)));
+                    if (!retryOn.includes(category))
+                        break;
+                }
+                const jitter = jitterMs > 0 ? Math.random() * jitterMs : 0;
+                await new Promise((r) => setTimeout(r, delayMs + jitter));
+                delayMs = Math.round(delayMs * backoffMultiplier);
+            }
         }
-        // Always store by step id
-        context[step.id] = output;
-        return { stepId: step.id, output, status: 'success' };
+        throw lastError;
     }
     async executeParallel(step, context) {
         const results = await Promise.all(step.steps.map((sub) => this.executeStep(sub, context)));
@@ -93,6 +164,9 @@ export class WorkflowExecutor {
     async executeMapReduce(step, context) {
         // Resolve items from context
         const resolvedItems = substitute(step.items, context);
+        if (resolvedItems.length > 1_000_000) {
+            throw new Error(`map_reduce step "${step.id}": items string exceeds 1MB size limit`);
+        }
         let items;
         try {
             items = JSON.parse(resolvedItems);
@@ -100,27 +174,34 @@ export class WorkflowExecutor {
                 throw new Error('not an array');
         }
         catch {
-            throw new Error(`map_reduce step "${step.id}": items must resolve to a JSON array, got: ${resolvedItems}`);
+            throw new Error(`map_reduce step "${step.id}": items must resolve to a JSON array, got: ${resolvedItems.slice(0, 200)}`);
+        }
+        const MAX_MAP_ITEMS = 500;
+        if (items.length > MAX_MAP_ITEMS) {
+            throw new Error(`map_reduce step "${step.id}": ${items.length} items exceeds limit of ${MAX_MAP_ITEMS}`);
         }
-        // Map phase: fan-out to map_agent
-        const mapResults = await Promise.all(items.map(async (item, idx) => {
+        // Map phase: fan-out to map_agent with concurrency cap (default 10, override via --concurrent)
+        const concurrency = step.concurrent ?? DEFAULT_MAP_CONCURRENCY;
+        const mapResults = await mapWithConcurrency(items, concurrency, async (item, idx, signal) => {
+            if (signal.aborted)
+                throw new Error('Map phase aborted');
             const taskStr = substitute(step.map_task, { ...context, item });
             const output = await this.dispatcher.dispatch(step.map_agent, taskStr, {
                 ...context,
                 item,
             });
             return { stepId: `${step.id}.map[${idx}]`, output, status: 'success' };
-        }));
+        });
         // Store mapped outputs for reduce
         const mapOutputs = mapResults.map((r) => r.output);
-        context[`${step.id}_map_results`] = mapOutputs;
+        safeContextWrite(context, `${step.id}_map_results`, mapOutputs);
         // Reduce phase
         const reduceTask = substitute(step.reduce_task, {
             ...context,
             map_results: mapOutputs,
         });
         const reduceOutput = await this.dispatcher.dispatch(step.reduce_agent, reduceTask, { ...context, map_results: mapOutputs });
-        context[step.id] = reduceOutput;
+        safeContextWrite(context, step.id, reduceOutput);
         return [
             ...mapResults,
             { stepId: `${step.id}.reduce`, output: reduceOutput, status: 'success' },
@@ -139,7 +220,7 @@ export class WorkflowExecutor {
             }
             iteration++;
         }
-        context[`${step.id}_iterations`] = iteration;
+        safeContextWrite(context, `${step.id}_iterations`, iteration);
         return results;
     }
 }

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.8.0",
+  "version": "1.9.1",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -86,7 +86,8 @@
   },
   "dependencies": {
     "@noble/ed25519": "^2.1.0",
-    "@monoes/monograph": "^1.1.0",
+    "@monoes/monograph": "workspace:*",
+    "@monomind/routing": "workspace:*",
     "graphology": "^0.25.4",
     "graphology-communities-louvain": "^2.0.1",
     "graphology-metrics": "^2.4.0",
@@ -104,7 +105,8 @@
     "@ruvector/router": "^0.1.27",
     "@ruvector/rvagent-wasm": "^0.1.0",
     "@ruvector/ruvllm-wasm": "^2.0.2",
-    "@ruvector/sona": "^0.1.5"
+    "@ruvector/sona": "^0.1.5",
+    "@anthropic-ai/sdk": "*"
   },
   "publishConfig": {
     "access": "public",