@gamaze/hicortex 0.2.0

package/dist/llm.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Multi-provider LLM client for consolidation and distillation.
+ * Ported from hicortex/consolidate/llm.py.
+ *
+ * Resolution order for LLM provider:
+ *   1. Plugin config (llmBaseUrl, llmApiKey, llmModel)
+ *   2. ~/.openclaw/openclaw.json agents.defaults.model.primary
+ *   3. Environment vars: OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_API_KEY
+ *   4. Fallback: Ollama at http://localhost:11434
+ *
+ * Supports: OpenAI, Anthropic (via OpenAI compat), Google, OpenRouter, Ollama, z.ai
+ */
+export interface LlmConfig {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    reflectModel: string;
+    provider: string;
+}
+/**
+ * Resolve LLM configuration from plugin config, OpenClaw config, env vars, or Ollama fallback.
+ */
+export declare function resolveLlmConfig(pluginConfig?: {
+    llmBaseUrl?: string;
+    llmApiKey?: string;
+    llmModel?: string;
+    reflectModel?: string;
+}): LlmConfig;
+export declare class RateLimitError extends Error {
+    retryAfterMs: number;
+    constructor(retryAfterMs: number);
+}
+export declare class LlmClient {
+    private config;
+    private rateLimitedUntil;
+    constructor(config: LlmConfig);
+    /** Check if we're currently rate limited */
+    get isRateLimited(): boolean;
+    private handleRateLimit;
+    /**
+     * Fast-tier completion (importance scoring, simple tasks).
+     */
+    completeFast(prompt: string, maxTokens?: number): Promise<string>;
+    /**
+     * Reflect-tier completion (nightly reflection, needs reasoning).
+     */
+    completeReflect(prompt: string, maxTokens?: number): Promise<string>;
+    /**
+     * Distillation-tier completion (session knowledge extraction).
+     */
+    completeDistill(prompt: string, maxTokens?: number): Promise<string>;
+    private complete;
+    /**
+     * Ollama: use /api/generate with think:false (important for qwen3.5 models).
+     */
+    private completeOllama;
+    /**
+     * Anthropic Messages API (/v1/messages). Used for Anthropic and z.ai.
+     * Auth via x-api-key header.
+     */
+    private completeAnthropic;
+    /**
+     * OpenAI-compatible /v1/chat/completions (works for OpenAI, OpenRouter, etc).
+     */
+    private completeOpenAiCompat;
+}

package/dist/llm.js

@@ -0,0 +1,421 @@
+"use strict";
+/**
+ * Multi-provider LLM client for consolidation and distillation.
+ * Ported from hicortex/consolidate/llm.py.
+ *
+ * Resolution order for LLM provider:
+ *   1. Plugin config (llmBaseUrl, llmApiKey, llmModel)
+ *   2. ~/.openclaw/openclaw.json agents.defaults.model.primary
+ *   3. Environment vars: OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_API_KEY
+ *   4. Fallback: Ollama at http://localhost:11434
+ *
+ * Supports: OpenAI, Anthropic (via OpenAI compat), Google, OpenRouter, Ollama, z.ai
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlmClient = exports.RateLimitError = void 0;
+exports.resolveLlmConfig = resolveLlmConfig;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+/**
+ * Resolve LLM configuration from plugin config, OpenClaw config, env vars, or Ollama fallback.
+ */
+function resolveLlmConfig(pluginConfig) {
+    // 1. Plugin config
+    if (pluginConfig?.llmBaseUrl && pluginConfig?.llmApiKey) {
+        const provider = detectProvider(pluginConfig.llmBaseUrl);
+        return {
+            baseUrl: pluginConfig.llmBaseUrl,
+            apiKey: pluginConfig.llmApiKey,
+            model: pluginConfig.llmModel ?? "qwen3.5:4b",
+            reflectModel: pluginConfig.reflectModel ?? pluginConfig.llmModel ?? "qwen3.5:cloud",
+            provider,
+        };
+    }
+    // 2. OpenClaw config file
+    const ocConfig = readOpenClawConfig();
+    if (ocConfig) {
+        return ocConfig;
+    }
+    // 3. Environment variables
+    const envConfig = resolveFromEnv();
+    if (envConfig) {
+        return envConfig;
+    }
+    // 4. Fallback: Ollama
+    return {
+        baseUrl: "http://localhost:11434",
+        apiKey: "",
+        model: "qwen3.5:4b",
+        reflectModel: "qwen3.5:cloud",
+        provider: "ollama",
+    };
+}
+function detectProvider(url) {
+    const u = url.toLowerCase();
+    if (u.includes("ollama") || u.includes(":11434"))
+        return "ollama";
+    if (u.includes("anthropic"))
+        return "anthropic";
+    if (u.includes("openrouter"))
+        return "openrouter";
+    if (u.includes("googleapis") || u.includes("generativelanguage"))
+        return "google";
+    if (u.includes("z.ai") || u.includes("zai"))
+        return "zai";
+    return "openai";
+}
+function readOpenClawConfig() {
+    try {
+        const configPath = (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw", "openclaw.json");
+        const raw = (0, node_fs_1.readFileSync)(configPath, "utf-8");
+        const config = JSON.parse(raw);
+        const primary = config?.agents?.defaults?.model?.primary;
+        if (!primary)
+            return null;
+        // primary format is "provider/model" (e.g. "zai/glm-5-turbo", "openai/gpt-4o")
+        if (typeof primary === "string" && (primary.includes("/") || primary.includes(":"))) {
+            const sep = primary.includes("/") ? "/" : ":";
+            const [providerHint, ...rest] = primary.split(sep);
+            const model = rest.join(sep);
+            // Accept any provider name — if it's in our URL map, we know it
+            const hint = providerHint.toLowerCase();
+            const provider = (hint in PROVIDER_BASE_URLS ? hint : "openai");
+            // Resolve base URL: OC config → per-agent models.json → built-in defaults
+            const baseUrl = readOcProviderBaseUrl(config, providerHint) ??
+                getDefaultUrlForProvider(provider);
+            // Resolve API key: OC auth-profiles.json → env vars
+            const apiKey = readOcAuthKey(providerHint) ??
+                getEnvKeyForProvider(provider);
+            if (!apiKey && provider !== "ollama")
+                return null;
+            return {
+                baseUrl,
+                apiKey: apiKey ?? "",
+                model,
+                reflectModel: model,
+                provider,
+            };
+        }
+    }
+    catch {
+        // Config file doesn't exist or is invalid
+    }
+    return null;
+}
+/**
+ * Read provider base URL from openclaw.json → models.providers.<name>.baseUrl
+ */
+function readOcProviderBaseUrl(config, provider) {
+    const providerConfig = config?.models?.providers?.[provider];
+    if (providerConfig?.baseUrl)
+        return providerConfig.baseUrl;
+    return undefined;
+}
+/**
+ * Read provider base URL from per-agent models.json files.
+ * Scans all agent dirs for a matching provider entry.
+ */
+function readAgentModelsBaseUrl(provider) {
+    try {
+        const { readdirSync } = require("node:fs");
+        const agentsDir = (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw", "agents");
+        const agents = readdirSync(agentsDir);
+        for (const agentId of agents) {
+            try {
+                const modelsPath = (0, node_path_1.join)(agentsDir, agentId, "agent", "models.json");
+                const raw = (0, node_fs_1.readFileSync)(modelsPath, "utf-8");
+                const models = JSON.parse(raw);
+                const providerConfig = models?.providers?.[provider];
+                if (providerConfig?.baseUrl)
+                    return providerConfig.baseUrl;
+            }
+            catch {
+                // Skip agents without models.json
+            }
+        }
+    }
+    catch {
+        // No agents dir
+    }
+    return undefined;
+}
+/**
+ * Read API key from OC's per-agent auth-profiles.json.
+ * Scans all agent dirs for a matching provider profile.
+ */
+function readOcAuthKey(provider) {
+    try {
+        const { readdirSync } = require("node:fs");
+        const agentsDir = (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw", "agents");
+        const agents = readdirSync(agentsDir);
+        for (const agentId of agents) {
+            try {
+                const authPath = (0, node_path_1.join)(agentsDir, agentId, "agent", "auth-profiles.json");
+                const raw = (0, node_fs_1.readFileSync)(authPath, "utf-8");
+                const auth = JSON.parse(raw);
+                const profiles = auth?.profiles ?? {};
+                // Look for a profile matching the provider (e.g. "zai:default")
+                for (const [profileId, profile] of Object.entries(profiles)) {
+                    const p = profile;
+                    if (p?.provider === provider ||
+                        profileId.startsWith(`${provider}:`)) {
+                        if (p?.key)
+                            return p.key;
+                    }
+                }
+            }
+            catch {
+                // Skip agents without auth
+            }
+        }
+    }
+    catch {
+        // No agents dir
+    }
+    return undefined;
+}
+function resolveFromEnv() {
+    const openaiKey = process.env.OPENAI_API_KEY;
+    const openaiBaseUrl = process.env.OPENAI_BASE_URL;
+    if (openaiKey) {
+        const baseUrl = openaiBaseUrl ?? "https://api.openai.com";
+        const provider = detectProvider(baseUrl);
+        return {
+            baseUrl,
+            apiKey: openaiKey,
+            model: process.env.OPENAI_MODEL ?? "gpt-4o-mini",
+            reflectModel: process.env.OPENAI_MODEL ?? "gpt-4o-mini",
+            provider,
+        };
+    }
+    const anthropicKey = process.env.ANTHROPIC_API_KEY;
+    if (anthropicKey) {
+        return {
+            baseUrl: process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com",
+            apiKey: anthropicKey,
+            model: "claude-sonnet-4-20250514",
+            reflectModel: "claude-sonnet-4-20250514",
+            provider: "anthropic",
+        };
+    }
+    const googleKey = process.env.GOOGLE_API_KEY;
+    if (googleKey) {
+        return {
+            baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+            apiKey: googleKey,
+            model: "gemini-2.0-flash",
+            reflectModel: "gemini-2.0-flash",
+            provider: "google",
+        };
+    }
+    return null;
+}
+function getEnvKeyForProvider(provider) {
+    switch (provider) {
+        case "openai":
+            return process.env.OPENAI_API_KEY;
+        case "anthropic":
+            return process.env.ANTHROPIC_API_KEY;
+        case "google":
+            return process.env.GOOGLE_API_KEY;
+        case "zai":
+            return process.env.ZAI_API_KEY ?? process.env.LLM_API_KEY;
+        default:
+            return undefined;
+    }
+}
+/** Default base URLs for all OC-supported providers (from OC gateway binary). */
+const PROVIDER_BASE_URLS = {
+    openai: "https://api.openai.com/v1",
+    anthropic: "https://api.anthropic.com",
+    google: "https://generativelanguage.googleapis.com/v1beta",
+    ollama: "http://localhost:11434",
+    openrouter: "https://openrouter.ai/api",
+    zai: "https://api.z.ai/api/anthropic",
+    groq: "https://api.groq.com/openai/v1",
+    deepseek: "https://api.deepseek.com",
+    mistral: "https://api.mistral.ai/v1",
+    together: "https://api.together.xyz/v1",
+    perplexity: "https://api.perplexity.ai",
+    nvidia: "https://integrate.api.nvidia.com/v1",
+    xai: "https://api.x.ai/v1",
+    venice: "https://api.venice.ai/api/v1",
+    minimax: "https://api.minimaxi.com/v1",
+    moonshot: "https://api.moonshot.ai/v1",
+    kimi: "https://api.kimi.com/coding",
+    chutes: "https://api.chutes.ai",
+    kilo: "https://api.kilo.ai/api/gateway",
+};
+function getDefaultUrlForProvider(provider) {
+    return PROVIDER_BASE_URLS[provider.toLowerCase()] ?? "https://api.openai.com/v1";
+}
+function getEnvKeyForZai() {
+    return process.env.ZAI_API_KEY ?? process.env.LLM_API_KEY;
+}
+// ---------------------------------------------------------------------------
+// LLM Client class
+// ---------------------------------------------------------------------------
+const DEFAULT_RATE_LIMIT_RETRY_MS = 5 * 60 * 60 * 1000 + 60_000; // 5h01m safety margin
+class RateLimitError extends Error {
+    retryAfterMs;
+    constructor(retryAfterMs) {
+        const hours = Math.round(retryAfterMs / (60 * 60 * 1000) * 10) / 10;
+        super(`Rate limited — will retry in ${hours}h`);
+        this.name = "RateLimitError";
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+exports.RateLimitError = RateLimitError;
+class LlmClient {
+    config;
+    rateLimitedUntil = 0;
+    constructor(config) {
+        this.config = config;
+    }
+    /** Check if we're currently rate limited */
+    get isRateLimited() {
+        return Date.now() < this.rateLimitedUntil;
+    }
+    handleRateLimit(resp) {
+        // Parse Retry-After header if present (seconds)
+        const retryAfter = resp.headers.get("retry-after");
+        const retryMs = retryAfter
+            ? parseInt(retryAfter, 10) * 1000
+            : DEFAULT_RATE_LIMIT_RETRY_MS;
+        this.rateLimitedUntil = Date.now() + retryMs;
+        console.log(`[hicortex] Rate limited by LLM provider. ` +
+            `Will retry after ${new Date(this.rateLimitedUntil).toISOString()}`);
+        throw new RateLimitError(retryMs);
+    }
+    /**
+     * Fast-tier completion (importance scoring, simple tasks).
+     */
+    async completeFast(prompt, maxTokens = 2048) {
+        return this.complete(this.config.model, prompt, maxTokens, 600_000);
+    }
+    /**
+     * Reflect-tier completion (nightly reflection, needs reasoning).
+     */
+    async completeReflect(prompt, maxTokens = 8192) {
+        return this.complete(this.config.reflectModel, prompt, maxTokens, 900_000);
+    }
+    /**
+     * Distillation-tier completion (session knowledge extraction).
+     */
+    async completeDistill(prompt, maxTokens = 2048) {
+        return this.complete(this.config.model, prompt, maxTokens, 900_000);
+    }
+    async complete(model, prompt, maxTokens, timeoutMs) {
+        if (this.isRateLimited) {
+            throw new RateLimitError(this.rateLimitedUntil - Date.now());
+        }
+        if (this.config.provider === "ollama") {
+            return this.completeOllama(model, prompt, maxTokens, timeoutMs);
+        }
+        if (this.config.provider === "anthropic" || this.config.provider === "zai") {
+            return this.completeAnthropic(model, prompt, maxTokens, timeoutMs);
+        }
+        return this.completeOpenAiCompat(model, prompt, maxTokens, timeoutMs);
+    }
+    /**
+     * Ollama: use /api/generate with think:false (important for qwen3.5 models).
+     */
+    async completeOllama(model, prompt, maxTokens, timeoutMs) {
+        const url = `${this.config.baseUrl.replace(/\/$/, "")}/api/generate`;
+        const resp = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model,
+                prompt,
+                stream: false,
+                think: false,
+                options: { num_predict: maxTokens, num_ctx: 32768 },
+            }),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (resp.status === 429)
+            this.handleRateLimit(resp);
+        if (!resp.ok) {
+            const text = await resp.text().catch(() => "");
+            if (text.includes("1113") || text.includes("Insufficient balance")) {
+                this.handleRateLimit(resp); // z.ai/Ollama Cloud quota exceeded
+            }
+            throw new Error(`Ollama error ${resp.status}: ${text}`);
+        }
+        const data = (await resp.json());
+        return (data.response ?? "").trim();
+    }
+    /**
+     * Anthropic Messages API (/v1/messages). Used for Anthropic and z.ai.
+     * Auth via x-api-key header.
+     */
+    async completeAnthropic(model, prompt, maxTokens, timeoutMs) {
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        const url = `${baseUrl}/v1/messages`;
+        const resp = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": this.config.apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            body: JSON.stringify({
+                model,
+                messages: [{ role: "user", content: prompt }],
+                max_tokens: maxTokens,
+            }),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (resp.status === 429)
+            this.handleRateLimit(resp);
+        if (!resp.ok) {
+            const text = await resp.text().catch(() => "");
+            throw new Error(`Anthropic API error ${resp.status}: ${text}`);
+        }
+        const data = (await resp.json());
+        const textBlock = data.content?.find((c) => c.type === "text");
+        return (textBlock?.text ?? "").trim();
+    }
+    /**
+     * OpenAI-compatible /v1/chat/completions (works for OpenAI, OpenRouter, etc).
+     */
+    async completeOpenAiCompat(model, prompt, maxTokens, timeoutMs) {
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        // Some providers (z.ai) include version in base URL already
+        const hasVersion = /\/v\d+\/?$/.test(baseUrl) || baseUrl.includes("/paas/v");
+        const url = hasVersion
+            ? `${baseUrl}/chat/completions`
+            : `${baseUrl}/v1/chat/completions`;
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.config.apiKey) {
+            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        }
+        const resp = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                model,
+                messages: [{ role: "user", content: prompt }],
+                max_tokens: maxTokens,
+            }),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (resp.status === 429)
+            this.handleRateLimit(resp);
+        if (!resp.ok) {
+            const text = await resp.text().catch(() => "");
+            // z.ai: "Insufficient balance" likely means wrong endpoint (coding vs paas)
+            if (text.includes("1113") || text.includes("Insufficient balance")) {
+                console.log(`[hicortex] LLM billing error. Check that llmBaseUrl matches your plan. Current: ${baseUrl}`);
+            }
+            throw new Error(`LLM API error ${resp.status}: ${text}`);
+        }
+        const data = (await resp.json());
+        return (data.choices?.[0]?.message?.content ?? "").trim();
+    }
+}
+exports.LlmClient = LlmClient;

package/dist/prompts.d.ts

@@ -0,0 +1,16 @@
+/**
+ * LLM prompt templates for memory consolidation and distillation.
+ * Copied EXACTLY from the Python codebase (proven working prompts).
+ */
+/**
+ * Importance scoring prompt. Takes a {memories_block} with indexed memories.
+ */
+export declare function importanceScoring(memoriesBlock: string): string;
+/**
+ * Reflection prompt. Takes a {memories_block} with today's memories.
+ */
+export declare function reflection(memoriesBlock: string): string;
+/**
+ * Distillation prompt. Extracts knowledge from a session transcript.
+ */
+export declare function distillation(projectName: string, date: string, transcript: string): string;

package/dist/prompts.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * LLM prompt templates for memory consolidation and distillation.
+ * Copied EXACTLY from the Python codebase (proven working prompts).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importanceScoring = importanceScoring;
+exports.reflection = reflection;
+exports.distillation = distillation;
+/**
+ * Importance scoring prompt. Takes a {memories_block} with indexed memories.
+ */
+function importanceScoring(memoriesBlock) {
+    return `You are a memory importance scorer. Rate each memory's long-term value.
+
+Score each memory from 0.0 (trivial/ephemeral) to 1.0 (critical/foundational).
+
+Scoring guide:
+- 0.0-0.2: Routine actions, transient state, trivial fixes
+- 0.3-0.5: Useful context, minor decisions, standard patterns
+- 0.6-0.8: Important decisions, debugging breakthroughs, architectural choices
+- 0.9-1.0: Foundational principles, critical constraints, core identity facts
+
+MEMORIES:
+${memoriesBlock}
+
+Respond with ONLY a JSON array of scores in the same order, e.g.:
+[0.3, 0.7, 0.5, 0.9]
+
+No explanations. Just the JSON array.`;
+}
+/**
+ * Reflection prompt. Takes a {memories_block} with today's memories.
+ */
+function reflection(memoriesBlock) {
+    return `You are a self-improvement analyst for a multi-agent AI system. Review today's memories and extract 1-3 actionable lessons.
+
+Quality over quantity. One genuine insight that prevents a future mistake is worth more than five restatements of what happened. Most days, 1-2 lessons is ideal. An empty array is fine if nothing warrants a lesson.
+
+Prefer GLOBAL lessons (applicable across all projects and agents) over project-specific ones. Only mark a lesson as project-specific if it truly cannot generalize.
+
+Good lesson: "When modifying template files processed by sed, always verify ALL substitution targets by diffing the output — partial fixes cause silent failures on other deployments"
+Bad lesson: "The deploy script had a bug" (restatement, not actionable)
+
+TODAY'S MEMORIES:
+${memoriesBlock}
+
+For each lesson, output a JSON object:
+- "lesson": Concise, actionable rule in imperative voice
+- "project": "global" unless genuinely project-specific
+- "severity": "critical" | "important" | "minor"
+- "confidence": "high" | "medium" | "low"
+- "source_pattern": What triggered this (1 sentence)
+
+Confidence:
+- "high": Pattern across multiple events, or clear mistake with obvious fix. Safe to auto-inject into agent instructions.
+- "medium": Single incident but likely to recur. Store but don't auto-propagate.
+- "low": Speculative. Store for retrieval only.
+
+Focus on: process gaps, repeated friction, silent failures, user corrections to agent behavior, cross-agent patterns.
+Skip: trivial actions, already-documented rules, one-off events.
+
+Respond with a JSON array. Empty array [] is a valid response.`;
+}
+/**
+ * Distillation prompt. Extracts knowledge from a session transcript.
+ */
+function distillation(projectName, date, transcript) {
+    return `You are a memory extraction agent. Analyze this AI session transcript and extract
+knowledge worth remembering long-term.
+
+SESSION TRANSCRIPT (project: ${projectName}, date: ${date}):
+${transcript}
+
+EXTRACT into this markdown format:
+
+# Session Memory: ${date} - ${projectName}
+
+## Classification: [pick one: PUBLIC / WORK / PERSONAL / SENSITIVE]
+
+### Decisions Made
+- [decision]: [reasoning] (${date})
+
+### Facts Learned
+- [fact]: [context/source] (${date})
+
+### Problems & Solutions
+- [problem] → [solution that worked] (${date})
+
+### Project State Changes
+- [what changed]: [from → to] (${date})
+
+### Key Entities & Relationships
+- [entity A] → [relationship] → [entity B] (${date})
+
+### Corrections & Rejections
+- [what AI proposed] → [why rejected/corrected] → [what user wanted instead] (${date})
+  (Include: tool use denials, "no/wrong/redo", style feedback, approach rejections,
+   user corrections of AI assumptions, quality complaints like "too verbose")
+
+RULES:
+- Extract MAX 20 items total (quality over quantity)
+- Each must be useful if recalled in a future session
+- Skip: routine code edits, standard tool usage, trivial fixes
+- Include: architectural decisions, debugging breakthroughs, user preferences,
+  tool configurations, API discoveries, project milestones
+- PRIORITIZE Corrections & Rejections — these are high-value signals for learning
+  what the user does NOT want. Even a single "no" or style correction is worth extracting.
+- PRIVACY CLASSIFICATION (one of):
+  - PUBLIC: general tech knowledge, open-source patterns, publicly available info
+  - WORK: project-specific decisions, architecture choices, client/business context
+  - PERSONAL: personal preferences, family, health, lifestyle, private life
+  - SENSITIVE: API keys mentioned, credentials, financial account details, medical records
+- Omit any section that has zero items (don't include empty sections)
+- If nothing worth extracting, output ONLY: "NO_EXTRACT"
+`;
+}

package/dist/retrieval.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Retrieval layer with composite scoring, RRF fusion, and graph traversal.
+ * Ported from hicortex/retrieval.py — same scoring model and weights.
+ *
+ * Scoring model:
+ *   score = similarity * 0.4 + effective_strength * 0.3 + connection_score * 0.2 + recency * 0.1
+ *
+ * Decay model (B+E+D):
+ *   base_decay = 0.0005 (~60-day half-life at importance 0.5)
+ *   decay_rate = 1 - base_decay * (1 - importance)
+ *   decay_rate = 1 - (1 - decay_rate) * 0.7^access_count
+ *   decay_rate = 1 - (1 - decay_rate) * 0.7^link_count
+ *   floor = base_strength * importance * 0.1
+ *   effective = floor + (base - floor) * decay_rate^hours
+ */
+import type Database from "better-sqlite3";
+import type { MemorySearchResult } from "./types.js";
+/**
+ * Compute decayed strength with adaptive decay (B+E+D model).
+ * Exported for use by consolidation decay/prune stage.
+ */
+export declare function effectiveStrength(baseStrength: number, lastAccessed: string | null, now: Date, options?: {
+    importance?: number;
+    accessCount?: number;
+    linkCount?: number;
+}): number;
+export interface EmbedFn {
+    (text: string): Promise<Float32Array>;
+}
+/**
+ * Main retrieval: BM25 + vector search with RRF fusion, graph traversal,
+ * and composite scoring. Strengthens accessed memories.
+ */
+export declare function retrieve(db: Database.Database, embedFn: EmbedFn, query: string, options?: {
+    limit?: number;
+    project?: string | null;
+    privacy?: string[];
+    sourceAgent?: string;
+}): Promise<MemorySearchResult[]>;
+/**
+ * Get recent context, optionally filtered by project and privacy.
+ */
+export declare function searchContext(db: Database.Database, options?: {
+    project?: string | null;
+    limit?: number;
+    privacy?: string[];
+}): MemorySearchResult[];