@vellumai/assistant 0.12.1-staging.1 → 0.12.1

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

@@ -901,32 +901,6 @@ describe("pairDeliveryWithConversation", () => {
   // body has to land there for that button to open something that contains
   // the notification the user tapped.
 
-  test("assistant reply keeps the source conversation without appending its preview", async () => {
-    mockExistingConversations["conv-user-chat"] = {
-      id: "conv-user-chat",
-      source: "user",
-      title: "An ordinary chat",
-    };
-    const signal = makeSignal({
-      requiresConversation: undefined,
-      sourceContextId: "conv-user-chat",
-      sourceEventName: "chat.assistant_reply",
-    });
-
-    const result = await pairDeliveryWithConversation(
-      signal,
-      "vellum" as NotificationChannel,
-      makeCopy({ body: "A short push preview…" }),
-    );
-
-    expect(result.conversationId).toBe("conv-user-chat");
-    expect(result.messageId).toBeNull();
-    expect(result.createdNewConversation).toBe(false);
-    expect(createConversationMock).not.toHaveBeenCalled();
-    expect(addMessageMock).not.toHaveBeenCalled();
-    expect(messagesInvalidated).toEqual([]);
-  });
-
   test("passive vellum signal appends the body to the producing conversation", async () => {
     mockExistingConversations["conv-producer"] = {
       id: "conv-producer",

package/src/__tests__/conversation-process-app-control-preactivation.test.ts

@@ -161,6 +161,12 @@ function makeFakeContext(opts: {
       trustClass: "guardian" as const,
       guardianPrincipalId: "user-1",
     },
+    setTrustContext(
+      this: { trustContext?: TrustContext },
+      trustContext: TrustContext | null,
+    ) {
+      this.trustContext = trustContext ?? undefined;
+    },
     setTransportHints() {},
     applyHostEnvFromTransport() {},
     ensureHostProxiesForTurn() {},
@@ -409,10 +415,10 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       "U-contact",
     );
     expect(ctx.currentTurnTrustContext?.sourceChannel).toBe("slack");
-    // The slot itself is left alone; only the turn's view is corrected. A
-    // drain stamping it would attribute the conversation to a sender whose
-    // turn can still lose the processing lock at persist time.
-    expect(ctx.trustContext?.trustClass).toBe("guardian");
+    // The drain is where a queued message commits to a run, so the resting
+    // slot names the sender too: history is scoped from it, and a slot still
+    // naming the guardian would hand the contact's turn the guardian's rows.
+    expect(ctx.trustContext).toBe(contactTrust);
   });
 
   test("buildPassthroughBatch refuses to coalesce two channel senders", async () => {

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

@@ -450,6 +450,17 @@ async function waitForCondition(
   }
 }
 
+/** Count the history reloads a conversation performs from this point on. */
+function countHistoryReloads(conversation: Conversation): () => number {
+  const originalLoad = conversation.loadFromDb.bind(conversation);
+  let reloads = 0;
+  conversation.loadFromDb = async () => {
+    reloads++;
+    return originalLoad();
+  };
+  return () => reloads;
+}
+
 /**
  * Resolve the Nth pending AgentLoop.run() call. Fires the minimal events
  * that `runAgentLoop` expects (usage + message_complete) so the conversation
@@ -715,21 +726,22 @@ describe("Conversation message queue", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  test("the turn-context actor section describes the turn's actor, not the conversation's resting actor", async () => {
-    // The drain carries its sender on the per-turn field and leaves the
-    // resting slot naming the previous actor. The actor section is frozen at
-    // turn start, so it has to read the turn's actor: reading the slot is what
-    // told the guardian's own drained turn it was talking to a trusted
-    // contact.
+  test("a drained turn commits its sender as the resting actor and re-scopes history", async () => {
+    // A contact's channel turn leaves the resting slot, and the resident
+    // history scoped from it, naming the contact. The guardian's message
+    // queued behind that turn must run as the guardian everywhere the slot is
+    // read, not only in the per-turn snapshot: the `<turn_context>` actor
+    // section is derived at turn start and history is scoped from the slot,
+    // so a drain that stamped only the snapshot rendered the guardian's own
+    // web turn as a trusted contact's and hid the guardian's rows from it.
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    const contact = {
-      trustClass: "trusted_contact" as const,
-      sourceChannel: "slack" as const,
+    conversation.setTrustContext({
+      trustClass: "trusted_contact",
+      sourceChannel: "slack",
       requesterExternalUserId: "U-contact",
-    };
-    conversation.setTrustContext(contact);
+    });
 
     const p1 = conversation.processMessage({
       content: "msg-1",
@@ -744,6 +756,7 @@ describe("Conversation message queue", () => {
       sourceChannel: "vellum" as const,
       requesterExternalUserId: "guardian-principal",
     };
+    const reloads = countHistoryReloads(conversation);
     conversation.enqueueMessage({
       content: "msg-2",
       requestId: "req-2",
@@ -754,30 +767,83 @@ describe("Conversation message queue", () => {
     await p1;
     await waitForPendingRun(2);
 
-    // Guard the test itself: the slot must disagree with the turn, or the
-    // assertion below passes for the wrong reason.
-    expect(conversation.getTrustContext()).toBe(contact);
+    // Read while run 2 is in flight: the slot, the snapshot, and the frozen
+    // actor section all describe the guardian, and the history was reloaded
+    // for that scope exactly once.
+    expect(conversation.getTrustContext()).toBe(guardian);
     expect(conversation.currentTurnTrustContext).toBe(guardian);
-    // A guardian turn renders no actor section, whatever the slot says.
     expect(conversation.currentTurnInboundActorContext).toBeNull();
+    expect(reloads()).toBe(1);
 
     await resolveRun(1);
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  test("the actor section names the drained contact while the slot holds the guardian", async () => {
-    // The inverse direction, so the assertion above cannot pass merely because
-    // the section is always absent: a contact's message drained behind the
-    // guardian's turn must be described as that contact.
+  test("a batched drain commits the head's sender as the resting actor", async () => {
+    // Same commitment on the batched path, which coalesces only messages that
+    // share a trust identity, so the head's sender is the batch's actor.
     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);
+
     const guardian = {
       trustClass: "guardian" as const,
       sourceChannel: "vellum" as const,
       requesterExternalUserId: "guardian-principal",
     };
-    conversation.setTrustContext(guardian);
+    const reloads = countHistoryReloads(conversation);
+    conversation.enqueueMessage({
+      content: "msg-2",
+      requestId: "req-2",
+      trustContext: guardian,
+    });
+    conversation.enqueueMessage({
+      content: "msg-3",
+      requestId: "req-3",
+      trustContext: guardian,
+    });
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    // One batched run for both siblings, committed as the guardian.
+    expect(pendingRuns.length).toBe(2);
+    expect(conversation.getTrustContext()).toBe(guardian);
+    expect(conversation.currentTurnTrustContext).toBe(guardian);
+    expect(conversation.currentTurnInboundActorContext).toBeNull();
+    expect(reloads()).toBe(1);
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+
+  test("a drained turn keeps its sender when the slot moves during the history reload", async () => {
+    // The commit captures the sender before the reload awaits. A writer that
+    // moves the slot inside that await (a wake's stamp, a pointer elevation)
+    // must not become the turn's actor: the history was reloaded for the
+    // sender, and running someone else's trust over it is the escalation.
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    conversation.setTrustContext({
+      trustClass: "trusted_contact",
+      sourceChannel: "slack",
+      requesterExternalUserId: "U-contact",
+    });
 
     const p1 = conversation.processMessage({
       content: "msg-1",
@@ -787,39 +853,49 @@ describe("Conversation message queue", () => {
     });
     await waitForPendingRun(1);
 
-    const contact = {
-      trustClass: "trusted_contact" as const,
-      sourceChannel: "slack" as const,
-      requesterExternalUserId: "U-contact",
+    const guardian = {
+      trustClass: "guardian" as const,
+      sourceChannel: "vellum" as const,
+      requesterExternalUserId: "guardian-principal",
+    };
+    const intruder = {
+      trustClass: "unknown" as const,
+      sourceChannel: "telegram" as const,
+      requesterExternalUserId: "T-stranger",
     };
     conversation.enqueueMessage({
       content: "msg-2",
       requestId: "req-2",
-      trustContext: contact,
+      trustContext: guardian,
     });
 
+    // The drain's reload is the await the writer lands inside.
+    const originalLoad = conversation.loadFromDb.bind(conversation);
+    let movedDuringReload = false;
+    conversation.loadFromDb = async () => {
+      const result = await originalLoad();
+      conversation.setTrustContext(intruder);
+      movedDuringReload = true;
+      return result;
+    };
+
     await resolveRun(0);
     await p1;
     await waitForPendingRun(2);
 
-    expect(conversation.getTrustContext()).toBe(guardian);
-    expect(conversation.currentTurnTrustContext).toBe(contact);
-    expect(conversation.currentTurnInboundActorContext).toMatchObject({
-      trustClass: "trusted_contact",
-      sourceChannel: "slack",
-      canonicalActorIdentity: "U-contact",
-    });
+    expect(movedDuringReload).toBe(true);
+    expect(conversation.getTrustContext()).toBe(intruder);
+    expect(conversation.currentTurnTrustContext).toBe(guardian);
+    expect(conversation.currentTurnInboundActorContext).toBeNull();
 
     await resolveRun(1);
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  test("a processMessage turn whose history reload fails puts the resting actor back", async () => {
-    // `processMessage` is the commitment point, so it stamps the slot before
-    // scoping history. A reload that throws starts no turn, and leaving the
-    // stamp would attribute the conversation to a sender that never ran: an
-    // actorless dispatch afterwards (a deferred wake) resolves the resting
-    // slot and would inherit it.
+  test("a drain whose history reload fails puts the resting actor back", async () => {
+    // A reload that fails starts no turn: the message is requeued for the
+    // next drain, so the slot must not keep naming a sender whose turn never
+    // began, or conversation-level readers report an owner that is not there.
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
@@ -830,27 +906,110 @@ describe("Conversation message queue", () => {
     };
     conversation.setTrustContext(contact);
 
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    const guardian = {
+      trustClass: "guardian" as const,
+      sourceChannel: "vellum" as const,
+      requesterExternalUserId: "guardian-principal",
+    };
+    conversation.enqueueMessage({
+      content: "msg-2",
+      requestId: "req-2",
+      trustContext: guardian,
+    });
+
+    let reloadAttempts = 0;
     conversation.loadFromDb = async () => {
+      reloadAttempts++;
       throw new Error("history store exploded");
     };
 
+    // Finish the first turn; the drain (and its one retry) fail on the reload.
+    await resolveRun(0);
+    await p1;
+    await waitForCondition(() => reloadAttempts >= 2);
+    await new Promise((r) => setTimeout(r, 20));
+
+    expect(pendingRuns.length).toBe(1);
+    expect(conversation.getQueueDepth()).toBe(1);
+    expect(conversation.getTrustContext()).toBe(contact);
+  });
+
+  test("the turn-context actor section follows the turn's actor when the slot moves before the loop opens", async () => {
+    // The actor section is frozen at turn start from the turn's own actor,
+    // not from the resting slot. The drain stamps the slot and then awaits
+    // (persist) before the loop opens; an out-of-band writer landing in that
+    // window (pointer elevation restore, a wake's restore) moves the slot
+    // without owning the turn, and a read of the slot there would describe
+    // that writer's actor to the model.
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const contact = {
+      trustClass: "trusted_contact" as const,
+      sourceChannel: "slack" as const,
+      requesterExternalUserId: "U-contact",
+    };
+    conversation.setTrustContext(contact);
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
     const guardian = {
       trustClass: "guardian" as const,
       sourceChannel: "vellum" as const,
       requesterExternalUserId: "guardian-principal",
     };
-    await expect(
-      conversation.processMessage({
-        content: "msg-1",
-        attachments: [],
-        onEvent: () => {},
-        requestId: "req-1",
-        trustContext: guardian,
-      }),
-    ).rejects.toThrow("history store exploded");
+    conversation.enqueueMessage({
+      content: "msg-2",
+      requestId: "req-2",
+      trustContext: guardian,
+    });
 
+    // Land the out-of-band slot write inside the drain's window, after its
+    // stamp and before the loop opens: the drain awaits persistUserMessage
+    // there. The resting slot alone is moved; the per-turn snapshot is the
+    // drain's to carry into the run.
+    const originalPersist = conversation.persistUserMessage.bind(conversation);
+    let slotMoved = false;
+    (
+      conversation as unknown as {
+        persistUserMessage: typeof conversation.persistUserMessage;
+      }
+    ).persistUserMessage = async (opts) => {
+      const result = await originalPersist(opts);
+      conversation.setTrustContext(contact);
+      slotMoved = true;
+      return result;
+    };
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    // Guard the test itself: the injection must have run, and the slot must
+    // disagree with the turn, or the assertion below passes for the wrong
+    // reason.
+    expect(slotMoved).toBe(true);
     expect(conversation.getTrustContext()).toBe(contact);
-    expect(pendingRuns.length).toBe(0);
+    expect(conversation.currentTurnTrustContext).toBe(guardian);
+    // The guardian's turn renders no actor section, whatever the slot says.
+    expect(conversation.currentTurnInboundActorContext).toBeNull();
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("a processMessage turn keeps its turn-start trust when the slot moves before the loop opens", async () => {

package/src/__tests__/conversation-retry-discard.test.ts

@@ -10,26 +10,13 @@ import {
   discardLastAssistantDisplayTurn,
   extractUserPromptText,
 } from "../daemon/conversation-history.js";
-import { registerPluginHooks } from "../hooks/registry.js";
 import { addMessage, getMessages } from "../persistence/conversation-crud.js";
-import { getDb, getMemorySqlite } from "../persistence/db-connection.js";
+import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { conversations, messages } from "../persistence/schema/index.js";
-import memoryMessageDeleted from "../plugins/defaults/memory/hooks/message-deleted.js";
-import {
-  ensureRetrospectiveCursorColumn,
-  getRetrospectiveState,
-} from "../plugins/defaults/memory/memory-retrospective-state.js";
-import type { PluginHooks } from "../plugins/types.js";
 
 await initializeDb();
 
-// Register the memory plugin's `message-deleted` hook the way boot does, so
-// the delete primitive's dispatch reaches the cursor bookkeeping.
-registerPluginHooks("default-memory", {
-  "message-deleted": memoryMessageDeleted,
-} as PluginHooks);
-
 const CONV_ID = "conv-retry-discard-test";
 
 function seedConversation(): void {
@@ -224,43 +211,3 @@ describe("extractUserPromptText", () => {
     expect(extractUserPromptText([])).toBe("");
   });
 });
-
-describe("discardLastAssistantDisplayTurn keeps the memory-retrospective cursor placeable", () => {
-  beforeEach(() => {
-    ensureRetrospectiveCursorColumn("test");
-    getMemorySqlite()!.exec(`DELETE FROM memory_retrospective_state`);
-  });
-
-  test("a cursor stored without its timestamp gets it from the reply being discarded", async () => {
-    const [, assistantId] = await seed([
-      { role: "user", content: text("hello") },
-      { role: "assistant", content: text("first attempt") },
-    ]);
-    const replyCreatedAt = getMessages(CONV_ID).find(
-      (m) => m.id === assistantId,
-    )!.createdAt;
-    // A state row as a build without the timestamp column wrote it: the
-    // retrospective reviewed through the reply, so the cursor sits on it.
-    getMemorySqlite()!
-      .query(
-        `INSERT INTO memory_retrospective_state
-           (conversation_id, last_processed_message_id, last_run_at, remembered_log, last_processed_created_at)
-         VALUES (?, ?, 1, NULL, NULL)`,
-      )
-      .run(CONV_ID, assistantId);
-
-    discardLastAssistantDisplayTurn(CONV_ID);
-
-    expect(getMessages(CONV_ID).some((m) => m.id === assistantId)).toBe(false);
-    // The hook chain is fire-and-forget from the delete primitive, so the
-    // stamp lands shortly after the discard returns.
-    const deadline = Date.now() + 2_000;
-    let stamped =
-      getRetrospectiveState(CONV_ID)?.lastProcessedCreatedAt ?? null;
-    while (stamped === null && Date.now() < deadline) {
-      await Bun.sleep(10);
-      stamped = getRetrospectiveState(CONV_ID)?.lastProcessedCreatedAt ?? null;
-    }
-    expect(stamped).toBe(replyCreatedAt);
-  });
-});

package/src/__tests__/conversation-skill-tools.test.ts

@@ -545,33 +545,6 @@ describe("projectSkillTools", () => {
     expect(mockRegisteredTools.has("deploy")).toBe(true);
   });
 
-  test("catalog membership changes are visible on the next projection with a persistent cache", () => {
-    const cache = {};
-    mockCatalog = [];
-    mockManifests = { deploy: makeManifest(["deploy_run"]) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    const result1 = projectSkillTools(history, {
-      previouslyActiveSkillIds: sessionState,
-      cache,
-    });
-    expect(result1.allowedToolNames.size).toBe(0);
-    expect(sessionState.has("deploy")).toBe(false);
-
-    mockCatalog = [makeSkill("deploy")];
-
-    const result2 = projectSkillTools(history, {
-      previouslyActiveSkillIds: sessionState,
-      cache,
-    });
-    expect(result2.allowedToolNames).toEqual(new Set(["deploy_run"]));
-    expect(sessionState.has("deploy")).toBe(true);
-    expect(mockRegisteredTools.has("deploy")).toBe(true);
-  });
-
   test("skill with manifest failure on turn 1 is registered when manifest is available on turn 2", () => {
     mockCatalog = [makeSkill("deploy")];
     // No manifest — will fail to load

package/src/__tests__/conversation-surfaces-app-control.test.ts

@@ -146,10 +146,8 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
       });
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain(
-        "The Vellum desktop app is needed to control apps on your computer",
-      );
-      expect(result.content).toContain("https://www.vellum.ai/downloads");
+      expect(result.content).toContain("not available");
+      expect(result.content).toContain("app-control");
       // No envelope dispatched.
       expect(sentMessages).toHaveLength(0);
     });
@@ -165,10 +163,7 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
       });
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain(
-        "The Vellum desktop app is needed to control apps on your computer",
-      );
-      expect(result.content).toContain("https://www.vellum.ai/downloads");
+      expect(result.content).toContain("not available");
       expect(sentMessages).toHaveLength(0);
 
       proxy.dispose();

package/src/__tests__/conversation-surfaces-task-progress.test.ts

@@ -21,7 +21,6 @@ import {
 function makeContext(
   sent: AssistantEvent[] = [],
   channelCapabilities?: { channel: string; supportsDynamicUi: boolean },
-  opts?: { hasNoClient?: boolean },
 ): Conversation {
   return asConversation({
     conversationId: "session-1",
@@ -38,7 +37,6 @@ function makeContext(
     accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
-    hasNoClient: opts?.hasNoClient ?? false,
     isProcessing: () => false,
     enqueueMessage: () => ({ queued: false, requestId: "req-1" }),
     getQueueDepth: () => 0,
@@ -67,71 +65,6 @@ describe("task_progress surface compatibility", () => {
     expect(sent).toHaveLength(0);
   });
 
-  test("persists a clientless choice from a non-rendering channel without waiting", async () => {
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext(
-      sent,
-      {
-        channel: "phone",
-        supportsDynamicUi: false,
-      },
-      { hasNoClient: true },
-    );
-
-    const result = await surfaceProxyResolver(ctx, "ui_show", {
-      surface_type: "choice",
-      title: "Choose a focus",
-      data: {
-        options: [
-          { id: "inbox", title: "Inbox" },
-          { id: "calendar", title: "Calendar" },
-        ],
-      },
-    });
-
-    expect(result.isError).toBe(false);
-    expect(result.yieldToUser).toBeUndefined();
-    const { surfaceId } = JSON.parse(result.content) as { surfaceId: string };
-    expect(ctx.currentTurnSurfaces.some((s) => s.surfaceId === surfaceId)).toBe(
-      true,
-    );
-    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(false);
-    expect(sent.some((msg) => msg.type === "ui_surface_show")).toBe(true);
-  });
-
-  test("persists a clientless update in the current-turn surface snapshot", async () => {
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext(
-      sent,
-      {
-        channel: "phone",
-        supportsDynamicUi: false,
-      },
-      { hasNoClient: true },
-    );
-    const shown = await surfaceProxyResolver(ctx, "ui_show", {
-      surface_type: "card",
-      title: "Background work",
-      data: {
-        template: "task_progress",
-        templateData: { status: "in_progress", steps: [] },
-      },
-    });
-    const { surfaceId } = JSON.parse(shown.content) as { surfaceId: string };
-
-    const result = await surfaceProxyResolver(ctx, "ui_update", {
-      surface_id: surfaceId,
-      data: { templateData: { status: "completed" } },
-    });
-
-    expect(result.isError).toBe(false);
-    const data = ctx.currentTurnSurfaces.find((s) => s.surfaceId === surfaceId)
-      ?.data as CardSurfaceData;
-    expect((data.templateData as Record<string, unknown>).status).toBe(
-      "completed",
-    );
-  });
-
   test("blocks ui_update when channel lacks dynamic UI support", async () => {
     const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent, {