feat(water-log): Smartsheet sync integration

Per-brand Smartsheet integration that pushes new water_log_entries to a
configured sheet. Config UI lives at /admin/water-log/settings.

Database (0093_water_smartsheet_sync.sql):
- water_smartsheet_config: one row per brand; AES-256-GCM encrypted API
  token (BYTEA), sheet id, column mapping JSONB, sync_frequency
  (realtime | every_15_minutes | hourly), enable flag, last-sync
  metadata. RLS via existing current_brand_id() pattern.
- water_smartsheet_sync_queue: one row per entry awaiting sync;
  tracks status / attempts / exponential backoff. UNIQUE(brand_id,
  entry_id) for idempotent enqueue.
- water_smartsheet_sync_log: append-only audit of every sync attempt
  (success or failure); backs the Recent Activity panel in the UI.

Server:
- src/lib/crypto.ts: AES-256-GCM encrypt/decrypt + token mask helper.
  Reads SMARTSHEET_TOKEN_ENC_KEY. Throws on missing/wrong-size key.
- src/lib/smartsheet.ts: typed REST wrapper (no SDK; the official
  smartsheet npm has Node 22 compat issues). getSheetMeta, addRow,
  findRowByColumn + typed SmartsheetApiError.
- src/services/smartsheet-sync.ts: syncEntryToSmartsheet (one entry),
  drainSyncQueue (batch with backoff), runScheduledSync (cron entry).
  Sequential processing stays well under Smartsheet's 300 req/min.
  Max 5 attempts, then row stays 'failed' permanently.
- src/actions/water-log/smartsheet.ts: 6 server actions. Token never
  returned in plaintext — UI gets maskedToken only. Permission check
  matches the rest of the water-log module (can_manage_water_log).
- src/app/api/water-log/smartsheet-sync/route.ts: POST cron route,
  bearer auth via SMARTSHEET_CRON_SECRET (falls back to CRON_SECRET).
  Optional {brandId} body for manual retry.
- vercel.json: added */15 * * * * cron entry. Single entry covers
  both 15-min and hourly frequencies (route filters per-brand).

UI:
- src/components/admin/water-log/SmartsheetIntegrationCard.tsx:
  self-contained client component with useReducer. Sections: enable
  toggle, sheet URL/ID + API token + Test Connection, sync frequency
  radio group, column mapping dropdowns (populated after Test),
  Recent Activity panel.
- src/app/admin/water-log/settings/page.tsx: mounted the card as new
  '§ 05 — Integrations' section after the existing admin-PIN settings.
  Card takes brandId as a prop (CLAUDE.md 'Brand ID Threading').

Hooks:
- src/actions/water-log/field.ts::submitWaterEntry: calls
  triggerSyncForEntry(brandId, entryId) in a fire-and-forget void
  after the entry insert. Sync failures NEVER bubble to the field
  worker.

Env vars (.env.example):
- SMARTSHEET_TOKEN_ENC_KEY (REQUIRED, 32 random bytes base64)
- SMARTSHEET_CRON_SECRET (optional bearer)
- SMARTSHEET_SYNC_TIMEOUT_MS (optional, default 8000)

Deploy:
1. openssl rand -base64 32 → SMARTSHEET_TOKEN_ENC_KEY in .env.local
   AND Vercel dashboard
2. npm run migrate:one 93  (pushes 0093_water_smartsheet_sync.sql)
3. Push triggers .gitea/workflows/deploy.yml

Rollback: remove cron entry, DROP the 3 tables, revert field.ts +
settings page hooks, git revert the merge commit. See MEMORY.md
for full rollback story + sharp edges (no key rotation, slug URLs).

db/schema/water-log.ts

@@ -24,11 +24,19 @@ import {
   index,
   uniqueIndex,
   integer,
-  check,
+  customType,
 } from "drizzle-orm/pg-core";
 import { brands } from "./brands";
 import { adminUsers } from "./brands";
 
+// Drizzle's stock `bytea` import is not exported in every version, so
+// register a small custom type that maps to the existing `bytea` PG type.
+const bytea = customType<{ data: Buffer; default: false }>({
+  dataType() {
+    return "bytea";
+  },
+});
+
 export const waterHeadgates = pgTable(
   "water_headgates",
   {
@@ -255,3 +263,177 @@ export type WaterAlertLog = typeof waterAlertLog.$inferSelect;
 export type WaterAdminSettings = typeof waterAdminSettings.$inferSelect;
 export type WaterAdminSession = typeof waterAdminSessions.$inferSelect;
 export type WaterAuditLog = typeof waterAuditLog.$inferSelect;
+
+// ── Smartsheet integration (added in 0093_water_smartsheet_sync.sql) ────────
+
+/**
+ * Allowed sync frequencies. Stored as TEXT to match the convention
+ * in CLAUDE.md ("Status enums stored as TEXT — no PostgreSQL ENUM type").
+ */
+export const SMARTSHEET_FREQUENCIES = [
+  "realtime",
+  "every_15_minutes",
+  "hourly",
+] as const;
+export type SmartsheetFrequency = (typeof SMARTSHEET_FREQUENCIES)[number];
+
+/**
+ * The Water-log fields a brand can map to their Smartsheet columns.
+ * `entry_id` and `logged_at` are required (used for dedup).
+ */
+export type SmartsheetColumnKey =
+  | "entry_id"
+  | "logged_at"
+  | "headgate"
+  | "measurement"
+  | "unit"
+  | "irrigator"
+  | "notes";
+export const SMARTSHEET_COLUMN_KEYS: readonly SmartsheetColumnKey[] = [
+  "entry_id",
+  "logged_at",
+  "headgate",
+  "measurement",
+  "unit",
+  "irrigator",
+  "notes",
+] as const;
+
+/**
+ * Shape stored in `water_smartsheet_config.column_mapping`. The values
+ * are Smartsheet column IDs (numeric strings, e.g. "8309876543210123").
+ *
+ * Only `entry_id` and `logged_at` are required (used for dedup). All
+ * other fields are nullable — `null` means "not mapped, don't write
+ * this column". The UI uses an empty string in the dropdown to mean
+ * the same thing and we coerce on the server.
+ */
+export type SmartsheetColumnMapping = {
+  entry_id: string;
+  logged_at: string;
+  headgate: string | null;
+  measurement: string | null;
+  unit: string | null;
+  irrigator: string | null;
+  notes: string | null;
+};
+
+export const waterSmartsheetConfig = pgTable("water_smartsheet_config", {
+  brandId: uuid("brand_id")
+    .primaryKey()
+    .references(() => brands.id, { onDelete: "cascade" }),
+  sheetId: text("sheet_id").notNull(),
+  encryptedApiToken: bytea("encrypted_api_token").notNull(),
+  tokenIv: bytea("token_iv").notNull(),
+  tokenAuthTag: bytea("token_auth_tag").notNull(),
+  columnMapping: jsonb("column_mapping")
+    .$type<SmartsheetColumnMapping>()
+    .notNull(),
+  syncFrequency: text("sync_frequency")
+    .$type<SmartsheetFrequency>()
+    .notNull()
+    .default("hourly"),
+  syncEnabled: boolean("sync_enabled").notNull().default(false),
+  lastSyncAt: timestamp("last_sync_at", { withTimezone: true }),
+  lastSyncError: text("last_sync_error"),
+  createdBy: text("created_by"),
+  updatedBy: text("updated_by"),
+  createdAt: timestamp("created_at", { withTimezone: true })
+    .notNull()
+    .defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true })
+    .notNull()
+    .defaultNow(),
+});
+
+export type WaterSmartsheetConfig = typeof waterSmartsheetConfig.$inferSelect;
+export type WaterSmartsheetConfigInsert = typeof waterSmartsheetConfig.$inferInsert;
+
+/**
+ * Sync queue status. Mirrors the SQL CHECK constraint.
+ */
+export const SMARTSHEET_QUEUE_STATUSES = [
+  "pending",
+  "syncing",
+  "synced",
+  "failed",
+] as const;
+export type SmartsheetQueueStatus = (typeof SMARTSHEET_QUEUE_STATUSES)[number];
+
+export const waterSmartsheetSyncQueue = pgTable(
+  "water_smartsheet_sync_queue",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    brandId: uuid("brand_id")
+      .notNull()
+      .references(() => brands.id, { onDelete: "cascade" }),
+    entryId: uuid("entry_id")
+      .notNull()
+      .references(() => waterLogEntries.id, { onDelete: "cascade" }),
+    smartsheetRowId: text("smartsheet_row_id"),
+    status: text("status")
+      .$type<SmartsheetQueueStatus>()
+      .notNull()
+      .default("pending"),
+    attempts: integer("attempts").notNull().default(0),
+    lastError: text("last_error"),
+    nextAttemptAt: timestamp("next_attempt_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    syncedAt: timestamp("synced_at", { withTimezone: true }),
+  },
+  (t) => ({
+    entryUnique: uniqueIndex("water_smartsheet_queue_entry_unique").on(
+      t.brandId,
+      t.entryId,
+    ),
+    brandStatusIdx: index("water_smartsheet_queue_brand_status_idx").on(
+      t.brandId,
+      t.status,
+      t.nextAttemptAt,
+    ),
+    brandRecentIdx: index("water_smartsheet_queue_brand_created_idx").on(
+      t.brandId,
+      t.createdAt,
+    ),
+  }),
+);
+
+export type WaterSmartsheetSyncQueue = typeof waterSmartsheetSyncQueue.$inferSelect;
+export type WaterSmartsheetSyncQueueInsert = typeof waterSmartsheetSyncQueue.$inferInsert;
+
+export const SMARTSHEET_LOG_ACTIONS = ["sync", "retry", "skip", "queue"] as const;
+export type SmartsheetLogAction = (typeof SMARTSHEET_LOG_ACTIONS)[number];
+
+export const waterSmartsheetSyncLog = pgTable(
+  "water_smartsheet_sync_log",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    brandId: uuid("brand_id")
+      .notNull()
+      .references(() => brands.id, { onDelete: "cascade" }),
+    entryId: uuid("entry_id").references(() => waterLogEntries.id, {
+      onDelete: "set null",
+    }),
+    smartsheetRowId: text("smartsheet_row_id"),
+    action: text("action").$type<SmartsheetLogAction>().notNull(),
+    success: boolean("success").notNull(),
+    error: text("error"),
+    durationMs: integer("duration_ms"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (t) => ({
+    brandRecentIdx: index("water_smartsheet_log_brand_recent_idx").on(
+      t.brandId,
+      t.createdAt,
+    ),
+  }),
+);
+
+export type WaterSmartsheetSyncLog = typeof waterSmartsheetSyncLog.$inferSelect;
+export type WaterSmartsheetSyncLogInsert = typeof waterSmartsheetSyncLog.$inferInsert;