zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/composer/run-meter.ts

@@ -1,228 +0,0 @@
-/**
- * Per-session counters of the current run, for the composer's run chip and
- * the cost pill: when it started, the output tokens of its settled parent
- * turns, the cost of turns settled since the last cost read, and the
- * streaming turn's live counters (`stream:progress`).
- *
- * Kept per session, outside React, from every session's stream signals
- * (`handle`): an app keeps one for the window's life, so switching
- * conversations never resets them. The live counters tick about 4 times a
- * second, so only the pills read them.
- */
-import type { Readable } from '../store';
-import type { LiveStreamProgress } from './live-cost';
-
-/** One session's run counters. */
-export interface RunMeterState {
-  /**
-   * When the run began: the host's `run:start` stamp, else its saved run
-   * record (a session row's `runStartedAt`, or the read of a run this window
-   * joined mid-way), else when this window first saw it (an older host, which
-   * sends neither).
-   */
-  startedAt: number | null;
-  /** Where `startedAt` came from: the host's own signal wins, the run's record corrects a first sighting. */
-  startedFrom: 'host' | 'record' | 'seen' | null;
-  /**
-   * Output tokens of the run's settled parent turns: the host's count from
-   * each `turn:end` (`runOutputTokens`) or the joined run's read, summed
-   * here only for an older host.
-   */
-  outputTokens: number;
-  /** Σ `turn:end` usage cost since the last cost read that settled it (`settleCost`). */
-  accruedCost: number;
-  /**
-   * Bumped at each run's start and end: a read issued during one run must
-   * not land on the next state (settle a newer run's accrual, seed a run
-   * that has ended).
-   */
-  generation: number;
-  /** The streaming parent turn's live counters, `null` between turns. */
-  progress: LiveStreamProgress | null;
-}
-
-/** The counters of a session with no run seen. */
-export const EMPTY_RUN_METER: RunMeterState = Object.freeze({
-  startedAt: null,
-  startedFrom: null,
-  outputTokens: 0,
-  accruedCost: 0,
-  generation: 0,
-  progress: null,
-});
-
-/** The stream signals the meter follows (the host's `HostSignal` variants, structurally). */
-export type RunMeterSignal =
-  | { kind: 'run:start'; sessionId: string; startedAt?: number }
-  | {
-      kind: 'stream:progress';
-      sessionId: string;
-      turnId: string;
-      outputTokens: number;
-      estimated: boolean;
-      elapsedMs: number;
-      estCostUsd?: number;
-    }
-  | {
-      kind: 'turn:end';
-      sessionId: string;
-      childId?: string;
-      usage?: { output?: number; cost?: number };
-      runOutputTokens?: number;
-    }
-  | { kind: 'run:end'; sessionId: string };
-
-/** A session row's word on its run (the session list's `runStartedAt`). */
-export interface RunMeterRow {
-  /** The session. */
-  id: string;
-  /** Its status (`running` counts). */
-  status: string;
-  /** When its run began (epoch ms). */
-  runStartedAt?: number;
-}
-
-/** The run counters of every session. */
-export interface RunMeter {
-  /** Follows one stream signal. Other kinds are ignored. */
-  handle(signal: { kind: string; sessionId?: string }): void;
-  /** Drops a deleted session's counters. */
-  forget(sessionId: string): void;
-  /** A session's counters as a store (one per session, the same each call). */
-  session(sessionId: string): Readable<RunMeterState>;
-  /** A session's counters now. */
-  get(sessionId: string): RunMeterState;
-  /** A running run with no start known yet counts from now. */
-  noteSeen(sessionId: string): void;
-  /** The session list's run starts: a window that missed a `run:start` times the run from its real start. */
-  noteStarts(rows: readonly RunMeterRow[]): void;
-  /** A run this window joined midway, as its host counts it; dropped when the run changed while it was read. */
-  noteProgress(sessionId: string, generation: number, progress: { startedAt: number; outputTokens: number }): void;
-  /** The session's run generation, to hand back to `settleCost` / `noteProgress`. */
-  generation(sessionId: string): number;
-  /** A cost read issued while idle settled every turn: zero the accrual, unless a newer run started since. */
-  settleCost(sessionId: string, generation: number): void;
-}
-
-/**
- * Creates an empty {@link RunMeter}.
- *
- * @param now - The clock (epoch ms), for runs whose start the host does not stamp.
- */
-export function createRunMeter(now: () => number = () => Date.now()): RunMeter {
-  const meters = new Map<string, RunMeterState>();
-  const listeners = new Map<string, Set<() => void>>();
-  const stores = new Map<string, Readable<RunMeterState>>();
-
-  const get = (sessionId: string): RunMeterState => meters.get(sessionId) ?? EMPTY_RUN_METER;
-  const notify = (sessionId: string) => {
-    for (const listener of listeners.get(sessionId) ?? []) listener();
-  };
-  const update = (sessionId: string, patch: Partial<RunMeterState>): void => {
-    const prev = get(sessionId);
-    const next = { ...prev, ...patch };
-    if ((Object.keys(patch) as (keyof RunMeterState)[]).every((k) => prev[k] === next[k])) return;
-    meters.set(sessionId, next);
-    notify(sessionId);
-  };
-  const subscribe = (sessionId: string, listener: () => void): (() => void) => {
-    let set = listeners.get(sessionId);
-    if (!set) {
-      set = new Set();
-      listeners.set(sessionId, set);
-    }
-    set.add(listener);
-    return () => {
-      set.delete(listener);
-      if (set.size === 0 && listeners.get(sessionId) === set) listeners.delete(sessionId);
-    };
-  };
-
-  const handle = (raw: { kind: string; sessionId?: string }): void => {
-    if (typeof raw.sessionId !== 'string') return;
-    const signal = raw as RunMeterSignal;
-    const id = signal.sessionId;
-    const meter = get(id);
-    switch (signal.kind) {
-      case 'run:start':
-        update(id, {
-          startedAt: signal.startedAt ?? now(),
-          startedFrom: signal.startedAt !== undefined ? 'host' : 'seen',
-          outputTokens: 0,
-          // The previous run's turns are in `run.cost` now; this run accrues from zero.
-          accruedCost: 0,
-          generation: meter.generation + 1,
-          progress: null,
-        });
-        return;
-      case 'stream:progress':
-        update(id, {
-          progress: {
-            turnId: signal.turnId,
-            outputTokens: signal.outputTokens,
-            estimated: signal.estimated,
-            elapsedMs: signal.elapsedMs,
-            ...(signal.estCostUsd !== undefined ? { estCostUsd: signal.estCostUsd } : {}),
-          },
-        });
-        return;
-      case 'turn:end': {
-        const parent = signal.childId === undefined;
-        // The host's count as is: one this window seeded mid-run never takes a turn twice.
-        const outputTokens = signal.runOutputTokens ?? meter.outputTokens + (signal.usage?.output ?? 0);
-        update(id, {
-          ...(parent ? { progress: null, outputTokens } : {}),
-          accruedCost: meter.accruedCost + (signal.usage?.cost ?? 0),
-        });
-        return;
-      }
-      case 'run:end':
-        update(id, { progress: null, startedAt: null, startedFrom: null, generation: meter.generation + 1 });
-        return;
-      default:
-    }
-  };
-
-  return {
-    handle,
-    forget(sessionId) {
-      stores.delete(sessionId);
-      if (meters.delete(sessionId)) notify(sessionId);
-    },
-    session(sessionId) {
-      let store = stores.get(sessionId);
-      if (!store) {
-        store = { get: () => get(sessionId), subscribe: (listener) => subscribe(sessionId, listener) };
-        stores.set(sessionId, store);
-      }
-      return store;
-    },
-    get,
-    noteSeen(sessionId) {
-      if (get(sessionId).startedAt === null) update(sessionId, { startedAt: now(), startedFrom: 'seen' });
-    },
-    noteStarts(rows) {
-      for (const row of rows) {
-        if (row.status !== 'running' || row.runStartedAt === undefined) continue;
-        const meter = get(row.id);
-        // The host's own `run:start` stamp stays: a row can be older than it.
-        if (meter.startedFrom !== 'host' && meter.startedAt !== row.runStartedAt) {
-          update(row.id, { startedAt: row.runStartedAt, startedFrom: 'record' });
-        }
-      }
-    },
-    noteProgress(sessionId, generation, progress) {
-      const meter = get(sessionId);
-      if (meter.generation !== generation) return;
-      update(sessionId, {
-        ...(meter.startedFrom !== 'host' ? { startedAt: progress.startedAt, startedFrom: 'record' as const } : {}),
-        // Never back: a `turn:end` that came meanwhile carries a newer count.
-        outputTokens: Math.max(meter.outputTokens, progress.outputTokens),
-      });
-    },
-    generation: (sessionId) => get(sessionId).generation,
-    settleCost(sessionId, generation) {
-      if (get(sessionId).generation === generation) update(sessionId, { accruedCost: 0 });
-    },
-  };
-}

package/src/chat/headless/composer-modes.ts

@@ -1,170 +0,0 @@
-/**
- * Composer prompt modes — pure state-machine helpers for the `!` (shell)
- * and `?` (transcript search) sentinels, mirroring the TUI's grammar
- * (src/tui/prompt/ `useSyncBuffer` / `usePromptKeyDown`):
- *
- *   - Entry: the sentinel must be TYPED as the first character of an
- *     empty composer (exactly-one-char transition — pasted/recalled
- *     `!cmd` stays literal text). The sentinel is consumed; it never
- *     enters the buffer.
- *   - Exit: Backspace with the caret at offset 0 leaves the mode
- *     (search also exits on Delete-at-0 and on Esc; shell does NOT
- *     exit on Esc — TUI parity).
- *   - Submit (shell): the bang is re-attached (`!cmd`) so the host
- *     routing and prompt history keep the TUI's on-disk grammar; a
- *     blank command is a no-op.
- *   - History: `!`-prefixed entries recall INTO shell mode with the
- *     bang stripped; stashing a shell-mode draft re-encodes the bang.
- *
- * Kept free of TipTap/React so the grammar is unit-testable.
- */
-
-export type ComposerMode = 'normal' | 'shell' | 'search';
-
-/**
- * Mode entered by typing `char` into the composer, or `null` when the
- * keystroke should be handled as ordinary input. Requires an empty
- * buffer and no active mode — matches the TUI's exactly-`!` /
- * exactly-`?` on `lastSynced === ''` checks (`useSyncBuffer`,
- * src/tui/prompt/use-sync-buffer.ts).
- *
- * @param char - The character just typed.
- * @param mode - The composer's mode now.
- * @param bufferEmpty - Whether the composer was empty before it.
- */
-export function modeForTypedChar(char: string, mode: ComposerMode, bufferEmpty: boolean): ComposerMode | null {
-  if (mode !== 'normal' || !bufferEmpty) {
-    return null;
-  }
-
-  if (char === '!') {
-    return 'shell';
-  }
-
-  if (char === '?') {
-    return 'search';
-  }
-
-  return null;
-}
-
-/**
- * Is the caret effectively at the buffer start for the mode-exit check?
- *
- * The obvious answer (`selection.empty && from === atStart`) misses a
- * ProseMirror trap: Cmd/Ctrl+A creates an `AllSelection`, and deleting
- * it leaves that SAME AllSelection spanning the now-empty doc — `empty`
- * stays `false`, `from` stays `0` — until a click or a typed character
- * replaces it. Without the empty-doc escape hatch, Backspace after a
- * select-all-clear can never exit shell mode (Esc doesn't exit it
- * either), so the mode — and its ghost-autocomplete suppression — stick
- * for the rest of the draft.
- *
- * A Backspace on an empty doc is a no-op edit whatever the selection
- * shape — exactly the TUI's "backspace at offset 0" exit trigger
- * (`handleShellExitKey`, src/tui/prompt/prompt-key-handlers.ts).
- *
- * @param selection - The editor's selection: where the caret is and whether it spans text.
- * @param atStartPos - The document position of the start of the text.
- * @param docEmpty - Whether the document holds no text.
- */
-export function caretEffectivelyAtStart(
-  selection: { empty: boolean; from: number },
-  atStartPos: number,
-  docEmpty: boolean,
-): boolean {
-  if (selection.empty) {
-    return selection.from === atStartPos;
-  }
-
-  return docEmpty;
-}
-
-/**
- * Whether `key` (a DOM `KeyboardEvent.key`) exits the active mode.
- * `caretAtStart` = collapsed selection at buffer offset 0.
- *
- *   - shell: Backspace-at-0 only (`handleShellExitKey`) — Esc stays free
- *     for its global meaning (stop run).
- *   - search: Backspace/Delete-at-0 (`isTranscriptSearchExitKey`,
- *     src/tui/prompt/prompt-key-handlers.ts) or Esc (`usePromptModes`,
- *     src/tui/prompt/use-prompt-modes.ts).
- *
- * @param mode - The composer's mode now.
- * @param key - The key pressed (`KeyboardEvent.key`).
- * @param caretAtStart - Whether the caret is at the start of the text.
- */
-export function exitsModeOnKey(mode: ComposerMode, key: string, caretAtStart: boolean): boolean {
-  if (mode === 'shell') {
-    return key === 'Backspace' && caretAtStart;
-  }
-
-  if (mode === 'search') {
-    return key === 'Escape' || ((key === 'Backspace' || key === 'Delete') && caretAtStart);
-  }
-
-  return false;
-}
-
-/**
- * Final submit text for the active mode, or `null` when the submit is
- * a no-op. Shell re-attaches the consumed bang (TUI `submit` in
- * src/tui/prompt/use-composer-actions.ts);
- * a blank shell command never submits, even with attachments staged.
- * Search mode never submits — Enter navigates matches instead.
- *
- * @param mode - The composer's mode.
- * @param text - The composer's text.
- */
-export function composeSubmitText(mode: ComposerMode, text: string): string | null {
-  if (mode === 'search') {
-    return null;
-  }
-
-  if (mode === 'shell') {
-    const command = text.trim();
-
-    return command.length > 0 ? `!${command}` : null;
-  }
-
-  return text;
-}
-
-/**
- * A submit that was not sent (its chat could not be created) back as the
- * draft it came from: the box is cleared on Enter, so a failure must not
- * lose what was typed. The inverse of {@link composeSubmitText}.
- *
- * @param submitted - The text the composer submitted (a `!` command keeps its sentinel).
- */
-export function unsentDraft(submitted: string): { text: string; shell: boolean } {
-  return submitted.startsWith('!') ? { text: submitted.slice(1), shell: true } : { text: submitted, shell: false };
-}
-
-/**
- * Encode the in-progress draft for the prompt-history stash so a
- * shell-mode draft survives the cycle round trip with its bang
- * (`usePromptHistory`, src/tui/prompt/use-prompt-history.ts). Search-mode drafts are never stashed (history
- * cycling is disabled in search mode).
- *
- * @param mode - The composer's mode the entry was sent in.
- * @param text - The text sent.
- */
-export function encodeHistoryDraft(mode: ComposerMode, text: string): string {
-  return mode === 'shell' ? `!${text}` : text;
-}
-
-/**
- * Decode a recalled history entry: `!`-prefixed entries recall INTO
- * shell mode with the bang stripped (`applyRecalledPrompt`,
- * src/tui/prompt/use-prompt-history.ts); everything else recalls as a normal prompt.
- *
- * @param entry - A prompt history entry.
- */
-export function decodeHistoryEntry(entry: string): { mode: 'normal' | 'shell'; text: string } {
-  if (entry.startsWith('!')) {
-    return { mode: 'shell', text: entry.slice(1) };
-  }
-
-  return { mode: 'normal', text: entry };
-}

package/src/chat/headless/draft-scope.ts

@@ -1,136 +0,0 @@
-/**
- * The new-chat draft's scope: its id, the local folder picked for it and that
- * folder's project root. Only a local folder makes a draft scope (a folderless
- * draft, or one on a server or machine, has none). The id is renewed after
- * each send, and when the draft moves to another project, so what was opened
- * in one draft (its terminals, its layout) never leaks into the next.
- */
-import type { Readable } from './store';
-
-/** The draft's state, as {@link DraftScopeStore} holds it. */
-export interface DraftScopeState {
-  /** The draft's id (what its terminals open under). */
-  id: string;
-  /** The local folder picked for the draft, `null` for none (or not local). */
-  folder: string | null;
-  /** The folder's project root once resolved. */
-  root: string | null;
-}
-
-/** A draft's scope: where its terminals and layout attach. */
-export interface DraftScope {
-  /** The project root. */
-  root: string;
-  /** The folder things open in. */
-  cwd: string;
-  /** The draft's id. */
-  draft: string;
-}
-
-/** What {@link createDraftScopeStore} asks the app. */
-export interface DraftScopeStoreOptions {
-  /** The folder's project root (worktrees fold into their main checkout); `null` when unknown. */
-  projectRoot(folder: string): Promise<string | null>;
-  /** A draft id was replaced: release what was opened under it (its terminals stay with the old project). */
-  release?(draftId: string): void;
-  /** A draft id is never shown again: forget what was kept for it (its layout record). */
-  forget?(draftId: string): void;
-  /** A new draft id. Default: `crypto.randomUUID`, else a time-and-random id. */
-  newId?(): string;
-}
-
-/** The draft's scope, readable (`get` returns the same state until it changes). */
-export interface DraftScopeStore extends Readable<DraftScopeState> {
-  /** The draft's local folder (`null` for folderless, server or machine drafts). */
-  publishFolder(folder: string | null): void;
-  /** A send turned the draft into a session: the next draft starts fresh. */
-  renew(): void;
-  /** The draft's scope, `null` while it has no local folder or its root is still resolving. */
-  scope(): DraftScope | null;
-  /** Back to a fresh draft with nothing cached (tests). */
-  reset(): void;
-}
-
-function randomId(): string {
-  return typeof crypto !== 'undefined' && 'randomUUID' in crypto
-    ? crypto.randomUUID()
-    : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-}
-
-/**
- * The scope of a draft state, `null` while it has none.
- *
- * @param state - The draft's state.
- */
-export function draftScopeOf(state: DraftScopeState): DraftScope | null {
-  return state.folder && state.root ? { root: state.root, cwd: state.folder, draft: state.id } : null;
-}
-
-/**
- * Creates the draft's scope store.
- *
- * @param options - How roots resolve and what a replaced id releases.
- */
-export function createDraftScopeStore(options: DraftScopeStoreOptions): DraftScopeStore {
-  const newId = options.newId ?? randomId;
-  const listeners = new Set<() => void>();
-  const roots = new Map<string, string | null>();
-  let draft: DraftScopeState = { id: newId(), folder: null, root: null };
-  /** The project root the current id has been scoped to, `null` before it had one. */
-  let idRoot: string | null = null;
-
-  const forget = (id: string) => options.forget?.(id);
-
-  const set = (input: DraftScopeState) => {
-    let next = input;
-    // Moved to another project: its terminals stay with the old one, under a new id.
-    if (next.id === draft.id && next.root && idRoot && next.root !== idRoot) {
-      const old = draft.id;
-      options.release?.(old);
-      forget(old);
-      next = { ...next, id: newId() };
-    }
-    if (next.root) idRoot = next.root;
-    if (next.id === draft.id && next.folder === draft.folder && next.root === draft.root) return;
-    draft = next;
-    for (const listener of listeners) listener();
-  };
-
-  return {
-    get: () => draft,
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    publishFolder(folder) {
-      if (folder === draft.folder) return;
-      if (!folder) {
-        set({ ...draft, folder: null, root: null });
-        return;
-      }
-      if (roots.has(folder)) {
-        set({ ...draft, folder, root: roots.get(folder) ?? null });
-        return;
-      }
-      set({ ...draft, folder, root: null });
-      void options
-        .projectRoot(folder)
-        .catch(() => null)
-        .then((root) => {
-          roots.set(folder, root);
-          if (draft.folder === folder) set({ ...draft, root });
-        });
-    },
-    renew() {
-      idRoot = null;
-      forget(draft.id);
-      set({ ...draft, id: newId() });
-    },
-    scope: () => draftScopeOf(draft),
-    reset() {
-      draft = { id: newId(), folder: null, root: null };
-      idRoot = null;
-      roots.clear();
-    },
-  };
-}

package/src/chat/headless/draft-target.ts

@@ -1,87 +0,0 @@
-/**
- * Where the new-chat draft runs, as rules: the recent folders its folder menu
- * offers, the folder it is in, and when that folder makes the window's draft
- * scope. The app keeps the picks (they reset with the draft) and feeds them in.
- */
-
-/** A session row as {@link recentLocalFolders} reads it. */
-export interface DraftFolderSource {
-  /** The session's folder (`''`: none). */
-  cwd?: string | null;
-  /** Set for a server's session: its folders are not on this computer. */
-  hostId?: string | null;
-}
-
-/**
- * This computer's recent folders, most recent first (the rows' order), each once.
- *
- * @param sessions - The session rows, most recently updated first.
- * @param limit - How many to keep.
- */
-export function recentLocalFolders(sessions: readonly DraftFolderSource[], limit = 5): string[] {
-  const seen = new Set<string>();
-  const out: string[] = [];
-  for (const s of sessions) {
-    if (!s.cwd || s.hostId || seen.has(s.cwd)) continue;
-    seen.add(s.cwd);
-    out.push(s.cwd);
-    if (out.length >= limit) break;
-  }
-  return out;
-}
-
-/**
- * A saved server's recent folders (its sessions' folders there), most recent first, each once.
- *
- * @param sessions - The session rows, most recently updated first.
- * @param hostId - The server.
- * @param limit - How many to keep.
- */
-export function recentHostFolders(sessions: readonly DraftFolderSource[], hostId: string, limit = 5): string[] {
-  const seen = new Set<string>();
-  const out: string[] = [];
-  for (const s of sessions) {
-    if (!s.cwd || s.hostId !== hostId || seen.has(s.cwd)) continue;
-    seen.add(s.cwd);
-    out.push(s.cwd);
-    if (out.length >= limit) break;
-  }
-  return out;
-}
-
-/** What {@link draftFolderPath} and {@link draftLocalFolder} read. */
-export interface DraftFolderState {
-  /** The open session's folder (`''` for none); `undefined` on the draft. */
-  sessionCwd?: string;
-  /** The draft runs on a saved server. */
-  onServer: boolean;
-  /** The draft runs on a machine's environment. */
-  onMachine?: boolean;
-  /** "Start without a folder" was picked for this draft. */
-  folderless: boolean;
-  /** The folder new chats open in (`null`: none picked yet). */
-  defaultFolder: string | null;
-}
-
-/**
- * The conversation's folder: `null` while the draft has none picked (the
- * folder gate shows), `''` for none (a server's draft has none on this
- * computer), else the folder.
- *
- * @param state - The draft's picks, or the open session's folder.
- */
-export function draftFolderPath(state: DraftFolderState): string | null {
-  if (state.sessionCwd !== undefined) return state.sessionCwd;
-  return state.onServer || state.folderless ? '' : state.defaultFolder;
-}
-
-/**
- * The draft's folder when it is a folder on this computer, the only kind that
- * makes a draft scope (a server's or machine's draft, or a folderless one, has none).
- *
- * @param state - The draft's picks (`sessionCwd` set: not a draft, `null`).
- */
-export function draftLocalFolder(state: DraftFolderState): string | null {
-  if (state.sessionCwd !== undefined || state.onServer || state.onMachine || state.folderless) return null;
-  return draftFolderPath(state) || null;
-}

package/src/chat/headless/extension-sources.ts

@@ -1,64 +0,0 @@
-/**
- * The chat's extension references and badge actions read from the
- * extensions host (`ExtensionsHost`: its `reference` and `badge-action`
- * items, resolved and run through `invoke`), for an app whose chat host
- * leaves `references` / `badges` out. A chat host that has them keeps them:
- * zidane's registry already serves the extensions' `Reference` and `BadgeAction`
- * items through those members, so the chat reads one source, never both.
- *
- * The extensions host follows the folder on screen, so `cwd` is not
- * consulted: the providers are the ones loaded there.
- */
-import type { BadgeActionEffect, BadgeMenuItem, BadgeTarget } from 'zidane/chat/pure';
-
-import type { ExtensionsHost } from '../../extensions/headless/host';
-import type { ChatBadgeActions, ChatReferences } from './transcript-host';
-
-const references = new WeakMap<ExtensionsHost, ChatReferences>();
-const badges = new WeakMap<ExtensionsHost, ChatBadgeActions>();
-
-/**
- * The extensions host's references as the chat reads them, or `undefined` when it can't resolve any.
- *
- * @param host - The extensions host.
- */
-export function extensionsChatReferences(host: ExtensionsHost | null | undefined): ChatReferences | undefined {
-  if (!host?.invoke) return undefined;
-  let made = references.get(host);
-  if (!made) {
-    const invoke = host.invoke.bind(host);
-    const items = host.items.reference;
-    made = {
-      providers: async () => items.get().map((e) => e.item),
-      resolve: (_cwd, list) =>
-        Promise.all(
-          list.map(({ providerId, key }) => invoke('reference.resolve', { providerId, key }).catch(() => null)),
-        ),
-      onChanged: (listener) => items.subscribe(() => listener({ kind: 'all' })),
-    };
-    references.set(host, made);
-  }
-  return made;
-}
-
-/**
- * The extensions host's badge actions as the badge menu reads them, or `undefined` when it can't run any.
- *
- * @param host - The extensions host.
- */
-export function extensionsBadgeActions(host: ExtensionsHost | null | undefined): ChatBadgeActions | undefined {
-  if (!host?.invoke) return undefined;
-  let made = badges.get(host);
-  if (!made) {
-    const invoke = host.invoke.bind(host);
-    const items = host.items['badge-action'];
-    made = {
-      actions: async (_cwd: string, target: BadgeTarget): Promise<readonly BadgeMenuItem[]> =>
-        items.get().length === 0 ? [] : invoke('badge.menu', { target }),
-      run: (cwd: string, source: string, id: string, target: BadgeTarget): Promise<BadgeActionEffect> =>
-        invoke('badge.run', { source, actionId: id, target, ...(cwd ? { cwd } : {}) }),
-    };
-    badges.set(host, made);
-  }
-  return made;
-}