@hanhnd/agent-kit 1.0.31 → 1.0.32

package/dist/memory/digest/processor.d.ts

@@ -0,0 +1,7 @@
+import type { DigestFileOptions, DigestPendingResult, ProvisionalDigestResult, ConversationDigestInitResult, InitializeConversationDigestInput } from './types.js';
+export declare function digestConversationFile(options: DigestFileOptions): Promise<ProvisionalDigestResult>;
+export declare function digestPendingConversations({ workspaceRoot, digestFn, }: {
+    workspaceRoot: string;
+    digestFn?: (opts: DigestFileOptions) => Promise<ProvisionalDigestResult>;
+}): Promise<DigestPendingResult>;
+export declare function initializeConversationDigestModel(input: InitializeConversationDigestInput): Promise<ConversationDigestInitResult>;

package/dist/memory/digest/processor.js

@@ -0,0 +1,171 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { DEFAULT_DIGEST_TIMEOUT_MS, DEFAULT_DIGEST_MAX_INPUT_CHARS, DIGEST_LOCKFILE_REL_PATH, WIKI_RAW_DIR, } from './constants.js';
+import { defaultProvisionalDigestDir, readConversationDigestInput, findExistingProvisionalDigest, writeProvisionalDigestFile, writeConversationDigestSettings, } from './files.js';
+import { getDigestModelSpec } from './model-registry.js';
+import { createLlamaLocalDigestProvider } from './providers/llama-local.js';
+import { loadProjectSettings, resolveConversationDigestConfig, resolveMemoryConfig } from '../../tools/config.js';
+import { MemoryStore } from '../store.js';
+import { MemoryIndexer } from '../indexer.js';
+import { releaseLock, tryAcquireProcessLock } from '../../utils/files.js';
+function digestLockPath(workspaceRoot) {
+    return path.join(workspaceRoot, DIGEST_LOCKFILE_REL_PATH);
+}
+async function indexProvisionalDigestFile(workspaceRoot, markdownPath) {
+    try {
+        const settings = loadProjectSettings(workspaceRoot);
+        const config = resolveMemoryConfig(settings, workspaceRoot);
+        const store = new MemoryStore(path.join(config.wikiDir, 'index.db'), config);
+        const embedder = { embed: async (_texts) => [], initialize: async () => { } };
+        const indexer = new MemoryIndexer(store, embedder, config);
+        await indexer.indexFile(markdownPath);
+        return { indexed: true };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { indexed: false, error: message };
+    }
+}
+export async function digestConversationFile(options) {
+    const outDir = options.outDir
+        ? path.resolve(options.workspaceRoot, options.outDir)
+        : defaultProvisionalDigestDir(options.workspaceRoot);
+    const input = readConversationDigestInput(options.workspaceRoot, options.inputPath);
+    const existingPath = findExistingProvisionalDigest(outDir, input);
+    if (existingPath) {
+        const indexResult = await indexProvisionalDigestFile(options.workspaceRoot, existingPath);
+        return {
+            markdown: existingPath,
+            status: 'provisional',
+            contentHash: input.contentHash,
+            skipped: true,
+            ...indexResult,
+        };
+    }
+    const provider = await createLlamaLocalDigestProvider(options.modelId);
+    try {
+        const markdown = await provider.generateDigestMarkdown(input, {
+            modelId: options.modelId,
+            maxInputChars: options.maxInputChars ?? DEFAULT_DIGEST_MAX_INPUT_CHARS,
+            timeoutMs: options.timeoutMs ?? DEFAULT_DIGEST_TIMEOUT_MS,
+        });
+        const markdownPath = writeProvisionalDigestFile(outDir, input, markdown);
+        const indexResult = await indexProvisionalDigestFile(options.workspaceRoot, markdownPath);
+        return {
+            markdown: markdownPath,
+            status: 'provisional',
+            contentHash: input.contentHash,
+            skipped: false,
+            ...indexResult,
+        };
+    }
+    finally {
+        await provider.dispose?.();
+    }
+}
+export async function digestPendingConversations({ workspaceRoot, digestFn = digestConversationFile, }) {
+    const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
+    if (!digestConfig || digestConfig.enabled === false) {
+        return { ok: true, initialized: false, action: 'noop', reason: 'not-initialized' };
+    }
+    const lockPath = digestLockPath(workspaceRoot);
+    if (!tryAcquireProcessLock(lockPath)) {
+        return { ok: true, initialized: true, action: 'noop', reason: 'locked' };
+    }
+    try {
+        const rawDir = path.join(workspaceRoot, WIKI_RAW_DIR);
+        let files;
+        try {
+            files = fs
+                .readdirSync(rawDir)
+                .filter((f) => f.startsWith('conv_') && f.endsWith('.md'))
+                .map((f) => path.join(rawDir, f))
+                .sort((a, b) => fs.statSync(a).mtimeMs - fs.statSync(b).mtimeMs);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                files = [];
+            }
+            else {
+                throw err;
+            }
+        }
+        const outDir = defaultProvisionalDigestDir(workspaceRoot);
+        const candidates = files.filter((f) => {
+            try {
+                const input = readConversationDigestInput(workspaceRoot, f);
+                return !findExistingProvisionalDigest(outDir, input);
+            }
+            catch {
+                return false;
+            }
+        });
+        if (candidates.length === 0) {
+            return { ok: true, initialized: true, action: 'noop', reason: 'no-pending' };
+        }
+        let count = 0;
+        let skipped = 0;
+        let errors = 0;
+        for (const filePath of candidates) {
+            try {
+                const result = await digestFn({
+                    workspaceRoot,
+                    inputPath: filePath,
+                    modelId: digestConfig.modelId,
+                });
+                if (result.skipped) {
+                    skipped++;
+                }
+                else {
+                    count++;
+                }
+            }
+            catch {
+                errors++;
+            }
+        }
+        return { ok: true, initialized: true, action: 'digested', count, skipped, errors };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, initialized: true, action: 'error', error: message };
+    }
+    finally {
+        releaseLock(lockPath);
+    }
+}
+export async function initializeConversationDigestModel(input) {
+    try {
+        getDigestModelSpec(input.modelId);
+        if (input.allowDownload !== true) {
+            return {
+                initialized: false,
+                modelId: input.modelId,
+                error: 'Digest model initialization requires explicit download permission',
+            };
+        }
+        const loadedProvider = await createLlamaLocalDigestProvider(input.modelId);
+        await loadedProvider?.dispose?.();
+        const initializedAt = new Date().toISOString();
+        writeConversationDigestSettings(input.workspaceRoot, {
+            enabled: input.enabled ?? true,
+            initialized: true,
+            modelId: input.modelId,
+            initializedAt,
+        });
+        await digestPendingConversations({ workspaceRoot: input.workspaceRoot });
+        return {
+            initialized: true,
+            modelId: input.modelId,
+            initializedAt,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            initialized: false,
+            modelId: input.modelId,
+            error: message,
+        };
+    }
+}

package/dist/memory/digest/providers/llama-local.d.ts

@@ -0,0 +1,7 @@
+import type { ConversationDigestProvider } from '../types.js';
+export declare class LlamaLocalDigestProviderError extends Error {
+    constructor(message: string);
+}
+export declare function trimConversationExport(content: string, maxInputChars: number): string;
+export declare function sanitizeConversationDigestMarkdown(generatedText: string): string;
+export declare function createLlamaLocalDigestProvider(modelId: string): Promise<ConversationDigestProvider>;

package/dist/memory/digest/providers/llama-local.js

@@ -0,0 +1,136 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getLlama, LlamaChatSession, createModelDownloader } from 'node-llama-cpp';
+import { LLAMA_CONTEXT_SIZE, LLAMA_MAX_GENERATED_TOKENS, LLAMA_TEMPERATURE } from '../constants.js';
+import { getDigestModelSpec } from '../model-registry.js';
+import { withTimeout } from '../../../utils/async.js';
+import { MODEL_CACHE_DIR } from '../../../utils/paths.js';
+export class LlamaLocalDigestProviderError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LlamaLocalDigestProviderError';
+    }
+}
+function titleFromSource(sourcePath) {
+    return path
+        .basename(sourcePath)
+        .replace(/\.[^.]+$/, '')
+        .replace(/[_-]+/g, ' ');
+}
+export function trimConversationExport(content, maxInputChars) {
+    const trimmed = content.trim();
+    if (trimmed.length <= maxInputChars)
+        return trimmed;
+    return [
+        '[Earlier conversation content omitted to fit the local digest context window.]',
+        trimmed.slice(-maxInputChars),
+    ].join('\n\n');
+}
+function buildPrompt(input, maxInputChars) {
+    const conversationExport = trimConversationExport(input.content, maxInputChars);
+    const sourceName = path.basename(input.sourcePath);
+    return [
+        {
+            role: 'system',
+            content: [
+                '# ROLE',
+                'You write short project-memory wiki pages from developer transcripts.',
+                'Your output is temporary recall to prevent blind steps.',
+                '',
+                '# RULES',
+                '1. Read the end of the export FIRST to discover the ultimate resolution.',
+                '2. What the user says LAST ALWAYS overrides earlier agreements.',
+                '3. Capture absolute engineering conclusions, never conversational pleasantries.',
+                '4. Return Markdown only. Do not wrap output in code blocks (```markdown ... ```).',
+            ].join('\n'),
+        },
+        {
+            role: 'user',
+            content: [
+                'Generate a high-level project memory page. STRICTLY adhere to this architectural layout:',
+                '',
+                '<layout>',
+                '# Digest: ' + titleFromSource(input.sourcePath),
+                '- **Ultimate Core Resolution**: [Describe the final working state of the feature and what problem it solves in 1-2 sentences. No conversational filler.]',
+                '- **Architectural Changes**: [List 3-4 high-level engineering decisions made (e.g., shifts in hook timing, data isolation, atomic locks). Focus on systemic changes, NOT individual files.]',
+                '- **Component State**: [Briefly state how the Plugin side and the MCP/CLI side now interact based on the final decision.]',
+                '- **Considered & Rejected**: [List concepts proposed but discarded (e.g., initial hooks location, mocking strategies). Omit if empty.]',
+                '</layout>',
+                '',
+                '# CRITICAL RULES:',
+                '- DO NOT list individual file paths, line numbers, or specific test cases (EXCLUDE lists of files).',
+                '- Focus entirely on the SYSTEM DESIGN and ARCHITECTURE that the next engineer needs to know.',
+                '- Keep output under 300 tokens. Stop immediately after the last valid section.',
+                '',
+                'Source path: ' + input.sourcePath,
+                '<conversation_export format="memory-kit">',
+                conversationExport,
+                '</conversation_export>',
+            ].join('\n'),
+        },
+    ];
+}
+function stripCodeFence(text) {
+    const trimmed = text.trim();
+    const match = trimmed.match(/^```(?:markdown|md)?\s*\n([\s\S]*?)\n```$/i);
+    return match ? match[1].trim() : trimmed;
+}
+export function sanitizeConversationDigestMarkdown(generatedText) {
+    return stripCodeFence(generatedText).trim() + '\n';
+}
+export async function createLlamaLocalDigestProvider(modelId) {
+    const spec = getDigestModelSpec(modelId);
+    const modelCacheDir = path.join(MODEL_CACHE_DIR, 'llama');
+    fs.mkdirSync(modelCacheDir, { recursive: true });
+    let modelFilePath;
+    try {
+        const downloader = await createModelDownloader({
+            modelUri: spec.ggufUri,
+            dirPath: modelCacheDir,
+        });
+        modelFilePath = downloader.entrypointFilePath;
+        if (!fs.existsSync(modelFilePath)) {
+            await downloader.download();
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new LlamaLocalDigestProviderError(`Failed to download model: ${message}`);
+    }
+    let llama;
+    let model;
+    try {
+        llama = await getLlama();
+        model = await llama.loadModel({ modelPath: modelFilePath });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new LlamaLocalDigestProviderError(`Failed to load model: ${message}`);
+    }
+    return {
+        id: 'llama-local',
+        async dispose() {
+            await model.dispose();
+        },
+        async generateDigestMarkdown(input, options) {
+            const messages = buildPrompt(input, options.maxInputChars);
+            const systemContent = messages[0].content;
+            const userContent = messages[1].content;
+            const context = await model.createContext({ contextSize: LLAMA_CONTEXT_SIZE });
+            try {
+                const session = new LlamaChatSession({
+                    contextSequence: context.getSequence(),
+                    systemPrompt: systemContent,
+                });
+                const response = await withTimeout(session.prompt(userContent, {
+                    maxTokens: LLAMA_MAX_GENERATED_TOKENS,
+                    temperature: LLAMA_TEMPERATURE,
+                }), options.timeoutMs, () => new LlamaLocalDigestProviderError(`Llama provider timed out after ${options.timeoutMs}ms`));
+                return sanitizeConversationDigestMarkdown(response);
+            }
+            finally {
+                await context.dispose();
+            }
+        },
+    };
+}

package/dist/memory/digest/types.d.ts

@@ -0,0 +1,85 @@
+export interface ConversationDigestSettings {
+    enabled?: boolean;
+    initialized: boolean;
+    modelId: string;
+    initializedAt: string;
+}
+export interface DigestModelSpec {
+    id: string;
+    ggufUri: string;
+    approxSizeBytes: number;
+    license: string;
+    sourceUrl: string;
+    enabled: boolean;
+}
+export interface ConversationDigestInput {
+    sourcePath: string;
+    content: string;
+    contentHash: string;
+}
+export interface ConversationDigestOptions {
+    modelId: string;
+    maxInputChars: number;
+    timeoutMs: number;
+}
+export interface ConversationDigestInitResult {
+    initialized: boolean;
+    modelId: string;
+    initializedAt?: string;
+    error?: string;
+}
+export interface ConversationDigestProvider {
+    readonly id: string;
+    dispose?(): Promise<void>;
+    generateDigestMarkdown(input: ConversationDigestInput, options: ConversationDigestOptions): Promise<string>;
+}
+export interface DigestFileOptions {
+    workspaceRoot: string;
+    inputPath: string;
+    modelId: string;
+    outDir?: string;
+    maxInputChars?: number;
+    timeoutMs?: number;
+}
+export interface ProvisionalDigestResult {
+    markdown: string;
+    status: 'provisional';
+    contentHash: string;
+    indexed: boolean;
+    skipped: boolean;
+    error?: string;
+}
+export interface InitializeConversationDigestInput {
+    workspaceRoot: string;
+    modelId: string;
+    allowDownload: boolean;
+    enabled?: boolean;
+}
+export type DigestPendingResult = {
+    ok: true;
+    initialized: false;
+    action: 'noop';
+    reason: 'not-initialized';
+} | {
+    ok: true;
+    initialized: true;
+    action: 'noop';
+    reason: 'locked';
+} | {
+    ok: true;
+    initialized: true;
+    action: 'noop';
+    reason: 'no-pending';
+} | {
+    ok: true;
+    initialized: true;
+    action: 'digested';
+    count: number;
+    skipped: number;
+    errors: number;
+} | {
+    ok: false;
+    initialized: true;
+    action: 'error';
+    error: string;
+};

package/dist/memory/digest/types.js

@@ -0,0 +1 @@
+export {};

package/dist/memory/digest/worker.d.ts

@@ -0,0 +1,3 @@
+export declare function parseDigestWorkerSuccess(stdout: string): boolean;
+export declare function isDigestWorkerInvocation(args: string[]): boolean;
+export declare function runDigestFileInWorker(args: string[]): number | undefined;

package/dist/memory/digest/worker.js

@@ -0,0 +1,51 @@
+import { spawnSync } from 'node:child_process';
+import { parseArgs, numberFlag } from '../../utils/args.js';
+import { DEFAULT_DIGEST_TIMEOUT_MS, DIGEST_TIMEOUT_GRACE_MS, DIGEST_WORKER_FLAG, DIGEST_WORKER_RESULT_PREFIX, } from './constants.js';
+function isDigestWorkerResult(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const record = value;
+    return typeof record.markdown === 'string' && record.status === 'provisional';
+}
+export function parseDigestWorkerSuccess(stdout) {
+    const line = stdout
+        .split(/\r?\n/)
+        .reverse()
+        .find((candidate) => candidate.startsWith(DIGEST_WORKER_RESULT_PREFIX));
+    if (!line)
+        return false;
+    try {
+        return isDigestWorkerResult(JSON.parse(line.slice(DIGEST_WORKER_RESULT_PREFIX.length)));
+    }
+    catch {
+        return false;
+    }
+}
+export function isDigestWorkerInvocation(args) {
+    return parseArgs(args).flags.get(DIGEST_WORKER_FLAG) === true;
+}
+export function runDigestFileInWorker(args) {
+    const parsed = parseArgs(args);
+    if (parsed.flags.get(DIGEST_WORKER_FLAG) === true)
+        return undefined;
+    const entrypoint = process.argv[1];
+    if (!entrypoint)
+        return undefined;
+    const timeoutMs = numberFlag(parsed.flags, 'timeout-ms', DEFAULT_DIGEST_TIMEOUT_MS);
+    const result = spawnSync(process.execPath, [entrypoint, 'memory', 'digest-file', ...args, `--${DIGEST_WORKER_FLAG}`], {
+        cwd: process.cwd(),
+        encoding: 'utf8',
+        maxBuffer: 1024 * 1024 * 20,
+        timeout: timeoutMs + DIGEST_TIMEOUT_GRACE_MS,
+    });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    const workerSucceeded = parseDigestWorkerSuccess(result.stdout);
+    if (result.stderr && !workerSucceeded)
+        process.stderr.write(result.stderr);
+    if (result.status === 0 || workerSucceeded)
+        return 0;
+    if (result.status !== null)
+        return result.status;
+    return 1;
+}

package/dist/memory/embedder.d.ts

@@ -10,5 +10,6 @@ export declare class Embedder {
     embed(texts: string[]): Promise<Float32Array[]>;
     get dimension(): number | undefined;
     isReady(): boolean;
+    initialize(): Promise<void>;
     private loadModel;
 }

package/dist/memory/embedder.js

@@ -40,6 +40,11 @@ export class Embedder {
     isReady() {
         return this.pipeline !== null;
     }
+    async initialize() {
+        if (!this.pipeline) {
+            await this.loadModel();
+        }
+    }
     async loadModel() {
         try {
             const { EmbeddingModel, FlagEmbedding } = await import('fastembed');
@@ -49,7 +54,11 @@ export class Embedder {
                 'Xenova/all-MiniLM-L6-v2': EmbeddingModel.AllMiniLML6V2,
             };
             const model = modelMap[this.modelName] ?? EmbeddingModel.BGESmallENV15;
-            const embedder = await FlagEmbedding.init({ model: model, cacheDir: FASTEMBED_CACHE_DIR, showDownloadProgress: false });
+            const embedder = await FlagEmbedding.init({
+                model: model,
+                cacheDir: FASTEMBED_CACHE_DIR,
+                showDownloadProgress: false,
+            });
             this.pipeline = async (texts) => {
                 const result = [];
                 for await (const batch of embedder.embed(texts, texts.length)) {

package/dist/memory/index.d.ts

@@ -2,4 +2,4 @@ export { MemoryStore, StoreError } from './store.js';
 export { Embedder, EmbedderError } from './embedder.js';
 export { MemoryIndexer } from './indexer.js';
 export type { MemoryChunk, SearchResult, MemoryConfig, IndexStats } from './types.js';
-export { DEFAULT_MEMORY_CONFIG } from './types.js';
+export { DEFAULT_MEMORY_CONFIG } from './constants.js';

package/dist/memory/index.js

@@ -1,4 +1,4 @@
 export { MemoryStore, StoreError } from './store.js';
 export { Embedder, EmbedderError } from './embedder.js';
 export { MemoryIndexer } from './indexer.js';
-export { DEFAULT_MEMORY_CONFIG } from './types.js';
+export { DEFAULT_MEMORY_CONFIG } from './constants.js';

package/dist/memory/indexer.d.ts

@@ -1,12 +1,15 @@
-import type { Embedder } from './embedder.js';
 import type { MemoryStore } from './store.js';
 import type { IndexStats, MemoryConfig, SearchResult } from './types.js';
+export interface TextEmbedder {
+    embed(texts: string[]): Promise<Float32Array[]>;
+    initialize(): Promise<void>;
+}
 export declare class MemoryIndexer {
     private readonly store;
     private readonly embedder;
     private readonly config;
     private _ready;
-    constructor(store: MemoryStore, embedder: Embedder, config: MemoryConfig);
+    constructor(store: MemoryStore, embedder: TextEmbedder, config: MemoryConfig);
     indexFile(absolutePath: string): Promise<IndexStats>;
     private indexFileRelativeTo;
     indexDirectory(rootDir: string, opts?: {

package/dist/memory/indexer.js

@@ -1,29 +1,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { chunkMarkdown } from './chunker.js';
-const LOCK_RETRY_MS = 50;
-const LOCK_TIMEOUT_MS = 500;
-async function acquireLock(lockPath) {
-    const deadline = Date.now() + LOCK_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-        try {
-            fs.writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
-            return true;
-        }
-        catch {
-            await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
-        }
-    }
-    return false;
-}
-function releaseLock(lockPath) {
-    try {
-        fs.unlinkSync(lockPath);
-    }
-    catch {
-        // ignore
-    }
-}
+import { LOCK_RETRY_MS, LOCK_TIMEOUT_MS, RRF_K } from './constants.js';
+import { acquireLock, releaseLock } from '../utils/files.js';
 export class MemoryIndexer {
     store;
     embedder;
@@ -39,19 +18,19 @@ export class MemoryIndexer {
     }
     async indexFileRelativeTo(absolutePath, sourceRoot) {
         const source = path.relative(sourceRoot, absolutePath);
-        const existingHashes = this.store.hashesBySource(source);
+        const existingChunkIds = this.store.hashesBySource(source);
         let text;
         try {
             text = fs.readFileSync(absolutePath, 'utf8');
         }
         catch (err) {
             console.warn(`[memory-indexer] Cannot read file ${absolutePath}:`, err);
-            return { indexed: 0, deleted: 0, skipped: existingHashes.size };
+            return { indexed: 0, deleted: 0, skipped: existingChunkIds.size };
         }
         const allChunks = chunkMarkdown(text, source, this.config);
-        const newHashes = new Set(allChunks.map((c) => c.id));
-        const toIndex = allChunks.filter((c) => !existingHashes.has(c.id));
-        const toDelete = [...existingHashes].filter((h) => !newHashes.has(h));
+        const currentChunkIds = new Set(allChunks.map((chunk) => chunk.id));
+        const toIndex = allChunks.filter((chunk) => !existingChunkIds.has(chunk.id));
+        const toDelete = [...existingChunkIds].filter((id) => !currentChunkIds.has(id));
         let embeddings = [];
         if (toIndex.length > 0) {
             try {
@@ -59,7 +38,7 @@ export class MemoryIndexer {
             }
             catch (err) {
                 console.warn(`[memory-indexer] Embedding failed for ${absolutePath}:`, err);
-                return { indexed: 0, deleted: 0, skipped: existingHashes.size };
+                return { indexed: 0, deleted: 0, skipped: existingChunkIds.size };
             }
         }
         if (toIndex.length > 0) {
@@ -135,24 +114,22 @@ export class MemoryIndexer {
         if (bm25Ids.size > 0) {
             denseResults = denseResults.filter((result) => bm25Ids.has(result.id));
         }
-        // RRF fusion (k=60)
-        const k = 60;
         const scoreMap = new Map();
         denseResults.forEach((r, rank) => {
-            scoreMap.set(r.id, { dense: 1 / (k + rank + 1), bm25: 0 });
+            scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0 });
         });
         bm25Results.forEach((r, rank) => {
             const existing = scoreMap.get(r.id);
             if (existing) {
-                existing.bm25 = 1 / (k + rank + 1);
+                existing.bm25 = 1 / (RRF_K + rank + 1);
             }
             else {
-                scoreMap.set(r.id, { dense: 0, bm25: 1 / (k + rank + 1) });
+                scoreMap.set(r.id, { dense: 0, bm25: 1 / (RRF_K + rank + 1) });
             }
         });
         const hasDense = this.store.vecAvailable && denseResults.length > 0;
         const numRetrievers = hasDense ? 2 : 1;
-        const maxScore = numRetrievers / 61;
+        const maxScore = numRetrievers / (RRF_K + 1);
         const ranked = [...scoreMap.entries()]
             .map(([id, scores]) => ({
             id,
@@ -193,7 +170,7 @@ export class MemoryIndexer {
         const savePath = path.join(rawDir, `conv_save_${datePart}.md`);
         const lockPath = `${savePath}.lock`;
         fs.mkdirSync(rawDir, { recursive: true });
-        const acquired = await acquireLock(lockPath);
+        const acquired = await acquireLock(lockPath, LOCK_TIMEOUT_MS, LOCK_RETRY_MS);
         if (!acquired) {
             console.warn('[memory-indexer] Could not acquire write lock, writing anyway (fail-open)');
         }
@@ -202,12 +179,13 @@ export class MemoryIndexer {
         }
         finally {
             if (acquired)
-                releaseLock(lockPath);
+                releaseLock(lockPath, { ignoreErrors: true });
         }
         return { indexed: 0, deleted: 0, skipped: 0 };
     }
     async startupIndex() {
         try {
+            await this.embedder.initialize();
             await this.indexDirectory(path.join(this.config.wikiDir, 'compiled'), {
                 relativeBase: this.config.wikiDir,
                 excludeFiles: ['index.md', 'log.md'],