Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

Replace the agent thread spinner with the shape-changing mascot (#3126)

sarah480cc5119a88
diff --git a/.changeset/acp-working-avatar.md b/.changeset/acp-working-avatar.md
new file mode 100644
index 000000000..47d4c6c1c
--- /dev/null
+++ b/.changeset/acp-working-avatar.md
@@ -0,0 +1,5 @@
+---
+"@inkeep/open-knowledge": patch
+---
+
+The agent thread's working row is now the OK mascot changing shape instead of a spinner. It holds each pose, changes into the next, and holds again, with a squash and a squint on top so a long wait reads as effort rather than a stall. The status line beside it says what the agent is actually doing when a tool is running (reading, drafting, retrieving) and otherwise drifts through a pool of phrases on a randomized beat, so the row keeps moving without ever implying progress it cannot see. The line fades between phrases rather than cutting, and the whole row fades in when a turn opens. Under reduced motion the mascot holds a single pose and only the fades remain.
diff --git a/packages/app/src/components/BottomComposer.tsx b/packages/app/src/components/BottomComposer.tsx
index 5b21a8a22..d8d498a4a 100644
--- a/packages/app/src/components/BottomComposer.tsx
+++ b/packages/app/src/components/BottomComposer.tsx
@@ -71,6 +71,7 @@ import {
selectionSnapshotToCompose,
} from '@/editor/selection-context';
import type { EditorSurface } from '@/editor/selection-stats';
+import { useReducedMotion } from '@/hooks/use-reduced-motion';
import { useSelectionContext } from '@/hooks/use-selection-context';
import { isDesktopTargetEnabled, isInAppAgentEnabled } from '@/lib/acp/agent-visibility';
import { useEnabledOverrides } from '@/lib/acp/enabled-agents';
@@ -134,26 +135,6 @@ function isNativeTextControl(target: EventTarget | null): boolean {
return tagName === 'INPUT' || tagName === 'TEXTAREA' || tagName === 'SELECT';
}
-function useReducedMotion(): boolean {
- // Lazy-init from the live media query so a `prefers-reduced-motion` user gets
- // the static state on the first render — no one animated frame before an
- // effect corrects it. Mirrors the `embeddedHost` lazy-init in EditorArea. The
- // effect still subscribes to runtime changes.
- const [reduced, setReduced] = useState(
- () =>
- typeof window !== 'undefined' &&
- window.matchMedia('(prefers-reduced-motion: reduce)').matches,
- );
- useEffect(() => {
- const mq = window.matchMedia('(prefers-reduced-motion: reduce)');
- setReduced(mq.matches);
- const onChange = (event: MediaQueryListEvent) => setReduced(event.matches);
- mq.addEventListener('change', onChange);
- return () => mq.removeEventListener('change', onChange);
- }, []);
- return reduced;
-}
-
/**
* Rotates through `phrases`, holding each one long enough to read, then fading
* it out and the next one in. `enabled === false` (reduced motion, or a
diff --git a/packages/app/src/components/OkBlob.tsx b/packages/app/src/components/OkBlob.tsx
index 44f18aeb4..a7ee190ff 100644
--- a/packages/app/src/components/OkBlob.tsx
+++ b/packages/app/src/components/OkBlob.tsx
@@ -1,5 +1,6 @@
import { type CSSProperties, useEffect, useLayoutEffect, useRef, useState } from 'react';
import { cn } from '@/lib/utils';
+import { MASCOT_OUTLINE_PATH } from './mascot-outline';
import {
type ActiveClickLevel,
type ClickLevel,
@@ -319,10 +320,7 @@ export function OkBlob({
key={`body-${clickSeq}`}
className={cn('ok-blob-group', isSleeping && 'ok-blob-sleeping', bounceClass)}
>
- <path
- d="M25.2339 6.78134C25.5199 7.35734 25.8179 8.47234 26.0179 9.07834C26.0189 9.08234 26.0209 9.08634 26.0219 9.09134C26.0229 9.09534 26.0249 9.10034 26.0259 9.10434C26.0539 9.19734 26.0949 9.29533 26.1519 9.41633C26.2919 9.71133 26.5269 10.1173 27.1299 11.1683C27.3259 11.4643 27.5209 11.7693 27.7119 12.0903C29.9739 15.1623 29.3259 20.1913 27.0469 22.9153C26.7779 23.2953 26.4869 23.6043 26.1889 23.8863C26.1519 23.9253 26.1129 23.9643 26.0729 24.0033C25.3159 24.7543 24.2949 25.4673 23.6129 25.8323C22.7469 26.2983 22.1349 26.5483 21.6299 26.7463C20.3649 27.3063 19.0609 27.7733 17.6569 28.0423C15.9649 28.3513 14.1939 28.4433 12.4569 28.1373C11.4779 27.9663 10.5119 27.6663 9.60891 27.2493C8.77491 26.8663 7.99192 26.3853 7.26992 25.8403C6.83592 25.5393 6.43893 25.2343 6.08093 24.9383C5.57893 24.5223 5.15993 24.1263 4.83493 23.7793C4.04993 22.9443 3.31593 21.8893 2.80893 21.0953C2.72593 20.9663 2.64792 20.8433 2.57592 20.7293C2.56192 20.7093 2.54793 20.6893 2.53393 20.6703C2.08593 20.0263 1.71892 19.3293 1.43792 18.5993C1.42892 18.5453 1.42093 18.4903 1.41293 18.4353C1.32093 17.7443 1.08292 16.9423 1.01092 15.6333C0.984921 15.0653 0.998928 14.4013 1.12393 13.6353C1.20693 13.1413 1.31993 12.9023 1.40893 12.7113C1.43593 12.6543 1.46193 12.6023 1.48593 12.5483C1.56793 12.3653 1.59392 12.1563 1.63592 11.9083C1.68992 11.5883 1.76992 11.1943 2.04592 10.7553C2.94392 9.37934 3.36792 8.81934 3.66592 8.33934C3.75592 8.20334 3.84292 8.08134 3.94192 7.96634C4.21592 7.64634 4.67693 7.29534 5.10293 7.05734C5.16693 7.02234 5.23093 6.98834 5.29193 6.95534C5.62993 6.77834 6.22592 6.30135 6.66992 5.92035C6.83692 5.77635 7.08193 5.60735 7.37393 5.40935C7.67393 5.20535 8.02593 4.96934 8.39193 4.70234C9.32093 4.02634 9.84091 3.69134 10.2599 3.42334C10.3799 3.34734 10.4919 3.27734 10.6049 3.20834C10.9609 2.98834 11.4149 2.73034 11.8869 2.48634C12.4519 2.19334 13.0469 1.92133 13.5089 1.72233C14.7399 1.30233 16.0539 1.01333 17.4169 1.00033C18.1169 0.991333 18.7939 1.16534 19.2389 1.43034C19.6869 1.69534 19.8689 2.00335 19.8039 2.23935C19.7379 2.47835 19.4399 2.63634 19.0109 2.74734C18.5789 2.85634 18.0469 2.92035 17.4889 2.96135C16.3639 3.04235 15.2399 3.36435 14.1499 3.80835C12.8199 4.35135 11.5379 5.07133 10.2719 5.84733C9.38691 6.39133 8.51192 6.97334 7.63592 7.56834C7.54492 7.63034 7.45492 7.69135 7.36492 7.75235C6.97392 8.06635 6.58293 8.38134 6.22293 8.66334C5.97893 8.85734 5.76793 9.04834 5.59393 9.21434C5.26893 9.52334 5.02393 9.74334 4.81893 9.93934C4.67793 10.0753 4.55793 10.2013 4.45593 10.3443C4.40093 10.4213 4.32992 10.5273 4.24792 10.6593C3.90492 11.1933 3.44493 12.1693 3.15393 13.1173C3.01893 13.5363 2.87991 14.0343 2.79391 14.5253C2.66591 15.2253 2.65594 15.9053 2.71994 16.2373C2.82794 16.8193 2.95593 17.4833 3.14093 18.0553C3.31293 18.6003 3.52991 19.0583 3.70791 19.2823C3.81591 19.4183 3.90394 19.5473 3.99594 19.6913C4.09394 19.8413 4.19191 20.0073 4.31091 20.2033C4.47891 20.4803 4.68592 20.8163 5.00192 21.2493C5.36492 21.7463 5.61793 22.1043 5.83493 22.4023C6.14493 22.8243 6.38591 23.1343 6.83691 23.5033C7.33891 23.9113 7.86593 24.3113 8.26693 24.6393C8.44893 24.7883 8.66993 24.9443 8.90493 25.0963C9.21593 25.2963 9.55192 25.4893 9.85592 25.6703C10.1059 25.8203 10.3059 25.9633 10.4869 26.0863C10.5429 26.1243 10.5979 26.1603 10.6519 26.1943C10.8699 26.2803 11.0929 26.3593 11.3159 26.4283C11.3539 26.4323 11.3949 26.4353 11.4369 26.4393C11.6509 26.4573 11.9089 26.4733 12.2209 26.5133C12.7169 26.5753 13.1399 26.6603 13.6019 26.7243C13.9589 26.7733 14.3409 26.8083 14.7729 26.7893C15.0729 26.7753 15.4069 26.7353 15.7389 26.6813C16.2349 26.6023 16.7179 26.4943 17.0569 26.4473C17.1499 26.4343 17.2359 26.4343 17.3209 26.4373C17.3489 26.4393 17.3799 26.4413 17.4109 26.4433C17.4119 26.4433 17.4119 26.4433 17.4129 26.4433C17.4199 26.4433 17.4279 26.4443 17.4349 26.4443C18.2329 26.2413 19.0259 25.9433 19.7959 25.5983C19.8609 25.5633 19.9259 25.5273 19.9899 25.4913C20.3059 25.3173 20.6049 25.1383 20.7869 24.9943C20.9829 24.8393 21.5189 24.5373 22.0579 24.1853C22.4109 23.9553 22.7649 23.7053 23.0369 23.4833C23.1949 23.3553 23.3689 23.2693 23.5479 23.1773C23.7129 23.0923 23.8809 23.0013 24.0349 22.8653C24.1109 22.7983 24.1869 22.7173 24.2639 22.6303C24.3309 22.5563 24.4039 22.4723 24.4759 22.3923C24.5459 22.3153 24.7199 22.1723 24.9139 21.9793C25.0079 21.8863 25.1059 21.7783 25.1909 21.6713C25.2199 21.6323 25.2489 21.5943 25.2769 21.5553C25.5919 21.0403 25.8779 20.5003 26.1019 19.9653C26.1299 19.8403 26.1379 19.7293 26.1279 19.6373C26.1199 19.5703 26.1029 19.5113 26.0839 19.4503C26.0599 19.3643 26.0329 19.2773 26.0239 19.1723C26.0169 19.0893 26.0309 19.0043 26.0629 18.9543C26.0779 18.9323 26.0969 18.9143 26.1129 18.8993C26.1329 18.8823 26.1499 18.8673 26.1569 18.8443C26.1609 18.8273 26.1579 18.8073 26.1529 18.7833C26.1459 18.7443 26.1369 18.6943 26.1539 18.6293C26.2189 18.3853 26.2869 18.1103 26.3319 17.8383C26.3829 17.5393 26.4049 17.2433 26.3949 17.0123C26.3849 16.7493 26.3909 16.3823 26.3469 16.0003C26.3179 15.7343 26.2659 15.4663 26.1979 15.2383C26.1319 15.0143 26.0219 14.7913 25.9039 14.5783C25.7629 14.3223 25.6119 14.0783 25.5169 13.8453C25.4969 13.7983 25.4999 13.7263 25.4999 13.6323C25.5009 13.5673 25.4999 13.4913 25.4919 13.4083C25.3239 13.1243 25.1459 12.8423 24.9589 12.5483C24.9479 12.5413 24.9369 12.5333 24.9249 12.5263C24.6689 12.3503 24.3139 12.1173 24.0769 11.5503C24.0179 11.4063 24.0069 11.2983 23.9969 11.1993C23.9859 11.1013 23.9799 11.0183 23.9289 10.9093C23.8709 10.7853 23.7759 10.6583 23.6709 10.4993C23.5849 10.3703 23.4899 10.2133 23.4199 10.0423C23.3819 9.95134 23.3509 9.85734 23.3329 9.75934C23.3299 9.74334 23.3269 9.72534 23.3229 9.70634C23.2899 9.52734 23.2439 9.26534 23.2409 8.98634C23.0209 8.24434 22.8339 7.48833 22.6519 6.77633C22.3429 5.57133 22.0519 4.54234 21.3329 3.95434C20.9839 3.65334 20.5689 3.35433 20.2459 3.05433C19.9259 2.75633 19.7449 2.47534 19.8019 2.23834C19.8639 2.00634 20.1589 1.82934 20.6659 1.80534C21.1699 1.78334 21.8699 1.93235 22.5209 2.39235C23.6159 3.14235 24.2029 4.38334 24.5599 5.35734C24.5829 5.40834 24.6049 5.46034 24.6259 5.51234C24.7849 5.89434 24.9529 6.22834 25.1199 6.55534C25.1579 6.63034 25.1969 6.70834 25.2339 6.78134Z"
- className="ok-blob-body"
- />
+ <path d={MASCOT_OUTLINE_PATH} className="ok-blob-body" />
{/* Eye group — receives the cursor-tracking translate transform so
every eye variant (open ellipses, happy arcs, sleeping arcs) sits
diff --git a/packages/app/src/components/WorkingAvatar.dom.test.tsx b/packages/app/src/components/WorkingAvatar.dom.test.tsx
new file mode 100644
index 000000000..cc3853ca1
--- /dev/null
+++ b/packages/app/src/components/WorkingAvatar.dom.test.tsx
@@ -0,0 +1,126 @@
+/**
+ * Behaviour only. Size, colour, spacing and which CSS personality layers are
+ * on are tuning knobs — pinning them here just turns a design tweak into a red
+ * test. What is worth guarding is the handful of contracts that break
+ * *silently*: a status swap that stops animating, a shimmer the cascade eats,
+ * and the fallback that keeps a mascot on screen where paths cannot be measured.
+ */
+
+import { cleanup, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { WorkingAvatar } from './WorkingAvatar';
+import { FALLBACK_SKIN_PATH, FALLBACK_STROKE_WIDTH } from './working-avatar-shapes';
+
+afterEach(cleanup);
+
+function renderAvatar(status = 'Sharpening a sentence') {
+ const { container } = render(<WorkingAvatar status={status} testId="working" />);
+ return {
+ container,
+ svg: container.querySelector('svg') as SVGSVGElement,
+ skin: container.querySelector('path') as SVGPathElement,
+ eyes: container.querySelectorAll('.ok-working-eye'),
+ label: screen.getByText(status),
+ };
+}
+
+describe('WorkingAvatar', () => {
+ test('shows the status text it was handed', () => {
+ renderAvatar();
+ expect(screen.getByText('Sharpening a sentence')).toBeTruthy();
+ });
+
+ test('renders the mascot with a face', () => {
+ const { eyes } = renderAvatar();
+ expect(eyes).toHaveLength(2);
+ });
+
+ test('remounts the status line when the text changes so the swap animates', () => {
+ // The line rewrites itself several times a turn as the agent moves between
+ // tools. Without a fresh node the CSS animation would not replay and the
+ // text would hard-cut.
+ // Must re-render the SAME instance: rendering a second tree would make
+ // `not.toBe` trivially true and the assertion would survive deleting `key`.
+ const { container, rerender } = render(<WorkingAvatar status="Reading…" testId="working" />);
+ const first = container.querySelector('.ok-working-status');
+ rerender(<WorkingAvatar status="Drafting…" testId="working" />);
+ const second = container.querySelector('.ok-working-status');
+ expect(second?.textContent).toBe('Drafting…');
+ expect(second).not.toBe(first);
+ });
+
+ test('keeps the swap fade and the shimmer on separate elements', () => {
+ // Both are `animation` shorthands, so on one element the cascade would drop
+ // whichever lost — and the line would silently stop shimmering.
+ const { container } = renderAvatar('Reading…');
+ const swap = container.querySelector('.ok-working-status');
+ expect(swap?.className).not.toContain('shimmer');
+ expect(swap?.querySelector('.shimmer')?.textContent).toBe('Reading…');
+ });
+
+ test('the mascot is hidden from assistive tech — the status text carries it', () => {
+ const { svg, label } = renderAvatar();
+ expect(svg.getAttribute('aria-hidden')).toBe('true');
+ expect(label.getAttribute('aria-hidden')).toBeNull();
+ });
+
+ test('falls back to the static pose where SVG paths cannot be measured', () => {
+ // jsdom implements neither getTotalLength nor getPointAtLength, so the
+ // shape library never builds and the morph loop never starts. The avatar
+ // still has to render a real mascot rather than an empty box.
+ const { skin } = renderAvatar();
+ expect(skin.getAttribute('d')).toBe(FALLBACK_SKIN_PATH);
+ });
+
+ test('announces the working state to screen readers', async () => {
+ // This shipped once as state with no rendered consumer — the string was
+ // computed and thrown away, so the whole announcement was a no-op that
+ // nothing caught. Assert the region exists AND carries text.
+ const { container } = render(<WorkingAvatar status="Thinking…" testId="working" />);
+ const region = container.querySelector('[role="status"]') as HTMLElement;
+ expect(region).toBeTruthy();
+ expect(region.getAttribute('aria-live')).toBe('polite');
+ expect(region.className).toContain('sr-only');
+ await waitFor(() => expect(region.textContent?.trim()).not.toBe(''));
+ });
+
+ test('does not announce the rotating line itself', async () => {
+ // Twelve synonyms on a 3.5-7s beat: piping those into the live region
+ // would narrate cosmetic variation faster than anyone can listen.
+ const { container } = render(<WorkingAvatar status="Thinking…" testId="working" />);
+ const region = container.querySelector('[role="status"]') as HTMLElement;
+ await waitFor(() => expect(region.textContent?.trim()).not.toBe(''));
+ expect(region.textContent).not.toContain('Thinking…');
+ expect(container.querySelector('.ok-working-status')?.closest('[role="status"]')).toBeNull();
+ });
+
+ test('reduced motion pins the mascot to its resting pose', () => {
+ // The guard is three DOM writes that only run for reduced-motion users, so
+ // nothing else would notice if it were deleted. jsdom cannot run the morph
+ // (no path measurement), so this proves the branch fires and writes the
+ // resting values — not the mid-turn transition itself.
+ const mq = vi.spyOn(window, 'matchMedia').mockImplementation(
+ (query: string) =>
+ ({
+ matches: query.includes('prefers-reduced-motion'),
+ media: query,
+ addEventListener: () => {},
+ removeEventListener: () => {},
+ addListener: () => {},
+ removeListener: () => {},
+ onchange: null,
+ dispatchEvent: () => false,
+ }) as unknown as MediaQueryList,
+ );
+ try {
+ const { container } = render(<WorkingAvatar status="Thinking…" testId="working" />);
+ const skin = container.querySelector('path') as SVGPathElement;
+ expect(skin.getAttribute('d')).toBe(FALLBACK_SKIN_PATH);
+ expect(Number(skin.getAttribute('stroke-width'))).toBeCloseTo(FALLBACK_STROKE_WIDTH, 2);
+ // A stale eye offset would leave the face sitting off the resting body.
+ expect(container.querySelector('g > g')?.getAttribute('transform')).toBeNull();
+ } finally {
+ mq.mockRestore();
+ }
+ });
+});
diff --git a/packages/app/src/components/WorkingAvatar.tsx b/packages/app/src/components/WorkingAvatar.tsx
new file mode 100644
index 000000000..e84a3f961
--- /dev/null
+++ b/packages/app/src/components/WorkingAvatar.tsx
@@ -0,0 +1,183 @@
+import { useLingui } from '@lingui/react/macro';
+import { useEffect, useRef, useState } from 'react';
+import { useReducedMotion } from '@/hooks/use-reduced-motion';
+import { cn } from '@/lib/utils';
+import { subscribeToMorphClock } from './working-avatar-driver';
+import {
+ buildMorphedPath,
+ EYE,
+ EYE_OFFSET_Y,
+ FALLBACK_SKIN_PATH,
+ FALLBACK_STROKE_WIDTH,
+ getShapeLibrary,
+ morphFrameAt,
+ POSE_SEQUENCE,
+ toMorphSource,
+} from './working-avatar-shapes';
+
+/** Rendered px. The mark sizes its own slot — there is no reserved column. */
+const MARK_SIZE = 20;
+
+/** Seconds for one full pass through {@link POSE_SEQUENCE}. */
+const DURATION_SECONDS = 8.4;
+
+interface WorkingAvatarProps {
+ /** Already-translated status text. One line, present tense, no percentages.
+ Typed as a string, not a node, because it doubles as the remount key that
+ replays the swap animation when the line changes. */
+ status: string;
+ className?: string;
+ testId?: string;
+}
+
+/**
+ * The agent-thread working state: the mascot changing shape beside a status
+ * line.
+ *
+ * The mascot holds each pose, changes into the next, holds again — the beat is
+ * what makes it read as deliberate effort rather than a spinner, and effort has
+ * to read as effort or a two-minute wait reads as stuck. The squash and squint
+ * layers on top come from CSS; only the shape change is JS-driven, because no
+ * CSS property interpolates between two path outlines.
+ *
+ * The `d` attribute is written imperatively rather than through React state —
+ * re-rendering a 250-number path string at 60fps would be pure waste.
+ */
+export function WorkingAvatar({ status, className, testId }: WorkingAvatarProps) {
+ const { t } = useLingui();
+ const skinRef = useRef<SVGPathElement>(null);
+ const eyesRef = useRef<SVGGElement>(null);
+ const reducedMotion = useReducedMotion();
+
+ useEffect(() => {
+ const skin = skinRef.current;
+ if (skin === null) return;
+ if (reducedMotion) {
+ // Flipping the OS setting mid-turn has to land on the same resting pose a
+ // reduced-motion user sees from mount. React will not re-apply the JSX
+ // defaults — from its side the props never changed — so the last
+ // imperative write would otherwise freeze the mascot half-morphed.
+ skin.setAttribute('d', FALLBACK_SKIN_PATH);
+ skin.setAttribute('stroke-width', String(FALLBACK_STROKE_WIDTH));
+ eyesRef.current?.removeAttribute('transform');
+ return;
+ }
+ // Null on platforms without SVG path measurement (jsdom) — the statically
+ // rendered resting pose is already correct there.
+ const library = getShapeLibrary();
+ if (library === null) return;
+
+ skin.setAttribute('stroke-width', library.strokeWidth.toFixed(2));
+ const source = toMorphSource(library.paths);
+ let lastEyeOffset = Number.NaN;
+ let lastPath = '';
+
+ return subscribeToMorphClock((elapsed) => {
+ const { from, to, t } = morphFrameAt(
+ elapsed,
+ POSE_SEQUENCE.length,
+ DURATION_SECONDS,
+ // Hold each pose once the morph into it finishes.
+ true,
+ );
+ const a = source.numbers[POSE_SEQUENCE[from]];
+ const b = source.numbers[POSE_SEQUENCE[to]];
+ const values = a.map((n, i) => n + (b[i] - n) * t);
+ const path = buildMorphedPath(source.fragments, values);
+ // A held pose produces the same path every frame for the rest of its
+ // segment — 40% of the runtime. Writing `d` repaints the element, so skip
+ // the writes that would change nothing.
+ if (path !== lastPath) {
+ lastPath = path;
+ skin.setAttribute('d', path);
+ }
+
+ const eyes = eyesRef.current;
+ if (eyes === null) return;
+ // Lerped alongside the morph so the face rides with a body that sits high
+ // (the comma), instead of two dots floating off it.
+ const fromOffset = EYE_OFFSET_Y[POSE_SEQUENCE[from]] ?? 0;
+ const toOffset = EYE_OFFSET_Y[POSE_SEQUENCE[to]] ?? 0;
+ const dy = fromOffset + (toOffset - fromOffset) * t;
+ if (dy === lastEyeOffset) return;
+ lastEyeOffset = dy;
+ eyes.setAttribute('transform', `translate(0 ${dy.toFixed(2)})`);
+ });
+ }, [reducedMotion]);
+
+ // Empty on the first paint, then filled — a live region that mounts with its
+ // text already in place is not announced by most screen readers.
+ const [announced, setAnnounced] = useState('');
+ useEffect(() => {
+ setAnnounced(t`The agent is working`);
+ }, [t]);
+
+ return (
+ <div className={cn('ok-working-enter flex items-center gap-2', className)} data-testid={testId}>
+ {/* The visible line rotates through synonyms every few seconds; piping
+ that into a live region would narrate cosmetic variation at a pace no
+ one can listen to. So the announcement is one stable sentence, made
+ once, and the rotating text stays readable on demand but unannounced. */}
+ <span aria-live="polite" className="sr-only" role="status">
+ {announced}
+ </span>
+ {/* Sized to the mark itself, not to a reserved avatar column — this
+ transcript has no avatar gutter (agent replies are full-width prose),
+ so a fixed column would open a hole beside the smaller poses.
+
+ Fainter than the status text beside it. An opacity modifier rather
+ than a lighter colour token, because `--muted-foreground` is
+ dark-on-light in one theme and light-on-dark in the other — a fixed
+ lighter value would drop contrast in one and raise it in the other. */}
+ <span className="grid shrink-0 place-items-center text-muted-foreground/80">
+ <svg
+ width={MARK_SIZE}
+ height={MARK_SIZE}
+ viewBox="0 0 30 30"
+ xmlns="http://www.w3.org/2000/svg"
+ aria-hidden="true"
+ // Never scale this with CSS `transform` — the size constant is what
+ // keeps the stroke weight honest.
+ className="ok-working-pop ok-working-squint block shrink-0 overflow-visible"
+ >
+ <g className="ok-working-group">
+ <path
+ ref={skinRef}
+ d={FALLBACK_SKIN_PATH}
+ fill="none"
+ stroke="currentColor"
+ strokeWidth={FALLBACK_STROKE_WIDTH}
+ strokeLinejoin="round"
+ strokeLinecap="round"
+ />
+ <g ref={eyesRef}>
+ <ellipse
+ className="ok-working-eye"
+ cx={EYE.leftCx}
+ cy={EYE.cy}
+ rx={EYE.rx}
+ ry={EYE.ry}
+ fill="currentColor"
+ />
+ <ellipse
+ className="ok-working-eye"
+ cx={EYE.rightCx}
+ cy={EYE.cy}
+ rx={EYE.rx}
+ ry={EYE.ry}
+ fill="currentColor"
+ />
+ </g>
+ </g>
+ </svg>
+ </span>
+ {/* Keyed on the text so a changed line remounts and replays the swap
+ animation. The fade lives on the outer span and the shimmer on the
+ inner one because both are `animation` shorthands — on one element
+ the cascade would drop whichever lost. */}
+ <span key={status} className="ok-working-status text-sm">
+ <span className="shimmer">{status}</span>
+ </span>
+ </div>
+ );
+}
diff --git a/packages/app/src/components/acp/ThreadView.tsx b/packages/app/src/components/acp/ThreadView.tsx
index e3c0216fb..ca72f06cf 100644
--- a/packages/app/src/components/acp/ThreadView.tsx
+++ b/packages/app/src/components/acp/ThreadView.tsx
@@ -73,6 +73,7 @@ import { Skeleton } from '@/components/ui/skeleton';
import { Switch } from '@/components/ui/switch';
import { Textarea } from '@/components/ui/textarea';
import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
+import { WorkingAvatar } from '@/components/WorkingAvatar';
import { useDocumentContext } from '@/editor/DocumentContext';
import {
agentSettingsKey,
@@ -105,6 +106,7 @@ import { latestFollowTarget, loadFollowFilePref, saveFollowFilePref } from './fo
import { appendPresenceWrite, latestAgentWrite, type PresenceWrite } from './presence-follow';
import { RegisteredAgentIcon } from './RegisteredAgentIcon';
import { transcriptItemId } from './transcript-item-id';
+import { activeToolKind, useThinkingLine, workingStatusText } from './working-status';
/**
* Stop sends ACP `session/cancel` — a courtesy the agent may ignore while it
@@ -172,6 +174,8 @@ export function ThreadView({ info }: { info: ThreadInfo }): ReactNode {
// An archived transcript can end mid-turn (server crash while streaming) —
// never let the fold's stale turn state drive the running UI.
const turnActive = model?.turnActive === true && !archived;
+ // Only consulted when no tool call is in flight — see `working-status.ts`.
+ const thinkingLine = useThinkingLine(turnActive);
const [resumePending, setResumePending] = useState(false);
const [resumeError, setResumeError] = useState<ThreadResumeError | null>(null);
const canPrompt = archived ? !resumePending : status === 'ready' && !turnActive;
@@ -410,13 +414,11 @@ export function ThreadView({ info }: { info: ThreadInfo }): ReactNode {
<span>{t`Waiting for your approval`}</span>
</div>
) : (
- <div
- className="flex items-center gap-2 px-1 py-1 text-muted-foreground text-sm shimmer"
- data-testid="agent-thread-working"
- >
- <Loader2 className="size-3.5 animate-spin" aria-hidden="true" />
- <span>{t`Working…`}</span>
- </div>
+ <WorkingAvatar
+ status={workingStatusText(activeToolKind(model.items), thinkingLine)}
+ className="px-1 py-1"
+ testId="agent-thread-working"
+ />
)
) : status === 'installing' || status === 'spawning' ? (
// A resume respawning its agent: the optimistic message echo is
diff --git a/packages/app/src/components/acp/ThreadView.working-loop.dom.test.tsx b/packages/app/src/components/acp/ThreadView.working-loop.dom.test.tsx
new file mode 100644
index 000000000..a338185b6
--- /dev/null
+++ b/packages/app/src/components/acp/ThreadView.working-loop.dom.test.tsx
@@ -0,0 +1,139 @@
+/**
+ * Guards the live-turn working row against a runaway render loop
+ * ("Maximum update depth exceeded"). The row is the only part of the
+ * transcript that updates on a timer rather than on an event, so a cascade
+ * here would be invisible to every other ThreadView test.
+ */
+
+import type { ThreadInfo } from '@inkeep/open-knowledge-core/acp/thread-protocol';
+import { act, cleanup, render as rtlRender } from '@testing-library/react';
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { TooltipProvider } from '@/components/ui/tooltip';
+import type { RenderedItem, ThreadRenderModel } from '@/lib/acp/thread-event-model';
+
+const render = (ui: Parameters<typeof rtlRender>[0]) => rtlRender(ui, { wrapper: TooltipProvider });
+
+let model: ThreadRenderModel | null = null;
+
+vi.doMock('@/lib/acp/thread-client', () => ({
+ getAgentThreadClient: () => ({
+ respondPermission: () => {},
+ respondRuntimeConsent: () => {},
+ cancel: () => {},
+ prompt: () => {},
+ editQueued: () => {},
+ removeQueued: () => {},
+ setMode: () => {},
+ setConfigOption: () => {},
+ closeThread: () => {},
+ createThread: async () => {
+ throw new Error('unused');
+ },
+ resumeThread: async () => {
+ throw new Error('unused');
+ },
+ }),
+ ThreadResumeError: class ThreadResumeError extends Error {
+ readonly code: string;
+ constructor(code: string, message: string) {
+ super(message);
+ this.code = code;
+ }
+ },
+ useAgentThread: () => ({ info: undefined, events: [], lastSeq: 5 }),
+ useAgentThreadModel: () => model,
+}));
+
+vi.doMock('@/editor/DocumentContext', () => ({
+ useDocumentContext: () => ({ systemProvider: null }),
+}));
+vi.doMock('@/lib/use-workspace', () => ({ useWorkspace: () => null }));
+vi.doMock('@/components/acp/AgentMarkdown', () => ({
+ AgentMarkdown: ({ text }: { text: string }) => <div>{text}</div>,
+}));
+// The comments store is deliberately NOT mocked here. It is the one dependency
+// in this component with a documented history of the runaway-update failure
+// (an unstable `useSyncExternalStore` snapshot — see comments/store.ts), and
+// every other ThreadView test stubs it out, so nothing else covers it.
+vi.doMock('@/comments/queue-attachment', () => ({ prepareQueuedComments: async () => [] }));
+
+const { ThreadView } = await import('./ThreadView');
+
+function info(): ThreadInfo {
+ return {
+ threadId: 'thread-1',
+ agent: { id: 'claude', name: 'Claude Agent', source: 'registry' },
+ title: 'Test thread',
+ status: 'running',
+ createdAt: 1,
+ lastActivityAt: 2,
+ lastSeq: 5,
+ archived: false,
+ };
+}
+
+const message: RenderedItem = {
+ kind: 'message',
+ role: 'agent',
+ text: 'hello',
+ messageId: 'm1',
+};
+
+afterEach(() => {
+ cleanup();
+ model = null;
+});
+
+describe('live-turn working row', () => {
+ test('does not cascade as the idle line rotates', () => {
+ // The rotation reschedules itself after every tick, so a cascade here would
+ // blow React's nested-update limit and throw rather than settle. Several
+ // minutes of turn are simulated to cover many rotations.
+ vi.useFakeTimers();
+ try {
+ model = {
+ items: [message],
+ plan: [],
+ turnActive: true,
+ tokenUsage: null,
+ terminals: {},
+ permissionsByToolCall: {},
+ };
+ const { getByTestId } = render(<ThreadView info={info()} />);
+ expect(getByTestId('agent-thread-working')).toBeTruthy();
+
+ for (const ms of [11_000, 21_000, 61_000, 60_000, 120_000]) {
+ act(() => {
+ vi.advanceTimersByTime(ms);
+ });
+ }
+ expect(getByTestId('agent-thread-working')).toBeTruthy();
+ } finally {
+ vi.useRealTimers();
+ }
+ });
+
+ test('does not cascade when the turn ends mid-rotation', () => {
+ vi.useFakeTimers();
+ try {
+ model = {
+ items: [message],
+ plan: [],
+ turnActive: true,
+ tokenUsage: null,
+ terminals: {},
+ permissionsByToolCall: {},
+ };
+ const { rerender, queryByTestId } = render(<ThreadView info={info()} />);
+ act(() => {
+ vi.advanceTimersByTime(95_000);
+ });
+
+ model = { ...model, turnActive: false };
+ rerender(<ThreadView info={info()} />);
+ expect(queryByTestId('agent-thread-working')).toBeNull();
+ } finally {
+ vi.useRealTimers();
+ }
+ });
+});
diff --git a/packages/app/src/components/acp/working-status-loop.dom.test.tsx b/packages/app/src/components/acp/working-status-loop.dom.test.tsx
new file mode 100644
index 000000000..113f4dee9
--- /dev/null
+++ b/packages/app/src/components/acp/working-status-loop.dom.test.tsx
@@ -0,0 +1,155 @@
+import { act, cleanup, render } from '@testing-library/react';
+import { useState } from 'react';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { THINKING_HOLD_MS, useThinkingLine } from './working-status';
+
+afterEach(cleanup);
+
+/**
+ * The idle line rotates on a self-rescheduling timer, which is the shape that
+ * most easily turns into a runaway update loop ("Maximum update depth
+ * exceeded"). Render counts are asserted so a cascade shows up as an unbounded
+ * count rather than a thrown React error a test could swallow.
+ */
+function Harness({ turnActive, onRender }: { turnActive: boolean; onRender: () => void }) {
+ const line = useThinkingLine(turnActive);
+ onRender();
+ return <span data-testid="line">{line}</span>;
+}
+
+/** Past the longest possible hold, so exactly one rotation is guaranteed. */
+const PAST_ONE_HOLD = THINKING_HOLD_MS.max + 1;
+
+describe('useThinkingLine', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ });
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ test('settles in a bounded number of renders when the turn opens', () => {
+ const onRender = vi.fn();
+ render(<Harness turnActive onRender={onRender} />);
+ expect(onRender.mock.calls.length).toBeLessThan(5);
+ });
+
+ test('keeps rotating for as long as the turn runs', () => {
+ const onRender = vi.fn();
+ const { getByTestId } = render(<Harness turnActive onRender={onRender} />);
+ const seen = new Set([getByTestId('line').textContent]);
+ for (let i = 0; i < 6; i++) {
+ act(() => {
+ vi.advanceTimersByTime(PAST_ONE_HOLD);
+ });
+ seen.add(getByTestId('line').textContent);
+ }
+ // The whole point is movement — a timer that fired once and stopped, or one
+ // that kept re-picking the same line, would leave a single entry.
+ expect(seen.size).toBeGreaterThan(1);
+ });
+
+ test('changes line on every rotation rather than sometimes standing still', () => {
+ // Pinning the random source makes each hold exactly the minimum, so one
+ // advance fires exactly one rotation. Without it, advancing past the
+ // maximum hold can fire two — and A→B→A would look like a stall that
+ // isn't one.
+ vi.spyOn(Math, 'random').mockReturnValue(0);
+ try {
+ const { getByTestId } = render(<Harness turnActive onRender={vi.fn()} />);
+ let previous = getByTestId('line').textContent;
+ for (let i = 0; i < 12; i++) {
+ act(() => {
+ vi.advanceTimersByTime(THINKING_HOLD_MS.min + 1);
+ });
+ const current = getByTestId('line').textContent;
+ expect(current).not.toBe(previous);
+ previous = current;
+ }
+ } finally {
+ vi.mocked(Math.random).mockRestore();
+ }
+ });
+
+ test('draws a fresh line when a turn opens', () => {
+ // Without a per-turn redraw the second turn resumes where the first
+ // stopped and opens on the word already on screen.
+ //
+ // Draw order is load-bearing here: mounting consumes three samples (the
+ // lazy initial index, the effect's redraw, the first hold), and each later
+ // turn-open consumes two (redraw, hold). Only samples 1 and 3 pick an
+ // index, so those are the two that have to differ.
+ const samples = [0.5, 0, 0.5, 0.5];
+ let draw = 0;
+ vi.spyOn(Math, 'random').mockImplementation(() => samples[draw++] ?? 0.5);
+ try {
+ const { rerender, getByTestId } = render(<Harness turnActive onRender={vi.fn()} />);
+ const first = getByTestId('line').textContent;
+ rerender(<Harness turnActive={false} onRender={vi.fn()} />);
+ rerender(<Harness turnActive onRender={vi.fn()} />);
+ expect(getByTestId('line').textContent).not.toBe(first);
+ } finally {
+ vi.mocked(Math.random).mockRestore();
+ }
+ });
+
+ test('streamed output does not advance the line — only the clock does', () => {
+ // A parent re-rendering (new message chunks arriving) must not reselect,
+ // or the line would flicker faster than it can be read.
+ const { rerender, getByTestId } = render(<Harness turnActive onRender={vi.fn()} />);
+ const before = getByTestId('line').textContent;
+ for (let i = 0; i < 20; i++) {
+ rerender(<Harness turnActive onRender={vi.fn()} />);
+ }
+ expect(getByTestId('line').textContent).toBe(before);
+ });
+
+ test('schedules nothing while no turn is running', () => {
+ const onRender = vi.fn();
+ render(<Harness turnActive={false} onRender={onRender} />);
+ onRender.mockClear();
+ act(() => {
+ vi.advanceTimersByTime(PAST_ONE_HOLD * 10);
+ });
+ expect(onRender).not.toHaveBeenCalled();
+ });
+
+ test('a parent that re-renders constantly does not compound', () => {
+ const onRender = vi.fn();
+ const { rerender } = render(<Harness turnActive onRender={onRender} />);
+ for (let i = 0; i < 50; i++) {
+ rerender(<Harness turnActive onRender={onRender} />);
+ }
+ // 50 parent renders plus a handful of state-driven ones, nowhere near a loop.
+ expect(onRender.mock.calls.length).toBeLessThan(70);
+ });
+
+ test('rapid turnActive flapping settles instead of compounding', () => {
+ const onRender = vi.fn();
+ const { rerender } = render(<Harness turnActive onRender={onRender} />);
+ for (let i = 0; i < 25; i++) {
+ rerender(<Harness turnActive={i % 2 === 0} onRender={onRender} />);
+ }
+ expect(onRender.mock.calls.length).toBeLessThan(80);
+ });
+});
+
+/** A parent holding state that the hook's consumer feeds back into — the shape
+ that actually produces the runaway loop if the hook is not stable. */
+function FeedbackHarness({ onRender }: { onRender: () => void }) {
+ const [turns, setTurns] = useState(0);
+ const line = useThinkingLine(true);
+ onRender();
+ // Deliberately hostile: a parent that reacts to the line by updating state.
+ if (turns === 0) setTurns(1);
+ return <span data-testid="line">{`${line}:${turns}`}</span>;
+}
+
+describe('useThinkingLine under a state-updating consumer', () => {
+ test('a consumer reacting to the line still converges', () => {
+ const onRender = vi.fn();
+ const { getByTestId } = render(<FeedbackHarness onRender={onRender} />);
+ expect(getByTestId('line').textContent).toMatch(/^\d+:1$/);
+ expect(onRender.mock.calls.length).toBeLessThan(10);
+ });
+});
diff --git a/packages/app/src/components/acp/working-status.test.ts b/packages/app/src/components/acp/working-status.test.ts
new file mode 100644
index 000000000..d572d0295
--- /dev/null
+++ b/packages/app/src/components/acp/working-status.test.ts
@@ -0,0 +1,171 @@
+import { describe, expect, test } from 'vitest';
+import type { RenderedItem, RenderedToolCall } from '@/lib/acp/thread-event-model';
+import {
+ activeToolKind,
+ nextThinkingIndex,
+ THINKING_HOLD_MS,
+ thinkingHoldMs,
+ thinkingStatusLines,
+ workingStatusText,
+} from './working-status';
+
+function toolCall(toolKind: string, status: RenderedToolCall['status']): RenderedItem {
+ return {
+ kind: 'tool_call',
+ toolCallId: `${toolKind}-${status}`,
+ title: toolKind,
+ toolKind,
+ status,
+ diffs: [],
+ terminalIds: [],
+ content: [],
+ locations: [],
+ rawInput: null,
+ };
+}
+
+const message: RenderedItem = {
+ kind: 'message',
+ role: 'agent',
+ text: 'hello',
+ messageId: 'm1',
+};
+
+describe('activeToolKind', () => {
+ test('finds nothing in an empty or message-only transcript', () => {
+ expect(activeToolKind([])).toBeNull();
+ expect(activeToolKind([message])).toBeNull();
+ });
+
+ test('reports the kind of a call that is running', () => {
+ expect(activeToolKind([toolCall('read', 'in_progress')])).toBe('read');
+ });
+
+ test('counts an accepted-but-not-started call as in flight', () => {
+ // It draws a spinner for the same reason: from the reader's side it is
+ // indistinguishable from work already underway.
+ expect(activeToolKind([toolCall('search', 'pending')])).toBe('search');
+ });
+
+ test('ignores calls that already settled', () => {
+ expect(activeToolKind([toolCall('read', 'completed')])).toBeNull();
+ expect(activeToolKind([toolCall('edit', 'failed')])).toBeNull();
+ });
+
+ test('speaks for the most recent live call, not the first', () => {
+ const items = [
+ toolCall('read', 'completed'),
+ toolCall('search', 'in_progress'),
+ toolCall('edit', 'in_progress'),
+ ];
+ expect(activeToolKind(items)).toBe('edit');
+ });
+
+ test('looks past trailing messages to a still-running call', () => {
+ expect(activeToolKind([toolCall('execute', 'in_progress'), message])).toBe('execute');
+ });
+});
+
+describe('thinking rotation', () => {
+ test('always lands on a different line', () => {
+ // A rotation that repeats the current phrase reads as a freeze. Sweeping
+ // the whole 0..1 sample range proves no draw can produce one.
+ const count = thinkingStatusLines().length;
+ for (let current = 0; current < count; current++) {
+ for (let step = 0; step < 40; step++) {
+ const next = nextThinkingIndex(current, count, step / 40);
+ expect(next).not.toBe(current);
+ expect(next).toBeGreaterThanOrEqual(0);
+ expect(next).toBeLessThan(count);
+ }
+ }
+ });
+
+ test('can reach every other line from any starting point', () => {
+ // Offsetting rather than re-rolling must not make some lines unreachable.
+ const count = thinkingStatusLines().length;
+ for (let current = 0; current < count; current++) {
+ const reached = new Set<number>();
+ for (let step = 0; step < 200; step++) {
+ reached.add(nextThinkingIndex(current, count, step / 200));
+ }
+ expect(reached.size).toBe(count - 1);
+ }
+ });
+
+ test('degenerates safely to a single line', () => {
+ expect(nextThinkingIndex(0, 1, 0.99)).toBe(0);
+ });
+
+ test('holds within the configured range so the beat never sounds metronomic', () => {
+ expect(thinkingHoldMs(0)).toBe(THINKING_HOLD_MS.min);
+ expect(thinkingHoldMs(1)).toBe(THINKING_HOLD_MS.max);
+ expect(thinkingHoldMs(0.5)).toBeGreaterThan(THINKING_HOLD_MS.min);
+ expect(thinkingHoldMs(0.5)).toBeLessThan(THINKING_HOLD_MS.max);
+ });
+});
+
+describe('thinkingStatusLines', () => {
+ test('offers several distinct, non-empty phrases', () => {
+ const lines = thinkingStatusLines();
+ expect(lines.length).toBeGreaterThan(1);
+ for (const line of lines) expect(line.trim()).not.toBe('');
+ expect(new Set(lines).size).toBe(lines.length);
+ });
+});
+
+/**
+ * These pin the routing, not the wording — the copy is edited often and
+ * freezing the exact strings here would make every wording change a test
+ * change. What must hold is which source wins, that every branch says
+ * something, and that the lines stay distinct enough for a change to register.
+ */
+describe('workingStatusText', () => {
+ const KINDS = ['read', 'search', 'fetch', 'edit', 'delete', 'execute', 'think'];
+ const LINE_COUNT = thinkingStatusLines().length;
+ const EVERY_LINE = Array.from({ length: LINE_COUNT }, (_, i) => i);
+
+ test('gives every known tool kind its own line', () => {
+ // A repeated line would make a tool change look like nothing happened.
+ const lines = KINDS.map((kind) => workingStatusText(kind, 0));
+ for (const line of lines) expect(line.trim()).not.toBe('');
+ expect(new Set(lines).size).toBe(KINDS.length);
+ });
+
+ test('a live tool call outranks the idle rotation', () => {
+ // The line changing as the agent moves between tools is itself the
+ // reassurance — the idle vocabulary is for when nothing is moving.
+ for (const line of EVERY_LINE) {
+ expect(workingStatusText('read', line)).toBe(workingStatusText('read', 0));
+ }
+ });
+
+ test('walks the whole idle vocabulary as the rotation advances', () => {
+ const shown = EVERY_LINE.map((line) => workingStatusText(null, line));
+ expect(new Set(shown).size).toBe(LINE_COUNT);
+ });
+
+ test('renders a line for any index the rotation could hand it', () => {
+ // The index comes from a hook that could outlive a shortened array, and a
+ // blank status line is worse than a stale one.
+ for (const index of [-1, 0, LINE_COUNT, LINE_COUNT * 3 + 1, 9_999]) {
+ expect(workingStatusText(null, index).trim()).not.toBe('');
+ }
+ });
+
+ test('falls back to the idle vocabulary for a tool kind it has no line for', () => {
+ // Adapters are free to report kinds we have never seen; inventing a
+ // description for one would be a lie.
+ expect(workingStatusText('teleport', 2)).toBe(workingStatusText(null, 2));
+ });
+
+ test('never promises a time', () => {
+ // The one wording rule worth enforcing: we do not know how long the turn
+ // will take, and guessing is the fastest way to lose the reader's trust.
+ for (const line of EVERY_LINE) {
+ for (const kind of [null, ...KINDS]) {
+ expect(workingStatusText(kind, line)).not.toMatch(/almost|nearly|second|soon|%/i);
+ }
+ }
+ });
+});
diff --git a/packages/app/src/components/acp/working-status.ts b/packages/app/src/components/acp/working-status.ts
new file mode 100644
index 000000000..f699e436a
--- /dev/null
+++ b/packages/app/src/components/acp/working-status.ts
@@ -0,0 +1,146 @@
+/**
+ * The status line beside the working avatar.
+ *
+ * Two sources, and which one speaks is deliberate:
+ *
+ * - **A tool is in flight** → say what it is doing. The line then *changes* as
+ * the agent moves between reading, searching and editing, and that movement
+ * is itself the reassurance that the turn is alive.
+ * - **Nothing in flight** (a long think, or a hang) → the line would otherwise
+ * sit frozen for minutes, which is exactly when a wait starts reading as
+ * stuck. So it drifts through a pool of phrases instead, in no fixed order
+ * and on a randomized beat, so the row keeps moving without ever implying
+ * progress it cannot see.
+ *
+ * Copy rules: present tense, no percentages, and never a time estimate — we
+ * don't know one, and guessing is the fastest way to lose the reader's trust.
+ */
+
+import { t } from '@lingui/core/macro';
+import { useEffect, useState } from 'react';
+import type { RenderedItem } from '@/lib/acp/thread-event-model';
+
+/**
+ * The most recent tool call the agent has open, or null when it is between
+ * calls. `pending` (accepted, not yet started) counts as in flight for the
+ * same reason it draws a spinner — from the reader's side it is indistinguishable
+ * from work already underway.
+ */
+export function activeToolKind(items: readonly RenderedItem[]): string | null {
+ for (let i = items.length - 1; i >= 0; i--) {
+ const item = items[i];
+ if (item.kind !== 'tool_call') continue;
+ if (item.status === 'in_progress' || item.status === 'pending') return item.toolKind;
+ }
+ return null;
+}
+
+/**
+ * The idle vocabulary, drawn from at random. Every line has to work at any
+ * moment in a turn — a phrase that only makes sense late ("still going
+ * strong") reads as nonsense four seconds in, now that order is not
+ * guaranteed. Built inside a function so the macro resolves against the
+ * active locale at call time rather than at module load.
+ */
+export function thinkingStatusLines(): string[] {
+ return [
+ t`Thinking…`,
+ t`Mulling…`,
+ t`Pondering…`,
+ t`Percolating…`,
+ t`Puzzling…`,
+ t`Contemplating…`,
+ t`Digging…`,
+ t`Musing…`,
+ t`Ruminating…`,
+ t`Reflecting…`,
+ t`Sifting…`,
+ t`Sorting…`,
+ ];
+}
+
+/** How long a line holds before the next one, in ms. Randomized within this
+ range so the rotation never settles into an audible metronome. */
+export const THINKING_HOLD_MS = { min: 3_500, max: 7_000 } as const;
+
+/**
+ * Pick an index other than `current`, uniformly over the remaining lines.
+ * Offsetting by 1..count-1 rather than re-rolling guarantees the line actually
+ * changes — a "rotation" that lands on the same phrase reads as a freeze.
+ * `random` is a 0..1 sample, passed in so callers can make this deterministic.
+ */
+export function nextThinkingIndex(current: number, count: number, random: number): number {
+ if (count <= 1) return 0;
+ return (current + 1 + Math.floor(random * (count - 1))) % count;
+}
+
+export function thinkingHoldMs(random: number): number {
+ return THINKING_HOLD_MS.min + random * (THINKING_HOLD_MS.max - THINKING_HOLD_MS.min);
+}
+
+/**
+ * The index of the idle line currently showing.
+ *
+ * It moves on its own clock and nothing else: each turn opens on a freshly
+ * drawn line, then a different one lands after every randomized hold. Streamed
+ * output does NOT advance it — a line that changed on every chunk would flicker
+ * too fast to read, and one that changed per message would make the phrasing
+ * look like a report on the message rather than on the wait.
+ *
+ * Only runs while a turn is live — an idle thread schedules nothing.
+ */
+export function useThinkingLine(turnActive: boolean): number {
+ const [index, setIndex] = useState(() =>
+ Math.floor(Math.random() * thinkingStatusLines().length),
+ );
+ useEffect(() => {
+ if (!turnActive) return;
+ // Redrawn per turn, not just per mount: without this a second turn resumes
+ // wherever the last one stopped and opens on the word already on screen.
+ setIndex(Math.floor(Math.random() * thinkingStatusLines().length));
+ let timer: ReturnType<typeof setTimeout>;
+ const schedule = (): void => {
+ timer = setTimeout(() => {
+ setIndex((current) =>
+ nextThinkingIndex(current, thinkingStatusLines().length, Math.random()),
+ );
+ schedule();
+ }, thinkingHoldMs(Math.random()));
+ };
+ schedule();
+ return () => clearTimeout(timer);
+ }, [turnActive]);
+ return index;
+}
+
+/** Tool kinds come from the ACP adapter; anything unrecognized falls through
+ to the idle vocabulary rather than inventing a description. */
+function contextualStatus(toolKind: string | null): string | null {
+ switch (toolKind) {
+ case 'read':
+ return t`Reading…`;
+ case 'search':
+ return t`Having a look around…`;
+ case 'fetch':
+ return t`Retrieving…`;
+ case 'edit':
+ return t`Drafting…`;
+ case 'delete':
+ return t`Tidying up…`;
+ case 'execute':
+ return t`Trying it out…`;
+ case 'think':
+ return t`Turning it over…`;
+ default:
+ return null;
+ }
+}
+
+export function workingStatusText(toolKind: string | null, thinkingLine: number): string {
+ const contextual = contextualStatus(toolKind);
+ if (contextual !== null) return contextual;
+ const lines = thinkingStatusLines();
+ // Wrapped rather than bounds-checked so any index still yields a line — the
+ // caller is a hook whose count could drift from this array's if one is cut.
+ return lines[((thinkingLine % lines.length) + lines.length) % lines.length];
+}
diff --git a/packages/app/src/components/mascot-outline.ts b/packages/app/src/components/mascot-outline.ts
new file mode 100644
index 000000000..3aa9d7876
--- /dev/null
+++ b/packages/app/src/components/mascot-outline.ts
@@ -0,0 +1,11 @@
+/**
+ * The traced OK mascot outline, as filled path data.
+ *
+ * Shared rather than duplicated: {@link OkBlob} renders it directly as a
+ * filled mark, and the working avatar's shape library reduces it to a
+ * centreline plus the pen weight that drew it. Retracing the mark is a single
+ * edit here — two copies would let the app mascot and the thread mascot drift
+ * into different shapes with nothing to notice.
+ */
+export const MASCOT_OUTLINE_PATH =
+ 'M25.2339 6.78134C25.5199 7.35734 25.8179 8.47234 26.0179 9.07834C26.0189 9.08234 26.0209 9.08634 26.0219 9.09134C26.0229 9.09534 26.0249 9.10034 26.0259 9.10434C26.0539 9.19734 26.0949 9.29533 26.1519 9.41633C26.2919 9.71133 26.5269 10.1173 27.1299 11.1683C27.3259 11.4643 27.5209 11.7693 27.7119 12.0903C29.9739 15.1623 29.3259 20.1913 27.0469 22.9153C26.7779 23.2953 26.4869 23.6043 26.1889 23.8863C26.1519 23.9253 26.1129 23.9643 26.0729 24.0033C25.3159 24.7543 24.2949 25.4673 23.6129 25.8323C22.7469 26.2983 22.1349 26.5483 21.6299 26.7463C20.3649 27.3063 19.0609 27.7733 17.6569 28.0423C15.9649 28.3513 14.1939 28.4433 12.4569 28.1373C11.4779 27.9663 10.5119 27.6663 9.60891 27.2493C8.77491 26.8663 7.99192 26.3853 7.26992 25.8403C6.83592 25.5393 6.43893 25.2343 6.08093 24.9383C5.57893 24.5223 5.15993 24.1263 4.83493 23.7793C4.04993 22.9443 3.31593 21.8893 2.80893 21.0953C2.72593 20.9663 2.64792 20.8433 2.57592 20.7293C2.56192 20.7093 2.54793 20.6893 2.53393 20.6703C2.08593 20.0263 1.71892 19.3293 1.43792 18.5993C1.42892 18.5453 1.42093 18.4903 1.41293 18.4353C1.32093 17.7443 1.08292 16.9423 1.01092 15.6333C0.984921 15.0653 0.998928 14.4013 1.12393 13.6353C1.20693 13.1413 1.31993 12.9023 1.40893 12.7113C1.43593 12.6543 1.46193 12.6023 1.48593 12.5483C1.56793 12.3653 1.59392 12.1563 1.63592 11.9083C1.68992 11.5883 1.76992 11.1943 2.04592 10.7553C2.94392 9.37934 3.36792 8.81934 3.66592 8.33934C3.75592 8.20334 3.84292 8.08134 3.94192 7.96634C4.21592 7.64634 4.67693 7.29534 5.10293 7.05734C5.16693 7.02234 5.23093 6.98834 5.29193 6.95534C5.62993 6.77834 6.22592 6.30135 6.66992 5.92035C6.83692 5.77635 7.08193 5.60735 7.37393 5.40935C7.67393 5.20535 8.02593 4.96934 8.39193 4.70234C9.32093 4.02634 9.84091 3.69134 10.2599 3.42334C10.3799 3.34734 10.4919 3.27734 10.6049 3.20834C10.9609 2.98834 11.4149 2.73034 11.8869 2.48634C12.4519 2.19334 13.0469 1.92133 13.5089 1.72233C14.7399 1.30233 16.0539 1.01333 17.4169 1.00033C18.1169 0.991333 18.7939 1.16534 19.2389 1.43034C19.6869 1.69534 19.8689 2.00335 19.8039 2.23935C19.7379 2.47835 19.4399 2.63634 19.0109 2.74734C18.5789 2.85634 18.0469 2.92035 17.4889 2.96135C16.3639 3.04235 15.2399 3.36435 14.1499 3.80835C12.8199 4.35135 11.5379 5.07133 10.2719 5.84733C9.38691 6.39133 8.51192 6.97334 7.63592 7.56834C7.54492 7.63034 7.45492 7.69135 7.36492 7.75235C6.97392 8.06635 6.58293 8.38134 6.22293 8.66334C5.97893 8.85734 5.76793 9.04834 5.59393 9.21434C5.26893 9.52334 5.02393 9.74334 4.81893 9.93934C4.67793 10.0753 4.55793 10.2013 4.45593 10.3443C4.40093 10.4213 4.32992 10.5273 4.24792 10.6593C3.90492 11.1933 3.44493 12.1693 3.15393 13.1173C3.01893 13.5363 2.87991 14.0343 2.79391 14.5253C2.66591 15.2253 2.65594 15.9053 2.71994 16.2373C2.82794 16.8193 2.95593 17.4833 3.14093 18.0553C3.31293 18.6003 3.52991 19.0583 3.70791 19.2823C3.81591 19.4183 3.90394 19.5473 3.99594 19.6913C4.09394 19.8413 4.19191 20.0073 4.31091 20.2033C4.47891 20.4803 4.68592 20.8163 5.00192 21.2493C5.36492 21.7463 5.61793 22.1043 5.83493 22.4023C6.14493 22.8243 6.38591 23.1343 6.83691 23.5033C7.33891 23.9113 7.86593 24.3113 8.26693 24.6393C8.44893 24.7883 8.66993 24.9443 8.90493 25.0963C9.21593 25.2963 9.55192 25.4893 9.85592 25.6703C10.1059 25.8203 10.3059 25.9633 10.4869 26.0863C10.5429 26.1243 10.5979 26.1603 10.6519 26.1943C10.8699 26.2803 11.0929 26.3593 11.3159 26.4283C11.3539 26.4323 11.3949 26.4353 11.4369 26.4393C11.6509 26.4573 11.9089 26.4733 12.2209 26.5133C12.7169 26.5753 13.1399 26.6603 13.6019 26.7243C13.9589 26.7733 14.3409 26.8083 14.7729 26.7893C15.0729 26.7753 15.4069 26.7353 15.7389 26.6813C16.2349 26.6023 16.7179 26.4943 17.0569 26.4473C17.1499 26.4343 17.2359 26.4343 17.3209 26.4373C17.3489 26.4393 17.3799 26.4413 17.4109 26.4433C17.4119 26.4433 17.4119 26.4433 17.4129 26.4433C17.4199 26.4433 17.4279 26.4443 17.4349 26.4443C18.2329 26.2413 19.0259 25.9433 19.7959 25.5983C19.8609 25.5633 19.9259 25.5273 19.9899 25.4913C20.3059 25.3173 20.6049 25.1383 20.7869 24.9943C20.9829 24.8393 21.5189 24.5373 22.0579 24.1853C22.4109 23.9553 22.7649 23.7053 23.0369 23.4833C23.1949 23.3553 23.3689 23.2693 23.5479 23.1773C23.7129 23.0923 23.8809 23.0013 24.0349 22.8653C24.1109 22.7983 24.1869 22.7173 24.2639 22.6303C24.3309 22.5563 24.4039 22.4723 24.4759 22.3923C24.5459 22.3153 24.7199 22.1723 24.9139 21.9793C25.0079 21.8863 25.1059 21.7783 25.1909 21.6713C25.2199 21.6323 25.2489 21.5943 25.2769 21.5553C25.5919 21.0403 25.8779 20.5003 26.1019 19.9653C26.1299 19.8403 26.1379 19.7293 26.1279 19.6373C26.1199 19.5703 26.1029 19.5113 26.0839 19.4503C26.0599 19.3643 26.0329 19.2773 26.0239 19.1723C26.0169 19.0893 26.0309 19.0043 26.0629 18.9543C26.0779 18.9323 26.0969 18.9143 26.1129 18.8993C26.1329 18.8823 26.1499 18.8673 26.1569 18.8443C26.1609 18.8273 26.1579 18.8073 26.1529 18.7833C26.1459 18.7443 26.1369 18.6943 26.1539 18.6293C26.2189 18.3853 26.2869 18.1103 26.3319 17.8383C26.3829 17.5393 26.4049 17.2433 26.3949 17.0123C26.3849 16.7493 26.3909 16.3823 26.3469 16.0003C26.3179 15.7343 26.2659 15.4663 26.1979 15.2383C26.1319 15.0143 26.0219 14.7913 25.9039 14.5783C25.7629 14.3223 25.6119 14.0783 25.5169 13.8453C25.4969 13.7983 25.4999 13.7263 25.4999 13.6323C25.5009 13.5673 25.4999 13.4913 25.4919 13.4083C25.3239 13.1243 25.1459 12.8423 24.9589 12.5483C24.9479 12.5413 24.9369 12.5333 24.9249 12.5263C24.6689 12.3503 24.3139 12.1173 24.0769 11.5503C24.0179 11.4063 24.0069 11.2983 23.9969 11.1993C23.9859 11.1013 23.9799 11.0183 23.9289 10.9093C23.8709 10.7853 23.7759 10.6583 23.6709 10.4993C23.5849 10.3703 23.4899 10.2133 23.4199 10.0423C23.3819 9.95134 23.3509 9.85734 23.3329 9.75934C23.3299 9.74334 23.3269 9.72534 23.3229 9.70634C23.2899 9.52734 23.2439 9.26534 23.2409 8.98634C23.0209 8.24434 22.8339 7.48833 22.6519 6.77633C22.3429 5.57133 22.0519 4.54234 21.3329 3.95434C20.9839 3.65334 20.5689 3.35433 20.2459 3.05433C19.9259 2.75633 19.7449 2.47534 19.8019 2.23834C19.8639 2.00634 20.1589 1.82934 20.6659 1.80534C21.1699 1.78334 21.8699 1.93235 22.5209 2.39235C23.6159 3.14235 24.2029 4.38334 24.5599 5.35734C24.5829 5.40834 24.6049 5.46034 24.6259 5.51234C24.7849 5.89434 24.9529 6.22834 25.1199 6.55534C25.1579 6.63034 25.1969 6.70834 25.2339 6.78134Z';
diff --git a/packages/app/src/components/working-avatar-driver.test.ts b/packages/app/src/components/working-avatar-driver.test.ts
new file mode 100644
index 000000000..c842ad7b3
--- /dev/null
+++ b/packages/app/src/components/working-avatar-driver.test.ts
@@ -0,0 +1,140 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { subscribeToMorphClock } from './working-avatar-driver';
+
+/**
+ * Drives the loop by hand: rAF callbacks are queued rather than run, so a test
+ * can advance the clock and pump exactly one frame at a time.
+ */
+function installFakeRaf() {
+ let nextId = 1;
+ let pending: { id: number; fn: FrameRequestCallback } | null = null;
+ let requests = 0;
+
+ vi.stubGlobal('requestAnimationFrame', (fn: FrameRequestCallback) => {
+ requests += 1;
+ const id = nextId++;
+ pending = { id, fn };
+ return id;
+ });
+ vi.stubGlobal('cancelAnimationFrame', (id: number) => {
+ if (pending?.id === id) pending = null;
+ });
+
+ return {
+ /** Run the one queued callback, which re-queues the next frame. */
+ pump() {
+ const current = pending;
+ pending = null;
+ current?.fn(performance.now());
+ },
+ get running() {
+ return pending !== null;
+ },
+ /** Total rAF calls — one per frame, however many subscribers there are. */
+ get requests() {
+ return requests;
+ },
+ };
+}
+
+describe('working avatar morph clock', () => {
+ let raf: ReturnType<typeof installFakeRaf>;
+
+ beforeEach(() => {
+ vi.useFakeTimers();
+ raf = installFakeRaf();
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ vi.unstubAllGlobals();
+ });
+
+ test('every subscriber starts its own cycle at zero', () => {
+ // Otherwise a turn that opens after the page has been up for a while drops
+ // in mid-cycle, on whatever arbitrary pose the shared clock had reached.
+ const first: number[] = [];
+ const stopFirst = subscribeToMorphClock((t) => first.push(t));
+ raf.pump();
+ expect(first[0]).toBeCloseTo(0, 2);
+
+ vi.advanceTimersByTime(5_000);
+
+ const late: number[] = [];
+ const stopLate = subscribeToMorphClock((t) => late.push(t));
+ raf.pump();
+ expect(late[0]).toBeCloseTo(0, 2);
+ // The one that was already running keeps counting from its own join.
+ expect(first.at(-1)).toBeGreaterThan(4.9);
+
+ stopFirst();
+ stopLate();
+ });
+
+ test('drives any number of subscribers from a single frame request', () => {
+ const stops = [
+ subscribeToMorphClock(() => {}),
+ subscribeToMorphClock(() => {}),
+ subscribeToMorphClock(() => {}),
+ ];
+ const before = raf.requests;
+ raf.pump();
+ expect(raf.requests - before).toBe(1);
+ for (const stop of stops) stop();
+ });
+
+ test('stops the loop once the last subscriber leaves, and restarts on the next', () => {
+ const stopA = subscribeToMorphClock(() => {});
+ const stopB = subscribeToMorphClock(() => {});
+ expect(raf.running).toBe(true);
+
+ stopA();
+ expect(raf.running).toBe(true);
+ stopB();
+ expect(raf.running).toBe(false);
+
+ const stopC = subscribeToMorphClock(() => {});
+ expect(raf.running).toBe(true);
+ stopC();
+ });
+
+ test('the last subscriber leaving from inside its own tick stops the loop', () => {
+ // The path the size check in `loop()` exists for. `cancelAnimationFrame`
+ // here targets the frame that is already executing, so it does nothing —
+ // without the check the reschedule would revive an empty loop that runs for
+ // the page's lifetime, ticking nobody. An avatar unmounting mid-tick (any
+ // navigation away from a live thread) is how that would happen for real.
+ let ticks = 0;
+ let stop = () => {};
+ stop = subscribeToMorphClock(() => {
+ ticks += 1;
+ stop();
+ });
+
+ raf.pump();
+ expect(ticks).toBe(1);
+ expect(raf.running).toBe(false);
+
+ // And it stays stopped rather than spinning on an empty subscriber set.
+ raf.pump();
+ expect(ticks).toBe(1);
+ expect(raf.running).toBe(false);
+ });
+
+ test('an unsubscribed avatar stops receiving ticks', () => {
+ let ticks = 0;
+ const stop = subscribeToMorphClock(() => {
+ ticks += 1;
+ });
+ raf.pump();
+ expect(ticks).toBe(1);
+
+ // Keep a live subscriber so the loop stays running — this asserts the
+ // unsubscribe, not the shutdown path covered above.
+ const keepAlive = subscribeToMorphClock(() => {});
+ stop();
+ raf.pump();
+ expect(ticks).toBe(1);
+ keepAlive();
+ });
+});
diff --git a/packages/app/src/components/working-avatar-driver.ts b/packages/app/src/components/working-avatar-driver.ts
new file mode 100644
index 000000000..8f886937f
--- /dev/null
+++ b/packages/app/src/components/working-avatar-driver.ts
@@ -0,0 +1,49 @@
+/**
+ * One rAF loop for every {@link WorkingAvatar} on the page.
+ *
+ * Each avatar drives its own `d` attribute imperatively (React re-rendering a
+ * 250-number path string at 60fps would be pure waste), so the loop itself is
+ * shared but the clock is not: each subscriber's elapsed time counts from its
+ * own join, so a turn that starts always opens on the mascot's home pose rather
+ * than dropping in mid-cycle at whatever shape a page-lifetime clock had
+ * reached. The loop stops entirely once the last subscriber leaves.
+ */
+
+type Tick = (elapsedSeconds: number) => void;
+
+const subscribers = new Map<Tick, number>();
+let frame = 0;
+
+function now(): number {
+ return typeof performance !== 'undefined' && typeof performance.now === 'function'
+ ? performance.now()
+ : Date.now();
+}
+
+function loop(): void {
+ const t = now();
+ for (const [tick, joinedAt] of subscribers) tick((t - joinedAt) / 1000);
+ // A subscriber that unsubscribes from inside its own tick cancels the frame
+ // that is already executing, which is a no-op — without this check the
+ // reschedule below would revive an empty loop for the page's lifetime.
+ if (subscribers.size === 0) {
+ frame = 0;
+ return;
+ }
+ frame = requestAnimationFrame(loop);
+}
+
+/** Subscribe to the shared loop. Returns an unsubscribe function. */
+export function subscribeToMorphClock(tick: Tick): () => void {
+ subscribers.set(tick, now());
+ if (frame === 0 && typeof requestAnimationFrame === 'function') {
+ frame = requestAnimationFrame(loop);
+ }
+ return () => {
+ subscribers.delete(tick);
+ if (subscribers.size === 0 && frame !== 0) {
+ cancelAnimationFrame(frame);
+ frame = 0;
+ }
+ };
+}
diff --git a/packages/app/src/components/working-avatar-shapes.test.ts b/packages/app/src/components/working-avatar-shapes.test.ts
new file mode 100644
index 000000000..42e779d34
--- /dev/null
+++ b/packages/app/src/components/working-avatar-shapes.test.ts
@@ -0,0 +1,149 @@
+import { createHash } from 'node:crypto';
+import { describe, expect, test } from 'vitest';
+import { MASCOT_OUTLINE_PATH } from './mascot-outline';
+import {
+ buildMorphedPath,
+ buildShapeLibrary,
+ EYE_OFFSET_Y,
+ ease,
+ FALLBACK_SKIN_PATH,
+ FALLBACK_STROKE_WIDTH,
+ morphFrameAt,
+ POSE_SEQUENCE,
+ SHAPE,
+ toMorphSource,
+} from './working-avatar-shapes';
+
+describe('morphFrameAt', () => {
+ const SEQ = 4;
+ const DUR = 8;
+
+ test('starts on the first segment with zero progress', () => {
+ expect(morphFrameAt(0, SEQ, DUR, false)).toEqual({ from: 0, to: 1, t: 0 });
+ });
+
+ test('walks segments in order across the cycle', () => {
+ expect(morphFrameAt(2.5, SEQ, DUR, false).from).toBe(0);
+ expect(morphFrameAt(3, SEQ, DUR, false).from).toBe(1);
+ expect(morphFrameAt(6, SEQ, DUR, false).from).toBe(2);
+ expect(morphFrameAt(6, SEQ, DUR, false).to).toBe(3);
+ });
+
+ test('wraps at the cycle boundary rather than running off the end', () => {
+ expect(morphFrameAt(DUR, SEQ, DUR, false)).toEqual(morphFrameAt(0, SEQ, DUR, false));
+ expect(morphFrameAt(DUR * 3 + 1, SEQ, DUR, false)).toEqual(morphFrameAt(1, SEQ, DUR, false));
+ });
+
+ test('never indexes past the last pose', () => {
+ // The final instant of the cycle still has to name a valid `to`.
+ const frame = morphFrameAt(DUR - 1e-9, SEQ, DUR, false);
+ expect(frame.to).toBeLessThanOrEqual(SEQ - 1);
+ });
+
+ test('hold finishes the morph early and then sits still', () => {
+ const segment = DUR / (SEQ - 1);
+ // 58% of the segment is the whole morph; everything after it is the beat.
+ expect(morphFrameAt(segment * 0.58, SEQ, DUR, true).t).toBe(1);
+ expect(morphFrameAt(segment * 0.9, SEQ, DUR, true).t).toBe(1);
+ // Without hold the same instant is still mid-morph.
+ expect(morphFrameAt(segment * 0.9, SEQ, DUR, false).t).toBeLessThan(1);
+ });
+});
+
+describe('ease', () => {
+ test('is pinned at both ends and symmetric about the midpoint', () => {
+ expect(ease(0)).toBe(0);
+ expect(ease(1)).toBe(1);
+ expect(ease(0.5)).toBeCloseTo(0.5, 10);
+ expect(ease(0.25) + ease(0.75)).toBeCloseTo(1, 10);
+ });
+});
+
+describe('POSE_SEQUENCE', () => {
+ test('starts and ends at home so the loop closes seamlessly', () => {
+ expect(POSE_SEQUENCE[0]).toBe(SHAPE.blobby);
+ expect(POSE_SEQUENCE.at(-1)).toBe(SHAPE.blobby);
+ });
+
+ test('only names poses the library actually builds', () => {
+ // Which poses are in the sequence is a design choice and free to change;
+ // naming one the library never builds would blank the mascot mid-cycle.
+ const built = Object.values(SHAPE);
+ for (const pose of POSE_SEQUENCE) expect(built).toContain(pose);
+ });
+
+ test('every pose carrying an eye offset lifts the face rather than dropping it', () => {
+ // The offsets exist for bodies that sit high (the comma). A positive value
+ // would push the eyes down off the shape instead.
+ for (const offset of Object.values(EYE_OFFSET_Y)) expect(offset).toBeLessThan(0);
+ });
+});
+
+describe('morph source', () => {
+ // Two hand-built paths with identical command structure — the precondition
+ // every generated shape has to satisfy for lerping to be meaningful.
+ const A = 'M1.00 2.00C3.00 4.00 5.00 6.00 7.00 8.00Z';
+ const B = 'M3.00 4.00C5.00 6.00 7.00 8.00 9.00 10.00Z';
+
+ test('splits a path into shared command fragments plus its numbers', () => {
+ const source = toMorphSource([A, B]);
+ expect(source.numbers[0]).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
+ expect(source.numbers[1]).toEqual([3, 4, 5, 6, 7, 8, 9, 10]);
+ });
+
+ test('rebuilds the original path when handed the original numbers', () => {
+ const source = toMorphSource([A, B]);
+ expect(buildMorphedPath(source.fragments, source.numbers[0])).toBe(A);
+ });
+
+ test('a half-way lerp lands half-way between the two shapes', () => {
+ const source = toMorphSource([A, B]);
+ const mid = source.numbers[0].map((n, i) => n + (source.numbers[1][i] - n) * 0.5);
+ expect(buildMorphedPath(source.fragments, mid)).toBe(
+ 'M2.00 3.00C4.00 5.00 6.00 7.00 8.00 9.00Z',
+ );
+ });
+});
+
+describe('buildShapeLibrary', () => {
+ // Node has no SVG path measurement, which is exactly the degraded path the
+ // component has to survive — it renders the static pose instead.
+ test('reports unavailability rather than throwing when paths cannot be measured', () => {
+ expect(buildShapeLibrary()).toBeNull();
+ });
+
+ test('the static fallback pose is a closed path the morph engine can parse', () => {
+ const source = toMorphSource([FALLBACK_SKIN_PATH]);
+ expect(FALLBACK_SKIN_PATH.endsWith('Z')).toBe(true);
+ // 40 cubic segments (6 numbers each) plus the opening moveto pair.
+ expect(source.numbers[0]).toHaveLength(40 * 6 + 2);
+ });
+});
+
+describe('frozen fallback pose', () => {
+ /**
+ * `FALLBACK_SKIN_PATH` is `buildShapeLibrary().paths[SHAPE.blobby]` captured by
+ * hand, and nothing can recompute it here — the generator needs
+ * `getPointAtLength`, which neither Node nor jsdom implements. So this pins
+ * its dominant input instead: retracing the mascot silently desynchronises the
+ * frozen pose, and reduced-motion users (who only ever see the frozen pose)
+ * would get a shape that no longer matches the live mascot.
+ *
+ * This is a tripwire, not an equality check. It catches "the outline moved and
+ * nobody regenerated"; it cannot catch a hand-corrupted constant.
+ */
+ test('the outline the fallback pose was traced from has not moved', () => {
+ const digest = createHash('sha256').update(MASCOT_OUTLINE_PATH).digest('hex').slice(0, 16);
+ expect(
+ digest,
+ 'MASCOT_OUTLINE_PATH changed. Regenerate FALLBACK_SKIN_PATH and FALLBACK_STROKE_WIDTH ' +
+ 'by running buildShapeLibrary() in a browser and taking paths[SHAPE.blobby] and ' +
+ 'strokeWidth, then update this digest.',
+ ).toBe('abc881bcf4959fe4');
+ });
+
+ test('the fallback stroke width is the weight the pose was traced at', () => {
+ // Both constants are regenerated together; a lone edit to one is drift.
+ expect(FALLBACK_STROKE_WIDTH).toBeCloseTo(2.26, 2);
+ });
+});
diff --git a/packages/app/src/components/working-avatar-shapes.ts b/packages/app/src/components/working-avatar-shapes.ts
new file mode 100644
index 000000000..4e8fc3b2d
--- /dev/null
+++ b/packages/app/src/components/working-avatar-shapes.ts
@@ -0,0 +1,489 @@
+/**
+ * Shape library + morph maths for {@link WorkingAvatar}.
+ *
+ * Every shape is resampled to exactly {@link POINTS} points and emitted as one
+ * closed cubic-Bezier path with identical command structure. That is the whole
+ * trick: because all paths share structure, morphing between any two of them is
+ * a straight numeric lerp over the path-data numbers — no path-diffing library
+ * needed. Do not drop the resample step when adding a shape.
+ *
+ * Building the library needs `SVGPathElement.getTotalLength`/`getPointAtLength`,
+ * which jsdom does not implement, so it happens lazily on first use behind
+ * {@link getShapeLibrary} and falls back to a single static pose.
+ */
+
+/** Points per shape. Also the number of cubic segments in every emitted path. */
+const POINTS = 40;
+
+/** Shape centre in viewBox units (all shapes share `viewBox="0 0 30 30"`). */
+const CX = 15;
+const CY = 15;
+
+/** Nominal shape radius the sequence entries are expressed relative to. */
+const R = 12.4;
+
+import { MASCOT_OUTLINE_PATH } from './mascot-outline';
+
+type Point = [number, number];
+
+/** Named indices into {@link ShapeLibrary.paths}. Sequences reference these. */
+export const SHAPE = {
+ blobby: 0,
+ triangle: 1,
+ square: 2,
+ sparkle: 3,
+ pentagon: 4,
+ hexagon: 5,
+ /** The beat between poses — everything breathes down to this and back out. */
+ dot: 6,
+ star5: 7,
+ clover: 8,
+ star6: 9,
+ scallop: 10,
+ comma: 11,
+ diamond: 12,
+ cloud: 13,
+} as const;
+
+export interface ShapeLibrary {
+ /** One path string per {@link SHAPE} index, all structurally identical. */
+ paths: string[];
+ /** Traced marker weight at 30x30, used as the default `stroke-width`. */
+ strokeWidth: number;
+}
+
+/**
+ * The blobby pose, precomputed. Used when path measurement is unavailable
+ * (jsdom) and as the first-paint value before the library builds. Regenerating
+ * it means running {@link buildShapeLibrary} in a browser and taking `paths[0]`.
+ */
+export const FALLBACK_SKIN_PATH =
+ 'M15.34 2.91C15.96 2.77 16.69 2.65 17.33 2.63C17.97 2.62 18.72 2.71 19.36 2.84C20.00 2.97 20.79 3.10 21.33 3.44C21.88 3.79 22.38 4.46 22.75 5.01C23.12 5.56 23.42 6.30 23.66 6.89C23.90 7.49 24.06 8.18 24.26 8.73C24.45 9.28 24.66 9.84 24.89 10.34C25.12 10.84 25.39 11.36 25.68 11.85C25.97 12.34 26.46 12.87 26.71 13.41C26.96 13.94 27.12 14.61 27.26 15.21C27.39 15.80 27.54 16.52 27.55 17.14C27.56 17.76 27.43 18.47 27.30 19.09C27.16 19.71 26.99 20.43 26.72 21.01C26.46 21.58 26.05 22.20 25.64 22.69C25.22 23.17 24.65 23.63 24.15 24.02C23.66 24.41 23.09 24.82 22.55 25.14C22.02 25.45 21.39 25.74 20.84 25.99C20.28 26.25 19.65 26.52 19.08 26.70C18.50 26.89 17.83 27.05 17.23 27.15C16.63 27.26 15.95 27.34 15.34 27.37C14.73 27.39 14.03 27.40 13.42 27.33C12.81 27.26 12.12 27.10 11.54 26.92C10.95 26.73 10.30 26.47 9.75 26.18C9.20 25.90 8.62 25.51 8.11 25.15C7.61 24.80 7.06 24.37 6.60 23.94C6.15 23.52 5.68 23.00 5.28 22.52C4.89 22.03 4.47 21.45 4.13 20.92C3.79 20.38 3.41 19.75 3.16 19.16C2.91 18.57 2.68 17.86 2.56 17.23C2.45 16.60 2.42 15.85 2.45 15.21C2.48 14.56 2.60 13.83 2.76 13.22C2.93 12.60 3.18 11.91 3.47 11.35C3.77 10.80 4.24 10.23 4.63 9.75C5.01 9.27 5.45 8.74 5.89 8.34C6.34 7.95 6.93 7.61 7.40 7.27C7.88 6.94 8.38 6.57 8.83 6.25C9.29 5.93 9.79 5.56 10.27 5.25C10.75 4.95 11.29 4.61 11.81 4.33C12.32 4.05 12.92 3.74 13.49 3.52C14.05 3.29 14.73 3.05 15.34 2.91Z';
+
+/** Marker weight the fallback pose was traced at, matching {@link FALLBACK_SKIN_PATH}. */
+export const FALLBACK_STROKE_WIDTH = 2.26;
+
+/** A comma glyph outline. `fit` samples it into the shared point structure. */
+const COMMA_OUTLINE =
+ 'M76.4805 11.041C99.1124 7.04848 118.186 8.33731 134.31 14.4102C150.369 20.4588 164.177 31.5065 175.929 48.1846L176.446 48.9199C187.179 64.5695 195.653 90.2797 191.323 112.539C186.344 138.13 169.219 160.474 150.105 178.107C131.113 195.629 111.037 207.691 101.728 212.842C98.3779 214.693 93.3915 217.316 88.0508 217.316C85.74 217.316 83.6583 216.814 81.7607 215.855L81.3838 215.658C75.1451 212.251 73.9381 205.91 73.376 198.68L73.2705 197.222C72.953 192.5 72.5095 188.039 71.1416 184.247C69.5395 179.806 66.852 176.673 63.1406 174.227L63.1377 174.225C41.2846 159.832 21.8495 144.226 13.3828 121.439L13.3818 121.438L13.0146 120.427C5.46004 99.1404 7.95139 74.5467 20.4404 52.7568L20.4414 52.7549C33.2945 30.3176 54.4303 14.925 76.4785 11.041H76.4805Z';
+
+/** Build one smooth closed curve through `p`. Identical command structure for
+ every input, which is the precondition for numeric morphing. */
+function smoothPath(p: Point[]): string {
+ const tangent = (i: number): Point => {
+ const a = p[(i - 1 + POINTS) % POINTS];
+ const b = p[(i + 1) % POINTS];
+ return [(b[0] - a[0]) * 0.16, (b[1] - a[1]) * 0.16];
+ };
+ let out = `M${p[0][0].toFixed(2)} ${p[0][1].toFixed(2)}`;
+ for (let i = 0; i < POINTS; i++) {
+ const a = p[i];
+ const b = p[(i + 1) % POINTS];
+ const ta = tangent(i);
+ const tb = tangent((i + 1) % POINTS);
+ out += `C${(a[0] + ta[0]).toFixed(2)} ${(a[1] + ta[1]).toFixed(2)} ${(b[0] - tb[0]).toFixed(2)} ${(b[1] - tb[1]).toFixed(2)} ${b[0].toFixed(2)} ${b[1].toFixed(2)}`;
+ }
+ return `${out}Z`;
+}
+
+/** Recentre + rescale a point cloud so its longest axis spans `target * 2`. */
+function normalize(p: Point[], target: number): Point[] {
+ const xs = p.map((q) => q[0]);
+ const ys = p.map((q) => q[1]);
+ const x0 = Math.min(...xs);
+ const x1 = Math.max(...xs);
+ const y0 = Math.min(...ys);
+ const y1 = Math.max(...ys);
+ const scale = (target * 2) / Math.max(x1 - x0, y1 - y0);
+ return p.map((q) => [CX + (q[0] - (x0 + x1) / 2) * scale, CY + (q[1] - (y0 + y1) / 2) * scale]);
+}
+
+/** Pull each point toward the midpoint of its neighbours — softens inner
+ corners without losing the silhouette. */
+function relax(p: Point[], passes: number, strength: number): Point[] {
+ let out = p;
+ for (let s = 0; s < passes; s++) {
+ const prev = out;
+ out = prev.map((q, i): Point => {
+ const a = prev[(i - 1 + POINTS) % POINTS];
+ const b = prev[(i + 1) % POINTS];
+ return [
+ q[0] * (1 - strength) + ((a[0] + b[0]) / 2) * strength,
+ q[1] * (1 - strength) + ((a[1] + b[1]) / 2) * strength,
+ ];
+ });
+ }
+ return out;
+}
+
+/** A measuring `<path>` detached from layout. Null when the platform can't
+ measure paths (jsdom), which is the signal to use the static fallback. */
+function createProbe(): SVGPathElement | null {
+ if (typeof document === 'undefined') return null;
+ const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+ svg.setAttribute('width', '0');
+ svg.setAttribute('height', '0');
+ svg.style.position = 'absolute';
+ svg.style.visibility = 'hidden';
+ const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+ svg.appendChild(path);
+ document.body.appendChild(svg);
+ if (typeof path.getTotalLength !== 'function' || typeof path.getPointAtLength !== 'function') {
+ svg.remove();
+ return null;
+ }
+ try {
+ path.setAttribute('d', 'M0 0L1 0');
+ path.getPointAtLength(0);
+ } catch {
+ svg.remove();
+ return null;
+ }
+ return path;
+}
+
+/** Everything below takes the probe explicitly so the library builds in one
+ pass and the probe can be torn down straight after. */
+function makeBuilders(probe: SVGPathElement) {
+ /** Walk an arbitrary path at even arc-length intervals. */
+ function sample(d: string, count: number): Point[] {
+ probe.setAttribute('d', d);
+ const length = probe.getTotalLength();
+ const out: Point[] = [];
+ for (let i = 0; i < count; i++) {
+ const q = probe.getPointAtLength((length * i) / count);
+ out.push([q.x, q.y]);
+ }
+ return out;
+ }
+
+ /** Bucket a dense sample by ray angle from the centroid. Returns the max and
+ min radius seen in each of {@link POINTS} angular buckets. */
+ function radialProfile(points: Point[]): { cx: number; cy: number; hi: number[]; lo: number[] } {
+ let cx = 0;
+ let cy = 0;
+ for (const q of points) {
+ cx += q[0];
+ cy += q[1];
+ }
+ cx /= points.length;
+ cy /= points.length;
+ const hi = new Array<number>(POINTS).fill(0);
+ const lo = new Array<number>(POINTS).fill(Number.POSITIVE_INFINITY);
+ for (const q of points) {
+ const angle = Math.atan2(q[1] - cy, q[0] - cx);
+ const radius = Math.hypot(q[0] - cx, q[1] - cy);
+ let bucket = Math.round(((angle + Math.PI / 2) / (2 * Math.PI)) * POINTS);
+ bucket = ((bucket % POINTS) + POINTS) % POINTS;
+ if (radius > hi[bucket]) hi[bucket] = radius;
+ if (radius < lo[bucket]) lo[bucket] = radius;
+ }
+ return { cx, cy, hi, lo };
+ }
+
+ function polar(radii: number[], cx: number, cy: number): Point[] {
+ return radii.map((r, i): Point => {
+ const a = -Math.PI / 2 + (i * 2 * Math.PI) / POINTS;
+ return [cx + Math.cos(a) * r, cy + Math.sin(a) * r];
+ });
+ }
+
+ /** Reduce a marker-drawn filled outline to its centreline, and report the
+ average outline thickness — that thickness is the pen weight to stroke at. */
+ function silhouette(d: string, target: number): { path: string; strokeWidth: number } {
+ const { cx, cy, hi, lo } = radialProfile(sample(d, 1080));
+ const mid = hi.map((v, i) => (v + lo[i]) / 2);
+ const thickness = hi.reduce((sum, v, i) => sum + (v - lo[i]), 0) / POINTS;
+ const p = polar(mid, cx, cy);
+ // `normalize` rescales the centreline, so the pen weight scales with it.
+ const xs = p.map((q) => q[0]);
+ const ys = p.map((q) => q[1]);
+ const scale =
+ (target * 2) / Math.max(Math.max(...xs) - Math.min(...xs), Math.max(...ys) - Math.min(...ys));
+ return { path: smoothPath(normalize(p, target)), strokeWidth: thickness * scale };
+ }
+
+ /** Outer hull of a multi-circle blob, lightly smoothed — turns overlapping
+ circles into a cloud/teardrop rather than a lumpy union. */
+ function hull(d: string, target: number): string {
+ const { cx, cy, hi } = radialProfile(sample(d, 1400));
+ const smoothed = hi.map(
+ (_, i) => hi[i] * 0.86 + (hi[(i - 1 + POINTS) % POINTS] + hi[(i + 1) % POINTS]) * 0.07,
+ );
+ return smoothPath(normalize(polar(smoothed, cx, cy), target));
+ }
+
+ /** Resample an arbitrary closed path, keeping its concavities. */
+ function fit(d: string, target: number): string {
+ return smoothPath(normalize(sample(d, POINTS), target));
+ }
+
+ function soften(d: string, passes: number, strength: number): string {
+ return smoothPath(relax(sample(d, POINTS), passes, strength));
+ }
+
+ function squeeze(d: string, sx: number, sy: number): string {
+ const p = sample(d, POINTS).map((q): Point => [CX + (q[0] - CX) * sx, CY + (q[1] - CY) * sy]);
+ return smoothPath(p);
+ }
+
+ /** Radial ripple applied to an existing shape so no two poses read as
+ machine-drawn. `seed` picks the phase, `amp` scales the wobble. */
+ function wobble(d: string, seed: number, amp = 1): string {
+ const p = sample(d, POINTS).map((q, i): Point => {
+ const a = (i * 2 * Math.PI) / POINTS;
+ const w =
+ 1 +
+ amp *
+ (0.035 * Math.sin(a * 3 + seed) +
+ 0.025 * Math.sin(a * 5 + seed * 2) +
+ 0.018 * Math.sin(a * 2 - seed));
+ return [CX + (q[0] - CX) * w, CY + (q[1] - CY) * w];
+ });
+ return smoothPath(p);
+ }
+
+ /** Regular polygon with rounded corners, clockwise from the top. Returns raw
+ path data — callers resample it (every caller pipes it through `wobble`
+ or `squeeze`, both of which sample). */
+ function poly(sides: number, radius: number, round: number, rot = 0): string {
+ const v: Point[] = [];
+ for (let i = 0; i < sides; i++) {
+ const a = -Math.PI / 2 + (i * 2 * Math.PI) / sides + rot;
+ v.push([CX + Math.cos(a) * radius, CY + Math.sin(a) * radius]);
+ }
+ const unit = (p: Point, q: Point): Point => {
+ const dx = q[0] - p[0];
+ const dy = q[1] - p[1];
+ const l = Math.hypot(dx, dy);
+ return [dx / l, dy / l];
+ };
+ let d = '';
+ for (let i = 0; i < sides; i++) {
+ const cur = v[i];
+ const d1 = unit(cur, v[(i - 1 + sides) % sides]);
+ const d2 = unit(cur, v[(i + 1) % sides]);
+ const a: Point = [cur[0] + d1[0] * round, cur[1] + d1[1] * round];
+ const b: Point = [cur[0] + d2[0] * round, cur[1] + d2[1] * round];
+ d += `${i ? 'L' : 'M'}${a[0].toFixed(2)} ${a[1].toFixed(2)}A${round} ${round} 0 0 1 ${b[0].toFixed(2)} ${b[1].toFixed(2)}`;
+ }
+ return `${d}Z`;
+ }
+
+ /** Straight-sided star, relaxed so the tips carry a marker radius. */
+ function star(points: number, outer: number, inner: number, passes: number): string {
+ let d = '';
+ for (let i = 0; i < points * 2; i++) {
+ const a = -Math.PI / 2 + (i * Math.PI) / points;
+ const r = i % 2 ? inner : outer;
+ d += `${i ? 'L' : 'M'}${(CX + Math.cos(a) * r).toFixed(2)} ${(CY + Math.sin(a) * r).toFixed(2)}`;
+ }
+ return smoothPath(normalize(relax(sample(`${d}Z`, POINTS), passes, 0.3), outer));
+ }
+
+ /** Four-point sparkle: sharp tips joined by concave curves, then relaxed. */
+ function sparkle(outer: number, waist: number, passes: number): string {
+ const tip = (i: number): Point => {
+ const a = -Math.PI / 2 + (i * Math.PI) / 2;
+ return [CX + Math.cos(a) * outer, CY + Math.sin(a) * outer];
+ };
+ let d = `M${tip(0)[0].toFixed(2)} ${tip(0)[1].toFixed(2)}`;
+ for (let i = 0; i < 4; i++) {
+ const a = -Math.PI / 2 + ((i + 0.5) * Math.PI) / 2;
+ const c: Point = [CX + Math.cos(a) * waist, CY + Math.sin(a) * waist];
+ const n = tip((i + 1) % 4);
+ d += `Q${c[0].toFixed(2)} ${c[1].toFixed(2)} ${n[0].toFixed(2)} ${n[1].toFixed(2)}`;
+ }
+ return smoothPath(normalize(relax(sample(`${d}Z`, POINTS), passes, 0.34), outer));
+ }
+
+ /** Polar lobed shape. `exponent` shapes how pointy vs round the arms read. */
+ function lobed(lobes: number, outer: number, inner: number, exponent: number): string {
+ const p: Point[] = [];
+ for (let i = 0; i < POINTS; i++) {
+ const a = -Math.PI / 2 + (i * 2 * Math.PI) / POINTS;
+ const f = (1 + Math.cos(lobes * (a + Math.PI / 2))) / 2;
+ const r = inner + (outer - inner) * f ** exponent;
+ p.push([CX + Math.cos(a) * r, CY + Math.sin(a) * r]);
+ }
+ return smoothPath(p);
+ }
+
+ function dot(radius: number): string {
+ const p: Point[] = [];
+ for (let i = 0; i < POINTS; i++) {
+ const a = -Math.PI / 2 + (i * 2 * Math.PI) / POINTS;
+ p.push([CX + Math.cos(a) * radius, CY + Math.sin(a) * radius]);
+ }
+ return smoothPath(p);
+ }
+
+ const circle = (x: number, y: number, r: number) =>
+ `M${x - r} ${y}a${r} ${r} 0 1 0 ${r * 2} 0a${r} ${r} 0 1 0 ${-r * 2} 0`;
+
+ return {
+ silhouette,
+ hull,
+ fit,
+ soften,
+ squeeze,
+ wobble,
+ poly,
+ star,
+ sparkle,
+ lobed,
+ dot,
+ circle,
+ };
+}
+
+/** Build the full shape library. Needs a DOM with SVG path measurement;
+ returns null where that isn't available. Exported for the generator that
+ refreshes {@link FALLBACK_SKIN_PATH}. */
+export function buildShapeLibrary(): ShapeLibrary | null {
+ const probe = createProbe();
+ if (probe === null) return null;
+ try {
+ const b = makeBuilders(probe);
+ const blobby = b.silhouette(MASCOT_OUTLINE_PATH, 12.55);
+ // Index order must match SHAPE.
+ const paths = [
+ blobby.path,
+ b.wobble(b.poly(3, R * 1.16, R * 0.5, 0.1), 1.1),
+ b.wobble(b.poly(4, R * 1.02, R * 0.44), 2.3),
+ b.wobble(b.sparkle(R * 1.24, R * 0.1, 3), 3.7),
+ b.wobble(b.poly(5, R * 1.0, R * 0.38), 4.9),
+ b.wobble(b.poly(6, R * 0.98, R * 0.34), 6.2),
+ b.wobble(b.dot(R * 0.34), 2.8),
+ b.wobble(b.star(5, R * 1.14, R * 0.68, 6), 7.4),
+ b.wobble(b.soften(b.lobed(4, R * 1.16, R * 0.46, 0.5), 3, 0.3), 8.1),
+ b.wobble(b.star(6, R * 1.2, R * 0.42, 4), 9.3),
+ b.wobble(b.lobed(8, R * 1.06, R * 0.74, 0.6), 10.5),
+ b.wobble(b.soften(b.fit(COMMA_OUTLINE, R * 1.12), 3, 0.22), 11.7, 0.3),
+ b.wobble(b.squeeze(b.poly(4, R * 1.3, R * 0.2), 0.84, 1), 12.9),
+ b.wobble(
+ b.hull(
+ b.circle(10.2, 16, 4.3) +
+ b.circle(15, 12, 5.5) +
+ b.circle(20, 15.4, 4.4) +
+ b.circle(15, 17.4, 5.2),
+ 12.4,
+ ),
+ 13.6,
+ ),
+ ];
+ return { paths, strokeWidth: blobby.strokeWidth };
+ } finally {
+ probe.ownerSVGElement?.remove();
+ }
+}
+
+let cachedLibrary: ShapeLibrary | null | undefined;
+
+/** Build-once accessor. Null means path measurement is unavailable and callers
+ should render {@link FALLBACK_SKIN_PATH} statically. */
+export function getShapeLibrary(): ShapeLibrary | null {
+ if (cachedLibrary === undefined) cachedLibrary = buildShapeLibrary();
+ return cachedLibrary;
+}
+
+/* -------------------------------------------------------------------------- */
+/* Morphing */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * Split every path into its literal command fragments plus a flat number list.
+ * The fragments are identical across shapes (same command structure), so
+ * rebuilding a morphed path is `fragments[i] + lerped[i]` all the way down.
+ */
+export interface MorphSource {
+ fragments: string[];
+ numbers: number[][];
+}
+
+const NUMBER_RE = /-?\d+(?:\.\d+)?/g;
+
+export function toMorphSource(paths: string[]): MorphSource {
+ return {
+ fragments: paths[0].split(NUMBER_RE),
+ numbers: paths.map((d) => (d.match(NUMBER_RE) ?? []).map(Number)),
+ };
+}
+
+export function buildMorphedPath(fragments: string[], values: number[]): string {
+ let out = '';
+ for (let i = 0; i < values.length; i++) out += fragments[i] + values[i].toFixed(2);
+ return out + fragments[values.length];
+}
+
+/** Symmetric ease used for every segment. */
+export function ease(t: number): number {
+ return t < 0.5 ? 2 * t * t : 1 - 2 * (1 - t) ** 2;
+}
+
+/** Fraction of a segment the morph occupies when `hold` is on. The remainder
+ is dead still — that pause is what gives each pose a beat. */
+const HOLD_MORPH_FRACTION = 0.58;
+
+export interface MorphFrame {
+ /** Index into the sequence of the pose being morphed away from. */
+ from: number;
+ /** Index into the sequence of the pose being morphed toward. */
+ to: number;
+ /** Eased 0..1 progress between them. */
+ t: number;
+}
+
+/**
+ * Where in the sequence we are at `elapsedSeconds`. Pure — the rAF loop and the
+ * tests both go through this.
+ */
+export function morphFrameAt(
+ elapsedSeconds: number,
+ sequenceLength: number,
+ durationSeconds: number,
+ hold: boolean,
+): MorphFrame {
+ const segments = sequenceLength - 1;
+ const segmentDuration = durationSeconds / segments;
+ const t = elapsedSeconds % durationSeconds;
+ const index = Math.max(0, Math.min(segments - 1, Math.floor(t / segmentDuration)));
+ const local = (t % segmentDuration) / segmentDuration;
+ return {
+ from: index,
+ to: index + 1,
+ t: ease(hold ? Math.min(1, local / HOLD_MORPH_FRACTION) : local),
+ };
+}
+
+/* -------------------------------------------------------------------------- */
+/* Sequence */
+/* -------------------------------------------------------------------------- */
+
+const S = SHAPE;
+
+/**
+ * The poses the mascot cycles through, starting and ending at home so the loop
+ * closes seamlessly. Retunable from the full {@link SHAPE} palette — the
+ * library builds every entry, not just the ones used here, so swapping a pose
+ * costs one edit.
+ */
+export const POSE_SEQUENCE = [
+ S.blobby,
+ S.triangle,
+ S.square,
+ S.sparkle,
+ S.comma,
+ S.pentagon,
+ S.hexagon,
+ S.blobby,
+];
+
+/**
+ * Per-shape eye offset in viewBox units, lerped along with the morph. The
+ * comma's body sits high, so without this the face floats off the body.
+ */
+export const EYE_OFFSET_Y: Record<number, number> = { [S.comma]: -2.9 };
+
+/** Resting eye geometry, in viewBox units. */
+export const EYE = { leftCx: 10.9, rightCx: 18.1, cy: 16, rx: 1.25, ry: 1.9 } as const;
diff --git a/packages/app/src/globals.css b/packages/app/src/globals.css
index 15141f691..59a8e1ddd 100644
--- a/packages/app/src/globals.css
+++ b/packages/app/src/globals.css
@@ -874,6 +874,126 @@
}
}
+/* Working avatar (agent-thread "working" row) — the personality layer on top of
+ the JS-driven shape morph in WorkingAvatar.tsx. The morph itself sets `d`
+ every frame; everything here is squash, blink and squint applied on top.
+ `transform-box: fill-box` is required — SVG children default to the
+ viewport's coordinate box, so a percentage transform-origin would otherwise
+ resolve against the wrong rect. */
+/* The row arrives when a turn opens. Short enough to stay under the
+ interactive-UI ceiling — this is a state change you see on every turn, not a
+ scroll reveal you see once. Compositor-only (opacity + transform). */
+.ok-working-enter {
+ animation: ok-working-enter 180ms var(--ease-out-strong) both;
+}
+
+@keyframes ok-working-enter {
+ from {
+ opacity: 0;
+ transform: translateY(2px);
+ }
+}
+
+/* The status line rewrites itself several times a turn as the agent moves
+ between tools, and a hard text swap reads as a glitch rather than a change.
+ A short fade with a touch of blur bridges the two states — the blur is what
+ makes an un-crossfadeable swap (the outgoing text is already gone) still
+ read as one transformation. Kept well under the 20px where blur gets
+ expensive. */
+.ok-working-status {
+ animation: ok-working-status-in 200ms var(--ease-out-strong) both;
+}
+
+@keyframes ok-working-status-in {
+ from {
+ opacity: 0;
+ filter: blur(2px);
+ }
+}
+
+.ok-working-group {
+ transform-box: fill-box;
+ transform-origin: 50% 50%;
+}
+
+/* Needed by the squint below — SVG children resolve a percentage
+ transform-origin against the viewport box, not their own. */
+.ok-working-eye {
+ transform-box: fill-box;
+ transform-origin: 50% 50%;
+}
+
+/* Four squash beats per cycle — the "still going" tell on long tasks. The
+ strong in-out curve is what makes each beat land as a squash; the built-in
+ `ease-in-out` is too weak and reads as a slow pulse instead. */
+.ok-working-pop .ok-working-group {
+ animation: ok-working-pop 4.8s var(--ease-in-out-strong) infinite;
+}
+
+@keyframes ok-working-pop {
+ 0%,
+ 25%,
+ 50%,
+ 75%,
+ 100% {
+ transform: scale(1);
+ }
+ 12%,
+ 37%,
+ 62%,
+ 87% {
+ transform: scale(1.1, 0.9);
+ }
+}
+
+/* Effort tell. Replaces the ambient blink by specificity — the mascot is
+ squinting at the work, not idly blinking at you. */
+.ok-working-squint .ok-working-eye {
+ animation: ok-working-squint 1.8s ease-in-out infinite;
+}
+
+@keyframes ok-working-squint {
+ 0%,
+ 44%,
+ 100% {
+ transform: scaleY(1);
+ }
+ 50% {
+ transform: scaleY(0.35);
+ }
+ 56% {
+ transform: scaleY(1);
+ }
+}
+
+/* Reduced motion pins the avatar to its resting pose. The shape morph is
+ suppressed in JS (the rAF loop never subscribes), so only the CSS layer
+ needs stopping here. The entrance keeps its opacity fade and loses only the
+ spatial travel — the fade is what tells you a new row appeared, and dropping
+ it would make the working state blink into existence with no warning. */
+@media (prefers-reduced-motion: reduce) {
+ .ok-working-group,
+ .ok-working-eye,
+ .ok-working-pop .ok-working-group,
+ .ok-working-squint .ok-working-eye {
+ animation: none;
+ }
+ .ok-working-enter {
+ animation-name: ok-working-enter-fade;
+ }
+ /* The status swap keeps its fade but drops the blur — blur is a spatial
+ effect, and the fade alone still marks the line as having changed. */
+ .ok-working-status {
+ animation-name: ok-working-enter-fade;
+ }
+}
+
+@keyframes ok-working-enter-fade {
+ from {
+ opacity: 0;
+ }
+}
+
/* Collaboration cursor styles (WYSIWYG — TipTap) */
.collaboration-cursor__caret {
position: relative;
diff --git a/packages/app/src/hooks/use-reduced-motion.ts b/packages/app/src/hooks/use-reduced-motion.ts
new file mode 100644
index 000000000..eabf5030a
--- /dev/null
+++ b/packages/app/src/hooks/use-reduced-motion.ts
@@ -0,0 +1,27 @@
+import { useEffect, useState } from 'react';
+
+/**
+ * Whether the user has asked for reduced motion, kept live.
+ *
+ * Components that only need to suppress a CSS animation should use the
+ * `prefers-reduced-motion` media query directly in the stylesheet. This hook is
+ * for the cases where JavaScript has to branch — an imperative animation loop
+ * that must not start, or DOM that must be reset when the setting flips.
+ */
+export function useReducedMotion(): boolean {
+ // Lazy-init from the live query so a reduced-motion user never sees one
+ // animated frame before an effect corrects it.
+ const [reduced, setReduced] = useState(
+ () =>
+ typeof window !== 'undefined' &&
+ window.matchMedia('(prefers-reduced-motion: reduce)').matches,
+ );
+ useEffect(() => {
+ const mq = window.matchMedia('(prefers-reduced-motion: reduce)');
+ setReduced(mq.matches);
+ const onChange = (event: MediaQueryListEvent) => setReduced(event.matches);
+ mq.addEventListener('change', onChange);
+ return () => mq.removeEventListener('change', onChange);
+ }, []);
+ return reduced;
+}
diff --git a/packages/app/src/locales/en/messages.json b/packages/app/src/locales/en/messages.json
index 058dfdc5c..e58c09abe 100644
--- a/packages/app/src/locales/en/messages.json
+++ b/packages/app/src/locales/en/messages.json
@@ -17,6 +17,7 @@
"-LHLx7": ["edited template"],
"-QCLWk": ["Templates available"],
"-Qw-1t": ["GitHub authentication failed. Try signing in again."],
+ "-VqsyR": ["Thinking…"],
"-WFFG2": ["Default properties"],
"-WeuHF": ["Remove queued message"],
"-YV1Uo": ["Pattern ", ["patternNumber"]],
@@ -262,6 +263,7 @@
"3v62tp": ["Popular on skills.sh"],
"3wiBAs": ["Where should it live?"],
"3y6XTb": ["Semantic search"],
+ "3zDeFb": ["Ruminating…"],
"3zyg_A": ["Ignore patterns"],
"4-Phgi": ["Show or hide agents"],
"438Fca": ["Cloned successfully, but could not open the project."],
@@ -720,6 +722,7 @@
]
],
"BGHHtQ": ["Single page"],
+ "BGoW3h": ["Turning it over…"],
"BGtzlf": [["uploadFolderName"], " — 1 file"],
"BH56dn": ["Custom display text"],
"BKI4hX": ["Find in file"],
@@ -761,6 +764,7 @@
"CB7c0Z": ["Save queued message"],
"CBsdhe": ["The agent isn't stopping. Force stop closes this thread and quits the agent."],
"CCTop_": ["Recent"],
+ "CD8lBW": ["Tidying up…"],
"CFnavk": ["This project isn't a git repository, so worktrees aren't available."],
"CHfFN_": ["Remove OpenKnowledge from ", ["0"]],
"CKyk7Q": ["Go back"],
@@ -807,8 +811,10 @@
],
"D2emTw": ["Something went wrong sending your feedback. Please try again."],
"D4H2N6": ["Remove ", ["tag"]],
+ "D7hnvB": ["Pondering…"],
"D8JJwQ": ["Feedback isn't available right now. Please try again later."],
"D8OV7J": ["Only collaborators"],
+ "DCSSZt": ["The agent is working"],
"DDTdLl": ["Code block settings"],
"DELNQk": ["Collaborators see your in-progress edits as soon as they sync."],
"DEWDbv": ["Show diagram"],
@@ -1009,6 +1015,7 @@
"Source mode requires a live connection — your edits are saved and will appear when you reconnect."
],
"G-h6qN": [["0", "plural", { "one": ["#", " option set"], "other": ["#", " options set"] }]],
+ "G0I7bo": ["Puzzling…"],
"G0YZ-I": ["Indent or outdent list item"],
"G1Gw0v": ["New template"],
"G1XxbZ": ["Checkbox"],
@@ -1063,6 +1070,7 @@
"GuaJb-": ["Open email draft"],
"GubkSu": ["Use a starter pack"],
"GuqOb1": ["Failed to load headings"],
+ "GwpcXB": ["Drafting…"],
"Gx0VS1": ["e.g. drafts/ or *.draft.md"],
"GzPQ2f": ["Stay in the loop"],
"H-hzll": ["Please choose Good or Not great."],
@@ -1168,6 +1176,7 @@
"J6mxC1": ["A network problem or GitHub outage interrupted the clone."],
"J7nMqi": ["Uninstall OpenKnowledge"],
"J86siq": ["Install from ", ["plugin"]],
+ "JAQ09e": ["Reflecting…"],
"JCxGEX": [
"No disconnected pages. Pages appear here only when they have no incoming and no outgoing graph edges."
],
@@ -1195,6 +1204,7 @@
"JsY1p5": ["Denied"],
"JtD-Br": ["Page link"],
"Jw6EC4": ["Branch switch failed — try opening the ", ["targetNoun"], " manually."],
+ "JyW5aS": ["Sifting…"],
"K-a33w": ["Start writing to create this page"],
"K-h9cT": ["Couldn't save the resolution for ", ["filePath"], "."],
"K0FgsP": [
@@ -1772,6 +1782,7 @@
"U9tm58": ["Hide problem indicators"],
"UBv8UK": ["Delete Permanently"],
"UDFrWm": ["Checking GitHub connection..."],
+ "UD_onR": ["Mulling…"],
"UDb2YD": ["React"],
"UEdTEN": ["Orphaned"],
"UGeJuP": ["Allowed values (empty = any)"],
@@ -1992,7 +2003,6 @@
"Xk0-VC": [
"Previews of links to other documents in this project are always on and read from the local index — nothing leaves your computer for those."
],
- "XklovM": ["Working…"],
"Xl-UUg": ["guides/install or https://example.com"],
"XmJfZT": ["name"],
"XnlF3W": ["Add the next matching source selection."],
@@ -2032,6 +2042,7 @@
"YEP3X2": ["Delete a table when the active table cell selection covers the full table."],
"YGIi_c": ["Reinstall"],
"YGNRB5": ["— except"],
+ "YGt-0e": ["Reading…"],
"YJ1BTp": ["A skill with that name already exists."],
"YJPN3F": ["Too slow"],
"YKLP_-": ["Template renamed"],
@@ -2275,6 +2286,7 @@
"bkQRMh": ["Paragraph"],
"blFttG": ["Search projects"],
"bmC18N": ["Clearing local collaboration data for \"", ["docName"], "\" before reconnecting."],
+ "bnOTEz": ["Retrieving…"],
"bpytj4": ["Move to ", ["0"]],
"brCtGB": ["History unavailable"],
"buNXgr": ["Switch between the visual and source editors, keeping your place."],
@@ -2455,6 +2467,7 @@
"eTsJYJ": ["description"],
"eUFXS1": ["Sort skills"],
"eVPynQ": ["Open <0><1>", ["verificationUri"], "</1><2/></0> and enter this code:"],
+ "eXPP7Z": ["Contemplating…"],
"eaHUxx": ["Files toolbar"],
"eazHgv": [
"Git can't track this folder — it's empty or contains only ignored files. The link won't work until you add a tracked document."
@@ -2578,6 +2591,7 @@
"glG1TR": ["Pulling the latest changes"],
"gljvbT": [["words", "plural", { "one": ["word"], "other": ["words"] }]],
"glzsS_": ["Pan right"],
+ "gmAH_b": ["Sorting…"],
"gmJ0An": ["Failed to open folder."],
"goO4Ll": ["Editor status bar"],
"gp3I7-": ["Before syncing, set your identity for git commits:"],
@@ -2742,6 +2756,7 @@
"j9tqwO": ["Not in sidebar"],
"jAMpHn": ["What is a starter pack?"],
"jBVUXo": ["Couldn't open the terminal — please try again."],
+ "jC8Bv4": ["Having a look around…"],
"jC8LSZ": ["Reset view filters"],
"jENU1Q": [
"Applies to all projects on this machine. Claude and Codex, started from the built-in terminal, auto-approve OpenKnowledge's read and write tools (Claude also auto-runs \"ok open\"). Deleting, moving, sharing, importing or installing skills, other commands, and non-OpenKnowledge file edits still ask. Cursor, OpenCode, and Pi are unaffected. Best-effort per agent."
@@ -2782,6 +2797,7 @@
"ju38ms": [
"This project has no git repository — sharing mode does not apply. Initialize a repo to enable the toggle."
],
+ "juD53g": ["Digging…"],
"jwnpdM": [
"A template named <0>",
["trimmedSlug"],
@@ -3364,6 +3380,7 @@
" · crash dump not redacted"
],
"snrVQ7": ["probe failed"],
+ "sqUrlK": ["Musing…"],
"ssk6rl": [
"The skill's own folder (",
["path"],
@@ -3442,6 +3459,7 @@
"uDlyqd": [
"Document the architecture of this repo: create an overview page that links to a page per major module describing its responsibilities and entry points."
],
+ "uF82hk": ["Percolating…"],
"uF9ruK": ["Saving"],
"uFQbYd": ["Home page and entry point."],
"uGaIIS": ["Check out worktree"],
@@ -3586,6 +3604,7 @@
],
"w_Sphq": ["Attachments"],
"wbv9xO": ["Create new project"],
+ "wc54KE": ["Trying it out…"],
"wcfO9r": ["No bug reports yet."],
"wdxz7K": ["Source"],
"wdzBgi": ["Config sharing is now Only me."],
diff --git a/packages/app/src/locales/en/messages.po b/packages/app/src/locales/en/messages.po
index a15fc285a..7ff833445 100644
--- a/packages/app/src/locales/en/messages.po
+++ b/packages/app/src/locales/en/messages.po
@@ -2540,6 +2540,10 @@ msgstr "Connection lost — keep this tab open, your edits will sync when reconn
msgid "Connects automatically the next time you open this project in a trusted Codex session."
msgstr "Connects automatically the next time you open this project in a trusted Codex session."
+#: src/components/acp/working-status.ts
+msgid "Contemplating…"
+msgstr "Contemplating…"
+
#: src/components/ConsentDialogBody.tsx
msgid "Content directory"
msgstr "Content directory"
@@ -3715,6 +3719,10 @@ msgstr "Diff unavailable"
msgid "Different version here — click to compare and resolve"
msgstr "Different version here — click to compare and resolve"
+#: src/components/acp/working-status.ts
+msgid "Digging…"
+msgstr "Digging…"
+
#. placeholder {0}: plugin.label
#. placeholder {0}: rule.name
#: src/components/settings/LintingSection.tsx
@@ -3905,6 +3913,10 @@ msgstr "Draft a spec"
msgid "Draft a technical spec for my project. Start with an overview, then add cross-linked pages for the architecture, the key modules, and the open questions, all linked from a specs index."
msgstr "Draft a technical spec for my project. Start with an overview, then add cross-linked pages for the architecture, the key modules, and the open questions, all linked from a specs index."
+#: src/components/acp/working-status.ts
+msgid "Drafting…"
+msgstr "Drafting…"
+
#: src/components/FrontmatterRow.tsx
msgid "Drag {keyName} to reorder"
msgstr "Drag {keyName} to reorder"
@@ -5195,6 +5207,10 @@ msgstr "Hard break"
msgid "Hard to use"
msgstr "Hard to use"
+#: src/components/acp/working-status.ts
+msgid "Having a look around…"
+msgstr "Having a look around…"
+
#: src/editor/slash-command/items.tsx
msgid "Heading 1"
msgstr "Heading 1"
@@ -6516,10 +6532,18 @@ msgstr "Moved {0} to position {1} of {2}"
msgid "moved template"
msgstr "moved template"
+#: src/components/acp/working-status.ts
+msgid "Mulling…"
+msgstr "Mulling…"
+
#: src/editor/slash-command/component-items.tsx
msgid "Multi-page PDF viewer with toolbar controls (thumbnails, page nav, zoom)."
msgstr "Multi-page PDF viewer with toolbar controls (thumbnails, page nav, zoom)."
+#: src/components/acp/working-status.ts
+msgid "Musing…"
+msgstr "Musing…"
+
#: src/components/NewWorktreeDialog.tsx
msgid "my-feature"
msgstr "my-feature"
@@ -7900,6 +7924,10 @@ msgstr "Pause sync"
msgid "pending"
msgstr "pending"
+#: src/components/acp/working-status.ts
+msgid "Percolating…"
+msgstr "Percolating…"
+
#: src/components/CreateProjectDialog.tsx
msgid "Permanently deletes <0>{targetGitPath}</0> and all its git history. Working files stay in place. If the parent git repo is intentional (e.g. you cloned it), cancel and pick a location outside it."
msgstr "Permanently deletes <0>{targetGitPath}</0> and all its git history. Working files stay in place. If the parent git repo is intentional (e.g. you cloned it), cancel and pick a location outside it."
@@ -7994,6 +8022,10 @@ msgstr "Plugins"
msgid "Point semantic search at any OpenAI-compatible embeddings endpoint — a self-hosted server or another provider. The API key above is for whichever endpoint you set here."
msgstr "Point semantic search at any OpenAI-compatible embeddings endpoint — a self-hosted server or another provider. The API key above is for whichever endpoint you set here."
+#: src/components/acp/working-status.ts
+msgid "Pondering…"
+msgstr "Pondering…"
+
#: src/components/ExploreSkills.tsx
msgid "Popular"
msgstr "Popular"
@@ -8232,6 +8264,10 @@ msgstr "Push failed — check the server logs for details."
msgid "Pushing"
msgstr "Pushing"
+#: src/components/acp/working-status.ts
+msgid "Puzzling…"
+msgstr "Puzzling…"
+
#: src/comments/comment-chips.tsx
#: src/comments/CommentQueuePanel.tsx
#: src/comments/CommentsPanel.tsx
@@ -8292,6 +8328,10 @@ msgstr "Read-only copy of a MirrorSource block from another doc. Edit at the sou
msgid "Read-only file in the {name} skill"
msgstr "Read-only file in the {name} skill"
+#: src/components/acp/working-status.ts
+msgid "Reading…"
+msgstr "Reading…"
+
#: src/components/SeedDialog.tsx
msgid "Ready-made folders and templates to get you started quickly."
msgstr "Ready-made folders and templates to get you started quickly."
@@ -8365,6 +8405,10 @@ msgstr "Refactoring"
msgid "Reference <0>{0}</0>"
msgstr "Reference <0>{0}</0>"
+#: src/components/acp/working-status.ts
+msgid "Reflecting…"
+msgstr "Reflecting…"
+
#: src/components/InstallInClaudeDesktopDialog.tsx
#: src/components/settings/IntegrationsSection.tsx
msgid "Reinstall"
@@ -8901,6 +8945,10 @@ msgstr "Resume sync"
msgid "Resuming the conversation"
msgstr "Resuming the conversation"
+#: src/components/acp/working-status.ts
+msgid "Retrieving…"
+msgstr "Retrieving…"
+
#: src/components/ActivityModeContent.tsx
#: src/components/BugReportHistory.tsx
#: src/components/ConnectingBanner.tsx
@@ -8992,6 +9040,10 @@ msgstr "Rule editing is available for the project's root markdownlint config"
msgid "Rules"
msgstr "Rules"
+#: src/components/acp/working-status.ts
+msgid "Ruminating…"
+msgstr "Ruminating…"
+
#: src/components/settings/LintingSection.tsx
msgid "Run a project audit from the Problems panel."
msgstr "Run a project audit from the Problems panel."
@@ -9754,6 +9806,10 @@ msgstr "Showing top matches — keep typing to narrow"
msgid "Shows above the code body. Round-trips as `title=\"...\"` in markdown."
msgstr "Shows above the code body. Round-trips as `title=\"...\"` in markdown."
+#: src/components/acp/working-status.ts
+msgid "Sifting…"
+msgstr "Sifting…"
+
#: src/components/settings/AccountSection.tsx
#: src/components/settings/SyncSection.tsx
#: src/components/ShareBranchSwitchDialog.tsx
@@ -9894,6 +9950,10 @@ msgstr "Sort by"
msgid "Sort skills"
msgstr "Sort skills"
+#: src/components/acp/working-status.ts
+msgid "Sorting…"
+msgstr "Sorting…"
+
#: src/components/SkillInstallMenu.tsx
msgid "source"
msgstr "source"
@@ -10528,6 +10588,10 @@ msgstr "The {targetNoun} could not be opened — try navigating to it manually."
msgid "The <0>type</0> every document created from this template gets (e.g. <1>research-note</1>). Keeps new docs Open Knowledge Format–conformant."
msgstr "The <0>type</0> every document created from this template gets (e.g. <1>research-note</1>). Keeps new docs Open Knowledge Format–conformant."
+#: src/components/WorkingAvatar.tsx
+msgid "The agent is working"
+msgstr "The agent is working"
+
#: src/components/acp/ThreadView.tsx
msgid "The agent isn't stopping. Force stop closes this thread and quits the agent."
msgstr "The agent isn't stopping. Force stop closes this thread and quits the agent."
@@ -10723,6 +10787,10 @@ msgstr "There's no project folder for this window, so a terminal can't start her
msgid "These rules come from your project's <0>{configFile}</0> file, which fully governs linting for this project. Turn rules on or off and edit their options here; changes write back to the file."
msgstr "These rules come from your project's <0>{configFile}</0> file, which fully governs linting for this project. Turn rules on or off and edit their options here; changes write back to the file."
+#: src/components/acp/working-status.ts
+msgid "Thinking…"
+msgstr "Thinking…"
+
#: src/components/share-receive-miss-content.tsx
msgid "This {targetNoun} has been moved, renamed, or deleted in your local copy of branch <0>{branch}</0>, and that change hasn't synced yet."
msgstr "This {targetNoun} has been moved, renamed, or deleted in your local copy of branch <0>{branch}</0>, and that change hasn't synced yet."
@@ -11020,6 +11088,10 @@ msgstr "This usually means one of:"
msgid "This window can't store a token — open Settings from the main app window."
msgstr "This window can't store a token — open Settings from the main app window."
+#: src/components/acp/working-status.ts
+msgid "Tidying up…"
+msgstr "Tidying up…"
+
#: src/components/DocPanel.tsx
#: src/components/TimelinePanel.tsx
msgid "Timeline"
@@ -11171,6 +11243,10 @@ msgstr "Try a prompt"
msgid "Try again"
msgstr "Try again"
+#: src/components/acp/working-status.ts
+msgid "Trying it out…"
+msgstr "Trying it out…"
+
#. placeholder {0}: scope === 'global' ? `~/${o.root}` : o.root
#: src/components/settings/SkillTargetsPicker.tsx
msgid "Turn {0} back into a real directory holding a per-skill symlink for each skill it currently sees — nothing stops working, and each skill's menu manages it from there."
@@ -11205,6 +11281,10 @@ msgstr "Turn on semantic search?"
msgid "Turn the things you read into clear, trusted articles. Save a source, figure out what it means, then keep the final version so you can rely on it later."
msgstr "Turn the things you read into clear, trusted articles. Save a source, figure out what it means, then keep the final version so you can rely on it later."
+#: src/components/acp/working-status.ts
+msgid "Turning it over…"
+msgstr "Turning it over…"
+
#. placeholder {0}: skill.name
#: src/components/SkillForkDialog.tsx
msgid "Two versions of \"{0}\" — source vs {editor}"
@@ -11837,10 +11917,6 @@ msgstr "Work through these comments"
msgid "Working"
msgstr "Working"
-#: src/components/acp/ThreadView.tsx
-msgid "Working…"
-msgstr "Working…"
-
#: src/lib/keyboard-shortcuts.ts
msgid "Workspace"
msgstr "Workspace"
diff --git a/packages/app/src/locales/pseudo/messages.json b/packages/app/src/locales/pseudo/messages.json
index a06d199f6..66b67516a 100644
--- a/packages/app/src/locales/pseudo/messages.json
+++ b/packages/app/src/locales/pseudo/messages.json
@@ -17,6 +17,7 @@
"-LHLx7": ["ēďĩţēď ţēḿƥĺàţē"],
"-QCLWk": ["Ţēḿƥĺàţēś àvàĩĺàƀĺē"],
"-Qw-1t": ["ĜĩţĤũƀ àũţĥēńţĩćàţĩōń ƒàĩĺēď. Ţŕŷ śĩĝńĩńĝ ĩń àĝàĩń."],
+ "-VqsyR": ["Ţĥĩńķĩńĝ…"],
"-WFFG2": ["Ďēƒàũĺţ ƥŕōƥēŕţĩēś"],
"-WeuHF": ["Ŕēḿōvē ǫũēũēď ḿēśśàĝē"],
"-YV1Uo": ["Ƥàţţēŕń ", ["patternNumber"]],
@@ -262,6 +263,7 @@
"3v62tp": ["Ƥōƥũĺàŕ ōń śķĩĺĺś.śĥ"],
"3wiBAs": ["Ŵĥēŕē śĥōũĺď ĩţ ĺĩvē?"],
"3y6XTb": ["Śēḿàńţĩć śēàŕćĥ"],
+ "3zDeFb": ["Ŕũḿĩńàţĩńĝ…"],
"3zyg_A": ["Ĩĝńōŕē ƥàţţēŕńś"],
"4-Phgi": ["Śĥōŵ ōŕ ĥĩďē àĝēńţś"],
"438Fca": ["Ćĺōńēď śũććēśśƒũĺĺŷ, ƀũţ ćōũĺď ńōţ ōƥēń ţĥē ƥŕōĴēćţ."],
@@ -720,6 +722,7 @@
]
],
"BGHHtQ": ["Śĩńĝĺē ƥàĝē"],
+ "BGoW3h": ["Ţũŕńĩńĝ ĩţ ōvēŕ…"],
"BGtzlf": [["uploadFolderName"], " — 1 ƒĩĺē"],
"BH56dn": ["Ćũśţōḿ ďĩśƥĺàŷ ţēxţ"],
"BKI4hX": ["Ƒĩńď ĩń ƒĩĺē"],
@@ -761,6 +764,7 @@
"CB7c0Z": ["Śàvē ǫũēũēď ḿēśśàĝē"],
"CBsdhe": ["Ţĥē àĝēńţ ĩśń'ţ śţōƥƥĩńĝ. Ƒōŕćē śţōƥ ćĺōśēś ţĥĩś ţĥŕēàď àńď ǫũĩţś ţĥē àĝēńţ."],
"CCTop_": ["Ŕēćēńţ"],
+ "CD8lBW": ["Ţĩďŷĩńĝ ũƥ…"],
"CFnavk": ["Ţĥĩś ƥŕōĴēćţ ĩśń'ţ à ĝĩţ ŕēƥōśĩţōŕŷ, śō ŵōŕķţŕēēś àŕēń'ţ àvàĩĺàƀĺē."],
"CHfFN_": ["Ŕēḿōvē ŌƥēńĶńōŵĺēďĝē ƒŕōḿ ", ["0"]],
"CKyk7Q": ["Ĝō ƀàćķ"],
@@ -807,8 +811,10 @@
],
"D2emTw": ["Śōḿēţĥĩńĝ ŵēńţ ŵŕōńĝ śēńďĩńĝ ŷōũŕ ƒēēďƀàćķ. Ƥĺēàśē ţŕŷ àĝàĩń."],
"D4H2N6": ["Ŕēḿōvē ", ["tag"]],
+ "D7hnvB": ["Ƥōńďēŕĩńĝ…"],
"D8JJwQ": ["Ƒēēďƀàćķ ĩśń'ţ àvàĩĺàƀĺē ŕĩĝĥţ ńōŵ. Ƥĺēàśē ţŕŷ àĝàĩń ĺàţēŕ."],
"D8OV7J": ["Ōńĺŷ ćōĺĺàƀōŕàţōŕś"],
+ "DCSSZt": ["Ţĥē àĝēńţ ĩś ŵōŕķĩńĝ"],
"DDTdLl": ["Ćōďē ƀĺōćķ śēţţĩńĝś"],
"DELNQk": ["Ćōĺĺàƀōŕàţōŕś śēē ŷōũŕ ĩń-ƥŕōĝŕēśś ēďĩţś àś śōōń àś ţĥēŷ śŷńć."],
"DEWDbv": ["Śĥōŵ ďĩàĝŕàḿ"],
@@ -1009,6 +1015,7 @@
"Śōũŕćē ḿōďē ŕēǫũĩŕēś à ĺĩvē ćōńńēćţĩōń — ŷōũŕ ēďĩţś àŕē śàvēď àńď ŵĩĺĺ àƥƥēàŕ ŵĥēń ŷōũ ŕēćōńńēćţ."
],
"G-h6qN": [["0", "plural", { "one": ["#", " ōƥţĩōń śēţ"], "other": ["#", " ōƥţĩōńś śēţ"] }]],
+ "G0I7bo": ["Ƥũźźĺĩńĝ…"],
"G0YZ-I": ["Ĩńďēńţ ōŕ ōũţďēńţ ĺĩśţ ĩţēḿ"],
"G1Gw0v": ["Ńēŵ ţēḿƥĺàţē"],
"G1XxbZ": ["Ćĥēćķƀōx"],
@@ -1063,6 +1070,7 @@
"GuaJb-": ["Ōƥēń ēḿàĩĺ ďŕàƒţ"],
"GubkSu": ["Ũśē à śţàŕţēŕ ƥàćķ"],
"GuqOb1": ["Ƒàĩĺēď ţō ĺōàď ĥēàďĩńĝś"],
+ "GwpcXB": ["Ďŕàƒţĩńĝ…"],
"Gx0VS1": ["ē.ĝ. ďŕàƒţś/ ōŕ *.ďŕàƒţ.ḿď"],
"GzPQ2f": ["Śţàŷ ĩń ţĥē ĺōōƥ"],
"H-hzll": ["Ƥĺēàśē ćĥōōśē Ĝōōď ōŕ Ńōţ ĝŕēàţ."],
@@ -1168,6 +1176,7 @@
"J6mxC1": ["À ńēţŵōŕķ ƥŕōƀĺēḿ ōŕ ĜĩţĤũƀ ōũţàĝē ĩńţēŕŕũƥţēď ţĥē ćĺōńē."],
"J7nMqi": ["Ũńĩńśţàĺĺ ŌƥēńĶńōŵĺēďĝē"],
"J86siq": ["Ĩńśţàĺĺ ƒŕōḿ ", ["plugin"]],
+ "JAQ09e": ["Ŕēƒĺēćţĩńĝ…"],
"JCxGEX": [
"Ńō ďĩśćōńńēćţēď ƥàĝēś. Ƥàĝēś àƥƥēàŕ ĥēŕē ōńĺŷ ŵĥēń ţĥēŷ ĥàvē ńō ĩńćōḿĩńĝ àńď ńō ōũţĝōĩńĝ ĝŕàƥĥ ēďĝēś."
],
@@ -1195,6 +1204,7 @@
"JsY1p5": ["Ďēńĩēď"],
"JtD-Br": ["Ƥàĝē ĺĩńķ"],
"Jw6EC4": ["ßŕàńćĥ śŵĩţćĥ ƒàĩĺēď — ţŕŷ ōƥēńĩńĝ ţĥē ", ["targetNoun"], " ḿàńũàĺĺŷ."],
+ "JyW5aS": ["Śĩƒţĩńĝ…"],
"K-a33w": ["Śţàŕţ ŵŕĩţĩńĝ ţō ćŕēàţē ţĥĩś ƥàĝē"],
"K-h9cT": ["Ćōũĺďń'ţ śàvē ţĥē ŕēśōĺũţĩōń ƒōŕ ", ["filePath"], "."],
"K0FgsP": [
@@ -1772,6 +1782,7 @@
"U9tm58": ["Ĥĩďē ƥŕōƀĺēḿ ĩńďĩćàţōŕś"],
"UBv8UK": ["Ďēĺēţē Ƥēŕḿàńēńţĺŷ"],
"UDFrWm": ["Ćĥēćķĩńĝ ĜĩţĤũƀ ćōńńēćţĩōń..."],
+ "UD_onR": ["Ḿũĺĺĩńĝ…"],
"UDb2YD": ["Ŕēàćţ"],
"UEdTEN": ["Ōŕƥĥàńēď"],
"UGeJuP": ["Àĺĺōŵēď vàĺũēś (ēḿƥţŷ = àńŷ)"],
@@ -1992,7 +2003,6 @@
"Xk0-VC": [
"Ƥŕēvĩēŵś ōƒ ĺĩńķś ţō ōţĥēŕ ďōćũḿēńţś ĩń ţĥĩś ƥŕōĴēćţ àŕē àĺŵàŷś ōń àńď ŕēàď ƒŕōḿ ţĥē ĺōćàĺ ĩńďēx — ńōţĥĩńĝ ĺēàvēś ŷōũŕ ćōḿƥũţēŕ ƒōŕ ţĥōśē."
],
- "XklovM": ["Ŵōŕķĩńĝ…"],
"Xl-UUg": ["ĝũĩďēś/ĩńśţàĺĺ ōŕ ĥţţƥś://ēxàḿƥĺē.ćōḿ"],
"XmJfZT": ["ńàḿē"],
"XnlF3W": ["Àďď ţĥē ńēxţ ḿàţćĥĩńĝ śōũŕćē śēĺēćţĩōń."],
@@ -2032,6 +2042,7 @@
"YEP3X2": ["Ďēĺēţē à ţàƀĺē ŵĥēń ţĥē àćţĩvē ţàƀĺē ćēĺĺ śēĺēćţĩōń ćōvēŕś ţĥē ƒũĺĺ ţàƀĺē."],
"YGIi_c": ["Ŕēĩńśţàĺĺ"],
"YGNRB5": ["— ēxćēƥţ"],
+ "YGt-0e": ["Ŕēàďĩńĝ…"],
"YJ1BTp": ["À śķĩĺĺ ŵĩţĥ ţĥàţ ńàḿē àĺŕēàďŷ ēxĩśţś."],
"YJPN3F": ["Ţōō śĺōŵ"],
"YKLP_-": ["Ţēḿƥĺàţē ŕēńàḿēď"],
@@ -2275,6 +2286,7 @@
"bkQRMh": ["Ƥàŕàĝŕàƥĥ"],
"blFttG": ["Śēàŕćĥ ƥŕōĴēćţś"],
"bmC18N": ["Ćĺēàŕĩńĝ ĺōćàĺ ćōĺĺàƀōŕàţĩōń ďàţà ƒōŕ \"", ["docName"], "\" ƀēƒōŕē ŕēćōńńēćţĩńĝ."],
+ "bnOTEz": ["Ŕēţŕĩēvĩńĝ…"],
"bpytj4": ["Ḿōvē ţō ", ["0"]],
"brCtGB": ["Ĥĩśţōŕŷ ũńàvàĩĺàƀĺē"],
"buNXgr": ["Śŵĩţćĥ ƀēţŵēēń ţĥē vĩśũàĺ àńď śōũŕćē ēďĩţōŕś, ķēēƥĩńĝ ŷōũŕ ƥĺàćē."],
@@ -2455,6 +2467,7 @@
"eTsJYJ": ["ďēśćŕĩƥţĩōń"],
"eUFXS1": ["Śōŕţ śķĩĺĺś"],
"eVPynQ": ["Ōƥēń <0><1>", ["verificationUri"], "</1><2/></0> àńď ēńţēŕ ţĥĩś ćōďē:"],
+ "eXPP7Z": ["Ćōńţēḿƥĺàţĩńĝ…"],
"eaHUxx": ["Ƒĩĺēś ţōōĺƀàŕ"],
"eazHgv": [
"Ĝĩţ ćàń'ţ ţŕàćķ ţĥĩś ƒōĺďēŕ — ĩţ'ś ēḿƥţŷ ōŕ ćōńţàĩńś ōńĺŷ ĩĝńōŕēď ƒĩĺēś. Ţĥē ĺĩńķ ŵōń'ţ ŵōŕķ ũńţĩĺ ŷōũ àďď à ţŕàćķēď ďōćũḿēńţ."
@@ -2578,6 +2591,7 @@
"glG1TR": ["Ƥũĺĺĩńĝ ţĥē ĺàţēśţ ćĥàńĝēś"],
"gljvbT": [["words", "plural", { "one": ["ŵōŕď"], "other": ["ŵōŕďś"] }]],
"glzsS_": ["Ƥàń ŕĩĝĥţ"],
+ "gmAH_b": ["Śōŕţĩńĝ…"],
"gmJ0An": ["Ƒàĩĺēď ţō ōƥēń ƒōĺďēŕ."],
"goO4Ll": ["Ēďĩţōŕ śţàţũś ƀàŕ"],
"gp3I7-": ["ßēƒōŕē śŷńćĩńĝ, śēţ ŷōũŕ ĩďēńţĩţŷ ƒōŕ ĝĩţ ćōḿḿĩţś:"],
@@ -2742,6 +2756,7 @@
"j9tqwO": ["Ńōţ ĩń śĩďēƀàŕ"],
"jAMpHn": ["Ŵĥàţ ĩś à śţàŕţēŕ ƥàćķ?"],
"jBVUXo": ["Ćōũĺďń'ţ ōƥēń ţĥē ţēŕḿĩńàĺ — ƥĺēàśē ţŕŷ àĝàĩń."],
+ "jC8Bv4": ["Ĥàvĩńĝ à ĺōōķ àŕōũńď…"],
"jC8LSZ": ["Ŕēśēţ vĩēŵ ƒĩĺţēŕś"],
"jENU1Q": [
"Àƥƥĺĩēś ţō àĺĺ ƥŕōĴēćţś ōń ţĥĩś ḿàćĥĩńē. Ćĺàũďē àńď Ćōďēx, śţàŕţēď ƒŕōḿ ţĥē ƀũĩĺţ-ĩń ţēŕḿĩńàĺ, àũţō-àƥƥŕōvē ŌƥēńĶńōŵĺēďĝē'ś ŕēàď àńď ŵŕĩţē ţōōĺś (Ćĺàũďē àĺśō àũţō-ŕũńś \"ōķ ōƥēń\"). Ďēĺēţĩńĝ, ḿōvĩńĝ, śĥàŕĩńĝ, ĩḿƥōŕţĩńĝ ōŕ ĩńśţàĺĺĩńĝ śķĩĺĺś, ōţĥēŕ ćōḿḿàńďś, àńď ńōń-ŌƥēńĶńōŵĺēďĝē ƒĩĺē ēďĩţś śţĩĺĺ àśķ. Ćũŕśōŕ, ŌƥēńĆōďē, àńď Ƥĩ àŕē ũńàƒƒēćţēď. ßēśţ-ēƒƒōŕţ ƥēŕ àĝēńţ."
@@ -2782,6 +2797,7 @@
"ju38ms": [
"Ţĥĩś ƥŕōĴēćţ ĥàś ńō ĝĩţ ŕēƥōśĩţōŕŷ — śĥàŕĩńĝ ḿōďē ďōēś ńōţ àƥƥĺŷ. Ĩńĩţĩàĺĩźē à ŕēƥō ţō ēńàƀĺē ţĥē ţōĝĝĺē."
],
+ "juD53g": ["Ďĩĝĝĩńĝ…"],
"jwnpdM": [
"À ţēḿƥĺàţē ńàḿēď <0>",
["trimmedSlug"],
@@ -3364,6 +3380,7 @@
" · ćŕàśĥ ďũḿƥ ńōţ ŕēďàćţēď"
],
"snrVQ7": ["ƥŕōƀē ƒàĩĺēď"],
+ "sqUrlK": ["Ḿũśĩńĝ…"],
"ssk6rl": [
"Ţĥē śķĩĺĺ'ś ōŵń ƒōĺďēŕ (",
["path"],
@@ -3442,6 +3459,7 @@
"uDlyqd": [
"Ďōćũḿēńţ ţĥē àŕćĥĩţēćţũŕē ōƒ ţĥĩś ŕēƥō: ćŕēàţē àń ōvēŕvĩēŵ ƥàĝē ţĥàţ ĺĩńķś ţō à ƥàĝē ƥēŕ ḿàĴōŕ ḿōďũĺē ďēśćŕĩƀĩńĝ ĩţś ŕēśƥōńśĩƀĩĺĩţĩēś àńď ēńţŕŷ ƥōĩńţś."
],
+ "uF82hk": ["Ƥēŕćōĺàţĩńĝ…"],
"uF9ruK": ["Śàvĩńĝ"],
"uFQbYd": ["Ĥōḿē ƥàĝē àńď ēńţŕŷ ƥōĩńţ."],
"uGaIIS": ["Ćĥēćķ ōũţ ŵōŕķţŕēē"],
@@ -3586,6 +3604,7 @@
],
"w_Sphq": ["Àţţàćĥḿēńţś"],
"wbv9xO": ["Ćŕēàţē ńēŵ ƥŕōĴēćţ"],
+ "wc54KE": ["Ţŕŷĩńĝ ĩţ ōũţ…"],
"wcfO9r": ["Ńō ƀũĝ ŕēƥōŕţś ŷēţ."],
"wdxz7K": ["Śōũŕćē"],
"wdzBgi": ["Ćōńƒĩĝ śĥàŕĩńĝ ĩś ńōŵ Ōńĺŷ ḿē."],
diff --git a/packages/app/src/locales/pseudo/messages.po b/packages/app/src/locales/pseudo/messages.po
index f984eb6f8..7cf0c7f9a 100644
--- a/packages/app/src/locales/pseudo/messages.po
+++ b/packages/app/src/locales/pseudo/messages.po
@@ -2536,6 +2536,10 @@ msgstr ""
msgid "Connects automatically the next time you open this project in a trusted Codex session."
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Contemplating…"
+msgstr ""
+
#: src/components/ConsentDialogBody.tsx
msgid "Content directory"
msgstr ""
@@ -3711,6 +3715,10 @@ msgstr ""
msgid "Different version here — click to compare and resolve"
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Digging…"
+msgstr ""
+
#. placeholder {0}: plugin.label
#. placeholder {0}: rule.name
#: src/components/settings/LintingSection.tsx
@@ -3901,6 +3909,10 @@ msgstr ""
msgid "Draft a technical spec for my project. Start with an overview, then add cross-linked pages for the architecture, the key modules, and the open questions, all linked from a specs index."
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Drafting…"
+msgstr ""
+
#: src/components/FrontmatterRow.tsx
msgid "Drag {keyName} to reorder"
msgstr ""
@@ -5191,6 +5203,10 @@ msgstr ""
msgid "Hard to use"
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Having a look around…"
+msgstr ""
+
#: src/editor/slash-command/items.tsx
msgid "Heading 1"
msgstr ""
@@ -6512,10 +6528,18 @@ msgstr ""
msgid "moved template"
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Mulling…"
+msgstr ""
+
#: src/editor/slash-command/component-items.tsx
msgid "Multi-page PDF viewer with toolbar controls (thumbnails, page nav, zoom)."
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Musing…"
+msgstr ""
+
#: src/components/NewWorktreeDialog.tsx
msgid "my-feature"
msgstr ""
@@ -7896,6 +7920,10 @@ msgstr ""
msgid "pending"
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Percolating…"
+msgstr ""
+
#: src/components/CreateProjectDialog.tsx
msgid "Permanently deletes <0>{targetGitPath}</0> and all its git history. Working files stay in place. If the parent git repo is intentional (e.g. you cloned it), cancel and pick a location outside it."
msgstr ""
@@ -7990,6 +8018,10 @@ msgstr ""
msgid "Point semantic search at any OpenAI-compatible embeddings endpoint — a self-hosted server or another provider. The API key above is for whichever endpoint you set here."
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Pondering…"
+msgstr ""
+
#: src/components/ExploreSkills.tsx
msgid "Popular"
msgstr ""
@@ -8228,6 +8260,10 @@ msgstr ""
msgid "Pushing"
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Puzzling…"
+msgstr ""
+
#: src/comments/comment-chips.tsx
#: src/comments/CommentQueuePanel.tsx
#: src/comments/CommentsPanel.tsx
@@ -8288,6 +8324,10 @@ msgstr ""
msgid "Read-only file in the {name} skill"
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Reading…"
+msgstr ""
+
#: src/components/SeedDialog.tsx
msgid "Ready-made folders and templates to get you started quickly."
msgstr ""
@@ -8361,6 +8401,10 @@ msgstr ""
msgid "Reference <0>{0}</0>"
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Reflecting…"
+msgstr ""
+
#: src/components/InstallInClaudeDesktopDialog.tsx
#: src/components/settings/IntegrationsSection.tsx
msgid "Reinstall"
@@ -8897,6 +8941,10 @@ msgstr ""
msgid "Resuming the conversation"
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Retrieving…"
+msgstr ""
+
#: src/components/ActivityModeContent.tsx
#: src/components/BugReportHistory.tsx
#: src/components/ConnectingBanner.tsx
@@ -8988,6 +9036,10 @@ msgstr ""
msgid "Rules"
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Ruminating…"
+msgstr ""
+
#: src/components/settings/LintingSection.tsx
msgid "Run a project audit from the Problems panel."
msgstr ""
@@ -9750,6 +9802,10 @@ msgstr ""
msgid "Shows above the code body. Round-trips as `title=\"...\"` in markdown."
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Sifting…"
+msgstr ""
+
#: src/components/settings/AccountSection.tsx
#: src/components/settings/SyncSection.tsx
#: src/components/ShareBranchSwitchDialog.tsx
@@ -9890,6 +9946,10 @@ msgstr ""
msgid "Sort skills"
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Sorting…"
+msgstr ""
+
#: src/components/SkillInstallMenu.tsx
msgid "source"
msgstr ""
@@ -10524,6 +10584,10 @@ msgstr ""
msgid "The <0>type</0> every document created from this template gets (e.g. <1>research-note</1>). Keeps new docs Open Knowledge Format–conformant."
msgstr ""
+#: src/components/WorkingAvatar.tsx
+msgid "The agent is working"
+msgstr ""
+
#: src/components/acp/ThreadView.tsx
msgid "The agent isn't stopping. Force stop closes this thread and quits the agent."
msgstr ""
@@ -10719,6 +10783,10 @@ msgstr ""
msgid "These rules come from your project's <0>{configFile}</0> file, which fully governs linting for this project. Turn rules on or off and edit their options here; changes write back to the file."
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Thinking…"
+msgstr ""
+
#: src/components/share-receive-miss-content.tsx
msgid "This {targetNoun} has been moved, renamed, or deleted in your local copy of branch <0>{branch}</0>, and that change hasn't synced yet."
msgstr ""
@@ -11016,6 +11084,10 @@ msgstr ""
msgid "This window can't store a token — open Settings from the main app window."
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Tidying up…"
+msgstr ""
+
#: src/components/DocPanel.tsx
#: src/components/TimelinePanel.tsx
msgid "Timeline"
@@ -11167,6 +11239,10 @@ msgstr ""
msgid "Try again"
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Trying it out…"
+msgstr ""
+
#. placeholder {0}: scope === 'global' ? `~/${o.root}` : o.root
#: src/components/settings/SkillTargetsPicker.tsx
msgid "Turn {0} back into a real directory holding a per-skill symlink for each skill it currently sees — nothing stops working, and each skill's menu manages it from there."
@@ -11201,6 +11277,10 @@ msgstr ""
msgid "Turn the things you read into clear, trusted articles. Save a source, figure out what it means, then keep the final version so you can rely on it later."
msgstr ""
+#: src/components/acp/working-status.ts
+msgid "Turning it over…"
+msgstr ""
+
#. placeholder {0}: skill.name
#: src/components/SkillForkDialog.tsx
msgid "Two versions of \"{0}\" — source vs {editor}"
@@ -11833,10 +11913,6 @@ msgstr ""
msgid "Working"
msgstr ""
-#: src/components/acp/ThreadView.tsx
-msgid "Working…"
-msgstr ""
-
#: src/lib/keyboard-shortcuts.ts
msgid "Workspace"
msgstr ""