@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/__tests__/voice-guardian-cold-cache-warm.test.ts

@@ -1,16 +1,13 @@
 /**
- * Cold-cache guardian voice/phone regression.
+ * Cold-cache guardian classification regression.
  *
  * The sync trust resolver (`resolveActorTrust`) reads the IO-free guardian-
  * delivery cache snapshot (`peekCachedGuardianDelivery`) keyed per channel
- * filter. On a cold process only `vellum` is warmed at daemon startup, so for
- * `phone` the snapshot is empty until some read warms that exact channel key.
- * The voice setup path therefore awaits
- * `getGuardianDeliveryFresh({ channelTypes: ["phone"] })` BEFORE the sync
- * resolve so an inbound guardian call classifies as `guardian` rather than
- * misclassifying during a gateway verdict blip. It reads FRESH because gateway-
- * side binding writes don't invalidate the daemon cache: a stale empty snapshot
- * from an earlier setup would otherwise survive the TTL.
+ * filter. On a cold process only `vellum` is warmed at daemon startup, so
+ * other channel keys stay empty until some async read warms that exact key —
+ * a cold snapshot classifies `unknown`, and gateway-side binding writes don't
+ * invalidate the daemon cache, so only `getGuardianDeliveryFresh` bypasses a
+ * stale empty snapshot before the TTL.
  *
  * This test drives the REAL guardian-delivery reader cache (mocking only the
  * gateway `ipcCall`) so the cold→warm transition is exercised end to end.
@@ -45,12 +42,6 @@ mock.module("../ipc/gateway-client.js", () => ({
   },
 }));
 
-// Member lookup is irrelevant to guardian classification (address match on the
-// cached delivery decides it); return null so the member path is a no-op.
-mock.module("../contacts/contact-store.js", () => ({
-  findContactByAddress: () => null,
-}));
-
 import {
   __resetGuardianDeliveryCacheForTest,
   getGuardianDelivery,
@@ -59,7 +50,7 @@ import {
 } from "../contacts/guardian-delivery-reader.js";
 import { resolveActorTrust } from "../runtime/actor-trust-resolver.js";
 
-describe("voice path warms the phone guardian cache before sync trust", () => {
+describe("guardian-delivery cache cold→warm transition for sync trust", () => {
   beforeEach(() => {
     __resetGuardianDeliveryCacheForTest();
     ipcCalls = [];
@@ -81,7 +72,7 @@ describe("voice path warms the phone guardian cache before sync trust", () => {
     });
     expect(cold.trustClass).toBe("unknown");
 
-    // The voice setup path warms the phone-specific key via the fresh reader.
+    // A fresh read warms the phone-specific key.
     await getGuardianDeliveryFresh({ channelTypes: ["phone"] });
     expect(
       ipcCalls.some(

package/src/__tests__/voice-scoped-grant-consumer.test.ts

@@ -20,14 +20,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Platform + logger mocks (must come before any source imports) ────
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
 // ── Config mock ─────────────────────────────────────────────────────
 
 mock.module("../config/loader.js", () => ({
@@ -102,7 +94,7 @@ import { initializeDb } from "../persistence/db-init.js";
 import { scopedApprovalGrants } from "../persistence/schema/index.js";
 
 const { createScopedApprovalGrant } = _internal;
-import type { TrustContext } from "../daemon/trust-context.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 
 await initializeDb();
@@ -139,7 +131,6 @@ function createMockSession(opts?: {
 
   const session = {
     isProcessing: () => false,
-    memoryPolicy: {},
     setAssistantId: () => {},
     setTrustContext: () => {},
     setCommandIntent: () => {},

package/src/__tests__/voice-session-bridge-processing-wait.test.ts

@@ -5,13 +5,6 @@ import { describe, expect, mock, test } from "bun:test";
 // imports (logger, config loader) stay side-effect free for this pure helper.
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({}),
 }));

package/src/__tests__/voice-session-bridge.test.ts

@@ -23,13 +23,6 @@ let mockedConfig: {
   memory: { enabled: false },
 };
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => mockedConfig,
 }));
@@ -45,6 +38,7 @@ mock.module("../daemon/conversation-store.js", () => ({
   },
 }));
 
+import { CALL_OPENING_MARKER } from "../calls/voice-control-protocol.js";
 import { startVoiceTurn } from "../calls/voice-session-bridge.js";
 import {
   createConversation,
@@ -68,10 +62,6 @@ function makeStreamingSession(events: ServerMessage[]): Conversation {
       id: "test-msg-id",
       deduplicated: false,
     }),
-    memoryPolicy: {
-      scopeId: "default",
-      includeDefaultFallback: false,
-    },
     setChannelCapabilities: () => {},
     setAssistantId: () => {},
     setTrustContext: () => {},
@@ -112,10 +102,6 @@ function makePersistingStreamingSession(
     currentRequestId: undefined,
     queue: {} as never,
     trustContext: undefined,
-    memoryPolicy: {
-      scopeId: "default",
-      includeDefaultFallback: false,
-    },
     isProcessing: () => processing,
     setProcessing: (value: boolean) => {
       processing = value;
@@ -279,10 +265,6 @@ describe("voice-session-bridge", () => {
         session.currentRequestId = options.requestId;
         return { id: "test-msg-id", deduplicated: false };
       },
-      memoryPolicy: {
-        scopeId: "default",
-        includeDefaultFallback: false,
-      },
       setChannelCapabilities: () => {},
       setAssistantId: () => {},
       setTrustContext: () => {},
@@ -368,10 +350,6 @@ describe("voice-session-bridge", () => {
         session.currentRequestId = options.requestId;
         return { id: "test-msg-id", deduplicated: false };
       },
-      memoryPolicy: {
-        scopeId: "default",
-        includeDefaultFallback: false,
-      },
       setChannelCapabilities: () => {},
       setAssistantId: () => {},
       setTrustContext: () => {},
@@ -577,7 +555,9 @@ describe("voice-session-bridge", () => {
     const session = {
       ...makeStreamingSession(events),
       setTrustContext: (ctx: unknown) => {
-        if (ctx != null) capturedTrustContext = ctx;
+        if (ctx != null) {
+          capturedTrustContext = ctx;
+        }
       },
     } as unknown as Conversation;
 
@@ -618,7 +598,9 @@ describe("voice-session-bridge", () => {
     const session = {
       ...makeStreamingSession(events),
       setVoiceCallControlPrompt: (prompt: string | null) => {
-        if (prompt != null) capturedPrompt = prompt;
+        if (prompt != null) {
+          capturedPrompt = prompt;
+        }
       },
     } as unknown as Conversation;
 
@@ -638,8 +620,9 @@ describe("voice-session-bridge", () => {
     });
 
     await new Promise((r) => setTimeout(r, 50));
-    if (!capturedPrompt)
+    if (!capturedPrompt) {
       throw new Error("Expected voice call control prompt to be set");
+    }
     const prompt: string = capturedPrompt;
 
     expect(prompt).toContain(
@@ -682,7 +665,9 @@ describe("voice-session-bridge", () => {
     const session = {
       ...makeStreamingSession(events),
       setVoiceCallControlPrompt: (prompt: string | null) => {
-        if (prompt != null) capturedPrompt = prompt;
+        if (prompt != null) {
+          capturedPrompt = prompt;
+        }
       },
     } as unknown as Conversation;
 
@@ -702,8 +687,9 @@ describe("voice-session-bridge", () => {
     });
 
     await new Promise((r) => setTimeout(r, 50));
-    if (!capturedPrompt)
+    if (!capturedPrompt) {
       throw new Error("Expected voice call control prompt to be set");
+    }
     const prompt: string = capturedPrompt;
 
     expect(prompt).toContain(
@@ -735,10 +721,6 @@ describe("voice-session-bridge", () => {
         id: "test-msg-id",
         deduplicated: false,
       }),
-      memoryPolicy: {
-        scopeId: "default",
-        includeDefaultFallback: false,
-      },
       setChannelCapabilities: () => {},
       setAssistantId: () => {},
       setTrustContext: () => {},
@@ -825,10 +807,6 @@ describe("voice-session-bridge", () => {
         id: "test-msg-id",
         deduplicated: false,
       }),
-      memoryPolicy: {
-        scopeId: "default",
-        includeDefaultFallback: false,
-      },
       setChannelCapabilities: () => {},
       setAssistantId: () => {},
       setTrustContext: () => {},
@@ -896,10 +874,6 @@ describe("voice-session-bridge", () => {
         id: "test-msg-id",
         deduplicated: false,
       }),
-      memoryPolicy: {
-        scopeId: "default",
-        includeDefaultFallback: false,
-      },
       setChannelCapabilities: () => {},
       setAssistantId: () => {},
       setTrustContext: () => {},
@@ -973,10 +947,6 @@ describe("voice-session-bridge", () => {
         id: "test-msg-id",
         deduplicated: false,
       }),
-      memoryPolicy: {
-        scopeId: "default",
-        includeDefaultFallback: false,
-      },
       setChannelCapabilities: () => {},
       setAssistantId: () => {},
       setTrustContext: () => {},
@@ -1066,10 +1036,6 @@ describe("voice-session-bridge", () => {
         id: "test-msg-id",
         deduplicated: false,
       }),
-      memoryPolicy: {
-        scopeId: "default",
-        includeDefaultFallback: false,
-      },
       setChannelCapabilities: () => {},
       setAssistantId: () => {},
       setTrustContext: () => {},
@@ -1142,10 +1108,6 @@ describe("voice-session-bridge", () => {
         id: "test-msg-id",
         deduplicated: false,
       }),
-      memoryPolicy: {
-        scopeId: "default",
-        includeDefaultFallback: false,
-      },
       setChannelCapabilities: () => {},
       setAssistantId: () => {},
       setTrustContext: () => {},
@@ -1214,10 +1176,6 @@ describe("voice-session-bridge", () => {
       persistUserMessage: async () => {
         throw new Error("simulated persistence failure");
       },
-      memoryPolicy: {
-        scopeId: "default",
-        includeDefaultFallback: false,
-      },
       setChannelCapabilities: () => {},
       setAssistantId: () => {},
       setTrustContext: () => {},
@@ -1277,10 +1235,6 @@ describe("voice-session-bridge", () => {
       persistUserMessage: async () => {
         throw new Error("simulated persistence failure");
       },
-      memoryPolicy: {
-        scopeId: "default",
-        includeDefaultFallback: false,
-      },
       setChannelCapabilities: recordLast("setChannelCapabilities"),
       setAssistantId: recordLast("setAssistantId"),
       setTrustContext: recordLast("setTrustContext"),
@@ -1347,10 +1301,6 @@ describe("voice-session-bridge", () => {
       persistUserMessage: async () => {
         throw new Error("persist failed before bridge installed callback");
       },
-      memoryPolicy: {
-        scopeId: "default",
-        includeDefaultFallback: false,
-      },
       setChannelCapabilities: () => {},
       setAssistantId: () => {},
       setTrustContext: () => {},
@@ -1411,10 +1361,6 @@ describe("voice-session-bridge", () => {
         session.currentRequestId = options.requestId;
         return { id: "test-msg-id", deduplicated: false };
       },
-      memoryPolicy: {
-        scopeId: "default",
-        includeDefaultFallback: false,
-      },
       setChannelCapabilities: () => {},
       setAssistantId: () => {},
       setTrustContext: () => {},
@@ -1450,4 +1396,106 @@ describe("voice-session-bridge", () => {
 
     expect(abortCalled).toBe(true);
   });
+
+  test("broadcasts a user_message_echo before the assistant reply streams (JARVIS-1258)", async () => {
+    const conversation = createConversation(
+      "voice bridge user echo ordering test",
+    );
+    const events: ServerMessage[] = [
+      {
+        type: "assistant_text_delta",
+        text: "Hi ",
+        conversationId: conversation.id,
+      },
+      {
+        type: "assistant_text_delta",
+        text: "there",
+        conversationId: conversation.id,
+      },
+      { type: "message_complete", conversationId: conversation.id },
+    ];
+    const session = makeStreamingSession(events);
+    injectDeps(() => session);
+
+    const published: ServerMessage[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      filter: { conversationId: conversation.id },
+      callback: (event) => {
+        published.push(event.message);
+      },
+    });
+
+    try {
+      await startVoiceTurn({
+        conversationId: conversation.id,
+        content: "Hello from caller",
+        isInbound: true,
+        onTextDelta: () => {},
+        onComplete: () => {},
+        onError: () => {},
+      });
+
+      await new Promise((r) => setTimeout(r, 50));
+
+      const echoIndex = published.findIndex(
+        (m) => m.type === "user_message_echo",
+      );
+      const firstDeltaIndex = published.findIndex(
+        (m) => m.type === "assistant_text_delta",
+      );
+
+      // The user turn boundary must be broadcast, and must precede the
+      // assistant deltas — otherwise the web client folds the reply into the
+      // previous assistant bubble until a /messages reconcile splits them.
+      expect(echoIndex).toBeGreaterThanOrEqual(0);
+      expect(firstDeltaIndex).toBeGreaterThan(echoIndex);
+      expect(published[echoIndex]).toMatchObject({
+        type: "user_message_echo",
+        text: "Hello from caller",
+        conversationId: conversation.id,
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("suppresses the user_message_echo for synthetic opener prompts", async () => {
+    const conversation = createConversation(
+      "voice bridge opener echo suppression test",
+    );
+    const events: ServerMessage[] = [
+      { type: "message_complete", conversationId: conversation.id },
+    ];
+    const session = makeStreamingSession(events);
+    injectDeps(() => session);
+
+    const published: ServerMessage[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      filter: { conversationId: conversation.id },
+      callback: (event) => {
+        published.push(event.message);
+      },
+    });
+
+    try {
+      await startVoiceTurn({
+        conversationId: conversation.id,
+        content: CALL_OPENING_MARKER,
+        isInbound: true,
+        onTextDelta: () => {},
+        onComplete: () => {},
+        onError: () => {},
+      });
+
+      await new Promise((r) => setTimeout(r, 50));
+
+      // The opener is internal scaffolding — it persists a row so the model
+      // wakes, but it is not user speech and must not render as a user bubble.
+      expect(published.some((m) => m.type === "user_message_echo")).toBe(false);
+    } finally {
+      subscription.dispose();
+    }
+  });
 });

package/src/__tests__/workspace-git-service.test.ts

@@ -69,7 +69,12 @@ describe("WorkspaceGitService", () => {
       expect(content).toContain("*.sock");
       expect(content).toContain("*.pid");
       expect(content).toContain("session-token");
-      expect(content).toContain("plugins/*/node_modules/");
+      expect(content).toContain("node_modules/");
+      expect(content).toContain("/embedding-models/");
+      expect(content).toContain(".DS_Store");
+      expect(content).toContain("*.png");
+      expect(content).toContain("*.jsonl");
+      expect(content).toContain("!conversations/**");
     });
 
     test("sets git identity correctly", async () => {
@@ -694,6 +699,47 @@ describe("WorkspaceGitService", () => {
       expect(branchAfter).toBe("main");
     });
 
+    test("gitignore rules and untracking apply to main after a branch switch", async () => {
+      execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
+      execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
+        cwd: testDir,
+      });
+      // main: committed runtime junk and a .gitignore without Vellum rules
+      writeFileSync(join(testDir, ".gitignore"), "main-rule\n");
+      mkdirSync(join(testDir, "embedding-models"), { recursive: true });
+      writeFileSync(join(testDir, "embedding-models", "model.bin"), "weights");
+      writeFileSync(join(testDir, "notes.md"), "keep me");
+      execFileSync("git", ["add", "-A", "-f"], { cwd: testDir });
+      execFileSync("git", ["commit", "-m", "init"], { cwd: testDir });
+      // Checked out on a branch whose .gitignore differs from main's
+      execFileSync("git", ["checkout", "-b", "legacy"], { cwd: testDir });
+      writeFileSync(join(testDir, ".gitignore"), "legacy-rule\n");
+      execFileSync("git", ["add", "-A"], { cwd: testDir });
+      execFileSync("git", ["commit", "-m", "legacy rule"], { cwd: testDir });
+
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      // Landed on main with the Vellum rules applied to MAIN's .gitignore
+      const branch = execFileSync("git", ["symbolic-ref", "--short", "HEAD"], {
+        cwd: testDir,
+        encoding: "utf-8",
+      }).trim();
+      expect(branch).toBe("main");
+      const content = readFileSync(join(testDir, ".gitignore"), "utf-8");
+      expect(content).toContain("main-rule");
+      expect(content).toContain("data/db/");
+
+      // Untracking ran against main's index
+      const tracked = execFileSync("git", ["ls-files"], {
+        cwd: testDir,
+        encoding: "utf-8",
+      });
+      expect(tracked).not.toContain("embedding-models/model.bin");
+      expect(tracked).toContain("notes.md");
+    });
+
     test("existing repo gets .gitignore rules appended on init", async () => {
       // Set up a pre-existing git repo without our gitignore rules
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
@@ -723,6 +769,165 @@ describe("WorkspaceGitService", () => {
       expect(contentAfter).toContain("session-token");
     });
 
+    test("existing repo with committed runtime state gets it untracked on init", async () => {
+      // Repo that committed runtime state before the ignore rule existed
+      execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
+      execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
+        cwd: testDir,
+      });
+      mkdirSync(join(testDir, "embedding-models"), { recursive: true });
+      writeFileSync(join(testDir, "embedding-models", "model.bin"), "weights");
+      writeFileSync(join(testDir, "notes.md"), "keep me");
+      execFileSync("git", ["add", "-A"], { cwd: testDir });
+      execFileSync("git", ["commit", "-m", "init"], { cwd: testDir });
+
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      // Now-ignored path is dropped from the index; tracked files survive.
+      const tracked = execFileSync("git", ["ls-files"], {
+        cwd: testDir,
+        encoding: "utf-8",
+      });
+      expect(tracked).not.toContain("embedding-models/model.bin");
+      expect(tracked).toContain("notes.md");
+
+      // Working tree is untouched — only the index entry is removed.
+      expect(existsSync(join(testDir, "embedding-models", "model.bin"))).toBe(
+        true,
+      );
+
+      // The staged deletion rides along with the next commit and the file
+      // is not re-added despite `git add -A`.
+      await service.commitChanges("next turn");
+      const headFiles = execFileSync(
+        "git",
+        ["ls-tree", "-r", "--name-only", "HEAD"],
+        { cwd: testDir, encoding: "utf-8" },
+      );
+      expect(headFiles).not.toContain("embedding-models/model.bin");
+      expect(headFiles).toContain("notes.md");
+    });
+
+    test("partial init with staged now-ignored files drops them from the initial commit", async () => {
+      // Interrupted previous init: `.git` exists with staged files, no commit
+      execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
+      mkdirSync(join(testDir, "embedding-models"), { recursive: true });
+      writeFileSync(join(testDir, "embedding-models", "model.bin"), "weights");
+      writeFileSync(join(testDir, "notes.md"), "keep me");
+      execFileSync("git", ["add", "-A"], { cwd: testDir });
+
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      const headFiles = execFileSync(
+        "git",
+        ["ls-tree", "-r", "--name-only", "HEAD"],
+        { cwd: testDir, encoding: "utf-8" },
+      );
+      expect(headFiles).not.toContain("embedding-models/model.bin");
+      expect(headFiles).toContain("notes.md");
+    });
+
+    test("untracking is limited to Vellum rules and keeps avatar/sounds state", async () => {
+      execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
+      execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
+        cwd: testDir,
+      });
+      // Canonical user state that matches the media extension rules
+      mkdirSync(join(testDir, "data", "avatar"), { recursive: true });
+      writeFileSync(join(testDir, "data", "avatar", "avatar-image.png"), "img");
+      mkdirSync(join(testDir, "data", "sounds"), { recursive: true });
+      writeFileSync(join(testDir, "data", "sounds", "ding.mp3"), "snd");
+      mkdirSync(join(testDir, "data", "apps", "my-app", "dist"), {
+        recursive: true,
+      });
+      writeFileSync(join(testDir, "data", "apps", "my-app", "icon.png"), "ic");
+      writeFileSync(
+        join(testDir, "data", "apps", "my-app", "dist", "bundle.png"),
+        "junk",
+      );
+      // Conversation disk views survive the *.jsonl rule
+      mkdirSync(join(testDir, "conversations", "conv-1"), { recursive: true });
+      writeFileSync(
+        join(testDir, "conversations", "conv-1", "messages.jsonl"),
+        "{}",
+      );
+      // Media junk elsewhere that should be untracked
+      mkdirSync(join(testDir, "pkb"), { recursive: true });
+      writeFileSync(join(testDir, "pkb", "photo.png"), "junk");
+      // Tracked file matching only the user's repo-local exclude file — the
+      // untrack step must not consult it.
+      writeFileSync(join(testDir, "fixture-keep.md"), "keep");
+      writeFileSync(
+        join(testDir, ".git", "info", "exclude"),
+        "fixture-keep.md\n",
+      );
+      // Force-added despite a user-authored .gitignore rule — the untrack
+      // step matches Vellum-managed rules only, so it must stay tracked.
+      writeFileSync(join(testDir, ".gitignore"), "user-secret.md\n");
+      writeFileSync(join(testDir, "user-secret.md"), "keep");
+      execFileSync("git", ["add", "-A", "-f"], { cwd: testDir });
+      execFileSync("git", ["commit", "-m", "init"], { cwd: testDir });
+
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      const tracked = execFileSync("git", ["ls-files"], {
+        cwd: testDir,
+        encoding: "utf-8",
+      });
+      expect(tracked).toContain("data/avatar/avatar-image.png");
+      expect(tracked).toContain("data/sounds/ding.mp3");
+      expect(tracked).toContain("data/apps/my-app/icon.png");
+      expect(tracked).toContain("conversations/conv-1/messages.jsonl");
+      expect(tracked).toContain("fixture-keep.md");
+      expect(tracked).toContain("user-secret.md");
+      expect(tracked).not.toContain("pkb/photo.png");
+      // The icon negation must not drag dist/ back in
+      expect(tracked).not.toContain("data/apps/my-app/dist/bundle.png");
+    });
+
+    test("appending rules keeps negations last even when already present mid-file", async () => {
+      execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
+      execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
+        cwd: testDir,
+      });
+      // Negation already present BEFORE the extension rules get appended —
+      // if it stayed there, a later *.png would win and re-ignore the avatar.
+      writeFileSync(
+        join(testDir, ".gitignore"),
+        "!data/avatar/**\nnode_modules/\n",
+      );
+      writeFileSync(join(testDir, "file.txt"), "content");
+      execFileSync("git", ["add", "-A"], { cwd: testDir });
+      execFileSync("git", ["commit", "-m", "init"], { cwd: testDir });
+
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      const content = readFileSync(join(testDir, ".gitignore"), "utf-8");
+      expect(content.lastIndexOf("!data/avatar/**")).toBeGreaterThan(
+        content.indexOf("*.png"),
+      );
+
+      // Effective behavior: the avatar path is not ignored (check-ignore
+      // exits 1 → throws), media elsewhere is (exits 0).
+      expect(() =>
+        execFileSync(
+          "git",
+          ["check-ignore", "-q", "data/avatar/avatar-image.png"],
+          { cwd: testDir },
+        ),
+      ).toThrow();
+      execFileSync("git", ["check-ignore", "-q", "pkb/photo.png"], {
+        cwd: testDir,
+      });
+    });
+
     test("existing repo with old data/ rule gets it replaced with selective rules", async () => {
       // Set up a pre-existing git repo with the OLD broad data/ rule
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
@@ -830,7 +1035,7 @@ describe("WorkspaceGitService", () => {
         cwd: testDir,
       });
       const gitignoreContent =
-        "# Runtime state - excluded from git tracking\ndata/db/\ndata/qdrant/\ndata/monitoring/\ndata/apps/*/records/\ndata/apps/*/dist/\ndata/apps/*.preview\nplugins/*/node_modules/\nlogs/\n*.log\n*.sock\n*.pid\n*.sqlite\n*.sqlite-journal\n*.sqlite-wal\n*.sqlite-shm\n*.db\n*.db-journal\n*.db-wal\n*.db-shm\nvellum.pid\nsession-token\n";
+        "# Runtime state - excluded from git tracking\ndata/db/\ndata/qdrant/\ndata/monitoring/\ndata/apps/*/records/\ndata/apps/*/dist/\ndata/apps/*.preview\n/embedding-models/\n/external/\n/bin/\n/plugins-data/\nnode_modules/\n__pycache__/\n.venv/\nlogs/\n*.log\n*.jsonl\n*.sock\n*.pid\ndaemon-startup.lock\nsession-token\n*.sqlite*\n*.db\n*.db-*\n.DS_Store\n*.zip\n*.tar\n*.gz\n*.tgz\n*.bz2\n*.xz\n*.7z\n*.rar\n*.dmg\n*.iso\n*.png\n*.jpg\n*.jpeg\n*.gif\n*.webp\n*.heic\n*.bmp\n*.tiff\n*.mp3\n*.wav\n*.m4a\n*.flac\n*.ogg\n*.mp4\n*.mov\n*.avi\n*.mkv\n*.webm\n*.pdf\n*.gguf\n*.onnx\n*.safetensors\n*.pt\n*.pth\n!data/avatar/**\n!data/sounds/**\n!data/apps/*/icon.png\n!conversations/**\n";
       writeFileSync(join(testDir, ".gitignore"), gitignoreContent);
       writeFileSync(join(testDir, "file.txt"), "content");
       execFileSync("git", ["add", "-A"], { cwd: testDir });