@vellumai/assistant 0.11.9-staging.2 → 0.11.9

package/src/avatar/__tests__/avatar-store.test.ts

@@ -32,7 +32,13 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { clearAvatar, setCharacter, setImage } from "../avatar-store.js";
+import {
+  backfillAccent,
+  clearAvatar,
+  setAccent,
+  setCharacter,
+  setImage,
+} from "../avatar-store.js";
 
 // A valid trait triple drawn from the real component set.
 const VALID_TRAITS = { bodyShape: "blob", eyeStyle: "curious", color: "green" };
@@ -43,11 +49,18 @@ const ASCII_FILENAME = "character-ascii.txt";
 const MANIFEST_FILENAME = "avatar.json";
 const NATIVE_RENDER_TEST_TIMEOUT_MS = 15_000;
 
+/** A 4x4 PNG of one red (#c81e1e), so an accent can be read out of it. */
+const RED_PNG = Buffer.from(
+  "iVBORw0KGgoAAAANSUhEUgAAAAQAAAAECAYAAACp8Z5+AAAACXBIWXMAAAPoAAAD6AG1e1JrAAAAEklEQVQImWM4ISf3HxkzkC4AAEG4IDHG8wOiAAAAAElFTkSuQmCC",
+  "base64",
+);
+
 interface ManifestShape {
   kind: string;
   traits: Record<string, unknown> | null;
   source: string | null;
   image: { updatedAt: string; etag: string } | null;
+  accent: { hex: string; source: string } | null;
 }
 
 describe("avatar-store", () => {
@@ -117,6 +130,8 @@ describe("avatar-store", () => {
         expect(manifest!.source).toBe("builder");
         expect(manifest!.image).not.toBeNull();
         expect(manifest!.image!.etag).toMatch(/^[0-9a-f]{16}$/);
+        // The accent is the chosen palette colour.
+        expect(manifest!.accent).toEqual({ hex: "#4C9B50", source: "palette" });
       },
       NATIVE_RENDER_TEST_TIMEOUT_MS,
     );
@@ -135,8 +150,8 @@ describe("avatar-store", () => {
   });
 
   describe("setImage", () => {
-    test("writes the PNG and an image manifest", () => {
-      setImage(Buffer.from("fake png bytes"), "upload");
+    test("writes the PNG and an image manifest", async () => {
+      await setImage(Buffer.from("fake png bytes"), "upload");
 
       expect(existsSync(path(IMAGE_FILENAME))).toBe(true);
       expect(readFileSync(path(IMAGE_FILENAME)).toString()).toBe(
@@ -153,14 +168,24 @@ describe("avatar-store", () => {
       expect(manifest!.image!.updatedAt).toMatch(
         /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/,
       );
+      // Bytes that do not decode carry no colour, and that is not a failure.
+      expect(manifest!.accent).toBeNull();
+    });
+
+    test("reads the accent out of the image", async () => {
+      await setImage(RED_PNG, "upload");
+      expect(readManifestFile()!.accent).toEqual({
+        hex: "#c81e1e",
+        source: "derived",
+      });
     });
 
-    test("removes stale character sidecars on transition", () => {
+    test("removes stale character sidecars on transition", async () => {
       // Seed legacy character artifacts.
       writeFileSync(path(TRAITS_FILENAME), JSON.stringify(VALID_TRAITS));
       writeFileSync(path(ASCII_FILENAME), "ascii art");
 
-      setImage(Buffer.from("png"), "ai");
+      await setImage(Buffer.from("png"), "ai");
 
       expect(existsSync(path(TRAITS_FILENAME))).toBe(false);
       expect(existsSync(path(ASCII_FILENAME))).toBe(false);
@@ -168,15 +193,112 @@ describe("avatar-store", () => {
       expect(readManifestFile()!.kind).toBe("image");
     });
 
-    test("is idempotent across repeated calls", () => {
-      setImage(Buffer.from("v1"), "upload");
-      setImage(Buffer.from("v2"), "upload");
+    test("is idempotent across repeated calls", async () => {
+      await setImage(Buffer.from("v1"), "upload");
+      await setImage(Buffer.from("v2"), "upload");
 
       expect(readFileSync(path(IMAGE_FILENAME)).toString()).toBe("v2");
       expect(readManifestFile()!.kind).toBe("image");
     });
   });
 
+  describe("setAccent", () => {
+    test("writes a custom accent over an image without touching the artifacts", async () => {
+      await setImage(RED_PNG, "upload");
+      const before = readManifestFile()!;
+
+      const state = await setAccent("#12ab34");
+      expect(state?.accent).toEqual({ hex: "#12ab34", source: "custom" });
+      const after = readManifestFile()!;
+      expect(after.accent).toEqual({ hex: "#12ab34", source: "custom" });
+      expect(after.image).toEqual(before.image);
+      expect(readFileSync(path(IMAGE_FILENAME))).toEqual(RED_PNG);
+    });
+
+    test("null returns an image to the colour read out of it", async () => {
+      await setImage(RED_PNG, "upload");
+      await setAccent("#12ab34");
+
+      const state = await setAccent(null);
+      expect(state?.accent).toEqual({ hex: "#c81e1e", source: "derived" });
+      expect(readManifestFile()!.accent).toEqual({
+        hex: "#c81e1e",
+        source: "derived",
+      });
+    });
+
+    test("null returns a character to its palette colour", async () => {
+      // Seeded as a manifest rather than through setCharacter, whose native
+      // renderer may be absent here.
+      writeFileSync(
+        path(MANIFEST_FILENAME),
+        JSON.stringify({
+          kind: "character",
+          traits: { ...VALID_TRAITS, color: "orange" },
+          source: "builder",
+          image: null,
+          accent: { hex: "#12ab34", source: "custom" },
+        }),
+      );
+
+      const state = await setAccent(null);
+      expect(state?.accent).toEqual({ hex: "#E9642F", source: "palette" });
+    });
+
+    test("refuses when there is no avatar, writing nothing", async () => {
+      expect(await setAccent("#12ab34")).toBeNull();
+      expect(readManifestFile()).toBeNull();
+    });
+  });
+
+  describe("backfillAccent", () => {
+    const imageState = (etag: string) => ({
+      kind: "image" as const,
+      traits: null,
+      source: "upload" as const,
+      image: { updatedAt: "2026-01-01T00:00:00.000Z", etag },
+      accent: null,
+    });
+
+    test("reads an image's accent out of the PNG on disk and persists it", async () => {
+      writeFileSync(path(IMAGE_FILENAME), RED_PNG);
+      const state = imageState("backfill-red");
+      writeFileSync(path(MANIFEST_FILENAME), JSON.stringify(state));
+
+      const result = await backfillAccent(state);
+      expect(result.accent).toEqual({ hex: "#c81e1e", source: "derived" });
+      expect(readManifestFile()!.accent).toEqual({
+        hex: "#c81e1e",
+        source: "derived",
+      });
+    });
+
+    test("leaves a state that already has an accent, or none to derive, alone", async () => {
+      const withAccent = {
+        ...imageState("has-accent"),
+        accent: { hex: "#12ab34", source: "custom" as const },
+      };
+      expect(await backfillAccent(withAccent)).toBe(withAccent);
+
+      const none = {
+        kind: "none" as const,
+        traits: null,
+        source: null,
+        image: null,
+        accent: null,
+      };
+      expect(await backfillAccent(none)).toBe(none);
+      expect(readManifestFile()).toBeNull();
+    });
+
+    test("returns the state unchanged, and writes nothing, when the image cannot be read", async () => {
+      writeFileSync(path(IMAGE_FILENAME), Buffer.from("not a png"));
+      const state = imageState("backfill-bad");
+      expect(await backfillAccent(state)).toBe(state);
+      expect(readManifestFile()).toBeNull();
+    });
+  });
+
   describe("clearAvatar", () => {
     test("removes all artifacts AND the manifest (none == absence)", () => {
       writeFileSync(path(IMAGE_FILENAME), Buffer.from("png"));

package/src/avatar/__tests__/ensure-raster.test.ts

@@ -68,6 +68,7 @@ describe("ensureAvatarRaster", () => {
       traits: null,
       source: null,
       image: null,
+      accent: null,
     });
     expect(await ensureAvatarRaster()).toBeNull();
   });
@@ -83,6 +84,7 @@ describe("ensureAvatarRaster", () => {
       traits: null,
       source: "upload",
       image: { updatedAt: new Date().toISOString(), etag: "0123456789abcdef" },
+      accent: null,
     });
     const raster = await ensureAvatarRaster();
     expect(raster).not.toBeNull();
@@ -96,6 +98,7 @@ describe("ensureAvatarRaster", () => {
       traits: VALID_TRAITS,
       source: "builder",
       image: null,
+      accent: null,
     });
     // Force the unavailable path: a re-render attempt would return null.
     __setResvgCacheForTests({ available: false, error: new Error("nope") });
@@ -113,6 +116,7 @@ describe("ensureAvatarRaster", () => {
       traits: null,
       source: "upload",
       image: { updatedAt: new Date().toISOString(), etag: "0123456789abcdef" },
+      accent: null,
     });
     expect(await ensureAvatarRasterPath()).toBe(
       join(avatarDir, IMAGE_FILENAME),
@@ -130,6 +134,7 @@ describe("ensureAvatarRaster", () => {
       traits: null,
       source: "upload",
       image: { updatedAt: new Date().toISOString(), etag: "0123456789abcdef" },
+      accent: null,
     });
     expect(await ensureAvatarRaster()).toBeNull();
     rmSync(foreign, { recursive: true, force: true });
@@ -141,6 +146,7 @@ describe("ensureAvatarRaster", () => {
       traits: null,
       source: "upload",
       image: { updatedAt: new Date().toISOString(), etag: "0123456789abcdef" },
+      accent: null,
     });
     expect(await ensureAvatarRaster()).toBeNull();
     expect(existsSync(join(avatarDir, IMAGE_FILENAME))).toBe(false);
@@ -152,6 +158,7 @@ describe("ensureAvatarRaster", () => {
       traits: VALID_TRAITS,
       source: "builder",
       image: null,
+      accent: null,
     });
     __setResvgCacheForTests({ available: false, error: new Error("nope") });
     expect(await ensureAvatarRaster()).toBeNull();
@@ -166,6 +173,7 @@ describe("ensureAvatarRaster", () => {
         traits: VALID_TRAITS,
         source: "builder",
         image: null,
+        accent: null,
       });
       const raster = await ensureAvatarRaster();
       if (!isResvgAvailable()) {
@@ -192,6 +200,7 @@ describe("ensureAvatarRaster", () => {
         traits: null,
         source: null,
         image: null,
+        accent: null,
       }),
     ).toBeNull();
   });
@@ -204,6 +213,7 @@ describe("ensureAvatarRaster", () => {
         traits: null,
         source: null,
         image: null,
+        accent: null,
       });
       expect(await ensureAvatarRasterPath()).toBeNull();
     });
@@ -218,6 +228,7 @@ describe("ensureAvatarRaster", () => {
           updatedAt: new Date().toISOString(),
           etag: "0123456789abcdef",
         },
+        accent: null,
       });
       expect(await ensureAvatarRasterPath()).toBe(
         join(avatarDir, IMAGE_FILENAME),
@@ -236,6 +247,7 @@ describe("ensureAvatarRaster", () => {
           updatedAt: new Date().toISOString(),
           etag: "0123456789abcdef",
         },
+        accent: null,
       });
       expect(await ensureAvatarRasterPath()).toBe(
         join(avatarDir, IMAGE_FILENAME),
@@ -252,6 +264,7 @@ describe("ensureAvatarRaster", () => {
           updatedAt: new Date().toISOString(),
           etag: "0123456789abcdef",
         },
+        accent: null,
       });
       expect(await ensureAvatarRasterPath()).toBeNull();
     });
@@ -262,6 +275,7 @@ describe("ensureAvatarRaster", () => {
         traits: VALID_TRAITS,
         source: "builder",
         image: null,
+        accent: null,
       });
       __setResvgCacheForTests({ available: false, error: new Error("nope") });
       expect(await ensureAvatarRasterPath()).toBeNull();
@@ -276,6 +290,7 @@ describe("ensureAvatarRaster", () => {
           traits: VALID_TRAITS,
           source: "builder",
           image: null,
+          accent: null,
         });
         const path = await ensureAvatarRasterPath();
         if (!isResvgAvailable()) {

package/src/avatar/avatar-accent.ts

@@ -0,0 +1,57 @@
+/**
+ * Reading an accent colour out of an avatar image.
+ *
+ * The colour maths is `dominantAccentHex` in `@vellumai/avatar-manifest`,
+ * shared with the web so both sides agree on what colour an image is. This
+ * module only decodes: sharp turns the upload into a small square of RGBA
+ * pixels, centre-cropped the way the avatar is drawn, so the sample comes from
+ * the pixels the user actually sees.
+ */
+import { accentHexForColorId } from "@vellumai/avatar-catalog/colors";
+import {
+  type AvatarAccent,
+  dominantAccentHex,
+} from "@vellumai/avatar-manifest";
+
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("avatar-accent");
+
+/** Side of the square the image is sampled at; enough for a histogram, cheap to decode to. */
+const SAMPLE_SIZE = 48;
+
+/**
+ * The dominant accent of an image, or null when the bytes cannot be decoded
+ * or hold no opaque pixel. Never throws: the accent decorates surfaces, and a
+ * decode failure must not fail the upload that carried the image.
+ */
+export async function deriveAccentHexFromImage(
+  bytes: Buffer,
+): Promise<string | null> {
+  try {
+    const { default: sharp } = await import("sharp");
+    const { data } = await sharp(bytes, { failOn: "error" })
+      .resize(SAMPLE_SIZE, SAMPLE_SIZE, { fit: "cover" })
+      .ensureAlpha()
+      .raw()
+      .toBuffer({ resolveWithObject: true });
+    return dominantAccentHex(data);
+  } catch (err) {
+    log.warn(
+      { err },
+      "Could not read an accent colour out of the avatar image",
+    );
+    return null;
+  }
+}
+
+/** The accent a character wears: its palette colour. Null for an id the palette lacks. */
+export function paletteAccent(colorId: string): AvatarAccent | null {
+  const hex = accentHexForColorId(colorId);
+  return hex ? { hex, source: "palette" } : null;
+}
+
+/** The accent read out of an image's pixels, or null when there was none to read. */
+export function derivedAccent(hex: string | null): AvatarAccent | null {
+  return hex ? { hex, source: "derived" } : null;
+}

package/src/avatar/avatar-manifest.ts

@@ -21,6 +21,7 @@ import {
   AVATAR_IMAGE_FILENAME,
   AVATAR_MANIFEST_FILENAME,
   AVATAR_TRAITS_FILENAME,
+  type AvatarAccent,
   type AvatarImageMeta,
   type AvatarKind,
   type AvatarSource,
@@ -32,10 +33,17 @@ import {
 
 import { getLogger } from "../util/logger.js";
 import { getAvatarDir } from "../util/platform.js";
+import { paletteAccent } from "./avatar-accent.js";
 
 const log = getLogger("avatar-manifest");
 
-export type { AvatarImageMeta, AvatarKind, AvatarSource, AvatarState };
+export type {
+  AvatarAccent,
+  AvatarImageMeta,
+  AvatarKind,
+  AvatarSource,
+  AvatarState,
+};
 export type { CharacterTraits };
 
 /**
@@ -134,16 +142,26 @@ export function deriveStateFromLegacyFiles(
         traits: derived.traits,
         source: null,
         image: null,
+        accent: paletteAccent(derived.traits.color),
       };
     case "image":
+      // The image's accent is read out of its pixels by the store's backfill,
+      // which the state route runs; this derivation stays synchronous.
       return {
         kind: "image",
         traits: null,
         source: null,
         image: computeImageMeta(imagePath),
+        accent: null,
       };
     case "none":
-      return { kind: "none", traits: null, source: null, image: null };
+      return {
+        kind: "none",
+        traits: null,
+        source: null,
+        image: null,
+        accent: null,
+      };
   }
 }
 

package/src/avatar/avatar-store.ts

@@ -19,15 +19,24 @@ import {
   AVATAR_IMAGE_FILENAME,
   AVATAR_MANIFEST_FILENAME,
   AVATAR_TRAITS_FILENAME,
+  type AvatarAccent,
 } from "@vellumai/avatar-manifest";
 
 import { getLogger } from "../util/logger.js";
 import { getAvatarDir, getAvatarImagePath } from "../util/platform.js";
+import {
+  deriveAccentHexFromImage,
+  derivedAccent,
+  paletteAccent,
+} from "./avatar-accent.js";
 import {
   type AvatarSource,
+  type AvatarState,
   computeImageMeta,
+  readAvatarState,
   writeManifest,
 } from "./avatar-manifest.js";
+import { readContainedAvatarRaster } from "./ensure-raster.js";
 import {
   ASCII_FILENAME,
   type CharacterTraits,
@@ -58,6 +67,7 @@ export function setCharacter(traits: CharacterTraits): TraitsSyncResult {
     traits,
     source: "builder",
     image: computeImageMeta(getAvatarImagePath()),
+    accent: paletteAccent(traits.color),
   });
   return result;
 }
@@ -65,10 +75,15 @@ export function setCharacter(traits: CharacterTraits): TraitsSyncResult {
 /**
  * Sets the avatar to an uploaded/AI image: atomically writes the PNG, removes
  * the now-stale character sidecars (traits + ASCII), then records an `image`
- * manifest. The PNG is written before the manifest so an interrupted call never
- * leaves the manifest ahead of the artifact.
+ * manifest carrying the accent read out of the image. The accent is derived
+ * before anything is written and the PNG is written before the manifest, so an
+ * interrupted call never leaves the manifest ahead of the artifact.
  */
-export function setImage(pngBuffer: Buffer, source: AvatarSource): void {
+export async function setImage(
+  pngBuffer: Buffer,
+  source: AvatarSource,
+): Promise<void> {
+  const accent = derivedAccent(await deriveAccentHexFromImage(pngBuffer));
   const avatarDir = getAvatarDir();
   mkdirSync(avatarDir, { recursive: true });
 
@@ -85,9 +100,101 @@ export function setImage(pngBuffer: Buffer, source: AvatarSource): void {
     traits: null,
     source,
     image: computeImageMeta(pngPath),
+    accent,
   });
 
-  log.info({ source }, "Set avatar from image and removed character sidecars");
+  log.info(
+    { source, accent: accent?.hex ?? null },
+    "Set avatar from image and removed character sidecars",
+  );
+}
+
+/**
+ * The accent the current avatar earns on its own: a character's palette
+ * colour, or the colour read out of the image on disk. Null for `none`, and
+ * for an image that cannot be read.
+ */
+async function automaticAccent(
+  state: AvatarState,
+): Promise<AvatarAccent | null> {
+  if (state.kind === "character" && state.traits) {
+    return paletteAccent(state.traits.color);
+  }
+  if (state.kind === "image") {
+    const bytes = readContainedAvatarRaster(getAvatarImagePath());
+    return bytes ? derivedAccent(await deriveAccentHexFromImage(bytes)) : null;
+  }
+  return null;
+}
+
+/**
+ * Sets the accent over the current avatar: a `#rrggbb` the user chose, or
+ * `null` to go back to the automatic one. Returns the state as written, or
+ * null when there is no avatar to colour. Only the manifest changes; the
+ * artifacts are untouched.
+ */
+export async function setAccent(
+  hex: string | null,
+): Promise<AvatarState | null> {
+  const state = readAvatarState();
+  if (state.kind === "none") {
+    return null;
+  }
+  const next: AvatarState = {
+    ...state,
+    accent: hex ? { hex, source: "custom" } : await automaticAccent(state),
+  };
+  writeManifest(next);
+  return next;
+}
+
+/**
+ * Image etags whose accent derivation came back empty. Remembered so a read
+ * of an unreadable image does not decode it again on every request; a new
+ * upload carries a new etag and is tried afresh.
+ */
+const accentlessImageEtags = new Set<string>();
+/** The one derivation in flight per etag, so concurrent reads share it. */
+const pendingAccents = new Map<string, Promise<AvatarAccent | null>>();
+
+/**
+ * Fills in the accent of a state written before accents existed, persisting
+ * it so later reads are manifest-only. The one exception to the manifest
+ * being written only by the mutations above, for the same reason the read
+ * handlers self-heal a missing manifest: the accent is derivable from what is
+ * on disk, and deriving it once beats every client deriving it on every read.
+ * The persist is best-effort; a read-only workspace still gets the accent.
+ */
+export async function backfillAccent(state: AvatarState): Promise<AvatarState> {
+  if (state.kind === "none" || state.accent !== null) {
+    return state;
+  }
+  const etag = state.image?.etag ?? null;
+  if (etag && accentlessImageEtags.has(etag)) {
+    return state;
+  }
+  const key = etag ?? state.kind;
+  let pending = pendingAccents.get(key);
+  if (!pending) {
+    pending = automaticAccent(state).finally(() => {
+      pendingAccents.delete(key);
+    });
+    pendingAccents.set(key, pending);
+  }
+  const accent = await pending;
+  if (!accent) {
+    if (etag) {
+      accentlessImageEtags.add(etag);
+    }
+    return state;
+  }
+  const next: AvatarState = { ...state, accent };
+  try {
+    writeManifest(next);
+  } catch (err) {
+    log.warn({ err }, "Failed to persist the backfilled avatar accent");
+  }
+  return next;
 }
 
 /**

package/src/config/bundled-skills/media-processing/SKILL.md

@@ -25,7 +25,7 @@ The processing pipeline follows a sequential 3-phase flow:
 
 1. **Ingest** (`ingest_media`) - Register a media file, detect MIME type, extract duration, deduplicate by content hash.
 2. **Preprocess** (`extract_keyframes`) - Detect dead time, segment the video into windows, extract downscaled keyframes, build a subject registry, and write a pipeline manifest.
-3. **Map** (`analyze_keyframes`) - Send each segment's frames to Gemini 2.5 Flash with assistant-provided extraction instructions and a JSON Schema for guaranteed structured output. Supports concurrency pooling, cost tracking, resumability, and automatic retries.
+3. **Map** (`analyze_keyframes`) - Send each segment's frames to the configured Gemini vision model with assistant-provided extraction instructions and a JSON Schema for guaranteed structured output. Supports concurrency pooling, cost tracking, resumability, and automatic retries.
 4. **Reduce / Query** (`query_media`) - Send all map output to Claude for intelligent analysis and Q&A. Supports arbitrary natural language queries about video content.
 5. **Clip** (`generate_clip`) - Extract video clips around specific moments.
 
@@ -85,7 +85,7 @@ Parameters:
 - `asset_id` (required) - ID of the media asset.
 - `query` (required) - Natural language query about the video data.
 - `system_prompt` - Optional system prompt for Claude.
-- `model` - LLM model to use (default: `claude-sonnet-4-6`).
+- `model` - LLM model to use. Defaults to the assistant's active chat model.
 
 ### generate_clip
 
@@ -110,7 +110,7 @@ Handles dead-time detection, video segmentation, keyframe extraction, and subjec
 
 ### Gemini Map (services/gemini-map.ts)
 
-Sends video segments to Gemini 2.5 Flash with structured output schemas. Handles concurrency pooling, cost tracking, resumability, and retries.
+Sends video segments to the configured Gemini vision model with structured output schemas. Handles concurrency pooling, cost tracking, resumability, and retries.
 
 ### Reduce (services/reduce.ts)
 

package/src/config/bundled-skills/media-processing/TOOLS.json

@@ -170,7 +170,7 @@
           },
           "model": {
             "type": "string",
-            "description": "LLM model to use for analysis. Default: 'claude-sonnet-4-6'"
+            "description": "LLM model to use for analysis. Defaults to the assistant's active chat model."
           }
         },
         "required": ["asset_id", "query"]

package/src/config/bundled-skills/schedule/SKILL.md

@@ -247,4 +247,4 @@ Choose the right delivery tool based on the content:
 
 Example schedule message for a Slack digest:
 
-> "Scan my Slack channels for the last 24 hours using the Slack Web API via bash (network_mode: proxied, credential_ids: ['slack_channel/bot_token']), then post the summary to #alex-agent-messages (C0A7STRJ4G5)."
+> "Scan my Slack channels for the last 24 hours using the Slack Web API via bash (network_mode: proxied, credential_ids: ['slack_channel/bot_token']), then post the summary to the channel the user named."

package/src/platform/sync-avatar.test.ts

@@ -127,6 +127,7 @@ function imageState(etag: string): AvatarState {
     traits: null,
     source: "upload",
     image: { updatedAt: "2026-01-01T00:00:00.000Z", etag },
+    accent: null,
   };
 }
 
@@ -135,6 +136,7 @@ const NONE: AvatarState = {
   traits: null,
   source: null,
   image: null,
+  accent: null,
 };
 
 interface Patch {
@@ -275,6 +277,7 @@ describe("syncAvatarToPlatform", () => {
       traits: { bodyShape: "blob", eyeStyle: "curious", color: "green" },
       source: null,
       image: null,
+      accent: null,
     };
     mockRasterPath = null;
     syncAvatarToPlatform();