@vellumai/assistant 0.6.4 → 0.6.6

package/src/memory/job-handlers/conversation-starters.ts

@@ -60,7 +60,7 @@ export function buildMemoryRollup(scopeId: string): string {
         and(
           sql`${memoryGraphNodes.fidelity} != 'gone'`,
           eq(memoryGraphNodes.scopeId, scopeId),
-        )
+        ),
       )
       .orderBy(desc(memoryGraphNodes.significance))
       .limit(60)
@@ -111,19 +111,21 @@ function buildNewItemsDiff(scopeId: string): string {
      WHERE fidelity != 'gone' AND scope_id = ? AND created > ?
      ORDER BY created DESC LIMIT 20`,
     scopeId,
-    lastGenAt
+    lastGenAt,
   );
 
   if (newItems.length === 0) return "";
 
   return (
     "## New since last generation\n" +
-    newItems.map((i) => {
-      const nl = i.content.indexOf("\n");
-      const subject = nl >= 0 ? i.content.slice(0, nl) : i.content;
-      const statement = nl >= 0 ? i.content.slice(nl + 1) : i.content;
-      return `- (${i.kind}) ${subject}: ${statement}`;
-    }).join("\n")
+    newItems
+      .map((i) => {
+        const nl = i.content.indexOf("\n");
+        const subject = nl >= 0 ? i.content.slice(0, nl) : i.content;
+        const statement = nl >= 0 ? i.content.slice(nl + 1) : i.content;
+        return `- (${i.kind}) ${subject}: ${statement}`;
+      })
+      .join("\n")
   );
 }
 
@@ -162,7 +164,8 @@ export const CONVERSATION_STARTER_CATEGORIES = [
   "integration",
 ] as const;
 
-export type ConversationStarterCategory = typeof CONVERSATION_STARTER_CATEGORIES[number];
+export type ConversationStarterCategory =
+  (typeof CONVERSATION_STARTER_CATEGORIES)[number];
 
 interface GeneratedStarter {
   label: string;
@@ -171,7 +174,7 @@ interface GeneratedStarter {
 }
 
 async function generateStarters(scopeId: string): Promise<GeneratedStarter[]> {
-  const provider = await getConfiguredProvider();
+  const provider = await getConfiguredProvider("conversationStarters");
   if (!provider) {
     log.info("No configured provider for conversation starters generation");
     return [];
@@ -288,7 +291,7 @@ Bad → Good (incomplete phrase → complete):
     const response = await provider.sendMessage(
       [
         userMessage(
-          "Generate personalized conversation starters based on my context."
+          "Generate personalized conversation starters based on my context.",
         ),
       ],
       [
@@ -330,7 +333,7 @@ Bad → Good (incomplete phrase → complete):
       systemPrompt,
       {
         config: {
-          modelIntent: "quality-optimized",
+          callSite: "conversationStarters" as const,
           max_tokens: 2048,
           tool_choice: {
             type: "tool" as const,
@@ -338,14 +341,14 @@ Bad → Good (incomplete phrase → complete):
           },
         },
         signal,
-      }
+      },
     );
     cleanup();
 
     const toolBlock = extractToolUse(response);
     if (!toolBlock) {
       log.warn(
-        "No tool_use block in conversation starters generation response"
+        "No tool_use block in conversation starters generation response",
       );
       return [];
     }
@@ -363,7 +366,7 @@ Bad → Good (incomplete phrase → complete):
           s.label.length > 0 &&
           s.label.length <= 40 &&
           typeof s.prompt === "string" &&
-          s.prompt.length > 0
+          s.prompt.length > 0,
       )
       .slice(0, 4)
       .map((s) => ({
@@ -372,7 +375,7 @@ Bad → Good (incomplete phrase → complete):
         category:
           typeof s.category === "string" &&
           (CONVERSATION_STARTER_CATEGORIES as readonly string[]).includes(
-            s.category
+            s.category,
           )
             ? s.category
             : "productivity",
@@ -386,7 +389,7 @@ Bad → Good (incomplete phrase → complete):
 // ── Job handler ───────────────────────────────────────────────────
 
 export async function generateConversationStartersJob(
-  job: MemoryJob
+  job: MemoryJob,
 ): Promise<void> {
   const scopeId = asString(job.payload.scopeId) ?? "default";
 
@@ -419,7 +422,7 @@ export async function generateConversationStartersJob(
         and(
           sql`${memoryGraphNodes.fidelity} != 'gone'`,
           eq(memoryGraphNodes.scopeId, scopeId),
-        )
+        ),
       )
       .groupBy(memoryGraphNodes.type)
       .all();
@@ -453,7 +456,7 @@ export async function generateConversationStartersJob(
   // Count active items for checkpoint
   const countRow = rawGet<{ c: number }>(
     `SELECT COUNT(*) AS c FROM memory_graph_nodes WHERE fidelity != 'gone' AND scope_id = ?`,
-    scopeId
+    scopeId,
   );
   const totalActive = countRow?.c ?? 0;
 
@@ -474,6 +477,6 @@ export async function generateConversationStartersJob(
 
   log.info(
     { scopeId, batch: nextBatch, count: starters.length },
-    "Generated conversation starters"
+    "Generated conversation starters",
   );
 }

package/src/memory/job-handlers/summarization.ts

@@ -161,7 +161,7 @@ async function summarizeWithLLM(
     return buildFallbackSummary(existingSummary, newContent, label);
   }
 
-  const provider = await getConfiguredProvider();
+  const provider = await getConfiguredProvider("conversationSummarization");
   if (!provider) {
     log.debug(
       { label },
@@ -189,7 +189,7 @@ async function summarizeWithLLM(
         systemPrompt,
         {
           config: {
-            modelIntent: summarizationConfig.modelIntent,
+            callSite: "conversationSummarization" as const,
             max_tokens: SUMMARY_MAX_TOKENS,
           },
           signal,

package/src/memory/job-utils.ts

@@ -147,7 +147,13 @@ export function truncate(text: string, max: number): string {
 
 export async function embedAndUpsert(
   config: AssistantConfig,
-  targetType: "segment" | "item" | "summary" | "media" | "graph_node",
+  targetType:
+    | "segment"
+    | "item"
+    | "summary"
+    | "media"
+    | "graph_node"
+    | "pkb_file",
   targetId: string,
   input: EmbeddingInput,
   extraPayload?: Record<string, unknown>,

package/src/memory/jobs/embed-pkb-file.test.ts

@@ -0,0 +1,168 @@
+import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Track calls to indexPkbFile so we can assert the handler forwards payload
+// fields correctly.
+const indexPkbFileCalls: Array<{
+  pkbRoot: string;
+  absPath: string;
+  memoryScopeId: string;
+}> = [];
+
+mock.module("../pkb/pkb-index.js", () => ({
+  indexPkbFile: async (
+    pkbRoot: string,
+    absPath: string,
+    memoryScopeId: string,
+  ) => {
+    indexPkbFileCalls.push({ pkbRoot, absPath, memoryScopeId });
+  },
+}));
+
+mock.module("../../config/loader.js", () => ({
+  loadConfig: () => ({}),
+  getConfig: () => ({}),
+  invalidateConfigCache: () => {},
+}));
+
+import { DEFAULT_CONFIG } from "../../config/defaults.js";
+import type { AssistantConfig } from "../../config/types.js";
+import { getDb, initializeDb } from "../db.js";
+import {
+  claimMemoryJobs,
+  type MemoryJob,
+  type MemoryJobType,
+} from "../jobs-store.js";
+import { memoryJobs } from "../schema.js";
+import { embedPkbFileJob, enqueuePkbIndexJob } from "./embed-pkb-file.js";
+
+const TEST_CONFIG: AssistantConfig = DEFAULT_CONFIG;
+
+function makeJob(payload: Record<string, unknown>): MemoryJob {
+  return {
+    id: "job-1",
+    type: "embed_pkb_file",
+    payload,
+    status: "running",
+    attempts: 0,
+    deferrals: 0,
+    runAfter: 0,
+    lastError: null,
+    startedAt: Date.now(),
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+}
+
+describe("embedPkbFileJob", () => {
+  beforeAll(() => {
+    initializeDb();
+  });
+
+  beforeEach(() => {
+    indexPkbFileCalls.length = 0;
+    const db = getDb();
+    db.delete(memoryJobs).run();
+  });
+
+  test("calls indexPkbFile with payload fields", async () => {
+    await embedPkbFileJob(
+      makeJob({
+        pkbRoot: "/pkb/root",
+        absPath: "/pkb/root/note.md",
+        memoryScopeId: "scope-123",
+      }),
+      TEST_CONFIG,
+    );
+
+    expect(indexPkbFileCalls).toHaveLength(1);
+    expect(indexPkbFileCalls[0]).toEqual({
+      pkbRoot: "/pkb/root",
+      absPath: "/pkb/root/note.md",
+      memoryScopeId: "scope-123",
+    });
+  });
+
+  test("skips when pkbRoot is missing", async () => {
+    await embedPkbFileJob(
+      makeJob({ absPath: "/pkb/root/note.md", memoryScopeId: "scope-123" }),
+      TEST_CONFIG,
+    );
+    expect(indexPkbFileCalls).toHaveLength(0);
+  });
+
+  test("skips when absPath is missing", async () => {
+    await embedPkbFileJob(
+      makeJob({ pkbRoot: "/pkb/root", memoryScopeId: "scope-123" }),
+      TEST_CONFIG,
+    );
+    expect(indexPkbFileCalls).toHaveLength(0);
+  });
+
+  test("skips when memoryScopeId is missing", async () => {
+    await embedPkbFileJob(
+      makeJob({ pkbRoot: "/pkb/root", absPath: "/pkb/root/note.md" }),
+      TEST_CONFIG,
+    );
+    expect(indexPkbFileCalls).toHaveLength(0);
+  });
+});
+
+describe("enqueuePkbIndexJob", () => {
+  beforeAll(() => {
+    initializeDb();
+  });
+
+  beforeEach(() => {
+    indexPkbFileCalls.length = 0;
+    const db = getDb();
+    db.delete(memoryJobs).run();
+  });
+
+  test("enqueues a pending embed_pkb_file job with payload", () => {
+    const id = enqueuePkbIndexJob({
+      pkbRoot: "/pkb/root",
+      absPath: "/pkb/root/note.md",
+      memoryScopeId: "scope-abc",
+    });
+    expect(id).toBeTruthy();
+
+    const claimed = claimMemoryJobs(10);
+    expect(claimed).toHaveLength(1);
+    const [job] = claimed;
+    const expectedType: MemoryJobType = "embed_pkb_file";
+    expect(job.type).toBe(expectedType);
+    expect(job.payload).toEqual({
+      pkbRoot: "/pkb/root",
+      absPath: "/pkb/root/note.md",
+      memoryScopeId: "scope-abc",
+    });
+  });
+
+  test("round-trip: enqueued job dispatched to handler invokes indexPkbFile", async () => {
+    enqueuePkbIndexJob({
+      pkbRoot: "/pkb/root",
+      absPath: "/pkb/root/note.md",
+      memoryScopeId: "scope-rt",
+    });
+
+    const claimed = claimMemoryJobs(10);
+    expect(claimed).toHaveLength(1);
+    const [job] = claimed;
+    expect(job.type).toBe("embed_pkb_file");
+
+    await embedPkbFileJob(job, TEST_CONFIG);
+    expect(indexPkbFileCalls).toHaveLength(1);
+    expect(indexPkbFileCalls[0]).toEqual({
+      pkbRoot: "/pkb/root",
+      absPath: "/pkb/root/note.md",
+      memoryScopeId: "scope-rt",
+    });
+  });
+});

package/src/memory/jobs/embed-pkb-file.ts

@@ -0,0 +1,54 @@
+import type { AssistantConfig } from "../../config/types.js";
+import { asString } from "../job-utils.js";
+import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
+import { indexPkbFile } from "../pkb/pkb-index.js";
+
+/**
+ * Input shape for the `embed_pkb_file` background job.
+ */
+export interface EmbedPkbFileJobInput {
+  pkbRoot: string;
+  absPath: string;
+  memoryScopeId: string;
+}
+
+/**
+ * Job handler: read a PKB markdown file, chunk it, and upsert each chunk to
+ * Qdrant via the shared embedding pipeline. Thin wrapper around
+ * {@link indexPkbFile} so write hooks and startup reconciliation can
+ * fire-and-forget into the async job queue.
+ */
+export async function embedPkbFileJob(
+  job: MemoryJob,
+  _config: AssistantConfig,
+): Promise<void> {
+  const pkbRoot = asString(job.payload.pkbRoot);
+  const absPath = asString(job.payload.absPath);
+  const memoryScopeId = asString(job.payload.memoryScopeId);
+  if (!pkbRoot || !absPath || !memoryScopeId) return;
+
+  try {
+    await indexPkbFile(pkbRoot, absPath, memoryScopeId);
+  } catch (error) {
+    if (
+      error !== null &&
+      typeof error === "object" &&
+      "code" in error &&
+      (error as { code?: unknown }).code === "ENOENT"
+    ) {
+      return;
+    }
+    throw error;
+  }
+}
+
+/**
+ * Enqueue an `embed_pkb_file` job (async, fire-and-forget).
+ */
+export function enqueuePkbIndexJob(input: EmbedPkbFileJobInput): string {
+  return enqueueMemoryJob("embed_pkb_file", {
+    pkbRoot: input.pkbRoot,
+    absPath: input.absPath,
+    memoryScopeId: input.memoryScopeId,
+  });
+}

package/src/memory/jobs-store.ts

@@ -1,4 +1,4 @@
-import { and, asc, eq, inArray, lte, notInArray, sql } from "drizzle-orm";
+import { and, asc, eq, inArray, lte, notInArray, or, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getLogger } from "../util/logger.js";
@@ -27,6 +27,7 @@ export type MemoryJobType =
   | "embed_attachment"
   | "generate_conversation_starters"
   | "embed_graph_node"
+  | "embed_pkb_file"
   | "graph_extract"
   | "graph_decay"
   | "graph_consolidate"
@@ -41,6 +42,7 @@ const EMBED_JOB_TYPES: MemoryJobType[] = [
   "embed_media",
   "embed_attachment",
   "embed_graph_node",
+  "embed_pkb_file",
   "graph_trigger_embed",
 ];
 
@@ -165,6 +167,10 @@ export function upsertAutoAnalysisJob(
     : never,
 ): void {
   const db = dbOverride ?? getDb();
+  // Match rows with the same triggerGroup OR legacy rows without triggerGroup
+  // (from older builds that used upsertDebouncedJob before triggerGroup was
+  // introduced). Without the IS NULL fallback, the next enqueue would insert
+  // a duplicate pending row for the same conversation.
   const existing = db
     .select()
     .from(memoryJobs)
@@ -173,18 +179,53 @@ export function upsertAutoAnalysisJob(
         eq(memoryJobs.type, "conversation_analyze"),
         eq(memoryJobs.status, "pending"),
         sql`json_extract(${memoryJobs.payload}, '$.conversationId') = ${payload.conversationId}`,
-        sql`json_extract(${memoryJobs.payload}, '$.triggerGroup') = ${payload.triggerGroup}`,
+        or(
+          sql`json_extract(${memoryJobs.payload}, '$.triggerGroup') = ${payload.triggerGroup}`,
+          sql`json_extract(${memoryJobs.payload}, '$.triggerGroup') IS NULL`,
+        ),
       ),
     )
     .get();
   if (existing) {
+    // Merge triggerGroup into legacy rows so subsequent lookups use the new key.
+    const existingPayload = JSON.parse(existing.payload) as Record<
+      string,
+      unknown
+    >;
+    const needsPayloadUpdate = !existingPayload.triggerGroup;
     db.update(memoryJobs)
-      .set({ runAfter, updatedAt: Date.now() })
+      .set({
+        runAfter,
+        updatedAt: Date.now(),
+        ...(needsPayloadUpdate
+          ? {
+              payload: JSON.stringify({ ...existingPayload, ...payload }),
+            }
+          : {}),
+      })
       .where(eq(memoryJobs.id, existing.id))
       .run();
   } else {
     enqueueMemoryJob("conversation_analyze", payload, runAfter, dbOverride);
   }
+
+  // When an immediate trigger fires (batch/compaction), cancel any pending
+  // debounced row for the same conversation — the immediate analysis covers
+  // those messages, making the debounced pass redundant. Without this, both
+  // rows fire independently and double the LLM cost per batch crossing.
+  if (payload.triggerGroup === "immediate") {
+    db.update(memoryJobs)
+      .set({ status: "completed", updatedAt: Date.now() })
+      .where(
+        and(
+          eq(memoryJobs.type, "conversation_analyze"),
+          eq(memoryJobs.status, "pending"),
+          sql`json_extract(${memoryJobs.payload}, '$.conversationId') = ${payload.conversationId}`,
+          sql`json_extract(${memoryJobs.payload}, '$.triggerGroup') = 'debounced'`,
+        ),
+      )
+      .run();
+  }
 }
 
 /**

package/src/memory/jobs-worker.ts

@@ -44,6 +44,7 @@ import {
   RETRY_MAX_ATTEMPTS,
   retryDelayForAttempt,
 } from "./job-utils.js";
+import { embedPkbFileJob } from "./jobs/embed-pkb-file.js";
 import {
   claimMemoryJobs,
   completeMemoryJob,
@@ -420,6 +421,9 @@ async function processJob(
     case "embed_graph_node":
       await embedGraphNodeJob(job, config);
       return;
+    case "embed_pkb_file":
+      await embedPkbFileJob(job, config);
+      return;
     case "graph_trigger_embed":
       await embedGraphTriggerJob(job, config);
       return;

package/src/memory/migrations/041-approval-prompt-ts-tracker.ts

@@ -0,0 +1,26 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+/**
+ * Tracker for approval prompt message timestamps.
+ *
+ * Stores the (channel, chat_id, ts) tuples for delivered guardian approval
+ * prompts so only reactions on a known prompt can resolve a pending
+ * request. Persistence (rather than in-memory state) is required because
+ * the guardian approval TTL is 30 minutes, which can span a daemon
+ * restart between prompt delivery and the user's reaction.
+ */
+export function createApprovalPromptTsTrackerTable(database: DrizzleDb): void {
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS approval_prompt_ts_tracker (
+      channel TEXT NOT NULL,
+      chat_id TEXT NOT NULL,
+      ts TEXT NOT NULL,
+      expires_at INTEGER NOT NULL,
+      PRIMARY KEY (channel, chat_id, ts)
+    )
+  `);
+
+  database.run(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_approval_prompt_ts_tracker_expires ON approval_prompt_ts_tracker(expires_at)`,
+  );
+}

package/src/memory/migrations/140-backfill-usage-cache-accounting.ts

@@ -196,7 +196,7 @@ export function migrateBackfillUsageCacheAccounting(database: DrizzleDb): void {
     const requestLogsByConversation = buildRequestLogMap(requestLogRows);
     const requestOffsets = new Map<string, number>();
     const previousUsageEventCreatedAt = new Map<string, number>();
-    const pricingOverrides = getConfig().pricingOverrides;
+    const pricingOverrides = getConfig().llm.pricingOverrides;
 
     let scannedAnthropicRows = 0;
     let updatedRows = 0;

package/src/memory/migrations/149-oauth-tables.ts

@@ -15,6 +15,7 @@ export function createOAuthTables(database: DrizzleDb): void {
       base_url TEXT,
       default_scopes TEXT NOT NULL DEFAULT '[]',
       scope_policy TEXT NOT NULL DEFAULT '{}',
+      available_scopes TEXT,
       extra_params TEXT,
       callback_transport TEXT,
       loopback_port INTEGER,

package/src/memory/migrations/220-normalize-user-file-by-principal.ts

@@ -63,8 +63,8 @@ export function isAutoIncrementedUserFile(
  * Multiple contact rows may represent the same principal (one per channel:
  * desktop, phone, Slack, etc.). When a new row was created for a second
  * channel, `generateUserFileSlug(displayName)` auto-incremented to avoid a
- * filename collision (e.g. `sidd.md` → `sidd-2.md`), even though no
- * `sidd-2.md` file ever existed on disk. The persona resolver then silently
+ * filename collision (e.g. `alice.md` → `alice-2.md`), even though no
+ * `alice-2.md` file ever existed on disk. The persona resolver then silently
  * fell back to `users/default.md` for that channel's messages — and the same
  * slug is used for the journal directory, so the user lost per-principal
  * continuity on every non-primary channel.

package/src/memory/migrations/222-strip-placeholder-sentinels-from-messages.ts

@@ -0,0 +1,82 @@
+import { isPlaceholderSentinelText } from "../../providers/anthropic/client.js";
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Strip Anthropic provider placeholder sentinel text blocks from persisted
+ * assistant messages.
+ *
+ * PLACEHOLDER_EMPTY_TURN and PLACEHOLDER_BLOCKS_OMITTED are injected into
+ * outbound Anthropic request bodies to preserve role alternation when an
+ * assistant turn would otherwise be empty. They are never supposed to be
+ * persisted, but a leak path caused them to be stored in the messages table
+ * where they render in chat bubbles as bold "PLACEHOLDER[...]" (markdown
+ * interprets the double-underscore surround as bold).
+ *
+ * This migration walks every assistant message, parses its content blocks,
+ * and drops text blocks whose text matches either sentinel (with or without
+ * the null-byte prefix, to cover rows that round-tripped through tools that
+ * stripped null bytes). If stripping leaves the message empty, stores [].
+ *
+ * Idempotent — safe to re-run.
+ */
+export function migrateStripPlaceholderSentinelsFromMessages(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(
+    database,
+    "migration_strip_placeholder_sentinels_from_messages_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+
+      const BATCH_SIZE = 100;
+      let lastRowid = 0;
+
+      for (;;) {
+        const rows = raw
+          .query(
+            `SELECT rowid, id, content FROM messages
+             WHERE role = 'assistant'
+               AND content LIKE '%__PLACEHOLDER__%'
+               AND rowid > ?
+             ORDER BY rowid
+             LIMIT ?`,
+          )
+          .all(lastRowid, BATCH_SIZE) as Array<{
+          rowid: number;
+          id: string;
+          content: string;
+        }>;
+
+        if (rows.length === 0) break;
+
+        for (const row of rows) {
+          lastRowid = row.rowid;
+
+          let blocks: Array<Record<string, unknown>>;
+          try {
+            const parsed = JSON.parse(row.content);
+            if (!Array.isArray(parsed)) continue;
+            blocks = parsed;
+          } catch {
+            continue;
+          }
+
+          const stripped = blocks.filter((b) => {
+            if (typeof b !== "object" || b === null) return false;
+            if (b.type !== "text") return true;
+            const text = typeof b.text === "string" ? b.text : "";
+            return !isPlaceholderSentinelText(text);
+          });
+
+          if (stripped.length === blocks.length) continue;
+
+          raw
+            .query(`UPDATE messages SET content = ? WHERE id = ?`)
+            .run(JSON.stringify(stripped), row.id);
+        }
+      }
+    },
+  );
+}

package/src/memory/migrations/223-schedule-script-column.ts

@@ -0,0 +1,11 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateScheduleScriptColumn(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(`ALTER TABLE cron_jobs ADD COLUMN script TEXT`);
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

package/src/memory/migrations/224-oauth-providers-managed-service-is-paid.ts

@@ -0,0 +1,24 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Add the `managed_service_is_paid` column to `oauth_providers`.
+ *
+ * Flags whether a provider's managed OAuth variant requires a paid plan
+ * upstream (e.g. Twitter). Defaults to 0 (false) for all existing rows.
+ *
+ * Mirrors the pattern from migration 178. The raw.exec() call below is
+ * Drizzle's SQLite statement runner — NOT a shell exec.
+ */
+export function migrateOAuthProvidersManagedServiceIsPaid(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(
+      /*sql*/ `ALTER TABLE oauth_providers ADD COLUMN managed_service_is_paid INTEGER NOT NULL DEFAULT 0`,
+    );
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}