@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -100,6 +100,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     content: string,
     metadata?: Record<string, unknown>,
   ) => addMessageMock(conversationId, role, content, metadata),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../runtime/local-actor-identity.js", () => ({
@@ -218,7 +219,10 @@ function makeConversation(overrides: Record<string, unknown> = {}) {
     hasAnyPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
     enqueueMessage: () => ({ queued: true, requestId: "queued-id" }),
-    persistUserMessage: mock(async () => "persisted-user-id"),
+    persistUserMessage: mock(async () => ({
+      id: "persisted-user-id",
+      deduplicated: false,
+    })),
     runAgentLoop: mock(async () => undefined),
     getMessages: () => [] as unknown[],
     assistantId: "self",
@@ -296,7 +300,10 @@ describe("HTTP POST /v1/messages does not intercept recording intents (by design
     // Dedicated /v1/recording/* endpoints handle recording lifecycle.
     // Text-based recording intent interception was retired with the
     // legacy handleUserMessage entry point.
-    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-msg-id",
+      deduplicated: false,
+    }));
     const runAgentLoop = mock(async () => undefined);
     const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
@@ -313,7 +320,10 @@ describe("HTTP POST /v1/messages does not intercept recording intents (by design
     // content, conversationKey, attachmentIds, sourceChannel, and interface.
     // This ensures a future regression that starts parsing commandIntent would
     // be caught.
-    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-msg-id",
+      deduplicated: false,
+    }));
     const runAgentLoop = mock(async () => undefined);
     const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
@@ -327,7 +337,10 @@ describe("HTTP POST /v1/messages does not intercept recording intents (by design
   });
 
   test("stop recording commands pass through to the agent loop", async () => {
-    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-msg-id",
+      deduplicated: false,
+    }));
     const runAgentLoop = mock(async () => undefined);
     const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
@@ -351,7 +364,10 @@ describe("HTTP POST /v1/messages clientTimezone transport metadata", () => {
   });
 
   test("passes canonical clientTimezone through host-proxy transport", async () => {
-    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-msg-id",
+      deduplicated: false,
+    }));
     const runAgentLoop = mock(async () => undefined);
     const conversation = makeConversation({ persistUserMessage, runAgentLoop });
     let capturedOptions: Record<string, unknown> | undefined;
@@ -378,7 +394,10 @@ describe("HTTP POST /v1/messages clientTimezone transport metadata", () => {
   });
 
   test("passes canonical clientTimezone through non-host-proxy transport", async () => {
-    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-msg-id",
+      deduplicated: false,
+    }));
     const runAgentLoop = mock(async () => undefined);
     const conversation = makeConversation({ persistUserMessage, runAgentLoop });
     let capturedOptions: Record<string, unknown> | undefined;
@@ -405,7 +424,10 @@ describe("HTTP POST /v1/messages clientTimezone transport metadata", () => {
   });
 
   test("drops invalid clientTimezone without rejecting the message", async () => {
-    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-msg-id",
+      deduplicated: false,
+    }));
     const runAgentLoop = mock(async () => undefined);
     const conversation = makeConversation({ persistUserMessage, runAgentLoop });
     let capturedOptions: Record<string, unknown> | undefined;

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

@@ -60,6 +60,8 @@ mock.module("../prompts/persona-resolver.js", () => ({
 import {
   computeIdentityContentHash,
   getCachedIntro,
+  parseGreetingsSection,
+  readWorkspaceGreetings,
   readWorkspaceIdentityIntro,
   setCachedIntro,
 } from "../runtime/routes/identity-intro-cache.js";
@@ -113,21 +115,21 @@ describe("identity intro cache", () => {
     expect(getCachedIntro()).toBeNull();
   });
 
-  test("round-trip: set then get returns cached text", () => {
+  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.");
+    setCachedIntro(["Hey, I'm Atlas.", "What's up?"]);
     const cached = getCachedIntro();
     expect(cached).not.toBeNull();
-    expect(cached!.text).toBe("Hey, I'm Atlas.");
+    expect(cached!.greetings).toEqual(["Hey, I'm Atlas.", "What's up?"]);
   });
 
   test("returns null when cache is expired (TTL exceeded)", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
 
-    setCachedIntro("Hello!");
+    setCachedIntro(["Hello!"]);
 
     // Manually set the timestamp to 5 hours ago
     const fiveHoursAgo = String(Date.now() - 5 * 60 * 60 * 1000);
@@ -136,10 +138,10 @@ describe("identity intro cache", () => {
     expect(getCachedIntro()).toBeNull();
   });
 
-  test("returns cached text when within TTL (3 hours ago)", () => {
+  test("returns cached greetings when within TTL (3 hours ago)", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
 
-    setCachedIntro("Hello!");
+    setCachedIntro(["Hello!"]);
 
     // Set timestamp to 3 hours ago (within 4-hour TTL)
     const threeHoursAgo = String(Date.now() - 3 * 60 * 60 * 1000);
@@ -147,12 +149,12 @@ describe("identity intro cache", () => {
 
     const cached = getCachedIntro();
     expect(cached).not.toBeNull();
-    expect(cached!.text).toBe("Hello!");
+    expect(cached!.greetings).toEqual(["Hello!"]);
   });
 
   test("busts cache when IDENTITY.md changes", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
-    setCachedIntro("I'm Atlas!");
+    setCachedIntro(["I'm Atlas!"]);
 
     // Change IDENTITY.md
     workspaceFiles["IDENTITY.md"] = "- **Name:** Nova";
@@ -162,7 +164,7 @@ describe("identity intro cache", () => {
 
   test("busts cache when SOUL.md changes", () => {
     workspaceFiles["SOUL.md"] = "Be playful.";
-    setCachedIntro("Hey there!");
+    setCachedIntro(["Hey there!"]);
 
     // Change SOUL.md
     workspaceFiles["SOUL.md"] = "Be serious and formal.";
@@ -172,7 +174,7 @@ describe("identity intro cache", () => {
 
   test("busts cache when guardian persona content changes", () => {
     guardianPersonaContent = "Likes coffee.";
-    setCachedIntro("Good morning!");
+    setCachedIntro(["Good morning!"]);
 
     // Change guardian persona (e.g. user edited users/<slug>.md)
     guardianPersonaContent = "Likes tea.";
@@ -185,11 +187,10 @@ describe("identity intro cache", () => {
     workspaceFiles["SOUL.md"] = "Be chill.";
     guardianPersonaContent = "Likes sunsets.";
 
-    setCachedIntro("Atlas here.");
+    setCachedIntro(["Atlas here.", "Hey friend."]);
 
-    // Read twice with the same guardian persona — both should return the cached value
-    expect(getCachedIntro()?.text).toBe("Atlas here.");
-    expect(getCachedIntro()?.text).toBe("Atlas here.");
+    expect(getCachedIntro()?.greetings).toEqual(["Atlas here.", "Hey friend."]);
+    expect(getCachedIntro()?.greetings).toEqual(["Atlas here.", "Hey friend."]);
   });
 
   test("computeIdentityContentHash is deterministic", () => {
@@ -235,30 +236,140 @@ describe("identity intro cache", () => {
 
   test("handles missing workspace files gracefully", () => {
     // No files exist — should still work (empty content hashed)
-    setCachedIntro("Hello!");
+    setCachedIntro(["Hello!"]);
     const cached = getCachedIntro();
     expect(cached).not.toBeNull();
-    expect(cached!.text).toBe("Hello!");
+    expect(cached!.greetings).toEqual(["Hello!"]);
   });
 
-  test("returns null when text checkpoint is missing", () => {
+  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();
+    expect(cached).not.toBeNull();
+    expect(cached!.greetings).toEqual(["Legacy greeting"]);
+  });
+
+  test("returns null when greetings checkpoint is missing", () => {
     checkpointStore.set("identity:intro:content_hash", "abc");
     checkpointStore.set("identity:intro:cached_at", String(Date.now()));
-    // Missing text — should return null
     expect(getCachedIntro()).toBeNull();
   });
 
   test("returns null when hash checkpoint is missing", () => {
-    checkpointStore.set("identity:intro:text", "Hello");
+    checkpointStore.set("identity:intro:greetings", '["Hello"]');
     checkpointStore.set("identity:intro:cached_at", String(Date.now()));
-    // Missing hash — should return null
     expect(getCachedIntro()).toBeNull();
   });
 
   test("returns null when timestamp checkpoint is missing", () => {
-    checkpointStore.set("identity:intro:text", "Hello");
+    checkpointStore.set("identity:intro:greetings", '["Hello"]');
     checkpointStore.set("identity:intro:content_hash", "abc");
-    // Missing timestamp — should return null
     expect(getCachedIntro()).toBeNull();
   });
 });
+
+describe("parseGreetingsSection", () => {
+  test("parses bullet list from ## Greetings section", () => {
+    const content = [
+      "# Soul",
+      "",
+      "## Greetings",
+      "- Hey there, friend!",
+      "- What's on your mind?",
+      "- Ready to roll!",
+      "",
+      "## Other Section",
+      "Some other content.",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual([
+      "Hey there, friend!",
+      "What's on your mind?",
+      "Ready to roll!",
+    ]);
+  });
+
+  test("handles asterisk bullets", () => {
+    const content = [
+      "## Greetings",
+      "* Hello!",
+      "* Hi there.",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual(["Hello!", "Hi there."]);
+  });
+
+  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");
+
+    expect(parseGreetingsSection(content)).toBeNull();
+  });
+
+  test("ignores non-bullet lines in section", () => {
+    const content = [
+      "## Greetings",
+      "Some intro text that's not a bullet",
+      "- Actual greeting",
+      "Another non-bullet line",
+      "- Second greeting",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual([
+      "Actual greeting",
+      "Second greeting",
+    ]);
+  });
+
+  test("stops at next heading", () => {
+    const content = [
+      "## Greetings",
+      "- First",
+      "- Second",
+      "### Sub-heading",
+      "- Should not appear",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual(["First", "Second"]);
+  });
+});
+
+describe("readWorkspaceGreetings", () => {
+  test("reads greetings from SOUL.md", () => {
+    workspaceFiles["SOUL.md"] = [
+      "# Soul",
+      "## Greetings",
+      "- Hey!",
+      "- What's up?",
+    ].join("\n");
+
+    expect(readWorkspaceGreetings()).toEqual(["Hey!", "What's up?"]);
+  });
+
+  test("returns null when SOUL.md has no greetings section", () => {
+    workspaceFiles["SOUL.md"] = "# Soul\nBe friendly.";
+    expect(readWorkspaceGreetings()).toBeNull();
+  });
+
+  test("returns null when SOUL.md does not exist", () => {
+    expect(readWorkspaceGreetings()).toBeNull();
+  });
+});

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

@@ -48,6 +48,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   provenanceFromTrustContext: () => ({}),
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-disk-view.js", () => ({
@@ -140,12 +141,10 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Reply inside a thread",
-      [],
-      "req-thread",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Reply inside a thread",
+      requestId: "req-thread",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelName: "engineering",
@@ -155,8 +154,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
           actorExternalUserId: "U_ALICE",
         },
       },
-      undefined,
-    );
+    });
 
     const slackMeta = readPersistedSlackMeta();
     expect(slackMeta).not.toBeNull();
@@ -176,20 +174,17 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Top-level channel post",
-      [],
-      "req-top",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Top-level channel post",
+      requestId: "req-top",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelTs: "1700000010.222222",
           displayName: "Bob",
         },
       },
-      undefined,
-    );
+    });
 
     const slackMeta = readPersistedSlackMeta();
     expect(slackMeta).not.toBeNull();
@@ -205,20 +200,17 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "@leo can you check this?",
-      [],
-      "req-normalized-content",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "@leo can you check this?",
+      requestId: "req-normalized-content",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelTs: "1700000015.123456",
           displayName: "Alice",
         },
       },
-      undefined,
-    );
+    });
 
     expect(JSON.parse(addMessageCalls.at(-1)!.content)).toEqual([
       { type: "text", text: "@leo can you check this?" },
@@ -236,19 +228,16 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Anonymous channel post",
-      [],
-      "req-anon",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Anonymous channel post",
+      requestId: "req-anon",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelTs: "1700000020.333333",
         },
       },
-      undefined,
-    );
+    });
 
     const slackMeta = readPersistedSlackMeta();
     expect(slackMeta).not.toBeNull();
@@ -261,14 +250,10 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "telegram",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Telegram message",
-      [],
-      "req-tg",
-      undefined,
-      undefined,
-    );
+    await persistQueuedMessageBody(ctx, {
+      content: "Telegram message",
+      requestId: "req-tg",
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackMeta" in metadata).toBe(false);
@@ -284,19 +269,16 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "telegram",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Telegram message with stray slackInbound",
-      [],
-      "req-tg-stray",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Telegram message with stray slackInbound",
+      requestId: "req-tg-stray",
+      metadata: {
         slackInbound: {
           channelId: "C0_DOES_NOT_APPLY",
           channelTs: "1700000030.444444",
         },
       },
-      undefined,
-    );
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackMeta" in metadata).toBe(false);
@@ -312,14 +294,10 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Slack wake without inbound metadata",
-      [],
-      "req-no-slack-inbound",
-      undefined,
-      undefined,
-    );
+    await persistQueuedMessageBody(ctx, {
+      content: "Slack wake without inbound metadata",
+      requestId: "req-no-slack-inbound",
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackMeta" in metadata).toBe(false);
@@ -331,19 +309,16 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Malformed inbound payload",
-      [],
-      "req-malformed",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Malformed inbound payload",
+      requestId: "req-malformed",
+      metadata: {
         slackInbound: {
           // channelTs intentionally missing — simulates a bug upstream.
           channelId: "C0123CHANNEL",
         } as unknown as Record<string, unknown>,
       },
-      undefined,
-    );
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackMeta" in metadata).toBe(false);
@@ -355,19 +330,16 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Verify carrier is stripped",
-      [],
-      "req-strip",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Verify carrier is stripped",
+      requestId: "req-strip",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelTs: "1700000040.555555",
         },
       },
-      undefined,
-    );
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackInbound" in metadata).toBe(false);

package/src/__tests__/inference-profile-reaper.test.ts

@@ -12,7 +12,7 @@ import {
   getConversation,
   setConversationInferenceProfileSession,
 } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import {
@@ -20,6 +20,7 @@ import {
   stopInferenceProfileSessionReaper,
   tickInferenceProfileReaper,
 } from "../runtime/routes/inference-profile-session-reaper.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -40,7 +41,7 @@ describe("inference-profile-session-reaper", () => {
 
   afterAll(() => {
     stopInferenceProfileSessionReaper();
-    resetDb();
+    resetDbForTesting();
     mock.restore();
   });
 

package/src/__tests__/inference-profile-session-ipc.test.ts

@@ -38,9 +38,10 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import { createConversation } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { ROUTES } from "../runtime/routes/inference-profile-session-routes.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -66,7 +67,7 @@ function clearTables(): void {
 describe("inference_profile_open IPC op", () => {
   beforeEach(clearTables);
   afterAll(() => {
-    resetDb();
+    resetDbForTesting();
     mock.restore();
   });
 

package/src/__tests__/init-feature-flag-overrides.test.ts

@@ -47,9 +47,9 @@ describe("initFeatureFlagOverrides", () => {
     // through the backoff schedule.
     await initFeatureFlagOverrides({ retryBackoffsMs: [] });
 
-    // Without gateway data or file, undeclared flags default to true
+    // Without gateway data or file, undeclared flags default to false
     const config = {} as any;
-    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(false);
   });
 
   it("respects false values from gateway IPC", async () => {
@@ -72,10 +72,9 @@ describe("initFeatureFlagOverrides", () => {
     // through the production backoff schedule.
     await initFeatureFlagOverrides({ retryBackoffsMs: [] });
 
-    // Undeclared flags without overrides default to true (not false from
-    // a cached empty map)
+    // Undeclared flags without overrides default to false.
     const config = {} as any;
-    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(false);
   });
 
   it("retries empty gateway responses and picks up flags once they become available", async () => {
@@ -111,6 +110,6 @@ describe("initFeatureFlagOverrides", () => {
     // first-call must still be true (from the cached first fetch)
     expect(isAssistantFeatureFlagEnabled("first-call", config)).toBe(true);
     // second-call should not be in the cache since init was a no-op
-    expect(isAssistantFeatureFlagEnabled("second-call", config)).toBe(true); // defaults to true (undeclared)
+    expect(isAssistantFeatureFlagEnabled("second-call", config)).toBe(false);
   });
 });