@psiclawops/hypermem 0.6.2 → 0.7.0

package/dist/contradiction-detector.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Contradiction Detector — heuristic-based contradiction detection for the fact store.
+ *
+ * Detects when a newly ingested fact contradicts existing active facts using
+ * vector similarity (when available) and FTS candidate retrieval, scored by
+ * pattern-based heuristics (negation, numeric conflict, state conflict, temporal).
+ *
+ * No LLM calls — v1 is purely heuristic. LLM-enhanced scoring is a future item.
+ */
+import type { FactStore } from './fact-store.js';
+import type { VectorStore } from './vector-store.js';
+export interface ContradictionCandidate {
+    existingFactId: number;
+    existingContent: string;
+    similarityScore: number;
+    contradictionScore: number;
+    reason: string;
+}
+export interface ContradictionResult {
+    contradictions: ContradictionCandidate[];
+    autoResolved: boolean;
+    resolvedCount: number;
+}
+export interface ContradictionDetectorConfig {
+    /** Minimum similarity to consider as candidate. Default: 0.6 */
+    minSimilarity?: number;
+    /** Minimum contradiction score for auto-resolution. Default: 0.85 */
+    autoResolveThreshold?: number;
+    /** Max candidates to evaluate per ingest. Default: 10 */
+    maxCandidates?: number;
+    /** Enable auto-resolution. Default: true */
+    autoResolve?: boolean;
+}
+export declare class ContradictionDetector {
+    private readonly factStore;
+    private readonly vectorStore?;
+    private readonly config;
+    constructor(factStore: FactStore, vectorStore?: VectorStore | undefined, config?: ContradictionDetectorConfig);
+    /**
+     * On fact ingest, check if the new fact contradicts existing active facts.
+     * Uses vector similarity (when available) + FTS to find candidates, then
+     * scores each candidate with heuristic contradiction checks.
+     */
+    detectOnIngest(agentId: string, newFact: {
+        content: string;
+        domain?: string;
+    }): Promise<ContradictionResult>;
+    /**
+     * Resolve a detected contradiction between an existing fact and a new fact.
+     */
+    resolveContradiction(oldFactId: number, newFactId: number, resolution: 'supersede' | 'keep-both' | 'reject-new'): void;
+    /**
+     * Auto-resolve high-confidence contradictions: newer supersedes older.
+     * Only resolves candidates above the autoResolveThreshold.
+     *
+     * @param agentId - The agent whose facts are being resolved (for audit trail)
+     * @param candidates - Scored contradiction candidates from detectOnIngest
+     * @returns Count of auto-resolved contradictions
+     */
+    autoResolve(_agentId: string, candidates: ContradictionCandidate[]): Promise<number>;
+    /**
+     * Find candidate facts that might contradict the new fact.
+     * Uses vector search (if available) and FTS, deduplicates, and returns
+     * up to maxCandidates results above minSimilarity.
+     */
+    private findCandidates;
+    /**
+     * Score a candidate fact against the new fact content for contradiction.
+     * Returns a ContradictionCandidate if any heuristic fires, null otherwise.
+     */
+    private scoreContradiction;
+    /**
+     * Compute Jaccard-like token overlap between two texts.
+     * Returns 0-1 where 1 means identical token sets.
+     */
+    private tokenOverlapSimilarity;
+}
+//# sourceMappingURL=contradiction-detector.d.ts.map

package/dist/contradiction-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contradiction-detector.d.ts","sourceRoot":"","sources":["../src/contradiction-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,mBAAmB,CAAC;AAIzE,MAAM,WAAW,sBAAsB;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,sBAAsB,EAAE,CAAC;IACzC,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,2BAA2B;IAC1C,gEAAgE;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,yDAAyD;IACzD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAkKD,qBAAa,qBAAqB;IAI9B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAJ/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwC;gBAG5C,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,WAAW,YAAA,EAC1C,MAAM,CAAC,EAAE,2BAA2B;IAKtC;;;;OAIG;IACG,cAAc,CAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAC5C,OAAO,CAAC,mBAAmB,CAAC;IAuB/B;;OAEG;IACH,oBAAoB,CAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,WAAW,GAAG,WAAW,GAAG,YAAY,GACnD,IAAI;IAcP;;;;;;;OAOG;IACG,WAAW,CACf,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,sBAAsB,EAAE,GACnC,OAAO,CAAC,MAAM,CAAC;IAoBlB;;;;OAIG;YACW,cAAc;IA0E5B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IA0D1B;;;OAGG;IACH,OAAO,CAAC,sBAAsB;CAa/B"}

package/dist/contradiction-detector.js

@@ -0,0 +1,362 @@
+/**
+ * Contradiction Detector — heuristic-based contradiction detection for the fact store.
+ *
+ * Detects when a newly ingested fact contradicts existing active facts using
+ * vector similarity (when available) and FTS candidate retrieval, scored by
+ * pattern-based heuristics (negation, numeric conflict, state conflict, temporal).
+ *
+ * No LLM calls — v1 is purely heuristic. LLM-enhanced scoring is a future item.
+ */
+// ─── Internal Constants ──────────────────────────────────────────
+const DEFAULT_CONFIG = {
+    minSimilarity: 0.6,
+    autoResolveThreshold: 0.85,
+    maxCandidates: 10,
+    autoResolve: true,
+};
+/** Words whose presence/absence flips meaning. */
+const NEGATION_WORDS = new Set([
+    'not', 'no', 'never', 'none', 'neither', 'nor', 'cannot', "can't",
+    "don't", "doesn't", "didn't", "won't", "wouldn't", "shouldn't",
+    "isn't", "aren't", "wasn't", "weren't", "hasn't", "haven't", "hadn't",
+]);
+/** Antonym pairs where one in text A and the other in text B signals conflict. */
+const STATE_ANTONYMS = [
+    ['enabled', 'disabled'],
+    ['active', 'inactive'],
+    ['active', 'deprecated'],
+    ['running', 'stopped'],
+    ['running', 'crashed'],
+    ['up', 'down'],
+    ['true', 'false'],
+    ['yes', 'no'],
+    ['on', 'off'],
+    ['open', 'closed'],
+    ['allowed', 'denied'],
+    ['allowed', 'blocked'],
+    ['available', 'unavailable'],
+    ['connected', 'disconnected'],
+    ['online', 'offline'],
+    ['present', 'absent'],
+    ['healthy', 'unhealthy'],
+    ['valid', 'invalid'],
+    ['complete', 'incomplete'],
+    ['success', 'failure'],
+];
+// ─── Helpers ─────────────────────────────────────────────────────
+/** Normalize text for comparison: lowercase, collapse whitespace. */
+function normalize(text) {
+    return text.toLowerCase().replace(/\s+/g, ' ').trim();
+}
+/** Tokenize into word-boundary tokens. */
+function tokenize(text) {
+    return normalize(text).split(/[\s,;:()[\]{}]+/).filter(Boolean);
+}
+/** Convert VectorStore distance (lower = closer) to a 0-1 similarity score. */
+function distanceToSimilarity(distance) {
+    // sqlite-vec uses L2 distance by default. Convert to 0-1 similarity.
+    // distance=0 => similarity=1, distance grows => similarity decays toward 0.
+    return 1 / (1 + distance);
+}
+/**
+ * Build a safe FTS query from content. Takes the first several meaningful words
+ * to avoid FTS syntax errors from special characters.
+ */
+function buildFtsQuery(content) {
+    const words = tokenize(content)
+        .filter(w => w.length > 2 && !/^\d+$/.test(w))
+        .slice(0, 6);
+    if (words.length === 0)
+        return '';
+    // OR-join for broad recall
+    return words.join(' OR ');
+}
+/**
+ * Extract numbers and their rough context (preceding word) from text.
+ * Returns pairs of [contextWord, number].
+ */
+function extractNumbers(text) {
+    const results = [];
+    const tokens = tokenize(text);
+    for (let i = 0; i < tokens.length; i++) {
+        const num = parseFloat(tokens[i]);
+        if (!isNaN(num) && isFinite(num)) {
+            const context = i > 0 ? tokens[i - 1] : '';
+            results.push({ context, value: num });
+        }
+    }
+    return results;
+}
+/**
+ * Check if one text contains a negation of the other.
+ * Returns true if one has a negation word in a position where the other doesn't
+ * (or vice versa), given high token overlap.
+ */
+function detectNegation(tokensA, tokensB) {
+    const negA = tokensA.filter(t => NEGATION_WORDS.has(t));
+    const negB = tokensB.filter(t => NEGATION_WORDS.has(t));
+    // One has negation words, the other doesn't (or different count)
+    if (negA.length !== negB.length) {
+        // Check that the non-negation content overlaps substantially
+        const contentA = new Set(tokensA.filter(t => !NEGATION_WORDS.has(t)));
+        const contentB = new Set(tokensB.filter(t => !NEGATION_WORDS.has(t)));
+        const intersection = [...contentA].filter(t => contentB.has(t));
+        const smaller = Math.min(contentA.size, contentB.size);
+        // Need at least 40% content overlap to consider it a negation of the same claim
+        return smaller > 0 && intersection.length / smaller >= 0.4;
+    }
+    return false;
+}
+/**
+ * Check for antonym state pairs between two token sets.
+ * Returns the matching antonym pair if found, or null.
+ */
+function detectStateConflict(tokensA, tokensB) {
+    const setA = new Set(tokensA);
+    const setB = new Set(tokensB);
+    for (const [word1, word2] of STATE_ANTONYMS) {
+        if ((setA.has(word1) && setB.has(word2)) || (setA.has(word2) && setB.has(word1))) {
+            // Verify there's enough shared context (not just random words)
+            const contentA = new Set(tokensA.filter(t => t !== word1 && t !== word2));
+            const contentB = new Set(tokensB.filter(t => t !== word1 && t !== word2));
+            const intersection = [...contentA].filter(t => contentB.has(t));
+            const smaller = Math.min(contentA.size, contentB.size);
+            if (smaller > 0 && intersection.length / smaller >= 0.3) {
+                return setA.has(word1) ? [word1, word2] : [word2, word1];
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Check for numeric conflicts: same contextual subject, different numbers.
+ */
+function detectNumericConflict(textA, textB) {
+    const numsA = extractNumbers(textA);
+    const numsB = extractNumbers(textB);
+    for (const a of numsA) {
+        for (const b of numsB) {
+            // Same context word, different value
+            if (a.context && a.context === b.context && a.value !== b.value) {
+                return { contextWord: a.context, valueA: a.value, valueB: b.value };
+            }
+        }
+    }
+    return null;
+}
+// ─── ContradictionDetector ───────────────────────────────────────
+export class ContradictionDetector {
+    factStore;
+    vectorStore;
+    config;
+    constructor(factStore, vectorStore, config) {
+        this.factStore = factStore;
+        this.vectorStore = vectorStore;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * On fact ingest, check if the new fact contradicts existing active facts.
+     * Uses vector similarity (when available) + FTS to find candidates, then
+     * scores each candidate with heuristic contradiction checks.
+     */
+    async detectOnIngest(agentId, newFact) {
+        const candidates = await this.findCandidates(agentId, newFact);
+        const contradictions = [];
+        for (const candidate of candidates) {
+            const scored = this.scoreContradiction(newFact.content, candidate);
+            if (scored) {
+                contradictions.push(scored);
+            }
+        }
+        // Sort by contradiction score descending
+        contradictions.sort((a, b) => b.contradictionScore - a.contradictionScore);
+        const result = {
+            contradictions,
+            autoResolved: false,
+            resolvedCount: 0,
+        };
+        return result;
+    }
+    /**
+     * Resolve a detected contradiction between an existing fact and a new fact.
+     */
+    resolveContradiction(oldFactId, newFactId, resolution) {
+        switch (resolution) {
+            case 'supersede':
+                this.factStore.markSuperseded(oldFactId, newFactId);
+                break;
+            case 'keep-both':
+                // No-op: both facts remain active
+                break;
+            case 'reject-new':
+                this.factStore.invalidateFact(newFactId);
+                break;
+        }
+    }
+    /**
+     * Auto-resolve high-confidence contradictions: newer supersedes older.
+     * Only resolves candidates above the autoResolveThreshold.
+     *
+     * @param agentId - The agent whose facts are being resolved (for audit trail)
+     * @param candidates - Scored contradiction candidates from detectOnIngest
+     * @returns Count of auto-resolved contradictions
+     */
+    async autoResolve(_agentId, candidates) {
+        if (!this.config.autoResolve)
+            return 0;
+        let resolved = 0;
+        for (const candidate of candidates) {
+            if (candidate.contradictionScore >= this.config.autoResolveThreshold) {
+                // The existing fact is older; the new fact (which triggered detection)
+                // is assumed to be the more recent truth. We mark the existing as superseded.
+                // Note: the caller must supply the newFactId when wiring this into ingest.
+                // For now, we invalidate the old fact since we don't have the new fact's id here.
+                this.factStore.invalidateFact(candidate.existingFactId);
+                resolved++;
+            }
+        }
+        return resolved;
+    }
+    // ─── Private Methods ────────────────────────────────────────────
+    /**
+     * Find candidate facts that might contradict the new fact.
+     * Uses vector search (if available) and FTS, deduplicates, and returns
+     * up to maxCandidates results above minSimilarity.
+     */
+    async findCandidates(agentId, newFact) {
+        const seen = new Set();
+        const candidates = [];
+        const { maxCandidates, minSimilarity } = this.config;
+        // Path 1: Vector similarity search (if VectorStore is available)
+        if (this.vectorStore) {
+            try {
+                const vectorResults = await this.vectorStore.search(newFact.content, {
+                    tables: ['facts'],
+                    limit: maxCandidates * 2, // over-fetch to allow for filtering
+                });
+                for (const vr of vectorResults) {
+                    const similarity = distanceToSimilarity(vr.distance);
+                    if (similarity < minSimilarity)
+                        continue;
+                    if (seen.has(vr.sourceId))
+                        continue;
+                    seen.add(vr.sourceId);
+                    // Retrieve the full fact row for metadata checks
+                    const facts = this.factStore.searchFacts(vr.content.slice(0, 30), {
+                        agentId,
+                        limit: 1,
+                    });
+                    const fact = facts.find(f => f.id === vr.sourceId);
+                    if (fact && !fact.supersededBy && !fact.invalidAt) {
+                        candidates.push({ fact, similarity });
+                    }
+                }
+            }
+            catch {
+                // Vector search failed (embedding model unavailable, etc.)
+                // Fall through to FTS-only path
+            }
+        }
+        // Path 2: FTS search (always available, fills gaps)
+        if (candidates.length < maxCandidates) {
+            const ftsQuery = buildFtsQuery(newFact.content);
+            if (ftsQuery) {
+                try {
+                    const ftsResults = this.factStore.searchFacts(ftsQuery, {
+                        agentId,
+                        domain: newFact.domain,
+                        limit: maxCandidates * 2,
+                    });
+                    for (const fact of ftsResults) {
+                        if (seen.has(fact.id))
+                            continue;
+                        if (fact.supersededBy || fact.invalidAt)
+                            continue;
+                        seen.add(fact.id);
+                        // Compute a rough token-overlap similarity for FTS results
+                        const similarity = this.tokenOverlapSimilarity(newFact.content, fact.content);
+                        if (similarity >= minSimilarity) {
+                            candidates.push({ fact, similarity });
+                        }
+                    }
+                }
+                catch {
+                    // FTS query failed (malformed query, etc.)
+                }
+            }
+        }
+        // Sort by similarity descending, trim to maxCandidates
+        candidates.sort((a, b) => b.similarity - a.similarity);
+        return candidates.slice(0, maxCandidates);
+    }
+    /**
+     * Score a candidate fact against the new fact content for contradiction.
+     * Returns a ContradictionCandidate if any heuristic fires, null otherwise.
+     */
+    scoreContradiction(newContent, candidate) {
+        const existingContent = candidate.fact.content;
+        const tokensNew = tokenize(newContent);
+        const tokensExisting = tokenize(existingContent);
+        let bestScore = 0;
+        let bestReason = '';
+        // Heuristic 1: Negation detection (score: 0.9)
+        if (detectNegation(tokensNew, tokensExisting)) {
+            bestScore = 0.9;
+            bestReason = 'Negation detected: one fact negates the other';
+        }
+        // Heuristic 2: State conflict via antonym pairs (score: 0.85)
+        const stateConflict = detectStateConflict(tokensNew, tokensExisting);
+        if (stateConflict && stateConflict.length === 2) {
+            const score = 0.85;
+            if (score > bestScore) {
+                bestScore = score;
+                bestReason = `State conflict: "${stateConflict[0]}" vs "${stateConflict[1]}"`;
+            }
+        }
+        // Heuristic 3: Numeric conflict (score: 0.8)
+        const numConflict = detectNumericConflict(newContent, existingContent);
+        if (numConflict) {
+            const score = 0.8;
+            if (score > bestScore) {
+                bestScore = score;
+                bestReason = `Numeric conflict on "${numConflict.contextWord}": ${numConflict.valueA} vs ${numConflict.valueB}`;
+            }
+        }
+        // Heuristic 4: Temporal supersede — high similarity, different conclusion (score: 0.7)
+        // If similarity is very high (>0.8) but content isn't identical, it's likely a revised version
+        if (bestScore === 0 && candidate.similarity > 0.8) {
+            const contentDiffers = normalize(newContent) !== normalize(existingContent);
+            if (contentDiffers) {
+                bestScore = 0.7;
+                bestReason = 'Temporal supersede: high similarity with different content (likely revised)';
+            }
+        }
+        if (bestScore === 0)
+            return null;
+        return {
+            existingFactId: candidate.fact.id,
+            existingContent,
+            similarityScore: candidate.similarity,
+            contradictionScore: bestScore,
+            reason: bestReason,
+        };
+    }
+    /**
+     * Compute Jaccard-like token overlap between two texts.
+     * Returns 0-1 where 1 means identical token sets.
+     */
+    tokenOverlapSimilarity(textA, textB) {
+        const setA = new Set(tokenize(textA));
+        const setB = new Set(tokenize(textB));
+        if (setA.size === 0 || setB.size === 0)
+            return 0;
+        let intersection = 0;
+        for (const token of setA) {
+            if (setB.has(token))
+                intersection++;
+        }
+        const union = new Set([...setA, ...setB]).size;
+        return union > 0 ? intersection / union : 0;
+    }
+}
+//# sourceMappingURL=contradiction-detector.js.map

package/dist/expertise-store.d.ts

@@ -0,0 +1,129 @@
+/**
+ * hypermem Expertise Store
+ *
+ * Stores domain expertise patterns — learned behaviors that make the Nth run
+ * better than the 1st. Two-phase lifecycle:
+ *   1. Observations: raw learnings logged from conversations, pipelines, reviews
+ *   2. Patterns: graduated observations with N≥3 confirming instances
+ *
+ * Patterns are agent-scoped but domain-tagged, enabling cross-agent queries.
+ * Patterns have confidence, frequency tracking, and decay on counter-evidence.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+export interface ExpertiseObservation {
+    id: number;
+    agentId: string;
+    domain: string;
+    context: string | null;
+    observationText: string;
+    sourceType: 'conversation' | 'pipeline' | 'review' | 'manual';
+    sourceRef: string | null;
+    createdAt: string;
+}
+export interface ExpertisePattern {
+    id: number;
+    agentId: string;
+    domain: string;
+    patternText: string;
+    confidence: number;
+    frequency: number;
+    firstSeen: string;
+    lastConfirmed: string;
+    invalidatedAt: string | null;
+    invalidationReason: string | null;
+    decayScore: number;
+}
+export interface ExpertiseEvidence {
+    observationId: number;
+    patternId: number;
+    relationship: 'confirms' | 'contradicts';
+    createdAt: string;
+}
+export declare class ExpertiseStore {
+    private readonly db;
+    private readonly graduationThreshold;
+    constructor(db: DatabaseSync, graduationThreshold?: number);
+    /**
+     * Record a raw observation from any source.
+     */
+    record(agentId: string, observationText: string, domain: string, opts?: {
+        context?: string;
+        sourceType?: ExpertiseObservation['sourceType'];
+        sourceRef?: string;
+    }): ExpertiseObservation;
+    /**
+     * Get observations for an agent, optionally filtered by domain.
+     */
+    getObservations(agentId: string, opts?: {
+        domain?: string;
+        limit?: number;
+    }): ExpertiseObservation[];
+    /**
+     * Retrieve active expertise patterns for current work context.
+     * Returns patterns sorted by confidence DESC, frequency DESC.
+     * Excludes invalidated patterns by default.
+     */
+    query(agentId: string, domain: string, opts?: {
+        context?: string;
+        includeInvalidated?: boolean;
+        limit?: number;
+        minConfidence?: number;
+    }): ExpertisePattern[];
+    /**
+     * Cross-agent query: get patterns from any agent in a given domain.
+     * Useful for fleet-wide expertise ("what has any agent learned about X?").
+     */
+    queryFleet(domain: string, opts?: {
+        limit?: number;
+        minConfidence?: number;
+    }): ExpertisePattern[];
+    /**
+     * Graduate an observation to a pattern.
+     *
+     * If a similar pattern already exists (same agent, domain, and pattern text prefix match),
+     * increments its frequency and updates lastConfirmed instead of creating a duplicate.
+     *
+     * Auto-graduation happens when an observation has N≥graduationThreshold confirming
+     * evidence links. Can also be called manually.
+     */
+    graduate(agentId: string, observationId: number, opts?: {
+        patternText?: string;
+        confidence?: number;
+    }): ExpertisePattern | null;
+    /**
+     * Record evidence linking an observation to a pattern.
+     * If this pushes a pattern's contradicting evidence past threshold,
+     * auto-invalidates the pattern.
+     */
+    addEvidence(observationId: number, patternId: number, relationship: 'confirms' | 'contradicts'): void;
+    /**
+     * Check if any observations are ready for auto-graduation.
+     * An observation graduates when it has N≥threshold confirming evidence links.
+     * Returns the number of newly graduated patterns.
+     */
+    autoGraduate(agentId: string): number;
+    /**
+     * Mark a pattern as invalidated.
+     */
+    invalidate(patternId: number, reason: string): boolean;
+    /**
+     * List all active patterns for an agent, optionally filtered by domain.
+     */
+    list(agentId: string, opts?: {
+        domain?: string;
+        includeInvalidated?: boolean;
+    }): ExpertisePattern[];
+    /**
+     * Decay all patterns by a fixed rate. Similar to fact decay.
+     */
+    decayPatterns(agentId: string, decayRate?: number): number;
+    /**
+     * Get pattern and observation counts for an agent.
+     */
+    getStats(agentId: string): {
+        observations: number;
+        activePatterns: number;
+        invalidatedPatterns: number;
+    };
+}
+//# sourceMappingURL=expertise-store.d.ts.map

package/dist/expertise-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expertise-store.d.ts","sourceRoot":"","sources":["../src/expertise-store.ts"],"names":[],"mappings":"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"}