@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/telemetry/usage-telemetry-reporter.test.ts

@@ -11,17 +11,20 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 // Module mocks (must precede production imports)
 // ---------------------------------------------------------------------------
 
-const mockGetMemoryCheckpoint = mock<(key: string) => string | null>(
-  () => null,
-);
-const mockSetMemoryCheckpoint = mock<(key: string, value: string) => void>(
+// Watermark storage fake, injected via the reporter's constructor (see
+// `makeReporter` below) — the real store lives on the telemetry DB and has
+// its own DB-backed test, so it is deliberately NOT module-mocked here.
+const mockGetFlushCheckpoint = mock<(key: string) => string | null>(() => null);
+const mockSetFlushCheckpoint = mock<(key: string, value: string) => void>(
   () => {},
 );
+const mockIsFlushCheckpointStoreAvailable = mock<() => boolean>(() => true);
 
-mock.module("../persistence/checkpoints.js", () => ({
-  getMemoryCheckpoint: mockGetMemoryCheckpoint,
-  setMemoryCheckpoint: mockSetMemoryCheckpoint,
-}));
+const fakeFlushCheckpointStore = {
+  isAvailable: () => mockIsFlushCheckpointStoreAvailable(),
+  get: (key: string) => mockGetFlushCheckpoint(key),
+  set: (key: string, value: string) => mockSetFlushCheckpoint(key, value),
+};
 
 const mockQueryUnreportedUsageEvents = mock(
   () =>
@@ -84,13 +87,6 @@ mock.module("../util/device-id.js", () => ({
   getDeviceId: mockGetDeviceId,
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../version.js", () => ({
   APP_VERSION: "1.2.3-test",
 }));
@@ -100,7 +96,7 @@ const mockGetCachedShareAnalytics = mock(() => true);
 const mockGetCachedShareDiagnostics = mock(() => false);
 // Owner's accepted diagnostics-consent version — the disclosing-version part of
 // the trace gate. Default to a far-future (unconditionally eligible) version so
-// the consent/flag cases drive eligibility on those axes; the version-specific
+// the consent cases drive eligibility on that axis; the version-specific
 // cases override it with old/empty values.
 const mockGetCachedShareDiagnosticsVersion = mock(() => "2999-01-01");
 
@@ -110,28 +106,14 @@ mock.module("../platform/consent-cache.js", () => ({
   getCachedShareDiagnosticsVersion: mockGetCachedShareDiagnosticsVersion,
 }));
 
-// The `trace-collection` feature flag — the other half of the trace gate.
-const mockIsAssistantFeatureFlagEnabled = mock(
-  (_key: string, _config: unknown): boolean => true,
-);
-
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: mockIsAssistantFeatureFlagEnabled,
-}));
-
-// Stub config — the flag checker is mocked, so the contents don't matter; this
-// just keeps `getConfig()` from touching the real loader / filesystem.
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({}),
-}));
-
 interface MockTurnTrace {
-  schema_version: 2;
+  schema_version: 3;
   messages: {
     id: string;
     role: string;
     created_at: number;
     content: unknown;
+    model: string | null;
   }[];
   tool_calls: unknown[];
   system_prompt: string | null;
@@ -150,13 +132,14 @@ function defaultBoundedTurnTrace(boundary: {
   userMessageCreatedAt: number;
 }): MockTurnTrace | null {
   return {
-    schema_version: 2,
+    schema_version: 3,
     messages: [
       {
         id: boundary.userMessageId,
         role: "user",
         created_at: boundary.userMessageCreatedAt,
         content: [{ type: "text", text: "hello" }],
+        model: null,
       },
     ],
     tool_calls: [],
@@ -188,49 +171,11 @@ mock.module("./turn-trace-store.js", () => ({
   isTurnSettled: mockIsTurnSettled,
 }));
 
-const mockQueryUnreportedLifecycleEvents = mock(
-  () =>
-    [] as {
-      id: string;
-      eventName: string;
-      createdAt: number;
-    }[],
-);
-
-mock.module("../persistence/lifecycle-events-store.js", () => ({
-  queryUnreportedLifecycleEvents: mockQueryUnreportedLifecycleEvents,
-}));
-
-const mockQueryUnreportedOnboardingEvents = mock(
-  () =>
-    [] as {
-      id: string;
-      createdAt: number;
-      screen: string;
-      toolsJson: string | null;
-      tasksJson: string | null;
-      tone: string | null;
-      googleConnected: boolean | null;
-      googleScopesJson: string | null;
-      priorAssistantsJson: string | null;
-      abVariant: string | null;
-      sessionId: string | null;
-      stepName: string | null;
-      stepIndex: number | null;
-      completedAt: string | null;
-      funnelVersion: string | null;
-    }[],
-);
-
-mock.module("../onboarding/onboarding-events-store.js", () => ({
-  queryUnreportedOnboardingEvents: mockQueryUnreportedOnboardingEvents,
-}));
-
-// The auth-fallback, tool-executed, and skill-loaded stores are intentionally
-// NOT mocked — they have their own DB-backed tests, and Bun's `mock.module`
-// is process-global, so mocking them here would leak into those tests when
-// files share an invocation. We seed the real DB instead so every test stays
-// order-independent.
+// The auth-fallback, tool-executed, and skill-loaded stores are
+// intentionally NOT mocked — they have their own DB-backed tests, and Bun's
+// `mock.module` is process-global, so mocking them here would leak into those
+// tests when files share an invocation. We seed the real DB instead so every
+// test stays order-independent.
 
 // ---------------------------------------------------------------------------
 // Production import (after mocks)
@@ -241,12 +186,16 @@ import {
   TOOL_INVOCATION_PII_SENTINEL as TOOL_PII_SENTINEL,
   type ToolInvocationSeedSpec,
 } from "../__tests__/test-support/tool-invocation-seed.js";
-import { getDb } from "../persistence/db-connection.js";
+import {
+  recordActivationEvent,
+  recordOnboardingEvent,
+} from "../onboarding/onboarding-events-store.js";
+import { getDb, getTelemetryDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { recordLifecycleEvent } from "../persistence/lifecycle-events-store.js";
 import {
-  authFallbackEvents,
   conversations,
-  skillLoadedEvents,
+  telemetryEvents,
   toolInvocations,
 } from "../persistence/schema/index.js";
 import { recordAuthFallbackCounts } from "../security/auth-fallback-events-store.js";
@@ -255,8 +204,37 @@ import {
   ACTIVATION_FUNNEL_VERSION,
   buildActivationDaemonEventId,
 } from "./activation-funnel.js";
+import { recordConfigSettingEvent } from "./config-setting-events-store.js";
 import { recordSkillLoadedEvent } from "./skill-loaded-events-store.js";
-import { UsageTelemetryReporter } from "./usage-telemetry-reporter.js";
+import {
+  ALL_TELEMETRY_EVENT_SOURCES,
+  DAEMON_TELEMETRY_EVENT_SOURCES,
+  MONITOR_TELEMETRY_EVENT_SOURCES,
+  outboxSource,
+  type TelemetryEventSource,
+} from "./telemetry-event-sources.js";
+import {
+  insertTelemetryOutboxEvent,
+  queryTelemetryOutboxBatch,
+} from "./telemetry-events-outbox.js";
+import type { OutboxTelemetryEventName, TelemetryEvent } from "./types.js";
+import {
+  initToolExecutedWatermarkIfAbsent,
+  UsageTelemetryReporter,
+} from "./usage-telemetry-reporter.js";
+import { recordWatchdogEvent } from "./watchdog-events-store.js";
+
+/**
+ * Construct a reporter wired to the in-memory checkpoint fake. All tests go
+ * through this so watermark reads/writes stay assertable via the mocks
+ * without process-global module mocking of the real telemetry-DB store.
+ */
+function makeReporter(): UsageTelemetryReporter {
+  return new UsageTelemetryReporter(
+    ALL_TELEMETRY_EVENT_SOURCES,
+    fakeFlushCheckpointStore,
+  );
+}
 
 await initializeDb();
 
@@ -306,34 +284,6 @@ function makeUsageEvent(
   };
 }
 
-type OnboardingEventFixture = ReturnType<
-  typeof mockQueryUnreportedOnboardingEvents
->[number];
-
-function makeOnboardingEvent(
-  overrides: Partial<OnboardingEventFixture> = {},
-): OnboardingEventFixture {
-  eventIdCounter += 1;
-  return {
-    id: `onb-${eventIdCounter}`,
-    createdAt: 1700000000000 + eventIdCounter * 1000,
-    screen: "tools",
-    toolsJson: null,
-    tasksJson: null,
-    tone: null,
-    googleConnected: null,
-    googleScopesJson: null,
-    priorAssistantsJson: null,
-    abVariant: null,
-    sessionId: null,
-    stepName: null,
-    stepIndex: null,
-    completedAt: null,
-    funnelVersion: null,
-    ...overrides,
-  };
-}
-
 const TOOL_CONVERSATION_ID = "conv-reporter-tool-executed";
 
 function seedToolInvocation(
@@ -355,10 +305,10 @@ function useStatefulCheckpoints(
   seed: Record<string, string> = {},
 ): Map<string, string> {
   const checkpoints = new Map(Object.entries(seed));
-  mockGetMemoryCheckpoint.mockImplementation(
+  mockGetFlushCheckpoint.mockImplementation(
     (key) => checkpoints.get(key) ?? null,
   );
-  mockSetMemoryCheckpoint.mockImplementation((key, value) => {
+  mockSetFlushCheckpoint.mockImplementation((key, value) => {
     checkpoints.set(key, value);
   });
   return checkpoints;
@@ -381,29 +331,22 @@ beforeEach(() => {
   mockGetCachedShareDiagnostics.mockReset();
   mockGetCachedShareDiagnostics.mockReturnValue(false);
   // Default the accepted consent version eligible so trace tests drive the gate
-  // via the flag + share_diagnostics knobs; version cases override it.
+  // via the share_diagnostics knob; version cases override it.
   mockGetCachedShareDiagnosticsVersion.mockReset();
   mockGetCachedShareDiagnosticsVersion.mockReturnValue("2999-01-01");
-  // Default the `trace-collection` flag ON so trace tests can drive eligibility
-  // via the consent knob alone; the flag-gating test flips it explicitly.
-  mockIsAssistantFeatureFlagEnabled.mockReset();
-  mockIsAssistantFeatureFlagEnabled.mockReturnValue(true);
   mockAssembleBoundedTurnTrace.mockReset();
   mockAssembleBoundedTurnTrace.mockImplementation(defaultBoundedTurnTrace);
   mockIsTurnSettled.mockReset();
   mockIsTurnSettled.mockReturnValue(true);
-  mockGetMemoryCheckpoint.mockReset();
-  mockSetMemoryCheckpoint.mockReset();
+  mockGetFlushCheckpoint.mockReset();
+  mockSetFlushCheckpoint.mockReset();
+  mockIsFlushCheckpointStoreAvailable.mockReset();
+  mockIsFlushCheckpointStoreAvailable.mockReturnValue(true);
   mockQueryUnreportedUsageEvents.mockReset();
   mockQueryUnreportedTurnEvents.mockReset();
   mockQueryUnreportedTurnEvents.mockReturnValue([]);
-  mockQueryUnreportedLifecycleEvents.mockReset();
-  mockQueryUnreportedLifecycleEvents.mockReturnValue([]);
-  mockQueryUnreportedOnboardingEvents.mockReset();
-  mockQueryUnreportedOnboardingEvents.mockReturnValue([]);
-  getDb().delete(authFallbackEvents).run();
   getDb().delete(toolInvocations).run();
-  getDb().delete(skillLoadedEvents).run();
+  getTelemetryDb()!.delete(telemetryEvents).run();
   delete process.env.VELLUM_DISABLE_PLATFORM;
   delete process.env.IS_PLATFORM;
   mockGetPlatformBaseUrl.mockReset();
@@ -415,7 +358,7 @@ beforeEach(() => {
   mockGetPlatformUserId.mockReturnValue("");
 
   // Defaults
-  mockGetMemoryCheckpoint.mockReturnValue(null);
+  mockGetFlushCheckpoint.mockReturnValue(null);
   mockGetPlatformBaseUrl.mockReturnValue("https://platform.vellum.ai");
 
   mockFetch = mock(() =>
@@ -459,7 +402,7 @@ describe("UsageTelemetryReporter", () => {
     const events = [makeUsageEvent(), makeUsageEvent()];
     mockQueryUnreportedUsageEvents.mockReturnValue(events);
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(clientFetchMock).toHaveBeenCalledTimes(1);
@@ -477,11 +420,11 @@ describe("UsageTelemetryReporter", () => {
     const events = [makeUsageEvent()];
     mockQueryUnreportedUsageEvents.mockReturnValue(events);
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).not.toHaveBeenCalled();
-    const watermarkCalls = mockSetMemoryCheckpoint.mock.calls.filter(
+    const watermarkCalls = mockSetFlushCheckpoint.mock.calls.filter(
       (c) => c[0] === "telemetry:usage:last_reported_at",
     );
     expect(watermarkCalls.length).toBe(0);
@@ -496,14 +439,14 @@ describe("UsageTelemetryReporter", () => {
     const events = [makeUsageEvent()];
     mockQueryUnreportedUsageEvents.mockReturnValue(events);
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     // Construction initializes the absent tool_executed watermark; clear that
     // call so the assertion below covers only the flush.
-    mockSetMemoryCheckpoint.mockClear();
+    mockSetFlushCheckpoint.mockClear();
     await reporter.flush();
 
     expect(mockFetch).not.toHaveBeenCalled();
-    expect(mockSetMemoryCheckpoint).not.toHaveBeenCalled();
+    expect(mockSetFlushCheckpoint).not.toHaveBeenCalled();
   });
 
   test("VELLUM_DISABLE_PLATFORM is ignored when IS_PLATFORM is set (managed mode)", async () => {
@@ -516,7 +459,7 @@ describe("UsageTelemetryReporter", () => {
     const events = [makeUsageEvent()];
     mockQueryUnreportedUsageEvents.mockReturnValue(events);
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -532,10 +475,10 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":2}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
-    const watermarkCalls = mockSetMemoryCheckpoint.mock.calls.filter(
+    const watermarkCalls = mockSetFlushCheckpoint.mock.calls.filter(
       (c) => c[0] === "telemetry:usage:last_reported_at",
     );
     expect(watermarkCalls.length).toBeGreaterThanOrEqual(1);
@@ -545,7 +488,7 @@ describe("UsageTelemetryReporter", () => {
     );
 
     // The compound cursor ID should also be set to the last event's id
-    const idCalls = mockSetMemoryCheckpoint.mock.calls.filter(
+    const idCalls = mockSetFlushCheckpoint.mock.calls.filter(
       (c) => c[0] === "telemetry:usage:last_reported_id",
     );
     expect(idCalls.length).toBeGreaterThanOrEqual(1);
@@ -559,10 +502,10 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response("error", { status: 500 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
-    const watermarkCalls = mockSetMemoryCheckpoint.mock.calls.filter(
+    const watermarkCalls = mockSetFlushCheckpoint.mock.calls.filter(
       (c) => c[0] === "telemetry:usage:last_reported_at",
     );
     expect(watermarkCalls.length).toBe(0);
@@ -575,7 +518,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
 
     // First flush — should use the per-device ID
     await reporter.flush();
@@ -598,7 +541,7 @@ describe("UsageTelemetryReporter", () => {
   test("empty batch makes no HTTP call", async () => {
     mockQueryUnreportedUsageEvents.mockReturnValue([]);
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).not.toHaveBeenCalled();
@@ -614,7 +557,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":500}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     // MAX_CONSECUTIVE_BATCHES = 10
@@ -628,7 +571,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     reporter.start();
 
     // Wait a tick so start()'s immediate flush settles.
@@ -662,7 +605,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -731,7 +674,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     const body = JSON.parse(
@@ -755,7 +698,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     const body = JSON.parse(
@@ -782,7 +725,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     const body = JSON.parse(
@@ -800,7 +743,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -820,7 +763,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -838,7 +781,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -867,7 +810,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":2}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -935,7 +878,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":3}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -1014,7 +957,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":4}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -1068,8 +1011,8 @@ describe("UsageTelemetryReporter", () => {
   });
 
   // -------------------------------------------------------------------------
-  // Per-turn trace collection (gated on the trace-collection flag AND
-  // share_diagnostics consent)
+  // Per-turn trace collection (gated on share_diagnostics consent at an
+  // eligible accepted version)
   // -------------------------------------------------------------------------
 
   function singleTurnEvent() {
@@ -1087,8 +1030,7 @@ describe("UsageTelemetryReporter", () => {
     ];
   }
 
-  test("attaches the assembled trace when the trace-collection flag, share_diagnostics, and an eligible consent version are all true", async () => {
-    mockIsAssistantFeatureFlagEnabled.mockReturnValue(true);
+  test("attaches the assembled trace when share_diagnostics and an eligible consent version are both true", async () => {
     mockGetCachedShareDiagnostics.mockReturnValue(true);
     mockQueryUnreportedUsageEvents.mockReturnValue([]);
     mockQueryUnreportedTurnEvents.mockReturnValue(singleTurnEvent());
@@ -1096,15 +1038,9 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
-    // The gate consults the `trace-collection` flag.
-    expect(mockIsAssistantFeatureFlagEnabled).toHaveBeenCalledWith(
-      "trace-collection",
-      expect.anything(),
-    );
-
     // The assembler is called with the turn's (conversationId, id, createdAt)
     // boundary so the window lines up with the turn event.
     expect(mockAssembleBoundedTurnTrace).toHaveBeenCalledTimes(1);
@@ -1124,13 +1060,13 @@ describe("UsageTelemetryReporter", () => {
     expect(turn.type).toBe("turn");
     expect(turn.daemon_event_id).toBe("evt-turn-trace");
     expect(turn.trace).toBeDefined();
-    expect(turn.trace.schema_version).toBe(2);
+    expect(turn.trace.schema_version).toBe(3);
     expect(turn.trace.messages[0].id).toBe("evt-turn-trace");
+    expect(turn.trace.messages[0].model).toBeNull();
     expect(Array.isArray(turn.trace.tool_calls)).toBe(true);
   });
 
-  test("omits the trace when share_diagnostics is false even though the flag is on (and still emits the turn event)", async () => {
-    mockIsAssistantFeatureFlagEnabled.mockReturnValue(true);
+  test("omits the trace when share_diagnostics is false (and still emits the turn event)", async () => {
     mockGetCachedShareDiagnostics.mockReturnValue(false);
     mockQueryUnreportedUsageEvents.mockReturnValue([]);
     mockQueryUnreportedTurnEvents.mockReturnValue(singleTurnEvent());
@@ -1138,7 +1074,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     // Gate off → no assembly at all (no PII touched).
@@ -1156,8 +1092,7 @@ describe("UsageTelemetryReporter", () => {
     expect("trace" in turn).toBe(false);
   });
 
-  test("omits the trace when the accepted consent version predates the disclosure threshold (flag + share_diagnostics on)", async () => {
-    mockIsAssistantFeatureFlagEnabled.mockReturnValue(true);
+  test("omits the trace when the accepted consent version predates the disclosure threshold (share_diagnostics on)", async () => {
     mockGetCachedShareDiagnostics.mockReturnValue(true);
     // Consent recorded under an older version that never disclosed trace
     // collection → gate closed, mirroring the platform ingest gate.
@@ -1168,7 +1103,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     // Version below threshold → no assembly at all (no PII touched).
@@ -1183,7 +1118,6 @@ describe("UsageTelemetryReporter", () => {
   });
 
   test("omits the trace when the owner never accepted a versioned consent (empty version)", async () => {
-    mockIsAssistantFeatureFlagEnabled.mockReturnValue(true);
     mockGetCachedShareDiagnostics.mockReturnValue(true);
     // Empty version (never accepted / no-row default where share_diagnostics is
     // true but unversioned) fails closed.
@@ -1194,7 +1128,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockAssembleBoundedTurnTrace).not.toHaveBeenCalled();
@@ -1205,30 +1139,6 @@ describe("UsageTelemetryReporter", () => {
     expect("trace" in body.events[0]).toBe(false);
   });
 
-  test("omits the trace when the trace-collection flag is off even though share_diagnostics is true", async () => {
-    mockIsAssistantFeatureFlagEnabled.mockReturnValue(false);
-    mockGetCachedShareDiagnostics.mockReturnValue(true);
-    mockQueryUnreportedUsageEvents.mockReturnValue([]);
-    mockQueryUnreportedTurnEvents.mockReturnValue(singleTurnEvent());
-    mockFetch.mockImplementation(() =>
-      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
-    );
-
-    const reporter = new UsageTelemetryReporter();
-    await reporter.flush();
-
-    // Flag off → gate closed → no assembly at all (no PII touched).
-    expect(mockAssembleBoundedTurnTrace).not.toHaveBeenCalled();
-
-    expect(mockFetch).toHaveBeenCalledTimes(1);
-    const body = JSON.parse(
-      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
-    );
-    // The single turn event still flushes — just without a trace.
-    expect(body.events.length).toBe(1);
-    expect("trace" in body.events[0]).toBe(false);
-  });
-
   test("omits the trace (key absent) when the assembler returns null (over-cap / failure) but still emits the turn event", async () => {
     mockGetCachedShareDiagnostics.mockReturnValue(true);
     // Over-cap / assembly-failure path: the bounded assembler returns null.
@@ -1239,7 +1149,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockAssembleBoundedTurnTrace).toHaveBeenCalledTimes(1);
@@ -1253,13 +1163,12 @@ describe("UsageTelemetryReporter", () => {
   test("no trace is assembled or attached when the whole flush is gated off by share_analytics", async () => {
     // The analytics gate short-circuits the entire flush; trace assembly must
     // never run (and nothing is sent) even when the trace gate is fully on
-    // (flag + share_diagnostics both true).
+    // (share_diagnostics true at an eligible version).
     mockGetCachedShareAnalytics.mockReturnValue(false);
-    mockIsAssistantFeatureFlagEnabled.mockReturnValue(true);
     mockGetCachedShareDiagnostics.mockReturnValue(true);
     mockQueryUnreportedTurnEvents.mockReturnValue(singleTurnEvent());
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockAssembleBoundedTurnTrace).not.toHaveBeenCalled();
@@ -1303,7 +1212,7 @@ describe("UsageTelemetryReporter", () => {
     // The turn's response is still streaming — not settled.
     mockIsTurnSettled.mockReturnValue(false);
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     // No trace assembled, and the turn is NOT sent (the only event was deferred).
@@ -1324,7 +1233,7 @@ describe("UsageTelemetryReporter", () => {
 
     // Flush 1: turn in progress -> deferred, nothing sent.
     mockIsTurnSettled.mockReturnValue(false);
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
     expect(mockFetch).not.toHaveBeenCalled();
 
@@ -1332,19 +1241,21 @@ describe("UsageTelemetryReporter", () => {
     // the full trace assembles. The same (still-unreported) turn now ships.
     mockIsTurnSettled.mockReturnValue(true);
     mockAssembleBoundedTurnTrace.mockReturnValue({
-      schema_version: 2,
+      schema_version: 3,
       messages: [
         {
           id: "evt-inflight",
           role: "user",
           created_at: 1700000050000,
           content: [{ type: "text", text: "do a thing" }],
+          model: null,
         },
         {
           id: "asst-1",
           role: "assistant",
           created_at: 1700000051000,
           content: [{ type: "text", text: "done" }],
+          model: "claude-fable-5",
         },
       ],
       tool_calls: [{ id: "ti-1" }],
@@ -1389,7 +1300,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockAssembleBoundedTurnTrace).toHaveBeenCalledTimes(1);
@@ -1423,7 +1334,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -1460,7 +1371,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockIsTurnSettled).toHaveBeenCalled();
@@ -1481,7 +1392,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -1520,7 +1431,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":4}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -1562,7 +1473,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     const body = JSON.parse(
@@ -1602,7 +1513,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":3}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -1661,33 +1572,28 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     // Construction initializes the absent tool_executed watermark; clear that
     // call so the count below covers only the flush's advancement.
-    mockSetMemoryCheckpoint.mockClear();
+    mockSetFlushCheckpoint.mockClear();
     await reporter.flush();
 
     // No HTTP call should have been made
     expect(mockFetch).not.toHaveBeenCalled();
 
-    // All 8 timestamp watermarks should have been advanced, and all 8 ID
-    // watermarks pinned to the high-sorting sentinel (a truthy value keeps
-    // the compound-cursor branch active while closing its same-millisecond
-    // arm against opt-out rows).
-    expect(mockSetMemoryCheckpoint).toHaveBeenCalledTimes(16);
+    // All 3 watermark-mode timestamp watermarks should have been advanced,
+    // and their 3 ID watermarks pinned to the high-sorting sentinel (a truthy
+    // value keeps the compound-cursor branch active while closing its
+    // same-millisecond arm against opt-out rows). Ack-mode sources
+    // (lifecycle, onboarding, auth_fallback, skill_loaded, watchdog,
+    // config_setting) discard their pending outbox rows instead and never
+    // touch `flush_checkpoints`.
+    expect(mockSetFlushCheckpoint).toHaveBeenCalledTimes(6);
 
-    const calls = mockSetMemoryCheckpoint.mock.calls;
+    const calls = mockSetFlushCheckpoint.mock.calls;
     const keys = calls.map((c) => c[0]);
-    const eventTypes = [
-      "usage",
-      "turns",
-      "lifecycle",
-      "onboarding",
-      "auth_fallback",
-      "tool_executed",
-      "skill_loaded",
-      "watchdog",
-    ];
+    expect(keys.some((k) => k.includes("skill_loaded"))).toBe(false);
+    const eventTypes = ["usage", "turns", "tool_executed"];
     for (const eventType of eventTypes) {
       expect(keys).toContain(`telemetry:${eventType}:last_reported_at`);
       const idCall = calls.find(
@@ -1695,6 +1601,11 @@ describe("UsageTelemetryReporter", () => {
       );
       expect(idCall?.[1]).toBe("ffffffff-ffff-ffff-ffff-ffffffffffff");
     }
+    expect(keys).not.toContain("telemetry:auth_fallback:last_reported_at");
+    expect(keys).not.toContain("telemetry:auth_fallback:last_reported_id");
+    expect(keys.some((k) => k.includes(":lifecycle:"))).toBe(false);
+    expect(keys).not.toContain("telemetry:onboarding:last_reported_at");
+    expect(keys).not.toContain("telemetry:onboarding:last_reported_id");
   });
 
   test("platform disabled takes precedence over consent off — watermarks NOT advanced", async () => {
@@ -1708,23 +1619,44 @@ describe("UsageTelemetryReporter", () => {
     const events = [makeUsageEvent()];
     mockQueryUnreportedUsageEvents.mockReturnValue(events);
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     // Construction initializes the absent tool_executed watermark; clear that
     // call so the assertion below covers only the flush.
-    mockSetMemoryCheckpoint.mockClear();
+    mockSetFlushCheckpoint.mockClear();
     await reporter.flush();
 
     expect(mockFetch).not.toHaveBeenCalled();
-    expect(mockSetMemoryCheckpoint).not.toHaveBeenCalled();
+    expect(mockSetFlushCheckpoint).not.toHaveBeenCalled();
+  });
+
+  test("flush skipped entirely when the flush-checkpoint store is unavailable", async () => {
+    // An unreadable checkpoint store must not be mistaken for cursor 0 —
+    // that would requery and re-ship history from the beginning. Nothing is
+    // sent and no watermark is touched (not even the opt-out sentinel);
+    // the cycle retries once the store is back.
+    mockIsFlushCheckpointStoreAvailable.mockReturnValue(false);
+    const events = [makeUsageEvent()];
+    mockQueryUnreportedUsageEvents.mockReturnValue(events);
+
+    const reporter = makeReporter();
+    // Construction initializes the absent tool_executed watermark; clear
+    // those calls so the assertions below cover only the flush.
+    mockGetFlushCheckpoint.mockClear();
+    mockSetFlushCheckpoint.mockClear();
+    await reporter.flush();
+
+    expect(mockFetch).not.toHaveBeenCalled();
+    expect(mockGetFlushCheckpoint).not.toHaveBeenCalled();
+    expect(mockSetFlushCheckpoint).not.toHaveBeenCalled();
   });
 
   test("events sent normally after re-granting share_analytics consent", async () => {
     // First flush with opt-out — watermarks advance, nothing sent
     mockGetCachedShareAnalytics.mockReturnValue(false);
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
     expect(mockFetch).not.toHaveBeenCalled();
-    mockSetMemoryCheckpoint.mockReset();
+    mockSetFlushCheckpoint.mockReset();
 
     // Re-grant consent and flush with new events
     mockGetCachedShareAnalytics.mockReturnValue(true);
@@ -1748,9 +1680,9 @@ describe("UsageTelemetryReporter", () => {
   //
   // The envelope's `assistant_version` is upload-time (always the current
   // binary). The per-event field is record-time (the binary that was running
-  // when the event was persisted to SQLite). In this PR only `llm_usage`
-  // events carry a true record-time value; turn events (and lifecycle /
-  // onboarding events, not asserted here) stamp the running binary's
+  // when the event was persisted to SQLite). `llm_usage` events and the
+  // outbox-backed types carry a true record-time value; turn events
+  // (not asserted here) stamp the running binary's
   // `APP_VERSION` directly until their respective follow-ups land.
   // Nullable llm_usage cases (legacy rows from before migration 267 ran)
   // fall back to the running binary's `APP_VERSION` rather than emitting
@@ -1769,7 +1701,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     const body = JSON.parse(
@@ -1793,7 +1725,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     const body = JSON.parse(
@@ -1830,7 +1762,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     const body = JSON.parse(
@@ -1859,7 +1791,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":2}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     const body = JSON.parse(
@@ -1891,7 +1823,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -1914,7 +1846,7 @@ describe("UsageTelemetryReporter", () => {
     expect(typeof body.events[0].daemon_event_id).toBe("string");
   });
 
-  test("auth_fallback watermark advances to the last reported row on success", async () => {
+  test("auth_fallback rows are deleted on success and never watermarked (ack mode)", async () => {
     mockQueryUnreportedUsageEvents.mockReturnValue([]);
     recordAuthFallbackCounts(1700000000000, 1700000001000, [
       {
@@ -1933,59 +1865,66 @@ describe("UsageTelemetryReporter", () => {
     mockFetch.mockImplementation(() =>
       Promise.resolve(new Response('{"accepted":2}', { status: 200 })),
     );
+    expect(queryTelemetryOutboxBatch("auth_fallback", 10)).toHaveLength(2);
 
-    // The last row by the reporter's (createdAt, id) cursor order is the one
-    // whose watermark should be persisted after a successful upload.
-    const rows = getDb()
-      .select()
-      .from(authFallbackEvents)
-      .orderBy(authFallbackEvents.createdAt, authFallbackEvents.id)
-      .all();
-    const lastRow = rows[rows.length - 1];
-
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
-    const watermarkCalls = mockSetMemoryCheckpoint.mock.calls.filter(
-      (c) => c[0] === "telemetry:auth_fallback:last_reported_at",
+    // Both rows shipped, were acknowledged (deleted), and no auth_fallback
+    // watermark was ever written — ack-mode sources bypass flush_checkpoints.
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
     );
-    expect(watermarkCalls.length).toBeGreaterThanOrEqual(1);
-    expect(watermarkCalls[watermarkCalls.length - 1][1]).toBe(
-      String(lastRow.createdAt),
+    expect(
+      body.events.filter((e: { type: string }) => e.type === "auth_fallback"),
+    ).toHaveLength(2);
+    expect(queryTelemetryOutboxBatch("auth_fallback", 10)).toHaveLength(0);
+    const authFallbackKeys = mockSetFlushCheckpoint.mock.calls.filter((c) =>
+      String(c[0]).startsWith("telemetry:auth_fallback:"),
+    );
+    expect(authFallbackKeys).toHaveLength(0);
+  });
+
+  test("auth_fallback rows survive a failed POST and re-ship on the next flush", async () => {
+    mockQueryUnreportedUsageEvents.mockReturnValue([]);
+    recordAuthFallbackCounts(1700000000000, 1700000001000, [
+      {
+        guard: "edge",
+        path: "/v1/messages",
+        failureKind: "missing_authorization",
+        count: 9,
+      },
+    ]);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response("server error", { status: 500 })),
     );
 
-    const idCalls = mockSetMemoryCheckpoint.mock.calls.filter(
-      (c) => c[0] === "telemetry:auth_fallback:last_reported_id",
+    const reporter = makeReporter();
+    await reporter.flush();
+    expect(queryTelemetryOutboxBatch("auth_fallback", 10)).toHaveLength(1);
+
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
-    expect(idCalls.length).toBeGreaterThanOrEqual(1);
-    expect(idCalls[idCalls.length - 1][1]).toBe(lastRow.id);
+    await reporter.flush();
+    expect(queryTelemetryOutboxBatch("auth_fallback", 10)).toHaveLength(0);
   });
 
   // -------------------------------------------------------------------------
   // Onboarding / activation funnel events
   // -------------------------------------------------------------------------
 
-  test("activation onboarding row serializes funnel fields + deterministic daemon_event_id", async () => {
+  test("activation onboarding row flushes with funnel fields + deterministic daemon_event_id, then acks", async () => {
     mockQueryUnreportedUsageEvents.mockReturnValue([]);
     const sessionId = "sess-activation-1";
     const stepName = "activation_moment_1_complete";
-    mockQueryUnreportedOnboardingEvents.mockReturnValue([
-      makeOnboardingEvent({
-        id: "onb-activation-1",
-        screen: stepName,
-        abVariant: "variant-a",
-        sessionId,
-        stepName,
-        stepIndex: 1,
-        completedAt: "2026-06-06T00:00:00.000Z",
-        funnelVersion: ACTIVATION_FUNNEL_VERSION,
-      }),
-    ]);
+    const recorded = recordActivationEvent({ stepName, sessionId });
+    expect(recorded).not.toBeNull();
     mockFetch.mockImplementation(() =>
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -1998,69 +1937,66 @@ describe("UsageTelemetryReporter", () => {
       session_id: sessionId,
       step_name: stepName,
       step_index: 1,
-      completed_at: "2026-06-06T00:00:00.000Z",
-      funnel_version: "activation_v1_2026_06",
+      funnel_version: ACTIVATION_FUNNEL_VERSION,
       daemon_event_id: buildActivationDaemonEventId(sessionId, stepName),
     });
+    // The wire id is the deterministic activation id, distinct from the
+    // outbox row id (a UUID) the ack deletes by.
+    expect(body.events[0].daemon_event_id).not.toBe(recorded!.id);
+    expect(queryTelemetryOutboxBatch("onboarding", 10)).toHaveLength(0);
   });
 
-  test("activation daemon_event_id is keyed on the row's stored funnel_version, not the binary constant", async () => {
+  test("queued activation row recorded under an older funnel version ships its frozen payload verbatim", async () => {
     mockQueryUnreportedUsageEvents.mockReturnValue([]);
-    const sessionId = "sess-activation-old";
-    const stepName = "activation_moment_1_complete";
-    // A row recorded under an OLDER funnel version, queued across an upgrade.
+    // The payload (including the deterministic daemon_event_id keyed on the
+    // OLD funnel version) was frozen at record time; a flush after a version
+    // bump must not restamp it with the new binary's constant.
     const oldVersion = "activation_v0_2026_05";
     expect(oldVersion).not.toBe(ACTIVATION_FUNNEL_VERSION);
-    mockQueryUnreportedOnboardingEvents.mockReturnValue([
-      makeOnboardingEvent({
-        id: "onb-activation-old",
-        screen: stepName,
-        abVariant: "variant-a",
-        sessionId,
-        stepName,
-        stepIndex: 1,
-        completedAt: "2026-05-01T00:00:00.000Z",
-        funnelVersion: oldVersion,
-      }),
-    ]);
+    const frozen: TelemetryEvent = {
+      type: "onboarding",
+      daemon_event_id: `${oldVersion}:sess-activation-old:activation_moment_1_complete`,
+      recorded_at: 1700000100000,
+      screen: "activation_moment_1_complete",
+      ab_variant: "variant-a",
+      session_id: "sess-activation-old",
+      step_name: "activation_moment_1_complete",
+      step_index: 1,
+      completed_at: "2026-05-01T00:00:00.000Z",
+      funnel_version: oldVersion,
+      assistant_version: "0.9.0-old",
+    };
+    insertTelemetryOutboxEvent({
+      id: "row-activation-old",
+      name: "onboarding",
+      createdAt: 1700000100000,
+      event: frozen,
+    });
     mockFetch.mockImplementation(() =>
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     const body = JSON.parse(
       (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
     );
-    expect(body.events[0]).toMatchObject({
-      funnel_version: oldVersion,
-      daemon_event_id: buildActivationDaemonEventId(
-        sessionId,
-        stepName,
-        oldVersion,
-      ),
-    });
-    // Guard: the id must carry the row's version, not the binary constant.
-    expect(body.events[0].daemon_event_id).toBe(
-      `${oldVersion}:${sessionId}:${stepName}`,
-    );
+    expect(body.events).toEqual([frozen]);
   });
 
-  test("legacy onboarding row keeps daemon_event_id: e.id and omits funnel fields", async () => {
+  test("legacy onboarding row keeps daemon_event_id = row id and omits funnel fields", async () => {
     mockQueryUnreportedUsageEvents.mockReturnValue([]);
-    mockQueryUnreportedOnboardingEvents.mockReturnValue([
-      makeOnboardingEvent({
-        id: "onb-legacy-1",
-        screen: "tools",
-        toolsJson: JSON.stringify(["calendar"]),
-      }),
-    ]);
+    const recorded = recordOnboardingEvent({
+      screen: "tools",
+      tools: ["calendar"],
+    });
+    expect(recorded).not.toBeNull();
     mockFetch.mockImplementation(() =>
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -2070,7 +2006,8 @@ describe("UsageTelemetryReporter", () => {
     expect(body.events.length).toBe(1);
     const e = body.events[0];
     expect(e.type).toBe("onboarding");
-    expect(e.daemon_event_id).toBe("onb-legacy-1");
+    expect(e.daemon_event_id).toBe(recorded!.id);
+    expect(e.tools).toEqual(["calendar"]);
     expect(e.session_id).toBeUndefined();
     expect(e.step_name).toBeUndefined();
     expect(e.step_index).toBeUndefined();
@@ -2118,7 +2055,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":2}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -2174,10 +2111,10 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":2}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
-    const watermarkCalls = mockSetMemoryCheckpoint.mock.calls.filter(
+    const watermarkCalls = mockSetFlushCheckpoint.mock.calls.filter(
       (c) => c[0] === "telemetry:tool_executed:last_reported_at",
     );
     expect(watermarkCalls.length).toBeGreaterThanOrEqual(1);
@@ -2185,7 +2122,7 @@ describe("UsageTelemetryReporter", () => {
       String(1700000002000),
     );
 
-    const idCalls = mockSetMemoryCheckpoint.mock.calls.filter(
+    const idCalls = mockSetFlushCheckpoint.mock.calls.filter(
       (c) => c[0] === "telemetry:tool_executed:last_reported_id",
     );
     expect(idCalls.length).toBeGreaterThanOrEqual(1);
@@ -2197,18 +2134,20 @@ describe("UsageTelemetryReporter", () => {
     seedToolInvocation({ id: "ti-r1", createdAt: 1700000001000 });
     seedToolInvocation({ id: "ti-r2", createdAt: 1700000002000 });
     // A previous flush already reported ti-r1.
-    mockGetMemoryCheckpoint.mockImplementation((key) => {
+    mockGetFlushCheckpoint.mockImplementation((key) => {
       if (key === "telemetry:tool_executed:last_reported_at") {
         return String(1700000001000);
       }
-      if (key === "telemetry:tool_executed:last_reported_id") return "ti-r1";
+      if (key === "telemetry:tool_executed:last_reported_id") {
+        return "ti-r1";
+      }
       return null;
     });
     mockFetch.mockImplementation(() =>
       Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -2229,7 +2168,7 @@ describe("UsageTelemetryReporter", () => {
     // predating the reporter) stay behind the watermark.
     const checkpoints = useStatefulCheckpoints();
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     const rowCreatedAt =
       Number(checkpoints.get("telemetry:tool_executed:last_reported_at")) +
       1000;
@@ -2268,7 +2207,7 @@ describe("UsageTelemetryReporter", () => {
       createdAt: Date.now() - 60_000,
     });
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
 
     // The checkpoint is persisted immediately at construction so a crash
     // before the first flush can't re-initialize later.
@@ -2313,7 +2252,7 @@ describe("UsageTelemetryReporter", () => {
     // opted-in rows.
     seedToolInvocation({ id: "ti-backlog", createdAt: 1700000002000 });
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     expect(checkpoints.get("telemetry:tool_executed:last_reported_at")).toBe(
       String(1700000001000),
     );
@@ -2347,7 +2286,7 @@ describe("UsageTelemetryReporter", () => {
       id: "ti-opt-out-window",
       createdAt: optOutRowCreatedAt,
     });
-    const optedOutReporter = new UsageTelemetryReporter();
+    const optedOutReporter = makeReporter();
     await optedOutReporter.stop(); // shutdown path: runs the final flush
     expect(mockFetch).not.toHaveBeenCalled();
     const advanced = Number(
@@ -2359,7 +2298,7 @@ describe("UsageTelemetryReporter", () => {
     // after the opt-out epoch ship — the opt-out-window row never does.
     mockGetCachedShareAnalytics.mockReturnValue(true);
     seedToolInvocation({ id: "ti-after-opt-in", createdAt: advanced + 1000 });
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -2383,7 +2322,7 @@ describe("UsageTelemetryReporter", () => {
     // Opted-out flush: advances the timestamp watermark to Date.now() and
     // must also pin the ID watermark to the high-sorting sentinel.
     mockGetCachedShareAnalytics.mockReturnValue(false);
-    const optedOutReporter = new UsageTelemetryReporter();
+    const optedOutReporter = makeReporter();
     await optedOutReporter.flush();
     expect(mockFetch).not.toHaveBeenCalled();
     const watermark = Number(
@@ -2402,7 +2341,7 @@ describe("UsageTelemetryReporter", () => {
     // Re-opt-in: only rows strictly after the opt-out epoch ship.
     mockGetCachedShareAnalytics.mockReturnValue(true);
     seedToolInvocation({ id: "ti-after-opt-in", createdAt: watermark + 1000 });
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -2414,21 +2353,61 @@ describe("UsageTelemetryReporter", () => {
     ).toEqual(["ti-after-opt-in"]);
   });
 
+  test("a turn-only (daemon) reporter never touches the tool_executed watermark", () => {
+    new UsageTelemetryReporter(
+      DAEMON_TELEMETRY_EVENT_SOURCES,
+      fakeFlushCheckpointStore,
+    );
+    expect(mockGetFlushCheckpoint).not.toHaveBeenCalled();
+    expect(mockSetFlushCheckpoint).not.toHaveBeenCalled();
+  });
+
+  test("a monitor reporter re-runs the guarded tool_executed watermark init as a backstop", () => {
+    new UsageTelemetryReporter(
+      MONITOR_TELEMETRY_EVENT_SOURCES,
+      fakeFlushCheckpointStore,
+    );
+    expect(mockGetFlushCheckpoint).toHaveBeenCalledWith(
+      "telemetry:tool_executed:last_reported_at",
+    );
+    expect(mockSetFlushCheckpoint).toHaveBeenCalledTimes(1);
+  });
+
+  test("initToolExecutedWatermarkIfAbsent sets the epoch once and never overwrites", () => {
+    const checkpoints = useStatefulCheckpoints();
+    initToolExecutedWatermarkIfAbsent(fakeFlushCheckpointStore);
+    const epoch = checkpoints.get("telemetry:tool_executed:last_reported_at");
+    expect(epoch).toBeString();
+
+    initToolExecutedWatermarkIfAbsent(fakeFlushCheckpointStore);
+    expect(checkpoints.get("telemetry:tool_executed:last_reported_at")).toBe(
+      epoch!,
+    );
+
+    // A store failure is non-fatal (degraded-DB daemons still start).
+    mockGetFlushCheckpoint.mockImplementation(() => {
+      throw new Error("database disk image is malformed");
+    });
+    expect(() =>
+      initToolExecutedWatermarkIfAbsent(fakeFlushCheckpointStore),
+    ).not.toThrow();
+  });
+
   test("checkpoint store failure during construction is non-fatal — degraded-DB daemons still start", () => {
     // initializeDb() failures are tolerated at daemon startup (degraded
     // mode), so the constructor's checkpoint init must never throw out of
     // the constructor and abort the daemon.
-    mockGetMemoryCheckpoint.mockImplementation(() => {
+    mockGetFlushCheckpoint.mockImplementation(() => {
       throw new Error("database disk image is malformed");
     });
-    expect(() => new UsageTelemetryReporter()).not.toThrow();
+    expect(() => makeReporter()).not.toThrow();
 
     // The write path failing is equally non-fatal.
-    mockGetMemoryCheckpoint.mockImplementation(() => null);
-    mockSetMemoryCheckpoint.mockImplementation(() => {
+    mockGetFlushCheckpoint.mockImplementation(() => null);
+    mockSetFlushCheckpoint.mockImplementation(() => {
       throw new Error("database disk image is malformed");
     });
-    expect(() => new UsageTelemetryReporter()).not.toThrow();
+    expect(() => makeReporter()).not.toThrow();
   });
 
   // -------------------------------------------------------------------------
@@ -2452,7 +2431,7 @@ describe("UsageTelemetryReporter", () => {
       Promise.resolve(new Response('{"accepted":2}', { status: 200 })),
     );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
@@ -2491,59 +2470,637 @@ describe("UsageTelemetryReporter", () => {
     });
   });
 
-  test("skill_loaded watermark advances to the last reported row on success", async () => {
+  test("skill_loaded rows are deleted from the outbox after a 2xx, never via watermarks", async () => {
     mockQueryUnreportedUsageEvents.mockReturnValue([]);
     recordSkillLoadedEvent({ skillName: "web-research" });
     recordSkillLoadedEvent({ skillName: "tasks" });
+    expect(queryTelemetryOutboxBatch("skill_loaded", 10)).toHaveLength(2);
     mockFetch.mockImplementation(() =>
       Promise.resolve(new Response('{"accepted":2}', { status: 200 })),
     );
 
-    // The last row by the reporter's (createdAt, id) cursor order is the one
-    // whose watermark should be persisted after a successful upload.
-    const rows = getDb()
-      .select()
-      .from(skillLoadedEvents)
-      .orderBy(skillLoadedEvents.createdAt, skillLoadedEvents.id)
-      .all();
-    const lastRow = rows[rows.length - 1];
+    const reporter = makeReporter();
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(queryTelemetryOutboxBatch("skill_loaded", 10)).toHaveLength(0);
+    // Ack-mode: the skill_loaded source never touches flush_checkpoints.
+    expect(
+      mockSetFlushCheckpoint.mock.calls.some((c) =>
+        c[0].includes("skill_loaded"),
+      ),
+    ).toBe(false);
+  });
+
+  test("a full skill_loaded batch drives recursion until the outbox drains", async () => {
+    mockQueryUnreportedUsageEvents.mockReturnValue([]);
+    // BATCH_SIZE (500) + 1 rows: the first flush ships and deletes a full
+    // batch, and the fullBatch recursion ships the remaining row.
+    for (let i = 0; i < 501; i++) {
+      recordSkillLoadedEvent({ skillName: `skill-${i}` });
+    }
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":500}', { status: 200 })),
+    );
 
-    const reporter = new UsageTelemetryReporter();
+    const reporter = makeReporter();
     await reporter.flush();
 
-    const watermarkCalls = mockSetMemoryCheckpoint.mock.calls.filter(
-      (c) => c[0] === "telemetry:skill_loaded:last_reported_at",
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(queryTelemetryOutboxBatch("skill_loaded", 1000)).toHaveLength(0);
+  });
+
+  // -------------------------------------------------------------------------
+  // Config-setting events
+  // -------------------------------------------------------------------------
+
+  test("config_setting events ship the key/value pair on the standard envelope", async () => {
+    mockQueryUnreportedUsageEvents.mockReturnValue([]);
+    recordConfigSettingEvent({
+      configKey: "memory.enabled",
+      configValue: "true",
+    });
+    recordConfigSettingEvent({
+      configKey: "memory.v2.enabled",
+      configValue: "false",
+    });
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":2}', { status: 200 })),
     );
-    expect(watermarkCalls.length).toBeGreaterThanOrEqual(1);
-    expect(watermarkCalls[watermarkCalls.length - 1][1]).toBe(
-      String(lastRow.createdAt),
+
+    const reporter = makeReporter();
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
     );
+    expect(body.events.length).toBe(2);
+
+    const byKey: Record<string, Record<string, unknown>> = {};
+    for (const e of body.events as Array<{ config_key: string }>) {
+      byKey[e.config_key] = e;
+    }
 
-    const idCalls = mockSetMemoryCheckpoint.mock.calls.filter(
-      (c) => c[0] === "telemetry:skill_loaded:last_reported_id",
+    expect(byKey["memory.enabled"]).toMatchObject({
+      type: "config_setting",
+      config_key: "memory.enabled",
+      config_value: "true",
+      assistant_version: "1.2.3-test",
+    });
+    expect(typeof byKey["memory.enabled"].daemon_event_id).toBe("string");
+    expect(typeof byKey["memory.enabled"].recorded_at).toBe("number");
+    expect(byKey["memory.v2.enabled"]).toMatchObject({
+      type: "config_setting",
+      config_key: "memory.v2.enabled",
+      config_value: "false",
+    });
+  });
+
+  test("config_setting rows are deleted on success and no watermark is written", async () => {
+    mockQueryUnreportedUsageEvents.mockReturnValue([]);
+    recordConfigSettingEvent({
+      configKey: "memory.enabled",
+      configValue: "true",
+    });
+    recordConfigSettingEvent({
+      configKey: "memory.v2.enabled",
+      configValue: "true",
+    });
+    expect(queryTelemetryOutboxBatch("config_setting", 10)).toHaveLength(2);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":2}', { status: 200 })),
     );
-    expect(idCalls.length).toBeGreaterThanOrEqual(1);
-    expect(idCalls[idCalls.length - 1][1]).toBe(lastRow.id);
+
+    const reporter = makeReporter();
+    await reporter.flush();
+
+    // Ack-mode: acknowledged rows are deleted from the outbox instead of
+    // advancing a `flush_checkpoints` watermark.
+    expect(queryTelemetryOutboxBatch("config_setting", 10)).toHaveLength(0);
+    const watermarkKeys = mockSetFlushCheckpoint.mock.calls
+      .map((c) => c[0] as string)
+      .filter((key) => key.startsWith("telemetry:config_setting:"));
+    expect(watermarkKeys).toHaveLength(0);
   });
 
-  test("batch recursion when skill_loaded returns a full batch, capped at 10", async () => {
+  test("config_setting rows survive a failed POST for the next flush", async () => {
+    mockQueryUnreportedUsageEvents.mockReturnValue([]);
+    recordConfigSettingEvent({
+      configKey: "memory.enabled",
+      configValue: "true",
+    });
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response("error", { status: 500 })),
+    );
+
+    const reporter = makeReporter();
+    await reporter.flush();
+
+    expect(queryTelemetryOutboxBatch("config_setting", 10)).toHaveLength(1);
+  });
+
+  // -------------------------------------------------------------------------
+  // Watchdog events
+  // -------------------------------------------------------------------------
+
+  test("watchdog events ship the record-time payload with nested detail, then delete", async () => {
     mockQueryUnreportedUsageEvents.mockReturnValue([]);
-    // Exactly BATCH_SIZE rows; the mocked checkpoints never persist, so each
-    // recursion re-reads the same full batch until the cap.
-    const fullBatch = Array.from({ length: 500 }, (_, i) => ({
-      id: `sle-batch-${String(i).padStart(3, "0")}`,
+    recordWatchdogEvent({
+      checkName: "event_loop_blocked",
+      value: 60000,
+      detail: { reason: "no_bytes_60s", threshold_ms: 5000 },
+    });
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
+    );
+
+    const reporter = makeReporter();
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(body.events).toHaveLength(1);
+    expect(body.events[0]).toMatchObject({
+      type: "watchdog",
+      check_name: "event_loop_blocked",
+      value: 60000,
+      detail: { reason: "no_bytes_60s", threshold_ms: 5000 },
+      assistant_version: "1.2.3-test",
+    });
+    expect(typeof body.events[0].daemon_event_id).toBe("string");
+    expect(typeof body.events[0].recorded_at).toBe("number");
+    expect(queryTelemetryOutboxBatch("watchdog", 10)).toHaveLength(0);
+  });
+
+  // -------------------------------------------------------------------------
+  // Ack-mode sources (grouped `ack` field: acknowledge + discardPending)
+  // -------------------------------------------------------------------------
+
+  // Wire id deliberately differs from the row id: acknowledge must receive
+  // ROW ids, never wire daemon_event_ids.
+  function fakeWireEvent(rowId: string, createdAt: number): TelemetryEvent {
+    return {
+      type: "lifecycle",
+      daemon_event_id: `wire-${rowId}`,
+      event_name: "fake_event",
+      recorded_at: createdAt,
+      assistant_version: "1.2.3-test",
+    };
+  }
+
+  /**
+   * Ack-mode fake backed by a mutable in-memory row array: `collect` ignores
+   * the cursor args, `acknowledge` deletes the acknowledged rows, and
+   * `discardPending` drops everything — mirroring the outbox-store contract.
+   */
+  function makeAckSource(id: string, rowIds: string[] = []) {
+    let rows = rowIds.map((rowId, i) => ({
+      rowId,
       createdAt: 1700000000000 + i,
-      skillName: "web-research",
     }));
-    getDb().insert(skillLoadedEvents).values(fullBatch).run();
+    const acknowledge = mock((acked: string[]) => {
+      rows = rows.filter((r) => !acked.includes(r.rowId));
+    });
+    const discardPending = mock(() => {
+      rows = [];
+    });
+    const source: TelemetryEventSource = {
+      id,
+      collect(_afterCreatedAt, _afterId, limit) {
+        const batch = rows.slice(0, limit);
+        return {
+          events: batch.map((r) => fakeWireEvent(r.rowId, r.createdAt)),
+          rowIds: batch.map((r) => r.rowId),
+          lastCursor: null,
+          fullBatch: batch.length === limit,
+        };
+      },
+      ack: { acknowledge, discardPending },
+    };
+    return { source, acknowledge, discardPending, pending: () => rows.length };
+  }
+
+  function makeWatermarkSource(
+    id: string,
+    rowIds: string[] = [],
+  ): TelemetryEventSource {
+    const rows = rowIds.map((rowId, i) => ({
+      rowId,
+      createdAt: 1700000000000 + i,
+    }));
+    return {
+      id,
+      collect(_afterCreatedAt, _afterId, limit) {
+        const batch = rows.slice(0, limit);
+        const last = batch.length > 0 ? batch[batch.length - 1] : null;
+        return {
+          events: batch.map((r) => fakeWireEvent(r.rowId, r.createdAt)),
+          lastCursor: last
+            ? { createdAt: last.createdAt, id: last.rowId }
+            : null,
+          fullBatch: batch.length === limit,
+        };
+      },
+    };
+  }
+
+  test("ack-mode source: acknowledge receives ROW ids after a 2xx and no watermark keys are written", async () => {
+    const { source, acknowledge } = makeAckSource("fake_ack", [
+      "row-1",
+      "row-2",
+    ]);
+    const reporter = new UsageTelemetryReporter(
+      [source],
+      fakeFlushCheckpointStore,
+    );
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(
+      body.events.map((e: { daemon_event_id: string }) => e.daemon_event_id),
+    ).toEqual(["wire-row-1", "wire-row-2"]);
+    expect(acknowledge).toHaveBeenCalledTimes(1);
+    expect(acknowledge.mock.calls[0][0]).toEqual(["row-1", "row-2"]);
+    // Ack-mode sources never touch flush_checkpoints.
+    expect(mockSetFlushCheckpoint).not.toHaveBeenCalled();
+  });
+
+  test("acknowledge is NOT called when the POST fails", async () => {
     mockFetch.mockImplementation(() =>
-      Promise.resolve(new Response('{"accepted":500}', { status: 200 })),
+      Promise.resolve(new Response("error", { status: 500 })),
+    );
+    const { source, acknowledge, pending } = makeAckSource("fake_ack", [
+      "row-1",
+    ]);
+    const reporter = new UsageTelemetryReporter(
+      [source],
+      fakeFlushCheckpointStore,
     );
+    await reporter.flush();
+
+    expect(acknowledge).not.toHaveBeenCalled();
+    expect(pending()).toBe(1);
+    expect(mockSetFlushCheckpoint).not.toHaveBeenCalled();
+  });
 
-    const reporter = new UsageTelemetryReporter();
+  test("acknowledge is NOT called when platform credentials are missing", async () => {
+    mockPlatformClient = null;
+    const { source, acknowledge, pending } = makeAckSource("fake_ack", [
+      "row-1",
+    ]);
+    const reporter = new UsageTelemetryReporter(
+      [source],
+      fakeFlushCheckpointStore,
+    );
     await reporter.flush();
 
-    // MAX_CONSECUTIVE_BATCHES = 10
-    expect(mockFetch).toHaveBeenCalledTimes(10);
+    expect(mockFetch).not.toHaveBeenCalled();
+    expect(acknowledge).not.toHaveBeenCalled();
+    expect(pending()).toBe(1);
+  });
+
+  test("acknowledge is skipped for an empty ack batch shipped alongside a watermark source", async () => {
+    const { source: ackSource, acknowledge } = makeAckSource("fake_ack");
+    const wmSource = makeWatermarkSource("fake_wm", ["wm-1"]);
+    const reporter = new UsageTelemetryReporter(
+      [wmSource, ackSource],
+      fakeFlushCheckpointStore,
+    );
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(acknowledge).not.toHaveBeenCalled();
+  });
+
+  test("opt-out: discardPending drops ack-mode rows while watermark sources get the sentinel pin", async () => {
+    mockGetCachedShareAnalytics.mockReturnValue(false);
+    const {
+      source: ackSource,
+      discardPending,
+      pending,
+    } = makeAckSource("fake_ack", ["row-1"]);
+    const wmSource = makeWatermarkSource("fake_wm", ["wm-1"]);
+    const reporter = new UsageTelemetryReporter(
+      [wmSource, ackSource],
+      fakeFlushCheckpointStore,
+    );
+    await reporter.flush();
+
+    expect(mockFetch).not.toHaveBeenCalled();
+    expect(discardPending).toHaveBeenCalledTimes(1);
+    expect(pending()).toBe(0);
+
+    const keys = mockSetFlushCheckpoint.mock.calls.map((c) => c[0]);
+    expect(keys).toContain("telemetry:fake_wm:last_reported_at");
+    const wmIdCall = mockSetFlushCheckpoint.mock.calls.find(
+      (c) => c[0] === "telemetry:fake_wm:last_reported_id",
+    );
+    expect(wmIdCall?.[1]).toBe("ffffffff-ffff-ffff-ffff-ffffffffffff");
+    expect(keys.some((k) => k.includes("fake_ack"))).toBe(false);
+  });
+
+  test("mixed watermark+ack sources flush in construction order, each acknowledged in its own mode", async () => {
+    const wmSource = makeWatermarkSource("fake_wm", ["wm-1", "wm-2"]);
+    const { source: ackSource, acknowledge } = makeAckSource("fake_ack", [
+      "row-1",
+    ]);
+    const reporter = new UsageTelemetryReporter(
+      [wmSource, ackSource],
+      fakeFlushCheckpointStore,
+    );
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(
+      body.events.map((e: { daemon_event_id: string }) => e.daemon_event_id),
+    ).toEqual(["wire-wm-1", "wire-wm-2", "wire-row-1"]);
+
+    expect(acknowledge).toHaveBeenCalledTimes(1);
+    expect(acknowledge.mock.calls[0][0]).toEqual(["row-1"]);
+
+    const wmAtCalls = mockSetFlushCheckpoint.mock.calls.filter(
+      (c) => c[0] === "telemetry:fake_wm:last_reported_at",
+    );
+    expect(wmAtCalls[wmAtCalls.length - 1][1]).toBe(String(1700000000001));
+    const wmIdCalls = mockSetFlushCheckpoint.mock.calls.filter(
+      (c) => c[0] === "telemetry:fake_wm:last_reported_id",
+    );
+    expect(wmIdCalls[wmIdCalls.length - 1][1]).toBe("wm-2");
+    expect(
+      mockSetFlushCheckpoint.mock.calls.some((c) => c[0].includes("fake_ack")),
+    ).toBe(false);
+  });
+
+  test("an ack-mode full batch drives recursion until the backlog drains", async () => {
+    // 501 rows: the first collect fills BATCH_SIZE (500), acknowledge drains
+    // them, and the fullBatch recursion ships the remaining row.
+    const rowIds = Array.from({ length: 501 }, (_, i) => `row-${i}`);
+    const { source, acknowledge, pending } = makeAckSource("fake_ack", rowIds);
+    const reporter = new UsageTelemetryReporter(
+      [source],
+      fakeFlushCheckpointStore,
+    );
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(acknowledge).toHaveBeenCalledTimes(2);
+    expect(acknowledge.mock.calls[0][0]).toHaveLength(500);
+    expect(acknowledge.mock.calls[1][0]).toEqual(["row-500"]);
+    expect(pending()).toBe(0);
+  });
+
+  /** Ack source whose collect returns events with broken rowIds. */
+  function makeBrokenAckSource(id: string, rowIds: string[] | undefined) {
+    const acknowledge = mock((_acked: string[]) => {});
+    const discardPending = mock(() => {});
+    const source: TelemetryEventSource = {
+      id,
+      collect() {
+        return {
+          events: [
+            fakeWireEvent("row-1", 1700000000000),
+            fakeWireEvent("row-2", 1700000000001),
+          ],
+          ...(rowIds ? { rowIds } : {}),
+          lastCursor: null,
+          fullBatch: false,
+        };
+      },
+      ack: { acknowledge, discardPending },
+    };
+    return { source, acknowledge };
+  }
+
+  test("an ack batch omitting rowIds ships nothing while other sources still ship", async () => {
+    const { source: brokenSource, acknowledge } = makeBrokenAckSource(
+      "fake_broken_ack",
+      undefined,
+    );
+    const wmSource = makeWatermarkSource("fake_wm", ["wm-1"]);
+    const reporter = new UsageTelemetryReporter(
+      [brokenSource, wmSource],
+      fakeFlushCheckpointStore,
+    );
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(
+      body.events.map((e: { daemon_event_id: string }) => e.daemon_event_id),
+    ).toEqual(["wire-wm-1"]);
+    expect(acknowledge).not.toHaveBeenCalled();
+    expect(
+      mockSetFlushCheckpoint.mock.calls.some((c) =>
+        c[0].includes("fake_broken_ack"),
+      ),
+    ).toBe(false);
+  });
+
+  test("an ack batch with mismatched rowIds ships nothing while other sources still ship", async () => {
+    const { source: brokenSource, acknowledge } = makeBrokenAckSource(
+      "fake_broken_ack",
+      ["row-1"],
+    );
+    const wmSource = makeWatermarkSource("fake_wm", ["wm-1"]);
+    const reporter = new UsageTelemetryReporter(
+      [brokenSource, wmSource],
+      fakeFlushCheckpointStore,
+    );
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(
+      body.events.map((e: { daemon_event_id: string }) => e.daemon_event_id),
+    ).toEqual(["wire-wm-1"]);
+    expect(acknowledge).not.toHaveBeenCalled();
+  });
+
+  // -------------------------------------------------------------------------
+  // outboxSource (real telemetry_events outbox behind an ack-mode source)
+  // -------------------------------------------------------------------------
+
+  // Synthetic name: these tests exercise the generic outbox machinery, not a
+  // shipped event type.
+  const OUTBOX_NAME = "test_outbox" as OutboxTelemetryEventName;
+
+  function seedOutboxRow(id: string, createdAt: number): void {
+    insertTelemetryOutboxEvent({
+      id,
+      name: OUTBOX_NAME,
+      createdAt,
+      event: fakeWireEvent(id, createdAt),
+    });
+  }
+
+  function pendingOutboxIds(): string[] {
+    return queryTelemetryOutboxBatch(OUTBOX_NAME, 1000).map((r) => r.id);
+  }
+
+  test("outboxSource ships pending rows and deletes them after a 2xx", async () => {
+    seedOutboxRow("ob-1", 1700000001000);
+    seedOutboxRow("ob-2", 1700000002000);
+    const reporter = new UsageTelemetryReporter(
+      [outboxSource(OUTBOX_NAME)],
+      fakeFlushCheckpointStore,
+    );
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(
+      body.events.map((e: { daemon_event_id: string }) => e.daemon_event_id),
+    ).toEqual(["wire-ob-1", "wire-ob-2"]);
+    expect(pendingOutboxIds()).toEqual([]);
+    // Ack-mode: flush_checkpoints untouched.
+    expect(mockSetFlushCheckpoint).not.toHaveBeenCalled();
+  });
+
+  test("outboxSource leaves rows intact when the POST fails", async () => {
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response("error", { status: 500 })),
+    );
+    seedOutboxRow("ob-1", 1700000001000);
+    const reporter = new UsageTelemetryReporter(
+      [outboxSource(OUTBOX_NAME)],
+      fakeFlushCheckpointStore,
+    );
+    await reporter.flush();
+
+    expect(pendingOutboxIds()).toEqual(["ob-1"]);
+    expect(mockSetFlushCheckpoint).not.toHaveBeenCalled();
+  });
+
+  test("outboxSource opt-out discards all pending rows for the name", async () => {
+    mockGetCachedShareAnalytics.mockReturnValue(false);
+    seedOutboxRow("ob-1", 1700000001000);
+    seedOutboxRow("ob-2", 1700000002000);
+    const reporter = new UsageTelemetryReporter(
+      [outboxSource(OUTBOX_NAME)],
+      fakeFlushCheckpointStore,
+    );
+    await reporter.flush();
+
+    expect(mockFetch).not.toHaveBeenCalled();
+    expect(pendingOutboxIds()).toEqual([]);
+    expect(mockSetFlushCheckpoint).not.toHaveBeenCalled();
+  });
+
+  test("outboxSource purges corrupt-payload rows at collect while valid siblings ship", async () => {
+    // Raw inserts: the store API only writes JSON.stringify-ed events, so
+    // corrupt payloads (invalid JSON, non-object JSON) go in directly.
+    getTelemetryDb()!
+      .insert(telemetryEvents)
+      .values([
+        {
+          id: "ob-corrupt-json",
+          name: OUTBOX_NAME,
+          createdAt: 1700000001000,
+          conversationId: null,
+          payload: "{not json",
+        },
+        {
+          id: "ob-non-object",
+          name: OUTBOX_NAME,
+          createdAt: 1700000002000,
+          conversationId: null,
+          payload: "42",
+        },
+      ])
+      .run();
+    seedOutboxRow("ob-valid", 1700000003000);
+    const reporter = new UsageTelemetryReporter(
+      [outboxSource(OUTBOX_NAME)],
+      fakeFlushCheckpointStore,
+    );
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(
+      body.events.map((e: { daemon_event_id: string }) => e.daemon_event_id),
+    ).toEqual(["wire-ob-valid"]);
+    // Corrupt rows are gone (purged at collect), the valid row via ack.
+    expect(pendingOutboxIds()).toEqual([]);
+  });
+
+  test("a full outbox batch drives recursion until the backlog drains", async () => {
+    // 501 rows: the first collect fills BATCH_SIZE (500) and the fullBatch
+    // recursion ships the remaining row.
+    for (let i = 0; i < 501; i++) {
+      seedOutboxRow(`ob-${String(i).padStart(3, "0")}`, 1700000000000 + i);
+    }
+    const reporter = new UsageTelemetryReporter(
+      [outboxSource(OUTBOX_NAME)],
+      fakeFlushCheckpointStore,
+    );
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    const secondBody = JSON.parse(
+      (mockFetch.mock.calls[1] as [string, RequestInit])[1].body as string,
+    );
+    expect(secondBody.events).toHaveLength(1);
+    expect(pendingOutboxIds()).toEqual([]);
+  });
+
+  // -------------------------------------------------------------------------
+  // Lifecycle events (outbox-backed)
+  // -------------------------------------------------------------------------
+
+  test("a recorded lifecycle event flushes once and its outbox row is deleted", async () => {
+    mockQueryUnreportedUsageEvents.mockReturnValue([]);
+    const recorded = recordLifecycleEvent("app_open");
+    expect(recorded).not.toBeNull();
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
+    );
+
+    const reporter = makeReporter();
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(body.events).toHaveLength(1);
+    // The stored payload IS the wire event — record-time version included.
+    expect(body.events[0]).toEqual({
+      type: "lifecycle",
+      daemon_event_id: recorded!.id,
+      event_name: "app_open",
+      recorded_at: recorded!.createdAt,
+      assistant_version: "1.2.3-test",
+    });
+    // Delete-on-flush: the outbox row is gone, and lifecycle (ack-mode)
+    // never touches flush_checkpoints.
+    expect(queryTelemetryOutboxBatch("lifecycle", 10)).toEqual([]);
+    expect(
+      mockSetFlushCheckpoint.mock.calls.some((c) =>
+        c[0].includes(":lifecycle:"),
+      ),
+    ).toBe(false);
+
+    // A second flush finds nothing pending — the event never re-ships.
+    mockFetch.mockClear();
+    await reporter.flush();
+    expect(mockFetch).not.toHaveBeenCalled();
   });
 });