@vellumai/assistant 0.8.6 → 0.8.7

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

@@ -44,31 +44,17 @@ export interface LlmRequestLogSource {
    * whose `createdAt` falls in the **open window**
    * `(afterCreatedAt, beforeCreatedAt)`, ordered chronologically.
    *
-   * Drives the Inspector's Compaction tab. The route handler resolves
-   * both bounds: the selected LLM call's `createdAt` (ceiling) and the
-   * previous non-`compactionAgent` call's `createdAt` (floor) — passing
-   * `null` for the floor when the selected call is the first real call
-   * in the conversation. See `getCompactionLogsBetween` and
-   * `getPreviousNonCompactionCallCreatedAt` in `llm-request-log-store.ts`
-   * for the full bound semantics.
+   * 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
+   * `llm-request-log-store.ts` for the SQL.
    */
   getCompactionLogsBetween(
     conversationId: string,
     afterCreatedAt: number | null,
     beforeCreatedAt: number,
   ): Promise<LogRow[]>;
-
-  /**
-   * Find the `createdAt` of the most recent non-`compactionAgent` LLM
-   * call in the conversation strictly before `beforeCreatedAt`, or
-   * `null` when no such call exists. Pairs with
-   * `getCompactionLogsBetween` to bound the compaction trail to the
-   * window between the prior real call and the selected call.
-   */
-  getPreviousNonCompactionCallCreatedAt(
-    conversationId: string,
-    beforeCreatedAt: number,
-  ): Promise<number | null>;
 }
 
 /**
@@ -89,14 +75,12 @@ export async function getLlmRequestLogSource(): Promise<LlmRequestLogSource> {
   const cfg = config.llmRequestLogs ?? { readSource: "local" as const };
 
   if (cfg.readSource === "clickhouse") {
-    const { ClickHouseLlmRequestLogSource } = await import(
-      "./llm-request-log-source-clickhouse.js"
-    );
+    const { ClickHouseLlmRequestLogSource } =
+      await import("./llm-request-log-source-clickhouse.js");
     return new ClickHouseLlmRequestLogSource(cfg.clickhouse);
   }
 
-  const { LocalLlmRequestLogSource } = await import(
-    "./llm-request-log-source-local.js"
-  );
+  const { LocalLlmRequestLogSource } =
+    await import("./llm-request-log-source-local.js");
   return new LocalLlmRequestLogSource();
 }

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

@@ -9,8 +9,6 @@ import {
   isNull,
   lt,
   lte,
-  ne,
-  or,
   sql,
 } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
@@ -456,45 +454,6 @@ export function getCompactionLogsBetween(
     .all();
 }
 
-/**
- * Find the `createdAt` of the most recent non-`compactionAgent` LLM
- * call in the conversation strictly before `beforeCreatedAt`, or `null`
- * when no such call exists (i.e. the cutoff is the first real call).
- *
- * Pairs with `getCompactionLogsBetween` to bound the compaction trail
- * to the window between the prior real call and the selected call.
- *
- * "Non-compactionAgent" means `callSite IS NULL OR callSite !=
- * 'compactionAgent'`. NULL rows are pre-migration-264 (no backfill) and
- * are treated as real agent calls — they were `mainAgent` in practice.
- * The OR-with-IS NULL is required because SQL's three-valued logic
- * makes `callSite != 'compactionAgent'` return UNKNOWN (not TRUE) for
- * NULL rows, which would otherwise filter them out.
- */
-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;
-}
-
 export function getRequestLogById(logId: string): LogRow | null {
   const db = getDb();
   return (

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

@@ -6,6 +6,7 @@ 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 { conversations, llmUsageEvents } from "./schema.js";
@@ -39,6 +40,7 @@ export function recordUsageEvent(
     inferenceProfileSource: input.inferenceProfileSource ?? null,
     estimatedCostUsd: pricing.estimatedCostUsd,
     pricingStatus: pricing.pricingStatus,
+    assistantVersion: APP_VERSION,
   };
   db.insert(llmUsageEvents)
     .values({
@@ -62,6 +64,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 +98,7 @@ function rowToUsageEvent(row: {
   rawUsage: string | null;
   estimatedCostUsd: number | null;
   pricingStatus: string;
+  assistantVersion: string | null;
 }): UsageEvent {
   return {
     id: row.id,
@@ -112,6 +120,7 @@ function rowToUsageEvent(row: {
     rawUsage: parseRawUsage(row.rawUsage),
     estimatedCostUsd: row.estimatedCostUsd,
     pricingStatus: row.pricingStatus as "priced" | "unpriced",
+    assistantVersion: row.assistantVersion,
   };
 }
 
@@ -213,6 +222,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

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/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/__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,10 @@ 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 {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/schema/infrastructure.ts

@@ -21,6 +21,7 @@ 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
   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 +243,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),