zidane-ui 9.0.4 → 9.1.3

package/src/chat/testing/contract.ts

@@ -1,634 +0,0 @@
-/**
- * What every `ChatHost` implementation does alike, as a vitest suite: the in-memory fixture
- * (`createFixtureHost`), zidane-server (`createServerHost`), the desktop app's IPC host.
- *
- * An implementation's test calls {@link describeChatHostContract} with a harness factory. The
- * contract hands it a {@link ChatHostContractBackend}: the sessions, transcripts and tool outputs the
- * backend holds, and a script of what it does with each prompt (reply, ask a question, hold the run
- * until interrupted). The harness builds the host over a backend that does exactly that (a fixture
- * reply, a fake WebSocket server, a mocked IPC bridge). The capabilities list says which optional
- * members the host offers: the suite checks that the others are left out (undefined, never a
- * throwing stub) and skips the behaviours that need them.
- *
- *   describeChatHostContract('createFixtureHost', (backend) => ({ host: createFixtureHost(…) }), [
- *     'sessions', 'sessions.create', 'send', 'interrupt', 'interactions',
- *   ]);
- */
-import type { InteractionRequest, QuestionRequest } from 'zidane/chat';
-import type { BadgeActionEffect, BadgeMenuItem, ExtensionReferenceView, ReferenceProviderWire } from 'zidane/chat/pure';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import type { ChatEvent, ChatHost, ChatSession, TranscriptState } from '../headless/host';
-import type {
-  ChatCommandFacts,
-  ChatCommit,
-  ChatContextFacts,
-  ChatResolvedPath,
-  ChatSearchState,
-  ChatSessionFacts,
-  ChatSkillFacts,
-} from '../headless/transcript-host';
-
-/** An optional `ChatHost` member, by its path. */
-export type ChatHostCapability =
-  | 'sessions'
-  | 'sessions.create'
-  | 'sessions.rename'
-  | 'sessions.setArchived'
-  | 'sessions.setFavorite'
-  | 'sessions.remove'
-  | 'sessions.query'
-  | 'sessions.setSpace'
-  | 'sessions.search'
-  | 'sessions.onChanged'
-  | 'sessions.views'
-  | 'sessions.main'
-  | 'send'
-  | 'interrupt'
-  | 'shell'
-  | 'providerReady'
-  | 'steer'
-  | 'followUp'
-  | 'interactions'
-  | 'interactions.cancel'
-  | 'interactions.all'
-  | 'models'
-  | 'toolOutput'
-  | 'cancelTool'
-  | 'searchSync'
-  | 'references'
-  | 'paths'
-  | 'chips'
-  | 'chips.commit'
-  | 'chips.sessions'
-  | 'chips.context'
-  | 'chips.skills'
-  | 'chips.commands'
-  | 'badges'
-  | 'siteIcons';
-
-const CAPABILITIES: readonly ChatHostCapability[] = [
-  'sessions',
-  'sessions.create',
-  'sessions.rename',
-  'sessions.setArchived',
-  'sessions.setFavorite',
-  'sessions.remove',
-  'sessions.query',
-  'sessions.setSpace',
-  'sessions.search',
-  'sessions.onChanged',
-  'sessions.views',
-  'sessions.main',
-  'send',
-  'interrupt',
-  'shell',
-  'providerReady',
-  'steer',
-  'followUp',
-  'interactions',
-  'interactions.cancel',
-  'interactions.all',
-  'models',
-  'toolOutput',
-  'cancelTool',
-  'searchSync',
-  'references',
-  'paths',
-  'chips',
-  'chips.commit',
-  'chips.sessions',
-  'chips.context',
-  'chips.skills',
-  'chips.commands',
-  'badges',
-  'siteIcons',
-];
-
-/** The capabilities whose member is an object of methods, not a function. */
-const GROUPS: readonly ChatHostCapability[] = [
-  'sessions',
-  'sessions.views',
-  'interactions',
-  'searchSync',
-  'references',
-  'paths',
-  'chips',
-  'badges',
-  'siteIcons',
-];
-
-/** One thing the backend does while it runs a prompt, in order. */
-export type ChatHostScriptStep =
-  /** Stream a markdown reply with this text. */
-  | { kind: 'reply'; text: string }
-  /** Raise the request and wait until it is answered or dismissed, then go on with the next steps. */
-  | { kind: 'ask'; request: InteractionRequest }
-  /** Keep the run in flight until it is interrupted (always the last step). */
-  | { kind: 'hold' };
-
-/** What the backend behind the host holds, and how it answers a prompt. */
-export interface ChatHostContractBackend {
-  /** The sessions the backend starts with. */
-  sessions: readonly ChatSession[];
-  /** Stored events per session id (a session missing here has none). */
-  transcripts: Readonly<Record<string, readonly ChatEvent[]>>;
-  /** A tool call's full output, by call id (any session). */
-  toolOutputs: Readonly<Record<string, string>>;
-  /**
-   * What a run does with a sent prompt. The backend echoes the prompt into the transcript, starts the
-   * run, plays these steps, and ends the run when they are done (unless a step holds it).
-   */
-  script(prompt: string): readonly ChatHostScriptStep[];
-  /** What a `!` run of `command` prints; the backend streams it into the session's transcript (no prompt echo). */
-  shell(command: string): string;
-  /** Whether a model provider can answer a prompt. */
-  providerReady: boolean;
-  /** The orchestration Main session's id (created by the first ask), `null` while orchestration is off. */
-  mainSession: string | null;
-  /** Extension reference providers per folder, and the views of their keys by `providerId:key`. */
-  references: {
-    providers: Readonly<Record<string, readonly ReferenceProviderWire[]>>;
-    views: Readonly<Record<string, ExtensionReferenceView>>;
-  };
-  /** What each text names, per folder (a text missing here names nothing: `missing`). */
-  paths: Readonly<Record<string, Readonly<Record<string, ChatResolvedPath>>>>;
-  /** Commits by full sha (any folder). */
-  commits: Readonly<Record<string, ChatCommit>>;
-  /** The sessions `#chat` cards read. */
-  sessionFacts: readonly ChatSessionFacts[];
-  /** Context gauges by session id. */
-  contexts: Readonly<Record<string, ChatContextFacts>>;
-  /** Skills per folder. */
-  skills: Readonly<Record<string, readonly ChatSkillFacts[]>>;
-  /** Commands per folder. */
-  commands: Readonly<Record<string, readonly ChatCommandFacts[]>>;
-  /** The extensions' badge items per folder. */
-  badgeItems: Readonly<Record<string, readonly BadgeMenuItem[]>>;
-  /** The effect running an item answers, by item id. */
-  badgeEffects: Readonly<Record<string, BadgeActionEffect>>;
-  /** Site icons by origin (an origin missing here has none). */
-  siteIcons: Readonly<Record<string, string>>;
-}
-
-/** Changes the backend from outside, as another window or the backend does. */
-export interface ChatHostContractControl {
-  /** Another window changed a session's transcript search. */
-  searchChanged?(state: ChatSearchState): void;
-}
-
-/** A host built over a scripted backend, and how to tear it down. */
-export interface ChatHostHarness {
-  /** The host under test. */
-  host: ChatHost;
-  /** Changes the backend from outside. Absent: the behaviours that need it are skipped. */
-  control?: ChatHostContractControl;
-  /** Closes connections and timers after each test. */
-  dispose?(): void;
-}
-
-/** Builds a fresh host (and its backend) for one test. */
-export type ChatHostHarnessFactory = (backend: ChatHostContractBackend) => ChatHostHarness | Promise<ChatHostHarness>;
-
-/** The request a contract run raises when the script asks a question. */
-const CONTRACT_QUESTION: QuestionRequest = {
-  id: 'contract-q1',
-  origin: 'model',
-  kind: 'question',
-  tool: 'ask_user',
-  createdAt: 0,
-  payload: { questions: [{ id: 'name', type: 'text', prompt: 'Name?' }] },
-};
-
-const SESSIONS: readonly ChatSession[] = [
-  { id: 'c-1', title: 'First', status: 'idle', createdAt: 1, updatedAt: 2 },
-  { id: 'c-2', title: 'Second', status: 'idle', createdAt: 3, updatedAt: 4 },
-];
-
-function contractBackend(): ChatHostContractBackend {
-  return {
-    sessions: SESSIONS.map((s) => ({ ...s })),
-    transcripts: {
-      'c-1': [
-        { kind: 'user-prompt', text: 'earlier' },
-        { kind: 'markdown', text: 'earlier reply' },
-      ],
-    },
-    toolOutputs: { 'call-1': 'the full output' },
-    script(prompt) {
-      if (prompt === 'hold') return [{ kind: 'hold' }];
-      if (prompt === 'ask')
-        return [
-          { kind: 'ask', request: CONTRACT_QUESTION },
-          { kind: 'reply', text: 'after the answer' },
-        ];
-      return [{ kind: 'reply', text: `echo: ${prompt}` }];
-    },
-    shell: (command) => `ran ${command}`,
-    providerReady: true,
-    mainSession: 'c-main',
-    references: {
-      providers: { '/repo': [{ id: 'tickets', patterns: [{ regex: 'ZID-\\d+' }] }] },
-      views: { 'tickets:ZID-1': { label: 'ZID-1', status: 'Open' } },
-    },
-    paths: { '/repo': { 'a.ts': { kind: 'file', path: '/repo/src/a.ts' }, main: { kind: 'branch', name: 'main' } } },
-    commits: {
-      [CONTRACT_SHA]: {
-        sha: CONTRACT_SHA,
-        subject: 'Fix it',
-        author: 'Ada',
-        authoredAt: 5,
-        added: 3,
-        removed: 1,
-        files: 2,
-      },
-    },
-    sessionFacts: [{ id: 'c-1', title: 'First', status: 'idle', updatedAt: 2, prompts: 1, turns: 2 }],
-    contexts: { 'c-1': { modelId: 'm', usedLabel: '1k', windowLabel: '200k', fraction: 0.005 } },
-    skills: { '/repo': [{ name: 'review', description: 'Review a change' }] },
-    commands: { '/repo': [{ name: 'fix', description: 'Fix conflicts', aliases: ['f'] }] },
-    badgeItems: { '/repo': [{ source: 'ext', id: 'copy-key', label: 'Copy key' }] },
-    badgeEffects: { 'copy-key': { copy: 'ZID-1' } },
-    siteIcons: { 'https://example.com': 'data:image/png;base64,AAAA' },
-  };
-}
-
-const CONTRACT_SHA = 'abc1234def5678abc1234def5678abc1234def56';
-
-function member(host: ChatHost, capability: ChatHostCapability): unknown {
-  const [head, tail] = capability.split('.') as [keyof ChatHost, string | undefined];
-  const value = host[head] as Record<string, unknown> | undefined;
-  return tail ? value?.[tail] : value;
-}
-
-const waitFor = <T>(check: () => T) => vi.waitFor(check, { timeout: 3000, interval: 2 });
-
-/**
- * Declares the shared `ChatHost` suite for one implementation.
- *
- * @param name - The implementation's name, shown in the suite title.
- * @param makeHarness - Builds a fresh host over a backend that holds and does what it is given, once per test.
- * @param capabilities - The optional members the host offers. Every other optional member must be undefined.
- */
-export function describeChatHostContract(
-  name: string,
-  makeHarness: ChatHostHarnessFactory,
-  capabilities: readonly ChatHostCapability[],
-): void {
-  const has = (...needed: ChatHostCapability[]) => needed.every((c) => capabilities.includes(c));
-
-  describe(`ChatHost contract: ${name}`, () => {
-    const cleanup: (() => void)[] = [];
-    afterEach(() => {
-      for (const done of cleanup.splice(0).reverse()) done();
-    });
-
-    const setup = async () => {
-      const harness = await makeHarness(contractBackend());
-      cleanup.push(() => harness.dispose?.());
-      const host = harness.host;
-      /** Opens a transcript the way a component does (subscribed), waits for its history, and records every state. */
-      const watch = async (sessionId: string) => {
-        const transcript = host.transcript(sessionId);
-        const seen: TranscriptState[] = [];
-        cleanup.push(transcript.subscribe(() => seen.push(transcript.get())));
-        await waitFor(() => expect(transcript.get().hydrated).toBe(true));
-        return { get: () => transcript.get(), seen };
-      };
-      const list = () => host.sessions?.list.get() ?? [];
-      return { host, watch, list };
-    };
-
-    it('offers exactly its capabilities; the members it leaves out are undefined', async () => {
-      const { host } = await setup();
-      expect(typeof host.transcript).toBe('function');
-      for (const capability of CAPABILITIES) {
-        const value = member(host, capability);
-        if (!has(capability)) {
-          expect(value, capability).toBeUndefined();
-          continue;
-        }
-        if (GROUPS.includes(capability)) expect(typeof value, capability).toBe('object');
-        else if (capability === 'models') expect(Array.isArray(host.models?.get()), capability).toBe(true);
-        else expect(typeof value, capability).toBe('function');
-      }
-      if (has('sessions')) expect(typeof host.sessions?.list.subscribe).toBe('function');
-      if (has('interactions')) expect(typeof host.interactions?.pending).toBe('function');
-    });
-
-    it.skipIf(!has('sessions'))('lists the backend sessions', async () => {
-      const { list } = await setup();
-      await waitFor(() =>
-        expect(list().map(({ id, title }) => ({ id, title }))).toEqual(
-          expect.arrayContaining(SESSIONS.map(({ id, title }) => ({ id, title }))),
-        ),
-      );
-    });
-
-    it('reads a transcript and flags it hydrated', async () => {
-      const { watch } = await setup();
-      const t = await watch('c-1');
-      expect(t.get().running).toBe(false);
-      expect(t.get().events).toEqual([
-        expect.objectContaining({ kind: 'user-prompt', text: 'earlier' }),
-        expect.objectContaining({ kind: 'markdown', text: 'earlier reply' }),
-      ]);
-    });
-
-    it.skipIf(!has('sessions', 'sessions.create'))('creates a session that appears in the list', async () => {
-      const { host, watch, list } = await setup();
-      const made = await host.sessions!.create!({ title: 'Made' });
-      expect(made).toMatchObject({ title: 'Made' });
-      await waitFor(() => expect(list().find((s) => s.id === made.id)?.title).toBe('Made'));
-      const t = await watch(made.id);
-      expect(t.get().events).toEqual([]);
-    });
-
-    it.skipIf(!has('sessions', 'sessions.rename'))('renames a session', async () => {
-      const { host, list } = await setup();
-      await waitFor(() => expect(list().some((s) => s.id === 'c-1')).toBe(true));
-      await host.sessions!.rename!('c-1', 'Renamed');
-      await waitFor(() => expect(list().find((s) => s.id === 'c-1')?.title).toBe('Renamed'));
-    });
-
-    it.skipIf(!has('sessions', 'sessions.setArchived'))('archives and restores a session', async () => {
-      const { host, list } = await setup();
-      await waitFor(() => expect(list().some((s) => s.id === 'c-1')).toBe(true));
-      await host.sessions!.setArchived!('c-1', true);
-      await waitFor(() => expect(list().find((s) => s.id === 'c-1')?.archived).toBe(true));
-      await host.sessions!.setArchived!('c-1', false);
-      await waitFor(() => expect(list().find((s) => s.id === 'c-1')?.archived).toBeFalsy());
-    });
-
-    it.skipIf(!has('sessions', 'sessions.remove'))('removes a session', async () => {
-      const { host, list } = await setup();
-      await waitFor(() => expect(list().some((s) => s.id === 'c-1')).toBe(true));
-      await host.sessions!.remove!('c-1');
-      await waitFor(() => expect(list().some((s) => s.id === 'c-1')).toBe(false));
-      expect(list().some((s) => s.id === 'c-2')).toBe(true);
-    });
-
-    it.skipIf(!has('send'))('send echoes the prompt once and runs the reply to the end', async () => {
-      const { host, watch, list } = await setup();
-      const t = await watch('c-2');
-      await host.send!({ sessionId: 'c-2', prompt: 'hello' });
-      await waitFor(() => {
-        expect(t.get().running).toBe(false);
-        expect(t.get().events.some((e) => e.kind === 'markdown' && e.text === 'echo: hello')).toBe(true);
-      });
-      expect(t.seen.some((s) => s.running)).toBe(true);
-      expect(t.get().events.filter((e) => e.kind === 'user-prompt' && e.text === 'hello')).toHaveLength(1);
-      if (has('sessions')) await waitFor(() => expect(list().find((s) => s.id === 'c-2')?.status).toBe('completed'));
-    });
-
-    it.skipIf(!has('send'))('send with the echo off shows the prompt once, from the backend', async () => {
-      const { host, watch } = await setup();
-      const t = await watch('c-2');
-      await host.send!({ sessionId: 'c-2', prompt: 'quiet', echo: false, activatedSkills: [] });
-      await waitFor(() =>
-        expect(t.get().events.some((e) => e.kind === 'markdown' && e.text === 'echo: quiet')).toBe(true),
-      );
-      expect(t.get().events.filter((e) => e.kind === 'user-prompt' && e.text === 'quiet')).toHaveLength(1);
-    });
-
-    it.skipIf(!has('shell'))('a `!` shell run streams into the transcript without a prompt echo', async () => {
-      const { host, watch } = await setup();
-      const t = await watch('c-2');
-      await host.shell!('c-2', 'ls');
-      await waitFor(() => expect(t.get().events.some((e) => JSON.stringify(e).includes('ran ls'))).toBe(true));
-      expect(t.get().events.some((e) => e.kind === 'user-prompt')).toBe(false);
-    });
-
-    it.skipIf(!has('sessions.main'))('resolves the orchestration Main session', async () => {
-      const { host } = await setup();
-      await expect(host.sessions!.main!()).resolves.toBe('c-main');
-    });
-
-    it.skipIf(!has('providerReady'))('says whether a provider can answer', async () => {
-      const { host } = await setup();
-      await expect(host.providerReady!()).resolves.toBe(true);
-    });
-
-    it.skipIf(!has('send', 'interrupt'))('interrupt stops a run in flight', async () => {
-      const { host, watch, list } = await setup();
-      const t = await watch('c-2');
-      void host.send!({ sessionId: 'c-2', prompt: 'hold' }).catch(() => {});
-      await waitFor(() => expect(t.get().running).toBe(true));
-      host.interrupt!('c-2');
-      await waitFor(() => expect(t.get().running).toBe(false));
-      if (has('sessions')) await waitFor(() => expect(list().find((s) => s.id === 'c-2')?.status).not.toBe('running'));
-    });
-
-    it.skipIf(!has('send', 'interrupt', 'steer', 'followUp'))(
-      'steer and followUp resolve false when idle, true while a run is in flight',
-      async () => {
-        const { host, watch } = await setup();
-        const t = await watch('c-2');
-        expect(await host.steer!('c-2', 'nudge')).toBe(false);
-        expect(await host.followUp!('c-2', 'later')).toBe(false);
-        void host.send!({ sessionId: 'c-2', prompt: 'hold' }).catch(() => {});
-        await waitFor(() => expect(t.get().running).toBe(true));
-        expect(await host.steer!('c-2', 'nudge')).toBe(true);
-        expect(await host.followUp!('c-2', 'later')).toBe(true);
-        host.interrupt!('c-2');
-        await waitFor(() => expect(t.get().running).toBe(false));
-      },
-    );
-
-    it.skipIf(!has('send', 'interactions'))('raises a question, takes the answer, and runs on', async () => {
-      const { host, watch } = await setup();
-      const t = await watch('c-2');
-      const pending = host.interactions!.pending('c-2');
-      cleanup.push(pending.subscribe(() => {}));
-      expect(pending.get()).toEqual([]);
-      void host.send!({ sessionId: 'c-2', prompt: 'ask' }).catch(() => {});
-      await waitFor(() =>
-        expect(pending.get()).toEqual([
-          expect.objectContaining({ requestId: CONTRACT_QUESTION.id, sessionId: 'c-2', request: CONTRACT_QUESTION }),
-        ]),
-      );
-      await host.interactions!.answer(CONTRACT_QUESTION.id, { kind: 'question', answers: { name: 'Ada' } });
-      await waitFor(() => expect(pending.get()).toEqual([]));
-      await waitFor(() => {
-        expect(t.get().events.some((e) => e.kind === 'markdown' && e.text === 'after the answer')).toBe(true);
-        expect(t.get().running).toBe(false);
-      });
-    });
-
-    it.skipIf(!has('send', 'interactions.all'))("lists every session's requests together", async () => {
-      const { host, watch } = await setup();
-      await watch('c-2');
-      const all = host.interactions!.all!();
-      cleanup.push(all.subscribe(() => {}));
-      void host.send!({ sessionId: 'c-2', prompt: 'ask' }).catch(() => {});
-      await waitFor(() =>
-        expect(all.get()).toEqual([expect.objectContaining({ requestId: CONTRACT_QUESTION.id, sessionId: 'c-2' })]),
-      );
-      await host.interactions!.answer(CONTRACT_QUESTION.id, { kind: 'question', answers: { name: 'Ada' } });
-      await waitFor(() => expect(all.get()).toEqual([]));
-    });
-
-    it.skipIf(!has('send', 'interactions', 'interactions.cancel'))(
-      'dismisses a question and the run goes on',
-      async () => {
-        const { host, watch } = await setup();
-        const t = await watch('c-2');
-        const pending = host.interactions!.pending('c-2');
-        cleanup.push(pending.subscribe(() => {}));
-        void host.send!({ sessionId: 'c-2', prompt: 'ask' }).catch(() => {});
-        await waitFor(() => expect(pending.get().map((i) => i.requestId)).toEqual([CONTRACT_QUESTION.id]));
-        await host.interactions!.cancel!(CONTRACT_QUESTION.id);
-        await waitFor(() => expect(pending.get()).toEqual([]));
-        await waitFor(() => expect(t.get().running).toBe(false));
-      },
-    );
-
-    it.skipIf(!has('toolOutput'))("reads a tool call's full output", async () => {
-      const { host } = await setup();
-      expect(await host.toolOutput!('c-1', 'call-1')).toBe('the full output');
-      expect(await host.toolOutput!('c-1', 'call-unknown')).toBeNull();
-    });
-
-    it.skipIf(!has('searchSync'))("shares a session's search with its other windows", async () => {
-      const harness = await makeHarness(contractBackend());
-      cleanup.push(() => harness.dispose?.());
-      const sync = harness.host.searchSync!;
-      await expect(sync.set('c-1', { active: true, query: 'needle' })).resolves.toBeUndefined();
-      if (!harness.control?.searchChanged) return;
-      const seen: ChatSearchState[] = [];
-      cleanup.push(sync.onChanged((state) => seen.push(state)));
-      harness.control.searchChanged({ sessionId: 'c-2', active: true, query: 'other' });
-      await waitFor(() => expect(seen).toEqual([{ sessionId: 'c-2', active: true, query: 'other' }]));
-    });
-
-    it.skipIf(!has('references'))('lists reference providers per folder and resolves their keys', async () => {
-      const { host } = await setup();
-      const references = host.references!;
-      expect((await references.providers('/repo'))?.map((p) => p.id)).toEqual(['tickets']);
-      expect(await references.providers('/elsewhere')).toEqual([]);
-      const views = await references.resolve('/repo', [
-        { providerId: 'tickets', key: 'ZID-1' },
-        { providerId: 'tickets', key: 'ZID-404' },
-      ]);
-      expect(views.map((v) => v?.label ?? null)).toEqual(['ZID-1', null]);
-    });
-
-    it.skipIf(!has('paths'))('says what each text in prose names on disk', async () => {
-      const { host } = await setup();
-      expect(await host.paths!.resolve('/repo', ['a.ts', 'main', 'nope.ts'])).toEqual([
-        { kind: 'file', path: '/repo/src/a.ts' },
-        { kind: 'branch', name: 'main' },
-        { kind: 'missing' },
-      ]);
-    });
-
-    it.skipIf(!has('chips.commit'))("reads a commit for a sha chip's card", async () => {
-      const { host } = await setup();
-      expect((await host.chips!.commit!('/repo', CONTRACT_SHA))?.subject).toBe('Fix it');
-      expect(await host.chips!.commit!('/repo', 'ffffffffffffffffffffffffffffffffffffffff')).toBeNull();
-    });
-
-    it.skipIf(!has('chips.sessions'))('lists the sessions a #chat chip can name', async () => {
-      const { host } = await setup();
-      expect((await host.chips!.sessions!()).map((s) => s.id)).toContain('c-1');
-    });
-
-    it.skipIf(!has('chips.context'))("reads a session's context gauge", async () => {
-      const { host } = await setup();
-      const context = await host.chips!.context!('c-1');
-      // The labels are the host's to format (the desktop app's and a server's read `200.0k`).
-      expect(context).toMatchObject({ modelId: 'm', fraction: 0.005 });
-      expect(context?.windowLabel).toMatch(/^200(\.0)?k$/);
-    });
-
-    it.skipIf(!has('chips.skills'))("lists a folder's skills", async () => {
-      const { host } = await setup();
-      expect((await host.chips!.skills!('/repo')).map((s) => s.name)).toContain('review');
-    });
-
-    it.skipIf(!has('chips.commands'))("lists a folder's commands", async () => {
-      const { host } = await setup();
-      expect((await host.chips!.commands!('/repo', null)).map((c) => c.name)).toContain('fix');
-    });
-
-    it.skipIf(!has('sessions', 'sessions.query'))("queries a host's sessions under the archive filter", async () => {
-      const { host } = await setup();
-      const rows = await host.sessions!.query!({ archive: 'all' });
-      expect(rows.map((s) => s.id).sort()).toEqual(['c-1', 'c-2']);
-      for (const row of rows) expect(typeof row.cwd).toBe('string');
-      if (has('sessions.setArchived')) {
-        await host.sessions!.setArchived!('c-1', true);
-        expect((await host.sessions!.query!({ archive: 'active' })).map((s) => s.id)).toEqual(['c-2']);
-        expect((await host.sessions!.query!({ archive: 'archived' })).map((s) => s.id)).toEqual(['c-1']);
-      }
-    });
-
-    it.skipIf(!has('sessions', 'sessions.query', 'sessions.setSpace'))('moves a session to a space', async () => {
-      const { host } = await setup();
-      await host.sessions!.setSpace!('c-1', 'work');
-      await waitFor(async () =>
-        expect((await host.sessions!.query!({ archive: 'all' })).find((s) => s.id === 'c-1')?.spaceId).toBe('work'),
-      );
-    });
-
-    it.skipIf(!has('sessions', 'sessions.search'))('finds a conversation by its content', async () => {
-      const { host } = await setup();
-      const hits = await host.sessions!.search!('earlier reply', { archive: 'all' });
-      expect(hits.map((h) => h.sessionId)).toEqual(['c-1']);
-      expect(hits[0]?.matchCount).toBeGreaterThan(0);
-      expect(await host.sessions!.search!('nothing like this', { archive: 'all' })).toEqual([]);
-    });
-
-    it.skipIf(!has('sessions', 'sessions.onChanged', 'sessions.rename'))('signals a changed session', async () => {
-      const { host } = await setup();
-      const seen: string[] = [];
-      cleanup.push(host.sessions!.onChanged!((id) => seen.push(id)));
-      await host.sessions!.rename!('c-2', 'Renamed');
-      await waitFor(() => expect(seen).toContain('c-2'));
-    });
-
-    it.skipIf(!has('sessions', 'sessions.views'))('keeps the sidebar views and the shown space', async () => {
-      const { host } = await setup();
-      const views = host.sessions!.views!;
-      // A space's record: its view and the conversation last open in it.
-      const view = {
-        archive: 'all',
-        project: null,
-        activity: '7d',
-        groupBy: 'date',
-        sortBy: 'recency',
-        session: 'c-1',
-      } as const;
-      await views.setView('work', view);
-      expect(((await views.getViews()) as Record<string, unknown>).work).toEqual(view);
-      await views.setSpace('work');
-      expect(await views.getSpace()).toBe('work');
-    });
-
-    it.skipIf(!has('siteIcons'))("loads a site's icon once, and says when it lands", async () => {
-      const { host } = await setup();
-      const icons = host.siteIcons!;
-      const landed = vi.fn();
-      cleanup.push(icons.subscribe(landed));
-      icons.request('https://example.com');
-      icons.request('https://example.com');
-      await waitFor(() => expect(icons.get('https://example.com')).toBe('data:image/png;base64,AAAA'));
-      expect(landed).toHaveBeenCalled();
-      icons.request('https://none.example');
-      await new Promise((r) => setTimeout(r, 10));
-      expect(icons.get('https://none.example')).toBeNull();
-    });
-
-    it.skipIf(!has('badges'))("lists a badge's extension actions and runs one", async () => {
-      const { host } = await setup();
-      const target = { kind: 'reference' as const, text: 'ZID-1' };
-      expect((await host.badges!.actions('/repo', target)).map((i) => i.id)).toEqual(['copy-key']);
-      expect(await host.badges!.run('/repo', 'ext', 'copy-key', target)).toEqual({ copy: 'ZID-1' });
-    });
-  });
-}
-
-/** The rich composer's host contract (`ComposerHost`). */
-export * from './composer.contract';
-/** The sidebar's host contract (`SidebarHost`). */
-export * from './sidebar.contract';