@hanhnd/agent-kit 1.0.34 → 1.0.36

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

@@ -1,6 +1,6 @@
 import { DigestModelId } from './types.js';
-export declare const DEFAULT_DIGEST_MODEL_ID = DigestModelId.DEFAULT;
-export declare const DEFAULT_DIGEST_MAX_INPUT_CHARS = 3000;
+export declare const DEFAULT_DIGEST_MODEL_ID = DigestModelId.BASE;
+export declare const DEFAULT_DIGEST_MAX_INPUT_CHARS = 10000;
 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";
@@ -12,6 +12,6 @@ export declare const PROVISIONAL_DIGEST_DIR: string;
 export declare const DIGEST_LOCKFILE_REL_PATH: string;
 export declare const DIGEST_WORKER_STATUS_REL_PATH: string;
 export declare const DIGEST_WORKER_LOG_REL_PATH: string;
-export declare const LLAMA_CONTEXT_SIZE = 4096;
+export declare const LLAMA_CONTEXT_SIZE = 8192;
 export declare const LLAMA_MAX_GENERATED_TOKENS = 512;
 export declare const LLAMA_TEMPERATURE = 0.1;

package/dist/services/digest/constants.js

@@ -1,7 +1,7 @@
 import * as path from 'node:path';
 import { DigestModelId } from './types.js';
-export const DEFAULT_DIGEST_MODEL_ID = DigestModelId.DEFAULT;
-export const DEFAULT_DIGEST_MAX_INPUT_CHARS = 3000;
+export const DEFAULT_DIGEST_MODEL_ID = DigestModelId.BASE;
+export const DEFAULT_DIGEST_MAX_INPUT_CHARS = 10000;
 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';
@@ -14,6 +14,6 @@ const DIGEST_WORKER_DIR = path.join(WIKI_DIR, 'digest');
 export const DIGEST_LOCKFILE_REL_PATH = path.join(DIGEST_WORKER_DIR, 'digest-worker.lock');
 export const DIGEST_WORKER_STATUS_REL_PATH = path.join(DIGEST_WORKER_DIR, 'digest-worker.status.json');
 export const DIGEST_WORKER_LOG_REL_PATH = path.join(DIGEST_WORKER_DIR, 'digest-worker.log');
-export const LLAMA_CONTEXT_SIZE = 4096;
+export const LLAMA_CONTEXT_SIZE = 8192;
 export const LLAMA_MAX_GENERATED_TOKENS = 512;
 export const LLAMA_TEMPERATURE = 0.1;

package/dist/services/digest/digest-background.test.js

@@ -1,15 +1,26 @@
 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 { afterEach, describe, test, beforeEach } from 'node:test';
 import { createTempDirTracker } from '../../utils/temp-dir.test.js';
 import { writeConversationDigestSettings } from './files.js';
 import { launchDigestPendingWorker, runDigestPendingWorker } from './background.js';
 import { DIGEST_WORKER_LOG_REL_PATH, DIGEST_WORKER_STATUS_REL_PATH } from './constants.js';
 import { DigestModelId } from './types.js';
 const tempDirs = createTempDirTracker();
+let originalHome;
+let originalUserProfile;
+beforeEach(() => {
+    originalHome = process.env.HOME;
+    originalUserProfile = process.env.USERPROFILE;
+    const mockHome = tempDirs.makeTempDir('mock-home-');
+    process.env.HOME = mockHome;
+    process.env.USERPROFILE = mockHome;
+});
 afterEach(() => {
     tempDirs.cleanup();
+    process.env.HOME = originalHome;
+    process.env.USERPROFILE = originalUserProfile;
 });
 function digestWorkerLogPath(workspace) {
     return path.join(workspace, DIGEST_WORKER_LOG_REL_PATH);
@@ -35,7 +46,7 @@ function writeInitState(workspace) {
     writeConversationDigestSettings(workspace, {
         enabled: true,
         initialized: true,
-        modelId: DigestModelId.DEFAULT,
+        modelId: DigestModelId.BASE,
         initializedAt: new Date().toISOString(),
     });
 }
@@ -74,7 +85,7 @@ describe('digest background helpers', () => {
     });
 });
 describe('launchDigestPendingWorker', () => {
-    test('writes not-initialized and does not spawn before digest init', () => {
+    test('writes not-initialized and does not spawn before digest init', async () => {
         const workspace = tempDirs.makeTempDir('digest-bg-not-init-');
         const result = launchDigestPendingWorker({
             workspaceRoot: workspace,
@@ -86,7 +97,7 @@ describe('launchDigestPendingWorker', () => {
         assert.equal(result.status.state, 'not-initialized');
         assert.equal(readDigestWorkerStatus(workspace)?.state, 'not-initialized');
     });
-    test('writes no-pending and does not spawn when initialized with no candidates', () => {
+    test('writes no-pending and does not spawn when initialized with no candidates', async () => {
         const workspace = tempDirs.makeTempDir('digest-bg-no-pending-');
         writeInitState(workspace);
         const result = launchDigestPendingWorker({
@@ -98,7 +109,7 @@ describe('launchDigestPendingWorker', () => {
         assert.equal(result.spawned, false);
         assert.equal(result.status.state, 'no-pending');
     });
-    test('writes locked when an existing running worker pid is live', () => {
+    test('writes locked when an existing running worker pid is live', async () => {
         const workspace = tempDirs.makeTempDir('digest-bg-locked-status-');
         writeDigestWorkerStatus(workspace, status());
         const result = launchDigestPendingWorker({
@@ -109,7 +120,7 @@ describe('launchDigestPendingWorker', () => {
         assert.equal(result.spawned, false);
         assert.equal(result.status.state, 'locked');
     });
-    test('marks stale running status before continuing to no-pending preflight', () => {
+    test('marks stale running status before continuing to no-pending preflight', async () => {
         const workspace = tempDirs.makeTempDir('digest-bg-stale-status-');
         writeInitState(workspace);
         writeDigestWorkerStatus(workspace, status({ pid: 999999999 }));
@@ -121,7 +132,7 @@ describe('launchDigestPendingWorker', () => {
         assert.equal(result.spawned, false);
         assert.equal(result.status.state, 'no-pending');
     });
-    test('tolerates corrupt stale lock files and continues preflight', () => {
+    test('tolerates corrupt stale lock files and continues preflight', async () => {
         const workspace = tempDirs.makeTempDir('digest-bg-stale-lock-');
         writeInitState(workspace);
         const lockDir = path.join(workspace, '.agent-kit', 'wiki', 'digest');
@@ -135,7 +146,7 @@ describe('launchDigestPendingWorker', () => {
         assert.equal(result.spawned, false);
         assert.equal(result.status.state, 'no-pending');
     });
-    test('writes failed status when pending work exists but entrypoint is unavailable', () => {
+    test('writes failed status when pending work exists but entrypoint is unavailable', async () => {
         const workspace = tempDirs.makeTempDir('digest-bg-spawn-failed-');
         writeInitState(workspace);
         writeConvFile(workspace);

package/dist/services/digest/digest-init.test.js

@@ -1,13 +1,24 @@
 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 { afterEach, describe, test, beforeEach } from 'node:test';
 import { createTempDirTracker } from '../../utils/temp-dir.test.js';
 import { initializeConversationDigestModel } from './processor.js';
 import { DigestModelId } from './types.js';
 const tempDirs = createTempDirTracker();
+let originalHome;
+let originalUserProfile;
+beforeEach(() => {
+    originalHome = process.env.HOME;
+    originalUserProfile = process.env.USERPROFILE;
+    const mockHome = tempDirs.makeTempDir('mock-home-');
+    process.env.HOME = mockHome;
+    process.env.USERPROFILE = mockHome;
+});
 afterEach(() => {
     tempDirs.cleanup();
+    process.env.HOME = originalHome;
+    process.env.USERPROFILE = originalUserProfile;
 });
 describe('initializeConversationDigestModel', () => {
     test('rejects unknown model and leaves settings absent', async () => {
@@ -24,7 +35,7 @@ describe('initializeConversationDigestModel', () => {
         const workspace = tempDirs.makeTempDir('digest-init-');
         const result = await initializeConversationDigestModel({
             workspaceRoot: workspace,
-            modelId: DigestModelId.DEFAULT,
+            modelId: DigestModelId.BASE,
             allowDownload: false,
         });
         assert.equal(result.initialized, false);

package/dist/services/digest/digest-pending.test.js

@@ -1,16 +1,27 @@
 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 { afterEach, describe, test, beforeEach } from 'node:test';
 import { createTempDirTracker } from '../../utils/temp-dir.test.js';
 import { defaultProvisionalDigestDir, readConversationDigestInput, writeConversationDigestSettings, writeProvisionalDigestFile, } from './files.js';
 import { DigestModelId } from './types.js';
 import { digestPendingConversations, summarizePendingConversations } from './processor.js';
 const tempDirs = createTempDirTracker();
+let originalHome;
+let originalUserProfile;
+beforeEach(() => {
+    originalHome = process.env.HOME;
+    originalUserProfile = process.env.USERPROFILE;
+    const mockHome = tempDirs.makeTempDir('mock-home-');
+    process.env.HOME = mockHome;
+    process.env.USERPROFILE = mockHome;
+});
 afterEach(() => {
     tempDirs.cleanup();
+    process.env.HOME = originalHome;
+    process.env.USERPROFILE = originalUserProfile;
 });
-function writeInitState(workspace, modelId = DigestModelId.DEFAULT) {
+function writeInitState(workspace, modelId = DigestModelId.BASE) {
     writeConversationDigestSettings(workspace, {
         enabled: true,
         initialized: true,

package/dist/services/digest/digest-processor.test.js

@@ -6,10 +6,32 @@ import { createTempDirTracker } from '../../utils/temp-dir.test.js';
 import { DEFAULT_DIGEST_MODEL_ID } from './constants.js';
 import { defaultProvisionalDigestDir, writeProvisionalDigestFile, readConversationDigestInput } from './files.js';
 import { digestConversationFile } from './processor.js';
+import { MemoryIndexer } from '../memory/indexer.js';
+import { MemoryStore } from '../memory/store.js';
+import { EmbeddingModelName } from '../memory/types.js';
 const tempDirs = createTempDirTracker();
 afterEach(() => {
     tempDirs.cleanup();
 });
+class StubEmbedder {
+    async embed(texts) {
+        return texts.map(() => new Float32Array(384).fill(0.05));
+    }
+    initialize() {
+        return Promise.resolve();
+    }
+}
+function makeConfig(workspace) {
+    return {
+        enabled: true,
+        wikiDir: path.join(workspace, '.agent-kit', 'wiki'),
+        topK: 5,
+        chunkSize: 1500,
+        overlapLines: 2,
+        embeddingModel: EmbeddingModelName.BASE,
+        vectorDimension: 384,
+    };
+}
 describe('digestConversationFile', () => {
     test('returns existing content-hash named provisional digest without loading model', async () => {
         const workspace = tempDirs.makeTempDir('digest-processor-');
@@ -29,4 +51,34 @@ describe('digestConversationFile', () => {
         assert.equal(result.contentHash, input.contentHash);
         assert.match(path.basename(result.markdown), /^[a-f0-9]{16}-conv\.md$/);
     });
+    test('indexes existing provisional digest with searchable store vector data', async () => {
+        const workspace = tempDirs.makeTempDir('digest-processor-index-');
+        const inputPath = path.join(workspace, '.agent-kit', 'wiki', 'archive', 'conversations', 'conv.md');
+        fs.mkdirSync(path.dirname(inputPath), { recursive: true });
+        fs.writeFileSync(inputPath, '**User:** remember vector indexing\n\n**Assistant:** done', 'utf8');
+        const input = readConversationDigestInput(workspace, inputPath);
+        const outDir = defaultProvisionalDigestDir(workspace);
+        const markdownPath = writeProvisionalDigestFile(outDir, input, '# Conversation Digest: conv\nindexed digest content\n');
+        const config = makeConfig(workspace);
+        const dbPath = path.join(config.wikiDir, 'index.db');
+        const store = new MemoryStore(dbPath, config);
+        const indexer = new MemoryIndexer(store, new StubEmbedder(), config);
+        try {
+            const result = await digestConversationFile({
+                workspaceRoot: workspace,
+                inputPath,
+                modelId: DEFAULT_DIGEST_MODEL_ID,
+                indexer,
+            });
+            assert.equal(result.indexed, true);
+            assert.equal(result.markdown, markdownPath);
+            const denseResults = store.searchDense(new Float32Array(384).fill(0.05), 5);
+            const indexedSource = path.relative(config.wikiDir, markdownPath);
+            const indexedChunks = store.getChunksByIds(denseResults.map((denseResult) => denseResult.id));
+            assert.ok(indexedChunks.some((chunk) => chunk.source === indexedSource), `Expected dense search to return a chunk for ${indexedSource}`);
+        }
+        finally {
+            store.close();
+        }
+    });
 });

package/dist/services/digest/files.js

@@ -3,7 +3,7 @@ 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 '../../core/config/index.js';
+import { loadGlobalSettings, writeGlobalSettings } from '../../core/config/index.js';
 export function defaultProvisionalDigestDir(workspaceRoot) {
     return path.join(workspaceRoot, PROVISIONAL_DIGEST_DIR);
 }
@@ -33,9 +33,9 @@ export function writeProvisionalDigestFile(outDir, input, markdown) {
     return markdownPath;
 }
 export function writeConversationDigestSettings(workspaceRoot, digest) {
-    const current = loadProjectSettings(workspaceRoot);
+    const current = loadGlobalSettings();
     const memory = current.memory ?? {};
-    writeProjectSettings(workspaceRoot, {
+    writeGlobalSettings({
         memory: {
             ...memory,
             enabled: memory.enabled ?? true,

package/dist/services/digest/model-registry.js

@@ -14,8 +14,8 @@ const DIGEST_MODEL_REGISTRY = {
         sourceUrl: 'https://huggingface.co/bartowski/Qwen2.5-0.5B-Instruct-GGUF',
         enabled: true,
     },
-    [DigestModelId.DEFAULT]: {
-        id: DigestModelId.DEFAULT,
+    [DigestModelId.BASE]: {
+        id: DigestModelId.BASE,
         ggufUri: 'hf:bartowski/Qwen2.5-1.5B-Instruct-GGUF/Qwen2.5-1.5B-Instruct-Q4_K_M.gguf',
         approxSizeBytes: 1_000_000_000,
         license: 'Apache-2.0',

package/dist/services/digest/processor.js

@@ -4,9 +4,10 @@ import { DEFAULT_DIGEST_TIMEOUT_MS, DEFAULT_DIGEST_MAX_INPUT_CHARS, DIGEST_LOCKF
 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 '../../core/config/index.js';
+import { loadGlobalSettings, resolveConversationDigestConfig, resolveMemoryConfig } from '../../core/config/index.js';
 import { MemoryStore } from '../memory/store.js';
 import { MemoryIndexer } from '../memory/indexer.js';
+import { Embedder } from '../memory/embedder.js';
 import { releaseLock, tryAcquireProcessLock } from '../../utils/files.js';
 function digestLockPath(workspaceRoot) {
     return path.join(workspaceRoot, DIGEST_LOCKFILE_REL_PATH);
@@ -40,19 +41,28 @@ function discoverPendingConversationFiles(workspaceRoot) {
         }
     });
 }
-async function indexProvisionalDigestFile(workspaceRoot, markdownPath) {
+async function indexProvisionalDigestFile(workspaceRoot, markdownPath, indexer) {
+    let store;
     try {
-        const settings = loadProjectSettings(workspaceRoot);
+        if (indexer) {
+            await indexer.indexFile(markdownPath);
+            return { indexed: true };
+        }
+        const settings = loadGlobalSettings();
         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);
+        if (config.enabled !== true)
+            return { indexed: false };
+        store = new MemoryStore(path.join(config.wikiDir, 'index.db'), config);
+        const embedder = new Embedder(config.embeddingModel);
+        await embedder.initialize();
+        await new MemoryIndexer(store, embedder, config).indexFile(markdownPath);
         return { indexed: true };
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { indexed: false, error: message };
+        return { indexed: false, error: err instanceof Error ? err.message : String(err) };
+    }
+    finally {
+        store?.close();
     }
 }
 export async function digestConversationFile(options) {
@@ -62,7 +72,7 @@ export async function digestConversationFile(options) {
     const input = readConversationDigestInput(options.workspaceRoot, options.inputPath);
     const existingPath = findExistingProvisionalDigest(outDir, input);
     if (existingPath) {
-        const indexResult = await indexProvisionalDigestFile(options.workspaceRoot, existingPath);
+        const indexResult = await indexProvisionalDigestFile(options.workspaceRoot, existingPath, options.indexer);
         return {
             markdown: existingPath,
             status: 'provisional',
@@ -79,7 +89,7 @@ export async function digestConversationFile(options) {
             timeoutMs: options.timeoutMs ?? DEFAULT_DIGEST_TIMEOUT_MS,
         });
         const markdownPath = writeProvisionalDigestFile(outDir, input, markdown);
-        const indexResult = await indexProvisionalDigestFile(options.workspaceRoot, markdownPath);
+        const indexResult = await indexProvisionalDigestFile(options.workspaceRoot, markdownPath, options.indexer);
         return {
             markdown: markdownPath,
             status: 'provisional',
@@ -93,7 +103,7 @@ export async function digestConversationFile(options) {
     }
 }
 export function summarizePendingConversations(workspaceRoot) {
-    const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
+    const digestConfig = resolveConversationDigestConfig(loadGlobalSettings());
     if (!digestConfig || digestConfig.enabled === false) {
         return { initialized: false, pending: 0, reason: 'not-initialized' };
     }
@@ -104,7 +114,7 @@ export function summarizePendingConversations(workspaceRoot) {
     return { initialized: true, pending: candidates.length };
 }
 export async function digestPendingConversations({ workspaceRoot, digestFn = digestConversationFile, onProgress, }) {
-    const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
+    const digestConfig = resolveConversationDigestConfig(loadGlobalSettings());
     if (!digestConfig || digestConfig.enabled === false) {
         return { ok: true, initialized: false, action: 'noop', reason: 'not-initialized' };
     }
@@ -112,11 +122,21 @@ export async function digestPendingConversations({ workspaceRoot, digestFn = dig
     if (!tryAcquireProcessLock(lockPath)) {
         return { ok: true, initialized: true, action: 'noop', reason: 'locked' };
     }
+    let closeIndexer;
     try {
         const candidates = discoverPendingConversationFiles(workspaceRoot);
         if (candidates.length === 0) {
             return { ok: true, initialized: true, action: 'noop', reason: 'no-pending' };
         }
+        let indexer;
+        const memoryConfig = resolveMemoryConfig(loadGlobalSettings(), workspaceRoot);
+        if (memoryConfig.enabled === true) {
+            const store = new MemoryStore(path.join(memoryConfig.wikiDir, 'index.db'), memoryConfig);
+            const embedder = new Embedder(memoryConfig.embeddingModel);
+            indexer = new MemoryIndexer(store, embedder, memoryConfig);
+            closeIndexer = () => store.close();
+            await embedder.initialize();
+        }
         let count = 0;
         let skipped = 0;
         let errors = 0;
@@ -126,6 +146,7 @@ export async function digestPendingConversations({ workspaceRoot, digestFn = dig
                     workspaceRoot,
                     inputPath: filePath,
                     modelId: digestConfig.modelId,
+                    indexer,
                 });
                 if (result.skipped) {
                     skipped++;
@@ -145,10 +166,19 @@ export async function digestPendingConversations({ workspaceRoot, digestFn = dig
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
+        console.warn('[digest] Pending conversation digest failed:', err);
         return { ok: false, initialized: true, action: 'error', error: message };
     }
     finally {
         releaseLock(lockPath);
+        if (closeIndexer) {
+            try {
+                closeIndexer();
+            }
+            catch (err) {
+                console.warn('[digest] Failed to close memory indexer store:', err);
+            }
+        }
     }
 }
 export async function initializeConversationDigestModel(input) {

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

@@ -32,39 +32,19 @@ function buildPrompt(input, maxInputChars) {
         {
             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 ... ```).',
+                'You are a technical summarizer.',
+                'Focus ONLY on the final decisions made at the end of the transcript.',
+                'Never invent or guess details.',
+                'Keep the output concise and strictly factual.',
             ].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">',
+                'Transcript:',
                 conversationExport,
-                '</conversation_export>',
+                '',
+                'Task: Write a brief summary paragraph of the final agreed-upon decisions in the transcript above. Then, provide a simple bulleted list of the specific technical changes or outcomes.',
             ].join('\n'),
         },
     ];
@@ -125,7 +105,16 @@ export async function createLlamaLocalDigestProvider(modelId) {
                     maxTokens: LLAMA_MAX_GENERATED_TOKENS,
                     temperature: LLAMA_TEMPERATURE,
                 }), options.timeoutMs, () => new LlamaLocalDigestProviderError(`Llama provider timed out after ${options.timeoutMs}ms`));
-                return sanitizeConversationDigestMarkdown(response);
+                const metadata = `## Digest: ${titleFromSource(input.sourcePath)}
+
+| Key | Value |
+| ------ | ----- |
+| **Source** | ${input.sourcePath} |
+| **Generated** | ${new Date().toISOString().split('T')[0]} |
+| **Model** | ${modelId} |
+`;
+                const sanitized = sanitizeConversationDigestMarkdown(response);
+                return `${metadata}\n\n${sanitized}`;
             }
             finally {
                 await context.dispose();

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

@@ -1,6 +1,7 @@
+import type { MemoryIndexer } from '../memory/indexer.js';
 export declare enum DigestModelId {
     TINY = "tiny",
-    DEFAULT = "default",
+    BASE = "base",
     LARGE = "large"
 }
 export interface ConversationDigestSettings {
@@ -45,6 +46,7 @@ export interface DigestFileOptions {
     outDir?: string;
     maxInputChars?: number;
     timeoutMs?: number;
+    indexer?: MemoryIndexer;
 }
 export interface ProvisionalDigestResult {
     markdown: string;

package/dist/services/digest/types.js

@@ -1,6 +1,6 @@
 export var DigestModelId;
 (function (DigestModelId) {
     DigestModelId["TINY"] = "tiny";
-    DigestModelId["DEFAULT"] = "default";
+    DigestModelId["BASE"] = "base";
     DigestModelId["LARGE"] = "large";
 })(DigestModelId || (DigestModelId = {}));

package/dist/services/memory/chunker.d.ts

@@ -1,2 +1,5 @@
-import type { MemoryChunk, MemoryConfig } from './types.js';
-export declare function chunkMarkdown(text: string, source: string, config: Pick<MemoryConfig, 'chunkSize' | 'overlapLines'>): MemoryChunk[];
+import type { MemoryChunk, MemoryConfig, SourceType } from './types.js';
+export declare function chunkMarkdown(text: string, source: string, config: Pick<MemoryConfig, 'chunkSize' | 'overlapLines'>, meta: {
+    sourceType: SourceType;
+    fileMtimeAt: number;
+}): MemoryChunk[];

package/dist/services/memory/chunker.js

@@ -85,7 +85,7 @@ function splitSection(text, maxLen) {
         return byPara;
     return byPara.flatMap((p) => (p.length <= maxLen ? [p] : splitAtLine(p, maxLen)));
 }
-export function chunkMarkdown(text, source, config) {
+export function chunkMarkdown(text, source, config, meta) {
     if (!text || !text.trim())
         return [];
     const { chunkSize, overlapLines } = config;
@@ -129,11 +129,13 @@ export function chunkMarkdown(text, source, config) {
             chunks.push({
                 id: computeChunkId(content),
                 source,
+                sourceType: meta.sourceType,
                 heading: section.heading,
                 headingLevel: section.headingLevel,
                 content,
                 lineStart: firstLine,
                 lineEnd: lastLine,
+                fileMtimeAt: meta.fileMtimeAt,
             });
             // Update overlap for next iteration (last N lines of this chunk)
             if (pi === parts.length - 1) {

package/dist/services/memory/chunker.test.js

@@ -3,16 +3,17 @@ import { describe, test } from 'node:test';
 import { chunkMarkdown } from './chunker.js';
 const CFG = { chunkSize: 200, overlapLines: 2 };
 const SRC = 'test.md';
+const META = { sourceType: 'wiki', fileMtimeAt: 123 };
 describe('chunkMarkdown', () => {
     test('returns [] for empty string', () => {
-        assert.deepEqual(chunkMarkdown('', SRC, CFG), []);
+        assert.deepEqual(chunkMarkdown('', SRC, CFG, META), []);
     });
     test('returns [] for whitespace-only string', () => {
-        assert.deepEqual(chunkMarkdown('   \n\n  ', SRC, CFG), []);
+        assert.deepEqual(chunkMarkdown('   \n\n  ', SRC, CFG, META), []);
     });
     test('single heading + short body produces one chunk with correct metadata', () => {
         const text = '# My Heading\nThis is the body text.';
-        const chunks = chunkMarkdown(text, SRC, CFG);
+        const chunks = chunkMarkdown(text, SRC, CFG, META);
         assert.equal(chunks.length, 1);
         const [c] = chunks;
         assert.equal(c.heading, 'My Heading');
@@ -23,20 +24,20 @@ describe('chunkMarkdown', () => {
     });
     test('chunk id is deterministic — same content produces same id', () => {
         const text = '# Section\nHello world.';
-        const [a] = chunkMarkdown(text, SRC, CFG);
-        const [b] = chunkMarkdown(text, 'other-source.md', CFG);
+        const [a] = chunkMarkdown(text, SRC, CFG, META);
+        const [b] = chunkMarkdown(text, 'other-source.md', CFG, META);
         assert.equal(a.id, b.id, 'id must depend on content only, not source');
     });
     test('chunk id changes when content changes', () => {
-        const [a] = chunkMarkdown('# H\nVersion A', SRC, CFG);
-        const [b] = chunkMarkdown('# H\nVersion B', SRC, CFG);
+        const [a] = chunkMarkdown('# H\nVersion A', SRC, CFG, META);
+        const [b] = chunkMarkdown('# H\nVersion B', SRC, CFG, META);
         assert.notEqual(a.id, b.id);
     });
     test('body exceeding chunkSize produces multiple chunks', () => {
         const word = 'a'.repeat(50);
         const body = Array.from({ length: 10 }, (_, i) => `Paragraph ${i}: ${word}`).join('\n\n');
         const text = `# Big Section\n${body}`;
-        const chunks = chunkMarkdown(text, SRC, { chunkSize: 100, overlapLines: 0 });
+        const chunks = chunkMarkdown(text, SRC, { chunkSize: 100, overlapLines: 0 }, META);
         assert.ok(chunks.length > 1, `Expected >1 chunks, got ${chunks.length}`);
         for (const c of chunks) {
             assert.equal(c.heading, 'Big Section');
@@ -51,7 +52,7 @@ describe('chunkMarkdown', () => {
             '### Deep Level',
             'Deep content.',
         ].join('\n');
-        const chunks = chunkMarkdown(text, SRC, CFG);
+        const chunks = chunkMarkdown(text, SRC, CFG, META);
         const levels = chunks.map((c) => c.headingLevel);
         assert.ok(levels.includes(1), 'Expected headingLevel 1');
         assert.ok(levels.includes(2), 'Expected headingLevel 2');
@@ -59,14 +60,23 @@ describe('chunkMarkdown', () => {
     });
     test('HTML comment is stripped from chunk content', () => {
         const text = '# Section\nVisible text <!-- hidden comment --> more visible text.';
-        const [chunk] = chunkMarkdown(text, SRC, CFG);
+        const [chunk] = chunkMarkdown(text, SRC, CFG, META);
         assert.ok(!chunk.content.includes('hidden comment'), 'HTML comment must be stripped');
         assert.ok(chunk.content.includes('Visible text'), 'Visible text must remain');
     });
     test('multiline HTML comment is stripped', () => {
         const text = '# Section\nBefore.\n<!-- multi\nline\ncomment -->\nAfter.';
-        const [chunk] = chunkMarkdown(text, SRC, CFG);
+        const [chunk] = chunkMarkdown(text, SRC, CFG, META);
         assert.ok(!chunk.content.includes('multi'), 'Multiline comment must be stripped');
         assert.ok(chunk.content.includes('Before.'), 'Text before comment must remain');
     });
+    test('propagates source type and file mtime metadata to every chunk', () => {
+        const text = '# One\nBody one.\n\n# Two\nBody two.';
+        const chunks = chunkMarkdown(text, SRC, CFG, { sourceType: 'digest', fileMtimeAt: 456 });
+        assert.ok(chunks.length > 0);
+        for (const chunk of chunks) {
+            assert.equal(chunk.sourceType, 'digest');
+            assert.equal(chunk.fileMtimeAt, 456);
+        }
+    });
 });

package/dist/services/memory/constants.js

@@ -5,7 +5,7 @@ export const DEFAULT_MEMORY_CONFIG = {
     topK: 5,
     chunkSize: 1500,
     overlapLines: 2,
-    embeddingModel: EmbeddingModelName.SMALL,
+    embeddingModel: EmbeddingModelName.BASE,
     vectorDimension: 384,
 };
 export const LOCK_RETRY_MS = 50;