@vellumai/assistant 0.11.3 → 0.11.4-staging.1

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

@@ -79,10 +79,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 +599,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

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -103,6 +103,7 @@ mock.module("../daemon/date-context.js", () => ({
   formatTurnTimestamp: () => FIXED_TURN_TIMESTAMP,
 }));
 
+import type { SurfaceDataByType } from "../api/surfaces.js";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { LLMSchema } from "../config/schemas/llm.js";
 import { REFUSAL_FALLBACK_TEXT } from "../context/refusal-quarantine.js";
@@ -136,7 +137,7 @@ import {
   stripInjectionsForCompaction,
   stripNowScratchpad,
 } from "../daemon/conversation-runtime-assembly.js";
-import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
+import type { SurfaceStateEntry } from "../daemon/conversation-surface-state.js";
 import { buildPkbReminder } from "../daemon/pkb-reminder-builder.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import {
@@ -161,6 +162,7 @@ import { wrapUntrustedContent } from "../security/untrusted-content.js";
 import { getSubagentManager } from "../subagent/index.js";
 import type { SubagentState } from "../subagent/types.js";
 import { getWorkspacePromptPath } from "../util/platform.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // `applyRuntimeInjections` self-resolves the Slack active-thread focus block by
 // reading the live conversation's persisted message rows, so the schema must
@@ -215,27 +217,30 @@ function seedActiveSurfaceConversation(
   conversationId: string,
   workspaceText: string,
   surfaceId: string,
-  data: SurfaceData,
+  data: SurfaceDataByType["dynamic_page"],
   channelCapabilities?: ChannelCapabilities,
   commandIntent?: { type: string; payload?: string; languageCode?: string },
   currentTurnTemporalSnapshot?: {
     clientTimezone: string | null;
+    timeSinceLastMessage: string | null;
   },
 ): void {
-  setConversation(conversationId, {
+  setConversation(
     conversationId,
-    workingDir: "/sandbox",
-    workspaceTopLevelContext: workspaceText,
-    workspaceTopLevelDirty: false,
-    currentActiveSurfaceId: surfaceId,
-    surfaceState: new Map<
-      string,
-      { surfaceType: SurfaceType; data: SurfaceData }
-    >([[surfaceId, { surfaceType: "dynamic_page", data }]]),
-    channelCapabilities: channelCapabilities ?? undefined,
-    commandIntent,
-    currentTurnTemporalSnapshot,
-  } as never);
+    asConversation({
+      conversationId,
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: workspaceText,
+      workspaceTopLevelDirty: false,
+      currentActiveSurfaceId: surfaceId,
+      surfaceState: new Map<string, SurfaceStateEntry>([
+        [surfaceId, { surfaceType: "dynamic_page", data }],
+      ]),
+      channelCapabilities: channelCapabilities ?? undefined,
+      commandIntent,
+      currentTurnTemporalSnapshot,
+    }),
+  );
 }
 
 function clearWorkspaceContext(): void {
@@ -252,15 +257,18 @@ function seedChannelCapabilitiesConversation(
   caps: ChannelCapabilities | null,
   transportHints?: string[],
 ): void {
-  setConversation("runtime-assembly-fallback", {
-    conversationId: "runtime-assembly-fallback",
-    workingDir: "/sandbox",
-    workspaceTopLevelContext: "",
-    workspaceTopLevelDirty: false,
-    surfaceState: new Map(),
-    channelCapabilities: caps ?? undefined,
-    transportHints,
-  } as never);
+  setConversation(
+    "runtime-assembly-fallback",
+    asConversation({
+      conversationId: "runtime-assembly-fallback",
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: "",
+      workspaceTopLevelDirty: false,
+      surfaceState: new Map(),
+      channelCapabilities: caps ?? undefined,
+      transportHints,
+    }),
+  );
 }
 
 // ---------------------------------------------------------------------------
@@ -986,6 +994,7 @@ describe("applyRuntimeInjections — injection mode", () => {
       { type: "start" },
       {
         clientTimezone: null,
+        timeSinceLastMessage: null,
       },
     );
   });
@@ -1023,15 +1032,18 @@ describe("applyRuntimeInjections — injection mode", () => {
     // rehydration-order tests in conversation-lifecycle.test.ts). background-turn
     // fires only for a background/scheduled live conversation, so register one
     // under the turn's conversation id.
-    setConversation("injection-mode-conv", {
-      conversationId: "injection-mode-conv",
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      channelCapabilities,
-      conversationType: "background",
-    } as never);
+    setConversation(
+      "injection-mode-conv",
+      asConversation({
+        conversationId: "injection-mode-conv",
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        channelCapabilities,
+        conversationType: "background",
+      }),
+    );
 
     const { blocks } = await applyRuntimeInjections(baseMessages, fullOptions);
 
@@ -2227,20 +2239,24 @@ describe("applyRuntimeInjections with unifiedTurnContext", () => {
   // context (so the injector sources the interface label to match
   // `sampleOptions.interfaceName`).
   function seedTemporalSnapshot(): void {
-    setConversation("runtime-assembly-fallback", {
-      conversationId: "runtime-assembly-fallback",
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      currentTurnTemporalSnapshot: {
-        clientTimezone: null,
-      },
-      currentTurnInterfaceContext: {
-        userMessageInterface: "macos",
-        assistantMessageInterface: "macos",
-      },
-    } as never);
+    setConversation(
+      "runtime-assembly-fallback",
+      asConversation({
+        conversationId: "runtime-assembly-fallback",
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        currentTurnTemporalSnapshot: {
+          clientTimezone: null,
+          timeSinceLastMessage: null,
+        },
+        currentTurnInterfaceContext: {
+          userMessageInterface: "macos",
+          assistantMessageInterface: "macos",
+        },
+      }),
+    );
   }
 
   test("injects the turn-context block when the inputs are provided", async () => {
@@ -2327,17 +2343,20 @@ describe("applyRuntimeInjections timezone resolution", () => {
     clientTimezone: string | null,
     timeSinceLastMessage: string | null = null,
   ): void {
-    setConversation("runtime-assembly-fallback", {
-      conversationId: "runtime-assembly-fallback",
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      currentTurnTemporalSnapshot: {
-        clientTimezone,
-        timeSinceLastMessage,
-      },
-    } as never);
+    setConversation(
+      "runtime-assembly-fallback",
+      asConversation({
+        conversationId: "runtime-assembly-fallback",
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        currentTurnTemporalSnapshot: {
+          clientTimezone,
+          timeSinceLastMessage,
+        },
+      }),
+    );
   }
 
   function injectedText(result: { messages: Message[] }): string {
@@ -2491,20 +2510,24 @@ describe("applyRuntimeInjections blocks.unifiedTurnContext", () => {
   // context (so the injector sources the interface label to match
   // `sampleOptions.interfaceName`).
   function seedTemporalSnapshot(): void {
-    setConversation("runtime-assembly-fallback", {
-      conversationId: "runtime-assembly-fallback",
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      currentTurnTemporalSnapshot: {
-        clientTimezone: null,
-      },
-      currentTurnInterfaceContext: {
-        userMessageInterface: "macos",
-        assistantMessageInterface: "macos",
-      },
-    } as never);
+    setConversation(
+      "runtime-assembly-fallback",
+      asConversation({
+        conversationId: "runtime-assembly-fallback",
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        currentTurnTemporalSnapshot: {
+          clientTimezone: null,
+          timeSinceLastMessage: null,
+        },
+        currentTurnInterfaceContext: {
+          userMessageInterface: "macos",
+          assistantMessageInterface: "macos",
+        },
+      }),
+    );
   }
 
   test("captures unifiedTurnContext when tail is a user message", async () => {
@@ -2688,15 +2711,18 @@ describe("applyRuntimeInjections — subagent status", () => {
   // a fallback fake carrying that delegation for the seeded children to
   // surface.
   beforeEach(() => {
-    setConversation(FALLBACK_CONVERSATION_ID, {
-      conversationId: FALLBACK_CONVERSATION_ID,
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      getSubagentChildren: () =>
-        getSubagentManager().getChildrenOf(FALLBACK_CONVERSATION_ID),
-    } as never);
+    setConversation(
+      FALLBACK_CONVERSATION_ID,
+      asConversation({
+        conversationId: FALLBACK_CONVERSATION_ID,
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        getSubagentChildren: () =>
+          getSubagentManager().getChildrenOf(FALLBACK_CONVERSATION_ID),
+      }),
+    );
   });
 
   afterEach(() => {
@@ -2750,14 +2776,17 @@ describe("applyRuntimeInjections — subagent status", () => {
 
   test("skips subagent status when the conversation is itself a subagent", async () => {
     // GIVEN the live conversation is itself a subagent (no nesting)
-    setConversation("runtime-assembly-fallback", {
-      conversationId: "runtime-assembly-fallback",
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      isSubagent: true,
-    } as never);
+    setConversation(
+      "runtime-assembly-fallback",
+      asConversation({
+        conversationId: "runtime-assembly-fallback",
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        isSubagent: true,
+      }),
+    );
     // AND a child is registered under its id
     seedSubagentChild(
       "runtime-assembly-fallback",
@@ -4317,19 +4346,22 @@ describe("Slack channel chronological rendering — multi-thread", () => {
         )
         .run();
     }
-    setConversation("runtime-assembly-fallback", {
-      conversationId: "runtime-assembly-fallback",
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      channelCapabilities: caps,
-      trustContext: { trustClass: "guardian" },
-      slackContextCompactionWatermarkTs:
-        compaction.slackContextCompactionWatermarkTs ?? null,
-      contextCompactedMessageCount:
-        compaction.contextCompactedMessageCount ?? 0,
-    } as never);
+    setConversation(
+      "runtime-assembly-fallback",
+      asConversation({
+        conversationId: "runtime-assembly-fallback",
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        channelCapabilities: caps,
+        trustContext: { trustClass: "guardian", sourceChannel: "vellum" },
+        slackContextCompactionWatermarkTs:
+          compaction.slackContextCompactionWatermarkTs ?? null,
+        contextCompactedMessageCount:
+          compaction.contextCompactedMessageCount ?? 0,
+      }),
+    );
   }
 
   // Re-run a Slack-channel turn through the public assembly path. The