@vellumai/assistant 0.7.0 → 0.7.1

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

@@ -222,18 +222,6 @@ export function getGuardianActionRequest(
   return row ? rowToRequest(row) : null;
 }
 
-export function getByPendingQuestionId(
-  questionId: string,
-): GuardianActionRequest | null {
-  const db = getDb();
-  const row = db
-    .select()
-    .from(guardianActionRequests)
-    .where(eq(guardianActionRequests.pendingQuestionId, questionId))
-    .get();
-  return row ? rowToRequest(row) : null;
-}
-
 /**
  * Find the most recent pending guardian action request for a given call session.
  * Used by the consultation timeout handler to mark the linked request as timed out.
@@ -382,37 +370,6 @@ export function supersedeGuardianActionRequest(
   return getGuardianActionRequest(id);
 }
 
-/**
- * Backfill supersession metadata on an already-expired request.
- * Used when the superseding request ID is not known at the time the
- * original request is expired (e.g., the new request is created
- * asynchronously via dispatchGuardianQuestion).
- *
- * Only updates requests that are already in 'expired' status with
- * expired_reason='superseded'.
- */
-export function backfillSupersessionMetadata(
-  id: string,
-  supersededByRequestId: string,
-): void {
-  const db = getDb();
-  const now = Date.now();
-
-  db.update(guardianActionRequests)
-    .set({
-      supersededByRequestId,
-      supersededAt: now,
-      updatedAt: now,
-    })
-    .where(
-      and(
-        eq(guardianActionRequests.id, id),
-        eq(guardianActionRequests.status, "expired"),
-      ),
-    )
-    .run();
-}
-
 /**
  * Get all pending guardian action requests that have expired.
  */
@@ -683,46 +640,6 @@ export function createGuardianActionDelivery(params: {
   return rowToDelivery(row);
 }
 
-/**
- * Look up sent deliveries for a specific destination.
- * Used by inbound message routing to match incoming answers to deliveries.
- */
-export function getPendingDeliveriesByDestination(
-  channel: string,
-  chatId: string,
-): GuardianActionDelivery[] {
-  try {
-    const db = getDb();
-
-    const rows = db
-      .select({
-        delivery: guardianActionDeliveries,
-      })
-      .from(guardianActionDeliveries)
-      .innerJoin(
-        guardianActionRequests,
-        eq(guardianActionDeliveries.requestId, guardianActionRequests.id),
-      )
-      .where(
-        and(
-          eq(guardianActionRequests.status, "pending"),
-          eq(guardianActionDeliveries.destinationChannel, channel),
-          eq(guardianActionDeliveries.destinationChatId, chatId),
-          eq(guardianActionDeliveries.status, "sent"),
-        ),
-      )
-      .all();
-
-    return rows.map((r) => rowToDelivery(r.delivery));
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("no such table")) {
-      log.warn({ err }, "guardian tables not yet created");
-      return [];
-    }
-    throw err;
-  }
-}
-
 /**
  * Look up all pending deliveries by destination conversation ID.
  * Used for disambiguation when a reused vellum conversation has multiple active

package/src/memory/guardian-approvals.ts

@@ -292,54 +292,6 @@ export function updateApprovalDecision(
     .run();
 }
 
-// ---------------------------------------------------------------------------
-// Escalation Query Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * List approval requests optionally filtered by channel, conversation, and
- * status. Returns a paginated list of escalations.
- */
-export function listPendingApprovalRequests(params: {
-  channel?: string;
-  conversationId?: string;
-  status?: ApprovalRequestStatus;
-  limit?: number;
-  offset?: number;
-}): GuardianApprovalRequest[] {
-  const db = getDb();
-
-  const conditions: ReturnType<typeof eq>[] = [];
-  if (params.channel) {
-    conditions.push(
-      eq(channelGuardianApprovalRequests.channel, params.channel),
-    );
-  }
-  if (params.conversationId) {
-    conditions.push(
-      eq(channelGuardianApprovalRequests.conversationId, params.conversationId),
-    );
-  }
-  conditions.push(
-    eq(channelGuardianApprovalRequests.status, params.status ?? "pending"),
-  );
-
-  let query = db
-    .select()
-    .from(channelGuardianApprovalRequests)
-    .where(and(...conditions))
-    .orderBy(desc(channelGuardianApprovalRequests.createdAt));
-
-  if (params.limit !== undefined) {
-    query = query.limit(params.limit) as typeof query;
-  }
-  if (params.offset !== undefined) {
-    query = query.offset(params.offset) as typeof query;
-  }
-
-  return query.all().map(rowToApprovalRequest);
-}
-
 /**
  * Fetch a single approval request by its primary key.
  */

package/src/memory/indexer.ts

@@ -1,5 +1,5 @@
 import { createHash } from "crypto";
-import { desc, eq } from "drizzle-orm";
+import { eq } from "drizzle-orm";
 
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
@@ -349,20 +349,6 @@ export function enqueueRebuildIndexJob(): string {
   return enqueueMemoryJob("rebuild_index", {});
 }
 
-export function getRecentSegmentsForConversation(
-  conversationId: string,
-  limit: number,
-): Array<typeof memorySegments.$inferSelect> {
-  const db = getDb();
-  return db
-    .select()
-    .from(memorySegments)
-    .where(eq(memorySegments.conversationId, conversationId))
-    .orderBy(desc(memorySegments.createdAt))
-    .limit(limit)
-    .all();
-}
-
 function buildSegmentId(messageId: string, segmentIndex: number): string {
   return `${messageId}:${segmentIndex}`;
 }

package/src/memory/job-handlers/conversation-starters.ts

@@ -19,6 +19,16 @@ import {
 } from "../../providers/provider-send-message.js";
 import { getLogger } from "../../util/logger.js";
 import { truncate } from "../../util/truncate.js";
+import {
+  checkpointKey,
+  CK_BATCH,
+  CK_ITEM_COUNT,
+  CK_LAST_GEN_AT,
+  countActiveMemoryNodes,
+  getCheckpointValue,
+  parseCheckpointInt,
+  upsertCheckpoint,
+} from "../conversation-starter-checkpoints.js";
 import {
   buildConversationStarterValidationContext,
   isValidConversationStarterText,
@@ -26,23 +36,11 @@ import {
 import { getDb } from "../db-connection.js";
 import { asString } from "../job-utils.js";
 import type { MemoryJob } from "../jobs-store.js";
-import { rawAll, rawGet } from "../raw-query.js";
-import {
-  conversationStarters,
-  memoryCheckpoints,
-  memoryGraphNodes,
-} from "../schema.js";
+import { rawAll } from "../raw-query.js";
+import { conversationStarters, memoryGraphNodes } from "../schema.js";
 
 const log = getLogger("conversation-starters-gen");
 
-function checkpointKey(base: string, scopeId: string): string {
-  return `${base}:${scopeId}`;
-}
-
-const CK_ITEM_COUNT = "conversation_starters:item_count_at_last_gen";
-const CK_BATCH = "conversation_starters:generation_batch";
-const CK_LAST_GEN_AT = "conversation_starters:last_gen_at";
-
 // ── Rollup construction ───────────────────────────────────────────
 
 function buildMemoryRollup(scopeId: string): string {
@@ -97,13 +95,10 @@ function buildMemoryRollup(scopeId: string): string {
 }
 
 function buildNewItemsDiff(scopeId: string): string {
-  const db = getDb();
-  const checkpoint = db
-    .select({ value: memoryCheckpoints.value })
-    .from(memoryCheckpoints)
-    .where(eq(memoryCheckpoints.key, checkpointKey(CK_LAST_GEN_AT, scopeId)))
-    .get();
-  const lastGenAt = checkpoint ? parseInt(checkpoint.value, 10) : 0;
+  const lastGenAt =
+    parseCheckpointInt(
+      getCheckpointValue(checkpointKey(CK_LAST_GEN_AT, scopeId)),
+    ) ?? 0;
 
   if (lastGenAt === 0) return ""; // No previous generation — skip diff
 
@@ -400,25 +395,27 @@ export async function generateConversationStartersJob(
   job: MemoryJob,
 ): Promise<void> {
   const scopeId = asString(job.payload.scopeId) ?? "default";
+  const db = getDb();
+  const now = Date.now();
 
   const starters = await generateStarters(scopeId);
   if (starters.length === 0) {
     log.info({ scopeId }, "No conversation starters generated");
+
+    // Sync checkpoints so both `staleByAge` and `checkpointAhead` clear.
+    const totalActive = countActiveMemoryNodes(scopeId);
+    upsertCheckpoint(
+      checkpointKey(CK_ITEM_COUNT, scopeId),
+      String(totalActive),
+      now,
+    );
+    upsertCheckpoint(checkpointKey(CK_LAST_GEN_AT, scopeId), String(now), now);
     return;
   }
 
-  const db = getDb();
-  const now = Date.now();
-
   // Determine next batch number
-  const batchCheckpoint = db
-    .select({ value: memoryCheckpoints.value })
-    .from(memoryCheckpoints)
-    .where(eq(memoryCheckpoints.key, checkpointKey(CK_BATCH, scopeId)))
-    .get();
-  const nextBatch = batchCheckpoint
-    ? parseInt(batchCheckpoint.value, 10) + 1
-    : 1;
+  const prevBatch = getCheckpointValue(checkpointKey(CK_BATCH, scopeId));
+  const nextBatch = prevBatch ? parseInt(prevBatch, 10) + 1 : 1;
 
   // Collect the memory types that informed this batch
   let sourceKinds = "";
@@ -444,7 +441,6 @@ export async function generateConversationStartersJob(
     .where(eq(conversationStarters.scopeId, scopeId))
     .run();
 
-  // Insert starters — all are chips
   for (const starter of starters) {
     db.insert(conversationStarters)
       .values({
@@ -461,27 +457,14 @@ export async function generateConversationStartersJob(
       .run();
   }
 
-  // Count active items for checkpoint
-  const countRow = rawGet<{ c: number }>(
-    `SELECT COUNT(*) AS c FROM memory_graph_nodes WHERE fidelity != 'gone' AND scope_id = ?`,
-    scopeId,
+  const totalActive = countActiveMemoryNodes(scopeId);
+  upsertCheckpoint(
+    checkpointKey(CK_ITEM_COUNT, scopeId),
+    String(totalActive),
+    now,
   );
-  const totalActive = countRow?.c ?? 0;
-
-  // Update all three checkpoints
-  const upsertCheckpoint = (key: string, value: string) => {
-    db.insert(memoryCheckpoints)
-      .values({ key, value, updatedAt: now })
-      .onConflictDoUpdate({
-        target: memoryCheckpoints.key,
-        set: { value, updatedAt: now },
-      })
-      .run();
-  };
-
-  upsertCheckpoint(checkpointKey(CK_ITEM_COUNT, scopeId), String(totalActive));
-  upsertCheckpoint(checkpointKey(CK_BATCH, scopeId), String(nextBatch));
-  upsertCheckpoint(checkpointKey(CK_LAST_GEN_AT, scopeId), String(now));
+  upsertCheckpoint(checkpointKey(CK_BATCH, scopeId), String(nextBatch), now);
+  upsertCheckpoint(checkpointKey(CK_LAST_GEN_AT, scopeId), String(now), now);
 
   log.info(
     { scopeId, batch: nextBatch, count: starters.length },

package/src/memory/job-utils.ts

@@ -132,12 +132,6 @@ export function asString(value: unknown): string | null {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 
-export function asPositiveMs(value: unknown): number | null {
-  if (typeof value !== "number") return null;
-  if (!Number.isFinite(value) || value <= 0) return null;
-  return Math.floor(value);
-}
-
 export function truncate(text: string, max: number): string {
   if (text.length <= max) return text;
   return `${text.slice(0, max - 3)}...`;

package/src/memory/jobs-store.ts

@@ -40,7 +40,6 @@ export type MemoryJobType =
   | "memory_v2_sweep"
   | "memory_v2_consolidate"
   | "memory_v2_migrate"
-  | "memory_v2_rebuild_edges"
   | "memory_v2_reembed"
   | "memory_v2_activation_recompute";
 

package/src/memory/jobs-worker.ts

@@ -6,7 +6,6 @@ import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import {
   getLastScheduledCleanupEnqueueMs,
   markScheduledCleanupEnqueued,
-  resetCleanupScheduleThrottle as resetCleanupScheduleThrottleImpl,
 } from "./cleanup-schedule-state.js";
 import { conversationAnalyzeJob } from "./conversation-analyze-job.js";
 import { maybeRunDbMaintenance } from "./db-maintenance.js";
@@ -64,7 +63,6 @@ import { QdrantCircuitOpenError } from "./qdrant-circuit-breaker.js";
 import {
   memoryV2ActivationRecomputeJob,
   memoryV2MigrateJob,
-  memoryV2RebuildEdgesJob,
   memoryV2ReembedJob,
 } from "./v2/backfill-jobs.js";
 import { memoryV2ConsolidateJob } from "./v2/consolidation-job.js";
@@ -88,6 +86,7 @@ const LEGACY_JOB_TYPES = new Set([
   "journal_carry_forward",
   "generate_capability_cards",
   "generate_thread_starters",
+  "memory_v2_rebuild_edges",
 ]);
 
 export const POLL_INTERVAL_MIN_MS = 1_500;
@@ -473,9 +472,6 @@ async function processJob(
     case "memory_v2_migrate":
       await memoryV2MigrateJob(job, config);
       return;
-    case "memory_v2_rebuild_edges":
-      await memoryV2RebuildEdgesJob(job, config);
-      return;
     case "memory_v2_reembed":
       await memoryV2ReembedJob(job, config);
       return;
@@ -494,16 +490,6 @@ async function processJob(
   }
 }
 
-// ── Cleanup scheduling ─────────────────────────────────────────────
-
-/**
- * Re-export of the shared throttle-reset helper. The underlying state lives
- * in cleanup-schedule-state.ts so that lighter-weight callers (e.g.
- * ConfigWatcher) can reset it without pulling in jobs-worker's transitive
- * imports.
- */
-export const resetCleanupScheduleThrottle = resetCleanupScheduleThrottleImpl;
-
 /**
  * Enqueue periodic cleanup jobs using config-driven retention windows.
  * Enqueue is deduped in jobs-store, so repeated calls remain safe.
@@ -546,7 +532,7 @@ const GRAPH_CONSOLIDATE_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4 hours
 const GRAPH_PATTERN_SCAN_INTERVAL_MS = 24 * 60 * 60 * 1000; // 1 day
 const GRAPH_NARRATIVE_INTERVAL_MS = 7 * 24 * 60 * 60 * 1000; // 1 week
 
-const GRAPH_MAINTENANCE_CHECKPOINTS = {
+export const GRAPH_MAINTENANCE_CHECKPOINTS = {
   decay: "graph_maintenance:decay:last_run",
   consolidate: "graph_maintenance:consolidate:last_run",
   patternScan: "graph_maintenance:pattern_scan:last_run",

package/src/memory/llm-request-log-store.ts

@@ -43,32 +43,6 @@ export function recordRequestLog(
   return id;
 }
 
-export function queryRequestLogs(
-  conversationId: string,
-  startTime: number,
-  endTime: number,
-): Array<{
-  id: string;
-  conversationId: string;
-  requestPayload: string;
-  responsePayload: string;
-  createdAt: number;
-}> {
-  const db = getDb();
-  return db
-    .select()
-    .from(llmRequestLogs)
-    .where(
-      and(
-        eq(llmRequestLogs.conversationId, conversationId),
-        gte(llmRequestLogs.createdAt, startTime),
-        lte(llmRequestLogs.createdAt, endTime),
-      ),
-    )
-    .orderBy(llmRequestLogs.createdAt)
-    .all();
-}
-
 export function backfillMessageIdOnLogs(
   conversationId: string,
   messageId: string,
@@ -85,21 +59,6 @@ export function backfillMessageIdOnLogs(
     .run();
 }
 
-/**
- * Set `messageId` on specific log rows identified by their IDs.
- * Unlike `backfillMessageIdOnLogs` (which updates all null-messageId rows
- * for a conversation), this targets only the given log rows — safe for
- * concurrent watch/assistant turns.
- */
-export function setMessageIdOnLogs(logIds: string[], messageId: string): void {
-  if (logIds.length === 0) return;
-  const db = getDb();
-  db.update(llmRequestLogs)
-    .set({ messageId })
-    .where(inArray(llmRequestLogs.id, logIds))
-    .run();
-}
-
 /**
  * Re-link LLM request logs from a set of source message IDs to a target
  * message. Used during message consolidation so logs from deleted