@vellumai/assistant 0.5.13 → 0.5.14

package/src/memory/admin.ts

@@ -1,13 +1,21 @@
+import { and, count, desc, eq, sql } from "drizzle-orm";
+
 import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
-import { rawGet } from "./db.js";
+import { deleteMemoryCheckpoint } from "./checkpoints.js";
+import { getConversationMemoryScopeId } from "./conversation-crud.js";
+import { getDb, rawGet } from "./db.js";
 import { getMemoryBackendStatus } from "./embedding-backend.js";
-import { enqueueBackfillJob, enqueueRebuildIndexJob } from "./indexer.js";
+import { enqueueBackfillJob, enqueueRebuildIndexJob, MIN_SEGMENT_CHARS } from "./indexer.js";
 import {
   enqueueCleanupStaleSupersededItemsJob,
+  enqueueMemoryJob,
   getMemoryJobCounts,
 } from "./jobs-store.js";
+import { withQdrantBreaker } from "./qdrant-circuit-breaker.js";
+import { getQdrantClient } from "./qdrant-client.js";
 import { queryMemoryForCli } from "./retriever.js";
+import { conversations, memorySegments, memorySummaries, messages } from "./schema.js";
 
 const log = getLogger("memory-admin");
 
@@ -106,3 +114,174 @@ export function requestMemoryCleanup(retentionMs?: number): {
 export async function queryMemory(query: string, conversationId: string) {
   return queryMemoryForCli(query, conversationId, getConfig());
 }
+
+// ── Short segment cleanup ─────────────────────────────────────────────
+
+export interface CleanupShortSegmentsResult {
+  removed: number;
+  failed: number;
+  dryRunCount?: number;
+}
+
+/**
+ * Remove segments shorter than MIN_SEGMENT_CHARS from SQLite and Qdrant.
+ * These short fragments waste embedding budget, retrieval slots, and
+ * injection tokens.
+ */
+export async function cleanupShortSegments(
+  opts?: { dryRun?: boolean },
+): Promise<CleanupShortSegmentsResult> {
+  const db = getDb();
+
+  const shortSegments = db
+    .select({ id: memorySegments.id })
+    .from(memorySegments)
+    .where(sql`length(${memorySegments.text}) < ${MIN_SEGMENT_CHARS}`)
+    .all();
+
+  if (opts?.dryRun) {
+    return { removed: 0, failed: 0, dryRunCount: shortSegments.length };
+  }
+
+  let removed = 0;
+  let failed = 0;
+  for (const row of shortSegments) {
+    try {
+      const qdrant = getQdrantClient();
+      await withQdrantBreaker(() => qdrant.deleteByTarget("segment", row.id));
+    } catch (err) {
+      // Keep the SQLite row so the target ID is preserved for retry
+      log.warn({ segmentId: row.id, err }, "Qdrant deletion failed — skipping SQLite deletion to preserve target ID");
+      failed++;
+      continue;
+    }
+
+    db.delete(memorySegments)
+      .where(eq(memorySegments.id, row.id))
+      .run();
+    removed++;
+  }
+
+  log.info({ removed, failed, threshold: MIN_SEGMENT_CHARS }, "Cleaned up short segments");
+  return { removed, failed };
+}
+
+// ── Re-extraction ──────────────────────────────────────────────────────
+
+export interface ReextractTarget {
+  conversationId: string;
+  title: string | null;
+  messageCount: number;
+}
+
+/**
+ * Find the top N conversations by message count for re-extraction.
+ * Excludes background and private conversations.
+ */
+export function findReextractTargets(limit: number): ReextractTarget[] {
+  const db = getDb();
+  interface Row {
+    id: string;
+    title: string | null;
+    msg_count: number;
+  }
+  const rows = db
+    .select({
+      id: conversations.id,
+      title: conversations.title,
+      msg_count: count(messages.id),
+    })
+    .from(conversations)
+    .leftJoin(messages, eq(messages.conversationId, conversations.id))
+    .where(
+      sql`${conversations.conversationType} NOT IN ('background', 'private')`,
+    )
+    .groupBy(conversations.id)
+    .orderBy(desc(sql`count(${messages.id})`))
+    .limit(limit)
+    .all() as Row[];
+
+  return rows.map((r) => ({
+    conversationId: r.id,
+    title: r.title,
+    messageCount: r.msg_count,
+  }));
+}
+
+/**
+ * Look up a conversation for re-extraction targeting.
+ */
+export function findReextractTarget(
+  conversationId: string,
+): ReextractTarget | null {
+  const db = getDb();
+  const conv = db
+    .select({ id: conversations.id, title: conversations.title })
+    .from(conversations)
+    .where(eq(conversations.id, conversationId))
+    .get();
+  if (!conv) return null;
+
+  const [{ total }] = db
+    .select({ total: count() })
+    .from(messages)
+    .where(eq(messages.conversationId, conversationId))
+    .all();
+
+  return {
+    conversationId: conv.id,
+    title: conv.title,
+    messageCount: total,
+  };
+}
+
+/**
+ * Queue re-extraction for a set of conversations.
+ * Resets extraction checkpoints and clears extraction summaries so the
+ * batch extraction handler processes all messages from scratch with
+ * expanded supersession context.
+ */
+export function requestReextract(
+  targets: ReextractTarget[],
+): { jobIds: string[] } {
+  const db = getDb();
+  const jobIds: string[] = [];
+
+  for (const target of targets) {
+    const { conversationId } = target;
+
+    // Reset batch extraction checkpoints
+    deleteMemoryCheckpoint(
+      `batch_extract:${conversationId}:last_message_id`,
+    );
+    deleteMemoryCheckpoint(
+      `batch_extract:${conversationId}:pending_count`,
+    );
+
+    // Clear the extraction summary so it starts fresh
+    db.delete(memorySummaries)
+      .where(
+        and(
+          eq(memorySummaries.scope, "extraction_context"),
+          eq(memorySummaries.scopeKey, conversationId),
+        ),
+      )
+      .run();
+
+    // Resolve scope and enqueue with fullReextract flag
+    const scopeId = getConversationMemoryScopeId(conversationId);
+    const jobId = enqueueMemoryJob("batch_extract", {
+      conversationId,
+      scopeId,
+      fullReextract: true,
+    });
+    jobIds.push(jobId);
+
+    log.info(
+      { conversationId, title: target.title, messages: target.messageCount },
+      "Queued re-extraction job",
+    );
+  }
+
+  return { jobIds };
+}

package/src/memory/app-git-service.ts

@@ -26,6 +26,27 @@ import { getAppsDir, resolveAppDir } from "./app-store.js";
 
 const log = getLogger("app-git");
 
+// ---------------------------------------------------------------------------
+// Pending commit message — set by app tool executors, consumed at turn boundary
+// ---------------------------------------------------------------------------
+
+const pendingAppCommitMessages = new Map<string, string>();
+
+/** Set the commit message for the next app turn-boundary commit. */
+export function setAppCommitMessage(
+  conversationId: string,
+  message: string,
+): void {
+  pendingAppCommitMessages.set(conversationId, message);
+}
+
+/** Consume and clear the pending commit message for a conversation. */
+function consumeAppCommitMessage(conversationId: string): string | undefined {
+  const msg = pendingAppCommitMessages.get(conversationId);
+  pendingAppCommitMessages.delete(conversationId);
+  return msg;
+}
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -170,15 +191,51 @@ export async function commitAppTurnChanges(
   conversationId: string,
   turnNumber: number,
 ): Promise<void> {
+  // Consume before any work that could throw, so the message doesn't leak
+  const changeSummary = consumeAppCommitMessage(conversationId);
   try {
     const appsDir = getAppsDir();
     ensureAppGitignoreRules(appsDir);
 
     const gitService = getWorkspaceGitService(appsDir);
-    await gitService.commitIfDirty(() => ({
-      message: `Turn ${turnNumber}: app changes`,
-      metadata: { conversationId, turnNumber },
-    }));
+
+    await gitService.commitIfDirty((status) => {
+      if (changeSummary) {
+        return {
+          message: changeSummary,
+          metadata: { conversationId, turnNumber },
+        };
+      }
+
+      // Fallback: derive app names from changed file paths
+      const allFiles = [
+        ...new Set([...status.staged, ...status.modified, ...status.untracked]),
+      ];
+      const dirNames = [
+        ...new Set(allFiles.map((f) => f.split("/")[0].replace(/\.json$/, ""))),
+      ];
+      const appNames = dirNames.map((dirName) => {
+        try {
+          const jsonPath = join(appsDir, `${dirName}.json`);
+          const raw = readFileSync(jsonPath, "utf-8");
+          const app = JSON.parse(raw) as { name?: string };
+          return app.name || dirName;
+        } catch {
+          return dirName;
+        }
+      });
+      const subject =
+        appNames.length === 1
+          ? `update ${appNames[0]}`
+          : appNames.length <= 3
+            ? `update ${appNames.join(", ")}`
+            : `update ${appNames.length} apps`;
+
+      return {
+        message: subject,
+        metadata: { conversationId, turnNumber },
+      };
+    });
   } catch (err) {
     log.error(
       { err, conversationId, turnNumber },

package/src/memory/attachments-store.ts

@@ -345,6 +345,8 @@ const ALLOWED_MIME_TYPES = new Set([
   "image/bmp",
   "image/tiff",
   "image/x-icon",
+  "image/heic",
+  "image/heif",
   // Audio
   "audio/mpeg",
   "audio/ogg",

package/src/memory/canonical-guardian-store.ts

@@ -59,6 +59,10 @@ export interface CanonicalGuardianRequest {
   requestCode: string | null;
   toolName: string | null;
   inputDigest: string | null;
+  commandPreview: string | null;
+  riskLevel: string | null;
+  activityText: string | null;
+  executionTarget: string | null;
   status: CanonicalRequestStatus;
   answerText: string | null;
   decidedByExternalUserId: string | null;
@@ -149,6 +153,10 @@ function rowToRequest(
     requestCode: row.requestCode,
     toolName: row.toolName,
     inputDigest: row.inputDigest,
+    commandPreview: row.commandPreview,
+    riskLevel: row.riskLevel,
+    activityText: row.activityText,
+    executionTarget: row.executionTarget,
     status: row.status as CanonicalRequestStatus,
     answerText: row.answerText,
     decidedByExternalUserId: row.decidedByExternalUserId,
@@ -196,6 +204,10 @@ export interface CreateCanonicalGuardianRequestParams {
   requestCode?: string;
   toolName?: string;
   inputDigest?: string;
+  commandPreview?: string;
+  riskLevel?: string;
+  activityText?: string;
+  executionTarget?: string;
   status?: CanonicalRequestStatus;
   answerText?: string;
   decidedByExternalUserId?: string;
@@ -250,6 +262,10 @@ export function createCanonicalGuardianRequest(
     requestCode: params.requestCode ?? generateCanonicalRequestCode(),
     toolName: params.toolName ?? null,
     inputDigest: params.inputDigest ?? null,
+    commandPreview: params.commandPreview ?? null,
+    riskLevel: params.riskLevel ?? null,
+    activityText: params.activityText ?? null,
+    executionTarget: params.executionTarget ?? null,
     status: params.status ?? ("pending" as const),
     answerText: params.answerText ?? null,
     decidedByExternalUserId: params.decidedByExternalUserId ?? null,

package/src/memory/db-init.ts

@@ -82,6 +82,7 @@ import {
   migrateGuardianDeliveryConversationIndex,
   migrateGuardianPrincipalIdColumns,
   migrateGuardianPrincipalIdNotNull,
+  migrateGuardianRequestEnrichmentColumns,
   migrateGuardianTimestampsEpochMs,
   migrateGuardianVerificationPurpose,
   migrateGuardianVerificationSessions,
@@ -122,6 +123,7 @@ import {
   migrateSchemaIndexesAndColumns,
   migrateStripIntegrationPrefixFromProviderKeys,
   migrateUsageDashboardIndexes,
+  migrateUsageLlmCallCount,
   migrateVoiceInviteColumns,
   migrateVoiceInviteDisplayMetadata,
   recoverCrashedMigrations,
@@ -532,6 +534,12 @@ export function initializeDb(): void {
   // 96. Drop the setup_skill_id column from oauth_providers (concept removed)
   migrateDropSetupSkillIdColumn(database);
 
+  // 97. Add enrichment columns to canonical_guardian_requests for guardian approval UX
+  migrateGuardianRequestEnrichmentColumns(database);
+
+  // 98. Add llm_call_count column to llm_usage_events for accurate LLM call counting
+  migrateUsageLlmCallCount(database);
+
   validateMigrationState(database);
 
   if (process.env.BUN_TEST === "1") {

package/src/memory/embedding-local.ts

@@ -3,7 +3,10 @@ import { join } from "node:path";
 
 import { getIsContainerized } from "../config/env-registry.js";
 import { getLogger } from "../util/logger.js";
-import { getEmbeddingModelsDir, getRootDir } from "../util/platform.js";
+import {
+  getEmbeddingModelsDir,
+  getEmbedWorkerPidPath,
+} from "../util/platform.js";
 import { PromiseGuard } from "../util/promise-guard.js";
 import type {
   EmbeddingBackend,
@@ -404,7 +407,7 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
     if (getIsContainerized()) {
       return join("/tmp", LocalEmbeddingBackend.PID_FILENAME);
     }
-    return join(getRootDir(), LocalEmbeddingBackend.PID_FILENAME);
+    return getEmbedWorkerPidPath();
   }
 
   private writePidFile(pid: number): void {

package/src/memory/indexer.ts

@@ -5,6 +5,7 @@ import { getConfig } from "../config/loader.js";
 import type { MemoryConfig } from "../config/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { getLogger } from "../util/logger.js";
+import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import { getDb } from "./db.js";
 import { selectedBackendSupportsMultimodal } from "./embedding-backend.js";
 import { enqueueMemoryJob, upsertDebouncedJob } from "./jobs-store.js";
@@ -17,10 +18,8 @@ import { segmentText } from "./segmenter.js";
 
 const log = getLogger("memory-indexer");
 
-/** Delay before a conversation summary job becomes eligible to run.
- *  Each new message in the same conversation resets the timer, so the
- *  summary is only built once the conversation has been idle for this long. */
-const SUMMARY_DEBOUNCE_MS = 3 * 60 * 1000; // 3 minutes
+/** Minimum character length for a segment to be worth storing and embedding (~12-15 tokens). */
+export const MIN_SEGMENT_CHARS = 50;
 
 export interface IndexMessageInput {
   messageId: string;
@@ -59,12 +58,7 @@ export async function indexMessageNow(
 
   const text = extractTextFromStoredMessageContent(input.content);
   if (text.length === 0) {
-    upsertDebouncedJob(
-      "build_conversation_summary",
-      { conversationId: input.conversationId },
-      Date.now() + SUMMARY_DEBOUNCE_MS,
-    );
-    return { indexedSegments: 0, enqueuedJobs: 1 };
+    return { indexedSegments: 0, enqueuedJobs: 0 };
   }
 
   const db = getDb();
@@ -95,8 +89,13 @@ export async function indexMessageNow(
   // Wrap all segment inserts and job enqueues in a single transaction so they
   // either all succeed or all roll back, preventing partial/orphaned state.
   let skippedEmbedJobs = 0;
+  let skippedShortSegments = 0;
   db.transaction((tx) => {
     for (const segment of segments) {
+      if (segment.text.length < MIN_SEGMENT_CHARS) {
+        skippedShortSegments++;
+        continue;
+      }
       const segmentId = buildSegmentId(input.messageId, segment.segmentIndex);
       const hash = createHash("sha256").update(segment.text).digest("hex");
 
@@ -151,22 +150,42 @@ export async function indexMessageNow(
       );
     }
 
-    if (shouldExtract && isTrustedActor && !input.automated && config.extraction.useLLM) {
-      enqueueMemoryJob(
-        "extract_items",
-        { messageId: input.messageId, scopeId: input.scopeId ?? "default" },
-        Date.now(),
-        tx,
-      );
+  });
+
+  // ── Batch extraction tracking ──────────────────────────────────────
+  // Instead of per-message extraction, track pending unextracted messages
+  // and trigger batch extraction when the threshold is reached or after idle.
+  if (shouldExtract && isTrustedActor && !input.automated && config.extraction.useLLM) {
+    const pendingKey = `batch_extract:${input.conversationId}:pending_count`;
+    const currentVal = getMemoryCheckpoint(pendingKey);
+    const pendingCount = (currentVal ? parseInt(currentVal, 10) : 0) + 1;
+    setMemoryCheckpoint(pendingKey, String(pendingCount));
+
+    const batchSize = config.extraction.batchSize ?? 10;
+    const idleTimeoutMs = config.extraction.idleTimeoutMs ?? 300_000;
+
+    if (pendingCount >= batchSize) {
+      // Threshold reached — trigger immediate batch extraction
+      enqueueMemoryJob("batch_extract", {
+        conversationId: input.conversationId,
+        scopeId: input.scopeId ?? "default",
+      });
     }
 
+    // Also maintain idle debounce: enqueue a delayed batch_extract that fires
+    // if no new messages arrive within the idle timeout window.
     upsertDebouncedJob(
-      "build_conversation_summary",
+      "batch_extract",
       { conversationId: input.conversationId },
-      Date.now() + SUMMARY_DEBOUNCE_MS,
-      tx,
+      Date.now() + idleTimeoutMs,
     );
-  });
+  }
+
+  if (skippedShortSegments > 0) {
+    log.debug(
+      `Skipped ${skippedShortSegments}/${segments.length} segments shorter than ${MIN_SEGMENT_CHARS} chars`,
+    );
+  }
 
   if (skippedEmbedJobs > 0) {
     log.debug(
@@ -188,14 +207,13 @@ export async function indexMessageNow(
     log.info("Skipping extraction job: LLM extraction is disabled (useLLM=false)");
   }
 
-  const extractionGated = !isTrustedActor || !!input.automated || !config.extraction.useLLM;
+  const storedSegments = segments.length - skippedShortSegments;
   const enqueuedJobs =
-    segments.length -
+    storedSegments -
     skippedEmbedJobs +
-    mediaBlocks.length +
-    (shouldExtract && !extractionGated ? 2 : 1);
+    mediaBlocks.length;
   return {
-    indexedSegments: segments.length,
+    indexedSegments: storedSegments,
     enqueuedJobs,
   };
 }