ultraclaude-agent 0.0.14 → 0.0.16

package/__tests__/daemon-reconcile.test.ts

@@ -47,6 +47,13 @@ vi.mock('../src/config.js', () => ({
   getProjectAccount: (...args: unknown[]) => mockGetProjectAccount(...args),
   setProjectAccount: (...args: unknown[]) => mockSetProjectAccount(...args),
   getDefaultAccount: (...args: unknown[]) => mockGetDefaultAccount(...args),
+  resolveServerPaths: vi.fn().mockReturnValue({
+    accountsDir: '/tmp/accounts',
+    configFile: '/tmp/config.json',
+    statusFile: '/tmp/status.json',
+    logDir: '/tmp/logs',
+  }),
+  isDaemonRunning: vi.fn().mockReturnValue(false),
   paths: {
     claudeProjects: '/tmp/test-claude-projects',
     projectIdFile: '.claude/ultra/project-id',
@@ -202,7 +209,7 @@ describe('daemon — reconcileWatchers edge cases', () => {
     const { startDaemon, getDaemonStatus } = await import('../src/daemon.js');
     await startDaemon();
 
-    expect(getDaemonStatus().running).toBe(true);
+    expect((await getDaemonStatus()).running).toBe(true);
 
     // All accounts removed from disk
     mockLoadAllCredentials.mockResolvedValue(new Map());
@@ -217,7 +224,7 @@ describe('daemon — reconcileWatchers edge cases', () => {
     await addDirHandler();
 
     // Daemon should have stopped
-    expect(getDaemonStatus().running).toBe(false);
+    expect((await getDaemonStatus()).running).toBe(false);
   });
 
   it('logs warning for project with removed account', async () => {

package/__tests__/daemon.test.ts

@@ -23,10 +23,22 @@ const mockMigrateOldConfigDir = vi.fn().mockResolvedValue(false);
 const mockGetProjectAccount = vi.fn();
 const mockSetProjectAccount = vi.fn().mockResolvedValue(undefined);
 const mockGetDefaultAccount = vi.fn();
+const mockLoadServerConfig = vi.fn().mockResolvedValue({
+  defaultAccount: '',
+  autoAssignNewProjects: true,
+  projectAccounts: {},
+});
+const mockResolveServerPaths = vi.fn().mockReturnValue({
+  accountsDir: '/tmp/accounts',
+  configFile: '/tmp/config.json',
+  statusFile: '/tmp/status.json',
+  logDir: '/tmp/logs',
+});
 
 vi.mock('../src/config.js', () => ({
   loadCredentials: (...args: unknown[]) => mockLoadCredentials(...args),
   loadAllCredentials: (...args: unknown[]) => mockLoadAllCredentials(...args),
+  loadServerConfig: (...args: unknown[]) => mockLoadServerConfig(...args),
   getServerUrl: (creds: { serverUrl: string } | null) =>
     creds?.serverUrl ?? 'https://dashboard.ultra-claude.dev',
   loadRegistry: (...args: unknown[]) => mockLoadRegistry(...args),
@@ -38,6 +50,8 @@ vi.mock('../src/config.js', () => ({
   getProjectAccount: (...args: unknown[]) => mockGetProjectAccount(...args),
   setProjectAccount: (...args: unknown[]) => mockSetProjectAccount(...args),
   getDefaultAccount: (...args: unknown[]) => mockGetDefaultAccount(...args),
+  resolveServerPaths: (...args: unknown[]) => mockResolveServerPaths(...args),
+  isDaemonRunning: vi.fn().mockReturnValue(false),
   paths: {
     claudeProjects: '/tmp/test-claude-projects',
     projectIdFile: '.claude/ultra/project-id',
@@ -135,7 +149,7 @@ describe('daemon', () => {
     expect(result.success).toBe(true);
     expect(mockLoadAllCredentials).toHaveBeenCalledWith('http://localhost:3000');
 
-    const status = getDaemonStatus();
+    const status = await getDaemonStatus();
     expect(status.accounts).toHaveLength(2);
     expect(status.accounts).toEqual(
       expect.arrayContaining([
@@ -184,7 +198,7 @@ describe('daemon', () => {
     expect(callA![0].credentials.userId).toBe('user-1');
     expect(callB![0].credentials.userId).toBe('user-2');
 
-    const status = getDaemonStatus();
+    const status = await getDaemonStatus();
     expect(status.projects).toHaveLength(2);
 
     await stopDaemon();
@@ -330,7 +344,7 @@ describe('daemon', () => {
     const { startDaemon, getDaemonStatus, stopDaemon } = await import('../src/daemon.js');
     await startDaemon();
 
-    const status = getDaemonStatus();
+    const status = await getDaemonStatus();
     expect(status.running).toBe(true);
     expect(status.accounts).toHaveLength(2);
     expect(status.projects).toHaveLength(1);
@@ -338,7 +352,7 @@ describe('daemon', () => {
     expect(status.projects[0]!.accountEmail).toBe('alice@example.com');
 
     await stopDaemon();
-    const stopped = getDaemonStatus();
+    const stopped = await getDaemonStatus();
     expect(stopped.running).toBe(false);
     expect(stopped.accounts).toHaveLength(0);
   });
@@ -368,7 +382,7 @@ describe('daemon', () => {
     const { startDaemon, getDaemonStatus, stopDaemon } = await import('../src/daemon.js');
     await startDaemon();
 
-    expect(getDaemonStatus().projects).toHaveLength(1);
+    expect((await getDaemonStatus()).projects).toHaveLength(1);
 
     // Now user-2 account is removed — simulate reconcile trigger
     mockLoadAllCredentials.mockResolvedValue(new Map([['user-1', testCreds]]));
@@ -383,7 +397,7 @@ describe('daemon', () => {
 
     // Watcher for project-a should have been closed (account removed)
     expect(mockClose).toHaveBeenCalled();
-    expect(getDaemonStatus().projects).toHaveLength(0);
+    expect((await getDaemonStatus()).projects).toHaveLength(0);
 
     await stopDaemon();
   });

package/__tests__/push-version-metadata.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { join } from 'node:path';
+import { mkdtemp, writeFile, mkdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+
+// Mock fetch globally
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+// Mock config module
+vi.mock('../src/config.js', () => ({
+  loadCredentials: vi.fn().mockResolvedValue({
+    apiKey: 'test-api-key',
+    userId: 'test-user',
+    serverUrl: 'http://localhost:3000',
+  }),
+  getServerUrl: vi.fn().mockReturnValue('http://localhost:3000'),
+}));
+
+// Mock logger
+vi.mock('../src/logger.js', () => ({
+  logger: {
+    child: () => ({
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    }),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+
+const testCreds = { apiKey: 'test-api-key', userId: 'test-user', serverUrl: 'http://localhost:3000' };
+const testProjectId = 'test-project-id';
+
+describe('pushVersionMetadata', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    mockFetch.mockReset();
+    tempDir = await mkdtemp(join(tmpdir(), 'agent-version-test-'));
+    await mkdir(join(tempDir, '.claude', 'ultra'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('reads lastMigrated and lastMigratedSeq from version.json and sends PATCH request', async () => {
+    const { pushVersionMetadata } = await import('../src/sync.js');
+
+    const versionData = {
+      lastMigrated: '2026.04.04-24',
+      lastMigratedSeq: 24,
+    };
+    await writeFile(
+      join(tempDir, '.claude', 'ultra', 'version.json'),
+      JSON.stringify(versionData),
+    );
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: { id: testProjectId, ultraVersion: '2026.04.04-24', ultraVersionSeq: 24 } }),
+    });
+
+    await pushVersionMetadata(testProjectId, tempDir, testCreds);
+
+    const [url, options] = mockFetch.mock.calls[0]!;
+    expect(url).toContain(`/api/projects/${testProjectId}`);
+    expect(options.method).toBe('PATCH');
+    const body = JSON.parse(options.body);
+    expect(body.ultraVersion).toBe('2026.04.04-24');
+    expect(body.ultraVersionSeq).toBe(24);
+  });
+
+  it('does not call PATCH when version.json does not exist', async () => {
+    const { pushVersionMetadata } = await import('../src/sync.js');
+
+    // No version.json created
+    await pushVersionMetadata(testProjectId, tempDir, testCreds);
+
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('does not call PATCH when version.json has no version data', async () => {
+    const { pushVersionMetadata } = await import('../src/sync.js');
+
+    await writeFile(
+      join(tempDir, '.claude', 'ultra', 'version.json'),
+      JSON.stringify({ someOtherField: 'value' }),
+    );
+
+    await pushVersionMetadata(testProjectId, tempDir, testCreds);
+
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('logs warning but does not throw when PATCH request fails', async () => {
+    const { pushVersionMetadata } = await import('../src/sync.js');
+
+    const versionData = { lastMigrated: '2026.04.04-24', lastMigratedSeq: 24 };
+    await writeFile(
+      join(tempDir, '.claude', 'ultra', 'version.json'),
+      JSON.stringify(versionData),
+    );
+
+    mockFetch.mockRejectedValueOnce(new Error('Network error'));
+
+    // Should not throw — pushVersionMetadata is best-effort
+    await expect(
+      pushVersionMetadata(testProjectId, tempDir, testCreds),
+    ).resolves.not.toThrow();
+  });
+
+  it('handles server returning non-ok status without throwing', async () => {
+    const { pushVersionMetadata } = await import('../src/sync.js');
+
+    const versionData = { lastMigrated: '2026.04.04-24', lastMigratedSeq: 24 };
+    await writeFile(
+      join(tempDir, '.claude', 'ultra', 'version.json'),
+      JSON.stringify(versionData),
+    );
+
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+    });
+
+    await expect(
+      pushVersionMetadata(testProjectId, tempDir, testCreds),
+    ).resolves.not.toThrow();
+  });
+
+  it('sends only ultraVersion when lastMigratedSeq is absent from version.json', async () => {
+    const { pushVersionMetadata } = await import('../src/sync.js');
+
+    const versionData = { lastMigrated: '2026.04.04-24' }; // no lastMigratedSeq
+    await writeFile(
+      join(tempDir, '.claude', 'ultra', 'version.json'),
+      JSON.stringify(versionData),
+    );
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: {} }),
+    });
+
+    await pushVersionMetadata(testProjectId, tempDir, testCreds);
+
+    const body = JSON.parse(mockFetch.mock.calls[0]![1].body);
+    expect(body.ultraVersion).toBe('2026.04.04-24');
+    expect(body.ultraVersionSeq).toBeUndefined();
+  });
+
+  it('sends correct Authorization header', async () => {
+    const { pushVersionMetadata } = await import('../src/sync.js');
+
+    const versionData = { lastMigrated: '2026.04.04-24', lastMigratedSeq: 24 };
+    await writeFile(
+      join(tempDir, '.claude', 'ultra', 'version.json'),
+      JSON.stringify(versionData),
+    );
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: {} }),
+    });
+
+    await pushVersionMetadata(testProjectId, tempDir, testCreds);
+
+    const [, options] = mockFetch.mock.calls[0]!;
+    expect(options.headers['Authorization']).toBe('Bearer test-api-key');
+  });
+});

package/__tests__/repl-reset.test.ts

@@ -0,0 +1,296 @@
+/**
+ * Tests for REPL `reset` command.
+ * Task 2 success criteria:
+ *  - REPL `reset` prompts for confirmation before wiping
+ *  - REPL `reset` stops daemon, removes accounts/, removes config.json
+ *  - REPL `reset` with "no" answer does nothing
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Capture readline event handlers
+let lineHandler: ((line: string) => void) | null = null;
+let questionAnswer = 'no'; // Default answer for confirmation prompts
+
+const mockRl = {
+  prompt: vi.fn(),
+  pause: vi.fn(),
+  resume: vi.fn(),
+  close: vi.fn(),
+  question: vi.fn().mockImplementation((_prompt: string, callback: (answer: string) => void) => {
+    callback(questionAnswer);
+  }),
+  on: vi.fn().mockImplementation((event: string, handler: unknown) => {
+    if (event === 'line') lineHandler = handler as (line: string) => void;
+    return mockRl;
+  }),
+};
+
+vi.mock('node:readline', () => ({
+  createInterface: vi.fn(() => mockRl),
+}));
+
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs/promises')>();
+  return { ...actual, unlink: vi.fn().mockResolvedValue(undefined) };
+});
+
+// Config mocks
+const mockLoadAllCredentials = vi.fn();
+const mockLoadServerConfig = vi.fn();
+const mockSaveServerConfig = vi.fn().mockResolvedValue(undefined);
+const mockLoadRegistry = vi.fn();
+const mockGetServerUrl = vi.fn().mockReturnValue('http://localhost:3000');
+const mockGetProjectId = vi.fn();
+const mockLoadCredentials = vi.fn();
+const mockReadPid = vi.fn();
+const mockIsDaemonRunning = vi.fn();
+const mockResolveServerPaths = vi.fn();
+const mockClearServerConfig = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('../src/config.js', () => ({
+  loadAllCredentials: (...args: unknown[]) => mockLoadAllCredentials(...args),
+  loadServerConfig: (...args: unknown[]) => mockLoadServerConfig(...args),
+  saveServerConfig: (...args: unknown[]) => mockSaveServerConfig(...args),
+  loadRegistry: (...args: unknown[]) => mockLoadRegistry(...args),
+  getServerUrl: (...args: unknown[]) => mockGetServerUrl(...args),
+  getProjectId: (...args: unknown[]) => mockGetProjectId(...args),
+  loadCredentials: (...args: unknown[]) => mockLoadCredentials(...args),
+  readPid: (...args: unknown[]) => mockReadPid(...args),
+  isDaemonRunning: (...args: unknown[]) => mockIsDaemonRunning(...args),
+  resolveServerPaths: (...args: unknown[]) => mockResolveServerPaths(...args),
+  clearServerConfig: (...args: unknown[]) => mockClearServerConfig(...args),
+  paths: {
+    claudeProjects: '/tmp/test-claude-projects',
+    projectIdFile: '.claude/ultra/project-id',
+    oldConfigDir: '/tmp/test-old-config',
+  },
+}));
+
+vi.mock('../src/auth.js', () => ({
+  login: vi.fn(),
+}));
+
+const mockStartDaemon = vi.fn();
+const mockStopDaemon = vi.fn().mockResolvedValue(undefined);
+const mockGetDaemonStatus = vi.fn();
+const mockForkDaemon = vi.fn();
+const mockIsRunningInProcess = vi.fn().mockReturnValue(false);
+
+vi.mock('../src/daemon.js', () => ({
+  startDaemon: (...args: unknown[]) => mockStartDaemon(...args),
+  stopDaemon: (...args: unknown[]) => mockStopDaemon(...args),
+  getDaemonStatus: (...args: unknown[]) => mockGetDaemonStatus(...args),
+  forkDaemon: (...args: unknown[]) => mockForkDaemon(...args),
+  isRunningInProcess: (...args: unknown[]) => mockIsRunningInProcess(...args),
+}));
+
+vi.mock('../src/service.js', () => ({
+  isServiceInstalled: vi.fn().mockResolvedValue(false),
+}));
+
+vi.mock('../src/sync.js', () => ({
+  initialSync: vi.fn().mockResolvedValue(undefined),
+  createSnapshot: vi.fn().mockResolvedValue(true),
+}));
+
+vi.mock('../src/logger.js', () => ({
+  logger: {
+    child: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }),
+    info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn(), fatal: vi.fn(),
+  },
+}));
+
+const SERVER_URL = 'http://localhost:3000';
+const alice = { apiKey: 'key-alice', userId: 'user-alice', serverUrl: SERVER_URL, email: 'alice@example.com' };
+
+function defaultConfig(overrides = {}) {
+  return { defaultAccount: 'user-alice', projectAccounts: {}, ...overrides };
+}
+
+function defaultRegistry() {
+  return { projects: [{ path: '/home/user/projects/my-app', name: 'my-app' }] };
+}
+
+/** Run a REPL command and wait for the async handler to finish (rl.resume called in .finally). */
+async function runCommand(cmd: string): Promise<void> {
+  return new Promise<void>((resolve) => {
+    mockRl.resume.mockImplementationOnce(() => resolve());
+    lineHandler!(cmd);
+  });
+}
+
+/** Run reset and wait — it calls rl.close() on success, so resume may not be called; handle both. */
+async function runResetCommand(): Promise<void> {
+  return new Promise<void>((resolve) => {
+    // Either rl.resume (cancelled path) or rl.close (success path) signals completion
+    mockRl.resume.mockImplementationOnce(() => resolve());
+    mockRl.close.mockImplementationOnce(() => resolve());
+    lineHandler!('reset');
+  });
+}
+
+describe('repl — reset command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    lineHandler = null;
+    questionAnswer = 'no';
+    mockGetServerUrl.mockReturnValue(SERVER_URL);
+    mockResolveServerPaths.mockReturnValue({
+      accountsDir: '/tmp/accounts',
+      configFile: '/tmp/config.json',
+      logDir: '/tmp/logs',
+    });
+    mockLoadAllCredentials.mockResolvedValue(new Map([['user-alice', alice]]));
+    mockLoadServerConfig.mockResolvedValue(defaultConfig());
+    mockLoadRegistry.mockResolvedValue(defaultRegistry());
+    mockGetDaemonStatus.mockResolvedValue({ running: false, pid: null, startedAt: null, projects: [] });
+    mockIsRunningInProcess.mockReturnValue(false);
+    mockReadPid.mockResolvedValue(null);
+    // Re-apply question mock after clearAllMocks (implementation is kept, just clear calls)
+    mockRl.question.mockImplementation((_prompt: string, callback: (answer: string) => void) => {
+      callback(questionAnswer);
+    });
+    mockRl.on.mockImplementation((event: string, handler: unknown) => {
+      if (event === 'line') lineHandler = handler as (line: string) => void;
+      return mockRl;
+    });
+  });
+
+  it('reset — prompts for confirmation before wiping', async () => {
+    questionAnswer = 'no'; // Will cancel
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      vi.resetModules();
+      const { startRepl } = await import('../src/repl.js');
+      await startRepl(SERVER_URL);
+
+      await runCommand('reset');
+
+      // Must have called question() with a prompt about confirmation
+      expect(mockRl.question).toHaveBeenCalledWith(
+        expect.stringMatching(/are you sure/i),
+        expect.any(Function),
+      );
+    } finally {
+      consoleSpy.mockRestore();
+    }
+  });
+
+  it('reset — with "no" answer does nothing (no config cleared, no daemon stopped)', async () => {
+    questionAnswer = 'no';
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      vi.resetModules();
+      const { startRepl } = await import('../src/repl.js');
+      await startRepl(SERVER_URL);
+
+      await runCommand('reset');
+
+      // clearServerConfig must NOT have been called
+      expect(mockClearServerConfig).not.toHaveBeenCalled();
+      // stopDaemon must NOT have been called
+      expect(mockStopDaemon).not.toHaveBeenCalled();
+    } finally {
+      consoleSpy.mockRestore();
+    }
+  });
+
+  it('reset — "no" answer prints cancellation message', async () => {
+    questionAnswer = 'no';
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      vi.resetModules();
+      const { startRepl } = await import('../src/repl.js');
+      await startRepl(SERVER_URL);
+
+      await runCommand('reset');
+
+      const output = consoleSpy.mock.calls.flat().join('\n');
+      expect(output).toMatch(/cancel|no/i);
+    } finally {
+      consoleSpy.mockRestore();
+    }
+  });
+
+  it('reset — with "yes" answer calls clearServerConfig', async () => {
+    questionAnswer = 'yes';
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      vi.resetModules();
+      const { startRepl } = await import('../src/repl.js');
+      await startRepl(SERVER_URL);
+
+      await runResetCommand();
+
+      // clearServerConfig must be called with the server URL
+      expect(mockClearServerConfig).toHaveBeenCalledWith(SERVER_URL);
+    } finally {
+      consoleSpy.mockRestore();
+    }
+  });
+
+  it('reset — with "yes" answer stops external daemon if running', async () => {
+    questionAnswer = 'yes';
+    mockIsRunningInProcess.mockReturnValue(false);
+    mockReadPid.mockResolvedValue(12345);
+    mockIsDaemonRunning.mockReturnValue(true);
+
+    const killSpy = vi.spyOn(process, 'kill').mockImplementation(() => true);
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      vi.resetModules();
+      const { startRepl } = await import('../src/repl.js');
+      await startRepl(SERVER_URL);
+
+      await runResetCommand();
+
+      // Should send SIGTERM to the daemon PID
+      expect(killSpy).toHaveBeenCalledWith(12345, 'SIGTERM');
+      // Still wipes config
+      expect(mockClearServerConfig).toHaveBeenCalledWith(SERVER_URL);
+    } finally {
+      killSpy.mockRestore();
+      consoleSpy.mockRestore();
+    }
+  });
+
+  it('reset — with "yes" answer stops in-process daemon', async () => {
+    questionAnswer = 'yes';
+    mockIsRunningInProcess.mockReturnValue(true);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      vi.resetModules();
+      const { startRepl } = await import('../src/repl.js');
+      await startRepl(SERVER_URL);
+
+      await runResetCommand();
+
+      expect(mockStopDaemon).toHaveBeenCalled();
+      expect(mockClearServerConfig).toHaveBeenCalledWith(SERVER_URL);
+    } finally {
+      consoleSpy.mockRestore();
+    }
+  });
+
+  it('help — lists reset command', async () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      vi.resetModules();
+      const { startRepl } = await import('../src/repl.js');
+      await startRepl(SERVER_URL);
+
+      await runCommand('help');
+      const output = consoleSpy.mock.calls.flat().join('\n');
+
+      expect(output).toMatch(/reset/i);
+    } finally {
+      consoleSpy.mockRestore();
+    }
+  });
+});

package/__tests__/repl-status-account.test.ts

@@ -64,6 +64,8 @@ vi.mock('../src/daemon.js', () => ({
   startDaemon: vi.fn(),
   stopDaemon: vi.fn().mockResolvedValue(undefined),
   getDaemonStatus: (...args: unknown[]) => mockGetDaemonStatus(...args),
+  forkDaemon: vi.fn(),
+  isRunningInProcess: vi.fn().mockReturnValue(false),
 }));
 
 vi.mock('../src/service.js', () => ({ isServiceInstalled: vi.fn().mockResolvedValue(false) }));

package/__tests__/repl.test.ts

@@ -67,10 +67,14 @@ vi.mock('../src/auth.js', () => ({
 const mockStartDaemon = vi.fn();
 const mockStopDaemon = vi.fn().mockResolvedValue(undefined);
 const mockGetDaemonStatus = vi.fn();
+const mockForkDaemon = vi.fn();
+const mockIsRunningInProcess = vi.fn().mockReturnValue(false);
 vi.mock('../src/daemon.js', () => ({
   startDaemon: (...args: unknown[]) => mockStartDaemon(...args),
   stopDaemon: (...args: unknown[]) => mockStopDaemon(...args),
   getDaemonStatus: (...args: unknown[]) => mockGetDaemonStatus(...args),
+  forkDaemon: (...args: unknown[]) => mockForkDaemon(...args),
+  isRunningInProcess: (...args: unknown[]) => mockIsRunningInProcess(...args),
 }));
 
 // Mock service
@@ -658,8 +662,9 @@ describe('repl — start/stop/status/push/snapshot commands', () => {
     mockLoadRegistry.mockResolvedValue(defaultRegistry());
   });
 
-  it('start — calls startDaemon() and prints success', async () => {
-    mockStartDaemon.mockResolvedValue({ success: true });
+  it('start — calls forkDaemon() and prints success', async () => {
+    mockGetDaemonStatus.mockResolvedValue({ running: false, pid: null });
+    mockForkDaemon.mockReturnValue({ pid: 12345 });
 
     vi.resetModules();
     const { startRepl } = await import('../src/repl.js');
@@ -668,7 +673,7 @@ describe('repl — start/stop/status/push/snapshot commands', () => {
     try {
       await startRepl(SERVER_URL);
       await runCommand('start');
-      expect(mockStartDaemon).toHaveBeenCalled();
+      expect(mockForkDaemon).toHaveBeenCalled();
       const output = consoleSpy.mock.calls.flat().join('\n');
       expect(output).toMatch(/daemon started/i);
     } finally {
@@ -676,8 +681,8 @@ describe('repl — start/stop/status/push/snapshot commands', () => {
     }
   });
 
-  it('start — prints failure message when startDaemon fails', async () => {
-    mockStartDaemon.mockResolvedValue({ success: false, message: 'already running', error: 'ALREADY_RUNNING' });
+  it('start — prints failure message when already running', async () => {
+    mockGetDaemonStatus.mockResolvedValue({ running: true, pid: 99999 });
 
     vi.resetModules();
     const { startRepl } = await import('../src/repl.js');
@@ -687,16 +692,15 @@ describe('repl — start/stop/status/push/snapshot commands', () => {
       await startRepl(SERVER_URL);
       await runCommand('start');
       const output = consoleSpy.mock.calls.flat().join('\n');
-      expect(output).toMatch(/could not start|already running/i);
+      expect(output).toMatch(/already running/i);
     } finally {
       consoleSpy.mockRestore();
     }
   });
 
   it('stop — sends SIGTERM to external daemon process', async () => {
-    mockGetDaemonStatus.mockReturnValue({ running: false });
-    mockReadPid.mockResolvedValue(12345);
-    mockIsDaemonRunning.mockReturnValue(true);
+    mockIsRunningInProcess.mockReturnValue(false);
+    mockGetDaemonStatus.mockResolvedValue({ running: true, pid: 12345 });
 
     const killSpy = vi.spyOn(process, 'kill').mockImplementation(() => true);
 
@@ -715,7 +719,7 @@ describe('repl — start/stop/status/push/snapshot commands', () => {
   });
 
   it('stop — stops in-process daemon directly', async () => {
-    mockGetDaemonStatus.mockReturnValue({ running: true });
+    mockIsRunningInProcess.mockReturnValue(true);
     mockStopDaemon.mockResolvedValue(undefined);
 
     vi.resetModules();