@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/conversation-agent-loop.test.ts

@@ -318,6 +318,8 @@ const deleteMessageByIdMock = mock(() => ({
   deletedSummaryIds: [],
 }));
 const reserveMessageMock = mock(async () => ({ id: "msg-reserve" }));
+/** Persisted rows the loop reads back. Empty unless a test seeds one. */
+let mockStoredMessages: unknown[] = [];
 const updateMessageContentMock = mock(() => {});
 const finalizeMessageContentMock = mock(() => {});
 const addMessageMock = mock(() => ({ id: "mock-msg-id" }));
@@ -328,7 +330,7 @@ mock.module("../persistence/conversation-crud.js", () => ({
   updateConversationUsage: () => {},
   updateMessageMetadata: updateMessageMetadataMock,
   setConversationHistoryStrippedAt: setConversationHistoryStrippedAtMock,
-  getMessages: () => [],
+  getMessages: () => mockStoredMessages,
   getConversation: () => mockConversationRow,
   provenanceFromTrustContext: () => ({
     source: "user",
@@ -673,6 +675,7 @@ import {
   applyCompactionResult,
   runAgentLoopImpl,
 } from "../daemon/conversation-agent-loop.js";
+import { settleTurnTail } from "../daemon/turn-tail-chain.js";
 import {
   createMockProvider,
   type ScriptedResponse,
@@ -780,6 +783,7 @@ function makeCtx(
     channelCapabilities: undefined,
     commandIntent: undefined,
     trustContext: undefined,
+    toolsDisabledDepth: 0,
 
     allowedToolNames: undefined,
     preactivatedSkillIds: undefined,
@@ -862,6 +866,24 @@ function makeCtx(
   return ctx;
 }
 
+/**
+ * What `classifyConversationError` returns for a daily-credit-limit 402 (see
+ * `dailyLimitClassification` in conversation-error.ts). Its `userMessage` is
+ * banner voice; the loop swaps in {@link DAILY_LIMIT_ASSISTANT_REPLY} for the
+ * transcript row.
+ */
+const DAILY_LIMIT_CLASSIFICATION = {
+  code: "PROVIDER_BILLING",
+  userMessage:
+    "You've hit your daily credit limit. Raise the limit in Billing settings to keep going today.",
+  retryable: false,
+  errorCategory: "daily_limit_reached",
+};
+
+/** Mirrors `DAILY_LIMIT_REACHED_ASSISTANT_REPLY` in conversation-agent-loop.ts. */
+const DAILY_LIMIT_ASSISTANT_REPLY =
+  "I had to stop because you hit your daily credit limit. Raise the limit in Settings → Billing and we can pick up where we left off, or I can continue once it resets.";
+
 type CompactionResult = Parameters<typeof applyCompactionResult>[1];
 
 function makeCompactionResult(
@@ -931,7 +953,9 @@ beforeEach(() => {
   getSlackCompactionWatermarkForPrefixMock.mockClear();
   deleteMessageByIdMock.mockClear();
   reserveMessageMock.mockClear();
+  mockStoredMessages = [];
   updateMessageContentMock.mockClear();
+  updateMessageContentMock.mockImplementation(() => {});
   finalizeMessageContentMock.mockClear();
   rmSync(inflightDir(), { recursive: true, force: true });
   addMessageMock.mockClear();
@@ -1183,6 +1207,92 @@ describe("session-agent-loop", () => {
         runAgentLoopImpl(ctx, "hello", "msg-1", () => {}),
       ).rejects.toThrow("runAgentLoop called without prior persistUserMessage");
     });
+
+    test("defers workspace Git work when tools are disabled", async () => {
+      const ensureInitialized = mock(async () => {});
+      const commitTurnChanges = mock(async () => {});
+      const ctx = makeCtx({
+        toolsDisabledDepth: 1,
+        getWorkspaceGitService: () => ({ ensureInitialized }),
+        commitTurnChanges,
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+
+      expect(ensureInitialized).not.toHaveBeenCalled();
+      expect(commitTurnChanges).not.toHaveBeenCalled();
+
+      await new Promise<void>((resolve) => setImmediate(resolve));
+
+      expect(commitTurnChanges).toHaveBeenCalledTimes(1);
+    });
+
+    test("leaves a deferred commit to an immediate follow-up turn", async () => {
+      const commitTurnChanges = mock(async () => {});
+      const ctx = makeCtx({
+        toolsDisabledDepth: 1,
+        commitTurnChanges,
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+      ctx.setProcessing(true);
+      await new Promise<void>((resolve) => setImmediate(resolve));
+
+      expect(commitTurnChanges).not.toHaveBeenCalled();
+      ctx.setProcessing(false);
+    });
+
+    test("initializes workspace Git before hooks when tools can run", async () => {
+      let initialized = false;
+      const ensureInitialized = mock(async () => {
+        initialized = true;
+      });
+      const commitTurnChanges = mock(async () => {});
+      const initializedDuringHook: boolean[] = [];
+      registerPlugin({
+        manifest: {
+          name: "test-workspace-git-ready-before-hook",
+          version: "1.0.0",
+        },
+        hooks: {
+          "user-prompt-submit": async () => {
+            initializedDuringHook.push(initialized);
+          },
+        },
+      });
+      const ctx = makeCtx({
+        getWorkspaceGitService: () => ({ ensureInitialized }),
+        commitTurnChanges,
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+
+      expect(ensureInitialized).toHaveBeenCalledTimes(1);
+      expect(commitTurnChanges).toHaveBeenCalledTimes(1);
+      expect(initializedDuringHook).toEqual([true]);
+    });
+
+    test("continues a tool-capable turn when workspace Git initialization fails", async () => {
+      const ensureInitialized = mock(async () => {
+        throw new Error("simulated Git initialization failure");
+      });
+      const events: AssistantEvent[] = [];
+      const ctx = makeCtx({
+        getWorkspaceGitService: () => ({ ensureInitialized }),
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (event) =>
+        events.push(event),
+      );
+
+      expect(ensureInitialized).toHaveBeenCalledTimes(1);
+      expect(events.some((event) => event.type === "message_complete")).toBe(
+        true,
+      );
+      expect(events.some((event) => event.type === "conversation_error")).toBe(
+        false,
+      );
+    });
   });
 
   describe("disk pressure injection context", () => {
@@ -1971,6 +2081,76 @@ describe("session-agent-loop", () => {
       expect(ctx.pendingSurfaceActions.has("stale-form-1")).toBe(false);
     });
 
+    test("withholds the dismissal event and keeps the surface pending when its persisted write fails", async () => {
+      const events: AssistantEvent[] = [];
+
+      const ctx = makeCtx();
+      ctx.pendingSurfaceActions.set("stale-table-2", { surfaceType: "table" });
+      mockStoredMessages = [
+        {
+          id: "msg-with-stale-surface",
+          conversationId: "conv-1",
+          role: "assistant",
+          content: [{ type: "ui_surface", surfaceId: "stale-table-2" }],
+          createdAt: 0,
+          metadata: null,
+        },
+      ];
+      updateMessageContentMock.mockImplementationOnce(() => {
+        throw new Error("database is locked");
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg), {
+        isUserMessage: true,
+      });
+
+      // Announcing a dismissal the DB still holds as pending leaves the client
+      // showing a card the next history reseed reverts.
+      expect(
+        events.filter((e) => e.type === "ui_surface_complete"),
+      ).toHaveLength(0);
+      // The card stays live on the client, so the daemon must keep treating it
+      // as pending; the sweep retries on the next user message.
+      expect(ctx.pendingSurfaceActions.has("stale-table-2")).toBe(true);
+    });
+
+    test("dismisses the remaining surfaces when one write fails", async () => {
+      const events: AssistantEvent[] = [];
+
+      const ctx = makeCtx();
+      ctx.pendingSurfaceActions.set("stale-table-3", { surfaceType: "table" });
+      ctx.pendingSurfaceActions.set("stale-form-3", { surfaceType: "form" });
+      mockStoredMessages = [
+        {
+          id: "msg-with-stale-surfaces",
+          conversationId: "conv-1",
+          role: "assistant",
+          content: [
+            { type: "ui_surface", surfaceId: "stale-table-3" },
+            { type: "ui_surface", surfaceId: "stale-form-3" },
+          ],
+          createdAt: 0,
+          metadata: null,
+        },
+      ];
+      updateMessageContentMock.mockImplementationOnce(() => {
+        throw new Error("database is locked");
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg), {
+        isUserMessage: true,
+      });
+
+      // Retaining the failed entry must not stall the sweep: deleting the
+      // current key while iterating the map leaves later keys reachable.
+      const completed = events
+        .filter((e) => e.type === "ui_surface_complete")
+        .map((e) => (e as { surfaceId: string }).surfaceId);
+      expect(completed).toEqual(["stale-form-3"]);
+      expect(ctx.pendingSurfaceActions.has("stale-table-3")).toBe(true);
+      expect(ctx.pendingSurfaceActions.has("stale-form-3")).toBe(false);
+    });
+
     test("does not auto-complete surfaces when request is a surface action", async () => {
       const events: AssistantEvent[] = [];
 
@@ -2277,6 +2457,134 @@ describe("session-agent-loop", () => {
       });
     });
 
+    test("persists assistant-voice daily-limit copy on a first-call rejection", async () => {
+      mockConversationErrorClassification = DAILY_LIMIT_CLASSIFICATION;
+
+      const ctx = makeCtx({
+        loopProvider: {
+          name: "mock-provider",
+          async sendMessage() {
+            throw new Error("Payment Required");
+          },
+        } as unknown as Provider,
+      });
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+
+      expect(addMessageMock).toHaveBeenCalledTimes(1);
+      const addCall = addMessageMock.mock.calls[0] as unknown as [
+        string,
+        string,
+        string,
+        { metadata?: Record<string, unknown> },
+      ];
+      expect(addCall[1]).toBe("assistant");
+      // Like the credits-exhausted row, the daily-limit row re-enters LLM
+      // history and renders as assistant speech, so it carries first-person
+      // copy rather than the banner-voice classification text.
+      const persistedBlocks = JSON.parse(addCall[2]) as Array<{
+        type: string;
+        text: string;
+      }>;
+      expect(persistedBlocks[0]?.text).toBe(DAILY_LIMIT_ASSISTANT_REPLY);
+      expect(addCall[3]?.metadata).toMatchObject({
+        messageKind: "provider_error",
+        providerErrorCode: "PROVIDER_BILLING",
+        providerErrorCategory: "daily_limit_reached",
+      });
+    });
+
+    test("persists the synthetic error row when a daily-limit error kills the run mid-turn", async () => {
+      // Mid-turn shape: the run already carries assistant `tool_use` messages
+      // from the completed tool round-trip, and only the failing follow-up
+      // call lacks a reply. The synthetic error row must persist for this
+      // shape too, so a reload explains why the assistant stopped instead of
+      // ending on a bare tool call.
+      reserveMessageMock
+        .mockImplementationOnce(async () => ({ id: "msg-reserve-1" }))
+        .mockImplementationOnce(async () => ({ id: "msg-reserve-2" }))
+        .mockImplementationOnce(async () => ({ id: "msg-reserve-3" }));
+      mockConversationErrorClassification = DAILY_LIMIT_CLASSIFICATION;
+
+      // GIVEN a run whose first call asks for a tool, the tool succeeds, and
+      // the follow-up call is rejected with a daily-limit 402.
+      const ctx = makeCtx({
+        providerResponses: [
+          toolUseResponse("tu-1", "file_read", {}),
+          new Error("Payment Required"),
+        ],
+        loopTools: [
+          {
+            name: "file_read",
+            description: "Read a file",
+            input_schema: { type: "object", properties: {} },
+          },
+        ],
+        toolExecutor: async () => ({ content: "file content", isError: false }),
+      } as unknown as Partial<Conversation>);
+
+      await runAgentLoopImpl(ctx, "hello", "msg-user-daily", () => {});
+
+      // (a) The synthetic provider-error row is persisted with the
+      // assistant-voice daily-limit copy and the classification metadata.
+      expect(addMessageMock).toHaveBeenCalledTimes(1);
+      const addCall = addMessageMock.mock.calls[0] as unknown as [
+        string,
+        string,
+        string,
+        { metadata?: Record<string, unknown> },
+      ];
+      expect(addCall[1]).toBe("assistant");
+      const persistedBlocks = JSON.parse(addCall[2]) as Array<{
+        type: string;
+        text: string;
+      }>;
+      expect(persistedBlocks[0]?.text).toBe(DAILY_LIMIT_ASSISTANT_REPLY);
+      expect(addCall[3]?.metadata).toMatchObject({
+        messageKind: "provider_error",
+        providerErrorCode: "PROVIDER_BILLING",
+        providerErrorCategory: "daily_limit_reached",
+      });
+
+      // (b) The empty row the failing call reserved at `llm_call_started` is
+      // dropped, so the transcript carries the error row instead of a stranded
+      // blank bubble. The failing call reserves last (after the first call's
+      // assistant row and the grouped tool-result row).
+      expect(deleteMessageByIdMock).toHaveBeenCalledTimes(1);
+      const deleteCall = deleteMessageByIdMock.mock.calls[0] as unknown as [
+        string,
+      ];
+      expect(deleteCall[0]).toBe("msg-reserve-3");
+
+      // (c) The turn is stamped failed with the classified code.
+      const outcomeStamps = (
+        updateMessageMetadataMock.mock.calls as unknown as Array<
+          [string, Record<string, unknown>]
+        >
+      ).filter((call) => call[1]?.turnOutcome !== undefined);
+      expect(outcomeStamps).toHaveLength(1);
+      expect(outcomeStamps[0]?.[0]).toBe("msg-user-daily");
+      expect(outcomeStamps[0]?.[1]).toMatchObject({
+        turnOutcome: "failed",
+        turnFailureCode: "PROVIDER_BILLING",
+      });
+
+      // (d) History ends tool_use -> tool_result -> error text, so the row
+      // never lands between a tool_use and its tool_result on replay.
+      const tail = ctx.messages.slice(-3) as Array<{
+        role: string;
+        content: Array<{ type: string; text?: string }>;
+      }>;
+      expect(tail[0]?.role).toBe("assistant");
+      expect(tail[0]?.content[0]?.type).toBe("tool_use");
+      expect(tail[1]?.role).toBe("user");
+      expect(tail[1]?.content[0]?.type).toBe("tool_result");
+      expect(tail[2]?.role).toBe("assistant");
+      expect(tail[2]?.content[0]).toEqual({
+        type: "text",
+        text: DAILY_LIMIT_ASSISTANT_REPLY,
+      });
+    });
+
     test("does not persist managed credential refresh failures as assistant text", async () => {
       mockConversationErrorClassification = {
         code: "MANAGED_KEY_INVALID",
@@ -2435,6 +2743,128 @@ describe("session-agent-loop", () => {
     });
   });
 
+  describe("detached deferred turn tail", () => {
+    const reservedAssistantRow = {
+      id: "msg-reserve",
+      conversationId: "test-conv",
+      createdAt: 1_700_000_000_001,
+      role: "assistant" as const,
+      content: "[]",
+      metadata: null,
+    };
+
+    test("frees the conversation before the deferred tail finishes, and serializes tails", async () => {
+      mockMessageById = reservedAssistantRow;
+      // A tail effect that never settles on its own stands in for the
+      // production case this guards: memory indexing that takes tens of
+      // seconds against a slow embedding provider.
+      let releaseFirstIndex: (() => void) | undefined;
+      const firstIndexHangs = new Promise<void>((resolve) => {
+        releaseFirstIndex = resolve;
+      });
+      indexMessageNowMock.mockImplementationOnce(async () => {
+        await firstIndexHangs;
+        return { indexedSegments: 0, enqueuedJobs: 0 };
+      });
+
+      const drainReasons: string[] = [];
+      const ctx = makeCtx({
+        providerResponses: [textResponse("first"), textResponse("second")],
+        drainQueue: async (reason?: string) => {
+          drainReasons.push(reason ?? "loop_complete");
+        },
+      });
+
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      // The tail is still parked inside the indexer…
+      expect(indexMessageNowMock).toHaveBeenCalledTimes(1);
+      // …yet the conversation is already released and the queue already
+      // kicked, so a send arriving now runs instead of being queued.
+      expect(ctx.isProcessing()).toBe(false);
+      expect(drainReasons).toEqual(["loop_complete"]);
+
+      // A follow-up turn runs to completion against the still-hung tail.
+      ctx.abortController = new AbortController();
+      ctx.setProcessing(true);
+      await runAgentLoopImpl(ctx, "again", "msg-2", () => {});
+      expect(ctx.isProcessing()).toBe(false);
+      expect(drainReasons).toEqual(["loop_complete", "loop_complete"]);
+
+      // The second turn's tail is chained behind the first, so it has not run
+      // its own indexing yet.
+      expect(indexMessageNowMock).toHaveBeenCalledTimes(1);
+
+      releaseFirstIndex?.();
+      await settleTurnTail(ctx.conversationId);
+      expect(indexMessageNowMock).toHaveBeenCalledTimes(2);
+    });
+
+    test("a throwing tail effect neither latches the lock nor skips the drain", async () => {
+      mockMessageById = reservedAssistantRow;
+      indexMessageNowMock.mockImplementationOnce(async () => {
+        throw new Error("indexer exploded");
+      });
+
+      const drainReasons: string[] = [];
+      const ctx = makeCtx({
+        providerResponses: [textResponse("first")],
+        drainQueue: async (reason?: string) => {
+          drainReasons.push(reason ?? "loop_complete");
+        },
+      });
+
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+      // The chain settles rather than rejecting, so the throw can neither
+      // surface as an unhandled rejection nor poison a later turn's tail.
+      await settleTurnTail(ctx.conversationId);
+
+      expect(ctx.isProcessing()).toBe(false);
+      expect(drainReasons).toEqual(["loop_complete"]);
+      // The tail continued past the failure: attention projection still ran.
+      expect(projectAssistantMessageMock).toHaveBeenCalledTimes(1);
+    });
+
+    test("the queue drain waits for the turn-boundary commit", async () => {
+      // `commitTurnChanges` attributes the working tree's changes to the turn
+      // that just finished, so a queued turn must not start writing files
+      // while it runs. The lock release above frees direct sends immediately;
+      // the drain is what has to wait.
+      let commitReached: (() => void) | undefined;
+      const commitStarted = new Promise<void>((resolve) => {
+        commitReached = resolve;
+      });
+      let releaseCommit: (() => void) | undefined;
+      const commitHangs = new Promise<void>((resolve) => {
+        releaseCommit = resolve;
+      });
+
+      const drainReasons: string[] = [];
+      const ctx = makeCtx({
+        providerResponses: [textResponse("first")],
+        commitTurnChanges: async () => {
+          commitReached?.();
+          await commitHangs;
+        },
+        drainQueue: async (reason?: string) => {
+          drainReasons.push(reason ?? "loop_complete");
+        },
+      });
+
+      const loop = runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+      await commitStarted;
+
+      // Released for direct sends…
+      expect(ctx.isProcessing()).toBe(false);
+      // …but the queue is untouched until the commit settles.
+      expect(drainReasons).toEqual([]);
+
+      releaseCommit?.();
+      await loop;
+      expect(drainReasons).toEqual(["loop_complete"]);
+    });
+  });
+
   describe("B3 pre-allocation: indexing + cleanup", () => {
     test("handleMessageComplete indexes and projects the finalized assistant row", async () => {
       // The pre-B3 path inserted assistant rows via `addMessage`, which ran
@@ -2461,6 +2891,9 @@ describe("session-agent-loop", () => {
         providerResponses: [textResponse("indexed reply")],
       });
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+      // The finalize effects run on the detached tail, so wait for the chain
+      // rather than on the loop's own resolution.
+      await settleTurnTail(ctx.conversationId);
 
       // Indexer fired with the reserved row's id + the finalized content.
       expect(indexMessageNowMock).toHaveBeenCalledTimes(1);
@@ -2537,8 +2970,9 @@ describe("session-agent-loop", () => {
         providerResponses: [textResponse("indexed reply")],
       });
       await runAgentLoopImpl(ctx, "hi", "msg-1", (msg) => events.push(msg));
+      await settleTurnTail(ctx.conversationId);
 
-      // The deferred indexer runs exactly once, within the turn…
+      // The deferred indexer runs exactly once…
       expect(indexMessageNowMock).toHaveBeenCalledTimes(1);
       // …and only after the terminal SSE that re-enables the composer.
       expect(messageCompleteSeenWhenIndexed).toBe(true);
@@ -2561,6 +2995,7 @@ describe("session-agent-loop", () => {
       // GIVEN a real loop that answers with a single finalized assistant turn
       const ctx = makeCtx({ providerResponses: [textResponse("quiet")] });
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+      await settleTurnTail(ctx.conversationId);
 
       expect(projectAssistantMessageMock).toHaveBeenCalledTimes(1);
       // The mock will still receive a `:messages` invalidation from the
@@ -2950,6 +3385,7 @@ describe("session-agent-loop", () => {
 
       // WHEN the orchestrator runs the turn to completion
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+      await settleTurnTail(ctx.conversationId);
 
       expect(snapshot).toBeDefined();
       // Indexer + projector were both ZERO during the mid-turn partial

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

@@ -128,7 +128,11 @@ describe("addMessage + syncMessageToDisk → disk view", () => {
       skipIndexing: true,
     });
 
-    const att = uploadAttachment("screenshot.png", "image/png", "iVBORw0K");
+    const att = await uploadAttachment(
+      "screenshot.png",
+      "image/png",
+      "iVBORw0K",
+    );
     linkAttachmentToMessage(msg.id, att.id, 0);
 
     syncMessageToDisk(conv.id, msg.id, conv.createdAt);

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

@@ -434,7 +434,7 @@ describe("syncMessageToDisk", () => {
     });
 
     // Upload an attachment and link to the message
-    const att = uploadAttachment("photo.png", "image/png", "iVBORw0K");
+    const att = await uploadAttachment("photo.png", "image/png", "iVBORw0K");
     linkAttachmentToMessage(msg.id, att.id, 0);
 
     syncMessageToDisk(conv.id, msg.id, conv.createdAt);
@@ -498,7 +498,7 @@ describe("syncMessageToDisk", () => {
       skipIndexing: true,
     });
 
-    const att = uploadAttachment("legacy.png", "image/png", "iVBORw0K");
+    const att = await uploadAttachment("legacy.png", "image/png", "iVBORw0K");
     linkAttachmentToMessage(msg.id, att.id, 0);
 
     syncMessageToDisk(conv.id, msg.id, createdAt);
@@ -525,7 +525,7 @@ describe("syncMessageToDisk", () => {
     const msg = await addMessage(conv.id, "user", "Disk repair", {
       skipIndexing: true,
     });
-    const att = uploadAttachment("repair.png", "image/png", "iVBORw0K");
+    const att = await uploadAttachment("repair.png", "image/png", "iVBORw0K");
     rawRun(
       "test:linkAttachment",
       `INSERT INTO message_attachments (id, message_id, attachment_id, position, created_at)
@@ -603,7 +603,7 @@ describe("rebuildConversationDiskViewFromDbState", () => {
       { skipIndexing: true },
     );
 
-    const att = uploadAttachment("result.txt", "text/plain", "ok");
+    const att = await uploadAttachment("result.txt", "text/plain", "ok");
     linkAttachmentToMessage(assistantPart2.id, att.id, 0);
 
     // Simulate stale disk view generated before consolidation.

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

@@ -1556,7 +1556,7 @@ describe("ConnectionResolutionError classification", () => {
     expect(result.profileName).toBe("custom-fast");
   });
 
-  it("classifies missing_connection with an add-a-key fix and no sentinel name", () => {
+  it("classifies missing_connection offering inline recovery and no sentinel name", () => {
     const err = new ConnectionResolutionError(
       "<llm.default>",
       "missing_connection",
@@ -1566,7 +1566,10 @@ describe("ConnectionResolutionError classification", () => {
     expect(result.userMessage).toContain(
       "No provider connection is configured",
     );
-    expect(result.userMessage).toContain("Add an API key or log in");
+    // The user is locked out of chat here, so the copy must offer recovery in
+    // the conversation itself, not only a settings detour.
+    expect(result.userMessage).toContain("Ask me to set one up right here");
+    expect(result.userMessage).toContain("Settings → Models & Services");
     expect(result.userMessage).not.toContain("<llm.default>");
     expect(result.connectionName).toBeUndefined();
   });
@@ -1610,7 +1613,7 @@ describe("ConnectionResolutionError classification", () => {
     expect(result.userMessage).toContain('profile "custom-fast"');
   });
 
-  it("classifies platform_unauthenticated with a log-in fix", () => {
+  it("classifies platform_unauthenticated with a log-in fix on a non-platform install", () => {
     const err = new ConnectionResolutionError(
       "vellum",
       "platform_unauthenticated",
@@ -1621,6 +1624,22 @@ describe("ConnectionResolutionError classification", () => {
     expect(result.userMessage).toContain("Log in");
   });
 
+  it("classifies platform_unauthenticated as a re-provision hint on a platform-managed assistant", () => {
+    const err = new ConnectionResolutionError(
+      "vellum",
+      "platform_unauthenticated",
+      "unavailable",
+    );
+    process.env.IS_PLATFORM = "true";
+    try {
+      const result = classifyConversationError(err, errCtx);
+      expect(result.userMessage).toContain("re-provisioned");
+      expect(result.userMessage).not.toContain("Log in");
+    } finally {
+      delete process.env.IS_PLATFORM;
+    }
+  });
+
   it("is a structured VellumError (ConfigError) for logging/monitoring", () => {
     const err = new ConnectionResolutionError("x", "not_found", "m");
     expect(err).toBeInstanceOf(VellumError);

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

@@ -702,7 +702,11 @@ describe("forkConversation", () => {
       "Attached the updated mock.",
       { skipIndexing: true },
     );
-    const uploaded = uploadAttachment("wireframe.png", "image/png", "iVBORw0K");
+    const uploaded = await uploadAttachment(
+      "wireframe.png",
+      "image/png",
+      "iVBORw0K",
+    );
     linkAttachmentToMessage(sourceAssistant.id, uploaded.id, 0);
 
     const sourceAttachments = getAttachmentsForMessage(sourceAssistant.id);