@vellumai/assistant 0.6.4 → 0.6.5

package/src/memory/conversation-crud.ts

@@ -10,6 +10,7 @@ import {
   gte,
   inArray,
   isNull,
+  like,
   lt,
   lte,
   sql,
@@ -23,6 +24,7 @@ import { CHANNEL_IDS, INTERFACE_IDS, isChannelId } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
 import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
 import { UserError } from "../util/errors.js";
+import { safeParseRecord } from "../util/json.js";
 import { getLogger } from "../util/logger.js";
 import { getConversationsDir } from "../util/platform.js";
 import { createRowMapper } from "../util/row-mapper.js";
@@ -102,6 +104,9 @@ export const messageMetadataSchema = z
     forkSourceMessageId: z.string().optional(),
     /** Image source paths from desktop attachments, keyed by filename. */
     imageSourcePaths: z.record(z.string(), z.string()).optional(),
+    memoryInjectedBlock: z.string().optional(),
+    turnContextBlock: z.string().optional(),
+    pkbSystemReminderBlock: z.string().optional(),
   })
   .passthrough();
 
@@ -420,9 +425,7 @@ export function findAnalysisConversationFor(
  * not found. Tiny convenience used by the recursion guard in the
  * auto-analyze loop.
  */
-export function getConversationSource(
-  conversationId: string,
-): string | null {
+export function getConversationSource(conversationId: string): string | null {
   const db = getDb();
   const row = db
     .select({ source: conversations.source })
@@ -1044,6 +1047,49 @@ export function getMessages(conversationId: string): MessageRow[] {
     .map(parseMessage);
 }
 
+/**
+ * Count messages whose metadata JSON contains a `slackMeta` envelope, capped
+ * at `limit`. Pushes the cap into SQL (`LIKE` + `LIMIT`) so warm Slack DM
+ * conversations don't require a full-table scan + JSON parse on every
+ * inbound message to confirm the cold-start threshold has been cleared.
+ * Returns the number of matching rows up to `limit`; callers compare against
+ * the cold-start threshold to decide whether to backfill.
+ */
+export function countMessagesWithSlackMeta(
+  conversationId: string,
+  limit: number,
+): number {
+  const db = getDb();
+  const rows = db
+    .select({ one: sql`1` })
+    .from(messages)
+    .where(
+      and(
+        eq(messages.conversationId, conversationId),
+        like(messages.metadata, '%"slackMeta"%'),
+      ),
+    )
+    .limit(limit)
+    .all();
+  return rows.length;
+}
+
+/**
+ * Efficient existence check — returns true if the conversation has at least
+ * one message row. Uses `LIMIT 1` + `select({ 1 })` to avoid loading and
+ * parsing any message content.
+ */
+export function hasMessages(conversationId: string): boolean {
+  const db = getDb();
+  const row = db
+    .select({ one: sql`1` })
+    .from(messages)
+    .where(eq(messages.conversationId, conversationId))
+    .limit(1)
+    .get();
+  return row !== undefined;
+}
+
 export interface PaginatedMessagesResult {
   messages: MessageRow[];
   hasMore: boolean;
@@ -1456,6 +1502,60 @@ export function updateMessageMetadata(
     .run();
 }
 
+/**
+ * Bulk-remove the `pkbSystemReminderBlock` field from every user-message
+ * metadata row in a conversation. Called from compaction-strip sites so
+ * post-restart rehydration stays consistent with the in-memory state
+ * produced by `stripInjectionsForCompaction` (which removes
+ * `<system_reminder>` from live messages but cannot touch the DB).
+ */
+export function clearPkbSystemReminderMetadataForConversation(
+  conversationId: string,
+): void {
+  rawRun(
+    `UPDATE messages
+        SET metadata = json_remove(metadata, '$.pkbSystemReminderBlock')
+      WHERE conversation_id = ?
+        AND role = 'user'
+        AND metadata IS NOT NULL
+        AND json_extract(metadata, '$.pkbSystemReminderBlock') 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
+ * body and stamp metadata (e.g. `slackMeta.editedAt`) in a single
+ * transaction so a partial write cannot leak.
+ *
+ * `metadataUpdates` is shallow-merged into the existing top-level metadata
+ * object. To merge into a nested sub-key (e.g. `slackMeta`), the caller
+ * must compute the merged sub-value first and pass `{ slackMeta: merged }`.
+ */
+export function updateMessageContentAndMetadata(
+  messageId: string,
+  newContent: string,
+  metadataUpdates: Record<string, unknown>,
+): void {
+  const db = getDb();
+  db.transaction((tx) => {
+    const row = tx
+      .select({ metadata: messages.metadata })
+      .from(messages)
+      .where(eq(messages.id, messageId))
+      .get();
+    const existing = row?.metadata ? safeParseRecord(row.metadata) : {};
+    tx.update(messages)
+      .set({
+        content: newContent,
+        metadata: JSON.stringify({ ...existing, ...metadataUpdates }),
+      })
+      .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

package/src/memory/conversation-group-migration.ts

@@ -58,10 +58,6 @@ export function ensureGroupMigration(): void {
   }
 
   // 3. Seed system groups.
-  //
-  // `system:reflections` is a legacy group kept for backward compatibility
-  // with existing installations. New auto-analysis conversations are assigned
-  // to `system:background`; the migration in step 6 moves existing ones.
   const now = Math.floor(Date.now() / 1000);
   rawExec(`
     INSERT OR IGNORE INTO conversation_groups (id, name, sort_position, is_system_group, created_at, updated_at)
@@ -69,8 +65,7 @@ export function ensureGroupMigration(): void {
       ('system:pinned', 'Pinned', 0, TRUE, ${now}, ${now}),
       ('system:scheduled', 'Scheduled', 1, TRUE, ${now}, ${now}),
       ('system:background', 'Background', 2, TRUE, ${now}, ${now}),
-      ('system:all', 'Recents', 3, TRUE, ${now}, ${now}),
-      ('system:reflections', 'Reflections', 100, TRUE, ${now}, ${now})
+      ('system:all', 'Recents', 3, TRUE, ${now}, ${now})
   `);
 
   // One-time migration: move system:all to sortPosition 3 (from 999999).
@@ -245,5 +240,42 @@ export function ensureGroupMigration(): void {
     }
   }
 
+  // 7. One-time cleanup: delete the orphaned system:reflections group row.
+  //
+  // Reflections render as a sub-group under Background via the client's
+  // sub-group label provider; the standalone system:reflections group is no
+  // longer referenced by any conversation after step 6. Leaving the row in
+  // place causes the macOS sidebar to render an empty duplicate "Reflections"
+  // entry with a fallback folder icon alongside the Background sub-group.
+  const reflectionsGroupDeleted = rawGet<{ id: string }>(
+    "SELECT id FROM conversation_groups WHERE id = '_reflections_group_deleted_complete'",
+  );
+
+  if (!reflectionsGroupDeleted) {
+    try {
+      rawExec("BEGIN");
+
+      // Belt-and-suspenders: re-run the conversation move in case a straggler
+      // crept in between step 6's sentinel being set and this step shipping.
+      rawExec(`
+        UPDATE conversations SET group_id = 'system:background'
+        WHERE group_id = 'system:reflections'
+      `);
+
+      rawExec(`DELETE FROM conversation_groups WHERE id = 'system:reflections'`);
+
+      rawExec(`
+        INSERT OR IGNORE INTO conversation_groups (id, name, sort_position, is_system_group)
+        VALUES ('_reflections_group_deleted_complete', '_reflections_group_deleted_complete', -1, TRUE)
+      `);
+
+      rawExec("COMMIT");
+    } catch (err) {
+      rawExec("ROLLBACK");
+      log.error({ err }, "reflections-group deletion failed, rolled back");
+      throw err;
+    }
+  }
+
   migrated = true;
 }

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

@@ -37,6 +37,7 @@ export type TitleOrigin =
   | "filing"
   | "local"
   | "task_submit"
+  | "updates_bulletin"
   | "misc";
 
 export interface TitleContext {
@@ -118,7 +119,8 @@ export async function generateAndPersistConversationTitle(
     return { title: conversation.title!, updated: false };
   }
 
-  const provider = params.provider ?? (await getConfiguredProvider());
+  const provider =
+    params.provider ?? (await getConfiguredProvider("conversationTitle"));
   if (!provider) {
     // No provider available — fall back to context-derived title or untitled
     const fallback = deriveFallbackTitle(context) ?? UNTITLED_FALLBACK;
@@ -133,7 +135,7 @@ export async function generateAndPersistConversationTitle(
     provider,
     systemPrompt: buildTitleSystemPrompt(),
     tools: [],
-    modelIntent: "quality-optimized",
+    callSite: "conversationTitle",
     signal,
     timeoutMs: 10_000,
   });
@@ -219,7 +221,8 @@ export async function regenerateConversationTitle(
     return { title: conversation?.title ?? UNTITLED_FALLBACK, updated: false };
   }
 
-  const provider = params.provider ?? (await getConfiguredProvider());
+  const provider =
+    params.provider ?? (await getConfiguredProvider("conversationTitle"));
   if (!provider) {
     return { title: conversation.title ?? UNTITLED_FALLBACK, updated: false };
   }
@@ -236,7 +239,7 @@ export async function regenerateConversationTitle(
     provider,
     systemPrompt: buildTitleSystemPrompt(),
     tools: [],
-    modelIntent: "quality-optimized",
+    callSite: "conversationTitle",
     signal,
     timeoutMs: 10_000,
   });

package/src/memory/db-init.ts

@@ -146,6 +146,7 @@ import {
   migrateSchemaIndexesAndColumns,
   migrateScrubCorruptedImageAttachments,
   migrateStripIntegrationPrefixFromProviderKeys,
+  migrateStripPlaceholderSentinelsFromMessages,
   migrateStripThinkingFromConsolidated,
   migrateUsageDashboardIndexes,
   migrateUsageLlmCallCount,
@@ -370,6 +371,7 @@ export function initializeDb(): void {
     migrateOAuthProvidersTokenExchangeBodyFormat,
     migrateNormalizeUserFileByPrincipal,
     migrateConversationsArchivedAt,
+    migrateStripPlaceholderSentinelsFromMessages,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/embedding-backend.ts

@@ -795,7 +795,7 @@ export async function selectedBackendSupportsMultimodal(
 
 async function isOllamaConfigured(config: AssistantConfig): Promise<boolean> {
   return (
-    config.services.inference.provider === "ollama" ||
+    config.llm.default.provider === "ollama" ||
     Boolean(await getProviderKeyAsync("ollama")) ||
     Boolean(getOllamaBaseUrlEnv())
   );

package/src/memory/graph/compaction.ts

@@ -0,0 +1,299 @@
+// ---------------------------------------------------------------------------
+// Memory Graph — One-off backfill to compact over-long node content
+//
+// Scans memory_graph_nodes for entries whose `content` exceeds a length
+// threshold and rewrites them via an LLM call constrained to the same
+// "1-3 sentences / ~300 chars" rule the extraction prompt now enforces.
+// Preserves all other node fields (significance, emotionalCharge, edges,
+// triggers, image_refs). Each rewrite is logged in memory_graph_node_edits
+// with source="manual" so it is reversible and auditable.
+// ---------------------------------------------------------------------------
+
+import { and, sql } from "drizzle-orm";
+
+import {
+  extractToolUse,
+  getConfiguredProvider,
+  userMessage,
+} from "../../providers/provider-send-message.js";
+import { BackendUnavailableError } from "../../util/errors.js";
+import { getLogger } from "../../util/logger.js";
+import { getDb } from "../db.js";
+import { memoryGraphNodes } from "../schema.js";
+import { recordNodeEdit, updateNode } from "./store.js";
+
+const log = getLogger("graph-compaction");
+
+const COMPACTION_TOOL_SCHEMA = {
+  name: "compact_memory",
+  description: "Rewrite a memory node's content to fit the length cap",
+  input_schema: {
+    type: "object" as const,
+    properties: {
+      compacted_content: {
+        type: "string" as const,
+        description:
+          "The rewritten content — 1-3 sentences, first-person, ~300 characters or fewer",
+      },
+    },
+    required: ["compacted_content"] as const,
+  },
+};
+
+const COMPACTION_SYSTEM_PROMPT = `You are compacting an over-long memory node in an AI assistant's memory graph. The original content exceeds the extraction prompt's 1-3 sentence / ~300 character cap because it was written before the cap existed. Rewrite it to fit.
+
+## Rules
+
+**LENGTH: 1-3 sentences. Target ~300 characters. Hard cap ~400.** No exceptions.
+
+**Preserve:**
+- The core fact, event, or moment being remembered
+- First-person prose style if the original is first-person
+- The essential emotional tone of the memory
+
+**Drop:**
+- Scene-setting and surrounding context
+- Dialogue preservation (unless one short quote IS the memory)
+- Narrative "what it meant" commentary
+- Cataloging of every emotional nuance
+- Image descriptions packed into prose (images live in image_refs, not content)
+
+**Never:**
+- Invent facts not present in the original
+- Change the core subject or emotional valence
+- Pad to hit a target length — shorter than 300 chars is fine if the essence is there
+
+The node's \`emotionalCharge\` and \`significance\` fields (not shown) already carry the weight. Content stays lean.
+
+Call the \`compact_memory\` tool with the rewritten content. No preamble.`;
+
+export interface CompactionCandidate {
+  id: string;
+  beforeLen: number;
+}
+
+export interface CompactionProgress {
+  nodeId: string;
+  beforeLen: number;
+  afterLen: number;
+  action: "compacted" | "skipped" | "failed";
+  newContent?: string;
+  reason?: string;
+}
+
+export interface CompactionResult {
+  /** Nodes whose content exceeded the threshold (before --limit is applied). */
+  scanned: number;
+  /** Nodes actually processed (scanned ∩ limit). */
+  processed: number;
+  compacted: number;
+  skipped: number;
+  failures: number;
+  beforeChars: number;
+  afterChars: number;
+}
+
+export interface CompactionOptions {
+  /** Content length threshold — nodes above this get compacted. Default 400. */
+  threshold?: number;
+  /** If true, write changes. If false, only list candidates (no LLM calls). Default false. */
+  apply?: boolean;
+  /** Max nodes to process. Default: no limit. */
+  limit?: number;
+  /** Called for each node as it is processed in apply mode. */
+  onProgress?: (evt: CompactionProgress) => void;
+  /** Called once with the full candidate list (both preview and apply modes). */
+  onCandidates?: (candidates: CompactionCandidate[]) => void;
+}
+
+/**
+ * Find over-length nodes in the memory graph and (optionally) rewrite their
+ * content to fit the length cap. In preview mode (apply=false) no LLM calls
+ * are made — only the candidate list is returned.
+ */
+export async function compactLongMemories(
+  opts: CompactionOptions = {},
+): Promise<CompactionResult> {
+  const threshold = opts.threshold ?? 400;
+  const apply = opts.apply ?? false;
+
+  const db = getDb();
+  const rows = db
+    .select({
+      id: memoryGraphNodes.id,
+      content: memoryGraphNodes.content,
+    })
+    .from(memoryGraphNodes)
+    .where(
+      and(
+        // Skip already-dead nodes — rewriting content on "gone" fidelity is wasted work
+        sql`${memoryGraphNodes.fidelity} != 'gone'`,
+        sql`LENGTH(${memoryGraphNodes.content}) > ${threshold}`,
+      ),
+    )
+    .all();
+
+  const candidates = opts.limit != null ? rows.slice(0, opts.limit) : rows;
+
+  opts.onCandidates?.(
+    candidates.map((r) => ({ id: r.id, beforeLen: r.content.length })),
+  );
+
+  const result: CompactionResult = {
+    scanned: rows.length,
+    processed: candidates.length,
+    compacted: 0,
+    skipped: 0,
+    failures: 0,
+    beforeChars: candidates.reduce((sum, r) => sum + r.content.length, 0),
+    afterChars: 0,
+  };
+
+  if (!apply) {
+    // Preview mode: record beforeChars as afterChars (no rewrites attempted)
+    result.afterChars = result.beforeChars;
+    return result;
+  }
+
+  if (candidates.length === 0) return result;
+
+  const provider = await getConfiguredProvider("memoryConsolidation");
+  if (!provider) {
+    throw new BackendUnavailableError(
+      "Provider unavailable for memory compaction",
+    );
+  }
+
+  for (const row of candidates) {
+    const beforeLen = row.content.length;
+
+    try {
+      const response = await provider.sendMessage(
+        [
+          userMessage(
+            `Original memory content (length: ${beforeLen} chars):\n\n${row.content}`,
+          ),
+        ],
+        [COMPACTION_TOOL_SCHEMA],
+        COMPACTION_SYSTEM_PROMPT,
+        {
+          config: {
+            callSite: "memoryConsolidation" as const,
+            tool_choice: {
+              type: "tool" as const,
+              name: "compact_memory",
+            },
+          },
+        },
+      );
+
+      const toolBlock = extractToolUse(response);
+      if (!toolBlock) {
+        result.failures += 1;
+        result.afterChars += beforeLen;
+        opts.onProgress?.({
+          nodeId: row.id,
+          beforeLen,
+          afterLen: beforeLen,
+          action: "failed",
+          reason: "no tool_use block in response",
+        });
+        continue;
+      }
+
+      const input = toolBlock.input as { compacted_content?: string };
+      const newContent =
+        typeof input.compacted_content === "string"
+          ? input.compacted_content.trim()
+          : "";
+
+      if (!newContent) {
+        result.failures += 1;
+        result.afterChars += beforeLen;
+        opts.onProgress?.({
+          nodeId: row.id,
+          beforeLen,
+          afterLen: beforeLen,
+          action: "failed",
+          reason: "empty compacted_content",
+        });
+        continue;
+      }
+
+      // If the model didn't actually shrink it, skip — never overwrite with
+      // something equivalent or longer. Preserves the original when the LLM
+      // fails to compress.
+      if (newContent.length >= beforeLen) {
+        result.skipped += 1;
+        result.afterChars += beforeLen;
+        opts.onProgress?.({
+          nodeId: row.id,
+          beforeLen,
+          afterLen: newContent.length,
+          action: "skipped",
+          reason: "rewrite was not shorter than original",
+          newContent,
+        });
+        continue;
+      }
+
+      // Reject rewrites that are shorter than the original but still exceed
+      // the threshold cap — the whole point of the compaction is to land
+      // under the cap, not merely to reduce length.
+      if (newContent.length > threshold) {
+        result.skipped += 1;
+        result.afterChars += beforeLen;
+        opts.onProgress?.({
+          nodeId: row.id,
+          beforeLen,
+          afterLen: newContent.length,
+          action: "skipped",
+          reason: `rewrite still exceeds threshold (${newContent.length} > ${threshold})`,
+          newContent,
+        });
+        continue;
+      }
+
+      // Wrap edit recording + node update in a transaction so they are
+      // atomic: if updateNode fails, the edit record is rolled back. Without
+      // this, a mid-operation throw leaves an orphaned audit row pointing at
+      // a change that never committed.
+      getDb().transaction(() => {
+        recordNodeEdit({
+          nodeId: row.id,
+          previousContent: row.content,
+          newContent,
+          source: "manual",
+        });
+        updateNode(row.id, {
+          content: newContent,
+          lastConsolidated: Date.now(),
+        });
+      });
+
+      result.compacted += 1;
+      result.afterChars += newContent.length;
+      opts.onProgress?.({
+        nodeId: row.id,
+        beforeLen,
+        afterLen: newContent.length,
+        action: "compacted",
+        newContent,
+      });
+    } catch (err) {
+      result.failures += 1;
+      result.afterChars += beforeLen;
+      const reason = err instanceof Error ? err.message : String(err);
+      log.warn({ nodeId: row.id, err: reason }, "Compaction failed for node");
+      opts.onProgress?.({
+        nodeId: row.id,
+        beforeLen,
+        afterLen: beforeLen,
+        action: "failed",
+        reason,
+      });
+    }
+  }
+
+  return result;
+}

package/src/memory/graph/consolidation.ts

@@ -262,7 +262,7 @@ async function identifyDuplicateGroups(
 ): Promise<MemoryNode[][]> {
   if (nodes.length < 2) return [];
 
-  const provider = await getConfiguredProvider();
+  const provider = await getConfiguredProvider("memoryConsolidation");
   if (!provider) return [];
 
   // Compact listing: ID + first 100 chars of content
@@ -282,7 +282,7 @@ async function identifyDuplicateGroups(
     systemPrompt,
     {
       config: {
-        modelIntent: "quality-optimized" as const,
+        callSite: "memoryConsolidation" as const,
         tool_choice: { type: "tool" as const, name: "report_duplicate_groups" },
       },
     },
@@ -428,7 +428,7 @@ async function consolidateChunk(
     return true;
   });
 
-  const provider = await getConfiguredProvider();
+  const provider = await getConfiguredProvider("memoryConsolidation");
   if (!provider) {
     throw new BackendUnavailableError("Provider unavailable for consolidation");
   }
@@ -459,7 +459,7 @@ async function consolidateChunk(
     systemPrompt,
     {
       config: {
-        modelIntent: "quality-optimized" as const,
+        callSite: "memoryConsolidation" as const,
         tool_choice: { type: "tool" as const, name: "consolidate_diff" },
       },
     },