@vellumai/assistant 0.6.2 → 0.6.4

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

@@ -197,7 +197,7 @@ async function generateStarters(scopeId: string): Promise<GeneratedStarter[]> {
   })}`;
 
   // Truncate identity context to prevent oversized prompts when SOUL.md /
-  // IDENTITY.md / USER.md are large.
+  // IDENTITY.md / users/<slug>.md are large.
   const rawIdentityContext = buildCoreIdentityContext({
     userPersona: resolveGuardianPersona(),
   });
@@ -205,11 +205,11 @@ async function generateStarters(scopeId: string): Promise<GeneratedStarter[]> {
     ? truncate(rawIdentityContext, 2000, "\n…[truncated]")
     : null;
 
-  const systemPrompt = `You are generating 4 conversation starters for a personal assistant app. These appear as clickable chips on the empty conversation page — the first thing the user sees when they open the app. Clicking a chip sends its prompt as a message from the user.
+  const systemPrompt = `You are generating conversation starters for a personal assistant app. These appear as clickable chips on the empty conversation page — the first thing the user sees when they open the app. Clicking a chip sends its prompt as a message from the user.
 
 ${timeContext}
 
-Your goal: suggest the 4 most useful things this person could ask you to do right now.
+Your goal: suggest the most useful things this person could ask you to do right now. Produce 8 candidates, ranked best-first; only the top 4 will be shown.
 
 ${
   identityContext
@@ -223,7 +223,7 @@ ${skills}
 
 ## Selection
 
-Generate exactly 4 starters, ranked #1 (best) to #4.
+Generate exactly 8 starters, ranked #1 (best) to #8. The top 4 will be shown; the rest are fallbacks in case any fail downstream validation (e.g. label too long). Put real effort into every slot — any of them may end up displayed.
 
 Start from the user's situation, not from the skill list. Ask yourself:
 - What is this person likely dealing with right now (given the day/time and their context)?
@@ -250,7 +250,7 @@ Favor what is live over what is merely true. Recent changes matter more than old
 ## Output format
 
 Each starter has:
-- label: 3-6 words, max 40 chars, starts with a verb. Written in the user's voice — something they'd want to do, not something the assistant is offering.
+- label: 3-6 words, max 40 chars, starts with a verb. Written in the user's voice — something they'd want to do, not something the assistant is offering. MUST be a grammatically complete phrase: if it uses an adjective ("quarterly", "weekly"), include the noun it modifies ("quarterly review", "weekly sync"). Never end on a dangling modifier, preposition, or trailing "the/my/a". Prefer completeness over tightness when you have room under 40 chars.
 - prompt: 1-2 natural sentences, as the user would actually say them.
 - category: one of ${CONVERSATION_STARTER_CATEGORIES.join(", ")}
 
@@ -258,9 +258,9 @@ Each starter has:
 
 **Voice**: The user clicks these chips to send a message. Every label must read as something the user is asking to do, never something the assistant is saying to the user.
 
-**Coherence**: The 4 starters should feel like one set — similar abstraction level, no jarring mix of mundane chores and life strategy.
+**Coherence**: The top 4 starters should feel like one set — similar abstraction level, no jarring mix of mundane chores and life strategy. The remaining 4 fallbacks may branch into adjacent topics.
 
-**Diversity**: Each chip covers a distinct topic. Never two chips about the same tool, project, or theme. Four topics, four chips.
+**Diversity**: Each chip covers a distinct topic. Never two chips about the same tool, project, or theme. Across all 8 starters, avoid repeating topics.
 
 **No setup chips**: Never include a chip whose primary meaning is configuration or "set up X for Y" unless it solves an urgent pain the user is actively feeling. Prefer the outcome over the mechanism.
 
@@ -276,7 +276,12 @@ Bad → Good (ticket-speak → natural):
 
 Bad → Good (assistant voice → user voice):
 - "You've got a busy week ahead" → "Plan my week ahead"
-- "Let me check your calendar" → "Check my Thursday schedule"`;
+- "Let me check your calendar" → "Check my Thursday schedule"
+
+Bad → Good (incomplete phrase → complete):
+- "Prep for Friday's quarterly" → "Prep for Friday's quarterly review"
+- "Finish the onboarding" → "Finish the onboarding guide"
+- "Draft the release" → "Draft the release notes"`;
 
   const { signal, cleanup } = createTimeout(20000);
   try {
@@ -326,7 +331,7 @@ Bad → Good (assistant voice → user voice):
       {
         config: {
           modelIntent: "quality-optimized",
-          max_tokens: 1024,
+          max_tokens: 2048,
           tool_choice: {
             type: "tool" as const,
             name: "store_conversation_starters",
@@ -356,12 +361,13 @@ Bad → Good (assistant voice → user voice):
         (s) =>
           typeof s.label === "string" &&
           s.label.length > 0 &&
+          s.label.length <= 40 &&
           typeof s.prompt === "string" &&
           s.prompt.length > 0
       )
       .slice(0, 4)
       .map((s) => ({
-        label: truncate(s.label, 40, ""),
+        label: s.label,
         prompt: truncate(s.prompt, 500, ""),
         category:
           typeof s.category === "string" &&

package/src/memory/jobs-store.ts

@@ -18,6 +18,7 @@ export type MemoryJobType =
   | "prune_old_conversations"
   | "prune_old_llm_request_logs"
   | "build_conversation_summary"
+  | "conversation_analyze"
   | "backfill"
   | "rebuild_index"
   | "delete_qdrant_vectors"
@@ -89,15 +90,19 @@ export function enqueueMemoryJob(
 
 /**
  * Upsert a debounced job: if a pending job of the same type and conversation
- * already exists, push its `runAfter` forward instead of creating a duplicate.
- * This prevents rapid message indexing from spawning redundant jobs.
+ * already exists, merge the new payload into the existing row and update
+ * `runAfter` instead of creating a duplicate. This prevents rapid message
+ * indexing from spawning redundant jobs while ensuring the latest payload
+ * keys (e.g. `scopeId`) reach the handler — including on upgraded instances
+ * where the existing pending row was enqueued by an older build that did
+ * not write those keys.
  *
  * Pass a `dbOverride` (transaction handle) to make this call atomic with
  * surrounding writes.
  */
 export function upsertDebouncedJob(
   type: MemoryJobType,
-  payload: { conversationId: string },
+  payload: { conversationId: string } & Record<string, unknown>,
   runAfter: number,
   dbOverride?: Parameters<ReturnType<typeof getDb>["transaction"]>[0] extends (
     tx: infer T,
@@ -118,8 +123,19 @@ export function upsertDebouncedJob(
     )
     .get();
   if (existing) {
+    let existingPayload: Record<string, unknown> = {};
+    try {
+      existingPayload = JSON.parse(existing.payload) as Record<string, unknown>;
+    } catch {
+      existingPayload = {};
+    }
+    const mergedPayload = { ...existingPayload, ...payload };
     db.update(memoryJobs)
-      .set({ runAfter, updatedAt: Date.now() })
+      .set({
+        payload: JSON.stringify(mergedPayload),
+        runAfter,
+        updatedAt: Date.now(),
+      })
       .where(eq(memoryJobs.id, existing.id))
       .run();
   } else {
@@ -127,6 +143,50 @@ export function upsertDebouncedJob(
   }
 }
 
+/**
+ * Upsert a pending `conversation_analyze` job keyed by both
+ * `conversationId` and `triggerGroup`. Immediate triggers (batch,
+ * compaction) and debounced triggers (idle, lifecycle) live in separate
+ * rows so an idle enqueue cannot push an already-scheduled immediate
+ * row's `runAfter` into the future (and vice versa). Each group still
+ * coalesces within itself: two batch crossings, or two idle triggers,
+ * collapse to a single pending row.
+ */
+export function upsertAutoAnalysisJob(
+  payload: {
+    conversationId: string;
+    triggerGroup: "immediate" | "debounced";
+  },
+  runAfter: number,
+  dbOverride?: Parameters<ReturnType<typeof getDb>["transaction"]>[0] extends (
+    tx: infer T,
+  ) => unknown
+    ? T
+    : never,
+): void {
+  const db = dbOverride ?? getDb();
+  const existing = db
+    .select()
+    .from(memoryJobs)
+    .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') = ${payload.triggerGroup}`,
+      ),
+    )
+    .get();
+  if (existing) {
+    db.update(memoryJobs)
+      .set({ runAfter, updatedAt: Date.now() })
+      .where(eq(memoryJobs.id, existing.id))
+      .run();
+  } else {
+    enqueueMemoryJob("conversation_analyze", payload, runAfter, dbOverride);
+  }
+}
+
 /**
  * Check whether a pending or running job of the given type already exists.
  * Used to prevent duplicate enqueues for long-running maintenance jobs.

package/src/memory/jobs-worker.ts

@@ -2,6 +2,13 @@ import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/types.js";
 import { getLogger } from "../util/logger.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
+import {
+  getLastScheduledCleanupEnqueueMs,
+  markScheduledCleanupEnqueued,
+  resetCleanupScheduleThrottle as resetCleanupScheduleThrottleImpl,
+} from "./cleanup-schedule-state.js";
+import { conversationAnalyzeJob } from "./conversation-analyze-job.js";
+import { maybeRunDbMaintenance } from "./db-maintenance.js";
 import { bootstrapFromHistory } from "./graph/bootstrap.js";
 import { runConsolidation } from "./graph/consolidation.js";
 import { runDecayTick } from "./graph/decay.js";
@@ -160,6 +167,7 @@ export async function runMemoryJobsOnce(
       maybeEnqueueScheduledCleanupJobs(config);
     }
     maybeEnqueueGraphMaintenanceJobs();
+    maybeRunDbMaintenance();
     return 0;
   }
 
@@ -256,6 +264,7 @@ export async function runMemoryJobsOnce(
     maybeEnqueueScheduledCleanupJobs(config);
   }
   maybeEnqueueGraphMaintenanceJobs();
+  maybeRunDbMaintenance();
   return processed;
 }
 
@@ -417,6 +426,9 @@ async function processJob(
     case "graph_extract":
       await graphExtractJob(job, config);
       return;
+    case "conversation_analyze":
+      await conversationAnalyzeJob(job, config);
+      return;
     case "graph_decay":
       graphDecayJob(job);
       return;
@@ -449,12 +461,13 @@ async function processJob(
 
 // ── Cleanup scheduling ─────────────────────────────────────────────
 
-let lastScheduledCleanupEnqueueMs = 0;
-
-/** Reset the cleanup enqueue throttle so tests can run deterministic checks. */
-export function resetCleanupScheduleThrottle(): void {
-  lastScheduledCleanupEnqueueMs = 0;
-}
+/**
+ * Re-export of the shared throttle-reset helper. The underlying state lives
+ * in cleanup-schedule-state.ts so that lighter-weight callers (e.g.
+ * ConfigWatcher) can reset it without pulling in jobs-worker's transitive
+ * imports.
+ */
+export const resetCleanupScheduleThrottle = resetCleanupScheduleThrottleImpl;
 
 /**
  * Enqueue periodic cleanup jobs using config-driven retention windows.
@@ -466,7 +479,7 @@ export function maybeEnqueueScheduledCleanupJobs(
 ): boolean {
   const cleanup = config.memory.cleanup;
   if (!cleanup.enabled) return false;
-  if (nowMs - lastScheduledCleanupEnqueueMs < cleanup.enqueueIntervalMs)
+  if (nowMs - getLastScheduledCleanupEnqueueMs() < cleanup.enqueueIntervalMs)
     return false;
 
   const pruneConversationsJobId =
@@ -474,10 +487,10 @@ export function maybeEnqueueScheduledCleanupJobs(
       ? enqueuePruneOldConversationsJob(cleanup.conversationRetentionDays)
       : null;
   const pruneLlmRequestLogsJobId =
-    cleanup.llmRequestLogRetentionMs > 0
+    cleanup.llmRequestLogRetentionMs !== null
       ? enqueuePruneOldLlmRequestLogsJob(cleanup.llmRequestLogRetentionMs)
       : null;
-  lastScheduledCleanupEnqueueMs = nowMs;
+  markScheduledCleanupEnqueued(nowMs);
   log.debug(
     {
       pruneConversationsJobId,

package/src/memory/llm-usage-store.ts

@@ -9,6 +9,11 @@ import type {
 import { getDb } from "./db.js";
 import { rawAll } from "./raw-query.js";
 import { llmUsageEvents } from "./schema.js";
+import {
+  bucketEventsByDay,
+  bucketEventsByHour,
+  type UsageEventBucketRow,
+} from "./usage-buckets.js";
 
 // ---------------------------------------------------------------------------
 // Write
@@ -152,8 +157,25 @@ export type UsageGranularity = "daily" | "hourly";
 
 /** A single time bucket with its aggregate totals. */
 export interface UsageDayBucket {
-  /** ISO date string: "YYYY-MM-DD" (daily) or "YYYY-MM-DD HH:00" (hourly), UTC. */
+  /**
+   * Stable unique identifier for the bucket. Safe for use as a SwiftUI/React
+   * list key. Distinct even for DST fall-back duplicate hours (which share the
+   * same `date` string). Daily buckets use `date` directly; hourly buckets use
+   * "YYYY-MM-DD HH:00|<offsetMinutes>" to disambiguate repeated local hours.
+   */
+  bucketId: string;
+  /**
+   * Local-time bucket key in the requested tz:
+   * "YYYY-MM-DD" (daily) or "YYYY-MM-DD HH:00" (hourly).
+   * NOT unique: on DST fall-back days, two 01:00 hourly buckets share this key.
+   * Use `bucketId` as a list identifier and `date` for display/sort only.
+   */
   date: string;
+  /**
+   * Human-readable label for the bucket, formatted in the requested tz.
+   * Hourly: "3pm". Daily: "Apr 11".
+   */
+  displayLabel?: string;
   /** Direct input tokens only; cache traffic is tracked separately in totals. */
   totalInputTokens: number;
   totalOutputTokens: number;
@@ -164,6 +186,14 @@ export interface UsageDayBucket {
 /** A grouped breakdown row (by actor, provider, or model). */
 export interface UsageGroupBreakdown {
   group: string;
+  /**
+   * Stable identifier for the group. Populated with the conversation id when
+   * `groupBy === "conversation"` (and `null` for that mode's "Other" bucket,
+   * which aggregates events with no conversation id). For all other group-bys
+   * (`actor`, `provider`, `model`) this is always `null` — the raw grouping
+   * column is already exposed via `group`.
+   */
+  groupId: string | null;
   /** Direct input tokens only; cache traffic is reported separately below. */
   totalInputTokens: number;
   totalOutputTokens: number;
@@ -186,16 +216,10 @@ interface TotalsRow {
   unpriced_event_count: number;
 }
 
-interface DayBucketRow {
-  date: string;
-  total_input_tokens: number;
-  total_output_tokens: number;
-  total_estimated_cost_usd: number | null;
-  event_count: number;
-}
 
 interface GroupRow {
   group_key: string;
+  group_id: string | null;
   total_input_tokens: number;
   total_output_tokens: number;
   total_cache_creation_tokens: number;
@@ -238,70 +262,71 @@ export function getUsageTotals(range: UsageTimeRange): UsageTotals {
   };
 }
 
-/**
- * Return per-day aggregates (UTC) within the given time range, ordered by date ascending.
- *
- * Each bucket key is a YYYY-MM-DD string derived by dividing the epoch-millis
- * timestamp by 86400000 and formatting as a date.
- */
-export function getUsageDayBuckets(range: UsageTimeRange): UsageDayBucket[] {
-  const rows = rawAll<DayBucketRow>(
+/** Fetch raw events in a time range for in-memory bucketing. */
+function fetchRawBucketRows(range: UsageTimeRange): UsageEventBucketRow[] {
+  return rawAll<UsageEventBucketRow>(
     /*sql*/ `
     SELECT
-      strftime('%Y-%m-%d', created_at / 1000, 'unixepoch')  AS date,
-      COALESCE(SUM(input_tokens), 0)                         AS total_input_tokens,
-      COALESCE(SUM(output_tokens), 0)                        AS total_output_tokens,
-      COALESCE(SUM(estimated_cost_usd), 0)                   AS total_estimated_cost_usd,
-      COALESCE(SUM(COALESCE(llm_call_count, 1)), 0)          AS event_count
+      created_at,
+      input_tokens,
+      output_tokens,
+      estimated_cost_usd,
+      llm_call_count
     FROM llm_usage_events
     WHERE created_at >= ?1 AND created_at <= ?2
-    GROUP BY date
-    ORDER BY date ASC
     `,
     range.from,
     range.to,
   );
-  return rows.map((r) => ({
-    date: r.date,
-    totalInputTokens: r.total_input_tokens,
-    totalOutputTokens: r.total_output_tokens,
-    totalEstimatedCostUsd: r.total_estimated_cost_usd ?? 0,
-    eventCount: r.event_count,
-  }));
+}
+
+/** Options for bucket aggregation. */
+export interface UsageBucketOptions {
+  /**
+   * When true, emit a zero-value bucket for every day (or hour) in the range
+   * even if no events fall inside it. Defaults to false so the CLI and other
+   * callers only see active periods; the chart route opts in.
+   */
+  fillEmpty?: boolean;
 }
 
 /**
- * Return per-hour aggregates (UTC) within the given time range, ordered ascending.
+ * Return per-day aggregates within the given time range, keyed by local date
+ * in the requested timezone (default UTC).
  *
- * Each bucket key is a "YYYY-MM-DD HH:00" string.
+ * Each bucket key is a "YYYY-MM-DD" string anchored on local midnight in `tz`.
+ * When `options.fillEmpty` is true, empty days within the range are filled
+ * with zero-value buckets. DST-short and DST-long local days are handled
+ * correctly.
  */
-export function getUsageHourBuckets(range: UsageTimeRange): UsageDayBucket[] {
-  const rows = rawAll<DayBucketRow>(
-    /*sql*/ `
-    SELECT
-      strftime('%Y-%m-%d %H:00', created_at / 1000, 'unixepoch')  AS date,
-      COALESCE(SUM(input_tokens), 0)                               AS total_input_tokens,
-      COALESCE(SUM(output_tokens), 0)                              AS total_output_tokens,
-      COALESCE(SUM(estimated_cost_usd), 0)                         AS total_estimated_cost_usd,
-      COALESCE(SUM(COALESCE(llm_call_count, 1)), 0)                AS event_count
-    FROM llm_usage_events
-    WHERE created_at >= ?1 AND created_at <= ?2
-    GROUP BY date
-    ORDER BY date ASC
-    `,
-    range.from,
-    range.to,
-  );
-  return rows.map((r) => ({
-    date: r.date,
-    totalInputTokens: r.total_input_tokens,
-    totalOutputTokens: r.total_output_tokens,
-    totalEstimatedCostUsd: r.total_estimated_cost_usd ?? 0,
-    eventCount: r.event_count,
-  }));
+export function getUsageDayBuckets(
+  range: UsageTimeRange,
+  tz: string = "UTC",
+  options: UsageBucketOptions = {},
+): UsageDayBucket[] {
+  const rows = fetchRawBucketRows(range);
+  return bucketEventsByDay(rows, range, tz, options);
+}
+
+/**
+ * Return per-hour aggregates within the given time range, keyed by local hour
+ * in the requested timezone (default UTC).
+ *
+ * Each bucket key is a "YYYY-MM-DD HH:00" string anchored on local hour starts.
+ * When `options.fillEmpty` is true, empty hours are filled with zero-value
+ * buckets. DST fall-back produces two distinct buckets for the duplicated hour;
+ * DST spring-forward produces 23 buckets for the affected day.
+ */
+export function getUsageHourBuckets(
+  range: UsageTimeRange,
+  tz: string = "UTC",
+  options: UsageBucketOptions = {},
+): UsageDayBucket[] {
+  const rows = fetchRawBucketRows(range);
+  return bucketEventsByHour(rows, range, tz, options);
 }
 
-type GroupByDimension = "actor" | "provider" | "model";
+type GroupByDimension = "actor" | "provider" | "model" | "conversation";
 
 /**
  * Return grouped breakdowns across the given time range, ordered by total
@@ -312,15 +337,62 @@ export function getUsageGroupBreakdown(
   groupBy: GroupByDimension,
 ): UsageGroupBreakdown[] {
   // Runtime allowlist — defense-in-depth against SQL injection via type assertions.
-  const ALLOWED_COLUMNS = new Set<string>(["actor", "provider", "model"]);
-  if (!ALLOWED_COLUMNS.has(groupBy)) {
-    throw new Error(`Invalid groupBy column: ${groupBy}`);
+  const ALLOWED_DIMENSIONS = new Set<string>([
+    "actor",
+    "provider",
+    "model",
+    "conversation",
+  ]);
+  if (!ALLOWED_DIMENSIONS.has(groupBy)) {
+    throw new Error(`Invalid groupBy dimension: ${groupBy}`);
   }
+
+  // Conversation grouping requires a JOIN with conversations to resolve titles.
+  if (groupBy === "conversation") {
+    const rows = rawAll<GroupRow>(
+      /*sql*/ `
+      SELECT
+        CASE WHEN e.conversation_id IS NULL THEN 'Other'
+             ELSE COALESCE(c.title, 'Untitled')
+        END AS group_key,
+        e.conversation_id                                AS group_id,
+        COALESCE(SUM(e.input_tokens), 0)                 AS total_input_tokens,
+        COALESCE(SUM(e.output_tokens), 0)                AS total_output_tokens,
+        COALESCE(SUM(e.cache_creation_input_tokens), 0)  AS total_cache_creation_tokens,
+        COALESCE(SUM(e.cache_read_input_tokens), 0)      AS total_cache_read_tokens,
+        COALESCE(SUM(e.estimated_cost_usd), 0)           AS total_estimated_cost_usd,
+        COALESCE(SUM(COALESCE(e.llm_call_count, 1)), 0)  AS event_count
+      FROM llm_usage_events e
+      LEFT JOIN conversations c ON e.conversation_id = c.id
+      WHERE e.created_at >= ?1 AND e.created_at <= ?2
+      GROUP BY e.conversation_id
+      ORDER BY total_estimated_cost_usd DESC
+      LIMIT 50
+      `,
+      range.from,
+      range.to,
+    );
+    return rows.map((r) => ({
+      group: r.group_key,
+      // `GROUP BY e.conversation_id` makes `e.conversation_id` unambiguous
+      // inside each group — it is the seeded conversation id for real rows
+      // and `null` for the "Other" bucket (events with no conversation).
+      groupId: r.group_id,
+      totalInputTokens: r.total_input_tokens,
+      totalOutputTokens: r.total_output_tokens,
+      totalCacheCreationTokens: r.total_cache_creation_tokens,
+      totalCacheReadTokens: r.total_cache_read_tokens,
+      totalEstimatedCostUsd: r.total_estimated_cost_usd ?? 0,
+      eventCount: r.event_count,
+    }));
+  }
+
   const column = groupBy;
   const rows = rawAll<GroupRow>(
     /*sql*/ `
     SELECT
       ${column}                                      AS group_key,
+      NULL                                           AS group_id,
       COALESCE(SUM(input_tokens), 0)                 AS total_input_tokens,
       COALESCE(SUM(output_tokens), 0)                AS total_output_tokens,
       COALESCE(SUM(cache_creation_input_tokens), 0)  AS total_cache_creation_tokens,
@@ -337,6 +409,11 @@ export function getUsageGroupBreakdown(
   );
   return rows.map((r) => ({
     group: r.group_key,
+    // Non-conversation group-bys (actor/provider/model) don't have a
+    // separate stable id — the grouping column itself is the identifier
+    // and is already exposed via `group`. The SELECT projects
+    // `NULL AS group_id` so the runtime shape matches `GroupRow`.
+    groupId: r.group_id,
     totalInputTokens: r.total_input_tokens,
     totalOutputTokens: r.total_output_tokens,
     totalCacheCreationTokens: r.total_cache_creation_tokens,

package/src/memory/migrations/213-oauth-providers-scope-separator.ts

@@ -0,0 +1,13 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateOAuthProvidersScopeSeparator(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(
+      `ALTER TABLE oauth_providers ADD COLUMN scope_separator TEXT NOT NULL DEFAULT ' '`,
+    );
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

package/src/memory/migrations/214-oauth-providers-refresh-url.ts

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

package/src/memory/migrations/215-oauth-providers-revoke.ts

@@ -0,0 +1,14 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateOAuthProvidersRevoke(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const columns = ["revoke_url TEXT", "revoke_body_template TEXT"];
+  for (const col of columns) {
+    try {
+      raw.exec(`ALTER TABLE oauth_providers ADD COLUMN ${col}`);
+    } catch {
+      // Column already exists — nothing to do.
+    }
+  }
+}

package/src/memory/migrations/216-oauth-providers-token-auth-method.ts

@@ -0,0 +1,30 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Backfill `oauth_providers.token_endpoint_auth_method` for any rows where
+ * the value is NULL or empty string, setting them to the new default
+ * "client_secret_post". This brings existing rows in line with the
+ * Drizzle schema's new `.notNull().default("client_secret_post")`
+ * constraint, which is enforced at write time via the TypeScript layer.
+ *
+ * SQLite cannot retroactively add a NOT NULL constraint to an existing
+ * column without a full table rebuild, so the underlying column remains
+ * nullable at the SQLite level. All writes go through Drizzle, which
+ * applies the default for any insert that omits the field.
+ *
+ * The UPDATE is inherently idempotent and safe to re-run. Errors are
+ * allowed to propagate to the migration runner in `db-init.ts`, which
+ * records the failure, logs it, and continues to the next migration.
+ */
+export function migrateOAuthProvidersTokenAuthMethodDefault(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(
+    `UPDATE oauth_providers
+     SET token_endpoint_auth_method = 'client_secret_post'
+     WHERE token_endpoint_auth_method IS NULL
+        OR token_endpoint_auth_method = ''`,
+  );
+}

package/src/memory/migrations/217-conversation-host-access.ts

@@ -0,0 +1,40 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_conversation_host_access_v1";
+
+/**
+ * Add conversation-scoped host access state with a safe default of disabled.
+ *
+ * Idempotent: ALTER TABLE is guarded and the backfill only touches NULL rows.
+ */
+export function migrateConversationHostAccess(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+
+    try {
+      raw.exec(
+        `ALTER TABLE conversations ADD COLUMN host_access INTEGER NOT NULL DEFAULT 0`,
+      );
+    } catch {
+      // Column already exists.
+    }
+
+    raw.exec(`
+      UPDATE conversations
+      SET host_access = 0
+      WHERE host_access IS NULL
+    `);
+  });
+}
+
+/**
+ * Reverse: no-op.
+ *
+ * The forward migration is additive and SQLite cannot drop one column without
+ * rebuilding the table.
+ */
+export function downConversationHostAccess(_database: DrizzleDb): void {
+  // Intentionally empty.
+}

package/src/memory/migrations/218-oauth-providers-logo-url.ts

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