@hanhnd/agent-kit 1.0.31 → 1.0.33

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

@@ -0,0 +1,192 @@
+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 { 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 = DigestModelId.DEFAULT) {
+    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', '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 });
+        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', 'wiki', 'digest', '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', 'wiki', 'digest', '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', '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', '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', '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-');
+        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', '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/services/digest/digest-processor.test.d.ts

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

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

@@ -0,0 +1,32 @@
+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 { 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();
+});
+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 = writeProvisionalDigestFile(outDir, input, '# Conversation Digest: conv\n');
+        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/services/digest/files.d.ts

@@ -0,0 +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 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/services/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 '../../core/config/index.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),
+    };
+}
+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/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/services/digest/model-registry.js

@@ -0,0 +1,49 @@
+import { DigestModelId } from './types.js';
+class DigestModelRegistryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DigestModelRegistryError';
+    }
+}
+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,
+    },
+    [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,
+    },
+    [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',
+        sourceUrl: 'https://huggingface.co/bartowski/Qwen2.5-3B-Instruct-GGUF',
+        enabled: true,
+    },
+};
+export function getDigestModelSpec(modelId) {
+    if (!modelId.trim()) {
+        throw new DigestModelRegistryError('Digest model id is required');
+    }
+    const spec = DIGEST_MODEL_REGISTRY[modelId];
+    if (!spec) {
+        throw new DigestModelRegistryError(`Unknown digest model: ${modelId}`);
+    }
+    if (spec.enabled !== true) {
+        throw new DigestModelRegistryError(`Digest model is disabled: ${modelId}`);
+    }
+    if (!spec.ggufUri || !spec.sourceUrl) {
+        throw new DigestModelRegistryError(`Digest model spec is incomplete: ${modelId}`);
+    }
+    return spec;
+}

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/services/digest/processor.js

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

package/dist/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>;