@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/memory/llm-request-log-store.ts

@@ -24,9 +24,23 @@ import {
   getTurnTimeBounds,
   messageMetadataSchema,
 } from "./conversation-crud.js";
-import { getDb } from "./db-connection.js";
+import { type DrizzleDb, getDb, getLogsDb } from "./db-connection.js";
 import { llmRequestLogs, messages } from "./schema.js";
 
+/**
+ * The logs connection (`assistant-logs.db`), where `llm_request_logs` lives.
+ * Throws if the file cannot be opened — the store has no fallback, and a
+ * missing logs DB is a genuine failure for these call sites (insert/read of
+ * request logs). Callers that must not fail on this already wrap in try/catch.
+ */
+function logsDb(): DrizzleDb {
+  const db = getLogsDb();
+  if (!db) {
+    throw new Error("logs database unavailable");
+  }
+  return db;
+}
+
 export type LogRow = {
   id: string;
   conversationId: string;
@@ -111,7 +125,7 @@ export function recordRequestLog(
   provider?: string,
   callSite?: LLMCallSite,
 ): string {
-  const db = getDb();
+  const db = logsDb();
   const id = uuid();
   db.insert(llmRequestLogs)
     .values({
@@ -178,7 +192,7 @@ export function recordSyntheticAgentErrorMessageLog(args: {
   preparedRequest: unknown | null;
   createdAt: number;
 }): string {
-  const db = getDb();
+  const db = logsDb();
   const id = uuid();
   const requestPayload = JSON.stringify({
     syntheticAgentErrorMessage: {
@@ -225,7 +239,7 @@ export function setAgentLoopExitReasonOnLatestLog(
   conversationId: string,
   reason: string,
 ): void {
-  const db = getDb();
+  const db = logsDb();
   const latest = db
     .select({ id: llmRequestLogs.id })
     .from(llmRequestLogs)
@@ -249,7 +263,7 @@ export function backfillMessageIdOnLogs(
   conversationId: string,
   messageId: string,
 ): void {
-  const db = getDb();
+  const db = logsDb();
   db.update(llmRequestLogs)
     .set({ messageId })
     .where(
@@ -272,7 +286,7 @@ export function relinkLlmRequestLogs(
   toMessageId: string,
 ): void {
   if (fromMessageIds.length === 0) return;
-  const db = getDb();
+  const db = logsDb();
   db.update(llmRequestLogs)
     .set({ messageId: toMessageId })
     .where(inArray(llmRequestLogs.messageId, fromMessageIds))
@@ -286,7 +300,7 @@ export function relinkLlmRequestLogs(
  */
 function selectLogsByMessageIds(messageIds: string[]): LogRow[] {
   if (messageIds.length === 0) return [];
-  const db = getDb();
+  const db = logsDb();
   return db
     .select({
       id: llmRequestLogs.id,
@@ -314,7 +328,7 @@ function selectLogsByMessageIds(messageIds: string[]): LogRow[] {
 export function getRequestLogsByConversationId(
   conversationId: string,
 ): LogRow[] {
-  const db = getDb();
+  const db = logsDb();
   return db
     .select({
       id: llmRequestLogs.id,
@@ -346,9 +360,13 @@ function selectOrphanedLogsInRange(
   endTime: number,
 ): LogRow[] {
   if (endTime <= startTime) return [];
-  const db = getDb();
-  // LEFT JOIN messages → filter where message row IS NULL (orphaned).
-  return db
+  // `llm_request_logs` and `messages` live in separate connections now, so the
+  // old LEFT JOIN can't span them. Resolve it in three steps:
+  //   (a) logs conn → candidate rows in [start,end] for the conversation with a
+  //       non-NULL message_id;
+  //   (b) main conn → which of those message_ids still exist in `messages`;
+  //   (c) filter to candidates whose message_id is NOT in the existing set.
+  const candidates = logsDb()
     .select({
       id: llmRequestLogs.id,
       conversationId: llmRequestLogs.conversationId,
@@ -361,18 +379,32 @@ function selectOrphanedLogsInRange(
       callSite: llmRequestLogs.callSite,
     })
     .from(llmRequestLogs)
-    .leftJoin(messages, eq(llmRequestLogs.messageId, messages.id))
     .where(
       and(
         eq(llmRequestLogs.conversationId, conversationId),
         gte(llmRequestLogs.createdAt, startTime),
         lte(llmRequestLogs.createdAt, endTime),
-        sql`${messages.id} IS NULL`,
         sql`${llmRequestLogs.messageId} IS NOT NULL`,
       ),
     )
     .orderBy(llmRequestLogs.createdAt)
     .all();
+  if (candidates.length === 0) return [];
+
+  const candidateMessageIds = [
+    ...new Set(candidates.map((c) => c.messageId as string)),
+  ];
+  const existing = new Set(
+    getDb()
+      .select({ id: messages.id })
+      .from(messages)
+      .where(inArray(messages.id, candidateMessageIds))
+      .all()
+      .map((r) => r.id),
+  );
+
+  // Orphaned = the referenced message no longer exists.
+  return candidates.filter((c) => !existing.has(c.messageId as string));
 }
 
 /**
@@ -389,7 +421,7 @@ function selectUnlinkedLogsInRange(
   endTime: number,
 ): LogRow[] {
   if (endTime <= startTime) return [];
-  const db = getDb();
+  const db = logsDb();
   return db
     .select({
       id: llmRequestLogs.id,
@@ -432,7 +464,7 @@ export function getPreviousNonCompactionCallCreatedAt(
   conversationId: string,
   beforeCreatedAt: number,
 ): number | null {
-  const db = getDb();
+  const db = logsDb();
   const row = db
     .select({ createdAt: llmRequestLogs.createdAt })
     .from(llmRequestLogs)
@@ -480,7 +512,7 @@ export function getCompactionLogsBetween(
   afterCreatedAt: number | null,
   beforeCreatedAt: number,
 ): CompactionAgentLogRow[] {
-  const db = getDb();
+  const db = logsDb();
   const predicates = [
     eq(llmRequestLogs.conversationId, conversationId),
     eq(llmRequestLogs.callSite, "compactionAgent"),
@@ -524,7 +556,7 @@ export function getCompactionLogsBetween(
  * full context window.
  */
 export function getRequestLogMetaById(logId: string): LogMetaRow | null {
-  const db = getDb();
+  const db = logsDb();
   return (
     db
       .select({
@@ -543,7 +575,7 @@ export function getRequestLogMetaById(logId: string): LogMetaRow | null {
 }
 
 export function getRequestLogById(logId: string): LogRow | null {
-  const db = getDb();
+  const db = logsDb();
   return (
     db
       .select({
@@ -609,7 +641,7 @@ export function getRequestLogsByMessageId(messageId: string): LogRow[] {
         // authoritative caller (e.g. watch-notifier).
         if (unlinkedLogs.length > 0 && turnMessageIds.length > 0) {
           try {
-            const db = getDb();
+            const db = logsDb();
             const ids = unlinkedLogs.map((l) => l.id);
             const targetMessageId = turnMessageIds[turnMessageIds.length - 1]!;
             db.update(llmRequestLogs)

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

@@ -363,6 +363,14 @@ export interface UsageGroupBreakdown {
   totalCacheReadTokens: number;
   totalEstimatedCostUsd: number;
   eventCount: number;
+  /**
+   * Number of turns in the conversation — the count of eligible user messages
+   * (tool-result turns excluded). Only populated when `groupBy ===
+   * "conversation"` (and `null` for that mode's "Other" bucket, which has no
+   * parent conversation). `null` for every other grouping, where a turn count
+   * has no well-defined meaning.
+   */
+  turnCount: number | null;
 }
 
 // -- raw row shapes returned by SQLite aggregation queries --
@@ -388,6 +396,8 @@ interface GroupRow {
   total_cache_read_tokens: number;
   total_estimated_cost_usd: number | null;
   event_count: number;
+  /** Only selected by the conversation grouping query; absent otherwise. */
+  turn_count?: number | null;
 }
 
 type UsageQueryParam = ScheduleAttributionSqlParam;
@@ -645,6 +655,9 @@ function mapGroupRow(
     totalCacheReadTokens: row.total_cache_read_tokens,
     totalEstimatedCostUsd: row.total_estimated_cost_usd ?? 0,
     eventCount: row.event_count,
+    // Turns are only meaningful per conversation; other dimensions select no
+    // turn_count column, so this collapses to null.
+    turnCount: groupBy === "conversation" ? (row.turn_count ?? null) : null,
   };
 }
 
@@ -678,7 +691,24 @@ export function getUsageGroupBreakdown(
         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
+        COALESCE(SUM(COALESCE(e.llm_call_count, 1)), 0)  AS event_count,
+        -- Number of turns in the conversation: the count of eligible user
+        -- messages (tool-result turns excluded, mirroring the turnIndex
+        -- definition). Evaluated once per conversation group via the
+        -- idx_messages_conversation_id index rather than once per usage event,
+        -- so it stays cheap as call volume grows. NULL for the "Other" (no
+        -- conversation) bucket. Note: derived from surviving messages, so a
+        -- turn removed via Undo (deleteLastExchange) stops being counted even
+        -- though its billed usage still shows up in Cost/Tokens.
+        CASE WHEN e.conversation_id IS NULL THEN NULL
+             ELSE (
+               SELECT COUNT(*) FROM messages AS m2
+               WHERE m2.conversation_id = e.conversation_id
+                 AND m2.role = 'user'
+                 AND m2.content NOT LIKE '%"type":"tool\\_result"%' ESCAPE '\\'
+                 AND m2.content NOT LIKE '%"type":"web\\_search\\_tool\\_result"%' ESCAPE '\\'
+             )
+        END                                              AS turn_count
       FROM llm_usage_events e
       LEFT JOIN conversations c ON e.conversation_id = c.id
       WHERE ${where.sql}

package/src/memory/memory-retrospective-job.ts

@@ -60,12 +60,11 @@ import {
   type ConversationRow,
   deleteConversation,
   findMostRecentRetrospectiveFor,
-  forkConversation,
+  forkConversationForRetrospective,
   getConversation,
   getMessagesAfter,
   resolveOverrideProfile,
 } from "./conversation-crud.js";
-import { isBackgroundConversationType } from "./conversation-types.js";
 import {
   enqueueMemoryJob,
   type MemoryJob,
@@ -131,7 +130,7 @@ export async function memoryRetrospectiveJob(
 // the source's turns.
 // ---------------------------------------------------------------------------
 
-async function runForkBasedRetrospective(
+export async function runForkBasedRetrospective(
   sourceConversationId: string,
   config: AssistantConfig,
 ): Promise<MemoryRetrospectiveOutcome> {
@@ -216,9 +215,14 @@ async function runForkBasedRetrospective(
   // `contextCompactedMessageCount` / `contextCompactedAt` when the fork
   // point sits within the visible window. Compacted source ⇒ compacted
   // fork ⇒ summary + tail visible to the agent natively.
-  let forkConversationRow: ReturnType<typeof forkConversation>;
+  let forkConversationRow: Awaited<
+    ReturnType<typeof forkConversationForRetrospective>
+  >;
   try {
-    forkConversationRow = forkConversation({
+    // Async variant: the source message-row copy runs off the event loop in a
+    // sqlite3 subprocess so this background pass cannot freeze the daemon's
+    // event loop (health probes / gateway IPC) on a large database.
+    forkConversationRow = await forkConversationForRetrospective({
       conversationId: sourceConversationId,
       throughMessageId: cutoffMessageId,
       source: MEMORY_RETROSPECTIVE_FORK_SOURCE,
@@ -230,7 +234,7 @@ async function runForkBasedRetrospective(
     bumpRetrospectiveLastRunAt(sourceConversationId, Date.now());
     log.error(
       { err, sourceConversationId },
-      "memory-retrospective (fork): forkConversation failed",
+      "memory-retrospective (fork): forkConversationForRetrospective failed",
     );
     throw err;
   }
@@ -314,14 +318,13 @@ async function runForkBasedRetrospective(
       // {@link WakeToolContextPin}.
       toolGateMode: "execution" as const,
       toolContextPin,
-      // Reproduce the source's turn block for message-tier cache-prefix
-      // parity: background/scheduled sources ran non-interactive live turns
-      // (which carry `<background_turn>`), so the fork must run non-interactive
-      // too. Standard/user sources ran interactive (no `<background_turn>`), so
-      // the fork stays interactive — preserving their existing byte parity.
-      isNonInteractive: isBackgroundConversationType(
-        sourceConversation.conversationType,
-      ),
+      // Message-tier cache-prefix parity — reproducing the source's
+      // `<background_turn>` / `<channel_capabilities>` / `<non_interactive_context>`
+      // blocks — is handled by metadata rehydration, not by re-running runtime
+      // injection on the fork: the source's live turns persist those blocks onto
+      // message metadata, the fork copies that metadata, and
+      // `Conversation.loadFromDb` rehydrates them byte-for-byte. The wake never
+      // re-runs the injection pipeline, so it needs no interactivity hint here.
       // Profile forcing (model/thinking/effort parity) is a separate concern
       // and stays keyed on `matchConversationProfile` via `matchedProfile`.
       ...(matchedProfile !== undefined
@@ -777,9 +780,14 @@ function extractRememberContents(messages: MessageLike[]): string[] {
       const input = b.input;
       if (!input || typeof input !== "object") continue;
       const content = (input as Record<string, unknown>).content;
-      if (typeof content !== "string") continue;
-      const trimmed = content.trim();
-      if (trimmed.length > 0) contents.push(trimmed);
+      // `remember` accepts a single string or an array of facts (batch form);
+      // flatten both so batched saves still feed the dedup baseline.
+      const facts = Array.isArray(content) ? content : [content];
+      for (const fact of facts) {
+        if (typeof fact !== "string") continue;
+        const trimmed = fact.trim();
+        if (trimmed.length > 0) contents.push(trimmed);
+      }
     }
   }
   return contents;
@@ -849,7 +857,7 @@ function buildForkInstruction({
     ? "Your review window is the full conversation above, ending just before this instruction message."
     : `Your review window starts at ${anchorDescription} and ends just before this instruction message. If you cannot locate that anchoring turn in your visible history (for example, it is behind the compaction summary), fail closed: review only the most recent visible messages after the summary, not the whole conversation.`;
 
-  return `This is an automated background memory pass over the conversation above — not a message from the user. Do not reply conversationally or in persona; just perform the review described here. Only the \`remember\` tool is available for this pass — any other tool call will be rejected, so don't attempt one.
+  return `This is an automated background memory pass over the conversation above — not a message from the user. Do not reply conversationally; just perform the review described here. Only the \`remember\` tool is available for this pass — any other tool call will be rejected, so don't attempt one.
 
 ${windowAnchor}
 
@@ -865,6 +873,6 @@ Two dedup sources to skip:
 1. Anything semantically captured in <already_remembered> above (from prior retrospective passes).
 2. Anything you already called \`remember\` on inline within your review window — those appear as \`tool_use\` blocks with \`name: "remember"\` in your history.
 
-For everything else in your review window, use the \`remember\` tool on facts, plans, decisions, preferences, names, dates, felt moments, corrections, commitments, or anything else concrete and worth carrying forward. One \`remember\` call per fact. If nothing new is worth saving, say "Nothing new to save." and stop.
+For everything else in your review window, use the \`remember\` tool on facts, plans, decisions, preferences, names, dates, felt moments, corrections, commitments, or anything else concrete and worth carrying forward. When several facts are worth saving, pass them all as an array to a single \`remember\` call rather than calling it once per fact. If nothing new is worth saving, say "Nothing new to save." and stop.
 `;
 }

package/src/memory/memory-retrospective-startup-cleanup.ts

@@ -54,7 +54,7 @@ import {
 import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
 import { deleteConversation } from "./conversation-crud.js";
-import { getDb } from "./db-connection.js";
+import { getDb, getMemoryDb } from "./db-connection.js";
 import { MEMORY_RETROSPECTIVE_SOURCES } from "./memory-retrospective-constants.js";
 import { loadRetrospectiveRunMessages } from "./memory-retrospective-fork-boundary.js";
 import { conversations, memoryJobs } from "./schema.js";
@@ -98,6 +98,14 @@ export function sweepOrphanMemoryRetrospectiveConversations(
   const cutoff = now - ORPHAN_AGE_MS;
   const db = getDb();
 
+  // `memory_jobs` lives on the dedicated memory connection. If it is unavailable
+  // we cannot tell which sources have in-flight retrospective jobs, so skip the
+  // sweep rather than risk deleting a conversation whose job is still running.
+  const memoryDb = getMemoryDb();
+  if (!memoryDb) {
+    return { swept: 0 };
+  }
+
   // Job payloads encode the SOURCE conversation id (the conversation being
   // analyzed), not the background-conversation id of the retrospective itself.
   // The background conversation links back to its source via
@@ -105,7 +113,7 @@ export function sweepOrphanMemoryRetrospectiveConversations(
   // memory-retrospective-job.ts). To protect in-flight jobs we therefore
   // compare source-id to source-id by filtering on
   // `conversations.forkParentConversationId`, not `conversations.id`.
-  const activeJobSourceConversationIds = db
+  const activeJobSourceConversationIds = memoryDb
     .select({
       conversationId: sql<string>`json_extract(${memoryJobs.payload}, '$.conversationId')`,
     })

package/src/memory/migrations/{100-core-tables.ts → 000-core-tables.ts}

@@ -3,12 +3,16 @@ import type { DrizzleDb } from "../db-connection.js";
 /**
  * Core tables: conversations, messages, tool_invocations, memory_segments,
  * memory_items, memory_item_sources, memory_item_conflicts, memory_summaries,
- * memory_embeddings, memory_jobs, memory_checkpoints, attachments,
+ * memory_embeddings, memory_jobs, attachments,
  * message_attachments, message_surfaces, channel_inbound_events,
  * message_runs, cron_jobs, cron_runs, documents,
  * published_pages, shared_app_links, home_base_app_links.
+ *
+ * The migration bookkeeping table `memory_checkpoints` is created by the
+ * migration runner (`runMigrationSteps`) before any step runs, so it is not
+ * created here.
  */
-export function createCoreTables(database: DrizzleDb): void {
+export function migrateCoreTables(database: DrizzleDb): void {
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS conversations (
       id TEXT PRIMARY KEY,
@@ -150,14 +154,6 @@ export function createCoreTables(database: DrizzleDb): void {
     )
   `);
 
-  database.run(/*sql*/ `
-    CREATE TABLE IF NOT EXISTS memory_checkpoints (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL,
-      updated_at INTEGER NOT NULL
-    )
-  `);
-
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS attachments (
       id TEXT PRIMARY KEY,

package/src/memory/migrations/104-core-indexes.ts

@@ -95,7 +95,7 @@ export function createCoreIndexes(database: DrizzleDb): void {
     /*sql*/ `DROP INDEX IF EXISTS idx_memory_embeddings_provider_model`,
   );
   // Ensure a unique constraint exists on (target_type, target_id, provider, model).
-  // New databases get this via the table-level UNIQUE in 100-core-tables.ts (autoindex),
+  // New databases get this via the table-level UNIQUE in 000-core-tables.ts (autoindex),
   // but for pre-100 databases where CREATE TABLE IF NOT EXISTS was a no-op, the autoindex
   // doesn't exist. Always create the named index — it's a no-op if it already exists and
   // harmless if an autoindex also covers these columns.