zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/composer/host.ts

@@ -1,250 +0,0 @@
-/**
- * The rich composer's host: what the desktop composer reads beyond sending
- * (the app's `onSend`): the shared per-session draft, the completion catalogs
- * behind `@` `/` `#` and the extensions' triggers, inline ghost text and the
- * next-prompt suggestion. An app implements it once (over IPC, over zidane-server, in
- * memory) and hands it to `ComposerHostProvider` (or `AppHost.composer`).
- *
- * Every member is optional: a host that leaves one out hides what needs it
- * (no `drafts`: the draft stays in this window; no `completions.files`: `@`
- * lists no files; no `autocomplete`: no ghost text). The chrome around the
- * editor reads the members in `host-chrome.ts` (pickers, meters, the badge
- * strip). Session ids are the app's own (the desktop app passes its session
- * keys through unchanged).
- */
-import type { CommandArgSuggestionSummary, CommandSummary, FileEntry, PromptAttachment } from 'zidane/chat';
-import type { ChatReferenceEntry } from 'zidane/chat/pure';
-import type { SkillConfig } from 'zidane/skills';
-
-import type { ChatAttachment } from '../host';
-import type {
-  ComposerAgents,
-  ComposerContext,
-  ComposerControls,
-  ComposerModels,
-  ComposerPrefs,
-  ComposerRuns,
-} from './host-chrome';
-import type { ModelPickerPrefsStore } from './model-picker-prefs';
-
-export type { CommandArgSuggestionSummary, CommandSummary, FileEntry, PromptAttachment, SkillConfig };
-
-/** An attachment staged in a composer: always read into a `data:` URL, keyed for removal. */
-export interface ComposerAttachment extends ChatAttachment {
-  /** Unique id (a random UUID) that keys the attachment and removes it. */
-  id: string;
-  dataUrl: string;
-  /** The dropped, pasted or picked file's `attachmentFileKey`, so the same file doesn't stage twice. */
-  fileKey?: string;
-}
-
-/** Where a completion list comes from: the composer's folder and the host it runs on (`null`: this computer). */
-export interface ComposerScope {
-  /** The folder the session (or the new chat) runs in; `''` when it has none. */
-  cwd: string;
-  /** The server the session runs on, `null` for this computer. */
-  hostId: string | null;
-}
-
-/** A session's shared draft, as another window left it. */
-export interface SharedDraft {
-  /** The draft's text (shell mode's `!` not included). */
-  text: string;
-  /** True when the draft is a shell command. */
-  shell?: boolean;
-  /** The files staged with the draft. */
-  attachments?: PromptAttachment[];
-  /** The transcript search the draft drives, when it is in search mode. */
-  search?: { active: boolean; query: string };
-}
-
-/** A draft written in another window. */
-export interface SharedDraftChange {
-  /** The session whose draft changed. */
-  sessionId: string;
-  /** The new text. */
-  text: string;
-  /** True when the new draft is a shell command. */
-  shell?: boolean;
-}
-
-/** The staged files of a draft written in another window. */
-export interface SharedDraftAttachmentsChange {
-  /** The session whose draft changed. */
-  sessionId: string;
-  /** The staged files now. */
-  attachments: PromptAttachment[];
-}
-
-/** Hears another window's staged files for a draft. */
-export type ComposerDraftAttachmentsListener = (change: SharedDraftAttachmentsChange) => void;
-
-/** The per-session draft every window of the app shares. Absent: each window keeps its own. */
-export interface ComposerDrafts {
-  /** The session's draft (`text: ''` when it has none). */
-  get(sessionId: string): Promise<SharedDraft>;
-  /** Replaces the session's draft text. */
-  set(sessionId: string, text: string, shell?: boolean): Promise<void>;
-  /** Replaces the session's staged files. Absent: staged files stay in this window. */
-  setAttachments?(sessionId: string, attachments: PromptAttachment[]): Promise<void>;
-  /** Calls `listener` when another window changes a draft's text. Returns the unsubscribe. */
-  onChanged?(listener: (change: SharedDraftChange) => void): () => void;
-  /** Calls `listener` when another window changes a draft's staged files. Returns the unsubscribe. */
-  onAttachmentsChanged?(listener: (change: SharedDraftAttachmentsChange) => void): () => void;
-}
-
-/** An extension's completion trigger (a character that opens its popover). */
-export interface ComposerExtensionProvider {
-  /** The provider's id, passed back to {@link ComposerCompletions.extensionItems}. */
-  id: string;
-  /** The character that opens it. */
-  trigger: string;
-  /** What the popover's header says. */
-  label: string;
-}
-
-/** One item an extension's completion offers. */
-export interface ComposerExtensionItem {
-  /** The item's id. */
-  id: string;
-  /** What the row shows. */
-  label: string;
-  /** What a pick writes into the prompt. */
-  insertText: string;
-  /** Short text under the label. */
-  description?: string;
-}
-
-/** Where a folder sits: its checkout and the project it belongs to. */
-export interface ComposerFolderLocation {
-  /** The git checkout holding the folder (the folder itself outside git). */
-  checkoutRoot: string;
-  /** The project root (the main checkout for a worktree). */
-  projectRoot: string;
-}
-
-/** The folder a new session opens in, remembered across launches. */
-export interface ComposerFolders {
-  /** The folder last picked for a new session, `null` when none was. */
-  lastUsed(): Promise<string | null>;
-  /** Remembers `path` as the next new session's folder. */
-  setLastUsed(path: string): Promise<void>;
-}
-
-/** The catalogs behind the composer's completions. Each one left out empties its popover. */
-export interface ComposerCompletions {
-  /** The files under `root` for `@` mentions (`hostId`: the server holding `root`). */
-  files?(root: string, hostId: string | null): Promise<readonly FileEntry[]>;
-  /** The `/` commands in a scope. */
-  commands?(scope: ComposerScope): Promise<readonly CommandSummary[]>;
-  /** Suggestions for `/name <prefix>`. Best effort: resolves `[]` on failure. */
-  commandArgs?(scope: ComposerScope, name: string, prefix: string): Promise<readonly CommandArgSuggestionSummary[]>;
-  /** The sessions `#` can reference. */
-  chats?(): Promise<readonly ChatReferenceEntry[]>;
-  /** Calls `listener` with the enabled skills in a scope (`/skill` completion and badges), now and on each change. Returns the unsubscribe. */
-  watchSkills?(scope: ComposerScope, listener: (skills: readonly SkillConfig[]) => void): () => void;
-  /** Calls `listener` with the extensions' completion triggers in a scope, now and on each change. Returns the unsubscribe. */
-  watchExtensionProviders?(
-    scope: ComposerScope,
-    listener: (providers: readonly ComposerExtensionProvider[]) => void,
-  ): () => void;
-  /** An extension trigger's items for what was typed after it. */
-  extensionItems?(
-    cwd: string,
-    providerId: string,
-    query: string,
-    text: string,
-    caret: number,
-  ): Promise<readonly ComposerExtensionItem[]>;
-  /** Runs the extensions' submit hooks on a prompt before it is sent. */
-  submit?(scope: ComposerScope, text: string, caret: number): Promise<void>;
-  /** Where a folder sits, so `@` mentions in a worktree list the project's files. */
-  locationOf?(cwd: string): Promise<ComposerFolderLocation>;
-}
-
-/**
- * The commands' fixed argument values, shared by everything that reads a
- * `/command` (the composer's badge, the transcript's prompt rows): what the
- * `/` popover learns is noted here. The app keeps one; the rich composer takes
- * it as a prop.
- */
-export interface ComposerCommandArgs {
-  /** `name`'s values known so far in a scope. */
-  args(scope: ComposerScope, name: string): ReadonlySet<string>;
-  /** Asks for `name`'s values in a scope (once; subscribers hear when they arrive). */
-  request(scope: ComposerScope, name: string): void;
-  /** Records values learned for `name` in a scope. */
-  note(scope: ComposerScope, name: string, values: readonly string[]): void;
-  /** Calls `listener` when values arrive. Returns the unsubscribe. */
-  subscribe(listener: () => void): () => void;
-}
-
-/** A ghost text another window resolved for a session's draft. */
-export interface ComposerSharedGhost {
-  /** The session whose draft it completes. */
-  sessionId: string;
-  /** The request's sequence number. */
-  seq: number;
-  /** The draft text it completes. */
-  basis: string;
-  /** The caret it completes at. */
-  caret: number;
-  /** The completion, `null` for none. */
-  suggestion: string | null;
-  /** Every candidate, for ↑/↓ rotation. */
-  candidates?: string[];
-}
-
-/** Inline ghost-text autocomplete. Absent: no ghost text. */
-export interface ComposerAutocomplete {
-  /** The completions for `text` with the caret at `caret`, `null` for none. `sessionId` shares the result with the session's other windows. */
-  inline(cwd: string, text: string, caret: number, sessionId?: string): Promise<string[] | null>;
-  /** Calls `listener` when another window resolved a ghost text. Returns the unsubscribe. */
-  onShared?(listener: (ghost: ComposerSharedGhost) => void): () => void;
-}
-
-/** A next prompt the host suggests once a run ends. */
-export interface ComposerPromptSuggestion {
-  /** The session it is for. */
-  sessionId: string;
-  /** The run that ended. */
-  runId: string;
-  /** The suggested prompt. */
-  text: string;
-}
-
-/** Next-prompt suggestions. Absent: none are shown. */
-export interface ComposerSuggestions {
-  /** Calls `listener` with each suggestion. Returns the unsubscribe. */
-  onReady(listener: (suggestion: ComposerPromptSuggestion) => void): () => void;
-  /** Calls `listener` with a session whose suggestion went stale (a run or a compaction started, a prompt was sent). Returns the unsubscribe. */
-  onStale?(listener: (sessionId: string) => void): () => void;
-}
-
-/** The rich composer's host. Every member is optional. */
-export interface ComposerHost {
-  /** The shared per-session draft. */
-  drafts?: ComposerDrafts;
-  /** The completion catalogs. */
-  completions?: ComposerCompletions;
-  /** The folder a new session opens in, remembered. Absent: a new session starts without one. */
-  folders?: ComposerFolders;
-  /** Inline ghost text. */
-  autocomplete?: ComposerAutocomplete;
-  /** Next-prompt suggestions. */
-  suggestions?: ComposerSuggestions;
-  /** The pickers' writes on a session (model, effort, options, agent) and their cache estimates. */
-  controls?: ComposerControls;
-  /** The model catalogs the pickers list. */
-  models?: ComposerModels;
-  /** The agent profiles the agent picker offers. */
-  agents?: ComposerAgents;
-  /** Where picks are remembered across apps (effort and options per model, the next chat's model). */
-  prefs?: ComposerPrefs;
-  /** The model picker's per-device preferences. Absent: an in-memory store for the page's life. */
-  pickerPrefs?: ModelPickerPrefsStore;
-  /** A session's context gauge, its breakdown and its settled cost. */
-  context?: ComposerContext;
-  /** The current run's counters per session (the run chip, the cost pill). */
-  runs?: ComposerRuns;
-}

package/src/chat/headless/composer/index.ts

@@ -1,17 +0,0 @@
-/** The rich composer's React-free layer: its host, labels, the command lookup, the completion lists and the draft helpers apps share; the chrome's stores (run meter, remembered knobs, picker prefs, the extensions' strip) and models (live cost, badges, the remembered pick). */
-export * from './host';
-export * from './host-chrome';
-export * from './models';
-export * from './labels';
-export * from './labels-chrome';
-export * from './commands';
-export { createComposerLists, type ComposerListScope, type ComposerLists, type LazyList } from './composer-sources';
-export { wireAttachmentsToChat } from './draft-sync';
-export * from './live-cost';
-export * from './run-meter';
-export * from './model-knobs';
-export * from './model-picker-prefs';
-export * from './remember-model-pick';
-export * from './new-session-defaults';
-export * from './conversation-badges';
-export * from './model-names';

package/src/chat/headless/composer/labels-chrome.ts

@@ -1,83 +0,0 @@
-/** The strings of the chrome around the editor (run chip, pickers, dock, badges). Merged into `DEFAULT_COMPOSER_LABELS`. */
-export const DEFAULT_COMPOSER_CHROME_LABELS = {
-  /** The badge strip: the queue, running work, the inbox and the todos. */
-  badgeQueued: 'Queued',
-  badgeQueuedTitle: (n: number) =>
-    n === 1 ? 'A message waits for the run to end' : `${n} messages wait for the run to end`,
-  badgeRunning: 'Running',
-  badgeRunningTitle: (names: readonly string[], more: number, total: number) =>
-    `${names.join(', ')}${more > 0 ? ` and ${more} more` : ''}. Click to see or stop ${total === 1 ? 'it' : 'them'}.`,
-  badgePlan: 'Plan to review',
-  badgePlanTitle: (title: string) => `Plan to review: ${title}`,
-  badgeQuestions: (n: number) => (n === 1 ? 'Question' : `${n} questions`),
-  badgeQuestionsTitle: (n: number) => (n === 1 ? 'The agent has a question' : `The agent has ${n} questions`),
-  badgeWaiting: 'Waiting on you',
-  badgeWaitingTitle: 'The agent is waiting on you',
-  badgeFromPrevious: (title: string) => `${title} (from a previous session)`,
-  badgeTodos: 'Todos',
-  badgeTodosProgress: (done: number, total: number) => `${done} of ${total} done`,
-  badgeTodosCurrent: (content: string, progress: string) => `${content} (${progress})`,
-  badgeTodosLast: (progress: string) => `Last list: ${progress}`,
-  /** The archived session's banner. */
-  archivedNotice: 'This session is archived. Unarchive it to continue.',
-  unarchive: 'Unarchive',
-  /** A draft's Chat / folder toggle. */
-  scopeGroup: 'Session scope',
-  scopeChat: 'Chat',
-  scopeChatHint: 'Chat without a folder',
-  scopeChooseFolder: 'Choose a folder',
-  scopeFolderHint: (folder: string) => `${folder}. Click to change folder`,
-  scopeSelectHint: 'Select a folder for this session',
-  scopeSelect: 'Select…',
-  scopeImportRepo: 'Import repository…',
-  scopeSelectDirectory: 'Select directory…',
-  scopeBackToProjects: 'Projects',
-  scopeServerGroup: (host: string) => `Folder on ${host}`,
-  scopeServerChoose: (host: string) => `Choose a folder on ${host}`,
-  scopeServerFolderHint: (folder: string, host: string) => `${folder} on ${host}. Click to change folder`,
-  scopeServerDefault: 'Default folder',
-  scopeServerDefaultHint: (host: string) => `The first workspace root on ${host}`,
-  scopeCloneWill: (name: string) => `${name} · will clone`,
-  scopeCloneWillHint: (url: string, parent: string, host: string) => `Sending clones ${url} into ${parent} on ${host}`,
-  scopeCloneThere: (path: string, host: string) => `${path} on ${host}, already there`,
-  scopeCloneOffHint: (host: string) => `Cloning is off on ${host} (allowClone). New chats start in its default folder.`,
-  scopeCloning: (name: string) => `Cloning ${name}…`,
-  scopeCloneTag: 'will clone',
-  scopeCloneThereTag: 'on the server',
-  scopeCloneOffTag: 'cloning off',
-  /** The run chip's tooltip, and its rate's unit. */
-  runChipHint: 'Elapsed time, output tokens and session cost',
-  runChipEstimatedHint: 'Elapsed time, output tokens (estimated until the turn ends) and session cost',
-  runChipRate: 'tok/s',
-  /** The Model dialog. */
-  modelDialogTitle: 'Model',
-  modelDialogDescription: (title: string) => `Pick a model for "${title}". Add more to build a fallback chain.`,
-  /** The model options dialog. */
-  effortDialogTitle: 'Model options',
-  effortDialogDescription: (title: string) => `Effort and features for "${title}".`,
-  effortDialogReasoning: 'Reasoning effort',
-  effortDialogFeatures: 'Features',
-  /** The agent dialog. */
-  agentDialogTitle: 'Switch agent',
-  agentDialogDescription: 'Applies to this session only.',
-  agentSwitching: 'switching…',
-  /** The model pill: a session's, a draft's (the next chat's default). */
-  modelSwitch: 'Switch model',
-  modelPickDefault: 'Pick default model',
-  /** The model options pill's tooltip. */
-  modelOptionsTitle: 'Reasoning effort and model options',
-  /** The retry pill's tooltip. */
-  retryStallHint: (attempt: number, max: number) =>
-    `The provider stream stalled. Retry ${attempt} of ${max}. Clears when the stream resumes or the run ends.`,
-  /** A new chat's title when neither its prompt nor its folder names it. */
-  sendUntitled: 'New chat',
-  /** The draft's notice when its first send could not create the chat. */
-  sendCreateFailed: (message: string) => `The chat couldn't be created: ${message}`,
-  sendCloneFailed: (url: string, message: string) => `${url} could not be cloned: ${message}`,
-  sendCloneCancelled: 'The clone was stopped.',
-  /** The context breakdown that failed to load. */
-  breakdownError: (message: string) => `Couldn't read the breakdown: ${message}`,
-};
-
-/** The chrome's strings. */
-export type ComposerChromeLabels = typeof DEFAULT_COMPOSER_CHROME_LABELS;

package/src/chat/headless/composer/labels-editor.ts

@@ -1,44 +0,0 @@
-/** The rich editor's strings (`zidane-ui/chat/rich-composer`). Merged into `DEFAULT_COMPOSER_LABELS`. */
-export const DEFAULT_COMPOSER_EDITOR_LABELS = {
-  /** The + button. */
-  attachFile: 'Attach file',
-  /** The send button. */
-  sendMessage: 'Send message',
-  /** The send button's tooltip. */
-  sendHint: 'Send (Enter)',
-  /** The stop button. */
-  stop: 'Stop',
-  /** The stop button's tooltip. */
-  stopHint: 'Stop the run (Esc)',
-  /** The editor's accessible name (the chat labels' key: one override names both composers). */
-  composerLabel: 'Message',
-  /** The editor's placeholder: no folder picked, shell mode, search mode, and a prompt. */
-  placeholderNoFolder: 'Pick a folder to begin…',
-  placeholderShell: 'Run a shell command…',
-  placeholderSearch: 'Search this conversation…',
-  placeholderChat: 'Chat with Zidane…',
-  /** The `#` popover's scope (its Tab hint). */
-  chatScopeProject: 'This project',
-  chatScopeAll: 'All projects',
-  /** A `#` row's message count. */
-  chatMessages: (n: number) => `${n} messages`,
-  /** The prompt mode chips, and the history position while ↑/↓ browse it. */
-  modeShell: 'shell',
-  modeSearch: 'search',
-  historyPosition: (position: number, total: number) => `history ${position}/${total}`,
-  /** The mention popover with nothing to offer. */
-  mentionNoMatches: 'No matches',
-  /** The mention popover's key hints. */
-  mentionNavigate: 'Navigate',
-  mentionInsert: 'Insert',
-  mentionClose: 'Close',
-  /** A staged attachment's open and remove buttons. */
-  viewAttachment: (name: string) => `View ${name}`,
-  removeAttachment: (name: string) => `Remove ${name}`,
-  /** A file tile's tooltip: its name and media type. */
-  attachmentTitle: (name: string, type: string) => `${name} (${type})`,
-  /** The media type a text tile with none shows. */
-  attachmentTextType: 'text',
-  /** The media type another file tile with none shows. */
-  attachmentUnknownType: 'unknown type',
-};

package/src/chat/headless/composer/labels.ts

@@ -1,18 +0,0 @@
-/**
- * The composer's strings (the desktop app's wording): the rich editor's
- * (`labels-editor.ts`) and the chrome's around it (`labels-chrome.ts`: run
- * chip, pickers, dock, badges). One flat dictionary an app overrides with
- * `<LabelsProvider>` or the `labels` prop of `ComposerHostProvider`. Keys
- * you leave out keep the default English label.
- */
-import { DEFAULT_COMPOSER_CHROME_LABELS } from './labels-chrome';
-import { DEFAULT_COMPOSER_EDITOR_LABELS } from './labels-editor';
-
-/** Every composer string. */
-export type ComposerLabels = typeof DEFAULT_COMPOSER_EDITOR_LABELS & typeof DEFAULT_COMPOSER_CHROME_LABELS;
-
-/** The default English composer strings. */
-export const DEFAULT_COMPOSER_LABELS: ComposerLabels = {
-  ...DEFAULT_COMPOSER_EDITOR_LABELS,
-  ...DEFAULT_COMPOSER_CHROME_LABELS,
-};

package/src/chat/headless/composer/live-cost.ts

@@ -1,67 +0,0 @@
-/**
- * Pure composition of the session cost pill while a run is in flight.
- *
- * Three sources, three cadences:
- *   - `fetched`  — the host's `context.cost`, sums `run.cost`, which main stamps
- *                  only when a run ENDS. Refetched at run boundaries.
- *   - `accrued`  — Σ `turn:end.usage.cost` observed since the last fetch
- *                  (parent and subagent turns). Moves once per turn.
- *   - `progress` — the loop's `stream:progress` estimate for the turn
- *                  currently streaming. Moves ~4/s, dropped at its `turn:end`.
- *
- * The three never overlap: a turn's estimate is cleared by the same signal
- * that adds its settled cost, and a fetch that includes a run's cost resets
- * `accrued` to zero. `estimated` flags a figure that still contains an
- * in-flight estimate so the surface can render it as provisional.
- */
-import { formatCostLabel } from 'zidane/chat/pure';
-
-import type { ComposerCostStatus } from './host-chrome';
-
-/** Shared with the TUI (`formatCostLabel` in `src/chat/format.ts`). */
-export const formatSessionCostLabel = formatCostLabel;
-
-/** The streaming turn's live counters (`stream:progress`). */
-export interface LiveStreamProgress {
-  /** The streaming turn. */
-  turnId: string;
-  /** Output tokens so far. */
-  outputTokens: number;
-  /** `outputTokens` is an estimate. */
-  estimated: boolean;
-  /** Time since the turn began. */
-  elapsedMs: number;
-  /** The turn's cost so far, estimated. */
-  estCostUsd?: number;
-}
-
-/** The cost pill's figure: settled, accrued and streaming. */
-export interface LiveCostStatus extends ComposerCostStatus {
-  /** `true` while the total includes the streaming turn's running estimate. */
-  estimated: boolean;
-}
-
-/**
- * The cost pill's figure while a run is in flight (see the header).
- *
- * @param fetched - The cost as last read.
- * @param accrued - Settled turn costs since that read.
- * @param progress - The streaming turn's counters.
- */
-export function composeLiveCost(
-  fetched: ComposerCostStatus | null,
-  accrued: number,
-  progress: LiveStreamProgress | null,
-): LiveCostStatus | null {
-  const live = progress?.estCostUsd ?? 0;
-  const total = (fetched?.totalCost ?? 0) + accrued + live;
-  if (total <= 0) {
-    return null;
-  }
-  return {
-    totalCost: total,
-    runCount: fetched?.runCount ?? 0,
-    label: formatSessionCostLabel(total),
-    estimated: live > 0,
-  };
-}

package/src/chat/headless/composer/model-knobs.ts

@@ -1,179 +0,0 @@
-/**
- * Reasoning effort and model options (fast mode, …) remembered per model, in
- * the host's `prefs` (the desktop app: the `state.json` keys the TUI reads and
- * writes, `lastEffortByModel` and `lastModelOptionsByModel`). Every pick (in
- * a draft or a live session) updates them.
- *
- * A new chat starts from, first to last: what was picked in its draft, the
- * configured defaults (the space's, else the app's, whatever the model:
- * `defaultSessionKnobs`), the last values used with its model in either app,
- * then medium and no options.
- *
- * Outside React: the composer's draft pill and the send path read the same
- * values, and the send path reads them synchronously.
- */
-import type { SessionKnobs } from 'zidane/chat/pure';
-
-import type { ComposerEffort, ComposerPrefs, ComposerPrefsState } from './host-chrome';
-
-/** What the store holds. */
-export interface ModelKnobsMemory {
-  /** The last effort per model. */
-  effort: Record<string, ComposerEffort>;
-  /** The last enabled options per model. */
-  options: Record<string, Record<string, boolean>>;
-  /** The draft's own picks, until its chat is created (`clearDraft`). */
-  draft: { modelId: string; effort?: ComposerEffort; options?: Record<string, boolean> } | null;
-}
-
-/** An effort and the enabled options. */
-export interface ModelKnobs {
-  /** The reasoning effort. */
-  effort: ComposerEffort;
-  /** The enabled options (`{ fast: true }`). */
-  options: Record<string, boolean>;
-}
-
-/** The remembered knobs. */
-export interface ModelKnobsStore {
-  /** Reads the remembered picks from the prefs, once. */
-  load(): Promise<void>;
-  /** Registers a listener called after the memory changes. Returns the unsubscribe. */
-  subscribe(listener: () => void): () => void;
-  /** The memory now (a new object on each change). */
-  snapshot(): ModelKnobsMemory;
-  /** The last effort and enabled options used with `modelId` (medium, none, when never set). */
-  remembered(modelId: string | null, from?: ModelKnobsMemory): ModelKnobs;
-  /** A new chat's starting effort and enabled options on `modelId` (see the header for the order). */
-  draft(modelId: string | null, configured: SessionKnobs | undefined, from?: ModelKnobsMemory): ModelKnobs;
-  /** Remembers an effort for a model. */
-  rememberEffort(modelId: string | null, effort: ComposerEffort): void;
-  /** Remembers the enabled options for a model. */
-  rememberModelOptions(modelId: string | null, options: Record<string, boolean>): void;
-  /** A pick in the draft's pill: this chat starts on it, and it is remembered for the model. */
-  pickDraftEffort(modelId: string | null, effort: ComposerEffort): void;
-  /** A pick of options in the draft's pill. */
-  pickDraftOptions(modelId: string | null, options: Record<string, boolean>): void;
-  /** The draft became a chat: the next one starts from the defaults again. */
-  clearDraft(): void;
-  /** Tests: forget everything, reload from the prefs on next use. */
-  reset(): void;
-}
-
-/** The enabled ids only: `{ fast: true }`, never `{ fast: false }`. */
-function enabledOnly(options: Record<string, boolean>): Record<string, boolean> {
-  return Object.fromEntries(Object.entries(options).filter(([, on]) => on === true));
-}
-
-/**
- * Creates the remembered knobs over a host's prefs.
- *
- * @param prefs - Where picks are remembered. Absent: they last for the page's life.
- */
-export function createModelKnobs(prefs: ComposerPrefs | undefined): ModelKnobsStore {
-  let memory: ModelKnobsMemory = { effort: {}, options: {}, draft: null };
-  let loaded: Promise<void> | null = null;
-  const listeners = new Set<() => void>();
-  const emit = () => {
-    for (const l of listeners) l();
-  };
-
-  /** Merge into the prefs without clobbering keys another writer (the TUI) set meanwhile. */
-  const persist = async (patch: (s: ComposerPrefsState) => ComposerPrefsState): Promise<void> => {
-    if (!prefs) return;
-    try {
-      const current = await prefs.get();
-      await prefs.set(patch(current ?? {}));
-    } catch {
-      // The pick still applies to this window; it just won't be remembered.
-    }
-  };
-
-  const store: ModelKnobsStore = {
-    load() {
-      loaded ??= Promise.resolve()
-        .then(() => prefs?.get() ?? null)
-        .then((s) => {
-          if (!s) return;
-          memory = {
-            effort: { ...(s.lastEffortByModel ?? {}), ...memory.effort },
-            options: { ...(s.lastModelOptionsByModel ?? {}), ...memory.options },
-            draft: memory.draft,
-          };
-          emit();
-        })
-        .catch(() => undefined);
-      return loaded;
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    snapshot: () => memory,
-    remembered: (modelId, from = memory) => ({
-      effort: (modelId && from.effort[modelId]) || 'medium',
-      options: (modelId && from.options[modelId]) || {},
-    }),
-    draft(modelId, configured, from = memory) {
-      const picked = from.draft && from.draft.modelId === modelId ? from.draft : null;
-      return {
-        effort: picked?.effort ?? configured?.effort ?? ((modelId && from.effort[modelId]) || 'medium'),
-        options: picked?.options ?? configured?.modelOptions ?? ((modelId && from.options[modelId]) || {}),
-      };
-    },
-    rememberEffort(modelId, effort) {
-      if (!modelId) return;
-      memory = { ...memory, effort: { ...memory.effort, [modelId]: effort } };
-      emit();
-      void persist((s) => ({ lastEffortByModel: { ...(s.lastEffortByModel ?? {}), [modelId]: effort } }));
-    },
-    rememberModelOptions(modelId, options) {
-      if (!modelId) return;
-      const enabled = enabledOnly(options);
-      memory = { ...memory, options: { ...memory.options, [modelId]: enabled } };
-      emit();
-      void persist((s) => ({
-        lastModelOptionsByModel: { ...(s.lastModelOptionsByModel ?? {}), [modelId]: enabled },
-      }));
-    },
-    pickDraftEffort(modelId, effort) {
-      if (!modelId) return;
-      memory = { ...memory, draft: { ...(memory.draft?.modelId === modelId ? memory.draft : {}), modelId, effort } };
-      store.rememberEffort(modelId, effort);
-    },
-    pickDraftOptions(modelId, options) {
-      if (!modelId) return;
-      const enabled = enabledOnly(options);
-      memory = {
-        ...memory,
-        draft: { ...(memory.draft?.modelId === modelId ? memory.draft : {}), modelId, options: enabled },
-      };
-      store.rememberModelOptions(modelId, options);
-    },
-    clearDraft() {
-      if (!memory.draft) return;
-      memory = { ...memory, draft: null };
-      emit();
-    },
-    reset() {
-      memory = { effort: {}, options: {}, draft: null };
-      loaded = null;
-    },
-  };
-  return store;
-}
-
-const stores = new WeakMap<object, ModelKnobsStore>();
-const NO_PREFS = {};
-
-/**
- * The one {@link ModelKnobsStore} over a host's `prefs` (one shared in-memory store when it has none).
- *
- * @param prefs - The host's member.
- */
-export function modelKnobsOf(prefs: ComposerPrefs | undefined): ModelKnobsStore {
-  const key = prefs ?? NO_PREFS;
-  let store = stores.get(key);
-  if (!store) stores.set(key, (store = createModelKnobs(prefs)));
-  return store;
-}