@vellumai/assistant 0.11.3 → 0.11.4-staging.1

package/src/__tests__/channel-capabilities-dedupe.test.ts

@@ -0,0 +1,214 @@
+/**
+ * `<channel_capabilities>` must not accumulate one copy per turn, and
+ * deduplicating it must not disturb the cross-turn byte-identity that prompt
+ * caching depends on (see `prompt-cache-cross-turn-stability.test.ts`, which
+ * owns that invariant end to end).
+ */
+import { describe, expect, test } from "bun:test";
+
+import {
+  dedupeChannelCapabilityBlocks,
+  preModelCallSanitize,
+} from "../context/outbound-sanitize.js";
+import type { Message } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Fixtures, shaped like what runtime injection actually produces: the block is
+// its OWN text content block, prepended to the turn-starting user message by
+// `injectChannelCapabilityContext`, and then frozen into history.
+// ---------------------------------------------------------------------------
+
+const slackCapabilities = (dynamicUi = false): string =>
+  [
+    "<channel_capabilities>",
+    "channel: slack",
+    "dashboard_capable: false",
+    `supports_dynamic_ui: ${dynamicUi}`,
+    "supports_voice_input: false",
+    "",
+    "CHANNEL CONSTRAINTS:",
+    "- Do NOT reference the dashboard UI, settings panels, or visual preference pickers.",
+    '- Do NOT use app_create. Only use ui_show/ui_update for card surfaces with template: "task_progress"; present all other information as text.',
+    "- Present information as well-formatted text instead of dynamic UI.",
+    "</channel_capabilities>",
+  ].join("\n");
+
+const CAPS = slackCapabilities();
+
+const turnContextBlock = (turn: number): string =>
+  [
+    "<turn_context>",
+    `current_time: 2026-05-21 (Thursday) 10:${String(turn).padStart(2, "0")}:00 -05:00 (America/Chicago)`,
+    "interface: slack",
+    "trust_class: guardian",
+    "</turn_context>",
+  ].join("\n");
+
+const userTurn = (turn: number, caps: string = CAPS): Message => ({
+  role: "user",
+  content: [
+    { type: "text", text: turnContextBlock(turn) },
+    { type: "text", text: caps },
+    { type: "text", text: `User message ${turn}.` },
+  ],
+});
+
+const assistantTurn = (turn: number): Message => ({
+  role: "assistant",
+  content: [{ type: "text", text: `Reply ${turn}.` }],
+});
+
+/** An N-turn conversation, every user row carrying its own injected copy. */
+const conversation = (turns: number): Message[] => {
+  const messages: Message[] = [];
+  for (let turn = 1; turn <= turns; turn++) {
+    messages.push(userTurn(turn));
+    if (turn < turns) {
+      messages.push(assistantTurn(turn));
+    }
+  }
+  return messages;
+};
+
+const allText = (messages: Message[]): string =>
+  messages
+    .flatMap((m) =>
+      m.content.filter((b) => b.type === "text").map((b) => b.text),
+    )
+    .join("\n");
+
+const countOccurrences = (haystack: string, needle: string): number =>
+  haystack.split(needle).length - 1;
+
+// ---------------------------------------------------------------------------
+
+describe("<channel_capabilities> does not accumulate across a conversation", () => {
+  test("a 50-turn conversation carries exactly one copy", () => {
+    const raw = conversation(50);
+    expect(countOccurrences(allText(raw), "<channel_capabilities>")).toBe(50);
+
+    const text = allText(preModelCallSanitize(raw));
+    expect(countOccurrences(text, "<channel_capabilities>")).toBe(1);
+    expect(countOccurrences(text, "CHANNEL CONSTRAINTS:")).toBe(1);
+  });
+
+  test("the surviving copy is the first one, unmodified", () => {
+    const sanitized = preModelCallSanitize(conversation(6));
+    expect(sanitized[0].content).toEqual(conversation(6)[0].content);
+    expect(allText([sanitized[2]])).not.toContain("<channel_capabilities>");
+  });
+
+  test("outbound size stops growing with the repeated block", () => {
+    const rawGrowth =
+      allText(conversation(45)).length - allText(conversation(5)).length;
+    const sanitizedGrowth =
+      allText(preModelCallSanitize(conversation(45))).length -
+      allText(preModelCallSanitize(conversation(5))).length;
+
+    // Every extra raw turn pays for a full copy of the block; the deduplicated
+    // projection pays nothing for it.
+    expect((rawGrowth - sanitizedGrowth) / 40).toBeGreaterThanOrEqual(
+      CAPS.length,
+    );
+  });
+
+  test("everything else on the row is untouched", () => {
+    const sanitized = preModelCallSanitize(conversation(4));
+    // `<turn_context>` is deliberately left alone: it carries a fresh
+    // timestamp each turn and historical copies are read back by the
+    // compactor's tail resolution.
+    expect(countOccurrences(allText(sanitized), "<turn_context>")).toBe(4);
+    // The dropped block is the only thing that goes: the row keeps its
+    // `<turn_context>` and the user's own text, in order.
+    expect(sanitized[6].content).toEqual([
+      { type: "text", text: turnContextBlock(4) },
+      { type: "text", text: "User message 4." },
+    ]);
+  });
+});
+
+describe("cross-turn byte stability", () => {
+  test("a message renders identically no matter how many turns follow it", () => {
+    // The prompt cache is only readable when turn N's messages recur
+    // byte-identically at the same index in turn N+1. Deduplication must
+    // therefore depend only on what sits ABOVE a message, never on how far it
+    // is from the end.
+    const turn2 = preModelCallSanitize(conversation(2));
+    const turn20 = preModelCallSanitize(conversation(20));
+
+    turn2.forEach((message, index) => {
+      expect(JSON.stringify(turn20[index])).toBe(JSON.stringify(message));
+    });
+  });
+
+  test("the turn-starting message is not treated specially", () => {
+    const sanitized = preModelCallSanitize(conversation(3));
+    const turnStart = sanitized[sanitized.length - 1];
+    // Turn 3 opened this turn and still drops its duplicate copy, which is
+    // exactly what keeps it stable once turn 4 arrives.
+    expect(allText([turnStart])).not.toContain("<channel_capabilities>");
+  });
+
+  test("is idempotent", () => {
+    const once = preModelCallSanitize(conversation(6));
+    expect(preModelCallSanitize(once)).toEqual(once);
+  });
+});
+
+describe("changes and safety", () => {
+  test("capabilities that actually change mid-conversation are kept", () => {
+    const changed = slackCapabilities(true);
+    const history: Message[] = [
+      userTurn(1),
+      assistantTurn(1),
+      userTurn(2),
+      assistantTurn(2),
+      userTurn(3, changed),
+      assistantTurn(3),
+      userTurn(4, changed),
+    ];
+
+    const sanitized = dedupeChannelCapabilityBlocks(history);
+    const text = allText(sanitized);
+    expect(countOccurrences(text, "<channel_capabilities>")).toBe(2);
+    expect(text).toContain("supports_dynamic_ui: false");
+    expect(text).toContain("supports_dynamic_ui: true");
+    // Turn 2 and turn 4 are the repeats and are the ones that go.
+    expect(allText([sanitized[2]])).not.toContain("<channel_capabilities>");
+    expect(allText([sanitized[6]])).not.toContain("<channel_capabilities>");
+  });
+
+  test("a conversation with a single copy is returned untouched", () => {
+    const history = conversation(1);
+    expect(dedupeChannelCapabilityBlocks(history)).toBe(history);
+  });
+
+  test("user-authored text that merely mentions the tag is left alone", () => {
+    const authored =
+      "why does <channel_capabilities> say dashboard_capable: false?";
+    const history: Message[] = [
+      { role: "user", content: [{ type: "text", text: authored }] },
+      assistantTurn(1),
+      { role: "user", content: [{ type: "text", text: authored }] },
+    ];
+
+    expect(dedupeChannelCapabilityBlocks(history)).toBe(history);
+  });
+
+  test("a user row made only of the block is never emptied or dropped", () => {
+    const history: Message[] = [
+      userTurn(1),
+      assistantTurn(1),
+      { role: "user", content: [{ type: "text", text: CAPS }] },
+      assistantTurn(2),
+      userTurn(3),
+    ];
+
+    const sanitized = dedupeChannelCapabilityBlocks(history);
+    expect(sanitized).toHaveLength(5);
+    expect(sanitized[2].content).toEqual(history[2].content);
+    // The all-block row is retained, so it becomes the baseline the later
+    // duplicate is measured against and turn 3 still drops.
+    expect(allText([sanitized[4]])).not.toContain("<channel_capabilities>");
+  });
+});

package/src/__tests__/channel-delivery-store.test.ts

@@ -504,23 +504,23 @@ describe("channel-delivery-store", () => {
     expect(r1.conversationId).not.toBe(r2.conversationId);
   });
 
-  test("same chat/channel but different assistantId uses different conversations", () => {
-    const r1 = recordInbound("telegram", "chat-1", "msg-1", {
-      assistantId: "asst-A",
-    });
-    const r2 = recordInbound("telegram", "chat-1", "msg-2", {
-      assistantId: "asst-B",
-    });
+  test("the same chat keeps the same conversation", () => {
+    const r1 = recordInbound("telegram", "chat-1", "msg-1");
+    const r2 = recordInbound("telegram", "chat-1", "msg-2");
 
-    expect(r1.conversationId).not.toBe(r2.conversationId);
+    expect(r1.conversationId).toBe(r2.conversationId);
   });
 
-  test("no assistantId defaults to self-scoped key", () => {
-    const r1 = recordInbound("telegram", "chat-1", "msg-1");
-    const r2 = recordInbound("telegram", "chat-1", "msg-2", {
-      assistantId: "self",
-    });
-    expect(r1.conversationId).toBe(r2.conversationId);
+  test("binds under the self-scoped key", () => {
+    // The prefix is a stored format, not an internal detail. It reads like a
+    // leftover of the assistant id that used to be interpolated into it, so
+    // pin it: rows already written under `asst:self:` stop resolving if a
+    // later tidy-up drops it.
+    const { conversationId } = recordInbound("telegram", "chat-1", "msg-1");
+
+    expect(
+      getConversationByKey("asst:self:telegram:chat-1")?.conversationId,
+    ).toBe(conversationId);
   });
 
   test("external bindings allow multiple Slack thread anchors per channel", () => {

package/src/__tests__/config-loader-backfill.test.ts

@@ -877,13 +877,13 @@ describe("loadConfig startup behavior", () => {
       raw.llm.defaultProvider,
     );
     expect(effective.balanced?.provider).toBe("openai");
-    expect(effective.balanced?.model).toBe("gpt-5.4-mini");
+    expect(effective.balanced?.model).toBe("gpt-5.6-luna");
     expect(effective.balanced?.provider_connection).toBe("openai-personal");
     expect(effective.balanced?.source).toBe("managed");
     expect(effective["quality-optimized"]?.provider).toBe("openai");
-    expect(effective["quality-optimized"]?.model).toBe("gpt-5.4");
+    expect(effective["quality-optimized"]?.model).toBe("gpt-5.6-sol");
     expect(effective["cost-optimized"]?.provider).toBe("openai");
-    expect(effective["cost-optimized"]?.model).toBe("gpt-5.4-nano");
+    expect(effective["cost-optimized"]?.model).toBe("gpt-5.6-luna");
   });
 
   test("off-platform hatch with a provider outside the named matrix columns resolves through the shared BYOK templates", () => {

package/src/__tests__/config-schema.test.ts

@@ -398,11 +398,19 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("rejects invalid provider", () => {
+  test("parses an unknown provider (read tolerance for entry names)", () => {
+    // The provider schema is an open string: a stored value outside the
+    // known set parses instead of stripping its profile, and dispatch
+    // resolves it as a connection entry name (or fails explainably).
+    // Write-time membership is enforced at the profiles route and the
+    // config-write choke point.
     const result = AssistantConfigSchema.safeParse({
-      llm: { profiles: { custom: { provider: "invalid" } } },
+      llm: { profiles: { custom: { provider: "anthropic-work" } } },
     });
-    expect(result.success).toBe(false);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.llm.profiles.custom?.provider).toBe("anthropic-work");
+    }
   });
 
   test("accepts the vellum and chatgpt routing identities with a routable model", () => {
@@ -940,8 +948,6 @@ describe("AssistantConfigSchema", () => {
         endpointDecisionTimeoutMs: 1200,
         endpointExtensionMs: 1500,
         endpointMaxExtensions: 2,
-        ackFirstDeltaTimeoutMs: 2500,
-        ackGenerationTimeoutMs: 600,
         progress: {
           enabled: true,
           opsThreshold: 3,
@@ -952,6 +958,12 @@ describe("AssistantConfigSchema", () => {
           generationTimeoutMs: 1500,
         },
       },
+      flux: {
+        turnEnd: { enabled: false },
+        model: "flux-general-en",
+        eotThreshold: 0.7,
+        eotTimeoutMs: 5000,
+      },
       maxSessionDurationSeconds: 1800,
       archiveAudio: false,
     });
@@ -976,6 +988,8 @@ describe("AssistantConfigSchema", () => {
     // Unspecified vad fields still get defaults
     expect(result.liveVoice.vad.maxTurnDurationMs).toBe(30000);
     expect(result.liveVoice.maxSessionDurationSeconds).toBe(900);
+    // A partial liveVoice override leaves Flux turn-end disabled by default.
+    expect(result.liveVoice.flux.turnEnd.enabled).toBe(false);
   });
 
   test("accepts a liveVoice.vad.bargeInMinSpeechMs of 0 (guard disabled)", () => {
@@ -2340,16 +2354,17 @@ describe("loadConfig with schema validation", () => {
     expect(config.llm.callSites?.mainAgent?.maxTokens).toBe(4096);
   });
 
-  test("falls back to default for invalid provider", () => {
-    // Leaf-deletion recovery: the invalid provider leaf is stripped and the
-    // rest of the profile survives.
+  test("keeps an unknown provider on load (read tolerance for entry names)", () => {
+    // The open provider schema keeps the whole profile: an unknown value is
+    // resolved as a connection entry name at dispatch (or fails there
+    // explainably) rather than being leaf-stripped on read.
     writeConfig({
       llm: {
-        profiles: { custom: { provider: "invalid-provider", model: "gpt-4" } },
+        profiles: { custom: { provider: "unknown-provider", model: "gpt-4" } },
       },
     });
     const config = loadConfig();
-    expect(config.llm.profiles.custom?.provider).toBeUndefined();
+    expect(config.llm.profiles.custom?.provider).toBe("unknown-provider");
     expect(config.llm.profiles.custom?.model).toBe("gpt-4");
   });
 

package/src/__tests__/conversation-agent-loop-inference-profile.test.ts

@@ -325,6 +325,8 @@ mock.module("../persistence/llm-request-log-store.js", () => ({
 
 import type { Conversation } from "../daemon/conversation.js";
 import { runAgentLoopImpl } from "../daemon/conversation-agent-loop.js";
+import type { QueueDrainReason } from "../daemon/conversation-queue-manager.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // ── Test helpers ─────────────────────────────────────────────────────
 
@@ -363,7 +365,7 @@ function makeCtx(
     ];
   };
 
-  return {
+  return asConversation({
     conversationId: "test-conv",
     messages: [
       { role: "user", content: [{ type: "text", text: "Hello" }] },
@@ -433,12 +435,7 @@ function makeCtx(
     skillProjectionCache:
       new Map() as unknown as Conversation["skillProjectionCache"],
 
-    usageStats: {
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalEstimatedCost: 0,
-      model: "",
-    },
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     turnCount: 0,
 
     lastAssistantAttachments: [],
@@ -456,12 +453,12 @@ function makeCtx(
     getQueueDepth: () => 0,
     hasQueuedMessages: () => false,
     canHandoffAtCheckpoint: () => false,
-    drainQueue: (_reason?: string) => {},
+    drainQueue: async (_reason?: QueueDrainReason) => {},
     // Forwards to drainQueue so tests that spy the drain observe the agent
     // loop's post-turn kick through the guarded entry point.
     kickDrainQueue(
-      this: { drainQueue: (reason?: string) => unknown },
-      reason: string = "loop_complete",
+      this: { drainQueue: (reason?: QueueDrainReason) => Promise<void> },
+      reason: QueueDrainReason = "loop_complete",
       _origin?: string,
     ) {
       return this.drainQueue(reason);
@@ -493,7 +490,7 @@ function makeCtx(
     } as unknown as Conversation["graphMemory"],
 
     ...overrides,
-  } as unknown as Conversation;
+  });
 }
 
 // ── Tests ────────────────────────────────────────────────────────────

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -472,6 +472,8 @@ mock.module("../memory/archive-store.js", () => ({
 import { AgentLoop } from "../agent/loop.js";
 import type { Conversation } from "../daemon/conversation.js";
 import { runAgentLoopImpl } from "../daemon/conversation-agent-loop.js";
+import type { QueueDrainReason } from "../daemon/conversation-queue-manager.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 import {
   createMockProvider,
   type ScriptedResponse,
@@ -519,7 +521,7 @@ function makeCtx(
     toolExecutor,
   });
 
-  const ctx = {
+  const ctx = asConversation({
     conversationId: "test-conv",
     messages: [
       { role: "user", content: [{ type: "text", text: "Hello" }] },
@@ -572,12 +574,7 @@ function makeCtx(
     skillProjectionCache:
       new Map() as unknown as Conversation["skillProjectionCache"],
 
-    usageStats: {
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalEstimatedCost: 0,
-      model: "",
-    },
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     turnCount: 0,
 
     lastAssistantAttachments: [],
@@ -595,12 +592,12 @@ function makeCtx(
     getQueueDepth: () => 0,
     hasQueuedMessages: () => false,
     canHandoffAtCheckpoint: () => false,
-    drainQueue: (_reason?: string) => {},
+    drainQueue: async (_reason?: QueueDrainReason) => {},
     // Forwards to drainQueue so tests that spy the drain observe the agent
     // loop's post-turn kick through the guarded entry point.
     kickDrainQueue(
-      this: { drainQueue: (reason?: string) => unknown },
-      reason: string = "loop_complete",
+      this: { drainQueue: (reason?: QueueDrainReason) => Promise<void> },
+      reason: QueueDrainReason = "loop_complete",
       _origin?: string,
     ) {
       return this.drainQueue(reason);
@@ -632,7 +629,7 @@ function makeCtx(
     } as unknown as Conversation["graphMemory"],
 
     ...ctxOverrides,
-  } as unknown as Conversation;
+  });
   // The convergence driver resolves the turn-scoped overflow ladder off the
   // manager; give every fake manager the ladder methods unless a test supplied
   // its own.

package/src/__tests__/conversation-agent-loop.test.ts

@@ -268,7 +268,18 @@ const setConversationHistoryStrippedAtMock = mock(
 const updateConversationSlackContextWatermarkMock = mock(
   (_conversationId: string, _watermarkTs: string, _compactedAt?: number) => {},
 );
-let mockConversationRow: Record<string, unknown> = {
+interface MockConversationRow {
+  conversationType?: string;
+  source?: string;
+  contextSummary?: string | null;
+  contextCompactedMessageCount?: number;
+  contextCompactedAt?: number | null;
+  slackContextCompactionWatermarkTs?: string | null;
+  lastNotifiedInferenceProfile?: string | null;
+  processingStartedAt?: string | null;
+  [key: string]: unknown;
+}
+let mockConversationRow: MockConversationRow = {
   id: "conv-1",
   createdAt: 1_700_000_000_000,
   contextSummary: null,
@@ -675,7 +686,9 @@ import {
   applyCompactionResult,
   runAgentLoopImpl,
 } from "../daemon/conversation-agent-loop.js";
+import type { QueueDrainReason } from "../daemon/conversation-queue-manager.js";
 import { settleTurnTail } from "../daemon/turn-tail-chain.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 import {
   createMockProvider,
   type ScriptedResponse,
@@ -731,7 +744,7 @@ function makeCtx(
     toolExecutor,
   });
 
-  const ctx = {
+  const ctx = asConversation({
     conversationId: "test-conv",
     messages: [
       { role: "user", content: [{ type: "text", text: "Hello" }] },
@@ -791,12 +804,7 @@ function makeCtx(
     skillProjectionCache:
       new Map() as unknown as Conversation["skillProjectionCache"],
 
-    usageStats: {
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalEstimatedCost: 0,
-      model: "",
-    },
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     turnCount: 0,
 
     lastAssistantAttachments: [],
@@ -814,12 +822,12 @@ function makeCtx(
     getQueueDepth: () => 0,
     hasQueuedMessages: () => false,
     canHandoffAtCheckpoint: () => false,
-    drainQueue: (_reason?: string) => {},
+    drainQueue: async (_reason?: QueueDrainReason) => {},
     // Forwards to drainQueue so tests that spy the drain observe the agent
     // loop's post-turn kick through the guarded entry point.
     kickDrainQueue(
-      this: { drainQueue: (reason?: string) => unknown },
-      reason: string = "loop_complete",
+      this: { drainQueue: (reason?: QueueDrainReason) => Promise<void> },
+      reason: QueueDrainReason = "loop_complete",
       _origin?: string,
     ) {
       return this.drainQueue(reason);
@@ -851,7 +859,7 @@ function makeCtx(
     } as unknown as Conversation["graphMemory"],
 
     ...ctxOverrides,
-  } as unknown as Conversation;
+  });
   // Reactive overflow recovery resolves the turn-scoped reduction ladder off
   // the manager; give every fake manager the ladder methods unless a test
   // supplied its own.
@@ -1795,7 +1803,7 @@ describe("session-agent-loop", () => {
         ],
         toolExecutor: async () => ({ content: "file content", isError: false }),
         canHandoffAtCheckpoint: () => true,
-      } as unknown as Partial<Conversation>);
+      });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
@@ -1826,7 +1834,7 @@ describe("session-agent-loop", () => {
         ],
         toolExecutor: async () => ({ content: "content", isError: false }),
         canHandoffAtCheckpoint: () => false,
-      } as unknown as Partial<Conversation>);
+      });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
@@ -1975,13 +1983,13 @@ describe("session-agent-loop", () => {
 
     test("drains queue after completion", async () => {
       // GIVEN a real loop that answers in a single text turn
-      let drainReason: string | undefined;
+      let drainReason: QueueDrainReason | undefined;
       const ctx = makeCtx({
         providerResponses: [textResponse("ok")],
-        drainQueue: (reason: string) => {
+        drainQueue: async (reason?: QueueDrainReason) => {
           drainReason = reason;
         },
-      } as unknown as Partial<Conversation>);
+      });
 
       // WHEN the orchestrator runs the turn to completion
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
@@ -2018,10 +2026,10 @@ describe("session-agent-loop", () => {
         abortController,
         // Fire the watchdog quickly instead of the ~45s production default.
         abortWatchdogMs: 30,
-        drainQueue: (reason: string) => {
+        drainQueue: async (reason?: QueueDrainReason) => {
           drainReason = reason;
         },
-      } as unknown as Partial<Conversation>);
+      });
 
       try {
         // WHEN the orchestrator runs the turn
@@ -2520,7 +2528,7 @@ describe("session-agent-loop", () => {
           },
         ],
         toolExecutor: async () => ({ content: "file content", isError: false }),
-      } as unknown as Partial<Conversation>);
+      });
 
       await runAgentLoopImpl(ctx, "hello", "msg-user-daily", () => {});
 

package/src/__tests__/conversation-attention-store.test.ts

@@ -832,3 +832,66 @@ describe("conversation-attention-store", () => {
     });
   });
 });
+
+describe("attention watermarks and streaming rows", () => {
+  test("state init from an upgraded database anchors on the latest finalized reply", () => {
+    clearTables();
+    ensureConversation("conv-1");
+    insertAssistantMessage("conv-1", "msg-done", 1_000);
+    getDb()
+      .insert(messages)
+      .values({
+        id: "msg-streaming",
+        conversationId: "conv-1",
+        role: "assistant",
+        content: "still being written",
+        createdAt: 2_000,
+        metadata: null,
+        finalized: 0,
+      })
+      .run();
+
+    // No attention row exists, so the seen signal initializes state from the
+    // messages table. The streaming row is newest but is not a reply yet;
+    // anchoring the watermark on it would classify the finished reply as
+    // already seen the moment it completes.
+    recordConversationSeenSignal({
+      conversationId: "conv-1",
+      sourceChannel: "vellum",
+      signalType: "macos_conversation_opened",
+      confidence: "explicit",
+      source: "desktop-client",
+    });
+
+    const state = getAttentionStateByConversationIds(["conv-1"]).get("conv-1")!;
+    expect(state.latestAssistantMessageId).toBe("msg-done");
+    expect(state.lastSeenAssistantMessageId).toBe("msg-done");
+  });
+});
+
+describe("markConversationUnread with only a streaming reply", () => {
+  test("reports no assistant message rather than rewinding onto the streaming row", () => {
+    clearTables();
+    ensureConversation("conv-1");
+    getDb()
+      .insert(messages)
+      .values({
+        id: "msg-streaming-only",
+        conversationId: "conv-1",
+        role: "assistant",
+        content: "still being written",
+        createdAt: 1_000,
+        metadata: null,
+        finalized: 0,
+      })
+      .run();
+
+    // The write-path projection anchors at the finalize seam
+    // (`reserveMessage` deliberately skips it), so attention state for this
+    // conversation says "no reply yet". The rewind fallback must agree with
+    // the projection rather than anchoring on the streaming row.
+    expect(() => markConversationUnread("conv-1")).toThrow(
+      /no assistant message/i,
+    );
+  });
+});

package/src/__tests__/conversation-delete-schedule-cleanup.test.ts

@@ -10,10 +10,6 @@ mock.module("../config/env.js", () => ({
   hasUngatedHttpAuthDisabled: () => false,
 }));
 
-mock.module("../daemon/conversation-store.js", () => ({
-  destroyActiveConversation: () => {},
-}));
-
 mock.module("../daemon/handlers/conversations.js", () => ({
   cancelGeneration: () => true,
   clearAllConversations: async () => 0,