Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

24.0 KB
Raw Blame
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { delimiter, join } from 'node:path';
import { OK_HOSTED_AGENT_ENV } from '@inkeep/open-knowledge-core';
import { afterEach, describe, expect, test, vi } from 'vitest';
import type { AgentSessionManager } from '../agent-sessions.ts';
import { resolveOnPath } from '../git-preflight.ts';
import { getLogger } from '../logger.ts';
import { MCP_HOSTED_AGENT_HEADER } from '../mcp/agent-identity.ts';
import { AGENT_BROWSER_MCP_PACKAGE, resolveBrowserNpx } from './browser-mcp.ts';
import { agentSpawnPath } from './launch.ts';
import { AcpPermissionStore, readAgentBrowserTools } from './permissions.ts';
import { AcpRegistry } from './registry.ts';
import {
  AcpThreadManager,
  type AcpThreadManagerOptions,
  type HarnessManagedMcpEntryHit,
  type OkMcpHostedMarker,
} from './thread-manager.ts';

const log = getLogger('acp-injection-skip-test');

const fakeSessionManager = {
  getSession: async () => {
    throw new Error('not used');
  },
  closeAllForAgent: async () => {},
} as unknown as AgentSessionManager;

let dirs: string[] = [];
let managers: AcpThreadManager[] = [];
function tmp(): string {
  const d = mkdtempSync(join(tmpdir(), 'acp-injection-skip-'));
  dirs.push(d);
  return d;
}
afterEach(async () => {
  await Promise.allSettled(managers.map((m) => m.destroy()));
  managers = [];
  for (const d of dirs) rmSync(d, { recursive: true, force: true });
  dirs = [];
});

type SeamLaunchTicket = { initialPrompt: null };

type BuildMcpServersSeam = {
  buildMcpServers: (
    record: {
      agentRef: { source: 'registry' | 'custom'; id: string };
      cwd: string;
      info: { threadId: string };
      launchTicket: SeamLaunchTicket;
      agentNpmCache?: string | null;
    },
    ticket: SeamLaunchTicket,
    init: { agentCapabilities?: { mcpCapabilities?: { http?: boolean } } },
    consentBudgetMs?: number,
  ) => Promise<{
    servers: Array<{
      name: string;
      type?: string;
      env?: Array<{ name: string; value: string }>;
      headers?: Array<{ name: string; value: string }>;
    }>;
    hostedMarker: OkMcpHostedMarker;
    browserUnavailable: 'no-node' | 'failed' | null;
    browserInjected: boolean;
  }>;
};

function makeManager(
  probe?: AcpThreadManagerOptions['probeHarnessManagedMcpEntry'],
  stdio: AcpThreadManagerOptions['getMcpStdioCommand'] = () => ({
    command: 'open-knowledge',
    args: ['mcp', '--port', '4242'],
  }),
  pi?: {
    probePiAcpBridge?: AcpThreadManagerOptions['probePiAcpBridge'];
    ensurePiAcpBridge?: AcpThreadManagerOptions['ensurePiAcpBridge'];
  },
  browser?: {
    enabled: AcpThreadManagerOptions['agentBrowserTools'];
    resolveNpx?: AcpThreadManagerOptions['resolveBrowserNpx'];
    ensurePackage?: AcpThreadManagerOptions['ensureBrowserPackage'];
    installWaitMs?: number;
    localDir?: string;
    globalDir?: string | null;
  },
): BuildMcpServersSeam {
  const localDir = browser?.localDir ?? tmp();
  const globalDir =
    browser === undefined ? null : browser.globalDir === undefined ? tmp() : browser.globalDir;
  const manager = new AcpThreadManager({
    ...pi,
    contentDir: tmp(),
    localDir,
    globalDir,
    registry: new AcpRegistry({
      localDir,
      log,
      fetchImpl: (async () => {
        throw new Error('offline test');
      }) as typeof fetch,
    }),
    permissions: new AcpPermissionStore(localDir, log),
    sessionManager: fakeSessionManager,
    isExcludedPath: () => false,
    isIgnoredPath: () => false,
    getServerUrl: () => 'http://127.0.0.1:4242',
    getMcpStdioCommand: stdio,
    probeHarnessManagedMcpEntry: probe,
    agentBrowserTools: browser?.enabled,
    resolveBrowserNpx: browser?.resolveNpx,
    ensureBrowserPackage: browser?.ensurePackage ?? (async () => {}),
    browserInstallWaitMs: browser?.installWaitMs,
    log,
    resolveLoginShellPath: async () => null,
  });
  managers.push(manager);
  return manager as unknown as BuildMcpServersSeam;
}

const THREAD_ID = '6f1c2d3e-4a5b-4c6d-8e7f-9a0b1c2d3e4f';

const PROJECT = '/tmp/acp-injection-skip-project';

const LAUNCH: SeamLaunchTicket = { initialPrompt: null };

const record = (source: 'registry' | 'custom', id: string) => ({
  agentRef: { source, id },
  cwd: PROJECT,
  info: { threadId: THREAD_ID },
  launchTicket: LAUNCH,
});

const HTTP_INIT = { agentCapabilities: { mcpCapabilities: { http: true } } };

const hit: HarnessManagedMcpEntryHit = {
  editorId: 'codex',
  scope: 'project',
  configPath: '/tmp/acp-injection-skip-project/.codex/config.toml',
};

describe('buildMcpServers × probeHarnessManagedMcpEntry', () => {
  test('skips injection entirely on a probe hit (http-capable and stdio agents)', async () => {
    const m = makeManager(() => hit);
    expect(
      (await m.buildMcpServers(record('registry', 'codex-acp'), LAUNCH, HTTP_INIT)).servers,
    ).toEqual([]);
    expect((await m.buildMcpServers(record('registry', 'claude-acp'), LAUNCH, {})).servers).toEqual(
      [],
    );
  });

  test('injects on a probe miss', async () => {
    const m = makeManager(() => null);
    const { servers } = await m.buildMcpServers(record('registry', 'codex-acp'), LAUNCH, HTTP_INIT);
    expect(servers).toHaveLength(1);
    expect(servers[0]).toMatchObject({ name: 'open-knowledge', type: 'http' });
  });

  test('a Beta server injects its own server name on both transports', async () => {
    vi.stubEnv('OK_CHANNEL', 'beta');
    try {
      const m = makeManager(() => null);
      const http = await m.buildMcpServers(record('registry', 'codex-acp'), LAUNCH, HTTP_INIT);
      const stdio = await m.buildMcpServers(record('registry', 'claude-acp'), LAUNCH, {});
      expect(http.servers[0]).toMatchObject({ name: 'open-knowledge-beta', type: 'http' });
      expect(stdio.servers[0]).toMatchObject({ name: 'open-knowledge-beta' });
    } finally {
      vi.unstubAllEnvs();
    }
  });

  test('the injected HTTP server carries the hosted-agent header', async () => {
    const m = makeManager(() => null);
    const { servers, hostedMarker } = await m.buildMcpServers(
      record('registry', 'codex-acp'),
      LAUNCH,
      HTTP_INIT,
    );
    expect(servers[0]).toMatchObject({
      type: 'http',
      headers: [{ name: MCP_HOSTED_AGENT_HEADER, value: '1' }],
    });
    expect(hostedMarker).toBe('http-header');
  });

  test('the injected stdio server carries the hosted-agent marker and PATH', async () => {
    const m = makeManager(() => null);
    const { servers, hostedMarker } = await m.buildMcpServers(
      record('registry', 'claude-acp'),
      LAUNCH,
      {},
    );
    expect(servers).toHaveLength(1);
    expect(servers[0]).toMatchObject({ name: 'open-knowledge' });
    const env = (servers[0] as { env: Array<{ name: string; value: string }> }).env;
    expect(env).toContainEqual({ name: OK_HOSTED_AGENT_ENV, value: '1' });
    expect(hostedMarker).toBe('stdio-entry-env');
  });

  test('the injected stdio server carries the channel its host CLI was built with', async () => {
    const m = makeManager(
      () => null,
      () => ({
        command: 'node',
        args: ['/src/cli.mjs', 'mcp', '--port', '4242'],
        env: { OK_CHANNEL: 'dev' },
      }),
    );
    const { servers } = await m.buildMcpServers(record('registry', 'claude-acp'), LAUNCH, {});
    const env = (servers[0] as { env: Array<{ name: string; value: string }> }).env;
    expect(env).toContainEqual({ name: 'OK_CHANNEL', value: 'dev' });
    expect(env).toContainEqual({ name: OK_HOSTED_AGENT_ENV, value: '1' });
  });

  test('the injected stdio PATH is the agent spawn PATH, not the server process PATH', async () => {
    const m = makeManager(() => null);
    const { servers } = await m.buildMcpServers(record('registry', 'claude-acp'), LAUNCH, {});
    const env = (servers[0] as { env: Array<{ name: string; value: string }> }).env;
    const declared = env.find((e) => e.name === 'PATH')?.value;
    expect(declared).toBe(agentSpawnPath());
    const declaredDirs = new Set((declared ?? '').split(delimiter));
    for (const dir of (process.env.PATH ?? '').split(delimiter)) {
      if (dir !== '') expect(declaredDirs.has(dir)).toBe(true);
    }
  });

  test('never probes for custom agents or registry agents without an OK config surface', async () => {
    let calls = 0;
    const m = makeManager(() => {
      calls += 1;
      return hit;
    });
    expect(
      (await m.buildMcpServers(record('custom', 'my-agent'), LAUNCH, HTTP_INIT)).servers,
    ).toHaveLength(1);
    expect(
      (await m.buildMcpServers(record('registry', 'gemini'), LAUNCH, HTTP_INIT)).servers,
    ).toHaveLength(1);
    expect(calls).toBe(0);
  });

  test('always injects for Cursor, even when its config carries OK’s entry', async () => {
    let calls = 0;
    const m = makeManager(() => {
      calls += 1;
      return { ...hit, editorId: 'cursor' as const };
    });
    const { servers, hostedMarker } = await m.buildMcpServers(
      record('registry', 'cursor'),
      LAUNCH,
      {
        agentCapabilities: { mcpCapabilities: { http: true } },
      },
    );
    expect(servers).toHaveLength(1);
    expect(servers[0]).toMatchObject({ name: 'open-knowledge', type: 'http' });
    expect(hostedMarker).toBe('http-header');
    expect(calls).toBe(0);
  });

  test('fail-open: a throwing probe still injects', async () => {
    const m = makeManager(() => {
      throw new Error('probe exploded');
    });
    const { servers } = await m.buildMcpServers(record('registry', 'claude-acp'), LAUNCH, {});
    expect(servers).toHaveLength(1);
    expect(servers[0]).toMatchObject({ name: 'open-knowledge', command: 'open-knowledge' });
  });

  test('unwired seam keeps unconditional injection', async () => {
    const m = makeManager(undefined);
    expect(
      (await m.buildMcpServers(record('registry', 'codex-acp'), LAUNCH, HTTP_INIT)).servers,
    ).toEqual([expect.objectContaining({ name: 'open-knowledge' })]);
  });
});

describe('buildMcpServers hosted-marker outcomes', () => {
  test('a skip-branch thread reports `unknown`, not a false negative', async () => {
    const m = makeManager(() => hit);
    expect(
      (await m.buildMcpServers(record('registry', 'codex-acp'), LAUNCH, HTTP_INIT)).hostedMarker,
    ).toBe('unknown');
    expect(
      (await m.buildMcpServers(record('registry', 'claude-acp'), LAUNCH, {})).hostedMarker,
    ).toBe('unknown');
  });

  test('an agent with no usable transport reports `none` and gets no servers', async () => {
    const m = makeManager(
      () => null,
      () => null,
    );
    const { servers, hostedMarker } = await m.buildMcpServers(
      record('registry', 'claude-acp'),
      LAUNCH,
      {},
    );
    expect(servers).toEqual([]);
    expect(hostedMarker).toBe('none');
  });
});

describe.skipIf(process.platform === 'win32')('buildMcpServers × agentBrowserTools', () => {
  const fakeNpx = () => {
    const dir = tmp();
    writeFileSync(join(dir, 'npx'), '');
    writeFileSync(join(dir, 'node'), '');
    return { npx: join(dir, 'npx'), path: dir };
  };
  const names = async (m: BuildMcpServersSeam, id: string, init = HTTP_INIT) =>
    (await m.buildMcpServers(record('registry', id), LAUNCH, init)).servers.map((s) => s.name);
  const unavailable = async (m: BuildMcpServersSeam, id = 'claude-acp') =>
    (await m.buildMcpServers(record('registry', id), LAUNCH, HTTP_INIT)).browserUnavailable;

  test('adds the browser after OK tools, relayed through the node beside the resolved npx, from its own folder', async () => {
    const localDir = tmp();
    const globalDir = tmp();
    const npx = fakeNpx();
    const seen: Array<readonly (string | null | undefined)[]> = [];
    const m = makeManager(undefined, undefined, undefined, {
      enabled: () => true,
      resolveNpx: (candidates) => {
        seen.push(candidates);
        return npx;
      },
      localDir,
      globalDir,
    });
    const { servers } = await m.buildMcpServers(record('registry', 'claude-acp'), LAUNCH, {});
    expect(servers.map((s) => s.name)).toEqual(['open-knowledge', 'ok-browser']);
    const browser = servers[1] as { command?: string; args?: string[]; env?: unknown };
    expect(browser.command).toBe(join(npx.path, 'node'));
    const chat = join(globalDir, 'agent-browser', THREAD_ID);
    expect(browser.args?.slice(2, 7)).toEqual([
      join(chat, 'npm'),
      join(chat, 'files'),
      npx.npx,
      '--prefix',
      join(chat, 'npm'),
    ]);
    expect(browser.args).toContain('--no-webmcp');
    expect(browser.args?.join(' ')).toContain(`--output-dir ${join(chat, 'files')}`);
    expect(browser.args?.join(' ')).not.toContain(localDir);
    expect(browser.env).toEqual([
      { name: 'PATH', value: npx.path },
      { name: 'npm_config_prefer_offline', value: 'true' },
    ]);
    expect(seen[0]?.at(-1)).toBe(agentSpawnPath());
  });

  test('the injected npx resolves on the PATH it is handed', async () => {
    const npx = resolveOnPath('npx', agentSpawnPath());
    if (npx === null) return;
    const m = makeManager(undefined, undefined, undefined, { enabled: () => true });
    const { servers } = await m.buildMcpServers(
      record('registry', 'claude-acp'),
      LAUNCH,
      HTTP_INIT,
    );
    const browser = servers.find((s) => s.name === 'ok-browser') as
      | { args: string[]; env: Array<{ name: string; value: string }> }
      | undefined;
    const path = browser?.env.find((e) => e.name === 'PATH')?.value;
    expect(browser?.args[4]).toBe(resolveOnPath('npx', path));
  });

  test('adds the browser even when the harness already loads OK tools', async () => {
    const npx = fakeNpx();
    const m = makeManager(() => hit, undefined, undefined, {
      enabled: () => true,
      resolveNpx: () => npx,
    });
    expect(await names(m, 'codex-acp')).toEqual(['ok-browser']);
  });

  test('leaves the browser out when it is off, unset, npx is missing, or there is no per-user folder', async () => {
    const npx = fakeNpx();
    const off = makeManager(undefined, undefined, undefined, {
      enabled: () => false,
      resolveNpx: () => npx,
    });
    const noNpx = makeManager(undefined, undefined, undefined, {
      enabled: () => true,
      resolveNpx: () => null,
    });
    const noGlobalDir = makeManager(undefined, undefined, undefined, {
      enabled: () => true,
      resolveNpx: () => npx,
      globalDir: null,
    });
    expect(await names(off, 'claude-acp')).toEqual(['open-knowledge']);
    expect(await names(makeManager(), 'claude-acp')).toEqual(['open-knowledge']);
    expect(await names(noNpx, 'claude-acp')).toEqual(['open-knowledge']);
    expect(await names(noGlobalDir, 'claude-acp')).toEqual(['open-knowledge']);
    expect(await unavailable(off)).toBeNull();
    expect(await unavailable(makeManager())).toBeNull();
    expect(await unavailable(noNpx)).toBe('no-node');
    expect(await unavailable(noGlobalDir)).toBe('failed');
  });

  test('leaves the browser out when installing its package fails from cached and from fresh package data', async () => {
    const npx = fakeNpx();
    const installs: Array<{
      cmd: string;
      path: string | undefined;
      acquired: string;
      reacquire: boolean | undefined;
      preferOffline: string | undefined;
    }> = [];
    const m = makeManager(undefined, undefined, undefined, {
      enabled: () => true,
      resolveNpx: () => npx,
      ensurePackage: async (launch, acquired, _log, acquisition) => {
        installs.push({
          cmd: launch.cmd,
          path: launch.env.PATH,
          acquired,
          reacquire: acquisition.reacquire,
          preferOffline: launch.env.npm_config_prefer_offline,
        });
        throw new Error('npm install failed');
      },
    });
    const { servers, browserUnavailable } = await m.buildMcpServers(
      record('registry', 'claude-acp'),
      LAUNCH,
      HTTP_INIT,
    );
    expect(servers.map((s) => s.name)).toEqual(['open-knowledge']);
    expect(browserUnavailable).toBe('failed');
    expect(installs).toEqual(
      ['true', 'false'].map((preferOffline) => ({
        cmd: npx.npx,
        path: npx.path,
        acquired: AGENT_BROWSER_MCP_PACKAGE,
        reacquire: true,
        preferOffline,
      })),
    );
  });

  test("installs and starts the browser from the npm cache the chat's agent runs with", async () => {
    const npx = fakeNpx();
    const installCaches: Array<string | undefined> = [];
    const m = makeManager(undefined, undefined, undefined, {
      enabled: () => true,
      resolveNpx: () => npx,
      ensurePackage: async (launch) => {
        installCaches.push(launch.env.npm_config_cache);
      },
    });
    const { servers } = await m.buildMcpServers(
      { ...record('registry', 'codex-acp'), agentNpmCache: '/runtime/npm-cache' },
      LAUNCH,
      HTTP_INIT,
    );
    const browser = servers.find((s) => s.name === 'ok-browser');
    expect(browser?.env).toContainEqual({ name: 'npm_config_cache', value: '/runtime/npm-cache' });
    expect(installCaches).toEqual(['/runtime/npm-cache']);
  });

  test('starts the chat without the browser when installing it outlasts the wait', async () => {
    const npx = fakeNpx();
    const m = makeManager(undefined, undefined, undefined, {
      enabled: () => true,
      resolveNpx: () => npx,
      ensurePackage: () => new Promise<void>(() => {}),
      installWaitMs: 20,
    });
    const { servers, browserUnavailable } = await m.buildMcpServers(
      record('registry', 'claude-acp'),
      LAUNCH,
      HTTP_INIT,
    );
    expect(servers.map((s) => s.name)).toEqual(['open-knowledge']);
    expect(browserUnavailable).toBe('failed');
  });

  test('waits on the browser install no longer than the budget of a resume or retry', async () => {
    const npx = fakeNpx();
    const m = makeManager(undefined, undefined, undefined, {
      enabled: () => true,
      resolveNpx: () => npx,
      ensurePackage: () => new Promise<void>(() => {}),
    });
    const { browserUnavailable } = await m.buildMcpServers(
      record('registry', 'claude-acp'),
      LAUNCH,
      HTTP_INIT,
      20,
    );
    expect(browserUnavailable).toBe('failed');
  });

  test('gives the browser only to Claude Code and Codex chats, whose adapters name the tool each call runs', async () => {
    const npx = fakeNpx();
    const on = makeManager(undefined, undefined, undefined, {
      enabled: () => true,
      resolveNpx: () => npx,
    });
    expect(await names(on, 'claude-acp')).toEqual(['open-knowledge', 'ok-browser']);
    expect(await names(on, 'codex-acp')).toEqual(['open-knowledge', 'ok-browser']);
    for (const id of ['gemini', 'cursor', 'opencode', 'github-copilot-cli']) {
      expect(await names(on, id)).toEqual(['open-knowledge']);
    }
    expect(await names(on, 'pi-acp')).toEqual([]);
    const custom = await on.buildMcpServers(record('custom', 'claude-acp'), LAUNCH, HTTP_INIT);
    expect(custom.servers.map((s) => s.name)).toEqual(['open-knowledge']);
  });

  test('refuses an npx inside the project, or one with no node beside it, and tries the next PATH', async () => {
    const tried: string[] = [];
    const bare = tmp();
    const safe = fakeNpx();
    const m = makeManager(undefined, undefined, undefined, {
      enabled: () => true,
      resolveNpx: (_candidates, _resolveCommand, accept) =>
        resolveBrowserNpx(
          [join(PROJECT, 'node_modules', '.bin'), bare, safe.path],
          (name, path) => {
            tried.push(path);
            return join(path, name);
          },
          accept,
        ),
    });
    const { servers } = await m.buildMcpServers(
      record('registry', 'claude-acp'),
      LAUNCH,
      HTTP_INIT,
    );
    const browser = servers.find((s) => s.name === 'ok-browser') as { args?: string[] } | undefined;
    expect(browser?.args?.[4]).toBe(safe.npx);
    expect(tried).toEqual([join(PROJECT, 'node_modules', '.bin'), bare, safe.path]);

    const onlyProject = makeManager(undefined, undefined, undefined, {
      enabled: () => true,
      resolveNpx: (_candidates, _resolveCommand, accept) =>
        resolveBrowserNpx([join(PROJECT, 'bin')], (name, path) => join(path, name), accept),
    });
    expect(await names(onlyProject, 'claude-acp')).toEqual(['open-knowledge']);
    expect(await unavailable(onlyProject)).toBe('no-node');
    expect(await unavailable(m)).toBeNull();
  });

  test('a failure preparing the browser still starts the chat with OK tools', async () => {
    const globalDir = tmp();
    writeFileSync(join(globalDir, 'agent-browser'), 'not a folder');
    const npx = fakeNpx();
    const m = makeManager(undefined, undefined, undefined, {
      enabled: () => true,
      resolveNpx: () => npx,
      globalDir,
    });
    expect(await names(m, 'claude-acp')).toEqual(['open-knowledge']);
    expect(await unavailable(m)).toBe('failed');
  });

  test('follows agents.browserTools in the user config file', async () => {
    const home = tmp();
    const projectDir = tmp();
    const npx = fakeNpx();
    const m = makeManager(undefined, undefined, undefined, {
      enabled: () => readAgentBrowserTools(projectDir, home),
      resolveNpx: () => npx,
    });
    expect(await names(m, 'claude-acp')).toEqual(['open-knowledge']);
    mkdirSync(join(home, '.ok'), { recursive: true });
    writeFileSync(join(home, '.ok', 'global.yml'), 'agents:\n  browserTools: true\n');
    expect(await names(m, 'claude-acp')).toEqual(['open-knowledge', 'ok-browser']);
    writeFileSync(join(home, '.ok', 'global.yml'), 'agents:\n  browserTools: false\n');
    expect(await names(m, 'claude-acp')).toEqual(['open-knowledge']);
  });
});

describe('buildMcpServers × pi-acp', () => {
  const PI_LOADABLE = {
    project: 'ready' as const,
    cwd: '/tmp/acp-injection-skip-project',
    canonicalCwd: '/tmp/acp-injection-skip-project',
    bridgePath: '/tmp/acp-injection-skip-project/.pi/extensions/open-knowledge.ts',
    trustPath: '/tmp/acp-injection-skip-home/.pi/agent/trust.json',
    bridge: 'own-current' as const,
    trust: 'trusted' as const,
    bridgeLoadable: true,
    otherExtensions: [],
  };

  test('never injects for pi, even with an http-capable init and a working stdio command', async () => {
    const m = makeManager(() => null, undefined, { probePiAcpBridge: () => PI_LOADABLE });
    expect(
      (await m.buildMcpServers(record('registry', 'pi-acp'), LAUNCH, HTTP_INIT)).servers,
    ).toEqual([]);
    expect((await m.buildMcpServers(record('registry', 'pi-acp'), LAUNCH, {})).servers).toEqual([]);
  });

  test('a loadable bridge reports `unknown` — the bridge spawns the server, not us', async () => {
    const m = makeManager(() => null, undefined, { probePiAcpBridge: () => PI_LOADABLE });
    expect(
      (await m.buildMcpServers(record('registry', 'pi-acp'), LAUNCH, HTTP_INIT)).hostedMarker,
    ).toBe('unknown');
  });

  test('unwired seams suppress injection and report `unknown`, not `none`', async () => {
    const m = makeManager(() => null);
    const { servers, hostedMarker } = await m.buildMcpServers(
      record('registry', 'pi-acp'),
      LAUNCH,
      HTTP_INIT,
    );
    expect(servers).toEqual([]);
    expect(hostedMarker).toBe('unknown');
  });

  test('a throwing probe degrades to `unknown` rather than failing session setup', async () => {
    const m = makeManager(() => null, undefined, {
      probePiAcpBridge: () => {
        throw new Error('probe exploded');
      },
    });
    expect(
      (await m.buildMcpServers(record('registry', 'pi-acp'), LAUNCH, HTTP_INIT)).hostedMarker,
    ).toBe('unknown');
  });

  test('an unprovisioned bridge with no ensure seam reports `none` without prompting', async () => {
    const m = makeManager(() => null, undefined, {
      probePiAcpBridge: () => ({
        ...PI_LOADABLE,
        bridge: 'absent',
        trust: 'untrusted',
        bridgeLoadable: false,
      }),
    });
    const { servers, hostedMarker } = await m.buildMcpServers(
      record('registry', 'pi-acp'),
      LAUNCH,
      HTTP_INIT,
    );
    expect(servers).toEqual([]);
    expect(hostedMarker).toBe('none');
  });

  test('a custom agent named like the registry entry still gets normal injection', async () => {
    const m = makeManager(() => null, undefined, { probePiAcpBridge: () => PI_LOADABLE });
    const { servers } = await m.buildMcpServers(record('custom', 'pi-acp'), LAUNCH, HTTP_INIT);
    expect(servers).toHaveLength(1);
  });
});