@vellumai/assistant 0.6.1 → 0.6.3

package/src/memory/graph/consolidation.ts

@@ -4,8 +4,7 @@
 // Runs daily (or on demand). Processes nodes in partitions:
 // 1. Recency: nodes from last 7 days — merge duplicates, initial narrative
 // 2. Significance: top N by significance — update narrative arcs
-// 3. Decay: nodes at faded/gist fidelity — candidates for merging or marking gone
-// 4. Random sample: cross-pollination and pattern detection
+// 3. Random sample: cross-pollination and pattern detection
 //
 // Each partition is a separate LLM call. The LLM produces a MemoryDiff
 // (same format as extraction) that is applied to the graph.
@@ -91,25 +90,25 @@ Today is ${today}.
 
 ## Your Tasks
 
-1. **Merge duplicates**: If two or more nodes describe the same event or fact, merge them into one by:
+1. **Merge duplicates**: If two or more nodes describe the exact same specific event or fact with substantially the same details, merge them into one by:
    - Keeping the richer/more complete version (UPDATE it to incorporate details from duplicates)
    - DELETE the duplicates
    - Preserve the highest significance, reinforcement count, and stability from the merged nodes
-   - Create a "supersedes" edge from the surviving node to each deleted node (the store handles deletion, but log the relationship)
+   - Create a "supersedes" edge from the surviving node to each deleted node
+   - Two nodes about the same person or topic but with DIFFERENT details, timestamps, or context are NOT duplicates — leave them both intact.
 
-2. **Downgrade faded memories**: For nodes at "faded" or "gist" fidelity, rewrite their content to be shorter and more abstract — like how a real memory fades. A "faded" memory should be 1-2 sentences. A "gist" memory should be one sentence capturing only the essence.
+2. **Rewrite faded content**: For nodes at "faded" or "gist" fidelity, rewrite their content to be shorter and more abstract — like how a real memory fades. A "faded" memory should be 1-2 sentences. A "gist" memory should be one sentence capturing only the essence.
 
 3. **Update narrative roles**: If a node is clearly a turning point, inciting incident, or thesis in a larger story arc, set its narrativeRole and partOfStory.
 
-4. **Mark gone**: If a node is at "gist" fidelity and has very low significance (< 0.2), mark it for deletion — it's faded beyond usefulness.
-
-5. **Resolve stale prospective nodes**: If a prospective node (type=prospective) is older than 7 days and has no "resolved-by" edge, it's likely a stale commitment. Downgrade its fidelity to "gist" and rewrite it as a past observation (e.g. "Had planned to X" instead of "Need to X"). If it's already at gist with significance < 0.2, mark it for deletion. If the node has an event_date in the past, clear it by setting event_date to null.
+4. **Resolve stale prospective nodes**: If a prospective node (type=prospective) is older than 7 days and has no "resolved-by" edge, downgrade its fidelity to "gist" and rewrite it as a past observation (e.g. "Had planned to X" instead of "Need to X"). If the node has an event_date in the past, clear it by setting event_date to null.
 
 ## Constraints
 
-- Do NOT create new nodes — consolidation only merges, updates, and prunes
+- Do NOT create new nodes — consolidation only merges, updates, and rewrites
 - Do NOT change a node's type
 - Do NOT increase fidelity (memories only fade, never sharpen)
+- Do NOT delete non-duplicate nodes — only delete the non-survivor in a merge. Fading and eventual cleanup are handled by the decay engine, not consolidation.
 - Preserve first-person prose style in content rewrites
 - When merging, keep the node with higher reinforcementCount as the survivor
 
@@ -159,7 +158,7 @@ const CONSOLIDATE_TOOL_SCHEMA = {
       },
       delete_ids: {
         type: "array" as const,
-        description: "Node IDs to delete (merged duplicates, gone memories)",
+        description: "Node IDs to delete (merged duplicates only)",
         items: { type: "string" as const },
       },
       merge_edges: {
@@ -206,17 +205,6 @@ function getTopSignificanceNodes(
     .slice(0, n);
 }
 
-function getDecayedNodes(scopeId: string): MemoryNode[] {
-  const all = queryNodes({
-    scopeId,
-    limit: 10000,
-  });
-  return all.filter(
-    (n) =>
-      (n.fidelity === "faded" || n.fidelity === "gist") && !isCapabilityNode(n),
-  );
-}
-
 function getRandomSample(scopeId: string, n: number = 30): MemoryNode[] {
   const all = queryNodes({
     scopeId,
@@ -286,7 +274,7 @@ async function identifyDuplicateGroups(
     })
     .join("\n");
 
-  const systemPrompt = `You are scanning a list of memory nodes for DUPLICATES — nodes that describe the same event, fact, or topic. Group duplicates together. Two nodes are duplicates if they describe the same underlying thing, even if worded differently. Be aggressive — if in doubt, group them. Only include nodes that have at least one duplicate.`;
+  const systemPrompt = `You are scanning a list of memory nodes for DUPLICATES — nodes that describe the exact same specific event or fact. Group duplicates together. Two nodes are duplicates ONLY if they describe the same underlying thing with substantially the same details. Be conservative — nodes about the same person or topic but with different details, timestamps, or context are NOT duplicates. Only include nodes that have at least one true duplicate.`;
 
   const response = await provider.sendMessage(
     [userMessage(listing)],
@@ -657,7 +645,6 @@ export async function runConsolidation(
   const partitions: Array<{ name: string; nodes: MemoryNode[] }> = [
     { name: "recent", nodes: getRecentNodes(scopeId) },
     { name: "significant", nodes: getTopSignificanceNodes(scopeId) },
-    { name: "decayed", nodes: getDecayedNodes(scopeId) },
     { name: "random", nodes: getRandomSample(scopeId) },
   ];
 

package/src/memory/graph/extraction-job.ts

@@ -9,6 +9,7 @@
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "../checkpoints.js";
+import { maybeEnqueueConversationStartersJob } from "../conversation-starters-cadence.js";
 import { asString } from "../job-utils.js";
 import type { MemoryJob } from "../jobs-store.js";
 import { runGraphExtraction } from "./extraction.js";
@@ -64,6 +65,20 @@ export async function graphExtractJob(
       },
       "Graph extraction job complete",
     );
+
+    try {
+      maybeEnqueueConversationStartersJob(scopeId);
+    } catch (cadenceErr) {
+      log.warn(
+        {
+          err:
+            cadenceErr instanceof Error
+              ? cadenceErr.message
+              : String(cadenceErr),
+        },
+        "Conversation starters cadence check failed (non-fatal)",
+      );
+    }
   } catch (err) {
     log.error(
       { conversationId, err: err instanceof Error ? err.message : String(err) },

package/src/memory/graph/retriever.ts

@@ -371,8 +371,9 @@ export async function loadContextMemory(
   opts: ContextLoadOpts,
 ): Promise<ContextLoadResult> {
   const start = Date.now();
-  const maxNodes = opts.maxNodes ?? 40;
-  const serendipitySlots = opts.serendipitySlots ?? 10;
+  const ctxLoadCfg = opts.config.memory.retrieval.injection.contextLoad;
+  const maxNodes = opts.maxNodes ?? ctxLoadCfg.maxNodes;
+  const serendipitySlots = opts.serendipitySlots ?? ctxLoadCfg.serendipitySlots;
   const now = new Date();
   const nowMs = now.getTime();
 
@@ -547,13 +548,16 @@ export async function loadContextMemory(
   // 5b. Reserve slots for skill/CLI capabilities. Queried directly from
   // SQLite — no Qdrant vectors needed — so capabilities surface even on
   // fresh assistants whose embedding jobs haven't completed yet.
-  const CAPABILITY_RESERVE = 5;
-  const rawCapabilityNodes = queryNodes({
-    scopeId: opts.scopeId,
-    types: ["procedural"],
-    fidelityNot: ["gone"],
-    limit: CAPABILITY_RESERVE * 4,
-  });
+  const capabilityReserve = ctxLoadCfg.capabilityReserve;
+  const rawCapabilityNodes =
+    capabilityReserve > 0
+      ? queryNodes({
+          scopeId: opts.scopeId,
+          types: ["procedural"],
+          fidelityNot: ["gone"],
+          limit: capabilityReserve * 4,
+        })
+      : [];
 
   // Dedup: both seeding systems may create nodes for the same capability.
   // Extract capability ID from content and keep only the first node per ID.
@@ -574,14 +578,14 @@ export async function loadContextMemory(
 
   // Rank by semantic similarity when a query vector exists
   let selectedCapabilities: MemoryNode[];
-  if (queryVector && capabilityNodes.length > CAPABILITY_RESERVE) {
+  if (queryVector && capabilityNodes.length > capabilityReserve) {
     selectedCapabilities = capabilityNodes
       .map((node) => ({ node, sim: semanticCandidateIds.get(node.id) ?? 0 }))
       .sort((a, b) => b.sim - a.sim)
-      .slice(0, CAPABILITY_RESERVE)
+      .slice(0, capabilityReserve)
       .map((e) => e.node);
   } else {
-    selectedCapabilities = capabilityNodes.slice(0, CAPABILITY_RESERVE);
+    selectedCapabilities = capabilityNodes.slice(0, capabilityReserve);
   }
 
   const reservedCapabilities: ScoredNode[] = selectedCapabilities.map(
@@ -987,7 +991,8 @@ export async function retrieveForTurn(
   // 5b. Reserve slots for capability nodes (skills/CLI).
   // Sourced from vector search candidates — only semantically relevant
   // capabilities compete for reserved slots.
-  const PROCEDURAL_RESERVE = 3;
+  const perTurnCfg = opts.config.memory.retrieval.injection.perTurn;
+  const capabilityReserve = perTurnCfg.capabilityReserve;
 
   const proceduralCandidates = capabilityCandidates
     .filter(({ node }) => !opts.tracker.isInContext(node.id))
@@ -1006,7 +1011,7 @@ export async function retrieveForTurn(
       }
       return true;
     })
-    .slice(0, PROCEDURAL_RESERVE);
+    .slice(0, capabilityReserve);
 
   const proceduralScored: ScoredNode[] = rankedProcedural.map(({ node, sim }) =>
     scoreCandidate(
@@ -1033,8 +1038,14 @@ export async function retrieveForTurn(
   // Sort and apply threshold — pull a wider pool for dedup, then trim
   scored.sort((a, b) => b.score - a.score);
   const INJECTION_THRESHOLD = 0.3;
+  // Hard cap on candidates fed to the dedup LLM — effectively caps maxNodes
   const PRE_DEDUP_POOL = 20;
-  const MAX_INJECTED = 4;
+  const maxGeneralNodes = Math.max(
+    0,
+    perTurnCfg.maxNodes -
+      perTurnCfg.serendipitySlots -
+      proceduralInjected.length,
+  );
   const pool = scored
     .filter((s) => s.score >= INJECTION_THRESHOLD)
     .slice(0, PRE_DEDUP_POOL);
@@ -1042,8 +1053,12 @@ export async function retrieveForTurn(
   // Dedup + rerank with a fast model when the pool is large enough to warrant it
   let injected: ScoredNode[];
   let llmDedupApplied = false;
-  if (pool.length > MAX_INJECTED) {
-    const result = await dedupForTurn(pool, MAX_INJECTED, opts.userLastMessage);
+  if (pool.length > maxGeneralNodes) {
+    const result = await dedupForTurn(
+      pool,
+      maxGeneralNodes,
+      opts.userLastMessage,
+    );
     injected = result.nodes;
     llmDedupApplied = result.llmApplied;
   } else {
@@ -1054,17 +1069,17 @@ export async function retrieveForTurn(
   const generalInjected = injected.filter((s) => !proceduralIds.has(s.node.id));
 
   // Backfill vacated general slots from the remaining pool so we always
-  // return up to MAX_INJECTED general memories when eligible candidates exist.
+  // return up to maxGeneralNodes when eligible candidates exist.
   // Only skip backfill when LLM dedup genuinely ran — it intentionally rejected
   // items as duplicates/irrelevant. When dedupForTurn fell back to a plain
   // top-N slice (no provider, tool call failure), backfill is still appropriate.
-  if (generalInjected.length < MAX_INJECTED && !llmDedupApplied) {
+  if (generalInjected.length < maxGeneralNodes && !llmDedupApplied) {
     const usedIds = new Set([
       ...generalInjected.map((s) => s.node.id),
       ...proceduralIds,
     ]);
     const backfillCandidates = pool.filter((s) => !usedIds.has(s.node.id));
-    const needed = MAX_INJECTED - generalInjected.length;
+    const needed = maxGeneralNodes - generalInjected.length;
     for (let i = 0; i < Math.min(needed, backfillCandidates.length); i++) {
       generalInjected.push(backfillCandidates[i]);
     }
@@ -1073,11 +1088,14 @@ export async function retrieveForTurn(
   const allDeterministic = [...generalInjected, ...proceduralInjected];
   const deterministicIds = new Set(allDeterministic.map((n) => n.node.id));
 
-  // Reserve 1 serendipity slot from scored candidates not in the deterministic set
+  // Reserve serendipity slots from scored candidates not in the deterministic set
   const serendipityPool = scored.filter(
     (s) => s.score >= INJECTION_THRESHOLD && !deterministicIds.has(s.node.id),
   );
-  const serendipityPicks = sampleSerendipity(serendipityPool, 1);
+  const serendipityPicks = sampleSerendipity(
+    serendipityPool,
+    perTurnCfg.serendipitySlots,
+  );
   const allInjected = [...allDeterministic, ...serendipityPicks];
 
   const TOP_N = 20;

package/src/memory/graph/store.test.ts

@@ -179,10 +179,12 @@ describe("node CRUD", () => {
     expect(updated!.eventDate).toBeNull();
   });
 
-  test("deleteNode removes the node", () => {
+  test("deleteNode soft-deletes the node by setting fidelity to gone", () => {
     const node = createNode(makeNewNode());
     deleteNode(node.id);
-    expect(getNode(node.id)).toBeNull();
+    const deleted = getNode(node.id);
+    expect(deleted).not.toBeNull();
+    expect(deleted!.fidelity).toBe("gone");
   });
 });
 
@@ -755,7 +757,9 @@ describe("applyDiff", () => {
       reinforceNodeIds: [],
     });
     expect(result.nodesDeleted).toBe(1);
-    expect(getNode(node.id)).toBeNull();
+    const deleted = getNode(node.id);
+    expect(deleted).not.toBeNull();
+    expect(deleted!.fidelity).toBe("gone");
   });
 
   test("updates nodes", () => {

package/src/memory/graph/store.ts

@@ -2,10 +2,11 @@
 // Memory Graph — Data access layer
 // ---------------------------------------------------------------------------
 
-import { and, desc, eq, inArray, sql } from "drizzle-orm";
+import { and, desc, eq, inArray, or, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "../db.js";
+import { enqueueMemoryJob } from "../jobs-store.js";
 import {
   memoryGraphEdges,
   memoryGraphNodeEdits,
@@ -270,7 +271,14 @@ export function updateNode(
 
 export function deleteNode(id: string): void {
   const db = getDb();
-  db.delete(memoryGraphNodes).where(eq(memoryGraphNodes.id, id)).run();
+  db.update(memoryGraphNodes)
+    .set({ fidelity: "gone", lastAccessed: Date.now() })
+    .where(eq(memoryGraphNodes.id, id))
+    .run();
+  enqueueMemoryJob("delete_qdrant_vectors", {
+    targetType: "graph_node",
+    targetId: id,
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -343,7 +351,7 @@ export function queryNodes(filters: NodeQueryFilters): MemoryNode[] {
     .where(conditions.length > 0 ? and(...conditions) : undefined)
     .orderBy(sql`${memoryGraphNodes.significance} DESC`);
 
-  if (filters.limit) {
+  if (filters.limit != null) {
     query = query.limit(filters.limit) as typeof query;
   }
 
@@ -396,12 +404,19 @@ export function getEdgesForNode(
   direction?: "incoming" | "outgoing",
 ): MemoryEdge[] {
   const db = getDb();
-  const condition =
+  const dirCondition =
     direction === "outgoing"
       ? eq(memoryGraphEdges.sourceNodeId, nodeId)
       : direction === "incoming"
         ? eq(memoryGraphEdges.targetNodeId, nodeId)
-        : sql`${memoryGraphEdges.sourceNodeId} = ${nodeId} OR ${memoryGraphEdges.targetNodeId} = ${nodeId}`;
+        : or(eq(memoryGraphEdges.sourceNodeId, nodeId), eq(memoryGraphEdges.targetNodeId, nodeId));
+
+  // Exclude edges where either endpoint has fidelity='gone' (soft-deleted)
+  const condition = and(
+    dirCondition,
+    sql`NOT EXISTS (SELECT 1 FROM ${memoryGraphNodes} WHERE ${memoryGraphNodes.id} = ${memoryGraphEdges.sourceNodeId} AND ${memoryGraphNodes.fidelity} = 'gone')`,
+    sql`NOT EXISTS (SELECT 1 FROM ${memoryGraphNodes} WHERE ${memoryGraphNodes.id} = ${memoryGraphEdges.targetNodeId} AND ${memoryGraphNodes.fidelity} = 'gone')`,
+  );
 
   return db
     .select()
@@ -512,12 +527,23 @@ export function getActiveTriggersByType(
     return rows.map((r) => rowToTrigger(r.trigger));
   }
 
-  return db
-    .select()
+  const rows = db
+    .select({
+      trigger: memoryGraphTriggers,
+    })
     .from(memoryGraphTriggers)
-    .where(and(...conditions))
-    .all()
-    .map(rowToTrigger);
+    .innerJoin(
+      memoryGraphNodes,
+      eq(memoryGraphTriggers.nodeId, memoryGraphNodes.id),
+    )
+    .where(
+      and(
+        ...conditions,
+        sql`${memoryGraphNodes.fidelity} != 'gone'`,
+      ),
+    )
+    .all();
+  return rows.map((r) => rowToTrigger(r.trigger));
 }
 
 // ---------------------------------------------------------------------------
@@ -614,9 +640,18 @@ export function applyDiff(
   };
 
   db.transaction((tx) => {
-    // Delete nodes first (cascades edges + triggers)
+    // Soft-delete nodes (set fidelity='gone' and enqueue Qdrant cleanup)
     for (const id of diff.deleteNodeIds) {
-      tx.delete(memoryGraphNodes).where(eq(memoryGraphNodes.id, id)).run();
+      tx.update(memoryGraphNodes)
+        .set({ fidelity: "gone", lastAccessed: Date.now() })
+        .where(eq(memoryGraphNodes.id, id))
+        .run();
+      enqueueMemoryJob(
+        "delete_qdrant_vectors",
+        { targetType: "graph_node", targetId: id },
+        Date.now(),
+        tx,
+      );
       result.nodesDeleted++;
     }
 

package/src/memory/group-crud.ts

@@ -33,7 +33,7 @@ export function listGroups(): ConversationGroupRow[] {
     created_at: number;
     updated_at: number;
   }>(
-    "SELECT id, name, sort_position, is_system_group, created_at, updated_at FROM conversation_groups WHERE id != '_backfill_complete' ORDER BY sort_position ASC",
+    "SELECT id, name, sort_position, is_system_group, created_at, updated_at FROM conversation_groups WHERE id NOT IN ('_backfill_complete', '_backfill_all_complete', '_sort_shift_complete') ORDER BY sort_position ASC",
   );
   return rows.map((r) => ({
     id: r.id,
@@ -79,8 +79,8 @@ export function getGroup(groupId: string): ConversationGroupRow | null {
 
 /**
  * Create a custom group. Server assigns sort_position as max(custom) + 1.
- * System groups occupy positions 0 (pinned), 1 (scheduled), 2 (background).
- * First custom group gets position 3. Fallback ?? 2 ensures 2 + 1 = 3 when
+ * System groups occupy positions 0–3 (pinned, scheduled, background, all).
+ * First custom group gets position 4. Fallback ?? 3 ensures 3 + 1 = 4 when
  * no custom groups exist.
  */
 export function createGroup(name: string): ConversationGroupRow {
@@ -88,7 +88,7 @@ export function createGroup(name: string): ConversationGroupRow {
   const maxPos =
     rawGet<{ max: number | null }>(
       "SELECT MAX(sort_position) as max FROM conversation_groups WHERE is_system_group = 0",
-    )?.max ?? 2;
+    )?.max ?? 3;
   const sortPosition = maxPos + 1;
   const id = uuid();
   const now = Math.floor(Date.now() / 1000);
@@ -153,13 +153,16 @@ export function updateGroup(
 // Delete
 // ---------------------------------------------------------------------------
 
-// Relies on PRAGMA foreign_keys = ON (set at connection time) so that
-// ON DELETE SET NULL fires and clears group_id on conversations when
-// a group is deleted. If FK enforcement is ever disabled, orphaned
-// group_id values would persist and conversations would appear in a
-// non-existent group.
+// Reassign conversations to system:all before deleting the group so they
+// don't end up with NULL group_id (which would violate the system:all
+// invariant). The FK ON DELETE SET NULL would otherwise leave NULLs that
+// the one-time backfill won't re-fix.
 export function deleteGroup(groupId: string): boolean {
   ensureGroupMigration();
+  rawRun(
+    "UPDATE conversations SET group_id = 'system:all' WHERE group_id = ?",
+    groupId,
+  );
   rawRun("DELETE FROM conversation_groups WHERE id = ?", groupId);
   return true;
 }
@@ -176,6 +179,19 @@ export function reorderGroups(
   rawExec("BEGIN");
   try {
     for (const update of updates) {
+      // Look up the group first — skip unknown/stale IDs and system groups
+      const group = rawGet<{ id: string; is_system_group: number }>(
+        "SELECT id, is_system_group FROM conversation_groups WHERE id = ?",
+        update.groupId,
+      );
+      if (!group) continue;
+      if (group.is_system_group === 1) continue;
+
+      if (update.sortPosition < 4) {
+        throw new Error(
+          `Custom group sort_position must be >= 4 (got ${update.sortPosition} for ${update.groupId})`,
+        );
+      }
       rawRun(
         "UPDATE conversation_groups SET sort_position = ?, updated_at = ? WHERE id = ?",
         update.sortPosition,

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

@@ -301,7 +301,7 @@ export function getUsageHourBuckets(range: UsageTimeRange): UsageDayBucket[] {
   }));
 }
 
-type GroupByDimension = "actor" | "provider" | "model";
+type GroupByDimension = "actor" | "provider" | "model" | "conversation";
 
 /**
  * Return grouped breakdowns across the given time range, ordered by total
@@ -312,10 +312,51 @@ export function getUsageGroupBreakdown(
   groupBy: GroupByDimension,
 ): UsageGroupBreakdown[] {
   // Runtime allowlist — defense-in-depth against SQL injection via type assertions.
-  const ALLOWED_COLUMNS = new Set<string>(["actor", "provider", "model"]);
-  if (!ALLOWED_COLUMNS.has(groupBy)) {
-    throw new Error(`Invalid groupBy column: ${groupBy}`);
+  const ALLOWED_DIMENSIONS = new Set<string>([
+    "actor",
+    "provider",
+    "model",
+    "conversation",
+  ]);
+  if (!ALLOWED_DIMENSIONS.has(groupBy)) {
+    throw new Error(`Invalid groupBy dimension: ${groupBy}`);
   }
+
+  // Conversation grouping requires a JOIN with conversations to resolve titles.
+  if (groupBy === "conversation") {
+    const rows = rawAll<GroupRow>(
+      /*sql*/ `
+      SELECT
+        CASE WHEN e.conversation_id IS NULL THEN 'Other'
+             ELSE COALESCE(c.title, 'Untitled')
+        END AS group_key,
+        COALESCE(SUM(e.input_tokens), 0)                 AS total_input_tokens,
+        COALESCE(SUM(e.output_tokens), 0)                AS total_output_tokens,
+        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
+      FROM llm_usage_events e
+      LEFT JOIN conversations c ON e.conversation_id = c.id
+      WHERE e.created_at >= ?1 AND e.created_at <= ?2
+      GROUP BY e.conversation_id
+      ORDER BY total_estimated_cost_usd DESC
+      LIMIT 50
+      `,
+      range.from,
+      range.to,
+    );
+    return rows.map((r) => ({
+      group: r.group_key,
+      totalInputTokens: r.total_input_tokens,
+      totalOutputTokens: r.total_output_tokens,
+      totalCacheCreationTokens: r.total_cache_creation_tokens,
+      totalCacheReadTokens: r.total_cache_read_tokens,
+      totalEstimatedCostUsd: r.total_estimated_cost_usd ?? 0,
+      eventCount: r.event_count,
+    }));
+  }
+
   const column = groupBy;
   const rows = rawAll<GroupRow>(
     /*sql*/ `

package/src/memory/migrations/213-oauth-providers-scope-separator.ts

@@ -0,0 +1,13 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateOAuthProvidersScopeSeparator(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(
+      `ALTER TABLE oauth_providers ADD COLUMN scope_separator TEXT NOT NULL DEFAULT ' '`,
+    );
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

package/src/memory/migrations/214-oauth-providers-refresh-url.ts

@@ -0,0 +1,11 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateOAuthProvidersRefreshUrl(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(`ALTER TABLE oauth_providers ADD COLUMN refresh_url TEXT`);
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

package/src/memory/migrations/215-oauth-providers-revoke.ts

@@ -0,0 +1,14 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateOAuthProvidersRevoke(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const columns = ["revoke_url TEXT", "revoke_body_template TEXT"];
+  for (const col of columns) {
+    try {
+      raw.exec(`ALTER TABLE oauth_providers ADD COLUMN ${col}`);
+    } catch {
+      // Column already exists — nothing to do.
+    }
+  }
+}

package/src/memory/migrations/216-oauth-providers-token-auth-method.ts

@@ -0,0 +1,30 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Backfill `oauth_providers.token_endpoint_auth_method` for any rows where
+ * the value is NULL or empty string, setting them to the new default
+ * "client_secret_post". This brings existing rows in line with the
+ * Drizzle schema's new `.notNull().default("client_secret_post")`
+ * constraint, which is enforced at write time via the TypeScript layer.
+ *
+ * SQLite cannot retroactively add a NOT NULL constraint to an existing
+ * column without a full table rebuild, so the underlying column remains
+ * nullable at the SQLite level. All writes go through Drizzle, which
+ * applies the default for any insert that omits the field.
+ *
+ * The UPDATE is inherently idempotent and safe to re-run. Errors are
+ * allowed to propagate to the migration runner in `db-init.ts`, which
+ * records the failure, logs it, and continues to the next migration.
+ */
+export function migrateOAuthProvidersTokenAuthMethodDefault(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(
+    `UPDATE oauth_providers
+     SET token_endpoint_auth_method = 'client_secret_post'
+     WHERE token_endpoint_auth_method IS NULL
+        OR token_endpoint_auth_method = ''`,
+  );
+}

package/src/memory/migrations/217-conversation-host-access.ts

@@ -0,0 +1,40 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_conversation_host_access_v1";
+
+/**
+ * Add conversation-scoped host access state with a safe default of disabled.
+ *
+ * Idempotent: ALTER TABLE is guarded and the backfill only touches NULL rows.
+ */
+export function migrateConversationHostAccess(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+
+    try {
+      raw.exec(
+        `ALTER TABLE conversations ADD COLUMN host_access INTEGER NOT NULL DEFAULT 0`,
+      );
+    } catch {
+      // Column already exists.
+    }
+
+    raw.exec(`
+      UPDATE conversations
+      SET host_access = 0
+      WHERE host_access IS NULL
+    `);
+  });
+}
+
+/**
+ * Reverse: no-op.
+ *
+ * The forward migration is additive and SQLite cannot drop one column without
+ * rebuilding the table.
+ */
+export function downConversationHostAccess(_database: DrizzleDb): void {
+  // Intentionally empty.
+}

package/src/memory/migrations/218-oauth-providers-logo-url.ts

@@ -0,0 +1,11 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateOAuthProvidersLogoUrl(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(`ALTER TABLE oauth_providers ADD COLUMN logo_url TEXT`);
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}