@vellumai/assistant 0.8.3 → 0.8.5

package/src/memory/conversation-crud.ts

@@ -24,6 +24,7 @@ import type { ChannelId, InterfaceId } from "../channels/types.js";
 import { parseChannelId, parseInterfaceId } from "../channels/types.js";
 import { CHANNEL_IDS, isChannelId } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
+import { findDisplayTurnEndIndex } from "../conversations/message-consolidation.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { UserError } from "../util/errors.js";
 import { safeParseRecord } from "../util/json.js";
@@ -47,10 +48,11 @@ import {
 } from "./conversation-disk-view.js";
 import { ensureDisplayOrderMigration } from "./conversation-display-order-migration.js";
 import { ensureGroupMigration } from "./conversation-group-migration.js";
+import { runAsyncSqlite } from "./db-async-query.js";
 import { getDb, getSqliteFrom } from "./db-connection.js";
 import { forkGraphMemoryState } from "./graph/graph-memory-state-store.js";
 import { indexMessageNow } from "./indexer.js";
-import { MEMORY_RETROSPECTIVE_SOURCE } from "./memory-retrospective-constants.js";
+import { MEMORY_RETROSPECTIVE_SOURCES } from "./memory-retrospective-constants.js";
 import { forkRetrospectiveState } from "./memory-retrospective-state.js";
 import { rawExec, rawGet, rawRun } from "./raw-query.js";
 import {
@@ -190,6 +192,7 @@ export interface ConversationRow {
   contextSummary: string | null;
   contextCompactedMessageCount: number;
   contextCompactedAt: number | null;
+  historyStrippedAt: number | null;
   slackContextCompactionWatermarkTs: string | null;
   slackContextCompactionWatermarkAt: number | null;
   conversationType: string;
@@ -206,6 +209,7 @@ export interface ConversationRow {
   inferenceProfile: string | null;
   inferenceProfileSessionId: string | null;
   inferenceProfileExpiresAt: number | null;
+  lastNotifiedInferenceProfile: string | null;
 }
 
 export const parseConversation = createRowMapper<
@@ -222,6 +226,7 @@ export const parseConversation = createRowMapper<
   contextSummary: "contextSummary",
   contextCompactedMessageCount: "contextCompactedMessageCount",
   contextCompactedAt: "contextCompactedAt",
+  historyStrippedAt: "historyStrippedAt",
   slackContextCompactionWatermarkTs: "slackContextCompactionWatermarkTs",
   slackContextCompactionWatermarkAt: "slackContextCompactionWatermarkAt",
   conversationType: "conversationType",
@@ -238,6 +243,7 @@ export const parseConversation = createRowMapper<
   inferenceProfile: "inferenceProfile",
   inferenceProfileSessionId: "inferenceProfileSessionId",
   inferenceProfileExpiresAt: "inferenceProfileExpiresAt",
+  lastNotifiedInferenceProfile: "lastNotifiedInferenceProfile",
 });
 
 export interface MessageRow {
@@ -482,7 +488,7 @@ export function findMostRecentRetrospectiveFor(
       .from(conversations)
       .where(
         and(
-          eq(conversations.source, MEMORY_RETROSPECTIVE_SOURCE),
+          inArray(conversations.source, MEMORY_RETROSPECTIVE_SOURCES),
           eq(conversations.forkParentConversationId, currentId),
         ),
       )
@@ -535,6 +541,32 @@ function getConversationGroupId(conversationId: string): string | null {
 export function forkConversation(params: {
   conversationId: string;
   throughMessageId?: string;
+  /**
+   * Override the fork's `source` column. Defaults to the standard
+   * `createConversation` default (`"user"`). Used by fork-based memory
+   * retrospectives to mark the fork as a retrospective artifact distinct
+   * from a user-initiated fork, so dedup and cleanup queries can scope
+   * correctly.
+   */
+  source?: string;
+  /**
+   * Optional title for the fork. Defaults to `<parent title> (Fork)`.
+   */
+  title?: string;
+  /**
+   * Override the fork's `conversationType` column. Defaults to `"standard"`.
+   * Used by fork-based memory retrospectives to bucket the fork as a
+   * `"background"` conversation so it doesn't surface in the user's
+   * conversation list.
+   */
+  conversationType?: ConversationCreateType;
+  /**
+   * Override the fork's `groupId`. Defaults to the parent conversation's
+   * group (or `"system:all"` when the parent has none). Used by fork-based
+   * memory retrospectives to route the fork into a dedicated background
+   * group.
+   */
+  groupId?: string;
 }): ConversationRow {
   const { conversationId, throughMessageId } = params;
   const db = getDb();
@@ -551,17 +583,30 @@ export function forkConversation(params: {
     );
   }
 
-  const copyBoundaryIndex =
+  const initialBoundaryIndex =
     throughMessageId == null
       ? sourceMessages.length - 1
       : sourceMessages.findIndex((message) => message.id === throughMessageId);
 
-  if (throughMessageId != null && copyBoundaryIndex === -1) {
+  if (throughMessageId != null && initialBoundaryIndex === -1) {
     throw new UserError(
       `Message ${throughMessageId} does not belong to conversation ${conversationId}`,
     );
   }
 
+  // Extend the boundary to cover the full display turn the client
+  // addressed. The read-path collapses each assistant turn across
+  // multiple DB rows — consecutive assistant rows AND tool-result-only
+  // user rows between them — so "fork through message X" semantically
+  // means "fork through the entire display turn containing X" no matter
+  // which DB row in the cluster the client supplied. Single source of
+  // truth is `findDisplayTurnEndIndex`, shared with the read path so
+  // both stay in sync.
+  const copyBoundaryIndex = findDisplayTurnEndIndex(
+    sourceMessages,
+    initialBoundaryIndex,
+  );
+
   const visibleWindowStartIndex = Math.max(
     0,
     Math.min(
@@ -576,8 +621,20 @@ export function forkConversation(params: {
     copyBoundaryIndex >= 0
       ? sourceMessages.slice(0, copyBoundaryIndex + 1)
       : ([] as MessageRow[]);
+
+  // Inherit the history-strip marker only when the fork boundary is at-or-
+  // after the strip event. Pre-strip forks branch from history that pre-
+  // dates the strip, so the marker would be a no-op and is misleading to
+  // copy.
+  const sourceHistoryStrippedAt = sourceConversation.historyStrippedAt ?? null;
+  const boundaryMessageCreatedAt = messagesToCopy.at(-1)?.createdAt ?? null;
+  const inheritsHistoryStrippedAt =
+    sourceHistoryStrippedAt != null &&
+    boundaryMessageCreatedAt != null &&
+    boundaryMessageCreatedAt >= sourceHistoryStrippedAt;
   const forkParentMessageId = messagesToCopy.at(-1)?.id ?? null;
-  const forkTitle = `${sourceConversation.title ?? "Untitled"} (Fork)`;
+  const forkTitle =
+    params.title ?? `${sourceConversation.title ?? "Untitled"} (Fork)`;
 
   // Collect disk-sync work to run after the transaction commits.
   const diskSyncQueue: Array<{
@@ -597,8 +654,9 @@ export function forkConversation(params: {
   const forkedConversation = db.transaction(() => {
     const fc = createConversation({
       title: forkTitle,
-      conversationType: "standard",
-      groupId: parentGroupId ?? "system:all",
+      conversationType: params.conversationType ?? "standard",
+      groupId: params.groupId ?? parentGroupId ?? "system:all",
+      ...(params.source != null ? { source: params.source } : {}),
     });
 
     db.update(conversations)
@@ -620,6 +678,9 @@ export function forkConversation(params: {
         slackContextCompactionWatermarkAt: preserveSourceCompactionState
           ? sourceConversation.slackContextCompactionWatermarkAt
           : null,
+        historyStrippedAt: inheritsHistoryStrippedAt
+          ? sourceHistoryStrippedAt
+          : null,
         inferenceProfile: sourceConversation.inferenceProfile,
       })
       .where(eq(conversations.id, fc.id))
@@ -1229,10 +1290,14 @@ interface PaginatedMessagesResult {
   hasMore: boolean;
 }
 
+const PAGINATION_CHUNK_MIN = 50;
+const PAGINATION_SCAN_CAP = 10_000;
+
 export function getMessagesPaginated(
   conversationId: string,
   limit: number | undefined,
   beforeTimestamp?: number,
+  filter?: (row: MessageRow) => boolean,
 ): PaginatedMessagesResult {
   const db = getDb();
 
@@ -1248,51 +1313,69 @@ export function getMessagesPaginated(
       .orderBy(asc(messages.createdAt))
       .all()
       .map(parseMessage);
-    return { messages: rows, hasMore: false };
+    return {
+      messages: filter ? rows.filter(filter) : rows,
+      hasMore: false,
+    };
   }
 
-  const conditions = [eq(messages.conversationId, conversationId)];
-  if (beforeTimestamp !== undefined) {
-    conditions.push(lt(messages.createdAt, beforeTimestamp));
-  }
+  // Walk pages newest→oldest, applying `filter` in TS (metadata parsing is
+  // JSON, not a structured column). Keep fetching until we have `limit + 1`
+  // visible rows or the DB is exhausted, so `hasMore` and the cursor reflect
+  // the visible page rather than the unfiltered row count. Without this loop,
+  // a fully-hidden page returns `{ messages: [], hasMore: true }` with no
+  // cursor, which stalls the web client's older-page fetch.
+  let cursorCreatedAt = beforeTimestamp;
+  let cursorMessageId: string | undefined;
+  const visible: MessageRow[] = [];
+  const chunkSize = Math.max(limit + 1, PAGINATION_CHUNK_MIN);
+  // Bound the work a single request can do when `filter` rejects nearly every
+  // row — otherwise a pathological filter against a huge conversation would
+  // tie up a connection for thousands of roundtrips.
+  let rowsScanned = 0;
+
+  while (visible.length < limit + 1 && rowsScanned < PAGINATION_SCAN_CAP) {
+    const cursorPredicate =
+      cursorCreatedAt === undefined
+        ? undefined
+        : cursorMessageId === undefined
+          ? lt(messages.createdAt, cursorCreatedAt)
+          : or(
+              lt(messages.createdAt, cursorCreatedAt),
+              and(
+                eq(messages.createdAt, cursorCreatedAt),
+                lt(messages.id, cursorMessageId),
+              ),
+            );
 
-  const rows = db
-    .select()
-    .from(messages)
-    .where(and(...conditions))
-    .orderBy(desc(messages.createdAt))
-    .limit(limit + 1)
-    .all()
-    .map(parseMessage);
+    const chunk = db
+      .select()
+      .from(messages)
+      .where(and(eq(messages.conversationId, conversationId), cursorPredicate))
+      .orderBy(desc(messages.createdAt), desc(messages.id))
+      .limit(chunkSize)
+      .all()
+      .map(parseMessage);
 
-  const hasMore = rows.length > limit;
-  if (hasMore) {
-    rows.splice(limit);
+    if (chunk.length === 0) break;
+    rowsScanned += chunk.length;
+
+    for (const row of chunk) {
+      if (!filter || filter(row)) visible.push(row);
+      if (visible.length >= limit + 1) break;
+    }
+
+    if (chunk.length < chunkSize) break;
+    const lastRow = chunk[chunk.length - 1];
+    cursorCreatedAt = lastRow.createdAt;
+    cursorMessageId = lastRow.id;
   }
-  rows.reverse();
 
-  return { messages: rows, hasMore };
-}
+  const hasMore = visible.length > limit;
+  if (hasMore) visible.splice(limit);
+  visible.reverse();
 
-export function getLastAssistantTimestampBefore(
-  conversationId: string,
-  beforeTimestamp: number,
-): number {
-  const db = getDb();
-  const row = db
-    .select({ createdAt: messages.createdAt })
-    .from(messages)
-    .where(
-      and(
-        eq(messages.conversationId, conversationId),
-        eq(messages.role, "assistant"),
-        lt(messages.createdAt, beforeTimestamp),
-      ),
-    )
-    .orderBy(desc(messages.createdAt))
-    .limit(1)
-    .get();
-  return row?.createdAt ?? 0;
+  return { messages: visible, hasMore };
 }
 
 export function getLastUserTimestampBefore(
@@ -1386,6 +1469,20 @@ export function updateConversationContextWindow(
     .run();
 }
 
+export function setConversationHistoryStrippedAt(
+  id: string,
+  historyStrippedAt: number | null,
+): void {
+  const db = getDb();
+  db.update(conversations)
+    .set({
+      historyStrippedAt,
+      updatedAt: Date.now(),
+    })
+    .where(eq(conversations.id, id))
+    .run();
+}
+
 export function updateConversationSlackContextWatermark(
   id: string,
   watermarkTs: string,
@@ -1609,17 +1706,50 @@ export function getConversationOverrideProfile(
   return getConversationOverrideProfileFromRow(getConversation(conversationId));
 }
 
+export function setLastNotifiedInferenceProfile(
+  conversationId: string,
+  profileKey: string | null,
+): void {
+  rawRun(
+    "UPDATE conversations SET last_notified_inference_profile = ? WHERE id = ?",
+    profileKey,
+    conversationId,
+  );
+}
+
 /**
  * Delete all conversations, messages, and related data (tool invocations,
  * memory segments, etc.) from the daemon database.
  * Returns { conversations, messages } counts.
+ *
+ * Each bulk DELETE is dispatched through {@link runAsyncSqlite}: when
+ * the host has a `sqlite3` CLI it executes in a subprocess and the
+ * daemon's main event loop stays responsive while large tables
+ * (`llm_request_logs`, `tool_invocations`, etc.) are wiped. On hosts
+ * without the CLI the abstraction falls back to in-process blocking
+ * execution — the same behaviour the daemon had before.
  */
-export function clearAll(): { conversations: number; messages: number } {
+export async function clearAll(): Promise<{
+  conversations: number;
+  messages: number;
+}> {
   const msgCount =
     rawGet<{ c: number }>("SELECT COUNT(*) AS c FROM messages")?.c ?? 0;
   const convCount =
     rawGet<{ c: number }>("SELECT COUNT(*) AS c FROM conversations")?.c ?? 0;
 
+  // Each DELETE goes through `runAsyncSqlite`. The original code threw
+  // on rawExec failure; mirror that here by throwing when the async
+  // result reports `ok: false`, so the route handler still returns 500.
+  const runOrThrow = async (sql: string): Promise<void> => {
+    const result = await runAsyncSqlite(sql);
+    if (!result.ok) {
+      throw new Error(
+        `clearAll: \`${sql}\` failed (${result.backend}): ${result.error ?? "unknown"}`,
+      );
+    }
+  };
+
   // Delete in dependency order. Cascades handle memory_segments and
   // tool_invocations, but we explicitly clear non-cascading memory
   // tables too.
@@ -1629,22 +1759,21 @@ export function clearAll(): { conversations: number; messages: number } {
   // triggers so that the subsequent base-table DELETEs don't also fail
   // (SQLite triggers are atomic with the triggering statement, so a
   // corrupted FTS table would roll back every base-table DELETE).
-  rawExec("DELETE FROM memory_segments");
-  rawExec("DELETE FROM memory_summaries");
-  rawExec("DELETE FROM memory_embeddings");
-  rawExec("DELETE FROM memory_jobs");
-  rawExec("DELETE FROM memory_checkpoints");
-  rawExec("DELETE FROM llm_request_logs");
-  rawExec("DELETE FROM llm_usage_events");
-  rawExec("DELETE FROM message_attachments");
-  rawExec("DELETE FROM attachments");
-  rawExec("DELETE FROM tool_invocations");
+  await runOrThrow("DELETE FROM memory_segments");
+  await runOrThrow("DELETE FROM memory_summaries");
+  await runOrThrow("DELETE FROM memory_embeddings");
+  await runOrThrow("DELETE FROM memory_jobs");
+  await runOrThrow("DELETE FROM memory_checkpoints");
+  await runOrThrow("DELETE FROM llm_request_logs");
+  await runOrThrow("DELETE FROM llm_usage_events");
+  await runOrThrow("DELETE FROM message_attachments");
+  await runOrThrow("DELETE FROM attachments");
+  await runOrThrow("DELETE FROM tool_invocations");
   let messagesFtsCorrupted = false;
-  try {
-    rawExec("DELETE FROM messages_fts");
-  } catch (err) {
+  const ftsResult = await runAsyncSqlite("DELETE FROM messages_fts");
+  if (!ftsResult.ok) {
     log.warn(
-      { err },
+      { error: ftsResult.error, backend: ftsResult.backend },
       "clearAll: failed to clear messages_fts — dropping triggers so base-table cleanup can proceed",
     );
     rawExec("DROP TRIGGER IF EXISTS messages_fts_ai");
@@ -1652,8 +1781,8 @@ export function clearAll(): { conversations: number; messages: number } {
     rawExec("DROP TRIGGER IF EXISTS messages_fts_au");
     messagesFtsCorrupted = true;
   }
-  rawExec("DELETE FROM messages");
-  rawExec("DELETE FROM conversations");
+  await runOrThrow("DELETE FROM messages");
+  await runOrThrow("DELETE FROM conversations");
 
   // Record audit event — lifecycle_events is NOT deleted by clearAll(),
   // so this survives the wipe and provides a permanent trail.
@@ -1820,44 +1949,6 @@ export function updateMessageMetadata(
     .run();
 }
 
-/**
- * Bulk-remove the metadata fields that back the blocks stripped by
- * `stripInjectionsForCompaction` — currently `pkbSystemReminderBlock`
- * (`<system_reminder>`), `nowScratchpadBlock` (`<NOW.md …>`),
- * `pkbContextBlock` (`<knowledge_base>`), and `memoryV2StaticBlock`
- * (the static `<memory>\n…</memory>` block matched by the `<memory>\n`
- * prefix in `RUNTIME_INJECTION_PREFIXES`). Called from compaction-strip
- * sites so post-restart rehydration stays consistent with the in-memory
- * state produced by `stripInjectionsForCompaction` (which removes those
- * tags from live messages but cannot touch the DB). Fields backing
- * blocks that are intentionally NOT stripped (`turnContextBlock`,
- * `workspaceBlock`, `memoryInjectedBlock`) are preserved.
- */
-export function clearStrippedInjectionMetadataForConversation(
-  conversationId: string,
-): void {
-  rawRun(
-    `UPDATE messages
-        SET metadata = json_remove(
-          metadata,
-          '$.pkbSystemReminderBlock',
-          '$.nowScratchpadBlock',
-          '$.pkbContextBlock',
-          '$.memoryV2StaticBlock'
-        )
-      WHERE conversation_id = ?
-        AND role = 'user'
-        AND metadata IS NOT NULL
-        AND (
-          json_extract(metadata, '$.pkbSystemReminderBlock') IS NOT NULL
-          OR json_extract(metadata, '$.nowScratchpadBlock') IS NOT NULL
-          OR json_extract(metadata, '$.pkbContextBlock') IS NOT NULL
-          OR json_extract(metadata, '$.memoryV2StaticBlock') IS NOT NULL
-        )`,
-    conversationId,
-  );
-}
-
 /**
  * Atomically update both `content` and (shallow-merged) `metadata` for a
  * message. Used by edit-propagation paths that need to update the message

package/src/memory/conversation-starters-cadence.ts

@@ -9,7 +9,7 @@ import { and, eq, inArray, sql } from "drizzle-orm";
 
 import { getLogger } from "../util/logger.js";
 import { getDb } from "./db-connection.js";
-import { enqueueMemoryJob } from "./jobs-store.js";
+import { enqueueMemoryJob, isMemoryEnabled } from "./jobs-store.js";
 import { rawGet } from "./raw-query.js";
 import { memoryCheckpoints, memoryJobs } from "./schema.js";
 
@@ -20,6 +20,8 @@ const log = getLogger("conversation-starters-cadence");
  * generating a fresh batch of conversation starters.
  */
 export function maybeEnqueueConversationStartersJob(scopeId: string): void {
+  if (!isMemoryEnabled()) return;
+
   const db = getDb();
 
   // Count total active memory items

package/src/memory/conversation-title-service.ts

@@ -331,10 +331,10 @@ function buildTitlePrompt(
   }
 
   if (userMessage) {
-    parts.push(`User: ${userMessage}`);
+    parts.push(`User: ${stripThinkingTags(userMessage)}`);
   }
   if (assistantResponse) {
-    parts.push(`Assistant: ${assistantResponse}`);
+    parts.push(`Assistant: ${stripThinkingTags(assistantResponse)}`);
   }
 
   return parts.join("\n");
@@ -378,12 +378,28 @@ function truncateTitle(title: string): string {
 function normalizeTitle(raw: string): string {
   let title = raw.trim().replace(/^["']|["']$/g, "");
   title = stripMarkdown(title);
+  title = stripThinkingTags(title);
   if (META_FAILURE_TITLES.has(title.toLowerCase())) {
     return "";
   }
   return truncateTitle(title);
 }
 
+/** Strip thinking tags so they don't bleed into generated titles. */
+function stripThinkingTags(text: string): string {
+  return text
+    .replace(/<thinking>[\s\S]*?<\/thinking>/gi, "")
+    .replace(/<thought>[\s\S]*?<\/thought>/gi, "")
+    .replace(/<think>[\s\S]*?<\/think>/gi, "")
+    .replace(/<thought>/gi, "")
+    .replace(/<\/thought>/gi, "")
+    .replace(/<thinking>/gi, "")
+    .replace(/<\/thinking>/gi, "")
+    .replace(/<think>/gi, "")
+    .replace(/<\/think>/gi, "")
+    .replace(/<:[^>]*>/gi, "");
+}
+
 /** Strip common markdown formatting so titles render as plain text. */
 function stripMarkdown(text: string): string {
   return text
@@ -458,7 +474,7 @@ function buildRegenerationPrompt(recentMessages: MessageRow[]): string {
     const text = extractTextForTitle(msg.content);
     if (!text) continue;
     const role = msg.role === "user" ? "User" : "Assistant";
-    parts.push(`${role}: ${text}`);
+    parts.push(`${role}: ${stripThinkingTags(text)}`);
   }
 
   return parts.join("\n");