@vellumai/assistant 0.11.3 → 0.11.4-staging.2

package/src/__tests__/conversation-fork-crud.test.ts

@@ -1794,3 +1794,72 @@ describe("forkConversation + memory_retrospective_state", () => {
     expect(fork.slackContextCompactionWatermarkAt).toBe(compactedAt);
   });
 });
+
+describe("forkConversation with unfinalized rows", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("skips unfinalized rows and anchors the fork at the last finalized message", async () => {
+    const source = createConversation("Mid-turn fork");
+    await addMessage(source.id, "user", "question", { skipIndexing: true });
+    const lastFinalized = await addMessage(
+      source.id,
+      "assistant",
+      "completed reply",
+      { skipIndexing: true },
+    );
+    const streaming = await addMessage(
+      source.id,
+      "assistant",
+      "partial reply still being written",
+      { skipIndexing: true },
+    );
+    rawRun(
+      "test:markUnfinalized",
+      "UPDATE messages SET finalized = 0 WHERE id = ?",
+      streaming.id,
+    );
+
+    const fork = forkConversation({ conversationId: source.id });
+    const forkMessages = getMessages(fork.id);
+
+    // The invariant, not mere presence: exactly the finalized rows were
+    // copied, every copy reads as finalized, no copy descends from the
+    // unfinalized source row, and the lineage anchor is a row the fork
+    // actually holds.
+    expect(forkMessages).toHaveLength(2);
+    expect(forkMessages.every((row) => row.finalized === 1)).toBe(true);
+    const forkedFromIds = forkMessages.map(
+      (row) =>
+        (parseMetadata(row.metadata) as { forkSourceMessageId?: string })
+          ?.forkSourceMessageId,
+    );
+    expect(forkedFromIds).not.toContain(streaming.id);
+    expect(fork.forkParentMessageId).toBe(lastFinalized.id);
+    // The source still owns its in-flight row untouched.
+    expect(getMessages(source.id)).toHaveLength(3);
+  });
+
+  test("a stale mid-history unfinalized row is skipped without shifting the anchor", async () => {
+    const source = createConversation("Stale row fork");
+    await addMessage(source.id, "user", "first", { skipIndexing: true });
+    const stale = await addMessage(source.id, "assistant", "orphaned partial", {
+      skipIndexing: true,
+    });
+    const tail = await addMessage(source.id, "user", "latest", {
+      skipIndexing: true,
+    });
+    rawRun(
+      "test:markUnfinalized",
+      "UPDATE messages SET finalized = 0 WHERE id = ?",
+      stale.id,
+    );
+
+    const fork = forkConversation({ conversationId: source.id });
+    const forkMessages = getMessages(fork.id);
+
+    expect(forkMessages).toHaveLength(2);
+    expect(fork.forkParentMessageId).toBe(tail.id);
+  });
+});

package/src/__tests__/conversation-fork-referential.test.ts

@@ -350,3 +350,70 @@ describe("referential forking", () => {
     expect(textOf(getMessages(source.id))).toHaveLength(4);
   });
 });
+
+describe("referential forking with unfinalized rows", () => {
+  beforeEach(() => {
+    resetTables();
+    clearConfig();
+  });
+
+  test("ancestor rows are hidden while unfinalized and appear once finalized", async () => {
+    const source = await seedSource("Launch");
+    const midRow = getMessages(source.id)[1]!;
+    getDb()
+      .update(messages)
+      .set({ finalized: 0 })
+      .where(eq(messages.id, midRow.id))
+      .run();
+
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    // The fork's lineage read excludes the ancestor's in-flight row; the
+    // source's own read keeps it.
+    expect(textOf(getMessages(fork.id))).toEqual([
+      "draft a launch plan",
+      "tweak the timeline",
+      "updated",
+    ]);
+    expect(getMessages(source.id)).toHaveLength(4);
+
+    getDb()
+      .update(messages)
+      .set({ finalized: 1 })
+      .where(eq(messages.id, midRow.id))
+      .run();
+
+    // Once the row finalizes it enters the inherited window on its own.
+    expect(textOf(getMessages(fork.id))).toEqual([
+      "draft a launch plan",
+      "here is a first pass",
+      "tweak the timeline",
+      "updated",
+    ]);
+  });
+
+  test("an unfinalized tail is not the fork anchor", async () => {
+    const source = await seedSource("Launch");
+    const tail = getMessages(source.id).at(-1)!;
+    getDb()
+      .update(messages)
+      .set({ finalized: 0 })
+      .where(eq(messages.id, tail.id))
+      .run();
+
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    expect(fork.forkParentMessageId).not.toBe(tail.id);
+    expect(textOf(getMessages(fork.id))).toEqual([
+      "draft a launch plan",
+      "here is a first pass",
+      "tweak the timeline",
+    ]);
+  });
+});

package/src/__tests__/conversation-fork-retrospective.test.ts

@@ -723,3 +723,27 @@ describe("forkConversationForRetrospective — compacted source", () => {
     });
   });
 });
+
+describe("forkConversationForRetrospective with unfinalized rows", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("skips the unfinalized tail and anchors at the last finalized message", async () => {
+    const source = await seedSource("Mid-turn retro");
+    const tail = getMessages(source.id).at(-1)!;
+    const db = getDb();
+    db.run(`UPDATE messages SET finalized = 0 WHERE id = '${tail.id}'`);
+
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+    const forkMessages = getMessages(fork.id);
+
+    // Invariant: only finalized rows are copied, and the lineage anchor is a
+    // row the fork actually holds.
+    expect(forkMessages).toHaveLength(3);
+    expect(forkMessages.every((row) => row.finalized === 1)).toBe(true);
+    expect(fork.forkParentMessageId).not.toBe(tail.id);
+  });
+});

package/src/__tests__/conversation-notifiers-provenance.test.ts

@@ -0,0 +1,59 @@
+/**
+ * The live-call question notifier persists its row after the voice turn has
+ * settled. The per-turn trust field is not cleared at release, so at that
+ * moment it can still hold the finished turn's actor while voice cleanup has
+ * restored the conversation's resting trust. The row must carry the owner,
+ * not the stale turn actor.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const added: Array<{ metadata?: Record<string, unknown> }> = [];
+mock.module("../persistence/conversation-crud.js", () => ({
+  addMessage: async (
+    _conversationId: string,
+    _role: string,
+    _content: string,
+    options?: { metadata?: Record<string, unknown> },
+  ) => {
+    added.push({ metadata: options?.metadata });
+    return { id: "msg-1", deduplicated: false };
+  },
+  provenanceFromTrustContext: (ctx?: { trustClass?: string }) =>
+    ctx ? { provenanceTrustClass: ctx.trustClass } : {},
+}));
+mock.module("../calls/call-store.js", () => ({
+  getCallSession: () => ({ toNumber: "+15550100" }),
+}));
+
+import { fireCallQuestionNotifier } from "../calls/call-state.js";
+import { registerConversationNotifiers } from "../daemon/conversation-notifiers.js";
+
+describe("live-call question provenance", () => {
+  beforeEach(() => {
+    added.length = 0;
+  });
+
+  test("a row persisted after the turn settled carries the owner, not the stale turn actor", async () => {
+    registerConversationNotifiers("conv-n1", {
+      sendToClient: () => {},
+      messages: [],
+      // Voice cleanup restored the owner; the per-turn field still holds the
+      // finished voice turn's contact.
+      trustContext: {
+        trustClass: "guardian",
+        sourceChannel: "vellum",
+      },
+      currentTurnTrustContext: {
+        trustClass: "trusted_contact",
+        sourceChannel: "phone",
+        requesterExternalUserId: "caller-1",
+      },
+    } as never);
+
+    fireCallQuestionNotifier("conv-n1", "sess-1", "Which slot works?");
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(added.length).toBe(1);
+    expect(added[0]?.metadata?.provenanceTrustClass).toBe("guardian");
+  });
+});

package/src/__tests__/conversation-queue.test.ts

@@ -11,6 +11,7 @@ import type {
 } from "../agent/loop.js";
 import type { AssistantEvent } from "../api/index.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { stampAndBuffer } from "../runtime/assistant-stream-state.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 import { setConfig } from "./helpers/set-config.js";
@@ -79,10 +80,12 @@ mock.module("../persistence/conversation-crud.js", () => ({
   setConversationOriginInterfaceIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
-  provenanceFromTrustContext: () => ({
-    source: "user",
-    trustContext: undefined,
-  }),
+  // Mirrors the real mapping so provenance assertions observe what production
+  // would stamp, rather than a placeholder.
+  provenanceFromTrustContext: (ctx?: { trustClass?: string }) =>
+    ctx
+      ? { provenanceTrustClass: ctx.trustClass }
+      : { provenanceTrustClass: "unknown" },
   getConversationOriginInterface: () => null,
   getConversationOriginChannel: () => null,
   getMessages: () => [],
@@ -597,6 +600,55 @@ describe("Conversation message queue", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 
+  test("a drained slash exchange is stamped with its sender's provenance, not the slot's", async () => {
+    // Provenance gates memory extraction and untrusted-content wrapping, so
+    // the stamped class must be the actor whose message this is. The unknown-
+    // slash drain branch persists an exchange for the queued sender; if the
+    // guardian wrote the conversation slot while that message waited, the
+    // rows must still carry the sender's class.
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    conversation.setTrustContext({
+      trustClass: "trusted_contact",
+      sourceChannel: "slack",
+      requesterExternalUserId: "U-contact",
+    });
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "/definitely-not-a-command",
+      requestId: "req-slash",
+    });
+
+    // The guardian moves the slot while the contact's message waits.
+    conversation.setTrustContext({
+      trustClass: "guardian",
+      sourceChannel: "vellum",
+      requesterExternalUserId: "guardian-principal",
+    });
+
+    capturedAddMessages.length = 0;
+    await resolveRun(0);
+    await p1;
+    await new Promise((r) => setTimeout(r, 20));
+
+    const exchange = capturedAddMessages.filter((m) =>
+      m.content.includes("definitely-not-a-command"),
+    );
+    expect(exchange.length).toBeGreaterThan(0);
+    for (const row of exchange) {
+      expect(row.metadata?.provenanceTrustClass).toBe("trusted_contact");
+    }
+  });
+
   test("a drained turn keeps its sender's trust once the agent loop is running", async () => {
     // Exercises the real drain -> runAgentLoop ordering against a live
     // Conversation. The loop re-initializes the per-turn trust snapshot on
@@ -3872,3 +3924,124 @@ describe("subagent notification user_message_echo suppression", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 });
+
+describe("interactive drain sender rebind", () => {
+  beforeEach(() => {
+    pendingRuns = [];
+  });
+
+  test("a drained interactive message rebinds the hub sender for its turn, then restores the pre-drain state", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    // Queue an interactive item the way the /v1/messages route does when the
+    // conversation is busy.
+    const result = conversation.enqueueMessage({
+      content: "msg-2",
+      requestId: "req-2",
+      onEvent: () => {},
+      isInteractive: true,
+    });
+    expect(result.queued).toBe(true);
+
+    // The interactive turn that finishes ahead of the drain resets the
+    // conversation-level sender to a no-op (process-message.ts contract).
+    // The drained turn must not inherit that dead sender: the
+    // PermissionPrompter reads the conversation-level sender, so a
+    // confirmation_request raised during the drained turn would otherwise
+    // reach no client and hang until the permission timeout.
+    conversation.updateClient(() => {}, true);
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    expect(conversation.getCurrentSender()).toBe(broadcastMessage);
+    expect(conversation.hasNoClient).toBe(false);
+
+    await resolveRun(1);
+    await waitForCondition(
+      () => conversation.getCurrentSender() !== broadcastMessage,
+    );
+    expect(conversation.hasNoClient).toBe(true);
+  });
+
+  test("a drained interactive message restores a live pre-drain binding instead of clearing it", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "msg-2",
+      requestId: "req-2",
+      onEvent: () => {},
+      isInteractive: true,
+    });
+
+    // A live binding predates the drained turn (the send route installs one
+    // when a message is queued behind a non-interactive turn, which performs
+    // no restore). The drain's restore must preserve it for out-of-turn
+    // producers (call transcript and completion notifiers), not clear it.
+    conversation.updateClient(broadcastMessage, false);
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    expect(conversation.getCurrentSender()).toBe(broadcastMessage);
+    expect(conversation.hasNoClient).toBe(false);
+
+    await resolveRun(1);
+    // The drained turn has ended; the pre-drain live binding must survive.
+    await waitForCondition(() => !conversation.isProcessing());
+    expect(conversation.getCurrentSender()).toBe(broadcastMessage);
+    expect(conversation.hasNoClient).toBe(false);
+  });
+
+  test("a drained non-interactive message leaves the no-op sender in place", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "msg-2",
+      requestId: "req-2",
+      onEvent: () => {},
+      isInteractive: false,
+    });
+
+    conversation.updateClient(() => {}, true);
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    expect(conversation.getCurrentSender()).not.toBe(broadcastMessage);
+    expect(conversation.hasNoClient).toBe(true);
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+});