Skip to content

Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.

feat(deck): the centre is a stage for the mascot, not a reticle for a sphere

Haraldea36baabe159
diff --git a/jarvis/ui/web/frontend/src/components/deck/DeckOrb.test.tsx b/jarvis/ui/web/frontend/src/components/deck/DeckOrb.test.tsx
index def4b06aca..f96aa28faa 100644
--- a/jarvis/ui/web/frontend/src/components/deck/DeckOrb.test.tsx
+++ b/jarvis/ui/web/frontend/src/components/deck/DeckOrb.test.tsx
@@ -16,14 +16,20 @@ import { useEventStore } from "@/store/events";
import { clearVoiceInputLevel, setVoiceInputLevel } from "@/lib/voiceInputLevel";
import type { ThinkingStep } from "@/lib/thinkingSteps";
+const step = (id: string, status: ThinkingStep["status"] = "active"): ThinkingStep => ({
+ id,
+ kind: "tool",
+ labelKey: "thinking.tool",
+ status,
+ startedTs: 0,
+});
+
/**
- * The orb is the click-shaped wake word (maintainer, 2026-08-18): pressing
- * the orb in the centre does what saying the phrase does. Display-only
- * callers get no button at all. The centre is the MASCOT — vectors, no
- * bitmap: the `/deck-orb.png` render that used to sit there was a picture of
- * a light whose baked-in white halo read as a grey box on the dark deck, and
- * the maintainer had asked repeatedly for it to go (2026-08-20). It carries
- * the live voice state so it can breathe with it.
+ * The centre is a STAGE, not a reticle (maintainer, 2026-08-20: "a circle
+ * around the mascot makes no sense"). The mascot stands free, lit from
+ * behind and below; the meter is a wave under it; the readouts are one row.
+ * Pressing the figure does what saying the wake phrase does; display-only
+ * callers get no button at all.
*/
describe("DeckOrb", () => {
afterEach(() => cleanup());
@@ -34,35 +40,50 @@ describe("DeckOrb", () => {
expect(screen.getByTestId("jarvis-orb")).toBeTruthy();
});
- test("the reticle is instruments only — no scenery left to turn", () => {
- const { container, rerender } = render(<DeckOrb steps={[]} busy={false} />);
- // Gone with the PNG: dial ticks, corner brackets, the two orbits, the
- // satellite, the idle ping. Instruments that measure nothing are a stage
- // set, and the living thing in the middle carries the life instead.
- expect(container.querySelector(".deck-orb-orbit-a")).toBeNull();
- expect(container.querySelector(".deck-orb-orbit-b")).toBeNull();
- expect(container.querySelector(".deck-orb-rings")).toBeNull();
- expect(screen.queryByTestId("deck-orb-satellite")).toBeNull();
- expect(screen.queryByTestId("deck-orb-ping")).toBeNull();
- // The 72 dial ticks and the compass crosshairs were the only <line>s here.
+ test("nothing rings the figure — the light is behind it and under it", () => {
+ const { container } = render(<DeckOrb steps={[]} busy={false} />);
+ // The sphere's furniture: bezel circle, dial ticks, the arc meter, the
+ // ripple rings, the corona. All of it went with the sphere.
expect(container.querySelectorAll("line")).toHaveLength(0);
- // What stays is what reads a real value: the meter, the ripple host — at
- // rest at zero — and one arc per running step.
- expect(screen.getByTestId("deck-orb-vu")).toBeTruthy();
- expect(screen.getByTestId("deck-orb-ripples").childElementCount).toBe(0);
- expect(screen.getByTestId("deck-orb").style.getPropertyValue("--orb-level")).toBe("0");
- const step: ThinkingStep = {
- id: "a",
- kind: "tool",
- labelKey: "thinking.tool",
- status: "active",
- startedTs: 0,
- };
- rerender(<DeckOrb steps={[step]} busy />);
- expect(container.querySelectorAll("path").length).toBeGreaterThan(0);
+ expect(screen.queryByTestId("deck-orb-vu")).toBeNull();
+ expect(screen.queryByTestId("deck-orb-ripples")).toBeNull();
+ expect(container.querySelector(".deck-orb-corona")).toBeNull();
+ expect(container.querySelector(".deck-orb-glow")).toBeNull();
+ // What stages the figure now.
+ expect(screen.getByTestId("deck-stage-light")).toBeTruthy();
+ expect(screen.getByTestId("deck-stage-footlight")).toBeTruthy();
+ expect(screen.getByTestId("deck-orb-wave")).toBeTruthy();
+ });
+
+ test("the readouts are one row, not four corners", () => {
+ render(
+ <DeckOrb
+ steps={[]}
+ busy={false}
+ readouts={{ nw: "Ready", ne: "0 steps", sw: "Vertex AI", se: "0 words" }}
+ />,
+ );
+ const row = screen.getByTestId("deck-orb-readouts");
+ // Engine first — the one a person checks before they speak.
+ expect(row.textContent).toContain("Vertex AI");
+ expect(row.textContent).toContain("Ready");
+ expect(row.textContent).toContain("0 steps");
+ expect(row.textContent).toContain("0 words");
+ expect(screen.getByTestId("deck-orb-provider").textContent).toBe("Vertex AI");
+ });
+
+ test("parallel work shows as marks, and nothing at all when none runs", () => {
+ const { rerender } = render(<DeckOrb steps={[]} busy={false} />);
+ expect(screen.queryByTestId("deck-orb-steps")).toBeNull();
+ rerender(<DeckOrb steps={[step("a"), step("b", "done")]} busy />);
+ expect(screen.getByTestId("deck-orb-steps").childElementCount).toBe(2);
+ // The wave only travels while work is running.
+ expect(screen.getByTestId("deck-orb-wave").getAttribute("data-busy")).toBe("true");
+ rerender(<DeckOrb steps={[]} busy={false} />);
+ expect(screen.getByTestId("deck-orb-wave").getAttribute("data-busy")).toBeNull();
});
- test("moves with the voice: the real microphone level while listening, one variable for all", async () => {
+ test("moves with the voice: the real microphone level, one variable for all", async () => {
useEventStore.setState({ voiceState: "listening" });
setVoiceInputLevel(0.8, "native");
try {
@@ -71,8 +92,6 @@ describe("DeckOrb", () => {
await waitFor(() => {
expect(Number(root.style.getPropertyValue("--orb-level"))).toBeGreaterThan(0.3);
});
- // A word landing sent a ripple from the sun towards the bezel.
- expect(screen.getByTestId("deck-orb-ripples").childElementCount).toBeGreaterThan(0);
} finally {
clearVoiceInputLevel();
useEventStore.setState({ voiceState: "idle" });
@@ -86,10 +105,9 @@ describe("DeckOrb", () => {
// The PNG is gone from the tree, so it cannot come back in through here.
expect(orb.querySelectorAll("img")).toHaveLength(0);
expect(orb.querySelector(".gigi-root")).toBeTruthy();
- expect(orb.querySelector("svg")).toBeTruthy();
});
- test("a press on the orb fires the handler and carries its label", () => {
+ test("a press on the figure fires the handler and carries its label", () => {
const onPress = vi.fn();
render(
<DeckOrb
diff --git a/jarvis/ui/web/frontend/src/components/deck/DeckOrb.tsx b/jarvis/ui/web/frontend/src/components/deck/DeckOrb.tsx
index f565b15be1..e53306025f 100644
--- a/jarvis/ui/web/frontend/src/components/deck/DeckOrb.tsx
+++ b/jarvis/ui/web/frontend/src/components/deck/DeckOrb.tsx
@@ -1,45 +1,48 @@
-import { useEffect, useId, useMemo, useRef, useState } from "react";
+import { useEffect, useMemo, useRef } from "react";
import { useEventStore, type VoiceState } from "@/store/events";
import { JarvisOrb } from "@/components/deck/JarvisOrb";
import type { ThinkingStep } from "@/lib/thinkingSteps";
-import { HudHaloDefs } from "@/components/deck/HudFrame";
import { readVoiceInputLevel } from "@/lib/voiceInputLevel";
-import { driveTarget, isOnset, orbDriveFor, smoothOrbLevel } from "@/lib/orbLevel";
+import { driveTarget, orbDriveFor, smoothOrbLevel } from "@/lib/orbLevel";
import { cn } from "@/lib/utils";
/**
- * The centre of the deck: the mascot in a reticle — one hairline bezel, one
- * bright arc per running step, the voice meter, and four small readouts at
- * the corners.
+ * The centre of the deck: the mascot on a stage.
*
- * The middle is Gigi itself (`JarvisOrb`), moved by the real voice state,
- * with a soft gold glow throwing the dark silhouette forward. It was a PNG
- * of a glowing sphere until 2026-08-20; the maintainer had asked repeatedly
- * for that picture to go and for the mascot to carry the product, and the
- * picture had earned it — its baked-in white halo read as a grey box on the
- * dark deck, and this reticle sliced that box off at the ring.
+ * This used to be a reticle — a bezel ring with 72 dial ticks, arcs riding
+ * the rim, a meter drawn along it and four readouts pinned to the corners.
+ * That was built for a SPHERE, and it worked while a sphere sat in it. It
+ * does not survive the mascot: Gigi is a tall figure, a circle is not its
+ * shape, and the ring cut straight through its head and its feet. A hoop
+ * drawn around a character means nothing (maintainer, 2026-08-20: "a circle
+ * around the mascot makes no sense — it has to look good and it has to make
+ * sense").
*
- * The reticle is now INSTRUMENTS ONLY, and every part of it carries
- * information: the arcs are parallel work made visible, the sweep turns only
- * while something runs, the meter is the voice, the readouts are live values
- * the caller sources. What went with the PNG was the scenery that measured
- * nothing — 72 dial ticks, corner brackets, two counter-turning orbits, a
- * satellite riding the bezel and an idle ping (maintainer, 2026-08-20:
- * instruments that show nothing are a stage set). The deck does not need
- * them to look alive: the living thing in the middle blinks, its pupils
- * drift and it waves, so the instruments can hold still until they have
- * something to say. Reduced motion stops what is left.
+ * So the ring is gone and the middle is staged instead of instrumented. Five
+ * parts, each of which is either the figure or something the figure actually
+ * does:
*
- * And it MOVES WITH THE VOICE, all of it (maintainer, 2026-08-19: "when you
- * speak the sun moved — that, on the next level; not just the core, all of
- * it, smooth"). One animation-frame loop computes the orb's LEVEL
- * (`lib/orbLevel.ts`: the real microphone while listening, a speech-shaped
- * envelope while the assistant speaks, a heartbeat while it thinks), smooths
- * it, and writes it to ONE CSS variable on the root (`--orb-level`); the
- * core's size and brightness, the glow, the corona's rays, the rings and the
- * level arc on the bezel all read that variable in CSS (index.css). A jump
- * in the level — a word landing — sends one ripple from the sun to the
- * bezel. One number, one smoothing, so every part moves as one thing.
+ * 1. BACKLIGHT — a soft upright pool of light behind Gigi, taller than it
+ * is wide, so the dark silhouette reads against it. It breathes at rest
+ * and opens up with the voice.
+ * 2. FOOTLIGHT — a flat ellipse of light under the figure. It is what puts
+ * Gigi on a floor rather than afloat in the middle of a page, and it
+ * brightens with the voice, so the figure looks lit from its own sound.
+ * 3. THE FIGURE — `JarvisOrb`, free, nothing drawn over or around it.
+ * 4. THE WAVE — one line under the figure whose amplitude IS `--orb-level`:
+ * the real microphone while listening, a speech-shaped envelope while
+ * the assistant speaks, a heartbeat while it thinks. Flat when there is
+ * nothing to hear. This is the meter the bezel arc used to be, in the
+ * shape a voice actually has.
+ * 5. THE LINE — the four readouts the corners used to scatter, set as one
+ * readable row: engine · mood · steps · words.
+ *
+ * Everything still reads ONE number. An animation-frame loop computes the
+ * level (`lib/orbLevel.ts`), smooths it, and writes it to `--orb-level` on
+ * the root; the backlight, the footlight, the wave and the figure all read
+ * that variable in CSS (index.css). Transform and opacity only, so the main
+ * thread pays for one style write per frame. Reduced motion gets the still
+ * picture, and the loop never starts.
*/
export interface OrbReadouts {
nw: string;
@@ -48,6 +51,13 @@ export interface OrbReadouts {
se: string;
}
+/**
+ * The wave's shape. Drawn HALF A VIEWBOX WIDER than it is shown so the flow
+ * animation can slide it by exactly one period and start over without a seam;
+ * the svg clips the overhang. Flat at rest — the level scales it.
+ */
+const WAVE_PATH = "M 0 8 Q 12.5 0 25 8 T 50 8 T 75 8 T 100 8 T 125 8 T 150 8";
+
export function DeckOrb({
steps,
busy,
@@ -64,9 +74,9 @@ export function DeckOrb({
readouts?: OrbReadouts;
className?: string;
/**
- * The click-shaped wake word: pressing the orb does what
- * saying the wake phrase does — starts the conversation, or ends the one
- * that runs. Without it the orb is display only.
+ * The click-shaped wake word: pressing the mascot does what saying the
+ * wake phrase does — starts the conversation, or ends the one that runs.
+ * Without it the stage is display only.
*/
onPress?: () => void;
/** What the press does right now — the accessible name and the tooltip. */
@@ -79,55 +89,15 @@ export function DeckOrb({
[],
);
- const [sweep, setSweep] = useState(0);
- const raf = useRef<number | null>(null);
- useEffect(() => {
- if (!busy || reduced) return;
- let start: number | null = null;
- const tick = (ts: number) => {
- if (start === null) start = ts;
- setSweep(((ts - start) / 30) % 360);
- raf.current = requestAnimationFrame(tick);
- };
- raf.current = requestAnimationFrame(tick);
- return () => {
- if (raf.current !== null) cancelAnimationFrame(raf.current);
- };
- }, [busy, reduced]);
-
- const R = size / 2;
- // The sphere sat at 0.78 of the reticle and left a ring of nothing around
- // it. Gigi carries a lot of air inside its own 256 viewBox — the figure is
- // roughly two thirds of it — so at 0.78 it read as a small toy in a big
- // dial. At 0.96 the figure fills the bezel the way the sphere used to.
- const orbSize = Math.round(size * 0.96);
- const point = (deg: number, r: number): [number, number] => {
- const rad = ((deg - 90) * Math.PI) / 180;
- return [R + r * Math.cos(rad), R + r * Math.sin(rad)];
- };
-
- const arcs = steps.slice(0, 8).map((step, i, all) => {
- const span = 320 / Math.max(1, all.length);
- const a0 = -160 + i * span + 3;
- const a1 = a0 + span - 6;
- const [x0, y0] = point(a0, R * 0.84);
- const [x1, y1] = point(a1, R * 0.84);
- return {
- id: step.id,
- d: `M ${x0} ${y0} A ${R * 0.84} ${R * 0.84} 0 ${a1 - a0 > 180 ? 1 : 0} 1 ${x1} ${y1}`,
- note: step.kind === "note",
- };
- });
-
- const [sx, sy] = point(sweep, R * 0.94);
- const [ex, ey] = point(sweep + 36, R * 0.94);
- const haloId = useId();
+ // The figure gets the room; the wave and the line take the rest. With no
+ // ring to sit inside, the figure can be nearly the whole width.
+ const figureSize = Math.round(size * 0.9);
+ const running = steps.slice(0, 8);
// The level loop: one number for everything that moves with the voice,
// written to the root as `--orb-level`. Runs only while a voice state
// drives it; idle (and reduced motion) is a still 0 and no loop at all.
const rootRef = useRef<HTMLDivElement>(null);
- const ripplesRef = useRef<HTMLDivElement>(null);
useEffect(() => {
const root = rootRef.current;
if (!root) return;
@@ -140,17 +110,11 @@ export function DeckOrb({
let level = 0;
const t0 = performance.now();
let last = t0;
- let lastRipple = Number.NEGATIVE_INFINITY;
const tick = (now: number) => {
const dt = Math.min(0.1, (now - last) / 1000);
last = now;
const target = driveTarget(drive, (now - t0) / 1000, readVoiceInputLevel(now));
- const next = smoothOrbLevel(level, target, dt);
- if (isOnset(level, next, now - lastRipple)) {
- lastRipple = now;
- spawnRipple(ripplesRef.current);
- }
- level = next;
+ level = smoothOrbLevel(level, target, dt);
root.style.setProperty("--orb-level", level.toFixed(3));
raf = requestAnimationFrame(tick);
};
@@ -161,79 +125,34 @@ export function DeckOrb({
};
}, [voiceState, reduced]);
+ const figure = <Figure voiceState={voiceState} size={figureSize} />;
+
return (
<div
ref={rootRef}
- className={cn("deck-orb-root relative shrink-0", className)}
- style={{ width: size, height: size }}
+ className={cn("deck-orb-root relative flex shrink-0 flex-col items-center", className)}
+ style={{ width: size }}
data-testid="deck-orb"
+ data-voice={voiceState}
>
- <svg viewBox={`0 0 ${size} ${size}`} className="absolute inset-0 h-full w-full" aria-hidden>
- <HudHaloDefs id={haloId} />
- <g filter={`url(#${haloId})`}>
- {/* bezel — the one hairline the meter and the arcs are read against */}
- <circle cx={R} cy={R} r={R * 0.94} fill="none" stroke="hsl(var(--primary))" strokeWidth={1} opacity={0.4} />
-
- {arcs.map((a) => (
- <path
- key={a.id}
- d={a.d}
- fill="none"
- stroke={a.note ? "hsl(var(--muted-foreground))" : "hsl(var(--primary))"}
- strokeWidth={3}
- strokeLinecap="butt"
- opacity={0.95}
- />
- ))}
- {busy && !reduced && (
- <path
- d={`M ${sx} ${sy} A ${R * 0.94} ${R * 0.94} 0 0 1 ${ex} ${ey}`}
- fill="none"
- stroke="hsl(var(--primary))"
- strokeWidth={2}
- strokeLinecap="butt"
- opacity={0.7}
- />
- )}
- </g>
- </svg>
-
- {/* The level arc on the bezel: grows from the top down both sides with
- the voice — a meter, reading `--orb-level` (CSS). */}
- <svg
- viewBox={`0 0 ${size} ${size}`}
- className="deck-orb-vu pointer-events-none absolute inset-0 h-full w-full"
- aria-hidden
- data-testid="deck-orb-vu"
- >
- <path
- d={`M ${R} ${R - R * 0.94} A ${R * 0.94} ${R * 0.94} 0 0 1 ${R} ${R + R * 0.94}`}
- pathLength={1}
- fill="none"
- stroke="hsl(var(--primary))"
- strokeWidth={3}
- strokeLinecap="round"
- />
- <path
- d={`M ${R} ${R - R * 0.94} A ${R * 0.94} ${R * 0.94} 0 0 0 ${R} ${R + R * 0.94}`}
- pathLength={1}
- fill="none"
- stroke="hsl(var(--primary))"
- strokeWidth={3}
- strokeLinecap="round"
- />
- </svg>
-
- {/* Ripples: one ring per word landing, from the sun to the bezel.
- Spawned by the level loop, gone when their animation ends. */}
+ {/* 1. The stage light — ONE element for the whole centre, and the only
+ thing that touches the wallpaper here. Warm where the figure stands
+ so the silhouette has something to be dark against, then falling to
+ the theme's ground colour so the wave and the readouts stay legible
+ over whatever picture is behind them, then to nothing. It was two
+ elements for an hour — a bright pool from here and a dark pool from
+ the view above it — and they fought: the pair drew a lit niche
+ around Gigi like a headstone (maintainer, 2026-08-20). One gradient
+ cannot fight itself. */}
<div
- ref={ripplesRef}
- className="pointer-events-none absolute inset-0 grid place-items-center"
aria-hidden
- data-testid="deck-orb-ripples"
+ data-testid="deck-stage-light"
+ className="deck-stage-light pointer-events-none absolute"
+ style={{ width: Math.round(size * 1.5), height: Math.round(size * 1.5) }}
/>
- <div className="absolute inset-0 grid place-items-center">
+ {/* 2 + 3: the figure, and the light it stands on. */}
+ <div className="relative grid place-items-center" style={{ height: figureSize }}>
{onPress ? (
<button
type="button"
@@ -242,92 +161,110 @@ export function DeckOrb({
aria-label={pressLabel}
title={pressLabel}
className={cn(
- "relative rounded-full transition-transform duration-200 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/70 focus-visible:ring-offset-2 focus-visible:ring-offset-background",
+ "relative rounded-2xl transition-transform duration-200 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/70 focus-visible:ring-offset-4 focus-visible:ring-offset-transparent",
pressDisabled
? "cursor-wait"
- : "cursor-pointer hover:scale-[1.04] active:scale-[0.97] motion-reduce:transform-none",
+ : "cursor-pointer hover:scale-[1.03] active:scale-[0.98] motion-reduce:transform-none",
)}
- style={{ width: orbSize, height: orbSize }}
+ style={{ width: figureSize, height: figureSize }}
>
- <OrbFace voiceState={voiceState} orbSize={orbSize} />
+ {figure}
</button>
) : (
- <div className="relative" style={{ width: orbSize, height: orbSize }}>
- <OrbFace voiceState={voiceState} orbSize={orbSize} />
+ <div className="relative" style={{ width: figureSize, height: figureSize }}>
+ {figure}
</div>
)}
+ <div
+ aria-hidden
+ data-testid="deck-stage-footlight"
+ className="deck-stage-footlight pointer-events-none absolute"
+ style={{ width: figureSize * 0.86, height: Math.round(figureSize * 0.11) }}
+ />
</div>
- {readouts && (
- <>
- <Readout className="left-1 top-1 text-left" text={readouts.nw} />
- <Readout className="right-1 top-1 text-right" text={readouts.ne} />
- <Readout
- className="bottom-1 left-1 text-left"
- text={readouts.sw}
- testId="deck-orb-provider"
+ {/* 4: the wave — the voice, in the shape a voice has. */}
+ <svg
+ viewBox="0 0 100 16"
+ preserveAspectRatio="none"
+ className="deck-orb-wave pointer-events-none mt-1"
+ style={{ width: Math.round(size * 0.6), height: 16 }}
+ aria-hidden
+ data-testid="deck-orb-wave"
+ /* While work is running the line travels; otherwise it only breathes
+ with the level, so a still line means nothing is happening. */
+ data-busy={busy && !reduced ? "true" : undefined}
+ >
+ {/* Two layers on purpose: the group carries the travel, the path
+ carries the amplitude, so neither transform overwrites the other. */}
+ <g className="deck-orb-wave-flow">
+ <path
+ className="deck-orb-wave-line"
+ d={WAVE_PATH}
+ fill="none"
+ stroke="hsl(var(--primary))"
+ strokeWidth={1.4}
+ strokeLinecap="round"
+ vectorEffect="non-scaling-stroke"
/>
- <Readout className="bottom-1 right-1 text-right" text={readouts.se} />
- </>
+ </g>
+ </svg>
+
+ {/* One mark per step running in parallel — nothing at all when none is. */}
+ {running.length > 0 && (
+ <div
+ className="mt-1 flex items-center gap-1"
+ aria-hidden
+ data-testid="deck-orb-steps"
+ >
+ {running.map((step) => (
+ <span
+ key={step.id}
+ className={cn(
+ "deck-orb-step h-1 rounded-full",
+ step.kind === "note" ? "bg-muted-foreground/60" : "bg-primary",
+ step.status === "active" ? "w-4 deck-orb-step-active" : "w-2 opacity-60",
+ )}
+ />
+ ))}
+ </div>
+ )}
+
+ {/* 5: the readouts the corners used to scatter, as one row. */}
+ {/* The row may run WIDER than the stage — the stage is sized for the
+ figure, and clamping the row to it truncated every field into
+ "VERTEX… · R… · 0 … · 0 …" (2026-08-20). Nothing clips it, so it
+ simply centres and overhangs. */}
+ {readouts && (
+ <div
+ className="mt-2 flex w-max items-center justify-center gap-x-2 whitespace-nowrap font-mono text-[9px] uppercase tracking-[0.1em] text-primary/75"
+ data-testid="deck-orb-readouts"
+ >
+ <span data-testid="deck-orb-provider">{readouts.sw}</span>
+ <Dot />
+ <span>{readouts.nw}</span>
+ <Dot />
+ <span>{readouts.ne}</span>
+ <Dot />
+ <span>{readouts.se}</span>
+ </div>
)}
</div>
);
}
-/**
- * The orb — the part of the centre a press lands on.
- *
- * Back to front: a soft gold glow wider than the sphere (`.deck-orb-glow`,
- * keyed on the voice state), then the mascot itself (`JarvisOrb`).
- */
-function OrbFace({ voiceState, orbSize }: { voiceState: VoiceState; orbSize: number }) {
- // The light behind the figure, a little wider than it so the silhouette
- // stands IN it rather than on it. It followed a smaller orb at 1.35; with
- // the figure nearly filling the bezel that would spill across the cards.
- const glow = Math.round(orbSize * 1.05);
+function Dot() {
return (
- <>
- <div
- aria-hidden
- className="deck-orb-glow pointer-events-none absolute left-1/2 top-1/2 rounded-full"
- data-voice={voiceState}
- style={{ width: glow, height: glow }}
- />
- <JarvisOrb size={orbSize} voiceState={voiceState} className="absolute inset-0" />
- </>
+ <span aria-hidden className="text-primary/35">
+ ·
+ </span>
);
}
-/** The most ripples alive at once — a burst is a few waves, not a strobe. */
-const MAX_RIPPLES = 4;
-
-/** One ripple ring, leaving the sun for the bezel; removes itself when done. */
-function spawnRipple(host: HTMLDivElement | null): void {
- if (!host || host.childElementCount >= MAX_RIPPLES) return;
- const el = document.createElement("div");
- el.className = "deck-orb-ripple rounded-full";
- el.addEventListener("animationend", () => el.remove(), { once: true });
- host.appendChild(el);
-}
-
-function Readout({
- text,
- className,
- testId,
-}: {
- text: string;
- className?: string;
- testId?: string;
-}) {
- return (
- <span
- data-testid={testId}
- className={cn(
- "pointer-events-none absolute max-w-[42%] truncate px-1.5 font-mono text-[9px] uppercase tracking-[0.16em] text-primary/90",
- className,
- )}
- >
- {text}
- </span>
- );
+/**
+ * The figure itself. Nothing is drawn over it and nothing rings it — the
+ * light behind and below is what stages it.
+ */
+function Figure({ voiceState, size }: { voiceState: VoiceState; size: number }) {
+ return <JarvisOrb size={size} voiceState={voiceState} className="absolute inset-0" />;
}
diff --git a/jarvis/ui/web/frontend/src/components/deck/JarvisOrb.tsx b/jarvis/ui/web/frontend/src/components/deck/JarvisOrb.tsx
index 5619f74c21..8fcb69ed98 100644
--- a/jarvis/ui/web/frontend/src/components/deck/JarvisOrb.tsx
+++ b/jarvis/ui/web/frontend/src/components/deck/JarvisOrb.tsx
@@ -14,13 +14,13 @@ import { cn } from "@/lib/utils";
* both PNGs are gone from the tree and the middle is Gigi, drawn as vectors:
* sharp at any size, no edge to cut, no bitmap to ship.
*
- * The staging is a dark figure standing in golden light. The glow behind it
- * (`.deck-orb-glow`, DeckOrb.tsx) throws the silhouette forward; the corona's
- * slow rays come up behind it in the voice. Gigi brings its own life — it
- * blinks, the pupils drift, it waves now and then, and with `reactToVoice` it
- * listens, thinks and speaks along. That is why the reticle around it no
- * longer needs to dance: the living thing is alive, the instruments stay
- * still until they have something to show.
+ * The staging is a dark figure standing in golden light, and it all happens
+ * BEHIND and BELOW it (DeckOrb.tsx: the backlight and the footlight) —
+ * nothing is drawn over the figure and nothing rings it. A corona of turning
+ * rays sat here for a day and went the same way as the bezel (2026-08-20):
+ * rays fanning out of a circle are sphere furniture, and the mascot is not a
+ * sphere. Gigi brings its own life — it blinks, the pupils drift, it waves
+ * now and then, and with `reactToVoice` it listens, thinks and speaks along.
*
* Voice moves the whole figure, honestly and cheaply. At rest a slow breath
* (framer, a gentle loop). While something is happening, the VOICE itself:
@@ -83,8 +83,6 @@ export function JarvisOrb({
className={cn("relative select-none", className)}
style={{ width: size, height: size }}
>
- {/* the corona: slow-turning rays behind the mascot, lit by the level */}
- <div aria-hidden className="deck-orb-corona pointer-events-none absolute rounded-full" />
{/* the reactor: the figure, sized and lit by the level */}
<div className="deck-orb-reactor absolute inset-0">
<motion.div
diff --git a/jarvis/ui/web/frontend/src/index.css b/jarvis/ui/web/frontend/src/index.css
index fc9d67a3ee..47b9ad3948 100644
--- a/jarvis/ui/web/frontend/src/index.css
+++ b/jarvis/ui/web/frontend/src/index.css
@@ -2084,92 +2084,139 @@
}
/* -----------------------------------------------------------
- The orb moves with the voice (DeckOrb.tsx, JarvisOrb.tsx).
- `--orb-level` is ONE number, 0..1, on the orb's root — the real
- microphone while listening, a speech-shaped envelope while the
- assistant speaks, a heartbeat while it thinks (lib/orbLevel.ts)
- — smoothed once, written once per frame. Everything below
- reads it: the sun's size and brightness, the glow, the corona's
- rays, the rings, the level arc on the bezel. Transform, opacity
- and a GPU brightness only, so it all moves as one and costs
- the main thread one style write.
+ The centre stage (DeckOrb.tsx, JarvisOrb.tsx).
+
+ `--orb-level` is ONE number, 0..1, on the stage's root — the
+ real microphone while listening, a speech-shaped envelope
+ while the assistant speaks, a heartbeat while it thinks
+ (lib/orbLevel.ts) — smoothed once, written once per frame.
+ Everything below reads it: the light behind the figure, the
+ light under it, the figure's own size and brightness, and the
+ wave. Transform, opacity and a GPU brightness only, so it all
+ moves as one and costs the main thread one style write.
+
+ Nothing here rings the figure. The bezel, the dial, the arc
+ meter and the corona were sphere furniture and went with the
+ sphere (2026-08-20).
----------------------------------------------------------- */
.deck-orb-root {
--orb-level: 0;
}
- .deck-orb-glow {
+
+ /* 1. The stage light — the ONE thing that touches the wallpaper here.
+ Three jobs in one gradient, in this order out from the middle:
+
+ · warm gold where the figure stands, so a black silhouette has
+ something to be dark against;
+ · then the theme's own ground colour, so the wave, the readouts and
+ the headline stay legible over whatever picture is behind them;
+ · then nothing, on a circle that reaches zero well inside its own
+ box — no edge anywhere can cut it.
+
+ It was two elements for an hour: this pool, plus a darkening wash the
+ view drew from outside. They fought — bright pool inside dark pool
+ framed the mascot in a lit niche, like a headstone (maintainer,
+ 2026-08-20). One gradient cannot fight itself. */
+ .deck-stage-light {
+ left: 50%;
+ top: 44%;
+ transform: translate(-50%, -50%) scale(calc(1 + var(--orb-level, 0) * 0.05));
+ border-radius: 50%;
background: radial-gradient(
- circle,
- rgba(248, 226, 151, 0.5) 0%,
- rgba(231, 196, 110, 0.28) 38%,
- rgba(210, 147, 24, 0.1) 58%,
- rgba(210, 147, 24, 0) 70%
+ circle at 50% 50%,
+ rgba(248, 226, 151, 0.34) 0%,
+ rgba(240, 212, 134, 0.24) 16%,
+ rgba(224, 178, 74, 0.12) 27%,
+ hsl(var(--background) / 0.5) 40%,
+ hsl(var(--background) / 0.28) 52%,
+ hsl(var(--background) / 0) 68%
);
- opacity: calc(0.6 + var(--orb-level, 0) * 0.4);
- transform: translate(-50%, -50%) scale(calc(1 + var(--orb-level, 0) * 0.18));
+ opacity: calc(0.85 + var(--orb-level, 0) * 0.15);
will-change: transform, opacity;
}
- /* at rest the glow breathes slowly — alive, not busy */
- .deck-orb-glow[data-voice="idle"] {
- animation: deck-orb-glow-idle 5.5s ease-in-out infinite;
+ /* At rest it breathes — alive, not busy. */
+ .deck-orb-root[data-voice="idle"] .deck-stage-light {
+ animation: deck-stage-breathe 6.5s ease-in-out infinite;
}
- /* the sun itself: bigger and brighter with the voice */
- .deck-orb-reactor {
- transform: scale(calc(1 + var(--orb-level, 0) * 0.09));
- filter: brightness(calc(1 + var(--orb-level, 0) * 0.55));
- will-change: transform, filter;
+ @keyframes deck-stage-breathe {
+ 0%,
+ 100% {
+ opacity: 0.8;
+ }
+ 50% {
+ opacity: 0.95;
+ }
}
- /* the corona: slow-turning rays behind the sun, seen only in the voice */
- .deck-orb-corona {
- inset: -18%;
- background: repeating-conic-gradient(
- from 0deg,
- hsl(var(--primary) / 0) 0deg 5deg,
- hsl(var(--primary) / 0.55) 8deg,
- hsl(var(--primary) / 0) 11deg 20deg
+
+ /* 2. The footlight: a flat ellipse under the figure. This is what puts
+ Gigi on a floor instead of afloat, and it takes the voice as light. */
+ .deck-stage-footlight {
+ left: 50%;
+ bottom: 13%;
+ transform: translateX(-50%) scaleX(calc(1 + var(--orb-level, 0) * 0.14));
+ border-radius: 50%;
+ background: radial-gradient(
+ ellipse at 50% 50%,
+ hsl(var(--primary) / 0.5) 0%,
+ hsl(var(--primary) / 0.2) 42%,
+ hsl(var(--primary) / 0) 72%
);
- -webkit-mask-image: radial-gradient(circle, transparent 30%, #000 42%, #000 58%, transparent 68%);
- mask-image: radial-gradient(circle, transparent 30%, #000 42%, #000 58%, transparent 68%);
- opacity: calc(var(--orb-level, 0) * 0.9);
- animation: deck-orb-turn 30s linear infinite;
+ opacity: calc(0.62 + var(--orb-level, 0) * 0.38);
+ filter: blur(1px);
will-change: transform, opacity;
}
- /* the level arc on the bezel: two half-circles from the top, drawn as far
- as the level goes; nothing at 0 */
- .deck-orb-vu path {
- stroke-dasharray: 1;
- stroke-dashoffset: calc(1 - var(--orb-level, 0));
- opacity: 0.9;
- }
- .deck-orb-vu {
- filter: drop-shadow(0 0 4px hsl(var(--primary) / 0.6));
- }
- /* a ripple: one ring from the sun to the bezel per word landing */
- .deck-orb-ripple {
- width: 78%;
- height: 78%;
- border: 1.5px solid hsl(var(--primary) / 0.85);
- box-shadow: 0 0 8px hsl(var(--primary) / 0.4);
- animation: deck-orb-ripple 800ms cubic-bezier(0.1, 0.6, 0.3, 1) forwards;
- will-change: transform, opacity;
+
+ /* 3. The figure: bigger and brighter with the voice. */
+ .deck-orb-reactor {
+ transform: scale(calc(1 + var(--orb-level, 0) * 0.07));
+ filter: brightness(calc(1 + var(--orb-level, 0) * 0.5));
+ will-change: transform, filter;
}
- @keyframes deck-orb-ripple {
- 0% {
- transform: scale(0.92);
- opacity: 0.75;
- }
- 100% {
- transform: scale(1.24);
- opacity: 0;
+
+ /* 4. The wave: the meter, in the shape a voice has. Flat when there is
+ nothing to hear — a still line is an honest zero. The group travels
+ while work runs; the line carries the amplitude. */
+ .deck-orb-wave {
+ overflow: hidden;
+ filter: drop-shadow(0 0 4px hsl(var(--primary) / 0.5));
+ /* Nothing to hear, nothing to draw: at rest this is invisible, so the
+ line can never read as a decorative rule under the figure. */
+ opacity: calc(var(--orb-level, 0) * 1.1);
+ }
+ .deck-orb-wave-line {
+ transform-box: fill-box;
+ transform-origin: 50% 50%;
+ transform: scaleY(calc(0.12 + var(--orb-level, 0) * 1.25));
+ will-change: transform;
+ }
+ .deck-orb-wave-flow {
+ will-change: transform;
+ }
+ .deck-orb-wave[data-busy="true"] .deck-orb-wave-flow {
+ animation: deck-wave-flow 2.4s linear infinite;
+ }
+ @keyframes deck-wave-flow {
+ to {
+ transform: translateX(-50px);
}
}
- @keyframes deck-orb-glow-idle {
+
+ /* 5. One mark per step running in parallel; the live one pulses. */
+ .deck-orb-step {
+ transition:
+ width 220ms ease-out,
+ opacity 220ms ease-out;
+ }
+ .deck-orb-step-active {
+ animation: deck-step-pulse 1.3s ease-in-out infinite;
+ }
+ @keyframes deck-step-pulse {
0%,
100% {
- opacity: 0.5;
+ opacity: 0.55;
}
50% {
- opacity: 0.74;
+ opacity: 1;
}
}
@@ -2197,16 +2244,12 @@
}
@media (prefers-reduced-motion: reduce) {
- .deck-orb-glow,
- .deck-orb-corona,
- .deck-orb-ripple,
+ .deck-stage-light,
+ .deck-orb-wave-flow,
+ .deck-orb-step-active,
.deck-ring-orbit {
animation: none !important;
}
- .deck-orb-corona,
- .deck-orb-ripple {
- display: none;
- }
}
/* ===========================================================
diff --git a/jarvis/ui/web/frontend/src/lib/deckStage.test.ts b/jarvis/ui/web/frontend/src/lib/deckStage.test.ts
index 94a960ac63..109379aa97 100644
--- a/jarvis/ui/web/frontend/src/lib/deckStage.test.ts
+++ b/jarvis/ui/web/frontend/src/lib/deckStage.test.ts
@@ -1,5 +1,5 @@
import { describe, expect, test } from "vitest";
-import { orbSizeFor, stageVignette, stageWashSize } from "@/lib/deckStage";
+import { orbSizeFor } from "@/lib/deckStage";
describe("orbSizeFor", () => {
test("is the maximum until the stage is measured", () => {
@@ -7,32 +7,15 @@ describe("orbSizeFor", () => {
});
test("fits the room under the headline and stays inside the bounds", () => {
- expect(orbSizeFor(600, 300)).toBe(228);
+ expect(orbSizeFor(600, 300)).toBe(200);
expect(orbSizeFor(220, 900)).toBe(204);
expect(orbSizeFor(120, 120)).toBe(200);
expect(orbSizeFor(2000, 2000)).toBe(320);
});
-});
-
-describe("stageVignette", () => {
- test("uses the theme ground colour and scales with the reticle", () => {
- const css = stageVignette(300);
- expect(css).toContain("hsl(var(--background)");
- expect(css).toContain("165px");
- expect(css).toContain("315px");
- });
-
- test("is centred on its own element, not offset for a column", () => {
- // It rode a wide, short column at "50% 46%" and got clipped top and
- // bottom while still opaque — a bright slab in light mode.
- expect(stageVignette(300)).toContain("circle at 50% 50%");
- });
- test("the element is wide enough for the circle to reach zero inside it", () => {
- // Anything smaller and an edge cuts the wash — the defect this pair fixes.
- for (const size of [200, 240, 300, 320]) {
- const outer = Number(/ (\d+)px\)$/.exec(stageVignette(size))?.[1]);
- expect(stageWashSize(size)).toBeGreaterThanOrEqual(outer * 2);
- }
+ test("keeps room under the figure for the wave and the readout row", () => {
+ // The stage grew a wave and a readout row below the figure on 2026-08-20;
+ // a reserve sized for the headline alone let them run off a short stage.
+ expect(orbSizeFor(2000, 400)).toBeLessThanOrEqual(400 - 108);
});
});
diff --git a/jarvis/ui/web/frontend/src/lib/deckStage.ts b/jarvis/ui/web/frontend/src/lib/deckStage.ts
index 8bdf83908f..58842f9609 100644
--- a/jarvis/ui/web/frontend/src/lib/deckStage.ts
+++ b/jarvis/ui/web/frontend/src/lib/deckStage.ts
@@ -1,51 +1,30 @@
/**
- * The deck's centre stage: how large the orb reticle is for the room it has,
- * and the vignette the wallpaper gets under it.
- */
-
-const ORB_MIN = 200;
-const ORB_MAX = 320;
-/** Vertical room kept for the headline under the orb (two lines plus the gap). */
-const HEADLINE_RESERVE = 72;
-
-/**
- * The reticle size for a stage of the given size — as large as the stage
- * allows, never taller than the room left under the headline, and never past
- * the point where the reticle stops reading as an instrument. The maximum
- * until the stage has been measured.
+ * The deck's centre stage: how large the stage is for the room it has.
+ *
+ * There used to be a `stageVignette` here too — a radial wash the view drew
+ * behind the centre. It is gone (2026-08-20). The stage now carries its own
+ * single light (`DeckOrb`'s `.deck-stage-light`, index.css), because two
+ * pools drawn from two places fought each other: one lifting the centre out
+ * of the wallpaper, one lighting the figure, and together they framed the
+ * mascot in a lit niche.
*/
-export function orbSizeFor(width: number, height: number): number {
- if (!width || !height) return ORB_MAX;
- const fit = Math.min(width - 16, height - HEADLINE_RESERVE);
- return Math.max(ORB_MIN, Math.min(ORB_MAX, Math.floor(fit)));
-}
+const STAGE_MIN = 200;
+const STAGE_MAX = 320;
/**
- * How wide the wash under the centre has to be drawn: twice its own outer
- * radius, so the circle reaches zero INSIDE its element.
- *
- * This is the whole point of the pair. The wash used to be a background on
- * the stage column itself, which is far wider than it is tall — the circle
- * ran off the top and bottom edges while still at a third of its opacity and
- * was cut there, so the "soft pool" was a rectangle with two straight edges.
- * On the dark deck that read as a slightly darker box; in light mode, where
- * the ground colour is near-white over a dark wallpaper, it was a bright slab
- * behind the mascot — the same defect the orb PNG had, from the other side.
- * On its own square element nothing can clip it.
+ * Vertical room kept under the figure for the wave, the readout row and the
+ * headline.
*/
-export function stageWashSize(size: number): number {
- return Math.round(size * 1.05) * 2;
-}
+const BELOW_RESERVE = 108;
/**
- * The stage under the centre: the wallpaper darkens softly around the mascot,
- * in the theme's own ground colour (so it is a light pool in light mode), and
- * the mascot stands on a stage instead of on whatever the wallpaper puts
- * there. Sized off the reticle so it reads the same at every stage size, and
- * centred on its own element (see `stageWashSize`).
+ * The stage size for a room of the given size — as large as the room allows,
+ * never taller than what is left under the headline, and never past the point
+ * where the mascot stops reading as a character and starts reading as a
+ * poster. The maximum until the room has been measured.
*/
-export function stageVignette(size: number): string {
- const inner = Math.round(size * 0.55);
- const outer = Math.round(size * 1.05);
- return `radial-gradient(circle at 50% 50%, hsl(var(--background) / 0.9) 0px, hsl(var(--background) / 0.55) ${inner}px, hsl(var(--background) / 0) ${outer}px)`;
+export function orbSizeFor(width: number, height: number): number {
+ if (!width || !height) return STAGE_MAX;
+ const fit = Math.min(width - 16, height - BELOW_RESERVE);
+ return Math.max(STAGE_MIN, Math.min(STAGE_MAX, Math.floor(fit)));
}
diff --git a/jarvis/ui/web/frontend/src/views/MissionDeckView.tsx b/jarvis/ui/web/frontend/src/views/MissionDeckView.tsx
index ada83e3fd7..caa98cc6ad 100644
--- a/jarvis/ui/web/frontend/src/views/MissionDeckView.tsx
+++ b/jarvis/ui/web/frontend/src/views/MissionDeckView.tsx
@@ -28,7 +28,7 @@ import { useVoiceReadiness } from "@/hooks/useVoiceReadiness";
import { useWakeWord } from "@/hooks/useWakeWord";
import { useVoiceCall } from "@/components/agentic/useVoiceCall";
import { useElementSize } from "@/hooks/useElementSize";
-import { orbSizeFor, stageVignette, stageWashSize } from "@/lib/deckStage";
+import { orbSizeFor } from "@/lib/deckStage";
import { HANDOFF, autoLaunchAfterMs, resolvePhase } from "@/lib/deckStandby";
import { writeDeckMode } from "@/lib/deckMode";
import { cn } from "@/lib/utils";
@@ -463,21 +463,11 @@ function BoardCentre({
>
{/* The same layoutId as the standby's orb: when the board takes over,
the orb travels here instead of blinking — and lands with a ring. */}
+ {/* No wash here. Lifting the centre off the wallpaper is the stage's
+ own job now (`DeckOrb`'s `.deck-stage-light`): a second pool drawn
+ from out here only fought the first one, and the two together drew
+ a lit niche around the mascot (maintainer, 2026-08-20). */}
<div className="relative isolate">
- {/* The wash that lifts the centre off the wallpaper. It rides on the
- orb, on a square of its own, because it used to be a background
- on the column above — where the column's straight top and bottom
- cut the circle while it was still opaque (deckStage.ts). */}
- <div
- aria-hidden
- data-testid="deck-stage-wash"
- className="pointer-events-none absolute left-1/2 top-1/2 -z-10 -translate-x-1/2 -translate-y-1/2 rounded-full"
- style={{
- width: stageWashSize(orbSize),
- height: stageWashSize(orbSize),
- backgroundImage: stageVignette(orbSize),
- }}
- />
<motion.div layoutId="deck-orb" layoutDependency={orbSize} transition={ORB_TRAVEL}>
<DeckOrb
steps={steps}