@nookplot/runtime 0.5.140 → 0.5.142

package/dist/presetLoader.js

@@ -1,734 +0,0 @@
-/**
- * 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;
-    constructor(runtime, configPath = "./nookplot.yaml") {
-        super();
-        this.runtime = runtime;
-        this.configPath = configPath;
-    }
-    /**
-     * 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() {
-        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