@vellumai/assistant 0.8.6 → 0.8.7

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -186,14 +186,16 @@ describe("handleConfirmationResponse canonical status sync", () => {
     ).toEqual([
       "req-confirm-allow",
       "allow",
-      undefined,
-      undefined,
-      undefined,
-      { source: "button" },
+      {
+        selectedPattern: undefined,
+        selectedScope: undefined,
+        emissionContext: { source: "button" },
+      },
     ]);
-    // Canonical status sync is now handled inside Conversation.handleConfirmationResponse,
-    // which this test mocks out — so the handler itself no longer calls resolveCanonicalGuardianRequest.
+    // Both canonical status sync and pendingInteractions lifecycle are owned
+    // by Conversation.handleConfirmationResponse (mocked above). The IPC
+    // handler delegates fully and does not call either directly.
     expect(resolveCanonicalGuardianRequestMock).not.toHaveBeenCalled();
-    expect(resolveMock).toHaveBeenCalledWith("req-confirm-allow", "approved");
+    expect(resolveMock).not.toHaveBeenCalled();
   });
 });

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -56,6 +56,7 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   markStaleRunsAsMissed: mockMarkStaleRunsAsMissed,
   markStaleRunningAsError: mockMarkStaleRunningAsError,
   countCompletedHeartbeatRuns: mock(() => 10),
+  countRecentConsecutiveRuns: mock(() => 0),
 }));
 
 mock.module("../schedule/recurrence-engine.js", () => ({

package/src/__tests__/heartbeat-service.test.ts

@@ -32,6 +32,7 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   markStaleRunningAsError: mockMarkStaleRunningAsError,
   listHeartbeatRuns: mockListHeartbeatRuns,
   countCompletedHeartbeatRuns: mockCountCompletedHeartbeatRuns,
+  countRecentConsecutiveRuns: mock(() => 0),
 }));
 
 // Mock config loader
@@ -360,7 +361,7 @@ describe("HeartbeatService", () => {
       processMessageCalls.push({
         conversationId: args[0] as string,
         content: args[1] as string,
-        options: (args[3] as { callSite?: string } | undefined) ?? undefined,
+        options: (args[2] as { callSite?: string } | undefined) ?? undefined,
       });
       return { messageId: "msg-1" };
     });

package/src/__tests__/history-repair-hook.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Tests for the default `history-repair` plugin's `user-prompt-submit` hook.
+ *
+ * Covers:
+ * - The hook normalizes `latestMessages` exactly as `repairHistory` would for
+ *   the three documented repair classes (orphan tool_result, missing
+ *   tool_result, consecutive same-role messages) and is a no-op for a
+ *   well-formed history.
+ * - End-to-end through `runHook` + the registry: registering the default
+ *   plugin makes the hook fire and repair the working message list.
+ * - Chain ordering: because defaults register first, the default repair hook
+ *   runs ahead of a later-registered user hook, which therefore observes an
+ *   already-normalized history.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { HOOKS } from "../plugin-api/constants.js";
+import type {
+  PluginLogger,
+  UserPromptSubmitContext,
+} from "../plugin-api/types.js";
+import userPromptSubmit from "../plugins/defaults/history-repair/hooks/user-prompt-submit.js";
+import { defaultHistoryRepairPlugin } from "../plugins/defaults/history-repair/register.js";
+import { repairHistory } from "../plugins/defaults/history-repair/terminal.js";
+import { runHook } from "../plugins/pipeline.js";
+import {
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type { Message } from "../providers/types.js";
+
+const noopLogger: PluginLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  debug: () => {},
+};
+
+function makeCtx(messages: Message[]): UserPromptSubmitContext {
+  return {
+    conversationId: "conv-test",
+    originalMessages: messages,
+    latestMessages: messages,
+    logger: noopLogger,
+  };
+}
+
+/** Drift case covering all three repair classes at once. */
+function driftedHistory(): Message[] {
+  return [
+    { role: "user", content: [{ type: "text", text: "Kick off" }] },
+    {
+      role: "assistant",
+      content: [
+        { type: "tool_use", id: "tu_1", name: "bash", input: { cmd: "ls" } },
+        { type: "tool_use", id: "tu_2", name: "read", input: { path: "/b" } },
+      ],
+    },
+    {
+      role: "user",
+      content: [{ type: "tool_result", tool_use_id: "tu_1", content: "ok" }],
+    },
+    { role: "user", content: [{ type: "text", text: "extra" }] },
+    { role: "assistant", content: [{ type: "text", text: "Done" }] },
+  ];
+}
+
+describe("history-repair user-prompt-submit hook — direct", () => {
+  test("normalizes latestMessages identically to repairHistory", async () => {
+    // GIVEN a history with an orphan tool_result, a missing tool_result, and
+    // consecutive same-role messages.
+    const messages = driftedHistory();
+    const expected = repairHistory(messages);
+    const ctx = makeCtx(messages);
+
+    // WHEN the hook runs over the context.
+    await userPromptSubmit(ctx);
+
+    // THEN latestMessages matches the canonical repair output, and at least
+    // one of each repair class fired (the case exercises all three).
+    expect(ctx.latestMessages).toEqual(expected.messages);
+    expect(expected.stats.missingToolResultsInserted).toBeGreaterThan(0);
+    expect(expected.stats.consecutiveSameRoleMerged).toBeGreaterThan(0);
+  });
+
+  test("is a no-op for a well-formed history", async () => {
+    // GIVEN a history that already satisfies the provider's pairing rules.
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Hello" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "tu_1", name: "read", input: { path: "/a" } },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "tu_1", content: "contents" },
+        ],
+      },
+      { role: "assistant", content: [{ type: "text", text: "Here." }] },
+    ];
+    const ctx = makeCtx(messages);
+
+    // WHEN the hook runs.
+    await userPromptSubmit(ctx);
+
+    // THEN the history is unchanged.
+    expect(ctx.latestMessages).toEqual(messages);
+  });
+});
+
+describe("history-repair user-prompt-submit hook — via runHook", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+  });
+
+  test("registering the default plugin repairs the working history", async () => {
+    // GIVEN the default history-repair plugin is registered.
+    registerPlugin(defaultHistoryRepairPlugin);
+    const messages = driftedHistory();
+    const expected = repairHistory(messages);
+
+    // WHEN the user-prompt-submit chain runs.
+    const result = await runHook<UserPromptSubmitContext>(
+      HOOKS.USER_PROMPT_SUBMIT,
+      makeCtx(messages),
+    );
+
+    // THEN the working history is normalized.
+    expect(result.latestMessages).toEqual(expected.messages);
+  });
+
+  test("default repair hook runs before a later-registered user hook", async () => {
+    // GIVEN the default plugin is registered first, then a user plugin whose
+    // hook records the history it observes.
+    let observed: Message[] | null = null;
+    registerPlugin(defaultHistoryRepairPlugin);
+    registerPlugin({
+      manifest: { name: "observer-plugin", version: "0.0.1" },
+      hooks: {
+        "user-prompt-submit": async (ctx: UserPromptSubmitContext) => {
+          observed = [...ctx.latestMessages];
+        },
+      },
+    });
+    const messages = driftedHistory();
+    const expected = repairHistory(messages);
+
+    // WHEN the chain runs.
+    await runHook<UserPromptSubmitContext>(
+      HOOKS.USER_PROMPT_SUBMIT,
+      makeCtx(messages),
+    );
+
+    // THEN the user hook saw the already-repaired history.
+    expect(observed as Message[] | null).toEqual(expected.messages);
+  });
+});

package/src/__tests__/history-repair-observability.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { repairHistory } from "../daemon/history-repair.js";
+import { repairHistory } from "../plugins/defaults/history-repair/terminal.js";
 import type { Message } from "../providers/types.js";
 
 describe("history-repair observability", () => {

package/src/__tests__/history-repair.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
-import { deepRepairHistory, repairHistory } from "../daemon/history-repair.js";
+import { deepRepairHistory } from "../plugins/defaults/history-repair/terminal.js";
+import { repairHistory } from "../plugins/defaults/history-repair/terminal.js";
 import type { Message } from "../providers/types.js";
 
 describe("repairHistory", () => {

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

@@ -13,6 +13,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
       cap === "host_app_control" && mockHasClient
         ? { id: "mock-client" }
         : null,
+    listClientsByCapability: () => [],
     getActorPrincipalIdForClient: (clientId: string) =>
       mockActorMap.get(clientId),
   },
@@ -1290,6 +1291,7 @@ describe("HostAppControlProxy", () => {
 
   describe("actor principal + targetClientId plumbing", () => {
     test("request() accepts sourceActorPrincipalId and targetClientId without crashing", async () => {
+      mockActorMap.set("client-A", "actor-principal-1");
       const proxy = new HostAppControlProxy("conv-1");
       const ctrl = new AbortController();
       _setActiveAppControlSession({

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-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

@@ -295,31 +295,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 +354,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",
+    ]);
   });
 });
 

package/src/__tests__/inbound-slack-persistence.test.ts

@@ -39,9 +39,14 @@ mock.module("../memory/conversation-crud.js", () => ({
     conversationId: string,
     role: string,
     content: string,
-    metadata?: Record<string, unknown>,
+    options?: { metadata?: Record<string, unknown> },
   ) => {
-    addMessageCalls.push({ conversationId, role, content, metadata });
+    addMessageCalls.push({
+      conversationId,
+      role,
+      content,
+      metadata: options?.metadata,
+    });
     return { id: `persisted-${addMessageCalls.length}` };
   },
   getConversation: () => null,