repoburg 1.3.202 → 1.3.204

package/agent-pane/backend/src/repoburg/agent-runtime-client.ts

@@ -1,285 +0,0 @@
-/**
- * Agent-runtime SSE client — consumes the root backend's agent-runtime
- * message stream (Claude-Code-SDK-style ordered messages):
- *   GET /agent-runtime/sessions/:sessionId/messages?stream=1
- *
- * One JSON message per SSE `data:` line; heartbeat comments (`: ping`) keep
- * the connection alive and count as activity for the stream watchdog.
- * The stream ends when the terminal `result` message arrives; connection
- * drops before it trigger reconnect with backoff until aborted.
- */
-
-// ---------------------------------------------------------------------------
-// Message types (mirror backend/src/agent-runtime/agent-runtime.types.ts)
-// ---------------------------------------------------------------------------
-
-export interface AgentRuntimeUsage {
-  input_tokens: number;
-  output_tokens: number;
-  cache_read_input_tokens: number;
-  cache_creation_input_tokens: number;
-}
-
-export interface AgentRuntimeActionInfo {
-  id: string;
-  action_type: string;
-  file_path: string | null;
-  command_string: string | null;
-  status: string;
-  server_name: string | null;
-  tool_name: string | null;
-  arguments: string | null;
-  plain: string | null;
-  /** Raw selections JSON string (ask_user/final) — parsed by the client. */
-  selections: string | null;
-  order_of_execution: number;
-}
-
-export type AgentRuntimeContentBlock =
-  | { type: 'text'; text: string }
-  | { type: 'thinking'; thinking: string }
-  | {
-      type: 'tool_use';
-      id: string;
-      name: string;
-      input: Record<string, unknown> | null;
-    };
-
-export interface AgentRuntimeToolResultBlock {
-  type: 'tool_result';
-  tool_use_id: string;
-  content: string;
-  is_error: boolean;
-  action: AgentRuntimeActionInfo;
-}
-
-export interface SystemInitMessage {
-  type: 'system';
-  subtype: 'init';
-  sessionId: string;
-  modelId: string | null;
-}
-
-export interface StreamEventMessage {
-  type: 'stream_event';
-  sessionId: string;
-  inputId: string;
-  delta: { type: 'text' | 'thinking'; text: string };
-}
-
-export interface AssistantMessage {
-  type: 'assistant';
-  sessionId: string;
-  inputId: string;
-  content: AgentRuntimeContentBlock[];
-  usage?: AgentRuntimeUsage;
-}
-
-export interface UserMessage {
-  type: 'user';
-  sessionId: string;
-  inputId: string;
-  content: AgentRuntimeToolResultBlock[];
-}
-
-/** Sub-agent lifecycle event on the PARENT session channel (Claude task
- *  parity) — compact; child content never crosses the wire. */
-export interface SubagentMessage {
-  type: 'subagent';
-  /** PARENT session id (routing). */
-  sessionId: string;
-  event: 'started' | 'progress' | 'completed' | 'failed';
-  /** Child session id — the task identity. */
-  task_id: string;
-  agent_name: string;
-  /** Task prompt on `started`; the child's latest action on `progress`. */
-  description: string;
-  /** Parent input + invoke_subagent action — the card key. */
-  input_id: string;
-  action_id: string;
-  last_tool_name?: string | null;
-  token_count?: number;
-  summary?: string;
-  usage?: AgentRuntimeUsage;
-}
-export interface ResultMessage {
-  type: 'result';
-  subtype: 'success' | 'error_during_execution' | 'aborted';
-  sessionId: string;
-  is_error: boolean;
-  result: string;
-  usage?: AgentRuntimeUsage;
-  num_rounds: number;
-  errors?: string[];
-}
-
-export type AgentRuntimeMessage =
-  | SystemInitMessage
-  | StreamEventMessage
-  | AssistantMessage
-  | UserMessage
-  | SubagentMessage
-  | ResultMessage;
-
-// ---------------------------------------------------------------------------
-// SSE stream consumer
-// ---------------------------------------------------------------------------
-
-export type MessageHandler = (message: AgentRuntimeMessage) => void;
-
-export interface StreamOptions {
-  /** Aborting closes the connection and stops reconnect attempts. */
-  signal?: AbortSignal;
-  /** false = request the stream without deltas (?stream=0). Default true. */
-  deltas?: boolean;
-  /** Called on ANY received bytes (message or heartbeat) — watchdog reset. */
-  onActivity?: () => void;
-  /** Backoff between reconnect attempts (ms). Default 2000. */
-  reconnectDelayMs?: number;
-}
-
-/** Why the stream ended. */
-export type StreamEndReason = 'result' | 'aborted' | 'session-not-found';
-
-/** Parse one SSE frame (already split on blank line) into its data payload.
- *  Comment (`:`) and non-data lines are ignored; multiple `data:` lines join. */
-export function parseSseFrame(frame: string): string | null {
-  const dataLines: string[] = [];
-  for (const line of frame.split('\n')) {
-    const trimmed = line.replace(/\r$/, '');
-    if (trimmed.startsWith(':')) continue; // heartbeat comment
-    if (trimmed.startsWith('data:')) {
-      dataLines.push(trimmed.slice(5).replace(/^ /, ''));
-    }
-  }
-  if (dataLines.length === 0) return null;
-  return dataLines.join('\n');
-}
-
-/** Split a raw chunk stream into complete SSE frames. Yields data payloads. */
-export function createSseParser(): (chunk: string) => string[] {
-  let buffer = '';
-  return (chunk: string) => {
-    // Normalize CRLF line endings — frames split on blank LF lines.
-    buffer += chunk.replace(/\r\n/g, '\n');
-    const payloads: string[] = [];
-    let boundary: number;
-    while ((boundary = buffer.indexOf('\n\n')) !== -1) {
-      const frame = buffer.slice(0, boundary);
-      buffer = buffer.slice(boundary + 2);
-      const data = parseSseFrame(frame);
-      if (data !== null) payloads.push(data);
-    }
-    return payloads;
-  };
-}
-
-/**
- * Consume the agent-runtime message stream for one session until the
- * terminal `result` message, an abort, or a missing session (404).
- * Connection drops reconnect with backoff; `onActivity` fires on every
- * received frame so callers can run a stream watchdog.
- */
-export async function streamAgentRuntimeMessages(
-  baseUrl: string,
-  sessionId: string,
-  onMessage: MessageHandler,
-  opts: StreamOptions = {},
-): Promise<StreamEndReason> {
-  const deltas = opts.deltas !== false;
-  const delayMs = opts.reconnectDelayMs ?? 2000;
-  const url = `${baseUrl.replace(/\/+$/, '')}/agent-runtime/sessions/${sessionId}/messages?stream=${deltas ? 1 : 0}`;
-
-  for (;;) {
-    if (opts.signal?.aborted) return 'aborted';
-
-    let response: Response;
-    try {
-      response = await fetch(url, { method: 'GET', signal: opts.signal });
-    } catch (err) {
-      if (opts.signal?.aborted || (err as Error).name === 'AbortError') {
-        return 'aborted';
-      }
-      await reconnectDelay(delayMs, opts.signal);
-      continue;
-    }
-
-    if (response.status === 404) return 'session-not-found';
-    if (!response.ok || !response.body) {
-      await reconnectDelay(delayMs, opts.signal);
-      continue;
-    }
-
-    // Read the body frame by frame.
-    const reason: StreamEndReason | null = await readBody(
-      response.body,
-      onMessage,
-      opts,
-    );
-    if (reason !== null) {
-      await response.body.cancel().catch(() => {});
-      return reason;
-    }
-
-    // Server closed the stream without a result — reconnect.
-    await reconnectDelay(delayMs, opts.signal);
-  }
-}
-
-/** Read one response body to its end. Returns a terminal reason or null
- *  (body ended without result / was aborted → caller reconnects). */
-async function readBody(
-  body: ReadableStream<Uint8Array>,
-  onMessage: MessageHandler,
-  opts: StreamOptions,
-): Promise<StreamEndReason | null> {
-  const parse = createSseParser();
-  const decoder = new TextDecoder();
-  const reader = body.getReader();
-
-  try {
-    for (;;) {
-      const { done, value } = await reader.read();
-      if (done) return null;
-      opts.onActivity?.();
-      for (const payload of parse(decoder.decode(value, { stream: true }))) {
-        let message: AgentRuntimeMessage | null = null;
-        try {
-          message = JSON.parse(payload) as AgentRuntimeMessage;
-        } catch {
-          continue; // Malformed frame — skip.
-        }
-        if (!message || typeof message.type !== 'string') continue;
-        onMessage(message);
-        if (message.type === 'result') return 'result';
-      }
-    }
-  } catch (err) {
-    if (opts.signal?.aborted || (err as Error).name === 'AbortError') {
-      return 'aborted';
-    }
-    return null; // Read error — caller reconnects.
-  } finally {
-    try {
-      reader.releaseLock();
-    } catch {
-      // Reader already released.
-    }
-  }
-}
-
-/** Wait the reconnect delay; resolve early when the signal aborts. */
-function reconnectDelay(delayMs: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve) => {
-    if (signal?.aborted) return resolve();
-    const timer = setTimeout(resolve, delayMs);
-    signal?.addEventListener(
-      'abort',
-      () => {
-        clearTimeout(timer);
-        resolve();
-      },
-      { once: true },
-    );
-  });
-}

package/agent-pane/backend/src/repoburg/backend-resolver.test.ts

@@ -1,356 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach, type Mock } from 'vitest';
-import path from 'node:path';
-import {
-  resolveBackendUrl,
-  daemonBaseUrl,
-  clearResolverCache,
-  invalidateBackend,
-  type DaemonService,
-} from './backend-resolver.ts';
-
-/** Build a daemon service row. */
-function service(partial: Partial<DaemonService> & { port: number }): DaemonService {
-  return {
-    name: partial.name ?? `svc-${partial.port}`,
-    path: partial.path ?? '/tmp/does-not-match',
-    port: partial.port,
-    status: partial.status ?? 'running',
-    pid: partial.pid ?? null,
-  };
-}
-
-/** JSON Response helper. */
-const jsonResponse = (body: unknown, status = 200): Response =>
-  new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } });
-
-/** Route table for the daemon + backend endpoints. */
-function mockFetchRoutes(routes: Array<{ match: (url: string, method: string) => boolean; respond: () => Response | Promise<Response> }>): Mock {
-  const mock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
-    const url = String(input);
-    const method = init?.method ?? 'GET';
-    for (const route of routes) {
-      if (route.match(url, method)) return route.respond();
-    }
-    return jsonResponse({ error: 'not found' }, 404);
-  });
-  vi.stubGlobal('fetch', mock);
-  return mock;
-}
-
-describe('backend-resolver', () => {
-  const DAEMON = 'http://localhost:9998';
-
-  beforeEach(() => {
-    delete process.env.REPOBURG_BACKEND_URL;
-    delete process.env.REPOBURG_DAEMON_URL;
-    clearResolverCache();
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    vi.useRealTimers();
-  });
-
-  it('daemonBaseUrl defaults to 9998 and honors REPOBURG_DAEMON_URL', () => {
-    expect(daemonBaseUrl()).toBe('http://localhost:9998');
-    process.env.REPOBURG_DAEMON_URL = 'http://localhost:9999/';
-    expect(daemonBaseUrl()).toBe('http://localhost:9999');
-    delete process.env.REPOBURG_DAEMON_URL;
-  });
-
-  it('REPOBURG_BACKEND_URL bypasses the daemon entirely', async () => {
-    process.env.REPOBURG_BACKEND_URL = 'http://localhost:1234/';
-    const fetchMock = mockFetchRoutes([]);
-    const resolved = await resolveBackendUrl('/tmp/proj');
-    expect(resolved?.baseUrl).toBe('http://localhost:1234');
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it('throws a clear error when the daemon is unreachable', async () => {
-    const fetchMock = vi.fn().mockRejectedValue(new Error('fetch failed'));
-    vi.stubGlobal('fetch', fetchMock);
-    await expect(resolveBackendUrl('/tmp/proj')).rejects.toThrow(
-      /daemon not reachable at http:\/\/localhost:9998/,
-    );
-  });
-
-  it('returns a healthy running service matching the project path', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok' }) },
-    ]);
-
-    const resolved = await resolveBackendUrl('/tmp/proj');
-    expect(resolved).toEqual({ baseUrl: 'http://localhost:3402', port: 3402, name: 'proj' });
-    expect(fetchMock).toHaveBeenCalledTimes(3); // daemon health + list + backend health
-  });
-
-  it('reuses the cached resolution without re-listing daemon services', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok' }) },
-    ]);
-
-    await resolveBackendUrl('/tmp/proj');
-    await resolveBackendUrl('/tmp/proj');
-    // Second call: only the cached backend health probe — no daemon calls.
-    expect(fetchMock).toHaveBeenCalledTimes(4);
-    expect(fetchMock.mock.calls.every(([u]) => !String(u).includes('/services'))).toBe(false);
-  });
-
-  it('restarts a running service whose backend died, then returns it', async () => {
-    const abs = path.resolve('/tmp/proj');
-    let backendDead = true;
-    const restartMock = vi.fn();
-    mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      {
-        match: (u) => u === 'http://localhost:3402/health',
-        respond: () => {
-          if (backendDead) return jsonResponse({ error: 'dead' }, 500);
-          return jsonResponse({ status: 'ok' });
-        },
-      },
-      {
-        match: (u, m) => u === `${DAEMON}/services/proj/restart` && m === 'POST',
-        respond: () => {
-          restartMock();
-          backendDead = false;
-          return jsonResponse(service({ path: abs, port: 3402, name: 'proj' }));
-        },
-      },
-    ]);
-
-    const resolved = await resolveBackendUrl('/tmp/proj');
-    expect(restartMock).toHaveBeenCalledTimes(1);
-    expect(resolved?.baseUrl).toBe('http://localhost:3402');
-  });
-
-  it('restarts a stopped service for the path', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj', status: 'stopped' })]),
-      },
-      {
-        match: (u, m) => u === `${DAEMON}/services/proj/restart` && m === 'POST',
-        respond: () => jsonResponse(service({ path: abs, port: 3402, name: 'proj' })),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok' }) },
-    ]);
-
-    const resolved = await resolveBackendUrl('/tmp/proj');
-    expect(resolved?.baseUrl).toBe('http://localhost:3402');
-    expect(fetchMock.mock.calls.some(([u, i]) => String(u).endsWith('/services/proj/restart') && (i as RequestInit)?.method === 'POST')).toBe(true);
-  });
-
-  it('starts a new backend via the daemon when no service matches', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      { match: (u) => u === `${DAEMON}/services`, respond: () => jsonResponse([]) },
-      {
-        match: (u, m) => u === `${DAEMON}/services/start` && m === 'POST',
-        respond: () => jsonResponse(service({ path: abs, port: 3410, name: 'proj' }), 201),
-      },
-      { match: (u) => u === 'http://localhost:3410/health', respond: () => jsonResponse({ status: 'ok' }) },
-    ]);
-
-    const resolved = await resolveBackendUrl('/tmp/proj');
-    expect(resolved).toEqual({ baseUrl: 'http://localhost:3410', port: 3410, name: 'proj' });
-
-    const startCall = fetchMock.mock.calls.find(([u]) => String(u).endsWith('/services/start'));
-    expect(JSON.parse((startCall![1] as RequestInit).body as string)).toEqual({ path: abs });
-  });
-
-  it('surfaces the daemon message when start fails (e.g. 401 unauthorized)', async () => {
-    mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      { match: (u) => u === `${DAEMON}/services`, respond: () => jsonResponse([]) },
-      {
-        match: (u) => u === `${DAEMON}/services/start`,
-        respond: () => jsonResponse({ error: 'Unauthorized', message: 'Please run repoburg login' }, 401),
-      },
-    ]);
-
-    await expect(resolveBackendUrl('/tmp/proj')).rejects.toThrow(/Please run repoburg login/);
-  });
-
-  it('autoStart=false returns null for stopped or missing services, resolves running ones', async () => {
-    const abs = path.resolve('/tmp/proj');
-    mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj', status: 'stopped' })]),
-      },
-    ]);
-    expect(await resolveBackendUrl('/tmp/proj', { autoStart: false })).toBeNull();
-    expect(await resolveBackendUrl('/tmp/other', { autoStart: false })).toBeNull();
-
-    clearResolverCache();
-    mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok' }) },
-    ]);
-    const resolved = await resolveBackendUrl('/tmp/proj', { autoStart: false });
-    expect(resolved?.baseUrl).toBe('http://localhost:3402');
-  });
-
-  it('autoStart=false returns null when the running backend is unhealthy (no restart)', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ error: 'dead' }, 500) },
-    ]);
-
-    expect(await resolveBackendUrl('/tmp/proj', { autoStart: false })).toBeNull();
-    expect(fetchMock.mock.calls.some(([u]) => String(u).includes('restart'))).toBe(false);
-  });
-
-  it('invalidateBackend drops the cache entry so the daemon is re-consulted', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok' }) },
-    ]);
-
-    const first = await resolveBackendUrl('/tmp/proj');
-    invalidateBackend(first!.baseUrl);
-    await resolveBackendUrl('/tmp/proj');
-    // Re-consulted the daemon after invalidation: 3 (first flow) + 3 (second flow).
-    expect(fetchMock).toHaveBeenCalledTimes(6);
-  });
-
-  it('throws when a freshly started backend never becomes healthy', async () => {
-    vi.useFakeTimers();
-    const abs = path.resolve('/tmp/proj');
-    mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      { match: (u) => u === `${DAEMON}/services`, respond: () => jsonResponse([]) },
-      {
-        match: (u) => u === `${DAEMON}/services/start`,
-        respond: () => jsonResponse(service({ path: abs, port: 3410, name: 'proj' }), 201),
-      },
-      { match: (u) => u === 'http://localhost:3410/health', respond: () => jsonResponse({ error: 'dead' }, 500) },
-    ]);
-
-    const promise = resolveBackendUrl('/tmp/proj');
-    const assertion = expect(promise).rejects.toThrow(/did not become healthy within 30s/);
-    await vi.advanceTimersByTimeAsync(31_000);
-    await assertion;
-  });
-it('accepts a healthy running backend whose health projectPath matches the workspace', async () => {
-    const abs = path.resolve('/tmp/proj');
-    mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok', projectPath: abs }) },
-    ]);
-
-    const resolved = await resolveBackendUrl('/tmp/proj');
-    expect(resolved?.baseUrl).toBe('http://localhost:3402');
-  });
-
-  it('treats a projectPath mismatch as unhealthy (autoStart=false → null, no restart)', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok', projectPath: '/tmp/other-workspace' }) },
-    ]);
-
-    expect(await resolveBackendUrl('/tmp/proj', { autoStart: false })).toBeNull();
-    expect(fetchMock.mock.calls.some(([u]) => String(u).includes('restart'))).toBe(false);
-  });
-
-  it('restarts a running backend that serves a different workspace, then resolves it', async () => {
-    const abs = path.resolve('/tmp/proj');
-    let servingWrongWorkspace = true;
-    const restartMock = vi.fn();
-    mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      {
-        match: (u) => u === 'http://localhost:3402/health',
-        respond: () =>
-          servingWrongWorkspace
-            ? jsonResponse({ status: 'ok', projectPath: '/tmp/other-workspace' })
-            : jsonResponse({ status: 'ok', projectPath: abs }),
-      },
-      {
-        match: (u, m) => u === `${DAEMON}/services/proj/restart` && m === 'POST',
-        respond: () => {
-          restartMock();
-          servingWrongWorkspace = false;
-          return jsonResponse(service({ path: abs, port: 3402, name: 'proj' }));
-        },
-      },
-    ]);
-
-    const resolved = await resolveBackendUrl('/tmp/proj');
-    expect(restartMock).toHaveBeenCalledTimes(1);
-    expect(resolved?.baseUrl).toBe('http://localhost:3402');
-  });
-
-  it('re-consults the daemon when the cached backend starts serving a different workspace', async () => {
-    const abs = path.resolve('/tmp/proj');
-    let projectPath = abs;
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok', projectPath }) },
-    ]);
-
-    // First resolve caches the backend (projectPath matches).
-    await resolveBackendUrl('/tmp/proj');
-
-    // The row got mis-mapped — the backend now serves another workspace.
-    projectPath = '/tmp/other-workspace';
-    fetchMock.mockClear();
-    await resolveBackendUrl('/tmp/proj', { autoStart: false });
-    // The cache was rejected and the daemon re-consulted (health probe rejected).
-    expect(fetchMock.mock.calls.some(([u]) => String(u) === 'http://localhost:3402/health')).toBe(true);
-    expect(fetchMock.mock.calls.some(([u]) => String(u) === `${DAEMON}/services`)).toBe(true);
-  });
-});