@synth-coder/memhub 0.1.0

package/test/contracts/schemas.test.ts

@@ -0,0 +1,313 @@
+/**
+ * Schema validation tests - RED phase (TDD)
+ * These tests define the expected behavior of Zod schemas
+ * They will fail until implementations are written
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  UUIDSchema,
+  ISO8601TimestampSchema,
+  TagSchema,
+  CategorySchema,
+  ImportanceSchema,
+  MemorySchema,
+  CreateMemoryInputSchema,
+  ReadMemoryInputSchema,
+  UpdateMemoryInputSchema,
+  DeleteMemoryInputSchema,
+  ListMemoryInputSchema,
+  SearchMemoryInputSchema,
+} from '../../src/contracts/schemas.js';
+
+describe('Schema Validation', () => {
+  describe('UUIDSchema', () => {
+    it('should accept valid UUID v4', () => {
+      const validUuid = '550e8400-e29b-41d4-a716-446655440000';
+      expect(UUIDSchema.safeParse(validUuid).success).toBe(true);
+    });
+
+    it('should reject invalid UUID format', () => {
+      const invalidUuid = 'not-a-uuid';
+      expect(UUIDSchema.safeParse(invalidUuid).success).toBe(false);
+    });
+
+    it('should reject empty string', () => {
+      expect(UUIDSchema.safeParse('').success).toBe(false);
+    });
+  });
+
+  describe('ISO8601TimestampSchema', () => {
+    it('should accept valid ISO 8601 timestamp', () => {
+      const validTimestamp = '2024-03-15T10:30:00Z';
+      expect(ISO8601TimestampSchema.safeParse(validTimestamp).success).toBe(true);
+    });
+
+    it('should reject invalid timestamp format', () => {
+      const invalidTimestamp = '2024-03-15';
+      expect(ISO8601TimestampSchema.safeParse(invalidTimestamp).success).toBe(false);
+    });
+
+    it('should reject non-ISO date strings', () => {
+      const nonIsoDate = 'March 15, 2024';
+      expect(ISO8601TimestampSchema.safeParse(nonIsoDate).success).toBe(false);
+    });
+  });
+
+  describe('TagSchema', () => {
+    it('should accept valid tag with lowercase letters and hyphens', () => {
+      expect(TagSchema.safeParse('project-management').success).toBe(true);
+    });
+
+    it('should accept tag with numbers', () => {
+      expect(TagSchema.safeParse('task-123').success).toBe(true);
+    });
+
+    it('should reject uppercase letters', () => {
+      expect(TagSchema.safeParse('Project').success).toBe(false);
+    });
+
+    it('should reject spaces', () => {
+      expect(TagSchema.safeParse('project management').success).toBe(false);
+    });
+
+    it('should reject special characters', () => {
+      expect(TagSchema.safeParse('project@work').success).toBe(false);
+    });
+
+    it('should reject empty string', () => {
+      expect(TagSchema.safeParse('').success).toBe(false);
+    });
+
+    it('should reject tags over 50 characters', () => {
+      const longTag = 'a'.repeat(51);
+      expect(TagSchema.safeParse(longTag).success).toBe(false);
+    });
+  });
+
+  describe('CategorySchema', () => {
+    it('should accept valid category', () => {
+      expect(CategorySchema.safeParse('work').success).toBe(true);
+    });
+
+    it('should reject uppercase letters', () => {
+      expect(CategorySchema.safeParse('Work').success).toBe(false);
+    });
+
+    it('should reject empty string', () => {
+      expect(CategorySchema.safeParse('').success).toBe(false);
+    });
+  });
+
+  describe('ImportanceSchema', () => {
+    it('should accept importance level 1', () => {
+      expect(ImportanceSchema.safeParse(1).success).toBe(true);
+    });
+
+    it('should accept importance level 5', () => {
+      expect(ImportanceSchema.safeParse(5).success).toBe(true);
+    });
+
+    it('should reject level 0', () => {
+      expect(ImportanceSchema.safeParse(0).success).toBe(false);
+    });
+
+    it('should reject level 6', () => {
+      expect(ImportanceSchema.safeParse(6).success).toBe(false);
+    });
+
+    it('should reject non-integer values', () => {
+      expect(ImportanceSchema.safeParse(3.5).success).toBe(false);
+    });
+  });
+
+  describe('MemorySchema', () => {
+    const validMemory = {
+      id: '550e8400-e29b-41d4-a716-446655440000',
+      createdAt: '2024-03-15T10:30:00Z',
+      updatedAt: '2024-03-15T10:30:00Z',
+      tags: ['work', 'project'],
+      category: 'general',
+      importance: 3,
+      title: 'Test Memory',
+      content: 'This is test content',
+    };
+
+    it('should accept valid memory object', () => {
+      expect(MemorySchema.safeParse(validMemory).success).toBe(true);
+    });
+
+    it('should reject memory with invalid UUID', () => {
+      const invalid = { ...validMemory, id: 'invalid-uuid' };
+      expect(MemorySchema.safeParse(invalid).success).toBe(false);
+    });
+
+    it('should reject memory with invalid timestamp', () => {
+      const invalid = { ...validMemory, createdAt: 'invalid-date' };
+      expect(MemorySchema.safeParse(invalid).success).toBe(false);
+    });
+
+    it('should reject memory with empty title', () => {
+      const invalid = { ...validMemory, title: '' };
+      expect(MemorySchema.safeParse(invalid).success).toBe(false);
+    });
+
+    it('should reject memory with title over 200 characters', () => {
+      const invalid = { ...validMemory, title: 'a'.repeat(201) };
+      expect(MemorySchema.safeParse(invalid).success).toBe(false);
+    });
+
+    it('should reject memory with content over 100000 characters', () => {
+      const invalid = { ...validMemory, content: 'a'.repeat(100001) };
+      expect(MemorySchema.safeParse(invalid).success).toBe(false);
+    });
+
+    it('should reject memory with invalid importance', () => {
+      const invalid = { ...validMemory, importance: 10 };
+      expect(MemorySchema.safeParse(invalid).success).toBe(false);
+    });
+  });
+
+  describe('CreateMemoryInputSchema', () => {
+    it('should accept valid create input', () => {
+      const input = {
+        title: 'New Memory',
+        content: 'Content here',
+      };
+      expect(CreateMemoryInputSchema.safeParse(input).success).toBe(true);
+    });
+
+    it('should accept input with optional fields', () => {
+      const input = {
+        title: 'New Memory',
+        content: 'Content here',
+        tags: ['tag1', 'tag2'],
+        category: 'work',
+        importance: 4,
+      };
+      expect(CreateMemoryInputSchema.safeParse(input).success).toBe(true);
+    });
+
+    it('should reject missing title', () => {
+      const input = { content: 'Content here' };
+      expect(CreateMemoryInputSchema.safeParse(input).success).toBe(false);
+    });
+
+    it('should reject missing content', () => {
+      const input = { title: 'New Memory' };
+      expect(CreateMemoryInputSchema.safeParse(input).success).toBe(false);
+    });
+
+    it('should apply default values for optional fields', () => {
+      const input = {
+        title: 'New Memory',
+        content: 'Content here',
+      };
+      const result = CreateMemoryInputSchema.parse(input);
+      expect(result.tags).toEqual([]);
+      expect(result.category).toBe('general');
+      expect(result.importance).toBe(3);
+    });
+  });
+
+  describe('ReadMemoryInputSchema', () => {
+    it('should accept valid read input', () => {
+      const input = { id: '550e8400-e29b-41d4-a716-446655440000' };
+      expect(ReadMemoryInputSchema.safeParse(input).success).toBe(true);
+    });
+
+    it('should reject invalid UUID', () => {
+      const input = { id: 'invalid-uuid' };
+      expect(ReadMemoryInputSchema.safeParse(input).success).toBe(false);
+    });
+  });
+
+  describe('UpdateMemoryInputSchema', () => {
+    it('should accept valid update input with ID only', () => {
+      const input = { id: '550e8400-e29b-41d4-a716-446655440000' };
+      expect(UpdateMemoryInputSchema.safeParse(input).success).toBe(true);
+    });
+
+    it('should accept update with partial fields', () => {
+      const input = {
+        id: '550e8400-e29b-41d4-a716-446655440000',
+        title: 'Updated Title',
+      };
+      expect(UpdateMemoryInputSchema.safeParse(input).success).toBe(true);
+    });
+
+    it('should reject missing ID', () => {
+      const input = { title: 'Updated Title' };
+      expect(UpdateMemoryInputSchema.safeParse(input).success).toBe(false);
+    });
+  });
+
+  describe('DeleteMemoryInputSchema', () => {
+    it('should accept valid delete input', () => {
+      const input = { id: '550e8400-e29b-41d4-a716-446655440000' };
+      expect(DeleteMemoryInputSchema.safeParse(input).success).toBe(true);
+    });
+
+    it('should reject invalid UUID', () => {
+      const input = { id: 'invalid' };
+      expect(DeleteMemoryInputSchema.safeParse(input).success).toBe(false);
+    });
+  });
+
+  describe('ListMemoryInputSchema', () => {
+    it('should accept empty list input', () => {
+      expect(ListMemoryInputSchema.safeParse({}).success).toBe(true);
+    });
+
+    it('should accept input with all filters', () => {
+      const input = {
+        category: 'work',
+        tags: ['project'],
+        fromDate: '2024-01-01T00:00:00Z',
+        toDate: '2024-12-31T23:59:59Z',
+        limit: 50,
+        offset: 10,
+        sortBy: 'createdAt',
+        sortOrder: 'desc',
+      };
+      expect(ListMemoryInputSchema.safeParse(input).success).toBe(true);
+    });
+
+    it('should reject limit over 100', () => {
+      const input = { limit: 101 };
+      expect(ListMemoryInputSchema.safeParse(input).success).toBe(false);
+    });
+
+    it('should reject negative offset', () => {
+      const input = { offset: -1 };
+      expect(ListMemoryInputSchema.safeParse(input).success).toBe(false);
+    });
+  });
+
+  describe('SearchMemoryInputSchema', () => {
+    it('should accept valid search input', () => {
+      const input = { query: 'search term' };
+      expect(SearchMemoryInputSchema.safeParse(input).success).toBe(true);
+    });
+
+    it('should reject empty query', () => {
+      const input = { query: '' };
+      expect(SearchMemoryInputSchema.safeParse(input).success).toBe(false);
+    });
+
+    it('should reject query over 1000 characters', () => {
+      const input = { query: 'a'.repeat(1001) };
+      expect(SearchMemoryInputSchema.safeParse(input).success).toBe(false);
+    });
+
+    it('should accept search with filters', () => {
+      const input = {
+        query: 'project',
+        limit: 20,
+        category: 'work',
+        tags: ['important'],
+      };
+      expect(SearchMemoryInputSchema.safeParse(input).success).toBe(true);
+    });
+  });
+});

package/test/contracts/types.test.ts

@@ -0,0 +1,21 @@
+/**
+ * Types Tests
+ * Tests for type definitions and error codes
+ */
+
+import { describe, it, expect } from 'vitest';
+import { ErrorCode } from '../../src/contracts/types.js';
+
+describe('ErrorCode', () => {
+  it('should have correct error code values', () => {
+    expect(ErrorCode.PARSE_ERROR).toBe(-32700);
+    expect(ErrorCode.INVALID_REQUEST).toBe(-32600);
+    expect(ErrorCode.METHOD_NOT_FOUND).toBe(-32601);
+    expect(ErrorCode.INVALID_PARAMS).toBe(-32602);
+    expect(ErrorCode.INTERNAL_ERROR).toBe(-32603);
+    expect(ErrorCode.NOT_FOUND).toBe(-32001);
+    expect(ErrorCode.STORAGE_ERROR).toBe(-32002);
+    expect(ErrorCode.VALIDATION_ERROR).toBe(-32003);
+    expect(ErrorCode.DUPLICATE_ERROR).toBe(-32004);
+  });
+});

package/test/frontmatter-parser-more.test.ts

@@ -0,0 +1,94 @@
+/**
+ * Additional FrontMatter Parser Tests
+ * For better branch coverage
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  parseFrontMatter,
+  stringifyFrontMatter,
+  FrontMatterError,
+} from '../src/storage/frontmatter-parser.js';
+import type { MemoryFrontMatter } from '../src/contracts/types.js';
+
+describe('parseFrontMatter additional branches', () => {
+  it('should throw for invalid front matter format', () => {
+    // Missing closing ---
+    const markdown = '---\nid: "test"\n# Title\n\nContent';
+    expect(() => parseFrontMatter(markdown)).toThrow(FrontMatterError);
+  });
+
+  it('should parse with Windows line endings', () => {
+    const markdown = `---\r\nid: "550e8400-e29b-41d4-a716-446655440000"\r\ncreated_at: "2024-03-15T10:30:00Z"\r\nupdated_at: "2024-03-15T10:30:00Z"\r\ntags: []\r\ncategory: "general"\r\nimportance: 3\r\n---\r\n\r\n# Title\r\n\r\nContent`;
+
+    const result = parseFrontMatter(markdown);
+    expect(result.frontMatter.id).toBe('550e8400-e29b-41d4-a716-446655440000');
+    expect(result.title).toBe('Title');
+  });
+
+  it('should handle front matter with extra whitespace', () => {
+    const markdown = `---
+  id: "550e8400-e29b-41d4-a716-446655440000"
+  created_at: "2024-03-15T10:30:00Z"
+  updated_at: "2024-03-15T10:30:00Z"
+  tags: []
+  category: "general"
+  importance: 3
+---
+
+# Title
+
+Content`;
+
+    const result = parseFrontMatter(markdown);
+    expect(result.frontMatter.id).toBe('550e8400-e29b-41d4-a716-446655440000');
+  });
+});
+
+describe('stringifyFrontMatter additional branches', () => {
+  const baseFrontMatter: MemoryFrontMatter = {
+    id: '550e8400-e29b-41d4-a716-446655440000',
+    created_at: '2024-03-15T10:30:00Z',
+    updated_at: '2024-03-15T10:30:00Z',
+    tags: [],
+    category: 'general',
+    importance: 3,
+  };
+
+  it('should handle empty title', () => {
+    const result = stringifyFrontMatter(baseFrontMatter, '', 'Content');
+    expect(result).toContain('---');
+    expect(result).toContain('Content');
+  });
+
+  it('should handle empty content', () => {
+    const result = stringifyFrontMatter(baseFrontMatter, 'Title', '');
+    expect(result).toContain('# Title');
+  });
+
+  it('should handle both empty title and content', () => {
+    const result = stringifyFrontMatter(baseFrontMatter, '', '');
+    expect(result).toContain('---');
+    expect(result).toContain('id:');
+  });
+
+  it('should handle single tag', () => {
+    const fm = { ...baseFrontMatter, tags: ['single'] };
+    const result = stringifyFrontMatter(fm, 'Title', 'Content');
+    expect(result).toContain('single');
+  });
+
+  it('should handle many tags', () => {
+    const fm = { ...baseFrontMatter, tags: ['a', 'b', 'c', 'd', 'e'] };
+    const result = stringifyFrontMatter(fm, 'Title', 'Content');
+    expect(result).toContain('a');
+    expect(result).toContain('e');
+  });
+
+  it('should end with single newline', () => {
+    const result = stringifyFrontMatter(baseFrontMatter, 'Title', 'Content');
+    const lines = result.split('\n');
+    expect(lines[lines.length - 1]).toBe('');
+    expect(lines[lines.length - 2]).not.toBe('');
+  });
+});

package/test/server/mcp-server-internals.test.ts

@@ -0,0 +1,257 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { McpServer } from '../../src/server/mcp-server.js';
+import { MCP_METHODS, ERROR_CODES, MCP_PROTOCOL_VERSION } from '../../src/contracts/mcp.js';
+import { ErrorCode } from '../../src/contracts/types.js';
+import { ServiceError } from '../../src/services/memory-service.js';
+
+interface ServerPrivate {
+  handleMethod: (method: string, params: unknown) => Promise<unknown>;
+  handleMessage: (message: string) => Promise<void>;
+  handleError: (id: string | number | null, error: unknown) => void;
+  sendResponse: (id: string | number, result: unknown) => void;
+  sendError: (id: string | number | null, code: number, message: string, data?: Record<string, unknown>) => void;
+  log: (level: 'debug' | 'info' | 'warn' | 'error', message: string) => void;
+}
+
+describe('McpServer internals', () => {
+  let tempDir: string;
+  let server: McpServer;
+  let serverPrivate: ServerPrivate;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'memhub-server-int-test-'));
+    process.env.MEMHUB_STORAGE_PATH = tempDir;
+    server = new McpServer();
+    serverPrivate = server as unknown as ServerPrivate;
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+    delete process.env.MEMHUB_STORAGE_PATH;
+    delete process.env.MEMHUB_LOG_LEVEL;
+    vi.restoreAllMocks();
+  });
+
+  it('handles initialize method', async () => {
+    const result = (await serverPrivate.handleMethod(MCP_METHODS.INITIALIZE, {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      capabilities: {},
+      clientInfo: { name: 'tester', version: '1.0.0' },
+    })) as { protocolVersion: string; serverInfo: { name: string; version: string } };
+
+    expect(result.protocolVersion).toBe(MCP_PROTOCOL_VERSION);
+    expect(result.serverInfo.name).toBe('memhub');
+    expect(result.serverInfo.version.length).toBeGreaterThan(0);
+  });
+
+  it('handles tools/list method', async () => {
+    const result = (await serverPrivate.handleMethod(MCP_METHODS.TOOLS_LIST, {})) as {
+      tools: Array<{ name: string }>;
+    };
+
+    expect(result.tools.length).toBe(2);
+    expect(result.tools.some(t => t.name === 'memory_load')).toBe(true);
+  });
+
+  it('handles tools/call for STM load + update flow', async () => {
+    const updateResult = (await serverPrivate.handleMethod(MCP_METHODS.TOOLS_CALL, {
+      name: 'memory_update',
+      arguments: {
+        sessionId: '550e8400-e29b-41d4-a716-446655440111',
+        entryType: 'decision',
+        title: 'TDD note',
+        content: 'Write tests first',
+        tags: ['tdd'],
+        category: 'engineering',
+      },
+    })) as { content: Array<{ text: string }> };
+
+    const updatePayload = JSON.parse(updateResult.content[0].text) as { id: string; sessionId: string };
+    expect(updatePayload.id).toBeTruthy();
+    expect(updatePayload.sessionId).toBe('550e8400-e29b-41d4-a716-446655440111');
+
+    const loadById = (await serverPrivate.handleMethod(MCP_METHODS.TOOLS_CALL, {
+      name: 'memory_load',
+      arguments: { id: updatePayload.id },
+    })) as { content: Array<{ text: string }> };
+    expect(loadById.content[0].text).toContain('TDD note');
+
+    const loadBySession = (await serverPrivate.handleMethod(MCP_METHODS.TOOLS_CALL, {
+      name: 'memory_load',
+      arguments: { sessionId: '550e8400-e29b-41d4-a716-446655440111', limit: 10 },
+    })) as { content: Array<{ text: string }> };
+    expect(loadBySession.content[0].text).toContain('items');
+  });
+
+  it('returns tool error payload for unknown tool', async () => {
+    const result = (await serverPrivate.handleMethod(MCP_METHODS.TOOLS_CALL, {
+      name: 'unknown_tool',
+      arguments: {},
+    })) as { isError?: boolean; content: Array<{ text: string }> };
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Unknown tool');
+  });
+
+  it('handles lifecycle methods', async () => {
+    await expect(serverPrivate.handleMethod(MCP_METHODS.INITIALIZED, {})).resolves.toBeNull();
+    await expect(serverPrivate.handleMethod(MCP_METHODS.SHUTDOWN, {})).resolves.toBeNull();
+
+    const exitSpy = vi
+      .spyOn(process, 'exit')
+      .mockImplementation(() => undefined as never);
+
+    await expect(serverPrivate.handleMethod(MCP_METHODS.EXIT, {})).resolves.toBeNull();
+    expect(exitSpy).toHaveBeenCalledWith(0);
+  });
+
+  it('throws ServiceError for unknown method', async () => {
+    await expect(serverPrivate.handleMethod('unknown/method', {})).rejects.toMatchObject({
+      code: ErrorCode.METHOD_NOT_FOUND,
+    });
+  });
+
+  it('routes parse errors from handleMessage', async () => {
+    const sendErrorSpy = vi
+      .spyOn(serverPrivate, 'sendError')
+      .mockImplementation(() => undefined);
+
+    await serverPrivate.handleMessage('{bad-json');
+
+    expect(sendErrorSpy).toHaveBeenCalledWith(
+      null,
+      ERROR_CODES.PARSE_ERROR,
+      'Parse error: Invalid JSON'
+    );
+  });
+
+  it('routes invalid request errors from handleMessage', async () => {
+    const sendErrorSpy = vi
+      .spyOn(serverPrivate, 'sendError')
+      .mockImplementation(() => undefined);
+
+    await serverPrivate.handleMessage(JSON.stringify({ jsonrpc: '2.0' }));
+
+    expect(sendErrorSpy).toHaveBeenCalledWith(
+      null,
+      ERROR_CODES.INVALID_REQUEST,
+      'Invalid Request'
+    );
+  });
+
+  it('does not send response for notifications without id', async () => {
+    const sendResponseSpy = vi
+      .spyOn(serverPrivate, 'sendResponse')
+      .mockImplementation(() => undefined);
+
+    await serverPrivate.handleMessage(
+      JSON.stringify({
+        jsonrpc: '2.0',
+        method: MCP_METHODS.INITIALIZED,
+        params: {},
+      })
+    );
+
+    expect(sendResponseSpy).not.toHaveBeenCalled();
+  });
+
+  it('returns INVALID_PARAMS on schema validation errors', async () => {
+    const sendErrorSpy = vi
+      .spyOn(serverPrivate, 'sendError')
+      .mockImplementation(() => undefined);
+
+    await serverPrivate.handleMessage(
+      JSON.stringify({
+        jsonrpc: '2.0',
+        id: 123,
+        method: MCP_METHODS.TOOLS_CALL,
+        params: {
+          name: 'memory_update',
+          arguments: { title: '' },
+        },
+      })
+    );
+
+    expect(sendErrorSpy).toHaveBeenCalledWith(
+      123,
+      ERROR_CODES.INVALID_PARAMS,
+      expect.stringContaining('Invalid parameters')
+    );
+  });
+
+  it('handleError maps ServiceError, validation error, and generic error', () => {
+    const sendErrorSpy = vi
+      .spyOn(serverPrivate, 'sendError')
+      .mockImplementation(() => undefined);
+
+    serverPrivate.handleError(
+      1,
+      new ServiceError('boom', ErrorCode.STORAGE_ERROR, { foo: 'bar' })
+    );
+    const zodLikeError = new Error('invalid');
+    zodLikeError.name = 'ZodError';
+    serverPrivate.handleError(2, zodLikeError);
+    serverPrivate.handleError(3, new Error('oops'));
+
+    expect(sendErrorSpy).toHaveBeenNthCalledWith(
+      1,
+      1,
+      ErrorCode.STORAGE_ERROR,
+      'boom',
+      { foo: 'bar' }
+    );
+    expect(sendErrorSpy).toHaveBeenNthCalledWith(
+      2,
+      2,
+      ERROR_CODES.INVALID_PARAMS,
+      'Invalid parameters: invalid'
+    );
+    expect(sendErrorSpy).toHaveBeenNthCalledWith(
+      3,
+      3,
+      ERROR_CODES.INTERNAL_ERROR,
+      'Internal error: oops'
+    );
+  });
+
+  it('sendResponse writes valid JSON-RPC response', () => {
+    const writeSpy = vi
+      .spyOn(process.stdout, 'write')
+      .mockReturnValue(true);
+
+    serverPrivate.sendResponse(7, { ok: true });
+
+    const output = String(writeSpy.mock.calls[0][0]).trim();
+    const parsed = JSON.parse(output) as { id: number; result: { ok: boolean } };
+    expect(parsed.id).toBe(7);
+    expect(parsed.result.ok).toBe(true);
+  });
+
+  it('sendError writes valid JSON-RPC error response', () => {
+    const writeSpy = vi
+      .spyOn(process.stdout, 'write')
+      .mockReturnValue(true);
+
+    serverPrivate.sendError(null, ERROR_CODES.INTERNAL_ERROR, 'failure');
+
+    const output = String(writeSpy.mock.calls[0][0]).trim();
+    const parsed = JSON.parse(output) as { id: null; error: { code: number; message: string } };
+    expect(parsed.id).toBeNull();
+    expect(parsed.error.code).toBe(ERROR_CODES.INTERNAL_ERROR);
+    expect(parsed.error.message).toBe('failure');
+  });
+
+  it('log respects configured log level', () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+
+    process.env.MEMHUB_LOG_LEVEL = 'error';
+    serverPrivate.log('info', 'ignore');
+    serverPrivate.log('error', 'report');
+
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+    expect(errorSpy.mock.calls[0][0]).toContain('[ERROR] report');
+  });
+});