@vellumai/assistant 0.4.54 → 0.4.56

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

@@ -67,7 +67,7 @@ const PRUNE_BATCH_LIMIT = 100;
  *
  * Tables with onDelete cascade on conversation FK (memory_segments,
  * conversation_keys, channel_inbound_events, message_runs, call_sessions,
- * external_conversation_bindings, assistant_inbox_thread_state) are handled
+ * external_conversation_bindings, assistant_inbox_conversation_state) are handled
  * automatically. Tables without cascade (messages, tool_invocations,
  * llm_request_logs) are deleted explicitly before removing the conversation row.
  */

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

@@ -0,0 +1,348 @@
+/**
+ * Job handler for generating thread starters.
+ *
+ * Crosses user memory items with the skill catalog to produce personalized
+ * suggestion chips shown on the empty thread page.
+ */
+
+import { and, desc, eq } from "drizzle-orm";
+import { v4 as uuid } from "uuid";
+
+import { loadSkillCatalog } from "../../config/skills.js";
+import {
+  createTimeout,
+  extractToolUse,
+  getConfiguredProvider,
+  userMessage,
+} from "../../providers/provider-send-message.js";
+import { getLogger } from "../../util/logger.js";
+import { truncate } from "../../util/truncate.js";
+import { getDb } from "../db.js";
+import { asString } from "../job-utils.js";
+import type { MemoryJob } from "../jobs-store.js";
+import { rawAll, rawGet } from "../raw-query.js";
+import { memoryCheckpoints, memoryItems, threadStarters } from "../schema.js";
+
+const log = getLogger("thread-starters-gen");
+
+function checkpointKey(base: string, scopeId: string): string {
+  return `${base}:${scopeId}`;
+}
+
+const CK_ITEM_COUNT = "thread_starters:item_count_at_last_gen";
+const CK_BATCH = "thread_starters:generation_batch";
+const CK_LAST_GEN_AT = "thread_starters:last_gen_at";
+
+// ── Rollup construction ───────────────────────────────────────────
+
+export function buildMemoryRollup(scopeId: string): string {
+  const db = getDb();
+  const items = db
+    .select({
+      kind: memoryItems.kind,
+      subject: memoryItems.subject,
+      statement: memoryItems.statement,
+      importance: memoryItems.importance,
+    })
+    .from(memoryItems)
+    .where(
+      and(eq(memoryItems.status, "active"), eq(memoryItems.scopeId, scopeId)),
+    )
+    .orderBy(desc(memoryItems.importance))
+    .limit(60)
+    .all();
+
+  if (items.length === 0) return "";
+
+  const byKind = new Map<string, string[]>();
+  for (const item of items) {
+    let lines = byKind.get(item.kind);
+    if (!lines) {
+      lines = [];
+      byKind.set(item.kind, lines);
+    }
+    lines.push(`- ${item.subject}: ${item.statement}`);
+  }
+
+  let rollup = "";
+  for (const [kind, lines] of byKind) {
+    rollup += `## ${kind}\n${lines.join("\n")}\n\n`;
+  }
+  return truncate(rollup, 6000, "");
+}
+
+function buildNewItemsDiff(scopeId: string): string {
+  const db = getDb();
+  const checkpoint = db
+    .select({ value: memoryCheckpoints.value })
+    .from(memoryCheckpoints)
+    .where(eq(memoryCheckpoints.key, checkpointKey(CK_LAST_GEN_AT, scopeId)))
+    .get();
+  const lastGenAt = checkpoint ? parseInt(checkpoint.value, 10) : 0;
+
+  if (lastGenAt === 0) return ""; // No previous generation — skip diff
+
+  const newItems = rawAll<{
+    kind: string;
+    subject: string;
+    statement: string;
+  }>(
+    `SELECT kind, subject, statement FROM memory_items
+     WHERE status = 'active' AND scope_id = ? AND first_seen_at > ?
+     ORDER BY first_seen_at DESC LIMIT 20`,
+    scopeId,
+    lastGenAt,
+  );
+
+  if (newItems.length === 0) return "";
+
+  return (
+    "## New since last generation\n" +
+    newItems.map((i) => `- (${i.kind}) ${i.subject}: ${i.statement}`).join("\n")
+  );
+}
+
+export function buildSkillsSummary(): string {
+  try {
+    const catalog = loadSkillCatalog();
+    if (catalog.length === 0) return "";
+
+    const lines = catalog
+      .filter((s) => s.description && s.displayName)
+      .map((s) => {
+        const emoji = s.emoji ? `${s.emoji} ` : "";
+        const hints = s.activationHints?.length
+          ? ` (hints: ${s.activationHints.join(", ")})`
+          : "";
+        return `- ${emoji}${s.displayName}: ${s.description}${hints}`;
+      });
+
+    return `## Available skills\n${lines.join("\n")}`;
+  } catch {
+    return "";
+  }
+}
+
+// ── LLM generation ────────────────────────────────────────────────
+
+/** Capability categories matching the Intelligence page taxonomy. */
+export const THREAD_STARTER_CATEGORIES = [
+  "communication",
+  "productivity",
+  "development",
+  "media",
+  "automation",
+  "web_social",
+  "knowledge",
+  "integration",
+] as const;
+
+export type ThreadStarterCategory = (typeof THREAD_STARTER_CATEGORIES)[number];
+
+interface GeneratedStarter {
+  label: string;
+  prompt: string;
+  category: string;
+}
+
+async function generateStarters(scopeId: string): Promise<GeneratedStarter[]> {
+  const provider = await getConfiguredProvider();
+  if (!provider) {
+    log.info("No configured provider for thread starters generation");
+    return [];
+  }
+
+  const rollup = buildMemoryRollup(scopeId);
+  if (!rollup) {
+    log.info("No memory items to generate thread starters from");
+    return [];
+  }
+  const diff = buildNewItemsDiff(scopeId);
+  const skills = buildSkillsSummary();
+
+  const systemPrompt = `You are generating thread starter suggestions for a personal AI assistant's empty conversation page. These are clickable chips that help the user discover what the assistant can do, personalized to their context.
+
+Given the user's accumulated memories and the assistant's available skills, generate 4-6 thread starters. Each starter has:
+- label: Short chip text (max 50 chars). Start with a verb. Be specific and actionable.
+- prompt: The full message that will be sent when clicked (1-2 natural sentences).
+- category: One of: ${THREAD_STARTER_CATEGORIES.join(", ")}. Pick the best-fit capability category.
+
+Rules:
+- Cross user context (who they are, what they work on) with assistant capabilities (skills).
+- Be specific to THIS user — generic suggestions like "Tell me a joke" are not useful.
+- Vary across different skills and memory categories.
+- Labels should be concise and scannable.
+- Prompts should be natural, as if the user typed them.
+
+${rollup}
+${diff}
+${skills}`;
+
+  const { signal, cleanup } = createTimeout(20000);
+  try {
+    const response = await provider.sendMessage(
+      [
+        userMessage(
+          "Generate personalized thread starters based on my context.",
+        ),
+      ],
+      [
+        {
+          name: "store_thread_starters",
+          description: "Store generated thread starter suggestions",
+          input_schema: {
+            type: "object" as const,
+            properties: {
+              starters: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    label: {
+                      type: "string",
+                      description:
+                        "Short chip text (max 50 chars, starts with a verb)",
+                    },
+                    prompt: {
+                      type: "string",
+                      description: "Full message sent on click (1-2 sentences)",
+                    },
+                    category: {
+                      type: "string",
+                      enum: [...THREAD_STARTER_CATEGORIES],
+                      description: "Capability category for grouping",
+                    },
+                  },
+                  required: ["label", "prompt", "category"],
+                },
+              },
+            },
+            required: ["starters"],
+          },
+        },
+      ],
+      systemPrompt,
+      {
+        config: {
+          modelIntent: "quality-optimized",
+          max_tokens: 1024,
+          tool_choice: { type: "tool" as const, name: "store_thread_starters" },
+        },
+        signal,
+      },
+    );
+    cleanup();
+
+    const toolBlock = extractToolUse(response);
+    if (!toolBlock) {
+      log.warn("No tool_use block in thread starters generation response");
+      return [];
+    }
+
+    const input = toolBlock.input as { starters?: GeneratedStarter[] };
+    if (!Array.isArray(input.starters)) {
+      log.warn("Invalid starters in generation response");
+      return [];
+    }
+
+    return input.starters
+      .filter(
+        (s) =>
+          typeof s.label === "string" &&
+          s.label.length > 0 &&
+          typeof s.prompt === "string" &&
+          s.prompt.length > 0,
+      )
+      .map((s) => ({
+        label: truncate(s.label, 50, ""),
+        prompt: truncate(s.prompt, 500, ""),
+        category:
+          typeof s.category === "string" &&
+          (THREAD_STARTER_CATEGORIES as readonly string[]).includes(s.category)
+            ? s.category
+            : "productivity",
+      }));
+  } catch (err) {
+    cleanup();
+    throw err;
+  }
+}
+
+// ── Job handler ───────────────────────────────────────────────────
+
+export async function generateThreadStartersJob(job: MemoryJob): Promise<void> {
+  const scopeId = asString(job.payload.scopeId) ?? "default";
+
+  const starters = await generateStarters(scopeId);
+  if (starters.length === 0) {
+    log.info({ scopeId }, "No thread starters generated");
+    return;
+  }
+
+  const db = getDb();
+  const now = Date.now();
+
+  // Determine next batch number
+  const batchCheckpoint = db
+    .select({ value: memoryCheckpoints.value })
+    .from(memoryCheckpoints)
+    .where(eq(memoryCheckpoints.key, checkpointKey(CK_BATCH, scopeId)))
+    .get();
+  const nextBatch = batchCheckpoint
+    ? parseInt(batchCheckpoint.value, 10) + 1
+    : 1;
+
+  // Collect the memory kinds that informed this batch
+  const kindRows = db
+    .select({ kind: memoryItems.kind })
+    .from(memoryItems)
+    .where(
+      and(eq(memoryItems.status, "active"), eq(memoryItems.scopeId, scopeId)),
+    )
+    .groupBy(memoryItems.kind)
+    .all();
+  const sourceKinds = kindRows.map((r) => r.kind).join(",");
+
+  // Insert starters
+  for (const starter of starters) {
+    db.insert(threadStarters)
+      .values({
+        id: uuid(),
+        label: starter.label,
+        prompt: starter.prompt,
+        category: starter.category,
+        generationBatch: nextBatch,
+        scopeId,
+        sourceMemoryKinds: sourceKinds,
+        createdAt: now,
+      })
+      .run();
+  }
+
+  // Count active items for checkpoint
+  const countRow = rawGet<{ c: number }>(
+    `SELECT COUNT(*) AS c FROM memory_items WHERE status = 'active' AND scope_id = ?`,
+    scopeId,
+  );
+  const totalActive = countRow?.c ?? 0;
+
+  // Update all three checkpoints
+  const upsertCheckpoint = (key: string, value: string) => {
+    db.insert(memoryCheckpoints)
+      .values({ key, value, updatedAt: now })
+      .onConflictDoUpdate({
+        target: memoryCheckpoints.key,
+        set: { value, updatedAt: now },
+      })
+      .run();
+  };
+
+  upsertCheckpoint(checkpointKey(CK_ITEM_COUNT, scopeId), String(totalActive));
+  upsertCheckpoint(checkpointKey(CK_BATCH, scopeId), String(nextBatch));
+  upsertCheckpoint(checkpointKey(CK_LAST_GEN_AT, scopeId), String(now));
+
+  log.info(
+    { scopeId, batch: nextBatch, count: starters.length },
+    "Generated thread starters",
+  );
+}

package/src/memory/jobs-store.ts

@@ -25,7 +25,9 @@ export type MemoryJobType =
   | "delete_qdrant_vectors"
   | "media_processing"
   | "embed_media"
-  | "embed_attachment";
+  | "embed_attachment"
+  | "generate_thread_starters"
+  | "generate_capability_cards";
 
 const EMBED_JOB_TYPES: MemoryJobType[] = [
   "embed_segment",
@@ -345,16 +347,11 @@ export function failMemoryJob(
 
 export function resetRunningJobsToPending(): number {
   const db = getDb();
-  const runningRows = db
-    .select({ id: memoryJobs.id })
-    .from(memoryJobs)
-    .where(eq(memoryJobs.status, "running"))
-    .all();
   db.update(memoryJobs)
     .set({ status: "pending", updatedAt: Date.now() })
     .where(eq(memoryJobs.status, "running"))
     .run();
-  return runningRows.length;
+  return rawChanges();
 }
 
 /**

package/src/memory/jobs-worker.ts

@@ -3,6 +3,7 @@ import type { AssistantConfig } from "../config/types.js";
 import { getLogger } from "../util/logger.js";
 import { rawRun } from "./db.js";
 import { backfillJob } from "./job-handlers/backfill.js";
+import { generateCapabilityCardsJob } from "./job-handlers/capability-cards.js";
 import {
   cleanupStaleSupersededItemsJob,
   pruneOldConversationsJob,
@@ -22,6 +23,7 @@ import {
 } from "./job-handlers/index-maintenance.js";
 import { mediaProcessingJob } from "./job-handlers/media-processing.js";
 import { buildConversationSummaryJob } from "./job-handlers/summarization.js";
+import { generateThreadStartersJob } from "./job-handlers/thread-starters.js";
 import {
   BackendUnavailableError,
   classifyError,
@@ -306,6 +308,12 @@ async function processJob(
     case "embed_attachment":
       await embedAttachmentJob(job, config);
       return;
+    case "generate_thread_starters":
+      await generateThreadStartersJob(job);
+      return;
+    case "generate_capability_cards":
+      await generateCapabilityCardsJob(job);
+      return;
     default:
       throw new Error(
         `Unknown memory job type: ${(job as { type: string }).type}`,

package/src/memory/migrations/033-scoped-approval-grants.ts

@@ -26,11 +26,11 @@ export function createScopedApprovalGrantsTable(database: DrizzleDb): void {
       requester_external_user_id TEXT,
       guardian_external_user_id TEXT,
       status TEXT NOT NULL,
-      expires_at TEXT NOT NULL,
-      consumed_at TEXT,
+      expires_at INTEGER NOT NULL,
+      consumed_at INTEGER,
       consumed_by_request_id TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
     )
   `);
 

package/src/memory/migrations/102-alter-table-columns.ts

@@ -256,6 +256,11 @@ export function addCoreColumns(database: DrizzleDb): void {
   } catch {
     /* already exists */
   }
+  try {
+    database.run(/*sql*/ `ALTER TABLE attachments ADD COLUMN file_path TEXT`);
+  } catch {
+    /* already exists */
+  }
 
   // cron_jobs
   try {

package/src/memory/migrations/105-contacts-and-triage.ts

@@ -8,6 +8,9 @@ export function createContactsAndTriageTables(database: DrizzleDb): void {
   // — dropped by migration 134 (contacts-notes-column). Omitting them here keeps
   //   the CREATE TABLE idempotent when initializeDb() runs a second time (e.g. the
   //   "daemon restart" tests) after migration 134 has already dropped them.
+  // Index removed: idx_contacts_last_interaction — the last_interaction column is
+  //   dropped by migration 159. Omitting the index avoids re-creating it on fresh
+  //   databases only for migration 159 to immediately drop it.
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS contacts (
       id TEXT PRIMARY KEY,
@@ -33,9 +36,6 @@ export function createContactsAndTriageTables(database: DrizzleDb): void {
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_contacts_display_name ON contacts(display_name)`,
   );
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_contacts_last_interaction ON contacts(last_interaction DESC)`,
-  );
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_contact_channels_contact_id ON contact_channels(contact_id)`,
   );

package/src/memory/migrations/111-media-assets.ts

@@ -1,8 +1,7 @@
 import type { DrizzleDb } from "../db-connection.js";
 
 /**
- * Media assets, processing stages, keyframes, vision outputs,
- * timelines, events, tracking profiles, and event feedback tables with indexes.
+ * Media assets, processing stages, and keyframes tables with indexes.
  */
 export function createMediaAssetsTables(database: DrizzleDb): void {
   database.run(/*sql*/ `
@@ -64,108 +63,4 @@ export function createMediaAssetsTables(database: DrizzleDb): void {
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_keyframes_asset_timestamp ON media_keyframes(asset_id, timestamp)`,
   );
-
-  database.run(/*sql*/ `
-    CREATE TABLE IF NOT EXISTS media_vision_outputs (
-      id TEXT PRIMARY KEY,
-      asset_id TEXT NOT NULL REFERENCES media_assets(id) ON DELETE CASCADE,
-      keyframe_id TEXT NOT NULL REFERENCES media_keyframes(id) ON DELETE CASCADE,
-      analysis_type TEXT NOT NULL,
-      output TEXT NOT NULL,
-      confidence REAL,
-      created_at INTEGER NOT NULL
-    )
-  `);
-
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_vision_outputs_asset_id ON media_vision_outputs(asset_id)`,
-  );
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_vision_outputs_keyframe_id ON media_vision_outputs(keyframe_id)`,
-  );
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_vision_outputs_asset_type ON media_vision_outputs(asset_id, analysis_type)`,
-  );
-
-  database.run(/*sql*/ `
-    CREATE TABLE IF NOT EXISTS media_timelines (
-      id TEXT PRIMARY KEY,
-      asset_id TEXT NOT NULL REFERENCES media_assets(id) ON DELETE CASCADE,
-      start_time REAL NOT NULL,
-      end_time REAL NOT NULL,
-      segment_type TEXT NOT NULL,
-      attributes TEXT,
-      confidence REAL,
-      created_at INTEGER NOT NULL
-    )
-  `);
-
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_timelines_asset_id ON media_timelines(asset_id)`,
-  );
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_timelines_asset_time ON media_timelines(asset_id, start_time)`,
-  );
-
-  database.run(/*sql*/ `
-    CREATE TABLE IF NOT EXISTS media_events (
-      id TEXT PRIMARY KEY,
-      asset_id TEXT NOT NULL REFERENCES media_assets(id) ON DELETE CASCADE,
-      event_type TEXT NOT NULL,
-      start_time REAL NOT NULL,
-      end_time REAL NOT NULL,
-      confidence REAL NOT NULL,
-      reasons TEXT NOT NULL,
-      metadata TEXT,
-      created_at INTEGER NOT NULL
-    )
-  `);
-
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_events_asset_id ON media_events(asset_id)`,
-  );
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_events_asset_type ON media_events(asset_id, event_type)`,
-  );
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_events_confidence ON media_events(confidence DESC)`,
-  );
-
-  database.run(/*sql*/ `
-    CREATE TABLE IF NOT EXISTS media_tracking_profiles (
-      id TEXT PRIMARY KEY,
-      asset_id TEXT NOT NULL REFERENCES media_assets(id) ON DELETE CASCADE,
-      capabilities TEXT NOT NULL,
-      created_at INTEGER NOT NULL
-    )
-  `);
-
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_tracking_profiles_asset_id ON media_tracking_profiles(asset_id)`,
-  );
-
-  database.run(/*sql*/ `
-    CREATE TABLE IF NOT EXISTS media_event_feedback (
-      id TEXT PRIMARY KEY,
-      asset_id TEXT NOT NULL REFERENCES media_assets(id) ON DELETE CASCADE,
-      event_id TEXT NOT NULL REFERENCES media_events(id) ON DELETE CASCADE,
-      feedback_type TEXT NOT NULL,
-      original_start_time REAL,
-      original_end_time REAL,
-      corrected_start_time REAL,
-      corrected_end_time REAL,
-      notes TEXT,
-      created_at INTEGER NOT NULL
-    )
-  `);
-
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_event_feedback_asset_id ON media_event_feedback(asset_id)`,
-  );
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_event_feedback_event_id ON media_event_feedback(event_id)`,
-  );
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_event_feedback_type ON media_event_feedback(asset_id, feedback_type)`,
-  );
 }

package/src/memory/migrations/121-canonical-guardian-requests.ts

@@ -27,9 +27,9 @@ export function createCanonicalGuardianTables(database: DrizzleDb): void {
       answer_text TEXT,
       decided_by_external_user_id TEXT,
       followup_state TEXT,
-      expires_at TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
+      expires_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
     )
   `);
 
@@ -61,8 +61,8 @@ export function createCanonicalGuardianTables(database: DrizzleDb): void {
       destination_chat_id TEXT,
       destination_message_id TEXT,
       status TEXT NOT NULL DEFAULT 'pending',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
     )
   `);
 

package/src/memory/migrations/159-drop-contact-interaction-columns.ts

@@ -8,6 +8,11 @@ export function migrateDropContactInteractionColumns(
   } catch {
     /* already dropped or doesn't exist */
   }
+
+  // Drop the index on last_interaction before dropping the column — SQLite
+  // rejects ALTER TABLE DROP COLUMN when a dependent index exists.
+  database.run(/*sql*/ `DROP INDEX IF EXISTS idx_contacts_last_interaction`);
+
   try {
     database.run(/*sql*/ `ALTER TABLE contacts DROP COLUMN last_interaction`);
   } catch {

package/src/memory/migrations/161-drop-orphaned-media-tables.ts

@@ -0,0 +1,18 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Drop orphaned media tables that are no longer used.
+ *
+ * These tables were previously created by 111-media-assets.ts but the CREATE
+ * TABLE statements were removed in PR #16739. This migration cleans up
+ * existing databases that still have them.
+ */
+export function migrateDropOrphanedMediaTables(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS media_vision_outputs`);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS media_timelines`);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS media_events`);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS media_tracking_profiles`);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS media_event_feedback`);
+}