@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/__tests__/channel-retry-sweep.test.ts

@@ -236,6 +236,55 @@ function seedFailedSlackEvent(opts: {
   return inbound.eventId;
 }
 
+function seedFailedTelegramEvent(opts: {
+  content: string;
+  externalChatId: string;
+  messageId: string;
+  threadId?: string;
+  /** Sender display name as `storePayload` records it at ingress. */
+  senderName?: string;
+  /** Stands in for the `channelInbound` the live path captures onto the payload. */
+  channelInbound?: Record<string, unknown>;
+}): string {
+  const inbound = deliveryCrud.recordInbound(
+    "telegram",
+    opts.externalChatId,
+    opts.messageId,
+  );
+  deliveryCrud.storePayload(inbound.eventId, {
+    content: opts.content,
+    sourceChannel: "telegram",
+    interface: "telegram",
+    externalChatId: opts.externalChatId,
+    externalMessageId: opts.messageId,
+    sourceMetadata: {
+      messageId: opts.messageId,
+      ...(opts.threadId ? { threadId: opts.threadId } : {}),
+    },
+    ...(opts.senderName ? { senderName: opts.senderName } : {}),
+    ...(opts.channelInbound ? { channelInbound: opts.channelInbound } : {}),
+    trustCtx: {
+      trustClass: "guardian",
+      sourceChannel: "telegram",
+      requesterExternalUserId: "user-1",
+      requesterChatId: opts.externalChatId,
+      guardianPrincipalId: "principal-1",
+    },
+  });
+
+  getDb()
+    .update(channelInboundEvents)
+    .set({
+      processingStatus: "failed",
+      processingAttempts: 1,
+      retryAfter: Date.now() - 1,
+    })
+    .where(eq(channelInboundEvents.id, inbound.eventId))
+    .run();
+
+  return inbound.eventId;
+}
+
 describe("channel-retry-sweep", () => {
   beforeEach(() => {
     resetTables();
@@ -352,6 +401,37 @@ describe("channel-retry-sweep", () => {
     expect(eventRow?.processingStatus).toBe("processed");
   });
 
+  test("restores the triggering message's id and thread on replay", async () => {
+    seedFailedEventWithTrustClass("guardian", {
+      sourceMessageId: "1700000000.000200",
+      sourceThreadId: "1700000000.000100",
+    });
+
+    let capturedTrust: Record<string, unknown> | undefined;
+    await sweepFailedEvents(async (conversationId, _content, options) => {
+      capturedTrust = (options as { trustContext?: Record<string, unknown> })
+        .trustContext;
+      const messageId = "message-location";
+      getDb()
+        .insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: "retry me" }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
+
+    // The replayed turn names the same message and thread the live turn
+    // did, so the turn's chat and thread lines and approval-card source
+    // links read the same on a retry as on the first attempt.
+    expect(capturedTrust?.sourceMessageId).toBe("1700000000.000200");
+    expect(capturedTrust?.sourceThreadId).toBe("1700000000.000100");
+  });
+
   test("fences a non-guardian Slack replay in external_content and carries the ingress idempotency key", async () => {
     seedFailedSlackEvent({
       trustClass: "unverified_contact",
@@ -442,6 +522,125 @@ describe("channel-retry-sweep", () => {
     expect(capturedOptions?.slackInbound?.channelTs).toBe("1700000000.000200");
   });
 
+  test("replays a captured channelInbound envelope verbatim", async () => {
+    const captured = {
+      source: "telegram",
+      conversationExternalId: "chat-500",
+      messageId: "tg-msg-1",
+      threadId: "topic-3",
+      actorExternalId: "user-77",
+      displayName: "Alice",
+      eventKind: "message",
+    };
+    seedFailedTelegramEvent({
+      content: "retry me",
+      externalChatId: "chat-500",
+      messageId: "tg-msg-1",
+      channelInbound: captured,
+    });
+
+    let capturedOptions:
+      | { channelInbound?: Record<string, unknown> }
+      | undefined;
+    await sweepFailedEvents(async (conversationId, content, options) => {
+      capturedOptions = options as {
+        channelInbound?: Record<string, unknown>;
+      };
+      const messageId = "message-tg-captured";
+      getDb()
+        .insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: content }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
+
+    // The captured envelope is the EXACT object the live turn used, so the
+    // replayed row persists an identical providerMeta.
+    expect(capturedOptions?.channelInbound).toEqual(captured);
+  });
+
+  test("reconstructs channelInbound from the stored payload when no capture exists", async () => {
+    // The crash window: `storePayload` ran at ingress but the daemon died
+    // before `storeInboundChannelMetadata`. Recovery must rebuild the same
+    // envelope the live turn would have persisted, sender fields included.
+    seedFailedTelegramEvent({
+      content: "retry me",
+      externalChatId: "chat-501",
+      messageId: "tg-msg-2",
+      threadId: "topic-9",
+      senderName: "Alice",
+    });
+
+    let capturedOptions:
+      | { channelInbound?: Record<string, unknown> }
+      | undefined;
+    await sweepFailedEvents(async (conversationId, content, options) => {
+      capturedOptions = options as {
+        channelInbound?: Record<string, unknown>;
+      };
+      const messageId = "message-tg-fallback";
+      getDb()
+        .insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: content }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
+
+    expect(capturedOptions?.channelInbound).toEqual({
+      source: "telegram",
+      conversationExternalId: "chat-501",
+      messageId: "tg-msg-2",
+      threadId: "topic-9",
+      displayName: "Alice",
+      actorExternalId: "user-1",
+      eventKind: "message",
+    });
+  });
+
+  test("a Slack replay carries no channelInbound (Slack keeps slackMeta)", async () => {
+    seedFailedSlackEvent({
+      trustClass: "guardian",
+      content: "hello",
+      externalChatId: "C0000001",
+      channelTs: "1700000001.000100",
+    });
+
+    let capturedOptions:
+      | { channelInbound?: Record<string, unknown> }
+      | undefined;
+    await sweepFailedEvents(async (conversationId, content, options) => {
+      capturedOptions = options as {
+        channelInbound?: Record<string, unknown>;
+      };
+      const messageId = "message-slack-no-neutral";
+      getDb()
+        .insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: content }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
+
+    expect(capturedOptions?.channelInbound).toBeUndefined();
+  });
+
   test("replays the sender's Slack app context from the captured slackInbound", async () => {
     seedFailedSlackEvent({
       trustClass: "guardian",

package/src/__tests__/client-os-metadata-persistence.test.ts

@@ -84,6 +84,7 @@ function createWebTurnContext(
     size: () => 0,
   } as unknown as MessageQueue;
   let processing = false;
+  let owner = 0;
   return {
     conversationId: "conv-client-os-test",
     messages: [],
@@ -91,6 +92,21 @@ function createWebTurnContext(
     setProcessing: (value: boolean) => {
       processing = value;
     },
+    acquireProcessingFenced: async () => {
+      if (processing) {
+        return null;
+      }
+      processing = true;
+      owner += 1;
+      return owner;
+    },
+    releaseProcessing: (claim: number) => {
+      if (claim !== owner) {
+        return false;
+      }
+      processing = false;
+      return true;
+    },
     abortController: null,
     queue: queueStub,
     clientOs,
@@ -111,7 +127,7 @@ describe("client OS surface metadata persistence", () => {
     addMessageCalls.length = 0;
   });
 
-  test.each(["macos", "windows", "ios", "android", "web"])(
+  test.each(["macos", "windows", "linux", "ios", "android", "web"])(
     "stamps client.os = %s from the conversation's clientOs",
     async (os) => {
       const ctx = createWebTurnContext(os);
@@ -137,7 +153,7 @@ describe("client OS surface metadata persistence", () => {
   });
 
   test("omits the client bag for values outside the ClientOs vocabulary", async () => {
-    const ctx = createWebTurnContext("linux");
+    const ctx = createWebTurnContext("plan9");
     await persistQueuedMessageBody(ctx, {
       content: "hello",
       requestId: "req-invalid",
@@ -214,9 +230,22 @@ describe("client OS per-row evidence marker", () => {
     expect(isDesktopOriginatedUserMessage(lastUserMetadata())).toBe(true);
   });
 
+  test("recognizes a Linux app turn as desktop-originated", async () => {
+    const ctx = createWebTurnContext("linux");
+    await persistQueuedMessageBody(ctx, {
+      content: "hello",
+      requestId: "req-transport-os-linux",
+      requestClientOs: "linux",
+    });
+
+    expect(lastUserMetadata().client).toEqual({ os: "linux" });
+    expect(lastUserMetadata().clientOsFromRequest).toBe(true);
+    expect(isDesktopOriginatedUserMessage(lastUserMetadata())).toBe(true);
+  });
+
   // Mirrors the Mac-originated case above: a plain browser tab reports
   // `client.os: "web"`, while the Electron desktop renderer resolves its own
-  // host OS first and persists `macos`/`windows` instead.
+  // host OS first and persists `macos`/`windows`/`linux` instead.
   test("marks an OS this row's own transport reported (web)", async () => {
     const ctx = createWebTurnContext("web");
     await persistQueuedMessageBody(ctx, {

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

@@ -1677,6 +1677,21 @@ describe("ConnectionResolutionError classification", () => {
     expect(result.userMessage).toContain("Restart the assistant");
   });
 
+  it("classifies adapter_unavailable for a Vellum-hosted GPU model", () => {
+    const err = new ConnectionResolutionError(
+      "vellum",
+      "adapter_unavailable",
+      "no adapter",
+      { model: "qwen/qwen3-8b", profileName: "steer" },
+    );
+    const result = classifyConversationError(err, errCtx);
+    expect(result.code).toBe("PROVIDER_NOT_CONFIGURED");
+    expect(result.userMessage).toContain("qwen/qwen3-8b");
+    expect(result.userMessage).toContain("Vellum GPU route");
+    expect(result.userMessage).toContain('profile "steer"');
+    expect(result.userMessage).toContain("was not sent through another provider");
+  });
+
   it("classifies missing_credential naming the connection and fix", () => {
     const err = new ConnectionResolutionError(
       "anthropic-personal",

package/src/__tests__/conversation-load-history-repair.test.ts

@@ -589,6 +589,53 @@ describe("loadFromDb history repair", () => {
     expect(allText).not.toContain("hunter2");
   });
 
+  test("the assistant's own deleted post keeps its content plus a visibility marker", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: [{ type: "text", text: "What time is the meeting?" }],
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: [{ type: "text", text: "The meeting is at 3pm." }],
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            messageId: "555.2",
+            eventKind: "message",
+            deletedAt: 1700000001000,
+          }),
+        }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const assistantRow = conversation
+      .getMessages()
+      .find((m) => m.role === "assistant");
+    const texts = (assistantRow?.content ?? [])
+      .filter((b) => b.type === "text")
+      .map((b) => (b.type === "text" ? b.text : ""));
+    // Erasure is for a retracted user message; the assistant's own words
+    // stay (it did say them), and the rendered fact is lost visibility.
+    expect(texts.join("\n")).toContain("The meeting is at 3pm.");
+    expect(texts.join("\n")).toContain(
+      "[This message was deleted from the channel and is no longer visible to participants]",
+    );
+  });
+
   test("a reaction never quotes a target that was later deleted", async () => {
     mockConversation = {
       id: "conv-1",
@@ -703,6 +750,77 @@ describe("loadFromDb history repair", () => {
     expect(allText).not.toContain("an earlier message");
   });
 
+  test("a partially deleted split reply quotes only its surviving posts", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    const reactionRow = (target: string, emoji: string, id: string) => ({
+      id,
+      role: "user",
+      content: [{ type: "text", text: "[reaction]" }],
+      metadata: JSON.stringify({
+        providerMeta: JSON.stringify({
+          source: "discord",
+          conversationExternalId: "chan-1",
+          eventKind: "reaction",
+          reaction: {
+            targetMessageId: target,
+            emoji,
+            op: "added",
+            actorDisplayName: "Alice",
+          },
+        }),
+      }),
+    });
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "assistant",
+        content: [{ type: "text", text: "Deploy finished cleanly." }],
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            messageId: "555.1",
+            additionalMessageIds: ["555.2"],
+            deletedMessageIds: ["555.2"],
+            eventKind: "message",
+          }),
+        }),
+      },
+      // Reaction on the surviving post: still quotable.
+      reactionRow("555.1", "tada", "m2"),
+      // Reaction on the deleted post: degrades to the unresolved form
+      // rather than quoting content no longer on the channel.
+      reactionRow("555.2", "eyes", "m3"),
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const allText = conversation
+      .getMessages()
+      .flatMap((m) => m.content)
+      .filter((b) => b.type === "text")
+      .map((b) => (b.type === "text" ? b.text : ""))
+      .join("\n");
+    // The row itself is NOT fully deleted: its content stays.
+    expect(allText).toContain("Deploy finished cleanly.");
+    // :tada: (surviving target) quotes; :eyes: (deleted target) does not.
+    const tadaLine = allText
+      .split("\n")
+      .find((line) => line.includes(":tada:"));
+    const eyesLine = allText
+      .split("\n")
+      .find((line) => line.includes(":eyes:"));
+    expect(tadaLine).toContain("Deploy finished cleanly.");
+    expect(eyesLine).toContain("an earlier message");
+  });
+
   test("the assistant's own reaction row renders second-person", async () => {
     mockConversation = {
       id: "conv-1",

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

@@ -19,9 +19,17 @@ let addMessageShouldThrow = false;
 /** Simulated existing conversations for getConversation mock. */
 let mockExistingConversations: Record<
   string,
-  { id: string; source: string; title: string | null }
+  {
+    id: string;
+    source: string;
+    title: string | null;
+    conversationType?: string;
+  }
 > = {};
 
+/** Mutable arm for the assistant-initiated-threads gate mock. */
+let assistantInitiatedThreadsEnabled = false;
+
 const createConversationMock = mock((_opts?: unknown) => {
   if (createConversationShouldThrow) {
     throw new Error("DB write failed");
@@ -102,6 +110,12 @@ mock.module("../persistence/external-conversation-store.js", () => ({
   upsertOutboundBinding: upsertOutboundBindingMock,
 }));
 
+/* The registry resolves through workspace override files; a mutable arm keeps
+   these tests off the filesystem, mirroring the section-split suite. */
+mock.module("../config/assistant-initiated-threads-gate.js", () => ({
+  isAssistantInitiatedThreadsEnabled: () => assistantInitiatedThreadsEnabled,
+}));
+
 import { pairDeliveryWithConversation } from "../notifications/conversation-pairing.js";
 import type { NotificationSignal } from "../notifications/signal.js";
 import type {
@@ -162,6 +176,7 @@ describe("pairDeliveryWithConversation", () => {
     addMessageShouldThrow = false;
     mockExistingConversations = {};
     mockBindings = {};
+    assistantInitiatedThreadsEnabled = false;
   });
 
   // ── start_new_conversation (vellum) ─────────────────────────────────
@@ -1356,4 +1371,129 @@ describe("pairDeliveryWithConversation", () => {
     expect(result.conversationId).toBe("conv-001");
     expect(result.messageId).toBe("msg-001");
   });
+  // ── assistant.share → assistant-initiated thread (flag-gated) ────────
+
+  describe("assistant.share promotion under assistant-initiated-threads", () => {
+    const share = (overrides?: Partial<NotificationSignal>) =>
+      makeSignal({
+        requiresConversation: undefined,
+        sourceEventName: "assistant.share",
+        sourceContextId: "conv-heartbeat",
+        ...overrides,
+      });
+
+    test("flag on: a share from a background run materializes a section thread", async () => {
+      assistantInitiatedThreadsEnabled = true;
+      mockExistingConversations["conv-heartbeat"] = {
+        id: "conv-heartbeat",
+        source: "heartbeat",
+        title: null,
+        conversationType: "background",
+      };
+
+      const result = await pairDeliveryWithConversation(
+        share(),
+        "vellum" as NotificationChannel,
+        makeCopy({ conversationTitle: "Noticed something" }),
+      );
+
+      expect(result.createdNewConversation).toBe(true);
+      const callArgs = createConversationMock.mock.calls[0]![0] as Record<
+        string,
+        unknown
+      >;
+      expect(callArgs.source).toBe("assistant_initiated");
+      expect(callArgs.conversationType).toBe("standard");
+      expect(callArgs.title).toBe("Noticed something");
+    });
+
+    test("flag on: an unresolvable source context still materializes", async () => {
+      assistantInitiatedThreadsEnabled = true;
+
+      const result = await pairDeliveryWithConversation(
+        share({ sourceContextId: "cli-123" }),
+        "vellum" as NotificationChannel,
+        makeCopy(),
+      );
+
+      expect(result.createdNewConversation).toBe(true);
+      const callArgs = createConversationMock.mock.calls[0]![0] as Record<
+        string,
+        unknown
+      >;
+      expect(callArgs.source).toBe("assistant_initiated");
+    });
+
+    test("flag on: a share from a user-facing thread keeps the passive append", async () => {
+      assistantInitiatedThreadsEnabled = true;
+      mockExistingConversations["conv-user"] = {
+        id: "conv-user",
+        source: "user",
+        title: "Ongoing chat",
+        conversationType: "standard",
+      };
+
+      const result = await pairDeliveryWithConversation(
+        share({ sourceContextId: "conv-user" }),
+        "vellum" as NotificationChannel,
+        makeCopy(),
+      );
+
+      expect(result.createdNewConversation).toBe(false);
+      expect(result.conversationId).toBe("conv-user");
+      expect(createConversationMock).not.toHaveBeenCalled();
+    });
+
+    test("flag off: shares keep the passive append even from background runs", async () => {
+      mockExistingConversations["conv-heartbeat"] = {
+        id: "conv-heartbeat",
+        source: "heartbeat",
+        title: null,
+        conversationType: "background",
+      };
+
+      const result = await pairDeliveryWithConversation(
+        share(),
+        "vellum" as NotificationChannel,
+        makeCopy(),
+      );
+
+      expect(result.createdNewConversation).toBe(false);
+      expect(result.conversationId).toBe("conv-heartbeat");
+      expect(createConversationMock).not.toHaveBeenCalled();
+    });
+
+    test("flag on: an explicit conversationMetadata.source wins over promotion", async () => {
+      assistantInitiatedThreadsEnabled = true;
+
+      const result = await pairDeliveryWithConversation(
+        share({ conversationMetadata: { source: "schedule" } }),
+        "vellum" as NotificationChannel,
+        makeCopy(),
+      );
+
+      // The producer declared its own filing, so the passive rule holds.
+      expect(result.createdNewConversation).toBe(false);
+      expect(createConversationMock).not.toHaveBeenCalled();
+    });
+
+    test("flag on: non-share passive events keep the passive append", async () => {
+      assistantInitiatedThreadsEnabled = true;
+      mockExistingConversations["conv-heartbeat"] = {
+        id: "conv-heartbeat",
+        source: "heartbeat",
+        title: null,
+        conversationType: "background",
+      };
+
+      const result = await pairDeliveryWithConversation(
+        share({ sourceEventName: "scheduler.reminder_fired" }),
+        "vellum" as NotificationChannel,
+        makeCopy(),
+      );
+
+      expect(result.createdNewConversation).toBe(false);
+      expect(createConversationMock).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -97,8 +97,35 @@ function createFakeConversation(conversationId: string): Conversation {
     isProcessing(this: { processing: boolean }) {
       return this.processing;
     },
-    setProcessing(this: { processing: boolean }, value: boolean) {
+    setProcessing(
+      this: { processing: boolean; owner: number },
+      value: boolean,
+    ) {
       this.processing = value;
+      this.owner = value ? this.owner + 1 : 0;
+    },
+    owner: 0,
+    async acquireProcessingFenced(this: {
+      processing: boolean;
+      owner: number;
+    }) {
+      if (this.processing) {
+        return null;
+      }
+      this.processing = true;
+      this.owner += 1;
+      return this.owner;
+    },
+    releaseProcessing(
+      this: { processing: boolean; owner: number },
+      claim: number,
+    ) {
+      if (claim !== this.owner) {
+        return false;
+      }
+      this.processing = false;
+      this.owner = 0;
+      return true;
     },
     setChannelCapabilities: () => {},
     setAssistantId: () => {},