society-protocol 1.0.1 → 1.2.0

package/dist/knowledge.js

@@ -10,7 +10,95 @@
  */
 import { EventEmitter } from 'events';
 import { ulid } from 'ulid';
-// ─── Knowledge Pool Engine ───────────────────────────────────────
+/**
+ * Compare two vector clocks for causal ordering.
+ * Returns:
+ *   'before'     — a causally precedes b (a < b)
+ *   'after'      — a causally follows b (a > b)
+ *   'concurrent' — neither precedes the other
+ *   'equal'      — identical clocks
+ */
+export function compareVectorClocks(a, b) {
+    const allNodes = new Set([...Object.keys(a), ...Object.keys(b)]);
+    let aLess = false;
+    let bLess = false;
+    for (const node of allNodes) {
+        const va = a[node] || 0;
+        const vb = b[node] || 0;
+        if (va < vb)
+            aLess = true;
+        if (va > vb)
+            bLess = true;
+        if (aLess && bLess)
+            return 'concurrent';
+    }
+    if (!aLess && !bLess)
+        return 'equal';
+    if (aLess && !bLess)
+        return 'before';
+    return 'after';
+}
+/**
+ * Merge two vector clocks by taking component-wise maximum.
+ */
+export function mergeVectorClocks(a, b) {
+    const merged = { ...a };
+    for (const [node, count] of Object.entries(b)) {
+        merged[node] = Math.max(merged[node] || 0, count);
+    }
+    return merged;
+}
+/**
+ * Advance HLC for a local event (Kulkarni et al. 2014, §3.1).
+ * l' = max(l.wallTime, pt) ; c' = (l' == l.wallTime) ? l.logical + 1 : 0
+ */
+export function tickHLC(current) {
+    const pt = Date.now();
+    if (pt > current.wallTime) {
+        return { wallTime: pt, logical: 0, nodeId: current.nodeId };
+    }
+    return { wallTime: current.wallTime, logical: current.logical + 1, nodeId: current.nodeId };
+}
+/**
+ * Receive HLC from a remote message (Kulkarni et al. 2014, §3.2).
+ * Merges local and remote clocks to maintain causal ordering.
+ */
+export function receiveHLC(local, remote) {
+    const pt = Date.now();
+    const maxWall = Math.max(local.wallTime, remote.wallTime, pt);
+    let logical;
+    if (maxWall === local.wallTime && maxWall === remote.wallTime) {
+        logical = Math.max(local.logical, remote.logical) + 1;
+    }
+    else if (maxWall === local.wallTime) {
+        logical = local.logical + 1;
+    }
+    else if (maxWall === remote.wallTime) {
+        logical = remote.logical + 1;
+    }
+    else {
+        logical = 0; // pt is strictly greater
+    }
+    return { wallTime: maxWall, logical, nodeId: local.nodeId };
+}
+/**
+ * Compare two HLCs for total ordering.
+ * Returns negative if a < b, positive if a > b, 0 if equal.
+ * Tie-breaking: wallTime → logical → nodeId (lexicographic).
+ */
+export function compareHLC(a, b) {
+    if (a.wallTime !== b.wallTime)
+        return a.wallTime - b.wallTime;
+    if (a.logical !== b.logical)
+        return a.logical - b.logical;
+    return a.nodeId < b.nodeId ? -1 : a.nodeId > b.nodeId ? 1 : 0;
+}
+const DEFAULT_COMPACTION_CONFIG = {
+    compactAfterMessages: 20,
+    maxRecentMessages: 40,
+    ollamaUrl: 'http://127.0.0.1:11434',
+    ollamaModel: 'qwen3:1.7b',
+};
 export class KnowledgePool extends EventEmitter {
     storage;
     identity;
@@ -25,10 +113,15 @@ export class KnowledgePool extends EventEmitter {
     // Link indexes for O(1) graph traversal (fixes N+1 query)
     linksBySource = new Map();
     linksByTarget = new Map();
-    constructor(storage, identity) {
+    // Chat message buffers per space (for auto-compaction)
+    chatBuffers = new Map();
+    compactionConfig;
+    compacting = new Set(); // spaces currently compacting
+    constructor(storage, identity, compactionConfig) {
         super();
         this.storage = storage;
         this.identity = identity;
+        this.compactionConfig = { ...DEFAULT_COMPACTION_CONFIG, ...compactionConfig };
         this.loadFromStorage();
     }
     // ─── Space Management ────────────────────────────────────────
@@ -129,9 +222,10 @@ export class KnowledgePool extends EventEmitter {
             // TODO: Verificar permissões de edição
             throw new Error('No permission to edit');
         }
-        // CRDT: Incrementar versão e atualizar clocks
+        // CRDT: Advance HLC (Kulkarni et al. 2014) and increment vector clock
         card.version++;
         card.updatedAt = Date.now();
+        card.crdt.hlc = tickHLC(card.crdt.hlc);
         card.crdt.vectorClock[this.identity.did] =
             (card.crdt.vectorClock[this.identity.did] || 0) + 1;
         // Aplicar updates
@@ -170,6 +264,166 @@ export class KnowledgePool extends EventEmitter {
         await this.saveCard(card);
         this.emit('card:deleted', id);
     }
+    // ─── CRDT Merge ────────────────────────────────────────────────
+    /**
+     * Merge a remote knowledge card with the local copy.
+     *
+     * Algorithm (state-based CRDT with causal metadata):
+     * 1. If card is unknown locally → accept remote (new knowledge).
+     * 2. Compare vector clocks for causal ordering:
+     *    - remote ≤ local  → discard (stale).
+     *    - local < remote  → accept remote (strictly newer).
+     *    - concurrent      → LWW tie-break on HLC (wallTime, logical, nodeId).
+     * 3. Merge vector clocks (component-wise max) regardless of winner.
+     * 4. Advance local HLC via receiveHLC to maintain causal consistency.
+     * 5. Tombstone wins: if either copy is tombstoned, result is tombstoned.
+     *
+     * Returns the merged card, or null if the remote was stale.
+     */
+    mergeCard(remote) {
+        const local = this.cards.get(remote.id);
+        // Case 1: New card — accept remote entirely
+        if (!local) {
+            // Advance our HLC on receipt of remote clock
+            const mergedHlc = receiveHLC({ wallTime: Date.now(), logical: 0, nodeId: this.identity.did }, remote.crdt.hlc);
+            const card = {
+                ...remote,
+                crdt: {
+                    ...remote.crdt,
+                    hlc: mergedHlc,
+                    vectorClock: { ...remote.crdt.vectorClock }
+                }
+            };
+            this.cards.set(card.id, card);
+            const space = this.spaces.get(card.spaceId);
+            if (space && !card.crdt.tombstone) {
+                space.cards.add(card.id);
+                space.stats.cardCount = space.cards.size;
+                space.stats.lastActivity = Date.now();
+            }
+            this.indexCard(card);
+            this.saveCard(card);
+            this.emit('card:merged', { card, action: 'new' });
+            return card;
+        }
+        // Case 2: Compare vector clocks
+        const order = compareVectorClocks(local.crdt.vectorClock, remote.crdt.vectorClock);
+        if (order === 'equal' || order === 'after') {
+            // Local is same or newer — discard remote
+            return null;
+        }
+        // Determine the winner for content (used when concurrent)
+        let winner;
+        let action;
+        if (order === 'before') {
+            // Remote is strictly newer — accept remote content
+            winner = remote;
+            action = 'remote-wins';
+        }
+        else {
+            // Concurrent — LWW tie-break on HLC
+            const hlcCmp = compareHLC(local.crdt.hlc, remote.crdt.hlc);
+            winner = hlcCmp >= 0 ? local : remote;
+            action = hlcCmp >= 0 ? 'local-wins-concurrent' : 'remote-wins-concurrent';
+        }
+        // Merge metadata regardless of content winner
+        const mergedVectorClock = mergeVectorClocks(local.crdt.vectorClock, remote.crdt.vectorClock);
+        const mergedHlc = receiveHLC(local.crdt.hlc, remote.crdt.hlc);
+        // Tombstone wins: once deleted, stays deleted
+        const tombstone = local.crdt.tombstone || remote.crdt.tombstone;
+        // Build merged card
+        const merged = {
+            ...winner,
+            crdt: {
+                hlc: mergedHlc,
+                vectorClock: mergedVectorClock,
+                tombstone
+            },
+            // Take the higher version
+            version: Math.max(local.version, remote.version),
+            // Merge usage counters (take max of each)
+            usage: {
+                views: Math.max(local.usage.views, remote.usage.views),
+                citations: Math.max(local.usage.citations, remote.usage.citations),
+                applications: Math.max(local.usage.applications, remote.usage.applications),
+                lastAccessed: Math.max(local.usage.lastAccessed, remote.usage.lastAccessed)
+            },
+            // Union verifications (deduplicate by verifier+timestamp)
+            verifications: this.mergeVerifications(local.verifications, remote.verifications)
+        };
+        // Update indexes
+        this.removeFromIndex(local);
+        this.cards.set(merged.id, merged);
+        if (!tombstone) {
+            this.indexCard(merged);
+        }
+        // Handle tombstone side effects
+        const space = this.spaces.get(merged.spaceId);
+        if (space) {
+            if (tombstone) {
+                space.cards.delete(merged.id);
+            }
+            else {
+                space.cards.add(merged.id);
+            }
+            space.stats.cardCount = space.cards.size;
+        }
+        this.saveCard(merged);
+        this.emit('card:merged', { card: merged, action });
+        return merged;
+    }
+    /**
+     * Merge verification arrays, deduplicating by (verifier, timestamp).
+     */
+    mergeVerifications(a, b) {
+        const seen = new Set();
+        const merged = [];
+        for (const v of [...a, ...b]) {
+            const key = `${v.verifier}:${v.timestamp}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                merged.push(v);
+            }
+        }
+        return merged;
+    }
+    /**
+     * Serialize a card for network transmission (GossipSub).
+     */
+    serializeCard(card) {
+        return new TextEncoder().encode(JSON.stringify(card));
+    }
+    /**
+     * Deserialize a card received from the network.
+     */
+    deserializeCard(data) {
+        const raw = JSON.parse(new TextDecoder().decode(data));
+        return this.normalizeCard(raw);
+    }
+    /**
+     * Handle incoming knowledge sync message from GossipSub.
+     * Deserializes, merges, and emits sync events.
+     */
+    handleSyncMessage(data, from) {
+        try {
+            const remote = this.deserializeCard(data);
+            const result = this.mergeCard(remote);
+            if (result) {
+                this.emit('sync:merged', { card: result, from });
+            }
+        }
+        catch (err) {
+            this.emit('sync:error', { error: err, from });
+        }
+    }
+    /**
+     * Get all cards that have been modified since a given timestamp.
+     * Used for anti-entropy sync (periodic full-state exchange).
+     */
+    getModifiedSince(since) {
+        return Array.from(this.cards.values())
+            .filter(c => c.updatedAt > since);
+    }
     async linkCards(sourceId, targetId, type, strength = 0.5, evidence) {
         // Verificar se cards existem
         if (!this.cards.has(sourceId) || !this.cards.has(targetId)) {
@@ -385,7 +639,432 @@ ${cu.sharedState.decisions.slice(-5).join('\n')}
 ${cu.workingMemory.contextWindow}
         `.trim();
     }
+    // ─── Conversational Knowledge Exchange ─────────────────────
+    /**
+     * Get or create CollectiveUnconscious for a space/room.
+     * Public so rooms can initialize knowledge tracking.
+     */
+    async getOrCreateCU(spaceId) {
+        const existing = this.collectiveUnconscious.get(spaceId);
+        if (existing)
+            return existing;
+        return this.createCollectiveUnconscious(spaceId);
+    }
+    /**
+     * Ingest a chat message into the collaborative context.
+     * Called by RoomManager when chat messages are received.
+     * Triggers auto-compaction when buffer exceeds threshold.
+     */
+    async ingestChatMessage(spaceId, msg) {
+        const cu = await this.getOrCreateCU(spaceId);
+        // Add to raw buffer
+        if (!this.chatBuffers.has(spaceId)) {
+            this.chatBuffers.set(spaceId, []);
+        }
+        const buffer = this.chatBuffers.get(spaceId);
+        buffer.push(msg);
+        // Update working memory
+        const senderLabel = msg.senderName || msg.sender.slice(0, 16);
+        cu.workingMemory.recentMessages.push(`[${senderLabel}]: ${msg.content}`);
+        // Track participants
+        if (!cu.workingMemory.participants.includes(msg.sender)) {
+            cu.workingMemory.participants.push(msg.sender);
+        }
+        // Trim recent messages to max
+        const max = this.compactionConfig.maxRecentMessages;
+        if (cu.workingMemory.recentMessages.length > max) {
+            cu.workingMemory.recentMessages = cu.workingMemory.recentMessages.slice(-max);
+        }
+        cu.lastUpdate = Date.now();
+        // Auto-compact when buffer reaches threshold
+        if (buffer.length >= this.compactionConfig.compactAfterMessages && !this.compacting.has(spaceId)) {
+            this.compacting.add(spaceId);
+            this.compactContext(spaceId).finally(() => this.compacting.delete(spaceId));
+        }
+        this.emit('chat:ingested', { spaceId, msg });
+    }
+    /**
+     * Compact the conversation context using Ollama.
+     * Summarizes recent messages into a dense context window,
+     * extracts key concepts, decisions, and open questions.
+     */
+    async compactContext(spaceId) {
+        const cu = this.collectiveUnconscious.get(spaceId);
+        if (!cu)
+            return;
+        const buffer = this.chatBuffers.get(spaceId) || [];
+        if (buffer.length === 0)
+            return;
+        // Build conversation transcript
+        const transcript = buffer.map(m => {
+            const name = m.senderName || m.sender.slice(0, 16);
+            return `${name}: ${m.content}`;
+        }).join('\n');
+        const previousContext = cu.workingMemory.contextWindow || '';
+        try {
+            const response = await this.callOllama(`You are a context compactor for a multi-agent conversation system.
+
+Given the previous context summary and new conversation messages, produce a COMPACT updated context.
+
+PREVIOUS CONTEXT:
+${previousContext || '(none)'}
+
+NEW MESSAGES:
+${transcript}
+
+Produce a JSON response with these fields:
+- "contextSummary": A concise summary of the conversation state (max 500 chars)
+- "activeTopics": Array of topic strings currently being discussed
+- "keyConcepts": Array of key facts/concepts established
+- "decisions": Array of decisions made (if any)
+- "openQuestions": Array of unresolved questions
+- "recurringThemes": Array of recurring themes
+
+Respond ONLY with valid JSON, no markdown.`);
+            const parsed = this.parseJsonResponse(response);
+            if (parsed) {
+                cu.workingMemory.contextWindow = parsed.contextSummary || previousContext;
+                cu.workingMemory.activeTopics = parsed.activeTopics || cu.workingMemory.activeTopics;
+                if (parsed.keyConcepts?.length) {
+                    for (const concept of parsed.keyConcepts) {
+                        if (!cu.longTermMemory.keyConcepts.includes(concept)) {
+                            cu.longTermMemory.keyConcepts.push(concept);
+                        }
+                    }
+                    // Keep bounded
+                    cu.longTermMemory.keyConcepts = cu.longTermMemory.keyConcepts.slice(-50);
+                }
+                if (parsed.decisions?.length) {
+                    cu.sharedState.decisions.push(...parsed.decisions);
+                    cu.sharedState.decisions = cu.sharedState.decisions.slice(-20);
+                }
+                if (parsed.openQuestions?.length) {
+                    cu.sharedState.openQuestions = parsed.openQuestions;
+                }
+                if (parsed.recurringThemes?.length) {
+                    cu.longTermMemory.recurringThemes = parsed.recurringThemes;
+                }
+            }
+        }
+        catch {
+            // Ollama unavailable — use simple text compaction
+            cu.workingMemory.contextWindow = this.simpleCompact(previousContext, transcript);
+        }
+        // Clear the buffer after compaction
+        this.chatBuffers.set(spaceId, []);
+        cu.lastUpdate = Date.now();
+        cu.coherence = Math.min(1.0, cu.coherence + 0.05);
+        await this.saveCollectiveUnconscious(cu);
+        this.emit('context:compacted', { spaceId, cu });
+    }
+    /**
+     * Serialize the collaborative context for sharing with peers.
+     * Used by knowledge.context_sync SWP messages.
+     */
+    serializeContext(spaceId) {
+        const cu = this.collectiveUnconscious.get(spaceId);
+        if (!cu)
+            return null;
+        const payload = {
+            spaceId,
+            contextWindow: cu.workingMemory.contextWindow,
+            activeTopics: cu.workingMemory.activeTopics,
+            keyConcepts: cu.longTermMemory.keyConcepts,
+            recurringThemes: cu.longTermMemory.recurringThemes,
+            decisions: cu.sharedState.decisions,
+            openQuestions: cu.sharedState.openQuestions,
+            lastUpdate: cu.lastUpdate,
+        };
+        return new TextEncoder().encode(JSON.stringify(payload));
+    }
+    /**
+     * Merge a remote context sync into the local CollectiveUnconscious.
+     * Takes the union of topics, concepts, decisions, etc.
+     */
+    async mergeRemoteContext(data) {
+        try {
+            const remote = JSON.parse(new TextDecoder().decode(data));
+            const cu = await this.getOrCreateCU(remote.spaceId);
+            // Merge context window: keep longer/newer
+            if (remote.lastUpdate > cu.lastUpdate && remote.contextWindow) {
+                cu.workingMemory.contextWindow = remote.contextWindow;
+            }
+            // Union active topics
+            if (remote.activeTopics?.length) {
+                const topics = new Set([...cu.workingMemory.activeTopics, ...remote.activeTopics]);
+                cu.workingMemory.activeTopics = Array.from(topics).slice(-20);
+            }
+            // Union key concepts
+            if (remote.keyConcepts?.length) {
+                const concepts = new Set([...cu.longTermMemory.keyConcepts, ...remote.keyConcepts]);
+                cu.longTermMemory.keyConcepts = Array.from(concepts).slice(-50);
+            }
+            // Union recurring themes
+            if (remote.recurringThemes?.length) {
+                const themes = new Set([...cu.longTermMemory.recurringThemes, ...remote.recurringThemes]);
+                cu.longTermMemory.recurringThemes = Array.from(themes);
+            }
+            // Union decisions
+            if (remote.decisions?.length) {
+                const decisions = new Set([...cu.sharedState.decisions, ...remote.decisions]);
+                cu.sharedState.decisions = Array.from(decisions).slice(-20);
+            }
+            // Merge open questions
+            if (remote.openQuestions?.length) {
+                const questions = new Set([...cu.sharedState.openQuestions, ...remote.openQuestions]);
+                cu.sharedState.openQuestions = Array.from(questions);
+            }
+            cu.lastUpdate = Math.max(cu.lastUpdate, remote.lastUpdate);
+            await this.saveCollectiveUnconscious(cu);
+            this.emit('context:synced', { spaceId: remote.spaceId });
+        }
+        catch (err) {
+            this.emit('context:sync-error', { error: err });
+        }
+    }
+    /**
+     * Get the chat message buffer for a space (for inspection/testing).
+     */
+    getChatBuffer(spaceId) {
+        return this.chatBuffers.get(spaceId) || [];
+    }
+    // ─── Knowledge Gossip Sync ───────────────────────────────────
+    /**
+     * Get top knowledge cards for gossip broadcast to peers.
+     * Returns cards sorted by confidence * usage, most valuable first.
+     */
+    getGossipPayload(spaceId, limit = 10) {
+        return this.queryCards({
+            spaceId,
+            sortBy: 'relevance',
+            limit,
+        });
+    }
+    /**
+     * Apply knowledge decay to all cards.
+     * Cards not reinforced lose confidence over time.
+     * Should be called periodically (e.g., daily).
+     *
+     * @param decayRate - fraction of confidence lost per call (default 0.05 = 5%)
+     */
+    applyKnowledgeDecay(decayRate = 0.05) {
+        let decayed = 0;
+        const now = Date.now();
+        const dayMs = 24 * 60 * 60 * 1000;
+        for (const card of this.cards.values()) {
+            if (card.crdt.tombstone)
+                continue;
+            const daysSinceAccess = (now - card.usage.lastAccessed) / dayMs;
+            if (daysSinceAccess < 1)
+                continue; // Skip recently accessed
+            const oldConfidence = card.confidence;
+            card.confidence = Math.max(0.1, card.confidence * (1 - decayRate));
+            if (card.confidence !== oldConfidence) {
+                card.updatedAt = now;
+                this.saveCard(card);
+                decayed++;
+            }
+        }
+        this.emit('knowledge:decay', { decayed, decayRate });
+        return decayed;
+    }
+    /**
+     * Boost confidence when multiple agents confirm the same fact.
+     * If 2+ agents have verified a card, boost by confirmationBoost.
+     *
+     * @param cardId - card to boost
+     * @param verifierDid - DID of the confirming agent
+     * @param boostAmount - confidence boost (default 0.2 = 20%)
+     */
+    confirmKnowledge(cardId, verifierDid, boostAmount = 0.2) {
+        const card = this.cards.get(cardId);
+        if (!card || card.crdt.tombstone)
+            return null;
+        // Add verification if not already present
+        const alreadyVerified = card.verifications.some(v => v.verifier === verifierDid);
+        if (!alreadyVerified) {
+            card.verifications.push({
+                verifier: verifierDid,
+                timestamp: Date.now(),
+                method: 'consensus',
+                confidence: card.confidence + boostAmount,
+            });
+        }
+        // Boost confidence based on number of unique verifiers
+        const uniqueVerifiers = new Set(card.verifications.map(v => v.verifier));
+        if (uniqueVerifiers.size >= 2) {
+            card.confidence = Math.min(1.0, card.confidence + boostAmount);
+            card.verificationStatus = 'verified';
+        }
+        card.updatedAt = Date.now();
+        card.crdt.hlc = tickHLC(card.crdt.hlc);
+        card.crdt.vectorClock[this.identity.did] =
+            (card.crdt.vectorClock[this.identity.did] || 0) + 1;
+        this.saveCard(card);
+        this.emit('knowledge:confirmed', { cardId, verifier: verifierDid, confidence: card.confidence });
+        return card;
+    }
+    /**
+     * Distill lessons learned from a completed CoC chain.
+     * Creates knowledge cards from the chain's experience.
+     *
+     * @param chainId - ID of the completed chain
+     * @param summary - chain summary/final report
+     * @param goal - original chain goal
+     * @param spaceId - space to store knowledge in
+     * @param participants - DIDs of participating agents
+     */
+    async distillChainExperience(chainId, summary, goal, spaceId, participants) {
+        const space = this.spaces.get(spaceId);
+        if (!space)
+            return [];
+        const cards = [];
+        try {
+            const response = await this.callOllama(`You are a knowledge extractor for a multi-agent collaboration system.
+
+A collaborative chain (goal: "${goal}") has completed. Extract the key lessons learned.
+
+CHAIN SUMMARY:
+${summary}
+
+PARTICIPANTS: ${participants.length} agents
+
+Produce a JSON array of knowledge items to store. Each item should have:
+- "type": one of "insight", "decision", "sop", "finding"
+- "title": concise title (max 80 chars)
+- "content": detailed description
+- "tags": array of relevant tags
+- "confidence": 0-1 confidence score
+
+Respond ONLY with a valid JSON array.`);
+            const parsed = this.parseJsonResponse(response);
+            const items = Array.isArray(parsed) ? parsed : (parsed?.items || []);
+            for (const item of items.slice(0, 5)) {
+                if (!item.title || !item.content)
+                    continue;
+                const card = await this.createCard(spaceId, item.type || 'insight', item.title, item.content, {
+                    tags: item.tags || [],
+                    source: { type: 'coc', id: chainId, context: goal },
+                    confidence: item.confidence || 0.7,
+                });
+                cards.push(card);
+            }
+        }
+        catch {
+            // Ollama unavailable — create a single summary card
+            const card = await this.createCard(spaceId, 'finding', `Chain ${chainId.slice(0, 8)}: ${goal}`, summary, {
+                tags: ['chain-distill', 'auto-extracted'],
+                source: { type: 'coc', id: chainId, context: goal },
+                confidence: 0.6,
+            });
+            cards.push(card);
+        }
+        this.emit('knowledge:distilled', { chainId, cardCount: cards.length });
+        return cards;
+    }
+    /**
+     * Extract knowledge from a batch of chat messages.
+     * Used for periodic knowledge extraction from conversations.
+     */
+    async extractFromConversation(spaceId, messages) {
+        const space = this.spaces.get(spaceId);
+        if (!space || messages.length === 0)
+            return [];
+        const transcript = messages.map(m => {
+            const name = m.senderName || m.sender.slice(0, 16);
+            return `${name}: ${m.content}`;
+        }).join('\n');
+        const cards = [];
+        try {
+            const response = await this.callOllama(`You are a knowledge extractor. Extract key facts and insights from this conversation.
+
+CONVERSATION:
+${transcript}
+
+Extract structured knowledge items as a JSON array. Each item:
+- "type": "fact" | "insight" | "decision" | "hypothesis"
+- "title": concise title
+- "content": the knowledge content
+- "tags": relevant tags
+- "confidence": 0-1
+
+Only extract genuinely useful knowledge. Skip small talk or trivial messages.
+Respond ONLY with a valid JSON array. Return empty array [] if nothing useful.`);
+            const parsed = this.parseJsonResponse(response);
+            const items = Array.isArray(parsed) ? parsed : [];
+            for (const item of items.slice(0, 5)) {
+                if (!item.title || !item.content)
+                    continue;
+                const card = await this.createCard(spaceId, item.type || 'fact', item.title, item.content, {
+                    tags: [...(item.tags || []), 'auto-extracted', 'chat'],
+                    source: { type: 'chat', context: spaceId },
+                    confidence: item.confidence || 0.6,
+                });
+                cards.push(card);
+            }
+        }
+        catch {
+            // Ollama unavailable — skip extraction
+        }
+        this.emit('knowledge:extracted', { spaceId, cardCount: cards.length });
+        return cards;
+    }
     // ─── Private Helpers ─────────────────────────────────────────
+    /**
+     * Simple text-based compaction when Ollama is unavailable.
+     * Keeps last few lines of previous context + summary of new transcript.
+     */
+    simpleCompact(previousContext, newTranscript) {
+        const prevLines = previousContext ? previousContext.split('\n').slice(-5).join('\n') : '';
+        const newLines = newTranscript.split('\n');
+        const summary = newLines.length > 10
+            ? `[${newLines.length} messages exchanged covering: ${newLines.slice(0, 3).join('; ')}...]`
+            : newLines.join('\n');
+        return [prevLines, summary].filter(Boolean).join('\n---\n').slice(-2000);
+    }
+    /**
+     * Call Ollama for context summarization.
+     */
+    async callOllama(prompt) {
+        const url = `${this.compactionConfig.ollamaUrl}/api/generate`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: this.compactionConfig.ollamaModel,
+                prompt,
+                stream: false,
+                options: { temperature: 0.3, num_predict: 1024 },
+            }),
+        });
+        if (!res.ok)
+            throw new Error(`Ollama error: ${res.status}`);
+        const json = await res.json();
+        return json.response;
+    }
+    /**
+     * Parse JSON from LLM response (handles markdown code blocks).
+     */
+    parseJsonResponse(text) {
+        // Strip thinking tags if present
+        let cleaned = text.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+        // Strip markdown code blocks
+        cleaned = cleaned.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '').trim();
+        try {
+            return JSON.parse(cleaned);
+        }
+        catch {
+            // Try to extract JSON object
+            const match = cleaned.match(/\{[\s\S]*\}/);
+            if (match) {
+                try {
+                    return JSON.parse(match[0]);
+                }
+                catch { /* ignore */ }
+            }
+            return null;
+        }
+    }
     generateSummary(content, maxLength = 200) {
         // Remover markdown
         const plain = content