Node-based terminal manager for AI coding agents — tmux-backed terminals and parallel agent sessions as draggable nodes on an infinite pan/zoom canvas. macOS, Linux, and a browser Server Edition.
TypeScript adhdagent-orchestrationai-agentscanvasclaude-codecodexcoding-agentsdeveloper-toolselectrongeminilinuxmacosmultiplexeropencodeparallel-agentsterminalterminal-emulatorterminal-multiplexertmuxworkspace-manager
feat(glass): Glass slider from Clear to Tinted, with refraction
iceclatterWTaaa7256bbae7
diff --git a/CLAUDE.md b/CLAUDE.mdindex 4da1068af..7815c3bf2 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -3883,6 +3883,25 @@ glass never sits over plain black; a wallpaper the user chose is never replaced.glass header are ink over a tinted chip (`-webkit-text-fill-color: var(--text)` with the chipmixed from `currentColor`), not coloured text. `styles.palette.test.ts` pins the mapping and thatno two meanings resolve to the same colour, in both themes.+- **Glass slider + refraction** (Settings → Appearance, shown only under Liquid Glass; iOS 26's+ Clear ↔ Tinted). `settings.glassTint` is a slider POSITION, not an alpha (`null` = the Readable+ tick, read through `resolveGlassSlider`): every surface has its own readable alpha, so each maps+ the position through three points — `GLASS_CLEAR_ALPHA` 0.2 at Clear, its OWN computed readable+ alpha at `GLASS_READABLE_TICK` (0.7), `max(readable, 0.95)` at Tinted (`glassSliderAlpha`). At the+ tick every surface is exactly at the alpha `glassTintAlpha`/`glassChromeAlpha` computed, and every+ alpha right of it is higher — so Readable→Tinted keeps 4.5:1; left of the tick the row says the+ guarantee is off. Measured: chrome dark 0.20 / 0.70 / 0.95, chrome light 0.20 / 0.745 / 0.95,+ nodeterm-dark 0.20 / 0.675 / 0.95 (Clear / Readable / Tinted). App.tsx sets `--glass-t` (blur+ 16→28px, saturation 200→145%) and `--glass-sheen`. **Refraction** is ONE shared SVG filter+ (`components/GlassRefraction.tsx`, `#nt-refract`: a 256² edge-lens displacement map generated once,+ `primitiveUnits="objectBoundingBox"` so one filter fits every element), referenced from+ `--glass-blur` as `url(#nt-refract)` — no per-node filters. Its scale is `0.06 × (1 − t)`; it moves+ backdrop pixels, never the tint, so it cannot touch contrast. The specular sheen is a background+ gradient scaled by `glassSheen(t)`, which is ZERO from the tick on — it lightens the surface, so it+ may only exist where the promise is already off. Node blur+refraction still pause while the camera+ moves (`.canvas-moving`); chrome keeps both. MEASURED on the live dev build (CDP computed style):+ Chromium keeps `url("#nt-refract") blur(…) saturate(…)` on the tab bar, dock, sessions sidebar,+ minimap, zoom controls and terminal nodes.- **Surfaces.** Desktop: full. Server Edition: gradients + glass; the stills list is empty (notmacOS) and "Choose image…" is hidden (a picker there browses the SERVER's disk). Relay tabs keepa stub (no stills, import refused). Mobile: N/A (no canvas). Kanban: N/A (the board is opaque).diff --git a/src/renderer/App.tsx b/src/renderer/App.tsxindex 78f744574..414b5c12c 100644--- a/src/renderer/App.tsx+++ b/src/renderer/App.tsx@@ -19,7 +19,8 @@ import { resolveUiScale } from '../shared/ui-scale'import { resolveTabBarHeight } from '../shared/window-chrome-metrics'import { useAppTheme } from './state/useAppTheme'import { installWindowActivityOnDocument } from './lib/windowActivity'-import { glassChromeAlpha, parseCssColor } from './lib/glassContrast'+import { glassChromeAlpha, glassSheen, glassSliderAlpha, parseCssColor, resolveGlassSlider } from './lib/glassContrast'+import { GlassRefraction } from './components/GlassRefraction'import { isLiquidGlass } from './lib/appTheme'export default function App() {@@ -81,11 +82,16 @@ export default function App() {// stays the one source of truth; declared after the data-theme effect, so it reads the tokens// of the theme that effect just applied. An unparseable token leaves the chrome opaque.const liquidGlass = isLiquidGlass(useSettings((s) => s.settings.appTheme))+ // The Glass slider moves every surface between Clear and Tinted through its own readable alpha+ // (glassSliderAlpha); `--glass-t` scales the blur and `--glass-sheen` the specular wash in CSS.+ const glassSlider = resolveGlassSlider(useSettings((s) => s.settings.glassTint))useEffect(() => {const root = document.documentElementif (!liquidGlass) {delete root.dataset.ntGlassroot.style.removeProperty('--glass-chrome-bg')+ root.style.removeProperty('--glass-t')+ root.style.removeProperty('--glass-sheen')return}// Read the tokens with the glass overrides OFF: under them `--panel` IS the glass fill, and a@@ -94,14 +100,18 @@ export default function App() {const css = getComputedStyle(root)const text = css.getPropertyValue('--text').trim()const panel = css.getPropertyValue('--panel').trim()- const alpha = glassChromeAlpha(text, panel)+ const readable = glassChromeAlpha(text, panel)const rgb = parseCssColor(panel)?.rgbroot.style.setProperty('--glass-chrome-bg',- alpha !== null && rgb ? `rgba(${rgb.join(', ')}, ${alpha.toFixed(3)})` : panel+ readable !== null && rgb+ ? `rgba(${rgb.join(', ')}, ${glassSliderAlpha(glassSlider, readable).toFixed(3)})`+ : panel)+ root.style.setProperty('--glass-t', glassSlider.toFixed(3))+ root.style.setProperty('--glass-sheen', glassSheen(glassSlider).toFixed(3))root.dataset.ntGlass = 'on'- }, [liquidGlass, appTheme])+ }, [liquidGlass, appTheme, glassSlider])// Apply the UI scale as page zoom (issue #299 — 4K readability; the why-page-zoom write-up// lives in shared/ui-scale.ts). Gated on `hydrated` so boot doesn't flash-reset a scaled window@@ -130,6 +140,7 @@ export default function App() {{/* The node-icon picker, opened from the node menu, a node header and the kanban cardmodal — one dialog for all three, driven by nodeIconDialog(). */}<NodeIconDialogHost />+ {liquidGlass && <GlassRefraction slider={glassSlider} />}</ReactFlowProvider></SessionProvider>)diff --git a/src/renderer/components/GlassRefraction.tsx b/src/renderer/components/GlassRefraction.tsxnew file mode 100644index 000000000..98440e279--- /dev/null+++ b/src/renderer/components/GlassRefraction.tsx@@ -0,0 +1,58 @@+import { glassRefraction } from '../lib/glassContrast'++/**+ * The ONE refraction filter every Liquid Glass surface references (`backdrop-filter:+ * url(#nt-refract) …`, styles.css `--glass-refract`). An edge lens: a displacement map that is+ * neutral in the middle and pushes the backdrop outward near the edges, so the picture bends at a+ * surface's rim the way it does under Apple's glass. `primitiveUnits="objectBoundingBox"` scales it+ * to whatever element uses it, so one filter serves nodes, menus and the tab bar alike.+ */+let mapUrl: string | null = null++/** The displacement map, generated once per renderer (R = x push, G = y push, 128 = none). */+function displacementMap(): string {+ if (mapUrl) return mapUrl+ const size = 256+ const edge = 0.12+ const canvas = document.createElement('canvas')+ canvas.width = canvas.height = size+ const ctx = canvas.getContext('2d')+ if (!ctx) return (mapUrl = '')+ const img = ctx.createImageData(size, size)+ const push = (u: number): number => (u < edge ? -(1 - u / edge) : u > 1 - edge ? 1 - (1 - u) / edge : 0)+ for (let y = 0; y < size; y++) {+ const dy = push(y / (size - 1))+ for (let x = 0; x < size; x++) {+ const dx = push(x / (size - 1))+ const i = (y * size + x) * 4+ img.data[i] = 128 + 127 * Math.sign(dx) * dx * dx+ img.data[i + 1] = 128 + 127 * Math.sign(dy) * dy * dy+ img.data[i + 2] = 128+ img.data[i + 3] = 255+ }+ }+ ctx.putImageData(img, 0, 0)+ return (mapUrl = canvas.toDataURL())+}++export function GlassRefraction({ slider }: { slider: number }) {+ const map = displacementMap()+ if (!map) return null+ return (+ <svg width="0" height="0" aria-hidden style={{ position: 'absolute' }}>+ <filter+ id="nt-refract"+ x="0"+ y="0"+ width="100%"+ height="100%"+ colorInterpolationFilters="sRGB"+ primitiveUnits="objectBoundingBox"+ >+ <feImage href={map} x="0" y="0" width="1" height="1" preserveAspectRatio="none" result="map" />+ <feGaussianBlur in="SourceGraphic" stdDeviation="0.004" result="soft" />+ <feDisplacementMap in="soft" in2="map" scale={glassRefraction(slider)} xChannelSelector="R" yChannelSelector="G" />+ </filter>+ </svg>+ )+}diff --git a/src/renderer/components/settings/sections/AppearanceSection.tsx b/src/renderer/components/settings/sections/AppearanceSection.tsxindex 82cae8bc6..161f2d633 100644--- a/src/renderer/components/settings/sections/AppearanceSection.tsx+++ b/src/renderer/components/settings/sections/AppearanceSection.tsx@@ -1,6 +1,7 @@import { useEffect, useState } from 'react'import { useSettings } from '../../../state/settings'import { isLiquidGlass } from '@renderer/lib/appTheme'+import { GLASS_READABLE_TICK, resolveGlassSlider } from '@renderer/lib/glassContrast'import { showCanvasDots } from '@renderer/lib/canvasDots'import {defaultWallpaper,@@ -69,6 +70,10 @@ const ROWS = {'native']},+ glassTint: {+ title: 'Glass',+ keywords: ['glass', 'liquid', 'transparency', 'clear', 'tinted', 'frosted', 'blur', 'opacity']+ },canvasDots: {title: 'Show grid dots',keywords: ['grid', 'dots', 'dot', 'canvas', 'background', 'pattern']@@ -337,6 +342,7 @@ export function AppearanceSection({ isActive }: { isActive: boolean }): React.JSconst hiddenHeaderButtons = useSettings((s) => s.settings.hiddenHeaderButtons)const showResumeCard = useSettings((s) => s.settings.showResumeCard)const canvasDots = useSettings((s) => s.settings.canvasDots)+ const glassSlider = resolveGlassSlider(useSettings((s) => s.settings.glassTint))const windowTitleActiveSession = useSettings((s) => s.settings.windowTitleActiveSession)const update = useSettings((s) => s.update)// Glass over plain black reads as a dark theme with smudges, so choosing Liquid Glass with no@@ -382,6 +388,54 @@ export function AppearanceSection({ isActive }: { isActive: boolean }): React.JS}/></SearchableRow>+ {isLiquidGlass(appTheme) && (+ <SearchableRow {...ROWS.glassTint}>+ <FieldRow+ label="Glass"+ description={+ glassSlider < GLASS_READABLE_TICK+ ? 'Clearer than Readable: the wallpaper shows through more, and text contrast is no longer guaranteed.'+ : 'From Readable to Tinted, regular text keeps 4.5:1 contrast over any wallpaper.'+ }+ control={+ <div className="flex w-56 flex-col gap-1">+ <input+ type="range"+ min={0}+ max={1}+ step={0.01}+ list="nt-glass-ticks"+ value={glassSlider}+ aria-label="Glass, from Clear to Tinted"+ aria-valuetext={+ Math.abs(glassSlider - GLASS_READABLE_TICK) < 0.005+ ? 'Readable'+ : `${Math.round(glassSlider * 100)}% tinted`+ }+ onChange={(e) => update({ glassTint: Number(e.target.value) })}+ className="w-full accent-[var(--accent)]"+ />+ <datalist id="nt-glass-ticks">+ <option value={GLASS_READABLE_TICK} label="Readable" />+ </datalist>+ <div className="relative h-4 text-[11px] text-muted">+ <span className="absolute left-0">Clear</span>+ <button+ type="button"+ className="absolute -translate-x-1/2 hover:text-text"+ style={{ left: `${GLASS_READABLE_TICK * 100}%` }}+ onClick={() => update({ glassTint: null })}+ title="Back to the readable point"+ >+ Readable+ </button>+ <span className="absolute right-0">Tinted</span>+ </div>+ </div>+ }+ />+ </SearchableRow>+ )}<SearchableRow {...ROWS.uiScale}><UiScaleRow /></SearchableRow>diff --git a/src/renderer/lib/glassContrast.test.ts b/src/renderer/lib/glassContrast.test.tsindex ac1db97ef..a83c9391f 100644--- a/src/renderer/lib/glassContrast.test.ts+++ b/src/renderer/lib/glassContrast.test.ts@@ -12,7 +12,15 @@ import {glassChromeAlpha,parseCssColor,parseHex,- worstContrast+ worstContrast,+ GLASS_CLEAR_ALPHA,+ GLASS_READABLE_TICK,+ GLASS_TINTED_ALPHA,+ glassRefraction,+ glassSheen,+ glassSliderAlpha,+ glassTint,+ resolveGlassSlider} from './glassContrast'const WHITE = [255, 255, 255] as const@@ -133,3 +141,60 @@ describe('glassChromeAlpha (Liquid Glass chrome, both app themes)', () => {expect(glassChromeAlpha('nope', '#000')).toBeNull()})})++describe('Glass slider (Clear ↔ Tinted)', () => {+ const css = readFileSync(join(__dirname, '..', 'styles.css'), 'utf8').replace(/\r\n/g, '\n')+ const body = (sel: string): string => {+ const i = css.indexOf(`\n${sel} {\n`)+ return css.slice(i, css.indexOf('\n}\n', i))+ }+ const tok = (b: string, n: string) => new RegExp(`\\n\\s*${n}:\\s*([^;]+);`).exec(b)?.[1].trim()+ const dark = body(':root')+ const light = body(":root[data-theme='light']")+ const chrome = (b: string): number => {+ const tint = tok(b, '--tint-rgb') ?? tok(dark, '--tint-rgb')!+ const text = (tok(b, '--text') ?? tok(dark, '--text')!).replace('var(--tint-rgb)', tint)+ return glassChromeAlpha(text, tok(b, '--panel')!)!+ }+ const surfaces: Array<[string, number]> = [+ ['chrome dark', chrome(dark)],+ ['chrome light', chrome(light)],+ ...TERMINAL_THEMES.map((t) => [t.id, glassTintAlpha(t.theme.foreground!, t.theme.background!)] as [string, number])+ ]++ it.each(surfaces)('%s: the Readable tick is exactly the computed 4.5:1 alpha', (_id, readable) => {+ expect(glassSliderAlpha(GLASS_READABLE_TICK, readable)).toBeCloseTo(readable, 10)+ })++ it.each(surfaces)('%s: alpha rises monotonically from Clear to Tinted', (_id, readable) => {+ let prev = -1+ for (let i = 0; i <= 100; i++) {+ const a = glassSliderAlpha(i / 100, readable)+ expect(a).toBeGreaterThanOrEqual(prev)+ prev = a+ }+ expect(glassSliderAlpha(0, readable)).toBe(GLASS_CLEAR_ALPHA)+ expect(glassSliderAlpha(1, readable)).toBe(Math.max(readable, GLASS_TINTED_ALPHA))+ })++ it('an untouched or hand-mangled setting is the Readable tick; numbers clamp', () => {+ for (const v of [null, undefined, 'x', Number.NaN, Infinity]) expect(resolveGlassSlider(v)).toBe(GLASS_READABLE_TICK)+ expect(resolveGlassSlider(-3)).toBe(0)+ expect(resolveGlassSlider(7)).toBe(1)+ })++ it('the sheen appears only left of the tick; refraction fades to nothing at Tinted', () => {+ expect(glassSheen(0)).toBe(1)+ for (const t of [GLASS_READABLE_TICK, 0.85, 1]) expect(glassSheen(t)).toBe(0)+ expect(glassRefraction(0)).toBeGreaterThan(glassRefraction(GLASS_READABLE_TICK))+ expect(glassRefraction(1)).toBe(0)+ })++ it('a terminal tint follows the slider', () => {+ const t = TERMINAL_THEMES.find((x) => x.id === 'nodeterm-dark') ?? TERMINAL_THEMES[0]+ const at = (s: number) => Number(/, ([\d.]+)\)$/.exec(glassTint(t.theme, s)!.background)![1])+ expect(at(0)).toBeLessThan(at(GLASS_READABLE_TICK))+ expect(at(GLASS_READABLE_TICK)).toBeCloseTo(glassTintAlpha(t.theme.foreground!, t.theme.background!), 3)+ expect(at(1)).toBeGreaterThanOrEqual(at(GLASS_READABLE_TICK))+ })+})diff --git a/src/renderer/lib/glassContrast.ts b/src/renderer/lib/glassContrast.tsindex c90f64f8e..a1a2c6d7e 100644--- a/src/renderer/lib/glassContrast.ts+++ b/src/renderer/lib/glassContrast.ts@@ -114,12 +114,16 @@ export interface GlassTint {foreground: string}-/** CSS for a theme's glass, or null when its background is not a colour we can parse. */-export function glassTint(theme: { background?: string; foreground?: string }): GlassTint | null {+/** CSS for a theme's glass at a Glass-slider position (default: the Readable tick), or null when+ * its background is not a colour we can parse. */+export function glassTint(+ theme: { background?: string; foreground?: string },+ slider: number = GLASS_READABLE_TICK+): GlassTint | null {const bg = theme.background ? parseHex(theme.background) : nullif (!bg) return nullconst foreground = theme.foreground ?? '#ffffff'- const alpha = glassTintAlpha(foreground, theme.background!)+ const alpha = glassSliderAlpha(slider, glassTintAlpha(foreground, theme.background!))const rgb = bg.join(', ')return {background: `rgba(${rgb}, ${alpha.toFixed(3)})`,@@ -186,3 +190,54 @@ export function glassChromeAlpha(text: string, panel: string, minRatio = 4.5): nif (lowest === Infinity) return 1return Math.max(GLASS_ALPHA_MIN, lowest)}++/* ------------------------------------------------------------------------------------------- *+ * The Glass slider (Settings → Appearance, Liquid Glass only): Clear ↔ Tinted, like iOS 26.+ *+ * One setting drives every glass surface, and every surface has its OWN readable alpha (the chrome+ * fill, each terminal theme). So the slider is not an alpha: it is a position `t` in 0..1, and each+ * surface maps it through three points — Clear at 0, its own readable alpha at the Readable tick,+ * Tinted at 1. At the tick every surface sits exactly at the alpha the functions above computed,+ * which is why the tick can promise 4.5:1; right of it every alpha is higher, and the scans above+ * return the bottom of a range that reaches opaque, so the promise holds all the way to Tinted.+ * Left of the tick is clearer than the guarantee, and the Settings row says so.+ * ------------------------------------------------------------------------------------------- */++/** Tint alpha at the Clear end: never fully clear, the tint still says where a surface is. */+export const GLASS_CLEAR_ALPHA = 0.2+/** Tint alpha at the Tinted end (a surface whose readable alpha is higher keeps its own). */+export const GLASS_TINTED_ALPHA = 0.95+/** Where the Readable tick sits on the track — also the default, so an untouched slider is the+ * look Liquid Glass shipped with. 0.7 is close to where the chrome's readable alpha falls on a+ * straight Clear→Tinted scale (dark 0.70 → 0.67, light 0.745 → 0.73), so the track reads as+ * roughly linear. */+export const GLASS_READABLE_TICK = 0.7++/** `settings.glassTint` → a slider position. Absent / not a finite number = the Readable tick. */+export function resolveGlassSlider(value: unknown): number {+ return typeof value === 'number' && Number.isFinite(value)+ ? Math.min(1, Math.max(0, value))+ : GLASS_READABLE_TICK+}++/** The tint alpha of a surface whose readable alpha is `readable`, at slider position `t`. */+export function glassSliderAlpha(t: number, readable: number): number {+ const tinted = Math.max(readable, GLASS_TINTED_ALPHA)+ if (t <= GLASS_READABLE_TICK) {+ return GLASS_CLEAR_ALPHA + ((readable - GLASS_CLEAR_ALPHA) * t) / GLASS_READABLE_TICK+ }+ return readable + ((tinted - readable) * (t - GLASS_READABLE_TICK)) / (1 - GLASS_READABLE_TICK)+}++/** Specular sheen strength, 0..1: full at Clear, ZERO from the Readable tick on — the sheen is a+ * white wash under the text, so it may only appear where the contrast promise is already off. */+export function glassSheen(t: number): number {+ return Math.max(0, (GLASS_READABLE_TICK - t) / GLASS_READABLE_TICK)+}++/** Edge-lens displacement (feDisplacementMap `scale`, objectBoundingBox units): strongest at+ * Clear, flat at Tinted. It moves backdrop pixels, never the tint, so it cannot touch contrast. */+export const GLASS_REFRACT_MAX = 0.06+export function glassRefraction(t: number): number {+ return GLASS_REFRACT_MAX * (1 - t)+}diff --git a/src/renderer/nodes/TerminalNode.tsx b/src/renderer/nodes/TerminalNode.tsxindex f75658d1e..b7c6c900a 100644--- a/src/renderer/nodes/TerminalNode.tsx+++ b/src/renderer/nodes/TerminalNode.tsx@@ -179,7 +179,7 @@ import { useCopyFeedback } from '../terminal/useCopyFeedback'import { ContextMeter } from '../components/ContextMeter'import { isZoomModifierHeld } from '../lib/zoomModifier'import { isHidden } from '../lib/ui-visibility'-import { glassTint } from '../lib/glassContrast'+import { glassTint, resolveGlassSlider } from '../lib/glassContrast'import { isLiquidGlass } from '../lib/appTheme'import { resolveTerminalTheme } from '../terminal/themes'import { readsClaudeTranscript } from '../lib/transcriptGates'@@ -1249,9 +1249,10 @@ export function TerminalNode({// translucent tint of THIS node's effective theme — project override included — at the alpha// that keeps its foreground at 4.5:1 over any backdrop (lib/glassContrast.ts).const glass = isLiquidGlass(useSettings((s) => s.settings.appTheme))+ const glassSlider = resolveGlassSlider(useSettings((s) => s.settings.glassTint))const glassVars = useMemo(() => {if (!glass) return null- const tint = glassTint(resolveTerminalTheme(visual.terminalTheme).theme)+ const tint = glassTint(resolveTerminalTheme(visual.terminalTheme).theme, glassSlider)return tint? ({'--term-glass-bg': tint.background,@@ -1259,7 +1260,7 @@ export function TerminalNode({'--term-glass-fg': tint.foreground} as React.CSSProperties): null- }, [glass, visual.terminalTheme])+ }, [glass, glassSlider, visual.terminalTheme])// The account list, for the chip and for the READERS below: a config dir the user links while// this pane sits quiet must resolve to its new account immediately, not at the next hook event.const claudeAccounts = useSettings((s) => s.settings.claudeAccounts)diff --git a/src/renderer/styles.css b/src/renderer/styles.cssindex 4b19401b4..bed2d42fe 100644--- a/src/renderer/styles.css+++ b/src/renderer/styles.css@@ -13533,7 +13533,26 @@ body.focus-mode .dock:hover {--surface-overlay: var(--glass-chrome-bg);--tabbar-bg: var(--glass-chrome-bg);--glass-edge: rgba(var(--tint-rgb), 0.2);- --glass-blur: blur(24px) saturate(160%);+ /* The Glass slider (App.tsx sets the live values inline; these are the Readable-tick defaults):+ `--glass-t` 0 = Clear … 1 = Tinted, `--glass-sheen` the specular wash (0 from the tick on).+ Clearer glass blurs a little less and saturates a little more, and refracts at its rim+ (`#nt-refract`, components/GlassRefraction.tsx — its strength also follows the slider). */+ --glass-t: 0.7;+ --glass-sheen: 0;+ --glass-refract: url(#nt-refract);+ --glass-blur: var(--glass-refract) blur(calc(16px + 12px * var(--glass-t)))+ saturate(calc(200% - 55% * var(--glass-t)));+ /* A diagonal light across the surface, strongest at the top-left rim. Painted as a background+ layer (under the content), and only left of the Readable tick: it lightens the surface, so it+ may only appear where the contrast promise is already off. */+ --glass-sheen-image: linear-gradient(+ 135deg,+ rgba(255, 255, 255, calc(0.22 * var(--glass-sheen))) 0%,+ rgba(255, 255, 255, calc(0.04 * var(--glass-sheen))) 22%,+ rgba(255, 255, 255, 0) 50%,+ rgba(255, 255, 255, calc(0.06 * var(--glass-sheen))) 85%,+ rgba(255, 255, 255, calc(0.14 * var(--glass-sheen))) 100%+ );}/* Outermost chrome: fill + blur. */@@ -13564,6 +13583,7 @@ body.focus-mode .dock:hover {.nt-settings) {background: var(--glass-chrome-bg) !important;+ background-image: var(--glass-sheen-image) !important;-webkit-backdrop-filter: var(--glass-blur);backdrop-filter: var(--glass-blur);}@@ -13591,6 +13611,7 @@ body.focus-mode .dock:hover {background: var(--glass-chrome-bg);}:root[data-nt-glass='on'] :is(.term-node, .files-node, .loop-node, .subagent-node, .trigger-node, .dino-node) {+ background-image: var(--glass-sheen-image);-webkit-backdrop-filter: var(--glass-blur);backdrop-filter: var(--glass-blur);}diff --git a/src/shared/types.ts b/src/shared/types.tsindex a4f9417e1..7db7f56ad 100644--- a/src/shared/types.ts+++ b/src/shared/types.ts@@ -1693,6 +1693,9 @@ export interface Settings {/** Draw the canvas dot grid (Settings → Appearance). Display only — snapping and align-to-grid* are unchanged. Default ON in every appearance; read through `showCanvasDots`. */canvasDots: boolean+ /** The Liquid Glass slider (Settings → Appearance), 0 = Clear … 1 = Tinted. null = the Readable+ * tick, where text keeps 4.5:1 (renderer/lib/glassContrast.ts `resolveGlassSlider`). */+ glassTint: number | null/** Whether usage percentages render as consumed ("32% used"), remaining ("68% left"), or raw* token counts ("48k/200k tokens" — context-window surfaces only; provider quota surfaces* have no token counts and fall back to 'used' display). 'remaining' is the historical@@ -1938,6 +1941,7 @@ export const DEFAULT_SETTINGS: Settings = {// reads as noise to users who navigate by the trail chords/Dock buttons instead.showResumeCard: false,canvasDots: true,+ glassTint: null,usagePercentMode: 'remaining',defaultAgent: 'claude',// Sessions start in auto mode out of the box. Existing users pick this up on hydrate