@vellumai/assistant 0.5.16 → 0.6.1

package/src/memory/conversation-crud.ts

@@ -41,17 +41,15 @@ import {
   updateMetaFile,
 } from "./conversation-disk-view.js";
 import { ensureDisplayOrderMigration } from "./conversation-display-order-migration.js";
-import { getDb, rawAll, rawExec, rawGet, rawRun } from "./db.js";
+import { ensureGroupMigration } from "./conversation-group-migration.js";
+import { getDb, rawExec, rawGet, rawRun } from "./db.js";
 import { indexMessageNow } from "./indexer.js";
-import { enqueueMemoryJob } from "./jobs-store.js";
 import {
   channelInboundEvents,
   conversations,
   conversationStarters,
   llmRequestLogs,
   memoryEmbeddings,
-  memoryItems,
-  memoryItemSources,
   memorySegments,
   memorySummaries,
   messageAttachments,
@@ -72,7 +70,7 @@ const interfaceIdSchema = z.enum(INTERFACE_IDS);
 const subagentNotificationSchema = z.object({
   subagentId: z.string(),
   label: z.string(),
-  status: z.enum(["completed", "failed", "aborted"]),
+  status: z.enum(["running", "completed", "failed", "aborted"]),
   error: z.string().optional(),
   conversationId: z.string().optional(),
 });
@@ -174,6 +172,7 @@ export interface ConversationRow {
   forkParentMessageId: string | null;
   isAutoTitle: number;
   scheduleJobId: string | null;
+  lastMessageAt: number | null;
 }
 
 export const parseConversation = createRowMapper<
@@ -199,6 +198,7 @@ export const parseConversation = createRowMapper<
   forkParentMessageId: "forkParentMessageId",
   isAutoTitle: "isAutoTitle",
   scheduleJobId: "scheduleJobId",
+  lastMessageAt: "lastMessageAt",
 });
 
 export interface MessageRow {
@@ -241,9 +241,10 @@ export function createConversation(
     | string
     | {
         title?: string;
-        conversationType?: "standard" | "private" | "background";
+        conversationType?: "standard" | "private" | "background" | "scheduled";
         source?: string;
         scheduleJobId?: string;
+        groupId?: string;
       },
 ) {
   const db = getDb();
@@ -254,9 +255,16 @@ export function createConversation(
       : (titleOrOpts ?? {});
   const conversationType = opts.conversationType ?? "standard";
   const source = opts.source ?? "user";
+  const groupId = opts.groupId;
   const id = uuid();
   const memoryScopeId =
     conversationType === "private" ? `private:${id}` : "default";
+
+  // Ensure group_id column exists for deterministic schema readiness,
+  // even when this conversation has no groupId (a subsequent query or
+  // reorder may reference the column).
+  ensureGroupMigration();
+
   const conversation = {
     id,
     title: opts.title ?? null,
@@ -276,6 +284,12 @@ export function createConversation(
 
   // Retry on SQLITE_BUSY and SQLITE_IOERR — transient disk I/O errors or WAL
   // contention can cause the first attempt to fail even under normal load.
+  // INSERT and group_id UPDATE are retried independently so a transient failure
+  // on the UPDATE doesn't re-execute the already-succeeded INSERT (which would
+  // hit a unique constraint violation).
+  // No explicit BEGIN/COMMIT here — callers that need atomicity (e.g.
+  // forkConversation) wrap in their own transaction, and nesting raw BEGIN
+  // inside Drizzle's db.transaction() would crash SQLite.
   const MAX_RETRIES = 3;
   for (let attempt = 0; ; attempt++) {
     try {
@@ -289,10 +303,8 @@ export function createConversation(
       ) {
         log.warn(
           { attempt, conversationId: id, code },
-          "createConversation: transient SQLite error, retrying",
+          "createConversation: INSERT transient error, retrying",
         );
-        // Synchronous sleep — createConversation is synchronous and the
-        // retry window is short (50-150ms), so Bun.sleepSync is appropriate.
         Bun.sleepSync(50 * (attempt + 1));
         continue;
       }
@@ -300,6 +312,35 @@ export function createConversation(
     }
   }
 
+  // group_id is NOT in the Drizzle schema (raw-query-only pattern).
+  // Set via raw SQL after the INSERT succeeds.
+  if (groupId) {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        rawRun(
+          "UPDATE conversations SET group_id = ? WHERE id = ?",
+          groupId,
+          id,
+        );
+        break;
+      } catch (err) {
+        const code = (err as { code?: string }).code ?? "";
+        if (
+          attempt < MAX_RETRIES &&
+          (code.startsWith("SQLITE_BUSY") || code.startsWith("SQLITE_IOERR"))
+        ) {
+          log.warn(
+            { attempt, conversationId: id, code },
+            "createConversation: group_id UPDATE transient error, retrying",
+          );
+          Bun.sleepSync(50 * (attempt + 1));
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+
   initConversationDir({ ...conversation, originChannel: null });
 
   return conversation;
@@ -344,6 +385,20 @@ export function getConversationMemoryScopeId(conversationId: string): string {
   return conv?.memoryScopeId ?? "default";
 }
 
+/**
+ * Fetch group_id for a conversation via raw SQL. group_id is NOT in the
+ * Drizzle schema (raw-query-only pattern), so ConversationRow doesn't
+ * include it. This helper is used by forkConversation to inherit group_id.
+ */
+export function getConversationGroupId(conversationId: string): string | null {
+  ensureGroupMigration();
+  const row = rawGet<{ group_id: string | null }>(
+    "SELECT group_id FROM conversations WHERE id = ?",
+    conversationId,
+  );
+  return row?.group_id ?? null;
+}
+
 export function forkConversation(params: {
   conversationId: string;
   throughMessageId?: string;
@@ -407,10 +462,14 @@ export function forkConversation(params: {
   // (linkAttachmentToMessage, relinkAttachments, seedForkedConversationAttention)
   // use the same underlying bun:sqlite connection, so their writes participate
   // in this transaction automatically.
+  // Inherit group_id from parent via raw SQL helper (group_id is not in Drizzle schema)
+  const parentGroupId = getConversationGroupId(conversationId);
+
   const forkedConversation = db.transaction(() => {
     const fc = createConversation({
       title: forkTitle,
       conversationType: "standard",
+      groupId: parentGroupId ?? undefined,
     });
 
     db.update(conversations)
@@ -526,6 +585,16 @@ export function forkConversation(params: {
       });
     }
 
+    // Set lastMessageAt to the max createdAt of copied messages so the
+    // forked conversation sorts correctly by message recency.
+    const lastCopiedMessage = messagesToCopy.at(-1);
+    if (lastCopiedMessage) {
+      db.update(conversations)
+        .set({ lastMessageAt: lastCopiedMessage.createdAt })
+        .where(eq(conversations.id, fc.id))
+        .run();
+    }
+
     seedForkedConversationAttention({
       conversationId: fc.id,
       latestAssistantMessageId: latestForkedAssistant?.messageId ?? null,
@@ -553,14 +622,13 @@ export function forkConversation(params: {
 
 /**
  * Delete a conversation and all its messages, cleaning up orphaned memory
- * artifacts (items, embeddings). Returns segment and orphaned item IDs so
- * callers can clean up the corresponding Qdrant vector entries.
+ * artifacts (embeddings). Returns segment IDs so callers can clean up
+ * the corresponding Qdrant vector entries.
  */
 export function deleteConversation(id: string): DeletedMemoryIds {
   const db = getDb();
   const result: DeletedMemoryIds = {
     segmentIds: [],
-    orphanedItemIds: [],
     deletedSummaryIds: [],
   };
 
@@ -589,16 +657,6 @@ export function deleteConversation(id: string): DeletedMemoryIds {
         .all();
       result.segmentIds = linkedSegments.map((r) => r.id);
 
-      // Collect memory item IDs linked to these messages before cascade.
-      const linkedItems = tx
-        .select({ memoryItemId: memoryItemSources.memoryItemId })
-        .from(memoryItemSources)
-        .where(inArray(memoryItemSources.messageId, messageIds))
-        .all();
-      const candidateItemIds = [
-        ...new Set(linkedItems.map((r) => r.memoryItemId)),
-      ];
-
       // Delete non-cascading tables first.
       tx.delete(llmRequestLogs)
         .where(eq(llmRequestLogs.conversationId, id))
@@ -606,7 +664,7 @@ export function deleteConversation(id: string): DeletedMemoryIds {
       tx.delete(toolInvocations)
         .where(eq(toolInvocations.conversationId, id))
         .run();
-      // Cascade deletes memory_segments, memory_item_sources, message_attachments.
+      // Cascade deletes memory_segments, message_attachments.
       tx.delete(messages).where(eq(messages.conversationId, id)).run();
 
       // Clean up segment embeddings.
@@ -620,34 +678,6 @@ export function deleteConversation(id: string): DeletedMemoryIds {
           )
           .run();
       }
-
-      // Clean up orphaned memory items whose only sources were in this conversation.
-      if (candidateItemIds.length > 0) {
-        const surviving = tx
-          .select({ memoryItemId: memoryItemSources.memoryItemId })
-          .from(memoryItemSources)
-          .where(inArray(memoryItemSources.memoryItemId, candidateItemIds))
-          .all();
-        const survivingIds = new Set(surviving.map((r) => r.memoryItemId));
-        const orphanedIds = candidateItemIds.filter(
-          (itemId) => !survivingIds.has(itemId),
-        );
-        result.orphanedItemIds = orphanedIds;
-
-        if (orphanedIds.length > 0) {
-          tx.delete(memoryEmbeddings)
-            .where(
-              and(
-                eq(memoryEmbeddings.targetType, "item"),
-                inArray(memoryEmbeddings.targetId, orphanedIds),
-              ),
-            )
-            .run();
-          tx.delete(memoryItems)
-            .where(inArray(memoryItems.id, orphanedIds))
-            .run();
-        }
-      }
     } else {
       // No messages — just clean up non-message tables.
       tx.delete(llmRequestLogs)
@@ -659,35 +689,6 @@ export function deleteConversation(id: string): DeletedMemoryIds {
     }
 
     if (isPrivateScope && memoryScopeId) {
-      // Sweep remaining memory items with this private scopeId.
-      const scopeItems = tx
-        .select({ id: memoryItems.id })
-        .from(memoryItems)
-        .where(eq(memoryItems.scopeId, memoryScopeId))
-        .all();
-      const alreadyDeleted = new Set(result.orphanedItemIds);
-      const scopeItemIds = scopeItems
-        .map((r) => r.id)
-        .filter((id) => !alreadyDeleted.has(id));
-
-      if (scopeItemIds.length > 0) {
-        tx.delete(memoryEmbeddings)
-          .where(
-            and(
-              eq(memoryEmbeddings.targetType, "item"),
-              inArray(memoryEmbeddings.targetId, scopeItemIds),
-            ),
-          )
-          .run();
-        tx.delete(memoryItemSources)
-          .where(inArray(memoryItemSources.memoryItemId, scopeItemIds))
-          .run();
-        tx.delete(memoryItems)
-          .where(inArray(memoryItems.id, scopeItemIds))
-          .run();
-        result.orphanedItemIds.push(...scopeItemIds);
-      }
-
       // Sweep memory summaries with this private scopeId.
       const scopeSummaries = tx
         .select({ id: memorySummaries.id })
@@ -733,79 +734,16 @@ export function deleteConversation(id: string): DeletedMemoryIds {
  *
  * 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 })
@@ -833,82 +771,14 @@ export function wipeConversation(id: string): WipeConversationResult {
   }
   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.
+  // Step D — Delegate to deleteConversation which handles messages (cascade
+  // segments, attachments), llmRequestLogs, toolInvocations,
+  // 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.
+  // Step E — Return the combined result.
   return {
     ...deletedMemoryIds,
-    unsupersededItemIds,
     deletedSummaryIds: [
       ...deletedSummaryIds,
       ...deletedMemoryIds.deletedSummaryIds,
@@ -938,20 +808,17 @@ export function purgePrivateConversations(): {
       count: 0,
       deletedMemory: {
         segmentIds: [],
-        orphanedItemIds: [],
         deletedSummaryIds: [],
       },
     };
   }
 
   const allSegmentIds: string[] = [];
-  const allOrphanedItemIds: string[] = [];
   const allDeletedSummaryIds: string[] = [];
 
   for (const conv of privateConvs) {
     const deleted = deleteConversation(conv.id);
     allSegmentIds.push(...deleted.segmentIds);
-    allOrphanedItemIds.push(...deleted.orphanedItemIds);
     allDeletedSummaryIds.push(...deleted.deletedSummaryIds);
   }
 
@@ -959,7 +826,6 @@ export function purgePrivateConversations(): {
     count: privateConvs.length,
     deletedMemory: {
       segmentIds: allSegmentIds,
-      orphanedItemIds: allOrphanedItemIds,
       deletedSummaryIds: allDeletedSummaryIds,
     },
   };
@@ -1021,7 +887,7 @@ export async function addMessage(
             .run();
         }
         tx.update(conversations)
-          .set({ updatedAt: now })
+          .set({ updatedAt: now, lastMessageAt: now })
           .where(eq(conversations.id, conversationId))
           .run();
       });
@@ -1265,18 +1131,16 @@ export function clearAll(): { conversations: number; messages: number } {
   const convCount =
     rawGet<{ c: number }>("SELECT COUNT(*) AS c FROM conversations")?.c ?? 0;
 
-  // Delete in dependency order. Cascades handle memory_segments,
-  // memory_item_sources, and tool_invocations, but we explicitly
-  // clear non-cascading memory tables too.
+  // Delete in dependency order. Cascades handle memory_segments and
+  // tool_invocations, but we explicitly clear non-cascading memory
+  // tables too.
   //
   // FTS virtual tables are cleared before their base tables. If an FTS
   // table is corrupted, the DELETE will fail — we drop the associated
   // 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_item_sources");
   rawExec("DELETE FROM memory_segments");
-  rawExec("DELETE FROM memory_items");
   rawExec("DELETE FROM memory_summaries");
   rawExec("DELETE FROM memory_embeddings");
   rawExec("DELETE FROM memory_jobs");
@@ -1398,8 +1262,16 @@ export function deleteLastExchange(conversationId: string): number {
 
   db.transaction((tx) => {
     tx.delete(messages).where(condition).run();
+    const maxResult = tx
+      .select({ maxCreatedAt: sql<number | null>`MAX(${messages.createdAt})` })
+      .from(messages)
+      .where(eq(messages.conversationId, conversationId))
+      .get();
     tx.update(conversations)
-      .set({ updatedAt: Date.now() })
+      .set({
+        updatedAt: Date.now(),
+        lastMessageAt: maxResult?.maxCreatedAt ?? null,
+      })
       .where(eq(conversations.id, conversationId))
       .run();
   });
@@ -1416,12 +1288,10 @@ export function deleteLastExchange(conversationId: string): number {
  */
 export interface DeletedMemoryIds {
   segmentIds: string[];
-  orphanedItemIds: string[];
   deletedSummaryIds: string[];
 }
 
 export interface WipeConversationResult extends DeletedMemoryIds {
-  unsupersededItemIds: string[];
   cancelledJobCount: number;
 }
 
@@ -1440,6 +1310,27 @@ export function updateMessageContent(
     .run();
 }
 
+/**
+ * Merge `updates` into the metadata JSON of an existing message.
+ * Reads the current metadata, shallow-merges the new fields, and writes back.
+ */
+export function updateMessageMetadata(
+  messageId: string,
+  updates: Record<string, unknown>,
+): void {
+  const db = getDb();
+  const row = db
+    .select({ metadata: messages.metadata })
+    .from(messages)
+    .where(eq(messages.id, messageId))
+    .get();
+  const existing = row?.metadata ? JSON.parse(row.metadata) : {};
+  db.update(messages)
+    .set({ metadata: JSON.stringify({ ...existing, ...updates }) })
+    .where(eq(messages.id, messageId))
+    .run();
+}
+
 /**
  * Re-link all attachments from a set of source messages to a target message.
  * Used during message consolidation so that attachments linked to deleted
@@ -1475,21 +1366,13 @@ export function relinkAttachments(
  * NULL before the message row is removed, so associated run and event
  * records survive.
  *
- * Also cleans up derived memory_items: if the memory worker has already
- * processed an extract_items job for this message, deleting the message
- * cascades memory_item_sources but leaves the memory_items active.
- * Without cleanup, those items would leak into summaries and recall.
- * We delete any memory_items that become orphaned (no remaining sources)
- * after this message is removed.
- *
- * Returns segment and orphaned item IDs so the caller can clean up the
- * corresponding Qdrant vector entries.
+ * Returns segment IDs so the caller can clean up the corresponding
+ * Qdrant vector entries.
  */
 export function deleteMessageById(messageId: string): DeletedMemoryIds {
   const db = getDb();
   const result: DeletedMemoryIds = {
     segmentIds: [],
-    orphanedItemIds: [],
     deletedSummaryIds: [],
   };
 
@@ -1503,6 +1386,13 @@ export function deleteMessageById(messageId: string): DeletedMemoryIds {
     .map((r) => r.attachmentId)
     .filter((id): id is string => id !== undefined);
 
+  // Look up the conversation before the transaction so we can recalculate lastMessageAt.
+  const msgRow = db
+    .select({ conversationId: messages.conversationId })
+    .from(messages)
+    .where(eq(messages.id, messageId))
+    .get();
+
   db.transaction((tx) => {
     // Collect memory segment IDs linked to this message before cascade.
     const linkedSegments = tx
@@ -1512,24 +1402,31 @@ export function deleteMessageById(messageId: string): DeletedMemoryIds {
       .all();
     result.segmentIds = linkedSegments.map((r) => r.id);
 
-    // Collect memory item IDs linked to this message before cascade.
-    const linkedItems = tx
-      .select({ memoryItemId: memoryItemSources.memoryItemId })
-      .from(memoryItemSources)
-      .where(eq(memoryItemSources.messageId, messageId))
-      .all();
-    const candidateItemIds = linkedItems.map((r) => r.memoryItemId);
-
     // Detach nullable FK references so the cascade doesn't destroy them.
     tx.update(channelInboundEvents)
       .set({ messageId: null })
       .where(eq(channelInboundEvents.messageId, messageId))
       .run();
 
-    // Now safe to delete — NOT NULL cascades remove memory_item_sources,
-    // memory_segments, and message_attachments.
+    // Now safe to delete — NOT NULL cascades remove memory_segments
+    // and message_attachments.
     tx.delete(messages).where(eq(messages.id, messageId)).run();
 
+    // Recalculate lastMessageAt after deletion.
+    if (msgRow) {
+      const maxResult = tx
+        .select({
+          maxCreatedAt: sql<number | null>`MAX(${messages.createdAt})`,
+        })
+        .from(messages)
+        .where(eq(messages.conversationId, msgRow.conversationId))
+        .get();
+      tx.update(conversations)
+        .set({ lastMessageAt: maxResult?.maxCreatedAt ?? null })
+        .where(eq(conversations.id, msgRow.conversationId))
+        .run();
+    }
+
     // Clean up segment embeddings from SQLite (Qdrant cleanup is the caller's job).
     if (result.segmentIds.length > 0) {
       tx.delete(memoryEmbeddings)
@@ -1541,37 +1438,6 @@ export function deleteMessageById(messageId: string): DeletedMemoryIds {
         )
         .run();
     }
-
-    // Clean up orphaned memory items whose only source was this message.
-    if (candidateItemIds.length > 0) {
-      // Find which items still have at least one remaining source.
-      const surviving = tx
-        .select({ memoryItemId: memoryItemSources.memoryItemId })
-        .from(memoryItemSources)
-        .where(inArray(memoryItemSources.memoryItemId, candidateItemIds))
-        .all();
-      const survivingIds = new Set(surviving.map((r) => r.memoryItemId));
-      const orphanedIds = candidateItemIds.filter(
-        (id) => !survivingIds.has(id),
-      );
-      result.orphanedItemIds = orphanedIds;
-
-      if (orphanedIds.length > 0) {
-        // Delete embeddings referencing these items.
-        tx.delete(memoryEmbeddings)
-          .where(
-            and(
-              eq(memoryEmbeddings.targetType, "item"),
-              inArray(memoryEmbeddings.targetId, orphanedIds),
-            ),
-          )
-          .run();
-        // Delete the orphaned memory items themselves.
-        tx.delete(memoryItems)
-          .where(inArray(memoryItems.id, orphanedIds))
-          .run();
-      }
-    }
   });
 
   deleteOrphanAttachments(candidateAttachmentIds);
@@ -1670,18 +1536,66 @@ export function batchSetDisplayOrders(
     id: string;
     displayOrder: number | null;
     isPinned: boolean;
+    groupId?: string | null;
   }>,
 ): void {
   ensureDisplayOrderMigration();
+  ensureGroupMigration();
   rawExec("BEGIN");
   try {
     for (const update of updates) {
-      rawRun(
-        "UPDATE conversations SET display_order = ?, is_pinned = ? WHERE id = ?",
-        update.displayOrder,
-        update.isPinned ? 1 : 0,
-        update.id,
-      );
+      if (update.groupId !== undefined) {
+        // New client: groupId is authoritative.
+        // Derive is_pinned from groupId.
+        // Sanitize: if groupId references a deleted/unknown group, fall back
+        // to NULL to avoid FK violation that would roll back the entire batch.
+        let safeGroupId = update.groupId;
+        if (
+          safeGroupId !== null &&
+          !rawGet<{ id: string }>(
+            "SELECT id FROM conversation_groups WHERE id = ?",
+            safeGroupId,
+          )
+        ) {
+          safeGroupId = null;
+        }
+        rawRun(
+          "UPDATE conversations SET display_order = ?, is_pinned = ?, group_id = ? WHERE id = ?",
+          update.displayOrder,
+          safeGroupId === "system:pinned" ? 1 : 0,
+          safeGroupId,
+          update.id,
+        );
+      } else {
+        // Old client: no groupId in payload
+        // isPinned true -> set group_id = system:pinned
+        // isPinned false -> clear group_id ONLY IF currently system:pinned
+        //                   otherwise preserve existing group_id
+        if (update.isPinned) {
+          rawRun(
+            "UPDATE conversations SET display_order = ?, is_pinned = 1, group_id = 'system:pinned' WHERE id = ?",
+            update.displayOrder,
+            update.id,
+          );
+        } else {
+          // Restore system group from source/conversationType when old clients
+          // unpin, instead of clearing to NULL (which would lose provenance).
+          rawRun(
+            `UPDATE conversations SET display_order = ?, is_pinned = 0,
+             group_id = CASE WHEN group_id = 'system:pinned' THEN
+               CASE
+                 WHEN source IN ('schedule', 'reminder') THEN 'system:scheduled'
+                 WHEN source IN ('heartbeat', 'task') THEN 'system:background'
+                 WHEN conversation_type = 'background' AND COALESCE(source, '') != 'notification' THEN 'system:background'
+                 ELSE NULL
+               END
+             ELSE group_id END
+             WHERE id = ?`,
+            update.displayOrder,
+            update.id,
+          );
+        }
+      }
     }
     rawExec("COMMIT");
   } catch (err) {
@@ -1692,21 +1606,30 @@ export function batchSetDisplayOrders(
 
 export function getDisplayMetaForConversations(
   conversationIds: string[],
-): Map<string, { displayOrder: number | null; isPinned: boolean }> {
+): Map<
+  string,
+  { displayOrder: number | null; isPinned: boolean; groupId: string | null }
+> {
   ensureDisplayOrderMigration();
+  ensureGroupMigration();
   const result = new Map<
     string,
-    { displayOrder: number | null; isPinned: boolean }
+    { displayOrder: number | null; isPinned: boolean; groupId: string | null }
   >();
   if (conversationIds.length === 0) return result;
   for (const id of conversationIds) {
     const row = rawGet<{
       display_order: number | null;
       is_pinned: number | null;
-    }>("SELECT display_order, is_pinned FROM conversations WHERE id = ?", id);
+      group_id: string | null;
+    }>(
+      "SELECT display_order, is_pinned, group_id FROM conversations WHERE id = ?",
+      id,
+    );
     result.set(id, {
       displayOrder: row?.display_order ?? null,
       isPinned: (row?.is_pinned ?? 0) === 1,
+      groupId: row?.group_id ?? null,
     });
   }
   return result;