@hanhnd/agent-kit 1.0.30 → 1.0.32

package/dist/memory/__tests__/digest-llama-local.test.d.ts

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

package/dist/memory/__tests__/digest-llama-local.test.js

@@ -0,0 +1,33 @@
+import * as assert from 'node:assert/strict';
+import { describe, test } from 'node:test';
+import { createLlamaLocalDigestProvider, sanitizeConversationDigestMarkdown, trimConversationExport, } from '../digest/providers/llama-local.js';
+const INPUT = {
+    sourcePath: '.agent-kit/wiki/archive/conversations/conv_2026-05-19T00-45-17-697Z.md',
+    contentHash: 'tiny',
+    content: '**User:** use local digest generation for archived conversations',
+};
+describe('createLlamaLocalDigestProvider', () => {
+    test('strips code fences without rewriting model output', () => {
+        const markdown = sanitizeConversationDigestMarkdown('```md\n# Notes\n\n**Summary**\n\nUse local digesting.\n```');
+        assert.match(markdown, /^# Notes/);
+        assert.match(markdown, /\*\*Summary\*\*/);
+        assert.doesNotMatch(markdown, /```/);
+    });
+    test('trims conversation exports from the end without parsing turns', () => {
+        const trimmed = trimConversationExport('first decision\nsecond decision\nfinal decision', 14);
+        assert.match(trimmed, /omitted/);
+        assert.doesNotMatch(trimmed, /first decision/);
+        assert.match(trimmed, /final decision/);
+    });
+    test('runs an opt-in smoke test against a real model', { skip: !process.env.AGENT_KIT_DIGEST_MODEL_ID }, async () => {
+        const modelId = process.env.AGENT_KIT_DIGEST_MODEL_ID;
+        const provider = await createLlamaLocalDigestProvider(modelId);
+        const output = await provider.generateDigestMarkdown(INPUT, {
+            modelId,
+            maxInputChars: 1000,
+            timeoutMs: 120_000,
+        });
+        assert.match(output, /^# Conversation Digest:/);
+        assert.match(output, /Status: provisional/);
+    });
+});

package/dist/memory/__tests__/digest-pending.test.d.ts

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

package/dist/memory/__tests__/digest-pending.test.js

@@ -0,0 +1,164 @@
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { afterEach, describe, test } from 'node:test';
+import { createTempDirTracker } from '../../__tests__/temp-dir.js';
+import { writeConversationDigestSettings } from '../digest/files.js';
+import { digestPendingConversations } from '../digest/processor.js';
+const tempDirs = createTempDirTracker();
+afterEach(() => {
+    tempDirs.cleanup();
+});
+function writeInitState(workspace, modelId = 'qwen2.5-1.5b-instruct-q4') {
+    writeConversationDigestSettings(workspace, {
+        enabled: true,
+        initialized: true,
+        modelId,
+        initializedAt: new Date().toISOString(),
+    });
+}
+function writeConvFile(workspace, name, content) {
+    const rawDir = path.join(workspace, '.agent-kit', 'wiki', 'raw');
+    fs.mkdirSync(rawDir, { recursive: true });
+    const filePath = path.join(rawDir, name);
+    fs.writeFileSync(filePath, content, 'utf8');
+    return filePath;
+}
+function stubDigest(result = {}) {
+    return async () => ({
+        markdown: 'out.md',
+        status: 'provisional',
+        contentHash: 'abc123',
+        skipped: false,
+        indexed: false,
+        ...result,
+    });
+}
+describe('digestPendingConversations', () => {
+    test('C13: no init state → noop not-initialized', async () => {
+        const workspace = tempDirs.makeTempDir('pending-c13-');
+        const result = await digestPendingConversations({ workspaceRoot: workspace });
+        assert.equal(result.ok, true);
+        assert.equal(result.initialized, false);
+        assert.equal(result.action, 'noop');
+        if (result.action === 'noop')
+            assert.equal(result.reason, 'not-initialized');
+    });
+    test('C14: init state, live lockfile → noop locked', async () => {
+        const workspace = tempDirs.makeTempDir('pending-c14-');
+        writeInitState(workspace);
+        const lockDir = path.join(workspace, '.agent-kit');
+        fs.mkdirSync(lockDir, { recursive: true });
+        fs.writeFileSync(path.join(lockDir, 'digest-worker.lock'), JSON.stringify({ pid: process.pid }));
+        const result = await digestPendingConversations({ workspaceRoot: workspace });
+        assert.equal(result.ok, true);
+        assert.equal(result.initialized, true);
+        assert.equal(result.action, 'noop');
+        if (result.action === 'noop')
+            assert.equal(result.reason, 'locked');
+    });
+    test('C15: init state, no lockfile, no conv files → noop no-pending, lock released', async () => {
+        const workspace = tempDirs.makeTempDir('pending-c15-');
+        writeInitState(workspace);
+        const result = await digestPendingConversations({ workspaceRoot: workspace });
+        assert.equal(result.ok, true);
+        assert.equal(result.action, 'noop');
+        if (result.action === 'noop')
+            assert.equal(result.reason, 'no-pending');
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'digest-worker.lock')), false);
+    });
+    test('C19: wiki/raw dir does not exist → noop no-pending', async () => {
+        const workspace = tempDirs.makeTempDir('pending-c19-');
+        writeInitState(workspace);
+        const result = await digestPendingConversations({ workspaceRoot: workspace });
+        assert.equal(result.action, 'noop');
+        if (result.action === 'noop')
+            assert.equal(result.reason, 'no-pending');
+    });
+    test('C16: one undigested conv file → digested count:1, lock released', async () => {
+        const workspace = tempDirs.makeTempDir('pending-c16-');
+        writeInitState(workspace);
+        writeConvFile(workspace, 'conv_2026-01-01T00-00-00-001Z.md', '**User:** hello\n\n**Assistant:** hi\n');
+        const result = await digestPendingConversations({
+            workspaceRoot: workspace,
+            digestFn: stubDigest(),
+        });
+        assert.equal(result.ok, true);
+        assert.equal(result.action, 'digested');
+        if (result.action === 'digested') {
+            assert.equal(result.count, 1);
+            assert.equal(result.errors, 0);
+        }
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'digest-worker.lock')), false);
+    });
+    test('C17: digestFn throws for one file → errors:1, lock released', async () => {
+        const workspace = tempDirs.makeTempDir('pending-c17-');
+        writeInitState(workspace);
+        writeConvFile(workspace, 'conv_2026-01-01T00-00-00-001Z.md', '**User:** hello\n\n**Assistant:** hi\n');
+        const throwingFn = async () => {
+            throw new Error('model error');
+        };
+        const result = await digestPendingConversations({
+            workspaceRoot: workspace,
+            digestFn: throwingFn,
+        });
+        assert.equal(result.ok, true);
+        assert.equal(result.action, 'digested');
+        if (result.action === 'digested') {
+            assert.equal(result.errors, 1);
+            assert.equal(result.count, 0);
+        }
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'digest-worker.lock')), false);
+    });
+    test('C18: stale lockfile (dead PID) → reclaims lock and returns (no-pending since no conv files)', async () => {
+        const workspace = tempDirs.makeTempDir('pending-c18-');
+        writeInitState(workspace);
+        const lockDir = path.join(workspace, '.agent-kit');
+        fs.mkdirSync(lockDir, { recursive: true });
+        fs.writeFileSync(path.join(lockDir, 'digest-worker.lock'), JSON.stringify({ pid: 999999999 }));
+        const result = await digestPendingConversations({ workspaceRoot: workspace });
+        assert.ok(result.ok);
+        if (result.action === 'noop')
+            assert.notEqual(result.reason, 'locked');
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'digest-worker.lock')), false);
+    });
+    test('C20: 3 undigested conv files → digestFn called 3 times, count+skipped+errors=3', async () => {
+        const workspace = tempDirs.makeTempDir('pending-c20-');
+        writeInitState(workspace);
+        writeConvFile(workspace, 'conv_2026-01-01T00-00-00-001Z.md', '**User:** a\n\n**Assistant:** b\n');
+        writeConvFile(workspace, 'conv_2026-01-01T00-00-00-002Z.md', '**User:** c\n\n**Assistant:** d\n');
+        writeConvFile(workspace, 'conv_2026-01-01T00-00-00-003Z.md', '**User:** e\n\n**Assistant:** f\n');
+        let callCount = 0;
+        const countingFn = async () => {
+            callCount++;
+            return {
+                markdown: 'out.md',
+                status: 'provisional',
+                contentHash: 'abc',
+                skipped: false,
+                indexed: false,
+            };
+        };
+        const result = await digestPendingConversations({
+            workspaceRoot: workspace,
+            digestFn: countingFn,
+        });
+        assert.equal(callCount, 3);
+        assert.equal(result.action, 'digested');
+        if (result.action === 'digested') {
+            assert.equal(result.count + result.skipped + result.errors, 3);
+        }
+    });
+    test('C21: outer error (fs throws unexpected) → returns ok:false, releases lock', async () => {
+        const workspace = tempDirs.makeTempDir('pending-c21-');
+        writeInitState(workspace);
+        // Create wiki/raw as a file (not a dir) so readdirSync throws ENOTDIR
+        const wikiDir = path.join(workspace, '.agent-kit', 'wiki');
+        fs.mkdirSync(wikiDir, { recursive: true });
+        fs.writeFileSync(path.join(wikiDir, 'raw'), 'not-a-directory', 'utf8');
+        const result = await digestPendingConversations({ workspaceRoot: workspace });
+        assert.equal(result.ok, false);
+        assert.equal(result.action, 'error');
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'digest-worker.lock')), false);
+    });
+});

package/dist/memory/__tests__/digest-processor.test.d.ts

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

package/dist/memory/__tests__/digest-processor.test.js

@@ -0,0 +1,34 @@
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { afterEach, describe, test } from 'node:test';
+import { createTempDirTracker } from '../../__tests__/temp-dir.js';
+import { DEFAULT_DIGEST_MODEL_ID } from '../digest/constants.js';
+import { defaultProvisionalDigestDir, provisionalDigestPath, readConversationDigestInput } from '../digest/files.js';
+import { digestConversationFile } from '../digest/processor.js';
+const tempDirs = createTempDirTracker();
+afterEach(() => {
+    tempDirs.cleanup();
+});
+describe('digestConversationFile', () => {
+    test('returns existing content-hash named provisional digest without loading model', async () => {
+        const workspace = tempDirs.makeTempDir('digest-processor-');
+        const inputPath = path.join(workspace, '.agent-kit', 'wiki', 'archive', 'conversations', 'conv.md');
+        fs.mkdirSync(path.dirname(inputPath), { recursive: true });
+        fs.writeFileSync(inputPath, '**User:** remember this decision', 'utf8');
+        const input = readConversationDigestInput(workspace, inputPath);
+        const outDir = defaultProvisionalDigestDir(workspace);
+        const markdownPath = provisionalDigestPath(outDir, input);
+        fs.mkdirSync(path.dirname(markdownPath), { recursive: true });
+        fs.writeFileSync(markdownPath, '# Conversation Digest: conv\n', 'utf8');
+        const result = await digestConversationFile({
+            workspaceRoot: workspace,
+            inputPath,
+            modelId: DEFAULT_DIGEST_MODEL_ID,
+        });
+        assert.equal(result.skipped, true);
+        assert.equal(result.markdown, markdownPath);
+        assert.equal(result.contentHash, input.contentHash);
+        assert.match(path.basename(result.markdown), /^[a-f0-9]{16}-conv\.md$/);
+    });
+});

package/dist/memory/__tests__/digest-worker.test.d.ts

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

package/dist/memory/__tests__/digest-worker.test.js

@@ -0,0 +1,46 @@
+import * as assert from 'node:assert/strict';
+import { describe, test } from 'node:test';
+import { parseDigestWorkerSuccess } from '../digest/worker.js';
+import { DIGEST_WORKER_RESULT_PREFIX } from '../digest/constants.js';
+function workerResultLine(result) {
+    return DIGEST_WORKER_RESULT_PREFIX + JSON.stringify(result);
+}
+describe('parseDigestWorkerSuccess', () => {
+    test('accepts a structured provisional digest worker line', () => {
+        const stdout = [
+            '[memory-kit] model-load: 612ms',
+            workerResultLine({
+                markdown: '/tmp/conversation-digests/abc-conv.md',
+                status: 'provisional',
+                contentHash: 'abc',
+                indexed: true,
+                skipped: false,
+            }),
+        ].join('\n');
+        assert.equal(parseDigestWorkerSuccess(stdout), true);
+    });
+    test('rejects stdout that only mentions markdown as plain text', () => {
+        const stdout = 'The model produced markdown but no digest result envelope.';
+        assert.equal(parseDigestWorkerSuccess(stdout), false);
+    });
+    test('rejects unprefixed JSON objects', () => {
+        const stdout = [
+            JSON.stringify({ markdown: '/tmp/file.md', status: 'draft' }),
+            JSON.stringify({ markdown: '/tmp/file.md', status: 'provisional' }),
+        ].join('\n');
+        assert.equal(parseDigestWorkerSuccess(stdout), false);
+    });
+    test('uses the last valid digest worker line after noisy output', () => {
+        const stdout = [
+            JSON.stringify({ event: 'model-load', markdown: false }),
+            'Metal cleanup warning',
+            workerResultLine({ markdown: '/tmp/final.md', status: 'provisional' }),
+            'trailing non-json output',
+        ].join('\n');
+        assert.equal(parseDigestWorkerSuccess(stdout), true);
+    });
+    test('rejects malformed digest worker lines', () => {
+        const stdout = ['[memory-kit] model-load: 612ms', DIGEST_WORKER_RESULT_PREFIX + '{"markdown":'].join('\n');
+        assert.equal(parseDigestWorkerSuccess(stdout), false);
+    });
+});

package/dist/memory/__tests__/embedder.test.d.ts

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

package/dist/memory/__tests__/embedder.test.js

@@ -0,0 +1,14 @@
+import * as assert from 'node:assert/strict';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { describe, test } from 'node:test';
+import { DEFAULT_MODEL_CACHE_DIR, FASTEMBED_CACHE_DIR } from '../embedder.js';
+import { AGENT_KIT_HOME, CREDENTIALS_FILE } from '../../utils/paths.js';
+describe('Embedder cache paths', () => {
+    test('uses global Agent Kit home for user-level files', () => {
+        assert.equal(AGENT_KIT_HOME, path.join(os.homedir(), '.agent-kit'));
+        assert.equal(CREDENTIALS_FILE, path.join(AGENT_KIT_HOME, 'credentials'));
+        assert.equal(DEFAULT_MODEL_CACHE_DIR, path.join(AGENT_KIT_HOME, 'cache', 'models'));
+        assert.equal(FASTEMBED_CACHE_DIR, path.join(DEFAULT_MODEL_CACHE_DIR, 'fastembed'));
+    });
+});

package/dist/memory/__tests__/indexer.test.js

@@ -7,16 +7,12 @@ import * as path from 'node:path';
 import { after, before, describe, test } from 'node:test';
 import { MemoryIndexer } from '../indexer.js';
 import { MemoryStore } from '../store.js';
-// Stub embedder — returns deterministic non-zero vectors without loading any model
 class StubEmbedder {
     async embed(texts) {
         return texts.map(() => new Float32Array(384).fill(0.05));
     }
-    get dimension() {
-        return 384;
-    }
-    isReady() {
-        return true;
+    initialize() {
+        return Promise.resolve();
     }
 }
 function makeConfig(wikiDir) {
@@ -140,7 +136,8 @@ describe('MemoryIndexer', () => {
         const compiledDir = path.join(testCfg.wikiDir, 'compiled');
         try {
             fs.mkdirSync(compiledDir, { recursive: true });
-            testStore.upsert([{
+            testStore.upsert([
+                {
                     id: 'stale-daily-file-0001',
                     source: '2026-05-18.md',
                     heading: 'Stale',
@@ -148,7 +145,8 @@ describe('MemoryIndexer', () => {
                     content: 'pre migration content',
                     lineStart: 1,
                     lineEnd: 2,
-                }], [new Float32Array(384)]);
+                },
+            ], [new Float32Array(384)]);
             assert.ok(testStore.hashesBySource('2026-05-18.md').size > 0);
             const stats = await testIndexer.indexDirectory(compiledDir, {
                 relativeBase: testCfg.wikiDir,
@@ -257,10 +255,7 @@ describe('MemoryIndexer', () => {
             fs.writeFileSync(secondPath, secondContent, 'utf8');
             const results = await testIndexer.search('duplicate source query', 2);
             assert.equal(results.length, 2);
-            assert.deepEqual(results.map((result) => result.chunk.source), [
-                'compiled/entities/first.md',
-                'compiled/entities/second.md',
-            ]);
+            assert.deepEqual(results.map((result) => result.chunk.source), ['compiled/entities/first.md', 'compiled/entities/second.md']);
             assert.equal(results[0].chunk.content, firstContent);
             assert.equal(results[1].chunk.content, secondContent);
         }

package/dist/memory/__tests__/lockfile.test.d.ts

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

package/dist/memory/__tests__/lockfile.test.js

@@ -0,0 +1,81 @@
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { afterEach, describe, test } from 'node:test';
+import { createTempDirTracker } from '../../__tests__/temp-dir.js';
+import { DIGEST_LOCKFILE_REL_PATH } from '../digest/constants.js';
+import { releaseLock, tryAcquireProcessLock } from '../../utils/files.js';
+const tempDirs = createTempDirTracker();
+afterEach(() => {
+    tempDirs.cleanup();
+});
+function lockPath(workspace) {
+    return path.join(workspace, DIGEST_LOCKFILE_REL_PATH);
+}
+describe('tryAcquireProcessLock', () => {
+    test('C1: no lockfile → creates it with current PID and returns true', () => {
+        const workspace = tempDirs.makeTempDir('lockfile-c1-');
+        const acquired = tryAcquireProcessLock(lockPath(workspace));
+        assert.equal(acquired, true);
+        const lockFile = path.join(workspace, '.agent-kit', 'digest-worker.lock');
+        const content = JSON.parse(fs.readFileSync(lockFile, 'utf8'));
+        assert.equal(content.pid, process.pid);
+    });
+    test('C2: lockfile with live foreign PID → returns false without modifying file', () => {
+        const workspace = tempDirs.makeTempDir('lockfile-c2-');
+        const lockDir = path.join(workspace, '.agent-kit');
+        const lockFile = path.join(lockDir, 'digest-worker.lock');
+        fs.mkdirSync(lockDir, { recursive: true });
+        // Use process.pid as "live" pid (current process is definitely alive)
+        const livePid = process.pid;
+        fs.writeFileSync(lockFile, JSON.stringify({ pid: livePid }), 'utf8');
+        const originalContent = fs.readFileSync(lockFile, 'utf8');
+        const acquired = tryAcquireProcessLock(lockPath(workspace));
+        assert.equal(acquired, false);
+        // File must be unchanged
+        assert.equal(fs.readFileSync(lockFile, 'utf8'), originalContent);
+    });
+    test('C3: lockfile with dead PID (ESRCH) → deletes stale lock, creates new one, returns true', () => {
+        const workspace = tempDirs.makeTempDir('lockfile-c3-');
+        const lockDir = path.join(workspace, '.agent-kit');
+        const lockFile = path.join(lockDir, 'digest-worker.lock');
+        fs.mkdirSync(lockDir, { recursive: true });
+        // PID 999999999 is virtually guaranteed to be dead
+        fs.writeFileSync(lockFile, JSON.stringify({ pid: 999999999 }), 'utf8');
+        const acquired = tryAcquireProcessLock(lockPath(workspace));
+        assert.equal(acquired, true);
+        const content = JSON.parse(fs.readFileSync(lockFile, 'utf8'));
+        assert.equal(content.pid, process.pid);
+    });
+    test('C4: concurrent callers — only one returns true (wx atomicity)', async () => {
+        const workspace = tempDirs.makeTempDir('lockfile-c4-');
+        // Call twice in the same tick; first wins, second sees EEXIST with live PID.
+        const r1 = tryAcquireProcessLock(lockPath(workspace));
+        const r2 = tryAcquireProcessLock(lockPath(workspace));
+        assert.equal(r1, true);
+        assert.equal(r2, false);
+    });
+    test('stale unparseable lockfile → treated as stale, returns true', () => {
+        const workspace = tempDirs.makeTempDir('lockfile-stale-');
+        const lockDir = path.join(workspace, '.agent-kit');
+        const lockFile = path.join(lockDir, 'digest-worker.lock');
+        fs.mkdirSync(lockDir, { recursive: true });
+        fs.writeFileSync(lockFile, 'not-json', 'utf8');
+        const acquired = tryAcquireProcessLock(lockPath(workspace));
+        assert.equal(acquired, true);
+    });
+});
+describe('releaseLock', () => {
+    test('C5: lockfile exists → deletes it', () => {
+        const workspace = tempDirs.makeTempDir('lockfile-c5-');
+        assert.equal(tryAcquireProcessLock(lockPath(workspace)), true);
+        const lockFile = path.join(workspace, '.agent-kit', 'digest-worker.lock');
+        assert.equal(fs.existsSync(lockFile), true);
+        releaseLock(lockPath(workspace));
+        assert.equal(fs.existsSync(lockFile), false);
+    });
+    test('C6: no lockfile → does not throw', () => {
+        const workspace = tempDirs.makeTempDir('lockfile-c6-');
+        assert.doesNotThrow(() => releaseLock(lockPath(workspace)));
+    });
+});

package/dist/memory/__tests__/store.test.js

@@ -54,8 +54,16 @@ describe('MemoryStore', () => {
         assert.ok(hashes.has('upsert-test-0001'));
     });
     test('deleteBySource removes all chunks for that source', () => {
-        const c1 = makeChunk({ id: 'del-src-0001', source: 'deleteme.md', content: 'delete source chunk 1' });
-        const c2 = makeChunk({ id: 'del-src-0002', source: 'deleteme.md', content: 'delete source chunk 2' });
+        const c1 = makeChunk({
+            id: 'del-src-0001',
+            source: 'deleteme.md',
+            content: 'delete source chunk 1',
+        });
+        const c2 = makeChunk({
+            id: 'del-src-0002',
+            source: 'deleteme.md',
+            content: 'delete source chunk 2',
+        });
         store.upsert([c1, c2], [new Float32Array(384), new Float32Array(384)]);
         store.deleteBySource('deleteme.md');
         const hashes = store.hashesBySource('deleteme.md');
@@ -124,7 +132,11 @@ describe('MemoryStore', () => {
         assert.equal(results[0].id, 'partial-found-0001');
     });
     test('indexedSources includes source after upsert', () => {
-        const chunk = makeChunk({ id: 'indexed-src-0001', source: 'indexed-source.md', content: 'indexed' });
+        const chunk = makeChunk({
+            id: 'indexed-src-0001',
+            source: 'indexed-source.md',
+            content: 'indexed',
+        });
         store.upsert([chunk], [new Float32Array(384)]);
         const sources = store.indexedSources();
         assert.ok(sources.includes('indexed-source.md'), `Expected 'indexed-source.md' in ${sources.join(', ')}`);

package/dist/memory/chunker.js

@@ -1,6 +1,6 @@
-import { createHash } from 'crypto';
+import { sha256Hex } from '../utils/hash.js';
 export function computeChunkId(content) {
-    return createHash('sha256').update(content).digest('hex').slice(0, 16);
+    return sha256Hex(content).slice(0, 16);
 }
 export function cleanContentForEmbedding(text) {
     return text.replace(/<!--[\s\S]*?-->/g, '');
@@ -116,9 +116,7 @@ export function chunkMarkdown(text, source, config) {
         const sectionText = section.lines.map((l) => l.text).join('\n');
         if (!sectionText.trim())
             continue;
-        const fullText = prevOverlapLines.length > 0
-            ? `${prevOverlapLines.join('\n')}\n${sectionText}`
-            : sectionText;
+        const fullText = prevOverlapLines.length > 0 ? `${prevOverlapLines.join('\n')}\n${sectionText}` : sectionText;
         const parts = splitSection(fullText, chunkSize);
         for (let pi = 0; pi < parts.length; pi++) {
             const part = parts[pi];

package/dist/memory/constants.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryConfig } from './types.js';
+export declare const DEFAULT_MEMORY_CONFIG: MemoryConfig;
+export declare const LOCK_RETRY_MS = 50;
+export declare const LOCK_TIMEOUT_MS = 500;
+export declare const RRF_K = 60;

package/dist/memory/constants.js

@@ -0,0 +1,12 @@
+export const DEFAULT_MEMORY_CONFIG = {
+    enabled: false,
+    wikiDir: '',
+    topK: 5,
+    chunkSize: 1500,
+    overlapLines: 2,
+    embeddingModel: 'Xenova/bge-small-en-v1.5',
+    vectorDimension: 384,
+};
+export const LOCK_RETRY_MS = 50;
+export const LOCK_TIMEOUT_MS = 500;
+export const RRF_K = 60;

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

@@ -0,0 +1,14 @@
+export declare const DEFAULT_DIGEST_MODEL_ID = "qwen2.5-1.5b-instruct-q4";
+export declare const DEFAULT_DIGEST_MAX_INPUT_CHARS = 3000;
+export declare const DEFAULT_DIGEST_TIMEOUT_MS = 120000;
+export declare const DIGEST_TIMEOUT_GRACE_MS = 5000;
+export declare const DIGEST_WORKER_FLAG = "__agent-kit-digest-worker";
+export declare const DIGEST_WORKER_RESULT_PREFIX = "AGENT_KIT_DIGEST_RESULT ";
+export declare const KIT_DIR = ".agent-kit";
+export declare const WIKI_DIR: string;
+export declare const WIKI_RAW_DIR: string;
+export declare const PROVISIONAL_DIGEST_DIR: string;
+export declare const DIGEST_LOCKFILE_REL_PATH: string;
+export declare const LLAMA_CONTEXT_SIZE = 4096;
+export declare const LLAMA_MAX_GENERATED_TOKENS = 512;
+export declare const LLAMA_TEMPERATURE = 0.1;

package/dist/memory/digest/constants.js

@@ -0,0 +1,15 @@
+import * as path from 'node:path';
+export const DEFAULT_DIGEST_MODEL_ID = 'qwen2.5-1.5b-instruct-q4';
+export const DEFAULT_DIGEST_MAX_INPUT_CHARS = 3000;
+export const DEFAULT_DIGEST_TIMEOUT_MS = 120_000;
+export const DIGEST_TIMEOUT_GRACE_MS = 5_000;
+export const DIGEST_WORKER_FLAG = '__agent-kit-digest-worker';
+export const DIGEST_WORKER_RESULT_PREFIX = 'AGENT_KIT_DIGEST_RESULT ';
+export const KIT_DIR = '.agent-kit';
+export const WIKI_DIR = path.join(KIT_DIR, 'wiki');
+export const WIKI_RAW_DIR = path.join(WIKI_DIR, 'raw');
+export const PROVISIONAL_DIGEST_DIR = path.join(WIKI_DIR, 'compiled', 'provisional', 'conversation-digests');
+export const DIGEST_LOCKFILE_REL_PATH = path.join(KIT_DIR, 'digest-worker.lock');
+export const LLAMA_CONTEXT_SIZE = 4096;
+export const LLAMA_MAX_GENERATED_TOKENS = 512;
+export const LLAMA_TEMPERATURE = 0.1;

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

@@ -0,0 +1,7 @@
+import type { ConversationDigestInput, ConversationDigestSettings } from './types.js';
+export declare function defaultProvisionalDigestDir(workspaceRoot: string): string;
+export declare function readConversationDigestInput(workspaceRoot: string, inputPath: string): ConversationDigestInput;
+export declare function provisionalDigestPath(outDir: string, input: Pick<ConversationDigestInput, 'sourcePath' | 'contentHash'>): string;
+export declare function findExistingProvisionalDigest(outDir: string, input: ConversationDigestInput): string | undefined;
+export declare function writeProvisionalDigestFile(outDir: string, input: ConversationDigestInput, markdown: string): string;
+export declare function writeConversationDigestSettings(workspaceRoot: string, digest: ConversationDigestSettings): void;

package/dist/memory/digest/files.js

@@ -0,0 +1,45 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { PROVISIONAL_DIGEST_DIR } from './constants.js';
+import { atomicWriteTextFile } from '../../utils/files.js';
+import { sha256Hex } from '../../utils/hash.js';
+import { loadProjectSettings, writeProjectSettings } from '../../tools/config.js';
+export function defaultProvisionalDigestDir(workspaceRoot) {
+    return path.join(workspaceRoot, PROVISIONAL_DIGEST_DIR);
+}
+export function readConversationDigestInput(workspaceRoot, inputPath) {
+    const absoluteInput = path.isAbsolute(inputPath) ? inputPath : path.resolve(workspaceRoot, inputPath);
+    const content = fs.readFileSync(absoluteInput, 'utf8');
+    return {
+        sourcePath: path.relative(workspaceRoot, absoluteInput),
+        content,
+        contentHash: sha256Hex(content),
+    };
+}
+export function provisionalDigestPath(outDir, input) {
+    const safeName = path
+        .basename(input.sourcePath)
+        .replace(/\.[^.]+$/, '')
+        .replace(/[^a-z0-9._-]+/gi, '-');
+    return path.join(outDir, `${input.contentHash.slice(0, 16)}-${safeName}.md`);
+}
+export function findExistingProvisionalDigest(outDir, input) {
+    const markdownPath = provisionalDigestPath(outDir, input);
+    return fs.existsSync(markdownPath) ? markdownPath : undefined;
+}
+export function writeProvisionalDigestFile(outDir, input, markdown) {
+    const markdownPath = provisionalDigestPath(outDir, input);
+    atomicWriteTextFile(markdownPath, markdown);
+    return markdownPath;
+}
+export function writeConversationDigestSettings(workspaceRoot, digest) {
+    const current = loadProjectSettings(workspaceRoot);
+    const memory = current.memory ?? {};
+    writeProjectSettings(workspaceRoot, {
+        memory: {
+            ...memory,
+            enabled: memory.enabled ?? true,
+            conversationDigest: digest,
+        },
+    });
+}

package/dist/memory/digest/model-registry.d.ts

@@ -0,0 +1,6 @@
+import type { DigestModelSpec } from './types.js';
+export declare class DigestModelRegistryError extends Error {
+    constructor(message: string);
+}
+export declare const DIGEST_MODEL_REGISTRY: Record<string, DigestModelSpec>;
+export declare function getDigestModelSpec(modelId: string): DigestModelSpec;