@hanhnd/agent-kit 1.0.32 → 1.0.34

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/{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);
     });
 });