@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/__tests__/host-app-control-routes.test.ts

@@ -47,7 +47,7 @@ interface FakeConversation {
 
 const conversations = new Map<string, FakeConversation>();
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => conversations.get(id),
 }));
 

package/src/__tests__/host-cu-proxy.test.ts

@@ -21,6 +21,8 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: {
     getMostRecentClientByCapability: (cap: string) =>
       cap === "host_cu" && mockHasClient ? { id: "mock-client" } : null,
+    listClientsByCapability: (cap: string) =>
+      cap === "host_cu" ? mockClients : [],
     getClientById: (id: string) =>
       mockClients.find((c) => c.clientId === id) ?? undefined,
     getActorPrincipalIdForClient: (id: string) =>

package/src/__tests__/host-cu-routes-targeted.test.ts

@@ -8,9 +8,9 @@
  *  4. Untargeted (no targetClientId, no header) → 200 accepted (regression)
  *
  * Resolution goes through conversation.hostCuProxy?.resolve(...). The
- * conversation store is mocked to return a controlled conversation object.
+ * conversation registry is mocked to return a controlled conversation object.
  *
- * Note: host-cu-routes.ts has a deep import chain (conversation-store →
+ * Note: host-cu-routes.ts has a deep import chain (conversation-registry →
  * conversation.ts → ces-client → service-contracts) that requires mocking
  * before the module loads. We use dynamic imports to ensure all mocks are
  * registered before the route module is evaluated.
@@ -75,7 +75,7 @@ const conversationStore = new Map<
   { hostCuProxy?: { processObservation: (...args: unknown[]) => void } }
 >();
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (conversationId: string) =>
     conversationStore.get(conversationId),
 }));

package/src/__tests__/host-file-edit-tool.test.ts

@@ -12,7 +12,8 @@ let mockFileProxyRequestFn: (
   input: HostFileInput,
   conversationId: string,
   signal?: AbortSignal,
-) => Promise<ToolExecutionResult> = () => Promise.resolve({ content: "", isError: false });
+) => Promise<ToolExecutionResult> = () =>
+  Promise.resolve({ content: "", isError: false });
 
 mock.module("../daemon/host-file-proxy.js", () => ({
   HostFileProxy: {
@@ -43,7 +44,8 @@ afterEach(() => {
     rmSync(dir, { recursive: true, force: true });
   }
   mockFileProxyAvailable = false;
-  mockFileProxyRequestFn = () => Promise.resolve({ content: "", isError: false });
+  mockFileProxyRequestFn = () =>
+    Promise.resolve({ content: "", isError: false });
 });
 
 describe("host_file_edit tool", () => {

package/src/__tests__/host-file-proxy.test.ts

@@ -163,6 +163,37 @@ describe("HostFileProxy", () => {
       });
     });
 
+    test("rebuilds audio tool results from proxied audio payloads", async () => {
+      setup();
+
+      const resultPromise = proxy.request(
+        { operation: "read", path: "/Users/test/Desktop/voice.mp3" },
+        "session-1",
+      );
+
+      const sent = sentMessages[0] as Record<string, unknown>;
+      const requestId = sent.requestId as string;
+
+      proxy.resolve(requestId, {
+        content: "Audio loaded on host",
+        isError: false,
+        audioData: Buffer.from("fake-audio-bytes").toString("base64"),
+        audioMimeType: "audio/mpeg",
+      });
+
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+      expect(result.content).toContain("Audio loaded");
+      expect(result.contentBlocks).toHaveLength(1);
+      expect(result.contentBlocks?.[0]).toMatchObject({
+        type: "file",
+        source: {
+          media_type: "audio/mpeg",
+          filename: "voice.mp3",
+        },
+      });
+    });
+
     test("handles write operations", async () => {
       setup();
 

package/src/__tests__/host-file-read-tool.test.ts

@@ -12,7 +12,8 @@ let mockFileProxyRequestFn: (
   input: HostFileInput,
   conversationId: string,
   signal?: AbortSignal,
-) => Promise<ToolExecutionResult> = () => Promise.resolve({ content: "", isError: false });
+) => Promise<ToolExecutionResult> = () =>
+  Promise.resolve({ content: "", isError: false });
 
 mock.module("../daemon/host-file-proxy.js", () => ({
   HostFileProxy: {
@@ -49,7 +50,8 @@ afterEach(() => {
     rmSync(dir, { recursive: true, force: true });
   }
   mockFileProxyAvailable = false;
-  mockFileProxyRequestFn = () => Promise.resolve({ content: "", isError: false });
+  mockFileProxyRequestFn = () =>
+    Promise.resolve({ content: "", isError: false });
 });
 
 // Minimal valid JPEG: FF D8 FF E0 header

package/src/__tests__/host-file-write-tool.test.ts

@@ -12,7 +12,8 @@ let mockFileProxyRequestFn: (
   input: HostFileInput,
   conversationId: string,
   signal?: AbortSignal,
-) => Promise<ToolExecutionResult> = () => Promise.resolve({ content: "", isError: false });
+) => Promise<ToolExecutionResult> = () =>
+  Promise.resolve({ content: "", isError: false });
 
 mock.module("../daemon/host-file-proxy.js", () => ({
   HostFileProxy: {
@@ -43,7 +44,8 @@ afterEach(() => {
     rmSync(dir, { recursive: true, force: true });
   }
   mockFileProxyAvailable = false;
-  mockFileProxyRequestFn = () => Promise.resolve({ content: "", isError: false });
+  mockFileProxyRequestFn = () =>
+    Promise.resolve({ content: "", isError: false });
 });
 
 describe("host_file_write tool", () => {
@@ -202,7 +204,11 @@ describe("host_file_write tool", () => {
     };
 
     await hostFileWriteTool.execute(
-      { path: "/host/output.txt", content: "hello", target_client_id: "client-x" },
+      {
+        path: "/host/output.txt",
+        content: "hello",
+        target_client_id: "client-x",
+      },
       makeContext(),
     );
 

package/src/__tests__/host-proxy-preactivation.test.ts

@@ -108,10 +108,15 @@ function makeTarget(
 function setCapableClient(
   capability: HostProxyCapability,
   connected: boolean,
+  actorPrincipalId = "user-1",
 ): void {
   if (connected) {
     mockClientsByCapability.set(capability, [
-      { clientId: "mock-macos-client", capabilities: [capability] },
+      {
+        clientId: "mock-macos-client",
+        capabilities: [capability],
+        actorPrincipalId,
+      },
     ]);
   } else {
     mockClientsByCapability.delete(capability);
@@ -141,22 +146,37 @@ describe("shouldAttachHostProxyForCapability", () => {
 
     test("returns true for web source when a capable client is connected", () => {
       setCapableClient("host_cu", true);
-      expect(shouldAttachHostProxyForCapability("host_cu", "web")).toBe(true);
+      expect(
+        shouldAttachHostProxyForCapability("host_cu", "web", "user-1"),
+      ).toBe(true);
     });
 
     test("returns false for web source when no capable client is connected", () => {
       setCapableClient("host_cu", false);
-      expect(shouldAttachHostProxyForCapability("host_cu", "web")).toBe(false);
+      expect(
+        shouldAttachHostProxyForCapability("host_cu", "web", "user-1"),
+      ).toBe(false);
     });
 
     test("returns false for ios source when no capable client is connected", () => {
       setCapableClient("host_cu", false);
-      expect(shouldAttachHostProxyForCapability("host_cu", "ios")).toBe(false);
+      expect(
+        shouldAttachHostProxyForCapability("host_cu", "ios", "user-1"),
+      ).toBe(false);
     });
 
     test("returns true for ios source when a capable client is connected", () => {
       setCapableClient("host_cu", true);
-      expect(shouldAttachHostProxyForCapability("host_cu", "ios")).toBe(true);
+      expect(
+        shouldAttachHostProxyForCapability("host_cu", "ios", "user-1"),
+      ).toBe(true);
+    });
+
+    test("returns false for web source when only a different actor is capable", () => {
+      setCapableClient("host_cu", true, "user-other");
+      expect(
+        shouldAttachHostProxyForCapability("host_cu", "web", "user-1"),
+      ).toBe(false);
     });
 
     test("returns false for chrome-extension source even when a capable client is connected", () => {
@@ -177,14 +197,25 @@ describe("shouldAttachHostProxyForCapability", () => {
     test("returns true for web source when a capable client is connected", () => {
       setCapableClient("host_app_control", true);
       expect(
-        shouldAttachHostProxyForCapability("host_app_control", "web"),
+        shouldAttachHostProxyForCapability("host_app_control", "web", "user-1"),
       ).toBe(true);
     });
 
     test("returns false for web source when no capable client is connected", () => {
       setCapableClient("host_app_control", false);
       expect(
-        shouldAttachHostProxyForCapability("host_app_control", "web"),
+        shouldAttachHostProxyForCapability("host_app_control", "web", "user-1"),
+      ).toBe(false);
+    });
+
+    test("returns false for web source when only a different actor is capable", () => {
+      setCapableClient("host_app_control", true, "user-other");
+      expect(
+        shouldAttachHostProxyForCapability(
+          "host_app_control",
+          "web",
+          "user-1",
+        ),
       ).toBe(false);
     });
 
@@ -222,7 +253,7 @@ describe("preactivateHostProxySkills", () => {
     setCapableClient("host_cu", true);
     setCapableClient("host_app_control", true);
     const target = makeTarget();
-    preactivateHostProxySkills(target, "web");
+    preactivateHostProxySkills(target, "web", "user-1");
     expect(target.preactivatedSkillIds).toContain("computer-use");
     expect(target.preactivatedSkillIds).toContain("app-control");
   });
@@ -231,7 +262,7 @@ describe("preactivateHostProxySkills", () => {
     setCapableClient("host_cu", true);
     setCapableClient("host_app_control", false);
     const target = makeTarget();
-    preactivateHostProxySkills(target, "web");
+    preactivateHostProxySkills(target, "web", "user-1");
     expect(target.preactivatedSkillIds).toContain("computer-use");
     expect(target.preactivatedSkillIds).not.toContain("app-control");
   });
@@ -240,7 +271,7 @@ describe("preactivateHostProxySkills", () => {
     setCapableClient("host_cu", false);
     setCapableClient("host_app_control", false);
     const target = makeTarget();
-    preactivateHostProxySkills(target, "web");
+    preactivateHostProxySkills(target, "web", "user-1");
     expect(target.preactivatedSkillIds).toEqual([]);
   });
 
@@ -248,7 +279,15 @@ describe("preactivateHostProxySkills", () => {
     setCapableClient("host_cu", false);
     setCapableClient("host_app_control", false);
     const target = makeTarget();
-    preactivateHostProxySkills(target, "ios");
+    preactivateHostProxySkills(target, "ios", "user-1");
+    expect(target.preactivatedSkillIds).toEqual([]);
+  });
+
+  test("does not preactivate for web source when only different-actor clients are connected", () => {
+    setCapableClient("host_cu", true, "user-other");
+    setCapableClient("host_app_control", true, "user-other");
+    const target = makeTarget();
+    preactivateHostProxySkills(target, "web", "user-1");
     expect(target.preactivatedSkillIds).toEqual([]);
   });
 
@@ -290,7 +329,7 @@ describe("evaluateHostProxyAttachment", () => {
 
   test("returns cross_client with clientCount when a capable client is connected", () => {
     setCapableClient("host_cu", true);
-    expect(evaluateHostProxyAttachment("host_cu", "web")).toEqual({
+    expect(evaluateHostProxyAttachment("host_cu", "web", "user-1")).toEqual({
       shouldAttach: true,
       reason: "cross_client",
       clientCount: 1,
@@ -299,7 +338,7 @@ describe("evaluateHostProxyAttachment", () => {
 
   test("returns denied_no_clients with clientCount 0 when no capable client is connected", () => {
     setCapableClient("host_cu", false);
-    expect(evaluateHostProxyAttachment("host_cu", "web")).toEqual({
+    expect(evaluateHostProxyAttachment("host_cu", "web", "user-1")).toEqual({
       shouldAttach: false,
       reason: "denied_no_clients",
       clientCount: 0,
@@ -357,7 +396,7 @@ describe("preactivateHostProxySkills logging", () => {
   test("log captures cross_client + clientCount when a web source has a connected host_cu client", () => {
     setCapableClient("host_cu", true);
     const target = makeTarget();
-    preactivateHostProxySkills(target, "web");
+    preactivateHostProxySkills(target, "web", "user-1");
 
     expect(loggedInfoCalls).toHaveLength(1);
     const decisions = loggedInfoCalls[0].fields.decisions as Record<

package/src/__tests__/host-shell-tool.test.ts

@@ -56,7 +56,13 @@ mock.module("../util/logger.js", () => ({
 // Mock the host-bash-proxy singleton so proxy delegation tests can control it.
 let mockProxyAvailable = false;
 let mockProxyRequestFn: (
-  input: { command: string; working_dir?: string; timeout_seconds?: number; env?: Record<string, string>; targetClientId?: string },
+  input: {
+    command: string;
+    working_dir?: string;
+    timeout_seconds?: number;
+    env?: Record<string, string>;
+    targetClientId?: string;
+  },
   conversationId: string,
   signal?: AbortSignal,
 ) => Promise<ToolExecutionResult> = () =>
@@ -863,9 +869,8 @@ describe("host_bash — proxy delegation", () => {
 
   test("propagates VELLUM_UNTRUSTED_SHELL env to proxy under CES lockdown", async () => {
     // Enable CES shell lockdown via the override cache
-    const { setOverridesForTesting } = await import(
-  "./feature-flag-test-helpers.js"
-);
+    const { setOverridesForTesting } =
+      await import("./feature-flag-test-helpers.js");
     setOverridesForTesting({
       "ces-shell-lockdown": true,
     });

package/src/__tests__/http-user-message-parity.test.ts

@@ -98,8 +98,8 @@ mock.module("../memory/conversation-crud.js", () => ({
     conversationId: string,
     role: string,
     content: string,
-    metadata?: Record<string, unknown>,
-  ) => addMessageMock(conversationId, role, content, metadata),
+    options?: { metadata?: Record<string, unknown> },
+  ) => addMessageMock(conversationId, role, content, options),
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 

package/src/__tests__/identity-intro-cache.test.ts

@@ -1,9 +1,8 @@
 /**
  * Unit tests for the identity intro cache (identity-intro-cache.ts).
  *
- * Validates TTL-based expiration, content-hash-based invalidation when
- * workspace identity files or the guardian persona content change, and
- * round-trip get/set behavior.
+ * Validates TTL-based expiration, round-trip get/set behavior, and parsing
+ * workspace-authored greeting sections.
  */
 
 import { afterEach, describe, expect, mock, test } from "bun:test";
@@ -45,20 +44,11 @@ mock.module("node:fs", () => ({
   },
 }));
 
-// Mocked guardian persona — mutable so tests can change it and verify cache
-// invalidation based on the per-user persona file content.
-let guardianPersonaContent: string | null = null;
-
-mock.module("../prompts/persona-resolver.js", () => ({
-  resolveGuardianPersona: () => guardianPersonaContent,
-}));
-
 // ---------------------------------------------------------------------------
 // Imports (after mocks)
 // ---------------------------------------------------------------------------
 
 import {
-  computeIdentityContentHash,
   getCachedIntro,
   parseGreetingsSection,
   readWorkspaceGreetings,
@@ -75,7 +65,6 @@ afterEach(() => {
   for (const key of Object.keys(workspaceFiles)) {
     delete workspaceFiles[key];
   }
-  guardianPersonaContent = null;
 });
 
 // ---------------------------------------------------------------------------
@@ -118,7 +107,6 @@ describe("identity intro cache", () => {
   test("round-trip: set then get returns cached greetings array", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
     workspaceFiles["SOUL.md"] = "Be playful.";
-    guardianPersonaContent = "The user likes coffee.";
 
     setCachedIntro(["Hey, I'm Atlas.", "What's up?"]);
     const cached = getCachedIntro();
@@ -131,111 +119,45 @@ describe("identity intro cache", () => {
 
     setCachedIntro(["Hello!"]);
 
-    // Manually set the timestamp to 5 hours ago
-    const fiveHoursAgo = String(Date.now() - 5 * 60 * 60 * 1000);
-    checkpointStore.set("identity:intro:cached_at", fiveHoursAgo);
+    const fortyNineHoursAgo = String(Date.now() - 49 * 60 * 60 * 1000);
+    checkpointStore.set("identity:intro:cached_at", fortyNineHoursAgo);
 
     expect(getCachedIntro()).toBeNull();
   });
 
-  test("returns cached greetings when within TTL (3 hours ago)", () => {
+  test("returns cached greetings when within TTL (47 hours ago)", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
 
     setCachedIntro(["Hello!"]);
 
-    // Set timestamp to 3 hours ago (within 4-hour TTL)
-    const threeHoursAgo = String(Date.now() - 3 * 60 * 60 * 1000);
-    checkpointStore.set("identity:intro:cached_at", threeHoursAgo);
+    const fortySevenHoursAgo = String(Date.now() - 47 * 60 * 60 * 1000);
+    checkpointStore.set("identity:intro:cached_at", fortySevenHoursAgo);
 
     const cached = getCachedIntro();
     expect(cached).not.toBeNull();
     expect(cached!.greetings).toEqual(["Hello!"]);
   });
 
-  test("busts cache when IDENTITY.md changes", () => {
+  test("keeps cached greetings when IDENTITY.md changes", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
     setCachedIntro(["I'm Atlas!"]);
 
-    // Change IDENTITY.md
     workspaceFiles["IDENTITY.md"] = "- **Name:** Nova";
 
-    expect(getCachedIntro()).toBeNull();
+    expect(getCachedIntro()?.greetings).toEqual(["I'm Atlas!"]);
   });
 
-  test("busts cache when SOUL.md changes", () => {
+  test("keeps cached greetings when SOUL.md changes", () => {
     workspaceFiles["SOUL.md"] = "Be playful.";
     setCachedIntro(["Hey there!"]);
 
-    // Change SOUL.md
     workspaceFiles["SOUL.md"] = "Be serious and formal.";
 
-    expect(getCachedIntro()).toBeNull();
-  });
-
-  test("busts cache when guardian persona content changes", () => {
-    guardianPersonaContent = "Likes coffee.";
-    setCachedIntro(["Good morning!"]);
-
-    // Change guardian persona (e.g. user edited users/<slug>.md)
-    guardianPersonaContent = "Likes tea.";
-
-    expect(getCachedIntro()).toBeNull();
-  });
-
-  test("cache remains valid when guardian persona is unchanged", () => {
-    workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
-    workspaceFiles["SOUL.md"] = "Be chill.";
-    guardianPersonaContent = "Likes sunsets.";
-
-    setCachedIntro(["Atlas here.", "Hey friend."]);
-
-    expect(getCachedIntro()?.greetings).toEqual(["Atlas here.", "Hey friend."]);
-    expect(getCachedIntro()?.greetings).toEqual(["Atlas here.", "Hey friend."]);
-  });
-
-  test("computeIdentityContentHash is deterministic", () => {
-    workspaceFiles["IDENTITY.md"] = "test";
-    workspaceFiles["SOUL.md"] = "test2";
-    guardianPersonaContent = "test3";
-
-    const hash1 = computeIdentityContentHash();
-    const hash2 = computeIdentityContentHash();
-    expect(hash1).toBe(hash2);
-    expect(hash1).toMatch(/^[a-f0-9]{64}$/); // SHA-256 hex
-  });
-
-  test("computeIdentityContentHash changes when guardian persona changes", () => {
-    workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
-    workspaceFiles["SOUL.md"] = "Be playful.";
-    guardianPersonaContent = "Likes coffee.";
-    const hash1 = computeIdentityContentHash();
-
-    guardianPersonaContent = "Likes tea.";
-    const hash2 = computeIdentityContentHash();
-
-    expect(hash1).not.toBe(hash2);
-  });
-
-  test("computeIdentityContentHash handles null guardian persona", () => {
-    workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
-    guardianPersonaContent = null;
-
-    const hash = computeIdentityContentHash();
-    expect(hash).toMatch(/^[a-f0-9]{64}$/);
-  });
-
-  test("computeIdentityContentHash changes when file content changes", () => {
-    workspaceFiles["IDENTITY.md"] = "v1";
-    const hash1 = computeIdentityContentHash();
-
-    workspaceFiles["IDENTITY.md"] = "v2";
-    const hash2 = computeIdentityContentHash();
-
-    expect(hash1).not.toBe(hash2);
+    expect(getCachedIntro()?.greetings).toEqual(["Hey there!"]);
   });
 
   test("handles missing workspace files gracefully", () => {
-    // No files exist — should still work (empty content hashed)
+    // No files exist — should still work.
     setCachedIntro(["Hello!"]);
     const cached = getCachedIntro();
     expect(cached).not.toBeNull();
@@ -244,9 +166,7 @@ describe("identity intro cache", () => {
 
   test("handles legacy single-string cache value", () => {
     // Simulate a cache entry written by an older daemon version
-    const hash = computeIdentityContentHash();
     checkpointStore.set("identity:intro:greetings", "Legacy greeting");
-    checkpointStore.set("identity:intro:content_hash", hash);
     checkpointStore.set("identity:intro:cached_at", String(Date.now()));
 
     const cached = getCachedIntro();
@@ -255,20 +175,12 @@ describe("identity intro cache", () => {
   });
 
   test("returns null when greetings checkpoint is missing", () => {
-    checkpointStore.set("identity:intro:content_hash", "abc");
-    checkpointStore.set("identity:intro:cached_at", String(Date.now()));
-    expect(getCachedIntro()).toBeNull();
-  });
-
-  test("returns null when hash checkpoint is missing", () => {
-    checkpointStore.set("identity:intro:greetings", '["Hello"]');
     checkpointStore.set("identity:intro:cached_at", String(Date.now()));
     expect(getCachedIntro()).toBeNull();
   });
 
   test("returns null when timestamp checkpoint is missing", () => {
     checkpointStore.set("identity:intro:greetings", '["Hello"]');
-    checkpointStore.set("identity:intro:content_hash", "abc");
     expect(getCachedIntro()).toBeNull();
   });
 });
@@ -295,31 +207,46 @@ describe("parseGreetingsSection", () => {
   });
 
   test("handles asterisk bullets", () => {
+    const content = ["## Greetings", "* Hello!", "* Hi there."].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual(["Hello!", "Hi there."]);
+  });
+
+  test("handles plus and numbered bullets", () => {
     const content = [
       "## Greetings",
-      "* Hello!",
-      "* Hi there.",
+      "+ Welcome back.",
+      "1. Ready when you are.",
+      "2) What are we building today?",
     ].join("\n");
 
-    expect(parseGreetingsSection(content)).toEqual(["Hello!", "Hi there."]);
+    expect(parseGreetingsSection(content)).toEqual([
+      "Welcome back.",
+      "Ready when you are.",
+      "What are we building today?",
+    ]);
   });
 
-  test("returns null when section is missing", () => {
+  test("only starts at a level-two Greetings heading", () => {
     const content = [
-      "# Soul",
-      "## Personality",
-      "Be friendly.",
+      "# Greetings",
+      "- Not the section contract.",
+      "",
+      "## Greetings",
+      "- The real greeting.",
     ].join("\n");
 
+    expect(parseGreetingsSection(content)).toEqual(["The real greeting."]);
+  });
+
+  test("returns null when section is missing", () => {
+    const content = ["# Soul", "## Personality", "Be friendly."].join("\n");
+
     expect(parseGreetingsSection(content)).toBeNull();
   });
 
   test("returns null when section is empty", () => {
-    const content = [
-      "## Greetings",
-      "",
-      "## Next Section",
-    ].join("\n");
+    const content = ["## Greetings", "", "## Next Section"].join("\n");
 
     expect(parseGreetingsSection(content)).toBeNull();
   });
@@ -339,16 +266,22 @@ describe("parseGreetingsSection", () => {
     ]);
   });
 
-  test("stops at next heading", () => {
+  test("allows nested headings and stops at the next same-or-higher heading", () => {
     const content = [
       "## Greetings",
       "- First",
       "- Second",
       "### Sub-heading",
+      "- Third",
+      "## Other Section",
       "- Should not appear",
     ].join("\n");
 
-    expect(parseGreetingsSection(content)).toEqual(["First", "Second"]);
+    expect(parseGreetingsSection(content)).toEqual([
+      "First",
+      "Second",
+      "Third",
+    ]);
   });
 });