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

package/src/persistence/migrations/__tests__/315-create-a2a-invites.test.ts

@@ -0,0 +1,161 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateCreateA2aInvitesTable } from "../315-create-a2a-invites.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  return drizzle(sqlite, { schema });
+}
+
+function createSourceTable(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE assistant_ingress_invites (
+      id TEXT PRIMARY KEY,
+      source_channel TEXT NOT NULL,
+      token_hash TEXT NOT NULL,
+      source_conversation_id TEXT,
+      note TEXT,
+      max_uses INTEGER NOT NULL DEFAULT 1,
+      use_count INTEGER NOT NULL DEFAULT 0,
+      expires_at INTEGER NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      redeemed_by_external_user_id TEXT,
+      redeemed_by_external_chat_id TEXT,
+      redeemed_at INTEGER,
+      expected_external_user_id TEXT,
+      voice_code_hash TEXT,
+      voice_code_digits INTEGER,
+      invite_code_hash TEXT,
+      friend_name TEXT,
+      guardian_name TEXT,
+      contact_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+}
+
+function seedInvite(
+  raw: Database,
+  opts: {
+    id: string;
+    sourceChannel: string;
+    status?: string;
+    useCount?: number;
+    redeemedBy?: string | null;
+    redeemedAt?: number | null;
+  },
+): void {
+  raw.run(
+    `INSERT INTO assistant_ingress_invites
+       (id, source_channel, token_hash, max_uses, use_count, expires_at,
+        status, redeemed_by_external_user_id, redeemed_at, contact_id,
+        created_at, updated_at)
+     VALUES (?, ?, ?, 1, ?, 9999999999999, ?, ?, ?, ?, 1000, 1000)`,
+    [
+      opts.id,
+      opts.sourceChannel,
+      `hash-${opts.id}`,
+      opts.useCount ?? 0,
+      opts.status ?? "active",
+      opts.redeemedBy ?? null,
+      opts.redeemedAt ?? null,
+      `contact-${opts.id}`,
+    ],
+  );
+}
+
+interface A2aInviteRow {
+  id: string;
+  token_hash: string;
+  contact_id: string;
+  max_uses: number;
+  use_count: number;
+  status: string;
+  redeemed_by_external_user_id: string | null;
+  redeemed_at: number | null;
+}
+
+function listA2aInvites(raw: Database): A2aInviteRow[] {
+  return raw
+    .prepare(`SELECT * FROM a2a_invites ORDER BY id`)
+    .all() as A2aInviteRow[];
+}
+
+describe("migration 315 — create a2a_invites", () => {
+  test("creates the table and copies only a2a rows from assistant_ingress_invites", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    createSourceTable(raw);
+    seedInvite(raw, { id: "inv-a2a-1", sourceChannel: "a2a" });
+    seedInvite(raw, {
+      id: "inv-a2a-2",
+      sourceChannel: "a2a",
+      status: "redeemed",
+      useCount: 1,
+      redeemedBy: "acceptor-1",
+      redeemedAt: 2000,
+    });
+    seedInvite(raw, { id: "inv-telegram", sourceChannel: "telegram" });
+    seedInvite(raw, { id: "inv-phone", sourceChannel: "phone" });
+
+    migrateCreateA2aInvitesTable(db);
+
+    const copied = listA2aInvites(raw);
+    expect(copied.map((r) => r.id)).toEqual(["inv-a2a-1", "inv-a2a-2"]);
+    expect(copied[0]).toMatchObject({
+      token_hash: "hash-inv-a2a-1",
+      contact_id: "contact-inv-a2a-1",
+      max_uses: 1,
+      use_count: 0,
+      status: "active",
+      redeemed_by_external_user_id: null,
+      redeemed_at: null,
+    });
+    expect(copied[1]).toMatchObject({
+      status: "redeemed",
+      use_count: 1,
+      redeemed_by_external_user_id: "acceptor-1",
+      redeemed_at: 2000,
+    });
+
+    // Source rows are left untouched — the table drops wholesale later.
+    const sourceCount = raw
+      .prepare(`SELECT COUNT(*) AS n FROM assistant_ingress_invites`)
+      .get() as { n: number };
+    expect(sourceCount.n).toBe(4);
+  });
+
+  test("is idempotent — re-running does not duplicate or clobber rows", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    createSourceTable(raw);
+    seedInvite(raw, { id: "inv-a2a-1", sourceChannel: "a2a" });
+
+    migrateCreateA2aInvitesTable(db);
+
+    // Mutate the copied row so a re-run's INSERT OR IGNORE must not clobber it.
+    raw.run(`UPDATE a2a_invites SET status = 'redeemed', use_count = 1`);
+
+    migrateCreateA2aInvitesTable(db);
+
+    const rows = listA2aInvites(raw);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]!.status).toBe("redeemed");
+    expect(rows[0]!.use_count).toBe(1);
+  });
+
+  test("creates an empty table when assistant_ingress_invites does not exist", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    expect(() => migrateCreateA2aInvitesTable(db)).not.toThrow();
+    expect(listA2aInvites(raw)).toHaveLength(0);
+  });
+});

package/src/persistence/migrations/__tests__/316-drop-contact-channels-invite-id.test.ts

@@ -0,0 +1,156 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateDropContactChannelInviteId } from "../316-drop-contact-channels-invite-id.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  return drizzle(sqlite, { schema });
+}
+
+/** Seed the pre-migration schema: the invite table plus contact_channels with invite_id. */
+function bootstrapLegacyTables(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE assistant_ingress_invites (
+      id TEXT PRIMARY KEY,
+      source_channel TEXT NOT NULL,
+      token_hash TEXT NOT NULL,
+      contact_id TEXT NOT NULL,
+      expires_at INTEGER NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE TABLE contact_channels (
+      id TEXT PRIMARY KEY,
+      contact_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      address TEXT NOT NULL,
+      is_primary INTEGER NOT NULL DEFAULT 0,
+      external_chat_id TEXT,
+      invite_id TEXT,
+      last_seen_at INTEGER,
+      interaction_count INTEGER NOT NULL DEFAULT 0,
+      last_interaction INTEGER,
+      updated_at INTEGER,
+      created_at INTEGER NOT NULL
+    )
+  `);
+}
+
+function tableExists(raw: Database, table: string): boolean {
+  return !!raw
+    .prepare(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(table);
+}
+
+function columnNames(raw: Database, table: string): Set<string> {
+  const cols = raw.prepare(`PRAGMA table_info(${table})`).all() as {
+    name: string;
+  }[];
+  return new Set(cols.map((c) => c.name));
+}
+
+describe("migration 316 — drop contact_channels.invite_id", () => {
+  test("drops the invite_id column, preserving channel data", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapLegacyTables(raw);
+
+    raw.run(
+      `INSERT INTO contact_channels
+         (id, contact_id, type, address, external_chat_id, invite_id, interaction_count, created_at)
+       VALUES ('ch-1', 'ct-1', 'telegram', 'user-1', 'chat-1', 'inv-1', 7, 1000)`,
+    );
+
+    migrateDropContactChannelInviteId(db);
+
+    const cols = columnNames(raw, "contact_channels");
+    expect(cols.has("invite_id")).toBe(false);
+    // Identity/INFO columns survive.
+    for (const col of [
+      "id",
+      "contact_id",
+      "type",
+      "address",
+      "is_primary",
+      "external_chat_id",
+      "last_seen_at",
+      "interaction_count",
+      "last_interaction",
+    ]) {
+      expect(cols.has(col)).toBe(true);
+    }
+
+    const row = raw
+      .prepare(
+        `SELECT contact_id, type, address, external_chat_id, interaction_count
+           FROM contact_channels WHERE id = 'ch-1'`,
+      )
+      .get() as Record<string, unknown>;
+    expect(row).toEqual({
+      contact_id: "ct-1",
+      type: "telegram",
+      address: "user-1",
+      external_chat_id: "chat-1",
+      interaction_count: 7,
+    });
+  });
+
+  test("leaves assistant_ingress_invites intact (gateway m0010 drops it after the m0009 backfill)", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapLegacyTables(raw);
+
+    raw.run(
+      `INSERT INTO assistant_ingress_invites
+         (id, source_channel, token_hash, contact_id, expires_at, created_at, updated_at)
+       VALUES ('inv-1', 'telegram', 'hash-1', 'ct-1', 9999999999999, 1000, 1000)`,
+    );
+
+    migrateDropContactChannelInviteId(db);
+
+    expect(tableExists(raw, "assistant_ingress_invites")).toBe(true);
+    const invite = raw
+      .prepare(
+        `SELECT token_hash FROM assistant_ingress_invites WHERE id = 'inv-1'`,
+      )
+      .get() as { token_hash: string };
+    expect(invite.token_hash).toBe("hash-1");
+  });
+
+  test("is idempotent — re-running after the drop does not throw", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapLegacyTables(raw);
+
+    migrateDropContactChannelInviteId(db);
+    expect(() => migrateDropContactChannelInviteId(db)).not.toThrow();
+
+    expect(columnNames(raw, "contact_channels").has("invite_id")).toBe(false);
+  });
+
+  test("no-ops on a fresh schema without the invite_id column", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    raw.exec(/*sql*/ `
+      CREATE TABLE contact_channels (
+        id TEXT PRIMARY KEY,
+        contact_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        address TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      )
+    `);
+
+    expect(() => migrateDropContactChannelInviteId(db)).not.toThrow();
+    expect(columnNames(raw, "contact_channels").has("invite_id")).toBe(false);
+  });
+});

package/src/persistence/migrations/__tests__/318-drop-contact-channel-telemetry.test.ts

@@ -0,0 +1,134 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateDropContactChannelTelemetry } from "../318-drop-contact-channel-telemetry.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  return drizzle(sqlite, { schema });
+}
+
+/** Seed the pre-migration schema: contact_channels with the telemetry columns. */
+function bootstrapLegacyTable(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE contact_channels (
+      id TEXT PRIMARY KEY,
+      contact_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      address TEXT NOT NULL,
+      is_primary INTEGER NOT NULL DEFAULT 0,
+      external_chat_id TEXT,
+      last_seen_at INTEGER,
+      interaction_count INTEGER NOT NULL DEFAULT 0,
+      last_interaction INTEGER,
+      updated_at INTEGER,
+      created_at INTEGER NOT NULL
+    )
+  `);
+}
+
+function columnNames(raw: Database, table: string): Set<string> {
+  const cols = raw.prepare(`PRAGMA table_info(${table})`).all() as {
+    name: string;
+  }[];
+  return new Set(cols.map((c) => c.name));
+}
+
+const TELEMETRY_COLUMNS = [
+  "last_seen_at",
+  "interaction_count",
+  "last_interaction",
+];
+
+describe("migration 318 — drop contact_channels telemetry columns", () => {
+  test("drops all three telemetry columns, preserving other channel data", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapLegacyTable(raw);
+
+    raw.run(
+      `INSERT INTO contact_channels
+         (id, contact_id, type, address, is_primary, external_chat_id,
+          last_seen_at, interaction_count, last_interaction, updated_at, created_at)
+       VALUES ('ch-1', 'ct-1', 'telegram', 'user-1', 1, 'chat-1',
+          5000, 7, 6000, 8000, 1000)`,
+    );
+
+    migrateDropContactChannelTelemetry(db);
+
+    const cols = columnNames(raw, "contact_channels");
+    for (const col of TELEMETRY_COLUMNS) {
+      expect(cols.has(col)).toBe(false);
+    }
+    // Identity/routing columns survive.
+    for (const col of [
+      "id",
+      "contact_id",
+      "type",
+      "address",
+      "is_primary",
+      "external_chat_id",
+      "updated_at",
+      "created_at",
+    ]) {
+      expect(cols.has(col)).toBe(true);
+    }
+
+    const row = raw
+      .prepare(
+        `SELECT id, contact_id, type, address, is_primary, external_chat_id,
+                updated_at, created_at
+           FROM contact_channels WHERE id = 'ch-1'`,
+      )
+      .get() as Record<string, unknown>;
+    expect(row).toEqual({
+      id: "ch-1",
+      contact_id: "ct-1",
+      type: "telegram",
+      address: "user-1",
+      is_primary: 1,
+      external_chat_id: "chat-1",
+      updated_at: 8000,
+      created_at: 1000,
+    });
+  });
+
+  test("is idempotent — re-running after the drop does not throw", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapLegacyTable(raw);
+
+    migrateDropContactChannelTelemetry(db);
+    expect(() => migrateDropContactChannelTelemetry(db)).not.toThrow();
+
+    const cols = columnNames(raw, "contact_channels");
+    for (const col of TELEMETRY_COLUMNS) {
+      expect(cols.has(col)).toBe(false);
+    }
+  });
+
+  test("no-ops on a fresh schema without the telemetry columns", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    raw.exec(/*sql*/ `
+      CREATE TABLE contact_channels (
+        id TEXT PRIMARY KEY,
+        contact_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        address TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      )
+    `);
+
+    expect(() => migrateDropContactChannelTelemetry(db)).not.toThrow();
+    const cols = columnNames(raw, "contact_channels");
+    for (const col of TELEMETRY_COLUMNS) {
+      expect(cols.has(col)).toBe(false);
+    }
+  });
+});

package/src/persistence/migrations/__tests__/migration-prefix-guard.test.ts

@@ -0,0 +1,99 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+/**
+ * Migration filename prefixes are the at-a-glance ordering signal for this
+ * directory. Execution order and checkpointing are driven by the
+ * `migrationSteps` array in `steps.ts` (checkpointed by function name), so a
+ * duplicate prefix does not break installs — but it makes two unrelated
+ * migrations read as one step and hides where each sits in the sequence. The
+ * groups below shipped sharing a prefix and are frozen as-is (migrations are
+ * append-only and never renamed): a new migration must take a fresh, unused
+ * prefix, and no file may join one of these groups.
+ */
+const FROZEN_DUPLICATE_PREFIX_GROUPS: Record<string, readonly string[]> = {
+  "028": [
+    "028-call-session-mode.ts",
+    "028-notification-delivery-client-ack.ts",
+  ],
+  "030": [
+    "030-guardian-action-followup.ts",
+    "030-guardian-verification-purpose.ts",
+  ],
+  "032": [
+    "032-guardian-delivery-conversation-index.ts",
+    "032-notification-delivery-thread-decision.ts",
+  ],
+  "196": [
+    "196-messages-conversation-created-at-index.ts",
+    "196-strip-integration-prefix-from-provider-keys.ts",
+  ],
+  "202": [
+    "202-drop-callback-transport-column.ts",
+    "202-memory-graph-tables.ts",
+  ],
+  "206": [
+    "206-memory-graph-node-edits.ts",
+    "206-scrub-corrupted-image-attachments.ts",
+  ],
+  "235": ["235-llm-usage-attribution.ts", "235-slack-compaction-watermark.ts"],
+  "253": [
+    "253-conversation-last-notified-profile.ts",
+    "253-document-comments.ts",
+  ],
+  "270": [
+    "270-messages-role-created-at-index.ts",
+    "270-schedule-description.ts",
+    "270-schedule-source-conversation.ts",
+  ],
+};
+
+const MIGRATION_FILE_PATTERN = /^(\d+[a-z]?)-.+\.ts$/;
+
+function collectPrefixGroups(): Map<string, string[]> {
+  const migrationsDir = join(import.meta.dir, "..");
+  const groups = new Map<string, string[]>();
+  for (const fileName of readdirSync(migrationsDir).sort()) {
+    if (fileName.endsWith(".test.ts")) {
+      continue;
+    }
+    const match = MIGRATION_FILE_PATTERN.exec(fileName);
+    if (!match) {
+      continue;
+    }
+    const prefix = match[1];
+    const group = groups.get(prefix) ?? [];
+    group.push(fileName);
+    groups.set(prefix, group);
+  }
+  return groups;
+}
+
+describe("migration filename prefix guard", () => {
+  test("every new migration takes a fresh numeric prefix", () => {
+    const violations: string[] = [];
+    for (const [prefix, files] of collectPrefixGroups()) {
+      if (files.length < 2 || prefix in FROZEN_DUPLICATE_PREFIX_GROUPS) {
+        continue;
+      }
+      violations.push(`${prefix}: ${files.join(", ")}`);
+    }
+    expect(
+      violations,
+      "Migration filename prefixes collide. Renumber the new migration to the next unused prefix.",
+    ).toEqual([]);
+  });
+
+  test("frozen duplicate groups keep their exact membership", () => {
+    const groups = collectPrefixGroups();
+    for (const [prefix, frozen] of Object.entries(
+      FROZEN_DUPLICATE_PREFIX_GROUPS,
+    )) {
+      expect(
+        groups.get(prefix)?.sort() ?? [],
+        `Frozen duplicate-prefix group ${prefix} changed. Migrations are append-only — restore the file or update the frozen list only for a deliberate rename.`,
+      ).toEqual([...frozen].sort());
+    }
+  });
+});

package/src/persistence/raw-query.ts

@@ -23,9 +23,6 @@
  * - **Atomic in-place updates**: Expressions like `SET count = count + 1` can
  *   use Drizzle's `sql` template, but raw SQL is acceptable when simpler.
  *
- * - **Bulk deletes across virtual tables**: Operations like clearing
- *   messages_fts that reference virtual tables not modeled in Drizzle.
- *
  * For everything else — selects, inserts, updates, deletes, joins, aggregations,
  * filtering, ordering, pagination — use Drizzle.
  */
@@ -39,19 +36,37 @@ type SqlParam = SQLQueryBindings;
 // ---------------------------------------------------------------------------
 // Typed query helpers (global Drizzle instance)
 // ---------------------------------------------------------------------------
+//
+// Every connection returned by the db-connection accessor is wrapped by
+// `wrapSqliteForSlowQueryLogging`, which times each `.get()/.all()/.run()`
+// execution and logs the slow ones. Each helper takes a required `label` first
+// argument — a short `domain:operation` attribution tag (e.g.
+// `"schedule:claimDue"`) — routed through `.label()` so a slow raw query names
+// its call site in the log, not just its SQL. The wrapper caches the timed proxy
+// per (statement, label), so repeated calls stay allocation-light.
 
 /** Execute a raw SQL query and return a single typed row, or null if no match. */
-export function rawGet<T>(sql: string, ...params: SqlParam[]): T | null {
+export function rawGet<T>(
+  label: string,
+  sql: string,
+  ...params: SqlParam[]
+): T | null {
   return (
     (getSqlite()
+      .label(label)
       .query(sql)
       .get(...params) as T) ?? null
   );
 }
 
 /** Execute a raw SQL query and return all matching rows with type safety. */
-export function rawAll<T>(sql: string, ...params: SqlParam[]): T[] {
+export function rawAll<T>(
+  label: string,
+  sql: string,
+  ...params: SqlParam[]
+): T[] {
   return getSqlite()
+    .label(label)
     .query(sql)
     .all(...params) as T[];
 }
@@ -60,8 +75,13 @@ export function rawAll<T>(sql: string, ...params: SqlParam[]): T[] {
  * Execute a raw SQL statement (INSERT/UPDATE/DELETE) and return the number
  * of affected rows.
  */
-export function rawRun(sql: string, ...params: SqlParam[]): number {
+export function rawRun(
+  label: string,
+  sql: string,
+  ...params: SqlParam[]
+): number {
   getSqlite()
+    .label(label)
     .query(sql)
     .run(...params);
   return rawChanges();
@@ -101,16 +121,28 @@ function logsSqlite(): Database {
 }
 
 /** {@link rawAll} against the memory connection. */
-export function rawMemoryAll<T>(sql: string, ...params: SqlParam[]): T[] {
+export function rawMemoryAll<T>(
+  label: string,
+  sql: string,
+  ...params: SqlParam[]
+): T[] {
   return memorySqlite()
+    .label(label)
     .query(sql)
     .all(...params) as T[];
 }
 
 /** {@link rawRun} against the memory connection. */
-export function rawMemoryRun(sql: string, ...params: SqlParam[]): number {
+export function rawMemoryRun(
+  label: string,
+  sql: string,
+  ...params: SqlParam[]
+): number {
   const sqlite = memorySqlite();
-  sqlite.query(sql).run(...params);
+  sqlite
+    .label(label)
+    .query(sql)
+    .run(...params);
   return (sqlite.query("SELECT changes() AS c").get() as { c: number }).c;
 }
 
@@ -121,9 +153,16 @@ export function rawMemoryChanges(): number {
 }
 
 /** {@link rawRun} against the logs connection. */
-export function rawLogsRun(sql: string, ...params: SqlParam[]): number {
+export function rawLogsRun(
+  label: string,
+  sql: string,
+  ...params: SqlParam[]
+): number {
   const sqlite = logsSqlite();
-  sqlite.query(sql).run(...params);
+  sqlite
+    .label(label)
+    .query(sql)
+    .run(...params);
   return (sqlite.query("SELECT changes() AS c").get() as { c: number }).c;
 }
 

package/src/persistence/schema/a2a.ts

@@ -1,5 +1,19 @@
 import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
 
+export const a2aInvites = sqliteTable("a2a_invites", {
+  id: text("id").primaryKey(),
+  tokenHash: text("token_hash").notNull(),
+  contactId: text("contact_id").notNull(),
+  maxUses: integer("max_uses").notNull().default(1),
+  useCount: integer("use_count").notNull().default(0),
+  expiresAt: integer("expires_at").notNull(),
+  status: text("status").notNull().default("active"),
+  redeemedByExternalUserId: text("redeemed_by_external_user_id"),
+  redeemedAt: integer("redeemed_at"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
 export const a2aTasks = sqliteTable("a2a_tasks", {
   id: text("id").primaryKey(),
   contextId: text("context_id"),