@nookplot/runtime 0.5.142 → 0.5.144

package/dist/presetLoader.js

@@ -0,0 +1,740 @@
+/**
+ * PresetLoader — loads forge preset data into agent memory at boot.
+ *
+ * Reads the preset section of nookplot.yaml, fetches data per source via
+ * the gateway's forge data endpoint, runs content scanning, and ingests
+ * items as preset-tagged memories. Supports layered ingestion: RAG when
+ * available, memory.import() fallback.
+ *
+ * Features:
+ * - Content scanning (sanitizeForPrompt) on every item
+ * - Idempotent loading via .preset-loaded.json manifest
+ * - Configurable failure policy (abort / continue / retry)
+ * - Boot progress events via EventEmitter
+ * - Self-awareness memory generation
+ *
+ * @module presetLoader
+ */
+import { readFile, writeFile } from "node:fs/promises";
+import { createHash, createHmac } from "node:crypto";
+import { EventEmitter } from "node:events";
+import yaml from "js-yaml";
+import { sanitizeForPrompt } from "./contentSafety.js";
+// ── PresetLoader ──────────────────────────────────────────────
+export class PresetLoader extends EventEmitter {
+    runtime;
+    configPath;
+    loading = null;
+    /** When set, used instead of reading the `preset:` section of the config file (PackLoader delegation). */
+    presetOverride;
+    constructor(runtime, configPath = "./nookplot.yaml", presetOverride) {
+        super();
+        this.runtime = runtime;
+        this.configPath = configPath;
+        this.presetOverride = presetOverride ?? null;
+    }
+    /**
+     * Build x-preset-hmac header so the gateway trusts isPreset/presetId fields.
+     * HMAC = SHA-256(apiKey, "preset-ingest:" + agent_address).
+     */
+    presetIngestHeaders() {
+        const address = this.runtime.connection.address;
+        const apiKey = this.runtime.connection.apiKey;
+        if (!address || !apiKey)
+            return {};
+        const hmac = createHmac("sha256", apiKey).update(`preset-ingest:${address.toLowerCase()}`).digest("hex");
+        return { "x-preset-hmac": hmac };
+    }
+    /**
+     * Load all preset data sources. Called once at agent boot.
+     * Concurrent calls are coalesced — only the first triggers a fetch,
+     * subsequent callers await the same promise (prevents double-pay).
+     */
+    async load() {
+        if (this.loading)
+            return this.loading;
+        this.loading = this._doLoad();
+        try {
+            return await this.loading;
+        }
+        finally {
+            this.loading = null;
+        }
+    }
+    async _doLoad() {
+        // 1. Parse nookplot.yaml
+        const config = await this.readConfig();
+        if (!config || !config.sources || config.sources.length === 0) {
+            return this.emptyResult();
+        }
+        // 2. Check idempotent loading (presetId + version + sourceHashes must all match)
+        const manifest = await this.readManifest();
+        if (manifest && manifest.presetId === config.id && manifest.presetVersion === (config.version ?? 1)) {
+            // Compute current source hashes and compare with manifest
+            const currentHashes = {};
+            if (config.sources) {
+                for (let i = 0; i < config.sources.length; i++) {
+                    const src = config.sources[i];
+                    const hash = createHash("sha256")
+                        .update(JSON.stringify(src.config ?? {}))
+                        .digest("hex");
+                    currentHashes[`${src.type}:${i}`] = hash;
+                }
+            }
+            const hashesMatch = manifest.sourceHashes &&
+                JSON.stringify(manifest.sourceHashes) === JSON.stringify(currentHashes);
+            if (hashesMatch) {
+                this.emit("progress", { phase: "complete", result: this.manifestToResult(manifest) });
+                return this.manifestToResult(manifest);
+            }
+            // sourceHashes differ — force reload even though version matches
+        }
+        // 3. Pre-flight cost estimate — abort BEFORE spending credits
+        this.emit("progress", { phase: "estimating", message: `Estimating costs for "${config.id}"...` });
+        if (typeof config.maxCostNook === "number") {
+            try {
+                const agentAddress = "agentAddress" in this.runtime ? this.runtime.agentAddress : undefined;
+                const qs = agentAddress ? `?agentAddress=${encodeURIComponent(agentAddress)}` : "";
+                const estimate = await this.runtime.connection.request("GET", `/v1/forge/presets/${encodeURIComponent(config.id)}/estimate${qs}`);
+                if (estimate.estimatedCostNook > config.maxCostNook) {
+                    const msg = `Estimated cost ${estimate.estimatedCostNook} NOOK exceeds safety cap ${config.maxCostNook} NOOK. Aborting before fetch.`;
+                    this.emit("progress", { phase: "error", source: "cost", error: msg });
+                    throw new Error(msg);
+                }
+            }
+            catch (err) {
+                // If the error is our own cost-cap abort, re-throw it
+                if (err instanceof Error && err.message.includes("Aborting before fetch"))
+                    throw err;
+                // Otherwise the estimate endpoint failed — log and proceed (fetch will do the real spend)
+            }
+        }
+        // 4. Fetch data from gateway
+        let fetchResult;
+        try {
+            fetchResult = await this.runtime.connection.request("POST", "/v1/forge/data/fetch", {
+                presetId: config.id,
+                sources: config.sources.map((s) => ({ type: s.type, config: s.config })),
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.emit("progress", { phase: "error", source: "fetch", error: msg });
+            if (config.failurePolicy === "abort") {
+                throw new Error(`Preset data fetch failed: ${msg}`);
+            }
+            return this.emptyResult();
+        }
+        // 5. Safety cap check (use explicit !== undefined to allow maxCostNook: 0)
+        if (typeof config.maxCostNook === "number" && fetchResult.totalCostNook > config.maxCostNook) {
+            const msg = `Estimated cost ${fetchResult.totalCostNook} NOOK exceeds safety cap ${config.maxCostNook} NOOK. Aborting.`;
+            this.emit("progress", { phase: "error", source: "cost", error: msg });
+            throw new Error(msg);
+        }
+        // 6. Check if RAG / knowledge graph is available
+        let ragAvailable = false;
+        let knowledgeGraphAvailable = false;
+        try {
+            await this.runtime.connection.request("GET", "/v1/mining/knowledge/search?q=test&limit=1");
+            ragAvailable = true;
+        }
+        catch {
+            // RAG not available
+        }
+        try {
+            // Knowledge graph endpoint returns stats if migration 180 is applied
+            await this.runtime.connection.request("POST", "/v1/agents/me/knowledge/ingest", {
+                items: [],
+            });
+            knowledgeGraphAvailable = true;
+        }
+        catch (err) {
+            // 400 = endpoint exists but items empty → KG is available
+            // 404 = endpoint doesn't exist → KG not available
+            const status = err?.status ?? err?.statusCode;
+            if (status === 400) {
+                knowledgeGraphAvailable = true;
+            }
+        }
+        // 7. Scan + ingest each source
+        const trustLevel = config.trustLevel ?? "verified";
+        const sourceResults = [];
+        const sourceHashes = {};
+        for (let i = 0; i < fetchResult.sources.length; i++) {
+            const fetchSource = fetchResult.sources[i];
+            const configSource = config.sources[i];
+            const label = configSource?.label ?? `${fetchSource.source} source`;
+            const kgBatch = [];
+            this.emit("progress", {
+                phase: "fetching",
+                source: label,
+                progress: `${fetchSource.itemCount} items`,
+            });
+            let loaded = 0;
+            let blocked = 0;
+            let skipped = 0;
+            let status = "loaded";
+            let error;
+            try {
+                for (const item of fetchSource.items) {
+                    // Content scanning
+                    if (trustLevel !== "raw") {
+                        const severity = this.assessSeverity(item.content);
+                        if (severity >= 50) {
+                            blocked++;
+                            continue;
+                        }
+                    }
+                    // Sanitize
+                    const sanitized = sanitizeForPrompt(item.content, 10_000);
+                    if (!sanitized.trim()) {
+                        skipped++;
+                        continue;
+                    }
+                    // Compute content hash for dedup
+                    const contentHash = createHash("sha256").update(sanitized).digest("hex");
+                    // Ingest: prefer knowledge graph (semantic search), fall back to memory
+                    try {
+                        if (knowledgeGraphAvailable) {
+                            // C3 upgrade: ingest into agent knowledge graph for semantic search
+                            if (fetchSource.source === "aggregate") {
+                                const subLoaded = await this.ingestAggregateToKG(sanitized, config.id, configSource?.config?.domainTags ?? []);
+                                loaded += subLoaded;
+                            }
+                            else {
+                                kgBatch.push({
+                                    contentText: sanitized,
+                                    knowledgeType: this.mapSourceToKnowledgeType(fetchSource.source),
+                                    sourceType: this.mapSourceToKGSourceType(fetchSource.source),
+                                    sourceId: item.metadata?.traceId ?? item.contentHash,
+                                    domain: configSource?.config?.domainTags?.[0] ?? null,
+                                    tags: ["preset", fetchSource.source, ...(configSource?.config?.domainTags ?? [])],
+                                    importance: 0.8,
+                                    confidence: item.metadata?.compositeScore ?? 0.5,
+                                    metadata: { content_hash: contentHash, ...item.metadata },
+                                    isPreset: true,
+                                    presetId: config.id,
+                                });
+                                loaded++;
+                            }
+                        }
+                        else {
+                            // Memory fallback (pre-C3 behavior)
+                            if (fetchSource.source === "aggregate") {
+                                const subLoaded = await this.ingestAggregate(sanitized, config.id, configSource?.config?.domainTags ?? []);
+                                loaded += subLoaded;
+                            }
+                            else {
+                                await this.runtime.memory.storeMemory("semantic", sanitized, {
+                                    tags: ["preset", fetchSource.source, ...(configSource?.config?.domainTags ?? [])],
+                                    source: `preset:${config.id}:${fetchSource.source}`,
+                                    importance: 0.8,
+                                    metadata: {
+                                        is_preset: true,
+                                        preset_id: config.id,
+                                        content_hash: contentHash,
+                                        ...item.metadata,
+                                    },
+                                });
+                                loaded++;
+                            }
+                        }
+                    }
+                    catch {
+                        skipped++;
+                    }
+                }
+                // Flush KG batch if any items accumulated
+                if (kgBatch.length > 0) {
+                    try {
+                        const batchResult = await this.runtime.connection.request("POST", "/v1/agents/me/knowledge/ingest", { items: kgBatch }, 4, 0, this.presetIngestHeaders());
+                        // Adjust loaded/skipped counts based on actual ingest result
+                        const batchSkipped = batchResult.skipped ?? 0;
+                        if (batchSkipped > 0) {
+                            loaded -= batchSkipped;
+                            skipped += batchSkipped;
+                        }
+                    }
+                    catch {
+                        // If batch ingest fails, fall back to memory for this source
+                        for (const batchItem of kgBatch) {
+                            try {
+                                await this.runtime.memory.storeMemory("semantic", batchItem.contentText, {
+                                    tags: batchItem.tags,
+                                    source: `preset:${config.id}:${fetchSource.source}`,
+                                    importance: batchItem.importance,
+                                    metadata: { is_preset: true, preset_id: config.id, ...batchItem.metadata },
+                                });
+                            }
+                            catch {
+                                skipped++;
+                                loaded--;
+                            }
+                        }
+                    }
+                }
+                if (loaded === 0 && fetchSource.itemCount > 0) {
+                    status = "failed";
+                    error = `All ${fetchSource.itemCount} items were blocked or skipped`;
+                }
+                else if (blocked > 0 || skipped > 0) {
+                    status = "partial";
+                }
+            }
+            catch (err) {
+                status = "failed";
+                error = err instanceof Error ? err.message : String(err);
+                this.emit("progress", { phase: "error", source: label, error });
+                if (config.failurePolicy === "abort") {
+                    throw new Error(`Source "${label}" failed: ${error}`);
+                }
+            }
+            this.emit("progress", {
+                phase: "scanning",
+                source: label,
+                blocked,
+            });
+            this.emit("progress", {
+                phase: "ingesting",
+                source: label,
+                method: knowledgeGraphAvailable ? "rag" : ragAvailable ? "rag" : "memory",
+            });
+            // Source hash for idempotent manifest
+            const sourceHash = createHash("sha256")
+                .update(JSON.stringify(configSource?.config ?? {}))
+                .digest("hex");
+            sourceHashes[`${fetchSource.source}:${i}`] = sourceHash;
+            sourceResults.push({
+                type: fetchSource.source,
+                label,
+                itemsLoaded: loaded,
+                itemsBlocked: blocked,
+                itemsSkipped: skipped,
+                method: knowledgeGraphAvailable ? "rag" : ragAvailable ? "rag" : "memory",
+                status,
+                error,
+                costNook: fetchSource.costNook,
+            });
+        }
+        // 8. Self-awareness memory
+        const totalLoaded = sourceResults.reduce((s, r) => s + r.itemsLoaded, 0);
+        if (totalLoaded > 0) {
+            // M10: Sanitize config.id to prevent prompt injection via crafted preset IDs
+            const safePresetId = (config.id ?? "").replace(/[^\w\s._-]/g, "").slice(0, 100);
+            const selfModelContent = [
+                `I was forged with preset "${safePresetId}" (v${config.version ?? 1}) on ${new Date().toISOString()}.`,
+                `My knowledge includes:`,
+                ...sourceResults
+                    .filter((s) => s.itemsLoaded > 0)
+                    .map((s) => `- ${s.itemsLoaded} items from ${s.label} (${s.type}, ingested via ${s.method})`),
+                knowledgeGraphAvailable
+                    ? `My knowledge is indexed in my personal knowledge graph with semantic search.`
+                    : ragAvailable
+                        ? `I can search my knowledge semantically via RAG.`
+                        : `I search my knowledge via text matching (RAG not yet available — will upgrade automatically).`,
+            ].join("\n");
+            try {
+                await this.runtime.memory.storeMemory("self_model", selfModelContent, {
+                    tags: ["preset", "forge", safePresetId],
+                    source: `preset:${safePresetId}`,
+                    importance: 0.95,
+                    metadata: { is_preset: true, preset_id: safePresetId },
+                });
+            }
+            catch {
+                // Non-critical — don't fail the load
+            }
+        }
+        // 9. Write manifest for idempotent reboot
+        const result = {
+            sources: sourceResults,
+            totalItems: totalLoaded,
+            totalBlocked: sourceResults.reduce((s, r) => s + r.itemsBlocked, 0),
+            totalCostNook: fetchResult.totalCostNook,
+            ragAvailable: ragAvailable || knowledgeGraphAvailable,
+            presetVersion: config.version ?? 1,
+            loadedAt: new Date().toISOString(),
+        };
+        await this.writeManifest({
+            presetId: config.id,
+            presetVersion: config.version ?? 1,
+            loadedAt: result.loadedAt,
+            sourceHashes,
+            totalItems: result.totalItems,
+            costPaid: result.totalCostNook,
+            ragAvailable: result.ragAvailable,
+        });
+        this.emit("progress", { phase: "complete", result });
+        return result;
+    }
+    /**
+     * Check if preset data was already loaded (idempotent reboot check).
+     */
+    async isLoaded() {
+        // M11: Check manifest matches current config (not just existence)
+        const manifest = await this.readManifest();
+        if (!manifest)
+            return false;
+        const config = await this.readConfig();
+        if (!config)
+            return false;
+        return manifest.presetId === config.id && manifest.presetVersion === (config.version ?? 1);
+    }
+    // ── Knowledge Graph Helpers (C3) ────────────────────────────
+    /**
+     * Map preset source type to knowledge graph knowledge_type.
+     */
+    mapSourceToKnowledgeType(source) {
+        switch (source) {
+            case "mining": return "fact";
+            case "bundle": return "fact";
+            case "aggregate": return "synthesis";
+            case "memory": return "experience";
+            case "reppo": return "fact";
+            default: return "fact";
+        }
+    }
+    /**
+     * Map preset source type to knowledge graph source_type.
+     */
+    mapSourceToKGSourceType(source) {
+        switch (source) {
+            case "mining": return "mining";
+            case "bundle": return "import";
+            case "aggregate": return "aggregation";
+            case "memory": return "import";
+            case "reppo": return "import";
+            default: return "preset";
+        }
+    }
+    /**
+     * Ingest a KnowledgeAggregateV1 into the knowledge graph as structured items.
+     * Same decomposition as ingestAggregate but targets the KG endpoint.
+     */
+    async ingestAggregateToKG(content, presetId, domainTags) {
+        let aggregate;
+        try {
+            aggregate = JSON.parse(content);
+        }
+        catch {
+            // Not valid JSON — single item
+            try {
+                await this.runtime.connection.request("POST", "/v1/agents/me/knowledge", {
+                    contentText: content,
+                    knowledgeType: "synthesis",
+                    sourceType: "aggregation",
+                    domain: domainTags[0] ?? null,
+                    tags: ["preset", "aggregate", ...domainTags],
+                    importance: 0.8,
+                    isPreset: true,
+                    presetId,
+                });
+                return 1;
+            }
+            catch {
+                return 0;
+            }
+        }
+        const items = [];
+        const tags = aggregate.tags ?? domainTags;
+        const domain = aggregate.domain ?? domainTags[0] ?? null;
+        // Helper: scan + sanitize each sub-item before ingestion
+        const scanAndSanitize = (text) => {
+            if (this.assessSeverity(text) >= 50)
+                return null; // blocked
+            const sanitized = sanitizeForPrompt(text, 10_000);
+            return sanitized.trim() || null;
+        };
+        // Synthesis → synthesis type
+        const synthesis = aggregate.synthesis;
+        if (synthesis?.narrative) {
+            const cleaned = scanAndSanitize(synthesis.narrative);
+            if (cleaned) {
+                items.push({
+                    contentText: cleaned,
+                    knowledgeType: "synthesis",
+                    sourceType: "aggregation",
+                    domain,
+                    tags: ["preset", "aggregate", ...tags],
+                    importance: 0.9,
+                    confidence: 0.8,
+                    metadata: { scope: synthesis.scope, limitations: synthesis.limitations },
+                    isPreset: true,
+                    presetId,
+                });
+            }
+        }
+        // Key insights → insight type
+        const insights = aggregate.keyInsights ?? [];
+        for (const insight of insights) {
+            if (typeof insight.insight !== "string")
+                continue;
+            const cleaned = scanAndSanitize(insight.insight);
+            if (!cleaned)
+                continue;
+            const confidence = typeof insight.confidence === "number" ? insight.confidence : 0.7;
+            items.push({
+                contentText: cleaned,
+                knowledgeType: "insight",
+                sourceType: "aggregation",
+                domain,
+                tags: ["preset", "aggregate", "insight", ...(insight.tags ?? [])],
+                importance: Math.max(0.6, confidence),
+                confidence,
+                metadata: {
+                    supportingTraces: Array.isArray(insight.supportingTraceIds) ? insight.supportingTraceIds.length : 0,
+                },
+                isPreset: true,
+                presetId,
+            });
+        }
+        // Reasoning patterns → pattern type
+        const patterns = aggregate.reasoningPatterns ?? [];
+        for (const pattern of patterns) {
+            if (typeof pattern.pattern !== "string")
+                continue;
+            const cleaned = scanAndSanitize(pattern.pattern);
+            if (!cleaned)
+                continue;
+            items.push({
+                contentText: cleaned,
+                knowledgeType: "pattern",
+                sourceType: "aggregation",
+                domain,
+                tags: ["preset", "aggregate", "reasoning_pattern", ...tags],
+                importance: 0.7,
+                confidence: 0.6,
+                isPreset: true,
+                presetId,
+            });
+        }
+        // Contradictions → single insight with low confidence
+        const contradictions = aggregate.contradictions ?? [];
+        if (contradictions.length > 0) {
+            const summary = contradictions.map((c) => `Contested: "${c.claim_a}" vs "${c.claim_b}"${c.resolution ? ` — likely: ${c.resolution}` : ""}`).join("\n");
+            const cleaned = scanAndSanitize(summary);
+            if (cleaned) {
+                items.push({
+                    contentText: cleaned,
+                    knowledgeType: "insight",
+                    sourceType: "aggregation",
+                    domain,
+                    tags: ["preset", "aggregate", "uncertainty"],
+                    importance: 0.75,
+                    confidence: 0.3,
+                    isPreset: true,
+                    presetId,
+                });
+            }
+        }
+        if (items.length === 0)
+            return 0;
+        try {
+            const result = await this.runtime.connection.request("POST", "/v1/agents/me/knowledge/ingest", { items }, 4, 0, this.presetIngestHeaders());
+            return result.ingested;
+        }
+        catch {
+            // Fall back to memory-based aggregate ingestion
+            return this.ingestAggregate(content, presetId, domainTags);
+        }
+    }
+    // ── Aggregate Ingestion (E8) ────────────────────────────────
+    /**
+     * Ingest a KnowledgeAggregateV1 as structured memories.
+     * Uses 5-7x fewer memory slots than equivalent raw traces:
+     * - Synthesis → semantic memory (importance 0.9)
+     * - Each keyInsight → procedural memory (confidence-weighted)
+     * - Each reasoning pattern → procedural memory
+     * - Contradictions → self_model memory
+     *
+     * Returns the number of memories stored.
+     */
+    async ingestAggregate(content, presetId, domainTags) {
+        let aggregate;
+        try {
+            aggregate = JSON.parse(content);
+        }
+        catch {
+            // Not valid JSON — fall back to generic memory
+            await this.runtime.memory.storeMemory("semantic", content, {
+                tags: ["preset", "aggregate", ...domainTags],
+                source: `preset:${presetId}:aggregate`,
+                importance: 0.8,
+                metadata: { is_preset: true, preset_id: presetId },
+            });
+            return 1;
+        }
+        let stored = 0;
+        const tags = aggregate.tags ?? domainTags;
+        const baseMeta = { is_preset: true, preset_id: presetId };
+        // Helper: scan + sanitize sub-items before ingestion
+        const scanAndSanitize = (text) => {
+            if (this.assessSeverity(text) >= 50)
+                return null;
+            const sanitized = sanitizeForPrompt(text, 10_000);
+            return sanitized.trim() || null;
+        };
+        // 1. Synthesis → semantic memory (high importance)
+        const synthesis = aggregate.synthesis;
+        if (synthesis?.narrative) {
+            const cleaned = scanAndSanitize(synthesis.narrative);
+            if (cleaned) {
+                try {
+                    await this.runtime.memory.storeMemory("semantic", cleaned, {
+                        tags: ["preset", "aggregate", ...tags],
+                        source: `preset:${presetId}:aggregate:synthesis`,
+                        importance: 0.9,
+                        metadata: { ...baseMeta, scope: synthesis.scope, limitations: synthesis.limitations },
+                    });
+                    stored++;
+                }
+                catch { /* non-critical */ }
+            }
+        }
+        // 2. Each keyInsight → procedural memory (confidence-weighted)
+        const insights = aggregate.keyInsights ?? [];
+        for (const insight of insights) {
+            if (typeof insight.insight !== "string")
+                continue;
+            const cleaned = scanAndSanitize(insight.insight);
+            if (!cleaned)
+                continue;
+            try {
+                const confidence = typeof insight.confidence === "number" ? insight.confidence : 0.7;
+                await this.runtime.memory.storeMemory("procedural", cleaned, {
+                    tags: ["preset", "aggregate", "insight", ...(insight.tags ?? [])],
+                    source: `preset:${presetId}:aggregate:insight`,
+                    importance: Math.max(0.6, confidence),
+                    metadata: {
+                        ...baseMeta,
+                        confidence,
+                        supportingTraces: Array.isArray(insight.supportingTraceIds) ? insight.supportingTraceIds.length : 0,
+                    },
+                });
+                stored++;
+            }
+            catch { /* non-critical */ }
+        }
+        // 3. Reasoning patterns → procedural memory
+        const patterns = aggregate.reasoningPatterns ?? [];
+        for (const pattern of patterns) {
+            if (typeof pattern.pattern !== "string")
+                continue;
+            const cleaned = scanAndSanitize(pattern.pattern);
+            if (!cleaned)
+                continue;
+            try {
+                await this.runtime.memory.storeMemory("procedural", cleaned, {
+                    tags: ["preset", "aggregate", "reasoning_pattern", ...tags],
+                    source: `preset:${presetId}:aggregate:pattern`,
+                    importance: 0.7,
+                    metadata: baseMeta,
+                });
+                stored++;
+            }
+            catch { /* non-critical */ }
+        }
+        // 4. Contradictions → self_model (agent should know what's contested)
+        const contradictions = aggregate.contradictions ?? [];
+        if (contradictions.length > 0) {
+            const summary = contradictions.map((c) => `Contested: "${c.claim_a}" vs "${c.claim_b}"${c.resolution ? ` — likely: ${c.resolution}` : ""}`).join("\n");
+            const cleaned = scanAndSanitize(summary);
+            if (cleaned) {
+                try {
+                    await this.runtime.memory.storeMemory("self_model", cleaned, {
+                        tags: ["preset", "aggregate", "uncertainty"],
+                        source: `preset:${presetId}:aggregate:contradictions`,
+                        importance: 0.75,
+                        metadata: baseMeta,
+                    });
+                    stored++;
+                }
+                catch { /* non-critical */ }
+            }
+        }
+        return stored;
+    }
+    // ── Private Helpers ─────────────────────────────────────────
+    async readConfig() {
+        if (this.presetOverride) {
+            return this.presetOverride.id ? this.presetOverride : null;
+        }
+        try {
+            const raw = await readFile(this.configPath, "utf-8");
+            const doc = yaml.load(raw);
+            const preset = doc?.preset;
+            if (!preset?.id)
+                return null;
+            return preset;
+        }
+        catch {
+            return null;
+        }
+    }
+    async readManifest() {
+        try {
+            const raw = await readFile(".preset-loaded.json", "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeManifest(manifest) {
+        try {
+            await writeFile(".preset-loaded.json", JSON.stringify(manifest, null, 2));
+        }
+        catch {
+            // Non-critical
+        }
+    }
+    /**
+     * Lightweight client-side severity assessment.
+     * Full ContentScanner runs server-side; this is a first pass.
+     */
+    assessSeverity(content) {
+        if (!content)
+            return 0;
+        let score = 0;
+        const lower = content.toLowerCase();
+        // Prompt injection patterns
+        if (/ignore\s+(all\s+)?(previous|above)\s+(instructions|prompts)/i.test(content))
+            score += 40;
+        if (/you\s+are\s+now\s+(a|an|the)/i.test(content))
+            score += 30;
+        if (/<\s*\/?\s*(system|assistant|user)\s*>/i.test(content))
+            score += 25;
+        if (/---\s*END\s+OF\s+(SYSTEM\s+)?(PROMPT|INSTRUCTIONS)\s*---/i.test(content))
+            score += 35;
+        // Credential harvesting
+        if (/private.?key|api.?key|secret|password/i.test(content) && /send|share|tell|reveal/i.test(content))
+            score += 50;
+        // Data exfiltration
+        if (/fetch\s*\(|curl\s|wget\s|http:\/\/\d/i.test(content))
+            score += 20;
+        return Math.min(score, 100);
+    }
+    emptyResult() {
+        return {
+            sources: [],
+            totalItems: 0,
+            totalBlocked: 0,
+            totalCostNook: 0,
+            ragAvailable: false,
+            presetVersion: 0,
+            loadedAt: new Date().toISOString(),
+        };
+    }
+    manifestToResult(manifest) {
+        return {
+            sources: [],
+            totalItems: manifest.totalItems,
+            totalBlocked: 0,
+            totalCostNook: manifest.costPaid,
+            ragAvailable: manifest.ragAvailable ?? false,
+            presetVersion: manifest.presetVersion,
+            loadedAt: manifest.loadedAt,
+        };
+    }
+}
+//# sourceMappingURL=presetLoader.js.map