monomind 1.8.0 → 1.9.0

package/packages/@monomind/cli/dist/src/agents/prompt-version-manager.d.ts

@@ -4,9 +4,11 @@
  * Provides publish-from-file, promote, rollback, and experiment
  * start/stop workflows on top of PromptVersionStore.
  *
- * @module @monoes/cli/agents/prompt-version-manager
+ * @module @monomind/cli/agents/prompt-version-manager
  */
-import type { PromptVersionStore, PromptVersion, PromptExperiment } from '../../../memory/src/prompt-version-store.js';
+type PromptVersionStore = any;
+type PromptVersion = any;
+type PromptExperiment = any;
 export declare class PromptVersionManager {
     private readonly store;
     constructor(store: PromptVersionStore);
@@ -16,4 +18,5 @@ export declare class PromptVersionManager {
     startExperiment(experiment: PromptExperiment): void;
     stopExperiment(agentSlug: string, promoteWinner?: boolean): void;
 }
+export {};
 //# sourceMappingURL=prompt-version-manager.d.ts.map

package/packages/@monomind/cli/dist/src/agents/prompt-version-manager.js

@@ -4,16 +4,39 @@
  * Provides publish-from-file, promote, rollback, and experiment
  * start/stop workflows on top of PromptVersionStore.
  *
- * @module @monoes/cli/agents/prompt-version-manager
+ * @module @monomind/cli/agents/prompt-version-manager
  */
 import * as fs from 'node:fs';
+import * as path from 'node:path';
 export class PromptVersionManager {
     store;
     constructor(store) {
         this.store = store;
     }
     publishFromFile(agentSlug, filePath, newVersion, changelog) {
-        const prompt = fs.readFileSync(filePath, 'utf-8');
+        // Symlink-aware containment: path.resolve does NOT follow symlinks, so
+        // a symlink under cwd pointing at /etc/shadow would have passed the
+        // prefix-check below. Use realpathSync on both sides and reject symlinks
+        // at the leaf so the resolved file is provably inside the project.
+        const allowedRoot = fs.realpathSync(process.cwd());
+        const requested = path.resolve(filePath);
+        if (!fs.existsSync(requested)) {
+            throw new Error(`filePath does not exist: ${requested}`);
+        }
+        if (fs.lstatSync(requested).isSymbolicLink()) {
+            throw new Error('filePath must not be a symlink');
+        }
+        const resolved = fs.realpathSync(requested);
+        const rel = path.relative(allowedRoot, resolved);
+        if (rel.startsWith('..') || path.isAbsolute(rel)) {
+            throw new Error(`filePath must be inside the project directory: ${allowedRoot}`);
+        }
+        const MAX_PROMPT_BYTES = 1 * 1024 * 1024;
+        const fileSize = fs.statSync(resolved).size;
+        if (fileSize > MAX_PROMPT_BYTES) {
+            throw new Error(`filePath exceeds maximum allowed size (${MAX_PROMPT_BYTES} bytes): ${resolved}`);
+        }
+        const prompt = fs.readFileSync(resolved, 'utf-8');
         const version = {
             agentSlug,
             version: newVersion,
@@ -47,8 +70,7 @@ export class PromptVersionManager {
         if (!experiment) {
             throw new Error(`No active experiment for "${agentSlug}"`);
         }
-        // Default winner is control
-        const winnerId = experiment.control;
+        const winnerId = (experiment.winner ?? experiment.control);
         this.store.concludeExperiment(agentSlug, winnerId);
         if (promoteWinner) {
             this.store.setActive(agentSlug, winnerId);

package/packages/@monomind/cli/dist/src/agents/specialization-scorer.js

@@ -4,9 +4,11 @@
  * JSONL-based per-agent-per-task-type scoring with time-decay.
  * Enables monomind to prefer historically successful agents for specific task types.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, statSync } from 'fs';
+import { randomBytes } from 'crypto';
 import { dirname } from 'path';
 import { calculateDecayFactor } from './score-decay.js';
+import { parseJsonl } from '../utils/parse-jsonl.js';
 /** Key used to identify a unique agent+taskType pair in the JSONL store. */
 function scoreKey(agentSlug, taskType) {
     return `${agentSlug}::${taskType}`;
@@ -34,17 +36,23 @@ export class SpecializationScorer {
         if (!existsSync(this.filePath)) {
             return [];
         }
-        const raw = readFileSync(this.filePath, 'utf-8').trim();
-        if (!raw)
-            return [];
-        return raw
-            .split('\n')
-            .filter(Boolean)
-            .map((line) => JSON.parse(line));
+        // 10MB cap. readAll is on the routing hot path; without this cap a
+        // bloated scorer file (planted or grown via repeated recordOutcome calls
+        // with diverse agentSlug::taskType keys) crashes the CLI on every route.
+        const stat = statSync(this.filePath);
+        if (stat.size > 10 * 1024 * 1024) {
+            throw new Error('Scorer store exceeds 10MB; run compaction');
+        }
+        const raw = readFileSync(this.filePath, 'utf-8');
+        return parseJsonl(raw).filter((r) => r !== null && typeof r === 'object' && !Array.isArray(r) &&
+            Object.getPrototypeOf(r) === Object.prototype);
     }
     writeAll(records) {
         const lines = records.map((r) => JSON.stringify(r));
-        writeFileSync(this.filePath, lines.join('\n') + '\n', 'utf-8');
+        // Unique tmp filename so concurrent recordOutcome calls don't collide.
+        const tmp = `${this.filePath}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`;
+        writeFileSync(tmp, lines.join('\n') + '\n', 'utf-8');
+        renameSync(tmp, this.filePath);
     }
     // ---------------------------------------------------------------------------
     // Public API

package/packages/@monomind/cli/dist/src/agents/trigger-scanner.d.ts

@@ -9,11 +9,12 @@
  * - `inject` matches accumulate as additional candidates.
  * - Invalid regex patterns are silently skipped.
  */
-import type { TriggerPattern, TriggerMatch, TriggerIndex } from '../../../../@monoes/shared/src/types/trigger.js';
+import type { TriggerPattern, TriggerMatch, TriggerIndex } from '../../../../@monomind/shared/src/types/trigger.js';
 export declare class TriggerScanner {
     private compiled;
     private patterns;
     private totalAgentsScanned;
+    private buildingIndex;
     constructor(patterns?: TriggerPattern[]);
     /**
      * Test all patterns against `taskDescription` and return matches.
@@ -29,7 +30,8 @@ export declare class TriggerScanner {
      * Reads each `.md` file, extracts YAML frontmatter, and looks for
      * `triggers:` entries with `pattern`, `mode`, and optional `priority`.
      */
-    buildIndex(agentDir: string): TriggerIndex;
+    buildIndex(agentDir: string, allowedRoot?: string): TriggerIndex;
+    private _buildIndex;
     /** Add a pattern to the index at runtime. */
     addPattern(pattern: TriggerPattern): void;
     /**
@@ -43,7 +45,7 @@ export declare class TriggerScanner {
     get size(): number;
     private compileAndAdd;
     private sortByPriority;
-    /** Recursively collect `.md` files. */
+    /** Recursively collect `.md` files (symlinks skipped, visited inodes tracked). */
     private collectMdFiles;
     /** Derive slug from filename. */
     private slugFromPath;

package/packages/@monomind/cli/dist/src/agents/trigger-scanner.js

@@ -9,12 +9,13 @@
  * - `inject` matches accumulate as additional candidates.
  * - Invalid regex patterns are silently skipped.
  */
-import { readFileSync, readdirSync, statSync } from 'fs';
-import { join, extname } from 'path';
+import { readFileSync, readdirSync, lstatSync, statSync, realpathSync } from 'fs';
+import { join, extname, resolve, sep } from 'path';
 export class TriggerScanner {
     compiled = [];
     patterns = [];
     totalAgentsScanned = 0;
+    buildingIndex = false;
     constructor(patterns = []) {
         for (const p of patterns) {
             this.compileAndAdd(p);
@@ -59,14 +60,48 @@ export class TriggerScanner {
      * Reads each `.md` file, extracts YAML frontmatter, and looks for
      * `triggers:` entries with `pattern`, `mode`, and optional `priority`.
      */
-    buildIndex(agentDir) {
+    buildIndex(agentDir, allowedRoot) {
+        if (this.buildingIndex) {
+            throw new Error('buildIndex is already running; concurrent invocations are not safe');
+        }
+        this.buildingIndex = true;
+        try {
+            return this._buildIndex(agentDir, allowedRoot);
+        }
+        finally {
+            this.buildingIndex = false;
+        }
+    }
+    _buildIndex(agentDir, allowedRoot) {
+        if (allowedRoot) {
+            let resolvedDir;
+            let resolvedRoot;
+            try {
+                resolvedDir = realpathSync(resolve(agentDir));
+            }
+            catch {
+                resolvedDir = resolve(agentDir);
+            }
+            try {
+                resolvedRoot = realpathSync(resolve(allowedRoot));
+            }
+            catch {
+                resolvedRoot = resolve(allowedRoot);
+            }
+            if (!resolvedDir.startsWith(resolvedRoot + sep) && resolvedDir !== resolvedRoot) {
+                throw new Error(`Agent directory escapes workspace: ${resolvedDir}`);
+            }
+        }
         const mdFiles = this.collectMdFiles(agentDir);
         this.patterns = [];
         this.compiled = [];
         this.totalAgentsScanned = mdFiles.length;
+        const MAX_AGENT_FILE_BYTES = 1 * 1024 * 1024;
         for (const filePath of mdFiles) {
             let content;
             try {
+                if (statSync(filePath).size > MAX_AGENT_FILE_BYTES)
+                    continue;
                 content = readFileSync(filePath, 'utf-8');
             }
             catch {
@@ -118,6 +153,14 @@ export class TriggerScanner {
     // Internal helpers
     // ---------------------------------------------------------------------------
     compileAndAdd(pattern) {
+        if (pattern.pattern.length > 200)
+            return;
+        // Reject patterns with nested/repeated quantifiers (ReDoS vectors)
+        // Covers: (a+)+, (a|b+)+, (a?){n}, ((a)+)+, [a-z]+{n}
+        if (/(\(.*[+*?].*\)|[+*?]){2,}|\{[0-9,]+\}.*[+*?]|(\[[^\]]*\]|\.)[+*?][+*?]/.test(pattern.pattern))
+            return;
+        if (/\([^)]*([+*][^)]*){2,}\)/.test(pattern.pattern))
+            return;
         try {
             const regex = new RegExp(pattern.pattern, 'i');
             this.patterns.push(pattern);
@@ -134,8 +177,8 @@ export class TriggerScanner {
         this.patterns = indexed.map((x) => x.p);
         this.compiled = indexed.map((x) => x.c);
     }
-    /** Recursively collect `.md` files. */
-    collectMdFiles(dir) {
+    /** Recursively collect `.md` files (symlinks skipped, visited inodes tracked). */
+    collectMdFiles(dir, visited = new Set()) {
         const results = [];
         let entries;
         try {
@@ -146,17 +189,22 @@ export class TriggerScanner {
         }
         for (const entry of entries) {
             const full = join(dir, entry);
-            let stat;
+            let lstat;
             try {
-                stat = statSync(full);
+                lstat = lstatSync(full);
             }
             catch {
                 continue;
             }
-            if (stat.isDirectory()) {
-                results.push(...this.collectMdFiles(full));
+            if (lstat.isSymbolicLink())
+                continue;
+            if (lstat.isDirectory()) {
+                if (visited.has(lstat.ino))
+                    continue;
+                visited.add(lstat.ino);
+                results.push(...this.collectMdFiles(full, visited));
             }
-            else if (stat.isFile() && extname(entry) === '.md') {
+            else if (lstat.isFile() && extname(entry) === '.md') {
                 results.push(full);
             }
         }

package/packages/@monomind/cli/dist/src/agents/version-store.d.ts

@@ -17,7 +17,6 @@ export declare class AgentVersionStore {
     constructor(dirPath: string);
     private readAll;
     private writeAll;
-    private appendRecord;
     /**
      * Save a new version for the given agent slug.
      *

package/packages/@monomind/cli/dist/src/agents/version-store.js

@@ -4,10 +4,11 @@
  * JSONL-based append-only storage for agent definition versions.
  * Supports save, list, get, rollback, and diff operations.
  */
-import { createHash, randomUUID } from 'crypto';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'fs';
+import { createHash, randomUUID, randomBytes } from 'crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, statSync } from 'fs';
 import { join } from 'path';
 import { computeUnifiedDiff } from './version-diff.js';
+import { parseJsonl } from '../utils/parse-jsonl.js';
 function toStored(r) {
     return {
         id: r.id,
@@ -63,21 +64,41 @@ export class AgentVersionStore {
         if (!existsSync(this.filePath)) {
             return [];
         }
-        const raw = readFileSync(this.filePath, 'utf-8').trim();
-        if (!raw)
-            return [];
-        return raw
-            .split('\n')
-            .filter(Boolean)
-            .map((line) => fromStored(JSON.parse(line)));
+        const stat = statSync(this.filePath);
+        if (stat.size > 10 * 1024 * 1024) {
+            throw new Error('Version store exceeds size limit; run compaction');
+        }
+        const raw = readFileSync(this.filePath, 'utf-8');
+        // Drop any record whose stored contentHash does not match the SHA-256 of
+        // its content. saveVersion advertises tamper-evidence by computing the
+        // hash; without this verification step, an attacker who can write the
+        // JSONL file can swap `content` with a poisoned agent prompt while
+        // leaving `contentHash` unchanged, and the next getCurrent() returns
+        // the tampered prompt verbatim into the LLM context.
+        const records = parseJsonl(raw);
+        const verified = [];
+        for (const r of records) {
+            if (typeof r?.content !== 'string' ||
+                typeof r?.contentHash !== 'string' ||
+                typeof r?.id !== 'string' ||
+                typeof r?.slug !== 'string' ||
+                typeof r?.version !== 'string' ||
+                typeof r?.changelog !== 'string' ||
+                typeof r?.capturedBy !== 'string' ||
+                typeof r?.capturedAt !== 'string')
+                continue;
+            const actual = createHash('sha256').update(r.content).digest('hex');
+            if (actual !== r.contentHash)
+                continue; // silently drop tampered record
+            verified.push(r);
+        }
+        return verified.map(fromStored);
     }
     writeAll(records) {
         const lines = records.map((r) => JSON.stringify(toStored(r)));
-        writeFileSync(this.filePath, lines.join('\n') + '\n', 'utf-8');
-    }
-    appendRecord(record) {
-        const line = JSON.stringify(toStored(record)) + '\n';
-        appendFileSync(this.filePath, line, 'utf-8');
+        const tmp = `${this.filePath}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`;
+        writeFileSync(tmp, lines.join('\n') + '\n', 'utf-8');
+        renameSync(tmp, this.filePath);
     }
     // ---------------------------------------------------------------------------
     // Public API
@@ -89,19 +110,20 @@ export class AgentVersionStore {
      * the same slug as non-current, and appends the new record.
      */
     saveVersion(slug, content, version, changelog, opts = {}) {
+        const MAX_CONTENT_BYTES = 512 * 1024;
+        if (Buffer.byteLength(content, 'utf-8') > MAX_CONTENT_BYTES) {
+            throw new Error(`content exceeds maximum allowed size (${MAX_CONTENT_BYTES} bytes)`);
+        }
         const contentHash = createHash('sha256').update(content).digest('hex');
-        // Mark previous versions as non-current (rewrite file)
+        // SINGLE-WRITER CONTRACT: version-store is written only by the daemon process.
+        // Concurrent saveVersion() calls from multiple processes would race on readAll/writeAll.
+        // If multi-writer access is needed in future, introduce an advisory lock here.
         const existing = this.readAll();
-        let changed = false;
         for (const rec of existing) {
             if (rec.slug === slug && rec.isCurrent) {
                 rec.isCurrent = false;
-                changed = true;
             }
         }
-        if (changed) {
-            this.writeAll(existing);
-        }
         const record = {
             id: randomUUID(),
             slug,
@@ -115,7 +137,8 @@ export class AgentVersionStore {
             capturedBy: opts.capturedBy ?? 'system',
             isCurrent: true,
         };
-        this.appendRecord(record);
+        existing.push(record);
+        this.writeAll(existing);
         return record;
     }
     /**

package/packages/@monomind/cli/dist/src/autopilot-state.js

@@ -7,6 +7,10 @@
  * ADR-072: Autopilot Integration
  * Security: Addresses prototype pollution, NaN bypass, input validation
  */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { randomUUID } from 'crypto';
 // ── Constants ─────────────────────────────────────────────────
 export const STATE_DIR = '.monomind/data';
 export const STATE_FILE = `${STATE_DIR}/autopilot-state.json`;
@@ -71,9 +75,8 @@ export function validateTaskSources(sources) {
 }
 // ── State Management ──────────────────────────────────────────
 export function getDefaultState() {
-    const crypto = require('crypto');
     return {
-        sessionId: crypto.randomUUID(),
+        sessionId: randomUUID(),
         enabled: false,
         startTime: Date.now(),
         iterations: 0,
@@ -85,8 +88,6 @@ export function getDefaultState() {
     };
 }
 export function loadState() {
-    const fs = require('fs');
-    const path = require('path');
     const filePath = path.resolve(STATE_FILE);
     const defaults = getDefaultState();
     try {
@@ -111,8 +112,6 @@ export function loadState() {
     return defaults;
 }
 export function saveState(state) {
-    const fs = require('fs');
-    const path = require('path');
     const dir = path.resolve(STATE_DIR);
     if (!fs.existsSync(dir))
         fs.mkdirSync(dir, { recursive: true });
@@ -120,43 +119,98 @@ export function saveState(state) {
     if (state.history.length > MAX_HISTORY_ENTRIES) {
         state.history = state.history.slice(-MAX_HISTORY_ENTRIES);
     }
-    const tmpFile = path.resolve(STATE_FILE) + '.tmp';
+    // Unique tmp filename — concurrent autopilot_enable/disable/reset calls
+    // must not collide on the same .tmp path.
+    const tmpFile = `${path.resolve(STATE_FILE)}.${process.pid}.${Date.now()}.tmp`;
     fs.writeFileSync(tmpFile, JSON.stringify(state, null, 2));
     fs.renameSync(tmpFile, path.resolve(STATE_FILE));
 }
 export function appendLog(entry) {
-    const fs = require('fs');
-    const path = require('path');
     const filePath = path.resolve(LOG_FILE);
     const dir = path.resolve(STATE_DIR);
     if (!fs.existsSync(dir))
         fs.mkdirSync(dir, { recursive: true });
-    let log = [];
+    // Append-only NDJSON: atomic at the OS level for individual lines, no
+    // read-modify-write race between concurrent MCP tool calls. Compaction is
+    // handled lazily by `compactLog()` which the daemon can call periodically.
+    // Previously this function did read → push → tmp-write → rename, which
+    // under concurrent autopilot_enable/disable/reset calls silently lost
+    // entries (last writer wins) and could truncate the log to a single entry
+    // if a peer crashed mid-write and the next caller's safeJsonParse threw.
     try {
-        if (fs.existsSync(filePath)) {
-            log = safeJsonParse(fs.readFileSync(filePath, 'utf-8'));
-            if (!Array.isArray(log))
-                log = [];
+        fs.appendFileSync(filePath, JSON.stringify(entry) + '\n', { flag: 'a' });
+    }
+    catch {
+        // Best-effort logging; do not throw from a non-critical observability path.
+    }
+    // Opportunistic compaction so the file doesn't grow without bound.
+    try {
+        const stat = fs.statSync(filePath);
+        if (stat.size > 4 * 1024 * 1024) {
+            compactLog(filePath);
         }
     }
+    catch { /* ignore */ }
+}
+/**
+ * Compact NDJSON log down to MAX_LOG_ENTRIES. On parse failure for any line,
+ * preserve the corrupt file aside (do not silently destroy data).
+ */
+function compactLog(filePath) {
+    let lines;
+    try {
+        lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(l => l.trim().length > 0);
+    }
     catch {
-        log = [];
+        return;
     }
-    log.push(entry);
-    if (log.length > MAX_LOG_ENTRIES)
-        log = log.slice(-MAX_LOG_ENTRIES);
-    const tmpFile = filePath + '.tmp';
-    fs.writeFileSync(tmpFile, JSON.stringify(log, null, 2));
-    fs.renameSync(tmpFile, filePath);
+    const entries = [];
+    let corrupt = 0;
+    for (const line of lines) {
+        try {
+            const e = safeJsonParse(line);
+            if (e && typeof e === 'object')
+                entries.push(e);
+        }
+        catch {
+            corrupt++;
+        }
+    }
+    if (corrupt > 0) {
+        try {
+            fs.copyFileSync(filePath, `${filePath}.corrupt-${Date.now()}`);
+        }
+        catch { /* ignore */ }
+    }
+    const trimmed = entries.length > MAX_LOG_ENTRIES ? entries.slice(-MAX_LOG_ENTRIES) : entries;
+    const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tmp, trimmed.map(e => JSON.stringify(e)).join('\n') + '\n');
+    fs.renameSync(tmp, filePath);
 }
 export function loadLog() {
-    const fs = require('fs');
-    const path = require('path');
     const filePath = path.resolve(LOG_FILE);
     try {
         if (fs.existsSync(filePath)) {
-            const result = safeJsonParse(fs.readFileSync(filePath, 'utf-8'));
-            return Array.isArray(result) ? result : [];
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            // Backward compatible: support both old JSON-array form and the new
+            // append-only NDJSON form. Prefer NDJSON if the file looks line-based.
+            const trimmed = raw.trim();
+            if (trimmed.startsWith('[')) {
+                const result = safeJsonParse(raw);
+                return Array.isArray(result) ? result : [];
+            }
+            const out = [];
+            for (const line of trimmed.split('\n')) {
+                if (!line)
+                    continue;
+                try {
+                    const entry = safeJsonParse(line);
+                    if (entry && typeof entry === 'object')
+                        out.push(entry);
+                }
+                catch { /* skip corrupt line */ }
+            }
+            return out;
         }
     }
     catch {
@@ -166,9 +220,6 @@ export function loadLog() {
 }
 // ── Task Discovery ────────────────────────────────────────────
 export function discoverTasks(sources) {
-    const fs = require('fs');
-    const path = require('path');
-    const os = require('os');
     const tasks = [];
     // Only process valid sources
     const validSources = sources.filter(s => VALID_TASK_SOURCES.has(s));

package/packages/@monomind/cli/dist/src/benchmarks/benchmark-runner.d.ts

@@ -2,7 +2,11 @@
  * Benchmark Runner for Regression Testing (Task 34)
  * Loads benchmark definitions, evaluates quality metrics, and detects regressions.
  */
-import type { BenchmarkDefinition, BenchmarkResult, BenchmarkBaseline, QualityMetric, MetricResult } from '@monoes/shared';
+type BenchmarkDefinition = any;
+type BenchmarkResult = any;
+type BenchmarkBaseline = any;
+type QualityMetric = any;
+type MetricResult = any;
 export declare class BenchmarkRunner {
     private baselines;
     /**
@@ -34,7 +38,7 @@ export declare class BenchmarkRunner {
     private evaluateSingleMetric;
 }
 /** Minimal local type aliases so SwarmBench doesn't depend on the broken
- *  @monoes/shared exports at the top of this file. */
+ *  @monomind/shared exports at the top of this file. */
 export interface SwarmBenchTask {
     /** Unique task ID */
     id: string;
@@ -79,4 +83,5 @@ export declare class SwarmBenchRunner {
     /** Expose underlying BenchmarkRunner for general benchmarks. */
     get benchmarkRunner(): BenchmarkRunner;
 }
+export {};
 //# sourceMappingURL=benchmark-runner.d.ts.map

package/packages/@monomind/cli/dist/src/benchmarks/benchmark-runner.js

@@ -14,19 +14,31 @@ export class BenchmarkRunner {
      */
     loadBenchmarks(dir) {
         const benchmarks = [];
-        if (!fs.existsSync(dir)) {
+        // Safe-root constraint: reject any path that escapes the working directory
+        const safeRoot = path.resolve(process.cwd());
+        const resolved = path.resolve(dir);
+        const rel = path.relative(safeRoot, resolved);
+        if (rel.startsWith('..') || path.isAbsolute(rel))
+            return [];
+        if (!fs.existsSync(resolved)) {
             return benchmarks;
         }
-        const files = fs.readdirSync(dir).filter((f) => f.endsWith('.json'));
+        const files = fs.readdirSync(resolved).filter((f) => f.endsWith('.json'));
         for (const file of files) {
-            const filePath = path.join(dir, file);
+            const filePath = path.join(resolved, file);
             const raw = fs.readFileSync(filePath, 'utf-8');
-            const parsed = JSON.parse(raw);
-            if (Array.isArray(parsed)) {
-                benchmarks.push(...parsed);
+            try {
+                const parsed = JSON.parse(raw);
+                if (Array.isArray(parsed)) {
+                    benchmarks.push(...parsed);
+                }
+                else {
+                    benchmarks.push(parsed);
+                }
             }
-            else {
-                benchmarks.push(parsed);
+            catch {
+                // skip malformed file
+                continue;
             }
         }
         return benchmarks;

package/packages/@monomind/cli/dist/src/benchmarks/metric-evaluators.d.ts

@@ -2,7 +2,7 @@
  * Metric Evaluators for Benchmark Runner (Task 34)
  * Individual metric evaluation functions for quality assessment.
  */
-import type { MetricResult } from '@monoes/shared';
+type MetricResult = any;
 /**
  * Checks whether the output contains the expected substring.
  */
@@ -32,4 +32,5 @@ export declare function jsonValid(output: string): MetricResult;
 export declare function customRegex(output: string, config: {
     pattern: string;
 }): MetricResult;
+export {};
 //# sourceMappingURL=metric-evaluators.d.ts.map