@hanhnd/agent-kit 1.0.32 → 1.0.34

package/dist/{tools/__tests__ → services/memory}/memory.test.js

@@ -1,7 +1,8 @@
 import * as assert from 'node:assert/strict';
 import { describe, test } from 'node:test';
-import { resolveMemoryConfig } from '../config.js';
-import { registerMemoryToolHandlers } from '../memory.js';
+import { EmbeddingModelName } from './types.js';
+import { resolveMemoryConfig } from '../../core/config/index.js';
+import { registerMemoryTools } from '../../mcp/memory.js';
 // Minimal McpServer stub that captures tool registrations
 function makeMockServer() {
     const tools = new Map();
@@ -30,7 +31,7 @@ const BASE_CONFIG = {
     topK: 5,
     chunkSize: 1500,
     overlapLines: 2,
-    embeddingModel: 'Xenova/bge-small-en-v1.5',
+    embeddingModel: EmbeddingModelName.SMALL,
     vectorDimension: 384,
 };
 function makeIndexerStub(overrides = {}) {
@@ -61,7 +62,11 @@ describe('kit_memory_search', () => {
         const indexer = makeIndexerStub({ search: async () => [searchResult] });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_search')({ query: 'test query' });
         const text = extractText(result);
         assert.ok(text.includes('Important memory content'), 'Result must include chunk content');
@@ -73,7 +78,11 @@ describe('kit_memory_search', () => {
         const indexer = makeIndexerStub({ search: async () => [] });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_search')({ query: 'nothing here' });
         const text = extractText(result);
         assert.ok(text.toLowerCase().includes('no memories') || text.includes('No memories'), `Expected "no memories" message, got: ${text.slice(0, 100)}`);
@@ -82,7 +91,11 @@ describe('kit_memory_search', () => {
         const indexer = makeIndexerStub({ search: async () => [] });
         const store = makeStoreStub(false);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_search')({ query: 'test' });
         const text = extractText(result);
         assert.ok(text.includes('Vector search unavailable') || text.includes('keyword-only'), `Expected degraded warning in: ${text.slice(0, 200)}`);
@@ -98,7 +111,11 @@ describe('kit_memory_search', () => {
         const indexer = makeIndexerStub({ search: async () => [searchResult] });
         const store = makeStoreStub(false);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_search')({ query: 'test' });
         const text = extractText(result);
         assert.ok(text.includes('Vector search unavailable') || text.includes('keyword-only'), `Expected degraded warning with results in: ${text.slice(0, 200)}`);
@@ -115,7 +132,11 @@ describe('kit_memory_search', () => {
         const indexer = makeIndexerStub({ search: async () => [searchResult] });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_search')({ query: 'test' });
         const text = extractText(result);
         assert.ok(text.includes('Source file unavailable'), `Expected fallback warning in: ${text}`);
@@ -131,7 +152,11 @@ describe('kit_memory_search', () => {
         });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         await tools.get('kit_memory_search')({ query: 'test', top_k: 3 });
         assert.equal(capturedTopK, 3);
     });
@@ -145,7 +170,11 @@ describe('kit_memory_search', () => {
         });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         await tools.get('kit_memory_search')({ query: 'test' });
         assert.equal(capturedTopK, BASE_CONFIG.topK);
     });
@@ -157,7 +186,11 @@ describe('kit_memory_search', () => {
         });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_search')({ query: 'test' });
         const text = extractText(result);
         assert.ok(text.includes('kit_memory_search failed'), `Expected error prefix, got: ${text}`);
@@ -171,7 +204,11 @@ describe('kit_memory_save', () => {
         });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_save')({ content: 'Some important note' });
         const text = extractText(result);
         const parsed = JSON.parse(text);
@@ -187,7 +224,11 @@ describe('kit_memory_save', () => {
         });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_save')({ content: 'note' });
         const text = extractText(result);
         const parsed = JSON.parse(text);

package/dist/{memory/__tests__ → services/memory}/store.test.js

@@ -3,14 +3,15 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { after, before, describe, test } from 'node:test';
-import { MemoryStore } from '../store.js';
+import { MemoryStore } from './store.js';
+import { EmbeddingModelName } from './types.js';
 const TEST_CONFIG = {
     enabled: true,
     wikiDir: '',
     topK: 5,
     chunkSize: 1500,
     overlapLines: 2,
-    embeddingModel: 'Xenova/bge-small-en-v1.5',
+    embeddingModel: EmbeddingModelName.SMALL,
     vectorDimension: 384,
 };
 function makeChunk(overrides = {}) {

package/dist/{memory → services/memory}/types.d.ts

@@ -1,4 +1,9 @@
-import type { ConversationDigestSettings } from './digest/types.js';
+import type { ConversationDigestSettings } from '../digest/types.js';
+export declare enum EmbeddingModelName {
+    TINY = "tiny",
+    SMALL = "small",
+    LARGE = "large"
+}
 export interface MemoryChunk {
     id: string;
     source: string;
@@ -20,7 +25,7 @@ export interface MemoryConfig {
     topK: number;
     chunkSize: number;
     overlapLines: number;
-    embeddingModel: string;
+    embeddingModel: EmbeddingModelName;
     vectorDimension: number;
     conversationDigest?: ConversationDigestSettings;
 }

package/dist/services/memory/types.js

@@ -0,0 +1,6 @@
+export var EmbeddingModelName;
+(function (EmbeddingModelName) {
+    EmbeddingModelName["TINY"] = "tiny";
+    EmbeddingModelName["SMALL"] = "small";
+    EmbeddingModelName["LARGE"] = "large";
+})(EmbeddingModelName || (EmbeddingModelName = {}));

package/dist/utils/files.d.ts

@@ -1,6 +1,5 @@
 export declare function atomicWriteTextFile(filePath: string, content: string): void;
 export declare function atomicWriteJsonFile(filePath: string, value: unknown): void;
-export declare function tryWriteFileExclusive(filePath: string, content: string): boolean;
 export declare function acquireLock(lockPath: string, timeoutMs: number, retryMs: number): Promise<boolean>;
 export declare function releaseLock(lockPath: string, opts?: {
     ignoreErrors?: boolean;

package/dist/utils/files.js

@@ -9,7 +9,7 @@ export function atomicWriteTextFile(filePath, content) {
 export function atomicWriteJsonFile(filePath, value) {
     atomicWriteTextFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
 }
-export function tryWriteFileExclusive(filePath, content) {
+function tryWriteFileExclusive(filePath, content) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     try {
         fs.writeFileSync(filePath, content, { flag: 'wx' });

package/dist/{memory/__tests__/lockfile.test.js → utils/files.test.js}

@@ -2,9 +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 { DIGEST_LOCKFILE_REL_PATH } from '../digest/constants.js';
-import { releaseLock, tryAcquireProcessLock } from '../../utils/files.js';
+import { createTempDirTracker } from './temp-dir.test.js';
+import { DIGEST_LOCKFILE_REL_PATH } from '../services/digest/constants.js';
+import { releaseLock, tryAcquireProcessLock } from './files.js';
 const tempDirs = createTempDirTracker();
 afterEach(() => {
     tempDirs.cleanup();
@@ -12,20 +12,22 @@ afterEach(() => {
 function lockPath(workspace) {
     return path.join(workspace, DIGEST_LOCKFILE_REL_PATH);
 }
+function lockDir(workspace) {
+    return path.dirname(lockPath(workspace));
+}
 describe('tryAcquireProcessLock', () => {
     test('C1: no lockfile → creates it with current PID and returns true', () => {
         const workspace = tempDirs.makeTempDir('lockfile-c1-');
         const acquired = tryAcquireProcessLock(lockPath(workspace));
         assert.equal(acquired, true);
-        const lockFile = path.join(workspace, '.agent-kit', 'digest-worker.lock');
+        const lockFile = lockPath(workspace);
         const content = JSON.parse(fs.readFileSync(lockFile, 'utf8'));
         assert.equal(content.pid, process.pid);
     });
     test('C2: lockfile with live foreign PID → returns false without modifying file', () => {
         const workspace = tempDirs.makeTempDir('lockfile-c2-');
-        const lockDir = path.join(workspace, '.agent-kit');
-        const lockFile = path.join(lockDir, 'digest-worker.lock');
-        fs.mkdirSync(lockDir, { recursive: true });
+        const lockFile = lockPath(workspace);
+        fs.mkdirSync(lockDir(workspace), { recursive: true });
         // Use process.pid as "live" pid (current process is definitely alive)
         const livePid = process.pid;
         fs.writeFileSync(lockFile, JSON.stringify({ pid: livePid }), 'utf8');
@@ -37,9 +39,8 @@ describe('tryAcquireProcessLock', () => {
     });
     test('C3: lockfile with dead PID (ESRCH) → deletes stale lock, creates new one, returns true', () => {
         const workspace = tempDirs.makeTempDir('lockfile-c3-');
-        const lockDir = path.join(workspace, '.agent-kit');
-        const lockFile = path.join(lockDir, 'digest-worker.lock');
-        fs.mkdirSync(lockDir, { recursive: true });
+        const lockFile = lockPath(workspace);
+        fs.mkdirSync(lockDir(workspace), { recursive: true });
         // PID 999999999 is virtually guaranteed to be dead
         fs.writeFileSync(lockFile, JSON.stringify({ pid: 999999999 }), 'utf8');
         const acquired = tryAcquireProcessLock(lockPath(workspace));
@@ -57,9 +58,8 @@ describe('tryAcquireProcessLock', () => {
     });
     test('stale unparseable lockfile → treated as stale, returns true', () => {
         const workspace = tempDirs.makeTempDir('lockfile-stale-');
-        const lockDir = path.join(workspace, '.agent-kit');
-        const lockFile = path.join(lockDir, 'digest-worker.lock');
-        fs.mkdirSync(lockDir, { recursive: true });
+        const lockFile = lockPath(workspace);
+        fs.mkdirSync(lockDir(workspace), { recursive: true });
         fs.writeFileSync(lockFile, 'not-json', 'utf8');
         const acquired = tryAcquireProcessLock(lockPath(workspace));
         assert.equal(acquired, true);
@@ -69,7 +69,7 @@ describe('releaseLock', () => {
     test('C5: lockfile exists → deletes it', () => {
         const workspace = tempDirs.makeTempDir('lockfile-c5-');
         assert.equal(tryAcquireProcessLock(lockPath(workspace)), true);
-        const lockFile = path.join(workspace, '.agent-kit', 'digest-worker.lock');
+        const lockFile = lockPath(workspace);
         assert.equal(fs.existsSync(lockFile), true);
         releaseLock(lockPath(workspace));
         assert.equal(fs.existsSync(lockFile), false);

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './async.js';
+export * from './files.js';
+export * from './hash.js';
+export * from './json.js';
+export * from './paths.js';
+export * from './utils.js';

package/dist/utils/index.js

@@ -0,0 +1,6 @@
+export * from './async.js';
+export * from './files.js';
+export * from './hash.js';
+export * from './json.js';
+export * from './paths.js';
+export * from './utils.js';

package/dist/utils/json.d.ts

@@ -1,2 +1 @@
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export declare function readJsonObjectFile(filePath: string): Record<string, unknown>;

package/dist/utils/json.js

@@ -1,13 +1,3 @@
-import * as fs from 'node:fs';
 export function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-export function readJsonObjectFile(filePath) {
-    if (!fs.existsSync(filePath))
-        return {};
-    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    if (!isRecord(parsed)) {
-        throw new Error(`${filePath} must contain a JSON object`);
-    }
-    return parsed;
-}

package/dist/utils/paths.d.ts

@@ -1,4 +1,3 @@
-export declare const AGENT_KIT_HOME: string;
 export declare const CREDENTIALS_FILE: string;
 export declare const MODEL_CACHE_DIR: string;
 export declare const FASTEMBED_CACHE_DIR: string;

package/dist/utils/paths.js

@@ -1,6 +1,6 @@
 import * as os from 'os';
 import * as path from 'path';
-export const AGENT_KIT_HOME = path.join(os.homedir(), '.agent-kit');
+const AGENT_KIT_HOME = path.join(os.homedir(), '.agent-kit');
 export const CREDENTIALS_FILE = path.join(AGENT_KIT_HOME, 'credentials');
 export const MODEL_CACHE_DIR = path.join(AGENT_KIT_HOME, 'cache', 'models');
 export const FASTEMBED_CACHE_DIR = path.join(MODEL_CACHE_DIR, 'fastembed');

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@hanhnd/agent-kit",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "description": "Agent Kit MCP server for software development agent workflows",
   "type": "module",
-  "main": "dist/kit-server.js",
+  "main": "dist/server.js",
   "bin": {
-    "agent-kit": "dist/kit-server.js",
-    "agent-kit-cli": "dist/kit-cli.js"
+    "agent-kit": "dist/server.js",
+    "cli": "dist/cli.js"
   },
   "files": [
     "dist",
@@ -22,10 +22,10 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc && npm run bundle",
-    "bundle": "esbuild src/kit-server.ts src/kit-cli.ts --bundle --platform=node --format=esm --outdir=dist --external:node:* --external:better-sqlite3 --external:sqlite-vec --external:fastembed --external:node-llama-cpp --banner:js=\"import { createRequire } from 'module'; const require = createRequire(import.meta.url);\"",
+    "bundle": "esbuild src/entrypoints/server.ts src/entrypoints/cli.ts --bundle --platform=node --format=esm --outdir=dist --external:node:* --external:better-sqlite3 --external:sqlite-vec --external:fastembed --external:node-llama-cpp --banner:js=\"import { createRequire } from 'module'; const require = createRequire(import.meta.url);\"",
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build",
-    "test": "tsc && node --test $(find src/memory/__tests__ src/tools/__tests__ -name '*.test.ts' | sed 's#^src/#dist/#; s#\\.ts$#.js#' | tr '\\n' ' ')"
+    "test": "tsc && node --test $(find dist -name '*.test.js' | tr '\\n' ' ')"
   },
   "dependencies": {
     "node-llama-cpp": "^3.0.0",

package/dist/memory/__tests__/digest-worker.test.js

@@ -1,46 +0,0 @@
-import * as assert from 'node:assert/strict';
-import { describe, test } from 'node:test';
-import { parseDigestWorkerSuccess } from '../digest/worker.js';
-import { DIGEST_WORKER_RESULT_PREFIX } from '../digest/constants.js';
-function workerResultLine(result) {
-    return DIGEST_WORKER_RESULT_PREFIX + JSON.stringify(result);
-}
-describe('parseDigestWorkerSuccess', () => {
-    test('accepts a structured provisional digest worker line', () => {
-        const stdout = [
-            '[memory-kit] model-load: 612ms',
-            workerResultLine({
-                markdown: '/tmp/conversation-digests/abc-conv.md',
-                status: 'provisional',
-                contentHash: 'abc',
-                indexed: true,
-                skipped: false,
-            }),
-        ].join('\n');
-        assert.equal(parseDigestWorkerSuccess(stdout), true);
-    });
-    test('rejects stdout that only mentions markdown as plain text', () => {
-        const stdout = 'The model produced markdown but no digest result envelope.';
-        assert.equal(parseDigestWorkerSuccess(stdout), false);
-    });
-    test('rejects unprefixed JSON objects', () => {
-        const stdout = [
-            JSON.stringify({ markdown: '/tmp/file.md', status: 'draft' }),
-            JSON.stringify({ markdown: '/tmp/file.md', status: 'provisional' }),
-        ].join('\n');
-        assert.equal(parseDigestWorkerSuccess(stdout), false);
-    });
-    test('uses the last valid digest worker line after noisy output', () => {
-        const stdout = [
-            JSON.stringify({ event: 'model-load', markdown: false }),
-            'Metal cleanup warning',
-            workerResultLine({ markdown: '/tmp/final.md', status: 'provisional' }),
-            'trailing non-json output',
-        ].join('\n');
-        assert.equal(parseDigestWorkerSuccess(stdout), true);
-    });
-    test('rejects malformed digest worker lines', () => {
-        const stdout = ['[memory-kit] model-load: 612ms', DIGEST_WORKER_RESULT_PREFIX + '{"markdown":'].join('\n');
-        assert.equal(parseDigestWorkerSuccess(stdout), false);
-    });
-});

package/dist/memory/__tests__/embedder.test.js

@@ -1,14 +0,0 @@
-import * as assert from 'node:assert/strict';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { describe, test } from 'node:test';
-import { DEFAULT_MODEL_CACHE_DIR, FASTEMBED_CACHE_DIR } from '../embedder.js';
-import { AGENT_KIT_HOME, CREDENTIALS_FILE } from '../../utils/paths.js';
-describe('Embedder cache paths', () => {
-    test('uses global Agent Kit home for user-level files', () => {
-        assert.equal(AGENT_KIT_HOME, path.join(os.homedir(), '.agent-kit'));
-        assert.equal(CREDENTIALS_FILE, path.join(AGENT_KIT_HOME, 'credentials'));
-        assert.equal(DEFAULT_MODEL_CACHE_DIR, path.join(AGENT_KIT_HOME, 'cache', 'models'));
-        assert.equal(FASTEMBED_CACHE_DIR, path.join(DEFAULT_MODEL_CACHE_DIR, 'fastembed'));
-    });
-});

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

@@ -1,6 +0,0 @@
-import type { DigestModelSpec } from './types.js';
-export declare class DigestModelRegistryError extends Error {
-    constructor(message: string);
-}
-export declare const DIGEST_MODEL_REGISTRY: Record<string, DigestModelSpec>;
-export declare function getDigestModelSpec(modelId: string): DigestModelSpec;

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

@@ -1,7 +0,0 @@
-import type { DigestFileOptions, DigestPendingResult, ProvisionalDigestResult, ConversationDigestInitResult, InitializeConversationDigestInput } from './types.js';
-export declare function digestConversationFile(options: DigestFileOptions): Promise<ProvisionalDigestResult>;
-export declare function digestPendingConversations({ workspaceRoot, digestFn, }: {
-    workspaceRoot: string;
-    digestFn?: (opts: DigestFileOptions) => Promise<ProvisionalDigestResult>;
-}): Promise<DigestPendingResult>;
-export declare function initializeConversationDigestModel(input: InitializeConversationDigestInput): Promise<ConversationDigestInitResult>;

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

@@ -1,7 +0,0 @@
-import type { ConversationDigestProvider } from '../types.js';
-export declare class LlamaLocalDigestProviderError extends Error {
-    constructor(message: string);
-}
-export declare function trimConversationExport(content: string, maxInputChars: number): string;
-export declare function sanitizeConversationDigestMarkdown(generatedText: string): string;
-export declare function createLlamaLocalDigestProvider(modelId: string): Promise<ConversationDigestProvider>;

package/dist/tools/__tests__/cli-digest-pending.test.js

@@ -1,51 +0,0 @@
-import * as assert from 'node:assert/strict';
-import { afterEach, describe, test } from 'node:test';
-import { createTempDirTracker } from '../../__tests__/temp-dir.js';
-import { runMemoryCli } from '../../cli/memory.js';
-const tempDirs = createTempDirTracker();
-afterEach(() => {
-    tempDirs.cleanup();
-});
-describe('cmdDigestPending CLI', () => {
-    test('C22: no --hook flag → writes usage to stderr and returns 1', async () => {
-        const stderrChunks = [];
-        const origWrite = process.stderr.write.bind(process.stderr);
-        process.stderr.write = (chunk) => {
-            stderrChunks.push(String(chunk));
-            return true;
-        };
-        let code;
-        try {
-            code = await runMemoryCli(['digest-pending'], process.env);
-        }
-        finally {
-            process.stderr.write = origWrite;
-        }
-        assert.equal(code, 1);
-        assert.ok(stderrChunks.some((s) => s.includes('Usage')));
-    });
-    test('C23: --hook returns 0 and emits one JSON line matching DigestPendingResult', async () => {
-        const workspace = tempDirs.makeTempDir('cli-pending-c23-');
-        const stdoutChunks = [];
-        const origWrite = process.stdout.write.bind(process.stdout);
-        process.stdout.write = (chunk) => {
-            stdoutChunks.push(String(chunk));
-            return true;
-        };
-        let code;
-        try {
-            code = await runMemoryCli(['digest-pending', '--hook'], {
-                ...process.env,
-                WORKSPACE_DIR: workspace,
-            });
-        }
-        finally {
-            process.stdout.write = origWrite;
-        }
-        assert.equal(code, 0);
-        const output = stdoutChunks.join('');
-        const parsed = JSON.parse(output.trim());
-        assert.ok('ok' in parsed, 'result must have ok field');
-        assert.ok('action' in parsed, 'result must have action field');
-    });
-});

package/dist/tools/__tests__/cli-memory.test.js

@@ -1,22 +0,0 @@
-import * as assert from 'node:assert/strict';
-import { afterEach, describe, test } from 'node:test';
-import { createTempDirTracker } from '../../__tests__/temp-dir.js';
-import { runMemoryCli } from '../../cli/memory.js';
-const tempDirs = createTempDirTracker();
-afterEach(() => {
-    tempDirs.cleanup();
-});
-describe('memory CLI', () => {
-    test('digest-pending --hook returns 0 when settings are missing', async () => {
-        const workspace = tempDirs.makeTempDir('digest-pending-');
-        const code = await runMemoryCli(['digest-pending', '--hook'], {
-            ...process.env,
-            WORKSPACE_DIR: workspace,
-        });
-        assert.equal(code, 0);
-    });
-    test('unknown command returns 1', async () => {
-        const code = await runMemoryCli(['unknown'], process.env);
-        assert.equal(code, 1);
-    });
-});

package/dist/tools/core.d.ts

@@ -1,10 +0,0 @@
-/**
- * Core Tools - Extension info and handoff persistence
- */
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { DEFAULT_EXTENSIONS } from './config.js';
-/**
- * Register core tools with MCP server
- */
-export declare function registerCoreTools(server: McpServer): void;
-export { DEFAULT_EXTENSIONS };

package/dist/tools/core.js

@@ -1,46 +0,0 @@
-/**
- * Core Tools - Extension info and handoff persistence
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { z } from 'zod';
-import { getWorkspaceRoot, mcpText } from '../utils/utils.js';
-import { DEFAULT_EXTENSIONS } from './config.js';
-import { HANDOFF_TYPES, resolveHandoffPath } from './handoffs.js';
-/**
- * Register core tools with MCP server
- */
-export function registerCoreTools(server) {
-    // ═══════════════════════════════════════════════════════════════
-    // TOOL: SAVE HANDOFF
-    // Writes handoff artifacts to the workspace
-    // Returns the saved file path to use in next-step instructions
-    // ═══════════════════════════════════════════════════════════════
-    server.tool('kit_save_handoff', `Save a handoff artifact to .agent-kit/handoffs/. Returns the saved file path to use in next-step instructions. Do NOT append version numbers (v2, v3, etc.) to the slug.`, {
-        type: z.enum(HANDOFF_TYPES).describe('Handoff type'),
-        content: z.string().describe('Full markdown content to save'),
-        slug: z
-            .string()
-            .describe('Short identifier for the filename, e.g. "user-auth" or "PROJ-123". Do NOT append version numbers (v2, v3, etc.).'),
-    }, async ({ type, content, slug }) => {
-        try {
-            const location = resolveHandoffPath({
-                workspaceRoot: getWorkspaceRoot(),
-                type,
-                slug,
-                content,
-            });
-            const handoffDir = path.dirname(location.filePath);
-            if (!fs.existsSync(handoffDir)) {
-                fs.mkdirSync(handoffDir, { recursive: true });
-            }
-            fs.writeFileSync(location.filePath, content, 'utf8');
-            return mcpText(`✅ Saved to: ${location.filePath}`);
-        }
-        catch (error) {
-            return mcpText(`Error saving handoff: ${error}`);
-        }
-    });
-}
-// Export DEFAULT_EXTENSIONS for backward compatibility
-export { DEFAULT_EXTENSIONS };

package/dist/tools/handoffs.d.ts

@@ -1,22 +0,0 @@
-export declare const HANDOFF_TYPES: readonly ["brainstorm", "clarification", "plan", "ticket", "research", "scenario", "investigation"];
-export type HandoffType = (typeof HANDOFF_TYPES)[number];
-export type CanonicalHandoffType = 'brainstorm' | 'clarification' | 'plan' | 'ticket' | 'research' | 'scenario' | 'investigation';
-export interface SavedHandoffLocation {
-    featureSlug: string;
-    canonicalType: CanonicalHandoffType;
-    filePath: string;
-    relativePath: string;
-}
-export declare function sanitizeFeatureSlug(value: string): string;
-export declare function normalizeHandoffType(type: HandoffType): CanonicalHandoffType;
-export declare function deriveFeatureSlug(input: {
-    requestedSlug: string;
-    content: string;
-    type: CanonicalHandoffType;
-}): string;
-export declare function resolveHandoffPath(input: {
-    workspaceRoot: string;
-    type: HandoffType;
-    slug: string;
-    content: string;
-}): SavedHandoffLocation;

package/dist/tools/memory.d.ts

@@ -1,16 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { MemoryIndexer } from '../memory/indexer.js';
-import { MemoryStore } from '../memory/store.js';
-import type { MemoryConfig } from '../memory/types.js';
-import { type ProjectSettings } from './config.js';
-/**
- * Registers tool handlers onto an already-constructed indexer/store pair.
- * Exported for unit testing with mocks.
- */
-export declare function registerMemoryToolHandlers(server: McpServer, indexer: MemoryIndexer, store: MemoryStore, config: MemoryConfig, workspaceRoot?: string): void;
-/**
- * Initializes the memory subsystem and registers all memory tools.
- * Returns the MemoryIndexer so the caller can fire startupIndex() after server.connect().
- * Returns null when memory is disabled (settings.memory.enabled !== true).
- */
-export declare function registerMemoryTools(server: McpServer, settings: ProjectSettings, workspaceRoot: string): MemoryIndexer | null;