zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/sidebar/dot-state.ts

@@ -1,36 +0,0 @@
-/**
- * A session's dot state from this window's signals and the daemon's shared
- * presence. React-free: the sidebar's live dot (`createSidebarLive`) feeds it.
- */
-import type { SessionPresence } from '../../../machines/headless/presence';
-
-/** What a session's dot says (`StatusDot` draws it). */
-export type SidebarDotState = 'idle' | 'running' | 'pending' | 'completed' | 'error' | 'attention' | 'attached';
-
-/** What {@link deriveDotState} reads. */
-export interface DotStateInput {
-  /** An approval, plan or question of this window waits on the user. */
-  pending: boolean;
-  /** This window sees the session's run going. */
-  running: boolean;
-  /** How the run that ended while the session was not open ended. */
-  notification: 'completed' | 'error' | null;
-  /** The daemon's presence for the session, when known. */
-  presence: Pick<SessionPresence, 'attention' | 'running' | 'windows'> | null;
-}
-
-/**
- * The dot state. Presence follows the TUI: awaiting input (◉) beats running
- * (▶) beats attached (○). This window's own pending ask sits on top; a
- * finished run's notification (completed / error) outranks attached.
- *
- * @param input - This window's signals and the session's presence.
- */
-export function deriveDotState(input: DotStateInput): SidebarDotState {
-  if (input.pending) return 'pending';
-  if (input.presence?.attention) return 'attention';
-  if (input.running || input.presence?.running) return 'running';
-  if (input.notification) return input.notification;
-  if ((input.presence?.windows ?? 0) > 0) return 'attached';
-  return 'idle';
-}

package/src/chat/headless/sidebar/environment.ts

@@ -1,70 +0,0 @@
-/**
- * How the sidebar words where a session runs: the environment kind's name,
- * the one-line summary its chip's tooltip reads, and the delete prompt that
- * warns when a remote sandbox goes with the session. React-free.
- */
-import type { SessionEnvironmentSummary } from 'zidane/chat';
-import { parseMachineKind } from 'zidane/chat/pure';
-
-import type { SidebarLabels } from './labels';
-
-/** Kinds whose work lives in a remote sandbox: deleting the session deletes it. */
-const REMOTE_KINDS: ReadonlySet<string> = new Set(['e2b', 'daytona']);
-
-/**
- * Whether the session runs in a sandbox on a provider's machines, deleted with the session.
- *
- * @param environment - The session's environment, if any.
- */
-export function runsInRemoteSandbox(environment: SessionEnvironmentSummary | undefined): boolean {
-  return environment !== undefined && REMOTE_KINDS.has(environment.kind);
-}
-
-/**
- * An environment kind's display name: a built-in kind's name, a machine's kind as `Local @ laptop`, else the id.
- *
- * @param kind - The kind (`worktree`, `local@laptop`, an extension's id).
- * @param labels - The sidebar labels.
- */
-export function environmentKindLabel(
-  kind: string,
-  labels: Pick<SidebarLabels, 'environmentKinds' | 'environmentOnMachine'>,
-): string {
-  const machine = parseMachineKind(kind);
-  if (machine) return labels.environmentOnMachine(labels.environmentKinds[machine.base] ?? machine.base, machine.name);
-  return labels.environmentKinds[kind] ?? kind;
-}
-
-/**
- * Where a session runs, in one line: tooltips and screen readers.
- *
- * @param environment - The session's environment.
- * @param labels - The sidebar labels.
- */
-export function environmentSummaryText(environment: SessionEnvironmentSummary, labels: SidebarLabels): string {
-  const label = environmentKindLabel(environment.kind, labels);
-  const where = environment.branch ? labels.environmentOnBranch(label, environment.branch) : label;
-  if (environment.state === 'provisioning') return labels.environmentSettingUp(where);
-  if (environment.state === 'failed') return labels.environmentSetupFailed(where, environment.error);
-  if (environment.suspended) return labels.environmentPaused(where);
-  return where;
-}
-
-/**
- * The delete confirmation: the question, and a warning when the session's sandbox goes with it.
- *
- * @param title - The session's title.
- * @param environment - Its environment, if any.
- * @param labels - The sidebar labels.
- */
-export function deleteSessionPrompt(
-  title: string,
-  environment: SessionEnvironmentSummary | undefined,
-  labels: SidebarLabels,
-): { question: string; detail?: string } {
-  const question = labels.deleteSessionQuestion(title);
-  if (environment && runsInRemoteSandbox(environment)) {
-    return { question, detail: labels.deleteSessionSandbox(environmentKindLabel(environment.kind, labels)) };
-  }
-  return { question };
-}

package/src/chat/headless/sidebar/estimates.ts

@@ -1,146 +0,0 @@
-/**
- * How long each session's runs have left (`Settings.runEstimates`), outside
- * React: the session's own run and its subagents', as the host estimated
- * them ({@link createRunEstimates}). Fed from the app's stream signals
- * (`run:estimate`, cleared on `run:start` / `run:end`) and from session rows
- * (`runEstimates`, the saved run records), so a window opened mid-run counts
- * down from the same point as the one that saw the estimate arrive.
- *
- * The store holds the estimates, not the countdown: a reader computes what
- * an estimate says now with `estimateReadout` (`zidane/chat/pure`).
- */
-import type { RunEstimateView } from 'zidane/chat/pure';
-
-/** The stream signals the store follows; any other kind is ignored. */
-export type RunEstimatesSignal =
-  | { kind: 'run:estimate'; sessionId: string; estimate: RunEstimateView }
-  | { kind: 'run:start'; sessionId: string }
-  | { kind: 'run:end'; sessionId: string };
-
-/** What the store reads of a session row (`noteRows`). */
-export interface RunEstimatesRow {
-  /** The session. */
-  id: string;
-  /** Its run state: only a `running` row's estimates count. */
-  status: string;
-  /** The estimates of its runs in progress. */
-  runEstimates?: readonly RunEstimateView[];
-}
-
-/** Every session's run estimates, outside React. */
-export interface RunEstimatesStore {
-  /** Follow the signals; returns the stop. Call once at boot. */
-  start(): () => void;
-  /** The session's estimates, the session's own run first; the same empty list when it has none. */
-  get(sessionId: string): readonly RunEstimateView[];
-  /** Fires when the session's estimates change. */
-  subscribe(sessionId: string, listener: () => void): () => void;
-  /** The session list's word on its running sessions' estimates (a window that missed the signals). */
-  noteRows(rows: readonly RunEstimatesRow[]): void;
-}
-
-const NONE: readonly RunEstimateView[] = [];
-
-/**
- * The estimate a row shows: the session's own run (`depth` 0), or the
- * subagent named `label` (`child-3`). `undefined` when there is none.
- *
- * @param estimates - The session's estimates ({@link RunEstimatesStore.get}).
- * @param label - A subagent's label; absent for the session's own run.
- */
-export function pickRunEstimate(estimates: readonly RunEstimateView[], label?: string): RunEstimateView | undefined {
-  return label === undefined ? estimates.find((e) => e.depth === 0) : estimates.find((e) => e.label === label);
-}
-
-/** The session's own run first, then by start: the order a row's list keeps. */
-function ordered(views: Iterable<RunEstimateView>): readonly RunEstimateView[] {
-  return [...views].sort((a, b) => a.depth - b.depth || a.startedAt - b.startedAt);
-}
-
-/**
- * The store over `subscribe`, the app's feed of every session's stream
- * signals (an Electron bus, a server connection's `ipc.signal`).
- *
- * @param options - The signal feed.
- */
-export function createRunEstimates(options: {
-  subscribe: (listener: (signal: { kind: string }) => void) => () => void;
-}): RunEstimatesStore {
-  /** Per session, by run id. */
-  const sessions = new Map<string, Map<string, RunEstimateView>>();
-  /** Per session, the list `get` returns: one object until it changes. */
-  const lists = new Map<string, readonly RunEstimateView[]>();
-  const listeners = new Map<string, Set<() => void>>();
-
-  const changed = (sessionId: string): void => {
-    const runs = sessions.get(sessionId);
-    if (runs && runs.size > 0) lists.set(sessionId, ordered(runs.values()));
-    else {
-      sessions.delete(sessionId);
-      lists.delete(sessionId);
-    }
-    for (const listener of listeners.get(sessionId) ?? []) listener();
-  };
-
-  const clear = (sessionId: string): void => {
-    if (!sessions.delete(sessionId)) return;
-    changed(sessionId);
-  };
-
-  /** Keep `view` unless what the session holds for its run is newer. `live`: a signal, which always wins. */
-  const put = (sessionId: string, view: RunEstimateView, live: boolean): boolean => {
-    let runs = sessions.get(sessionId);
-    if (!runs) {
-      runs = new Map();
-      sessions.set(sessionId, runs);
-    }
-    const held = runs.get(view.runId);
-    if (held && !live && held.at >= view.at) return false;
-    runs.set(view.runId, view);
-    return true;
-  };
-
-  const apply = (signal: RunEstimatesSignal): void => {
-    if (signal.kind === 'run:estimate') {
-      put(signal.sessionId, signal.estimate, true);
-      changed(signal.sessionId);
-    } else clear(signal.sessionId);
-  };
-
-  return {
-    start: () =>
-      options.subscribe((signal) => {
-        if (
-          (signal.kind === 'run:estimate' || signal.kind === 'run:start' || signal.kind === 'run:end') &&
-          'sessionId' in signal &&
-          typeof signal.sessionId === 'string'
-        ) {
-          apply(signal as RunEstimatesSignal);
-        }
-      }),
-    get: (sessionId) => lists.get(sessionId) ?? NONE,
-    subscribe(sessionId, listener) {
-      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);
-      };
-    },
-    noteRows(rows) {
-      for (const row of rows) {
-        if (row.status !== 'running') {
-          clear(row.id);
-          continue;
-        }
-        let any = false;
-        for (const view of row.runEstimates ?? []) any = put(row.id, view, false) || any;
-        if (any) changed(row.id);
-      }
-    },
-  };
-}

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

@@ -1,41 +0,0 @@
-/**
- * What the sidebar asks of the platform beyond the session list
- * (`ChatHost.sessions`): showing a folder in the file manager, opening a
- * session in a window of its own, the commands of the environment a
- * session runs in, the rows' badges, and a host's settings. Every member is
- * optional: leaving one out hides what needs it.
- *
- * The desktop app implements it over IPC (`hosts/electron-sidebar-host.ts`),
- * `createServerSidebarHost` (`zidane-ui/adapters`) over zidane-server. Both
- * run `describeSidebarHostContract` (`zidane-ui/chat/testing/contract`).
- */
-import type { EnvironmentActionResult, EnvironmentActionSummary } from 'zidane/chat';
-
-import type { SessionBadgesSource } from './badges';
-
-/** What a standalone window shows: the conversation with its panels, the conversation alone, or the panels alone. */
-export type SessionWindowMode = 'chat+panels' | 'chat' | 'panels';
-
-/** The commands of the environment a session runs in (push the branch, open a pull request). */
-export interface SidebarEnvironmentHost {
-  /** The commands the session's environment offers right now. Rejects when they can't be read. */
-  actions(sessionId: string): Promise<readonly EnvironmentActionSummary[]>;
-  /** Runs one of them; resolves with what to tell the user and, maybe, something to open. */
-  run(sessionId: string, actionId: string): Promise<EnvironmentActionResult>;
-  /** Sets a failed environment up again; progress arrives as the session's row changing. */
-  retry(sessionId: string): Promise<void>;
-}
-
-/** The sidebar's platform capabilities. Every member is optional. */
-export interface SidebarHost {
-  /** Shows a folder of this machine in the file manager. Absent: no "Open in Finder". */
-  revealPath?(path: string): Promise<void>;
-  /** Opens a session in a window of its own. Absent: no window rows. */
-  openWindow?(sessionId: string, mode: SessionWindowMode): Promise<void>;
-  /** A session's environment commands. Absent: no retry, no environment commands. */
-  environment?: SidebarEnvironmentHost;
-  /** The rows' badges and when they change, for `createSessionBadges`. Absent: the app reads them its own way, or rows show none. */
-  badges?: SessionBadgesSource;
-  /** Opens a saved host's page in the app's settings. Absent: a server folder's host badge is not a button. */
-  openHostSettings?(hostId: string): Promise<void>;
-}

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

@@ -1,18 +0,0 @@
-/** The session sidebar's headless layer: rows, views, the session directory and its live stores. */
-export * from './types';
-export * from './labels';
-export * from './rows';
-export * from './pinned-sessions';
-export * from './pinned-projects';
-export * from './project-icons';
-export * from './activity';
-export * from './estimates';
-export * from './compaction';
-export * from './badges';
-export * from './view';
-export * from './notifications';
-export * from './directory';
-export * from './query';
-export * from './host';
-export * from './dot-state';
-export * from './environment';

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

@@ -1,161 +0,0 @@
-/**
- * The sidebar's strings, on top of the chat layer's. One flat dictionary an app
- * overrides through `LabelsProvider`; headless helpers take it as an argument.
- * Each part keeps its keys under its own heading.
- */
-import { DEFAULT_CHAT_LABELS } from '../labels';
-
-/** The default English strings of the session sidebar, merged over the chat layer's. */
-export const DEFAULT_SIDEBAR_LABELS = {
-  ...DEFAULT_CHAT_LABELS,
-  // — Rows and live activity
-  // The orchestration main session's pinned row
-  mainSession: 'Main',
-  changeMainIcon: 'Change Main icon',
-  // What a running session is doing, when no tool names it
-  activityCompacting: 'Compacting',
-  activityRetrying: 'Retrying',
-  activityWriting: 'Writing',
-  activityThinking: 'Thinking',
-  // Project icons: the trigger's tooltip and name, the picker
-  changeProjectIcon: 'Change project icon',
-  changeIconFor: (project: string) => `Change icon for ${project}`,
-  chooseProjectIcon: 'Choose project icon',
-  emojiPlaceholder: 'Type any emoji, then ⏎',
-  customEmoji: 'Custom emoji',
-  chooseImage: 'Choose image…',
-  resetToFolder: 'Reset to folder',
-  // — The sidebar, its list, filters, search and spaces
-  searchSessionsLabel: 'Search sessions by title and content',
-  clearSearch: 'Clear search',
-  spaces: 'Spaces',
-  spaceNamed: (name: string) => `Space: ${name}`,
-  // A space an extension adds: its tooltip line, and the switcher's menu on a space
-  spaceFromExtension: (extension: string) => `From ${extension}`,
-  spaceOptions: (name: string) => `${name} options`,
-  hideSpace: 'Hide from switcher',
-  moveSpaceLeft: 'Move left',
-  moveSpaceRight: 'Move right',
-  hiddenSpaces: 'Hidden spaces',
-  showHiddenSpace: (name: string) => `Show ${name}`,
-  savedViewName: (n: number) => `View ${n}`,
-  saveViewFailed: (message: string) => `Couldn't save the view: ${message}`,
-  // Query groupings: the group of sessions without a value, and the agent grouping's for the default agent
-  queryGroupOther: 'Other',
-  agentGroupDefault: 'Default agent',
-  // Extension items among the sessions
-  itemActions: (title: string) => `Actions for ${title}`,
-  expandItem: (title: string) => `Show sessions under ${title}`,
-  collapseItem: (title: string) => `Hide sessions under ${title}`,
-  itemOpenFailed: (message: string) => `Couldn't open the item: ${message}`,
-  newSessionTitle: 'New session (⌘N / Ctrl+N)',
-  searchingSessions: 'Searching…',
-  sidebarNoMatches: 'No matches.',
-  noChatsYet: 'No chats yet.',
-  // The empty list while the view's filters hide every session, and its reset
-  noChatsMatchFilters: 'No chats match these filters.',
-  resetFilters: 'Reset filters',
-  expandSidebar: 'Expand sidebar',
-  collapseSidebar: 'Collapse sidebar',
-  // A row's trailing slot: before this window saw what the run does, waiting on the user, run details off
-  rowRunning: 'Running',
-  rowNeedsYou: 'Needs you',
-  rowWorking: 'Working',
-  // Where a session runs (its chip on the badge line, the delete prompt)
-  environmentKinds: {
-    local: 'Local',
-    worktree: 'Worktree',
-    docker: 'Docker',
-    e2b: 'E2B',
-    daytona: 'Daytona',
-  } as Readonly<Record<string, string>>,
-  environmentOnMachine: (kind: string, machine: string) => `${kind} @ ${machine}`,
-  environmentOnBranch: (kind: string, branch: string) => `${kind} (${branch})`,
-  environmentSettingUp: (where: string) => `${where}. Setting up…`,
-  environmentSetupFailed: (where: string, error?: string) => `${where}. Setup failed${error ? `: ${error}` : '.'}`,
-  environmentPaused: (where: string) => `${where}. Paused while idle, resumes on your next prompt.`,
-  // — Session and project menus
-  menuRename: 'Rename',
-  menuAddFavorite: 'Add to favorites',
-  menuRemoveFavorite: 'Remove from favorites',
-  menuArchive: 'Archive',
-  menuUnarchive: 'Unarchive',
-  menuReveal: 'Open in Finder',
-  menuCopyPath: 'Copy folder path',
-  menuOpenWindow: 'Open in new window',
-  menuOpenChatWindow: 'Open conversation in new window',
-  menuOpenPanelsWindow: 'Open side panels in new window',
-  menuRetryEnvironment: 'Retry environment setup',
-  menuMoveTo: 'Move to…',
-  menuMoveToSpace: 'Move to space',
-  menuDelete: 'Delete',
-  newSessionIn: (project: string) => `New session in ${project}`,
-  pinProject: 'Pin project',
-  unpinProject: 'Unpin project',
-  pinNamed: (project: string) => `Pin ${project}`,
-  unpinNamed: (project: string) => `Unpin ${project}`,
-  menuMoveProjectToSpace: 'Move project to space',
-  menuArchiveProject: 'Archive conversations…',
-  menuDeleteProject: 'Delete conversations…',
-  // Confirmations and failures
-  deleteSessionQuestion: (title: string) => `Delete "${title}"?`,
-  deleteSessionSandbox: (kind: string) => `Its ${kind} sandbox is deleted too. Push anything you want to keep first.`,
-  deleteConfirmLabel: 'Delete',
-  /** After a delete that left the session's environment on disk. */
-  environmentKept: (reason?: string) => `The session's environment was kept${reason ? `: ${reason}` : '.'}`,
-  /** After deleting several sessions, some of whose environments stayed on disk. */
-  environmentsKept: (count: number) =>
-    count === 1
-      ? "One session's environment was kept, so it is still on disk."
-      : `${count} sessions' environments were kept, so they are still on disk.`,
-  archiveConfirmLabel: 'Archive',
-  archiveProjectTitle: (count: number, project: string) =>
-    `Archive ${count === 1 ? '1 conversation' : `${count} conversations`} in ${project}?`,
-  archiveProjectMessage: (count: number) =>
-    count === 1
-      ? 'It stays under Archived, where you can restore it.'
-      : 'They stay under Archived, where you can restore them.',
-  deleteProjectTitle: (count: number, project: string) =>
-    `Delete ${count === 1 ? '1 conversation' : `${count} conversations`} in ${project}?`,
-  deleteProjectCannotUndo: "This can't be undone.",
-  deleteProjectArchived: (archived: number) =>
-    archived === 1 ? '1 of them is archived.' : `${archived} of them are archived.`,
-  deleteProjectSandboxes: (sandboxed: number) =>
-    sandboxed === 1
-      ? 'One runs in a remote sandbox that is deleted too. Push anything you want to keep first.'
-      : `${sandboxed} run in remote sandboxes that are deleted too. Push anything you want to keep first.`,
-  moveSessionFailed: (message: string) => `Couldn't move the session: ${message}`,
-  moveProjectFailed: (message: string) => `Couldn't move the project: ${message}`,
-  environmentActionFailed: (action: string, message: string) => `${action} failed: ${message}`,
-  retryEnvironmentFailed: (message: string) => `Couldn't retry the environment: ${message}`,
-  // — Footer strip
-  footerSettings: 'Settings',
-  footerSettingsWithNote: (note: string) => `Settings. ${note}`,
-  footerSignIn: 'sign in',
-  footerSignInTitle: 'No provider credentials. Click to sign in',
-  usageWindow: (window: string, percent: string) => `${window} window: ${percent}% used`,
-  usagePanelHint: 'Ctrl+P opens the usage panel.',
-  compactingTitle: 'Summarizing older turns to free up context.',
-  // — Settings › Spaces
-  spacesTitle: 'Spaces',
-  useSpaces: 'Use spaces',
-  useSpacesDescription:
-    'Group sessions into spaces, each with its own defaults for new sessions. Off shows every session in one list.',
-  yourSpaces: 'Your spaces',
-  addSpace: 'Add space',
-  newSpaceName: (n: number) => `Space ${n}`,
-  defaultSpaceName: 'Default',
-  deleteSpaceQuestion: (name: string) => `Delete "${name}"?`,
-  deleteSpaceMessage: (fallback: string) => `Its sessions move to ${fallback}. No session is deleted.`,
-  deleteSpace: 'Delete space',
-  spaceNameOf: (name: string) => `Name of space ${name}`,
-  moveSpaceUp: (name: string) => `Move ${name} up`,
-  moveSpaceDown: (name: string) => `Move ${name} down`,
-  deleteSpaceNamed: (name: string) => `Delete ${name}`,
-  changeSpaceIcon: 'Change space icon',
-  chooseSpaceIcon: 'Choose space icon',
-  resetToInitial: 'Reset to initial',
-};
-
-/** The sidebar's strings, as {@link DEFAULT_SIDEBAR_LABELS} has them. */
-export type SidebarLabels = typeof DEFAULT_SIDEBAR_LABELS;

package/src/chat/headless/sidebar/notifications.ts

@@ -1,61 +0,0 @@
-/**
- * Per-session notifications: a run that ended in a session nobody was
- * looking at leaves "completed" or "error" on it until the session opens.
- * Listeners subscribe per session, so a dot re-renders only for its own.
- */
-
-/** What a finished run left on a session the user wasn't watching. */
-export type SessionNotification = 'completed' | 'error';
-
-/** The notifications by session, subscribed to per session. */
-export interface SessionNotificationStore {
-  /** The session's notification, `null` for none. */
-  get(sessionId: string | null): SessionNotification | null;
-  /** Fires when the session's notification changes. */
-  subscribe(sessionId: string | null, listener: () => void): () => void;
-  /** Leaves a notification on the session. */
-  set(sessionId: string, value: SessionNotification): void;
-  /** Clears the session's notification (it was opened). */
-  clear(sessionId: string): void;
-}
-
-/** An empty notification store. */
-export function createNotificationStore(): SessionNotificationStore {
-  const map = new Map<string, SessionNotification>();
-  const listeners = new Map<string, Set<() => void>>();
-
-  const notify = (sessionId: string) => {
-    const set = listeners.get(sessionId);
-    if (!set) return;
-    for (const fn of set) fn();
-  };
-
-  return {
-    get: (sessionId) => (sessionId ? (map.get(sessionId) ?? null) : null),
-    subscribe: (sessionId, listener) => {
-      if (!sessionId) return () => undefined;
-      let set = listeners.get(sessionId);
-      if (!set) {
-        set = new Set();
-        listeners.set(sessionId, set);
-      }
-      set.add(listener);
-      return () => {
-        const live = listeners.get(sessionId);
-        if (!live) return;
-        live.delete(listener);
-        if (live.size === 0) listeners.delete(sessionId);
-      };
-    },
-    set: (sessionId, value) => {
-      if (map.get(sessionId) === value) return;
-      map.set(sessionId, value);
-      notify(sessionId);
-    },
-    clear: (sessionId) => {
-      if (!map.has(sessionId)) return;
-      map.delete(sessionId);
-      notify(sessionId);
-    },
-  };
-}

package/src/chat/headless/sidebar/pinned-projects.ts

@@ -1,51 +0,0 @@
-/**
- * Pinned projects: folders the user keeps at the top of the project-grouped
- * sidebar, one list per space. The model is pure; the app persists it (the
- * styled `usePinnedProjects` keeps it in localStorage under
- * {@link PINNED_PROJECTS_KEY}).
- */
-
-/** Where the pins persist. */
-export const PINNED_PROJECTS_KEY = 'zg-sidebar-pinned-projects';
-
-/** Pinned folder paths per space id, in pin order. */
-export type PinsBySpace = Record<string, string[]>;
-
-/**
- * Reads a stored pin map, dropping anything malformed and duplicate paths.
- *
- * @param raw - The stored JSON.
- */
-export function parsePinnedProjects(raw: string): PinsBySpace {
-  try {
-    const parsed: unknown = JSON.parse(raw);
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return {};
-    const out: PinsBySpace = {};
-    for (const [space, paths] of Object.entries(parsed)) {
-      if (!Array.isArray(paths)) continue;
-      const kept = [...new Set(paths.filter((p): p is string => typeof p === 'string' && p !== ''))];
-      if (kept.length > 0) out[space] = kept;
-    }
-    return out;
-  } catch {
-    return {};
-  }
-}
-
-/**
- * `pins` with `fullPath` pinned or unpinned in `spaceId`; the same object when nothing changes.
- *
- * @param pins - The current pins.
- * @param spaceId - The space the change is in.
- * @param fullPath - The project folder.
- * @param pin - Pin (true) or unpin (false).
- */
-export function withPinnedProject(pins: PinsBySpace, spaceId: string, fullPath: string, pin: boolean): PinsBySpace {
-  const own = pins[spaceId] ?? [];
-  if (own.includes(fullPath) === pin) return pins;
-  const nextOwn = pin ? [...own, fullPath] : own.filter((p) => p !== fullPath);
-  const next = { ...pins };
-  if (nextOwn.length > 0) next[spaceId] = nextOwn;
-  else delete next[spaceId];
-  return next;
-}

package/src/chat/headless/sidebar/pinned-sessions.ts

@@ -1,27 +0,0 @@
-/**
- * Sessions on screen besides the active conversation (a `/side` chat in the
- * panel): the transcript cache keeps them while pinned.
- */
-const pinned = new Map<string, number>();
-
-/**
- * Keep `key`'s transcript cached until the returned unpin runs.
- *
- * @param key - The session to keep.
- */
-export function pinSession(key: string): () => void {
-  pinned.set(key, (pinned.get(key) ?? 0) + 1);
-  let done = false;
-  return () => {
-    if (done) return;
-    done = true;
-    const n = (pinned.get(key) ?? 1) - 1;
-    if (n > 0) pinned.set(key, n);
-    else pinned.delete(key);
-  };
-}
-
-/** The sessions pinned now (each once, however many pins). */
-export function pinnedSessions(): Iterable<string> {
-  return pinned.keys();
-}