nastechai-desktop 18.1.0

package/src/store/subagents.test.ts

@@ -0,0 +1,111 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  $subagentsBySession,
+  activeSubagentCount,
+  buildSubagentTree,
+  clearSessionSubagents,
+  pruneDelegateFallbackSubagents,
+  upsertSubagent
+} from './subagents'
+
+const listFor = (sid: string) => $subagentsBySession.get()[sid] ?? []
+
+describe('subagent store', () => {
+  beforeEach(() => $subagentsBySession.set({}))
+
+  it('upserts subagent progress and keeps terminal status stable', () => {
+    upsertSubagent('s1', { goal: 'scan files', status: 'running', subagent_id: 'a1', task_index: 0 })
+    upsertSubagent('s1', { goal: 'scan files', status: 'completed', subagent_id: 'a1', summary: 'done', task_index: 0 })
+    upsertSubagent('s1', { goal: 'scan files', status: 'running', subagent_id: 'a1', task_index: 0, text: 'late' })
+
+    const item = listFor('s1')[0]
+    expect(item?.status).toBe('completed')
+    expect(item?.summary).toBe('done')
+  })
+
+  it('builds parent/child trees', () => {
+    upsertSubagent('s1', { goal: 'parent', status: 'running', subagent_id: 'p', task_index: 0 })
+    upsertSubagent('s1', { goal: 'child', parent_id: 'p', status: 'queued', subagent_id: 'c', task_index: 1 })
+
+    const tree = buildSubagentTree(listFor('s1'))
+    expect(tree).toHaveLength(1)
+    expect(tree[0]?.children[0]?.goal).toBe('child')
+    expect(activeSubagentCount(listFor('s1'))).toBe(2)
+  })
+
+  it('keeps root nodes in spawn order, not task index order', () => {
+    const nowSpy = vi.spyOn(Date, 'now')
+    nowSpy.mockReturnValueOnce(1_000)
+    upsertSubagent('s1', { goal: 'first spawn', status: 'running', subagent_id: 'a', task_index: 2 })
+    nowSpy.mockReturnValueOnce(2_000)
+    upsertSubagent('s1', { goal: 'second spawn', status: 'running', subagent_id: 'b', task_index: 0 })
+    nowSpy.mockRestore()
+
+    expect(buildSubagentTree(listFor('s1')).map(n => n.id)).toEqual(['a', 'b'])
+  })
+
+  it('captures live thinking/progress/tool stream lines', () => {
+    upsertSubagent(
+      's1',
+      { goal: 'scan files', status: 'queued', subagent_id: 'a1', task_index: 0 },
+      true,
+      'subagent.spawn_requested'
+    )
+    upsertSubagent(
+      's1',
+      {
+        status: 'running',
+        subagent_id: 'a1',
+        task_index: 0,
+        tool_name: 'search_files',
+        tool_preview: 'pattern=NASTECH'
+      },
+      false,
+      'subagent.tool'
+    )
+    upsertSubagent(
+      's1',
+      { status: 'running', subagent_id: 'a1', task_index: 0, text: 'plan the search order' },
+      false,
+      'subagent.thinking'
+    )
+    upsertSubagent(
+      's1',
+      { status: 'running', subagent_id: 'a1', task_index: 0, text: 'found candidate matches' },
+      false,
+      'subagent.progress'
+    )
+    upsertSubagent(
+      's1',
+      { status: 'completed', subagent_id: 'a1', summary: 'search complete', task_index: 0 },
+      false,
+      'subagent.complete'
+    )
+
+    const item = listFor('s1')[0]
+    expect(item?.stream.map(e => e.kind)).toEqual(['tool', 'thinking', 'progress', 'summary'])
+    expect(item?.stream.find(e => e.kind === 'tool')?.text).toContain('Search Files')
+    expect(item?.stream.find(e => e.kind === 'thinking')?.text).toBe('plan the search order')
+    expect(item?.stream.find(e => e.kind === 'summary')?.text).toBe('search complete')
+  })
+
+  it('prunes delegate fallback rows once native events arrive', () => {
+    upsertSubagent('s1', { goal: 'fallback', status: 'running', subagent_id: 'delegate-tool:abc:0', task_index: 0 })
+    upsertSubagent('s1', { goal: 'native', status: 'running', subagent_id: 'sa-0-xyz', task_index: 0 })
+
+    pruneDelegateFallbackSubagents('s1')
+
+    expect(listFor('s1').map(item => item.id)).toEqual(['sa-0-xyz'])
+  })
+
+  it('clears one session without touching another', () => {
+    upsertSubagent('s1', { goal: 'one', status: 'running', subagent_id: 'a1', task_index: 0 })
+    upsertSubagent('s2', { goal: 'two', status: 'running', subagent_id: 'a2', task_index: 0 })
+
+    clearSessionSubagents('s1')
+
+    expect($subagentsBySession.get().s1).toBeUndefined()
+    expect($subagentsBySession.get().s2).toHaveLength(1)
+  })
+})

package/src/store/subagents.ts

@@ -0,0 +1,260 @@
+import { atom } from 'nanostores'
+
+export type SubagentStatus = 'completed' | 'failed' | 'interrupted' | 'queued' | 'running'
+export type SubagentStreamKind = 'progress' | 'summary' | 'thinking' | 'tool'
+
+export interface SubagentStreamEntry {
+  at: number
+  isError?: boolean
+  kind: SubagentStreamKind
+  text: string
+}
+
+export interface SubagentProgress {
+  id: string
+  parentId: null | string
+  goal: string
+  model?: string
+  status: SubagentStatus
+  taskCount: number
+  taskIndex: number
+  startedAt: number
+  updatedAt: number
+  durationSeconds?: number
+  costUsd?: number
+  inputTokens?: number
+  outputTokens?: number
+  toolCount?: number
+  filesRead: string[]
+  filesWritten: string[]
+  stream: SubagentStreamEntry[]
+  summary?: string
+  /** Active tool while running — cleared on terminal status. */
+  currentTool?: string
+}
+
+export interface SubagentNode extends SubagentProgress {
+  children: SubagentNode[]
+}
+
+export type SubagentPayload = Record<string, unknown>
+
+const TERMINAL: ReadonlySet<SubagentStatus> = new Set(['completed', 'failed', 'interrupted'])
+const MAX_STREAM = 24
+const PREVIEW_MAX = 220
+const TOOL_PREVIEW_MAX = 96
+
+export const $subagentsBySession = atom<Record<string, SubagentProgress[]>>({})
+
+const isStr = (v: unknown): v is string => typeof v === 'string'
+const str = (v: unknown) => (isStr(v) ? v : '')
+const num = (v: unknown) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined)
+const strList = (v: unknown) => (Array.isArray(v) ? v.filter(isStr) : [])
+
+const asStatus = (v: unknown): SubagentStatus =>
+  v === 'completed' || v === 'failed' || v === 'interrupted' || v === 'queued' ? v : 'running'
+
+const compact = (text: string, max = PREVIEW_MAX) => {
+  const line = text.replace(/\s+/g, ' ').trim()
+
+  if (!line) {
+    return ''
+  }
+
+  return line.length > max ? `${line.slice(0, max - 1)}…` : line
+}
+
+const toolLabel = (name: string) =>
+  name
+    .split('_')
+    .filter(Boolean)
+    .map(p => p[0]!.toUpperCase() + p.slice(1))
+    .join(' ') || name
+
+const formatTool = (name: string, preview = '') => {
+  const snippet = compact(preview, TOOL_PREVIEW_MAX)
+
+  return snippet ? `${toolLabel(name)}("${snippet}")` : toolLabel(name)
+}
+
+interface TailEntry {
+  isError?: boolean
+  preview?: string
+  tool?: string
+}
+
+const asTail = (v: unknown): TailEntry[] =>
+  Array.isArray(v)
+    ? v
+        .filter((item): item is Record<string, unknown> => !!item && typeof item === 'object')
+        .map(item => ({
+          isError: item.is_error === true,
+          preview: str(item.preview) || undefined,
+          tool: str(item.tool) || undefined
+        }))
+    : []
+
+const idOf = (p: SubagentPayload) =>
+  str(p.subagent_id) || `${str(p.parent_id) || 'root'}:${num(p.task_index) ?? 0}:${str(p.goal)}`
+
+const appendStream = (stream: SubagentStreamEntry[], entry: SubagentStreamEntry) => {
+  const last = stream.at(-1)
+
+  if (last?.kind === entry.kind && last.text === entry.text && last.isError === entry.isError) {
+    return stream
+  }
+
+  return [...stream, entry].slice(-MAX_STREAM)
+}
+
+function streamFromPayload(
+  payload: SubagentPayload,
+  status: SubagentStatus,
+  eventType: string,
+  at: number
+): SubagentStreamEntry[] {
+  const out: SubagentStreamEntry[] = []
+  const tool = str(payload.tool_name)
+  const preview = str(payload.tool_preview) || str(payload.text)
+  const text = compact(str(payload.text) || preview)
+
+  for (const tail of asTail(payload.output_tail)) {
+    const line = tail.tool ? formatTool(tail.tool, tail.preview ?? '') : compact(tail.preview ?? '')
+
+    if (line) {
+      out.push({ at, isError: tail.isError, kind: tail.tool ? 'tool' : 'progress', text: line })
+    }
+  }
+
+  if (tool) {
+    out.push({ at, isError: !!payload.error, kind: 'tool', text: formatTool(tool, preview) })
+  }
+
+  if (eventType === 'subagent.progress' && text) {
+    out.push({ at, isError: !!payload.error, kind: 'progress', text })
+  }
+
+  if (eventType === 'subagent.thinking' && text) {
+    out.push({ at, kind: 'thinking', text })
+  }
+
+  const summary = compact(str(payload.summary) || str(payload.text))
+
+  if (TERMINAL.has(status) && summary) {
+    out.push({ at, isError: status === 'failed', kind: 'summary', text: summary })
+  }
+
+  return out
+}
+
+function toProgress(payload: SubagentPayload, prev: SubagentProgress | undefined, eventType = ''): SubagentProgress {
+  const at = Date.now()
+  const status = asStatus(payload.status)
+  const tool = str(payload.tool_name)
+  const stream = streamFromPayload(payload, status, eventType, at).reduce(appendStream, prev?.stream ?? [])
+  const filesRead = strList(payload.files_read)
+  const filesWritten = strList(payload.files_written)
+
+  return {
+    id: prev?.id ?? idOf(payload),
+    parentId: str(payload.parent_id) || prev?.parentId || null,
+    goal: str(payload.goal) || prev?.goal || 'Subagent',
+    model: str(payload.model) || prev?.model,
+    status,
+    taskCount: num(payload.task_count) ?? prev?.taskCount ?? 1,
+    taskIndex: num(payload.task_index) ?? prev?.taskIndex ?? 0,
+    startedAt: prev?.startedAt ?? at,
+    updatedAt: at,
+    durationSeconds: num(payload.duration_seconds) ?? prev?.durationSeconds,
+    costUsd: num(payload.cost_usd) ?? prev?.costUsd,
+    inputTokens: num(payload.input_tokens) ?? prev?.inputTokens,
+    outputTokens: num(payload.output_tokens) ?? prev?.outputTokens,
+    toolCount: num(payload.tool_count) ?? prev?.toolCount,
+    filesRead: filesRead.length ? filesRead : (prev?.filesRead ?? []),
+    filesWritten: filesWritten.length ? filesWritten : (prev?.filesWritten ?? []),
+    stream,
+    summary: str(payload.summary) || prev?.summary,
+    currentTool: TERMINAL.has(status) ? undefined : tool || prev?.currentTool
+  }
+}
+
+export function clearSessionSubagents(sid: string) {
+  const map = $subagentsBySession.get()
+
+  if (!(sid in map)) {
+    return
+  }
+
+  const { [sid]: _drop, ...rest } = map
+  $subagentsBySession.set(rest)
+}
+
+export function pruneDelegateFallbackSubagents(sid: string) {
+  const map = $subagentsBySession.get()
+  const list = map[sid]
+
+  if (!list?.length) {
+    return
+  }
+
+  const next = list.filter(item => !item.id.startsWith('delegate-tool:'))
+
+  if (next.length === list.length) {
+    return
+  }
+
+  $subagentsBySession.set({ ...map, [sid]: next })
+}
+
+export function upsertSubagent(sid: string, payload: SubagentPayload, createIfMissing = true, eventType?: string) {
+  const map = $subagentsBySession.get()
+  const list = map[sid] ?? []
+  const id = idOf(payload)
+  const idx = list.findIndex(item => item.id === id)
+
+  if (idx < 0 && !createIfMissing) {
+    return
+  }
+
+  const prev = idx >= 0 ? list[idx] : undefined
+
+  if (prev && TERMINAL.has(prev.status)) {
+    return
+  }
+
+  const next = toProgress(payload, prev, eventType)
+  const nextList = idx >= 0 ? list.map(item => (item.id === id ? next : item)) : [...list, next]
+
+  $subagentsBySession.set({ ...map, [sid]: nextList })
+}
+
+export function buildSubagentTree(items: readonly SubagentProgress[]): SubagentNode[] {
+  const nodes = new Map<string, SubagentNode>()
+
+  for (const item of items) {
+    nodes.set(item.id, { ...item, children: [] })
+  }
+
+  const roots: SubagentNode[] = []
+
+  for (const node of nodes.values()) {
+    const parent = node.parentId ? nodes.get(node.parentId) : null
+
+    if (parent) {
+      parent.children.push(node)
+    } else {
+      roots.push(node)
+    }
+  }
+
+  const sort = (a: SubagentNode, b: SubagentNode) =>
+    a.startedAt - b.startedAt || a.taskIndex - b.taskIndex || a.goal.localeCompare(b.goal)
+
+  const walk = (node: SubagentNode) => node.children.sort(sort).forEach(walk)
+  roots.sort(sort).forEach(walk)
+
+  return roots
+}
+
+export const activeSubagentCount = (items: readonly SubagentProgress[]) =>
+  items.filter(item => item.status === 'queued' || item.status === 'running').length

package/src/store/thread-scroll.ts

@@ -0,0 +1,46 @@
+import { atom, type WritableAtom } from 'nanostores'
+
+export const $threadScrolledUp = atom(false)
+export const $threadJumpButtonVisible = atom(false)
+
+const setter = (target: WritableAtom<boolean>) => (value: boolean) => {
+  if (target.get() !== value) {
+    target.set(value)
+  }
+}
+
+const setScrolledUp = setter($threadScrolledUp)
+const setJumpButtonVisible = setter($threadJumpButtonVisible)
+
+export const setThreadAtBottom = (isAtBottom: boolean) => {
+  setScrolledUp(!isAtBottom)
+  setJumpButtonVisible(!isAtBottom)
+}
+
+export const resetThreadScroll = () => setThreadAtBottom(true)
+
+const handlers = new Set<() => void>()
+
+export const onScrollToBottomRequest = (handler: () => void) => {
+  handlers.add(handler)
+  return () => void handlers.delete(handler)
+}
+
+export const requestScrollToBottom = () => handlers.forEach(handler => handler())
+
+const editOpenHandlers = new Set<() => void>()
+const editCloseHandlers = new Set<() => void>()
+
+export const onThreadEditOpen = (handler: () => void) => {
+  editOpenHandlers.add(handler)
+  return () => void editOpenHandlers.delete(handler)
+}
+
+export const notifyThreadEditOpen = () => editOpenHandlers.forEach(handler => handler())
+
+export const onThreadEditClose = (handler: () => void) => {
+  editCloseHandlers.add(handler)
+  return () => void editCloseHandlers.delete(handler)
+}
+
+export const notifyThreadEditClose = () => editCloseHandlers.forEach(handler => handler())

package/src/store/todos.test.ts

@@ -0,0 +1,47 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { TodoItem } from '@/lib/todos'
+
+import { $todosBySession, clearSessionTodos, setSessionTodos } from './todos'
+
+const todo = (id: string, status: TodoItem['status']): TodoItem => ({ content: `task ${id}`, id, status })
+
+describe('setSessionTodos finished-list auto-clear', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    clearSessionTodos('s1')
+    vi.useRealTimers()
+  })
+
+  it('keeps an in-flight list indefinitely', () => {
+    setSessionTodos('s1', [todo('a', 'completed'), todo('b', 'in_progress')])
+
+    vi.advanceTimersByTime(60_000)
+
+    expect($todosBySession.get().s1).toHaveLength(2)
+  })
+
+  it('drops the list shortly after every item completes', () => {
+    setSessionTodos('s1', [todo('a', 'completed'), todo('b', 'cancelled')])
+
+    expect($todosBySession.get().s1).toHaveLength(2)
+
+    vi.advanceTimersByTime(5_000)
+
+    expect($todosBySession.get().s1).toBeUndefined()
+  })
+
+  it('cancels the pending clear when a new active list arrives', () => {
+    setSessionTodos('s1', [todo('a', 'completed')])
+    vi.advanceTimersByTime(2_000)
+
+    // The next turn starts a fresh plan before the linger expires.
+    setSessionTodos('s1', [todo('a', 'completed'), todo('b', 'pending')])
+    vi.advanceTimersByTime(60_000)
+
+    expect($todosBySession.get().s1).toHaveLength(2)
+  })
+})

package/src/store/todos.ts

@@ -0,0 +1,64 @@
+import { atom } from 'nanostores'
+
+import type { TodoItem } from '@/lib/todos'
+
+/**
+ * Live todo list per runtime session, rendered by the composer status stack
+ * (the inline transcript panel is gone). Fed from two places:
+ *
+ * - live `todo` tool events (use-message-stream)
+ * - stored-session hydration (desktop-controller) — but only when the list is
+ *   still in flight, so reopening an old chat doesn't pin its finished plan
+ *   above the composer forever.
+ */
+export const $todosBySession = atom<Record<string, TodoItem[]>>({})
+
+export const todoListActive = (todos: readonly TodoItem[]) =>
+  todos.some(t => t.status === 'pending' || t.status === 'in_progress')
+
+// Once a list finishes (every item completed/cancelled), the final state
+// lingers just long enough to see the last checkmark land, then the group
+// drops out of the stack on its own.
+const FINISHED_LINGER_MS = 4_000
+const clearTimers = new Map<string, ReturnType<typeof setTimeout>>()
+
+function cancelScheduledClear(sid: string) {
+  const timer = clearTimers.get(sid)
+
+  if (timer !== undefined) {
+    clearTimeout(timer)
+    clearTimers.delete(sid)
+  }
+}
+
+export function setSessionTodos(sid: string, todos: TodoItem[]) {
+  if (!sid) {
+    return
+  }
+
+  cancelScheduledClear(sid)
+  $todosBySession.set({ ...$todosBySession.get(), [sid]: todos })
+
+  if (!todoListActive(todos)) {
+    clearTimers.set(
+      sid,
+      setTimeout(() => {
+        clearTimers.delete(sid)
+        clearSessionTodos(sid)
+      }, FINISHED_LINGER_MS)
+    )
+  }
+}
+
+export function clearSessionTodos(sid: string) {
+  cancelScheduledClear(sid)
+
+  const map = $todosBySession.get()
+
+  if (!(sid in map)) {
+    return
+  }
+
+  const { [sid]: _drop, ...rest } = map
+  $todosBySession.set(rest)
+}

package/src/store/tool-diffs.ts

@@ -0,0 +1,23 @@
+import { atom } from 'nanostores'
+
+const $toolDiffs = atom<Record<string, string>>({})
+
+export function recordToolDiff(toolCallId: string, diff: string) {
+  if (!toolCallId || !diff) {
+    return
+  }
+
+  const current = $toolDiffs.get()
+
+  if (current[toolCallId] === diff) {
+    return
+  }
+
+  $toolDiffs.set({ ...current, [toolCallId]: diff })
+}
+
+export function getToolDiff(toolCallId: string): string {
+  return toolCallId ? $toolDiffs.get()[toolCallId] || '' : ''
+}
+
+export const $toolInlineDiffs = $toolDiffs

package/src/store/tool-dismiss.ts

@@ -0,0 +1,45 @@
+import { atom, computed, type ReadableAtom } from 'nanostores'
+
+type DismissedToolRows = Record<string, true>
+
+// Tool rows the user has locally hidden via a row's dismiss control. This is a
+// *view-only* hide: the underlying tool call still lives in the stored chat
+// history, but once a turn has settled the user can clear a completed/failed
+// row out of the way so it stops sitting at the tail of the conversation.
+//
+// Kept in module memory (not localStorage, unlike $toolDisclosureStates) on
+// purpose: the thread is virtualized, so a dismissed row's component unmounts
+// and remounts as it scrolls — component-local state would forget the dismissal
+// and the row would pop back. Storing it here survives those remounts for the
+// life of the app session, while a reload restores every row in place rather
+// than permanently rewriting history from a stray click.
+export const $dismissedToolRows = atom<DismissedToolRows>({})
+
+const dismissedCache = new Map<string, ReadableAtom<boolean>>()
+
+export function $toolRowDismissed(id: string): ReadableAtom<boolean> {
+  let cached = dismissedCache.get(id)
+
+  if (!cached) {
+    cached = computed($dismissedToolRows, rows => Boolean(rows[id]))
+    dismissedCache.set(id, cached)
+  }
+
+  return cached
+}
+
+export function dismissToolRow(id: string) {
+  if (!id || $dismissedToolRows.get()[id]) {
+    return
+  }
+
+  $dismissedToolRows.set({ ...$dismissedToolRows.get(), [id]: true })
+}
+
+export function clearDismissedToolRows() {
+  if (Object.keys($dismissedToolRows.get()).length === 0) {
+    return
+  }
+
+  $dismissedToolRows.set({})
+}

package/src/store/tool-view.ts

@@ -0,0 +1,91 @@
+import { atom, computed, type ReadableAtom } from 'nanostores'
+
+import { persistBoolean, storedBoolean } from '@/lib/storage'
+
+export type ToolViewMode = 'product' | 'technical'
+
+type ToolDisclosureStates = Record<string, boolean>
+
+const TOOL_VIEW_TECHNICAL_STORAGE_KEY = 'NASTECH.desktop.toolView.technical'
+const TOOL_DISCLOSURE_STORAGE_KEY = 'NASTECH.desktop.toolDisclosure.v1'
+const MAX_DISCLOSURE_STATES = 240
+
+export const $toolViewMode = atom<ToolViewMode>(
+  storedBoolean(TOOL_VIEW_TECHNICAL_STORAGE_KEY, false) ? 'technical' : 'product'
+)
+export const $toolDisclosureStates = atom<ToolDisclosureStates>(loadToolDisclosureStates())
+const disclosureOpenCache = new Map<string, ReadableAtom<boolean | undefined>>()
+
+$toolViewMode.subscribe(mode => persistBoolean(TOOL_VIEW_TECHNICAL_STORAGE_KEY, mode === 'technical'))
+$toolDisclosureStates.subscribe(persistToolDisclosureStates)
+
+export function setToolViewMode(mode: ToolViewMode) {
+  $toolViewMode.set(mode)
+}
+
+export function $toolDisclosureOpen(id: string): ReadableAtom<boolean | undefined> {
+  let cached = disclosureOpenCache.get(id)
+
+  if (!cached) {
+    cached = computed($toolDisclosureStates, states => states[id])
+    disclosureOpenCache.set(id, cached)
+  }
+
+  return cached
+}
+
+function loadToolDisclosureStates(): ToolDisclosureStates {
+  if (typeof window === 'undefined') {
+    return {}
+  }
+
+  try {
+    const raw = window.localStorage.getItem(TOOL_DISCLOSURE_STORAGE_KEY)
+
+    if (!raw) {
+      return {}
+    }
+
+    const parsed = JSON.parse(raw) as unknown
+
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return {}
+    }
+
+    return Object.fromEntries(
+      Object.entries(parsed as Record<string, unknown>)
+        .filter((entry): entry is [string, boolean] => typeof entry[0] === 'string' && typeof entry[1] === 'boolean')
+        .slice(-MAX_DISCLOSURE_STATES)
+    )
+  } catch {
+    return {}
+  }
+}
+
+function persistToolDisclosureStates(states: ToolDisclosureStates) {
+  if (typeof window === 'undefined') {
+    return
+  }
+
+  try {
+    const entries = Object.entries(states).slice(-MAX_DISCLOSURE_STATES)
+
+    window.localStorage.setItem(TOOL_DISCLOSURE_STORAGE_KEY, JSON.stringify(Object.fromEntries(entries)))
+  } catch {
+    // Tool disclosure is a local UI preference; ignore storage failures.
+  }
+}
+
+export function setToolDisclosureOpen(id: string, open: boolean) {
+  if (!id) {
+    return
+  }
+
+  const current = $toolDisclosureStates.get()
+
+  if (current[id] === open) {
+    return
+  }
+
+  $toolDisclosureStates.set({ ...current, [id]: open })
+}