monomind 1.19.0 → 2.0.0

package/packages/@monomind/cli/dist/src/mcp-tools/security-tools.js

@@ -458,6 +458,107 @@ const monofenceHasPIITool = {
         }
     },
 };
+/**
+ * Scan LLM output for PII leakage, prompt echo, and policy violations
+ */
+const monofenceScanOutputTool = {
+    name: 'monofence_scan_output',
+    description: 'Scan LLM output for PII leakage, prompt echo (trigram Jaccard), and policy violations. Use after receiving a model response.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            output: {
+                type: 'string',
+                description: 'LLM output text to scan',
+            },
+            originalPrompt: {
+                type: 'string',
+                description: 'Original prompt sent to the LLM (enables echo detection)',
+            },
+        },
+        required: ['output'],
+    },
+    handler: async (args) => {
+        let output;
+        try {
+            output = capSecurityInput(args.output, 'output');
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: e.message }) }], isError: true };
+        }
+        const rawPrompt = args.originalPrompt;
+        const originalPrompt = typeof rawPrompt === 'string'
+            ? (rawPrompt.length > MAX_SECURITY_INPUT_LEN ? rawPrompt.slice(0, MAX_SECURITY_INPUT_LEN) : rawPrompt)
+            : undefined;
+        try {
+            const defender = await getMonoFence();
+            const result = await defender.scanOutput(output, originalPrompt);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: String(error) }),
+                    }],
+                isError: true,
+            };
+        }
+    },
+};
+/**
+ * Get or reset multi-turn context escalation state
+ */
+const monofenceContextTool = {
+    name: 'monofence_context',
+    description: 'Get the multi-turn context escalation state (normal/suspicious/elevated/attack) and cumulative threat score. Pass reset=true to start a fresh session.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            reset: {
+                type: 'boolean',
+                description: 'Reset context to start a new session',
+                default: false,
+            },
+        },
+    },
+    handler: async (args) => {
+        const reset = args.reset;
+        try {
+            const defender = await getMonoFence();
+            if (reset) {
+                defender.resetContext();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ message: 'Context reset — escalation state cleared', state: defender.getContextState() }, null, 2),
+                        }],
+                };
+            }
+            const state = defender.getContextState();
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(state, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: String(error) }),
+                    }],
+                isError: true,
+            };
+        }
+    },
+};
 /**
  * Export all security tools
  */
@@ -468,6 +569,8 @@ export const securityTools = [
     monofenceLearnTool,
     monofenceIsSafeTool,
     monofenceHasPIITool,
+    monofenceScanOutputTool,
+    monofenceContextTool,
 ];
 export default securityTools;
 //# sourceMappingURL=security-tools.js.map

package/packages/@monomind/cli/dist/src/memory/intelligence.d.ts

@@ -189,7 +189,8 @@ declare class LocalReasoningBank {
      */
     recordUsage(id: string): void;
     /**
-     * Optimized cosine similarity
+     * Cosine similarity — delegates to shared utility
+     * (see src/utils/cosine-similarity.ts)
      */
     private cosineSim;
     /**

package/packages/@monomind/cli/dist/src/memory/intelligence.js

@@ -10,9 +10,11 @@
  *
  * @module v1/cli/intelligence
  */
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, renameSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { cosineSimilarity as sharedCosineSimilarity } from '../utils/cosine-similarity.js';
+import { readJsonFileSync, writeJsonFileAtomic } from '../utils/json-file.js';
 // ============================================================================
 // Persistence Configuration
 // ============================================================================
@@ -330,34 +332,58 @@ class LocalReasoningBank {
      */
     loadFromDisk() {
         try {
-            const path = getPatternsPath();
-            if (existsSync(path) && statSync(path).size <= 50 * 1024 * 1024) {
-                const data = JSON.parse(readFileSync(path, 'utf-8'));
-                if (Array.isArray(data)) {
-                    // Validate each persisted pattern. The patterns file is part of the
-                    // IPFS-distributed pattern transfer flow — without bounds checks, a
-                    // malicious bundle can inject `confidence: 1e9` (deterministically wins
-                    // every routing decision) or `keywords: [10000 strings]` (DoS on every
-                    // findBestPatternMatch call).
-                    for (const pattern of data) {
-                        if (!pattern || typeof pattern !== 'object')
-                            continue;
-                        const id = pattern.id;
-                        if (typeof id !== 'string' || id.length === 0 || id.length > 256)
-                            continue;
-                        const conf = pattern.confidence;
-                        if (conf !== undefined && (typeof conf !== 'number' || !Number.isFinite(conf) || conf < 0 || conf > 1)) {
-                            continue;
-                        }
-                        const keywords = pattern.keywords;
-                        if (keywords !== undefined && (!Array.isArray(keywords) || keywords.length > 64)) {
-                            continue;
-                        }
-                        this.patterns.set(id, pattern);
-                        this.patternList.push(pattern);
+            const data = readJsonFileSync(getPatternsPath(), []);
+            if (Array.isArray(data)) {
+                // Validate each persisted pattern. The patterns file is part of the
+                // IPFS-distributed pattern transfer flow — without bounds checks, a
+                // malicious bundle can inject `confidence: 1e9` (deterministically wins
+                // every routing decision) or `keywords: [10000 strings]` (DoS on every
+                // findBestPatternMatch call).
+                for (const pattern of data) {
+                    if (!pattern || typeof pattern !== 'object')
+                        continue;
+                    const rec = pattern;
+                    const id = rec.id;
+                    if (typeof id !== 'string' || id.length === 0 || id.length > 256)
+                        continue;
+                    const conf = rec.confidence;
+                    if (conf !== undefined && (typeof conf !== 'number' || !Number.isFinite(conf) || conf < 0 || conf > 1)) {
+                        continue;
                     }
+                    const keywords = rec.keywords;
+                    if (keywords !== undefined && (!Array.isArray(keywords) || keywords.length > 64)) {
+                        continue;
+                    }
+                    // Build a well-typed StoredPattern instead of trusting the raw JSON
+                    // shape — this both satisfies the compiler (the previous code cast
+                    // `unknown` straight into the Map/array, which TS correctly rejected)
+                    // and hardens against malformed/malicious persisted entries (e.g. a
+                    // missing embedding array previously reached cosineSim() as `undefined`).
+                    const rawEmbedding = rec.embedding;
+                    const embedding = Array.isArray(rawEmbedding) && rawEmbedding.every(v => typeof v === 'number' && Number.isFinite(v))
+                        ? rawEmbedding
+                        : [];
+                    const rawUsage = rec.usageCount;
+                    const rawCreated = rec.createdAt;
+                    const rawLastUsed = rec.lastUsedAt;
+                    const stored = {
+                        id,
+                        type: typeof rec.type === 'string' ? rec.type : 'general',
+                        embedding,
+                        content: typeof rec.content === 'string' ? rec.content : '',
+                        confidence: typeof conf === 'number' ? conf : 0.5,
+                        usageCount: typeof rawUsage === 'number' && Number.isFinite(rawUsage) ? rawUsage : 0,
+                        createdAt: typeof rawCreated === 'number' && Number.isFinite(rawCreated) ? rawCreated : Date.now(),
+                        lastUsedAt: typeof rawLastUsed === 'number' && Number.isFinite(rawLastUsed) ? rawLastUsed : Date.now(),
+                        metadata: (rec.metadata && typeof rec.metadata === 'object') ? rec.metadata : undefined,
+                    };
+                    this.patterns.set(id, stored);
+                    this.patternList.push(stored);
                 }
             }
+            // MCP-trained patterns (neural-tools) now write directly to this
+            // ReasoningBank via intelligence.ts's public API, so no separate
+            // models.json bridge is needed.
         }
         catch {
             // Ignore load errors, start fresh
@@ -386,10 +412,7 @@ class LocalReasoningBank {
             return;
         try {
             ensureDataDir();
-            const path = getPatternsPath();
-            const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-            writeFileSync(tmp, JSON.stringify(this.patternList, null, 2), 'utf-8');
-            renameSync(tmp, path);
+            writeJsonFileAtomic(getPatternsPath(), this.patternList);
             this.dirty = false;
         }
         catch {
@@ -476,21 +499,11 @@ class LocalReasoningBank {
         this.saveToDisk();
     }
     /**
-     * Optimized cosine similarity
+     * Cosine similarity — delegates to shared utility
+     * (see src/utils/cosine-similarity.ts)
      */
     cosineSim(a, b) {
-        if (!a || !b || a.length === 0 || b.length === 0)
-            return 0;
-        const len = Math.min(a.length, b.length);
-        let dot = 0, normA = 0, normB = 0;
-        for (let i = 0; i < len; i++) {
-            const ai = a[i], bi = b[i];
-            dot += ai * bi;
-            normA += ai * ai;
-            normB += bi * bi;
-        }
-        const mag = Math.sqrt(normA * normB);
-        return mag === 0 ? 0 : dot / mag;
+        return sharedCosineSimilarity(a, b);
     }
     /**
      * Get statistics

package/packages/@monomind/cli/dist/src/memory/memory-bridge.js

@@ -271,7 +271,7 @@ export async function bridgeSearchEntries(options) {
                 results = searchResults.map((r) => ({
                     id: r.entry.id,
                     key: r.entry.key,
-                    content: (r.entry.content || '').substring(0, 60) + ((r.entry.content || '').length > 60 ? '...' : ''),
+                    content: r.entry.content || '',
                     score: r.score,
                     namespace: r.entry.namespace,
                     provenance: `semantic:${r.score.toFixed(3)}`,
@@ -281,12 +281,13 @@ export async function bridgeSearchEntries(options) {
             }
             catch { /* fall through to keyword search */ }
         }
-        // Keyword fallback
+        // Keyword fallback — scan all entries in namespace (not just first 100)
+        // to avoid missing documents that were ingested later in the batch.
         if (results.length === 0) {
             const entries = await backend.query({
                 type: 'exact',
                 namespace: namespace ?? 'default',
-                limit: Math.max(limit * 10, 100),
+                limit: 50000,
             });
             const queryLower = queryStr.toLowerCase();
             results = entries
@@ -296,7 +297,7 @@ export async function bridgeSearchEntries(options) {
                 .map((e) => ({
                 id: e.id,
                 key: e.key,
-                content: (e.content || '').substring(0, 60) + ((e.content || '').length > 60 ? '...' : ''),
+                content: e.content || '',
                 score: 0.5,
                 namespace: e.namespace,
                 provenance: 'keyword',
@@ -304,10 +305,14 @@ export async function bridgeSearchEntries(options) {
             }));
             searchMethod = 'keyword';
         }
-        // Filter stale entries based on automem config
-        const { staleDays } = getAutomemConfig();
-        const staleCutoff = Date.now() - staleDays * 86400000;
-        results = results.filter((r) => !r._createdAt || r._createdAt > staleCutoff);
+        // Filter stale entries based on automem config — skip for knowledge
+        // namespaces (documents should remain searchable indefinitely)
+        const isKnowledgeNs = namespace?.startsWith('knowledge:');
+        if (!isKnowledgeNs) {
+            const { staleDays } = getAutomemConfig();
+            const staleCutoff = Date.now() - staleDays * 86400000;
+            results = results.filter((r) => !r._createdAt || r._createdAt > staleCutoff);
+        }
         results.forEach((r) => delete r._createdAt);
         return {
             success: true,
@@ -542,7 +547,7 @@ export async function bridgeSearchPatterns(options) {
         patterns: result.results.map(r => {
             let parsed = {};
             try {
-                parsed = JSON.parse(r.content + (r.content.endsWith('...') ? '' : ''));
+                parsed = JSON.parse(r.content);
             }
             catch { /* use raw */ }
             return {

package/packages/@monomind/cli/dist/src/memory/memory-read.js

@@ -11,6 +11,7 @@ import { safeParseEmbedding } from './memory-bridge.js';
 import { ensureSchemaColumns } from './memory-migrations.js';
 import { generateEmbedding } from './embedding-operations.js';
 import { searchHNSWIndex } from './hnsw-operations.js';
+import { cosineSimilarity as cosineSim } from '../utils/cosine-similarity.js';
 /** Maximum SQLite database file size accepted before read (256 MB). */
 const MAX_DB_FILE_BYTES = 256 * 1024 * 1024;
 // ADR-053: Lazy import of LanceDB memory bridge
@@ -29,25 +30,6 @@ async function getBridge() {
         return null;
     }
 }
-/**
- * Optimized cosine similarity
- * V8 JIT-friendly - avoids manual unrolling which can hurt performance
- * ~0.5μs per 384-dim vector comparison
- */
-function cosineSim(a, b) {
-    if (!a || !b || a.length === 0 || b.length === 0)
-        return 0;
-    const len = Math.min(a.length, b.length);
-    let dot = 0, normA = 0, normB = 0;
-    for (let i = 0; i < len; i++) {
-        const ai = a[i], bi = b[i];
-        dot += ai * bi;
-        normA += ai * ai;
-        normB += bi * bi;
-    }
-    const mag = Math.sqrt(normA * normB);
-    return mag === 0 ? 0 : dot / mag;
-}
 /**
  * Search entries using sql.js with vector similarity
  * Uses HNSW index for 150x faster search when available

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

@@ -130,11 +130,8 @@ export const COMMON_TYPOS = {
     'perf': 'performance',
     'performace': 'performance',
     'provider': 'providers',
-    'claim': 'claims',
     'embed': 'embeddings',
     'embeding': 'embeddings',
-    'daemon': 'daemon',
-    'deamon': 'daemon',
     'doc': 'doctor',
     'docter': 'doctor',
     'complete': 'completions',
@@ -144,10 +141,7 @@ export const COMMON_TYPOS = {
     'taks': 'task',
     'sessio': 'session',
     'sess': 'session',
-    'sesssion': 'session',
-    'workflow': 'workflow',
-    'wf': 'workflow',
-    'wokflow': 'workflow'
+    'sesssion': 'session'
 };
 /**
  * Get corrected command if it's a common typo

package/packages/@monomind/cli/dist/src/transfer/store/discovery.d.ts

@@ -49,9 +49,10 @@ export declare class PatternDiscovery {
      */
     fetchRegistry(cid: string, gateway: string): Promise<PatternRegistry | null>;
     /**
-     * Get built-in genesis registry (always available offline)
+     * Honest empty registry returned when no registry is reachable.
+     * Contains no patterns and no fabricated stats.
      */
-    private getGenesisRegistry;
+    private getEmptyRegistry;
     /**
      * Verify registry signature.
      *

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

@@ -325,83 +325,35 @@ export class PatternDiscovery {
         catch {
             // GCS not available
         }
-        // Return fallback genesis registry if all else fails
-        console.log(`[Discovery] Using built-in genesis registry`);
-        return this.getGenesisRegistry(cid);
+        // No registry could be reached. Previously this fell back to a built-in
+        // "genesis registry" that invented a pattern with fabricated stats
+        // (1,000 downloads, 5.0 rating, 42 reviews). Return an honest empty
+        // registry instead.
+        console.log(`[Discovery] No registry reachable — transfer store requires a configured registry`);
+        return this.getEmptyRegistry();
     }
     /**
-     * Get built-in genesis registry (always available offline)
+     * Honest empty registry returned when no registry is reachable.
+     * Contains no patterns and no fabricated stats.
      */
-    getGenesisRegistry(cid) {
+    getEmptyRegistry() {
         return {
             version: '1.0.0',
             updatedAt: new Date().toISOString(),
-            ipnsName: 'k51qzi5uqu5dj0w8q1xvqn8ql2g4p7x8qpk9vz3xm1y2n3o4p5q6r7s8t9u0v',
+            ipnsName: '',
             previousCid: undefined,
-            patterns: [
-                {
-                    id: 'seraphine-genesis-v1',
-                    name: 'seraphine-genesis',
-                    displayName: 'Seraphine Genesis',
-                    description: 'The foundational Monomind pattern model. Contains core routing patterns, complexity heuristics, and coordination trajectories for multi-agent swarms.',
-                    version: '1.0.0',
-                    cid: 'bafybeibqsa442vty2cvhku4ujlrkupyl75536ene7ybqsa442v',
-                    size: 8808,
-                    checksum: '8df766b89d044815c84796e7f33ba30d7806bff7eb2a75e2a0b7d26b64c45231',
-                    author: {
-                        id: 'monomind-team',
-                        displayName: 'Monomind Team',
-                        verified: true,
-                        patterns: 1,
-                        totalDownloads: 1000,
-                    },
-                    license: 'MIT',
-                    categories: ['routing', 'coordination'],
-                    tags: ['genesis', 'foundational', 'routing', 'swarm', 'coordination', 'multi-agent', 'hello-world'],
-                    language: 'typescript',
-                    framework: 'monomind',
-                    downloads: 1000,
-                    rating: 5.0,
-                    ratingCount: 42,
-                    lastUpdated: new Date().toISOString(),
-                    createdAt: '2026-01-08T18:42:31.126Z',
-                    minMonomindVersion: '3.0.0',
-                    verified: true,
-                    trustLevel: 'verified',
-                    signature: 'ed25519:genesis-pattern-signature',
-                    publicKey: 'ed25519:monomind-team-key',
-                },
-            ],
-            categories: [
-                { id: 'routing', name: 'Task Routing', description: 'Task routing patterns', patternCount: 1, icon: '🔀' },
-                { id: 'coordination', name: 'Swarm Coordination', description: 'Multi-agent coordination', patternCount: 1, icon: '🐝' },
-                { id: 'security', name: 'Security', description: 'Security patterns', patternCount: 0, icon: '🔒' },
-                { id: 'performance', name: 'Performance', description: 'Performance patterns', patternCount: 0, icon: '⚡' },
-                { id: 'testing', name: 'Testing', description: 'Testing patterns', patternCount: 0, icon: '🧪' },
-            ],
-            authors: [
-                {
-                    id: 'monomind-team',
-                    displayName: 'Monomind Team',
-                    publicKey: 'ed25519:monomind-team-key',
-                    verified: true,
-                    patterns: 1,
-                    totalDownloads: 1000,
-                },
-            ],
-            totalPatterns: 1,
-            totalDownloads: 1000,
-            totalAuthors: 1,
-            featured: ['seraphine-genesis-v1'],
-            trending: ['seraphine-genesis-v1'],
-            newest: ['seraphine-genesis-v1'],
-            // No signature on the genesis fallback. Previously this slot used
-            // `crypto.randomBytes(32)` which is meaningless by construction — every
-            // call would produce a different "valid" signature that no real key
-            // signed. Trusted-registry callers must reject this fallback (the
-            // verification path requires `registrySignature` to be present and
-            // verified against a pinned public key).
-            registryPublicKey: 'ed25519:monomind-registry-key',
+            patterns: [],
+            categories: [],
+            authors: [],
+            totalPatterns: 0,
+            totalDownloads: 0,
+            totalAuthors: 0,
+            featured: [],
+            trending: [],
+            newest: [],
+            // No signature — trusted-registry callers must reject this fallback
+            // (the verification path requires `registrySignature` to be present
+            // and verified against a pinned public key).
         };
     }
     /**

package/packages/@monomind/cli/dist/src/update/checker.js

@@ -46,7 +46,6 @@ const MONOMIND_PACKAGES = [
     '@monoes/monograph',
     '@monoes/memory',
     '@monoes/monodesign',
-    '@monomind/guidance',
     '@monomind/hooks',
     '@monomind/mcp',
     '@monomind/routing',

package/packages/@monomind/cli/dist/src/utils/cosine-similarity.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared cosine similarity utility.
+ *
+ * Previously duplicated in 5 independent implementations:
+ *   - memory/intelligence.ts (ReasoningBank.cosineSim)
+ *   - mcp-tools/neural-tools.ts (cosineSimilarity)
+ *   - mcp-tools/embeddings-tools.ts (cosineSimilarity)
+ *   - mcp-tools/coherence/types.ts (cosineSimilarity)
+ *   - mcp-tools/coherence/coherence-check.ts (cosineSimilarity)
+ *
+ * This is the single canonical implementation. Accepts number[] or
+ * Float32Array. Handles dimension mismatches gracefully (uses the shorter
+ * length) and returns 0 for zero-magnitude vectors.
+ */
+/**
+ * Compute cosine similarity between two vectors.
+ *
+ * Returns a value in [-1, 1]. Returns 0 when either vector is empty or
+ * has zero magnitude.
+ */
+export declare function cosineSimilarity(a: number[] | Float32Array, b: number[] | Float32Array): number;
+//# sourceMappingURL=cosine-similarity.d.ts.map

package/packages/@monomind/cli/dist/src/utils/cosine-similarity.js

@@ -0,0 +1,38 @@
+/**
+ * Shared cosine similarity utility.
+ *
+ * Previously duplicated in 5 independent implementations:
+ *   - memory/intelligence.ts (ReasoningBank.cosineSim)
+ *   - mcp-tools/neural-tools.ts (cosineSimilarity)
+ *   - mcp-tools/embeddings-tools.ts (cosineSimilarity)
+ *   - mcp-tools/coherence/types.ts (cosineSimilarity)
+ *   - mcp-tools/coherence/coherence-check.ts (cosineSimilarity)
+ *
+ * This is the single canonical implementation. Accepts number[] or
+ * Float32Array. Handles dimension mismatches gracefully (uses the shorter
+ * length) and returns 0 for zero-magnitude vectors.
+ */
+/**
+ * Compute cosine similarity between two vectors.
+ *
+ * Returns a value in [-1, 1]. Returns 0 when either vector is empty or
+ * has zero magnitude.
+ */
+export function cosineSimilarity(a, b) {
+    if (!a || !b || a.length === 0 || b.length === 0)
+        return 0;
+    const len = Math.min(a.length, b.length);
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < len; i++) {
+        const ai = a[i];
+        const bi = b[i];
+        dot += ai * bi;
+        normA += ai * ai;
+        normB += bi * bi;
+    }
+    const mag = Math.sqrt(normA) * Math.sqrt(normB);
+    return mag === 0 ? 0 : dot / mag;
+}
+//# sourceMappingURL=cosine-similarity.js.map

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

@@ -0,0 +1,51 @@
+/**
+ * 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
+ */
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+    sanitized?: string;
+}
+export interface ValidateInputOpts {
+    type: 'string' | 'number' | 'path' | 'url' | 'orgName';
+    maxLength?: number;
+    required?: boolean;
+}
+/**
+ * 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 declare function validateInput(value: unknown, opts: ValidateInputOpts): ValidationResult;
+export interface ExternalContentResult {
+    safe: boolean;
+    reason?: string;
+}
+/**
+ * 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 declare function validateExternalContent(content: string, source?: string): Promise<ExternalContentResult>;
+//# sourceMappingURL=input-guards.d.ts.map