@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/memory/graph/conversation-graph-memory.ts

@@ -12,6 +12,7 @@ import { z } from "zod";
 import type { AssistantConfig } from "../../config/types.js";
 import { estimateTextTokens } from "../../context/token-estimator.js";
 import type { ServerMessage } from "../../daemon/message-protocol.js";
+import { clearConversation as clearV3EverInjected } from "../../plugins/defaults/memory-v3-shadow/ever-injected-store.js";
 import type {
   ContentBlock,
   ImageContent,
@@ -284,6 +285,19 @@ export class ConversationGraphMemory {
       );
     }
 
+    // Memory-v3's frozen-card dedup record resets at the same trigger: the
+    // cached card blocks those slugs rode were just stripped by compaction, so
+    // every slug must become re-injectable. Cleared unconditionally for the
+    // same crash-drift reason as v2's `everInjected` above.
+    try {
+      clearV3EverInjected(this.conversationId);
+    } catch (err) {
+      log.warn(
+        { err: err instanceof Error ? err.message : String(err) },
+        "Failed to clear memory-v3 everInjected on compaction (non-fatal)",
+      );
+    }
+
     this.needsReload = true;
     log.info(
       { compactedMessageCount },
@@ -370,6 +384,22 @@ export class ConversationGraphMemory {
     return this.lastPkbSparseVector;
   }
 
+  /**
+   * The unwrapped text of the dynamic memory block the last retrieval
+   * injected (the v2 router block, or the v1 context block on legacy
+   * configs), or `null` when the last retrieval injected nothing.
+   *
+   * Runtime assembly reads this as the IDENTITY of the v2 dynamic `<memory>`
+   * block when memory-v3 supersedes the v2 layer: v2's block and v3's frozen
+   * card blocks deliberately share the same wrapper AND leading instruction
+   * header bytes, so the tail strip must match the exact block this handle
+   * prepended (`prepareMemory` → `injectTextBlock`, or a convergence
+   * re-injection of the same cached text) rather than any shared prefix.
+   */
+  get lastInjectedBlockText(): string | null {
+    return this.lastInjectedBlock;
+  }
+
   /**
    * Main entry point — called on every turn before the LLM sees the messages.
    *
@@ -432,7 +462,7 @@ export class ConversationGraphMemory {
       metrics: null as RetrievalMetrics | null,
     };
 
-    if (!config.memory.enabled) {
+    if (config.memory.enabled === false) {
       // Clear any cached injection so a later overflow-reduction
       // re-injection via `reinjectCachedMemory()` cannot reintroduce a
       // stale <memory> block after the user disables memory.
@@ -970,9 +1000,11 @@ export function stripExistingMemoryInjections(messages: Message[]): Message[] {
 /**
  * Strip the memory-injected prefix from a single user message. Returns the
  * same message reference unchanged when it is not a user message or carries no
- * injected prefix, so callers can cheaply detect no-ops. Shared by
- * `stripExistingMemoryInjections` (last message only) and
- * `stripAllMemoryInjections` (every user message).
+ * injected prefix, so callers can cheaply detect no-ops. Used by
+ * `stripExistingMemoryInjections` (last message only) — memory-v3's frozen
+ * card carry means historical `<memory>` blocks are never bulk-stripped
+ * anymore (the old whole-layer `stripAllMemoryInjections` is gone): runtime
+ * assembly strips only the TAIL's fresh v2 prefix when v3 supersedes it.
  */
 function stripMemoryPrefixFromUserMessage(message: Message): Message {
   if (message.role !== "user") return message;
@@ -981,27 +1013,6 @@ function stripMemoryPrefixFromUserMessage(message: Message): Message {
   return { ...message, content: message.content.slice(firstNonMemory) };
 }
 
-/**
- * Remove memory-injected blocks from EVERY user message, not just the last.
- *
- * memory-v3 live mode strips the injected `<memory>` block from all historical
- * user messages each turn: it keeps the prompt lean and makes history
- * byte-stable for prompt caching (v2 strips only the last user message — see
- * `stripExistingMemoryInjections`). Reuses the same per-message block
- * recognition as the last-message strip. Wired into the runtime-assembly
- * suppression step (`conversation-runtime-assembly.ts`), which calls it when
- * `memory-v3-live` is on and the v3 injector produced a block this turn.
- */
-export function stripAllMemoryInjections(messages: Message[]): Message[] {
-  let changed = false;
-  const result = messages.map((message) => {
-    const stripped = stripMemoryPrefixFromUserMessage(message);
-    if (stripped !== message) changed = true;
-    return stripped;
-  });
-  return changed ? result : messages;
-}
-
 /**
  * Return the memory-injected prefix blocks from the last user message, or
  * an empty array when there is none. Used by runtime assembly to carry the

package/src/memory/graph/tool-handlers.ts

@@ -40,6 +40,9 @@ export function handleRemember(
   if (!input.content || input.content.trim().length === 0) {
     return { success: false, message: "content is required" };
   }
+  if (config.memory.enabled === false) {
+    return { success: false, message: "Memory is disabled." };
+  }
 
   const workspaceDir = getWorkspaceDir();
   const now = new Date();

package/src/memory/job-handlers/cleanup.ts

@@ -164,7 +164,8 @@ function parseDeletedCount(stdout: string | undefined): number {
  * conversation_keys, channel_inbound_events, message_runs, call_sessions,
  * external_conversation_bindings, assistant_inbox_conversation_state) are handled
  * automatically. Tables without cascade (messages, tool_invocations,
- * llm_request_logs) are deleted explicitly before removing the conversation row.
+ * llm_request_logs, skill_loaded_events) are deleted explicitly before
+ * removing the conversation row.
  */
 export function pruneOldConversationsJob(
   job: MemoryJob,
@@ -206,6 +207,7 @@ export function pruneOldConversationsJob(
       rawRun(`DELETE FROM llm_request_logs WHERE conversation_id = ?`, id);
       rawRun(`DELETE FROM tool_invocations WHERE conversation_id = ?`, id);
       rawRun(`DELETE FROM messages WHERE conversation_id = ?`, id);
+      rawRun(`DELETE FROM skill_loaded_events WHERE conversation_id = ?`, id);
       // Conversation row deletion cascades to remaining dependent tables
       rawRun(`DELETE FROM conversations WHERE id = ?`, id);
       pruned++;

package/src/memory/jobs-store.ts

@@ -342,34 +342,6 @@ export function hasActiveJobOfType(type: MemoryJobType): boolean {
   );
 }
 
-export function isAutomaticConsolidationJob(job: MemoryJob): boolean {
-  return job.payload.trigger !== MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS.manual;
-}
-
-export function cancelPendingAutomaticConsolidationJobs(): number {
-  const db = getDb();
-  db.update(memoryJobs)
-    .set({
-      status: "failed",
-      lastError: "automatic_consolidation_disabled",
-      updatedAt: Date.now(),
-    })
-    .where(
-      and(
-        eq(memoryJobs.type, "memory_v2_consolidate"),
-        eq(memoryJobs.status, "pending"),
-        or(
-          sql`json_extract(${memoryJobs.payload}, '$.trigger') = ${MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS.automatic}`,
-          // Legacy rows predate trigger markers and are indistinguishable from
-          // automatic enqueues, so disabling the schedule treats them as auto.
-          sql`json_extract(${memoryJobs.payload}, '$.trigger') IS NULL`,
-        ),
-      ),
-    )
-    .run();
-  return rawChanges();
-}
-
 export function enqueuePruneOldLlmRequestLogsJob(retentionMs?: number): string {
   const db = getDb();
   const existing = db

package/src/memory/jobs-worker.ts

@@ -68,7 +68,6 @@ import {
   failMemoryJob,
   failStalledJobs,
   hasActiveJobOfType,
-  isAutomaticConsolidationJob,
   MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS,
   type MemoryJob,
   type MemoryJobType,
@@ -242,7 +241,7 @@ export async function runMemoryJobsOnce(
   options: { enableScheduledCleanup?: boolean } = {},
 ): Promise<number> {
   const config = getConfig();
-  if (!config.memory.enabled) return 0;
+  if (config.memory.enabled === false) return 0;
   const enableScheduledCleanup = options.enableScheduledCleanup === true;
 
   const diskPressureGate = checkDiskPressureBackgroundGate("background-work");
@@ -625,16 +624,6 @@ async function processJob(
       await memoryV2SweepJob(job, config);
       return;
     case "memory_v2_consolidate":
-      if (
-        isAutomaticConsolidationJob(job) &&
-        !config.memory.v2.consolidation_enabled
-      ) {
-        log.info(
-          { jobId: job.id },
-          "Skipping automatic memory v2 consolidation because scheduled consolidation is disabled",
-        );
-        return;
-      }
       await memoryV2ConsolidateJob(job, config);
       return;
     case "memory_v2_migrate":
@@ -713,8 +702,8 @@ const GRAPH_PATTERN_SCAN_INTERVAL_MS = 24 * 60 * 60 * 1000; // 1 day
 const GRAPH_NARRATIVE_INTERVAL_MS = 7 * 24 * 60 * 60 * 1000; // 1 week
 // Backstop cadence for v3 self-maintenance. The primary trigger is the
 // post-consolidation follow-up (see `consolidation-job.ts`); this interval only
-// covers the case where that follow-up is missed (enqueue failure, or a v3-on
-// install with v2 consolidation disabled). A conservative cadence is fine since
+// covers the case where that follow-up is missed (enqueue failure). A
+// conservative cadence is fine since
 // the maintenance pass is idempotent and cheap when there's nothing to do.
 const GRAPH_V3_MAINTAIN_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
 
@@ -759,9 +748,10 @@ export function maybeEnqueueGraphMaintenanceJobs(
   config: AssistantConfig,
   nowMs = Date.now(),
 ): void {
+  const memoryEnabled = config.memory.enabled !== false;
+  if (!memoryEnabled) return;
+
   const v2Active = config.memory.v2.enabled;
-  const v2ConsolidationAutomaticEnabled =
-    v2Active && config.memory.v2.consolidation_enabled;
 
   // The single buffer-drainer entry for the v2-active branch. Referenced again
   // below by the size-based trigger.
@@ -776,9 +766,7 @@ export function maybeEnqueueGraphMaintenanceJobs(
     intervalMs: number;
     jobType: MemoryJobType;
   }> = v2Active
-    ? v2ConsolidationAutomaticEnabled
-      ? [consolidateEntry]
-      : []
+    ? [consolidateEntry]
     : [
         {
           key: GRAPH_MAINTENANCE_CHECKPOINTS.decay,
@@ -807,8 +795,8 @@ export function maybeEnqueueGraphMaintenanceJobs(
   // runs under either branch. Gated on the same flags that gate the v3 plugin
   // so it stays inert when v3 is off. The post-consolidation follow-up in
   // `consolidation-job.ts` remains the primary trigger; this interval only
-  // self-heals when that follow-up is missed (failed enqueue, or v3-on with v2
-  // consolidation disabled). The job handler itself no-ops when v3 is off, so
+  // self-heals when that follow-up is missed (failed enqueue). The job handler
+  // itself no-ops when v3 is off, so
   // this guard is belt-and-suspenders that also avoids a wasted enqueue.
   if (
     isAssistantFeatureFlagEnabled("memory-v3-shadow", config) ||
@@ -859,7 +847,7 @@ export function maybeEnqueueGraphMaintenanceJobs(
   // buffer stays over threshold, flooding the queue with redundant LLM work.
   const maxLines = config.memory.v2.consolidation_max_buffer_lines;
   if (
-    v2ConsolidationAutomaticEnabled &&
+    v2Active &&
     !enqueuedConsolidate &&
     maxLines !== null &&
     !hasActiveJobOfType(consolidateEntry.jobType)

package/src/memory/memory-marker.ts

@@ -15,3 +15,32 @@
 export function wrapMemoryBlock(text: string): string {
   return `<memory>\n${text}\n</memory>`;
 }
+
+/**
+ * Inverse of {@link wrapMemoryBlock}: recover the inner text from a wrapped
+ * block. Only unwraps when the full `<memory>\n…\n</memory>` pair is present,
+ * so payloads that merely start with the opening tag pass through unchanged —
+ * the same defensive guard the metadata rehydration in
+ * `daemon/conversation.ts` applies.
+ */
+export function unwrapMemoryBlock(block: string): string {
+  return block.startsWith("<memory>\n") && block.endsWith("\n</memory>")
+    ? block.slice("<memory>\n".length, -"\n</memory>".length)
+    : block;
+}
+
+/**
+ * The memory-v3 ephemeral spotlight wrapper. Unlike `<memory>` card blocks
+ * (frozen into history), the spotlight block is re-rendered onto the current
+ * user tail every turn: the per-turn scoped strip in
+ * `context/strip-injections.ts` (`stripSpotlightInjections`) and the
+ * compaction matcher in `RUNTIME_INJECTION_PREFIXES` both key off this exact
+ * prefix/suffix pair, so the producer wrapper lives here beside the `<memory>`
+ * marker it parallels.
+ */
+export const MEMORY_SPOTLIGHT_PREFIX = "<memory_spotlight>\n";
+export const MEMORY_SPOTLIGHT_SUFFIX = "\n</memory_spotlight>";
+
+export function wrapMemorySpotlightBlock(text: string): string {
+  return `${MEMORY_SPOTLIGHT_PREFIX}${text}${MEMORY_SPOTLIGHT_SUFFIX}`;
+}

package/src/memory/memory-retrospective-startup-cleanup.ts

@@ -93,7 +93,7 @@ export function sweepOrphanMemoryRetrospectiveConversations(
   // Compute the most-recent retro per source so we can preserve it.
   // `findMostRecentRetrospectiveFor` (called by the next retrospective run)
   // pulls dedup context from this row; sweeping it would re-introduce the
-  // unbounded-growth bug PR #30331 was created to fix.
+  // unbounded retrospective growth this cleanup exists to prevent.
   const allRetros = db
     .select({
       id: conversations.id,

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

@@ -6,6 +6,12 @@ import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
  * tagged with the lane (`source`) that produced it. `pinned` marks slugs
  * carried forward across turns rather than re-selected cold.
  *
+ * HISTORICAL NOTE: the working-set carry this table originally backed was
+ * removed (selections are current-turn only now; cross-turn persistence lives
+ * in the injector's frozen net-new blocks). The table itself is still live —
+ * the shadow plugin logs per-turn selections to it and the inspector /
+ * `summarizeSelections` read from it.
+ *
  * Idempotent — re-running is a no-op once the table and index exist.
  */
 export function migrateAddMemoryV3Selections(database: DrizzleDb): void {

package/src/memory/migrations/270-schedule-description.ts

@@ -0,0 +1,36 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_schedule_description_backfill_v1";
+
+export function migrateScheduleDescription(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  try {
+    raw.exec(
+      `ALTER TABLE cron_jobs ADD COLUMN description TEXT NOT NULL DEFAULT ''`,
+    );
+  } catch {
+    // Column already exists.
+  }
+
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    raw
+      .query(
+        `UPDATE cron_jobs
+         SET description = name
+         WHERE created_by <> 'defer' AND description = ''`,
+      )
+      .run();
+  });
+}
+
+export function downScheduleDescription(): void {
+  // Append-only schema migration; the column and backfill are intentionally kept.
+}

package/src/memory/migrations/275-tool-invocations-add-skill-id.test.ts

@@ -0,0 +1,81 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateToolInvocationsSkillId } from "./275-tool-invocations-add-skill-id.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  // Pre-275 shape: no skill_id column.
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE tool_invocations (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL,
+      tool_name TEXT NOT NULL,
+      input TEXT NOT NULL,
+      result TEXT NOT NULL,
+      decision TEXT NOT NULL,
+      risk_level TEXT NOT NULL,
+      matched_trust_rule_id TEXT,
+      duration_ms INTEGER NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function columnNames(sqlite: Database): string[] {
+  return (
+    sqlite.query("PRAGMA table_info(tool_invocations)").all() as Array<{
+      name: string;
+    }>
+  ).map((c) => c.name);
+}
+
+describe("migration 275: tool_invocations skill_id", () => {
+  test("adds a nullable skill_id column", () => {
+    const { sqlite, db } = createTestDb();
+    expect(columnNames(sqlite)).not.toContain("skill_id");
+
+    migrateToolInvocationsSkillId(db);
+
+    const column = (
+      sqlite.query("PRAGMA table_info(tool_invocations)").all() as Array<{
+        name: string;
+        notnull: number;
+      }>
+    ).find((c) => c.name === "skill_id");
+    expect(column).toBeDefined();
+    expect(column?.notnull).toBe(0);
+  });
+
+  test("existing rows read back with skill_id null", () => {
+    const { sqlite, db } = createTestDb();
+    sqlite.exec(/*sql*/ `
+      INSERT INTO tool_invocations
+        (id, conversation_id, tool_name, input, result, decision, risk_level, duration_ms, created_at)
+      VALUES
+        ('ti-1', 'conv-1', 'bash', '{}', 'ok', 'allow', 'low', 5, 1000)
+    `);
+
+    migrateToolInvocationsSkillId(db);
+
+    const row = sqlite
+      .query("SELECT skill_id FROM tool_invocations WHERE id = 'ti-1'")
+      .get() as { skill_id: string | null };
+    expect(row.skill_id).toBeNull();
+  });
+
+  test("is idempotent — re-run is a no-op", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateToolInvocationsSkillId(db);
+    expect(() => migrateToolInvocationsSkillId(db)).not.toThrow();
+
+    expect(
+      columnNames(sqlite).filter((name) => name === "skill_id"),
+    ).toHaveLength(1);
+  });
+});

package/src/memory/migrations/275-tool-invocations-add-skill-id.ts

@@ -0,0 +1,20 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+
+/**
+ * Add a nullable `skill_id` column to `tool_invocations`.
+ *
+ * Records which skill's `skill_execute` dispatch triggered the tool call so
+ * the `tool_execution` telemetry event can attribute skill-routed
+ * invocations. `NULL` for direct (non-skill) tool calls and for rows
+ * persisted before this migration ran.
+ *
+ * Idempotent — re-running is a no-op once the column exists. Pure DDL with a
+ * PRAGMA guard, no registry entry needed (matches the 273 pattern).
+ */
+export function migrateToolInvocationsSkillId(database: DrizzleDb): void {
+  if (tableHasColumn(database, "tool_invocations", "skill_id")) {
+    return;
+  }
+  database.run(`ALTER TABLE tool_invocations ADD COLUMN skill_id TEXT`);
+}

package/src/memory/migrations/276-tool-invocations-created-at-id-index.test.ts

@@ -0,0 +1,68 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateToolInvocationsCreatedAtIdIndex } from "./276-tool-invocations-created-at-id-index.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  // Pre-276 shape: no (created_at, id) index.
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE tool_invocations (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL,
+      tool_name TEXT NOT NULL,
+      input TEXT NOT NULL,
+      result TEXT NOT NULL,
+      decision TEXT NOT NULL,
+      risk_level TEXT NOT NULL,
+      matched_trust_rule_id TEXT,
+      skill_id TEXT,
+      duration_ms INTEGER NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function indexNames(sqlite: Database): string[] {
+  return (
+    sqlite.query("PRAGMA index_list(tool_invocations)").all() as Array<{
+      name: string;
+    }>
+  ).map((i) => i.name);
+}
+
+describe("migration 276: tool_invocations (created_at, id) index", () => {
+  test("creates the index on (created_at, id)", () => {
+    const { sqlite, db } = createTestDb();
+    expect(indexNames(sqlite)).not.toContain(
+      "idx_tool_invocations_created_at_id",
+    );
+
+    migrateToolInvocationsCreatedAtIdIndex(db);
+
+    expect(indexNames(sqlite)).toContain("idx_tool_invocations_created_at_id");
+    const columns = (
+      sqlite
+        .query("PRAGMA index_info(idx_tool_invocations_created_at_id)")
+        .all() as Array<{ name: string }>
+    ).map((c) => c.name);
+    expect(columns).toEqual(["created_at", "id"]);
+  });
+
+  test("is idempotent — re-run is a no-op", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateToolInvocationsCreatedAtIdIndex(db);
+    expect(() => migrateToolInvocationsCreatedAtIdIndex(db)).not.toThrow();
+
+    expect(
+      indexNames(sqlite).filter(
+        (name) => name === "idx_tool_invocations_created_at_id",
+      ),
+    ).toHaveLength(1);
+  });
+});

package/src/memory/migrations/276-tool-invocations-created-at-id-index.ts

@@ -0,0 +1,20 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+/**
+ * Indexes `tool_invocations(created_at, id)` so the tool_execution telemetry
+ * cursor can seek to the next unreported batch instead of scanning the table.
+ *
+ * `queryUnreportedToolExecutionEvents` filters and orders by `(created_at, id)`
+ * every telemetry flush (~5 min); without this index each flush scans and
+ * sorts the whole audit table, which grows unboundedly by default and carries
+ * large `input`/`result` text blobs.
+ *
+ * Idempotent — `CREATE INDEX IF NOT EXISTS` is a no-op once the index exists.
+ */
+export function migrateToolInvocationsCreatedAtIdIndex(
+  database: DrizzleDb,
+): void {
+  database.run(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_tool_invocations_created_at_id ON tool_invocations (created_at, id)`,
+  );
+}

package/src/memory/migrations/277-add-memory-v3-ever-injected.ts

@@ -0,0 +1,29 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Adds `memory_v3_ever_injected` for memory-v3's frozen-card carry: one row
+ * per (conversation, page-slug) the v3 injector ever attached as a card.
+ * `bytes` is the rendered card size used for resident-footprint accounting;
+ * `pruned_at` marks rows the prune valve removed from the live context (rows
+ * are never deleted — the record stays auditable, and a pruned page that is
+ * re-selected re-injects by clearing `pruned_at`).
+ *
+ * Idempotent — re-running is a no-op once the table and index exist.
+ */
+export function migrateAddMemoryV3EverInjected(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_v3_ever_injected (
+      conversation_id TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      injected_at INTEGER NOT NULL,
+      bytes INTEGER NOT NULL DEFAULT 0,
+      pruned_at INTEGER,
+      PRIMARY KEY (conversation_id, slug)
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_v3_ever_injected_conv
+      ON memory_v3_ever_injected (conversation_id)
+  `);
+}

package/src/memory/migrations/278-tool-invocations-telemetry-columns.test.ts

@@ -0,0 +1,96 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateToolInvocationsTelemetryColumns } from "./278-tool-invocations-telemetry-columns.js";
+
+const NEW_COLUMNS = [
+  "arg_bytes",
+  "result_bytes",
+  "provider",
+  "model",
+  "inference_profile",
+  "inference_profile_source",
+];
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  // Pre-278 shape: skill_id exists (275), telemetry columns do not.
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE tool_invocations (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL,
+      tool_name TEXT NOT NULL,
+      input TEXT NOT NULL,
+      result TEXT NOT NULL,
+      decision TEXT NOT NULL,
+      risk_level TEXT NOT NULL,
+      matched_trust_rule_id TEXT,
+      duration_ms INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      skill_id TEXT
+    )
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function tableInfo(sqlite: Database) {
+  return sqlite.query("PRAGMA table_info(tool_invocations)").all() as Array<{
+    name: string;
+    notnull: number;
+  }>;
+}
+
+describe("migration 278: tool_invocations telemetry columns", () => {
+  test("adds the nullable telemetry columns", () => {
+    const { sqlite, db } = createTestDb();
+    const before = tableInfo(sqlite).map((c) => c.name);
+    for (const name of NEW_COLUMNS) {
+      expect(before).not.toContain(name);
+    }
+
+    migrateToolInvocationsTelemetryColumns(db);
+
+    const after = tableInfo(sqlite);
+    for (const name of NEW_COLUMNS) {
+      const column = after.find((c) => c.name === name);
+      expect(column).toBeDefined();
+      expect(column?.notnull).toBe(0);
+    }
+  });
+
+  test("existing rows read back with null telemetry columns", () => {
+    const { sqlite, db } = createTestDb();
+    sqlite.exec(/*sql*/ `
+      INSERT INTO tool_invocations
+        (id, conversation_id, tool_name, input, result, decision, risk_level, duration_ms, created_at)
+      VALUES
+        ('ti-1', 'conv-1', 'bash', '{}', 'ok', 'allow', 'low', 5, 1000)
+    `);
+
+    migrateToolInvocationsTelemetryColumns(db);
+
+    const row = sqlite
+      .query(
+        `SELECT ${NEW_COLUMNS.join(", ")} FROM tool_invocations WHERE id = 'ti-1'`,
+      )
+      .get() as Record<string, unknown>;
+    for (const name of NEW_COLUMNS) {
+      expect(row[name]).toBeNull();
+    }
+  });
+
+  test("is idempotent — re-run is a no-op", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateToolInvocationsTelemetryColumns(db);
+    expect(() => migrateToolInvocationsTelemetryColumns(db)).not.toThrow();
+
+    const names = tableInfo(sqlite).map((c) => c.name);
+    for (const name of NEW_COLUMNS) {
+      expect(names.filter((n) => n === name)).toHaveLength(1);
+    }
+  });
+});