@hanhnd/agent-kit 1.0.32 → 1.0.33

package/dist/{memory → services}/digest/constants.d.ts

@@ -1,4 +1,5 @@
-export declare const DEFAULT_DIGEST_MODEL_ID = "qwen2.5-1.5b-instruct-q4";
+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_TIMEOUT_MS = 120000;
 export declare const DIGEST_TIMEOUT_GRACE_MS = 5000;
@@ -9,6 +10,8 @@ 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 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_MAX_GENERATED_TOKENS = 512;
 export declare const LLAMA_TEMPERATURE = 0.1;

package/dist/{memory → services}/digest/constants.js

@@ -1,5 +1,6 @@
 import * as path from 'node:path';
-export const DEFAULT_DIGEST_MODEL_ID = 'qwen2.5-1.5b-instruct-q4';
+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_TIMEOUT_MS = 120_000;
 export const DIGEST_TIMEOUT_GRACE_MS = 5_000;
@@ -9,7 +10,10 @@ 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');
+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_MAX_GENERATED_TOKENS = 512;
 export const LLAMA_TEMPERATURE = 0.1;

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

@@ -0,0 +1,206 @@
+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 '../../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();
+afterEach(() => {
+    tempDirs.cleanup();
+});
+function digestWorkerLogPath(workspace) {
+    return path.join(workspace, DIGEST_WORKER_LOG_REL_PATH);
+}
+function digestWorkerStatusPath(workspace) {
+    return path.join(workspace, DIGEST_WORKER_STATUS_REL_PATH);
+}
+function readDigestWorkerStatus(workspace) {
+    try {
+        const p = digestWorkerStatusPath(workspace);
+        return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeDigestWorkerStatus(workspace, status) {
+    const p = digestWorkerStatusPath(workspace);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(status), 'utf8');
+}
+function writeInitState(workspace) {
+    writeConversationDigestSettings(workspace, {
+        enabled: true,
+        initialized: true,
+        modelId: DigestModelId.DEFAULT,
+        initializedAt: new Date().toISOString(),
+    });
+}
+function writeConvFile(workspace) {
+    const rawDir = path.join(workspace, '.agent-kit', 'wiki', 'raw');
+    fs.mkdirSync(rawDir, { recursive: true });
+    fs.writeFileSync(path.join(rawDir, 'conv_2026-01-01T00-00-00-001Z.md'), '**User:** hello\n', 'utf8');
+}
+function status(overrides = {}) {
+    const now = new Date().toISOString();
+    return {
+        state: 'running',
+        pid: process.pid,
+        startedAt: now,
+        updatedAt: now,
+        pendingAtStart: 1,
+        processed: 0,
+        skipped: 0,
+        errors: 0,
+        ...overrides,
+    };
+}
+describe('digest background helpers', () => {
+    test('uses .agent-kit/wiki/digest paths for worker files', () => {
+        const workspace = tempDirs.makeTempDir('digest-bg-paths-');
+        assert.equal(digestWorkerStatusPath(workspace), path.join(workspace, '.agent-kit', 'wiki', 'digest', 'digest-worker.status.json'));
+        assert.equal(digestWorkerLogPath(workspace), path.join(workspace, '.agent-kit', 'wiki', 'digest', 'digest-worker.log'));
+    });
+    test('writes valid status atomically and tolerates invalid status reads', () => {
+        const workspace = tempDirs.makeTempDir('digest-bg-status-');
+        const written = status({ state: 'complete', pid: null, processed: 1 });
+        writeDigestWorkerStatus(workspace, written);
+        assert.deepEqual(readDigestWorkerStatus(workspace), written);
+        fs.writeFileSync(digestWorkerStatusPath(workspace), '{bad json', 'utf8');
+        assert.equal(readDigestWorkerStatus(workspace), undefined);
+    });
+});
+describe('launchDigestPendingWorker', () => {
+    test('writes not-initialized and does not spawn before digest init', () => {
+        const workspace = tempDirs.makeTempDir('digest-bg-not-init-');
+        const result = launchDigestPendingWorker({
+            workspaceRoot: workspace,
+            args: ['--background'],
+            entrypoint: 'cli.js',
+        });
+        assert.equal(result.ok, true);
+        assert.equal(result.spawned, false);
+        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', () => {
+        const workspace = tempDirs.makeTempDir('digest-bg-no-pending-');
+        writeInitState(workspace);
+        const result = launchDigestPendingWorker({
+            workspaceRoot: workspace,
+            args: ['--background'],
+            entrypoint: 'cli.js',
+        });
+        assert.equal(result.ok, true);
+        assert.equal(result.spawned, false);
+        assert.equal(result.status.state, 'no-pending');
+    });
+    test('writes locked when an existing running worker pid is live', () => {
+        const workspace = tempDirs.makeTempDir('digest-bg-locked-status-');
+        writeDigestWorkerStatus(workspace, status());
+        const result = launchDigestPendingWorker({
+            workspaceRoot: workspace,
+            args: ['--background'],
+            entrypoint: 'cli.js',
+        });
+        assert.equal(result.spawned, false);
+        assert.equal(result.status.state, 'locked');
+    });
+    test('marks stale running status before continuing to no-pending preflight', () => {
+        const workspace = tempDirs.makeTempDir('digest-bg-stale-status-');
+        writeInitState(workspace);
+        writeDigestWorkerStatus(workspace, status({ pid: 999999999 }));
+        const result = launchDigestPendingWorker({
+            workspaceRoot: workspace,
+            args: ['--background'],
+            entrypoint: 'cli.js',
+        });
+        assert.equal(result.spawned, false);
+        assert.equal(result.status.state, 'no-pending');
+    });
+    test('tolerates corrupt stale lock files and continues preflight', () => {
+        const workspace = tempDirs.makeTempDir('digest-bg-stale-lock-');
+        writeInitState(workspace);
+        const lockDir = path.join(workspace, '.agent-kit', 'wiki', 'digest');
+        fs.mkdirSync(lockDir, { recursive: true });
+        fs.writeFileSync(path.join(lockDir, 'digest-worker.lock'), 'not-json', 'utf8');
+        const result = launchDigestPendingWorker({
+            workspaceRoot: workspace,
+            args: ['--background'],
+            entrypoint: 'cli.js',
+        });
+        assert.equal(result.spawned, false);
+        assert.equal(result.status.state, 'no-pending');
+    });
+    test('writes failed status when pending work exists but entrypoint is unavailable', () => {
+        const workspace = tempDirs.makeTempDir('digest-bg-spawn-failed-');
+        writeInitState(workspace);
+        writeConvFile(workspace);
+        const result = launchDigestPendingWorker({
+            workspaceRoot: workspace,
+            args: ['--background'],
+            entrypoint: undefined,
+        });
+        assert.equal(result.ok, false);
+        assert.equal(result.spawned, false);
+        assert.equal(result.status.state, 'failed');
+        assert.equal(result.status.pendingAtStart, 1);
+    });
+});
+describe('runDigestPendingWorker', () => {
+    test('writes final no-pending status for initialized workspace without candidates', async () => {
+        const workspace = tempDirs.makeTempDir('digest-bg-worker-no-pending-');
+        writeInitState(workspace);
+        const result = await runDigestPendingWorker({ workspaceRoot: workspace, pendingAtStart: 0 });
+        assert.equal(result.state, 'no-pending');
+        assert.equal(readDigestWorkerStatus(workspace)?.state, 'no-pending');
+        assert.match(fs.readFileSync(digestWorkerLogPath(workspace), 'utf8'), /worker finished/);
+    });
+    test('writes failed final status for run-level processor failure', async () => {
+        const workspace = tempDirs.makeTempDir('digest-bg-worker-failed-');
+        writeInitState(workspace);
+        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 runDigestPendingWorker({ workspaceRoot: workspace, pendingAtStart: 1 });
+        assert.equal(result.state, 'failed');
+        assert.equal(result.errors, 1);
+        assert.ok(result.lastError);
+    });
+    test('updates status file in real-time as conversations are digested', async () => {
+        const workspace = tempDirs.makeTempDir('digest-bg-worker-realtime-');
+        writeInitState(workspace);
+        const rawDir = path.join(workspace, '.agent-kit', 'wiki', 'raw');
+        fs.mkdirSync(rawDir, { recursive: true });
+        fs.writeFileSync(path.join(rawDir, 'conv_1.md'), '**User:** one\n', 'utf8');
+        fs.writeFileSync(path.join(rawDir, 'conv_2.md'), '**User:** two\n', 'utf8');
+        const statusesSeen = [];
+        const mockDigestFn = async () => {
+            statusesSeen.push(readDigestWorkerStatus(workspace));
+            return {
+                markdown: 'out.md',
+                status: 'provisional',
+                contentHash: 'hash',
+                skipped: false,
+                indexed: false,
+            };
+        };
+        const result = await runDigestPendingWorker({
+            workspaceRoot: workspace,
+            pendingAtStart: 2,
+            digestFn: mockDigestFn,
+        });
+        assert.equal(statusesSeen.length, 2);
+        assert.ok(statusesSeen[0]);
+        assert.equal(statusesSeen[0].state, 'running');
+        assert.equal(statusesSeen[0].processed, 0);
+        assert.ok(statusesSeen[1]);
+        assert.equal(statusesSeen[1].state, 'running');
+        assert.equal(statusesSeen[1].processed, 1);
+        assert.equal(result.state, 'complete');
+        assert.equal(result.processed, 2);
+    });
+});

package/dist/{tools/__tests__ → services/digest}/digest-init.test.js

@@ -2,8 +2,9 @@ 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 { initializeConversationDigestModel } from '../../memory/digest/processor.js';
+import { createTempDirTracker } from '../../utils/temp-dir.test.js';
+import { initializeConversationDigestModel } from './processor.js';
+import { DigestModelId } from './types.js';
 const tempDirs = createTempDirTracker();
 afterEach(() => {
     tempDirs.cleanup();
@@ -23,7 +24,7 @@ describe('initializeConversationDigestModel', () => {
         const workspace = tempDirs.makeTempDir('digest-init-');
         const result = await initializeConversationDigestModel({
             workspaceRoot: workspace,
-            modelId: 'qwen2.5-1.5b-instruct-q4',
+            modelId: DigestModelId.DEFAULT,
             allowDownload: false,
         });
         assert.equal(result.initialized, false);

package/dist/{memory/__tests__ → services/digest}/digest-llama-local.test.js

@@ -1,24 +1,12 @@
 import * as assert from 'node:assert/strict';
 import { describe, test } from 'node:test';
-import { createLlamaLocalDigestProvider, sanitizeConversationDigestMarkdown, trimConversationExport, } from '../digest/providers/llama-local.js';
+import { createLlamaLocalDigestProvider } 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);

package/dist/{memory/__tests__ → services/digest}/digest-pending.test.js

@@ -2,14 +2,15 @@ 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';
+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();
 afterEach(() => {
     tempDirs.cleanup();
 });
-function writeInitState(workspace, modelId = 'qwen2.5-1.5b-instruct-q4') {
+function writeInitState(workspace, modelId = DigestModelId.DEFAULT) {
     writeConversationDigestSettings(workspace, {
         enabled: true,
         initialized: true,
@@ -47,7 +48,7 @@ describe('digestPendingConversations', () => {
     test('C14: init state, live lockfile → noop locked', async () => {
         const workspace = tempDirs.makeTempDir('pending-c14-');
         writeInitState(workspace);
-        const lockDir = path.join(workspace, '.agent-kit');
+        const lockDir = path.join(workspace, '.agent-kit', 'wiki', 'digest');
         fs.mkdirSync(lockDir, { recursive: true });
         fs.writeFileSync(path.join(lockDir, 'digest-worker.lock'), JSON.stringify({ pid: process.pid }));
         const result = await digestPendingConversations({ workspaceRoot: workspace });
@@ -65,7 +66,7 @@ describe('digestPendingConversations', () => {
         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);
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'wiki', 'digest', 'digest-worker.lock')), false);
     });
     test('C19: wiki/raw dir does not exist → noop no-pending', async () => {
         const workspace = tempDirs.makeTempDir('pending-c19-');
@@ -89,7 +90,7 @@ describe('digestPendingConversations', () => {
             assert.equal(result.count, 1);
             assert.equal(result.errors, 0);
         }
-        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'digest-worker.lock')), false);
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'wiki', 'digest', 'digest-worker.lock')), false);
     });
     test('C17: digestFn throws for one file → errors:1, lock released', async () => {
         const workspace = tempDirs.makeTempDir('pending-c17-');
@@ -108,19 +109,19 @@ describe('digestPendingConversations', () => {
             assert.equal(result.errors, 1);
             assert.equal(result.count, 0);
         }
-        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'digest-worker.lock')), false);
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'wiki', 'digest', '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');
+        const lockDir = path.join(workspace, '.agent-kit', 'wiki', 'digest');
         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);
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'wiki', 'digest', '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-');
@@ -159,6 +160,33 @@ describe('digestPendingConversations', () => {
         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);
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'wiki', 'digest', 'digest-worker.lock')), false);
+    });
+});
+describe('summarizePendingConversations', () => {
+    test('returns not-initialized without raw discovery side effects', () => {
+        const workspace = tempDirs.makeTempDir('pending-summary-init-');
+        const result = summarizePendingConversations(workspace);
+        assert.equal(result.initialized, false);
+        assert.equal(result.pending, 0);
+        assert.equal(result.reason, 'not-initialized');
+    });
+    test('returns no-pending when initialized workspace has no raw conversations', () => {
+        const workspace = tempDirs.makeTempDir('pending-summary-empty-');
+        writeInitState(workspace);
+        const result = summarizePendingConversations(workspace);
+        assert.equal(result.initialized, true);
+        assert.equal(result.pending, 0);
+        assert.equal(result.reason, 'no-pending');
+    });
+    test('counts only conversations without existing provisional digests', () => {
+        const workspace = tempDirs.makeTempDir('pending-summary-count-');
+        writeInitState(workspace);
+        const first = writeConvFile(workspace, 'conv_2026-01-01T00-00-00-001Z.md', '**User:** a\n');
+        writeConvFile(workspace, 'conv_2026-01-01T00-00-00-002Z.md', '**User:** b\n');
+        writeProvisionalDigestFile(defaultProvisionalDigestDir(workspace), readConversationDigestInput(workspace, first), '# Existing\n');
+        const result = summarizePendingConversations(workspace);
+        assert.equal(result.initialized, true);
+        assert.equal(result.pending, 1);
     });
 });

package/dist/{memory/__tests__ → services/digest}/digest-processor.test.js

@@ -2,10 +2,10 @@ 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';
+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';
 const tempDirs = createTempDirTracker();
 afterEach(() => {
     tempDirs.cleanup();
@@ -18,9 +18,7 @@ describe('digestConversationFile', () => {
         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 markdownPath = writeProvisionalDigestFile(outDir, input, '# Conversation Digest: conv\n');
         const result = await digestConversationFile({
             workspaceRoot: workspace,
             inputPath,

package/dist/{memory → services}/digest/files.d.ts

@@ -1,7 +1,6 @@
 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 → 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 '../../tools/config.js';
+import { loadProjectSettings, writeProjectSettings } from '../../core/config/index.js';
 export function defaultProvisionalDigestDir(workspaceRoot) {
     return path.join(workspaceRoot, PROVISIONAL_DIGEST_DIR);
 }
@@ -16,7 +16,7 @@ export function readConversationDigestInput(workspaceRoot, inputPath) {
         contentHash: sha256Hex(content),
     };
 }
-export function provisionalDigestPath(outDir, input) {
+function provisionalDigestPath(outDir, input) {
     const safeName = path
         .basename(input.sourcePath)
         .replace(/\.[^.]+$/, '')

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

@@ -0,0 +1,2 @@
+import { type DigestModelSpec } from './types.js';
+export declare function getDigestModelSpec(modelId: string): DigestModelSpec;

package/dist/{memory → services}/digest/model-registry.js

@@ -1,28 +1,29 @@
-export class DigestModelRegistryError extends Error {
+import { DigestModelId } from './types.js';
+class DigestModelRegistryError extends Error {
     constructor(message) {
         super(message);
         this.name = 'DigestModelRegistryError';
     }
 }
-export const DIGEST_MODEL_REGISTRY = {
-    'qwen2.5-0.5b-instruct-q4': {
-        id: 'qwen2.5-0.5b-instruct-q4',
+const DIGEST_MODEL_REGISTRY = {
+    [DigestModelId.TINY]: {
+        id: DigestModelId.TINY,
         ggufUri: 'hf:bartowski/Qwen2.5-0.5B-Instruct-GGUF/Qwen2.5-0.5B-Instruct-Q4_K_M.gguf',
         approxSizeBytes: 400_000_000,
         license: 'Apache-2.0',
         sourceUrl: 'https://huggingface.co/bartowski/Qwen2.5-0.5B-Instruct-GGUF',
         enabled: true,
     },
-    'qwen2.5-1.5b-instruct-q4': {
-        id: 'qwen2.5-1.5b-instruct-q4',
+    [DigestModelId.DEFAULT]: {
+        id: DigestModelId.DEFAULT,
         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',
         sourceUrl: 'https://huggingface.co/bartowski/Qwen2.5-1.5B-Instruct-GGUF',
         enabled: true,
     },
-    'qwen2.5-3b-instruct-q4': {
-        id: 'qwen2.5-3b-instruct-q4',
+    [DigestModelId.LARGE]: {
+        id: DigestModelId.LARGE,
         ggufUri: 'hf:bartowski/Qwen2.5-3B-Instruct-GGUF/Qwen2.5-3B-Instruct-Q4_K_M.gguf',
         approxSizeBytes: 1_900_000_000,
         license: 'Apache-2.0',

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

@@ -0,0 +1,13 @@
+import type { DigestFileOptions, DigestPendingCandidateSummary, DigestPendingResult, ProvisionalDigestResult, ConversationDigestInitResult, InitializeConversationDigestInput } from './types.js';
+export declare function digestConversationFile(options: DigestFileOptions): Promise<ProvisionalDigestResult>;
+export declare function summarizePendingConversations(workspaceRoot: string): DigestPendingCandidateSummary;
+export declare function digestPendingConversations({ workspaceRoot, digestFn, onProgress, }: {
+    workspaceRoot: string;
+    digestFn?: (opts: DigestFileOptions) => Promise<ProvisionalDigestResult>;
+    onProgress?: (progress: {
+        processed: number;
+        skipped: number;
+        errors: number;
+    }) => void | Promise<void>;
+}): Promise<DigestPendingResult>;
+export declare function initializeConversationDigestModel(input: InitializeConversationDigestInput): Promise<ConversationDigestInitResult>;

package/dist/{memory → services}/digest/processor.js

@@ -4,13 +4,42 @@ 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 '../../tools/config.js';
-import { MemoryStore } from '../store.js';
-import { MemoryIndexer } from '../indexer.js';
+import { loadProjectSettings, resolveConversationDigestConfig, resolveMemoryConfig } from '../../core/config/index.js';
+import { MemoryStore } from '../memory/store.js';
+import { MemoryIndexer } from '../memory/indexer.js';
 import { releaseLock, tryAcquireProcessLock } from '../../utils/files.js';
 function digestLockPath(workspaceRoot) {
     return path.join(workspaceRoot, DIGEST_LOCKFILE_REL_PATH);
 }
+function discoverPendingConversationFiles(workspaceRoot) {
+    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);
+    return files.filter((f) => {
+        try {
+            const input = readConversationDigestInput(workspaceRoot, f);
+            return !findExistingProvisionalDigest(outDir, input);
+        }
+        catch {
+            return false;
+        }
+    });
+}
 async function indexProvisionalDigestFile(workspaceRoot, markdownPath) {
     try {
         const settings = loadProjectSettings(workspaceRoot);
@@ -63,7 +92,18 @@ export async function digestConversationFile(options) {
         await provider.dispose?.();
     }
 }
-export async function digestPendingConversations({ workspaceRoot, digestFn = digestConversationFile, }) {
+export function summarizePendingConversations(workspaceRoot) {
+    const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
+    if (!digestConfig || digestConfig.enabled === false) {
+        return { initialized: false, pending: 0, reason: 'not-initialized' };
+    }
+    const candidates = discoverPendingConversationFiles(workspaceRoot);
+    if (candidates.length === 0) {
+        return { initialized: true, pending: 0, reason: 'no-pending' };
+    }
+    return { initialized: true, pending: candidates.length };
+}
+export async function digestPendingConversations({ workspaceRoot, digestFn = digestConversationFile, onProgress, }) {
     const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
     if (!digestConfig || digestConfig.enabled === false) {
         return { ok: true, initialized: false, action: 'noop', reason: 'not-initialized' };
@@ -73,33 +113,7 @@ export async function digestPendingConversations({ workspaceRoot, digestFn = dig
         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;
-            }
-        });
+        const candidates = discoverPendingConversationFiles(workspaceRoot);
         if (candidates.length === 0) {
             return { ok: true, initialized: true, action: 'noop', reason: 'no-pending' };
         }
@@ -123,6 +137,9 @@ export async function digestPendingConversations({ workspaceRoot, digestFn = dig
             catch {
                 errors++;
             }
+            if (onProgress) {
+                await onProgress({ processed: count, skipped, errors });
+            }
         }
         return { ok: true, initialized: true, action: 'digested', count, skipped, errors };
     }

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

@@ -0,0 +1,2 @@
+import type { ConversationDigestProvider } from '../types.js';
+export declare function createLlamaLocalDigestProvider(modelId: string): Promise<ConversationDigestProvider>;