@vellumai/assistant 0.8.4 → 0.8.5

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

@@ -1,6 +1,7 @@
-import { and, desc, eq, gte, inArray, isNull, lte, sql } from "drizzle-orm";
+import { and, asc, desc, eq, gte, inArray, isNull, lte, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import type { LLMCallSite } from "../config/schemas/llm.js";
 import { AssistantError, ProviderError } from "../util/errors.js";
 import {
   getAssistantMessageIdsInTurn,
@@ -26,6 +27,12 @@ export type LogRow = {
    * `AgentLoopExitReason` in `agent/loop.ts`.
    */
   agentLoopExitReason: string | null;
+  /**
+   * Logical call site that produced this row — `mainAgent`,
+   * `compactionAgent`, etc. NULL on pre-migration-264 rows (no backfill).
+   * In practice values come from `LLMCallSite` (`config/schemas/llm.ts`).
+   */
+  callSite: string | null;
 };
 
 /**
@@ -73,6 +80,7 @@ export function recordRequestLog(
   responsePayload: string,
   messageId?: string,
   provider?: string,
+  callSite?: LLMCallSite,
 ): string {
   const db = getDb();
   const id = uuid();
@@ -88,6 +96,10 @@ export function recordRequestLog(
       // Stamped later via setAgentLoopExitReasonOnLatestLog, once the
       // agent loop body actually exits. Intermediate rows stay NULL.
       agentLoopExitReason: null,
+      // Logical call site (`mainAgent`, `compactionAgent`, …). NULL when
+      // a caller hasn't been updated yet — preserves backward compat
+      // while we plumb call sites through one site at a time.
+      callSite: callSite ?? null,
     })
     .run();
   return id;
@@ -182,6 +194,7 @@ function selectLogsByMessageIds(messageIds: string[]): LogRow[] {
       responsePayload: llmRequestLogs.responsePayload,
       createdAt: llmRequestLogs.createdAt,
       agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+      callSite: llmRequestLogs.callSite,
     })
     .from(llmRequestLogs)
     .where(inArray(llmRequestLogs.messageId, messageIds))
@@ -189,6 +202,32 @@ function selectLogsByMessageIds(messageIds: string[]): LogRow[] {
     .all();
 }
 
+/**
+ * Query every LLM request log recorded for a conversation, ordered by
+ * creation time. Conversation-scoped inspector views intentionally do
+ * not apply turn recovery: the `conversation_id` column already includes
+ * linked, unlinked, and orphaned rows for the full conversation.
+ */
+export function getRequestLogsByConversationId(conversationId: string): LogRow[] {
+  const db = getDb();
+  return db
+    .select({
+      id: llmRequestLogs.id,
+      conversationId: llmRequestLogs.conversationId,
+      messageId: llmRequestLogs.messageId,
+      provider: llmRequestLogs.provider,
+      requestPayload: llmRequestLogs.requestPayload,
+      responsePayload: llmRequestLogs.responsePayload,
+      createdAt: llmRequestLogs.createdAt,
+      agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+      callSite: llmRequestLogs.callSite,
+    })
+    .from(llmRequestLogs)
+    .where(eq(llmRequestLogs.conversationId, conversationId))
+    .orderBy(asc(llmRequestLogs.createdAt), asc(llmRequestLogs.id))
+    .all();
+}
+
 /**
  * Find orphaned logs — logs whose `message_id` references a message that no
  * longer exists in the DB. These are left behind when intermediate assistant
@@ -214,6 +253,7 @@ function selectOrphanedLogsInRange(
       responsePayload: llmRequestLogs.responsePayload,
       createdAt: llmRequestLogs.createdAt,
       agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+      callSite: llmRequestLogs.callSite,
     })
     .from(llmRequestLogs)
     .leftJoin(messages, eq(llmRequestLogs.messageId, messages.id))
@@ -255,6 +295,7 @@ function selectUnlinkedLogsInRange(
       responsePayload: llmRequestLogs.responsePayload,
       createdAt: llmRequestLogs.createdAt,
       agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+      callSite: llmRequestLogs.callSite,
     })
     .from(llmRequestLogs)
     .where(
@@ -282,6 +323,7 @@ export function getRequestLogById(logId: string): LogRow | null {
         responsePayload: llmRequestLogs.responsePayload,
         createdAt: llmRequestLogs.createdAt,
         agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+      callSite: llmRequestLogs.callSite,
       })
       .from(llmRequestLogs)
       .where(eq(llmRequestLogs.id, logId))

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

@@ -57,6 +57,7 @@ export function recordUsageEvent(
       outputTokens: event.outputTokens,
       cacheCreationInputTokens: event.cacheCreationInputTokens,
       cacheReadInputTokens: event.cacheReadInputTokens,
+      rawUsage: event.rawUsage === null ? null : JSON.stringify(event.rawUsage),
       estimatedCostUsd: event.estimatedCostUsd,
       pricingStatus: event.pricingStatus,
       llmCallCount: event.llmCallCount ?? 1,
@@ -87,6 +88,7 @@ function rowToUsageEvent(row: {
   outputTokens: number;
   cacheCreationInputTokens: number | null;
   cacheReadInputTokens: number | null;
+  rawUsage: string | null;
   estimatedCostUsd: number | null;
   pricingStatus: string;
 }): UsageEvent {
@@ -107,11 +109,32 @@ function rowToUsageEvent(row: {
     outputTokens: row.outputTokens,
     cacheCreationInputTokens: row.cacheCreationInputTokens,
     cacheReadInputTokens: row.cacheReadInputTokens,
+    rawUsage: parseRawUsage(row.rawUsage),
     estimatedCostUsd: row.estimatedCostUsd,
     pricingStatus: row.pricingStatus as "priced" | "unpriced",
   };
 }
 
+/**
+ * Parse the JSON-serialized provider usage payload stored in `raw_usage`.
+ * Returns `null` for missing or malformed values; malformed JSON is logged
+ * and discarded rather than failing the read, because callers (admin
+ * dashboards, telemetry forwarders) treat `raw_usage` as opaque diagnostic
+ * data and shouldn't be blocked by a single corrupt row.
+ */
+function parseRawUsage(value: string | null): Record<string, unknown> | null {
+  if (value === null) return null;
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 export function listUsageEvents(options?: { limit?: number }): UsageEvent[] {
   const db = getDb();
   const rows = db
@@ -187,6 +210,7 @@ export function queryUnreportedUsageEvents(
       outputTokens: llmUsageEvents.outputTokens,
       cacheCreationInputTokens: llmUsageEvents.cacheCreationInputTokens,
       cacheReadInputTokens: llmUsageEvents.cacheReadInputTokens,
+      rawUsage: llmUsageEvents.rawUsage,
       estimatedCostUsd: llmUsageEvents.estimatedCostUsd,
       pricingStatus: llmUsageEvents.pricingStatus,
       conversationType: conversations.conversationType,

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

@@ -19,7 +19,10 @@ import {
 } from "../runtime/actor-trust-resolver.js";
 import { getLogger } from "../util/logger.js";
 import { getConversationSource } from "./conversation-crud.js";
-import { upsertMemoryRetrospectiveJob } from "./jobs-store.js";
+import {
+  isMemoryEnabled,
+  upsertMemoryRetrospectiveJob,
+} from "./jobs-store.js";
 import { MEMORY_RETROSPECTIVE_SOURCES } from "./memory-retrospective-constants.js";
 
 const log = getLogger("memory-retrospective-enqueue");
@@ -38,6 +41,10 @@ export function enqueueMemoryRetrospectiveIfEnabled(args: {
 }): void {
   const { conversationId, trigger } = args;
 
+  if (!isMemoryEnabled()) {
+    return;
+  }
+
   if (isMemoryRetrospectiveConversation(conversationId)) {
     log.debug(
       { conversationId, trigger },

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

@@ -208,6 +208,11 @@ async function runLegacyRetrospective(
       source: MEMORY_RETROSPECTIVE_SOURCE,
       trustContext: INTERNAL_GUARDIAN_TRUST_CONTEXT,
       callSite: "memoryRetrospective",
+      // 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
+      // scaffolding for the user. Suppress it, matching the fork-based path.
+      suppressWakeSurface: true,
     });
     wakeSucceeded = result.invoked;
     failureReason = result.reason;

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

@@ -115,11 +115,15 @@ export interface RecordMemoryV2ActivationLogParams {
    * `per-turn` for normal append injections, `errored` when `injectMemoryV2Block`
    * threw before completing — telemetry is still written so silent failures
    * are observable in the database, with whatever `concepts` rows had been
-   * built so far (possibly empty). `router` indicates the Sonnet
-   * router selected the per-turn page set; router-mode rows carry zeroed
-   * activation values and `source: "router"` on every concept row.
+   * built so far (possibly empty). `router` indicates the LLM router selected
+   * the per-turn page set; router-mode rows carry zeroed activation values and
+   * `source: "router"` on every concept row. `v3_shadow` is written by the
+   * live-shadow v3 retrieval middleware: it records v3's selection set for
+   * comparison without affecting injected context. The harness oracle filters
+   * `mode='router'`, so `v3_shadow` rows never pollute it; the inspector can
+   * still surface them.
    */
-  mode: "context-load" | "per-turn" | "errored" | "router";
+  mode: "context-load" | "per-turn" | "errored" | "router" | "v3_shadow";
   concepts: MemoryV2ConceptRowRecord[];
   config: MemoryV2ConfigSnapshot;
 }
@@ -167,7 +171,7 @@ export function backfillMemoryV2ActivationMessageId(
 export interface MemoryV2ActivationLog {
   conversationId: string;
   turn: number;
-  mode: "context-load" | "per-turn" | "errored" | "router";
+  mode: "context-load" | "per-turn" | "errored" | "router" | "v3_shadow";
   concepts: MemoryV2ConceptRowRecord[];
   config: MemoryV2ConfigSnapshot;
 }
@@ -188,7 +192,12 @@ export function getMemoryV2ActivationLogByMessageIds(
   return {
     conversationId: row.conversationId,
     turn: row.turn,
-    mode: row.mode as "context-load" | "per-turn" | "errored" | "router",
+    mode: row.mode as
+      | "context-load"
+      | "per-turn"
+      | "errored"
+      | "router"
+      | "v3_shadow",
     concepts: JSON.parse(row.conceptsJson) as MemoryV2ConceptRowRecord[],
     config: JSON.parse(row.configJson) as MemoryV2ConfigSnapshot,
   };

package/src/memory/migrations/260-rename-cleaned-at.ts

@@ -0,0 +1,44 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_rename_cleaned_at_v1";
+
+const OLD_COLUMN = "cleaned_at";
+const NEW_COLUMN = "history_stripped_at";
+
+/**
+ * Rename `conversations.cleaned_at` → `conversations.history_stripped_at`.
+ *
+ * The marker now records any injection-strip event (`/clean` or compaction),
+ * not just `/clean`. Renaming reflects the broader semantics; compaction
+ * sets it alongside its summary state instead of destructively wiping
+ * message metadata.
+ */
+export function migrateRenameCleanedAt(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (tableHasColumn(database, "conversations", NEW_COLUMN)) {
+      return;
+    }
+    if (!tableHasColumn(database, "conversations", OLD_COLUMN)) {
+      // 259 didn't run (fresh install on a newer schema where 259's column
+      // was added under the new name) — nothing to rename.
+      return;
+    }
+    database.run(
+      `ALTER TABLE conversations RENAME COLUMN ${OLD_COLUMN} TO ${NEW_COLUMN}`,
+    );
+  });
+}
+
+export function downRenameCleanedAt(database: DrizzleDb): void {
+  if (!tableHasColumn(database, "conversations", NEW_COLUMN)) {
+    return;
+  }
+  if (tableHasColumn(database, "conversations", OLD_COLUMN)) {
+    return;
+  }
+  database.run(
+    `ALTER TABLE conversations RENAME COLUMN ${NEW_COLUMN} TO ${OLD_COLUMN}`,
+  );
+}

package/src/memory/migrations/261-llm-usage-add-raw-usage.ts

@@ -0,0 +1,36 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_llm_usage_add_raw_usage_v1";
+
+const TABLE = "llm_usage_events";
+const COLUMN = "raw_usage";
+
+/**
+ * Add a `raw_usage` TEXT column to `llm_usage_events` for storing the
+ * provider's untouched `usage` block as JSON.
+ *
+ * The Anthropic API surfaces a TTL breakdown of cache writes
+ * (`usage.cache_creation.ephemeral_5m_input_tokens`,
+ * `usage.cache_creation.ephemeral_1h_input_tokens`); OpenAI surfaces
+ * nested `prompt_tokens_details` and `completion_tokens_details`; both
+ * are kept as opaque JSON so admin charts and downstream consumers can
+ * extract provider-specific detail without requiring a new column every
+ * time a provider adds a usage field. `NULL` for rows persisted before
+ * this migration ran and for providers that did not return a usage
+ * payload.
+ */
+export function migrateLlmUsageAddRawUsage(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (!tableHasColumn(database, TABLE, COLUMN)) {
+      database.run(`ALTER TABLE ${TABLE} ADD COLUMN ${COLUMN} TEXT`);
+    }
+  });
+}
+
+export function downLlmUsageAddRawUsage(database: DrizzleDb): void {
+  if (tableHasColumn(database, TABLE, COLUMN)) {
+    database.run(`ALTER TABLE ${TABLE} DROP COLUMN ${COLUMN}`);
+  }
+}

package/src/memory/migrations/262-memory-v3-coactivation.ts

@@ -0,0 +1,57 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_memory_v3_coactivation_v1";
+
+/**
+ * Create the memory_v3_coactivation table — an append-only log of
+ * pass-1 → pass-N co-activation pairs observed during a v3 retrieval loop.
+ *
+ * Each row records that a page (`target_slug`) first surfaced on a later
+ * descent pass was co-selected alongside a page (`source_slug`) that surfaced
+ * on pass 1, with `pass_gap` = passOf(target) − passOf(source). This is the
+ * raw gradient signal that edge-learning later reconciles into curated-graph
+ * edge weights: a source that repeatedly precedes a target across turns is a
+ * candidate association. `used` is the usefulness flag (0 here — the loop
+ * cannot know whether the target was actually load-bearing for the turn; a
+ * later edge-learning pass reconciles it).
+ *
+ * The table just accumulates raw events; the edge-learning formula or the
+ * decay/weighting can change later without losing signal.
+ *
+ * Indexes:
+ * - `(source_slug, target_slug)` for per-pair aggregation (the hot path for
+ *   edge-learning reads).
+ * - `(created_at)` for time-range pruning later.
+ */
+export function migrateMemoryV3Coactivation(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS memory_v3_coactivation (
+        id INTEGER PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        turn INTEGER NOT NULL,
+        source_slug TEXT NOT NULL,
+        target_slug TEXT NOT NULL,
+        pass_gap INTEGER NOT NULL,
+        used INTEGER NOT NULL,
+        created_at INTEGER NOT NULL
+      )
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_memory_v3_coactivation_pair
+        ON memory_v3_coactivation (source_slug, target_slug)
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_memory_v3_coactivation_time
+        ON memory_v3_coactivation (created_at)
+    `);
+  });
+}
+
+export function downMemoryV3Coactivation(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_v3_coactivation`);
+}

package/src/memory/migrations/263-memory-v3-auto-edges.ts

@@ -0,0 +1,50 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_memory_v3_auto_edges_v1";
+
+/**
+ * Create the memory_v3_auto_edges table — the **learned** edge graph, a
+ * distinct class from the curated `edges:` frontmatter graph.
+ *
+ * Each row is a weighted directed association `source_slug → target_slug` that
+ * the edge-learning job (`memory_v3_edge_learning`) accrues from *used*
+ * co-activations (migration 262's `memory_v3_coactivation` rows) and decays
+ * over time. `weight` is a multiplicatively-decaying real; `last_reinforced_at`
+ * is the wall-clock ms of the most recent reinforcement, used by the decay
+ * pass to compute elapsed time per pair.
+ *
+ * Auto-edges are advisory: the read path consumes only above-threshold pairs
+ * via edge-expansion's `extraAdjacency` seam, and high-weight pairs surface as
+ * promotion *candidates* for the assistant to ratify into curated `edges:`
+ * during consolidation. This table never auto-writes page frontmatter.
+ *
+ * `PRIMARY KEY(source_slug, target_slug)` makes each ordered pair unique, so
+ * reinforce is a single UPSERT. The index on `(weight)` keeps the
+ * above-threshold scan and top-N promotion-candidate read cheap as the learned
+ * graph grows.
+ */
+export function migrateMemoryV3AutoEdges(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS memory_v3_auto_edges (
+        source_slug TEXT NOT NULL,
+        target_slug TEXT NOT NULL,
+        weight REAL NOT NULL,
+        last_reinforced_at INTEGER NOT NULL,
+        PRIMARY KEY (source_slug, target_slug)
+      )
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_memory_v3_auto_edges_weight
+        ON memory_v3_auto_edges (weight)
+    `);
+  });
+}
+
+export function downMemoryV3AutoEdges(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_v3_auto_edges`);
+}

package/src/memory/migrations/264-llm-request-log-call-site.ts

@@ -0,0 +1,29 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Adds `call_site` (nullable TEXT) to the `llm_request_logs` table.
+ *
+ * Records the logical call site that produced the row — `mainAgent`,
+ * `compactionAgent`, etc. (string values from `LLMCallSite` in
+ * `config/schemas/llm.ts`). Lets the LLM Context Inspector and other
+ * observability tools filter "show me only compaction calls" without
+ * having to infer from request payload shape.
+ *
+ * No backfill — historical rows stay NULL ("we don't know"). New rows
+ * stamped at insertion time by callers of `recordRequestLog`.
+ *
+ * Idempotent — re-running is a no-op once the column exists. Modeled on
+ * migration 252 (`llm-request-log-agent-loop-exit-reason`).
+ */
+export function migrateLlmRequestLogCallSite(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  const columns = raw
+    .query(`PRAGMA table_info(llm_request_logs)`)
+    .all() as Array<{ name: string }>;
+  const columnNames = new Set(columns.map((c) => c.name));
+
+  if (!columnNames.has("call_site")) {
+    raw.exec(`ALTER TABLE llm_request_logs ADD COLUMN call_site TEXT`);
+  }
+}

package/src/memory/migrations/index.ts

@@ -234,6 +234,23 @@ export {
   downConversationCleanedAt,
   migrateConversationCleanedAt,
 } from "./259-conversation-cleaned-at.js";
+export {
+  downRenameCleanedAt,
+  migrateRenameCleanedAt,
+} from "./260-rename-cleaned-at.js";
+export {
+  downLlmUsageAddRawUsage,
+  migrateLlmUsageAddRawUsage,
+} from "./261-llm-usage-add-raw-usage.js";
+export {
+  downMemoryV3Coactivation,
+  migrateMemoryV3Coactivation,
+} from "./262-memory-v3-coactivation.js";
+export {
+  downMemoryV3AutoEdges,
+  migrateMemoryV3AutoEdges,
+} from "./263-memory-v3-auto-edges.js";
+export { migrateLlmRequestLogCallSite } from "./264-llm-request-log-call-site.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -53,6 +53,10 @@ import { downA2ATasks } from "./251-a2a-tasks.js";
 import { downExternalConversationBindingChatName } from "./254-external-conversation-binding-chat-name.js";
 import { downMemoryV2InjectionEvents } from "./256-memory-v2-injection-events.js";
 import { downConversationCleanedAt } from "./259-conversation-cleaned-at.js";
+import { downRenameCleanedAt } from "./260-rename-cleaned-at.js";
+import { downLlmUsageAddRawUsage } from "./261-llm-usage-add-raw-usage.js";
+import { downMemoryV3Coactivation } from "./262-memory-v3-coactivation.js";
+import { downMemoryV3AutoEdges } from "./263-memory-v3-auto-edges.js";
 
 export interface MigrationRegistryEntry {
   /** The checkpoint key written to memory_checkpoints on completion. */
@@ -453,6 +457,35 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
       "Add cleaned_at timestamp to conversations so /clean survives reload and forks inherit conditionally on fork point",
     down: downConversationCleanedAt,
   },
+  {
+    key: "migration_rename_cleaned_at_v1",
+    version: 53,
+    dependsOn: ["migration_conversation_cleaned_at_v1"],
+    description:
+      "Rename conversations.cleaned_at to history_stripped_at; the marker now records any injection-strip event (including compaction), not just /clean",
+    down: downRenameCleanedAt,
+  },
+  {
+    key: "migration_llm_usage_add_raw_usage_v1",
+    version: 54,
+    description:
+      "Add raw_usage TEXT column to llm_usage_events for storing the provider's untouched usage block as JSON (Anthropic TTL breakdown, OpenAI prompt/completion token details, etc.) so downstream consumers can extract provider-specific detail without per-field schema changes",
+    down: downLlmUsageAddRawUsage,
+  },
+  {
+    key: "migration_memory_v3_coactivation_v1",
+    version: 55,
+    description:
+      "Create memory_v3_coactivation table — append-only log of pass-1 → pass-N co-activation pairs (gradient signal) emitted by the v3 retrieval loop and reconciled later by edge-learning",
+    down: downMemoryV3Coactivation,
+  },
+  {
+    key: "migration_memory_v3_auto_edges_v1",
+    version: 56,
+    description:
+      "Create memory_v3_auto_edges table — weighted, decaying learned association graph (distinct from curated edges:) accrued by the edge-learning job from used co-activations and consumed above-threshold by edge expansion",
+    down: downMemoryV3AutoEdges,
+  },
 ];
 
 export function getMaxMigrationVersion(): number {

package/src/memory/schema/conversations.ts

@@ -21,7 +21,7 @@ export const conversations = sqliteTable(
       .notNull()
       .default(0),
     contextCompactedAt: integer("context_compacted_at"),
-    cleanedAt: integer("cleaned_at"),
+    historyStrippedAt: integer("history_stripped_at"),
     slackContextCompactionWatermarkTs: text(
       "slack_context_compaction_watermark_ts",
     ),

package/src/memory/schema/infrastructure.ts

@@ -138,6 +138,16 @@ export const llmRequestLogs = sqliteTable(
     responsePayload: text("response_payload").notNull(),
     createdAt: integer("created_at").notNull(),
     agentLoopExitReason: text("agent_loop_exit_reason"),
+    /**
+     * Logical call site that produced this row — e.g. `mainAgent`,
+     * `compactionAgent`. Stored as free-form text rather than enum-bound
+     * so a new call site can ship without a schema bump, but in practice
+     * callers pass values from `LLMCallSite` (`config/schemas/llm.ts`).
+     *
+     * Historical rows (pre-migration 264) stay NULL — "we don't know"
+     * rather than guessing `mainAgent`.
+     */
+    callSite: text("call_site"),
   },
   (table) => [
     index("idx_llm_request_logs_message_id").on(table.messageId),
@@ -217,6 +227,17 @@ export const llmUsageEvents = sqliteTable(
     outputTokens: integer("output_tokens").notNull(),
     cacheCreationInputTokens: integer("cache_creation_input_tokens"),
     cacheReadInputTokens: integer("cache_read_input_tokens"),
+    /**
+     * The provider's untouched `usage` block, serialized as JSON. Anthropic
+     * nests the TTL breakdown under `cache_creation.ephemeral_{5m,1h}_input_tokens`;
+     * OpenAI nests cached-read details under `prompt_tokens_details`; both are
+     * just preserved verbatim so admin charts and downstream consumers can
+     * extract whatever provider-specific detail they need without a schema
+     * change every time a provider exposes a new field. `null` when the
+     * provider didn't return a usage block or for rows persisted before
+     * migration 260.
+     */
+    rawUsage: text("raw_usage"),
     estimatedCostUsd: real("estimated_cost_usd"),
     pricingStatus: text("pricing_status").notNull(),
     llmCallCount: integer("llm_call_count"),

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

@@ -2,6 +2,7 @@ import { count, desc, lt } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getLogger } from "../util/logger.js";
+import { runAsyncSqlite } from "./db-async-query.js";
 import { getDb } from "./db-connection.js";
 import { toolInvocations } from "./schema.js";
 
@@ -47,25 +48,52 @@ export function getRecentInvocations(limit: number) {
 const log = getLogger("audit-log");
 
 /**
- * Delete tool invocation records older than the specified number of days.
- * Returns the number of deleted records. Does nothing if retentionDays is 0.
+ * Delete tool invocation records older than the specified number of
+ * days. Returns the number of deleted records. Does nothing if
+ * `retentionDays` is zero, negative, or non-finite.
+ *
+ * The DELETE runs through {@link runAsyncSqlite}: when the host has a
+ * `sqlite3` CLI it executes in a subprocess and the daemon's main
+ * event loop stays responsive. On hosts without the CLI the
+ * abstraction falls back to in-process blocking execution — the same
+ * behaviour the daemon had before this abstraction existed.
  */
-export function rotateToolInvocations(retentionDays: number): number {
-  if (retentionDays <= 0) return 0;
+export async function rotateToolInvocations(
+  retentionDays: number,
+): Promise<number> {
+  if (!Number.isFinite(retentionDays) || retentionDays <= 0) return 0;
 
-  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+  // Math.floor guarantees a plain integer literal in the inlined SQL
+  // below; no decimal, no exponent, no surprise characters.
+  const cutoffMs = Math.floor(
+    Date.now() - retentionDays * 24 * 60 * 60 * 1000,
+  );
   const db = getDb();
 
-  // Count before delete (Drizzle's .run() returns void on bun-sqlite)
+  // Count before delete so we can return + log the affected row count
+  // (`runAsyncSqlite` does not surface SQLite's `changes()` value).
   const [countRow] = db
     .select({ value: count() })
     .from(toolInvocations)
-    .where(lt(toolInvocations.createdAt, cutoff))
+    .where(lt(toolInvocations.createdAt, cutoffMs))
     .all();
   const toDelete = countRow?.value ?? 0;
   if (toDelete === 0) return 0;
 
-  db.delete(toolInvocations).where(lt(toolInvocations.createdAt, cutoff)).run();
+  // `runAsyncSqlite` takes a raw SQL string — sqlite3 CLI subprocesses
+  // see SQL on stdin without a binding layer. `cutoffMs` is a plain
+  // integer (see Math.floor above), so inlining it here is safe.
+  const result = await runAsyncSqlite(
+    `DELETE FROM tool_invocations WHERE created_at < ${cutoffMs}`,
+  );
+  if (!result.ok) {
+    log.error(
+      { error: result.error, backend: result.backend, toDelete },
+      "tool_invocations purge failed",
+    );
+    return 0;
+  }
+
   log.info(
     `Rotated ${toDelete} audit log entries older than ${retentionDays} day(s)`,
   );

package/src/memory/v2/__tests__/consolidation-job.test.ts

@@ -102,6 +102,7 @@ mock.module("../../jobs-store.js", () => ({
     nextJobIdCounter += 1;
     return `job-${nextJobIdCounter}`;
   },
+  isMemoryEnabled: () => true,
 }));
 
 // ── Workspace pin ───────────────────────────────────────────────────