@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/memory/llm-usage-store.ts

@@ -6,8 +6,16 @@ import type {
   UsageEvent,
   UsageEventInput,
 } from "../usage/types.js";
+import { APP_VERSION } from "../version.js";
 import { getDb } from "./db-connection.js";
 import { rawAll } from "./raw-query.js";
+import {
+  buildScheduleAttributionSubquery,
+  buildScheduleRunWindowExists,
+  normalizeScheduleAttributionFilter,
+  type ScheduleAttributionFilter,
+  type ScheduleAttributionSqlParam,
+} from "./schedule-attribution-sql.js";
 import { conversations, llmUsageEvents } from "./schema.js";
 import {
   bucketEventsByDay,
@@ -39,6 +47,7 @@ export function recordUsageEvent(
     inferenceProfileSource: input.inferenceProfileSource ?? null,
     estimatedCostUsd: pricing.estimatedCostUsd,
     pricingStatus: pricing.pricingStatus,
+    assistantVersion: APP_VERSION,
   };
   db.insert(llmUsageEvents)
     .values({
@@ -62,6 +71,11 @@ export function recordUsageEvent(
       pricingStatus: event.pricingStatus,
       llmCallCount: event.llmCallCount ?? 1,
       metadataJson: null,
+      // Capture the assistant's version at RECORD time so a batch flush
+      // days later doesn't mis-attribute this row to whatever version
+      // the assistant happens to be running on at upload time. See
+      // migration 267 + `TelemetryEventBase.assistant_version` (wire).
+      assistantVersion: event.assistantVersion,
     })
     .run();
   return event;
@@ -91,6 +105,7 @@ function rowToUsageEvent(row: {
   rawUsage: string | null;
   estimatedCostUsd: number | null;
   pricingStatus: string;
+  assistantVersion: string | null;
 }): UsageEvent {
   return {
     id: row.id,
@@ -112,6 +127,7 @@ function rowToUsageEvent(row: {
     rawUsage: parseRawUsage(row.rawUsage),
     estimatedCostUsd: row.estimatedCostUsd,
     pricingStatus: row.pricingStatus as "priced" | "unpriced",
+    assistantVersion: row.assistantVersion,
   };
 }
 
@@ -213,6 +229,7 @@ export function queryUnreportedUsageEvents(
       rawUsage: llmUsageEvents.rawUsage,
       estimatedCostUsd: llmUsageEvents.estimatedCostUsd,
       pricingStatus: llmUsageEvents.pricingStatus,
+      assistantVersion: llmUsageEvents.assistantVersion,
       conversationType: conversations.conversationType,
       // Null when conversationId is null (no parent conversation).
       // Otherwise the count of eligible user turns up to and including
@@ -272,6 +289,8 @@ export interface UsageTimeRange {
   to: number;
 }
 
+export type UsageAggregationFilter = ScheduleAttributionFilter;
+
 /** Aggregate totals across a time range. */
 export interface UsageTotals {
   /** Direct input tokens only; cache traffic is reported separately below. */
@@ -322,14 +341,15 @@ export interface UsageGroupBreakdown {
   /**
    * Stable identifier for the group. Populated with the conversation id when
    * `groupBy === "conversation"` (and `null` for that mode's "Other" bucket,
-   * which aggregates events with no conversation id). For all other group-bys
-   * this is always `null`.
+   * which aggregates events with no conversation id) or with the schedule id
+   * when `groupBy === "schedule"` (and `null` for "Other"). For all other
+   * group-bys this is always `null`.
    */
   groupId: string | null;
   /**
    * Raw stored grouping value for dimensions whose display label may differ
-   * from storage (`call_site`, `inference_profile`). Omitted for legacy
-   * dimensions where `group` is already the raw value.
+   * from storage (`call_site`, `inference_profile`, `schedule`). Omitted for
+   * legacy dimensions where `group` is already the raw value.
    */
   groupKey?: string | null;
   /** Direct input tokens only; cache traffic is reported separately below. */
@@ -357,6 +377,7 @@ interface TotalsRow {
 interface GroupRow {
   group_key: string | null;
   group_id: string | null;
+  group_label: string | null;
   total_input_tokens: number;
   total_output_tokens: number;
   total_cache_creation_tokens: number;
@@ -365,6 +386,39 @@ interface GroupRow {
   event_count: number;
 }
 
+type UsageQueryParam = ScheduleAttributionSqlParam;
+
+function normalizeUsageAggregationFilter(
+  filter?: UsageAggregationFilter,
+): UsageAggregationFilter {
+  return normalizeScheduleAttributionFilter(filter);
+}
+
+function buildUsageAggregationWhere(
+  range: UsageTimeRange,
+  filter?: UsageAggregationFilter,
+  eventAlias?: string,
+  now: number = Date.now(),
+): { sql: string; params: UsageQueryParam[] } {
+  const normalized = normalizeUsageAggregationFilter(filter);
+  const eventTable = eventAlias ?? "llm_usage_events";
+  const createdAt = `${eventTable}.created_at`;
+  const clauses = [`${createdAt} >= ? AND ${createdAt} <= ?`];
+  const params: UsageQueryParam[] = [range.from, range.to];
+
+  if (normalized.scheduleId) {
+    const exists = buildScheduleRunWindowExists({
+      eventAlias: eventTable,
+      filter: normalized,
+      now,
+    });
+    clauses.push(exists.sql);
+    params.push(...exists.params);
+  }
+
+  return { sql: clauses.join(" AND "), params };
+}
+
 /**
  * Return aggregate usage for a single conversation (e.g. a subagent).
  */
@@ -396,10 +450,38 @@ export function getConversationUsageTotals(conversationId: string): {
   };
 }
 
+export function getUsageCostForConversationWindow({
+  conversationId,
+  from,
+  to,
+}: {
+  conversationId: string;
+  from: number;
+  to: number;
+}): number {
+  const rows = rawAll<{ total_cost: number | null }>(
+    /*sql*/ `
+    SELECT COALESCE(SUM(estimated_cost_usd), 0) AS total_cost
+    FROM llm_usage_events
+    WHERE conversation_id = ?1
+      AND created_at >= ?2
+      AND created_at <= ?3
+    `,
+    conversationId,
+    from,
+    to,
+  );
+  return rows[0]?.total_cost ?? 0;
+}
+
 /**
  * Return aggregate totals for all usage events within the given time range.
  */
-export function getUsageTotals(range: UsageTimeRange): UsageTotals {
+export function getUsageTotals(
+  range: UsageTimeRange,
+  filter?: UsageAggregationFilter,
+): UsageTotals {
+  const where = buildUsageAggregationWhere(range, filter);
   const rows = rawAll<TotalsRow>(
     /*sql*/ `
     SELECT
@@ -412,10 +494,9 @@ export function getUsageTotals(range: UsageTimeRange): UsageTotals {
       COUNT(CASE WHEN pricing_status = 'priced' THEN 1 END)       AS priced_event_count,
       COUNT(CASE WHEN pricing_status = 'unpriced' THEN 1 END)     AS unpriced_event_count
     FROM llm_usage_events
-    WHERE created_at >= ?1 AND created_at <= ?2
+    WHERE ${where.sql}
     `,
-    range.from,
-    range.to,
+    ...where.params,
   );
   const row = rows[0];
   return {
@@ -431,7 +512,11 @@ export function getUsageTotals(range: UsageTimeRange): UsageTotals {
 }
 
 /** Fetch raw events in a time range for in-memory bucketing. */
-function fetchRawBucketRows(range: UsageTimeRange): UsageEventBucketRow[] {
+function fetchRawBucketRows(
+  range: UsageTimeRange,
+  filter?: UsageAggregationFilter,
+): UsageEventBucketRow[] {
+  const where = buildUsageAggregationWhere(range, filter);
   return rawAll<UsageEventBucketRow>(
     /*sql*/ `
     SELECT
@@ -441,11 +526,10 @@ function fetchRawBucketRows(range: UsageTimeRange): UsageEventBucketRow[] {
       estimated_cost_usd,
       llm_call_count
     FROM llm_usage_events
-    WHERE created_at >= ?1 AND created_at <= ?2
+    WHERE ${where.sql}
     ORDER BY created_at ASC
     `,
-    range.from,
-    range.to,
+    ...where.params,
   );
 }
 
@@ -472,8 +556,9 @@ export function getUsageDayBuckets(
   range: UsageTimeRange,
   tz: string = "UTC",
   options: UsageBucketOptions = {},
+  filter?: UsageAggregationFilter,
 ): UsageDayBucket[] {
-  const rows = fetchRawBucketRows(range);
+  const rows = fetchRawBucketRows(range, filter);
   return bucketEventsByDay(rows, range, tz, options);
 }
 
@@ -490,8 +575,9 @@ export function getUsageHourBuckets(
   range: UsageTimeRange,
   tz: string = "UTC",
   options: UsageBucketOptions = {},
+  filter?: UsageAggregationFilter,
 ): UsageDayBucket[] {
-  const rows = fetchRawBucketRows(range);
+  const rows = fetchRawBucketRows(range, filter);
   return bucketEventsByHour(rows, range, tz, options);
 }
 
@@ -502,6 +588,7 @@ export const USAGE_GROUP_BY_DIMENSIONS = [
   "conversation",
   "call_site",
   "inference_profile",
+  "schedule",
 ] as const;
 
 export type GroupByDimension = (typeof USAGE_GROUP_BY_DIMENSIONS)[number];
@@ -512,10 +599,11 @@ export const USAGE_SERIES_GROUP_BY_DIMENSIONS = [
   "model",
   "call_site",
   "inference_profile",
+  "schedule",
 ] as const satisfies readonly GroupByDimension[];
 
 const GROUP_BY_COLUMNS: Record<
-  Exclude<GroupByDimension, "conversation">,
+  Exclude<GroupByDimension, "conversation" | "schedule">,
   string
 > = {
   actor: "actor",
@@ -540,9 +628,11 @@ function mapGroupRow(
   groupBy: GroupByDimension,
 ): UsageGroupBreakdown {
   const includeGroupKey =
-    groupBy === "call_site" || groupBy === "inference_profile";
+    groupBy === "call_site" ||
+    groupBy === "inference_profile" ||
+    groupBy === "schedule";
   return {
-    group: displayUsageGroup(groupBy, row.group_key),
+    group: row.group_label ?? displayUsageGroup(groupBy, row.group_key),
     groupId: row.group_id,
     ...(includeGroupKey ? { groupKey: row.group_key } : {}),
     totalInputTokens: row.total_input_tokens,
@@ -561,12 +651,16 @@ function mapGroupRow(
 export function getUsageGroupBreakdown(
   range: UsageTimeRange,
   groupBy: GroupByDimension,
+  filter?: UsageAggregationFilter,
 ): UsageGroupBreakdown[] {
   // Runtime allowlist — defense-in-depth against SQL injection via type assertions.
   assertGroupByDimension(groupBy);
 
+  const normalizedFilter = normalizeUsageAggregationFilter(filter);
+
   // Conversation grouping requires a JOIN with conversations to resolve titles.
   if (groupBy === "conversation") {
+    const where = buildUsageAggregationWhere(range, normalizedFilter, "e");
     const rows = rawAll<GroupRow>(
       /*sql*/ `
       SELECT
@@ -574,6 +668,7 @@ export function getUsageGroupBreakdown(
              ELSE COALESCE(c.title, 'Untitled')
         END AS group_key,
         e.conversation_id                                AS group_id,
+        NULL                                             AS group_label,
         COALESCE(SUM(e.input_tokens), 0)                 AS total_input_tokens,
         COALESCE(SUM(e.output_tokens), 0)                AS total_output_tokens,
         COALESCE(SUM(e.cache_creation_input_tokens), 0)  AS total_cache_creation_tokens,
@@ -582,36 +677,81 @@ export function getUsageGroupBreakdown(
         COALESCE(SUM(COALESCE(e.llm_call_count, 1)), 0)  AS event_count
       FROM llm_usage_events e
       LEFT JOIN conversations c ON e.conversation_id = c.id
-      WHERE e.created_at >= ?1 AND e.created_at <= ?2
+      WHERE ${where.sql}
       GROUP BY e.conversation_id
       ORDER BY total_estimated_cost_usd DESC
       LIMIT 50
       `,
-      range.from,
-      range.to,
+      ...where.params,
+    );
+    return rows.map((row) => mapGroupRow(row, groupBy));
+  }
+
+  if (groupBy === "schedule") {
+    const now = Date.now();
+    const where = buildUsageAggregationWhere(range, normalizedFilter, "e", now);
+    const groupKeySubquery = buildScheduleAttributionSubquery({
+      eventAlias: "e",
+      filter: normalizedFilter,
+      now,
+      selectExpression: "schedule_attr_runs.job_id",
+    });
+    const rows = rawAll<GroupRow>(
+      /*sql*/ `
+      WITH schedule_usage AS (
+        SELECT
+          e.input_tokens,
+          e.output_tokens,
+          e.cache_creation_input_tokens,
+          e.cache_read_input_tokens,
+          e.estimated_cost_usd,
+          e.llm_call_count,
+          ${groupKeySubquery.sql} AS group_key
+        FROM llm_usage_events e
+        WHERE ${where.sql}
+      )
+      SELECT
+        schedule_usage.group_key                                      AS group_key,
+        schedule_usage.group_key                                      AS group_id,
+        MAX(schedule_group_jobs.name)                                 AS group_label,
+        COALESCE(SUM(schedule_usage.input_tokens), 0)                 AS total_input_tokens,
+        COALESCE(SUM(schedule_usage.output_tokens), 0)                AS total_output_tokens,
+        COALESCE(SUM(schedule_usage.cache_creation_input_tokens), 0)  AS total_cache_creation_tokens,
+        COALESCE(SUM(schedule_usage.cache_read_input_tokens), 0)      AS total_cache_read_tokens,
+        COALESCE(SUM(schedule_usage.estimated_cost_usd), 0)           AS total_estimated_cost_usd,
+        COALESCE(SUM(COALESCE(schedule_usage.llm_call_count, 1)), 0)  AS event_count
+      FROM schedule_usage
+      LEFT JOIN cron_jobs schedule_group_jobs
+        ON schedule_group_jobs.id = schedule_usage.group_key
+      GROUP BY schedule_usage.group_key
+      ORDER BY total_estimated_cost_usd DESC
+      `,
+      ...groupKeySubquery.params,
+      ...where.params,
     );
     return rows.map((row) => mapGroupRow(row, groupBy));
   }
 
   const column = GROUP_BY_COLUMNS[groupBy];
+  const where = buildUsageAggregationWhere(range, normalizedFilter, "e");
   const rows = rawAll<GroupRow>(
     /*sql*/ `
     SELECT
-      ${column}                                      AS group_key,
-      NULL                                           AS group_id,
-      COALESCE(SUM(input_tokens), 0)                 AS total_input_tokens,
-      COALESCE(SUM(output_tokens), 0)                AS total_output_tokens,
-      COALESCE(SUM(cache_creation_input_tokens), 0)  AS total_cache_creation_tokens,
-      COALESCE(SUM(cache_read_input_tokens), 0)      AS total_cache_read_tokens,
-      COALESCE(SUM(estimated_cost_usd), 0)           AS total_estimated_cost_usd,
-      COALESCE(SUM(COALESCE(llm_call_count, 1)), 0)  AS event_count
-    FROM llm_usage_events
-    WHERE created_at >= ?1 AND created_at <= ?2
-    GROUP BY ${column}
+      e.${column}                                      AS group_key,
+      NULL                                             AS group_id,
+      NULL                                             AS group_label,
+      COALESCE(SUM(e.input_tokens), 0)                 AS total_input_tokens,
+      COALESCE(SUM(e.output_tokens), 0)                AS total_output_tokens,
+      COALESCE(SUM(e.cache_creation_input_tokens), 0)  AS total_cache_creation_tokens,
+      COALESCE(SUM(e.cache_read_input_tokens), 0)      AS total_cache_read_tokens,
+      COALESCE(SUM(e.estimated_cost_usd), 0)           AS total_estimated_cost_usd,
+      COALESCE(SUM(COALESCE(e.llm_call_count, 1)), 0)  AS event_count
+    FROM llm_usage_events e
+    WHERE ${where.sql}
+    GROUP BY e.${column}
     ORDER BY total_estimated_cost_usd DESC
     `,
-    range.from,
-    range.to,
+    ...where.params,
   );
   return rows.map((row) => mapGroupRow(row, groupBy));
 }
@@ -622,29 +762,73 @@ export function getUsageGroupedSeries(
   granularity: UsageGranularity,
   tz: string = "UTC",
   options: UsageBucketOptions = {},
+  filter?: UsageAggregationFilter,
 ): UsageGroupedSeriesBucket[] {
   assertGroupByDimension(groupBy);
   if (groupBy === "conversation") {
     throw new Error("Grouped usage series does not support conversation");
   }
 
-  const column = GROUP_BY_COLUMNS[groupBy];
-  const rows = rawAll<UsageGroupedBucketRow>(
-    /*sql*/ `
-    SELECT
-      created_at,
-      input_tokens,
-      output_tokens,
-      estimated_cost_usd,
-      llm_call_count,
-      ${column} AS group_key
-    FROM llm_usage_events
-    WHERE created_at >= ?1 AND created_at <= ?2
-    ORDER BY created_at ASC
-    `,
-    range.from,
-    range.to,
-  );
+  const normalizedFilter = normalizeUsageAggregationFilter(filter);
+  let rows: UsageGroupedBucketRow[];
+
+  if (groupBy === "schedule") {
+    const now = Date.now();
+    const where = buildUsageAggregationWhere(range, normalizedFilter, "e", now);
+    const groupKeySubquery = buildScheduleAttributionSubquery({
+      eventAlias: "e",
+      filter: normalizedFilter,
+      now,
+      selectExpression: "schedule_attr_runs.job_id",
+    });
+    rows = rawAll<UsageGroupedBucketRow>(
+      /*sql*/ `
+      WITH schedule_usage AS (
+        SELECT
+          e.created_at,
+          e.input_tokens,
+          e.output_tokens,
+          e.estimated_cost_usd,
+          e.llm_call_count,
+          ${groupKeySubquery.sql} AS group_key
+        FROM llm_usage_events e
+        WHERE ${where.sql}
+      )
+      SELECT
+        schedule_usage.created_at,
+        schedule_usage.input_tokens,
+        schedule_usage.output_tokens,
+        schedule_usage.estimated_cost_usd,
+        schedule_usage.llm_call_count,
+        schedule_usage.group_key,
+        schedule_group_jobs.name AS group_label
+      FROM schedule_usage
+      LEFT JOIN cron_jobs schedule_group_jobs
+        ON schedule_group_jobs.id = schedule_usage.group_key
+      ORDER BY schedule_usage.created_at ASC
+      `,
+      ...groupKeySubquery.params,
+      ...where.params,
+    );
+  } else {
+    const column = GROUP_BY_COLUMNS[groupBy];
+    const where = buildUsageAggregationWhere(range, normalizedFilter, "e");
+    rows = rawAll<UsageGroupedBucketRow>(
+      /*sql*/ `
+      SELECT
+        e.created_at,
+        e.input_tokens,
+        e.output_tokens,
+        e.estimated_cost_usd,
+        e.llm_call_count,
+        e.${column} AS group_key
+      FROM llm_usage_events e
+      WHERE ${where.sql}
+      ORDER BY e.created_at ASC
+      `,
+      ...where.params,
+    );
+  }
 
   return bucketGroupedUsageEvents(rows, range, tz, {
     ...options,

package/src/memory/memory-marker.ts

@@ -0,0 +1,17 @@
+/**
+ * The shared `<memory>…</memory>` injection marker.
+ *
+ * Both the v2 graph-memory producers (`conversation-graph-memory.ts`) and the
+ * v3 live renderer (`v3/render-injection.ts`) emit memory blocks with this
+ * exact wrapper, and the strip/recognition machinery in
+ * `conversation-graph-memory.ts` (`countMemoryPrefixBlocks`) matches the same
+ * `"<memory>\n"` / `"\n</memory>"` delimiters. Keeping the producer wrapper in
+ * one leaf module guarantees the byte-for-byte marker contract across v2 and
+ * v3 — a change here updates every producer at once.
+ *
+ * This is a tiny dependency-free leaf so the pure v3 renderer can import it
+ * without pulling in the heavyweight graph-memory module.
+ */
+export function wrapMemoryBlock(text: string): string {
+  return `<memory>\n${text}\n</memory>`;
+}

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

@@ -208,6 +208,7 @@ async function runLegacyRetrospective(
       source: MEMORY_RETROSPECTIVE_SOURCE,
       trustContext: INTERNAL_GUARDIAN_TRUST_CONTEXT,
       callSite: "memoryRetrospective",
+      allowedTools: ["remember"],
       // The background conversation's title already reads "Memory
       // Retrospective", and `hint` is the full retrospective prompt — surfacing
       // it verbatim as a "Conversation Woke" card body is noisy internal
@@ -382,8 +383,10 @@ async function runForkBasedRetrospective(
       forkId,
       "user",
       JSON.stringify([{ type: "text", text: instruction }]),
-      { kind: MEMORY_RETROSPECTIVE_INSTRUCTION_KIND, hidden: true },
-      { skipIndexing: true },
+      {
+        metadata: { kind: MEMORY_RETROSPECTIVE_INSTRUCTION_KIND, hidden: true },
+        skipIndexing: true,
+      },
     );
   } catch (err) {
     log.error(
@@ -407,6 +410,7 @@ async function runForkBasedRetrospective(
       source: MEMORY_RETROSPECTIVE_SOURCE,
       trustContext: INTERNAL_GUARDIAN_TRUST_CONTEXT,
       callSite: "memoryRetrospective",
+      allowedTools: ["remember"],
       hintRole: "user",
       skipHintInjection: true,
       suppressAutoCompaction: true,

package/src/memory/memory-v2-activation-log-store.ts

@@ -1,9 +1,8 @@
-import { and, desc, eq, gte, inArray, isNull, lte, ne } from "drizzle-orm";
+import { and, desc, eq, inArray, isNull, ne } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "./db-connection.js";
 import { memoryV2ActivationLogs } from "./schema.js";
-import type { ShadowDiffLogRow } from "./v3/shadow-diff.js";
 
 export interface MemoryV2ConceptRowRecord {
   slug: string;
@@ -215,84 +214,3 @@ export function getMemoryV2ActivationLogByMessageIds(
     config: JSON.parse(row.configJson) as MemoryV2ConfigSnapshot,
   };
 }
-
-function parseConcepts(conceptsJson: string): MemoryV2ConceptRowRecord[] {
-  try {
-    const parsed = JSON.parse(conceptsJson);
-    return Array.isArray(parsed) ? (parsed as MemoryV2ConceptRowRecord[]) : [];
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Read the activation-log rows the v3 shadow-diff needs: every `v3_shadow` row
- * (optionally newer than `sinceMs`), plus the `router` rows that could pair
- * with them. The router read is bounded to the shadow rows' conversations and
- * their time span (padded by `paddingMs`) so a shadow-diff over a few turns
- * never scans the entire multi-GB log table. Returns `{ shadow, router }` for
- * {@link computeShadowDiff} to pair and diff.
- */
-export function readActivationLogsForShadowDiff(opts: {
-  sinceMs: number | null;
-  paddingMs: number;
-}): { shadow: ShadowDiffLogRow[]; router: ShadowDiffLogRow[] } {
-  const db = getDb();
-
-  const shadow = db
-    .select({
-      conversationId: memoryV2ActivationLogs.conversationId,
-      createdAt: memoryV2ActivationLogs.createdAt,
-      conceptsJson: memoryV2ActivationLogs.conceptsJson,
-    })
-    .from(memoryV2ActivationLogs)
-    .where(
-      opts.sinceMs !== null
-        ? and(
-            eq(memoryV2ActivationLogs.mode, "v3_shadow"),
-            gte(memoryV2ActivationLogs.createdAt, opts.sinceMs),
-          )
-        : eq(memoryV2ActivationLogs.mode, "v3_shadow"),
-    )
-    .orderBy(memoryV2ActivationLogs.createdAt)
-    .all()
-    .map((row) => ({
-      conversationId: row.conversationId,
-      createdAt: row.createdAt,
-      concepts: parseConcepts(row.conceptsJson),
-    }));
-
-  if (shadow.length === 0) return { shadow: [], router: [] };
-
-  const convIds = [...new Set(shadow.map((s) => s.conversationId))];
-  let tMin = Number.POSITIVE_INFINITY;
-  let tMax = Number.NEGATIVE_INFINITY;
-  for (const s of shadow) {
-    if (s.createdAt < tMin) tMin = s.createdAt;
-    if (s.createdAt > tMax) tMax = s.createdAt;
-  }
-
-  const router = db
-    .select({
-      conversationId: memoryV2ActivationLogs.conversationId,
-      createdAt: memoryV2ActivationLogs.createdAt,
-      conceptsJson: memoryV2ActivationLogs.conceptsJson,
-    })
-    .from(memoryV2ActivationLogs)
-    .where(
-      and(
-        eq(memoryV2ActivationLogs.mode, "router"),
-        inArray(memoryV2ActivationLogs.conversationId, convIds),
-        gte(memoryV2ActivationLogs.createdAt, tMin - opts.paddingMs),
-        lte(memoryV2ActivationLogs.createdAt, tMax + opts.paddingMs),
-      ),
-    )
-    .all()
-    .map((row) => ({
-      conversationId: row.conversationId,
-      createdAt: row.createdAt,
-      concepts: parseConcepts(row.conceptsJson),
-    }));
-
-  return { shadow, router };
-}

package/src/memory/migrations/222-strip-placeholder-sentinels-from-messages.ts

@@ -1,15 +1,16 @@
-import { isPlaceholderSentinelText } from "../../providers/anthropic/client.js";
+import { isPlaceholderSentinelText } from "../../providers/placeholder-sentinels.js";
 import type { DrizzleDb } from "../db-connection.js";
 import { getSqliteFrom } from "../db-connection.js";
 import { withCrashRecovery } from "./validate-migration-state.js";
 
 /**
- * Strip Anthropic provider placeholder sentinel text blocks from persisted
- * assistant messages.
+ * Strip provider placeholder sentinel text blocks from persisted assistant
+ * messages.
  *
  * PLACEHOLDER_EMPTY_TURN and PLACEHOLDER_BLOCKS_OMITTED are injected into
- * outbound Anthropic request bodies to preserve role alternation when an
- * assistant turn would otherwise be empty. They are never supposed to be
+ * outbound provider request bodies (Anthropic role alternation, OpenAI-
+ * compatible "content or tool_calls" constraint) when an assistant turn would
+ * otherwise be empty. They are never supposed to be
  * persisted, but a leak path caused them to be stored in the messages table
  * where they render in chat bubbles as bold "PLACEHOLDER[...]" (markdown
  * interprets the double-underscore surround as bold).