@mycadet/assistant 0.12.9 → 0.12.10

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

@@ -1,7 +1,6 @@
-import { and, asc, desc, eq, gt, or, sql } from "drizzle-orm";
+import { desc, eq } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getTelemetryMainDb } from "../telemetry/telemetry-main-db.js";
 import type {
   PricingResult,
   UsageEvent,
@@ -10,10 +9,7 @@ import type {
 import { APP_VERSION } from "../version.js";
 import { getDb } from "./db-connection.js";
 import { rawAll } from "./raw-query.js";
-import {
-  realUserTurnContentFilter,
-  realUserTurnContentFilterSql,
-} from "./real-user-turn-filter.js";
+import { realUserTurnContentFilterSql } from "./real-user-turn-filter.js";
 import {
   buildScheduleAttributionSubquery,
   buildScheduleRunWindowExists,
@@ -211,229 +207,6 @@ export function listUsageEvents(options?: { limit?: number }): UsageEvent[] {
   return rows.map(rowToUsageEvent);
 }
 
-/**
- * Telemetry-flavoured `UsageEvent`: the persisted columns plus the two
- * JOIN-computed conversation-level fields the reporter needs to emit
- * for analytics (`avg turns per conversation`, `tokens on first turn`,
- * foreground/background split on llm_usage rows themselves).
- *
- * Lives next to the query that produces it so the shape stays in lockstep
- * with the SELECT; broader `UsageEvent` consumers stay untouched.
- */
-export interface UnreportedUsageEvent extends UsageEvent {
-  /**
-   * Type of the parent conversation (`"standard"` / `"background"` /
-   * `"scheduled"`). Sourced from the value captured at record time
-   * (survives deletion of the parent conversation before flush), with a
-   * JOIN to `conversations` as the fallback for rows persisted before
-   * migration 353. Null when the LLM call has no `conversationId`
-   * (memory consolidation, background embedding work, etc.).
-   */
-  conversationType: string | null;
-  /**
-   * 1-indexed position of the user turn this LLM call belongs to within
-   * the parent conversation, counting only real user turns (tool-result
-   * rows persisted with role="user" are excluded — same filter as the
-   * turn-event eligibility predicate). Computed as the count of user
-   * messages with `created_at <= this LLM call's created_at` in the
-   * parent conversation. Null when there's no parent conversation, or
-   * when the LLM call fired before any user turn (rare — covers seed
-   * agent starts).
-   */
-  turnIndex: number | null;
-  /**
-   * Id of the conversation that spawned this LLM call's conversation:
-   * `parent_conversation_id` (subagent spawns), falling back to
-   * `fork_parent_conversation_id` for background forks (retrospectives).
-   * User-initiated forks are excluded — they are standard conversations
-   * whose usage belongs to themselves. Null when the conversation was
-   * not spawned by another conversation, or when the LLM call has no
-   * `conversationId` at all.
-   */
-  parentConversationId: string | null;
-  /**
-   * 1-indexed position of the parent-conversation user turn this LLM
-   * call's conversation branched from. Computed as the count of real user
-   * turns in the parent conversation (same eligibility filter as
-   * `turnIndex`) up to the child conversation's creation for subagent
-   * spawns, or up to the fork boundary message for retrospective forks
-   * (which can fork from a turn much earlier than their creation time).
-   * Null when there's no parent conversation.
-   */
-  parentTurnIndex: number | null;
-  /**
-   * Role of the subagent that owns this LLM call's conversation, from
-   * `SUBAGENT_ROLE_REGISTRY`. Null for every LLM call that did not run inside
-   * a subagent conversation, and for subagent conversations created before
-   * migration 362 whose `subagents` row had already been disposed.
-   */
-  subagentRole: string | null;
-  /**
-   * How that subagent was spawned, one of the modes described on
-   * `SubagentSpawnMode` in `subagent/types.ts`. Orthogonal to `subagentRole`:
-   * the role selects the child's capabilities, the spawn mode selects its
-   * context inheritance and lifecycle. Null under the same conditions as
-   * `subagentRole`.
-   */
-  subagentSpawnMode: string | null;
-}
-
-export function queryUnreportedUsageEvents(
-  afterCreatedAt: number,
-  afterId: string | undefined,
-  limit: number,
-): UnreportedUsageEvent[] {
-  const db = getTelemetryMainDb();
-  // Spawn linkage: `parent_conversation_id` (subagent spawns) with a
-  // fallback to `fork_parent_conversation_id` (retrospective forks — one
-  // hop up the fork chain is the intended attribution). The fallback is
-  // gated to background conversations: user-initiated forks also stamp
-  // `fork_parent_conversation_id` but are first-class standard
-  // conversations whose usage belongs to themselves, not the source turn.
-  // Null when the LEFT JOIN below misses or the conversation has no
-  // parent.
-  const parentIdSql = sql<string | null>`COALESCE(
-    ${conversations.parentConversationId},
-    CASE WHEN ${conversations.conversationType} = 'background'
-      THEN ${conversations.forkParentConversationId}
-    END
-  )`;
-  // Cutoff for the parent-turn count. Subagent spawns attribute to the
-  // parent turn in flight at child creation. Retrospective forks can
-  // branch from a turn far earlier than the fork's creation time, so
-  // they anchor on the fork boundary message instead; child creation is
-  // the fallback when the boundary message is absent.
-  // The turn-index subqueries below count user-role rows only. User rows are
-  // always written finalized (only assistant turns stream), so no completeness
-  // predicate is needed; do not copy this shape for assistant-row counts.
-  const parentTurnCutoffSql = sql<number>`CASE
-    WHEN ${conversations.parentConversationId} IS NOT NULL THEN ${conversations.createdAt}
-    ELSE COALESCE(
-      (SELECT mb.created_at FROM messages AS mb
-        WHERE mb.id = ${conversations.forkParentMessageId}),
-      ${conversations.createdAt}
-    )
-  END`;
-  // `conversationType` prefers the value stamped on the row at record
-  // time (migration 353) — the parent conversation may have been deleted
-  // before this flush (retrospective fork GC, user deletion) — and falls
-  // back to a LEFT JOIN against `conversations` for pre-353 rows. LEFT
-  // JOIN because `llm_usage_events.conversationId` is nullable — calls
-  // that aren't tied to a conversation (memory consolidation, etc.)
-  // still need to flush through telemetry.
-  //
-  // `turnIndex` is a correlated subquery counting real user turns in
-  // the same conversation up to and including this LLM call's
-  // `created_at`. The filter mirrors `queryUnreportedTurnEvents` so the
-  // two indexes stay aligned: an LLM call fired during processing of
-  // turn N reports `turn_index = N`, matching what the turn event
-  // stream emitted for the triggering user message.
-  const rows = db
-    .select({
-      id: llmUsageEvents.id,
-      createdAt: llmUsageEvents.createdAt,
-      conversationId: llmUsageEvents.conversationId,
-      runId: llmUsageEvents.runId,
-      cronRunId: llmUsageEvents.cronRunId,
-      requestId: llmUsageEvents.requestId,
-      actor: llmUsageEvents.actor,
-      callSite: llmUsageEvents.callSite,
-      inferenceProfile: llmUsageEvents.inferenceProfile,
-      inferenceProfileSource: llmUsageEvents.inferenceProfileSource,
-      provider: llmUsageEvents.provider,
-      model: llmUsageEvents.model,
-      inputTokens: llmUsageEvents.inputTokens,
-      outputTokens: llmUsageEvents.outputTokens,
-      cacheCreationInputTokens: llmUsageEvents.cacheCreationInputTokens,
-      cacheReadInputTokens: llmUsageEvents.cacheReadInputTokens,
-      rawUsage: llmUsageEvents.rawUsage,
-      estimatedCostUsd: llmUsageEvents.estimatedCostUsd,
-      pricingStatus: llmUsageEvents.pricingStatus,
-      assistantVersion: llmUsageEvents.assistantVersion,
-      llmCallCount: llmUsageEvents.llmCallCount,
-      conversationType: sql<
-        string | null
-      >`COALESCE(${llmUsageEvents.conversationType}, ${conversations.conversationType})`.as(
-        "resolved_conversation_type",
-      ),
-      // Null when conversationId is null (no parent conversation).
-      // Otherwise the count of eligible user turns up to and including
-      // this LLM call's createdAt. The COALESCE guard returns null
-      // (rather than 0) for the "no user turn yet" edge case so the
-      // analytics layer can distinguish "before-first-turn" LLM calls.
-      turnIndex: sql<number | null>`(
-        CASE WHEN ${llmUsageEvents.conversationId} IS NULL THEN NULL
-        ELSE (
-          SELECT COUNT(*) FROM messages AS m2
-          WHERE m2.conversation_id = ${llmUsageEvents.conversationId}
-            AND m2.role = 'user'
-            AND ${realUserTurnContentFilter("m2")}
-            AND m2.created_at <= ${llmUsageEvents.createdAt}
-        )
-        END
-      )`.as("turn_index"),
-      parentConversationId: parentIdSql.as("parent_conversation_id"),
-      // The parent turn this child conversation branched from: count of
-      // the PARENT conversation's real user turns with `created_at <=`
-      // the cutoff (child creation for subagent spawns, fork boundary
-      // message for retrospective forks). Same eligibility filter as
-      // `turnIndex` above.
-      // Stamped on the conversation row at spawn (migration 362) rather than
-      // joined from `subagents`, whose rows are deleted on dispose while this
-      // watermark query can trail far behind after an ingest outage.
-      subagentRole: conversations.subagentRole,
-      subagentSpawnMode: conversations.subagentSpawnMode,
-      parentTurnIndex: sql<number | null>`(
-        CASE WHEN ${parentIdSql} IS NULL THEN NULL
-        ELSE (
-          SELECT COUNT(*) FROM messages AS m3
-          WHERE m3.conversation_id = ${parentIdSql}
-            AND m3.role = 'user'
-            AND ${realUserTurnContentFilter("m3")}
-            AND m3.created_at <= ${parentTurnCutoffSql}
-        )
-        END
-      )`.as("parent_turn_index"),
-    })
-    .from(llmUsageEvents)
-    .leftJoin(
-      conversations,
-      eq(llmUsageEvents.conversationId, conversations.id),
-    )
-    .where(
-      afterId
-        ? or(
-            gt(llmUsageEvents.createdAt, afterCreatedAt),
-            and(
-              eq(llmUsageEvents.createdAt, afterCreatedAt),
-              gt(llmUsageEvents.id, afterId),
-            ),
-          )
-        : gt(llmUsageEvents.createdAt, afterCreatedAt),
-    )
-    .orderBy(asc(llmUsageEvents.createdAt), asc(llmUsageEvents.id))
-    .limit(limit)
-    .all();
-  return rows.map((row) => ({
-    ...rowToUsageEvent(row),
-    conversationType: row.conversationType,
-    // SQLite returns COUNT(*) as 0 when no rows match; the CASE in the
-    // subquery already collapses the no-conversation case to NULL.
-    // Convert the integer column to `number | null` for the typed
-    // return value.
-    turnIndex: row.turnIndex === null ? null : Number(row.turnIndex),
-    parentConversationId: row.parentConversationId,
-    parentTurnIndex:
-      row.parentTurnIndex === null ? null : Number(row.parentTurnIndex),
-    subagentRole: row.subagentRole,
-    subagentSpawnMode: row.subagentSpawnMode,
-  }));
-}
-
-// ---------------------------------------------------------------------------
-// Aggregation — time-range queries for the usage dashboard
-// ---------------------------------------------------------------------------
-
 export type UsageAggregationFilter = ScheduleAttributionFilter;
 
 /** Aggregate totals across a time range. */

package/src/persistence/message-content-file.ts

@@ -34,8 +34,8 @@ import { z } from "zod";
 
 import { contentBlockSchema } from "../providers/content-block-schema.js";
 import type { ContentBlock } from "../providers/types.js";
+import { getWorkspaceDir } from "../util/layout.js";
 import { getLogger } from "../util/logger.js";
-import { getWorkspaceDir } from "../util/platform.js";
 
 const log = getLogger("message-content-file");
 

package/src/persistence/migrations/209-strip-thinking-from-consolidated.ts

@@ -1,6 +1,6 @@
 import { getConfig } from "../../config/loader.js";
+import { getDbPath } from "../../util/layout.js";
 import { getLogger } from "../../util/logger.js";
-import { getDbPath } from "../../util/platform.js";
 import { runAsyncSqlite } from "../db-async-query.js";
 import type { DrizzleDb } from "../db-connection.js";
 import { getSqliteFrom } from "../db-connection.js";

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

@@ -3,8 +3,8 @@ import {
   PLACEHOLDER_BLOCKS_OMITTED,
   PLACEHOLDER_EMPTY_TURN,
 } from "../../providers/placeholder-sentinels.js";
+import { getDbPath } from "../../util/layout.js";
 import { getLogger } from "../../util/logger.js";
-import { getDbPath } from "../../util/platform.js";
 import { runAsyncSqlite } from "../db-async-query.js";
 import type { DrizzleDb } from "../db-connection.js";
 import { getSqliteFrom } from "../db-connection.js";

package/src/persistence/migrations/296-rewrite-balanced-economy-profile-pins.test.ts

@@ -4,7 +4,7 @@ import { afterEach, describe, expect, test } from "bun:test";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
-import { getWorkspaceConfigPath } from "../../util/platform.js";
+import { getWorkspaceConfigPath } from "../../util/layout.js";
 import * as schema from "../schema.js";
 import { migrateRewriteBalancedEconomyProfilePins } from "./296-rewrite-balanced-economy-profile-pins.js";
 

package/src/persistence/migrations/306-rewrite-frontier-profile-pins.test.ts

@@ -4,7 +4,7 @@ import { afterEach, describe, expect, test } from "bun:test";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
-import { getWorkspaceConfigPath } from "../../util/platform.js";
+import { getWorkspaceConfigPath } from "../../util/layout.js";
 import * as schema from "../schema.js";
 import { migrateRewriteFrontierProfilePins } from "./306-rewrite-frontier-profile-pins.js";
 

package/src/persistence/migrations/329-move-onboarding-events-to-telemetry-db.test.ts

@@ -23,6 +23,19 @@ const { migrateBackfillTelemetryEventsOutbox } =
 
 await initializeDb();
 
+// Migration 387 (the usage-telemetry removal) deletes the telemetry DB file
+// at the end of the chain, so after `initializeDb()` the telemetry-side
+// schema no longer exists. These tests drive the move + backfill steps
+// directly, so re-create the two tables they touch first — both owning
+// steps are idempotent CREATE IF NOT EXISTS on the lazily re-opened
+// telemetry file.
+const { migrateCreateTelemetryEventsTable } =
+  await import("./333-create-telemetry-events-table.js");
+const { createFlushCheckpointsTable } =
+  await import("./327-create-flush-checkpoints.js");
+migrateCreateTelemetryEventsTable(getDb());
+createFlushCheckpointsTable(getDb());
+
 const SOURCE_COLUMNS = `
   id TEXT PRIMARY KEY, created_at INTEGER NOT NULL, screen TEXT NOT NULL,
   tools_json TEXT, tasks_json TEXT, tone TEXT, google_connected INTEGER,

package/src/persistence/migrations/330-move-auth-fallback-events-to-telemetry-db.test.ts

@@ -23,6 +23,19 @@ const { migrateBackfillTelemetryEventsOutbox } =
 
 await initializeDb();
 
+// Migration 387 (the usage-telemetry removal) deletes the telemetry DB file
+// at the end of the chain, so after `initializeDb()` the telemetry-side
+// schema no longer exists. These tests drive the move + backfill steps
+// directly, so re-create the two tables they touch first — both owning
+// steps are idempotent CREATE IF NOT EXISTS on the lazily re-opened
+// telemetry file.
+const { migrateCreateTelemetryEventsTable } =
+  await import("./333-create-telemetry-events-table.js");
+const { createFlushCheckpointsTable } =
+  await import("./327-create-flush-checkpoints.js");
+migrateCreateTelemetryEventsTable(getDb());
+createFlushCheckpointsTable(getDb());
+
 const SOURCE_COLUMNS = `
   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,

package/src/persistence/migrations/331-move-lifecycle-events-to-telemetry-db.test.ts

@@ -23,6 +23,19 @@ const { migrateBackfillTelemetryEventsOutbox } =
 
 await initializeDb();
 
+// Migration 387 (the usage-telemetry removal) deletes the telemetry DB file
+// at the end of the chain, so after `initializeDb()` the telemetry-side
+// schema no longer exists. These tests drive the move + backfill steps
+// directly, so re-create the two tables they touch first — both owning
+// steps are idempotent CREATE IF NOT EXISTS on the lazily re-opened
+// telemetry file.
+const { migrateCreateTelemetryEventsTable } =
+  await import("./333-create-telemetry-events-table.js");
+const { createFlushCheckpointsTable } =
+  await import("./327-create-flush-checkpoints.js");
+migrateCreateTelemetryEventsTable(getDb());
+createFlushCheckpointsTable(getDb());
+
 /** Backfilled outbox rows for the lifecycle source, in `(created_at, id)` order. */
 function outboxLifecycleRows(): Array<{
   id: string;

package/src/persistence/migrations/332-move-skill-loaded-events-to-telemetry-db.test.ts

@@ -24,6 +24,19 @@ const { migrateBackfillTelemetryEventsOutbox } =
 
 await initializeDb();
 
+// Migration 387 (the usage-telemetry removal) deletes the telemetry DB file
+// at the end of the chain, so after `initializeDb()` the telemetry-side
+// schema no longer exists. These tests drive the move + backfill steps
+// directly, so re-create the two tables they touch first — both owning
+// steps are idempotent CREATE IF NOT EXISTS on the lazily re-opened
+// telemetry file.
+const { migrateCreateTelemetryEventsTable } =
+  await import("./333-create-telemetry-events-table.js");
+const { createFlushCheckpointsTable } =
+  await import("./327-create-flush-checkpoints.js");
+migrateCreateTelemetryEventsTable(getDb());
+createFlushCheckpointsTable(getDb());
+
 const SOURCE_COLUMNS = `
   id TEXT PRIMARY KEY, created_at INTEGER NOT NULL, conversation_id TEXT,
   skill_name TEXT NOT NULL, skill_updated_at TEXT, provider TEXT, model TEXT,

package/src/persistence/migrations/333-create-telemetry-events-table.test.ts

@@ -2,9 +2,10 @@
  * Tests for migration 333: creating the generic `telemetry_events` outbox
  * table on the dedicated telemetry database (`assistant-telemetry.db`).
  *
- * Runs against real workspace databases (`initializeDb()` already ran the
- * step once), so the tests assert the resulting telemetry-side schema and
- * that re-running the step is idempotent.
+ * Runs against real workspace databases. Migration 387 (the usage-telemetry
+ * removal) deletes the telemetry DB file at the end of the chain, so the
+ * tests re-drive the idempotent step themselves and assert the resulting
+ * telemetry-side schema and that re-running it is idempotent.
  */
 import { describe, expect, test } from "bun:test";
 
@@ -32,7 +33,9 @@ function telemetryIndexNames(): string[] {
 }
 
 describe("migration 333: create telemetry_events on the telemetry DB", () => {
-  test("initializeDb created the table with both indexes", () => {
+  test("the step creates the table with both indexes", () => {
+    migrateCreateTelemetryEventsTable(getDb());
+
     expect(telemetryTableExists("telemetry_events")).toBe(true);
     const indexes = telemetryIndexNames();
     expect(indexes).toContain("idx_telemetry_events_name_created_at_id");

package/src/persistence/migrations/334-backfill-telemetry-events-outbox.test.ts

@@ -20,6 +20,19 @@ const { APP_VERSION } = await import("../../version.js");
 
 await initializeDb();
 
+// Migration 387 (the usage-telemetry removal) deletes the telemetry DB file
+// at the end of the chain, so after `initializeDb()` the outbox and
+// checkpoint tables no longer exist. The tests recreate the legacy tables
+// and drive this step directly, so re-create the two tables it touches
+// first — both owning steps are idempotent CREATE IF NOT EXISTS on the
+// lazily re-opened telemetry file.
+const { migrateCreateTelemetryEventsTable } =
+  await import("./333-create-telemetry-events-table.js");
+const { createFlushCheckpointsTable } =
+  await import("./327-create-flush-checkpoints.js");
+migrateCreateTelemetryEventsTable(getDb());
+createFlushCheckpointsTable(getDb());
+
 const OPT_OUT_SENTINEL = "ffffffff-ffff-ffff-ffff-ffffffffffff";
 
 const LEGACY_TABLES: Record<string, string> = {

package/src/persistence/migrations/387-drop-telemetry-tables.ts

@@ -0,0 +1,51 @@
+import { existsSync, unlinkSync } from "node:fs";
+
+import { getTelemetryDbPath } from "../../util/telemetry-db-path.js";
+import { closeTelemetryDb, type DrizzleDb } from "../db-connection.js";
+
+/**
+ * Delete the dedicated telemetry database (`assistant-telemetry.db`, plus its
+ * `-wal` and `-shm` siblings).
+ *
+ * The usage-telemetry pipeline (reporter, event sources, outbox, traces, and
+ * every store that fed it) is gone — nothing reads or writes this database
+ * anymore. It held:
+ *
+ *   - `watchdog_events` (migration 301)
+ *   - `config_setting_events` (325)
+ *   - `flush_checkpoints` (327) — the reporter's watermark cursors
+ *   - `onboarding_events` (moved here by 329)
+ *   - `auth_fallback_events` (moved here by 330)
+ *   - `lifecycle_events` (moved here by 331)
+ *   - `skill_loaded_events` (moved here by 332)
+ *   - `telemetry_events` — the generic outbox (333)
+ *
+ * Deleting the FILES rather than DROP TABLE: a dropped table leaves its
+ * payloads recoverable in the file's freelist and WAL pages, and this
+ * database's last contents include the consented turn traces — unlinking is
+ * what actually destroys them on disk.
+ *
+ * Skipped entirely on a fresh install (no telemetry DB file): there is
+ * nothing to delete. The live connection is closed first so platforms that
+ * lock open files can complete the unlink; a failed unlink is logged and
+ * leaves the file in place, where it is inert — nothing opens it after this
+ * migration (the export route's checkpoint list no longer includes it).
+ *
+ * The `mainDb` parameter is accepted to satisfy the migration-step signature but
+ * is not used — this migration operates exclusively on the telemetry DB.
+ */
+export function migrateDropTelemetryTables(_mainDb: DrizzleDb): void {
+  closeTelemetryDb();
+  const base = getTelemetryDbPath();
+  for (const file of [base, `${base}-wal`, `${base}-shm`]) {
+    try {
+      if (existsSync(file)) {
+        unlinkSync(file);
+      }
+    } catch (error) {
+      console.warn(
+        `[migrate-387] could not delete ${file}: ${error instanceof Error ? error.message : String(error)} — leaving the inert file in place.`,
+      );
+    }
+  }
+}

package/src/persistence/migrations/__tests__/327-create-flush-checkpoints.test.ts

@@ -15,6 +15,12 @@ const { createFlushCheckpointsTable } =
 
 await initializeDb();
 
+// Migration 387 (the usage-telemetry removal) deletes the telemetry DB file
+// at the end of the chain, so after `initializeDb()` the telemetry-side
+// schema no longer exists. Re-drive the idempotent step so the tests
+// exercise it against a live telemetry file.
+createFlushCheckpointsTable(getDb());
+
 function telemetrySqlite() {
   const db = getTelemetrySqlite();
   if (!db) {
@@ -53,7 +59,9 @@ describe("migration 327 — flush_checkpoints on the telemetry database", () =>
       .run();
   });
 
-  test("after init, the table exists on the telemetry DB", () => {
+  test("the step creates the table on the telemetry DB", () => {
+    createFlushCheckpointsTable(getDb());
+
     const row = telemetrySqlite()
       .query(
         `SELECT name FROM sqlite_master WHERE type='table' AND name='flush_checkpoints'`,

package/src/persistence/migrations/__tests__/387-drop-telemetry-tables.test.ts

@@ -0,0 +1,79 @@
+import {
+  existsSync,
+  mkdirSync,
+  rmSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname } from "node:path";
+import { Database } from "bun:sqlite";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+// The migration resolves its target through this helper at call time — seed
+// the file at the SAME resolved path so the assertions and the migration can't
+// disagree about which file is the telemetry DB.
+import { getTelemetryDbPath } from "../../../util/telemetry-db-path.js";
+import * as schema from "../../schema.js";
+import { migrateDropTelemetryTables } from "../387-drop-telemetry-tables.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  return drizzle(sqlite, { schema });
+}
+
+function seededFiles(): string[] {
+  const base = getTelemetryDbPath();
+  return [base, `${base}-wal`, `${base}-shm`];
+}
+
+function seedTelemetryDb(): void {
+  const path = getTelemetryDbPath();
+  mkdirSync(dirname(path), { recursive: true });
+  rmSync(path, { force: true });
+  const raw = new Database(path);
+  raw.exec(`
+    CREATE TABLE IF NOT EXISTS telemetry_events (
+      id TEXT PRIMARY KEY, name TEXT NOT NULL, created_at INTEGER NOT NULL,
+      conversation_id TEXT, payload TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS flush_checkpoints (
+      key TEXT PRIMARY KEY, value TEXT NOT NULL
+    );
+  `);
+  raw.close();
+}
+
+describe("migrateDropTelemetryTables", () => {
+  beforeEach(() => {
+    // Never let one case's seeded files leak into the next.
+    for (const file of seededFiles()) {
+      if (existsSync(file)) {
+        unlinkSync(file);
+      }
+    }
+  });
+
+  test("no telemetry DB file → no-op (fresh installs never create one)", () => {
+    const db = createTestDb();
+    migrateDropTelemetryTables(db);
+    expect(existsSync(getTelemetryDbPath())).toBe(false);
+  });
+
+  test("deletes the telemetry database file and its -wal/-shm siblings", () => {
+    seedTelemetryDb();
+    // Siblings as sqlite leaves them after a WAL-mode session — the migration
+    // must sweep all three, since a DROP-less delete that only removed the
+    // base file would still leave trace payloads in the WAL.
+    writeFileSync(`${getTelemetryDbPath()}-wal`, "wal-bytes");
+    writeFileSync(`${getTelemetryDbPath()}-shm`, "shm-bytes");
+
+    const db = createTestDb();
+    migrateDropTelemetryTables(db);
+
+    for (const file of seededFiles()) {
+      expect(existsSync(file)).toBe(false);
+    }
+  });
+});

package/src/persistence/migrations/helpers/relocation.ts

@@ -1,7 +1,7 @@
 import type { Database } from "bun:sqlite";
 
+import { getDbPath } from "../../../util/layout.js";
 import { getLogger } from "../../../util/logger.js";
-import { getDbPath } from "../../../util/platform.js";
 import {
   parseChangesFromStdout,
   runAsyncSqlite,

package/src/persistence/migrations/run-migrations.ts

@@ -1,5 +1,5 @@
+import { getDbPath } from "../../util/layout.js";
 import { getLogger } from "../../util/logger.js";
-import { getDbPath } from "../../util/platform.js";
 import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
 
 const log = getLogger("db-init");

package/src/persistence/migrations/validate-migration-state.ts

@@ -1,6 +1,6 @@
 import { IntegrityError } from "../../util/errors.js";
+import { getDbPath } from "../../util/layout.js";
 import { getLogger } from "../../util/logger.js";
-import { getDbPath } from "../../util/platform.js";
 import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
 import {
   getStepName,

package/src/persistence/raw-query.ts

@@ -29,12 +29,7 @@
 
 import type { Database, SQLQueryBindings } from "bun:sqlite";
 
-import {
-  getLogsSqlite,
-  getMemorySqlite,
-  getSqlite,
-  getTelemetrySqlite,
-} from "./db-connection.js";
+import { getLogsSqlite, getMemorySqlite, getSqlite } from "./db-connection.js";
 
 type SqlParam = SQLQueryBindings;
 
@@ -129,15 +124,6 @@ function logsSqlite(): Database {
   return sqlite;
 }
 
-/** The telemetry connection, or a thrown error when it cannot be opened. */
-function telemetrySqlite(): Database {
-  const sqlite = getTelemetrySqlite();
-  if (!sqlite) {
-    throw new Error("telemetry database unavailable");
-  }
-  return sqlite;
-}
-
 /** {@link rawGet} against the memory connection. */
 export function rawMemoryGet<T>(
   label: string,
@@ -198,20 +184,6 @@ export function rawLogsRun(
   return (sqlite.query("SELECT changes() AS c").get() as { c: number }).c;
 }
 
-/** {@link rawRun} against the telemetry connection. */
-export function rawTelemetryRun(
-  label: string,
-  sql: string,
-  ...params: SqlParam[]
-): number {
-  const sqlite = telemetrySqlite();
-  sqlite
-    .label(label)
-    .query(sql)
-    .run(...params);
-  return (sqlite.query("SELECT changes() AS c").get() as { c: number }).c;
-}
-
 /**
  * Delete all rows from the given tables in a single transaction.
  *