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 orb's reticle is alive at rest, on the standby stage and on the board

Harald96fa083a251b
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 2fc173fac9..9bef3e1418 100644
--- a/jarvis/ui/web/frontend/src/components/deck/DeckOrb.test.tsx
+++ b/jarvis/ui/web/frontend/src/components/deck/DeckOrb.test.tsx
@@ -30,6 +30,17 @@ describe("DeckOrb", () => {
expect(screen.getByTestId("jarvis-orb")).toBeTruthy();
});
+ test("is alive at rest: turning scales, a satellite on the bezel, the idle ping", () => {
+ const { container, rerender } = render(<DeckOrb steps={[]} busy={false} />);
+ expect(container.querySelector(".deck-orb-orbit-a")).toBeTruthy();
+ expect(container.querySelector(".deck-orb-orbit-b")).toBeTruthy();
+ expect(screen.getByTestId("deck-orb-satellite")).toBeTruthy();
+ expect(screen.getByTestId("deck-orb-ping")).toBeTruthy();
+ // The satellite steps aside for the busy sweep — one signal on the bezel.
+ rerender(<DeckOrb steps={[]} busy />);
+ expect(screen.queryByTestId("deck-orb-satellite")).toBeNull();
+ });
+
test("the centre is the Jarvis orb artwork, and nothing rides in its core", () => {
render(<DeckOrb steps={[]} busy={false} />);
const orb = screen.getByTestId("jarvis-orb");
diff --git a/jarvis/ui/web/frontend/src/components/deck/DeckOrb.tsx b/jarvis/ui/web/frontend/src/components/deck/DeckOrb.tsx
index 72f171f7b2..b7ea1f0c69 100644
--- a/jarvis/ui/web/frontend/src/components/deck/DeckOrb.tsx
+++ b/jarvis/ui/web/frontend/src/components/deck/DeckOrb.tsx
@@ -19,6 +19,17 @@ import { cn } from "@/lib/utils";
* the deck's addition, and every part of it carries information: the arcs
* are parallel work made visible, the sweep turns only while something
* runs, the readouts are live values the caller sources.
+ *
+ * And it is ALIVE at rest (maintainer, 2026-08-19: the still reticle looked
+ * boring on both stages): the inner scale turns slowly one way, a sparse
+ * orbit the other, a satellite rides the bezel, the glow breathes, and while
+ * the assistant is idle a faint ping leaves the orb every few seconds — the
+ * listening heartbeat. Calm, not busy: slow periods, low opacities, nothing
+ * that competes with a real signal (the satellite steps aside for the busy
+ * sweep). Each living part is its own small layer — a root `<svg>` or a div
+ * with a CSS transform/opacity animation (index.css) — so the browser turns
+ * it on the compositor and the main thread never hears of it; the halo
+ * filter stays on the still reticle. Reduced motion stops all of it.
*/
export interface OrbReadouts {
nw: string;
@@ -143,18 +154,8 @@ export function DeckOrb({
return <line key={deg} x1={ax} y1={ay} x2={bx} y2={by} stroke="hsl(var(--primary))" strokeWidth={1.5} opacity={0.9} />;
})}
- {/* inner scale ring around the orb */}
+ {/* inner scale ring around the orb (the dashed scale inside it turns — see below) */}
<circle cx={R} cy={R} r={R * 0.84} fill="none" stroke="hsl(var(--primary))" strokeWidth={1} opacity={0.5} />
- <circle
- cx={R}
- cy={R}
- r={R * 0.66}
- fill="none"
- stroke="hsl(var(--primary))"
- strokeWidth={1}
- strokeDasharray="2 6"
- opacity={0.55}
- />
{arcs.map((a) => (
<path
@@ -180,6 +181,37 @@ export function DeckOrb({
</g>
</svg>
+ {/* The living parts, each its own layer (CSS, index.css): the dashed
+ inner scale turning one way, a sparse orbit the other, a satellite
+ on the bezel while nothing runs, and the idle ping. */}
+ <OrbitLayer size={size} r={R * 0.66} className="deck-orb-orbit-a" dash="2 6" opacity={0.55} />
+ <OrbitLayer size={size} r={R * 0.76} className="deck-orb-orbit-b" dash="18 54" opacity={0.32} />
+ {!busy && (
+ <svg
+ viewBox={`0 0 ${size} ${size}`}
+ className="deck-orb-satellite pointer-events-none absolute inset-0 h-full w-full"
+ aria-hidden
+ data-testid="deck-orb-satellite"
+ >
+ <path
+ d={`M ${point(-16, R * 0.94)[0]} ${point(-16, R * 0.94)[1]} A ${R * 0.94} ${R * 0.94} 0 0 1 ${R} ${R - R * 0.94}`}
+ fill="none"
+ stroke="hsl(var(--primary))"
+ strokeWidth={1.5}
+ opacity={0.45}
+ />
+ <circle cx={R} cy={R - R * 0.94} r={2.2} fill="hsl(var(--primary))" />
+ </svg>
+ )}
+ {voiceState === "idle" && (
+ <div
+ aria-hidden
+ data-testid="deck-orb-ping"
+ className="deck-orb-ping pointer-events-none absolute rounded-full"
+ style={{ inset: size * 0.08 }}
+ />
+ )}
+
<div className="absolute inset-0 grid place-items-center">
{onPress ? (
<button
@@ -238,6 +270,45 @@ function OrbFace({ voiceState, orbSize }: { voiceState: VoiceState; orbSize: num
);
}
+/**
+ * One turning ring of the reticle: a dashed circle in its own root `<svg>`,
+ * so its CSS rotation is a compositor transform (a transform on a group
+ * INSIDE an svg repaints the whole svg every frame).
+ */
+function OrbitLayer({
+ size,
+ r,
+ className,
+ dash,
+ opacity,
+}: {
+ size: number;
+ r: number;
+ className: string;
+ dash: string;
+ opacity: number;
+}) {
+ const c = size / 2;
+ return (
+ <svg
+ viewBox={`0 0 ${size} ${size}`}
+ className={cn("pointer-events-none absolute inset-0 h-full w-full", className)}
+ aria-hidden
+ >
+ <circle
+ cx={c}
+ cy={c}
+ r={r}
+ fill="none"
+ stroke="hsl(var(--primary))"
+ strokeWidth={1}
+ strokeDasharray={dash}
+ opacity={opacity}
+ />
+ </svg>
+ );
+}
+
function Readout({ text, className }: { text: string; className?: string }) {
return (
<span
diff --git a/jarvis/ui/web/frontend/src/components/deck/DeckStandby.tsx b/jarvis/ui/web/frontend/src/components/deck/DeckStandby.tsx
index ba84d2f612..5c88a57a5e 100644
--- a/jarvis/ui/web/frontend/src/components/deck/DeckStandby.tsx
+++ b/jarvis/ui/web/frontend/src/components/deck/DeckStandby.tsx
@@ -562,7 +562,10 @@ function StandbyRing({
const stroke = "hsl(var(--primary))";
const tickOpacity = [0.3, 0.55, 0.9] as const;
+ const innerR = Math.max(reticle / 2 + 18, R * 0.62);
+
return (
+ <>
<svg
viewBox={`0 0 ${size} ${size}`}
className="absolute inset-0 h-full w-full"
@@ -698,17 +701,27 @@ function StandbyRing({
)}
</g>
- {/* a faint scale between reticle and arcs — the ring's inner edge */}
+ </svg>
+
+ {/* a faint scale between reticle and arcs — the ring's inner edge — in
+ its own layer, turning slowly against the sweep (CSS, compositor) */}
+ <svg
+ viewBox={`0 0 ${size} ${size}`}
+ className="deck-ring-orbit pointer-events-none absolute inset-0 h-full w-full"
+ aria-hidden
+ >
+ <circle cx={C} cy={C} r={innerR} fill="none" stroke={stroke} strokeWidth={1} strokeDasharray="2 8" opacity={0.22} />
<circle
cx={C}
cy={C}
- r={Math.max(reticle / 2 + 18, R * 0.62)}
+ r={innerR + 10}
fill="none"
stroke={stroke}
strokeWidth={1}
- strokeDasharray="2 8"
- opacity={0.22}
+ strokeDasharray="26 74"
+ opacity={0.16}
/>
</svg>
+ </>
);
}
diff --git a/jarvis/ui/web/frontend/src/index.css b/jarvis/ui/web/frontend/src/index.css
index 6176c4e9e8..8a46abc958 100644
--- a/jarvis/ui/web/frontend/src/index.css
+++ b/jarvis/ui/web/frontend/src/index.css
@@ -2176,13 +2176,95 @@
transform: translate(-50%, -50%) scale(1.07);
}
}
+ /* 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;
+ }
+ @keyframes deck-orb-glow-idle {
+ 0%,
+ 100% {
+ opacity: 0.5;
+ }
+ 50% {
+ opacity: 0.74;
+ }
+ }
+
+ /* -----------------------------------------------------------
+ The reticle's living parts (DeckOrb.tsx). Each is a root
+ <svg> or a div of its own, so these transforms and opacities
+ are compositor work: the dashed inner scale turns one way,
+ a sparse orbit the other, a satellite rides the bezel, and
+ while the assistant is idle a faint ping leaves the orb every
+ seven seconds. The standby's big ring turns its inner scale
+ the same way (.deck-ring-orbit). Slow on purpose.
+ ----------------------------------------------------------- */
+ .deck-orb-orbit-a,
+ .deck-orb-orbit-b,
+ .deck-orb-satellite,
+ .deck-ring-orbit {
+ transform-origin: 50% 50%;
+ will-change: transform;
+ /* the same readability halo the still reticle gets from its SVG filter */
+ filter: drop-shadow(0 0 1.2px hsl(var(--background) / 0.85));
+ }
+ .deck-orb-orbit-a {
+ animation: deck-orb-turn 48s linear infinite;
+ }
+ .deck-orb-orbit-b {
+ animation: deck-orb-turn 36s linear infinite reverse;
+ }
+ .deck-orb-satellite {
+ animation: deck-orb-turn 18s linear infinite;
+ }
+ .deck-ring-orbit {
+ animation: deck-orb-turn 90s linear infinite reverse;
+ }
+ @keyframes deck-orb-turn {
+ to {
+ transform: rotate(360deg);
+ }
+ }
+ .deck-orb-ping {
+ border: 1px solid hsl(var(--primary) / 0.9);
+ box-shadow: 0 0 6px hsl(var(--primary) / 0.35);
+ opacity: 0;
+ transform: scale(0.88);
+ will-change: transform, opacity;
+ animation: deck-orb-ping 7s ease-out infinite;
+ }
+ @keyframes deck-orb-ping {
+ 0% {
+ opacity: 0;
+ transform: scale(0.88);
+ }
+ 3% {
+ opacity: 0.55;
+ }
+ 22% {
+ opacity: 0;
+ transform: scale(1.12);
+ }
+ 100% {
+ opacity: 0;
+ transform: scale(1.12);
+ }
+ }
@media (prefers-reduced-motion: reduce) {
.deck-core,
.deck-core *,
- .deck-orb-glow {
+ .deck-orb-glow,
+ .deck-orb-orbit-a,
+ .deck-orb-orbit-b,
+ .deck-orb-satellite,
+ .deck-orb-ping,
+ .deck-ring-orbit {
animation: none !important;
}
+ .deck-orb-ping {
+ display: none;
+ }
}
/* ===========================================================