@vellumai/assistant 0.8.2 → 0.8.4

package/src/memory/delivery-status.ts

@@ -6,7 +6,7 @@
  * retryable and dead-lettered events, and replaying dead letters.
  */
 
-import { and, eq, lte } from "drizzle-orm";
+import { and, eq, lte, or } from "drizzle-orm";
 
 import { getDb } from "./db-connection.js";
 import {
@@ -44,6 +44,7 @@ export function acknowledgeDelivery(
   db.update(channelInboundEvents)
     .set({
       deliveryStatus: "delivered",
+      retryAfter: null,
       updatedAt: now,
     })
     .where(eq(channelInboundEvents.id, existing.id))
@@ -61,6 +62,23 @@ export function markProcessed(eventId: string): void {
     .run();
 }
 
+/** Mark an event's outbound callback delivery as complete. */
+export function markDeliveryDelivered(eventId: string): void {
+  const db = getDb();
+  db.update(channelInboundEvents)
+    .set({
+      deliveryStatus: "delivered",
+      retryAfter: null,
+      updatedAt: Date.now(),
+    })
+    .where(eq(channelInboundEvents.id, eventId))
+    .run();
+}
+
+function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
 /**
  * Record a processing failure. Classifies the error to decide whether
  * the event should be retried (status='failed') or dead-lettered
@@ -79,7 +97,7 @@ export function recordProcessingFailure(eventId: string, err: unknown): void {
 
   const attempts = (row?.attempts ?? 0) + 1;
   const category = classifyError(err);
-  const errorMsg = err instanceof Error ? err.message : String(err);
+  const errorMsg = errorMessage(err);
 
   if (category === "fatal" || attempts >= RETRY_MAX_ATTEMPTS) {
     db.update(channelInboundEvents)
@@ -107,6 +125,51 @@ export function recordProcessingFailure(eventId: string, err: unknown): void {
   }
 }
 
+/**
+ * Record an outbound callback delivery failure without changing the processing
+ * status. Delivery uses its own retry budget so a turn that needed processing
+ * retries still gets a full delivery retry window.
+ */
+export function recordDeliveryFailure(eventId: string, err: unknown): void {
+  const db = getDb();
+  const now = Date.now();
+
+  const row = db
+    .select({ attempts: channelInboundEvents.deliveryAttempts })
+    .from(channelInboundEvents)
+    .where(eq(channelInboundEvents.id, eventId))
+    .get();
+
+  const attempts = (row?.attempts ?? 0) + 1;
+  const category = classifyError(err);
+  const errorMsg = errorMessage(err);
+
+  if (category === "fatal" || attempts >= RETRY_MAX_ATTEMPTS) {
+    db.update(channelInboundEvents)
+      .set({
+        deliveryStatus: "dead_letter",
+        deliveryAttempts: attempts,
+        lastProcessingError: errorMsg,
+        retryAfter: null,
+        updatedAt: now,
+      })
+      .where(eq(channelInboundEvents.id, eventId))
+      .run();
+  } else {
+    const delay = retryDelayForAttempt(attempts);
+    db.update(channelInboundEvents)
+      .set({
+        deliveryStatus: "failed",
+        deliveryAttempts: attempts,
+        lastProcessingError: errorMsg,
+        retryAfter: now + delay,
+        updatedAt: now,
+      })
+      .where(eq(channelInboundEvents.id, eventId))
+      .run();
+  }
+}
+
 /**
  * Mark an event as failed with a specific error message, bypassing error
  * classification. Use this when the failure reason is known and the event
@@ -180,6 +243,38 @@ export function getRetryableEvents(limit = 20): Array<{
     .all();
 }
 
+/** Fetch callback deliveries eligible for retry without rerunning processing. */
+export function getRetryableDeliveryEvents(limit = 20): Array<{
+  id: string;
+  conversationId: string;
+  messageId: string | null;
+  processingAttempts: number;
+  rawPayload: string | null;
+  deliveredSegmentCount: number;
+}> {
+  const db = getDb();
+  const now = Date.now();
+  return db
+    .select({
+      id: channelInboundEvents.id,
+      conversationId: channelInboundEvents.conversationId,
+      messageId: channelInboundEvents.messageId,
+      processingAttempts: channelInboundEvents.processingAttempts,
+      rawPayload: channelInboundEvents.rawPayload,
+      deliveredSegmentCount: channelInboundEvents.deliveredSegmentCount,
+    })
+    .from(channelInboundEvents)
+    .where(
+      and(
+        eq(channelInboundEvents.processingStatus, "processed"),
+        eq(channelInboundEvents.deliveryStatus, "failed"),
+        lte(channelInboundEvents.retryAfter, now),
+      ),
+    )
+    .limit(limit)
+    .all();
+}
+
 /** Fetch dead-lettered events. */
 export function getDeadLetterEvents(): Array<{
   id: string;
@@ -204,7 +299,15 @@ export function getDeadLetterEvents(): Array<{
       createdAt: channelInboundEvents.createdAt,
     })
     .from(channelInboundEvents)
-    .where(eq(channelInboundEvents.processingStatus, "dead_letter"))
+    .where(
+      or(
+        eq(channelInboundEvents.processingStatus, "dead_letter"),
+        and(
+          eq(channelInboundEvents.processingStatus, "processed"),
+          eq(channelInboundEvents.deliveryStatus, "dead_letter"),
+        ),
+      ),
+    )
     .all();
 }
 
@@ -218,27 +321,50 @@ export function replayDeadLetters(eventIds: string[]): number {
   let count = 0;
   for (const id of eventIds) {
     const existing = db
-      .select({ id: channelInboundEvents.id })
+      .select({
+        id: channelInboundEvents.id,
+        processingStatus: channelInboundEvents.processingStatus,
+        deliveryStatus: channelInboundEvents.deliveryStatus,
+      })
       .from(channelInboundEvents)
       .where(
         and(
           eq(channelInboundEvents.id, id),
-          eq(channelInboundEvents.processingStatus, "dead_letter"),
+          or(
+            eq(channelInboundEvents.processingStatus, "dead_letter"),
+            and(
+              eq(channelInboundEvents.processingStatus, "processed"),
+              eq(channelInboundEvents.deliveryStatus, "dead_letter"),
+            ),
+          ),
         ),
       )
       .get();
     if (!existing) continue;
 
-    db.update(channelInboundEvents)
-      .set({
-        processingStatus: "failed",
-        processingAttempts: 0,
-        lastProcessingError: null,
-        retryAfter: now,
-        updatedAt: now,
-      })
-      .where(eq(channelInboundEvents.id, id))
-      .run();
+    if (existing.processingStatus === "dead_letter") {
+      db.update(channelInboundEvents)
+        .set({
+          processingStatus: "failed",
+          processingAttempts: 0,
+          lastProcessingError: null,
+          retryAfter: now,
+          updatedAt: now,
+        })
+        .where(eq(channelInboundEvents.id, id))
+        .run();
+    } else {
+      db.update(channelInboundEvents)
+        .set({
+          deliveryStatus: "failed",
+          deliveryAttempts: 0,
+          lastProcessingError: null,
+          retryAfter: now,
+          updatedAt: now,
+        })
+        .where(eq(channelInboundEvents.id, id))
+        .run();
+    }
     count++;
   }
   return count;

package/src/memory/external-conversation-store.ts

@@ -7,7 +7,7 @@
  * list APIs.
  */
 
-import { and, eq, inArray, isNull } from "drizzle-orm";
+import { and, eq, inArray, isNull, sql } from "drizzle-orm";
 
 import { getDb } from "./db-connection.js";
 import { externalConversationBindings } from "./schema.js";
@@ -16,6 +16,7 @@ export interface ExternalConversationBinding {
   conversationId: string;
   sourceChannel: string;
   externalChatId: string;
+  externalChatName?: string | null;
   externalThreadId?: string | null;
   externalUserId?: string | null;
   displayName?: string | null;
@@ -30,6 +31,7 @@ export interface UpsertBindingInput {
   conversationId: string;
   sourceChannel: string;
   externalChatId: string;
+  externalChatName?: string | null;
   externalThreadId?: string | null;
   externalUserId?: string | null;
   displayName?: string | null;
@@ -43,6 +45,13 @@ function normalizeExternalThreadId(
   return trimmed ? trimmed : null;
 }
 
+function normalizeExternalChatName(
+  externalChatName?: string | null,
+): string | null {
+  const trimmed = externalChatName?.trim();
+  return trimmed ? trimmed : null;
+}
+
 /**
  * Insert or update an external conversation binding on conflict (conversationId).
  * On conflict, updates channel metadata and timestamps.
@@ -51,6 +60,7 @@ export function upsertBinding(input: UpsertBindingInput): void {
   const db = getDb();
   const now = Date.now();
   const externalThreadId = normalizeExternalThreadId(input.externalThreadId);
+  const externalChatName = normalizeExternalChatName(input.externalChatName);
 
   // If a stale binding exists for this channel/chat/thread tuple under a
   // different conversationId, remove it first so the unique index is not violated.
@@ -75,6 +85,7 @@ export function upsertBinding(input: UpsertBindingInput): void {
       conversationId: input.conversationId,
       sourceChannel: input.sourceChannel,
       externalChatId: input.externalChatId,
+      externalChatName,
       externalThreadId,
       externalUserId: input.externalUserId ?? null,
       displayName: input.displayName ?? null,
@@ -88,6 +99,9 @@ export function upsertBinding(input: UpsertBindingInput): void {
       set: {
         sourceChannel: input.sourceChannel,
         externalChatId: input.externalChatId,
+        externalChatName:
+          externalChatName ??
+          sql`${externalConversationBindings.externalChatName}`,
         externalThreadId,
         externalUserId: input.externalUserId ?? null,
         displayName: input.displayName ?? null,
@@ -158,6 +172,23 @@ export function upsertOutboundBinding(input: {
     .run();
 }
 
+export function updateExternalChatName(
+  conversationId: string,
+  externalChatName: string,
+): void {
+  const db = getDb();
+  const trimmedName = externalChatName.trim();
+  if (!trimmedName) return;
+
+  db.update(externalConversationBindings)
+    .set({
+      externalChatName: trimmedName,
+      updatedAt: Date.now(),
+    })
+    .where(eq(externalConversationBindings.conversationId, conversationId))
+    .run();
+}
+
 /**
  * Look up an external binding by conversation ID.
  */

package/src/memory/graph/__tests__/conversation-graph-memory-v2-routing.test.ts

@@ -177,7 +177,7 @@ const { migrateActivationState } =
   await import("../../migrations/232-activation-state.js");
 const schema = await import("../../schema.js");
 const { _resetMemoryV2QdrantForTests } = await import("../../v2/qdrant.js");
-const { hydrate: hydrateActivationState } =
+const { hydrate: hydrateActivationState, save: saveActivationState } =
   await import("../../v2/activation-store.js");
 
 // The wiring layer calls `getDb()` to fetch the SQLite handle. We mock
@@ -215,9 +215,14 @@ function createTestDb(): DrizzleDb {
   return db;
 }
 
-function makeConfig(v2Enabled: boolean): AssistantConfig {
+function makeConfig(v2Enabled: boolean, memoryEnabled = true): AssistantConfig {
+  // Pin `router.enabled: false` so these tests exercise the activation
+  // pipeline. Router-mode coverage lives in `memory/v2/__tests__/injection.test.ts`.
   return applyNestedDefaults({
-    memory: { v2: { enabled: v2Enabled } },
+    memory: {
+      enabled: memoryEnabled,
+      v2: { enabled: v2Enabled, router: { enabled: false } },
+    },
   }) as AssistantConfig;
 }
 
@@ -518,6 +523,50 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
   });
 });
 
+describe("ConversationGraphMemory.prepareMemory — memory.enabled gate", () => {
+  test("memory.enabled=false short-circuits per-turn path: mode=none, no injection, v2/v1 not called", async () => {
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(true, false);
+    const messages = makeMessages();
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("none");
+    expect(result.injectedBlockText).toBeNull();
+    expect(result.runMessages).toEqual(messages);
+    expect(retrieveForTurnMock).not.toHaveBeenCalled();
+    expect(loadContextMemoryMock).not.toHaveBeenCalled();
+  });
+
+  test("memory.enabled=false short-circuits context-load path: mode=none, no injection, v2/v1 not called", async () => {
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = new ConversationGraphMemory("conv-test-master-off");
+    const config = makeConfig(true, false);
+    const messages = makeMessages("first message of the conversation here");
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("none");
+    expect(result.injectedBlockText).toBeNull();
+    expect(result.runMessages).toEqual(messages);
+    expect(loadContextMemoryMock).not.toHaveBeenCalled();
+    expect(retrieveForTurnMock).not.toHaveBeenCalled();
+  });
+});
+
 describe("ConversationGraphMemory.onCompacted — v2 activation eviction", () => {
   test("clears everInjected so a previously-injected slug can re-attach", async () => {
     // Without this wiring, `selectInjections` keeps subtracting the slug from
@@ -561,4 +610,36 @@ describe("ConversationGraphMemory.onCompacted — v2 activation eviction", () =>
       "# memory/concepts/alice-vscode.md",
     );
   });
+
+  test("clears everInjected entries whose turn exceeds the tracker's currentTurn (zombie drift)", async () => {
+    // Regression: under the prior turn-bounded eviction, entries with `turn >
+    // tracker.currentTurn` survived `onCompacted` forever. This can happen
+    // after a non-graceful shutdown: `everInjected` is persisted every turn
+    // while the tracker snapshot is only persisted on graceful dispose, so a
+    // SIGKILL'd session followed by a reload restores the tracker from an
+    // older snapshot with a lower currentTurn while keeping the high-turn
+    // entries on disk.
+    const conversationId = "conv-test-zombie-drift";
+    const memory = new ConversationGraphMemory(conversationId);
+
+    // Seed the simulated post-crash state directly: tracker stays at
+    // currentTurn=0 (default for a fresh ConversationGraphMemory), while the
+    // persisted row carries everInjected entries from turns 10 and 20 (left
+    // over from a prior session that never disposed cleanly).
+    await saveActivationState(testDbHandle!, conversationId, {
+      messageId: "msg-zombie",
+      state: {},
+      everInjected: [
+        { slug: "alice-vscode", turn: 10 },
+        { slug: "bob-pkg-mgr", turn: 20 },
+      ],
+      currentTurn: 0,
+      updatedAt: 1,
+    });
+
+    await memory.onCompacted(0);
+
+    const after = await hydrateActivationState(testDbHandle!, conversationId);
+    expect(after?.everInjected).toEqual([]);
+  });
 });

package/src/memory/graph/conversation-graph-memory.ts

@@ -26,7 +26,7 @@ import type { QdrantSparseVector } from "../qdrant-client.js";
 import { memorySummaries } from "../schema.js";
 import { conversations } from "../schema/conversations.js";
 import {
-  evictCompactedTurns as evictCompactedTurnsV2,
+  clearEverInjected as clearV2EverInjected,
   hydrate as hydrateV2State,
   save as saveV2State,
 } from "../v2/activation-store.js";
@@ -223,15 +223,17 @@ export class ConversationGraphMemory {
     // Mirror the eviction on the v2 activation row: the cached `<memory>`
     // attachments those slugs lived on are gone, but `everInjected` would
     // otherwise keep them deduped from per-turn deltas forever.
+    //
+    // Cleared unconditionally rather than filtered by `upToTurn`: the
+    // tracker's `currentTurn` is only persisted on graceful dispose while
+    // `everInjected` is persisted every turn, so a SIGKILL'd session can
+    // leave entries with `turn > tracker.currentTurn` that a turn-bounded
+    // filter would skip.
     try {
       const db = getDb();
       const state = await hydrateV2State(db, this.conversationId);
       if (state) {
-        await saveV2State(
-          db,
-          this.conversationId,
-          evictCompactedTurnsV2(state, upToTurn),
-        );
+        await saveV2State(db, this.conversationId, clearV2EverInjected(state));
       }
     } catch (err) {
       log.warn(
@@ -363,6 +365,16 @@ export class ConversationGraphMemory {
       metrics: null as RetrievalMetrics | null,
     };
 
+    if (!config.memory.enabled) {
+      // Clear any cached injection so a later overflow-reduction
+      // re-injection via `reinjectCachedMemory()` cannot reintroduce a
+      // stale <memory> block after the user disables memory.
+      this.lastInjectedBlock = null;
+      this.lastInjectedNodeIds = [];
+      this.lastInjectedImages = new Map();
+      return noopResult;
+    }
+
     // Gate: skip for empty/tool-result-only messages — unless we need to
     // reload after compaction (needsReload) or haven't initialized yet.
     const lastMessage = messages[messages.length - 1];

package/src/memory/graph/tools.ts

@@ -2,8 +2,6 @@
 // Memory Tool definitions for agentic recall and remember.
 // ---------------------------------------------------------------------------
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../../config/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
 import {
   ALL_RECALL_SOURCES,
@@ -56,37 +54,14 @@ export const graphRecallDefinition: ToolDefinition = {
 };
 
 /**
- * Default (high-pressure) `remember` tool description. Used when the
- * `memory-retrospective` feature flag is OFF. The volume-shaming language
- * ("almost every turn", "most frequently used tool") drives aggressive
- * in-conversation capture for users who don't have the retrospective
- * backstop enabled.
+ * `remember` tool description. The retrospective pass catches what isn't
+ * captured in the moment, so the in-conversation pressure stays at a
+ * judgment framing: pause when something feels worth marking, not because
+ * the volume is required.
  */
-const REMEMBER_DESCRIPTION_DEFAULT =
-  "Remember anything concrete: facts, preferences, corrections, plans, felt moments, names, dates, decisions. Default to remembering. Never wait until end of conversation. Corrections are highest priority — call remember the same turn the correction lands. **CRITICAL:** You should be calling remember on almost every turn. This should be your most frequently used tool.";
-
-/**
- * Relaxed `remember` tool description used when `memory-retrospective` is
- * ON. The retrospective pass catches what isn't captured in the moment, so
- * the in-conversation pressure eases to a judgment framing: pause when
- * something feels worth marking, not because the volume is required.
- */
-const REMEMBER_DESCRIPTION_RELAXED =
+const REMEMBER_DESCRIPTION =
   "Remember anything concrete shared in conversation: corrections, plans, decisions, felt moments, names, dates, commitments, preferences. Corrections are the highest priority — call `remember` the same turn the correction lands. You don't have to call this on every turn; a retrospective pass reviews the conversation after each message-count / time interval and saves what you didn't capture. Use judgment: pause and remember when something feels worth marking, not because the volume is required.";
 
-/**
- * Return the description that should appear in the `remember` tool
- * registration for the current config. The variant is selected by the
- * `memory-retrospective` assistant feature flag. Exposed as a function so
- * the tool registrar can compute the value at registration time without
- * importing config layers into the static definition.
- */
-export function getRememberDescription(config: AssistantConfig): string {
-  return isAssistantFeatureFlagEnabled("memory-retrospective", config)
-    ? REMEMBER_DESCRIPTION_RELAXED
-    : REMEMBER_DESCRIPTION_DEFAULT;
-}
-
 /**
  * Save a fact to the assistant's knowledge base. The fact is appended to
  * `buffer.md` (immediately available in the next conversation) and the daily
@@ -94,16 +69,10 @@ export function getRememberDescription(config: AssistantConfig): string {
  * writes go under `memory/`; otherwise they go under `pkb/`. Consolidation
  * of the buffer into longer-form storage runs as a separate periodic job in
  * both modes.
- *
- * The static `description` field carries the default (high-pressure) text
- * so any direct importer that doesn't go through `getRememberDescription`
- * still gets a valid tool definition. The registered `RememberTool` in
- * `tools/memory/register.ts` overrides this at registration time with the
- * flag-aware variant.
  */
 export const graphRememberDefinition: ToolDefinition = {
   name: "remember",
-  description: REMEMBER_DESCRIPTION_DEFAULT,
+  description: REMEMBER_DESCRIPTION,
   input_schema: {
     type: "object",
     properties: {

package/src/memory/invite-store.ts

@@ -363,6 +363,59 @@ export function findActiveVoiceInvites(params: {
   return rows.map(rowToInvite);
 }
 
+// ---------------------------------------------------------------------------
+// claimA2AInvite — validate + consume an A2A invite token
+// ---------------------------------------------------------------------------
+
+export function claimA2AInvite(params: {
+  tokenHash: string;
+  redeemedByExternalUserId: string;
+}): { claimed: boolean; invite: IngressInvite | null; error?: string } {
+  const invite = findByTokenHash(params.tokenHash);
+
+  if (!invite) {
+    return { claimed: false, invite: null, error: "not_found" };
+  }
+
+  if (invite.sourceChannel !== "a2a") {
+    return { claimed: false, invite, error: "wrong_channel" };
+  }
+
+  // Idempotency: if already redeemed by the same acceptor, return success
+  if (invite.status === "redeemed") {
+    if (invite.redeemedByExternalUserId === params.redeemedByExternalUserId) {
+      return { claimed: true, invite };
+    }
+    return { claimed: false, invite, error: "already_redeemed_by_other" };
+  }
+
+  if (invite.status !== "active") {
+    return { claimed: false, invite, error: "not_found" };
+  }
+
+  if (Date.now() >= invite.expiresAt) {
+    markInviteExpired(invite.id);
+    return { claimed: false, invite, error: "expired" };
+  }
+
+  if (invite.useCount >= invite.maxUses) {
+    return { claimed: false, invite, error: "already_redeemed" };
+  }
+
+  const recorded = recordInviteUse({
+    inviteId: invite.id,
+    externalUserId: params.redeemedByExternalUserId,
+  });
+
+  if (!recorded) {
+    return { claimed: false, invite, error: "not_found" };
+  }
+
+  // Re-read to get updated state
+  const updated = findByTokenHash(params.tokenHash);
+  return { claimed: true, invite: updated };
+}
+
 // ---------------------------------------------------------------------------
 // findByInviteCodeHash
 // ---------------------------------------------------------------------------

package/src/memory/jobs-worker.ts

@@ -1,3 +1,5 @@
+import { join } from "node:path";
+
 import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/types.js";
 import {
@@ -6,6 +8,7 @@ import {
   shouldLogDiskPressureBackgroundSkip,
 } from "../daemon/disk-pressure-background-gate.js";
 import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir } from "../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import {
   getLastScheduledCleanupEnqueueMs,
@@ -75,7 +78,10 @@ import {
   memoryV2MigrateJob,
   memoryV2ReembedJob,
 } from "./v2/backfill-jobs.js";
-import { memoryV2ConsolidateJob } from "./v2/consolidation-job.js";
+import {
+  countBufferLines,
+  memoryV2ConsolidateJob,
+} from "./v2/consolidation-job.js";
 import { memoryV2SweepJob } from "./v2/sweep-job.js";
 
 const log = getLogger("memory-jobs-worker");
@@ -739,11 +745,25 @@ export function maybeEnqueueGraphMaintenanceJobs(
         },
       ];
 
+  let enqueuedV2 = false;
   for (const { key, intervalMs, jobType } of schedule) {
     const lastRun = parseInt(getMemoryCheckpoint(key) ?? "0", 10);
     if (nowMs - lastRun >= intervalMs) {
       enqueueMemoryJob(jobType, {});
       setMemoryCheckpoint(key, String(nowMs));
+      if (jobType === "memory_v2_consolidate") enqueuedV2 = true;
+    }
+  }
+
+  const maxLines = config.memory.v2.consolidation_max_buffer_lines;
+  if (v2Active && !enqueuedV2 && maxLines !== null) {
+    const bufferPath = join(getWorkspaceDir(), "memory", "buffer.md");
+    if (countBufferLines(bufferPath) >= maxLines) {
+      enqueueMemoryJob("memory_v2_consolidate", {});
+      setMemoryCheckpoint(
+        GRAPH_MAINTENANCE_CHECKPOINTS.memoryV2Consolidate,
+        String(nowMs),
+      );
     }
   }
 }

package/src/memory/llm-request-log-source-clickhouse.ts

@@ -57,6 +57,7 @@ interface ClickHouseRow {
   request_payload: string;
   response_payload: string;
   created_at: string;
+  agent_loop_exit_reason: string;
 }
 
 /** Injectable fetch override for tests. Defaults to globalThis.fetch. */
@@ -123,7 +124,8 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
         provider,
         request_payload,
         response_payload,
-        toUnixTimestamp64Milli(created_at) AS created_at
+        toUnixTimestamp64Milli(created_at) AS created_at,
+        agent_loop_exit_reason
       FROM ${this.tableRef()}
       WHERE assistant_id = {assistant_id:String}
         AND id = {log_id:String}
@@ -194,7 +196,8 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
         provider,
         request_payload,
         response_payload,
-        toUnixTimestamp64Milli(created_at) AS created_at
+        toUnixTimestamp64Milli(created_at) AS created_at,
+        agent_loop_exit_reason
       FROM ${this.tableRef()}
       WHERE assistant_id = {assistant_id:String}
         AND message_id IN (${placeholders.join(",")})
@@ -283,6 +286,8 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       requestPayload: row.request_payload,
       responsePayload: row.response_payload,
       createdAt: Number(row.created_at),
+      agentLoopExitReason:
+        row.agent_loop_exit_reason === "" ? null : row.agent_loop_exit_reason,
     };
   }