monomind 1.19.0 → 2.0.1

package/packages/@monomind/cli/dist/src/utils/input-guards.js

@@ -0,0 +1,223 @@
+/**
+ * Input validation and prompt-injection guards.
+ *
+ * Inlined from the former @monomind/security package. Provides a single
+ * typed entry point for input validation covering string, number, path,
+ * url, and orgName types, plus a heuristic prompt-injection detector
+ * for untrusted external content.
+ *
+ * @module @monomind/cli/utils/input-guards
+ */
+import { resolve, isAbsolute } from 'node:path';
+import { cwd } from 'node:process';
+/**
+ * Strip C0 and C1 control characters (U+0000–U+001F, U+007F–U+009F)
+ * but preserve printable ASCII and extended Unicode.
+ */
+function stripControlChars(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/[\x00-\x1F\x7F-\x9F]/g, '');
+}
+function validateString(value, opts) {
+    if (typeof value !== 'string') {
+        if (opts.required !== false && value == null) {
+            return { valid: false, error: 'Value is required' };
+        }
+        return { valid: false, error: 'Value must be a string' };
+    }
+    if (opts.required !== false && value.length === 0) {
+        return { valid: false, error: 'Value must not be empty' };
+    }
+    const maxLen = opts.maxLength ?? 4096;
+    if (value.length > maxLen) {
+        return {
+            valid: false,
+            error: `Value exceeds maximum length of ${maxLen}`,
+        };
+    }
+    const sanitized = stripControlChars(value);
+    return { valid: true, sanitized };
+}
+function validateNumber(value, opts) {
+    const parsed = typeof value === 'number'
+        ? value
+        : typeof value === 'string' && value.trim() !== ''
+            ? Number(value)
+            : NaN;
+    if (!Number.isFinite(parsed)) {
+        if (opts.required === false && value == null) {
+            return { valid: true };
+        }
+        return { valid: false, error: 'Value must be a finite number' };
+    }
+    return { valid: true, sanitized: String(parsed) };
+}
+function validatePath(value, opts) {
+    if (typeof value !== 'string') {
+        return { valid: false, error: 'Path must be a string' };
+    }
+    if (value.includes('\0')) {
+        return { valid: false, error: 'Path must not contain null bytes' };
+    }
+    // Reject traversal segments
+    if (/(^|[\\/])\.\.($|[\\/])/.test(value)) {
+        return { valid: false, error: 'Path must not contain directory traversal (..)' };
+    }
+    // Reject absolute paths that escape cwd
+    if (isAbsolute(value)) {
+        const cwdPath = cwd();
+        const resolved = resolve(value);
+        if (!resolved.startsWith(cwdPath + '/') && resolved !== cwdPath) {
+            return { valid: false, error: 'Absolute path must not escape the current working directory' };
+        }
+    }
+    const maxLen = opts.maxLength ?? 4096;
+    if (value.length > maxLen) {
+        return { valid: false, error: `Path exceeds maximum length of ${maxLen}` };
+    }
+    return { valid: true, sanitized: value };
+}
+function validateUrl(value, opts) {
+    if (typeof value !== 'string') {
+        return { valid: false, error: 'URL must be a string' };
+    }
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        return { valid: false, error: 'Value is not a valid URL' };
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        return { valid: false, error: 'URL must use http or https protocol' };
+    }
+    const maxLen = opts.maxLength ?? 4096;
+    if (value.length > maxLen) {
+        return { valid: false, error: `URL exceeds maximum length of ${maxLen}` };
+    }
+    return { valid: true, sanitized: parsed.toString() };
+}
+/** Org name: lowercase alphanumeric + hyphens, 1–64 chars, must start with alnum */
+const ORG_NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+function validateOrgName(value, _opts) {
+    if (typeof value !== 'string') {
+        return { valid: false, error: 'Org name must be a string' };
+    }
+    if (!ORG_NAME_RE.test(value)) {
+        return {
+            valid: false,
+            error: 'Org name must match ^[a-z0-9][a-z0-9-]{0,63}$ (lowercase, alphanumeric + hyphens, 1–64 chars)',
+        };
+    }
+    return { valid: true, sanitized: value };
+}
+/**
+ * Validate and sanitize an input value.
+ *
+ * @example
+ * const result = validateInput(req.body.name, { type: 'orgName' });
+ * if (!result.valid) throw new Error(result.error);
+ * const safeName = result.sanitized!;
+ */
+export function validateInput(value, opts) {
+    switch (opts.type) {
+        case 'string':
+            return validateString(value, opts);
+        case 'number':
+            return validateNumber(value, opts);
+        case 'path':
+            return validatePath(value, opts);
+        case 'url':
+            return validateUrl(value, opts);
+        case 'orgName':
+            return validateOrgName(value, opts);
+    }
+}
+/**
+ * Case-insensitive patterns that indicate an attempt to override
+ * system-level instructions or inject prompt directives.
+ */
+const INJECTION_PATTERNS = [
+    { re: /ignore\s+(all\s+)?previous\s+instructions/i, label: 'instruction override ("ignore previous instructions")' },
+    { re: /ignore\s+(all\s+)?prior\s+instructions/i, label: 'instruction override ("ignore prior instructions")' },
+    { re: /disregard\s+(all\s+)?(previous|prior|above)\s+instructions/i, label: 'instruction override ("disregard instructions")' },
+    { re: /forget\s+(all\s+)?(previous|prior|above)\s+(instructions|context)/i, label: 'instruction override ("forget instructions")' },
+    { re: /you\s+are\s+now\b/i, label: 'identity hijack ("you are now")' },
+    { re: /act\s+as\s+(if\s+you\s+are|a|an)\b/i, label: 'identity hijack ("act as")' },
+    { re: /pretend\s+(you\s+are|to\s+be)\b/i, label: 'identity hijack ("pretend to be")' },
+    { re: /^system\s*:/im, label: 'system prompt injection ("system:")' },
+    { re: /\[system\]/i, label: 'system prompt injection ("[system]")' },
+    { re: /<<\s*system\s*>>/i, label: 'system prompt injection ("<<system>>")' },
+    { re: /^IMPORTANT\s*:/im, label: 'directive injection ("IMPORTANT:")' },
+    { re: /^INSTRUCTION\s*:/im, label: 'directive injection ("INSTRUCTION:")' },
+    { re: /^OVERRIDE\s*:/im, label: 'directive injection ("OVERRIDE:")' },
+    { re: /\bdo\s+not\s+follow\s+(any\s+)?(previous|prior|earlier)\b/i, label: 'instruction override ("do not follow previous")' },
+    { re: /\bnew\s+instructions?\s*:/i, label: 'directive injection ("new instructions:")' },
+];
+/**
+ * Suspicious encoding patterns that may attempt to smuggle directives
+ * through Base64, hex escapes, or Unicode homoglyphs.
+ */
+const ENCODING_PATTERNS = [
+    // Large Base64 blobs (>80 chars of contiguous base64 alphabet)
+    { re: /[A-Za-z0-9+/=]{80,}/, label: 'suspicious Base64-encoded blob' },
+    // Excessive hex escapes (\x41\x42...)
+    { re: /(\\x[0-9a-fA-F]{2}){6,}/, label: 'suspicious hex-escape sequence' },
+    // Excessive Unicode escapes (AB...)
+    { re: /(\\u[0-9a-fA-F]{4}){6,}/, label: 'suspicious Unicode-escape sequence' },
+];
+/** Threshold ratio of uppercase + directive-like words to total words. */
+const DIRECTIVE_DENSITY_THRESHOLD = 0.4;
+const DIRECTIVE_WORDS = /\b(MUST|SHALL|ALWAYS|NEVER|IMPORTANT|OVERRIDE|IMMEDIATELY|MANDATORY|REQUIRED|CRITICAL)\b/g;
+/**
+ * Heuristically check whether `content` contains prompt-injection
+ * patterns. This is a structural / regex-based guard — it does not
+ * call any LLM.
+ *
+ * @param content - The untrusted string to inspect.
+ * @param source  - Optional label describing where the content came
+ *                  from (used only in log-friendly diagnostics, not
+ *                  in the returned reason).
+ * @returns `{ safe: true }` when no injection signal is found, or
+ *          `{ safe: false, reason }` describing the first match.
+ *
+ * @example
+ * const check = await validateExternalContent(userQuery, 'memory search');
+ * if (!check.safe) throw new Error(`Blocked: ${check.reason}`);
+ */
+export async function validateExternalContent(content, source) {
+    if (typeof content !== 'string') {
+        return { safe: false, reason: 'Content must be a string' };
+    }
+    // Empty / very short content is trivially safe.
+    if (content.length === 0) {
+        return { safe: true };
+    }
+    // --- 1. Direct injection patterns ---
+    for (const { re, label } of INJECTION_PATTERNS) {
+        if (re.test(content)) {
+            return { safe: false, reason: `Prompt injection detected: ${label}` };
+        }
+    }
+    // --- 2. Suspicious encoding ---
+    for (const { re, label } of ENCODING_PATTERNS) {
+        if (re.test(content)) {
+            return { safe: false, reason: `Suspicious encoding: ${label}` };
+        }
+    }
+    // --- 3. Directive density ---
+    // Only check strings long enough to be meaningful (>20 words).
+    const words = content.split(/\s+/).filter(Boolean);
+    if (words.length > 20) {
+        const matches = content.match(DIRECTIVE_WORDS);
+        const density = (matches?.length ?? 0) / words.length;
+        if (density >= DIRECTIVE_DENSITY_THRESHOLD) {
+            return {
+                safe: false,
+                reason: `Excessive directive density (${(density * 100).toFixed(0)}% directive keywords)`,
+            };
+        }
+    }
+    return { safe: true };
+}
+//# sourceMappingURL=input-guards.js.map

package/packages/@monomind/cli/dist/src/utils/json-file.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared atomic JSON file I/O utility.
+ *
+ * Previously duplicated across 10+ files with the same
+ * writeFileSync(tmp) + renameSync(tmp, path) pattern:
+ *   - mcp-tools/neural-tools.ts
+ *   - memory/intelligence.ts
+ *   - autopilot-state.ts
+ *   - commands/claims.ts
+ *   - commands/swarm.ts
+ *   - commands/neural-optimize.ts
+ *   - commands/neural-registry.ts
+ *   - commands/agent-lifecycle.ts
+ *   - commands/memory-admin.ts
+ *   - commands/memory-list.ts
+ *   - commands/security-cve.ts
+ *
+ * This is the single canonical implementation. Uses atomic
+ * rename to prevent partial writes on crash.
+ */
+/**
+ * Read and parse a JSON file. Returns `fallback` if file doesn't exist,
+ * exceeds maxBytes, or fails to parse.
+ */
+export declare function readJsonFileSync<T>(filePath: string, fallback: T, maxBytes?: number): T;
+/**
+ * Atomically write a JSON value to disk.
+ *
+ * Writes to a temporary file first (PID + timestamp suffix to avoid
+ * collisions), then renames into place. Ensures the directory exists.
+ */
+export declare function writeJsonFileAtomic(filePath: string, data: unknown, pretty?: boolean): void;
+//# sourceMappingURL=json-file.d.ts.map

package/packages/@monomind/cli/dist/src/utils/json-file.js

@@ -0,0 +1,57 @@
+/**
+ * Shared atomic JSON file I/O utility.
+ *
+ * Previously duplicated across 10+ files with the same
+ * writeFileSync(tmp) + renameSync(tmp, path) pattern:
+ *   - mcp-tools/neural-tools.ts
+ *   - memory/intelligence.ts
+ *   - autopilot-state.ts
+ *   - commands/claims.ts
+ *   - commands/swarm.ts
+ *   - commands/neural-optimize.ts
+ *   - commands/neural-registry.ts
+ *   - commands/agent-lifecycle.ts
+ *   - commands/memory-admin.ts
+ *   - commands/memory-list.ts
+ *   - commands/security-cve.ts
+ *
+ * This is the single canonical implementation. Uses atomic
+ * rename to prevent partial writes on crash.
+ */
+import { readFileSync, writeFileSync, renameSync, existsSync, statSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+/**
+ * Read and parse a JSON file. Returns `fallback` if file doesn't exist,
+ * exceeds maxBytes, or fails to parse.
+ */
+export function readJsonFileSync(filePath, fallback, maxBytes = 50 * 1024 * 1024) {
+    try {
+        if (!existsSync(filePath))
+            return fallback;
+        const stat = statSync(filePath);
+        if (stat.size > maxBytes)
+            return fallback;
+        const raw = readFileSync(filePath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return fallback;
+    }
+}
+/**
+ * Atomically write a JSON value to disk.
+ *
+ * Writes to a temporary file first (PID + timestamp suffix to avoid
+ * collisions), then renames into place. Ensures the directory exists.
+ */
+export function writeJsonFileAtomic(filePath, data, pretty = true) {
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const content = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+    const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmp, content, 'utf-8');
+    renameSync(tmp, filePath);
+}
+//# sourceMappingURL=json-file.js.map

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.19.0",
+  "version": "2.0.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",
@@ -71,14 +71,19 @@
     "!dist/**/__tests__/**",
     "bin",
     ".claude",
+    "!.claude/**/.monomind/**",
+    "!.claude/**/*.lock",
+    "!dist/**/.monomind/**",
+    "!.claude/agents/generated/**",
+    "!.claude/agents/reengineer-squad/**",
     "scripts",
     "README.md"
   ],
   "scripts": {
-    "build": "tsc --noEmitOnError false || true && mkdir -p dist/src/browser/dashboard && cp node_modules/@monoes/monobrowse/dist/src/browser/dashboard/ui.html dist/src/browser/dashboard/ui.html",
+    "build": "tsc --noEmitOnError false || true && mkdir -p dist/src/browser/dashboard && cp src/browser/dashboard/ui.html dist/src/browser/dashboard/ui.html",
     "test": "vitest run",
     "test:pattern-store": "npx tsx src/transfer/store/tests/standalone-test.ts",
-    "prepublishOnly": "cp ../../../README.md ./README.md && bash ./scripts/sync-claude-assets.sh",
+    "prepublishOnly": "cp ../../../README.md ./README.md",
     "release": "npm version prerelease --preid=alpha && npm run publish:all",
     "publish:all": "./scripts/publish.sh"
   },
@@ -87,8 +92,9 @@
     "vitest": "^4.1.4"
   },
   "dependencies": {
-    "@monoes/monobrowse": "^1.0.2",
-    "@monoes/monograph": "^1.3.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.207",
+    "@monoes/monobrowse": "^1.0.3",
+    "@monoes/monograph": "^1.4.0",
     "@noble/ed25519": "^2.1.0",
     "mammoth": "^1.12.0",
     "pdf-parse": "^2.4.5",
@@ -99,11 +105,9 @@
   "optionalDependencies": {
     "@huggingface/transformers": "^3.8.1",
     "@monoes/memory": "^1.0.5",
-    "@monomind/guidance": "*",
     "@monomind/hooks": "*",
     "@monomind/mcp": "*",
     "@monomind/routing": "*",
-    "@monomind/security": "*",
     "monofence-ai": "*",
     "sql.js": "^1.14.1"
   },

package/packages/@monomind/cli/scripts/sync-claude-assets.sh

@@ -1,23 +1,19 @@
 #!/usr/bin/env bash
-# Syncs distributable .claude assets (skills, commands, agents, helpers) from
-# the monorepo root into this package so they're included in the npm tarball.
+# DISABLED — do not run.
+#
+# This script used to rsync root .claude/ -> packages/@monomind/cli/.claude/
+# (with rm -rf delete semantics) so the package tarball would include the
+# assets. That direction is now DESTRUCTIVE: the canonical, complete copy of
+# the shipped .claude assets lives in packages/@monomind/cli/.claude, and the
+# monorepo root .claude contains only a small subset (4 of 25 skill dirs).
+# Running the old sync would wipe most of the shippable skills/agents/commands.
+#
+# Decision (2026-07): guard with a hard error instead of reversing direction —
+# nothing should be mirroring these trees anymore. If you need to change the
+# shipped assets, edit packages/@monomind/cli/.claude directly.
 set -e
 
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PKG_DIR="$SCRIPT_DIR/.."
-ROOT_DIR="$PKG_DIR/../../.."
-SRC="$ROOT_DIR/.claude"
-DEST="$PKG_DIR/.claude"
-
-mkdir -p "$DEST"
-
-for dir in skills commands agents helpers; do
-  if [ -d "$SRC/$dir" ]; then
-    rm -rf "$DEST/$dir"
-    # Copy while excluding runtime .monomind subdirectories
-    rsync -a --exclude='.monomind/' "$SRC/$dir/" "$DEST/$dir/"
-    echo "  synced .claude/$dir"
-  fi
-done
-
-echo "sync-claude-assets: done"
+echo "ERROR: sync-claude-assets.sh is disabled." >&2
+echo "The canonical .claude assets live in packages/@monomind/cli/.claude." >&2
+echo "The old root->CLI rsync would delete most shipped skills. Edit the CLI copy directly." >&2
+exit 1

package/scripts/generate-agent-avatars.mjs

@@ -27,7 +27,6 @@ const CAT_COLORS = {
   consensus:  { bg:'#EEF9FF', body:'#2196A8', accent:'#16707A' },
   perf:       { bg:'#FFF6EE', body:'#F4A261', accent:'#D4824A' },
   github:     { bg:'#F0F2F5', body:'#2D3748', accent:'#1a212e' },
-  sparc:      { bg:'#E8FAF5', body:'#2A9D8F', accent:'#1A7D72' },
   devops:     { bg:'#F0FFF4', body:'#38A169', accent:'#2D8656' },
   legal:      { bg:'#FFFBEC', body:'#8B6914', accent:'#6B4F10' },
   content:    { bg:'#FFF0F9', body:'#D63584', accent:'#A8266A' },
@@ -208,13 +207,6 @@ const AGENTS = [
   { id:'release-manager',      label:'Release Manager',       cat:'github',     icon:'🚀', acc:'none' },
   { id:'repo-architect',       label:'Repo Architect',        cat:'github',     icon:'🏗️', acc:'none' },
   { id:'workflow-automation',  label:'Workflow Automation',   cat:'github',     icon:'⚡', acc:'none' },
-  // ── SPARC ─────────────────────────────────────────────────────────────────
-  { id:'sparc-coord',          label:'SPARC Coordinator',     cat:'sparc',      icon:'⚡', acc:'crown' },
-  { id:'sparc-coder',          label:'SPARC Coder',           cat:'sparc',      icon:'💡', acc:'glasses' },
-  { id:'specification',        label:'Specification',         cat:'sparc',      icon:'📝', acc:'none' },
-  { id:'pseudocode',           label:'Pseudocode',            cat:'sparc',      icon:'🔤', acc:'none' },
-  { id:'architecture',         label:'Architecture',          cat:'sparc',      icon:'📐', acc:'none' },
-  { id:'refinement',           label:'Refinement',            cat:'sparc',      icon:'✨', acc:'none' },
   // ── Specialized Dev ───────────────────────────────────────────────────────
   { id:'backend-dev',          label:'Backend Dev',           cat:'core',       icon:'🗄️', acc:'none' },
   { id:'frontend-developer',   label:'Frontend Developer',    cat:'frontend',   icon:'🎨', acc:'none' },

package/.claude/agents/architecture/system-design/arch-system-design.md

@@ -1,54 +0,0 @@
----
-name: system-architect
-description: Expert agent for system architecture design, patterns, and high-level technical decisions
-capability:
-  role: system-architect
-  goal: Make high-level technical decisions and design scalable, maintainable system architectures
-  version: "1.0.0"
-  expertise:
-    - system architecture design
-    - architectural patterns
-    - technology trade-off analysis
-    - component interaction design
-    - scalability planning
-  task_types:
-    - system-design
-    - architecture-review
-    - technology-decision
-    - component-design
-  output_type: ArchitectureDesign
-  model_preference: opus
-  termination: System architecture documented with diagrams, rationale, and technology choices
----
-
-# System Architecture Designer
-
-You are a System Architecture Designer responsible for high-level technical decisions and system design.
-
-## Key responsibilities:
-1. Design scalable, maintainable system architectures
-2. Document architectural decisions with clear rationale
-3. Create system diagrams and component interactions
-4. Evaluate technology choices and trade-offs
-5. Define architectural patterns and principles
-
-## Best practices:
-- Consider non-functional requirements (performance, security, scalability)
-- Document ADRs (Architecture Decision Records) for major decisions
-- Use standard diagramming notations (C4, UML)
-- Think about future extensibility
-- Consider operational aspects (deployment, monitoring)
-
-## Deliverables:
-1. Architecture diagrams (C4 model preferred)
-2. Component interaction diagrams
-3. Data flow diagrams
-4. Architecture Decision Records
-5. Technology evaluation matrix
-
-## Decision framework:
-- What are the quality attributes required?
-- What are the constraints and assumptions?
-- What are the trade-offs of each option?
-- How does this align with business goals?
-- What are the risks and mitigation strategies?