@hanhnd/agent-kit 1.0.31 → 1.0.33

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

@@ -0,0 +1,11 @@
+import type { DigestPendingLauncherResult, DigestWorkerStatus, DigestFileOptions, ProvisionalDigestResult } from './types.js';
+export declare function runDigestPendingWorker(input: {
+    workspaceRoot: string;
+    pendingAtStart?: number;
+    digestFn?: (opts: DigestFileOptions) => Promise<ProvisionalDigestResult>;
+}): Promise<DigestWorkerStatus>;
+export declare function launchDigestPendingWorker(input: {
+    workspaceRoot: string;
+    args: string[];
+    entrypoint: string | undefined;
+}): DigestPendingLauncherResult;

package/dist/services/digest/background.js

@@ -0,0 +1,258 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { spawn } from 'node:child_process';
+import { DIGEST_LOCKFILE_REL_PATH, DIGEST_WORKER_FLAG, DIGEST_WORKER_LOG_REL_PATH, DIGEST_WORKER_STATUS_REL_PATH, } from './constants.js';
+import { digestPendingConversations, summarizePendingConversations } from './processor.js';
+import { atomicWriteJsonFile } from '../../utils/files.js';
+import { isRecord } from '../../utils/json.js';
+function digestWorkerStatusPath(workspaceRoot) {
+    return path.join(workspaceRoot, DIGEST_WORKER_STATUS_REL_PATH);
+}
+function digestWorkerLogPath(workspaceRoot) {
+    return path.join(workspaceRoot, DIGEST_WORKER_LOG_REL_PATH);
+}
+function digestWorkerLockPath(workspaceRoot) {
+    return path.join(workspaceRoot, DIGEST_LOCKFILE_REL_PATH);
+}
+function isoNow() {
+    return new Date().toISOString();
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function emptyStatus(state, pendingAtStart, startedAt = isoNow()) {
+    return {
+        state,
+        pid: null,
+        startedAt,
+        updatedAt: startedAt,
+        pendingAtStart,
+        processed: 0,
+        skipped: 0,
+        errors: 0,
+    };
+}
+const WORKER_STATES = new Set([
+    'running',
+    'complete',
+    'failed',
+    'not-initialized',
+    'no-pending',
+    'locked',
+    'stale',
+]);
+function isDigestWorkerStatus(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.state === 'string' &&
+        WORKER_STATES.has(value.state) &&
+        (typeof value.pid === 'number' || value.pid === null) &&
+        typeof value.startedAt === 'string' &&
+        typeof value.updatedAt === 'string' &&
+        typeof value.pendingAtStart === 'number' &&
+        typeof value.processed === 'number' &&
+        typeof value.skipped === 'number' &&
+        typeof value.errors === 'number' &&
+        (value.lastError === undefined || typeof value.lastError === 'string'));
+}
+function readDigestWorkerStatus(workspaceRoot) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(digestWorkerStatusPath(workspaceRoot), 'utf8'));
+        return isDigestWorkerStatus(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeDigestWorkerStatus(workspaceRoot, status) {
+    atomicWriteJsonFile(digestWorkerStatusPath(workspaceRoot), status);
+}
+function appendDigestWorkerLog(workspaceRoot, message) {
+    try {
+        const logPath = digestWorkerLogPath(workspaceRoot);
+        fs.mkdirSync(path.dirname(logPath), { recursive: true });
+        fs.appendFileSync(logPath, `[${isoNow()}] ${message}\n`, 'utf8');
+    }
+    catch {
+        // Diagnostics must never block hook startup or worker completion.
+    }
+}
+function isLivePid(pid) {
+    if (pid === null || !Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code !== 'ESRCH';
+    }
+}
+function readLockPid(workspaceRoot) {
+    const lockPath = digestWorkerLockPath(workspaceRoot);
+    if (!fs.existsSync(lockPath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+        return isRecord(parsed) && typeof parsed.pid === 'number' ? parsed.pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function statusFromPendingResult(result, startedAt, pendingAtStart) {
+    const updatedAt = isoNow();
+    if (!result.ok) {
+        return {
+            ...emptyStatus('failed', pendingAtStart, startedAt),
+            updatedAt,
+            errors: 1,
+            lastError: result.error,
+        };
+    }
+    if (result.action === 'digested') {
+        return {
+            state: 'complete',
+            pid: null,
+            startedAt,
+            updatedAt,
+            pendingAtStart,
+            processed: result.count,
+            skipped: result.skipped,
+            errors: result.errors,
+        };
+    }
+    return {
+        ...emptyStatus(result.reason, pendingAtStart, startedAt),
+        updatedAt,
+    };
+}
+export async function runDigestPendingWorker(input) {
+    const startedAt = isoNow();
+    let pendingAtStart = input.pendingAtStart ?? 0;
+    try {
+        const summary = summarizePendingConversations(input.workspaceRoot);
+        if (input.pendingAtStart === undefined) {
+            pendingAtStart = summary.initialized ? summary.pending : 0;
+        }
+        const runningStatus = {
+            ...emptyStatus('running', pendingAtStart, startedAt),
+            pid: process.pid,
+        };
+        writeDigestWorkerStatus(input.workspaceRoot, runningStatus);
+        appendDigestWorkerLog(input.workspaceRoot, `worker started pid=${process.pid} pending=${pendingAtStart}`);
+        const result = await digestPendingConversations({
+            workspaceRoot: input.workspaceRoot,
+            digestFn: input.digestFn,
+            onProgress: (progress) => {
+                const currentStatus = {
+                    ...runningStatus,
+                    updatedAt: isoNow(),
+                    processed: progress.processed,
+                    skipped: progress.skipped,
+                    errors: progress.errors,
+                };
+                writeDigestWorkerStatus(input.workspaceRoot, currentStatus);
+            },
+        });
+        const status = statusFromPendingResult(result, startedAt, pendingAtStart);
+        writeDigestWorkerStatus(input.workspaceRoot, status);
+        appendDigestWorkerLog(input.workspaceRoot, `worker finished state=${status.state} processed=${status.processed} skipped=${status.skipped} errors=${status.errors}`);
+        return status;
+    }
+    catch (err) {
+        const status = {
+            ...emptyStatus('failed', pendingAtStart, startedAt),
+            updatedAt: isoNow(),
+            errors: 1,
+            lastError: errorMessage(err),
+        };
+        writeDigestWorkerStatus(input.workspaceRoot, status);
+        appendDigestWorkerLog(input.workspaceRoot, `worker failed error=${status.lastError}`);
+        return status;
+    }
+}
+export function launchDigestPendingWorker(input) {
+    const startedAt = isoNow();
+    let pendingAtStart = 0;
+    try {
+        const previousStatus = readDigestWorkerStatus(input.workspaceRoot);
+        if (previousStatus?.state === 'running' && isLivePid(previousStatus.pid)) {
+            const status = {
+                ...previousStatus,
+                state: 'locked',
+                updatedAt: isoNow(),
+                lastError: undefined,
+            };
+            writeDigestWorkerStatus(input.workspaceRoot, status);
+            return { ok: true, mode: 'background-launcher', status, spawned: false, reason: 'locked' };
+        }
+        const lockPid = readLockPid(input.workspaceRoot);
+        if (lockPid !== undefined && isLivePid(lockPid)) {
+            const status = emptyStatus('locked', 0, startedAt);
+            writeDigestWorkerStatus(input.workspaceRoot, status);
+            return { ok: true, mode: 'background-launcher', status, spawned: false, reason: 'locked' };
+        }
+        const summary = summarizePendingConversations(input.workspaceRoot);
+        if (!summary.initialized) {
+            const status = emptyStatus('not-initialized', 0, startedAt);
+            writeDigestWorkerStatus(input.workspaceRoot, status);
+            return { ok: true, mode: 'background-launcher', status, spawned: false, reason: 'not-initialized' };
+        }
+        if (summary.pending === 0) {
+            const status = emptyStatus('no-pending', 0, startedAt);
+            writeDigestWorkerStatus(input.workspaceRoot, status);
+            return { ok: true, mode: 'background-launcher', status, spawned: false, reason: 'no-pending' };
+        }
+        pendingAtStart = summary.pending;
+        if (!input.entrypoint) {
+            const status = {
+                ...emptyStatus('failed', pendingAtStart, startedAt),
+                errors: 1,
+                lastError: 'CLI entrypoint is unavailable',
+            };
+            writeDigestWorkerStatus(input.workspaceRoot, status);
+            return {
+                ok: false,
+                mode: 'background-launcher',
+                status,
+                spawned: false,
+                reason: 'spawn-failed',
+                error: status.lastError,
+            };
+        }
+        const child = spawn(process.execPath, [input.entrypoint, 'memory', 'digest-pending', ...input.args, `--${DIGEST_WORKER_FLAG}`], {
+            cwd: input.workspaceRoot,
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+        if (!child.pid) {
+            throw new Error('worker process did not expose a pid');
+        }
+        const status = {
+            ...emptyStatus('running', pendingAtStart, startedAt),
+            pid: child.pid,
+        };
+        writeDigestWorkerStatus(input.workspaceRoot, status);
+        appendDigestWorkerLog(input.workspaceRoot, `launcher spawned pid=${child.pid} pending=${pendingAtStart}`);
+        return { ok: true, mode: 'background-launcher', status, spawned: true, pid: child.pid };
+    }
+    catch (err) {
+        const status = {
+            ...emptyStatus('failed', pendingAtStart, startedAt),
+            errors: 1,
+            lastError: errorMessage(err),
+        };
+        writeDigestWorkerStatus(input.workspaceRoot, status);
+        appendDigestWorkerLog(input.workspaceRoot, `launcher failed error=${status.lastError}`);
+        return {
+            ok: false,
+            mode: 'background-launcher',
+            status,
+            spawned: false,
+            reason: 'spawn-failed',
+            error: status.lastError,
+        };
+    }
+}

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

@@ -0,0 +1,17 @@
+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;
+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 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/services/digest/constants.js

@@ -0,0 +1,19 @@
+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_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');
+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/services/digest/digest-init.test.js

@@ -0,0 +1,33 @@
+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 { initializeConversationDigestModel } from './processor.js';
+import { DigestModelId } from './types.js';
+const tempDirs = createTempDirTracker();
+afterEach(() => {
+    tempDirs.cleanup();
+});
+describe('initializeConversationDigestModel', () => {
+    test('rejects unknown model and leaves settings absent', async () => {
+        const workspace = tempDirs.makeTempDir('digest-init-');
+        const result = await initializeConversationDigestModel({
+            workspaceRoot: workspace,
+            modelId: 'unknown-model',
+            allowDownload: true,
+        });
+        assert.equal(result.initialized, false);
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'settings.json')), false);
+    });
+    test('requires explicit download permission and leaves settings absent', async () => {
+        const workspace = tempDirs.makeTempDir('digest-init-');
+        const result = await initializeConversationDigestModel({
+            workspaceRoot: workspace,
+            modelId: DigestModelId.DEFAULT,
+            allowDownload: false,
+        });
+        assert.equal(result.initialized, false);
+        assert.equal(fs.existsSync(path.join(workspace, '.agent-kit', 'settings.json')), false);
+    });
+});

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

@@ -0,0 +1,21 @@
+import * as assert from 'node:assert/strict';
+import { describe, test } from 'node:test';
+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('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/services/digest/digest-pending.test.d.ts

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