zidane-ui 9.1.1 → 9.1.4

package/src/chat/composer/use-draft-target.ts

@@ -1,317 +0,0 @@
-/**
- * Where the new-chat draft will run: a folder on this computer (or none,
- * "just chat"), a saved server and its folder, or a machine's environment and
- * its folder. Every pick is the current draft's only: it resets when the
- * conversation moves to a session (the first send included), so the next new
- * chat asks again. The folder rules are `draft-target.ts`
- * (`zidane-ui/chat/headless`); the environment kinds come from the git host
- * (`useEnvironmentChoices`). The app holds the folder new chats open in and
- * the saved servers, and hears the draft's local folder (its draft scope).
- *
- * On a server, the draft offers the server's recent folders
- * (`serverFolders`), its first root (`remoteRoot`) and a repository import
- * there (`importRepoOnServer`). With no folder picked, a draft started from a
- * project on this computer clones that project's repository there on send
- * (`remoteClone`, `git/headless/remote-clone.ts`): the git host reads the
- * local `origin` and lists the server's first root.
- */
-import type { EnvironmentDescriptor } from 'zidane/chat';
-import { LOCAL_HOST_KEY } from 'zidane/chat/pure';
-import { useEffect, useMemo, useState } from 'react';
-
-import { useGitHost } from '../../git/GitProvider';
-import { resolveDraftDescriptor, type DraftEnvironment, type EnvironmentMachine } from '../../git/headless/environment';
-import type { GitFolderListing } from '../../git/headless/host';
-import { resolveRemoteClone, type DraftRemoteClone } from '../../git/headless/remote-clone';
-import { useImportRepo } from '../../git/ImportRepoDialog';
-import { useEnvironmentChoices } from '../../git/useEnvironmentChoices';
-import {
-  draftFolderPath,
-  draftLocalFolder,
-  recentHostFolders,
-  recentLocalFolders,
-  type DraftFolderSource,
-} from '../headless/draft-target';
-
-/** A saved server a draft can run on. */
-export interface DraftServer {
-  /** Its host id. */
-  id: string;
-  /** Its name. */
-  name: string;
-}
-
-/** What {@link useDraftTarget} reads from the app. */
-export interface DraftTargetOptions {
-  /** The open session (its folder, `''` for none); `null` for the new-chat draft. */
-  session: { id: string; cwd: string } | null;
-  /** The folder new chats open in (`null`: none picked yet). */
-  defaultFolder: string | null;
-  /** Makes `folder` the one new chats open in. */
-  setDefaultFolder(folder: string): void;
-  /** The session rows, most recently updated first: the folder menu's recent folders. */
-  sessions: readonly DraftFolderSource[];
-  /** The saved servers a draft can run on. */
-  servers: readonly DraftServer[];
-  /** Hears the draft's folder on this computer while the draft shows, `null` once it leaves. Absent: not told. */
-  onLocalFolder?(folder: string | null): void;
-  /**
-   * A pick made elsewhere (a server project's header in the sidebar, the
-   * Chats header): the draft moves to that host and folder, or to no folder,
-   * once per `seq`. A folder on this computer goes through `defaultFolder`
-   * instead.
-   */
-  request?: DraftTargetRequest | null;
-}
-
-/** A draft target picked outside the composer. */
-export interface DraftTargetRequest {
-  /** Grows with each request: a new one applies even to the same target. */
-  seq: number;
-  /** The saved server. */
-  hostId: string;
-  /** Its folder (`null`: its first root). */
-  folder: string | null;
-  /** A chat with no folder, on the request's host ("Start without a folder"); `folder` is ignored. */
-  folderless?: boolean;
-}
-
-/** The draft's target and its picks, as the composer's where menu and folder pickers read them. */
-export interface DraftTarget {
-  /** `null`: no folder picked yet (the folder gate shows); `''`: none. */
-  folderPath: string | null;
-  /** This computer's recent folders. */
-  recentFolders: readonly string[];
-  /** "Start without a folder" for this draft. */
-  justChat(): void;
-  /** Picks a folder on this computer (the git host's dialog). */
-  pickFolder(): Promise<void>;
-  /** Picks one of {@link DraftTarget.recentFolders}. */
-  pickRecent(folder: string): void;
-  /** Imports a repository and opens the draft in it. */
-  importRepoIntoDraft(): Promise<void>;
-  /** The saved server the draft runs on (absent: this computer). */
-  server?: DraftServer;
-  /** Runs the draft on a saved server (`LOCAL_HOST_KEY`: this computer). */
-  setHostId(hostId: string): void;
-  /** The server's folder (`null`: its first root). */
-  remoteFolder: string | null;
-  /** Picks the server's folder. */
-  setRemoteFolder(folder: string | null): void;
-  /** The server's recent folders (its sessions' folders), most recent first. */
-  serverFolders: readonly string[];
-  /** The server's first workspace root (the default folder), once read. */
-  remoteRoot: string | null;
-  /** Clones a repository on the server and opens the draft in it. Absent: the server takes no clones. */
-  importRepoOnServer?: () => Promise<void>;
-  /** On a server with no folder picked: the local project's repository, cloned there on send. `null`: nothing to clone. */
-  remoteClone: DraftRemoteClone | null;
-  /** The send is cloning {@link DraftTarget.remoteClone}. */
-  cloning: boolean;
-  /** Marks the clone of a send as running or done. */
-  setCloning(cloning: boolean): void;
-  /** The draft's environment pick (`null`: the default). */
-  environment: DraftEnvironment | null;
-  /** Picks the draft's environment. */
-  setEnvironment(environment: DraftEnvironment | null): void;
-  /** The environment kinds the draft's host offers. */
-  environmentChoices: readonly EnvironmentDescriptor[];
-  /** The machine the picked environment runs on. */
-  machine?: EnvironmentMachine;
-  /** The machine's folder (`null`: its first one). */
-  machineFolder: string | null;
-  /** Picks the machine's folder. */
-  setMachineFolder(folder: string | null): void;
-  /** The host the machine's folders are browsed through. */
-  machineHost: string;
-  /** Why the last new chat could not be created (the prompt is back in the box). */
-  error: string | null;
-  /** Shows or clears {@link DraftTarget.error}. */
-  setError(error: string | null): void;
-}
-
-/**
- * The new-chat draft's target, reset with the draft.
- *
- * @param options - The open session and the app's folder, sessions and servers.
- */
-export function useDraftTarget(options: DraftTargetOptions): DraftTarget {
-  const { session, defaultFolder, setDefaultFolder, sessions, servers, onLocalFolder, request } = options;
-  const isNewSession = session == null;
-
-  const recentFolders = useMemo(() => recentLocalFolders(sessions), [sessions]);
-
-  // "Start without a folder", for this draft only.
-  const [folderlessDraft, setFolderlessDraft] = useState(false);
-  const [environment, setEnvironment] = useState<DraftEnvironment | null>(null);
-
-  // This computer unless a saved server is picked; then the environment and folder steps ask that server.
-  const [hostId, setHostId] = useState<string>(LOCAL_HOST_KEY);
-  const [remoteFolder, setRemoteFolder] = useState<string | null>(null);
-  const server = isNewSession && hostId !== LOCAL_HOST_KEY ? servers.find((host) => host.id === hostId) : undefined;
-
-  const [error, setError] = useState<string | null>(null);
-
-  // The picks reset while rendering (no effect, no frame with the stale pick).
-  const sessionId = session?.id;
-  const [resetKeys, setResetKeys] = useState({ sessionId, hostId, defaultFolder });
-  if (resetKeys.sessionId !== sessionId || resetKeys.hostId !== hostId || resetKeys.defaultFolder !== defaultFolder) {
-    const newSession = resetKeys.sessionId !== sessionId;
-    const newHost = resetKeys.hostId !== hostId;
-    setResetKeys({ sessionId, hostId, defaultFolder });
-    // Picking a folder elsewhere (a project's "+" in the sidebar) takes the draft out of "no folder" mode.
-    if (newSession || resetKeys.defaultFolder !== defaultFolder) setFolderlessDraft(false);
-    // The picked server's folders and environments are its own: a new host starts over.
-    if (newHost) setRemoteFolder(null);
-    if (newSession || newHost) {
-      setEnvironment(null);
-      setError(null);
-    }
-  }
-
-  // A pick made elsewhere lands once: host and folder together, so the host change keeps the folder.
-  // Seqs start at 1: a request made before this draft mounted still lands (the app clears it once used).
-  const [appliedRequest, setAppliedRequest] = useState(0);
-  if (isNewSession && request && request.seq !== appliedRequest) {
-    setAppliedRequest(request.seq);
-    setHostId(request.hostId);
-    // The host's reset is done here, with the requested folder instead of none.
-    setResetKeys((keys) => ({ ...keys, hostId: request.hostId }));
-    setRemoteFolder(request.folderless ? null : request.folder);
-    setFolderlessDraft(request.folderless === true);
-    setEnvironment(null);
-    setError(null);
-  }
-
-  // The picked server was removed: the draft is back on this computer, visibly.
-  if (hostId !== LOCAL_HOST_KEY && !servers.some((host) => host.id === hostId)) setHostId(LOCAL_HOST_KEY);
-
-  const folderState = {
-    ...(session ? { sessionCwd: session.cwd } : {}),
-    onServer: Boolean(server),
-    folderless: folderlessDraft,
-    defaultFolder,
-  };
-  const folderPath = draftFolderPath(folderState);
-  const environmentChoices = useEnvironmentChoices(
-    isNewSession ? (server ? (remoteFolder ?? '') : (folderPath ?? '')) : null,
-    server?.id,
-  );
-  // A machine's environment: its folder is on that machine, browsed through the draft's host.
-  const machine = isNewSession ? resolveDraftDescriptor(environmentChoices, environment)?.machine : undefined;
-  const [machineFolder, setMachineFolder] = useState<string | null>(null);
-  const machineHost = server?.id ?? LOCAL_HOST_KEY;
-  const machineKey = `${machine?.id ?? ''}\u0000${machineHost}`;
-  const [folderMachine, setFolderMachine] = useState(machineKey);
-  if (folderMachine !== machineKey) {
-    setFolderMachine(machineKey);
-    setMachineFolder(null);
-  }
-  // Only a folder on this computer makes the draft's scope.
-  const localFolder = draftLocalFolder({ ...folderState, onMachine: Boolean(machine) });
-  // Only while it shows the draft: a session telling its (null) folder would clear the draft's scope.
-  useEffect(() => {
-    if (isNewSession) onLocalFolder?.(localFolder);
-  }, [isNewSession, localFolder, onLocalFolder]);
-  useEffect(() => {
-    if (!isNewSession) return undefined;
-    return () => onLocalFolder?.(null);
-  }, [isNewSession, onLocalFolder]);
-
-  // The server's first root (where clones land, what "Default folder" means, what it lets clients do) and the
-  // local project's `origin` (clone on send). Each answer is kept with what it was read for, so a stale one never
-  // shows for another pick.
-  const git = useGitHost();
-  const originUrl = git?.originUrl;
-  const listFolders = git?.listFolders;
-  const canClone = Boolean(git?.cloneOnServer);
-  const rootKey = server && listFolders ? server.id : null;
-  const [rootRead, setRootRead] = useState<{ key: string; root: GitFolderListing | null } | null>(null);
-  useEffect(() => {
-    if (!rootKey || !listFolders) return undefined;
-    let cancelled = false;
-    listFolders({ hostId: rootKey })
-      .then((listed) => {
-        if (!cancelled) setRootRead({ key: rootKey, root: listed.ok ? listed.listing : null });
-      })
-      .catch(() => {
-        if (!cancelled) setRootRead({ key: rootKey, root: null });
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [rootKey, listFolders]);
-  const remoteRootListing = rootKey && rootRead?.key === rootKey ? rootRead.root : null;
-
-  const cloneSource = server && canClone && !folderlessDraft ? defaultFolder : null;
-  const [originRead, setOriginRead] = useState<{ key: string; origin: string | null } | null>(null);
-  useEffect(() => {
-    if (!cloneSource || !originUrl) return undefined;
-    let cancelled = false;
-    originUrl(cloneSource)
-      .then((origin) => {
-        if (!cancelled) setOriginRead({ key: cloneSource, origin });
-      })
-      .catch(() => {
-        if (!cancelled) setOriginRead({ key: cloneSource, origin: null });
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [cloneSource, originUrl]);
-  const origin = cloneSource && originRead?.key === cloneSource ? originRead.origin : null;
-  const remoteClone =
-    remoteFolder === null && remoteRootListing && origin ? resolveRemoteClone(origin, remoteRootListing) : null;
-  const [cloning, setCloning] = useState(false);
-  const serverFolders = useMemo(() => (server ? recentHostFolders(sessions, server.id) : []), [server, sessions]);
-
-  const pickLocal = (folder: string) => {
-    // A real folder supersedes a "start without a folder" draft.
-    setFolderlessDraft(false);
-    setDefaultFolder(folder);
-  };
-  const importRepo = useImportRepo();
-  const importOnServer = useImportRepo(server ? { hostId: server.id } : undefined);
-  const serverImports = Boolean(server && canClone && remoteRootListing?.allows?.clone);
-
-  return {
-    folderPath,
-    recentFolders,
-    justChat: () => setFolderlessDraft(true),
-    pickFolder: async () => {
-      const picked = (await git?.pickFolder?.()) ?? null;
-      if (picked) pickLocal(picked);
-    },
-    pickRecent: pickLocal,
-    importRepoIntoDraft: async () => {
-      const cloned = await importRepo();
-      if (cloned) pickLocal(cloned);
-    },
-    ...(server ? { server } : {}),
-    setHostId,
-    remoteFolder,
-    setRemoteFolder,
-    serverFolders,
-    remoteRoot: remoteRootListing?.path ?? null,
-    ...(serverImports
-      ? {
-          importRepoOnServer: async () => {
-            const cloned = await importOnServer();
-            if (cloned) setRemoteFolder(cloned);
-          },
-        }
-      : {}),
-    remoteClone,
-    cloning,
-    setCloning,
-    environment,
-    setEnvironment,
-    environmentChoices,
-    ...(machine ? { machine } : {}),
-    machineFolder,
-    setMachineFolder,
-    machineHost,
-    error,
-    setError,
-  };
-}

package/src/chat/composer/use-new-session-defaults.ts

@@ -1,201 +0,0 @@
-/**
- * What a new session starts with: the folder (the one last used,
- * `ComposerHost.folders`), the agent, the model pick and its knobs. The
- * space's settings preset wins; else the model the host remembers
- * (`ComposerHost.prefs`), else the built-in default.
- */
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import type { Settings } from 'zidane/chat';
-import {
-  DEFAULT_MODEL_PICK,
-  defaultSessionAgent,
-  defaultSessionKnobs,
-  defaultSessionModel,
-  formatModelSetting,
-  parseModelSetting,
-  type SessionKnobs,
-} from 'zidane/chat/pure';
-
-import { defaultModelPatch, rememberedDefaultModel } from '../headless/composer/new-session-defaults';
-import { settledResource } from '../headless/composer/remember-model-pick';
-import type { ModelPickRef } from '../headless/composer/models';
-import { useComposerHost } from './ComposerHostProvider';
-
-/** Where the default model comes from. */
-export type NewSessionModelSource = 'preset' | 'remembered' | 'builtin';
-
-/** What a new session starts with, and the writers of each pick. */
-export interface NewSessionDefaults {
-  /** The project root of `defaultFolder`, `null` without a folder or a project. */
-  projectRoot: string | null;
-  /** The folder a new session opens in, `null` until known or when there is none. */
-  defaultFolder: string | null;
-  /** The agent: this chat's pick, else the space's, else `build`. */
-  defaultAgentId: string;
-  /** The effort and options the space's preset sets. */
-  newSessionKnobs: SessionKnobs;
-  /** The model's provider, `null` until resolved. */
-  defaultProviderKey: string | null;
-  /** The model, `null` until resolved. */
-  defaultModelId: string | null;
-  /** The stored account the model runs on, `null` for the active one. */
-  defaultAccount: string | null;
-  /** Where the model comes from, `null` until resolved. */
-  modelSource: NewSessionModelSource | null;
-  /** Sets the folder and remembers it (`null`: none, nothing remembered). */
-  setDefaultFolder: (path: string | null) => void;
-  /** Picks the agent for this chat (`null`: back to the space's). */
-  setDefaultAgentId: (id: string | null) => void;
-  /** Picks the model and remembers it, unless `persist` is `false`. */
-  setDefaultModel: (pick: ModelPickRef, opts?: { persist?: boolean }) => void;
-}
-
-interface ModelState {
-  providerKey: string | null;
-  modelId: string | null;
-  account: string | null;
-  source: NewSessionModelSource | null;
-}
-
-const UNRESOLVED: ModelState = { providerKey: null, modelId: null, account: null, source: null };
-const BUILTIN: ModelState = { ...DEFAULT_MODEL_PICK, account: null, source: 'builtin' };
-
-/**
- * The new session's defaults in a space, over the provided `ComposerHost`.
- *
- * @param settings - The settings (the space presets).
- * @param spaceId - The space new sessions go to.
- */
-export function useNewSessionDefaults(settings: Settings, spaceId: string): NewSessionDefaults {
-  const { prefs, models, folders, completions } = useComposerHost();
-  const locationOf = completions?.locationOf;
-  const [defaultFolder, setDefaultFolderState] = useState<string | null>(null);
-  const [agentPick, setAgentPick] = useState<string | null>(null);
-  // What the host remembers (read when no preset applies), and a pick made under the preset in force then.
-  const [remembered, setRemembered] = useState<ModelState>(UNRESOLVED);
-  const [picked, setPicked] = useState<{ model: ModelState; presetKey: string | null } | null>(null);
-  const [located, setLocated] = useState<string | null>(null);
-
-  const preset = useMemo(() => defaultSessionModel(settings, spaceId), [settings, spaceId]);
-  const newSessionKnobs = useMemo(() => defaultSessionKnobs(settings, spaceId), [settings, spaceId]);
-  const presetKey = preset ? formatModelSetting(preset) : null;
-  const defaultAgentId = agentPick ?? defaultSessionAgent(settings, spaceId) ?? 'build';
-  const presetModel = useMemo<ModelState | null>(() => {
-    const parsed = parseModelSetting(presetKey ?? undefined);
-    return parsed
-      ? { providerKey: parsed.providerKey, modelId: parsed.modelId, account: parsed.account ?? null, source: 'preset' }
-      : null;
-  }, [presetKey]);
-  // A preset change resets a pick made under the previous one.
-  const model =
-    picked && picked.presetKey === presetKey ? picked.model : (presetModel ?? (prefs ? remembered : BUILTIN));
-
-  useEffect(() => {
-    if (presetModel || !prefs) return undefined;
-    let cancelled = false;
-    void prefs
-      .get()
-      .then((state) => {
-        if (cancelled) return;
-        const pick = rememberedDefaultModel(state);
-        if (!pick) {
-          setRemembered(BUILTIN);
-          return;
-        }
-        const { providerKey, modelId, account } = pick;
-        setRemembered({ providerKey, modelId, account: null, source: 'remembered' });
-        // The remembered account only when it still serves that provider.
-        if (account && models) {
-          void settledResource(models.catalog(undefined, null))
-            .then((catalog) => {
-              if (!cancelled && catalog.some((e) => e.providerKey === providerKey && e.account?.id === account)) {
-                setRemembered((now) =>
-                  now.providerKey === providerKey && now.modelId === modelId ? { ...now, account } : now,
-                );
-              }
-            })
-            .catch(() => undefined);
-        }
-      })
-      .catch(() => {
-        if (!cancelled) setRemembered(BUILTIN);
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [presetModel, prefs, models]);
-
-  const setDefaultAgentId = useCallback((id: string | null) => setAgentPick(id), []);
-
-  const setDefaultModel = useCallback(
-    (pick: ModelPickRef, opts?: { persist?: boolean }) => {
-      setPicked({
-        model: {
-          providerKey: pick.providerKey,
-          modelId: pick.modelId,
-          account: pick.account ?? null,
-          source: 'remembered',
-        },
-        presetKey,
-      });
-      if (opts?.persist === false || !prefs) return;
-      void prefs
-        .get()
-        .then((current) => prefs.set(defaultModelPatch(current, pick)))
-        .catch(() => undefined);
-    },
-    [prefs, presetKey],
-  );
-
-  useEffect(() => {
-    if (!folders) return undefined;
-    let cancelled = false;
-    void folders
-      .lastUsed()
-      .then((last) => {
-        if (!cancelled) setDefaultFolderState(last);
-      })
-      .catch(() => undefined);
-    return () => {
-      cancelled = true;
-    };
-  }, [folders]);
-
-  useEffect(() => {
-    if (!defaultFolder || !locationOf) return undefined;
-    let cancelled = false;
-    void locationOf(defaultFolder)
-      .then((location) => {
-        if (!cancelled) setLocated(location?.projectRoot ?? null);
-      })
-      .catch(() => {
-        if (!cancelled) setLocated(null);
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [defaultFolder, locationOf]);
-  const projectRoot = defaultFolder && locationOf ? located : null;
-
-  const setDefaultFolder = useCallback(
-    (path: string | null) => {
-      setDefaultFolderState(path);
-      if (path && folders) void folders.setLastUsed(path).catch(() => undefined);
-    },
-    [folders],
-  );
-
-  return {
-    projectRoot,
-    defaultFolder,
-    defaultAgentId,
-    newSessionKnobs,
-    defaultProviderKey: model.providerKey,
-    defaultModelId: model.modelId,
-    defaultAccount: model.account,
-    modelSource: model.source,
-    setDefaultFolder,
-    setDefaultAgentId,
-    setDefaultModel,
-  };
-}

package/src/chat/composer/use-provider-ready-poll.ts

@@ -1,35 +0,0 @@
-/**
- * Whether a provider is ready (`ChatHost.providerReady`), read into a store
- * the app shares (the sign-in pill, the Connect a provider card, the send's
- * check): at mount and each time `paused` turns off. The app pauses it while
- * a modal is open: Settings › Accounts and the setup wizard own the
- * credential writes, so a read after they close is enough.
- */
-import { useEffect } from 'react';
-
-import type { Writable } from '../headless/store';
-import { useChatHost } from '../ChatProvider';
-
-/**
- * Keeps `store` on the chat host's provider check.
- *
- * @param store - Where the answer goes: `true` / `false`, `null` when the check failed (unknown, not "none": it must not block sends).
- * @param paused - Skip reading while true; turning false reads again.
- */
-export function useProviderReadyPoll(store: Writable<boolean | null>, paused = false): void {
-  const providerReady = useChatHost().providerReady;
-  useEffect(() => {
-    if (paused || !providerReady) return undefined;
-    let cancelled = false;
-    void providerReady()
-      .then((ready) => {
-        if (!cancelled) store.set(ready);
-      })
-      .catch(() => {
-        if (!cancelled) store.set(null);
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [paused, providerReady, store]);
-}

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

@@ -1,140 +0,0 @@
-/**
- * The current run's counters in a component, from the host's `runs`
- * (`createRunMeter` keeps them per session, outside React). The live
- * counters tick about 4 times a second, so each hook reads one field: a
- * reader re-renders only when its field changes, and keeps one subscription.
- */
-import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
-
-import type { ComposerRuns } from '../headless/composer/host-chrome';
-import { EMPTY_RUN_METER, type RunMeterState } from '../headless/composer/run-meter';
-import type { Readable } from '../headless/store';
-import { useComposerHost } from './ComposerHostProvider';
-
-const noSubscribe = () => () => undefined;
-
-/**
- * One field of a session's run counters (`store`: `RunMeter.session(id)`, `null` for none).
- *
- * @param store - The session's counters.
- * @param key - The field to read.
- */
-export function useRunMeterValue<K extends keyof RunMeterState>(
-  store: Readable<RunMeterState> | null,
-  key: K,
-): RunMeterState[K] {
-  const read = () => (store ? store.get() : EMPTY_RUN_METER)[key];
-  // Stable per store: a fresh function each render would unsubscribe and resubscribe on every progress tick.
-  const follow = useCallback((l: () => void) => (store ? store.subscribe(l) : noSubscribe()), [store]);
-  return useSyncExternalStore(follow, read, read);
-}
-
-function useSessionMeter(runs: ComposerRuns | undefined, sessionId: string | null): Readable<RunMeterState> | null {
-  return useMemo(() => (runs && sessionId ? runs.meter(sessionId) : null), [runs, sessionId]);
-}
-
-function useField<K extends keyof RunMeterState>(sessionId: string | null, key: K): RunMeterState[K] {
-  return useRunMeterValue(useSessionMeter(useComposerHost().runs, sessionId), key);
-}
-
-/**
- * The streaming parent turn's live counters, `null` between turns.
- *
- * @param sessionId - The session, `null` for none.
- */
-export const useRunProgress = (sessionId: string | null) => useField(sessionId, 'progress');
-
-/**
- * Output tokens of the run's settled parent turns.
- *
- * @param sessionId - The session, `null` for none.
- */
-export const useRunOutputTokens = (sessionId: string | null) => useField(sessionId, 'outputTokens');
-
-/**
- * Cost of turns settled since the last settling cost read.
- *
- * @param sessionId - The session, `null` for none.
- */
-export const useRunAccruedCost = (sessionId: string | null) => useField(sessionId, 'accruedCost');
-
-/**
- * When the run started (epoch ms), `null` while this window knows of none.
- *
- * @param sessionId - The session, `null` for none.
- */
-export const useRunStartedAt = (sessionId: string | null) => useField(sessionId, 'startedAt');
-
-/**
- * A running session this window did not see start (opened, reloaded or
- * reconnected mid-run): reads its run from the host once (`runs.progress`),
- * so the chip neither restarts its time nor counts its output from zero. A
- * run whose `run:start` it saw counts from the start already.
- *
- * @param sessionId - The session, `null` for none.
- * @param running - Whether it runs now.
- */
-export function useJoinedRunProgress(sessionId: string | null, running: boolean): void {
-  const runs = useComposerHost().runs;
-  const store = useSessionMeter(runs, sessionId);
-  const generation = useRunMeterValue(store, 'generation');
-  const joined = useRunMeterValue(store, 'startedFrom') !== 'host';
-  useEffect(() => {
-    if (!sessionId || !running || !joined || !runs?.progress) return undefined;
-    let cancelled = false;
-    // Best effort: unread, the chip counts from when this window saw the run.
-    runs.progress(sessionId).then(
-      (progress) => {
-        if (!cancelled && progress) runs.noteProgress?.(sessionId, generation, progress);
-      },
-      () => undefined,
-    );
-    return () => {
-      cancelled = true;
-    };
-  }, [runs, sessionId, running, joined, generation]);
-}
-
-/**
- * Whole-second elapsed counter for the session's current run, from its start
- * (the host's, so neither switching conversations nor opening a window
- * restarts it). Ticks every `tickMs`: 250 ms by default so `0s → 1s` is not
- * laggy, but renders once per second.
- *
- * @param sessionId - The session.
- * @param running - Whether it runs now.
- * @param tickMs - How often the clock is read.
- * @param runsOverride - The run counters to read. Default: the host's `runs`.
- */
-export function useRunElapsedSec(
-  sessionId: string,
-  running: boolean,
-  tickMs = 250,
-  runsOverride?: ComposerRuns,
-): number {
-  const hostRuns = useComposerHost().runs;
-  const runs = runsOverride ?? hostRuns;
-  const startedAt = useRunMeterValue(useSessionMeter(runs, sessionId), 'startedAt');
-  const startedAtRef = useRef(startedAt);
-  // eslint-disable-next-line react-hooks/refs -- the interval reads the latest start without restarting
-  startedAtRef.current = startedAt;
-  const [now, setNow] = useState(() => Date.now());
-  useEffect(() => {
-    if (running) runs?.noteSeen?.(sessionId);
-  }, [runs, sessionId, running]);
-  useEffect(() => {
-    if (!running) return undefined;
-    // A tick that lands in the same whole second keeps the old state: the fine
-    // tick is for promptness at the boundary, not a render 4 times a second.
-    const sec = (t: number) => (startedAtRef.current === null ? 0 : Math.floor((t - startedAtRef.current) / 1000));
-    const tick = () => {
-      const t = Date.now();
-      setNow((prev) => (sec(prev) === sec(t) ? prev : t));
-    };
-    // eslint-disable-next-line react-hooks/set-state-in-effect -- the clock starts with the run
-    setNow(Date.now());
-    const id = window.setInterval(tick, tickMs);
-    return () => window.clearInterval(id);
-  }, [running, tickMs]);
-  return running && startedAt !== null ? Math.max(0, Math.floor((now - startedAt) / 1000)) : 0;
-}