@vellumai/assistant 0.4.56 → 0.5.0

package/src/media/app-icon-generator.ts

@@ -37,13 +37,13 @@ export async function generateAppIcon(
   appDescription?: string,
 ): Promise<void> {
   const config = getConfig();
-  const apiKey = await getProviderKeyAsync("gemini");
+  const imageGenMode = config.services["image-generation"].mode;
 
+  // Resolve credentials strictly based on mode — no cross-mode fallbacks
   let credentials: ImageGenCredentials | undefined;
-  if (apiKey) {
-    credentials = { type: "direct", apiKey };
-  } else {
-    const managedBaseUrl = await buildManagedBaseUrl("vertex");
+
+  if (imageGenMode === "managed") {
+    const managedBaseUrl = await buildManagedBaseUrl("gemini");
     if (managedBaseUrl) {
       const ctx = await resolveManagedProxyContext();
       credentials = {
@@ -52,12 +52,19 @@ export async function generateAppIcon(
         baseUrl: managedBaseUrl,
       };
     }
+  } else {
+    const apiKey = await getProviderKeyAsync("gemini");
+    if (apiKey) {
+      credentials = { type: "direct", apiKey };
+    }
   }
 
   if (!credentials) {
-    log.debug(
-      "No Gemini API key or managed proxy — skipping app icon generation",
-    );
+    const reason =
+      imageGenMode === "managed"
+        ? "Managed proxy is not available"
+        : "No Gemini API key configured";
+    log.debug(`${reason} — skipping app icon generation`);
     return;
   }
 

package/src/media/avatar-router.ts

@@ -14,13 +14,13 @@ export async function generateAvatar(
   prompt: string,
 ): Promise<{ imageBase64: string; mimeType: string }> {
   const config = getConfig();
-  const geminiKey = await getProviderKeyAsync("gemini");
+  const imageGenMode = config.services["image-generation"].mode;
 
+  // Resolve credentials strictly based on mode — no cross-mode fallbacks
   let credentials: ImageGenCredentials | undefined;
-  if (geminiKey) {
-    credentials = { type: "direct", apiKey: geminiKey };
-  } else {
-    const managedBaseUrl = await buildManagedBaseUrl("vertex");
+
+  if (imageGenMode === "managed") {
+    const managedBaseUrl = await buildManagedBaseUrl("gemini");
     if (managedBaseUrl) {
       const ctx = await resolveManagedProxyContext();
       credentials = {
@@ -29,12 +29,19 @@ export async function generateAvatar(
         baseUrl: managedBaseUrl,
       };
     }
+  } else {
+    const geminiKey = await getProviderKeyAsync("gemini");
+    if (geminiKey) {
+      credentials = { type: "direct", apiKey: geminiKey };
+    }
   }
 
   if (!credentials) {
-    throw new ConfigError(
-      "Gemini API key is not configured. Set it via `keys set gemini <key>`.",
-    );
+    const hint =
+      imageGenMode === "managed"
+        ? "Managed proxy is not available. Please log in to Vellum or switch to Your Own mode."
+        : "Gemini API key is not configured. Please set your Gemini API key in Settings > Models & Services.";
+    throw new ConfigError(hint);
   }
 
   const result = await generateImage(credentials, {

package/src/media/gemini-image-service.ts

@@ -7,7 +7,7 @@ interface ImageGenerationRequest {
   mode: "generate" | "edit";
   /** Base64-encoded source images for edit mode */
   sourceImages?: Array<{ mimeType: string; dataBase64: string }>;
-  /** Model override; defaults to 'gemini-2.5-flash-image' */
+  /** Model override; defaults to 'gemini-3.1-flash-image-preview' */
   model?: string;
   /** Number of output variants (1-4, default 1) */
   variants?: number;
@@ -19,7 +19,7 @@ interface DirectCredentials {
   apiKey: string;
 }
 
-/** Credentials for managed proxy access via Vertex AI. */
+/** Credentials for managed proxy access (platform translates to Vertex AI). */
 interface ManagedProxyCredentials {
   type: "managed-proxy";
   assistantApiKey: string;
@@ -43,10 +43,9 @@ interface ImageGenerationResult {
 
 // --- Constants ---
 
-const DEFAULT_MODEL = "gemini-2.5-flash-image";
+const DEFAULT_MODEL = "gemini-3.1-flash-image-preview";
 const ALLOWED_MODELS = new Set([
-  "gemini-2.5-flash-image",
-  "gemini-3-pro-image",
+  "gemini-3.1-flash-image-preview",
   "gemini-3-pro-image-preview",
 ]);
 const MAX_VARIANTS = 4;
@@ -76,6 +75,77 @@ export function mapGeminiError(error: unknown): string {
   return "An unexpected error occurred during image generation.";
 }
 
+// --- Managed proxy direct HTTP call ---
+
+/**
+ * Call the managed proxy directly via fetch, using the Gemini API URL format.
+ * The platform proxy translates this to Vertex AI internally with ADC auth.
+ *
+ * Uses the Gemini API format:
+ *   POST {baseUrl}/v1beta/models/{model}:generateContent
+ */
+async function generateImageViaProxy(
+  credentials: ManagedProxyCredentials,
+  model: string,
+  contents: unknown[],
+  config: Record<string, unknown>,
+): Promise<{
+  images: GeneratedImage[];
+  text?: string;
+}> {
+  const url = `${credentials.baseUrl}/v1beta/models/${model}:generateContent`;
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${credentials.assistantApiKey}`,
+    },
+    body: JSON.stringify({
+      contents,
+      generationConfig: config,
+    }),
+  });
+
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(
+      `Managed proxy request failed (${response.status}): ${body}`,
+    );
+  }
+
+  const data = (await response.json()) as {
+    candidates?: Array<{
+      content?: {
+        parts?: Array<{
+          text?: string;
+          inlineData?: { mimeType?: string; data?: string };
+        }>;
+      };
+    }>;
+  };
+
+  const images: GeneratedImage[] = [];
+  let text: string | undefined;
+
+  const responseParts = data.candidates?.[0]?.content?.parts;
+  if (responseParts) {
+    for (const part of responseParts) {
+      if (part.inlineData) {
+        images.push({
+          mimeType: part.inlineData.mimeType ?? "image/png",
+          dataBase64: part.inlineData.data ?? "",
+        });
+      }
+      if (part.text) {
+        text = text ? `${text}\n${part.text}` : part.text;
+      }
+    }
+  }
+
+  return { images, text };
+}
+
 // --- Core function ---
 
 export async function generateImage(
@@ -89,19 +159,6 @@ export async function generateImage(
 
   const variants = Math.max(1, Math.min(request.variants ?? 1, MAX_VARIANTS));
 
-  const client =
-    credentials.type === "managed-proxy"
-      ? new GoogleGenAI({
-          vertexai: true,
-          project: "proxy",
-          location: "us-central1",
-          httpOptions: {
-            baseUrl: credentials.baseUrl,
-            headers: { Authorization: `Bearer ${credentials.assistantApiKey}` },
-          },
-        })
-      : new GoogleGenAI({ apiKey: credentials.apiKey });
-
   // Build contents array — append a title request so the model's text
   // response contains a short filename-safe title for the generated image.
   const promptWithTitle = `${request.prompt}\n\nAlso respond with a short title (max 6 words) for the image on its own line, prefixed with "Title: ".`;
@@ -118,11 +175,60 @@ export async function generateImage(
   }
 
   const config = { responseModalities: ["TEXT", "IMAGE"] as string[] };
+  const contents = [{ role: "user" as const, parts }];
+
+  // For the managed proxy, bypass the @google/genai SDK and make direct HTTP
+  // calls. The SDK's generateContent doesn't support responseModalities for
+  // image generation. Direct fetch lets us use the Gemini API format with
+  // the managed proxy translating to Vertex internally.
+  if (credentials.type === "managed-proxy") {
+    const makeSingleCall = () =>
+      generateImageViaProxy(credentials, model, contents, config);
+
+    if (variants === 1) {
+      const result = await makeSingleCall();
+      const title = extractTitle(result.text);
+      if (title) {
+        for (const img of result.images) img.title = title;
+      }
+      return {
+        images: result.images,
+        text: stripTitleLine(result.text),
+        resolvedModel: model,
+      };
+    }
+
+    const results = await Promise.all(
+      Array.from({ length: variants }, () => makeSingleCall()),
+    );
+    const allImages: GeneratedImage[] = [];
+    let combinedText: string | undefined;
+    for (const result of results) {
+      const title = extractTitle(result.text);
+      if (title) {
+        for (const img of result.images) img.title = title;
+      }
+      allImages.push(...result.images);
+      if (result.text) {
+        combinedText = combinedText
+          ? `${combinedText}\n${result.text}`
+          : result.text;
+      }
+    }
+    return {
+      images: allImages,
+      text: stripTitleLine(combinedText),
+      resolvedModel: model,
+    };
+  }
+
+  // Direct Gemini API path — use the SDK with API key auth.
+  const client = new GoogleGenAI({ apiKey: credentials.apiKey });
 
   const makeSingleCall = async () => {
     const response = await client.models.generateContent({
       model,
-      contents: [{ role: "user" as const, parts }],
+      contents,
       config,
     });
 
@@ -144,7 +250,6 @@ export async function generateImage(
       }
     }
 
-    // Extract title from the text response and apply to images
     const title = extractTitle(text);
     if (title) {
       for (const img of images) {
@@ -160,7 +265,6 @@ export async function generateImage(
     return { ...result, resolvedModel: model };
   }
 
-  // Parallel calls for multiple variants
   const results = await Promise.all(
     Array.from({ length: variants }, () => makeSingleCall()),
   );

package/src/memory/attachments-store.ts

@@ -48,8 +48,8 @@ function formatBytes(bytes: number): string {
 // Size and encoding limits
 // ---------------------------------------------------------------------------
 
-/** Hard ceiling on a single uploaded attachment (50 MB, matching assistant limits). */
-export const MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+/** Hard ceiling on a single uploaded attachment (100 MB, matching assistant limits). */
+export const MAX_UPLOAD_BYTES = 100 * 1024 * 1024;
 
 /** Attachments larger than this are stored on disk instead of inline in SQLite. */
 export const FILE_BACKED_THRESHOLD_BYTES = 5 * 1024 * 1024;
@@ -226,7 +226,7 @@ function computeContentHash(dataBase64: string): string {
 /**
  * Store a file-backed attachment by path reference, without reading the file
  * into memory. This avoids OOM risk for large recordings that exceed the
- * normal 50 MB upload limit.
+ * normal 100 MB upload limit.
  *
  * The file stays on disk; the attachment row stores an empty dataBase64 and
  * records the on-disk path in a `file_path` column (added via DB migration

package/src/memory/channel-verification-sessions.ts

@@ -59,7 +59,7 @@ export interface VerificationSession {
   challengeHash: string;
   expiresAt: number;
   status: SessionStatus;
-  createdByConversationId: string | null;
+  sourceConversationId: string | null;
   consumedByExternalUserId: string | null;
   consumedByChatId: string | null;
   // Outbound session: expected-identity binding
@@ -96,7 +96,7 @@ function rowToSession(
     challengeHash: row.challengeHash,
     expiresAt: row.expiresAt,
     status: row.status as SessionStatus,
-    createdByConversationId: row.createdByConversationId,
+    sourceConversationId: row.sourceConversationId,
     consumedByExternalUserId: row.consumedByExternalUserId,
     consumedByChatId: row.consumedByChatId,
     expectedExternalUserId: row.expectedExternalUserId ?? null,
@@ -127,7 +127,7 @@ export function createInboundSession(params: {
   channel: string;
   challengeHash: string;
   expiresAt: number;
-  createdByConversationId?: string;
+  sourceConversationId?: string;
 }): VerificationSession {
   const db = getDb();
   const now = Date.now();
@@ -150,7 +150,7 @@ export function createInboundSession(params: {
     challengeHash: params.challengeHash,
     expiresAt: params.expiresAt,
     status: "pending" as const,
-    createdByConversationId: params.createdByConversationId ?? null,
+    sourceConversationId: params.sourceConversationId ?? null,
     consumedByExternalUserId: null,
     consumedByChatId: null,
     expectedExternalUserId: null,
@@ -278,7 +278,7 @@ export function createVerificationSession(params: {
   challengeHash: string;
   expiresAt: number;
   status: SessionStatus;
-  createdByConversationId?: string;
+  sourceConversationId?: string;
   expectedExternalUserId?: string | null;
   expectedChatId?: string | null;
   expectedPhoneE164?: string | null;
@@ -313,7 +313,7 @@ export function createVerificationSession(params: {
     challengeHash: params.challengeHash,
     expiresAt: params.expiresAt,
     status: params.status as string,
-    createdByConversationId: params.createdByConversationId ?? null,
+    sourceConversationId: params.sourceConversationId ?? null,
     consumedByExternalUserId: null,
     consumedByChatId: null,
     expectedExternalUserId: params.expectedExternalUserId ?? null,

package/src/memory/conversation-crud.ts

@@ -12,8 +12,9 @@ import { createRowMapper } from "../util/row-mapper.js";
 import { deleteOrphanAttachments } from "./attachments-store.js";
 import { projectAssistantMessage } from "./conversation-attention-store.js";
 import { ensureDisplayOrderMigration } from "./conversation-display-order-migration.js";
-import { getDb, rawExec, rawGet, rawRun } from "./db.js";
+import { getDb, rawAll, rawExec, rawGet, rawRun } from "./db.js";
 import { indexMessageNow } from "./indexer.js";
+import { enqueueMemoryJob } from "./jobs-store.js";
 import {
   channelInboundEvents,
   conversations,
@@ -22,10 +23,12 @@ import {
   memoryItems,
   memoryItemSources,
   memorySegments,
+  memorySummaries,
   messageAttachments,
   messages,
   toolInvocations,
 } from "./schema.js";
+import { cancelPendingJobsForConversation } from "./task-memory-cleanup.js";
 
 const log = getLogger("conversation-store");
 
@@ -357,6 +360,192 @@ export function deleteConversation(id: string): DeletedMemoryIds {
   return result;
 }
 
+/**
+ * Wipe a conversation and revert all memory changes it caused.
+ *
+ * Extends `deleteConversation` with:
+ * - Cancelling pending memory jobs before deletion
+ * - Restoring memory items that were explicitly superseded by items from this conversation
+ * - Restoring orphaned subject-match superseded items after deletion
+ * - Deleting conversation-scoped memory summaries and their embeddings
+ * - Enqueuing `embed_item` jobs for all restored items
+ */
+export function wipeConversation(id: string): WipeConversationResult {
+  const db = getDb();
+  const unsupersededItemIds: string[] = [];
+  const deletedSummaryIds: string[] = [];
+
+  // Step A — Cancel pending memory jobs (before deleting messages, since
+  // the cancellation queries join on `messages`).
+  const cancelledJobCount = cancelPendingJobsForConversation(id);
+
+  // Step B — Un-supersede memory items with explicit `supersededBy` links.
+  // Find memory items whose `superseded_by` points to an item sourced
+  // exclusively from this conversation.
+  const explicitSuperseded = rawAll<{ oldItemId: string }>(
+    `SELECT DISTINCT mi_old.id AS oldItemId
+     FROM memory_items mi_old
+     JOIN memory_items mi_new ON mi_old.superseded_by = mi_new.id
+     WHERE mi_old.status = 'superseded'
+       AND mi_new.id IN (
+         SELECT mis.memory_item_id
+         FROM memory_item_sources mis
+         JOIN messages m ON m.id = mis.message_id
+         WHERE m.conversation_id = ?
+       )
+       AND NOT EXISTS (
+         SELECT 1 FROM memory_item_sources mis2
+         JOIN messages m2 ON m2.id = mis2.message_id
+         WHERE mis2.memory_item_id = mi_new.id
+           AND m2.conversation_id != ?
+       )
+       AND NOT EXISTS (
+         SELECT 1 FROM memory_items mi_active
+         WHERE mi_active.kind = mi_old.kind
+           AND mi_active.subject = mi_old.subject
+           AND mi_active.scope_id = mi_old.scope_id
+           AND mi_active.status = 'active'
+           AND mi_active.id != mi_old.id
+           -- Exclude items sourced exclusively from the conversation being
+           -- wiped — deleteConversation will remove them, so they should not
+           -- block restoration of mi_old.
+           AND NOT (
+             EXISTS (
+               SELECT 1 FROM memory_item_sources mis_a
+               JOIN messages m_a ON m_a.id = mis_a.message_id
+               WHERE mis_a.memory_item_id = mi_active.id
+                 AND m_a.conversation_id = ?
+             )
+             AND NOT EXISTS (
+               SELECT 1 FROM memory_item_sources mis_b
+               JOIN messages m_b ON m_b.id = mis_b.message_id
+               WHERE mis_b.memory_item_id = mi_active.id
+                 AND m_b.conversation_id != ?
+             )
+           )
+       )`,
+    id,
+    id,
+    id,
+    id,
+  );
+  for (const { oldItemId } of explicitSuperseded) {
+    rawRun(
+      "UPDATE memory_items SET status = 'active', superseded_by = NULL WHERE id = ?",
+      oldItemId,
+    );
+    enqueueMemoryJob("embed_item", { itemId: oldItemId });
+    unsupersededItemIds.push(oldItemId);
+  }
+
+  // Step C — Delete conversation-scoped memory summaries and their embeddings.
+  const summaryRows = db
+    .select({ id: memorySummaries.id })
+    .from(memorySummaries)
+    .where(
+      and(
+        eq(memorySummaries.scope, "conversation"),
+        eq(memorySummaries.scopeKey, id),
+      ),
+    )
+    .all();
+  const summaryIds = summaryRows.map((r) => r.id);
+  if (summaryIds.length > 0) {
+    db.delete(memoryEmbeddings)
+      .where(
+        and(
+          eq(memoryEmbeddings.targetType, "summary"),
+          inArray(memoryEmbeddings.targetId, summaryIds),
+        ),
+      )
+      .run();
+    db.delete(memorySummaries)
+      .where(inArray(memorySummaries.id, summaryIds))
+      .run();
+  }
+  deletedSummaryIds.push(...summaryIds);
+
+  // Step D — Get the conversation's memoryScopeId before deletion.
+  const scopeId = getConversationMemoryScopeId(id);
+
+  // Step D.5 — Collect kind + subject pairs of items that will be orphaned
+  // by deleteConversation. These are items sourced from this conversation's
+  // messages that have NO sources from any other conversation. We need this
+  // before deletion so we can scope Step F to only restore superseded items
+  // matching the specific kind + subject pairs that just lost their active
+  // replacement.
+  const orphanedKindSubjects = rawAll<{ kind: string; subject: string }>(
+    `SELECT DISTINCT mi.kind, mi.subject
+     FROM memory_items mi
+     JOIN memory_item_sources mis ON mis.memory_item_id = mi.id
+     JOIN messages m ON m.id = mis.message_id
+     WHERE m.conversation_id = ?
+       AND NOT EXISTS (
+         SELECT 1 FROM memory_item_sources mis2
+         JOIN messages m2 ON m2.id = mis2.message_id
+         WHERE mis2.memory_item_id = mi.id
+           AND m2.conversation_id != ?
+       )`,
+    id,
+    id,
+  );
+
+  // Step E — Delegate to deleteConversation which handles messages (cascade
+  // segments, item_sources, attachments), llmRequestLogs, toolInvocations,
+  // orphaned memory items + embeddings, and the conversation row.
+  const deletedMemoryIds = deleteConversation(id);
+
+  // Step F — Restore orphaned subject-match superseded items. After
+  // deleteConversation removes superseding items, find superseded items
+  // with no supersededBy link where no active item with the same
+  // kind + subject + scope_id exists. Scoped to only the kind + subject
+  // pairs of items that were just orphaned by deleteConversation, so we
+  // don't accidentally restore items superseded by unrelated conversations.
+  let orphanedSuperseded: Array<{ id: string }> = [];
+  if (orphanedKindSubjects.length > 0) {
+    const placeholders = orphanedKindSubjects.map(() => "(?, ?)").join(", ");
+    const params: Array<string> = [scopeId];
+    for (const { kind, subject } of orphanedKindSubjects) {
+      params.push(kind, subject);
+    }
+    orphanedSuperseded = rawAll<{ id: string }>(
+      `SELECT id FROM (
+         SELECT id, ROW_NUMBER() OVER (
+           PARTITION BY kind, subject, scope_id
+           ORDER BY last_seen_at DESC
+         ) AS rn
+         FROM memory_items
+         WHERE status = 'superseded'
+           AND superseded_by IS NULL
+           AND scope_id = ?
+           AND (kind, subject) IN (VALUES ${placeholders})
+           AND NOT EXISTS (
+             SELECT 1 FROM memory_items mi2
+             WHERE mi2.kind = memory_items.kind
+               AND mi2.subject = memory_items.subject
+               AND mi2.scope_id = memory_items.scope_id
+               AND mi2.status = 'active'
+               AND mi2.id != memory_items.id
+           )
+       ) WHERE rn = 1`,
+      ...params,
+    );
+  }
+  for (const { id: itemId } of orphanedSuperseded) {
+    rawRun("UPDATE memory_items SET status = 'active' WHERE id = ?", itemId);
+    enqueueMemoryJob("embed_item", { itemId });
+    unsupersededItemIds.push(itemId);
+  }
+
+  // Step G — Return the combined result.
+  return {
+    ...deletedMemoryIds,
+    unsupersededItemIds,
+    deletedSummaryIds,
+    cancelledJobCount,
+  };
+}
+
 /**
  * Delete all private (temporary) conversations and their associated data.
  * Called at daemon startup to clean up ephemeral conversations from previous sessions.
@@ -755,6 +944,12 @@ export interface DeletedMemoryIds {
   orphanedItemIds: string[];
 }
 
+export interface WipeConversationResult extends DeletedMemoryIds {
+  unsupersededItemIds: string[];
+  deletedSummaryIds: string[];
+  cancelledJobCount: number;
+}
+
 /**
  * Update the content of an existing message. Used when consolidating
  * multiple assistant messages into one.

package/src/memory/{thread-starters-cadence.ts → conversation-starters-cadence.ts}

@@ -1,7 +1,7 @@
 /**
- * Cadence logic for thread starters and capability cards generation.
+ * Cadence logic for conversation starters generation.
  *
- * Decides whether new generation jobs should be enqueued based on how many
+ * Decides whether a new generation job should be enqueued based on how many
  * active memory items have accumulated since the last generation.
  */
 
@@ -9,18 +9,17 @@ import { and, eq, inArray, like } from "drizzle-orm";
 
 import { getLogger } from "../util/logger.js";
 import { getDb } from "./db.js";
-import { CAPABILITY_CARD_CATEGORIES } from "./job-handlers/capability-cards.js";
 import { enqueueMemoryJob } from "./jobs-store.js";
 import { rawGet } from "./raw-query.js";
 import { memoryCheckpoints, memoryJobs } from "./schema.js";
 
-const log = getLogger("thread-starters-cadence");
+const log = getLogger("conversation-starters-cadence");
 
 /**
  * Check whether enough new memory items have accumulated to justify
- * generating a fresh batch of thread starters and capability cards.
+ * generating a fresh batch of conversation starters.
  */
-export function maybeEnqueueThreadStartersJob(scopeId: string): void {
+export function maybeEnqueueConversationStartersJob(scopeId: string): void {
   const db = getDb();
 
   // Count total active memory items
@@ -32,7 +31,7 @@ export function maybeEnqueueThreadStartersJob(scopeId: string): void {
   if (totalActive === 0) return;
 
   // Read checkpoint: item count at last generation (scoped so each scope tracks independently)
-  const checkpointKey = `thread_starters:item_count_at_last_gen:${scopeId}`;
+  const checkpointKey = `conversation_starters:item_count_at_last_gen:${scopeId}`;
   const checkpoint = db
     .select({ value: memoryCheckpoints.value })
     .from(memoryCheckpoints)
@@ -59,7 +58,7 @@ export function maybeEnqueueThreadStartersJob(scopeId: string): void {
     .from(memoryJobs)
     .where(
       and(
-        eq(memoryJobs.type, "generate_thread_starters"),
+        eq(memoryJobs.type, "generate_conversation_starters"),
         inArray(memoryJobs.status, ["pending", "running"]),
         like(memoryJobs.payload, `%"scopeId":"${scopeId}"%`),
       ),
@@ -67,41 +66,9 @@ export function maybeEnqueueThreadStartersJob(scopeId: string): void {
     .get();
   if (existing) return;
 
-  enqueueMemoryJob("generate_thread_starters", { scopeId });
+  enqueueMemoryJob("generate_conversation_starters", { scopeId });
   log.info(
     { totalActive, lastCount, delta, threshold, scopeId },
-    "Enqueued thread starters generation job",
+    "Enqueued conversation starters generation job",
   );
-
-  // Also enqueue capability card regeneration for all categories
-  maybeEnqueueCapabilityCardJobs(scopeId);
-}
-
-/**
- * Enqueue capability card generation jobs for all categories.
- * Skips categories that already have pending/running jobs.
- */
-function maybeEnqueueCapabilityCardJobs(scopeId: string): void {
-  const db = getDb();
-
-  for (const category of CAPABILITY_CARD_CATEGORIES) {
-    const existing = db
-      .select({ id: memoryJobs.id })
-      .from(memoryJobs)
-      .where(
-        and(
-          eq(memoryJobs.type, "generate_capability_cards"),
-          inArray(memoryJobs.status, ["pending", "running"]),
-          like(memoryJobs.payload, `%"scopeId":"${scopeId}"%`),
-          like(memoryJobs.payload, `%"category":"${category}"%`),
-        ),
-      )
-      .get();
-
-    if (!existing) {
-      enqueueMemoryJob("generate_capability_cards", { scopeId, category });
-    }
-  }
-
-  log.info({ scopeId }, "Enqueued capability card generation jobs");
 }