@pheem49/mint 1.16.0 → 1.18.0

package/src/renderer/shared/conversation/progressiveStream.ts

@@ -0,0 +1,219 @@
+/**
+ * shared/conversation/progressiveStream.ts
+ * Deep module for structure-aware progressive AI response rendering (Line-by-Line + Block-Aware).
+ * Holds incomplete Markdown tables and unclosed UI Card / JSON / Mermaid fenced blocks until
+ * their block completes, while streaming normal paragraphs, lists, alerts, and regular code blocks
+ * smoothly line by line.
+ */
+
+const ATOMIC_FENCED_LANGS = new Set([
+  'ui-grid',
+  'ui_grid',
+  'ui-grid-json',
+  'ui_grid_json',
+  'ui-card',
+  'ui_card',
+  'ui-card-json',
+  'ui_card_json',
+  'ui-feature',
+  'ui_feature',
+  'ui-mockup',
+  'ui_mockup',
+  'ui-mockup-json',
+  'ui_mockup_json',
+  'weather_json',
+  'weather-json',
+  'stock_json',
+  'stock-json',
+  'calculation_json',
+  'calculation-json',
+  'image_search_json',
+  'image-search-json',
+  'image_gen_json',
+  'image-gen-json',
+  'mermaid',
+])
+
+function isTableLine(line: string): boolean {
+  const trimmed = line.trim()
+  return trimmed.startsWith('|') && trimmed.endsWith('|') && trimmed.length > 1
+}
+
+function isAtomicFencedLang(lang: string): boolean {
+  return ATOMIC_FENCED_LANGS.has(lang.trim().toLowerCase())
+}
+
+/**
+ * Splits Markdown text into progressive units:
+ * - Standard lines & normal code block lines -> 1 line per unit
+ * - Consecutive Markdown table lines (`| ... |`) -> 1 atomic multi-line unit
+ * - Custom UI / JSON / Mermaid fenced blocks -> 1 atomic multi-line unit
+ * When `isComplete` is false, trailing incomplete lines, open tables, and unclosed atomic
+ * fenced blocks are held back so half-formed tables or raw JSON never flash in the UI.
+ */
+export function splitProgressiveStreamUnits(raw: string, isComplete: boolean): string[] {
+  if (!raw) return []
+  const normalized = raw.replace(/\r\n?/g, '\n')
+  let slice = normalized
+  if (!isComplete && !normalized.endsWith('\n')) {
+    const lastNewline = normalized.lastIndexOf('\n')
+    if (lastNewline === -1) return []
+    slice = normalized.slice(0, lastNewline + 1)
+  }
+
+  const rawLines = slice.endsWith('\n') ? slice.slice(0, -1).split('\n') : slice.split('\n')
+  const units: string[] = []
+  let inCodeBlock = false
+  let pendingCodeFence: { fence: string; canPromote: boolean } | null = null
+  let inAtomicFence = false
+  let atomicFenceBuffer: string[] = []
+  let tableBuffer: string[] = []
+
+  for (const line of rawLines) {
+    const trimmed = line.trimStart()
+
+    if (!inCodeBlock && !inAtomicFence && isTableLine(trimmed)) {
+      tableBuffer.push(line)
+      continue
+    }
+
+    if (tableBuffer.length > 0) {
+      units.push(tableBuffer.join('\n'))
+      tableBuffer = []
+    }
+
+    if (trimmed.startsWith('```')) {
+      if (!inCodeBlock && !inAtomicFence) {
+        const afterOpen = trimmed.replace(/^`+/, '').trim()
+        if (afterOpen.endsWith('```') && afterOpen.length > 3) {
+          units.push(line)
+          continue
+        }
+        const splitIdx = afterOpen.search(/[\s[{]/)
+        const lang = splitIdx > 0 ? afterOpen.slice(0, splitIdx) : afterOpen
+        if (isAtomicFencedLang(lang)) {
+          inAtomicFence = true
+          atomicFenceBuffer = [line]
+        } else {
+          inCodeBlock = true
+          const canPromote = !lang || lang.toLowerCase() === 'plaintext'
+          pendingCodeFence = { fence: line, canPromote }
+        }
+      } else if (inAtomicFence) {
+        atomicFenceBuffer.push(line)
+        units.push(atomicFenceBuffer.join('\n'))
+        atomicFenceBuffer = []
+        inAtomicFence = false
+      } else {
+        inCodeBlock = false
+        if (pendingCodeFence) {
+          units.push(`${pendingCodeFence.fence}\n${line}`)
+          pendingCodeFence = null
+        } else {
+          units.push(line)
+        }
+      }
+      continue
+    }
+
+    if (inAtomicFence) {
+      atomicFenceBuffer.push(line)
+      continue
+    }
+
+    if (pendingCodeFence) {
+      const { fence, canPromote } = pendingCodeFence
+      pendingCodeFence = null
+      const splitIdx = trimmed.search(/[\s[{]/)
+      const firstToken = splitIdx > 0 ? trimmed.slice(0, splitIdx) : trimmed
+      if (canPromote && isAtomicFencedLang(firstToken)) {
+        inCodeBlock = false
+        inAtomicFence = true
+        atomicFenceBuffer = [fence, line]
+      } else {
+        units.push(`${fence}\n${line}`)
+      }
+      continue
+    }
+
+    units.push(line)
+  }
+
+  if (isComplete) {
+    if (tableBuffer.length > 0) {
+      units.push(tableBuffer.join('\n'))
+    }
+    if (pendingCodeFence) {
+      units.push(pendingCodeFence.fence)
+      pendingCodeFence = null
+    }
+    if (atomicFenceBuffer.length > 0) {
+      units.push(atomicFenceBuffer.join('\n'))
+    }
+  }
+
+  return units
+}
+
+/**
+ * Returns the safe-to-render prefix of a streaming Markdown document.
+ */
+export function extractRenderableStreamPrefix(raw: string, isComplete: boolean): string {
+  const units = splitProgressiveStreamUnits(raw, isComplete)
+  return units.join('\n')
+}
+
+export interface ProgressiveStreamPacer {
+  pushDelta(delta: string): void
+  finish(authoritativeText?: string): void
+  step(): string | null
+  flushAll(): string
+  isDone(): boolean
+}
+
+export function createProgressiveStreamPacer(
+  onReveal?: (revealedText: string) => void,
+): ProgressiveStreamPacer {
+  let rawBuffer = ''
+  let completed = false
+  let revealedUnits = 0
+
+  return {
+    pushDelta(delta: string) {
+      if (delta) {
+        rawBuffer += delta
+      }
+    },
+    finish(authoritativeText?: string) {
+      if (typeof authoritativeText === 'string') {
+        rawBuffer = authoritativeText
+      }
+      completed = true
+    },
+    step(): string | null {
+      const units = splitProgressiveStreamUnits(rawBuffer, completed)
+      if (revealedUnits >= units.length) {
+        return null
+      }
+      const remaining = units.length - revealedUnits
+      const advance = remaining <= 12 ? 1 : Math.min(4, Math.max(1, Math.floor(remaining / 10)))
+      revealedUnits = Math.min(units.length, revealedUnits + advance)
+      const revealed = units.slice(0, revealedUnits).join('\n')
+      onReveal?.(revealed)
+      return revealed
+    },
+    flushAll(): string {
+      completed = true
+      const units = splitProgressiveStreamUnits(rawBuffer, true)
+      revealedUnits = units.length
+      const revealed = units.join('\n')
+      onReveal?.(revealed)
+      return revealed
+    },
+    isDone(): boolean {
+      if (!completed) return false
+      const units = splitProgressiveStreamUnits(rawBuffer, true)
+      return revealedUnits >= units.length
+    },
+  }
+}

package/src/renderer/shared/conversation/projectNavigation.test.ts

@@ -103,3 +103,21 @@ describe('project selection', () => {
   })
 
 })
+
+it('handoff opens the exact saved conversation with its own workspace', async () => {
+  const { navigateToSavedConversation } = await import('./projectNavigation')
+  const target = session('cli::saved', '/projects/target', '2026-10-18T00:00:00Z', 'cli')
+  const { state, ports } = fixture([target])
+  expect(await navigateToSavedConversation(target.id, ports)).toBe(true)
+  expect(state.activeId).toBe('cli::saved')
+  expect(state.workspace).toBe('/projects/target')
+  expect(state.view).toBe('chat')
+})
+it('a missing or superseded handoff never opens a different conversation', async () => {
+  const { navigateToSavedConversation } = await import('./projectNavigation')
+  const { state, ports } = fixture([session('other', null, '2026-10-18T00:00:00Z')])
+  expect(await navigateToSavedConversation('deleted', ports)).toBe(false)
+  expect(state.activeId).toBe('conversation-origin')
+  expect(await navigateToSavedConversation('other', { ...ports, isCurrent: () => false })).toBe(false)
+  expect(state.activeId).toBe('conversation-origin')
+})

package/src/renderer/shared/conversation/projectNavigation.ts

@@ -37,3 +37,14 @@ export async function navigateToProject(path: string, navigation: ProjectNavigat
     await navigation.newChat(targetPath, view)
   }
 }
+
+/** Open a persisted ID without substituting another session or its workspace. */
+export async function navigateToSavedConversation(id: string, navigation: Pick<ProjectNavigation, 'listSessions' | 'openSession' | 'isCurrent'>): Promise<boolean> {
+  if (navigation.isCurrent?.() === false) return false
+  const sessions = await navigation.listSessions()
+  if (navigation.isCurrent?.() === false) return false
+  const session = sessions.find(session => session.id === id)
+  if (!session) return false
+  await navigation.openSession(session, 'chat')
+  return true
+}

package/src/renderer/shared/conversation/transport.test.ts

@@ -160,4 +160,24 @@ describe.each([['Desktop', desktop], ['Web', web]] as const)('%s Conversation tr
       'chat-1', undefined, true)).resolves.toEqual(response)
     expect(captured).toMatchObject({ ownerToken: 'owner-token', request: { chatId: 'chat-1', planMode: true } })
   })
+
+  it('validates the 32 MiB request limit without TextEncoder allocations or double JSON.stringify on native IPC', async () => {
+    const encodeSpy = vi.spyOn(TextEncoder.prototype, 'encode')
+    const stringifySpy = vi.spyOn(JSON, 'stringify')
+    ;(window as any).__TAURI_INTERNALS__ = {}
+    native.invoke.mockResolvedValue(response)
+
+    await expect(adapter.streamChatMessage('hello', () => {}, 'data:image/png;base64,AAAA')).resolves.toEqual(response)
+    expect(encodeSpy).not.toHaveBeenCalled()
+    expect(stringifySpy).not.toHaveBeenCalled()
+
+    const oversized = 'A'.repeat(32 * 1024 * 1024 + 64)
+    await expect(adapter.streamChatMessage('hello', () => {}, oversized)).rejects.toThrow(
+      'Attachments exceed the 32 MiB request limit. Send fewer files at once.',
+    )
+    delete (window as any).__TAURI_INTERNALS__
+    await expect(adapter.streamChatMessage('hello', () => {}, oversized)).rejects.toThrow(
+      'Attachments exceed the 32 MiB request limit. Send fewer files at once.',
+    )
+  })
 })

package/src/renderer/shared/conversation/transport.ts

@@ -84,6 +84,29 @@ function withMediaPlaceholders(message: string, imageDataUri?: string | null, vi
   return message
 }
 
+const MAX_REQUEST_BYTES = 32 * 1024 * 1024
+const REQUEST_LIMIT_ERROR = 'Attachments exceed the 32 MiB request limit. Send fewer files at once.'
+
+function utf8ByteLength(value?: string | null): number {
+  if (!value) return 0
+  if (value.length > MAX_REQUEST_BYTES) return value.length
+  if (value.startsWith('data:') && value.includes(';base64,')) return value.length
+  let bytes = value.length
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i)
+    if (code >= 0x80) {
+      if (code <= 0x7ff) bytes += 1
+      else if (code >= 0xd800 && code <= 0xdbff) {
+        bytes += 2
+        i++
+      } else {
+        bytes += 2
+      }
+    }
+  }
+  return bytes
+}
+
 /** Shared wire contract; adapters supply runtime detection, address and authentication. */
 export function createConversationTransport(environment: TransportEnvironment): ConversationOperations {
   const requestBody = (message: string, imageDataUri?: string | null, audioDataUri?: string | null,
@@ -95,14 +118,33 @@ export function createConversationTransport(environment: TransportEnvironment):
     imageDataUri, audioDataUri, videoDataUri, documentAttachment, workspacePath, chatId, agentId, planMode, pinnedMcpServer,
   })
 
-  const validate = (request: ReturnType<typeof requestBody>) => {
-    const body = JSON.stringify(request)
-    if (new TextEncoder().encode(body).byteLength > 32 * 1024 * 1024) throw new Error('Attachments exceed the 32 MiB request limit. Send fewer files at once.')
-    return body
+  const assertWithinLimit = (request: ReturnType<typeof requestBody>) => {
+    const metadataBytes = request.attachmentMetadata
+      ? utf8ByteLength(request.attachmentMetadata.requestId)
+        + (request.attachmentMetadata.imageNames?.reduce((sum, name) => sum + utf8ByteLength(name) + 4, 0) ?? 0)
+        + (request.attachmentMetadata.videoNames?.reduce((sum, name) => sum + utf8ByteLength(name) + 4, 0) ?? 0)
+      : 0
+    const totalBytes = 256
+      + metadataBytes
+      + utf8ByteLength(request.message)
+      + utf8ByteLength(request.systemInstruction)
+      + utf8ByteLength(request.imageDataUri)
+      + utf8ByteLength(request.audioDataUri)
+      + utf8ByteLength(request.videoDataUri)
+      + utf8ByteLength(request.documentAttachment?.filename)
+      + utf8ByteLength(request.documentAttachment?.dataUri)
+      + utf8ByteLength(request.workspacePath)
+      + utf8ByteLength(request.chatId)
+      + utf8ByteLength(request.agentId)
+      + utf8ByteLength(request.pinnedMcpServer)
+    if (totalBytes > MAX_REQUEST_BYTES) throw new Error(REQUEST_LIMIT_ERROR)
+  }
+  const post = (route: string, request: ReturnType<typeof requestBody>) => {
+    assertWithinLimit(request)
+    return environment.fetch(`${environment.apiBase()}/${route}`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(request),
+    })
   }
-  const post = (route: string, request: ReturnType<typeof requestBody>) => environment.fetch(`${environment.apiBase()}/${route}`, {
-    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: validate(request),
-  })
 
 
   return {
@@ -125,7 +167,7 @@ export function createConversationTransport(environment: TransportEnvironment):
           return { provider: 'error', model: 'error', text: `Failed to connect to Local API Server: ${error}` }
         }
       }
-      validate(request)
+      assertWithinLimit(request)
       const { invoke } = await import('@tauri-apps/api/core')
       const response = await invoke<ChatResponse>('send_chat_message', { ownerToken: environment.ownerToken(), request, ...(attachmentMetadata ? { attachmentMetadata } : {}) })
       return response
@@ -145,7 +187,7 @@ export function createConversationTransport(environment: TransportEnvironment):
         }
         return readStream(response, callbacks)
       }
-      validate(request)
+      assertWithinLimit(request)
       const { invoke, Channel } = await import('@tauri-apps/api/core')
       const onEvent = new Channel<StreamEvent>()
       onEvent.onmessage = event => { deliverEvent(event, callbacks) }

package/src/renderer/shared/conversation/useConversationCoordinator.ts

@@ -33,23 +33,53 @@ export function useConversationCoordinator(
       else window.localStorage.removeItem(key)
     },
   }))
-  const conversation = useSyncExternalStore(actions.subscribe, actions.getSnapshot, actions.getSnapshot)
+  const dashboardSnapshotRef = useRef<ReturnType<typeof actions.getSnapshot> | null>(null)
+  const getDashboardSnapshot = () => {
+    const next = actions.getSnapshot()
+    const prev = dashboardSnapshotRef.current
+    if (prev && prev !== next) {
+      let onlyMessageChanged = prev.message !== next.message
+      if (onlyMessageChanged) {
+        for (const key of Object.keys(next) as Array<keyof typeof next>) {
+          if (key !== 'message' && prev[key] !== next[key]) {
+            onlyMessageChanged = false
+            break
+          }
+        }
+      }
+      if (onlyMessageChanged) {
+        return prev
+      }
+    }
+    dashboardSnapshotRef.current = next
+    return next
+  }
+
+  const conversation = useSyncExternalStore(actions.subscribe, getDashboardSnapshot, getDashboardSnapshot)
 
   useEffect(() => actions.watch({ window, document }, options.historyVisible),
     [actions, options.historyVisible, conversation.conversationId])
 
   useEffect(() => {
-    const timer = window.setTimeout(() => {
-      try {
-        const key = `${options.draftKeyPrefix}${conversation.conversationId}`
-        if (conversation.message) window.localStorage.setItem(key, conversation.message)
-        else window.localStorage.removeItem(key)
-      } catch {
-        // Draft persistence is best-effort in private browsing modes.
-      }
-    }, 300)
-    return () => window.clearTimeout(timer)
-  }, [conversation.message, conversation.conversationId, options.draftKeyPrefix])
+    let timer: number | undefined
+    const unsubscribe = actions.subscribe(() => {
+      const snap = actions.getSnapshot()
+      if (timer !== undefined) window.clearTimeout(timer)
+      timer = window.setTimeout(() => {
+        try {
+          const key = `${latest.current.draftKeyPrefix}${snap.conversationId}`
+          if (snap.message) window.localStorage.setItem(key, snap.message)
+          else window.localStorage.removeItem(key)
+        } catch {
+          // Draft persistence is best-effort in private browsing modes.
+        }
+      }, 300)
+    })
+    return () => {
+      unsubscribe()
+      if (timer !== undefined) window.clearTimeout(timer)
+    }
+  }, [actions])
 
   useEffect(() => {
     try {

package/src/renderer/shared/css/agent-observability.css

@@ -15,6 +15,7 @@
   color: var(--text-main, #e8e8ea);
   min-width: 0;
   max-width: 100%;
+  box-sizing: border-box;
   overflow: hidden;
 }
 
@@ -47,6 +48,38 @@
 .run-summary-heading strong { font-size: 0.8rem; font-weight: 650; line-height: 1.25; }
 .run-summary-heading small { overflow: hidden; color: var(--text-muted); font-family: var(--font-mono, ui-monospace, monospace); font-size: 0.65rem; font-weight: 400; text-overflow: ellipsis; white-space: nowrap; }
 
+.run-summary-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-shrink: 0;
+}
+
+.run-summary-export-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  padding: 2px 7px;
+  border-radius: var(--radius-sm, 6px);
+  font-size: 0.70rem;
+  font-weight: 500;
+  color: var(--text-muted, #8f8f94);
+  background: var(--surface-bg, rgba(255, 255, 255, 0.05));
+  border: 1px solid var(--border, rgba(255, 255, 255, 0.1));
+  cursor: pointer;
+  transition: all 0.15s ease;
+}
+
+.run-summary-export-btn:hover {
+  color: var(--text-main, #e8e8ea);
+  background: var(--surface-hover, rgba(255, 255, 255, 0.1));
+  border-color: var(--border-light, rgba(255, 255, 255, 0.2));
+}
+
+.run-summary-export-btn:active {
+  transform: scale(0.97);
+}
+
 .run-summary-badge {
   display: inline-flex;
   align-items: center;
@@ -59,21 +92,21 @@
 }
 
 .run-summary-badge.success {
-  background: color-mix(in srgb, var(--status-speaking, #22c55e) 15%, transparent);
-  color: var(--status-speaking, #22c55e);
-  border: 1px solid color-mix(in srgb, var(--status-speaking, #22c55e) 35%, transparent);
+  background: var(--status-success-bg);
+  color: var(--status-success-fg);
+  border: 1px solid var(--status-success-border);
 }
 
 .run-summary-badge.rollback {
-  background: color-mix(in srgb, #f59e0b 15%, transparent);
-  color: #f59e0b;
-  border: 1px solid color-mix(in srgb, #f59e0b 35%, transparent);
+  background: var(--status-warning-bg);
+  color: var(--status-warning-fg);
+  border: 1px solid var(--status-warning-border);
 }
 
 .run-summary-badge.failure {
-  background: color-mix(in srgb, var(--status-error, #ef4444) 15%, transparent);
-  color: var(--status-error, #ef4444);
-  border: 1px solid color-mix(in srgb, var(--status-error, #ef4444) 35%, transparent);
+  background: var(--status-error-bg);
+  color: var(--status-error-fg);
+  border: 1px solid var(--status-error-border);
 }
 
 .run-kpi-grid {
@@ -201,14 +234,14 @@
 }
 
 .run-timeline-note-failed {
-  color: var(--status-error, #ef4444);
+  color: var(--status-error-fg, #ef4444);
   font-weight: 600;
   font-size: 0.7rem;
   flex-shrink: 0;
 }
 
 .run-timeline-note-retry {
-  color: #f59e0b;
+  color: var(--status-warning-fg, #f59e0b);
   font-weight: 600;
   font-size: 0.7rem;
   flex-shrink: 0;
@@ -299,3 +332,164 @@
   flex: 1;
   line-height: 1.3;
 }
+
+/* --- Self-Correction Guidance Card --- */
+.diagnostic-guidance-card {
+  margin-top: 8px;
+  border-radius: var(--radius-md, 8px);
+  border: 1px solid var(--border-warning, rgba(234, 179, 8, 0.3));
+  background: color-mix(in srgb, var(--status-warning-bg, #78350f) 20%, transparent);
+  padding: 8px 10px;
+  font-size: 0.74rem;
+  color: var(--text-main, #e8e8ea);
+}
+
+.diagnostic-guidance-header {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin-bottom: 4px;
+  color: var(--status-warning-fg, #fde047);
+  font-weight: 600;
+  font-size: 0.72rem;
+}
+
+.diagnostic-guidance-card pre {
+  margin: 0;
+  font-family: var(--font-mono, ui-monospace, monospace);
+  font-size: 0.70rem;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+/* --- Release Notes Card Widget --- */
+.release-notes-card {
+  border-radius: var(--radius-lg, 10px);
+  border: none;
+  background: color-mix(in srgb, #404040 95%, transparent);
+  backdrop-filter: var(--glass-blur, blur(12px));
+  -webkit-backdrop-filter: var(--glass-blur, blur(12px));
+  padding: 16px 18px;
+  margin: 10px 0;
+  color: var(--text-main, #e8e8ea);
+}
+
+.release-notes-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 8px;
+}
+
+.release-notes-title {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 0.88rem;
+  font-weight: 650;
+  color: var(--text-main, #e8e8ea);
+}
+
+.release-notes-icon {
+  color: var(--accent, #10b981);
+}
+
+.release-notes-version-badge {
+  font-size: 0.72rem;
+  font-weight: 600;
+  padding: 1px 7px;
+  border-radius: var(--radius-full, 999px);
+  background: color-mix(in srgb, var(--accent, #10b981) 15%, transparent);
+  color: var(--accent, #10b981);
+  border: 1px solid color-mix(in srgb, var(--accent, #10b981) 30%, transparent);
+}
+
+.release-notes-count-badge {
+  font-size: 0.72rem;
+  color: var(--text-muted, #8f8f94);
+  font-weight: 500;
+}
+
+.release-notes-track {
+  display: none;
+}
+
+.release-notes-bar {
+  height: 100%;
+  width: 100%;
+  background: linear-gradient(90deg, var(--accent, #10b981), var(--status-listening, #7dd3fc));
+}
+
+.release-notes-body {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.release-notes-section-title {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 0.82rem;
+  font-weight: 600;
+  color: var(--text-main, #e8e8ea);
+  margin-bottom: 6px;
+}
+
+.release-notes-bullet {
+  color: var(--text-muted, #9ca3af);
+  font-size: 0.75rem;
+}
+
+.release-notes-items {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding-left: 6px;
+}
+
+.release-notes-item {
+  font-size: 0.76rem;
+  line-height: 1.55;
+  color: var(--text-main, #e8e8ea);
+}
+
+.release-notes-item-header {
+  display: inline;
+}
+
+.release-notes-item-bullet {
+  color: var(--accent, #10b981);
+  margin-right: 6px;
+  font-weight: bold;
+}
+
+.release-notes-item-title {
+  font-weight: 650;
+  color: var(--text-main, #fff);
+  margin-right: 5px;
+}
+
+.release-notes-item-desc {
+  color: var(--text-main, #d1d5db);
+}
+
+.release-notes-subitems {
+  margin-top: 4px;
+  margin-left: 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.release-notes-subitem {
+  display: flex;
+  align-items: baseline;
+  gap: 6px;
+  font-size: 0.73rem;
+  color: var(--text-muted, #9ca3af);
+}
+
+.release-notes-subitem-bullet {
+  color: var(--text-muted, #9ca3af);
+}