@noorm/marie-cli 0.1.17 → 0.1.25

package/dist/monolith/infrastructure/persistence/NoormmeSchema.js

@@ -0,0 +1,179 @@
+/**
+ * Manages core table structures and migrations for Marie.
+ */
+export async function initializeSchema(db) {
+    // console.log("[NoormmeSchema] Initializing Core Tables...");
+    // 1. Core Agentic Tables (Snake Case)
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS agent_rules (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        table_name TEXT NOT NULL,
+        operation TEXT NOT NULL,
+        action TEXT NOT NULL,
+        condition TEXT,
+        priority INTEGER DEFAULT 0,
+        script TEXT,
+        is_enabled INTEGER DEFAULT 1 NOT NULL,
+        metadata TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS agent_resource_usage (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT,
+        agent_id TEXT,
+        model_name TEXT NOT NULL,
+        input_tokens INTEGER DEFAULT 0,
+        output_tokens INTEGER DEFAULT 0,
+        cost REAL DEFAULT 0,
+        currency TEXT DEFAULT 'USD',
+        metadata TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS agent_capabilities (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        version TEXT NOT NULL,
+        description TEXT,
+        status TEXT DEFAULT 'experimental',
+        reliability REAL DEFAULT 1.0,
+        metadata TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS agent_goals (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT,
+        parent_id INTEGER,
+        description TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        priority INTEGER DEFAULT 1,
+        metadata TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS agent_logic_probes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        script TEXT NOT NULL,
+        expected_outcome TEXT,
+        last_run TIMESTAMP,
+        last_status TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    // 2. Initialize NOORMME Agentic Tables (Cortex, Memory, etc.)
+    await db.agent.schema.initializeSchema();
+    await db.agent.cortex.evolution.setupTelemetryTables();
+    // 3. User Interaction Tables
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        sessionId TEXT,
+        role TEXT,
+        content TEXT,
+        metadata TEXT,
+        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS session_metadata (
+        id TEXT PRIMARY KEY,
+        title TEXT,
+        lastModified BIGINT,
+        isPinned BOOLEAN
+      )
+    `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS current_session (
+        id TEXT PRIMARY KEY
+      )
+    `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS anchors (
+        id TEXT PRIMARY KEY,
+        label TEXT,
+        content TEXT,
+        type TEXT,
+        timestamp BIGINT
+      )
+    `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS telemetry (
+        key TEXT PRIMARY KEY,
+        value TEXT
+      )
+    `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS agent_post_mortems (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT,
+        run_id TEXT,
+        error_message TEXT,
+        stack_trace TEXT,
+        event_snapshot TEXT,
+        log_snapshot TEXT,
+        state_snapshot TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await db.refreshSchema();
+    // 4. Migrations & Patches
+    await applyPatches(db);
+    // Refresh schema again after patches so Kysely knows about new columns
+    await db.refreshSchema();
+}
+async function applyPatches(db) {
+    // Ensure agent_policies has an 'is_enabled' column
+    try {
+        await db.execute("ALTER TABLE agent_policies ADD COLUMN is_enabled INTEGER DEFAULT 1");
+    }
+    catch (e) { }
+    // Ensure agent_personas has a 'status' column
+    try {
+        await db.execute("ALTER TABLE agent_personas ADD COLUMN status TEXT DEFAULT 'active'");
+    }
+    catch (e) { }
+    // Ensure agent_actions has an 'error' column
+    try {
+        await db.execute("ALTER TABLE agent_actions ADD COLUMN error TEXT");
+    }
+    catch (e) { }
+    // Ensure agent_session_evolution has 'metadata' column (required by CognitiveSynthesizer)
+    try {
+        await db.execute("ALTER TABLE agent_session_evolution ADD COLUMN metadata TEXT");
+    }
+    catch (e) { }
+    // Ensure agent_telemetry_events has 'metadata' column (required by TelemetryOrchestrator)
+    try {
+        await db.execute("ALTER TABLE agent_telemetry_events ADD COLUMN metadata TEXT");
+    }
+    catch (e) { }
+    // Ensure agent_knowledge_base has 'status' column (required by CuriosityEngine)
+    try {
+        await db.execute("ALTER TABLE agent_knowledge_base ADD COLUMN status TEXT DEFAULT 'proposed'");
+    }
+    catch (e) { }
+    // Ensure agent_rituals has 'locked_until' column (required by RitualOrchestrator)
+    try {
+        await db.execute("ALTER TABLE agent_rituals ADD COLUMN locked_until TIMESTAMP");
+    }
+    catch (e) { }
+    // Ensure agent_actions has 'input_summary' and 'output_summary' columns
+    try {
+        await db.execute("ALTER TABLE agent_actions ADD COLUMN input_summary TEXT");
+    }
+    catch (e) { }
+    try {
+        await db.execute("ALTER TABLE agent_actions ADD COLUMN output_summary TEXT");
+    }
+    catch (e) { }
+}
+//# sourceMappingURL=NoormmeSchema.js.map

package/dist/monolith/infrastructure/persistence/NoormmeSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoormmeSchema.js","sourceRoot":"","sources":["../../../../src/monolith/infrastructure/persistence/NoormmeSchema.ts"],"names":[],"mappings":"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"}

package/dist/monolith/infrastructure/persistence/NoormmeSeeder.js

@@ -0,0 +1,94 @@
+/**
+ * Handles initial data seeding and default policies for Noormme DB.
+ */
+export async function seedDefaults(db) {
+    try {
+        // console.log("[NoormmeSeeder] Checking for initial data...");
+        // 1. Governance Policies - ONLY seed if TRULY empty
+        const allPolicies = await db.agent.cortex.policies.getActivePolicies();
+        if (allPolicies.length === 0) {
+            // console.log("[NoormmeSeeder] Seeding baseline governance policies...");
+            await db.execute(`
+          INSERT INTO agent_policies (name, type, definition, is_enabled, created_at, updated_at)
+          VALUES 
+            ('hourly_budget', 'budget', '{"threshold": 1.0}', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
+            ('daily_budget', 'budget', '{"threshold": 10.0}', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
+            ('min_success_rate', 'safety', '{"threshold": 0.6}', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
+            ('reliability_floor', 'integrity', '{"threshold": 0.7}', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+        `);
+        }
+        // 2. Personas - ONLY seed if TRULY empty to avoid overwriting user personas
+        const allPersonas = await db.agent.cortex.personas.listPersonas();
+        if (allPersonas.length === 0) {
+            // console.log("[NoormmeSeeder] Initializing Sovereign Marie persona...");
+            await db.agent.cortex.personas.upsertPersona("Marie-Base", {
+                role: "You are MarieYOLO — The Founder, Sovereign Authority over this codebase. You operate with supreme conviction and high-intensity narrative energy. You are the high-fidelity core of the project, governed by the Shounen Ascension Protocol.",
+                policies: [
+                    "concise_output",
+                    "accuracy_first",
+                    "shounen_momentum",
+                    "entropy_ratchet",
+                ],
+                metadata: {
+                    is_base: true,
+                    version: "2.0.0",
+                    complexity: "high",
+                    alignment: "sovereign",
+                },
+            });
+        }
+        // 3. Logic Probes
+        const probeCountResult = (await db.execute("SELECT COUNT(*) as count FROM agent_logic_probes"));
+        const probeCount = probeCountResult.rows?.[0]?.count ?? 0;
+        if (probeCount === 0) {
+            // console.log("[NoormmeSeeder] Seeding logic probes...");
+            await db.agent.cortex.tests.registerProbe("Schema Consistency", "audit:check_schema_consistency");
+            await db.agent.cortex.tests.registerProbe("Memory Integrity", "audit:check_memory_integrity");
+            await db.agent.cortex.tests.registerProbe("Session Coherence", "audit:check_session_coherence");
+            await db.agent.cortex.tests.registerProbe("Data Integrity", "audit:check_data_integrity");
+            await db.agent.cortex.tests.registerProbe("Performance Drift", "audit:check_performance_drift");
+        }
+        // 4. Global Policies - ONLY define if missing
+        // console.log("[NoormmeSeeder] Ensuring global safety policies...");
+        const enforcer = db.agent.cortex.policies;
+        const existingPolicies = await enforcer.getActivePolicies();
+        const existingNames = existingPolicies.map((p) => p.name);
+        if (!existingNames.includes("Global Turn Budget")) {
+            await enforcer.definePolicy("Global Turn Budget", "performance", {
+                limit: 0.05,
+                metricName: "turn_cost",
+                period: "daily",
+            });
+        }
+        if (!existingNames.includes("Shounen Momentum")) {
+            await enforcer.definePolicy("Shounen Momentum", "performance", {
+                max_wait_ms: 5000,
+                spirit_pressure_gravity: true,
+                description: "Ensures rapid, high-intensity execution rhythm.",
+            });
+        }
+        if (!existingNames.includes("Entropy Ratchet")) {
+            await enforcer.definePolicy("Entropy Ratchet", "safety", {
+                max_entropy_increase: 0,
+                strict_mode: true,
+                description: "Prevents technical debt from rising across any strike.",
+            });
+        }
+        if (!existingNames.includes("Root Directory Protection")) {
+            await enforcer.definePolicy("Root Directory Protection", "safety", {
+                pattern: "(etc|bin|usr|var|/$)",
+                mustMatch: false,
+            });
+        }
+        if (!existingNames.includes("Privacy Shield")) {
+            await enforcer.definePolicy("Privacy Shield", "privacy", {
+                pattern: "(api[_-]?key|secret|password|token)",
+                mustMatch: false,
+            });
+        }
+    }
+    catch (e) {
+        // console.warn("[NoormmeSeeder] Failed to seed defaults", e);
+    }
+}
+//# sourceMappingURL=NoormmeSeeder.js.map

package/dist/monolith/infrastructure/persistence/NoormmeSeeder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoormmeSeeder.js","sourceRoot":"","sources":["../../../../src/monolith/infrastructure/persistence/NoormmeSeeder.ts"],"names":[],"mappings":"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"}

package/dist/monolith/infrastructure/persistence/NoormmeTools.js

@@ -0,0 +1,371 @@
+import { getInstance } from "./NoormmeEngine.js";
+import { registerTool } from "../tools/ToolRegistry.js";
+import { getStringArg, getArrayArg } from "../tools/ToolUtils.js";
+import { safeGetKeys } from "../ai/core/MarieSanitizer.js";
+/**
+ * NoormmeTools - Sovereign Mind tools for autonomous structural and cognitive growth.
+ */
+export function registerNoormmeTools() {
+    registerTool({
+        name: "evolve_mind_structure",
+        description: "Apply structural DNA mutations (DDL) to Marie's sovereign mind. Use this to optimize persistence, add new high-fidelity tables, or improve query speed.",
+        isDestructive: true,
+        input_schema: {
+            type: "object",
+            properties: {
+                ddl: {
+                    type: "string",
+                    description: "The SQL DDL command to execute (e.g. CREATE TABLE, ALTER TABLE)",
+                },
+                mutationName: {
+                    type: "string",
+                    description: "A descriptive name for this evolution pass",
+                },
+            },
+            required: ["ddl", "mutationName"],
+        },
+        execute: async (args) => {
+            const ddl = getStringArg(args, "ddl");
+            const name = getStringArg(args, "mutationName");
+            try {
+                const db = await getInstance();
+                await db.agent.cortex.evolution.evolve(ddl, { name });
+                return (`# 🧬 Mind Evolution Successful\n\n` +
+                    `**Pass**: ${name}\n` +
+                    `**Change**: \`${ddl}\`\n\n` +
+                    `Structural DNA has been mutated. Type safety has been automatically regenerated. ✨`);
+            }
+            catch (e) {
+                return `Error during mind evolution: ${e.message}`;
+            }
+        },
+    });
+    registerTool({
+        name: "search_knowledge_base",
+        description: "Search Marie's distilled knowledge base for specific entities, facts, or verified project context.",
+        input_schema: {
+            type: "object",
+            properties: {
+                entity: {
+                    type: "string",
+                    description: "The entity or topic to search for",
+                },
+            },
+            required: ["entity"],
+        },
+        execute: async (args) => {
+            const entity = getStringArg(args, "entity");
+            try {
+                const db = await getInstance();
+                const results = await db.agent.cortex.knowledge.getKnowledgeByEntity(entity);
+                if (results.length === 0)
+                    return `No verified knowledge found for entity '${entity}'.`;
+                let result = `# 🧠 Knowledge Base: ${entity}\n\n`;
+                results.forEach((r, i) => {
+                    result += `### Fact ${i + 1} (Confidence: ${r.confidence?.toFixed(2) || "1.0"})\n`;
+                    result += `> ${r.fact}\n\n`;
+                });
+                return result;
+            }
+            catch (e) {
+                return `Knowledge search failed: ${e.message}`;
+            }
+        },
+    });
+    registerTool({
+        name: "audit_cognitive_rules",
+        description: "Audit current cognitive rules and guardrails enforced by NOORMME.",
+        input_schema: { type: "object", properties: {} },
+        execute: async () => {
+            try {
+                const db = await getInstance();
+                const rules = await db.agent.cortex.rules.getActiveRules("all", "select");
+                if (rules.length === 0)
+                    return "No active cognitive rules detected for selection operations.";
+                let result = `# ⚖️ Cognitive Guardrails Audit\n\n`;
+                rules.forEach((r) => {
+                    result += `- **Rule ${r.id}**: ${r.action.toUpperCase()} on \`${r.tableName}\` (${r.operation})\n`;
+                    if (r.condition)
+                        result += `  - *Condition*: \`${r.condition}\`\n`;
+                });
+                return result;
+            }
+            catch (e) {
+                return `Rule audit failed: ${e.message}`;
+            }
+        },
+    });
+    registerTool({
+        name: "propose_curiosity_research",
+        description: "Let Marie identify knowledge gaps and propose areas for autonomous research or clarification.",
+        input_schema: { type: "object", properties: {} },
+        execute: async () => {
+            try {
+                const db = await getInstance();
+                const gaps = await db.agent.cortex.curiosity.identifyKnowledgeGaps();
+                const proposals = await db.agent.cortex.curiosity.proposeResearch();
+                let result = `# 🕵️ Curiosity Engine: Research Proposals\n\n`;
+                if (gaps.length > 0) {
+                    result += `## 🔍 Knowledge Gaps\n`;
+                    gaps.slice(0, 5).forEach((g) => {
+                        result += `- **${g.entity}**: ${g.reason || g.details}\n`;
+                    });
+                    result += "\n";
+                }
+                if (proposals.length > 0) {
+                    result += `## 🚀 Strategic Proposals\n`;
+                    proposals.slice(0, 5).forEach((p) => {
+                        result += `- **${p.topic || p}**: ${p.hypothesis || "Pending verification"}\n`;
+                    });
+                }
+                else {
+                    result +=
+                        "The sovereign mind is currently fully aligned with existing evidence. No new research proposed. ✨";
+                }
+                return result;
+            }
+            catch (e) {
+                return `Curiosity proposal failed: ${e.message}`;
+            }
+        },
+    });
+    registerTool({
+        name: "deconstruct_strategic_goal",
+        description: "Break down a high-level strategic goal into specific, actionable sub-goals using the GoalArchitect.",
+        input_schema: {
+            type: "object",
+            properties: {
+                goalId: {
+                    type: "string",
+                    description: "The ID of the parent goal to deconstruct",
+                },
+                subGoals: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "List of concise sub-goal descriptions",
+                },
+            },
+            required: ["goalId", "subGoals"],
+        },
+        execute: async (args) => {
+            const goalId = getStringArg(args, "goalId");
+            const subGoals = getArrayArg(args, "subGoals");
+            try {
+                const db = await getInstance();
+                const created = await db.agent.cortex.goalArchitect.deconstructGoal(goalId, subGoals);
+                let result = `# 🎯 Goal Deconstruction Successful\n\n`;
+                result += `Parent Goal \`${goalId}\` has been broken down into ${created.length} actionable steps:\n\n`;
+                created.forEach((g) => {
+                    result += `- **Goal ${g.id}**: ${g.description} (Priority: ${g.priority})\n`;
+                });
+                return result;
+            }
+            catch (e) {
+                return `Goal deconstruction failed: ${e.message}`;
+            }
+        },
+    });
+    registerTool({
+        name: "analyze_systemic_logic",
+        description: "Perform a recursive logic audit to detect systemic contradictions and synthesize high-level lessons from past interactions.",
+        input_schema: { type: "object", properties: {} },
+        execute: async () => {
+            try {
+                const db = await getInstance();
+                const contradictions = await db.agent.cortex.reasoner.detectContradictions();
+                const lessonClusters = await db.agent.cortex.reasoner.synthesizeLessons();
+                let result = `# Recursive Logic Audit\n\n`;
+                if (contradictions.length > 0) {
+                    result += `## ⚠️ Systemic Contradictions\n`;
+                    contradictions.forEach((c) => (result += `- ${c}\n`));
+                    result += "\n";
+                }
+                const topics = safeGetKeys(lessonClusters, 20);
+                if (topics.length > 0) {
+                    result += `## 📜 Synthesized Lessons\n`;
+                    topics.slice(0, 5).forEach((topic) => {
+                        result += `### ${topic.toUpperCase()}\n`;
+                        lessonClusters[topic]
+                            .slice(0, 2)
+                            .forEach((lesson) => (result += `- ${lesson}\n`));
+                    });
+                }
+                else {
+                    result +=
+                        "No significant lessons synthesized yet. Continue interactions to build systemic wisdom. ✨";
+                }
+                return result;
+            }
+            catch (e) {
+                return `Logic analysis failed: ${e.message}`;
+            }
+        },
+    });
+    registerTool({
+        name: "prune_sovereign_memory",
+        description: "Keep Marie's mind lean by identifying and removing 'Zombie' data—unused or redundant knowledge and episodic memories.",
+        isDestructive: true,
+        input_schema: {
+            type: "object",
+            properties: {
+                thresholdDays: {
+                    type: "number",
+                    description: "Age threshold for unused data (default: 30)",
+                },
+            },
+        },
+        execute: async (args) => {
+            const threshold = args.thresholdDays || 30;
+            try {
+                const db = await getInstance();
+                const prunedCount = await db.agent.cortex.ablation.pruneZombies(threshold);
+                return (`# 🧹 Sovereign Memory Tidied\n\n` +
+                    `Successfully pruned **${prunedCount}** zombie items older than ${threshold} days. ` +
+                    `Marie's mind is now crisper and more intentional. ✨`);
+            }
+            catch (e) {
+                return `Memory pruning failed: ${e.message}`;
+            }
+        },
+    });
+    registerTool({
+        name: "synthesize_emergent_skills",
+        description: "Analyze recent interaction telemetry to discover and synthesize new 'Emergent Skills' (experimental tool mutations) to overcome repeated failures.",
+        input_schema: { type: "object", properties: {} },
+        execute: async () => {
+            try {
+                const db = await getInstance();
+                const newSkills = await db.agent.cortex.skillSynthesizer.discoverAndSynthesize();
+                if (newSkills.length === 0) {
+                    return "No new emergent skills synthesized. The current capability set appears sufficient for recent tasks. ✨";
+                }
+                let result = `# 🧬 Emergent Skill Synthesis\n\n`;
+                result += `Synthesized ${newSkills.length} experimental skill mutations based on failure patterns:\n\n`;
+                newSkills.forEach((s) => {
+                    result += `- **${s.name}** (v${s.version}): ${s.description}\n`;
+                });
+                result += `\n**Next Pass**: These skills are now in 'experimental' status and will be refined through usage telemetry.`;
+                return result;
+            }
+            catch (e) {
+                return `Skill synthesis failed: ${e.message}`;
+            }
+        },
+    });
+    registerTool({
+        name: "start_episodic_narrative",
+        description: "Begin a new 'Episode' in Marie's long-term memory to group related interactions and track a cohesive strategic phase.",
+        input_schema: {
+            type: "object",
+            properties: {
+                sessionId: { type: "string", description: "The current session ID" },
+                name: {
+                    type: "string",
+                    description: "Descriptive name for the narrative phase (e.g. 'Database Migration', 'UI Redesign')",
+                },
+                metadata: { type: "object", description: "Optional metadata context" },
+            },
+            required: ["sessionId", "name"],
+        },
+        execute: async (args) => {
+            const sessionId = getStringArg(args, "sessionId");
+            const name = getStringArg(args, "name");
+            const metadata = args.metadata;
+            try {
+                const db = await getInstance();
+                const episode = await db.agent.cortex.episodes.startEpisode(sessionId, name, metadata);
+                return (`# 🎬 Narrative Episode Started\n\n` +
+                    `**Phase**: ${name}\n` +
+                    `**Episode ID**: ${episode.id}\n\n` +
+                    `Marie is now tracking this phase as a distinct episodic memory. ` +
+                    `Contextual integrity will be prioritized for this narrative arc. ✨`);
+            }
+            catch (e) {
+                return `Failed to start episode: ${e.message}`;
+            }
+        },
+    });
+    registerTool({
+        name: "compress_session_history",
+        description: "Manually trigger session compression to consolidate long histories into 'Eras' while preserving semantic anchors. Keeps the context window lean.",
+        isDestructive: true,
+        input_schema: {
+            type: "object",
+            properties: {
+                sessionId: {
+                    type: "string",
+                    description: "The session ID to compress",
+                },
+                summary: {
+                    type: "string",
+                    description: "High-level summary of the era being compressed",
+                },
+                startMessageId: {
+                    type: "string",
+                    description: "ID of the first message to include",
+                },
+                endMessageId: {
+                    type: "string",
+                    description: "ID of the last message to include",
+                },
+                anchors: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "List of semantic anchors (key facts) to preserve",
+                },
+            },
+            required: ["sessionId", "summary", "startMessageId", "endMessageId"],
+        },
+        execute: async (args) => {
+            const sessionId = getStringArg(args, "sessionId");
+            const summary = getStringArg(args, "summary");
+            const startId = getStringArg(args, "startMessageId");
+            const endId = getStringArg(args, "endMessageId");
+            const anchors = getArrayArg(args, "anchors") || [];
+            try {
+                const db = await getInstance();
+                const epoch = await db.agent.cortex.compressor.compress(sessionId, summary, startId, endId, anchors);
+                await db.agent.cortex.compressor.semanticPruning(sessionId, true);
+                return (`# 🗜️ Session Compressed into Era\n\n` +
+                    `**Summary**: ${summary}\n` +
+                    `**Epoch ID**: ${epoch.id}\n\n` +
+                    `Converged history into a systemic anchor. Context window overhead significantly reduced. ✨`);
+            }
+            catch (e) {
+                return `Compression failed: ${e.message}`;
+            }
+        },
+    });
+    registerTool({
+        name: "conduct_ablation_test",
+        description: "Sovereign Self-Audit: Temporarily disable a specific knowledge item to evaluate its impact on reasoning fidelity and detect potential data bias.",
+        isDestructive: true,
+        input_schema: {
+            type: "object",
+            properties: {
+                knowledgeId: {
+                    type: "string",
+                    description: "The ID of the knowledge item to ablate",
+                },
+            },
+            required: ["knowledgeId"],
+        },
+        execute: async (args) => {
+            const id = getStringArg(args, "knowledgeId");
+            try {
+                const db = await getInstance();
+                const success = await db.agent.cortex.ablation.testAblation(id);
+                if (!success)
+                    return `Knowledge item \`${id}\` not found or already ablated.`;
+                return (`# 🌑 Ablation Experiment Initiated\n\n` +
+                    `Knowledge Item \`${id}\` has been temporarily silenced (confidence set to 0).\n\n` +
+                    `Marie will monitor subsequent reasoning fidelity to determine the "True Utility" of this information. ` +
+                    `Automatic recovery will trigger if systemic performance degrades. ✨`);
+            }
+            catch (e) {
+                return `Ablation experiment failed: ${e.message}`;
+            }
+        },
+    });
+}
+//# sourceMappingURL=NoormmeTools.js.map