opencode-fractal-memory 0.2.0

package/dist/hnsw-index.js

@@ -0,0 +1,138 @@
+import { HNSW } from "hnsw";
+const M = 16;
+const EF_CONSTRUCTION = 200;
+const EF_SEARCH = 64;
+export class HNSWIndex {
+    globalIndex = null;
+    projectIndex = null;
+    globalLabelMap;
+    projectLabelMap;
+    globalIdCounter;
+    projectIdCounter;
+    dimension;
+    initialized = false;
+    constructor(dimension = 384) {
+        this.dimension = dimension;
+        this.globalLabelMap = new Map();
+        this.projectLabelMap = new Map();
+        this.globalIdCounter = 0;
+        this.projectIdCounter = 0;
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            this.globalIndex = new HNSW(M, EF_CONSTRUCTION, this.dimension, "cosine", EF_SEARCH);
+            this.projectIndex = new HNSW(M, EF_CONSTRUCTION, this.dimension, "cosine", EF_SEARCH);
+            this.initialized = true;
+        }
+    }
+    getIndex(scope) {
+        this.ensureInitialized();
+        return scope === "global" ? this.globalIndex : this.projectIndex;
+    }
+    getMaps(scope) {
+        return scope === "global" ? this.globalLabelMap : this.projectLabelMap;
+    }
+    getCounter(scope) {
+        return scope === "global"
+            ? { value: this.globalIdCounter }
+            : { value: this.projectIdCounter };
+    }
+    setCounter(scope, value) {
+        if (scope === "global") {
+            this.globalIdCounter = value;
+        }
+        else {
+            this.projectIdCounter = value;
+        }
+    }
+    async addNode(scope, nodeId, embedding) {
+        if (embedding.length !== this.dimension) {
+            return -1;
+        }
+        this.ensureInitialized();
+        const index = this.getIndex(scope);
+        const labelMap = this.getMaps(scope);
+        const counter = this.getCounter(scope);
+        const hnswId = counter.value;
+        labelMap.set(hnswId, nodeId);
+        counter.value = hnswId + 1;
+        await index.addPoint(hnswId, embedding);
+        this.setCounter(scope, counter.value);
+        return hnswId;
+    }
+    async removeNode(scope, nodeId) {
+        const labelMap = this.getMaps(scope);
+        for (const [hnswId, storedId] of labelMap) {
+            if (storedId === nodeId) {
+                labelMap.delete(hnswId);
+                return;
+            }
+        }
+    }
+    async search(query, limit, scope, _levelFilter) {
+        if (!this.initialized || query.length !== this.dimension) {
+            return [];
+        }
+        let results;
+        if (scope === "global") {
+            results = this.globalIndex.searchKNN(query, limit);
+        }
+        else if (scope === "project") {
+            results = this.projectIndex.searchKNN(query, limit);
+        }
+        else {
+            const globalResults = this.globalIndex.searchKNN(query, limit);
+            const projectResults = this.projectIndex.searchKNN(query, limit);
+            const combined = [...globalResults, ...projectResults];
+            combined.sort((a, b) => b.score - a.score);
+            results = combined.slice(0, limit);
+        }
+        return results.map(r => {
+            let nodeId;
+            if (scope === "global") {
+                nodeId = this.globalLabelMap.get(r.id) ?? "";
+            }
+            else if (scope === "project") {
+                nodeId = this.projectLabelMap.get(r.id) ?? "";
+            }
+            else {
+                nodeId = this.globalLabelMap.get(r.id) ?? this.projectLabelMap.get(r.id) ?? "";
+            }
+            return { id: nodeId, score: r.score };
+        });
+    }
+    async rebuild(nodes) {
+        if (nodes.length > 0) {
+            this.dimension = nodes[0].embedding.length;
+        }
+        this.globalIndex = new HNSW(M, EF_CONSTRUCTION, this.dimension, "cosine", EF_SEARCH);
+        this.projectIndex = new HNSW(M, EF_CONSTRUCTION, this.dimension, "cosine", EF_SEARCH);
+        this.globalLabelMap.clear();
+        this.projectLabelMap.clear();
+        this.globalIdCounter = 0;
+        this.projectIdCounter = 0;
+        this.initialized = true;
+        for (const node of nodes) {
+            if (node.embedding.length === this.dimension) {
+                await this.addNode(node.scope, node.id, node.embedding);
+            }
+        }
+    }
+    getStats() {
+        return {
+            globalNodes: this.globalLabelMap.size,
+            projectNodes: this.projectLabelMap.size,
+            dimension: this.dimension,
+        };
+    }
+}
+let hnswInstance = null;
+export function getHNSWIndex(dimension = 384) {
+    if (!hnswInstance) {
+        hnswInstance = new HNSWIndex(dimension);
+    }
+    return hnswInstance;
+}
+export function resetHNSWIndex() {
+    hnswInstance = null;
+}

package/dist/hooks/auto-discover.js

@@ -0,0 +1,4 @@
+export {};
+// Playbook auto-discovery is now agent-driven.
+// The agent proposes playbooks when it notices repeated multi-step workflows.
+// Creates them via memory_set(label, ..., type: "playbook", sticky: true, metadata: { steps: [...] }).

package/dist/hooks/auto-distill.js

@@ -0,0 +1,120 @@
+import { memLog } from "../logging";
+export async function distillRules(store, config, sessionId, client) {
+    const lessons = await store.listNodes("global");
+    const lessonNodes = lessons.filter(n => n.label?.startsWith("lesson:") && !n.label.includes(":", 7));
+    if (lessonNodes.length < config.minLessons) {
+        return `Auto-distill: skipped, have ${lessonNodes.length} lessons, need ${config.minLessons}`;
+    }
+    const recentLessons = lessonNodes
+        .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
+        .slice(0, 10);
+    const fixes = [];
+    const allLessonNodes = lessons.filter(n => n.label?.startsWith("lesson:"));
+    for (const lesson of recentLessons) {
+        const fixNode = allLessonNodes.find(n => n.label === `${lesson.label}:fix`);
+        if (fixNode?.content) {
+            fixes.push(...fixNode.content.split("\n").filter(l => l.trim()));
+        }
+    }
+    const uniqueFixes = [...new Set(fixes)];
+    const distilledRules = [];
+    for (const fix of uniqueFixes) {
+        const match = fix.match(/^- (.+)$/);
+        const action = match?.[1];
+        if (action) {
+            if (action.includes("memory_drilldown")) {
+                distilledRules.push("- Avoid memory_drilldown with vague queries - use memory_search first");
+            }
+            else if (action.includes("memory_get")) {
+                distilledRules.push("- Always verify label exists before memory_get");
+            }
+            else if (action.includes("memory_replace")) {
+                distilledRules.push("- Re-read file before replace to ensure content is current");
+            }
+            else if (action.includes("read") || action.includes("glob")) {
+                distilledRules.push("- Check if file exists before read/glob");
+            }
+            else if (action.includes("search before get")) {
+                // Already in rules, skip
+            }
+            else {
+                distilledRules.push(`- ${action}`);
+            }
+        }
+    }
+    if (config.useLlm && client && client?.session?.prompt) {
+        try {
+            const lessonContent = recentLessons.map(l => l.content).join("\n---\n");
+            const prompt = `Based on these lesson summaries, generate specific, actionable rules for the agent.
+
+Lessons:
+${lessonContent}
+
+Current rules:
+${distilledRules.join("\n")}
+
+Generate more specific rules based on the lessons. Focus on:
+1. What specific checks to do before calling tools
+2. What common mistakes to avoid
+3. What order of operations works best
+
+Format as bullet points starting with "- ".
+
+Your rules:`;
+            const result = await client
+                .session?.prompt({
+                path: { id: sessionId ?? "auto-distill" },
+                body: {
+                    noReply: true,
+                    parts: [{ type: 'text', text: prompt }],
+                },
+            });
+            if (result) {
+                const llmResponse = await (await result.text()).trim();
+                if (llmResponse) {
+                    const llmRules = llmResponse.split("\n")
+                        .filter((line) => line.trim().startsWith("-"))
+                        .map((line) => line.trim());
+                    if (llmRules.length > 0) {
+                        distilledRules.push(...llmRules);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            memLog("error", "auto-distill", "LLM distillation failed:", { error });
+        }
+    }
+    if (distilledRules.length === 0) {
+        return `Auto-distill: no rules extracted from ${lessonNodes.length} lessons`;
+    }
+    const mandatoryNode = await store.getNodeByLabel("global", "rule:mandatory:memory").catch(() => null);
+    if (!mandatoryNode) {
+        return "Auto-distill: rule:mandatory:memory node not found";
+    }
+    const existingRules = mandatoryNode.content;
+    const newRules = [];
+    for (const rule of distilledRules) {
+        const ruleText = rule.replace(/^- /, "");
+        if (!existingRules.toLowerCase().includes(ruleText.toLowerCase().slice(0, 30))) {
+            newRules.push(rule);
+        }
+    }
+    if (newRules.length === 0) {
+        return `Auto-distill: no new rules (${lessonNodes.length} lessons, all ${distilledRules.length} rules already exist)`;
+    }
+    const autoLearnedSection = "### Auto-Learned";
+    const sectionIdx = existingRules.indexOf(autoLearnedSection);
+    let updatedContent;
+    if (sectionIdx >= 0) {
+        const before = existingRules.slice(0, sectionIdx + autoLearnedSection.length);
+        const after = existingRules.slice(sectionIdx + autoLearnedSection.length);
+        updatedContent = before + "\n" + newRules.join("\n") + after;
+    }
+    else {
+        updatedContent = existingRules + "\n\n" + autoLearnedSection + "\n" + newRules.join("\n");
+    }
+    await store.updateNode(mandatoryNode.id, { content: updatedContent });
+    memLog("info", "auto-distill", `Added ${newRules.length} rules from ${lessonNodes.length} lessons`);
+    return `Auto-distill: added ${newRules.length} new rules from ${lessonNodes.length} lessons`;
+}

package/dist/hooks/auto-retrieve/content.js

@@ -0,0 +1,47 @@
+export function truncateContent(content, maxTokens) {
+    const maxChars = maxTokens * 4;
+    if (content.length <= maxChars)
+        return content;
+    let truncated = content.slice(0, maxChars);
+    const lastSpace = truncated.lastIndexOf(" ");
+    if (lastSpace > maxChars * 0.8) {
+        truncated = truncated.slice(0, lastSpace);
+    }
+    const lastNewline = truncated.lastIndexOf("\n");
+    if (lastNewline > maxChars * 0.8) {
+        truncated = truncated.slice(0, lastNewline);
+    }
+    return truncated.trim();
+}
+export function cleanContent(content) {
+    return content
+        .replace(/^#{1,6} .*$/gm, "")
+        .replace(/^tag:.*$/gm, "")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+export function formatNodeForInjection(node, maxTokensPerNode) {
+    if (node.label?.startsWith("middle-term:") || node.metadata?.customType === "middle-term") {
+        try {
+            const parsed = JSON.parse(node.content);
+            return {
+                label: node.label ?? node.id,
+                type: "middle-term",
+                sessionId: parsed.sessionId,
+                timestamp: parsed.timestamp,
+                workingCacheCount: parsed.workingCache?.length || 0,
+                recentNodesCount: parsed.recentNodes?.length || 0,
+                contextTokens: parsed.contextTokens,
+            };
+        }
+        catch {
+            // Not valid JSON, fall through
+        }
+    }
+    const cleaned = cleanContent(node.content);
+    const truncated = truncateContent(cleaned, maxTokensPerNode);
+    return {
+        label: node.label ?? node.id,
+        content: truncated,
+    };
+}

package/dist/hooks/auto-retrieve/detection.js

@@ -0,0 +1,50 @@
+import { scoreCandidates } from "./scoring";
+export async function detectRelevantSkills(store, query, queryEmbedding, maxSkills = 3, log) {
+    try {
+        const skillCandidates = await store.searchByEmbedding(queryEmbedding, maxSkills * 3, { bm25Weight: 0.3 });
+        const skills = skillCandidates.filter(n => n.type === "skill");
+        if (skills.length === 0) {
+            log("debug", "No skill nodes found");
+            return [];
+        }
+        log("debug", "Found skill candidates", { count: skills.length });
+        const scored = scoreCandidates(skills, query, queryEmbedding);
+        const threshold = 0.15;
+        const relevant = scored.filter(s => {
+            const semantic = s.embedding && queryEmbedding.length > 0
+                ? s.embedding.reduce((dot, v, i) => dot + v * (queryEmbedding[i] ?? 0), 0) /
+                    (Math.sqrt(s.embedding.reduce((s, v) => s + v * v, 0)) * Math.sqrt(queryEmbedding.reduce((s, v) => s + v * v, 0)) + 1e-8)
+                : 0;
+            return semantic > threshold;
+        });
+        const selected = relevant.slice(0, maxSkills);
+        log("info", "Skill detection", { found: skills.length, selected: selected.length });
+        return selected;
+    }
+    catch (err) {
+        log("warn", "Skill detection failed", { error: String(err) });
+        return [];
+    }
+}
+export async function detectRelevantPlaybooks(store, queryEmbedding, maxPlaybooks, log) {
+    try {
+        const candidates = await store.searchByEmbedding(queryEmbedding, maxPlaybooks * 3, { bm25Weight: 0.4 });
+        const playbooks = candidates.filter(n => n.type === "playbook");
+        if (playbooks.length === 0) {
+            log("debug", "No matching playbooks found");
+            return [];
+        }
+        const selected = playbooks.slice(0, maxPlaybooks);
+        log("info", "Playbook detection", { found: playbooks.length, selected: selected.length });
+        return selected.map(pb => ({
+            label: pb.label || pb.id,
+            description: pb.content?.slice(0, 200) || "",
+            steps: pb.metadata?.steps?.length ?? 0,
+            executionCount: pb.metadata?.executionCount ?? 0,
+        }));
+    }
+    catch (err) {
+        log("warn", "Playbook detection failed", { error: String(err) });
+        return [];
+    }
+}

package/dist/hooks/auto-retrieve/formatting.js

@@ -0,0 +1,19 @@
+export function formatPlaybooksAsAvailable(playbooks) {
+    if (playbooks.length === 0)
+        return "";
+    const entries = playbooks.map(pb => `  <playbook>\n    <name>${pb.label}</name>\n    <description>${pb.description} (${pb.steps} steps, ${pb.executionCount} runs)</description>\n    <!-- memory_playbook_execute(playbook_id="${pb.label}") -->\n  </playbook>`).join("\n");
+    return `<available_playbooks>\n${entries}\n</available_playbooks>`;
+}
+export function formatSkillsAsAvailable(skills) {
+    if (skills.length === 0)
+        return "";
+    const skillEntries = skills.map(skill => {
+        const name = skill.label?.replace(/^skill:/, "") ?? skill.id.slice(0, 8);
+        const description = skill.summary ?? skill.content.slice(0, 200);
+        const triggers = skill.metadata?.triggers
+            ? ` [triggers: ${Array.isArray(skill.metadata.triggers) ? skill.metadata.triggers.join(", ") : skill.metadata.triggers}]`
+            : "";
+        return `  <skill>\n    <name>${name}</name>\n    <description>${description}${triggers}</description>\n    <!-- memory_skill_load(name="${name}") -->\n  </skill>`;
+    }).join("\n");
+    return `<available_skills>\n${skillEntries}\n</available_skills>`;
+}

package/dist/hooks/auto-retrieve/index.js

@@ -0,0 +1,163 @@
+import { generateEmbedding } from "../../embeddings";
+import { rerankDocuments } from "../../ollama";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { scoreCandidates } from "./scoring";
+import { detectRelevantSkills, detectRelevantPlaybooks } from "./detection";
+import { formatPlaybooksAsAvailable, formatSkillsAsAvailable } from "./formatting";
+import { formatNodeForInjection } from "./content";
+const INJECTION_LOG_FILE = path.join(os.homedir(), ".config", "opencode", "memory-injection.log");
+export function createAutoRetrieveHook(deps) {
+    const { store, config, log } = deps;
+    const autoConfig = config.autoRetrieve;
+    const ollamaConfig = config.ollama;
+    const recentToolNames = [];
+    log("info", "Auto-retrieve hook created", { enabled: autoConfig?.enabled, ollamaEnabled: ollamaConfig?.enabled });
+    return {
+        "experimental.chat.messages.transform": async (_input, output) => {
+            // Process pending injection queue first
+            try {
+                const pending = await store.getPendingInjections();
+                if (pending.length > 0) {
+                    log("info", "Processing pending injections", { count: pending.length });
+                    const pendingNodes = [];
+                    for (const p of pending) {
+                        try {
+                            const node = await store.getNode(p.nodeId);
+                            pendingNodes.push(node);
+                        }
+                        catch {
+                            log("warn", "Pending injection node not found", { nodeId: p.nodeId });
+                        }
+                    }
+                    if (pendingNodes.length > 0) {
+                        const MAX_TOKENS_PER_NODE = 300;
+                        const pendingJson = pendingNodes.map(n => formatNodeForInjection(n, MAX_TOKENS_PER_NODE));
+                        const pendingBlock = `\n\n### Injected Memory:\nThe following node was selected for injection from the management app.\n\n${JSON.stringify(pendingJson, null, 2)}---`;
+                        const lastUserIndex = findLastUserMessage(output.messages);
+                        if (lastUserIndex >= 0) {
+                            const userMsg = output.messages[lastUserIndex];
+                            if (userMsg && userMsg.parts) {
+                                userMsg.parts.unshift({ type: "text", text: pendingBlock + "\n\n" });
+                            }
+                        }
+                    }
+                    for (const p of pending) {
+                        await store.markInjectionProcessed(p.id);
+                    }
+                }
+            }
+            catch (err) {
+                log("error", "Pending injection processing failed", { error: String(err) });
+            }
+            if (!autoConfig?.enabled) {
+                log("debug", "Auto-retrieve disabled in config");
+                return;
+            }
+            try {
+                const lastUserIndex = findLastUserMessage(output.messages);
+                if (lastUserIndex === -1) {
+                    log("debug", "No user message found");
+                    return;
+                }
+                const userMsg = output.messages[lastUserIndex];
+                if (!userMsg) {
+                    log("debug", "User message not found at index");
+                    return;
+                }
+                const userText = userMsg.parts
+                    .filter(p => p.type === "text")
+                    .map(p => p.text || "")
+                    .join(" ")
+                    .trim();
+                if (!userText || userText.length < 3) {
+                    log("debug", "User message too short", { length: userText?.length });
+                    return;
+                }
+                log("info", "Auto-retrieving for query", { query: userText.slice(0, 50) + "..." });
+                const queryEmbedding = await generateEmbedding(userText);
+                const maxPlaybooks = autoConfig.maxInjectPlaybooks ?? 3;
+                const [candidates, relevantSkills, relevantPlaybooks] = await Promise.all([
+                    store.searchByEmbedding(queryEmbedding, autoConfig.candidateCount ?? 30, { bm25Weight: 0.4 }),
+                    detectRelevantSkills(store, userText, queryEmbedding, 3, log),
+                    detectRelevantPlaybooks(store, queryEmbedding, maxPlaybooks, log),
+                ]);
+                if (candidates.length === 0 && relevantSkills.length === 0 && relevantPlaybooks.length === 0) {
+                    log("debug", "No candidates, skills, or playbooks found");
+                    return;
+                }
+                const filtered = candidates.filter(c => !c.label?.startsWith("rule:") && c.type !== "skill");
+                if (filtered.length === 0 && relevantSkills.length === 0 && relevantPlaybooks.length === 0) {
+                    log("debug", "No candidates after dedup");
+                    return;
+                }
+                log("debug", "Candidates after dedup", { count: filtered.length, skills: relevantSkills.length, playbooks: relevantPlaybooks.length });
+                let scored = filtered.length > 0 ? scoreCandidates(filtered, userText, queryEmbedding) : [];
+                if (ollamaConfig?.enabled && scored.length > 0) {
+                    log("info", "Ollama reranking", { model: ollamaConfig.model, candidateCount: scored.length });
+                    const startTime = Date.now();
+                    const results = await rerankDocuments(userText, scored.map(c => ({ id: c.id, label: c.label ?? c.id, content: c.content })), {
+                        baseUrl: ollamaConfig.baseUrl,
+                        model: ollamaConfig.model,
+                        topK: autoConfig.maxInjectNodes ?? 5,
+                    });
+                    const ollamaDuration = Date.now() - startTime;
+                    const selectedIds = new Set(results.map(r => r.id));
+                    scored = scored.filter(c => selectedIds.has(c.id));
+                    log("info", "Ollama reranking done", { selectedCount: scored.length, ollamaDuration });
+                }
+                const maxNodes = autoConfig.maxInjectNodes ?? 5;
+                const maxMemoryNodes = Math.max(0, maxNodes - relevantSkills.length - relevantPlaybooks.length);
+                scored = scored.slice(0, maxMemoryNodes);
+                const MAX_TOKENS_PER_NODE = 150;
+                const memoriesJson = scored.map(n => formatNodeForInjection(n, MAX_TOKENS_PER_NODE));
+                let fullBlock = "";
+                if (memoriesJson.length > 0) {
+                    fullBlock += `### Retrieved Context:
+Use the following memories to inform your response. Do not repeat or summarize them.
+
+${JSON.stringify(memoriesJson, null, 2)}
+---`;
+                }
+                if (relevantSkills.length > 0) {
+                    const skillsBlock = formatSkillsAsAvailable(relevantSkills);
+                    if (skillsBlock) {
+                        fullBlock += `\n\n### Available Skills:\nThe following skills are relevant to your task. Load full instructions with:\nmemory_skill_load(name="skill-name")\n\n${skillsBlock}`;
+                    }
+                }
+                if (relevantPlaybooks.length > 0) {
+                    const playbooksBlock = formatPlaybooksAsAvailable(relevantPlaybooks);
+                    if (playbooksBlock) {
+                        fullBlock += `\n\n### Available Playbooks:\nThe following playbooks match your current task. Execute one with:\nmemory_playbook_execute playbook_id="<id>"\n\n${playbooksBlock}`;
+                    }
+                }
+                if (!fullBlock)
+                    return;
+                const debugLine = `[${new Date().toISOString()}] Query: ${userText.slice(0, 100)}...\n${fullBlock}\n\n`;
+                try {
+                    fs.appendFileSync(INJECTION_LOG_FILE, debugLine);
+                }
+                catch { /* silent fail */ }
+                if (userMsg && userMsg.parts) {
+                    userMsg.parts.unshift({ type: "text", text: fullBlock + "\n\n" });
+                }
+                log("info", "Memory injected", { nodeCount: scored.length, skillCount: relevantSkills.length, playbookCount: relevantPlaybooks.length, queryLength: userText.length });
+            }
+            catch (err) {
+                log("error", "Auto-retrieve failed", { error: String(err) });
+            }
+        },
+    };
+}
+function findLastUserMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (!msg)
+            continue;
+        if (msg.info?.role === "user" && !msg.info.synthetic) {
+            return i;
+        }
+    }
+    return -1;
+}

package/dist/hooks/auto-retrieve/scoring.js

@@ -0,0 +1,56 @@
+import { tokenize } from "../../storage/sqlite";
+export function scoreCandidates(candidates, query, queryEmbedding) {
+    const DAY_MS = 24 * 60 * 60 * 1000;
+    const now = Date.now();
+    const semanticScores = new Map();
+    if (queryEmbedding.length > 0) {
+        for (const node of candidates) {
+            if (node.embedding && node.embedding.length > 0) {
+                let dot = 0, normA = 0, normB = 0;
+                for (let i = 0; i < queryEmbedding.length && i < node.embedding.length; i++) {
+                    const qi = queryEmbedding[i] ?? 0;
+                    const ni = node.embedding[i] ?? 0;
+                    dot += qi * ni;
+                    normA += qi * qi;
+                    normB += ni * ni;
+                }
+                semanticScores.set(node.id, dot / (Math.sqrt(normA) * Math.sqrt(normB) + 1e-8));
+            }
+        }
+    }
+    const queryTerms = tokenize(query);
+    const keywordBoost = new Map();
+    if (queryTerms.length > 0) {
+        for (const node of candidates) {
+            const nodeTokens = tokenize(node.content + " " + (node.label ?? ""));
+            let overlap = 0;
+            for (const term of queryTerms) {
+                if (nodeTokens.includes(term))
+                    overlap++;
+            }
+            if (overlap > 0) {
+                keywordBoost.set(node.id, Math.min(0.15, (overlap / queryTerms.length) * 0.15));
+            }
+        }
+    }
+    const recencyBoost = new Map();
+    for (const node of candidates) {
+        if (node.updatedAt && node.updatedAt instanceof Date) {
+            const daysSince = (now - node.updatedAt.getTime()) / DAY_MS;
+            if (daysSince < 1)
+                recencyBoost.set(node.id, 0.1);
+            else if (daysSince < 7)
+                recencyBoost.set(node.id, 0.05);
+        }
+    }
+    const scored = candidates.map(node => {
+        const semantic = semanticScores.get(node.id) ?? 0;
+        const base = 0.4 * semantic + 0.3 * (node.importance ?? 0.5) + 0.15 * (node.confidence ?? 0.5) + 0.1 * (node.usefulnessScore ?? 0.5);
+        const access = Math.min(0.05, (node.accessCount ?? 0) * 0.005);
+        const recency = recencyBoost.get(node.id) ?? 0;
+        const keyword = keywordBoost.get(node.id) ?? 0;
+        return { node, score: base + access + recency + keyword };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored.map(s => s.node);
+}

package/dist/hooks/auto-retrieve.js

@@ -0,0 +1 @@
+export { createAutoRetrieveHook } from "./auto-retrieve/index";

package/dist/hooks/index.js

@@ -0,0 +1,4 @@
+export { createAutoRetrieveHook } from "./auto-retrieve";
+export { distillRules } from "./auto-distill";
+export { predictiveRateToolCall, applyScoreDecay } from "./predictive-rating";
+// Playbooks are now memory nodes (type: "playbook"). Auto-discover is agent-driven.