@vellumai/assistant 0.12.0 → 0.12.1-staging.1

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

@@ -161,12 +161,6 @@ function makeFakeContext(opts: {
       trustClass: "guardian" as const,
       guardianPrincipalId: "user-1",
     },
-    setTrustContext(
-      this: { trustContext?: TrustContext },
-      trustContext: TrustContext | null,
-    ) {
-      this.trustContext = trustContext ?? undefined;
-    },
     setTransportHints() {},
     applyHostEnvFromTransport() {},
     ensureHostProxiesForTurn() {},
@@ -415,10 +409,10 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       "U-contact",
     );
     expect(ctx.currentTurnTrustContext?.sourceChannel).toBe("slack");
-    // 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);
+    // 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");
   });
 
   test("buildPassthroughBatch refuses to coalesce two channel senders", async () => {

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

@@ -450,17 +450,6 @@ 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
@@ -726,22 +715,21 @@ describe("Conversation message queue", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  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.
+  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.
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.setTrustContext({
-      trustClass: "trusted_contact",
-      sourceChannel: "slack",
+    const contact = {
+      trustClass: "trusted_contact" as const,
+      sourceChannel: "slack" as const,
       requesterExternalUserId: "U-contact",
-    });
+    };
+    conversation.setTrustContext(contact);
 
     const p1 = conversation.processMessage({
       content: "msg-1",
@@ -756,7 +744,6 @@ describe("Conversation message queue", () => {
       sourceChannel: "vellum" as const,
       requesterExternalUserId: "guardian-principal",
     };
-    const reloads = countHistoryReloads(conversation);
     conversation.enqueueMessage({
       content: "msg-2",
       requestId: "req-2",
@@ -767,83 +754,30 @@ describe("Conversation message queue", () => {
     await p1;
     await waitForPendingRun(2);
 
-    // 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);
+    // 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);
     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("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.
+  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.
     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",
     };
-    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",
-    });
+    conversation.setTrustContext(guardian);
 
     const p1 = conversation.processMessage({
       content: "msg-1",
@@ -853,49 +787,39 @@ describe("Conversation message queue", () => {
     });
     await waitForPendingRun(1);
 
-    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",
+    const contact = {
+      trustClass: "trusted_contact" as const,
+      sourceChannel: "slack" as const,
+      requesterExternalUserId: "U-contact",
     };
     conversation.enqueueMessage({
       content: "msg-2",
       requestId: "req-2",
-      trustContext: guardian,
+      trustContext: contact,
     });
 
-    // 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(movedDuringReload).toBe(true);
-    expect(conversation.getTrustContext()).toBe(intruder);
-    expect(conversation.currentTurnTrustContext).toBe(guardian);
-    expect(conversation.currentTurnInboundActorContext).toBeNull();
+    expect(conversation.getTrustContext()).toBe(guardian);
+    expect(conversation.currentTurnTrustContext).toBe(contact);
+    expect(conversation.currentTurnInboundActorContext).toMatchObject({
+      trustClass: "trusted_contact",
+      sourceChannel: "slack",
+      canonicalActorIdentity: "U-contact",
+    });
 
     await resolveRun(1);
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  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.
+  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.
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
@@ -906,110 +830,27 @@ 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",
     };
-    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);
+    await expect(
+      conversation.processMessage({
+        content: "msg-1",
+        attachments: [],
+        onEvent: () => {},
+        requestId: "req-1",
+        trustContext: guardian,
+      }),
+    ).rejects.toThrow("history store exploded");
 
-    // 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(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));
+    expect(pendingRuns.length).toBe(0);
   });
 
   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,13 +10,26 @@ import {
   discardLastAssistantDisplayTurn,
   extractUserPromptText,
 } from "../daemon/conversation-history.js";
+import { registerPluginHooks } from "../hooks/registry.js";
 import { addMessage, getMessages } from "../persistence/conversation-crud.js";
-import { getDb } from "../persistence/db-connection.js";
+import { getDb, getMemorySqlite } 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 {
@@ -211,3 +224,43 @@ 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,6 +545,33 @@ 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,8 +146,10 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
       });
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("not available");
-      expect(result.content).toContain("app-control");
+      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");
       // No envelope dispatched.
       expect(sentMessages).toHaveLength(0);
     });
@@ -163,7 +165,10 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
       });
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("not available");
+      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(sentMessages).toHaveLength(0);
 
       proxy.dispose();

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

@@ -21,6 +21,7 @@ import {
 function makeContext(
   sent: AssistantEvent[] = [],
   channelCapabilities?: { channel: string; supportsDynamicUi: boolean },
+  opts?: { hasNoClient?: boolean },
 ): Conversation {
   return asConversation({
     conversationId: "session-1",
@@ -37,6 +38,7 @@ 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,
@@ -65,6 +67,71 @@ 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, {