@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/memory/conversation-queries.ts

@@ -1,4 +1,4 @@
-import { and, count, desc, eq, inArray, isNull, sql } from "drizzle-orm";
+import { and, count, desc, eq, inArray, isNull, lt, sql } from "drizzle-orm";
 
 import {
   parseExternalContentEnvelope,
@@ -166,13 +166,17 @@ export function listConversations(
   conversationType: ConversationType = "standard",
   offset = 0,
   archiveStatus: ArchiveStatusFilter = "active",
+  originChannel?: string,
 ): ConversationRow[] {
   ensureDisplayOrderMigration();
   ensureGroupMigration();
   const db = getDb();
   const typeCond = conversationTypeClause(conversationType);
   const archiveCond = archiveStatusClause(archiveStatus);
-  const where = archiveCond ? sql`${typeCond} AND ${archiveCond}` : typeCond;
+  const channelCond = originChannel
+    ? eq(conversations.originChannel, originChannel)
+    : undefined;
+  const where = and(typeCond, archiveCond ?? undefined, channelCond);
   const query = db
     .select()
     .from(conversations)
@@ -208,17 +212,24 @@ export function listConversations(
  *                              Defaults to `true` so callers that want a full
  *                              run history get one; pass `false` for views
  *                              that hide archived rows.
+ * @param opts.beforeCreatedAt  Only return rows with `createdAt` strictly
+ *                              older than this epoch-millis cursor (for
+ *                              paginating into history).
  */
 export function listConversationsBySource(
   source: string,
   limit = 20,
-  opts?: { includeArchived?: boolean },
+  opts?: { includeArchived?: boolean; beforeCreatedAt?: number },
 ): ConversationRow[] {
   const db = getDb();
   const includeArchived = opts?.includeArchived ?? true;
-  const where = includeArchived
-    ? eq(conversations.source, source)
-    : and(eq(conversations.source, source), isNull(conversations.archivedAt));
+  const where = and(
+    eq(conversations.source, source),
+    includeArchived ? undefined : isNull(conversations.archivedAt),
+    opts?.beforeCreatedAt != null
+      ? lt(conversations.createdAt, opts.beforeCreatedAt)
+      : undefined,
+  );
   const rows = db
     .select()
     .from(conversations)
@@ -361,12 +372,16 @@ export function listConversationsByTitlePrefix(
 export function countConversations(
   conversationType: ConversationType = "standard",
   archiveStatus: ArchiveStatusFilter = "active",
+  originChannel?: string,
 ): number {
   ensureGroupMigration();
   const db = getDb();
   const typeCond = conversationTypeClause(conversationType);
   const archiveCond = archiveStatusClause(archiveStatus);
-  const where = archiveCond ? sql`${typeCond} AND ${archiveCond}` : typeCond;
+  const channelCond = originChannel
+    ? eq(conversations.originChannel, originChannel)
+    : undefined;
+  const where = and(typeCond, archiveCond ?? undefined, channelCond);
   const [{ total }] = db
     .select({ total: count() })
     .from(conversations)

package/src/memory/db-init.ts

@@ -55,6 +55,7 @@ import {
   migrateBackfillContactInteractionStats,
   migrateBackfillGuardianPrincipalId,
   migrateBackfillInlineAttachmentsToDisk,
+  migrateBackfillOriginChannelFromBindings,
   migrateBackfillProviderConnectionLabel,
   migrateBackfillUsageCacheAccounting,
   migrateCallSessionInviteMetadata,
@@ -68,6 +69,7 @@ import {
   migrateChannelInteractionColumns,
   migrateContactChannelsAccessFields,
   migrateContactChannelsTypeChatIdIndex,
+  migrateContactChannelsUniqueExtUser,
   migrateContactsAssistantId,
   migrateContactsNotesColumn,
   migrateContactsRolePrincipal,
@@ -77,6 +79,7 @@ import {
   migrateConversationHostAccess,
   migrateConversationInferenceProfileSession,
   migrateConversationLastNotifiedProfile,
+  migrateConversationOriginChannelIndex,
   migrateConversationsArchivedAt,
   migrateConversationsLastMessageAt,
   migrateConversationsSurfacedAt,
@@ -136,11 +139,13 @@ import {
   migrateMemoryGraphImageRefs,
   migrateMemoryItemSupersession,
   migrateMemoryRecallLogsQueryContext,
+  migrateMemoryRetrospectiveRememberedLog,
   migrateMemoryRetrospectiveState,
   migrateMemoryV2ActivationLogs,
   migrateMemoryV2InjectionEvents,
   migrateMemoryV3AutoEdges,
   migrateMemoryV3Coactivation,
+  migrateMemoryV3SelectionsMessageIdAndSections,
   migrateMessageBookmarks,
   migrateMessagesClientMessageId,
   migrateMessagesConversationCreatedAtIndex,
@@ -189,7 +194,9 @@ import {
   migrateRenameVerificationSessionIdColumn,
   migrateRenameVerificationTable,
   migrateRenameVoiceToPhone,
+  migrateScheduleCapabilities,
   migrateScheduleDescription,
+  migrateScheduleInferenceProfile,
   migrateScheduleOneShotRouting,
   migrateScheduleQuietFlag,
   migrateScheduleRetryPolicy,
@@ -198,6 +205,7 @@ import {
   migrateScheduleScriptTimeout,
   migrateScheduleSourceConversation,
   migrateScheduleWakeConversationId,
+  migrateScheduleWorkflowMode,
   migrateSchemaIndexesAndColumns,
   migrateScrubCorruptedImageAttachments,
   migrateSlackCompactionWatermark,
@@ -214,6 +222,8 @@ import {
   migrateUsageLlmCallCount,
   migrateVoiceInviteColumns,
   migrateVoiceInviteDisplayMetadata,
+  migrateWorkflowRuns,
+  migrateWorkflowRunTrust,
   recoverCrashedMigrations,
   runComplexMigrations,
   runLateMigrations,
@@ -498,6 +508,16 @@ export function initializeDb(): void {
     migrateToolInvocationsTelemetryColumns,
     createSkillLoadedEventsTable,
     migrateConversationsSurfacedAt,
+    migrateMemoryRetrospectiveRememberedLog,
+    migrateScheduleInferenceProfile,
+    migrateMemoryV3SelectionsMessageIdAndSections,
+    migrateWorkflowRuns,
+    migrateScheduleWorkflowMode,
+    migrateWorkflowRunTrust,
+    migrateConversationOriginChannelIndex,
+    migrateBackfillOriginChannelFromBindings,
+    migrateContactChannelsUniqueExtUser,
+    migrateScheduleCapabilities,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/db-maintenance.ts

@@ -3,6 +3,7 @@ import { statSync } from "node:fs";
 import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
 import { getDbPath } from "../util/platform.js";
+import { pruneRuns } from "../workflows/journal-store.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import { getLastUserMessageTimestamp } from "./conversation-crud.js";
 import { runAsyncSqlite } from "./db-async-query.js";
@@ -56,6 +57,21 @@ async function runDbMaintenance(): Promise<void> {
     "Starting database maintenance",
   );
 
+  // Prune finished workflow runs (and their journals) past the retention
+  // window BEFORE VACUUM so the freed pages are reclaimed in the same pass.
+  // This is a fast bounded DELETE on the small workflow tables, so it runs on
+  // the main connection (`rawRun`) — unlike VACUUM/optimize it doesn't need the
+  // async/subprocess path. The maintenance scheduler below already defers this
+  // whole routine to an idle window.
+  try {
+    const deletedRuns = pruneRuns(getConfig().workflows.journalRetentionDays);
+    if (deletedRuns > 0) {
+      log.info({ deletedRuns }, "Pruned expired workflow runs");
+    }
+  } catch (err) {
+    log.warn({ err }, "Workflow run pruning failed (non-fatal)");
+  }
+
   // VACUUM is the long-running one — minutes on a multi-GB DB. PRAGMA
   // optimize is fast but routed through the same async path for
   // consistency and to keep both off the main thread when the CLI

package/src/memory/embedding-runtime-manager.ts

@@ -7,7 +7,7 @@
  * imported files, so we spawn a standalone bun process that runs an embed
  * worker script communicating via JSON-lines over stdin/stdout.
  *
- * The runtime is stored in ~/.vellum/workspace/embedding-models/ and used
+ * The runtime is stored in $VELLUM_WORKSPACE_DIR/embedding-models/ and used
  * by embedding-local.ts on demand.
  *
  * Follows the same download/install pattern as qdrant-manager.ts.

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

@@ -25,7 +25,11 @@ import {
   messageMetadataSchema,
 } from "./conversation-crud.js";
 import type { LlmRequestLogSource } from "./llm-request-log-source.js";
-import type { LogRow } from "./llm-request-log-store.js";
+import type {
+  CompactionAgentLogRow,
+  LogMetaRow,
+  LogRow,
+} from "./llm-request-log-store.js";
 
 const log = getLogger("clickhouse-llm-request-log-source");
 
@@ -70,6 +74,23 @@ interface ClickHouseRow {
   call_site: string;
 }
 
+/** Metadata-only wire row — `ClickHouseRow` without the payload columns. */
+type ClickHouseMetaRow = Omit<
+  ClickHouseRow,
+  "request_payload" | "response_payload"
+>;
+
+/**
+ * Wire row for the compaction-trail query: metadata plus the summarizer
+ * response payload and a message count computed server-side. ClickHouse's
+ * `JSONLength` returns 0 for missing/invalid paths; `exec` callers map the
+ * `nullif(…, 0)` result, so the field arrives as `number | null`.
+ */
+type ClickHouseCompactionRow = ClickHouseMetaRow & {
+  response_payload: string;
+  request_message_count: number | string | null;
+};
+
 /** Injectable fetch override for tests. Defaults to globalThis.fetch. */
 export type ClickHouseFetch = typeof fetch;
 
@@ -143,10 +164,36 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       ORDER BY created_at DESC
       LIMIT 1
       FORMAT JSONEachRow`;
-    const rows = await this.exec(sql, { assistant_id: aid, log_id: logId });
+    const rows = await this.exec<ClickHouseRow>(sql, {
+      assistant_id: aid,
+      log_id: logId,
+    });
     return rows[0] ? this.toLogRow(rows[0]) : null;
   }
 
+  async getRequestLogMetaById(logId: string): Promise<LogMetaRow | null> {
+    const aid = await this.assistantId();
+    const sql = `SELECT
+        id,
+        conversation_id,
+        message_id,
+        provider,
+        toUnixTimestamp64Milli(created_at) AS created_at,
+        agent_loop_exit_reason,
+        call_site
+      FROM ${this.tableRef()}
+      WHERE assistant_id = {assistant_id:String}
+        AND id = {log_id:String}
+      ORDER BY created_at DESC
+      LIMIT 1
+      FORMAT JSONEachRow`;
+    const rows = await this.exec<ClickHouseMetaRow>(sql, {
+      assistant_id: aid,
+      log_id: logId,
+    });
+    return rows[0] ? this.toLogMetaRow(rows[0]) : null;
+  }
+
   async getRequestLogsByMessageId(messageId: string): Promise<LogRow[]> {
     const turnIds = this.resolveTurnMessageIds(messageId);
     let rows = await this.selectByMessageIds(turnIds);
@@ -202,18 +249,46 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       ORDER BY created_at ASC, id ASC
       LIMIT 1 BY id
       FORMAT JSONEachRow`;
-    const rows = await this.exec(sql, {
+    const rows = await this.exec<ClickHouseRow>(sql, {
       assistant_id: aid,
       conversation_id: conversationId,
     });
     return rows.map((r) => this.toLogRow(r));
   }
 
+  async getPreviousNonCompactionCallCreatedAt(
+    conversationId: string,
+    beforeCreatedAt: number,
+  ): Promise<number | null> {
+    const aid = await this.assistantId();
+    // `call_site != 'compactionAgent'` keeps the pre-migration-264 rows
+    // (stored as the empty-string default) in scope as real calls and
+    // excludes only the summarizer's own logs, matching the local
+    // store's `isNull(callSite) OR callSite != 'compactionAgent'`.
+    const sql = `SELECT
+        toUnixTimestamp64Milli(created_at) AS created_at
+      FROM ${this.tableRef()}
+      WHERE assistant_id = {assistant_id:String}
+        AND conversation_id = {conversation_id:String}
+        AND call_site != {call_site:String}
+        AND created_at < fromUnixTimestamp64Milli({before_created_at:Int64})
+      ORDER BY created_at DESC, id DESC
+      LIMIT 1
+      FORMAT JSONEachRow`;
+    const rows = await this.exec<{ created_at: string }>(sql, {
+      assistant_id: aid,
+      conversation_id: conversationId,
+      call_site: "compactionAgent",
+      before_created_at: String(beforeCreatedAt),
+    });
+    return rows[0] ? Number(rows[0].created_at) : null;
+  }
+
   async getCompactionLogsBetween(
     conversationId: string,
     afterCreatedAt: number | null,
     beforeCreatedAt: number,
-  ): Promise<LogRow[]> {
+  ): Promise<CompactionAgentLogRow[]> {
     const aid = await this.assistantId();
     // `call_site` is bound as a literal via type-bound parameter (not
     // string interpolation) for parity with the rest of this class —
@@ -237,13 +312,23 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       afterPredicate =
         " AND created_at > fromUnixTimestamp64Milli({after_created_at:Int64})";
     }
+    // The request payload — an entire near-limit context window per
+    // compaction — is never transferred: the trail only needs the count
+    // of messages it contained, computed server-side across the three
+    // provider shapes (`messages`, `contents`, `input`). `JSONLength`
+    // returns 0 for missing paths or invalid JSON; `nullif` maps that
+    // back to NULL.
     const sql = `SELECT
         id,
         conversation_id,
         message_id,
         provider,
-        request_payload,
         response_payload,
+        nullif(greatest(
+          JSONLength(request_payload, 'messages'),
+          JSONLength(request_payload, 'contents'),
+          JSONLength(request_payload, 'input')
+        ), 0) AS request_message_count,
         toUnixTimestamp64Milli(created_at) AS created_at,
         agent_loop_exit_reason,
         call_site
@@ -255,8 +340,15 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       ORDER BY created_at ASC, id ASC
       LIMIT 1 BY id
       FORMAT JSONEachRow`;
-    const rows = await this.exec(sql, params);
-    return rows.map((r) => this.toLogRow(r));
+    const rows = await this.exec<ClickHouseCompactionRow>(sql, params);
+    return rows.map((r) => ({
+      ...this.toLogMetaRow(r),
+      responsePayload: r.response_payload,
+      requestMessageCount:
+        r.request_message_count === null
+          ? null
+          : Number(r.request_message_count),
+    }));
   }
 
   private async selectByMessageIds(ids: string[]): Promise<LogRow[]> {
@@ -293,7 +385,7 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       ORDER BY created_at ASC, id ASC
       LIMIT 1 BY id
       FORMAT JSONEachRow`;
-    const rows = await this.exec(sql, params);
+    const rows = await this.exec<ClickHouseRow>(sql, params);
     return rows.map((r) => this.toLogRow(r));
   }
 
@@ -304,10 +396,10 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
     return `\`${this.config.table.replace(/`/g, "``")}\``;
   }
 
-  private async exec(
+  private async exec<Row>(
     sql: string,
     params: Record<string, string>,
-  ): Promise<ClickHouseRow[]> {
+  ): Promise<Row[]> {
     const baseUrl = await this.url();
     const password = await this.password();
 
@@ -352,12 +444,12 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
     const text = await res.text();
     if (text.trim().length === 0) return [];
 
-    const rows: ClickHouseRow[] = [];
+    const rows: Row[] = [];
     for (const line of text.split("\n")) {
       const trimmed = line.trim();
       if (trimmed.length === 0) continue;
       try {
-        rows.push(JSON.parse(trimmed) as ClickHouseRow);
+        rows.push(JSON.parse(trimmed) as Row);
       } catch (err) {
         throw new Error(
           `Failed to parse ClickHouse JSONEachRow line: ${err instanceof Error ? err.message : String(err)}`,
@@ -368,6 +460,14 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
   }
 
   private toLogRow(row: ClickHouseRow): LogRow {
+    return {
+      ...this.toLogMetaRow(row),
+      requestPayload: row.request_payload,
+      responsePayload: row.response_payload,
+    };
+  }
+
+  private toLogMetaRow(row: ClickHouseMetaRow): LogMetaRow {
     return {
       id: row.id,
       conversationId: row.conversation_id,
@@ -376,8 +476,6 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       // overhead). Map empty back to null to match the local LogRow shape.
       messageId: row.message_id === "" ? null : row.message_id,
       provider: row.provider === "" ? null : row.provider,
-      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,

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

@@ -10,10 +10,14 @@
  */
 import type { LlmRequestLogSource } from "./llm-request-log-source.js";
 import {
+  type CompactionAgentLogRow,
   getCompactionLogsBetween,
+  getPreviousNonCompactionCallCreatedAt,
   getRequestLogById,
+  getRequestLogMetaById,
   getRequestLogsByConversationId,
   getRequestLogsByMessageId,
+  type LogMetaRow,
   type LogRow,
 } from "./llm-request-log-store.js";
 
@@ -22,6 +26,10 @@ export class LocalLlmRequestLogSource implements LlmRequestLogSource {
     return getRequestLogById(logId);
   }
 
+  async getRequestLogMetaById(logId: string): Promise<LogMetaRow | null> {
+    return getRequestLogMetaById(logId);
+  }
+
   async getRequestLogsByMessageId(messageId: string): Promise<LogRow[]> {
     return getRequestLogsByMessageId(messageId);
   }
@@ -32,11 +40,21 @@ export class LocalLlmRequestLogSource implements LlmRequestLogSource {
     return getRequestLogsByConversationId(conversationId);
   }
 
+  async getPreviousNonCompactionCallCreatedAt(
+    conversationId: string,
+    beforeCreatedAt: number,
+  ): Promise<number | null> {
+    return getPreviousNonCompactionCallCreatedAt(
+      conversationId,
+      beforeCreatedAt,
+    );
+  }
+
   async getCompactionLogsBetween(
     conversationId: string,
     afterCreatedAt: number | null,
     beforeCreatedAt: number,
-  ): Promise<LogRow[]> {
+  ): Promise<CompactionAgentLogRow[]> {
     return getCompactionLogsBetween(
       conversationId,
       afterCreatedAt,

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

@@ -17,12 +17,24 @@
  * Config edits take effect on the next request without an invalidation hook.
  */
 import { getConfig } from "../config/loader.js";
-import type { LogRow } from "./llm-request-log-store.js";
+import type {
+  CompactionAgentLogRow,
+  LogMetaRow,
+  LogRow,
+} from "./llm-request-log-store.js";
 
 export interface LlmRequestLogSource {
   /** Fetch a single log row by its primary key. Returns null if not found. */
   getRequestLogById(logId: string): Promise<LogRow | null>;
 
+  /**
+   * Fetch a single log row's metadata (no payloads) by its primary key.
+   * Prefer this when the caller only needs to locate or validate the row
+   * — request payloads can be entire context windows, so loading them for
+   * a conversation-scope check or a `createdAt` anchor is wasteful.
+   */
+  getRequestLogMetaById(logId: string): Promise<LogMetaRow | null>;
+
   /**
    * Fetch every LLM request log associated with the given message,
    * including all assistant messages in the same agent turn. Implementations
@@ -39,22 +51,39 @@ export interface LlmRequestLogSource {
    */
   getRequestLogsByConversationId(conversationId: string): Promise<LogRow[]>;
 
+  /**
+   * Return the `createdAt` of the most recent **non-`compactionAgent`**
+   * LLM call in the conversation that ran strictly before
+   * `beforeCreatedAt`, or `null` when the selected call is the first real
+   * call in the conversation.
+   *
+   * Drives the call-scoped floor for the Inspector's Compaction tab: a
+   * compaction is attributed to the next real call that ran after it, so
+   * the compactions for a given call are those that landed strictly
+   * between the previous real call and the selected call.
+   */
+  getPreviousNonCompactionCallCreatedAt(
+    conversationId: string,
+    beforeCreatedAt: number,
+  ): Promise<number | null>;
+
   /**
    * Fetch every `callSite = "compactionAgent"` log row in the conversation
    * whose `createdAt` falls in the **open window**
    * `(afterCreatedAt, beforeCreatedAt)`, ordered chronologically.
    *
-   * Drives the Inspector's Compaction tab. The route handler computes
-   * the window from the turn the selected call belongs to via
-   * `getTurnTimeBounds` in `memory/conversation-crud.ts`; this source
-   * method is bound-agnostic. See `getCompactionLogsBetween` in
+   * The legacy fallback for the Inspector's Compaction tab, used when the
+   * ClickHouse compaction log is unavailable. The route handler resolves
+   * the floor from `getPreviousNonCompactionCallCreatedAt` and the ceiling
+   * from the selected call's `createdAt`; this source method is
+   * bound-agnostic. See `getCompactionLogsBetween` in
    * `llm-request-log-store.ts` for the SQL.
    */
   getCompactionLogsBetween(
     conversationId: string,
     afterCreatedAt: number | null,
     beforeCreatedAt: number,
-  ): Promise<LogRow[]>;
+  ): Promise<CompactionAgentLogRow[]>;
 }
 
 /**

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

@@ -9,6 +9,8 @@ import {
   isNull,
   lt,
   lte,
+  ne,
+  or,
   sql,
 } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
@@ -48,6 +50,20 @@ export type LogRow = {
   callSite: string | null;
 };
 
+/** `LogRow` without the payload columns — for reads that only need metadata. */
+export type LogMetaRow = Omit<LogRow, "requestPayload" | "responsePayload">;
+
+/**
+ * Compaction-trail row: metadata plus the (small) summarizer response
+ * payload and a message count computed in SQL. The request payload — an
+ * entire near-limit context window per compaction — is deliberately never
+ * loaded; the trail only needs the count of messages it contained.
+ */
+export type CompactionAgentLogRow = LogMetaRow & {
+  responsePayload: string;
+  requestMessageCount: number | null;
+};
+
 /**
  * Build the structured response-payload object recorded in
  * `llm_request_logs.responsePayload` for a provider-rejected LLM call.
@@ -399,6 +415,43 @@ function selectUnlinkedLogsInRange(
     .all();
 }
 
+/**
+ * Return the `createdAt` of the most recent **non-`compactionAgent`** LLM
+ * call in the conversation that ran strictly before `beforeCreatedAt`, or
+ * `null` when no such call exists (the selected call is the first real
+ * call in the conversation).
+ *
+ * Drives the call-scoped floor for the Inspector's Compaction tab. A
+ * compaction is attributed to the next real call that runs after it, so
+ * the trail for a given call is the set of compactions that landed
+ * strictly between the previous real call and the selected call. NULL
+ * `callSite` rows (pre-migration-264) are treated as real calls — only
+ * `compactionAgent` rows are excluded.
+ */
+export function getPreviousNonCompactionCallCreatedAt(
+  conversationId: string,
+  beforeCreatedAt: number,
+): number | null {
+  const db = getDb();
+  const row = db
+    .select({ createdAt: llmRequestLogs.createdAt })
+    .from(llmRequestLogs)
+    .where(
+      and(
+        eq(llmRequestLogs.conversationId, conversationId),
+        lt(llmRequestLogs.createdAt, beforeCreatedAt),
+        or(
+          isNull(llmRequestLogs.callSite),
+          ne(llmRequestLogs.callSite, "compactionAgent"),
+        ),
+      ),
+    )
+    .orderBy(desc(llmRequestLogs.createdAt), desc(llmRequestLogs.id))
+    .limit(1)
+    .get();
+  return row?.createdAt ?? null;
+}
+
 /**
  * Fetch every `compactionAgent` log row in the conversation whose
  * `createdAt` falls in the **open window** `(afterCreatedAt, beforeCreatedAt)`,
@@ -426,7 +479,7 @@ export function getCompactionLogsBetween(
   conversationId: string,
   afterCreatedAt: number | null,
   beforeCreatedAt: number,
-): LogRow[] {
+): CompactionAgentLogRow[] {
   const db = getDb();
   const predicates = [
     eq(llmRequestLogs.conversationId, conversationId),
@@ -442,8 +495,18 @@ export function getCompactionLogsBetween(
       conversationId: llmRequestLogs.conversationId,
       messageId: llmRequestLogs.messageId,
       provider: llmRequestLogs.provider,
-      requestPayload: llmRequestLogs.requestPayload,
       responsePayload: llmRequestLogs.responsePayload,
+      // Count the request's messages in SQL instead of loading the payload:
+      // `messages` (Anthropic / OpenAI chat-completions), `contents`
+      // (Gemini), `input` (OpenAI Responses). NULL when the payload is
+      // malformed or none of the arrays exist.
+      requestMessageCount: sql<
+        number | null
+      >`CASE WHEN json_valid(${llmRequestLogs.requestPayload}) THEN coalesce(
+          json_array_length(${llmRequestLogs.requestPayload}, '$.messages'),
+          json_array_length(${llmRequestLogs.requestPayload}, '$.contents'),
+          json_array_length(${llmRequestLogs.requestPayload}, '$.input')
+        ) ELSE NULL END`,
       createdAt: llmRequestLogs.createdAt,
       agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
       callSite: llmRequestLogs.callSite,
@@ -454,6 +517,31 @@ export function getCompactionLogsBetween(
     .all();
 }
 
+/**
+ * Metadata-only lookup by primary key. Used where the caller needs to
+ * locate or validate a log (conversation scoping, `createdAt` anchoring)
+ * without paying to load its payloads — a single request payload can be a
+ * full context window.
+ */
+export function getRequestLogMetaById(logId: string): LogMetaRow | null {
+  const db = getDb();
+  return (
+    db
+      .select({
+        id: llmRequestLogs.id,
+        conversationId: llmRequestLogs.conversationId,
+        messageId: llmRequestLogs.messageId,
+        provider: llmRequestLogs.provider,
+        createdAt: llmRequestLogs.createdAt,
+        agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+        callSite: llmRequestLogs.callSite,
+      })
+      .from(llmRequestLogs)
+      .where(eq(llmRequestLogs.id, logId))
+      .get() ?? null
+  );
+}
+
 export function getRequestLogById(logId: string): LogRow | null {
   const db = getDb();
   return (

package/src/memory/memory-retrospective-constants.ts

@@ -24,6 +24,15 @@ export const MEMORY_RETROSPECTIVE_SOURCES: readonly string[] = [
   MEMORY_RETROSPECTIVE_FORK_SOURCE,
 ];
 
+/**
+ * Whether a conversation `source` value marks a memory-retrospective
+ * background conversation (either kind). Shared predicate for the recursion
+ * and auto-analysis guards.
+ */
+export function isMemoryRetrospectiveSource(source: string): boolean {
+  return MEMORY_RETROSPECTIVE_SOURCES.includes(source);
+}
+
 /**
  * Dedicated `group_id` value for memory-retrospective background
  * conversations. Placed under `system:background` alongside auto-analysis,