feat(tui): per-section visibility for the details accordion

Adds optional per-section overrides on top of the existing global
details_mode (hidden | collapsed | expanded).  Lets users keep the
accordion collapsed by default while auto-expanding tools, or hide the
activity panel entirely without touching thinking/tools/subagents.

Config (~/.hermes/config.yaml):

    display:
      details_mode: collapsed
      sections:
        thinking: expanded
        tools:    expanded
        activity: hidden

Slash command:

  /details                              show current global + overrides
  /details [hidden|collapsed|expanded]  set global mode (existing)
  /details <section> <mode|reset>       per-section override (new)
  /details <section> reset              clear override

Sections: thinking, tools, subagents, activity.

Implementation:

- ui-tui/src/types.ts             SectionName + SectionVisibility
- ui-tui/src/domain/details.ts    parseSectionMode / resolveSections /
                                  sectionMode + SECTION_NAMES
- ui-tui/src/app/uiStore.ts +
  app/interfaces.ts +
  app/useConfigSync.ts            sections threaded into UiState
- ui-tui/src/components/
  thinking.tsx                    ToolTrail consults per-section mode for
                                  hidden/expanded behaviour; expandAll
                                  skips hidden sections; floating-alert
                                  fallback respects activity:hidden
- ui-tui/src/components/
  messageLine.tsx + appLayout.tsx pass sections through render tree
- ui-tui/src/app/slash/
  commands/core.ts                /details <section> <mode|reset> syntax
- tui_gateway/server.py           config.set details_mode.<section>
                                  writes to display.sections.<section>
                                  (empty value clears the override)
- website/docs/user-guide/tui.md  documented

Tests: 14 new (4 domain, 4 useConfigSync, 3 slash, 3 gateway).
Total: 269/269 vitest, all gateway tests pass.

ui-tui/src/domain/details.ts

@@ -1,6 +1,7 @@
-import type { DetailsMode } from '../types.js'
+import type { DetailsMode, SectionName, SectionVisibility } from '../types.js'
 
 const MODES = ['hidden', 'collapsed', 'expanded'] as const
+export const SECTION_NAMES: readonly SectionName[] = ['thinking', 'tools', 'subagents', 'activity']
 
 const THINKING_FALLBACK: Record<string, DetailsMode> = {
   collapsed: 'collapsed',
@@ -14,6 +15,9 @@ export const parseDetailsMode = (v: unknown): DetailsMode | null => {
   return MODES.find(m => m === s) ?? null
 }
 
+export const isSectionName = (v: unknown): v is SectionName =>
+  typeof v === 'string' && (SECTION_NAMES as readonly string[]).includes(v)
+
 export const resolveDetailsMode = (d?: { details_mode?: unknown; thinking_mode?: unknown } | null): DetailsMode =>
   parseDetailsMode(d?.details_mode) ??
   THINKING_FALLBACK[
@@ -23,4 +27,35 @@ export const resolveDetailsMode = (d?: { details_mode?: unknown; thinking_mode?:
   ] ??
   'collapsed'
 
+// Build a SectionVisibility from a free-form `display.sections` config blob.
+// Skips keys that aren't recognized section names or don't parse to a valid
+// mode — partial overrides are intentional, missing keys fall through to the
+// global details_mode at render time.
+export const resolveSections = (raw: unknown): SectionVisibility => {
+  const out: SectionVisibility = {}
+
+  if (!raw || typeof raw !== 'object') {
+    return out
+  }
+
+  for (const [k, v] of Object.entries(raw as Record<string, unknown>)) {
+    const mode = parseDetailsMode(v)
+
+    if (mode && isSectionName(k)) {
+      out[k] = mode
+    }
+  }
+
+  return out
+}
+
+// Resolve the effective mode for one section: explicit override wins,
+// otherwise the global details_mode.  Single source of truth — every render
+// site that needs to know "is this section open by default" calls this.
+export const sectionMode = (
+  name: SectionName,
+  global: DetailsMode,
+  sections?: SectionVisibility
+): DetailsMode => sections?.[name] ?? global
+
 export const nextDetailsMode = (m: DetailsMode): DetailsMode => MODES[(MODES.indexOf(m) + 1) % MODES.length]!