diff --git a/tests/context-injection.test.ts b/tests/context-injection.test.ts
new file mode 100644
index 00000000..2e338994
--- /dev/null
+++ b/tests/context-injection.test.ts
@@ -0,0 +1,214 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import {
+  injectContextIntoMarkdownFile,
+  CONTEXT_TAG_OPEN,
+  CONTEXT_TAG_CLOSE,
+} from '../src/utils/context-injection';
+
+/**
+ * Tests for the shared context injection utility.
+ *
+ * injectContextIntoMarkdownFile is used by MCP integrations and OpenCode
+ * installer to inject or update a <claude-mem-context> section in markdown files.
+ */
+
+describe('Context Injection', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `context-injection-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('tag constants', () => {
+    it('exports correct open and close tags', () => {
+      expect(CONTEXT_TAG_OPEN).toBe('<claude-mem-context>');
+      expect(CONTEXT_TAG_CLOSE).toBe('</claude-mem-context>');
+    });
+  });
+
+  describe('inject into new file', () => {
+    it('creates a new file with context tags when file does not exist', () => {
+      const filePath = join(tempDir, 'CLAUDE.md');
+
+      injectContextIntoMarkdownFile(filePath, 'Hello world');
+
+      expect(existsSync(filePath)).toBe(true);
+      const content = readFileSync(filePath, 'utf-8');
+      expect(content).toContain(CONTEXT_TAG_OPEN);
+      expect(content).toContain('Hello world');
+      expect(content).toContain(CONTEXT_TAG_CLOSE);
+    });
+
+    it('creates parent directories if they do not exist', () => {
+      const filePath = join(tempDir, 'nested', 'deep', 'CLAUDE.md');
+
+      injectContextIntoMarkdownFile(filePath, 'test content');
+
+      expect(existsSync(filePath)).toBe(true);
+    });
+
+    it('writes content wrapped in context tags', () => {
+      const filePath = join(tempDir, 'CLAUDE.md');
+      const contextContent = '# Recent Activity\n\nSome memory data here.';
+
+      injectContextIntoMarkdownFile(filePath, contextContent);
+
+      const content = readFileSync(filePath, 'utf-8');
+      const expected = `${CONTEXT_TAG_OPEN}\n${contextContent}\n${CONTEXT_TAG_CLOSE}\n`;
+      expect(content).toBe(expected);
+    });
+  });
+
+  describe('headerLine support', () => {
+    it('prepends headerLine when creating a new file', () => {
+      const filePath = join(tempDir, 'AGENTS.md');
+      const headerLine = '# Claude-Mem Memory Context';
+
+      injectContextIntoMarkdownFile(filePath, 'context data', headerLine);
+
+      const content = readFileSync(filePath, 'utf-8');
+      expect(content.startsWith(headerLine)).toBe(true);
+      expect(content).toContain(CONTEXT_TAG_OPEN);
+      expect(content).toContain('context data');
+    });
+
+    it('places a blank line between headerLine and context tags', () => {
+      const filePath = join(tempDir, 'AGENTS.md');
+      const headerLine = '# My Header';
+
+      injectContextIntoMarkdownFile(filePath, 'data', headerLine);
+
+      const content = readFileSync(filePath, 'utf-8');
+      expect(content).toBe(`${headerLine}\n\n${CONTEXT_TAG_OPEN}\ndata\n${CONTEXT_TAG_CLOSE}\n`);
+    });
+
+    it('does not use headerLine when file already exists', () => {
+      const filePath = join(tempDir, 'AGENTS.md');
+      writeFileSync(filePath, '# Existing Content\n\nSome stuff.\n');
+
+      injectContextIntoMarkdownFile(filePath, 'new context', '# Should Not Appear');
+
+      const content = readFileSync(filePath, 'utf-8');
+      expect(content).toContain('# Existing Content');
+      expect(content).not.toContain('# Should Not Appear');
+      expect(content).toContain('new context');
+    });
+  });
+
+  describe('replace existing context section', () => {
+    it('replaces content between existing context tags', () => {
+      const filePath = join(tempDir, 'CLAUDE.md');
+      const initialContent = [
+        '# Project Instructions',
+        '',
+        `${CONTEXT_TAG_OPEN}`,
+        'Old context data',
+        `${CONTEXT_TAG_CLOSE}`,
+        '',
+        '## Other stuff',
+      ].join('\n');
+      writeFileSync(filePath, initialContent);
+
+      injectContextIntoMarkdownFile(filePath, 'New context data');
+
+      const content = readFileSync(filePath, 'utf-8');
+      expect(content).toContain('New context data');
+      expect(content).not.toContain('Old context data');
+      expect(content).toContain('# Project Instructions');
+      expect(content).toContain('## Other stuff');
+    });
+
+    it('preserves content before and after the context section', () => {
+      const filePath = join(tempDir, 'CLAUDE.md');
+      const before = '# Header\n\nSome instructions.\n\n';
+      const after = '\n\n## Footer\n\nMore content.\n';
+      const initialContent = `${before}${CONTEXT_TAG_OPEN}\nold\n${CONTEXT_TAG_CLOSE}${after}`;
+      writeFileSync(filePath, initialContent);
+
+      injectContextIntoMarkdownFile(filePath, 'replaced');
+
+      const content = readFileSync(filePath, 'utf-8');
+      expect(content).toContain('# Header');
+      expect(content).toContain('Some instructions.');
+      expect(content).toContain('## Footer');
+      expect(content).toContain('More content.');
+      expect(content).toContain('replaced');
+      expect(content).not.toContain('old');
+    });
+  });
+
+  describe('append to existing file', () => {
+    it('appends context section to file without existing tags', () => {
+      const filePath = join(tempDir, 'CLAUDE.md');
+      writeFileSync(filePath, '# My Project\n\nInstructions here.\n');
+
+      injectContextIntoMarkdownFile(filePath, 'appended context');
+
+      const content = readFileSync(filePath, 'utf-8');
+      expect(content).toContain('# My Project');
+      expect(content).toContain('Instructions here.');
+      expect(content).toContain(CONTEXT_TAG_OPEN);
+      expect(content).toContain('appended context');
+      expect(content).toContain(CONTEXT_TAG_CLOSE);
+    });
+
+    it('separates appended section with a blank line', () => {
+      const filePath = join(tempDir, 'CLAUDE.md');
+      writeFileSync(filePath, '# Header');
+
+      injectContextIntoMarkdownFile(filePath, 'data');
+
+      const content = readFileSync(filePath, 'utf-8');
+      // Should have double newline before the tag
+      expect(content).toContain(`# Header\n\n${CONTEXT_TAG_OPEN}`);
+    });
+
+    it('trims trailing whitespace before appending', () => {
+      const filePath = join(tempDir, 'CLAUDE.md');
+      writeFileSync(filePath, '# Header\n\n\n   \n');
+
+      injectContextIntoMarkdownFile(filePath, 'data');
+
+      const content = readFileSync(filePath, 'utf-8');
+      // Should not have excessive whitespace before the tag
+      expect(content).toContain(`# Header\n\n${CONTEXT_TAG_OPEN}`);
+    });
+  });
+
+  describe('idempotency', () => {
+    it('produces same result when called twice with same content', () => {
+      const filePath = join(tempDir, 'CLAUDE.md');
+
+      injectContextIntoMarkdownFile(filePath, 'stable content');
+      const firstWrite = readFileSync(filePath, 'utf-8');
+
+      injectContextIntoMarkdownFile(filePath, 'stable content');
+      const secondWrite = readFileSync(filePath, 'utf-8');
+
+      expect(secondWrite).toBe(firstWrite);
+    });
+
+    it('updates content when called with different data', () => {
+      const filePath = join(tempDir, 'CLAUDE.md');
+
+      injectContextIntoMarkdownFile(filePath, 'version 1');
+      injectContextIntoMarkdownFile(filePath, 'version 2');
+
+      const content = readFileSync(filePath, 'utf-8');
+      expect(content).toContain('version 2');
+      expect(content).not.toContain('version 1');
+    });
+  });
+});
diff --git a/tests/install-non-tty.test.ts b/tests/install-non-tty.test.ts
new file mode 100644
index 00000000..34ad1942
--- /dev/null
+++ b/tests/install-non-tty.test.ts
@@ -0,0 +1,112 @@
+import { describe, it, expect } from 'bun:test';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Tests for the non-TTY detection in the install command.
+ *
+ * The install command (src/npx-cli/commands/install.ts) has non-interactive
+ * fallbacks so it works in CI/CD, Docker, and piped environments where
+ * process.stdin.isTTY is undefined.
+ *
+ * Since isInteractive, runTasks, and log are not exported, we verify
+ * their presence and correctness via source inspection. This is a valid
+ * approach for testing private module-level constructs that can't be
+ * imported directly.
+ */
+
+const installSourcePath = join(
+  __dirname,
+  '..',
+  'src',
+  'npx-cli',
+  'commands',
+  'install.ts',
+);
+const installSource = readFileSync(installSourcePath, 'utf-8');
+
+describe('Install Non-TTY Support', () => {
+  describe('isInteractive flag', () => {
+    it('defines isInteractive based on process.stdin.isTTY', () => {
+      expect(installSource).toContain('const isInteractive = process.stdin.isTTY === true');
+    });
+
+    it('uses strict equality (===) not truthy check for isTTY', () => {
+      // Ensures undefined isTTY is treated as false, not just falsy
+      const match = installSource.match(/const isInteractive = process\.stdin\.isTTY === true/);
+      expect(match).not.toBeNull();
+    });
+  });
+
+  describe('runTasks helper', () => {
+    it('defines a runTasks function', () => {
+      expect(installSource).toContain('async function runTasks');
+    });
+
+    it('has interactive branch using p.tasks', () => {
+      expect(installSource).toContain('await p.tasks(tasks)');
+    });
+
+    it('has non-interactive fallback using console.log', () => {
+      // In non-TTY mode, tasks iterate and log output directly
+      expect(installSource).toContain('console.log(`  ${msg}`)');
+    });
+
+    it('branches on isInteractive', () => {
+      expect(installSource).toContain('if (isInteractive)');
+    });
+  });
+
+  describe('log wrapper', () => {
+    it('defines log.info that falls back to console.log', () => {
+      expect(installSource).toContain('info: (msg: string) =>');
+      // Should have console.log fallback
+      expect(installSource).toMatch(/info:.*console\.log/);
+    });
+
+    it('defines log.success that falls back to console.log', () => {
+      expect(installSource).toContain('success: (msg: string) =>');
+      expect(installSource).toMatch(/success:.*console\.log/);
+    });
+
+    it('defines log.warn that falls back to console.warn', () => {
+      expect(installSource).toContain('warn: (msg: string) =>');
+      expect(installSource).toMatch(/warn:.*console\.warn/);
+    });
+
+    it('defines log.error that falls back to console.error', () => {
+      expect(installSource).toContain('error: (msg: string) =>');
+      expect(installSource).toMatch(/error:.*console\.error/);
+    });
+  });
+
+  describe('non-interactive install path', () => {
+    it('defaults to claude-code when not interactive and no IDE specified', () => {
+      // The non-interactive path should have a fallback
+      expect(installSource).toContain("selectedIDEs = ['claude-code']");
+    });
+
+    it('uses console.log for intro in non-interactive mode', () => {
+      expect(installSource).toContain("console.log('claude-mem install')");
+    });
+
+    it('uses console.log for note/summary in non-interactive mode', () => {
+      expect(installSource).toContain("console.log('\\n  Installation Complete')");
+    });
+  });
+
+  describe('TaskDescriptor interface', () => {
+    it('defines a task interface with title and task function', () => {
+      expect(installSource).toContain('interface TaskDescriptor');
+      expect(installSource).toContain('title: string');
+      expect(installSource).toContain('task: (message: (msg: string) => void) => Promise<string>');
+    });
+  });
+
+  describe('InstallOptions interface', () => {
+    it('exports InstallOptions with optional ide field', () => {
+      expect(installSource).toContain('export interface InstallOptions');
+      expect(installSource).toContain('ide?: string');
+    });
+  });
+});
diff --git a/tests/json-utils.test.ts b/tests/json-utils.test.ts
new file mode 100644
index 00000000..13de0ea4
--- /dev/null
+++ b/tests/json-utils.test.ts
@@ -0,0 +1,128 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdirSync, writeFileSync, existsSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { readJsonSafe } from '../src/utils/json-utils';
+
+/**
+ * Tests for the shared JSON file utilities.
+ *
+ * readJsonSafe is used across the CLI and services to safely read JSON
+ * files with fallback to defaults when files are missing or corrupt.
+ */
+
+describe('JSON Utils', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `json-utils-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('readJsonSafe', () => {
+    it('returns default value when file does not exist', () => {
+      const nonExistentPath = join(tempDir, 'does-not-exist.json');
+
+      const result = readJsonSafe(nonExistentPath, { fallback: true });
+
+      expect(result).toEqual({ fallback: true });
+    });
+
+    it('returns parsed content for valid JSON file', () => {
+      const filePath = join(tempDir, 'valid.json');
+      const data = { name: 'test', count: 42, nested: { key: 'value' } };
+      writeFileSync(filePath, JSON.stringify(data));
+
+      const result = readJsonSafe(filePath, {});
+
+      expect(result).toEqual(data);
+    });
+
+    it('returns default value for corrupt JSON file', () => {
+      const filePath = join(tempDir, 'corrupt.json');
+      writeFileSync(filePath, 'this is not valid json {{{');
+
+      const defaultValue = { recovered: true };
+      const result = readJsonSafe(filePath, defaultValue);
+
+      expect(result).toEqual(defaultValue);
+    });
+
+    it('returns default value for empty file', () => {
+      const filePath = join(tempDir, 'empty.json');
+      writeFileSync(filePath, '');
+
+      const result = readJsonSafe(filePath, []);
+
+      expect(result).toEqual([]);
+    });
+
+    it('works with array default values', () => {
+      const nonExistentPath = join(tempDir, 'missing.json');
+
+      const result = readJsonSafe<string[]>(nonExistentPath, ['a', 'b']);
+
+      expect(result).toEqual(['a', 'b']);
+    });
+
+    it('works with string default values', () => {
+      const nonExistentPath = join(tempDir, 'missing.json');
+
+      const result = readJsonSafe<string>(nonExistentPath, 'default');
+
+      expect(result).toBe('default');
+    });
+
+    it('works with number default values', () => {
+      const nonExistentPath = join(tempDir, 'missing.json');
+
+      const result = readJsonSafe<number>(nonExistentPath, 0);
+
+      expect(result).toBe(0);
+    });
+
+    it('reads JSON arrays correctly', () => {
+      const filePath = join(tempDir, 'array.json');
+      writeFileSync(filePath, JSON.stringify([1, 2, 3]));
+
+      const result = readJsonSafe<number[]>(filePath, []);
+
+      expect(result).toEqual([1, 2, 3]);
+    });
+
+    it('reads deeply nested JSON correctly', () => {
+      const filePath = join(tempDir, 'nested.json');
+      const deepData = {
+        level1: {
+          level2: {
+            level3: {
+              value: 'deep',
+            },
+          },
+        },
+      };
+      writeFileSync(filePath, JSON.stringify(deepData));
+
+      const result = readJsonSafe<typeof deepData>(filePath, { level1: { level2: { level3: { value: '' } } } });
+
+      expect(result.level1.level2.level3.value).toBe('deep');
+    });
+
+    it('handles JSON with trailing newline', () => {
+      const filePath = join(tempDir, 'trailing-newline.json');
+      writeFileSync(filePath, JSON.stringify({ ok: true }) + '\n');
+
+      const result = readJsonSafe(filePath, {});
+
+      expect(result).toEqual({ ok: true });
+    });
+  });
+});
diff --git a/tests/mcp-integrations.test.ts b/tests/mcp-integrations.test.ts
new file mode 100644
index 00000000..3cf906c5
--- /dev/null
+++ b/tests/mcp-integrations.test.ts
@@ -0,0 +1,305 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+/**
+ * Tests for the MCP integration factory utilities.
+ *
+ * Because McpIntegrations.ts uses `findMcpServerPath()` which checks specific
+ * filesystem paths, and the factory functions are not individually exported,
+ * we test the underlying helpers indirectly by exercising writeMcpJsonConfig
+ * and buildMcpServerEntry behavior through the readJsonSafe + JSON file writing
+ * patterns they use.
+ *
+ * We also verify the key behavioral contract: MCP entries use process.execPath.
+ */
+
+import { readJsonSafe } from '../src/utils/json-utils';
+import { injectContextIntoMarkdownFile, CONTEXT_TAG_OPEN, CONTEXT_TAG_CLOSE } from '../src/utils/context-injection';
+
+/**
+ * Reimplements the core logic of buildMcpServerEntry and writeMcpJsonConfig
+ * from McpIntegrations.ts for testability, since those functions are not exported.
+ * The tests verify the contract these functions must uphold.
+ */
+function buildMcpServerEntry(mcpServerPath: string): { command: string; args: string[] } {
+  return {
+    command: process.execPath,
+    args: [mcpServerPath],
+  };
+}
+
+function writeMcpJsonConfig(
+  configFilePath: string,
+  mcpServerPath: string,
+  serversKeyName: string = 'mcpServers',
+): void {
+  const parentDirectory = join(configFilePath, '..');
+  mkdirSync(parentDirectory, { recursive: true });
+
+  const existingConfig = readJsonSafe<Record<string, any>>(configFilePath, {});
+
+  if (!existingConfig[serversKeyName]) {
+    existingConfig[serversKeyName] = {};
+  }
+
+  existingConfig[serversKeyName]['claude-mem'] = buildMcpServerEntry(mcpServerPath);
+
+  writeFileSync(configFilePath, JSON.stringify(existingConfig, null, 2) + '\n');
+}
+
+describe('MCP Integrations', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `mcp-integrations-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('buildMcpServerEntry', () => {
+    it('uses process.execPath as the command, not "node"', () => {
+      const entry = buildMcpServerEntry('/path/to/mcp-server.cjs');
+
+      expect(entry.command).toBe(process.execPath);
+      expect(entry.command).not.toBe('node');
+    });
+
+    it('passes the mcp server path as the sole argument', () => {
+      const serverPath = '/usr/local/lib/mcp-server.cjs';
+      const entry = buildMcpServerEntry(serverPath);
+
+      expect(entry.args).toEqual([serverPath]);
+    });
+
+    it('handles paths with spaces', () => {
+      const serverPath = '/path/to/my project/mcp-server.cjs';
+      const entry = buildMcpServerEntry(serverPath);
+
+      expect(entry.args).toEqual([serverPath]);
+    });
+  });
+
+  describe('writeMcpJsonConfig', () => {
+    it('creates config file if it does not exist', () => {
+      const configPath = join(tempDir, '.config', 'ide', 'mcp.json');
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      expect(existsSync(configPath)).toBe(true);
+    });
+
+    it('creates parent directories if they do not exist', () => {
+      const configPath = join(tempDir, 'deep', 'nested', 'mcp.json');
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      expect(existsSync(join(tempDir, 'deep', 'nested'))).toBe(true);
+    });
+
+    it('writes valid JSON with claude-mem entry', () => {
+      const configPath = join(tempDir, 'mcp.json');
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      const content = readFileSync(configPath, 'utf-8');
+      const config = JSON.parse(content);
+      expect(config.mcpServers).toBeDefined();
+      expect(config.mcpServers['claude-mem']).toBeDefined();
+      expect(config.mcpServers['claude-mem'].command).toBe(process.execPath);
+      expect(config.mcpServers['claude-mem'].args).toEqual(['/path/to/mcp.cjs']);
+    });
+
+    it('uses custom serversKeyName when provided', () => {
+      const configPath = join(tempDir, 'mcp.json');
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs', 'servers');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(config.servers).toBeDefined();
+      expect(config.servers['claude-mem']).toBeDefined();
+      expect(config.mcpServers).toBeUndefined();
+    });
+
+    it('preserves existing servers when adding claude-mem', () => {
+      const configPath = join(tempDir, 'mcp.json');
+      const existingConfig = {
+        mcpServers: {
+          'other-tool': {
+            command: 'python',
+            args: ['/path/to/other.py'],
+          },
+        },
+      };
+      writeFileSync(configPath, JSON.stringify(existingConfig));
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(config.mcpServers['other-tool']).toBeDefined();
+      expect(config.mcpServers['other-tool'].command).toBe('python');
+      expect(config.mcpServers['claude-mem']).toBeDefined();
+    });
+
+    it('preserves non-server keys in existing config', () => {
+      const configPath = join(tempDir, 'mcp.json');
+      const existingConfig = {
+        version: 2,
+        settings: { theme: 'dark' },
+        mcpServers: {},
+      };
+      writeFileSync(configPath, JSON.stringify(existingConfig));
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(config.version).toBe(2);
+      expect(config.settings).toEqual({ theme: 'dark' });
+      expect(config.mcpServers['claude-mem']).toBeDefined();
+    });
+  });
+
+  describe('idempotency', () => {
+    it('running install twice does not create duplicate entries', () => {
+      const configPath = join(tempDir, 'mcp.json');
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      const serverKeys = Object.keys(config.mcpServers);
+      const claudeMemEntries = serverKeys.filter((k) => k === 'claude-mem');
+      expect(claudeMemEntries).toHaveLength(1);
+    });
+
+    it('updates the server path on re-install', () => {
+      const configPath = join(tempDir, 'mcp.json');
+
+      writeMcpJsonConfig(configPath, '/old/path/mcp.cjs');
+      writeMcpJsonConfig(configPath, '/new/path/mcp.cjs');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(config.mcpServers['claude-mem'].args).toEqual(['/new/path/mcp.cjs']);
+    });
+  });
+
+  describe('corrupt file recovery', () => {
+    it('replaces corrupt JSON with fresh config', () => {
+      const configPath = join(tempDir, 'mcp.json');
+      writeFileSync(configPath, 'not valid json {{{{');
+
+      // readJsonSafe returns default {} for corrupt file
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(config.mcpServers['claude-mem']).toBeDefined();
+    });
+
+    it('handles empty file gracefully', () => {
+      const configPath = join(tempDir, 'mcp.json');
+      writeFileSync(configPath, '');
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(config.mcpServers['claude-mem']).toBeDefined();
+    });
+
+    it('handles file with only whitespace', () => {
+      const configPath = join(tempDir, 'mcp.json');
+      writeFileSync(configPath, '   \n\n   ');
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(config.mcpServers['claude-mem']).toBeDefined();
+    });
+  });
+
+  describe('merge with existing config', () => {
+    it('preserves other servers in mcpServers key', () => {
+      const configPath = join(tempDir, 'mcp.json');
+      const existingConfig = {
+        mcpServers: {
+          'server-a': { command: 'ruby', args: ['/a.rb'] },
+          'server-b': { command: 'node', args: ['/b.js'] },
+        },
+      };
+      writeFileSync(configPath, JSON.stringify(existingConfig));
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(Object.keys(config.mcpServers)).toHaveLength(3);
+      expect(config.mcpServers['server-a'].command).toBe('ruby');
+      expect(config.mcpServers['server-b'].command).toBe('node');
+      expect(config.mcpServers['claude-mem'].command).toBe(process.execPath);
+    });
+
+    it('preserves other servers when using "servers" key', () => {
+      const configPath = join(tempDir, 'mcp.json');
+      const existingConfig = {
+        servers: {
+          'copilot-tool': { command: 'python', args: ['/tool.py'] },
+        },
+      };
+      writeFileSync(configPath, JSON.stringify(existingConfig));
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs', 'servers');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(config.servers['copilot-tool']).toBeDefined();
+      expect(config.servers['claude-mem']).toBeDefined();
+    });
+
+    it('handles config with mcpServers as empty object', () => {
+      const configPath = join(tempDir, 'mcp.json');
+      writeFileSync(configPath, JSON.stringify({ mcpServers: {} }));
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(config.mcpServers['claude-mem']).toBeDefined();
+    });
+
+    it('handles config without the servers key at all', () => {
+      const configPath = join(tempDir, 'mcp.json');
+      writeFileSync(configPath, JSON.stringify({ version: 1 }));
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(config.version).toBe(1);
+      expect(config.mcpServers['claude-mem']).toBeDefined();
+    });
+  });
+
+  describe('output format', () => {
+    it('writes pretty-printed JSON with 2-space indent', () => {
+      const configPath = join(tempDir, 'mcp.json');
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      const content = readFileSync(configPath, 'utf-8');
+      expect(content).toContain('\n');
+      expect(content).toContain('  "mcpServers"');
+    });
+
+    it('ends file with trailing newline', () => {
+      const configPath = join(tempDir, 'mcp.json');
+
+      writeMcpJsonConfig(configPath, '/path/to/mcp.cjs');
+
+      const content = readFileSync(configPath, 'utf-8');
+      expect(content.endsWith('\n')).toBe(true);
+    });
+  });
+});