@piecemaker-legal/piecemaker 1.0.0

package/server/modules/websocket/tests/chat-run-registry.test.ts

@@ -0,0 +1,313 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import { chatRunRegistry } from '@/modules/websocket/services/chat-run-registry.service.js';
+import { connectedClients } from '@/modules/websocket/services/websocket-state.service.js';
+
+/**
+ * Minimal stand-in for a websocket connection: collects every JSON frame the
+ * gateway writer forwards so assertions can inspect the outbound protocol.
+ */
+class FakeConnection {
+  readyState = 1; // WS_OPEN_STATE
+  frames: Array<Record<string, unknown>> = [];
+
+  send(data: string): void {
+    this.frames.push(JSON.parse(data) as Record<string, unknown>);
+  }
+}
+
+async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'chat-run-registry-'));
+  const databasePath = path.join(tempDirectory, 'auth.db');
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  await initializeDatabase();
+
+  try {
+    await runTest();
+  } finally {
+    connectedClients.clear();
+    chatRunRegistry.clearAll();
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+test('live events are remapped to the app session id and sequenced', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-1', 'claude', '/workspace/demo');
+    const connection = new FakeConnection();
+    const run = chatRunRegistry.startRun({
+      appSessionId: 'app-run-1',
+      provider: 'claude',
+      providerSessionId: null,
+      connection,
+      userId: 'user-1',
+    });
+    assert.ok(run);
+
+    run.writer.send({ kind: 'stream_delta', provider: 'claude', sessionId: 'provider-id-9', content: 'hello' });
+    run.writer.send({ kind: 'text', provider: 'claude', sessionId: 'provider-id-9', content: 'hello world' });
+
+    assert.equal(connection.frames.length, 2);
+    assert.equal(connection.frames[0]?.sessionId, 'app-run-1');
+    assert.equal(connection.frames[0]?.seq, 1);
+    assert.equal(connection.frames[1]?.sessionId, 'app-run-1');
+    assert.equal(connection.frames[1]?.seq, 2);
+  });
+});
+
+test('session_created is swallowed and persisted as the provider-id mapping', async () => {
+  await withIsolatedDatabase(async () => {
+    sessionsDb.createAppSession('app-run-2', 'cursor', '/workspace/demo');
+    const connection = new FakeConnection();
+    connectedClients.add(connection as never);
+    const run = chatRunRegistry.startRun({
+      appSessionId: 'app-run-2',
+      provider: 'cursor',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(run);
+
+    run.writer.send({
+      kind: 'session_created',
+      provider: 'cursor',
+      sessionId: 'cursor-native-7',
+      newSessionId: 'cursor-native-7',
+    });
+
+    // The upsert is broadcast without blocking the run: resolving the owning
+    // project's display name is async, so let that settle before asserting.
+    await new Promise((resolve) => { setTimeout(resolve, 0); });
+
+    // The provider-native event itself is never forwarded...
+    const sessionUpserts = connection.frames.filter((frame) => frame.kind === 'session_upserted');
+    assert.equal(sessionUpserts.length, 1);
+    assert.equal(sessionUpserts[0]?.sessionId, 'app-run-2');
+    assert.equal(sessionUpserts[0]?.providerSessionId, 'cursor-native-7');
+    // ...but the canonical mapping is recorded and persisted in the database.
+    assert.equal(run.providerSessionId, 'cursor-native-7');
+    assert.equal(sessionsDb.getSessionById('app-run-2')?.provider_session_id, 'cursor-native-7');
+  });
+});
+
+test('complete marks the run finished and duplicate completes are dropped', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-3', 'codex', '/workspace/demo');
+    const connection = new FakeConnection();
+    const run = chatRunRegistry.startRun({
+      appSessionId: 'app-run-3',
+      provider: 'codex',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(run);
+
+    run.writer.send({ kind: 'complete', provider: 'codex', sessionId: 'native-3', exitCode: 0 });
+    // Late duplicate from a killed runtime's exit handler.
+    run.writer.send({ kind: 'complete', provider: 'codex', sessionId: 'native-3', exitCode: 1 });
+
+    const completes = connection.frames.filter((frame) => frame.kind === 'complete');
+    assert.equal(completes.length, 1);
+    assert.equal(completes[0]?.actualSessionId, 'app-run-3');
+    assert.equal(chatRunRegistry.isProcessing('app-run-3'), false);
+
+    // completeRun is also a no-op once the run already completed.
+    chatRunRegistry.completeRun('app-run-3', { exitCode: 1 });
+    assert.equal(connection.frames.filter((frame) => frame.kind === 'complete').length, 1);
+  });
+});
+
+test('a finished run\'s safety net cannot complete the session\'s next run', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-9', 'codex', '/workspace/demo');
+    const connection = new FakeConnection();
+
+    const firstRun = chatRunRegistry.startRun({
+      appSessionId: 'app-run-9',
+      provider: 'codex',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(firstRun);
+    firstRun.writer.send({ kind: 'complete', provider: 'codex', sessionId: 'native-9', exitCode: 0 });
+
+    // A queued message starts the next run before the first run's runtime
+    // promise settles (the chat handler's `finally` hasn't executed yet).
+    const secondRun = chatRunRegistry.startRun({
+      appSessionId: 'app-run-9',
+      provider: 'codex',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(secondRun);
+
+    // First run's safety net fires late: it must not touch the new run.
+    chatRunRegistry.completeRunIfCurrent(firstRun, { exitCode: 1 });
+    assert.equal(chatRunRegistry.isProcessing('app-run-9'), true);
+    assert.equal(connection.frames.filter((frame) => frame.kind === 'complete').length, 1);
+
+    // The second run's own safety net still works while it is current.
+    chatRunRegistry.completeRunIfCurrent(secondRun, { exitCode: 1 });
+    assert.equal(chatRunRegistry.isProcessing('app-run-9'), false);
+    assert.equal(connection.frames.filter((frame) => frame.kind === 'complete').length, 2);
+  });
+});
+
+test('listRunningRuns returns only currently running app sessions', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-7', 'claude', '/workspace/demo');
+    sessionsDb.createAppSession('app-run-8', 'codex', '/workspace/demo');
+    const connection = new FakeConnection();
+
+    const completedRun = chatRunRegistry.startRun({
+      appSessionId: 'app-run-7',
+      provider: 'claude',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(completedRun);
+
+    const runningRun = chatRunRegistry.startRun({
+      appSessionId: 'app-run-8',
+      provider: 'codex',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(runningRun);
+
+    chatRunRegistry.completeRun('app-run-7', { exitCode: 0 });
+
+    const runningSessions = chatRunRegistry.listRunningRuns();
+    assert.deepEqual(runningSessions.map((session) => session.sessionId), ['app-run-8']);
+    assert.equal(runningSessions[0]?.provider, 'codex');
+  });
+});
+
+test('replayEvents returns only events after the requested seq', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-4', 'claude', '/workspace/demo');
+    const connection = new FakeConnection();
+    const run = chatRunRegistry.startRun({
+      appSessionId: 'app-run-4',
+      provider: 'claude',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(run);
+
+    run.writer.send({ kind: 'stream_delta', provider: 'claude', sessionId: 'x', content: 'a' });
+    run.writer.send({ kind: 'stream_delta', provider: 'claude', sessionId: 'x', content: 'b' });
+    run.writer.send({ kind: 'stream_delta', provider: 'claude', sessionId: 'x', content: 'c' });
+
+    const replayed = chatRunRegistry.replayEvents('app-run-4', 1);
+    assert.deepEqual(replayed.map((event) => event.content), ['b', 'c']);
+    assert.deepEqual(replayed.map((event) => event.seq), [2, 3]);
+  });
+});
+
+test('attachConnection adds a socket without cutting off the ones already watching', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-5', 'opencode', '/workspace/demo');
+    const firstConnection = new FakeConnection();
+    const run = chatRunRegistry.startRun({
+      appSessionId: 'app-run-5',
+      provider: 'opencode',
+      providerSessionId: null,
+      connection: firstConnection,
+      userId: null,
+    });
+    assert.ok(run);
+
+    run.writer.send({ kind: 'stream_delta', provider: 'opencode', sessionId: 'o', content: 'before' });
+
+    // A second tab on the same session subscribes mid-run.
+    const secondConnection = new FakeConnection();
+    assert.equal(chatRunRegistry.attachConnection('app-run-5', secondConnection), true);
+    run.writer.send({ kind: 'stream_delta', provider: 'opencode', sessionId: 'o', content: 'after' });
+
+    assert.deepEqual(firstConnection.frames.map((frame) => frame.content), ['before', 'after']);
+    assert.deepEqual(secondConnection.frames.map((frame) => frame.content), ['after']);
+  });
+});
+
+test('a refreshed tab stops receiving once its old socket is closed', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-5b', 'opencode', '/workspace/demo');
+    const staleConnection = new FakeConnection();
+    const run = chatRunRegistry.startRun({
+      appSessionId: 'app-run-5b',
+      provider: 'opencode',
+      providerSessionId: null,
+      connection: staleConnection,
+      userId: null,
+    });
+    assert.ok(run);
+
+    // The page reloads: the original socket closes and the fresh one subscribes.
+    staleConnection.readyState = 3;
+    const reloadedConnection = new FakeConnection();
+    assert.equal(chatRunRegistry.attachConnection('app-run-5b', reloadedConnection), true);
+
+    run.writer.send({ kind: 'stream_delta', provider: 'opencode', sessionId: 'o', content: 'after' });
+    run.writer.send({ kind: 'stream_delta', provider: 'opencode', sessionId: 'o', content: 'later' });
+
+    assert.deepEqual(staleConnection.frames, []);
+    assert.deepEqual(reloadedConnection.frames.map((frame) => frame.content), ['after', 'later']);
+  });
+});
+
+test('startRun rejects a second concurrent run for the same session', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-6', 'opencode', '/workspace/demo');
+    const connection = new FakeConnection();
+    const first = chatRunRegistry.startRun({
+      appSessionId: 'app-run-6',
+      provider: 'opencode',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(first);
+
+    const second = chatRunRegistry.startRun({
+      appSessionId: 'app-run-6',
+      provider: 'opencode',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.equal(second, null);
+
+    // After the run finishes a new one is allowed again.
+    chatRunRegistry.completeRun('app-run-6', { exitCode: 0 });
+    const third = chatRunRegistry.startRun({
+      appSessionId: 'app-run-6',
+      provider: 'opencode',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(third);
+  });
+});

package/server/modules/websocket/tests/session-upsert-broadcast.test.ts

@@ -0,0 +1,138 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import {
+  broadcastSessionUpserted,
+  broadcastSessionUpsertedBatch,
+} from '@/modules/websocket/services/session-upsert-broadcast.service.js';
+import { connectedClients } from '@/modules/websocket/services/websocket-state.service.js';
+
+class FakeConnection {
+  readyState = 1; // WS_OPEN_STATE
+  frames: Array<Record<string, unknown>> = [];
+
+  send(data: string): void {
+    this.frames.push(JSON.parse(data) as Record<string, unknown>);
+  }
+}
+
+async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'session-upsert-broadcast-'));
+
+  closeConnection();
+  process.env.DATABASE_PATH = path.join(tempDirectory, 'auth.db');
+  await initializeDatabase();
+
+  try {
+    await runTest();
+  } finally {
+    connectedClients.clear();
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+test('an upsert always carries the provider session id', async () => {
+  await withIsolatedDatabase(async () => {
+    sessionsDb.createAppSession('app-1', 'opencode', '/workspace/demo');
+    sessionsDb.assignProviderSessionId('app-1', 'native-1');
+
+    const connection = new FakeConnection();
+    connectedClients.add(connection as never);
+
+    await broadcastSessionUpserted('app-1');
+
+    assert.equal(connection.frames.length, 1);
+    assert.equal(connection.frames[0].kind, 'session_upserted');
+    assert.equal(connection.frames[0].sessionId, 'app-1');
+    assert.equal(connection.frames[0].providerSessionId, 'native-1');
+  });
+});
+
+test('the watcher path resolves a provider-native id to the same canonical event', async () => {
+  await withIsolatedDatabase(async () => {
+    sessionsDb.createAppSession('app-2', 'opencode', '/workspace/demo');
+    sessionsDb.assignProviderSessionId('app-2', 'native-2');
+
+    const connection = new FakeConnection();
+    connectedClients.add(connection as never);
+
+    // The sessions watcher only ever knows the id written in the transcript.
+    await broadcastSessionUpsertedBatch(['native-2']);
+
+    assert.equal(connection.frames.length, 1);
+    assert.equal(connection.frames[0].sessionId, 'app-2');
+    assert.equal(connection.frames[0].providerSessionId, 'native-2');
+  });
+});
+
+test('a session with no provider id yet reports null rather than omitting the field', async () => {
+  await withIsolatedDatabase(async () => {
+    sessionsDb.createAppSession('app-3', 'claude', '/workspace/demo');
+
+    const connection = new FakeConnection();
+    connectedClients.add(connection as never);
+
+    await broadcastSessionUpserted('app-3');
+
+    assert.equal(connection.frames.length, 1);
+    assert.ok('providerSessionId' in connection.frames[0]);
+    assert.equal(connection.frames[0].providerSessionId, null);
+  });
+});
+
+test('an unresolvable id broadcasts nothing', async () => {
+  await withIsolatedDatabase(async () => {
+    const connection = new FakeConnection();
+    connectedClients.add(connection as never);
+
+    await broadcastSessionUpserted('does-not-exist');
+    await broadcastSessionUpsertedBatch(['also-missing']);
+
+    assert.deepEqual(connection.frames, []);
+  });
+});
+
+test('a batch delivers every resolvable session and skips the rest', async () => {
+  await withIsolatedDatabase(async () => {
+    sessionsDb.createAppSession('app-4', 'claude', '/workspace/demo');
+    sessionsDb.createAppSession('app-5', 'claude', '/workspace/demo');
+
+    const connection = new FakeConnection();
+    connectedClients.add(connection as never);
+
+    await broadcastSessionUpsertedBatch(['app-4', 'missing', 'app-5']);
+
+    assert.deepEqual(
+      connection.frames.map((frame) => frame.sessionId),
+      ['app-4', 'app-5'],
+    );
+  });
+});
+
+test('a closed socket is skipped', async () => {
+  await withIsolatedDatabase(async () => {
+    sessionsDb.createAppSession('app-6', 'claude', '/workspace/demo');
+
+    const open = new FakeConnection();
+    const closing = new FakeConnection();
+    closing.readyState = 3;
+    connectedClients.add(open as never);
+    connectedClients.add(closing as never);
+
+    await broadcastSessionUpserted('app-6');
+
+    assert.equal(open.frames.length, 1);
+    assert.deepEqual(closing.frames, []);
+  });
+});

package/server/modules/websocket/tests/shell-websocket.service.test.ts

@@ -0,0 +1,227 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { WebSocket } from 'ws';
+
+import { handleShellConnection } from '@/modules/websocket/services/shell-websocket.service.js';
+
+function createFakeSocket() {
+  const socket = new EventEmitter() as EventEmitter & {
+    readyState: number;
+    frames: string[];
+    send: (data: string) => void;
+  };
+  socket.readyState = WebSocket.OPEN;
+  socket.frames = [];
+  socket.send = (data: string) => socket.frames.push(data);
+  return socket;
+}
+
+function createFakePty() {
+  let dataListener: ((data: string) => void) | null = null;
+  let exitListener: ((event: { exitCode: number; signal?: number }) => void) | null = null;
+
+  return {
+    killed: false,
+    onData(listener: (data: string) => void) {
+      dataListener = listener;
+      return { dispose: () => undefined };
+    },
+    onExit(listener: (event: { exitCode: number; signal?: number }) => void) {
+      exitListener = listener;
+      return { dispose: () => undefined };
+    },
+    emitData(data: string) {
+      dataListener?.(data);
+    },
+    emitExit() {
+      exitListener?.({ exitCode: 0 });
+    },
+    write() {},
+    resize() {},
+    kill() {
+      this.killed = true;
+    },
+  };
+}
+
+test('a stale socket close cannot detach the socket that replaced it', () => {
+  const pty = createFakePty();
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    spawnPty: () => pty as never,
+  };
+  const initMessage = JSON.stringify({
+    type: 'init',
+    projectPath: process.cwd(),
+    sessionId: `stale-close-${Date.now()}`,
+    hasSession: false,
+    provider: 'plain-shell',
+    isPlainShell: true,
+    initialCommand: 'test-command',
+  });
+
+  const firstSocket = createFakeSocket();
+  handleShellConnection(firstSocket as never, dependencies);
+  firstSocket.emit('message', initMessage);
+
+  const replacementSocket = createFakeSocket();
+  handleShellConnection(replacementSocket as never, dependencies);
+  replacementSocket.emit('message', initMessage);
+  replacementSocket.frames.length = 0;
+
+  // This ordering reproduces a delayed close from a backgrounded mobile tab.
+  firstSocket.emit('close');
+  pty.emitData('output-after-stale-close');
+
+  assert.equal(pty.killed, false);
+  assert.equal(replacementSocket.frames.length, 1);
+  assert.match(replacementSocket.frames[0], /output-after-stale-close/);
+
+  pty.emitExit();
+});
+
+test('shell output detects and normalizes a wrapped authentication URL', () => {
+  const pty = createFakePty();
+  const socket = createFakeSocket();
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    spawnPty: () => pty as never,
+  };
+
+  handleShellConnection(socket as never, dependencies);
+  socket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `wrapped-url-${Date.now()}`,
+      hasSession: false,
+      provider: 'plain-shell',
+      isPlainShell: true,
+      initialCommand: 'test-command',
+    })
+  );
+  socket.frames.length = 0;
+
+  pty.emitData("Continue in your browser: https://example.com/authorize?\ncode=abc\x1b[0m");
+
+  const frames = socket.frames.map((frame) => JSON.parse(frame) as Record<string, unknown>);
+  const authenticationFrame = frames.find((frame) => frame.type === 'auth_url');
+  assert.deepEqual(authenticationFrame, {
+    type: 'auth_url',
+    url: 'https://example.com/authorize?code=abc',
+    autoOpen: false,
+  });
+
+  pty.emitExit();
+});
+
+test('bypassPermissions launches claude with --dangerously-skip-permissions', () => {
+  const spawnedCommands: string[] = [];
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    spawnPty: (_shell: string, args: string | string[]) => {
+      spawnedCommands.push(Array.isArray(args) ? args[args.length - 1] : args);
+      return createFakePty() as never;
+    },
+  };
+
+  const bypassSocket = createFakeSocket();
+  handleShellConnection(bypassSocket as never, dependencies);
+  bypassSocket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `bypass-on-${Date.now()}`,
+      hasSession: false,
+      provider: 'claude',
+      bypassPermissions: true,
+    })
+  );
+
+  const defaultSocket = createFakeSocket();
+  handleShellConnection(defaultSocket as never, dependencies);
+  defaultSocket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `bypass-off-${Date.now()}`,
+      hasSession: false,
+      provider: 'claude',
+    })
+  );
+
+  assert.deepEqual(spawnedCommands, ['claude --dangerously-skip-permissions', 'claude']);
+});
+
+test('bypassPermissions carries through to resumed claude sessions', () => {
+  const spawnedCommands: string[] = [];
+  const dependencies = {
+    resolveProviderSessionId: () => 'resumed-session-id',
+    spawnPty: (_shell: string, args: string | string[]) => {
+      spawnedCommands.push(Array.isArray(args) ? args[args.length - 1] : args);
+      return createFakePty() as never;
+    },
+  };
+
+  const socket = createFakeSocket();
+  handleShellConnection(socket as never, dependencies);
+  socket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `bypass-resume-${Date.now()}`,
+      hasSession: true,
+      provider: 'claude',
+      bypassPermissions: true,
+    })
+  );
+
+  assert.equal(spawnedCommands.length, 1);
+  if (os.platform() !== 'win32') {
+    assert.equal(
+      spawnedCommands[0],
+      'claude --resume "resumed-session-id" --dangerously-skip-permissions || claude --dangerously-skip-permissions'
+    );
+  }
+});
+
+test('a missing project directory is reported as an error frame and starts no pty', () => {
+  const socket = createFakeSocket();
+  let spawnCount = 0;
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    spawnPty: () => {
+      spawnCount += 1;
+      return createFakePty() as never;
+    },
+  };
+
+  handleShellConnection(socket as never, dependencies);
+  socket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      // A project row survives its directory being deleted or unmounted, so
+      // this is what the Shell tab sends for a stale sidebar entry.
+      projectPath: path.join(os.tmpdir(), `shell-missing-${Date.now()}`),
+      sessionId: `missing-path-${Date.now()}`,
+      hasSession: false,
+      provider: 'plain-shell',
+      isPlainShell: true,
+    })
+  );
+
+  assert.equal(spawnCount, 0);
+  assert.deepEqual(
+    socket.frames.map((frame) => JSON.parse(frame) as Record<string, unknown>),
+    [{ type: 'error', message: 'Invalid project path' }]
+  );
+});