@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/intelligence/temporal-facts.js

@@ -1,494 +0,0 @@
-/**
- * Temporal Fact Store — CozoDB-backed project knowledge with decay model.
- *
- * Layer 9 core: stores facts (conventions, decisions, anti-patterns) that
- * persist across sessions. Each fact decays over time unless reinforced.
- *
- * Decay formula (computed inline in Datalog at read time):
- *   effective_confidence = base_confidence * recency_factor * evidence_factor
- *   recency_factor = e^(-lambda * days_since_last_reinforcement)
- *   evidence_factor = min(1.0, reinforcement_count / 3.0)
- *
- * Decay rates (lambda) per fact type:
- *   procedural: 0.10 (fast — "how to" instructions go stale)
- *   semantic:   0.05 (medium — architectural knowledge)
- *   negative:   0.02 (slow — anti-patterns remain relevant)
- *   convention: 0.02 (slow — project standards persist like anti-patterns)
- *   episodic:   0.00 (never — immutable history)
- */
-import { randomUUID } from "node:crypto";
-import { initFactsSchema, openFactsDb } from "./facts-schema.js";
-const DEFAULT_CONFIG = {
-    decay_rates: {
-        procedural: 0.1,
-        semantic: 0.05,
-        negative: 0.02,
-        episodic: 0.0,
-        convention: 0.02,
-    },
-    recall_threshold: 0.2,
-    max_facts_per_response: 5,
-    prune_threshold: 0.05,
-};
-const DEFAULT_CONFIDENCE = {
-    agent_explicit: 0.95,
-    negative_knowledge: 0.9,
-    causal_bridge: 1.0,
-    convention_detector: 0.75,
-    session_analysis: 0.6,
-};
-const MAX_CONTENT_LENGTH = 500;
-/** Type-specific content limits — episodic needs space for what/why/how narratives. */
-const TYPE_CONTENT_LIMITS = {
-    convention: 600,
-    semantic: 500,
-    episodic: 800,
-    procedural: 400,
-    negative: 400,
-};
-// ── TemporalFactStore ────────────────────────────────────────────────
-export class TemporalFactStore {
-    db;
-    config;
-    constructor(db, config) {
-        this.db = db;
-        this.config = config;
-    }
-    /**
-     * Expose the underlying facts.db handle so cohabiting stores (e.g.
-     * SignalShowStore for rotation persistence) can share the connection
-     * instead of opening a second SQLite handle to the same file.
-     */
-    getDb() {
-        return this.db;
-    }
-    /**
-     * Create and initialize a TemporalFactStore from a project root path.
-     * Opens facts.db (creating if needed) and ensures schema is current.
-     */
-    static async create(projectRoot, config) {
-        const { db } = await openFactsDb(projectRoot);
-        await initFactsSchema(db);
-        const mergedConfig = { ...DEFAULT_CONFIG, ...config };
-        if (config?.decay_rates) {
-            mergedConfig.decay_rates = {
-                ...DEFAULT_CONFIG.decay_rates,
-                ...config.decay_rates,
-            };
-        }
-        return new TemporalFactStore(db, mergedConfig);
-    }
-    /**
-     * Create a TemporalFactStore from an already-opened CozoDB instance.
-     * Used when the caller manages the database lifecycle.
-     */
-    static fromDb(db, config) {
-        const mergedConfig = { ...DEFAULT_CONFIG, ...config };
-        if (config?.decay_rates) {
-            mergedConfig.decay_rates = {
-                ...DEFAULT_CONFIG.decay_rates,
-                ...config.decay_rates,
-            };
-        }
-        return new TemporalFactStore(db, mergedConfig);
-    }
-    // ── Write Operations ─────────────────────────────────────────────
-    /**
-     * Create a new fact or reinforce an existing one with matching (fact_type, scope, subject).
-     * Returns the fact_id (new or existing).
-     */
-    async createFact(input) {
-        const limit = TYPE_CONTENT_LIMITS[input.fact_type] ?? MAX_CONTENT_LENGTH;
-        const content = input.content.slice(0, limit);
-        const now = Date.now();
-        const existing = await this.findDuplicate(input.fact_type, input.scope, input.subject);
-        if (existing) {
-            await this.reinforceFact(existing, {
-                session_id: "auto-dedup",
-                action: "reinforced",
-                timestamp: now,
-            });
-            return existing;
-        }
-        const factId = randomUUID();
-        const baseConfidence = input.base_confidence ?? DEFAULT_CONFIDENCE[input.source] ?? 0.8;
-        const evidence = [
-            { session_id: "initial", action: "created", timestamp: now },
-        ];
-        await this.db.run(`
-      ?[fact_id, fact_type, scope, subject, content, base_confidence,
-        reinforcement_count, created_at, last_reinforced_at,
-        last_contradicted_at, source, evidence] <- [[
-        $fact_id, $fact_type, $scope, $subject, $content, $base_confidence,
-        1, $now, $now, 0.0, $source, $evidence
-      ]]
-      :put facts {
-        fact_id => fact_type, scope, subject, content, base_confidence,
-        reinforcement_count, created_at, last_reinforced_at,
-        last_contradicted_at, source, evidence
-      }
-      `, {
-            fact_id: factId,
-            fact_type: input.fact_type,
-            scope: input.scope,
-            subject: input.subject,
-            content,
-            base_confidence: baseConfidence,
-            now,
-            source: input.source,
-            evidence: JSON.stringify(evidence),
-        });
-        return factId;
-    }
-    /**
-     * Reinforce an existing fact — increases reinforcement_count, updates timestamp.
-     */
-    async reinforceFact(factId, evidence) {
-        const rows = await this.getRawFact(factId);
-        if (!rows)
-            return;
-        const existingEvidence = JSON.parse(rows.evidence);
-        existingEvidence.push(evidence);
-        const trimmedEvidence = existingEvidence.slice(-20);
-        await this.db.run(`
-      ?[fact_id, fact_type, scope, subject, content, base_confidence,
-        reinforcement_count, created_at, last_reinforced_at,
-        last_contradicted_at, source, evidence] <- [[
-        $fact_id, $fact_type, $scope, $subject, $content, $base_confidence,
-        $reinforcement_count, $created_at, $now, $last_contradicted_at,
-        $source, $evidence
-      ]]
-      :put facts {
-        fact_id => fact_type, scope, subject, content, base_confidence,
-        reinforcement_count, created_at, last_reinforced_at,
-        last_contradicted_at, source, evidence
-      }
-      `, {
-            fact_id: factId,
-            fact_type: rows.fact_type,
-            scope: rows.scope,
-            subject: rows.subject,
-            content: rows.content,
-            base_confidence: rows.base_confidence,
-            reinforcement_count: rows.reinforcement_count + 1,
-            created_at: rows.created_at,
-            now: Date.now(),
-            last_contradicted_at: rows.last_contradicted_at,
-            source: rows.source,
-            evidence: JSON.stringify(trimmedEvidence),
-        });
-    }
-    /**
-     * Contradict a fact — halves its confidence.
-     */
-    async contradictFact(factId, reason) {
-        const rows = await this.getRawFact(factId);
-        if (!rows)
-            return;
-        const now = Date.now();
-        const existingEvidence = JSON.parse(rows.evidence);
-        existingEvidence.push({
-            session_id: "contradiction",
-            action: "contradicted",
-            timestamp: now,
-        });
-        await this.db.run(`
-      ?[fact_id, fact_type, scope, subject, content, base_confidence,
-        reinforcement_count, created_at, last_reinforced_at,
-        last_contradicted_at, source, evidence] <- [[
-        $fact_id, $fact_type, $scope, $subject, $content, $base_confidence,
-        $reinforcement_count, $created_at, $last_reinforced_at, $now,
-        $source, $evidence
-      ]]
-      :put facts {
-        fact_id => fact_type, scope, subject, content, base_confidence,
-        reinforcement_count, created_at, last_reinforced_at,
-        last_contradicted_at, source, evidence
-      }
-      `, {
-            fact_id: factId,
-            fact_type: rows.fact_type,
-            scope: rows.scope,
-            subject: rows.subject,
-            content: rows.content,
-            base_confidence: rows.base_confidence * 0.5,
-            reinforcement_count: rows.reinforcement_count,
-            created_at: rows.created_at,
-            last_reinforced_at: rows.last_reinforced_at,
-            now,
-            source: rows.source,
-            evidence: JSON.stringify(existingEvidence.slice(-20)),
-        });
-    }
-    // ── Read Operations (with inline decay computation) ──────────────
-    /**
-     * Recall facts by scope with decay-adjusted confidence filtering.
-     */
-    async recallByScope(scope, minConfidence) {
-        return this.runDecayQuery(`*facts{fact_id, fact_type, scope, subject, content,
-              base_confidence, reinforcement_count, created_at,
-              last_reinforced_at, last_contradicted_at, source, evidence},
-        scope == $filter_scope`, { filter_scope: scope }, minConfidence);
-    }
-    /**
-     * Recall facts by subject (entity key or topic).
-     */
-    async recallBySubject(subject, minConfidence) {
-        return this.runDecayQuery(`*facts{fact_id, fact_type, scope, subject, content,
-              base_confidence, reinforcement_count, created_at,
-              last_reinforced_at, last_contradicted_at, source, evidence},
-        subject == $filter_subject`, { filter_subject: subject }, minConfidence);
-    }
-    /**
-     * Recall all negative facts (anti-patterns) — always relevant regardless of scope.
-     */
-    async recallNegative(minConfidence) {
-        return this.runDecayQuery(`*facts{fact_id, fact_type, scope, subject, content,
-              base_confidence, reinforcement_count, created_at,
-              last_reinforced_at, last_contradicted_at, source, evidence},
-        fact_type == "negative"`, {}, minConfidence);
-    }
-    /**
-     * Generate scope hierarchy from a file path for hierarchical matching.
-     * "src/proxy/proxy.ts" → ["src/proxy/proxy.ts", "src/proxy/", "src/", "project"]
-     */
-    buildScopeHierarchy(filePath) {
-        const scopes = [filePath];
-        const parts = filePath.split("/");
-        // Build directory prefixes from deepest to shallowest
-        for (let i = parts.length - 1; i > 0; i--) {
-            scopes.push(`${parts.slice(0, i).join("/")}/`);
-        }
-        scopes.push("project");
-        return scopes;
-    }
-    /**
-     * Recall facts by prefix hierarchy — facts scoped to a directory apply to all files in it.
-     * "src/proxy/proxy.ts" matches facts scoped to "src/proxy/proxy.ts", "src/proxy/", "src/", and "project".
-     */
-    async recallByPrefix(filePath, minConfidence) {
-        const scopes = this.buildScopeHierarchy(filePath);
-        // Build CozoDB or-clause for all scope levels
-        const conditions = scopes.map((_, i) => `scope == $s${i}`).join(" or ");
-        const params = {};
-        for (let i = 0; i < scopes.length; i++) {
-            params[`s${i}`] = scopes[i];
-        }
-        return this.runDecayQuery(`*facts{fact_id, fact_type, scope, subject, content,
-              base_confidence, reinforcement_count, created_at,
-              last_reinforced_at, last_contradicted_at, source, evidence},
-        (${conditions})`, params, minConfidence);
-    }
-    /**
-     * Recall facts relevant to a file — by hierarchical scope prefix OR entity keys within that file.
-     * This is the primary recall method used during tool responses.
-     */
-    async recallForFile(filePath, entityKeys) {
-        const threshold = this.config.recall_threshold;
-        const maxFacts = this.config.max_facts_per_response;
-        // Use hierarchical prefix matching instead of exact scope
-        const scopeFacts = await this.recallByPrefix(filePath, threshold);
-        const entityFacts = [];
-        for (const key of entityKeys.slice(0, 10)) {
-            const facts = await this.recallBySubject(key, threshold);
-            for (const f of facts) {
-                if (!entityFacts.some((ef) => ef.fact_id === f.fact_id)) {
-                    entityFacts.push(f);
-                }
-            }
-        }
-        const projectNegative = await this.recallByScope("project", threshold);
-        const negFacts = projectNegative.filter((f) => f.fact_type === "negative");
-        const all = [...scopeFacts, ...entityFacts, ...negFacts];
-        const deduped = new Map();
-        for (const fact of all) {
-            const existing = deduped.get(fact.fact_id);
-            if (!existing ||
-                fact.effective_confidence > existing.effective_confidence) {
-                deduped.set(fact.fact_id, fact);
-            }
-        }
-        return [...deduped.values()]
-            .sort((a, b) => b.effective_confidence - a.effective_confidence)
-            .slice(0, maxFacts);
-    }
-    /**
-     * Recall all facts regardless of scope (for dashboard listing).
-     */
-    async recallAll(minConfidence) {
-        return this.runDecayQuery(`*facts{fact_id, fact_type, scope, subject, content,
-              base_confidence, reinforcement_count, created_at,
-              last_reinforced_at, last_contradicted_at, source, evidence}`, {}, minConfidence ?? 0);
-    }
-    /**
-     * Recall facts with effective confidence in a given range (for decay visibility).
-     */
-    async recallDecaying(minConf, maxConf) {
-        const all = await this.runDecayQuery(`*facts{fact_id, fact_type, scope, subject, content,
-              base_confidence, reinforcement_count, created_at,
-              last_reinforced_at, last_contradicted_at, source, evidence}`, {}, minConf);
-        return all.filter((f) => f.effective_confidence < maxConf);
-    }
-    /**
-     * Get overall health metrics of the fact store.
-     */
-    async getFactHealth() {
-        const allFacts = await this.runDecayQuery(`*facts{fact_id, fact_type, scope, subject, content,
-              base_confidence, reinforcement_count, created_at,
-              last_reinforced_at, last_contradicted_at, source, evidence}`, {}, 0);
-        const byType = {
-            procedural: 0,
-            semantic: 0,
-            negative: 0,
-            episodic: 0,
-            convention: 0,
-        };
-        let totalConfidence = 0;
-        let active = 0;
-        const threshold = this.config.recall_threshold;
-        for (const fact of allFacts) {
-            byType[fact.fact_type]++;
-            totalConfidence += fact.effective_confidence;
-            if (fact.effective_confidence >= threshold)
-                active++;
-        }
-        return {
-            total: allFacts.length,
-            active,
-            decayed: allFacts.length - active,
-            by_type: byType,
-            avg_confidence: allFacts.length > 0 ? totalConfidence / allFacts.length : 0,
-        };
-    }
-    /**
-     * Remove facts whose effective confidence has dropped below the prune threshold.
-     * Returns the number of facts pruned.
-     */
-    async pruneDecayed(threshold) {
-        const pruneThreshold = threshold ?? this.config.prune_threshold;
-        const allFacts = await this.runDecayQuery(`*facts{fact_id, fact_type, scope, subject, content,
-              base_confidence, reinforcement_count, created_at,
-              last_reinforced_at, last_contradicted_at, source, evidence}`, {}, 0);
-        const toPrune = allFacts.filter((f) => f.fact_type !== "episodic" && f.effective_confidence < pruneThreshold);
-        for (const fact of toPrune) {
-            await this.db.run(`
-        ?[fact_id] <- [[$fact_id]]
-        :rm facts { fact_id }
-        `, { fact_id: fact.fact_id });
-        }
-        return toPrune.length;
-    }
-    /**
-     * Record an entity interaction (for cross-session history tracking).
-     */
-    async recordInteraction(entityKey, sessionId, interactionType, toolName, outcome) {
-        await this.db.run(`
-      ?[entity_key, session_id, interaction_type, timestamp, tool_name, outcome] <- [[
-        $entity_key, $session_id, $interaction_type, $timestamp, $tool_name, $outcome
-      ]]
-      :put entity_interactions {
-        entity_key, session_id, interaction_type, timestamp
-        => tool_name, outcome
-      }
-      `, {
-            entity_key: entityKey,
-            session_id: sessionId,
-            interaction_type: interactionType,
-            timestamp: Date.now(),
-            tool_name: toolName,
-            outcome,
-        });
-    }
-    // ── Internal ─────────────────────────────────────────────────────
-    async findDuplicate(factType, scope, subject) {
-        const result = await this.db.run(`
-      ?[fact_id] :=
-        *facts{fact_id, fact_type, scope, subject},
-        fact_type == $filter_type,
-        scope == $filter_scope,
-        subject == $filter_subject
-      :limit 1
-      `, {
-            filter_type: factType,
-            filter_scope: scope,
-            filter_subject: subject,
-        });
-        return result.rows.length > 0 ? result.rows[0]?.[0] : null;
-    }
-    async getRawFact(factId) {
-        const result = await this.db.run(`
-      ?[fact_id, fact_type, scope, subject, content, base_confidence,
-        reinforcement_count, created_at, last_reinforced_at,
-        last_contradicted_at, source, evidence] :=
-        *facts{fact_id, fact_type, scope, subject, content,
-               base_confidence, reinforcement_count, created_at,
-               last_reinforced_at, last_contradicted_at, source, evidence},
-        fact_id == $filter_fact_id
-      `, { filter_fact_id: factId });
-        if (result.rows.length === 0)
-            return null;
-        const row = result.rows[0];
-        return {
-            fact_id: row[0],
-            fact_type: row[1],
-            scope: row[2],
-            subject: row[3],
-            content: row[4],
-            base_confidence: row[5],
-            reinforcement_count: row[6],
-            created_at: row[7],
-            last_reinforced_at: row[8],
-            last_contradicted_at: row[9],
-            source: row[10],
-            evidence: row[11],
-        };
-    }
-    /**
-     * Execute a recall query with inline decay computation.
-     * The decay math runs entirely within CozoDB Datalog — no post-processing.
-     */
-    async runDecayQuery(sourceClause, params, minConfidence) {
-        const threshold = minConfidence ?? this.config.recall_threshold;
-        const nowMs = Date.now();
-        const query = `
-      ?[fact_id, fact_type, scope, subject, content, base_confidence,
-        reinforcement_count, created_at, last_reinforced_at,
-        last_contradicted_at, source, evidence, effective_conf] :=
-        ${sourceClause},
-        days = ($now_ms - last_reinforced_at) / 86400000.0,
-        lambda = if(fact_type == "procedural", $lambda_procedural,
-                 if(fact_type == "semantic", $lambda_semantic,
-                 if(fact_type == "negative", $lambda_negative,
-                 if(fact_type == "convention", $lambda_convention, 0.0)))),
-        recency = exp(-1.0 * lambda * max(0.0, days)),
-        ev_factor = if(source == "agent_explicit", 1.0, min(1.0, reinforcement_count / 3.0)),
-        effective_conf = base_confidence * recency * ev_factor,
-        effective_conf >= $min_confidence
-      :order -effective_conf
-      :limit 50
-    `;
-        const result = await this.db.run(query, {
-            ...params,
-            now_ms: nowMs,
-            lambda_procedural: this.config.decay_rates.procedural,
-            lambda_semantic: this.config.decay_rates.semantic,
-            lambda_negative: this.config.decay_rates.negative,
-            lambda_convention: this.config.decay_rates.convention,
-            min_confidence: threshold,
-        });
-        return result.rows.map((row) => ({
-            fact_id: row[0],
-            fact_type: row[1],
-            scope: row[2],
-            subject: row[3],
-            content: row[4],
-            base_confidence: row[5],
-            effective_confidence: row[12],
-            reinforcement_count: row[6],
-            created_at: row[7],
-            last_reinforced_at: row[8],
-            last_contradicted_at: row[9],
-            source: row[10],
-        }));
-    }
-}

package/dist/intelligence/token-estimator.js

@@ -1,100 +0,0 @@
-/**
- * Token Estimation Engine — fast heuristic-based token counting.
- *
- * Implements a 4-rule heuristic for cl100k_base (GPT-4/Claude) tokenization
- * that achieves within 10% accuracy without WASM overhead.
- *
- * Rules:
- *   1. Whitespace is cheap (~0.25 tokens per whitespace char)
- *   2. Code tokens ≈ chars / 3.5 (identifiers split on boundaries)
- *   3. English prose ≈ chars / 4 (natural language words)
- *   4. JSON/structured ≈ chars / 3 (many delimiters = more tokens)
- *
- * Per-model cost table for all major providers.
- */
-const CHARS_PER_TOKEN = {
-    code: 3.5,
-    prose: 4.0,
-    json: 3.0,
-    mixed: 3.7,
-};
-function detectContentType(text) {
-    if (text.length === 0)
-        return "mixed";
-    const sample = text.slice(0, 2000);
-    const lines = sample.split("\n");
-    const trimmed = sample.trim();
-    if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
-        (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
-        return "json";
-    }
-    const braceCount = (sample.match(/[{}()[\];=><]/g) ?? []).length;
-    const wordCount = (sample.match(/\b\w+\b/g) ?? []).length;
-    const codeIndicators = (sample.match(/\b(function|const|let|var|class|import|export|return|if|for|while|async|await|type|interface|def|fn)\b/g) ?? []).length;
-    if (codeIndicators > 3 || braceCount > wordCount * 0.15)
-        return "code";
-    if (braceCount < 5 && lines.length < sample.length / 60)
-        return "prose";
-    return "mixed";
-}
-/**
- * Estimate token count for a string using cl100k_base heuristics.
- * Accurate within 10% for typical code and prose inputs.
- */
-export function estimateTokenCount(text) {
-    if (!text || text.length === 0)
-        return 0;
-    const contentType = detectContentType(text);
-    const ratio = CHARS_PER_TOKEN[contentType];
-    const whitespaceCount = (text.match(/\s/g) ?? []).length;
-    const nonWhitespaceCount = text.length - whitespaceCount;
-    const whitespaceTokens = whitespaceCount * 0.25;
-    const contentTokens = nonWhitespaceCount / ratio;
-    return Math.ceil(whitespaceTokens + contentTokens);
-}
-/**
- * Estimate tokens for any value (string, object, array, etc.)
- */
-export function estimateTokens(value) {
-    if (value === null || value === undefined)
-        return 0;
-    const text = typeof value === "string" ? value : JSON.stringify(value);
-    return estimateTokenCount(text);
-}
-const MODEL_COSTS = {
-    "claude-sonnet-4-20250514": { inputPerMillion: 3, outputPerMillion: 15 },
-    "claude-opus-4-20250514": { inputPerMillion: 15, outputPerMillion: 75 },
-    "claude-haiku-4-20250506": { inputPerMillion: 0.8, outputPerMillion: 4 },
-    "gpt-4o": { inputPerMillion: 2.5, outputPerMillion: 10 },
-    "gpt-4o-mini": { inputPerMillion: 0.15, outputPerMillion: 0.6 },
-    "gpt-4-turbo": { inputPerMillion: 10, outputPerMillion: 30 },
-    "gemini-2.0-flash": { inputPerMillion: 0.1, outputPerMillion: 0.4 },
-    "gemini-1.5-pro": { inputPerMillion: 1.25, outputPerMillion: 5 },
-    ollama: { inputPerMillion: 0, outputPerMillion: 0 },
-};
-/**
- * Estimate the dollar cost of a token exchange.
- */
-export function estimateCost(model, inputTokens, outputTokens) {
-    const rates = MODEL_COSTS[model] ?? {
-        inputPerMillion: 3,
-        outputPerMillion: 15,
-    };
-    return ((inputTokens * rates.inputPerMillion +
-        outputTokens * rates.outputPerMillion) /
-        1_000_000);
-}
-/**
- * Get the cost rate for a model. Returns default rates for unknown models.
- */
-export function getModelCostRate(model) {
-    return MODEL_COSTS[model] ?? { inputPerMillion: 3, outputPerMillion: 15 };
-}
-/**
- * Estimate dollar savings from token reduction.
- */
-export function estimateSavings(model, originalTokens, deliveredTokens) {
-    const savedTokens = Math.max(0, originalTokens - deliveredTokens);
-    const rates = getModelCostRate(model);
-    return (savedTokens * rates.inputPerMillion) / 1_000_000;
-}

package/dist/intelligence/tool-injector.js

@@ -1,87 +0,0 @@
-/**
- * Sprint 9.7: Dynamic Tool Injection — inject block-level rules into tool descriptions.
- *
- * At MCP initialize, reads top block-level rules from CozoDB and appends them
- * to `sync_local_diff` and `check_rules` tool descriptions. On Butter-Sync
- * rule changes, emits `tools/list_changed` to refresh IDE descriptions.
- *
- * Budget: 500 tokens (~2000 chars) for injected rule context.
- *
- * Design authority: Phase 6 IS-06, SKILL doc §2.5, Module 6A §6.6.
- */
-/** stderr logger */
-const _log = {
-    info: (msg) => process.stderr.write(`[unerr:tool-injector] ${msg}\n`),
-};
-/** Tools that receive rule injection */
-const INJECTABLE_TOOLS = new Set(["sync_local_diff", "check_rules"]);
-/** Max characters for injected rule context (~500 tokens) */
-const MAX_INJECTION_CHARS = 2000;
-/** Max number of block rules to inject */
-const MAX_BLOCK_RULES = 10;
-/**
- * Get block-level rules from CozoDB for injection.
- */
-export async function getBlockRules(localGraph) {
-    const allRules = await localGraph.getRules();
-    return allRules
-        .filter((r) => r.severity === "block" && r.enabled)
-        .slice(0, MAX_BLOCK_RULES);
-}
-/**
- * Format block rules into a compact injection string.
- * Stays within 500-token budget.
- */
-export function formatRuleInjection(blockRules) {
-    if (blockRules.length === 0)
-        return "";
-    const lines = [
-        "\n\n---\n**Active Block Rules (violations will be flagged):**",
-    ];
-    let totalChars = lines[0]?.length ?? 0;
-    for (const rule of blockRules) {
-        const line = `\n- [${rule.key}] ${rule.name}: ${rule.message || "No description"}`;
-        if (totalChars + line.length > MAX_INJECTION_CHARS)
-            break;
-        lines.push(line);
-        totalChars += line.length;
-    }
-    return lines.join("");
-}
-/**
- * Inject block-level rule context into tool descriptions.
- * Returns new tool schemas with updated descriptions. Does not mutate input.
- */
-export async function injectRuleContext(tools, localGraph) {
-    const blockRules = await getBlockRules(localGraph);
-    if (blockRules.length === 0)
-        return tools;
-    const injection = formatRuleInjection(blockRules);
-    if (!injection)
-        return tools;
-    _log.info(`Injecting ${blockRules.length} block rules into tool descriptions`);
-    return tools.map((tool) => {
-        if (INJECTABLE_TOOLS.has(tool.name)) {
-            return {
-                ...tool,
-                description: (tool.description ?? "") + injection,
-            };
-        }
-        return tool;
-    });
-}
-/**
- * Check if tool descriptions need refreshing after a rule change.
- * Compares current block rules against a cached version.
- */
-export async function needsRefresh(localGraph, cachedRuleKeys) {
-    const currentBlockRules = await getBlockRules(localGraph);
-    const currentKeys = new Set(currentBlockRules.map((r) => r.key));
-    if (currentKeys.size !== cachedRuleKeys.size)
-        return true;
-    for (const key of currentKeys) {
-        if (!cachedRuleKeys.has(key))
-            return true;
-    }
-    return false;
-}