@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/persistence/__tests__/conversation-search-lexical.test.ts

@@ -0,0 +1,103 @@
+import { afterAll, describe, expect, mock, test } from "bun:test";
+
+import type { SparseEmbedding } from "../embeddings/embedding-types.js";
+import type { MessageLexicalSearchResult } from "../embeddings/messages-lexical-index.js";
+
+const SPARSE: SparseEmbedding = { indices: [1, 2, 3], values: [0.5, 0.5, 0.5] };
+const EMPTY_SPARSE: SparseEmbedding = { indices: [], values: [] };
+
+// Mirror the real encoder: input that tokenizes to nothing (only whitespace
+// or punctuation) yields an empty sparse vector.
+const generateSparseEmbeddingMock = mock(
+  (text: string): SparseEmbedding =>
+    /[\p{L}\p{N}]/u.test(text) ? SPARSE : EMPTY_SPARSE,
+);
+
+const searchLexicalMock = mock(
+  async (
+    _sparse: SparseEmbedding,
+    _limit: number,
+    _opts?: { conversationId?: string },
+  ): Promise<MessageLexicalSearchResult[]> => [
+    { messageId: "msg-1", score: 0.9 },
+    { messageId: "msg-2", score: 0.4 },
+  ],
+);
+
+const getMessagesLexicalIndexMock = mock(() => ({
+  searchLexical: searchLexicalMock,
+}));
+
+// `embedding-backend` is mocked WITHOUT spreading the real module: importing
+// it transitively pulls provider/security modules (and `packages/service-
+// contracts` → `zod`) into the test for no benefit. The helper only imports
+// `generateSparseEmbedding`, so a targeted replacement is complete for this
+// file's needs.
+mock.module("../embeddings/embedding-backend.js", () => ({
+  generateSparseEmbedding: generateSparseEmbeddingMock,
+}));
+
+// `messages-lexical-index` IS spread from the real module. Bun's
+// `mock.module` is process-global and is not undone by `mock.restore()`, so a
+// partial replacement would drop the module's other real exports
+// (`messagePointId`, `initMessagesLexicalIndex`, `MessagesLexicalIndex`, …)
+// for any test that runs later in the same process (e.g.
+// `embeddings/__tests__/messages-lexical-index.test.ts`, which imports
+// `messagePointId`). Spreading keeps those intact; its deps
+// (`@qdrant/js-client-rest`, `uuid`) are installed, so importing it is safe.
+const actualLexicalIndex =
+  await import("../embeddings/messages-lexical-index.js");
+mock.module("../embeddings/messages-lexical-index.js", () => ({
+  ...actualLexicalIndex,
+  getMessagesLexicalIndex: getMessagesLexicalIndexMock,
+}));
+
+const { searchMessageIdsLexical } =
+  await import("../conversation-search-lexical.js");
+
+afterAll(() => {
+  mock.restore();
+});
+
+describe("searchMessageIdsLexical", () => {
+  test("encodes the query and returns the index results", async () => {
+    generateSparseEmbeddingMock.mockClear();
+    searchLexicalMock.mockClear();
+
+    const results = await searchMessageIdsLexical("hello world", 5);
+
+    expect(generateSparseEmbeddingMock).toHaveBeenCalledTimes(1);
+    expect(generateSparseEmbeddingMock.mock.calls[0]).toEqual(["hello world"]);
+
+    // The encoded sparse vector and limit are passed straight through.
+    expect(searchLexicalMock).toHaveBeenCalledTimes(1);
+    expect(searchLexicalMock.mock.calls[0]![0]).toBe(SPARSE);
+    expect(searchLexicalMock.mock.calls[0]![1]).toBe(5);
+
+    expect(results).toEqual([
+      { messageId: "msg-1", score: 0.9 },
+      { messageId: "msg-2", score: 0.4 },
+    ]);
+  });
+
+  test("passes conversationId through to the index", async () => {
+    searchLexicalMock.mockClear();
+
+    await searchMessageIdsLexical("scoped", 3, { conversationId: "conv-xyz" });
+
+    expect(searchLexicalMock).toHaveBeenCalledTimes(1);
+    expect(searchLexicalMock.mock.calls[0]![2]).toEqual({
+      conversationId: "conv-xyz",
+    });
+  });
+
+  test("returns [] without querying the index for an empty-after-tokenize query", async () => {
+    searchLexicalMock.mockClear();
+
+    const results = await searchMessageIdsLexical("   ... !!! ", 5);
+
+    expect(results).toEqual([]);
+    // The empty sparse vector must never reach Qdrant.
+    expect(searchLexicalMock).not.toHaveBeenCalled();
+  });
+});

package/src/persistence/__tests__/jobs-worker-memory-disabled.test.ts

@@ -0,0 +1,95 @@
+/**
+ * With `memory.enabled === false` the job worker still drains the
+ * MESSAGE-LEXICAL job types (host-owned message-search indexing that shares
+ * the queue) while every memory job stays pending — the slow and embed lanes
+ * get no budget and the fast lane is restricted to the lexical types.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+import { DEFAULT_CONFIG } from "../../config/defaults.js";
+import type { AssistantConfig } from "../../config/types.js";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+let memoryEnabled = false;
+const testConfig = (): AssistantConfig => ({
+  ...DEFAULT_CONFIG,
+  memory: {
+    ...DEFAULT_CONFIG.memory,
+    enabled: memoryEnabled,
+  },
+});
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => testConfig(),
+  loadConfig: () => testConfig(),
+  invalidateConfigCache: () => {},
+}));
+
+import { getMemoryDb } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import { enqueueMemoryJob } from "../jobs-store.js";
+import { registerJobHandler, runMemoryJobsOnce } from "../jobs-worker.js";
+import { memoryJobs } from "../schema/index.js";
+
+await initializeDb();
+
+const processed: string[] = [];
+registerJobHandler("index_message_lexical", async (job) => {
+  processed.push(job.type);
+});
+registerJobHandler("memory_v2_activation_recompute", async (job) => {
+  processed.push(job.type);
+});
+
+function jobStatuses(type: string): string[] {
+  return getMemoryDb()!
+    .select({ status: memoryJobs.status })
+    .from(memoryJobs)
+    .where(eq(memoryJobs.type, type))
+    .all()
+    .map((row) => row.status);
+}
+
+describe("runMemoryJobsOnce with memory disabled", () => {
+  beforeEach(() => {
+    getMemoryDb()!.delete(memoryJobs).run();
+    processed.length = 0;
+    memoryEnabled = false;
+  });
+
+  test("drains lexical jobs while leaving memory jobs pending", async () => {
+    enqueueMemoryJob("index_message_lexical", { messageId: "msg-1" });
+    // A fast-lane MEMORY job type: proves the restriction is by type, not
+    // just by zeroing the slow/embed lane budgets.
+    enqueueMemoryJob("memory_v2_activation_recompute", {});
+
+    const ran = await runMemoryJobsOnce();
+
+    expect(ran).toBe(1);
+    expect(processed).toEqual(["index_message_lexical"]);
+    expect(jobStatuses("index_message_lexical")).toEqual(["completed"]);
+    expect(jobStatuses("memory_v2_activation_recompute")).toEqual(["pending"]);
+  });
+
+  test("drains both once memory is re-enabled", async () => {
+    enqueueMemoryJob("index_message_lexical", { messageId: "msg-2" });
+    enqueueMemoryJob("memory_v2_activation_recompute", {});
+
+    memoryEnabled = true;
+    const ran = await runMemoryJobsOnce();
+
+    expect(ran).toBe(2);
+    expect(jobStatuses("index_message_lexical")).toEqual(["completed"]);
+    expect(jobStatuses("memory_v2_activation_recompute")).toEqual([
+      "completed",
+    ]);
+  });
+});

package/src/persistence/__tests__/slow-query-log.test.ts

@@ -0,0 +1,266 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import {
+  callerFromStack,
+  SLOW_QUERY_THRESHOLD_MS,
+  type SlowQueryEvent,
+  wrapSqliteForSlowQueryLogging,
+} from "../slow-query-log.js";
+
+/**
+ * A deterministic `performance.now()` stand-in that yields the supplied values
+ * in order. Each timed execution consumes two readings (start + end), so a
+ * `[start, end]` pair per query lets a test dial an exact duration.
+ */
+function fakeClock(...readings: number[]): () => number {
+  let i = 0;
+  return () => readings[i++];
+}
+
+describe("slow-query-log", () => {
+  test("threshold default is a positive number", () => {
+    expect(SLOW_QUERY_THRESHOLD_MS).toBeGreaterThan(0);
+  });
+
+  test("a slow query logs exactly one event; a fast query logs none", () => {
+    const events: SlowQueryEvent[] = [];
+    const db = new Database(":memory:");
+    // First execution spans 0→300ms (slow); second spans 1000→1002ms (fast).
+    wrapSqliteForSlowQueryLogging(db, {
+      thresholdMs: 250,
+      now: fakeClock(0, 300, 1000, 1002),
+      onSlowQuery: (e) => events.push(e),
+    });
+
+    db.exec("CREATE TABLE t (id INTEGER PRIMARY KEY, v TEXT)");
+    db.query("INSERT INTO t (v) VALUES (?)").run("a"); // slow
+    db.query("SELECT * FROM t").all(); // fast
+
+    expect(events).toHaveLength(1);
+    expect(events[0].durationMs).toBe(300);
+    expect(events[0].sql).toContain("INSERT INTO t");
+  });
+
+  test("slow SELECT reports the returned row count", () => {
+    const events: SlowQueryEvent[] = [];
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE t (id INTEGER PRIMARY KEY)");
+    db.exec("INSERT INTO t (id) VALUES (1), (2), (3)");
+    wrapSqliteForSlowQueryLogging(db, {
+      thresholdMs: 100,
+      now: fakeClock(0, 500),
+      onSlowQuery: (e) => events.push(e),
+    });
+
+    const rows = db.query("SELECT * FROM t").all();
+
+    expect(rows).toHaveLength(3);
+    expect(events).toHaveLength(1);
+    expect(events[0].rowCount).toBe(3);
+  });
+
+  test("SQL preview is truncated to 120 characters", () => {
+    const events: SlowQueryEvent[] = [];
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE t (id INTEGER PRIMARY KEY)");
+    wrapSqliteForSlowQueryLogging(db, {
+      thresholdMs: 1,
+      now: fakeClock(0, 50),
+      onSlowQuery: (e) => events.push(e),
+    });
+
+    // A comment pads the statement well past the 120-char preview window.
+    const longSql = `SELECT * FROM t WHERE id = 1 -- ${"x".repeat(200)}`;
+    db.query(longSql).all();
+
+    expect(events).toHaveLength(1);
+    expect(events[0].sql).toHaveLength(120);
+    expect(events[0].sql).toBe(longSql.slice(0, 120));
+  });
+
+  test("a failing execution still reports once and rethrows unchanged", () => {
+    const events: SlowQueryEvent[] = [];
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE t (id INTEGER PRIMARY KEY)");
+    db.exec("INSERT INTO t (id) VALUES (1)"); // seed via exec (not timed)
+    wrapSqliteForSlowQueryLogging(db, {
+      thresholdMs: 0,
+      now: fakeClock(0, 7),
+      onSlowQuery: (e) => events.push(e),
+    });
+
+    // The duplicate primary key throws at execution time — the failed op still
+    // blocked the loop, so it is reported, and the error propagates unchanged.
+    expect(() => db.query("INSERT INTO t (id) VALUES (1)").run()).toThrow();
+    expect(events).toHaveLength(1);
+    expect(events[0].durationMs).toBe(7);
+  });
+
+  test("return values and types are unchanged through the wrapper", () => {
+    // A high threshold + noop sink keeps this purely about passthrough fidelity.
+    const bare = new Database(":memory:");
+    const wrapped = new Database(":memory:");
+    wrapSqliteForSlowQueryLogging(wrapped, {
+      thresholdMs: Number.POSITIVE_INFINITY,
+      onSlowQuery: () => {
+        throw new Error("must not fire on the fast path");
+      },
+    });
+
+    for (const db of [bare, wrapped]) {
+      db.exec("CREATE TABLE t (id INTEGER PRIMARY KEY, v TEXT)");
+    }
+
+    const runResult = wrapped
+      .query("INSERT INTO t (v) VALUES (?)")
+      .run("hello");
+    const bareRun = bare.query("INSERT INTO t (v) VALUES (?)").run("hello");
+    expect(runResult).toEqual(bareRun);
+    expect(typeof runResult.changes).toBe("number");
+    expect(runResult.changes).toBe(1);
+
+    expect(wrapped.query("SELECT * FROM t").all()).toEqual(
+      bare.query("SELECT * FROM t").all(),
+    );
+    expect(wrapped.query("SELECT * FROM t WHERE id = ?").get(1)).toEqual(
+      bare.query("SELECT * FROM t WHERE id = ?").get(1),
+    );
+    expect(wrapped.query("SELECT * FROM t").values()).toEqual(
+      bare.query("SELECT * FROM t").values(),
+    );
+
+    // `.get()` on a no-match returns the same nullish shape as the bare client.
+    expect(wrapped.query("SELECT * FROM t WHERE id = ?").get(999)).toEqual(
+      bare.query("SELECT * FROM t WHERE id = ?").get(999),
+    );
+
+    // Non-execution members pass straight through.
+    expect(wrapped.query("SELECT id, v FROM t").columnNames).toEqual([
+      "id",
+      "v",
+    ]);
+  });
+
+  test("times the Database.run shortcut, which bypasses query/prepare", () => {
+    const events: SlowQueryEvent[] = [];
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE t (id INTEGER PRIMARY KEY, v TEXT)");
+    wrapSqliteForSlowQueryLogging(db, {
+      thresholdMs: 250,
+      now: fakeClock(0, 400),
+      onSlowQuery: (e) => events.push(e),
+    });
+
+    const result = db.run("INSERT INTO t (v) VALUES (?)", ["a"]);
+
+    expect(result.changes).toBe(1);
+    expect(events).toHaveLength(1);
+    expect(events[0].durationMs).toBe(400);
+    expect(events[0].sql).toContain("INSERT INTO t");
+  });
+
+  test("label() tags the slow-query event", () => {
+    const events: SlowQueryEvent[] = [];
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE t (id INTEGER PRIMARY KEY, v TEXT)");
+    wrapSqliteForSlowQueryLogging(db, {
+      thresholdMs: 100,
+      now: fakeClock(0, 500, 1000, 1600),
+      onSlowQuery: (e) => events.push(e),
+    });
+
+    db.label("schedule::claimDue")
+      .query("INSERT INTO t (v) VALUES (?)")
+      .run("a");
+    db.label("schedule::complete").run("UPDATE t SET v = ? WHERE id = 1", [
+      "b",
+    ]);
+
+    expect(events).toHaveLength(2);
+    expect(events[0].label).toBe("schedule::claimDue");
+    expect(events[1].label).toBe("schedule::complete");
+    // A curated label suppresses the auto-derived caller.
+    expect(events[0].caller).toBeUndefined();
+    expect(events[0].sql).toContain("INSERT INTO t");
+  });
+
+  test("an unlabeled query derives a caller from the stack", () => {
+    const events: SlowQueryEvent[] = [];
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE t (id INTEGER PRIMARY KEY)");
+    wrapSqliteForSlowQueryLogging(db, {
+      thresholdMs: 100,
+      now: fakeClock(0, 500),
+      onSlowQuery: (e) => events.push(e),
+    });
+
+    // No `.label()` — mirrors a Drizzle query, which has no chokepoint to label.
+    db.query("SELECT * FROM t").all();
+
+    expect(events).toHaveLength(1);
+    expect(events[0].label).toBeUndefined();
+    // The caller points at this test file (the application frame that issued it),
+    // not at slow-query-log.ts or bun:sqlite internals.
+    expect(events[0].caller).toBeDefined();
+    expect(events[0].caller).toContain("slow-query-log.test.ts");
+    expect(events[0].caller).not.toContain("slow-query-log.ts");
+  });
+
+  test("wraps in place and returns the same Database instance", () => {
+    const db = new Database(":memory:");
+    expect(wrapSqliteForSlowQueryLogging(db)).toBe(db);
+  });
+});
+
+describe("callerFromStack", () => {
+  test("returns the first app frame in a source-tree run, skipping ORM/self", () => {
+    const stack = [
+      "Error",
+      "    at callerFromStack (/repo/assistant/src/persistence/slow-query-log.ts:110:20)",
+      "    at emit (/repo/assistant/src/persistence/slow-query-log.ts:192:5)",
+      "    at all (/root/.bun/install/cache/drizzle-orm@0.45.2@@@1/bun-sqlite/session.js:79:23)",
+      "    at insertMessageCore (/repo/assistant/src/persistence/conversation-crud.ts:474:10)",
+    ].join("\n");
+    expect(callerFromStack(stack)).toBe(
+      "persistence/conversation-crud.ts:insertMessageCore:474",
+    );
+  });
+
+  test("preserves the assistant's own src frames in a packaged install", () => {
+    // Local-runtime install: the daemon runs from
+    // node_modules/@vellumai/assistant/src, so app frames also contain
+    // node_modules. Third-party deps are still skipped; assistant src is not.
+    const stack = [
+      "Error",
+      "    at emit (/app/node_modules/@vellumai/assistant/src/persistence/slow-query-log.ts:192:5)",
+      "    at all (/app/node_modules/drizzle-orm/bun-sqlite/session.js:79:23)",
+      "    at claimDueSchedules (/app/node_modules/@vellumai/assistant/src/schedule/schedule-store.ts:88:12)",
+    ].join("\n");
+    expect(callerFromStack(stack)).toBe(
+      "schedule/schedule-store.ts:claimDueSchedules:88",
+    );
+  });
+
+  test("handles column-less frames (function omitted)", () => {
+    const stack = [
+      "Error",
+      "    at emit (/repo/assistant/src/persistence/slow-query-log.ts:192:5)",
+      "    at all (/root/.bun/install/cache/drizzle-orm@0.45.2/bun-sqlite/session.js:79:23)",
+      "    at /repo/assistant/src/plugins/defaults/memory/context-search/sources/conversations.ts:231",
+    ].join("\n");
+    expect(callerFromStack(stack)).toBe(
+      "plugins/defaults/memory/context-search/sources/conversations.ts:231",
+    );
+  });
+
+  test("returns undefined when no application frame is present", () => {
+    const stack = [
+      "Error",
+      "    at emit (/repo/assistant/src/persistence/slow-query-log.ts:192:5)",
+      "    at all (/root/.bun/install/cache/drizzle-orm@0.45.2/bun-sqlite/session.js:79:23)",
+      "    at processTicksAndRejections (native:7:39)",
+    ].join("\n");
+    expect(callerFromStack(stack)).toBeUndefined();
+  });
+});

package/src/persistence/__tests__/slow-sync-log.test.ts

@@ -0,0 +1,155 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  endSection,
+  getSectionTrail,
+  markSection,
+  reportSlowSync,
+  resetSectionTrailForTests,
+  SLOW_SYNC_CHECK_NAME,
+  SLOW_SYNC_THRESHOLD_MS,
+  timeSyncSection,
+  traceAsyncSection,
+} from "../slow-sync-log.js";
+
+describe("slow-sync-log", () => {
+  test("threshold default is a positive number", () => {
+    expect(SLOW_SYNC_THRESHOLD_MS).toBeGreaterThan(0);
+    expect(SLOW_SYNC_CHECK_NAME).toBe("slow_sync_operation");
+  });
+
+  test("timeSyncSection returns the section's value and runs it once", () => {
+    let calls = 0;
+    const result = timeSyncSection("test:value", () => {
+      calls++;
+      return 42;
+    });
+    expect(result).toBe(42);
+    expect(calls).toBe(1);
+  });
+
+  test("timeSyncSection propagates a thrown error unchanged", () => {
+    const boom = new Error("boom");
+    expect(() =>
+      timeSyncSection("test:throw", () => {
+        throw boom;
+      }),
+    ).toThrow(boom);
+  });
+
+  test("timeSyncSection only evaluates the detail thunk when reporting", () => {
+    // A fast section stays below the threshold, so the detail thunk (which
+    // would allocate on a hot query path) must not run.
+    let detailCalls = 0;
+    timeSyncSection(
+      "test:detail",
+      () => [1, 2, 3],
+      () => {
+        detailCalls++;
+        return { evaluated: true };
+      },
+    );
+    expect(detailCalls).toBe(0);
+  });
+
+  test("reportSlowSync is a no-op below the threshold and does not throw above it", () => {
+    // Below threshold: silent no-op.
+    expect(() => reportSlowSync("test:fast", 0)).not.toThrow();
+    expect(() =>
+      reportSlowSync("test:fast", SLOW_SYNC_THRESHOLD_MS - 1),
+    ).not.toThrow();
+    // At/above threshold: logs + records telemetry (telemetry no-ops under the
+    // test opt-out); must never throw out of the timed section.
+    expect(() =>
+      reportSlowSync("test:slow", SLOW_SYNC_THRESHOLD_MS + 5000, {
+        conversationId: "conv-123",
+        rowCount: 4200,
+      }),
+    ).not.toThrow();
+  });
+});
+
+describe("section trail", () => {
+  beforeEach(() => {
+    resetSectionTrailForTests();
+  });
+
+  test("marks appear newest-first with ago values relative to now", () => {
+    const first = markSection("test:first");
+    endSection(first);
+    markSection("test:second");
+
+    const trail = getSectionTrail(performance.now() + 100);
+    expect(trail.map((e) => e.label)).toEqual(["test:second", "test:first"]);
+    // Both marks started before the reference "now".
+    for (const entry of trail) {
+      expect(entry.startedAgoMs).toBeGreaterThanOrEqual(100);
+    }
+    // Only the ended mark carries an end age.
+    expect(trail[0]?.endedAgoMs).toBeUndefined();
+    expect(trail[1]?.endedAgoMs).toBeGreaterThanOrEqual(100);
+  });
+
+  test("endSection returns the section's elapsed time", () => {
+    const mark = markSection("test:elapsed");
+    const elapsed = endSection(mark);
+    expect(elapsed).toBeGreaterThanOrEqual(0);
+    expect(mark.endedAt).toBeDefined();
+  });
+
+  test("trail is capacity-bounded, evicting oldest marks", () => {
+    for (let i = 0; i < 20; i++) {
+      endSection(markSection(`test:mark-${i}`));
+    }
+    const trail = getSectionTrail();
+    expect(trail.length).toBe(16);
+    // Newest-first: the most recent mark leads, the earliest four are evicted.
+    expect(trail[0]?.label).toBe("test:mark-19");
+    expect(trail[trail.length - 1]?.label).toBe("test:mark-4");
+  });
+
+  test("timeSyncSection leaves an ended mark in the trail", () => {
+    timeSyncSection("test:timed", () => 1);
+    const trail = getSectionTrail();
+    expect(trail[0]?.label).toBe("test:timed");
+    expect(trail[0]?.endedAgoMs).toBeDefined();
+  });
+
+  test("timeSyncSection ends its mark when the section throws", () => {
+    expect(() =>
+      timeSyncSection("test:timed-throw", () => {
+        throw new Error("boom");
+      }),
+    ).toThrow("boom");
+    const trail = getSectionTrail();
+    expect(trail[0]?.label).toBe("test:timed-throw");
+    expect(trail[0]?.endedAgoMs).toBeDefined();
+  });
+
+  test("traceAsyncSection returns the value and ends the mark across an await", async () => {
+    const result = await traceAsyncSection("test:async", async () => {
+      // While awaited, the mark is open.
+      expect(getSectionTrail()[0]?.label).toBe("test:async");
+      expect(getSectionTrail()[0]?.endedAgoMs).toBeUndefined();
+      await Promise.resolve();
+      return "ok";
+    });
+    expect(result).toBe("ok");
+    const trail = getSectionTrail();
+    expect(trail[0]?.label).toBe("test:async");
+    expect(trail[0]?.endedAgoMs).toBeDefined();
+  });
+
+  test("traceAsyncSection ends the mark when the span rejects", async () => {
+    let thrown: unknown;
+    try {
+      await traceAsyncSection("test:async-throw", async () => {
+        throw new Error("boom");
+      });
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeInstanceOf(Error);
+    expect(getSectionTrail()[0]?.endedAgoMs).toBeDefined();
+  });
+});