@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/memory/migrations/278-tool-invocations-telemetry-columns.ts

@@ -0,0 +1,39 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+const TABLE = "tool_invocations";
+const COLUMNS: Array<{ name: string; type: string }> = [
+  { name: "arg_bytes", type: "INTEGER" },
+  { name: "result_bytes", type: "INTEGER" },
+  { name: "provider", type: "TEXT" },
+  { name: "model", type: "TEXT" },
+  { name: "inference_profile", type: "TEXT" },
+  { name: "inference_profile_source", type: "TEXT" },
+];
+
+/**
+ * Add nullable telemetry columns to `tool_invocations` for the
+ * `tool_executed` telemetry projection: serialized payload sizes (only the
+ * sizes leave the device, never the payloads) and the conversation's model
+ * attribution at invocation time. Nullable so pre-migration and
+ * permission-denied rows stay NULL (see the legacy-row filter in
+ * tool-executed-events-store.ts).
+ *
+ * Idempotent pure DDL with a PRAGMA guard, no registry entry needed
+ * (matches the 273 / 275 pattern).
+ */
+export function migrateToolInvocationsTelemetryColumns(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+
+  const columns = raw.query(`PRAGMA table_info(${TABLE})`).all() as Array<{
+    name: string;
+  }>;
+  const columnNames = new Set(columns.map((c) => c.name));
+
+  for (const { name, type } of COLUMNS) {
+    if (!columnNames.has(name)) {
+      raw.exec(`ALTER TABLE ${TABLE} ADD COLUMN ${name} ${type}`);
+    }
+  }
+}

package/src/memory/migrations/279-create-skill-loaded-events.test.ts

@@ -0,0 +1,84 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { createSkillLoadedEventsTable } from "./279-create-skill-loaded-events.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function columnNames(sqlite: Database): string[] {
+  return (
+    sqlite.query("PRAGMA table_info(skill_loaded_events)").all() as Array<{
+      name: string;
+    }>
+  ).map((c) => c.name);
+}
+
+function indexNames(sqlite: Database): string[] {
+  return (
+    sqlite.query("PRAGMA index_list(skill_loaded_events)").all() as Array<{
+      name: string;
+    }>
+  ).map((i) => i.name);
+}
+
+describe("migration 279: skill_loaded_events table", () => {
+  test("creates the table with the expected columns", () => {
+    const { sqlite, db } = createTestDb();
+
+    createSkillLoadedEventsTable(db);
+
+    expect(columnNames(sqlite)).toEqual([
+      "id",
+      "created_at",
+      "conversation_id",
+      "skill_name",
+      "skill_updated_at",
+      "provider",
+      "model",
+      "inference_profile",
+      "inference_profile_source",
+    ]);
+  });
+
+  test("creates the (created_at, id) cursor index", () => {
+    const { sqlite, db } = createTestDb();
+
+    createSkillLoadedEventsTable(db);
+
+    expect(indexNames(sqlite)).toContain(
+      "idx_skill_loaded_events_created_at_id",
+    );
+    const columns = (
+      sqlite
+        .query("PRAGMA index_info(idx_skill_loaded_events_created_at_id)")
+        .all() as Array<{ name: string }>
+    ).map((c) => c.name);
+    expect(columns).toEqual(["created_at", "id"]);
+  });
+
+  test("is idempotent — re-run is a no-op and preserves existing rows", () => {
+    const { sqlite, db } = createTestDb();
+
+    createSkillLoadedEventsTable(db);
+    sqlite.exec(/*sql*/ `
+      INSERT INTO skill_loaded_events (id, created_at, skill_name)
+      VALUES ('sle-1', 1000, 'web-research')
+    `);
+
+    expect(() => createSkillLoadedEventsTable(db)).not.toThrow();
+
+    const rows = sqlite.query("SELECT id FROM skill_loaded_events").all();
+    expect(rows).toEqual([{ id: "sle-1" }]);
+    expect(
+      indexNames(sqlite).filter(
+        (name) => name === "idx_skill_loaded_events_created_at_id",
+      ),
+    ).toHaveLength(1);
+  });
+});

package/src/memory/migrations/279-create-skill-loaded-events.ts

@@ -0,0 +1,26 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+/**
+ * Create the skill_loaded_events table for `skill_loaded` telemetry events —
+ * one row per activation of a Vellum-produced skill (see
+ * skill-loaded-events-store.ts for the data contract). The index backs the
+ * telemetry reporter's compound `(created_at, id)` watermark cursor.
+ */
+export function createSkillLoadedEventsTable(database: DrizzleDb): void {
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS skill_loaded_events (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL,
+      conversation_id TEXT,
+      skill_name TEXT NOT NULL,
+      skill_updated_at TEXT,
+      provider TEXT,
+      model TEXT,
+      inference_profile TEXT,
+      inference_profile_source TEXT
+    )
+  `);
+  database.run(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_skill_loaded_events_created_at_id ON skill_loaded_events (created_at, id)`,
+  );
+}

package/src/memory/migrations/280-conversations-surfaced-at.test.ts

@@ -0,0 +1,88 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateConversationsSurfacedAt } from "./280-conversations-surfaced-at.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  // Pre-280 shape: no surfaced_at column (trimmed to the columns the
+  // migration and assertions touch).
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      conversation_type TEXT NOT NULL DEFAULT 'standard',
+      archived_at INTEGER
+    )
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function columnNames(sqlite: Database): string[] {
+  return (
+    sqlite.query("PRAGMA table_info(conversations)").all() as Array<{
+      name: string;
+    }>
+  ).map((c) => c.name);
+}
+
+function indexNames(sqlite: Database): string[] {
+  return (
+    sqlite
+      .query(
+        "SELECT name FROM sqlite_master WHERE type = 'index' AND tbl_name = 'conversations'",
+      )
+      .all() as Array<{ name: string }>
+  ).map((i) => i.name);
+}
+
+describe("migration 280: conversations surfaced_at", () => {
+  test("adds a nullable surfaced_at column and index", () => {
+    const { sqlite, db } = createTestDb();
+    expect(columnNames(sqlite)).not.toContain("surfaced_at");
+
+    migrateConversationsSurfacedAt(db);
+
+    const column = (
+      sqlite.query("PRAGMA table_info(conversations)").all() as Array<{
+        name: string;
+        notnull: number;
+        dflt_value: string | null;
+      }>
+    ).find((c) => c.name === "surfaced_at");
+    expect(column).toBeDefined();
+    expect(column?.notnull).toBe(0);
+    expect(indexNames(sqlite)).toContain("idx_conversations_surfaced_at");
+  });
+
+  test("existing rows read back with surfaced_at null", () => {
+    const { sqlite, db } = createTestDb();
+    sqlite.exec(/*sql*/ `
+      INSERT INTO conversations (id, title, created_at, updated_at, conversation_type)
+      VALUES ('conv-1', 'Background run', 1000, 1000, 'background')
+    `);
+
+    migrateConversationsSurfacedAt(db);
+
+    const row = sqlite
+      .query("SELECT surfaced_at FROM conversations WHERE id = 'conv-1'")
+      .get() as { surfaced_at: number | null };
+    expect(row.surfaced_at).toBeNull();
+  });
+
+  test("is idempotent — re-run is a no-op", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateConversationsSurfacedAt(db);
+    expect(() => migrateConversationsSurfacedAt(db)).not.toThrow();
+
+    expect(
+      columnNames(sqlite).filter((name) => name === "surfaced_at"),
+    ).toHaveLength(1);
+  });
+});

package/src/memory/migrations/280-conversations-surfaced-at.ts

@@ -0,0 +1,24 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+
+/**
+ * Add a nullable `surfaced_at` column to `conversations`.
+ *
+ * Non-null marks a background/scheduled conversation as explicitly promoted
+ * ("surfaced") into the sidebar's Recents grouping. Promotion is always an
+ * explicit API call (`POST /v1/conversations/:id/surface`) — nothing sets
+ * this automatically, so all existing rows stay NULL and default sidebar
+ * behavior is unchanged.
+ *
+ * Idempotent — re-running is a no-op once the column and index exist.
+ */
+export function migrateConversationsSurfacedAt(database: DrizzleDb): void {
+  if (!tableHasColumn(database, "conversations", "surfaced_at")) {
+    database.run(
+      `ALTER TABLE conversations ADD COLUMN surfaced_at INTEGER DEFAULT NULL`,
+    );
+  }
+  database.run(
+    `CREATE INDEX IF NOT EXISTS idx_conversations_surfaced_at ON conversations (surfaced_at)`,
+  );
+}

package/src/memory/migrations/index.ts

@@ -257,11 +257,21 @@ export { migrateLlmUsageEventsAddAssistantVersion } from "./267-llm-usage-events
 export { migrateAddMemoryV3Selections } from "./268-add-memory-v3-selections.js";
 export { migrateScheduleScriptTimeout } from "./269-schedule-script-timeout.js";
 export { migrateMessagesRoleCreatedAtIndex } from "./270-messages-role-created-at-index.js";
+export {
+  downScheduleDescription,
+  migrateScheduleDescription,
+} from "./270-schedule-description.js";
 export { migrateScheduleSourceConversation } from "./270-schedule-source-conversation.js";
 export { createAuthFallbackEventsTable } from "./271-create-auth-fallback-events.js";
 export { migrateAcpSessionHistoryCwd } from "./272-acp-session-history-cwd.js";
 export { migrateOnboardingEventsFunnelColumns } from "./273-onboarding-events-funnel-columns.js";
 export { createActivationSessionsTable } from "./274-create-activation-sessions.js";
+export { migrateToolInvocationsSkillId } from "./275-tool-invocations-add-skill-id.js";
+export { migrateToolInvocationsCreatedAtIdIndex } from "./276-tool-invocations-created-at-id-index.js";
+export { migrateAddMemoryV3EverInjected } from "./277-add-memory-v3-ever-injected.js";
+export { migrateToolInvocationsTelemetryColumns } from "./278-tool-invocations-telemetry-columns.js";
+export { createSkillLoadedEventsTable } from "./279-create-skill-loaded-events.js";
+export { migrateConversationsSurfacedAt } from "./280-conversations-surfaced-at.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -57,6 +57,7 @@ import { downRenameCleanedAt } from "./260-rename-cleaned-at.js";
 import { downLlmUsageAddRawUsage } from "./261-llm-usage-add-raw-usage.js";
 import { downMemoryV3Coactivation } from "./262-memory-v3-coactivation.js";
 import { downMemoryV3AutoEdges } from "./263-memory-v3-auto-edges.js";
+import { downScheduleDescription } from "./270-schedule-description.js";
 
 export interface MigrationRegistryEntry {
   /** The checkpoint key written to memory_checkpoints on completion. */
@@ -486,6 +487,13 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
       "Create memory_v3_auto_edges table — weighted, decaying learned association graph (distinct from curated edges:) accrued by the edge-learning job from used co-activations and consumed above-threshold by edge expansion",
     down: downMemoryV3AutoEdges,
   },
+  {
+    key: "migration_schedule_description_backfill_v1",
+    version: 57,
+    description:
+      "Backfill authored schedule descriptions for legacy non-defer schedules from their existing names",
+    down: downScheduleDescription,
+  },
 ];
 
 export function getMaxMigrationVersion(): number {

package/src/memory/schema/conversations.ts

@@ -41,6 +41,13 @@ export const conversations = sqliteTable(
     scheduleJobId: text("schedule_job_id"),
     lastMessageAt: integer("last_message_at"),
     archivedAt: integer("archived_at"),
+    /**
+     * Epoch-ms timestamp set when a background/scheduled conversation is
+     * explicitly promoted into the sidebar's Recents grouping. NULL (the
+     * default) means not surfaced. Set/cleared only via the surface API —
+     * never automatically.
+     */
+    surfacedAt: integer("surfaced_at"),
     inferenceProfile: text("inference_profile"),
     inferenceProfileSessionId: text("inference_profile_session_id"),
     inferenceProfileExpiresAt: integer("inference_profile_expires_at"),
@@ -51,6 +58,7 @@ export const conversations = sqliteTable(
     index("idx_conversations_last_message_at").on(table.lastMessageAt),
     index("idx_conversations_conversation_type").on(table.conversationType),
     index("idx_conversations_archived_at").on(table.archivedAt),
+    index("idx_conversations_surfaced_at").on(table.surfacedAt),
     index("idx_conversations_fork_parent_conversation_id").on(
       table.forkParentConversationId,
     ),
@@ -93,6 +101,14 @@ export const toolInvocations = sqliteTable(
     matchedTrustRuleId: text("matched_trust_rule_id"),
     durationMs: integer("duration_ms").notNull(),
     createdAt: integer("created_at").notNull(),
+    /** Serialized input size in bytes, computed before any redaction. Null pre-migration-278. */
+    argBytes: integer("arg_bytes"),
+    /** Full serialized result size in bytes, computed before truncation/redaction. Null pre-migration-278 and for denied rows. */
+    resultBytes: integer("result_bytes"),
+    provider: text("provider"),
+    model: text("model"),
+    inferenceProfile: text("inference_profile"),
+    inferenceProfileSource: text("inference_profile_source"),
   },
   (table) => [
     index("idx_tool_invocations_conversation_id").on(table.conversationId),

package/src/memory/schema/infrastructure.ts

@@ -10,6 +10,7 @@ import {
 export const cronJobs = sqliteTable("cron_jobs", {
   id: text("id").primaryKey(),
   name: text("name").notNull(),
+  description: text("description").notNull().default(""),
   enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
   cronExpression: text("cron_expression"), // nullable for one-shot schedules; e.g. '0 9 * * 1-5'
   scheduleSyntax: text("schedule_syntax").notNull().default("cron"), // 'cron' | 'rrule'
@@ -307,6 +308,31 @@ export const activationSessions = sqliteTable("activation_sessions", {
   createdAt: integer("created_at").notNull(),
 });
 
+// One row per `skill_loaded` telemetry event, emitted when a Vellum-produced
+// skill is activated in a conversation — see skill-loaded-events-store.ts for
+// the data contract. Flushed by the usage telemetry reporter.
+export const skillLoadedEvents = sqliteTable(
+  "skill_loaded_events",
+  {
+    id: text("id").primaryKey(),
+    createdAt: integer("created_at").notNull(),
+    conversationId: text("conversation_id"),
+    skillName: text("skill_name").notNull(),
+    // ISO 8601 timestamp from the merged skill catalog, when known.
+    skillUpdatedAt: text("skill_updated_at"),
+    provider: text("provider"),
+    model: text("model"),
+    inferenceProfile: text("inference_profile"),
+    inferenceProfileSource: text("inference_profile_source"),
+  },
+  (table) => [
+    index("idx_skill_loaded_events_created_at_id").on(
+      table.createdAt,
+      table.id,
+    ),
+  ],
+);
+
 export const traceEvents = sqliteTable(
   "trace_events",
   {

package/src/memory/skill-loaded-events-store.test.ts

@@ -0,0 +1,160 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Silence the logger.
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+let collectUsageData = true;
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+    collectUsageData,
+  }),
+}));
+
+import { getDb } from "./db-connection.js";
+import { initializeDb } from "./db-init.js";
+import { skillLoadedEvents } from "./schema.js";
+import {
+  queryUnreportedSkillLoadedEvents,
+  recordSkillLoadedEvent,
+} from "./skill-loaded-events-store.js";
+
+initializeDb();
+
+function insertEvent(
+  id: string,
+  createdAt: number,
+  skillName = "web-research",
+): void {
+  getDb().insert(skillLoadedEvents).values({ id, createdAt, skillName }).run();
+}
+
+describe("skill-loaded-events-store", () => {
+  beforeEach(() => {
+    collectUsageData = true;
+    getDb().delete(skillLoadedEvents).run();
+  });
+
+  test("honors the collectUsageData opt-out (records nothing)", () => {
+    collectUsageData = false;
+    recordSkillLoadedEvent({ skillName: "web-research" });
+    expect(queryUnreportedSkillLoadedEvents(0, undefined, 10)).toHaveLength(0);
+  });
+
+  test("record + query round-trips all fields", () => {
+    recordSkillLoadedEvent({
+      conversationId: "conv-xyz",
+      skillName: "web-research",
+      skillUpdatedAt: "2026-06-01T00:00:00.000Z",
+      provider: "anthropic",
+      model: "model-a",
+      inferenceProfile: "balanced",
+      inferenceProfileSource: "active-profile",
+    });
+
+    const rows = queryUnreportedSkillLoadedEvents(0, undefined, 10);
+    expect(rows).toHaveLength(1);
+    const row = rows[0]!;
+    expect(row.id).toBeString();
+    expect(row.createdAt).toBeGreaterThan(0);
+    expect(row).toMatchObject({
+      conversationId: "conv-xyz",
+      skillName: "web-research",
+      skillUpdatedAt: "2026-06-01T00:00:00.000Z",
+      provider: "anthropic",
+      model: "model-a",
+      inferenceProfile: "balanced",
+      inferenceProfileSource: "active-profile",
+    });
+  });
+
+  test("optional fields persist as null", () => {
+    recordSkillLoadedEvent({ skillName: "tasks" });
+
+    const rows = queryUnreportedSkillLoadedEvents(0, undefined, 10);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      skillName: "tasks",
+      conversationId: null,
+      skillUpdatedAt: null,
+      provider: null,
+      model: null,
+      inferenceProfile: null,
+      inferenceProfileSource: null,
+    });
+  });
+
+  test("returns rows in (createdAt, id) order", () => {
+    insertEvent("sle-b", 2000);
+    insertEvent("sle-a", 1000);
+
+    const rows = queryUnreportedSkillLoadedEvents(0, undefined, 100);
+    expect(rows.map((r) => r.id)).toEqual(["sle-a", "sle-b"]);
+  });
+
+  test("query advances past the compound (createdAt, id) cursor", () => {
+    // Two rows in the same millisecond: pagination must use the id
+    // tiebreaker to make forward progress, not loop.
+    insertEvent("sle-1", 5000);
+    insertEvent("sle-2", 5000);
+    insertEvent("sle-3", 6000);
+
+    const first = queryUnreportedSkillLoadedEvents(0, undefined, 1);
+    expect(first.map((r) => r.id)).toEqual(["sle-1"]);
+
+    const second = queryUnreportedSkillLoadedEvents(
+      first[0]!.createdAt,
+      first[0]!.id,
+      100,
+    );
+    expect(second.map((r) => r.id)).toEqual(["sle-2", "sle-3"]);
+
+    // Without an id cursor the timestamp-only branch is used.
+    expect(
+      queryUnreportedSkillLoadedEvents(5000, undefined, 100).map((r) => r.id),
+    ).toEqual(["sle-3"]);
+
+    // Cursor past the last row returns nothing.
+    const last = second[second.length - 1]!;
+    expect(
+      queryUnreportedSkillLoadedEvents(last.createdAt, last.id, 100).length,
+    ).toBe(0);
+  });
+
+  test("resumes from a persisted watermark without re-reporting", () => {
+    insertEvent("sle-w1", 1000);
+    insertEvent("sle-w2", 2000);
+
+    const batch = queryUnreportedSkillLoadedEvents(0, undefined, 100);
+    const watermark = batch[batch.length - 1]!;
+
+    insertEvent("sle-w3", 3000);
+
+    const resumed = queryUnreportedSkillLoadedEvents(
+      watermark.createdAt,
+      watermark.id,
+      100,
+    );
+    expect(resumed.map((r) => r.id)).toEqual(["sle-w3"]);
+  });
+
+  test("honors the limit", () => {
+    insertEvent("sle-l1", 1000);
+    insertEvent("sle-l2", 2000);
+    insertEvent("sle-l3", 3000);
+
+    const rows = queryUnreportedSkillLoadedEvents(0, undefined, 2);
+    expect(rows.map((r) => r.id)).toEqual(["sle-l1", "sle-l2"]);
+  });
+});

package/src/memory/skill-loaded-events-store.ts

@@ -0,0 +1,95 @@
+import { and, asc, eq, gt, or } from "drizzle-orm";
+import { v4 as uuid } from "uuid";
+
+import { getConfig } from "../config/loader.js";
+import type { UsageAttributionColumns } from "../usage/attribution.js";
+import { getDb } from "./db-connection.js";
+import { skillLoadedEvents } from "./schema.js";
+
+/**
+ * Input for one `skill_loaded` telemetry event. Metadata only — never skill
+ * output or conversation content. The attribution columns reuse the shared
+ * nullable shape from `toAttributionColumns` so producers can spread it
+ * directly; null and absent both persist as NULL.
+ */
+export interface SkillLoadedEventRecord extends Partial<UsageAttributionColumns> {
+  conversationId?: string;
+  skillName: string;
+  /** ISO 8601 timestamp from the merged skill catalog, when known. */
+  skillUpdatedAt?: string;
+}
+
+/** A persisted skill_loaded event row. */
+export interface SkillLoadedEvent {
+  id: string;
+  createdAt: number;
+  conversationId: string | null;
+  skillName: string;
+  skillUpdatedAt: string | null;
+  provider: string | null;
+  model: string | null;
+  inferenceProfile: string | null;
+  inferenceProfileSource: string | null;
+}
+
+/**
+ * Record a `skill_loaded` telemetry event for a skill activation. No-ops when
+ * usage data collection is disabled (the event is dropped to honor the
+ * opt-out, matching the rest of telemetry).
+ */
+export function recordSkillLoadedEvent(record: SkillLoadedEventRecord): void {
+  if (!getConfig().collectUsageData) return;
+  const db = getDb();
+  db.insert(skillLoadedEvents)
+    .values({
+      id: uuid(),
+      createdAt: Date.now(),
+      conversationId: record.conversationId,
+      skillName: record.skillName,
+      skillUpdatedAt: record.skillUpdatedAt,
+      provider: record.provider,
+      model: record.model,
+      inferenceProfile: record.inferenceProfile,
+      inferenceProfileSource: record.inferenceProfileSource,
+    })
+    .run();
+}
+
+/**
+ * Query skill_loaded events that haven't been reported to telemetry yet.
+ * Uses a compound cursor (createdAt + id) for reliable watermarking.
+ */
+export function queryUnreportedSkillLoadedEvents(
+  afterCreatedAt: number,
+  afterId: string | undefined,
+  limit: number,
+): SkillLoadedEvent[] {
+  const db = getDb();
+  return db
+    .select({
+      id: skillLoadedEvents.id,
+      createdAt: skillLoadedEvents.createdAt,
+      conversationId: skillLoadedEvents.conversationId,
+      skillName: skillLoadedEvents.skillName,
+      skillUpdatedAt: skillLoadedEvents.skillUpdatedAt,
+      provider: skillLoadedEvents.provider,
+      model: skillLoadedEvents.model,
+      inferenceProfile: skillLoadedEvents.inferenceProfile,
+      inferenceProfileSource: skillLoadedEvents.inferenceProfileSource,
+    })
+    .from(skillLoadedEvents)
+    .where(
+      afterId
+        ? or(
+            gt(skillLoadedEvents.createdAt, afterCreatedAt),
+            and(
+              eq(skillLoadedEvents.createdAt, afterCreatedAt),
+              gt(skillLoadedEvents.id, afterId),
+            ),
+          )
+        : gt(skillLoadedEvents.createdAt, afterCreatedAt),
+    )
+    .orderBy(asc(skillLoadedEvents.createdAt), asc(skillLoadedEvents.id))
+    .limit(limit)
+    .all();
+}