monomind 1.8.0 → 1.9.0

package/packages/@monomind/cli/dist/src/dlq/dlq-replayer.d.ts

@@ -2,6 +2,11 @@
  * DLQ Replayer (Task 37)
  *
  * Replays dead-letter queue entries by re-invoking the original tool call.
+ *
+ * CONCURRENCY: Uses append-only status records to avoid racing with DLQWriter.enqueue().
+ * A status record `{ _statusFor, status, replayedAt, replayResult }` is appended after
+ * replay. readAll() merges status records into the base entries — the last status wins.
+ * Compaction rewrites the file when status records exceed 20% of total lines.
  */
 import type { DLQReplayResult } from '../../../shared/src/types/dlq.js';
 /** A function that attempts to call a tool with the original payload */
@@ -10,10 +15,12 @@ export declare class DLQReplayer {
     private readonly filePath;
     private readonly toolCaller;
     constructor(filePath: string, toolCaller: ToolCaller);
-    /** Read all entries */
+    /** Read all lines, merge status records into entries. Last status wins. */
     private readAll;
-    /** Write all entries back */
-    private writeAll;
+    /** Append a status-change record — never touches existing lines, safe alongside DLQWriter. */
+    private appendStatus;
+    /** Compact: rewrite file with merged entries only, removing status records. */
+    private compact;
     /** Replay a single DLQ entry by messageId */
     replay(messageId: string): Promise<DLQReplayResult>;
 }

package/packages/@monomind/cli/dist/src/dlq/dlq-replayer.js

@@ -2,8 +2,13 @@
  * DLQ Replayer (Task 37)
  *
  * Replays dead-letter queue entries by re-invoking the original tool call.
+ *
+ * CONCURRENCY: Uses append-only status records to avoid racing with DLQWriter.enqueue().
+ * A status record `{ _statusFor, status, replayedAt, replayResult }` is appended after
+ * replay. readAll() merges status records into the base entries — the last status wins.
+ * Compaction rewrites the file when status records exceed 20% of total lines.
  */
-import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { appendFileSync, existsSync, readFileSync, renameSync, statSync, writeFileSync } from 'fs';
 export class DLQReplayer {
     filePath;
     toolCaller;
@@ -11,23 +16,52 @@ export class DLQReplayer {
         this.filePath = filePath;
         this.toolCaller = toolCaller;
     }
-    /** Read all entries */
+    /** Read all lines, merge status records into entries. Last status wins. */
     readAll() {
         if (!existsSync(this.filePath))
-            return [];
+            return { entries: [], rawLineCount: 0 };
+        const stat = statSync(this.filePath);
+        if (stat.size > 256 * 1024 * 1024) {
+            throw new Error(`DLQ file exceeds 256MB (${stat.size} bytes). Run rotation/cleanup.`);
+        }
         const raw = readFileSync(this.filePath, 'utf-8').trim();
         if (!raw)
-            return [];
-        return raw.split('\n').map((line) => JSON.parse(line));
+            return { entries: [], rawLineCount: 0 };
+        const lines = raw.split('\n').filter(Boolean);
+        const statusMap = new Map();
+        const baseEntries = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed._statusFor) {
+                    statusMap.set(parsed._statusFor, parsed);
+                }
+                else {
+                    baseEntries.push(parsed);
+                }
+            }
+            catch { /* skip malformed lines */ }
+        }
+        const entries = baseEntries.map((e) => {
+            const s = statusMap.get(e.messageId);
+            return s ? { ...e, status: s.status, replayedAt: s.replayedAt, replayResult: s.replayResult } : e;
+        });
+        return { entries, rawLineCount: lines.length };
+    }
+    /** Append a status-change record — never touches existing lines, safe alongside DLQWriter. */
+    appendStatus(record) {
+        appendFileSync(this.filePath, JSON.stringify(record) + '\n', 'utf-8');
     }
-    /** Write all entries back */
-    writeAll(entries) {
+    /** Compact: rewrite file with merged entries only, removing status records. */
+    compact(entries) {
         const content = entries.map((e) => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : '');
-        writeFileSync(this.filePath, content, 'utf-8');
+        const tmp = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(tmp, content, 'utf-8');
+        renameSync(tmp, this.filePath);
     }
     /** Replay a single DLQ entry by messageId */
     async replay(messageId) {
-        const entries = this.readAll();
+        const { entries, rawLineCount } = this.readAll();
         const entry = entries.find((e) => e.messageId === messageId);
         if (!entry) {
             throw new Error(`DLQ entry not found: ${messageId}`);
@@ -38,17 +72,17 @@ export class DLQReplayer {
         const now = new Date().toISOString();
         try {
             await this.toolCaller(entry.toolName, entry.originalPayload);
-            entry.status = 'replayed';
-            entry.replayedAt = now;
-            entry.replayResult = 'success';
-            this.writeAll(entries);
+            this.appendStatus({ _statusFor: messageId, status: 'replayed', replayedAt: now, replayResult: 'success' });
+            // Compact when status records inflate file by >20%
+            if (rawLineCount > 0 && (rawLineCount - entries.length) / rawLineCount > 0.2) {
+                const merged = entries.map((e) => e.messageId === messageId ? { ...e, status: 'replayed', replayedAt: now, replayResult: 'success' } : e);
+                this.compact(merged);
+            }
             return { messageId, success: true, replayedAt: now };
         }
         catch (err) {
             const errorMessage = err instanceof Error ? err.message : String(err);
-            entry.replayResult = 'failed_again';
-            // status stays 'pending'
-            this.writeAll(entries);
+            this.appendStatus({ _statusFor: messageId, status: 'pending', replayedAt: now, replayResult: 'failed_again' });
             return { messageId, success: false, errorMessage, replayedAt: now };
         }
     }

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

@@ -5,14 +5,19 @@
  */
 import { randomUUID } from 'crypto';
 import { existsSync, mkdirSync, appendFileSync } from 'fs';
-import { join } from 'path';
+import { join, resolve, sep } from 'path';
 export class DLQWriter {
     filePath;
     constructor(dataDir) {
-        if (!existsSync(dataDir)) {
-            mkdirSync(dataDir, { recursive: true });
+        const resolvedDataDir = resolve(dataDir);
+        const allowedRoot = resolve(process.env.MONOMIND_DATA_DIR ?? process.cwd());
+        if (resolvedDataDir !== allowedRoot && !resolvedDataDir.startsWith(allowedRoot + sep)) {
+            throw new Error(`DLQ dataDir escapes allowed root: ${resolvedDataDir}`);
         }
-        this.filePath = join(dataDir, 'dead-letter-queue.jsonl');
+        if (!existsSync(resolvedDataDir)) {
+            mkdirSync(resolvedDataDir, { recursive: true });
+        }
+        this.filePath = join(resolvedDataDir, 'dead-letter-queue.jsonl');
     }
     /** Enqueue a failed message into the DLQ */
     enqueue(input) {
@@ -32,7 +37,24 @@ export class DLQWriter {
             status: 'pending',
             tags: input.tags ?? [],
         };
-        appendFileSync(this.filePath, JSON.stringify(entry) + '\n', 'utf-8');
+        // JSON.stringify can throw on circular references, BigInt, and non-serializable
+        // values. originalPayload is `unknown` (caller-controlled), so a malicious or
+        // malformed input could otherwise crash the writer mid-flight. Fall back to
+        // a sanitized record so the audit trail is preserved.
+        let serialized;
+        try {
+            serialized = JSON.stringify(entry);
+        }
+        catch {
+            serialized = JSON.stringify({
+                messageId: entry.messageId,
+                toolName: entry.toolName,
+                archivedAt: entry.archivedAt,
+                status: 'pending',
+                finalError: 'serialize_failed',
+            });
+        }
+        appendFileSync(this.filePath, serialized + '\n', 'utf-8');
         return entry;
     }
     /** Get the file path (for reader/replayer) */

package/packages/@monomind/cli/dist/src/eval/dataset-manager.d.ts

@@ -26,8 +26,8 @@ export declare class DatasetManager {
      */
     addTraceToDataset(datasetId: string, traceId: string): EvalDatasetEntry;
     /**
-     * Export a dataset to a JSON file.
+     * Export a dataset to a JSON file. Output path must be within `allowedRoot`.
      */
-    exportToFile(datasetId: string, outputPath: string): void;
+    exportToFile(datasetId: string, outputPath: string, allowedRoot?: string): void;
 }
 //# sourceMappingURL=dataset-manager.d.ts.map

package/packages/@monomind/cli/dist/src/eval/dataset-manager.js

@@ -2,7 +2,9 @@
  * DatasetManager - JSONL-based eval dataset management (Task 33)
  */
 import { randomUUID } from 'crypto';
-import { appendFileSync, readFileSync, writeFileSync, existsSync } from 'fs';
+import { appendFileSync, readFileSync, writeFileSync, renameSync, existsSync, statSync } from 'fs';
+import { resolve, sep } from 'path';
+import { parseJsonl } from '../utils/parse-jsonl.js';
 export class DatasetManager {
     datasetsPath;
     entriesPath;
@@ -43,10 +45,11 @@ export class DatasetManager {
     listDatasets() {
         if (!existsSync(this.datasetsPath))
             return [];
-        const content = readFileSync(this.datasetsPath, 'utf-8').trim();
-        if (!content)
-            return [];
-        return content.split('\n').map((line) => JSON.parse(line));
+        if (statSync(this.datasetsPath).size > 50 * 1024 * 1024) {
+            throw new Error('Dataset file exceeds 50MB — run cleanup');
+        }
+        const content = readFileSync(this.datasetsPath, 'utf-8');
+        return parseJsonl(content);
     }
     /**
      * Get entries for a specific dataset.
@@ -54,13 +57,11 @@ export class DatasetManager {
     getEntries(datasetId) {
         if (!existsSync(this.entriesPath))
             return [];
-        const content = readFileSync(this.entriesPath, 'utf-8').trim();
-        if (!content)
-            return [];
-        return content
-            .split('\n')
-            .map((line) => JSON.parse(line))
-            .filter((e) => e.datasetId === datasetId);
+        if (statSync(this.entriesPath).size > 50 * 1024 * 1024) {
+            throw new Error('Entries file exceeds 50MB — run cleanup');
+        }
+        const content = readFileSync(this.entriesPath, 'utf-8');
+        return parseJsonl(content).filter((e) => e.datasetId === datasetId);
     }
     /**
      * Add a single trace to an existing dataset.
@@ -73,7 +74,7 @@ export class DatasetManager {
             addedAt: new Date().toISOString(),
         };
         appendFileSync(this.entriesPath, JSON.stringify(entry) + '\n', 'utf-8');
-        // Update dataset entryCount
+        // Update dataset entryCount via atomic write
         const datasets = this.listDatasets();
         const updated = datasets.map((d) => {
             if (d.datasetId === datasetId) {
@@ -81,13 +82,22 @@ export class DatasetManager {
             }
             return d;
         });
-        writeFileSync(this.datasetsPath, updated.map((d) => JSON.stringify(d)).join('\n') + '\n', 'utf-8');
+        const tmp = `${this.datasetsPath}.${randomUUID()}.tmp`;
+        writeFileSync(tmp, updated.map((d) => JSON.stringify(d)).join('\n') + '\n', 'utf-8');
+        renameSync(tmp, this.datasetsPath);
         return entry;
     }
     /**
-     * Export a dataset to a JSON file.
+     * Export a dataset to a JSON file. Output path must be within `allowedRoot`.
      */
-    exportToFile(datasetId, outputPath) {
+    exportToFile(datasetId, outputPath, allowedRoot) {
+        if (allowedRoot) {
+            const resolvedOut = resolve(outputPath);
+            const resolvedRoot = resolve(allowedRoot);
+            if (!resolvedOut.startsWith(resolvedRoot + sep) && resolvedOut !== resolvedRoot) {
+                throw new Error(`Export path escapes allowed root: ${resolvedOut}`);
+            }
+        }
         const datasets = this.listDatasets();
         const dataset = datasets.find((d) => d.datasetId === datasetId);
         const entries = this.getEntries(datasetId);

package/packages/@monomind/cli/dist/src/eval/trace-collector.js

@@ -2,7 +2,8 @@
  * TraceCollector - JSONL-based production trace collection (Task 33)
  */
 import { randomUUID } from 'crypto';
-import { appendFileSync, readFileSync, existsSync } from 'fs';
+import { appendFileSync, readFileSync, existsSync, statSync } from 'fs';
+import { parseJsonl } from '../utils/parse-jsonl.js';
 export class TraceCollector {
     filePath;
     constructor(filePath) {
@@ -55,7 +56,22 @@ export class TraceCollector {
             correctedOutput: input.correctedOutput,
             tags: this.autoTag(input),
         };
-        appendFileSync(this.filePath, JSON.stringify(trace) + '\n', 'utf-8');
+        // Defensive serialization — agent outputs may contain circular references
+        // or BigInt; without this guard the writer crashes mid-trace.
+        let serialized;
+        try {
+            serialized = JSON.stringify(trace);
+        }
+        catch {
+            serialized = JSON.stringify({
+                traceId: trace.traceId,
+                agentSlug: trace.agentSlug,
+                capturedAt: trace.capturedAt,
+                reviewStatus: trace.reviewStatus,
+                outcome: 'serialize_failed',
+            });
+        }
+        appendFileSync(this.filePath, serialized + '\n', 'utf-8');
         return trace;
     }
     /**
@@ -64,10 +80,14 @@ export class TraceCollector {
     readAll() {
         if (!existsSync(this.filePath))
             return [];
+        const stat = statSync(this.filePath);
+        if (stat.size > 256 * 1024 * 1024) {
+            throw new Error(`Trace file exceeds 256MB (${stat.size} bytes). Run rotation/cleanup.`);
+        }
         const content = readFileSync(this.filePath, 'utf-8').trim();
         if (!content)
             return [];
-        return content.split('\n').map((line) => JSON.parse(line));
+        return parseJsonl(content);
     }
     /**
      * Get traces pending review, with optional limit.

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

@@ -206,7 +206,7 @@ export class CLI {
             }
             else {
                 // No action - show command help
-                this.showCommandHelp(commandName);
+                await this.showCommandHelp(commandName);
             }
         }
         catch (error) {
@@ -386,7 +386,7 @@ export class CLI {
     async loadConfig(configPath) {
         try {
             // Import config utilities
-            const { loadConfig: loadSystemConfig } = await import('@monoes/shared');
+            const { loadConfig: loadSystemConfig } = await import('@monomind/shared');
             const { systemConfigToMonomindConfig } = await import('./config-adapter.js');
             // Load configuration
             const loaded = await loadSystemConfig({
@@ -414,30 +414,32 @@ export class CLI {
     /**
      * Initialize optional subsystems at startup (non-blocking, all failures are silent).
      * Wires TierManager, ObservabilityBus + TraceCollector, and SwarmCheckpointer
-     * so that packages/@monoes/* actually contribute to the live runtime.
+     * so that packages/@monomind/* actually contribute to the live runtime.
      */
     async initSubsystems() {
         // GAP-003: TierManager
         try {
-            const { TierManager, createPersistentService } = await import('@monoes/memory');
+            const { TierManager, createPersistentService } = await import('@monomind/memory');
             const backend = createPersistentService('.monomind/memory');
-            new TierManager(backend, { shortTermCapacity: 1000 });
+            const _tierManager = new TierManager(backend, { shortTermCapacity: 1000 });
+            void _tierManager;
         }
         catch { /* optional — monomind/memory may not be installed */ }
         // GAP-004/005/006: Register background workers (EntityExtractor, EpisodeBinner, TraceCollector)
         try {
-            const { initDefaultWorkers } = await import('@monoes/hooks');
+            const { initDefaultWorkers } = await import('@monomind/hooks');
             await initDefaultWorkers();
         }
         catch { /* optional */ }
         // GAP-007: SwarmCheckpointer — write checkpoint files so crashed swarms can resume
         try {
-            const { SwarmCheckpointer } = await import('@monoes/memory');
-            new SwarmCheckpointer({
+            const { SwarmCheckpointer } = await import('@monomind/memory');
+            const _swarmCheckpointer = new SwarmCheckpointer({
                 dbPath: '.monomind/checkpoints/swarm.jsonl',
                 swarmId: 'default',
                 sessionId: `session-${Date.now()}`,
             });
+            void _swarmCheckpointer;
         }
         catch { /* optional — monomind/memory may not be installed */ }
         // Task 30: Build unified agent registry — extras (canonical) first, dev copies second.
@@ -490,7 +492,7 @@ export class CLI {
         catch { /* optional */ }
         // Task 01-03: SemanticRouteLayer + LLMFallbackRouting + KeywordRouting
         try {
-            const { RouteLayer, ALL_ROUTES } = await import('@monoes/routing');
+            const { RouteLayer, ALL_ROUTES } = await import('@monomind/routing');
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const routerConfig = { routes: ALL_ROUTES, enableKeywordFilter: true };
             // Task 02: LLMFallback — wire Anthropic Haiku when API key is present
@@ -513,7 +515,7 @@ export class CLI {
             // Expose for router.cjs via process global (router.cjs already checks __monomindRouteLayer)
             process.__monomindRouteLayer = routeLayer;
         }
-        catch { /* optional — @monoes/routing may not be installed */ }
+        catch { /* optional — @monomind/routing may not be installed */ }
     }
     /**
      * Handle errors

package/packages/@monomind/cli/dist/src/init/claudemd-generator.js

@@ -369,18 +369,18 @@ MONOMIND_MEMORY_PATH=./data/memory
 \`\`\``;
 }
 function graphifySection() {
-    return `## Knowledge Graph (graphify)
+    return `## Knowledge Graph (Monograph)
 
-Built into monomind since v1.3.0 — no separate install needed.
+Built into monomind since v1.8.0 — no separate install needed. Pure TypeScript, no Python required.
 
 ### MCP Tools (prefix: \`mcp__monomind__\`)
 
 | Tool | Description |
 |------|-------------|
-| \`graphify_build\` | Build or refresh knowledge graph from codebase |
-| \`graphify_report\` | Generate GRAPH_REPORT.md with community breakdown |
-| \`graphify_suggest\` | Get refactoring/architecture suggestions from graph |
-| \`graphify_health\` | Check graph quality score and experiment status |
+| \`monograph_build\` | Build or refresh knowledge graph from codebase |
+| \`monograph_report\` | Generate GRAPH_REPORT.md with community breakdown |
+| \`monograph_suggest\` | Get refactoring/architecture suggestions from graph |
+| \`monograph_health\` | Check graph quality score and experiment status |
 
 ### How It Works
 
@@ -390,13 +390,13 @@ Built into monomind since v1.3.0 — no separate install needed.
 4. **Experiment loop** — tracks BASELINE/KEEP/DISCARD in \`results.tsv\`
 5. **BFD chunking** — efficient Anthropic API calls via bin-packing
 
-> If graphify tools are not available, run \`npx monomind@latest init --force\` then restart Claude Code.`;
+> If monograph tools are not available, run \`npx monomind@latest init --force\` then restart Claude Code.`;
 }
 function setupAndBoundary() {
     return `## Quick Setup
 
 \`\`\`bash
-# Add MCP server — includes graphify, swarm, memory, hooks, all 200+ tools
+# Add MCP server — includes monograph, swarm, memory, hooks, all 200+ tools
 claude mcp add monomind -- npx -y monomind@latest mcp start
 
 # Start background workers