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

package/src/memory/migrations/267-llm-usage-events-add-assistant-version.ts

@@ -0,0 +1,46 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+const COLUMN = "assistant_version";
+const TABLE = "llm_usage_events";
+
+/**
+ * Add a nullable `assistant_version TEXT` column to `llm_usage_events`.
+ *
+ * Stamps the version of the assistant binary at the moment the event was
+ * RECORDED, not when the batch was uploaded. The previous shape sent the
+ * version only on the upload envelope, which silently mis-attributes
+ * delayed flushes: an assistant that buffered events for days (offline
+ * laptop, network outage, ingest clog — see May 2026 incident) and
+ * finally flushed under its current version stamps that current version
+ * onto every backlogged event, breaking the version filter on
+ * `/admin/inference`.
+ *
+ * `NULL` for rows persisted before this migration ran. The reporter
+ * falls back to the running binary's `APP_VERSION` when the per-event
+ * column is null, so legacy rows still produce a concrete version on
+ * the wire.
+ *
+ * Scope: only `llm_usage_events` for now. `lifecycle_events` (#18112)
+ * and `onboarding_events` (#30733) share the same record-time-attribution
+ * issue and will get the column in a follow-up. Turn events derive from
+ * the `messages` table and are also out of scope — see follow-up that
+ * adds the column to `messages`.
+ *
+ * Idempotent — re-running is a no-op once the column exists. Pure DDL
+ * with a PRAGMA guard, no registry entry needed (matches the 252 / 261
+ * / 264 / 265 pattern).
+ */
+export function migrateLlmUsageEventsAddAssistantVersion(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+
+  const columns = raw.query(`PRAGMA table_info(${TABLE})`).all() as Array<{
+    name: string;
+  }>;
+  const columnNames = new Set(columns.map((c) => c.name));
+
+  if (!columnNames.has(COLUMN)) {
+    raw.exec(`ALTER TABLE ${TABLE} ADD COLUMN ${COLUMN} TEXT`);
+  }
+}

package/src/memory/migrations/268-add-memory-v3-selections.ts

@@ -0,0 +1,28 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Adds `memory_v3_selections` for memory-v3 working-set persistence:
+ * one row per (conversation, turn, page-slug) the v3 retriever selected,
+ * tagged with the lane (`source`) that produced it. `pinned` marks slugs
+ * carried forward across turns rather than re-selected cold.
+ *
+ * Idempotent — re-running is a no-op once the table and index exist.
+ */
+export function migrateAddMemoryV3Selections(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_v3_selections (
+      conversation_id TEXT NOT NULL,
+      turn INTEGER NOT NULL,
+      slug TEXT NOT NULL,
+      source TEXT NOT NULL,
+      pinned INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (conversation_id, turn, slug)
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_v3_selections_conv
+      ON memory_v3_selections (conversation_id, turn DESC)
+  `);
+}

package/src/memory/migrations/269-schedule-script-timeout.ts

@@ -0,0 +1,11 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateScheduleScriptTimeout(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(`ALTER TABLE cron_jobs ADD COLUMN timeout_ms INTEGER`);
+  } catch {
+    /* Column already exists */
+  }
+}

package/src/memory/migrations/270-messages-role-created-at-index.ts

@@ -0,0 +1,18 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+/**
+ * Indexes `messages(role, created_at)` so the most recent message of a given
+ * role can be found with an indexed seek instead of a table scan.
+ *
+ * The database-maintenance quiet-period gate looks up the newest user-message
+ * timestamp on every idle worker tick; without this index that lookup scans
+ * the (potentially multi-GB) messages table on the daemon's synchronous
+ * connection.
+ *
+ * Idempotent — `CREATE INDEX IF NOT EXISTS` is a no-op once the index exists.
+ */
+export function migrateMessagesRoleCreatedAtIndex(database: DrizzleDb): void {
+  database.run(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_messages_role_created_at ON messages(role, created_at)`,
+  );
+}

package/src/memory/migrations/270-schedule-source-conversation.ts

@@ -0,0 +1,13 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateScheduleSourceConversation(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(
+      `ALTER TABLE cron_jobs ADD COLUMN created_from_conversation_id TEXT`,
+    );
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

package/src/memory/migrations/271-create-auth-fallback-events.ts

@@ -0,0 +1,21 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+/**
+ * Create the auth_fallback_events table for tracking legacy-loopback
+ * auth-fallback counts forwarded by the gateway. One row per
+ * (guard, path, failure_kind) per flush window.
+ */
+export function createAuthFallbackEventsTable(database: DrizzleDb): void {
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS auth_fallback_events (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL,
+      guard TEXT NOT NULL,
+      path TEXT NOT NULL,
+      failure_kind TEXT NOT NULL,
+      count INTEGER NOT NULL,
+      window_start INTEGER NOT NULL,
+      window_end INTEGER NOT NULL
+    )
+  `);
+}

package/src/memory/migrations/272-acp-session-history-cwd.ts

@@ -0,0 +1,36 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_acp_session_history_cwd_v1";
+
+const TABLE = "acp_session_history";
+const COLUMN = "cwd";
+
+/**
+ * Add a nullable `cwd TEXT` column to `acp_session_history`.
+ *
+ * Records the working directory the ACP agent process was spawned with so
+ * that a persisted session can later be resumed (`session/load` /
+ * `session/resume` both require the original cwd to reconstruct params).
+ *
+ * `NULL` for rows persisted before this migration ran — legacy sessions
+ * simply are not resumable.
+ *
+ * Idempotent — the PRAGMA guard makes re-running a no-op once the column
+ * exists.
+ */
+export function migrateAcpSessionHistoryCwd(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+
+    const columns = raw.query(`PRAGMA table_info(${TABLE})`).all() as Array<{
+      name: string;
+    }>;
+    const columnNames = new Set(columns.map((c) => c.name));
+
+    if (!columnNames.has(COLUMN)) {
+      raw.exec(`ALTER TABLE ${TABLE} ADD COLUMN ${COLUMN} TEXT`);
+    }
+  });
+}

package/src/memory/migrations/__tests__/267-llm-usage-events-add-assistant-version.test.ts

@@ -0,0 +1,117 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateLlmUsageEventsAddAssistantVersion } from "../267-llm-usage-events-add-assistant-version.js";
+
+interface ColumnRow {
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: string | null;
+  pk: number;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+/**
+ * Inline minimal CREATE TABLE for just `llm_usage_events`. We deliberately
+ * don't call migration 101 — it also sets up FTS triggers + other tables
+ * that aren't relevant here and pull in more surface area than we need to
+ * validate this migration.
+ *
+ * Schema mirrors the post-251 (llm_usage_events incl. inference profile)
+ * state on purpose so the test reflects what the migration runs against
+ * in prod.
+ */
+function bootstrap(db: ReturnType<typeof createTestDb>): void {
+  db.run(/*sql*/ `
+    CREATE TABLE llm_usage_events (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL,
+      output_tokens INTEGER NOT NULL
+    )
+  `);
+}
+
+describe("migration 267 — llm_usage_events add assistant_version", () => {
+  test("adds nullable assistant_version TEXT to llm_usage_events", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    const before = raw
+      .query(`PRAGMA table_info(llm_usage_events)`)
+      .all() as ColumnRow[];
+    expect(before.map((c) => c.name)).not.toContain("assistant_version");
+
+    migrateLlmUsageEventsAddAssistantVersion(db);
+
+    const after = raw
+      .query(`PRAGMA table_info(llm_usage_events)`)
+      .all() as ColumnRow[];
+    const col = after.find((c) => c.name === "assistant_version");
+    expect(col).toBeDefined();
+    expect(col!.type).toBe("TEXT");
+    // Nullable, no default — pre-migration rows stay NULL.
+    expect(col!.notnull).toBe(0);
+    expect(col!.dflt_value).toBeNull();
+  });
+
+  test("is idempotent — running twice does not throw", () => {
+    const db = createTestDb();
+    bootstrap(db);
+    migrateLlmUsageEventsAddAssistantVersion(db);
+    expect(() => migrateLlmUsageEventsAddAssistantVersion(db)).not.toThrow();
+  });
+
+  test("pre-migration rows survive with assistant_version = NULL", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    raw.run(`
+      INSERT INTO llm_usage_events
+        (id, created_at, provider, model, input_tokens, output_tokens)
+      VALUES
+        ('u1', 1, 'anthropic', 'claude-sonnet-4', 10, 20)
+    `);
+
+    migrateLlmUsageEventsAddAssistantVersion(db);
+
+    const usage = raw
+      .query(`SELECT id, assistant_version FROM llm_usage_events`)
+      .all() as Array<{ id: string; assistant_version: string | null }>;
+    expect(usage).toEqual([{ id: "u1", assistant_version: null }]);
+  });
+
+  test("post-migration rows can be inserted with assistant_version", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+    migrateLlmUsageEventsAddAssistantVersion(db);
+
+    raw.run(`
+      INSERT INTO llm_usage_events
+        (id, created_at, provider, model, input_tokens, output_tokens,
+         assistant_version)
+      VALUES
+        ('u2', 4, 'anthropic', 'claude-sonnet-4', 10, 20, '0.8.4')
+    `);
+    const row = raw
+      .query(`SELECT assistant_version FROM llm_usage_events WHERE id = 'u2'`)
+      .get() as { assistant_version: string };
+    expect(row.assistant_version).toBe("0.8.4");
+  });
+});

package/src/memory/migrations/index.ts

@@ -253,6 +253,13 @@ export {
 export { migrateLlmRequestLogCallSite } from "./264-llm-request-log-call-site.js";
 export { migrateDropProviderConnectionStatus } from "./265-drop-provider-connection-status.js";
 export { migrateMessagesClientMessageId } from "./266-messages-client-message-id.js";
+export { migrateLlmUsageEventsAddAssistantVersion } from "./267-llm-usage-events-add-assistant-version.js";
+export { migrateAddMemoryV3Selections } from "./268-add-memory-v3-selections.js";
+export { migrateScheduleScriptTimeout } from "./269-schedule-script-timeout.js";
+export { migrateMessagesRoleCreatedAtIndex } from "./270-messages-role-created-at-index.js";
+export { migrateScheduleSourceConversation } from "./270-schedule-source-conversation.js";
+export { createAuthFallbackEventsTable } from "./271-create-auth-fallback-events.js";
+export { migrateAcpSessionHistoryCwd } from "./272-acp-session-history-cwd.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/pkb/autoinject.ts

@@ -0,0 +1,61 @@
+/**
+ * Resolution of the PKB auto-inject file list (`pkb/_autoinject.md`).
+ *
+ * Which PKB files are always loaded into context is a PKB-domain concern
+ * owned here next to {@link getPkbRoot}, so both the runtime injector and the
+ * reminder-hint tracker resolve the list from a single canonical source
+ * rather than threading it through the orchestrator.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { stripCommentLines } from "../../util/strip-comment-lines.js";
+
+const PKB_DEFAULT_FILES = [
+  "INDEX.md",
+  "essentials.md",
+  "threads.md",
+  "buffer.md",
+];
+
+const AUTOINJECT_FILENAME = "_autoinject.md";
+
+/**
+ * Read `_autoinject.md` from the PKB directory and return the list of
+ * filenames to inject.
+ *
+ * - Returns `null` when the file is missing or unreadable — callers
+ *   should fall back to the hardcoded defaults.
+ * - Returns `[]` when the file exists but has no entries (empty or
+ *   comments only) — an explicit opt-out meaning "inject nothing."
+ */
+export function readAutoinjectList(pkbDir: string): string[] | null {
+  const filePath = join(pkbDir, AUTOINJECT_FILENAME);
+  if (!existsSync(filePath)) return null;
+  try {
+    const raw = stripCommentLines(readFileSync(filePath, "utf-8"));
+    const files = raw
+      .split("\n")
+      .map((l) => l.trim())
+      .filter((l) => l.length > 0);
+    return files.length > 0 ? files : [];
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve the effective list of auto-inject filenames for a PKB directory.
+ *
+ * This is the single source of truth used both by `readPkbContext` (which
+ * actually injects the files) and by the PKB reminder-hint injector (which
+ * needs to know what's already in context so it doesn't redundantly
+ * recommend those files).
+ *
+ * Returns `PKB_DEFAULT_FILES` when `_autoinject.md` is missing/unreadable,
+ * or the parsed list (possibly empty) when it is present.
+ */
+export function getPkbAutoInjectList(pkbRoot: string): string[] {
+  return readAutoinjectList(pkbRoot) ?? PKB_DEFAULT_FILES;
+}

package/src/memory/pkb/context.ts

@@ -0,0 +1,50 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+import { getWorkspaceDir } from "../../util/platform.js";
+import { stripCommentLines } from "../../util/strip-comment-lines.js";
+import { getPkbAutoInjectList } from "./autoinject.js";
+
+/** Max buffer.md lines injected into prompts — keeps context bounded even when filing is off. */
+const MAX_BUFFER_LINES = 50;
+
+/**
+ * Read the always-loaded PKB files and append a nudge encouraging the
+ * assistant to proactively read topic files and use `remember` aggressively.
+ *
+ * Which files are loaded is determined by `pkb/_autoinject.md` (one filename
+ * per line). Falls back to the built-in defaults when that file is absent.
+ *
+ * Returns the concatenated content ready for injection, or `null` if all
+ * files are missing or empty.
+ */
+export function readPkbContext(): string | null {
+  const pkbDir = join(getWorkspaceDir(), "pkb");
+  if (!existsSync(pkbDir)) return null;
+
+  const filesToInject = getPkbAutoInjectList(pkbDir);
+
+  const parts: string[] = [];
+  for (const file of filesToInject) {
+    // Path traversal guard: reject entries that escape the pkb directory
+    const filePath = resolve(pkbDir, file);
+    if (!filePath.startsWith(pkbDir + "/")) continue;
+
+    if (!existsSync(filePath)) continue;
+    try {
+      let content = stripCommentLines(readFileSync(filePath, "utf-8")).trim();
+      if (file === "buffer.md" && content.length > 0) {
+        // Cap buffer entries to prevent unbounded growth when filing is disabled
+        const lines = content.split("\n");
+        if (lines.length > MAX_BUFFER_LINES) {
+          content = lines.slice(-MAX_BUFFER_LINES).join("\n");
+        }
+      }
+      if (content.length > 0) parts.push(content);
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  return parts.length > 0 ? parts.join("\n\n") : null;
+}

package/src/memory/pkb/types.ts

@@ -5,8 +5,22 @@
  * index writer) land in later PRs.
  */
 
+import { join } from "node:path";
+
+import { getWorkspaceDir } from "../../util/platform.js";
+
 export const PKB_TARGET_TYPE = "pkb_file" as const;
 
+/**
+ * Absolute path to the workspace's PKB directory (`<workspace>/pkb`). PKB is
+ * a workspace-shared resource with a single on-disk location, so this is the
+ * canonical way to resolve its root rather than re-joining the workspace dir
+ * at each call site.
+ */
+export function getPkbRoot(): string {
+  return join(getWorkspaceDir(), "pkb");
+}
+
 /**
  * Sentinel `memory_scope_id` under which ALL PKB points are indexed and
  * searched. PKB files are a workspace-shared resource: one copy on disk is

package/src/memory/schedule-attribution-sql.ts

@@ -0,0 +1,104 @@
+export interface ScheduleAttributionFilter {
+  scheduleId?: string;
+}
+
+export type ScheduleAttributionSqlParam = string | number;
+
+export interface ScheduleAttributionSqlFragment {
+  sql: string;
+  params: ScheduleAttributionSqlParam[];
+}
+
+export function normalizeScheduleAttributionFilter(
+  filter?: ScheduleAttributionFilter,
+): ScheduleAttributionFilter {
+  const scheduleId = filter?.scheduleId?.trim();
+  return scheduleId ? { scheduleId } : {};
+}
+
+function usageColumn(column: string, eventAlias: string): string {
+  return `${eventAlias}.${column}`;
+}
+
+function buildScheduleRunWindowPredicate({
+  eventAlias,
+  runAlias,
+  filter,
+}: {
+  eventAlias: string;
+  runAlias: string;
+  filter?: ScheduleAttributionFilter;
+}): string {
+  const normalized = normalizeScheduleAttributionFilter(filter);
+  const scheduleClause = normalized.scheduleId
+    ? `${runAlias}.job_id = ? AND `
+    : "";
+  return `${scheduleClause}${runAlias}.conversation_id = ${usageColumn(
+    "conversation_id",
+    eventAlias,
+  )}
+    AND ${usageColumn("created_at", eventAlias)} >= ${runAlias}.started_at
+    AND ${usageColumn("created_at", eventAlias)} <= COALESCE(${runAlias}.finished_at, ?)`;
+}
+
+function buildScheduleRunWindowParams(
+  filter: ScheduleAttributionFilter | undefined,
+  now: number,
+): ScheduleAttributionSqlParam[] {
+  const normalized = normalizeScheduleAttributionFilter(filter);
+  return normalized.scheduleId ? [normalized.scheduleId, now] : [now];
+}
+
+export function buildScheduleRunWindowExists({
+  eventAlias,
+  filter,
+  now,
+  runAlias = "schedule_filter_runs",
+}: {
+  eventAlias: string;
+  filter?: ScheduleAttributionFilter;
+  now: number;
+  runAlias?: string;
+}): ScheduleAttributionSqlFragment {
+  return {
+    sql: `EXISTS (
+      SELECT 1
+      FROM cron_runs ${runAlias}
+      WHERE ${buildScheduleRunWindowPredicate({
+        eventAlias,
+        runAlias,
+        filter,
+      })}
+    )`,
+    params: buildScheduleRunWindowParams(filter, now),
+  };
+}
+
+export function buildScheduleAttributionSubquery({
+  eventAlias,
+  filter,
+  now,
+  selectExpression,
+  runAlias = "schedule_attr_runs",
+}: {
+  eventAlias: string;
+  filter?: ScheduleAttributionFilter;
+  now: number;
+  selectExpression: string;
+  runAlias?: string;
+}): ScheduleAttributionSqlFragment {
+  return {
+    sql: `(
+    SELECT ${selectExpression}
+    FROM cron_runs ${runAlias}
+    WHERE ${buildScheduleRunWindowPredicate({
+      eventAlias,
+      runAlias,
+      filter,
+    })}
+    ORDER BY ${runAlias}.started_at DESC, ${runAlias}.id DESC
+    LIMIT 1
+  )`,
+    params: buildScheduleRunWindowParams(filter, now),
+  };
+}

package/src/memory/schema/acp.ts

@@ -20,6 +20,10 @@ export const acpSessionHistory = sqliteTable(
     stopReason: text("stop_reason"),
     error: text("error"),
     eventLogJson: text("event_log_json").notNull().default("[]"),
+    // Working directory the agent process was spawned with. Required to
+    // resume a persisted session; null for rows written before migration
+    // 272 (those sessions are not resumable).
+    cwd: text("cwd"),
   },
   (table) => [
     index("idx_acp_session_history_started_at").on(table.startedAt),

package/src/memory/schema/infrastructure.ts

@@ -21,6 +21,8 @@ export const cronJobs = sqliteTable("cron_jobs", {
   retryCount: integer("retry_count").notNull().default(0),
   maxRetries: integer("max_retries").notNull().default(3),
   retryBackoffMs: integer("retry_backoff_ms").notNull().default(60000),
+  timeoutMs: integer("timeout_ms"), // script-mode execution timeout override (ms); null = use default
+  createdFromConversationId: text("created_from_conversation_id"),
   createdBy: text("created_by").notNull(), // 'agent' | 'user'
   mode: text("mode").notNull().default("execute"), // 'notify' | 'execute'
   routingIntent: text("routing_intent").notNull().default("all_channels"), // 'single_channel' | 'multi_channel' | 'all_channels'
@@ -242,6 +244,16 @@ export const llmUsageEvents = sqliteTable(
     pricingStatus: text("pricing_status").notNull(),
     llmCallCount: integer("llm_call_count"),
     metadataJson: text("metadata_json"),
+    /**
+     * Version of the assistant binary at the moment THIS event was
+     * recorded (not when the batch was uploaded). Telemetry uploads
+     * batch events together and may flush days after the event fired
+     * (offline laptop, network outage, ingest clog — see May 2026
+     * incident). Stamping at record time keeps the version filter on
+     * `/admin/inference` truthful for delayed batches. Null for rows
+     * persisted before migration 267 ran.
+     */
+    assistantVersion: text("assistant_version"),
   },
   (table) => [
     index("idx_llm_usage_events_conversation_id").on(table.conversationId),
@@ -267,6 +279,21 @@ export const onboardingEvents = sqliteTable("onboarding_events", {
   abVariant: text("ab_variant"),
 });
 
+// Aggregated legacy-loopback auth-fallback counts forwarded by the gateway.
+// One row per (guard, path, failure_kind) per flush window; `count` is how many
+// requests fell back to the loopback exemption in that window. Flushed to the
+// platform telemetry endpoint by the usage telemetry reporter.
+export const authFallbackEvents = sqliteTable("auth_fallback_events", {
+  id: text("id").primaryKey(),
+  createdAt: integer("created_at").notNull(),
+  guard: text("guard").notNull(), // 'edge' | 'edge-scoped' | 'edge-guardian'
+  path: text("path").notNull(),
+  failureKind: text("failure_kind").notNull(),
+  count: integer("count").notNull(),
+  windowStart: integer("window_start").notNull(),
+  windowEnd: integer("window_end").notNull(),
+});
+
 export const traceEvents = sqliteTable(
   "trace_events",
   {

package/src/memory/usage-grouped-buckets.ts

@@ -27,6 +27,7 @@ export interface UsageGroupedSeriesBucket extends UsageDayBucket {
 
 export interface UsageGroupedBucketRow extends UsageEventBucketRow {
   group_key: string | null;
+  group_label?: string | null;
 }
 
 const VALUE_GROUP_PREFIX = "value:";
@@ -42,6 +43,9 @@ export function displayUsageGroup(
   if (groupBy === "inference_profile") {
     return groupKey === null ? "Default / Unset" : groupKey;
   }
+  if (groupBy === "schedule") {
+    return groupKey ?? "Other";
+  }
   return groupKey ?? "Other";
 }
 
@@ -102,7 +106,8 @@ export function bucketGroupedUsageEvents(
     let group = groupedBucket.groups[seriesKey];
     if (!group) {
       group = {
-        group: displayUsageGroup(options.groupBy, row.group_key),
+        group:
+          row.group_label ?? displayUsageGroup(options.groupBy, row.group_key),
         groupKey: row.group_key,
         totalInputTokens: 0,
         totalOutputTokens: 0,