fix(web): repair fizruk daily-log SQLite read path and make dual-write batches atomic

Two data-layer fixes from the fizruk module audit:

- sqliteReader selected the raw `entry_at` column while the cached shape
  (and `rowToDailyLog`) read `row.at`, so every cached daily-log entry
  carried `at: undefined`. That poisoned the dual-write baseline built
  from the cache (constant re-upsert churn) and would surface as lost
  timestamps once reads flip to SQLite. Alias `entry_at AS at` +
  regression test.
- applyFizrukDualWriteOps applied ops one-by-one with per-op catch, so a
  mid-batch failure left SQLite on a state that never existed in LS.
  The batch now runs in a BEGIN/COMMIT transaction with ROLLBACK on
  failure; the next dual-write tick retries the diff wholesale. Test
  covers the rollback path.

Author: Skords-01

apps/web/src/modules/fizruk/lib/dualWrite/__tests__/adapter.test.ts

@@ -306,14 +306,13 @@ describe("applyFizrukDualWriteOps", () => {
 
   // --- Error handling ---
 
-  it("logs errors and continues processing remaining ops", async () => {
+  it("counts every applied op in a clean batch", async () => {
     const warnings: unknown[] = [];
     const ops: FizrukDualWriteOp[] = [
       {
         kind: "measurement-upsert",
         measurement: { id: "m1", at: "2026-05-01T08:00:00Z" },
       },
-      // This will also succeed since we're just testing the counter
       {
         kind: "measurement-upsert",
         measurement: { id: "m2", at: "2026-05-01T09:00:00Z", weightKg: 75 },
@@ -329,6 +328,48 @@ describe("applyFizrukDualWriteOps", () => {
     expect(result.errored).toBe(0);
   });
 
+  it("rolls the whole batch back when one op fails", async () => {
+    const warnings: Array<{ msg: string; meta?: unknown }> = [];
+    const failingClient: typeof handle.client = {
+      ...handle.client,
+      exec: (sql) => handle.client.exec(sql),
+      all: (sql, params) => handle.client.all(sql, params),
+      run: (sql, params) => {
+        if (Array.isArray(params) && params.includes("m-fail")) {
+          throw new Error("forced failure");
+        }
+        return handle.client.run(sql, params);
+      },
+    };
+
+    const ops: FizrukDualWriteOp[] = [
+      {
+        kind: "measurement-upsert",
+        measurement: { id: "m-ok", at: "2026-05-01T08:00:00Z" },
+      },
+      {
+        kind: "measurement-upsert",
+        measurement: { id: "m-fail", at: "2026-05-01T09:00:00Z" },
+      },
+    ];
+
+    const result = await applyFizrukDualWriteOps(failingClient, ops, {
+      userId: UID,
+      clientTs: TS1,
+      logger: (_level, msg, meta) => warnings.push({ msg, meta }),
+    });
+
+    expect(result).toEqual({ applied: 0, errored: 2, skipped: 0 });
+    expect(warnings.some((w) => w.msg.includes("rolled back"))).toBe(true);
+
+    // The successful first op must NOT survive — SQLite stays on the
+    // pre-batch state instead of a half-applied diff.
+    const rows = await handle.client.all<Record<string, unknown>>(
+      "SELECT id FROM fizruk_measurements",
+    );
+    expect(rows).toEqual([]);
+  });
+
   // --- Stage 12 / PR #070f-dualwrite — Daily log ops ---
 
   it("upserts a daily-log entry with all scalar fields", async () => {

apps/web/src/modules/fizruk/lib/dualWrite/adapter.ts

@@ -57,24 +57,35 @@ export async function applyFizrukDualWriteOps(
   }
   const logger = options.logger ?? DEFAULT_LOGGER;
   let applied = 0;
-  let errored = 0;
   let skipped = 0;
 
-  for (const op of ops) {
-    try {
+  // The whole batch is atomic: a diff describes one LS-state transition, so
+  // applying half of it would leave SQLite on a state that never existed in
+  // LS and silently diverge until the next full diff. On any failure the
+  // transaction rolls back and the batch is retried wholesale by the next
+  // dual-write tick.
+  await client.exec("BEGIN");
+  try {
+    for (const op of ops) {
       const outcome = await applyOne(client, op, options);
       if (outcome === "applied") applied += 1;
       else skipped += 1;
-    } catch (err) {
-      errored += 1;
-      logger("warn", "dual-write op failed", {
-        op: op.kind,
-        error: err instanceof Error ? err.message : String(err),
-      });
     }
+    await client.exec("COMMIT");
+  } catch (err) {
+    try {
+      await client.exec("ROLLBACK");
+    } catch {
+      /* rollback failure is unrecoverable here; the original error wins */
+    }
+    logger("warn", "dual-write batch rolled back", {
+      ops: ops.length,
+      error: err instanceof Error ? err.message : String(err),
+    });
+    return { applied: 0, errored: ops.length, skipped: 0 };
   }
 
-  return { applied, errored, skipped };
+  return { applied, errored: 0, skipped };
 }
 
 type ApplyOutcome = "applied" | "skipped";

apps/web/src/modules/fizruk/lib/sqliteReader.test.ts

@@ -205,6 +205,35 @@ describe("refreshFizrukSqliteState", () => {
     expect(cache.measurements).toHaveLength(1);
     expect(cache.measurements[0]!.id).toBe("m-1");
   });
+
+  it("hydrates daily-log entries with their timestamp intact", async () => {
+    // Regression: the table column is `entry_at` while the cached shape is
+    // `at` — without the SQL alias the timestamp silently became undefined.
+    const ops: FizrukDualWriteOp[] = [
+      {
+        kind: "daily-log-upsert",
+        entry: {
+          id: "dl-1",
+          at: "2026-05-01T07:00:00Z",
+          weightKg: 81.2,
+          sleepHours: 7.5,
+          energyLevel: 4,
+          mood: 3,
+          note: "ранковий запис",
+        },
+      },
+    ];
+    await applyFizrukDualWriteOps(handle.client, ops, {
+      userId: UID,
+      clientTs: TS,
+      logger: silentLogger,
+    });
+
+    const cache = await refreshFizrukSqliteState(handle.client, UID);
+    expect(cache.dailyLog).toHaveLength(1);
+    expect(cache.dailyLog[0]!.at).toBe("2026-05-01T07:00:00Z");
+    expect(cache.dailyLog[0]!.weightKg).toBe(81.2);
+  });
 });
 
 describe("getCachedFizrukSqliteState", () => {

apps/web/src/modules/fizruk/lib/sqliteReader.ts

@@ -373,7 +373,7 @@ export async function refreshFizrukSqliteState(
       [userId],
     ),
     client.all<DailyLogRow>(
-      `SELECT id, entry_at, weight_kg, sleep_hours, energy_level, mood, note
+      `SELECT id, entry_at AS at, weight_kg, sleep_hours, energy_level, mood, note
          FROM fizruk_daily_log
         WHERE user_id = ? AND deleted_at IS NULL
         ORDER BY entry_at DESC, id ASC`,