zidane-ui 9.1.1 → 9.1.4

package/src/chat/composer/use-send-prompt.ts

@@ -1,188 +0,0 @@
-/**
- * The composer's send and stop, bound to the hosts: the send flow
- * (`sendPrompt`, `zidane-ui/chat/headless`: draft → session, `!` shell, queue
- * while running, `/side`, the provider check, echo and send) over the
- * `ChatHost`, the session host's queue, the composer host's `/` commands, the
- * git host's machine folders and clone on send (`cloneOnServer`: a server
- * draft started from a local project runs in a clone of its repository
- * there), and the prompt history. The app gives what only it holds: how a
- * session is created, the picks a new one starts with, the side panel's
- * hand-over and the provider flag it keeps.
- */
-import { parseCommandInvocation } from 'zidane/chat/pure';
-import { useState, useSyncExternalStore } from 'react';
-
-import { useGitHost } from '../../git/GitProvider';
-import { useSessionHost } from '../../session/SessionProvider';
-import { useChatHost } from '../ChatProvider';
-import {
-  newSessionRequest,
-  sendPrompt,
-  type NewSessionDefaults,
-  type NewSessionRequest,
-  type SendAttachment,
-} from '../headless/send-flow';
-import type { Readable, Writable } from '../headless/store';
-import { useSessionStreamActions } from '../SessionStreamsProvider';
-import { useComposerHost, useComposerLabels } from './ComposerHostProvider';
-import { usePromptHistory } from './PromptHistoryProvider';
-import type { DraftTarget } from './use-draft-target';
-
-/** What {@link useSendPrompt} sends from and through. */
-export interface SendPromptOptions {
-  /** The conversation, `null` for the new-chat draft. */
-  session: { id: string } | null;
-  /** A run is in flight: a prompt is queued. */
-  running: boolean;
-  /** The draft's target (`useDraftTarget`). */
-  draft: DraftTarget;
-  /** The server the composer talks to (`null`: this computer). */
-  hostId: string | null;
-  /** Creates the draft's session. Rejects with why it can't (shown on the draft). */
-  createSession(request: NewSessionRequest): Promise<{ id: string; provisioning?: boolean }>;
-  /** What a new session starts with, read as it is created. */
-  newSessionDefaults(): Omit<NewSessionDefaults, 'untitled'>;
-  /** The draft's session exists: the picks that were for that chat only can reset. */
-  onSessionCreated?(): void;
-  /** Brings what was just sent into view (on the next frame). */
-  reveal?(): void;
-  /** Hands `/side [question]` over; returns why it can't, `null` once handed over. Absent: `/side` is a prompt. */
-  side?(sessionId: string | null, question: string): string | null;
-  /** Whether a provider is ready on this computer (`null`: not known), which a send checks and updates. Absent: never checked. */
-  providerReady?: Writable<boolean | null>;
-}
-
-/** The composer's send and stop. */
-export interface SendPromptControls {
-  /** Sends one prompt; rejects (the composer keeps the text) when it could not go. */
-  send(
-    text: string,
-    attachments: readonly SendAttachment[],
-    activatedSkills?: readonly string[],
-    options?: { keepDraft?: boolean },
-  ): Promise<void>;
-  /** Stops the conversation's run. */
-  stop(): void;
-  /** A send found no provider: the app asks to connect one, until one is ready. */
-  needsProvider: boolean;
-}
-
-const UNKNOWN: Readable<boolean | null> = { get: () => null, subscribe: () => () => {} };
-
-/**
- * Binds the send flow to the hosts and the app's inputs.
- *
- * @param options - See {@link SendPromptOptions}.
- */
-export function useSendPrompt(options: SendPromptOptions): SendPromptControls {
-  const { session, running, draft, hostId, providerReady } = options;
-  const chat = useChatHost();
-  const git = useGitHost();
-  const composer = useComposerHost();
-  const queue = useSessionHost().queue;
-  const history = usePromptHistory();
-  const streams = useSessionStreamActions();
-  const labels = useComposerLabels();
-
-  const provider = providerReady ?? UNKNOWN;
-  const ready = useSyncExternalStore(provider.subscribe, provider.get, provider.get);
-  const [needsProvider, setNeedsProvider] = useState(false);
-  // A provider ready since: the notice goes, while rendering.
-  if (ready && needsProvider) setNeedsProvider(false);
-
-  // On a machine: its folder, or its first one, through the draft's host.
-  const machineRoot = async (machineId: string) => {
-    const listed = await git!.listFolders!({ hostId: draft.machineHost, machineId });
-    if (!listed.ok) throw new Error(listed.error.code === 'failed' ? listed.error.message : listed.error.code);
-    return listed.listing.path;
-  };
-
-  // On a server with no folder picked: the local project's repository, cloned there first. `null`: nothing to clone.
-  const cloneForDraft = async (): Promise<string | null> => {
-    const { server, remoteFolder, remoteClone } = draft;
-    // Nothing to clone: a folder is picked, no local project, or cloning is off (the session starts in the first root).
-    if (!server || remoteFolder !== null || !remoteClone || remoteClone.state === 'off' || !git?.cloneOnServer)
-      return null;
-    draft.setCloning(true);
-    try {
-      const result = await git.cloneOnServer(server.id, remoteClone.input, remoteClone.parent);
-      if (result.ok) return result.path;
-      if ('cancelled' in result) throw new Error(labels.sendCloneCancelled);
-      const reason = result.error.code === 'failed' ? result.error.message : result.error.code;
-      throw new Error(labels.sendCloneFailed(remoteClone.input, reason));
-    } finally {
-      draft.setCloning(false);
-    }
-  };
-
-  const createFromDraft = async (text: string) => {
-    const { machine, machineFolder } = draft;
-    draft.setError(null);
-    try {
-      const onMachine = machine ? (machineFolder ?? (await machineRoot(machine.id))) : null;
-      const cloned = machine ? null : await cloneForDraft();
-      const request = newSessionRequest(
-        cloned ? { ...draft, remoteFolder: cloned } : draft,
-        text,
-        { ...options.newSessionDefaults(), untitled: labels.sendUntitled },
-        onMachine,
-      );
-      const created = await options.createSession(request);
-      options.onSessionCreated?.();
-      return created;
-    } catch (err) {
-      // Not created (its server went offline, …): say why; the composer puts the prompt back.
-      draft.setError(labels.sendCreateFailed((err as Error)?.message ?? String(err)));
-      throw err;
-    }
-  };
-
-  const isCommand = async (cwd: string, text: string) => {
-    const list = composer.completions?.commands;
-    if (!list) return false;
-    const commands = await list({ cwd, hostId }).catch(() => []);
-    return parseCommandInvocation(text, commands) !== null;
-  };
-
-  const send: SendPromptControls['send'] = (text, attachments, activatedSkills = [], opts = {}) => {
-    const cwd = draft.folderPath ?? '';
-    return sendPrompt(
-      {
-        sessionId: session?.id ?? null,
-        text,
-        attachments,
-        activatedSkills,
-        keepDraft: opts.keepDraft,
-        running,
-        cwd,
-        remote: Boolean(hostId || draft.server),
-      },
-      {
-        host: chat,
-        streams,
-        createSession: createFromDraft,
-        ...(queue?.add ? { enqueue: queue.add } : {}),
-        isCommand: (prompt) => isCommand(cwd, prompt),
-        remember: (id, prompt) => history.push(id, prompt),
-        ...(options.reveal ? { reveal: () => requestAnimationFrame(options.reveal!) } : {}),
-        ...(options.side ? { side: options.side } : {}),
-        draftError: (message) => draft.setError(message),
-        ...(providerReady
-          ? {
-              provider: {
-                known: providerReady.get,
-                ready: () => providerReady.set(true),
-                missing: () => setNeedsProvider(true),
-              },
-            }
-          : {}),
-      },
-    );
-  };
-
-  const stop = () => {
-    if (session) chat.interrupt?.(session.id);
-  };
-
-  return { send, stop, needsProvider };
-}

package/src/chat/composer/use-session-meters.ts

@@ -1,109 +0,0 @@
-/**
- * A conversation's meters: its context gauge (`ComposerHost.context.status`),
- * its cost as last read (`context.cost`) and its model, read for the session
- * it shows: keyed by session, so a switch never shows the previous
- * conversation's figures.
- */
-import { useEffect, useMemo, useState } from 'react';
-
-import type { ComposerContextStatus, ComposerCostStatus } from '../headless/composer/host-chrome';
-import { useComposerHost } from './ComposerHostProvider';
-import { useHostResource } from './use-composer-stores';
-
-/** What {@link useSessionMeters} reads of a session. */
-export interface SessionMetersTarget {
-  /** The session. */
-  id: string;
-  /** Its own model pick, if it has one. */
-  modelId?: string;
-  /** That model's provider. */
-  providerKey?: string;
-}
-
-/** A conversation's meters. */
-export interface SessionMeters {
-  /** Its context gauge, `null` while unknown. */
-  contextStatus: ComposerContextStatus | null;
-  /** The cost as last read; the pills add what the run settled and streams since (`ComposerHost.runs`). */
-  fetchedCost: ComposerCostStatus | null;
-  /** The session's model: its own pick, else the one its context status reports. */
-  modelId: string | null;
-}
-
-/**
- * The meters of the session shown.
- *
- * @param session - The session, `null` for a draft.
- * @param running - Whether it runs now (a run boundary reads the cost again).
- */
-export function useSessionMeters(session: SessionMetersTarget | null, running: boolean): SessionMeters {
-  const id = session?.id ?? null;
-  const modelId = session?.modelId ?? null;
-  const providerKey = session?.providerKey ?? null;
-  const contextStatus = useSessionContextStatus(session);
-  const fetchedCost = useFetchedCost(id, running, modelId, providerKey);
-  return { contextStatus, fetchedCost, modelId: modelId ?? contextStatus?.modelId ?? null };
-}
-
-/**
- * The context gauge of a session alone (what the model and effort pickers
- * read): the same keyed read as {@link useSessionMeters}', so one request.
- *
- * @param session - The session, `null` for a draft.
- * @returns Its context status, `null` while unknown.
- */
-export function useSessionContextStatus(session: SessionMetersTarget | null): ComposerContextStatus | null {
-  const context = useComposerHost().context;
-  const id = session?.id ?? null;
-  const modelId = session?.modelId ?? null;
-  const providerKey = session?.providerKey ?? null;
-  const resource = useMemo(
-    () => (id && context?.status ? context.status(id, modelId, providerKey) : null),
-    [context, id, modelId, providerKey],
-  );
-  return useHostResource(resource).data ?? null;
-}
-
-/**
- * The session's cost, read when it opens, when a run starts or ends and when
- * its model changes. The last figure stays up while the next one is read.
- */
-function useFetchedCost(
-  id: string | null,
-  running: boolean,
-  modelId: string | null,
-  providerKey: string | null,
-): ComposerCostStatus | null {
-  const { context, runs } = useComposerHost();
-  const [fetched, setFetched] = useState<{ id: string; cost: ComposerCostStatus | null } | null>(null);
-  useEffect(() => {
-    if (!id || !context?.cost) return undefined;
-    let cancelled = false;
-    /*
-     * Only a read issued while IDLE may zero the accrual: a run's cost is
-     * stamped at its end, so that read contains every turn accrued so far.
-     * One issued at run START (or on a model switch mid-run) does not: a fast
-     * first `turn:end` landing before the round trip would be wiped and the
-     * pill would under-report until run end. And if a new run began while an
-     * idle read was in flight, `run:start` already reset the accrual for it;
-     * resetting again would drop that run's early turns.
-     */
-    const settlesAccrual = !running;
-    const generation = runs ? runs.meter(id).get().generation : 0;
-    context.cost(id).then(
-      (cost) => {
-        if (cancelled) return;
-        setFetched({ id, cost });
-        if (settlesAccrual) runs?.settleCost?.(id, generation);
-      },
-      () => {
-        if (!cancelled) setFetched({ id, cost: null });
-      },
-    );
-    return () => {
-      cancelled = true;
-    };
-  }, [context, runs, id, running, modelId, providerKey]);
-  // Never another session's figure, not even for the frames before this one's arrives.
-  return fetched?.id === id ? fetched.cost : null;
-}

package/src/chat/composer/use-sustained-work.ts

@@ -1,74 +0,0 @@
-/**
- * The running work the composer's Running badge shows. A call shorter than
- * `WORK_SHOW_MS` never shows it (a quick read doesn't flash a badge), and
- * work that ended keeps it for `WORK_HOLD_MS` (back-to-back calls don't
- * open and close the band between them).
- *
- * The wait is measured from the oldest item's own start, so after a reload
- * or a conversation switch work that has been running a while shows at
- * once. Capped at `WORK_SHOW_MS` from now: a server whose clock runs ahead
- * never holds it back longer.
- */
-import { useEffect, useState } from 'react';
-
-import type { RunningWorkItem } from 'zidane/ipc';
-
-/** Work shorter than this never shows. */
-export const WORK_SHOW_MS = 800;
-/** Work that ended keeps showing this long. */
-export const WORK_HOLD_MS = 1500;
-
-const NONE: readonly RunningWorkItem[] = [];
-
-/**
- * How long until `items` should show, in ms: 0 when they already should.
- *
- * @param items - The running work, non-empty.
- * @param now - The current time, epoch ms.
- */
-export function workShowDelay(items: readonly RunningWorkItem[], now: number): number {
-  const oldest = Math.min(...items.map((item) => item.startedAt));
-  return Math.min(WORK_SHOW_MS, Math.max(0, oldest + WORK_SHOW_MS - now));
-}
-
-/**
- * The running work to show for a conversation (see the header).
- *
- * @param sessionId - The conversation.
- * @param items - Its running work now.
- */
-export function useSustainedWork(
-  sessionId: string | null,
-  items: readonly RunningWorkItem[],
-): readonly RunningWorkItem[] {
-  const initial = (): readonly RunningWorkItem[] =>
-    items.length > 0 && workShowDelay(items, Date.now()) === 0 ? items : NONE;
-  const [state, setState] = useState(() => ({ sessionId, shown: initial() }));
-  // Another conversation: its own work, as it stands, never the last one's held list.
-  if (state.sessionId !== sessionId) setState({ sessionId, shown: initial() });
-  const shown = state.sessionId === sessionId ? state.shown : NONE;
-  const showing = shown.length > 0;
-
-  useEffect(() => {
-    if (items.length > 0) {
-      if (showing) {
-        // eslint-disable-next-line react-hooks/set-state-in-effect -- shown work follows the live list at once
-        setState((s) => (s.shown === items ? s : { ...s, shown: items }));
-        return undefined;
-      }
-      const show = () => setState((s) => ({ ...s, shown: items }));
-      const delay = workShowDelay(items, Date.now());
-      if (delay === 0) {
-        show();
-        return undefined;
-      }
-      const timer = setTimeout(show, delay);
-      return () => clearTimeout(timer);
-    }
-    if (!showing) return undefined;
-    const timer = setTimeout(() => setState((s) => ({ ...s, shown: NONE })), WORK_HOLD_MS);
-    return () => clearTimeout(timer);
-  }, [items, showing]);
-
-  return shown;
-}

package/src/chat/composer/useAttachmentIngest.ts

@@ -1,116 +0,0 @@
-/**
- * The composer's staged attachments and the three ways in: paste (files, or
- * a long text folded into a `.txt`), drop, and the file picker. Every file
- * goes through the shared rule (`readAttachment`): images, PDFs and text
- * attach; anything else is refused, each refusal a line in `notices` until
- * dismissed or a few seconds pass. Disabled, every handler is a no-op that
- * lets the event through.
- */
-import { useCallback, useEffect, useRef, useState, type ChangeEvent, type DragEvent } from 'react';
-
-import { useChatLabels } from '../useChatLabels';
-import {
-  attachmentErrorText,
-  type ComposerAttachment,
-  pastedTextFilename,
-  readAttachment,
-  shouldFoldPasteToAttachment,
-} from './attachment-ingest';
-
-/** How long the notices about refused files stay, in milliseconds. */
-export const ATTACHMENT_NOTICE_MS = 8000;
-
-/** The latest notices kept: a large drop of refused files stays readable. */
-const MAX_NOTICES = 3;
-
-/**
- * The notices about files a composer did not attach: `refuse` words what
- * `readAttachment` rejected with; they clear on `dismiss`, or
- * {@link ATTACHMENT_NOTICE_MS} after the latest one.
- */
-export function useAttachmentNotices() {
-  const labels = useChatLabels();
-  const [refused, setRefused] = useState<ReadonlyArray<{ fileName: string; error: unknown }>>([]);
-
-  // A new refusal restarts the clock.
-  useEffect(() => {
-    if (refused.length === 0) return;
-    const timer = setTimeout(() => setRefused([]), ATTACHMENT_NOTICE_MS);
-    return () => clearTimeout(timer);
-  }, [refused]);
-
-  const refuse = useCallback((fileName: string, error: unknown) => {
-    setRefused((list) => [...list, { fileName: fileName || 'file', error }].slice(-MAX_NOTICES));
-  }, []);
-  const dismiss = useCallback(() => setRefused([]), []);
-  // The same file refused twice is one line.
-  const notices = [...new Set(refused.map((r) => attachmentErrorText(r.fileName, r.error, labels)))];
-  return { notices, refuse, dismiss };
-}
-
-/**
- * Manages the composer's staged attachments and the ways in: paste, drop, and the file picker. Images, PDFs and text files attach; anything else is refused with a notice.
- *
- * @param enabled - Turns the handlers on. When false every handler is a no-op that lets the event through.
- * @param initial - Attachments staged on mount, for example a restored draft. Defaults to none.
- */
-export function useAttachmentIngest(enabled: boolean, initial: readonly ComposerAttachment[] = []) {
-  const [attachments, setAttachments] = useState<ComposerAttachment[]>(() => [...initial]);
-  const { notices, refuse, dismiss } = useAttachmentNotices();
-  const [dragging, setDragging] = useState(false);
-  const inputRef = useRef<HTMLInputElement | null>(null);
-
-  const add = useCallback(
-    (files: readonly File[]) => {
-      for (const file of files) {
-        readAttachment(file).then(
-          (att) => setAttachments((list) => [...list, att]),
-          (error: unknown) => refuse(file.name, error),
-        );
-      }
-    },
-    [refuse],
-  );
-
-  return {
-    attachments,
-    notices,
-    dismissNotices: dismiss,
-    dragging,
-    inputRef,
-    remove: (id: string) => setAttachments((list) => list.filter((a) => a.id !== id)),
-    clear: () => setAttachments([]),
-    restore: (list: readonly ComposerAttachment[]) => setAttachments([...list]),
-    /** ProseMirror's paste hook: true when the paste became attachments. */
-    paste(event: ClipboardEvent): boolean {
-      if (!enabled || !event.clipboardData) return false;
-      const files = Array.from(event.clipboardData.files);
-      if (files.length > 0) {
-        add(files);
-        return true;
-      }
-      const text = event.clipboardData.getData('text/plain');
-      if (!text || !shouldFoldPasteToAttachment(text)) return false;
-      add([new File([text], pastedTextFilename(), { type: 'text/plain' })]);
-      return true;
-    },
-    pick(event: ChangeEvent<HTMLInputElement>) {
-      add(Array.from(event.target.files ?? []));
-      event.target.value = '';
-    },
-    dragOver(event: DragEvent) {
-      if (!enabled || !Array.from(event.dataTransfer.types).includes('Files')) return;
-      event.preventDefault();
-      setDragging(true);
-    },
-    dragLeave(event: DragEvent) {
-      if (event.currentTarget === event.target) setDragging(false);
-    },
-    drop(event: DragEvent) {
-      setDragging(false);
-      if (!enabled || event.dataTransfer.files.length === 0) return;
-      event.preventDefault();
-      add(Array.from(event.dataTransfer.files));
-    },
-  };
-}

package/src/chat/composer/useModelListSpy.ts

@@ -1,19 +0,0 @@
-/**
- * The model chain picker's scroll spy: the provider section under the list's
- * top edge is the active one, whatever moved the list (wheel, keyboard, a
- * jump). The list works it out from its own scroll position and the layout
- * (`groupAt`, no DOM reads) and reports it here whenever it changes.
- */
-import { useCallback, useState } from 'react';
-
-export function useModelListSpy() {
-  const [spied, setSpied] = useState<string | null>(null);
-  /**
-   * A pill click names its section outright; a short last section can never
-   * reach the top edge, so the spy would disagree. The pin holds until the
-   * user moves the list themselves (wheel, drag, keyboard).
-   */
-  const [pinned, setPinned] = useState<string | null>(null);
-  const unpin = useCallback(() => setPinned(null), []);
-  return { active: pinned ?? spied, report: setSpied, pin: setPinned, unpin };
-}

package/src/chat/headless/badge-refs.ts

@@ -1,76 +0,0 @@
-/**
- * Text that renders as a badge without a completion having typed it: links
- * anywhere in a prompt, and the `/name` a command invocation starts with.
- * Shared by the composer (decorations over the typed text) and the sent
- * prompt (chips), so a prompt reads the same in both.
- */
-import type { PromptSegmentRef } from 'zidane/chat/pure';
-
-/** `http(s)://` up to whitespace or a quote/bracket that cannot end a URL. */
-const URL_RE = /\bhttps?:\/\/[^\s<>"'`]+/g;
-
-/** Sentence punctuation after a link is not part of it; a `)` is, when the link opened one. */
-function trimUrl(raw: string): string {
-  let url = raw.replace(/[.,;:!?]+$/, '');
-  while (url.endsWith(')') && (url.match(/\(/g)?.length ?? 0) < (url.match(/\)/g)?.length ?? 0)) {
-    url = url.slice(0, -1).replace(/[.,;:!?]+$/, '');
-  }
-  return url;
-}
-
-/**
- * The links in a text, as prompt spans (`urls`): where each starts and ends.
- *
- * @param text - The text to scan.
- */
-export function urlRefs(text: string): PromptSegmentRef[] {
-  const refs: PromptSegmentRef[] = [];
-  for (const m of text.matchAll(URL_RE)) {
-    const url = trimUrl(m[0]);
-    // A bare scheme (`https://`) is not a link yet.
-    if (url.length > url.indexOf('//') + 2) {
-      refs.push({ start: m.index!, end: m.index! + url.length, providerId: 'urls' });
-    }
-  }
-  return refs;
-}
-
-/**
- * The command an invocation starts with: its `/name`, plus the leading
- * argument when that is one of the command's fixed values (`args`, which
- * may be several words): `/fix conflicts now` reads `/fix conflicts`. The
- * longest value wins, and it must end at a space or the end of the text.
- *
- * @param text - The prompt.
- * @param args - The command's fixed arguments, so `/fix conflicts` is one span.
- */
-export function commandRef(text: string, args: ReadonlySet<string> = NO_ARGS): PromptSegmentRef | null {
-  const name = /^\/[\w][\w:.-]*/.exec(text);
-  if (!name) return null;
-  const gap = /^ +/.exec(text.slice(name[0].length))?.[0].length ?? 0;
-  const rest = text.slice(name[0].length + gap).toLowerCase();
-  let value = 0;
-  if (gap > 0) {
-    for (const arg of args) {
-      const ends = rest.length === arg.length || /\s/.test(rest[arg.length] ?? '');
-      if (arg.length > value && ends && rest.startsWith(arg.toLowerCase())) value = arg.length;
-    }
-  }
-  return { start: 0, end: name[0].length + (value ? gap + value : 0), providerId: 'commands' };
-}
-
-const NO_ARGS: ReadonlySet<string> = new Set();
-
-/**
- * `https://www.github.com/a/b/` → `github.com/a/b`, ellipsized past `max` characters.
- *
- * @param url - The address.
- * @param max - The longest result, in characters.
- */
-export function shortUrl(url: string, max = 40): string {
-  const short = url
-    .replace(/^https?:\/\//, '')
-    .replace(/^www\./, '')
-    .replace(/\/$/, '');
-  return short.length > max ? `${short.slice(0, max - 1)}…` : short;
-}

package/src/chat/headless/chip-labels.ts

@@ -1,40 +0,0 @@
-/** The strings of prose chips, their hover cards, references and the badge menu. Part of `TRANSCRIPT_LABELS`. */
-export const CHIP_LABELS = {
-  // Chip hover cards: the facts' names
-  chipFactChanges: 'Changes',
-  chipFactDate: 'Date',
-  chipFactModel: 'Model',
-  chipFactContext: 'Context',
-  chipFactPrompts: 'Prompts',
-  chipFactTurns: 'Turns',
-  chipFactBranch: 'Branch',
-  chipFactUpdated: 'Updated',
-  chipFactAliases: 'Aliases',
-  chipFactSize: 'Size',
-  chipTokens: (count: string) => `~${count} tokens`,
-  chipSessionRunning: 'Running',
-  chipSessionError: 'Error',
-  chipUntitledChat: 'Untitled chat',
-  chipNotAmongChats: 'Not among your chats',
-  chipLoading: 'Loading…',
-  // Prose chips
-  chipCommit: (sha: string) => `Commit ${sha}`,
-  chipBranch: (name: string) => `Branch ${name}`,
-  chipRemoteFile: (path: string, host: string) => `${path}: on ${host}, not this computer`,
-  chipNotFound: (title: string) => `${title} (not found)`,
-  chipSkill: (name: string) => `Skill ${name}`,
-  chipCommand: (name: string) => `Command ${name}`,
-  chipChat: (name: string) => `Chat ${name}`,
-  // Plan / question calls in the transcript
-  interactionApproved: 'Approved',
-  interactionRevise: 'Revision requested',
-  interactionRejected: 'Rejected',
-  interactionWaitingDecision: 'Waiting for your decision',
-  interactionWaitingAnswers: 'Waiting for your answers',
-  interactionDismissed: 'Dismissed, no answer given',
-  interactionAnsweredBy: (who: string) => `Answered by ${who}`,
-  // Badge menu notices
-  badgePathUnavailable: 'Path unavailable.',
-  badgeNoComposer: 'No chat to add to here',
-  badgeCopied: 'Copied',
-};

package/src/chat/headless/chip-settle.ts

@@ -1,53 +0,0 @@
-/**
- * Chip lookups in flight, app-wide: the reference providers and views
- * (`reference-store.ts`) and the file / branch resolutions of prose chips
- * (`path-resolver.ts`). Each answer can change a chip's
- * size (plain text becoming a badge, a badge gaining its title), and a
- * size change reflows the transcript. `whenChipsSettle` lets a thread that
- * just opened wait for the lookups its rows started before it shows
- * (`useSettledReveal`), so those reflows happen out of sight.
- */
-
-let busy = 0;
-const waiters = new Set<() => void>();
-
-/** Mark one lookup as started; call the returned function once when it ends (success or not). */
-export function beginChipWork(): () => void {
-  busy++;
-  let ended = false;
-  return () => {
-    if (ended) return;
-    ended = true;
-    busy--;
-    if (busy === 0) for (const done of [...waiters]) done();
-  };
-}
-
-/** Whether any lookup is in flight. */
-export function chipWorkBusy(): boolean {
-  return busy > 0;
-}
-
-/**
- * Resolves once no lookup is in flight, or after `timeoutMs`, whichever is first.
- *
- * @param timeoutMs - How long to wait at most.
- */
-export function whenChipsSettle(timeoutMs: number): Promise<void> {
-  if (busy === 0) return Promise.resolve();
-  return new Promise((resolve) => {
-    const finish = () => {
-      clearTimeout(timer);
-      waiters.delete(finish);
-      resolve();
-    };
-    const timer = setTimeout(finish, timeoutMs);
-    waiters.add(finish);
-  });
-}
-
-/** Test seam. */
-export function resetChipWorkForTests(): void {
-  busy = 0;
-  waiters.clear();
-}