@vellumai/assistant 0.12.1 → 0.12.2-staging.1

package/src/__tests__/model-intents.test.ts

@@ -28,6 +28,9 @@ describe("model intents", () => {
     expect(resolveModelIntent("openai", "latency-optimized")).toBe(
       "gpt-5.6-luna",
     );
+    expect(resolveModelIntent("gemini", "cost-optimized")).toBe(
+      "gemini-3.1-flash-lite",
+    );
     expect(resolveModelIntent("gemini", "latency-optimized")).toBe(
       "gemini-3.1-flash-lite",
     );

package/src/__tests__/notification-vellum-adapter.test.ts

@@ -3,6 +3,11 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // ── Mocks: declared before imports that depend on them ──────────────
 
 let updateMessageContentShouldThrow = false;
+let assistantName: string | null = null;
+
+mock.module("../daemon/identity-helpers.js", () => ({
+  getAssistantName: () => assistantName,
+}));
 
 const updateMessageContentMock = mock(
   (_messageId: string, _content: string) => {
@@ -55,12 +60,21 @@ function makeDestination(
 function captureBroadcast(): {
   adapter: VellumAdapter;
   sent: AssistantEvent[];
+  conversationIds: Array<string | undefined>;
 } {
   const sent: AssistantEvent[] = [];
-  const adapter = new VellumAdapter((msg) => sent.push(msg));
-  return { adapter, sent };
+  const conversationIds: Array<string | undefined> = [];
+  const adapter = new VellumAdapter((msg, conversationId) => {
+    sent.push(msg);
+    conversationIds.push(conversationId);
+  });
+  return { adapter, sent, conversationIds };
 }
 
+beforeEach(() => {
+  assistantName = null;
+});
+
 describe("VellumAdapter silent flag", () => {
   test("non-urgent (low) urgency broadcasts silent: true", async () => {
     const { adapter, sent } = captureBroadcast();
@@ -181,6 +195,75 @@ describe("VellumAdapter remotePushDispatched pass-through", () => {
   });
 });
 
+describe("VellumAdapter assistant name", () => {
+  test("broadcasts the current verified assistant name after trimming it", async () => {
+    assistantName = "  Example Assistant  ";
+    const { adapter, sent } = captureBroadcast();
+
+    await adapter.send(makePayload(), makeDestination());
+
+    const intent = sent[0] as Extract<
+      AssistantEvent,
+      { type: "notification_intent" }
+    >;
+    expect(intent.assistantName).toBe("Example Assistant");
+  });
+
+  test("omits the assistant name when it is unavailable", async () => {
+    const { adapter, sent } = captureBroadcast();
+
+    await adapter.send(makePayload(), makeDestination());
+
+    const intent = sent[0] as Extract<
+      AssistantEvent,
+      { type: "notification_intent" }
+    >;
+    expect(intent.assistantName).toBeUndefined();
+    expect("assistantName" in intent).toBe(false);
+  });
+
+  test("omits a blank assistant name", async () => {
+    assistantName = " \t\n ";
+    const { adapter, sent } = captureBroadcast();
+
+    await adapter.send(makePayload(), makeDestination());
+
+    const intent = sent[0] as Extract<
+      AssistantEvent,
+      { type: "notification_intent" }
+    >;
+    expect(intent.assistantName).toBeUndefined();
+    expect("assistantName" in intent).toBe(false);
+  });
+
+  test("reflects a renamed assistant on the next intent", async () => {
+    assistantName = "Assistant A";
+    const { adapter, sent } = captureBroadcast();
+    await adapter.send(makePayload(), makeDestination());
+
+    assistantName = "Assistant B";
+    await adapter.send(makePayload(), makeDestination());
+
+    const intents = sent as Array<
+      Extract<AssistantEvent, { type: "notification_intent" }>
+    >;
+    expect(intents.map((intent) => intent.assistantName)).toEqual([
+      "Assistant A",
+      "Assistant B",
+    ]);
+  });
+
+  test("keeps notification intents outside conversation replay scope", async () => {
+    assistantName = "Example Assistant";
+    const { adapter, sent, conversationIds } = captureBroadcast();
+
+    await adapter.send(makePayload(), makeDestination());
+
+    expect(conversationIds).toEqual([undefined]);
+    expect("conversationId" in sent[0]!).toBe(false);
+  });
+});
+
 describe("VellumAdapter update", () => {
   beforeEach(() => {
     updateMessageContentMock.mockClear();

package/src/__tests__/oauth-commands-routes.test.ts

@@ -25,6 +25,9 @@ interface MockProviderRow {
   managedServiceConfigKey: string | null;
   baseUrl: string | null;
   injectionTemplates: string | null;
+  defaultScopes?: string;
+  authorizeParams?: string | null;
+  scopeSeparator?: string;
   pingUrl: string | null;
   pingMethod: string | null;
   pingHeaders: string | null;
@@ -109,10 +112,15 @@ mock.module("../oauth/oauth-store.js", () => ({
   listActiveConnectionsByProvider: (provider: string) =>
     mockActiveConnectionsByProvider[provider] ?? [],
   listConnections: (provider: string) => mockAllConnections[provider] ?? [],
+  // Imported by seed-providers.js at module load; the seed data is read here,
+  // never written.
+  migrateProviderBaseUrl: () => {},
+  seedProviders: () => {},
 }));
 
 mock.module("../oauth/connection-resolver.js", () => {
   const makeConnection = () => ({
+    id: "conn-1",
     accountInfo: "user@example.com",
     request: async (req: unknown) => {
       mockResolveRequests.push(req);
@@ -155,6 +163,7 @@ mock.module("../security/token-manager.js", () => ({
 }));
 
 import { loadRawConfig } from "../config/loader.js";
+import { PROVIDER_SEED_DATA } from "../oauth/seed-providers.js";
 import {
   BadRequestError,
   InternalError,
@@ -899,6 +908,110 @@ describe("POST oauth/request", () => {
     ]);
   });
 
+  /** The provider row exactly as seeding writes it, so the seed data is what the guard reads. */
+  function seededProvider(provider: keyof typeof PROVIDER_SEED_DATA) {
+    const seed = PROVIDER_SEED_DATA[provider];
+    return {
+      ...baseProvider,
+      provider,
+      managedServiceConfigKey: null,
+      baseUrl: seed.baseUrl ?? null,
+      injectionTemplates: JSON.stringify(seed.injectionTemplates),
+    };
+  }
+
+  test("admits a Slack file URL on both seeded Slack providers", async () => {
+    // Each Slack credential reads messages, and a file shared in a message is
+    // fetched from its `url_private_download` on files.slack.com with the
+    // same token.
+    for (const provider of ["slack", "slack_channel"] as const) {
+      mockProviders[provider] = seededProvider(provider);
+      mockResolveRequests = [];
+
+      await getRoute("POST", "oauth/request").handler(
+        makeArgs({
+          body: {
+            provider,
+            url: "https://files.slack.com/files-pri/T0123-F0456/download/shot.png",
+          },
+        }),
+      );
+
+      expect(mockResolveRequests).toEqual([
+        {
+          method: "GET",
+          path: "/files-pri/T0123-F0456/download/shot.png",
+          baseUrl: "https://files.slack.com",
+        },
+      ]);
+    }
+  });
+
+  test("the seeded Slack host policy admits nothing beyond the documented hosts", async () => {
+    mockProviders.slack_channel = seededProvider("slack_channel");
+
+    // A lookalike, an unrelated host, and the CDN host Slack redirects file
+    // downloads to: the guard sees only the URL the caller names, and that
+    // URL is the documented file host or nothing.
+    for (const url of [
+      "https://files.slack.com.attacker.example/files-pri/T0123-F0456/x.png",
+      "https://attacker.example/files-pri/T0123-F0456/x.png",
+      "https://files-origin.slack.com/files-pri/T0123-F0456/x.png",
+    ]) {
+      await expect(
+        getRoute("POST", "oauth/request").handler(
+          makeArgs({ body: { provider: "slack_channel", url } }),
+        ),
+      ).rejects.toBeInstanceOf(BadRequestError);
+    }
+    expect(mockResolveRequests).toHaveLength(0);
+  });
+
+  test("names the required scopes a stored grant lacks on the request itself", async () => {
+    // A connection made before a scope was required keeps working for every
+    // call that does not need it, so the caller must be told on the request,
+    // not only by the next health check.
+    const seed = PROVIDER_SEED_DATA.slack;
+    mockProviders.slack = {
+      ...seededProvider("slack"),
+      defaultScopes: JSON.stringify(seed.defaultScopes),
+      authorizeParams: JSON.stringify(seed.authorizeParams),
+      scopeSeparator: " ",
+    };
+    const grantedBeforeFilesRead = seed
+      .authorizeParams!.user_scope.split(",")
+      .filter((scope) => scope !== "files:read");
+    mockAllConnections.slack = [
+      {
+        id: "conn-1",
+        provider: "slack",
+        grantedScopes: JSON.stringify(grantedBeforeFilesRead),
+      },
+    ];
+
+    const stale = (await getRoute("POST", "oauth/request").handler(
+      makeArgs({ body: { provider: "slack", url: "/conversations.history" } }),
+    )) as { ok: boolean; hint?: string };
+
+    expect(stale.ok).toBe(true);
+    expect(stale.hint).toContain("files:read");
+    expect(stale.hint).toContain("oauth connect slack");
+
+    mockAllConnections.slack = [
+      {
+        id: "conn-1",
+        provider: "slack",
+        grantedScopes: JSON.stringify(
+          seed.authorizeParams!.user_scope.split(","),
+        ),
+      },
+    ];
+    const current = (await getRoute("POST", "oauth/request").handler(
+      makeArgs({ body: { provider: "slack", url: "/conversations.history" } }),
+    )) as { hint?: string };
+    expect(current.hint).toBeUndefined();
+  });
+
   test("allows cross-host absolute URLs declared by provider injection templates", async () => {
     mockProviders.google = {
       ...baseProvider,

package/src/__tests__/oauth-provider-profiles.test.ts

@@ -7,6 +7,7 @@ mock.module("../security/secure-keys.js", () => ({
 }));
 
 import { getProvider } from "../oauth/oauth-store.js";
+import { expectedScopesForStoredToken } from "../oauth/scope-utils.js";
 import { seedOAuthProviders } from "../oauth/seed-providers.js";
 import { initializeDb } from "../persistence/db-init.js";
 
@@ -22,6 +23,23 @@ describe("oauth provider profiles (DB-seeded)", () => {
     expect(scopes).toContain("https://www.googleapis.com/auth/drive");
   });
 
+  test("slack provider row requests files:read for the token it stores", () => {
+    // The flow persists the authed_user token, and credential health measures
+    // its grant through the same function used here, so this is the scope set
+    // an integration connection must carry to fetch a file from files.slack.com.
+    const provider = getProvider("slack");
+
+    expect(provider).toBeDefined();
+    const expected = expectedScopesForStoredToken(
+      JSON.parse(provider!.defaultScopes) as string[],
+      provider!.authorizeParams
+        ? (JSON.parse(provider!.authorizeParams) as Record<string, string>)
+        : undefined,
+      provider!.scopeSeparator ?? undefined,
+    );
+    expect(expected).toContain("files:read");
+  });
+
   test("google provider row contains bearer injection templates for 8 Google API hosts", () => {
     const provider = getProvider("google");
 

package/src/__tests__/openai-provider.test.ts

@@ -982,6 +982,7 @@ describe("OpenAIProvider", () => {
     );
 
     expect(lastCreateParams!.max_completion_tokens).toBe(64000);
+    expect(lastCreateParams).not.toHaveProperty("max_tokens");
   });
 
   // -----------------------------------------------------------------------

package/src/__tests__/outlook-messaging-provider.test.ts

@@ -429,7 +429,7 @@ describe("Outlook messaging provider", () => {
   describe("sendMessage", () => {
     test("sends a new message with correct recipient, subject, and body", async () => {
       const conn = createMockConnection();
-      const result = await outlookMessagingProvider.sendMessage(
+      const result = await outlookMessagingProvider.sendMessage!(
         conn,
         "recipient@example.com",
         "Hello!",
@@ -452,7 +452,7 @@ describe("Outlook messaging provider", () => {
 
     test("uses empty string for subject when not provided", async () => {
       const conn = createMockConnection();
-      await outlookMessagingProvider.sendMessage(
+      await outlookMessagingProvider.sendMessage!(
         conn,
         "recipient@example.com",
         "Hello!",
@@ -471,7 +471,7 @@ describe("Outlook messaging provider", () => {
 
     test("calls replyToMessage when inReplyTo is provided", async () => {
       const conn = createMockConnection();
-      const result = await outlookMessagingProvider.sendMessage(
+      const result = await outlookMessagingProvider.sendMessage!(
         conn,
         "conv-id",
         "Reply text",
@@ -493,7 +493,7 @@ describe("Outlook messaging provider", () => {
 
     test("attaches files to a new message as Graph file attachments", async () => {
       const conn = createMockConnection();
-      await outlookMessagingProvider.sendMessage(
+      await outlookMessagingProvider.sendMessage!(
         conn,
         "recipient@example.com",
         "See attached",
@@ -530,7 +530,7 @@ describe("Outlook messaging provider", () => {
 
     test("forwards attachments to replyToMessage when replying", async () => {
       const conn = createMockConnection();
-      await outlookMessagingProvider.sendMessage(
+      await outlookMessagingProvider.sendMessage!(
         conn,
         "conv-id",
         "Reply body",
@@ -563,7 +563,7 @@ describe("Outlook messaging provider", () => {
 
     test("throws when connection is undefined", async () => {
       await expect(
-        outlookMessagingProvider.sendMessage(
+        outlookMessagingProvider.sendMessage!(
           undefined,
           "recipient@example.com",
           "Hello!",

package/src/__tests__/platform-callback-registration.test.ts

@@ -110,8 +110,7 @@ describe("platform callback registration", () => {
   test("resolves managed callback context from stored credentials", async () => {
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "11111111-2222-4333-8444-555555555555";
+    mockPlatformAssistantId = "11111111-2222-4333-8444-555555555555";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-managed-key";
 
@@ -129,8 +128,7 @@ describe("platform callback registration", () => {
     mockIsPlatform = false;
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "22222222-3333-4444-8555-666666666666";
+    mockPlatformAssistantId = "22222222-3333-4444-8555-666666666666";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-self-hosted-key";
 
@@ -161,8 +159,7 @@ describe("platform callback registration", () => {
   test("registerCallbackRoute falls back to assistant API key auth", async () => {
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "11111111-2222-4333-8444-555555555555";
+    mockPlatformAssistantId = "11111111-2222-4333-8444-555555555555";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-managed-key";
 
@@ -209,8 +206,7 @@ describe("platform callback registration", () => {
     };
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "22222222-3333-4444-8555-666666666666";
+    mockPlatformAssistantId = "22222222-3333-4444-8555-666666666666";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-self-hosted-key";
 
@@ -251,8 +247,7 @@ describe("platform callback registration", () => {
     setIngressPublicBaseUrl("https://detected.example.com/");
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "22222222-3333-4444-8555-666666666666";
+    mockPlatformAssistantId = "22222222-3333-4444-8555-666666666666";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-self-hosted-key";
 
@@ -292,8 +287,7 @@ describe("platform callback registration", () => {
     mockConfig = {};
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "22222222-3333-4444-8555-666666666666";
+    mockPlatformAssistantId = "22222222-3333-4444-8555-666666666666";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-self-hosted-key";
 
@@ -334,8 +328,7 @@ describe("platform callback registration", () => {
     mockConfig = { ingress: { publicBaseUrl: "https://velay.example.com" } };
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "11111111-2222-4333-8444-555555555555";
+    mockPlatformAssistantId = "11111111-2222-4333-8444-555555555555";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-managed-key";
 
@@ -396,8 +389,7 @@ describe("resolveCallbackUrl resolution order", () => {
   function seedPlatformCredentials(): void {
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "11111111-2222-4333-8444-555555555555";
+    mockPlatformAssistantId = "11111111-2222-4333-8444-555555555555";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-managed-key";
   }

package/src/__tests__/platform-client-verify-credential.test.ts

@@ -19,7 +19,9 @@ mock.module("../providers/platform-proxy/context.js", () => ({
   }),
 }));
 
+const actualEnv = await import("../config/env.js");
 mock.module("../config/env.js", () => ({
+  ...actualEnv,
   getPlatformAssistantId: () => platformAssistantId,
 }));
 

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -129,6 +129,9 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../daemon/embedding-reconcile.js",
     "../../../../daemon/trust-context.js",
     "../../../../daemon/turn-latency-sub-spans.js",
+    // mcp-setup capability cards list configured server names from the
+    // workspace mcp.json document. No plugin-api equivalent.
+    "../../../../mcp/workspace-mcp-config.js",
     "../../../../notifications/background-failure-signal.js",
     "../../../../persistence/checkpoints.js",
     "../../../../persistence/conversation-types.js",
@@ -210,6 +213,16 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../persistence/job-handlers/message-lexical.js",
     "../../../persistence/job-utils.js",
     "../../../persistence/jobs-store.js",
+    // The retrospective cursor is a `(createdAt, id)` bound that must keep
+    // working after its message row is deleted. The resolver lives beside
+    // the persistence after-reads it also drives, so the plugin's
+    // accounting imports it rather than re-deriving the bound. No
+    // plugin-api equivalent.
+    "../../../persistence/message-cursor.js",
+    // Named any-state `createdAt` lookup the cursor bookkeeping uses for
+    // forks and the timestamp backfill; the messages-read boundary guard
+    // requires the read to live in persistence. No plugin-api equivalent.
+    "../../../persistence/message-reads.js",
     "../../../persistence/raw-query.js",
     "../../../persistence/schema/index.js",
     "../../../prompts/persona-resolver.js",
@@ -235,6 +248,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../util/sqlite-retry.js",
     "../../../util/strip-comment-lines.js",
     "../../../util/truncate.js",
+    "../../../util/unicode.js",
     "../../../util/worker-compute.js",
     "../../../util/worker-memory.js",
     "../../../util/worker-process.js",

package/src/__tests__/qdrant-manager.test.ts

@@ -21,7 +21,9 @@ import {
 const testDataDir = process.env.VELLUM_WORKSPACE_DIR!;
 
 import {
+  describeQdrantStartFailure,
   QdrantManager,
+  QdrantStartError,
   resolveQdrantReleaseAsset,
 } from "../persistence/embeddings/qdrant-manager.js";
 
@@ -395,6 +397,136 @@ describe("QdrantManager", () => {
       // THEN the error carries the stdout explanation, not just the noise
       await expect(mgr.start()).rejects.toThrow("Failed to load local shard");
     }, 10_000);
+
+    test("classifies a crash as an exit with its code and captured output", async () => {
+      // The reporter must not have to parse the message: the step, the exit
+      // code and the raw streams travel as fields.
+      placeFakeBinary(
+        '#!/bin/sh\necho "Panic occurred: no such shard"\nexit 101',
+      );
+
+      const mgr = new QdrantManager({
+        url: `http://127.0.0.1:${getTestPort()}`,
+        ...FAST_TIMEOUTS,
+      });
+
+      let caught: unknown;
+      await mgr.start().catch((err) => {
+        caught = err;
+      });
+
+      expect(caught).toBeInstanceOf(QdrantStartError);
+      const err = caught as QdrantStartError;
+      expect(err.kind).toBe("exited");
+      expect(err.exitCode).toBe(101);
+      expect(err.stdout).toContain("no such shard");
+    }, 10_000);
+
+    test("classifies a readiness timeout as not_ready with no exit code", async () => {
+      placeFakeBinary("#!/bin/sh\nexec sleep 300");
+
+      const mgr = new QdrantManager({
+        url: `http://127.0.0.1:${getTestPort()}`,
+        ...FAST_TIMEOUTS,
+      });
+
+      let caught: unknown;
+      await mgr.start().catch((err) => {
+        caught = err;
+      });
+
+      expect(caught).toBeInstanceOf(QdrantStartError);
+      expect((caught as QdrantStartError).kind).toBe("not_ready");
+      expect((caught as QdrantStartError).exitCode).toBeNull();
+    }, 10_000);
+  });
+
+  describe("describeQdrantStartFailure", () => {
+    const dataDir = "/home/example/workspace-data";
+    const failure = (stdout: string, kind: "exited" | "not_ready" = "exited") =>
+      new QdrantStartError(
+        "boom",
+        kind,
+        kind === "exited" ? 101 : null,
+        stdout,
+        "",
+      );
+
+    test("takes the reason from the last panic marker, after the backtrace", () => {
+      const stdout =
+        "   0: backtrace frame\n   1: another frame\n" +
+        "ERROR qdrant::startup: Panic occurred in file mod.rs at line 301: " +
+        "Failed to load local shard";
+
+      expect(describeQdrantStartFailure(failure(stdout), dataDir)).toEqual({
+        kind: "exited",
+        exit_code: 101,
+        panic:
+          "Panic occurred in file mod.rs at line 301: Failed to load local shard",
+      });
+    });
+
+    test("replaces the data directory wherever it appears", () => {
+      const stdout = `Panic occurred: cannot open ${dataDir}/qdrant/collections/x and ${dataDir}/qdrant/wal`;
+
+      expect(describeQdrantStartFailure(failure(stdout), dataDir).panic).toBe(
+        "Panic occurred: cannot open <data>/qdrant/collections/x and <data>/qdrant/wal",
+      );
+    });
+
+    test("falls back to the last stdout line when Qdrant died without panicking", () => {
+      const stdout =
+        "INFO starting\nERROR Address already in use (os error 48)\n";
+
+      expect(describeQdrantStartFailure(failure(stdout), dataDir).panic).toBe(
+        "ERROR Address already in use (os error 48)",
+      );
+    });
+
+    test("reports no reason for a silent timeout", () => {
+      expect(
+        describeQdrantStartFailure(failure("", "not_ready"), dataDir),
+      ).toEqual({ kind: "not_ready", exit_code: null, panic: null });
+    });
+
+    /**
+     * The telemetry server's measure: JSON with every code unit above 0x7E
+     * escaped to six ASCII bytes (`jsonByteLength` in
+     * `telemetry-wire.generated.ts`), minus the enclosing quotes.
+     */
+    const serverBytes = (s: string) =>
+      JSON.stringify(s).replace(/[^\x00-\x7e]/g, "\\uxxxx").length - 2;
+
+    test("caps an ASCII reason at the byte budget", () => {
+      const { panic } = describeQdrantStartFailure(
+        failure("Panic occurred: " + "x".repeat(5_000)),
+        dataDir,
+      );
+
+      expect(panic?.length).toBe(1_024);
+      expect(serverBytes(panic!)).toBe(1_024);
+    });
+
+    test("caps a non-ASCII reason by the server's escaped size, not by characters", () => {
+      // Each CJK character serializes to six bytes on the server, so a
+      // character cap would overshoot the budget six-fold and the event would
+      // be dropped at ingest.
+      const { panic } = describeQdrantStartFailure(
+        failure("Panic occurred: " + "測".repeat(2_000)),
+        dataDir,
+      );
+
+      expect(serverBytes(panic!)).toBeLessThanOrEqual(1_024);
+      expect(serverBytes(panic! + "測")).toBeGreaterThan(1_024);
+    });
+
+    test("never drops an unclassified failure", () => {
+      expect(describeQdrantStartFailure(new Error("nope"), dataDir)).toEqual({
+        kind: "unknown",
+        exit_code: null,
+        panic: null,
+      });
+    });
   });
 
   // ── Binary Detection ─────────────────────────────────────────