@psiclawops/hypermem 0.5.6 → 0.7.0

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/cross-agent.d.ts

@@ -25,6 +25,18 @@ export interface OrgRegistry {
 }
 /**
  * Default fleet org structure.
+ *
+ * ── EXAMPLE DATA ──────────────────────────────────────────────────────────
+ * The agent names below (agent1, agent2, director1, etc.) are PLACEHOLDERS.
+ * Replace them with your own agent IDs to match your fleet configuration.
+ *
+ * Single-agent installs: you don't need to edit this. Your agent ID is
+ * resolved automatically at runtime from your OpenClaw config.
+ *
+ * Multi-agent installs: edit the agents map and orgs map below, then
+ * rebuild (`npm run build`). See INSTALL.md § "Configure your fleet" for
+ * a worked example.
+ * ─────────────────────────────────────────────────────────────────────────
  */
 export declare function defaultOrgRegistry(): OrgRegistry;
 export declare function canAccess(requester: AgentIdentity, target: AgentIdentity, visibility: MemoryVisibility, registry: OrgRegistry): boolean;

package/dist/cross-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cross-agent.d.ts","sourceRoot":"","sources":["../src/cross-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,aAAa,EACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAK1C,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CACvC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,WAAW,CA2BhD;AAID,wBAAgB,SAAS,CACvB,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,gBAAgB,EAC5B,QAAQ,EAAE,WAAW,GACpB,OAAO,CAaT;AASD,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,aAAa,EACxB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,WAAW,GACpB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,OAAO,CAAA;CAAE,CA6B3F;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,YAAY,GAAG,WAAW,CAgD3E;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB,+BAAyB,CAAC;AAI5D;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,eAAe,EAC1B,KAAK,EAAE,eAAe,EACtB,QAAQ,EAAE,WAAW,GACpB,OAAO,EAAE,CAgCX"}
+{"version":3,"file":"cross-agent.d.ts","sourceRoot":"","sources":["../src/cross-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,aAAa,EACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAK1C,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CACvC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,IAAI,WAAW,CA2BhD;AAID,wBAAgB,SAAS,CACvB,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,gBAAgB,EAC5B,QAAQ,EAAE,WAAW,GACpB,OAAO,CAaT;AASD,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,aAAa,EACxB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,WAAW,GACpB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,OAAO,CAAA;CAAE,CA6B3F;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,YAAY,GAAG,WAAW,CAgD3E;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB,+BAAyB,CAAC;AAI5D;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,eAAe,EAC1B,KAAK,EAAE,eAAe,EACtB,QAAQ,EAAE,WAAW,GACpB,OAAO,EAAE,CAgCX"}

package/dist/cross-agent.js

@@ -19,30 +19,42 @@
 import { FleetStore } from './fleet-store.js';
 /**
  * Default fleet org structure.
+ *
+ * ── EXAMPLE DATA ──────────────────────────────────────────────────────────
+ * The agent names below (agent1, agent2, director1, etc.) are PLACEHOLDERS.
+ * Replace them with your own agent IDs to match your fleet configuration.
+ *
+ * Single-agent installs: you don't need to edit this. Your agent ID is
+ * resolved automatically at runtime from your OpenClaw config.
+ *
+ * Multi-agent installs: edit the agents map and orgs map below, then
+ * rebuild (`npm run build`). See INSTALL.md § "Configure your fleet" for
+ * a worked example.
+ * ─────────────────────────────────────────────────────────────────────────
  */
 export function defaultOrgRegistry() {
     const agents = {
-        alice: { agentId: 'alice', tier: 'council' },
-        bob: { agentId: 'bob', tier: 'council' },
-        clarity: { agentId: 'clarity', tier: 'council' },
-        dave: { agentId: 'dave', tier: 'council' },
-        carol: { agentId: 'carol', tier: 'council' },
-        oscar: { agentId: 'oscar', tier: 'council' },
-        hank: { agentId: 'hank', tier: 'director', org: 'alice-org', councilLead: 'alice' },
-        jack: { agentId: 'jack', tier: 'director', org: 'alice-org', councilLead: 'alice' },
-        irene: { agentId: 'irene', tier: 'director', org: 'alice-org', councilLead: 'alice' },
-        eve: { agentId: 'eve', tier: 'director', org: 'bob-org', councilLead: 'bob' },
-        frank: { agentId: 'frank', tier: 'director', org: 'bob-org', councilLead: 'bob' },
-        grace: { agentId: 'grace', tier: 'director', org: 'bob-org', councilLead: 'bob' },
-        leo: { agentId: 'leo', tier: 'director', org: 'dave-org', councilLead: 'dave' },
-        kate: { agentId: 'kate', tier: 'director', org: 'dave-org', councilLead: 'dave' },
-        mike: { agentId: 'mike', tier: 'specialist' },
-        nancy: { agentId: 'nancy', tier: 'specialist' },
+        agent1: { agentId: 'agent1', tier: 'council' },
+        agent2: { agentId: 'agent2', tier: 'council' },
+        agent4: { agentId: 'agent4', tier: 'council' },
+        agent3: { agentId: 'agent3', tier: 'council' },
+        agent6: { agentId: 'agent6', tier: 'council' },
+        agent5: { agentId: 'agent5', tier: 'council' },
+        director1: { agentId: 'director1', tier: 'director', org: 'agent1-org', councilLead: 'agent1' },
+        director2: { agentId: 'director2', tier: 'director', org: 'agent1-org', councilLead: 'agent1' },
+        director3: { agentId: 'director3', tier: 'director', org: 'agent1-org', councilLead: 'agent1' },
+        director4: { agentId: 'director4', tier: 'director', org: 'agent2-org', councilLead: 'agent2' },
+        director5: { agentId: 'director5', tier: 'director', org: 'agent2-org', councilLead: 'agent2' },
+        director6: { agentId: 'director6', tier: 'director', org: 'agent2-org', councilLead: 'agent2' },
+        director7: { agentId: 'director7', tier: 'director', org: 'agent3-org', councilLead: 'agent3' },
+        director8: { agentId: 'director8', tier: 'director', org: 'agent3-org', councilLead: 'agent3' },
+        specialist1: { agentId: 'specialist1', tier: 'specialist' },
+        specialist2: { agentId: 'specialist2', tier: 'specialist' },
     };
     const orgs = {
-        'alice-org': ['alice', 'hank', 'jack', 'irene'],
-        'bob-org': ['bob', 'eve', 'frank', 'grace'],
-        'dave-org': ['dave', 'leo', 'kate'],
+        'agent1-org': ['agent1', 'director1', 'director2', 'director3'],
+        'agent2-org': ['agent2', 'director4', 'director5', 'director6'],
+        'agent3-org': ['agent3', 'director7', 'director8'],
     };
     return { orgs, agents };
 }

package/dist/db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../src/db.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAqC3C,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;CACjB;AAQD;;;GAGG;AACH,iBAAS,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAI9C;AAED;;;GAGG;AACH,iBAAS,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAIvD;AAmBD,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,CAAC;AAEpD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmC;IAC9D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmC;IAC7D,OAAO,CAAC,SAAS,CAA6B;IAC9C,OAAO,CAAC,aAAa,CAAwB;IAE7C,6EAA6E;IAC7E,IAAI,YAAY,IAAI,OAAO,CAE1B;gBAEW,MAAM,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC;IAKnD;;;OAGG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY;IAiB3C;;;;OAIG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IA0BjD;;;;;;OAMG;IACH,iBAAiB,IAAI,YAAY,GAAG,IAAI;IAsBxC;;;OAGG;IACH,YAAY,IAAI,YAAY;IAa5B;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY;IAIzC;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAClC,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,GAAG,IAAI;IA2BR;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA+BxB;;OAEG;IACH,UAAU,IAAI,MAAM,EAAE;IAWtB;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAKpC;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAQzC;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAWzC;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IA8C/C;;;;;;;OAOG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QACnC,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GAAG;QAAE,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IA4BzE;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY;IAc9D;;OAEG;IACH,KAAK,IAAI,IAAI;CAgBd"}
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../src/db.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAuC3C,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;CACjB;AAQD;;;GAGG;AACH,iBAAS,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAI9C;AAED;;;GAGG;AACH,iBAAS,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAIvD;AAmBD,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,CAAC;AAEpD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmC;IAC9D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmC;IAC7D,OAAO,CAAC,SAAS,CAA6B;IAC9C,OAAO,CAAC,aAAa,CAAwB;IAE7C,6EAA6E;IAC7E,IAAI,YAAY,IAAI,OAAO,CAE1B;gBAEW,MAAM,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC;IAKnD;;;OAGG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY;IAwB3C;;;;OAIG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IA0BjD;;;;;;OAMG;IACH,iBAAiB,IAAI,YAAY,GAAG,IAAI;IAsBxC;;;OAGG;IACH,YAAY,IAAI,YAAY;IAa5B;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY;IAIzC;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAClC,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,GAAG,IAAI;IA2BR;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA+BxB;;OAEG;IACH,UAAU,IAAI,MAAM,EAAE;IAWtB;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAKpC;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAQzC;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAWzC;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IA8C/C;;;;;;;OAOG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QACnC,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GAAG;QAAE,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IA4BzE;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY;IAc9D;;OAEG;IACH,KAAK,IAAI,IAAI;CAgBd"}

package/dist/db.js

@@ -15,6 +15,8 @@ import path from 'node:path';
 import { migrate } from './schema.js';
 import { migrateLibrary } from './library-schema.js';
 import { ENGINE_VERSION } from './version.js';
+import { ensureContextSchema } from './context-store.js';
+import { backfillContexts } from './context-backfill.js';
 // sqlite-vec extension loading — optional dependency
 import { createRequire } from 'node:module';
 let sqliteVecAvailable = null;
@@ -106,6 +108,12 @@ export class DatabaseManager {
         db = new DatabaseSync(dbPath);
         applyPragmas(db);
         migrate(db);
+        ensureContextSchema(db);
+        // Backfill contexts for existing conversations on first run after migration
+        const contextCount = db.prepare('SELECT COUNT(*) as cnt FROM contexts').get();
+        if (contextCount.cnt === 0) {
+            backfillContexts(db);
+        }
         this.messageDbs.set(agentId, db);
         return db;
     }

package/dist/dreaming-promoter.d.ts

@@ -67,7 +67,7 @@ export interface DreamerResult {
 }
 /**
  * Resolve the workspace directory for an agent.
- * Council agents live at ~/.openclaw/workspace/{agentId}/
+ * Council agents live at ~/.openclaw/workspace-council/{agentId}/
  * Other agents at ~/.openclaw/workspace/{agentId}/
  */
 export declare function resolveAgentWorkspacePath(agentId: string): Promise<string | null>;

package/dist/dreaming-promoter.js

@@ -31,7 +31,7 @@ export const DEFAULT_DREAMER_CONFIG = {
 // ─── Workspace path resolution ───────────────────────────────────────────────
 /**
  * Resolve the workspace directory for an agent.
- * Council agents live at ~/.openclaw/workspace/{agentId}/
+ * Council agents live at ~/.openclaw/workspace-council/{agentId}/
  * Other agents at ~/.openclaw/workspace/{agentId}/
  */
 export async function resolveAgentWorkspacePath(agentId) {

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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"}