FEA-1564: Resolve backfill timestamp review gaps

- Keep sessions.updated_at as an ingest-time sync cursor while preserving source dates for analytics.

- Touch existing sessions only when new backfill events are appended or a row is reactivated.

- Cover future source timestamps and appended no-timestamp event imports.

Testing: Focused collector import tests, desktop typecheck, desktop lint, and full desktop test suite passed.

Risks: Token usage updated_at remains source-dated because token analytics use token_usage.created_at and session sync is driven by sessions.updated_at.

Author: mikeangstadt

apps/desktop/src/main/collectors/import-session.ts

@@ -11,6 +11,8 @@ import type { Harness, NormalizedSession, NormalizedToolUse } from "./types.js";
  *
  * Idempotency (FEA-1503 AC): re-import adds nothing new.
  *  - session row: COALESCE-fill on conflict, never clobbers a live row.
+ *    `updated_at` stays an ingest-time mutation cursor for cloud sync; source
+ *    dates live on `started_at`, `ended_at`, events, and token usage analytics.
  *  - events: per-(session, event_type) high-water-mark on `created_at` — only
  *    events with a source timestamp strictly greater than the stored max are
  *    inserted. Backfill never stamps events with importer runtime `now`; when an
@@ -74,10 +76,12 @@ export function createImporter(db: DatabaseSync, deps: ImporterDeps): Importer {
       model = COALESCE(model, ?),
       cwd = COALESCE(cwd, ?),
       harness = CASE WHEN COALESCE(harness, '') = '' THEN ? ELSE harness END,
-      billing_mode = CASE WHEN COALESCE(billing_mode, '') IN ('', 'unknown') THEN ? ELSE billing_mode END,
-      updated_at = CASE WHEN updated_at IS NULL OR updated_at < ? THEN ? ELSE updated_at END
+      billing_mode = CASE WHEN COALESCE(billing_mode, '') IN ('', 'unknown') THEN ? ELSE billing_mode END
     WHERE id = ?
   `);
+  const touchSessionStmt = db.prepare(
+    "UPDATE sessions SET updated_at = CASE WHEN updated_at IS NULL OR updated_at < ? THEN ? ELSE updated_at END WHERE id = ?",
+  );
   const reactivateSessionStmt = db.prepare(
     "UPDATE sessions SET status = 'active', ended_at = NULL, updated_at = ? WHERE id = ?",
   );
@@ -228,8 +232,8 @@ export function createImporter(db: DatabaseSync, deps: ImporterDeps): Importer {
           session.cwd ?? null,
           session.model ?? null,
           startedAt,
-          sourceUpdatedAt,
-          status === "completed" ? session.endedAt ?? null : null,
+          now,
+          status === "completed" ? sourceUpdatedAt : null,
           harness,
           billingMode,
           buildMetadata(session, harness),
@@ -244,7 +248,7 @@ export function createImporter(db: DatabaseSync, deps: ImporterDeps): Importer {
           null,
           null,
           startedAt,
-          sourceUpdatedAt,
+          now,
           status === "completed" ? sourceUpdatedAt : null,
           null,
           null,
@@ -257,15 +261,13 @@ export function createImporter(db: DatabaseSync, deps: ImporterDeps): Importer {
           session.cwd ?? null,
           harness,
           billingMode,
-          sourceUpdatedAt,
-          sourceUpdatedAt,
           session.sessionId,
         );
         const isLive = existing.status === "active" && existing.ended_at == null;
         if (recentlyActive && !isLive) {
-          reactivateSessionStmt.run(sourceUpdatedAt, session.sessionId);
+          reactivateSessionStmt.run(now, session.sessionId);
           if (getAgentStmt.get(mainId)) {
-            reactivateMainAgentStmt.run(sourceUpdatedAt, mainId);
+            reactivateMainAgentStmt.run(now, mainId);
           }
           reactivated = true;
         }
@@ -327,7 +329,7 @@ export function createImporter(db: DatabaseSync, deps: ImporterDeps): Importer {
             strOf(input.subagent_type) ?? null,
             prompt ? prompt.slice(0, 500) : null,
             tu.timestamp ?? startedAt,
-            tu.timestamp ?? sourceUpdatedAt,
+            tu.timestamp ?? now,
             tu.timestamp ?? sourceUpdatedAt,
             mainId,
           );
@@ -352,6 +354,10 @@ export function createImporter(db: DatabaseSync, deps: ImporterDeps): Importer {
         deps.tokenUsage.replace(session.sessionId, model, counts, sourceUpdatedAt);
       }
 
+      if (existing != null && inserted > 0 && !reactivated) {
+        touchSessionStmt.run(now, now, session.sessionId);
+      }
+
       db.exec("COMMIT");
 
       const skipped = existing != null && inserted === 0 && !reactivated;

apps/desktop/test/collectors-import.test.ts

@@ -148,7 +148,7 @@ test("a new event with a later timestamp backfills without duplicating prior eve
   }
 });
 
-test("backfill writes source timestamps instead of importer runtime", () => {
+test("backfill source-dates analytics while preserving the sync mutation cursor", () => {
   const { db, cleanup } = openTempDb();
   try {
     const importer = createImporter(db.connection, {
@@ -177,10 +177,12 @@ test("backfill writes source timestamps instead of importer runtime", () => {
     const session = db.sessions.getById("old-session");
     assert.ok(session);
     assert.equal(session.status, "completed");
-    assert.equal(session.updatedAt, "2026-04-01T10:05:00.000Z");
+    assert.equal(session.startedAt, "2026-04-01T10:00:00.000Z");
+    assert.equal(session.endedAt, "2026-04-01T10:05:00.000Z");
+    assert.equal(session.updatedAt, "2026-06-06T12:00:00.000Z");
 
     const agent = db.agents.getBySession("old-session")[0];
-    assert.equal(agent.updatedAt, "2026-04-01T10:05:00.000Z");
+    assert.equal(agent.updatedAt, "2026-06-06T12:00:00.000Z");
 
     const events = db.events.getBySession("old-session");
     assert.equal(events.length, 3);
@@ -238,7 +240,134 @@ test("backfill falls back missing event timestamps to the source session date",
 
     const events = db.events.getBySession("missing-event-ts");
     assert.equal(events.length, 1);
-    assert.equal(events[0].createdAt, "2026-04-02T10:00:00.000Z");
+    assert.equal(events[0].createdAt, "2026-04-02T10:05:00.000Z");
+  } finally {
+    cleanup();
+  }
+});
+
+test("backfill appends new missing-timestamp events without high-water collision", () => {
+  const { db, cleanup } = openTempDb();
+  try {
+    const importer = createImporter(db.connection, {
+      tokenUsage: db.tokenUsage,
+      detectBillingMode: () => "api",
+      now: () => "2026-06-06T12:00:00.000Z",
+    });
+
+    importer.importSession(
+      makeSession({
+        sessionId: "missing-event-append",
+        startedAt: "2026-04-02T10:00:00.000Z",
+        endedAt: "2026-04-02T10:05:00.000Z",
+        messageTimestamps: [],
+        toolUses: [{ name: "Read", timestamp: null, input: { file: "a" } }],
+      }),
+      "codex",
+    );
+
+    importer.importSession(
+      makeSession({
+        sessionId: "missing-event-append",
+        startedAt: "2026-04-02T10:00:00.000Z",
+        endedAt: "2026-04-02T10:05:00.000Z",
+        messageTimestamps: [],
+        toolUses: [
+          { name: "Read", timestamp: null, input: { file: "a" } },
+          { name: "Read", timestamp: null, input: { file: "b" } },
+        ],
+      }),
+      "codex",
+    );
+
+    const events = db.events.getBySession("missing-event-append");
+    assert.equal(events.length, 2);
+    assert.deepEqual(
+      events.map((event) => event.createdAt),
+      [
+        "2026-04-02T10:05:00.000Z",
+        "2026-04-02T10:05:00.001Z",
+      ],
+    );
+  } finally {
+    cleanup();
+  }
+});
+
+test("historical backfill imported after sync cursor remains visible to incremental sync", () => {
+  const { db, cleanup } = openTempDb();
+  try {
+    db.connection.prepare(`
+      INSERT INTO sessions (id, name, status, started_at, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(
+      "cursor-sentinel",
+      "Cursor sentinel",
+      "completed",
+      "2026-06-06T11:59:00.000Z",
+      "2026-06-06T12:00:00.000Z",
+    );
+
+    const importer = createImporter(db.connection, {
+      tokenUsage: db.tokenUsage,
+      detectBillingMode: () => "api",
+      now: () => "2026-06-06T12:01:00.000Z",
+    });
+
+    importer.importSession(
+      makeSession({
+        sessionId: "old-after-cursor",
+        startedAt: "2026-04-01T10:00:00.000Z",
+        endedAt: "2026-04-01T10:05:00.000Z",
+        messageTimestamps: [],
+        toolUses: [],
+      }),
+      "codex",
+    );
+
+    const rows = db.connection.prepare(`
+      SELECT id
+      FROM sessions
+      WHERE updated_at >= ?
+      ORDER BY updated_at DESC, id DESC
+    `).all("2026-06-06T12:00:00.000Z") as Array<{ id: string }>;
+    assert.ok(
+      rows.some((row) => row.id === "old-after-cursor"),
+      "new historical imports must remain visible to updated_at cursor sync",
+    );
+    const session = db.sessions.getById("old-after-cursor");
+    assert.equal(session?.startedAt, "2026-04-01T10:00:00.000Z");
+    assert.equal(session?.updatedAt, "2026-06-06T12:01:00.000Z");
+  } finally {
+    cleanup();
+  }
+});
+
+test("future-dated source activity does not mark a backfilled session active", () => {
+  const { db, cleanup } = openTempDb();
+  try {
+    const importer = createImporter(db.connection, {
+      tokenUsage: db.tokenUsage,
+      detectBillingMode: () => "api",
+      now: () => "2026-06-06T12:00:00.000Z",
+    });
+
+    importer.importSession(
+      makeSession({
+        sessionId: "future-source",
+        startedAt: "2026-06-06T12:30:00.000Z",
+        endedAt: "2026-06-06T12:35:00.000Z",
+        fileModifiedAt: Date.parse("2026-06-06T11:59:00.000Z"),
+        messageTimestamps: [],
+        toolUses: [],
+      }),
+      "codex",
+    );
+
+    const session = db.sessions.getById("future-source");
+    assert.ok(session);
+    assert.equal(session.status, "completed");
+    assert.equal(session.updatedAt, "2026-06-06T12:00:00.000Z");
   } finally {
     cleanup();
   }