@gouthamjm1997/dayflow 0.1.0

package/.env.example

@@ -0,0 +1,2 @@
+NEXT_PUBLIC_SUPABASE_URL=https://YOUR_PROJECT.supabase.co
+NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY=YOUR_SUPABASE_PUBLISHABLE_KEY

package/README.md

@@ -0,0 +1,67 @@
+# Dayflow
+
+A personal, mobile-first web app for daily planning, focus sessions, and movement. It is a Next.js App Router project designed to be installable as a PWA. Supabase uses the official `@supabase/ssr` browser/server clients with a Next.js 16 `proxy.js` session refresher.
+
+## What works locally
+
+- Plan, complete, and remove tasks in Google Tasks–style sections: create, rename, and delete lists, add tasks into the active section, move a task between sections, and collapse completed work per list.
+- Forest-inspired focus: custom countdowns (1–180 minutes), stopwatch, task-linked sessions, reusable saved tags with add/remove controls, timer recovery after tab suspension/reload, editable session tags, a per-session tree collection, seven-day totals, and time-by-tag summaries.
+- Log and remove workouts; see recent movement history.
+- Follow the six-day gym split (Saturday optional, Sunday rest) with set/reps/kg logging, Jeff Nippard tier/video references, and per-lift progress charts.
+- Data is saved in this browser while cloud settings are not configured.
+- Google Calendar connection can read today's primary-calendar events and add a scheduled task as a 30-minute event.
+
+## Run it
+
+Requirements: Node.js 20.9 or newer.
+
+```sh
+npm install
+npm run dev
+```
+
+Open http://localhost:3000. Run `npm test` for the domain tests and `npm run build` for a production build.
+
+## Enable cross-device sync and Google Calendar
+
+The app uses Supabase Auth/Database and Google OAuth. Provider credentials are not included in this repository; the first local run works without them, but cloud sync and Google Calendar remain inactive until configured.
+
+1. Create a Supabase project and run `db/setup.sql` in its SQL editor. The table has row-level security so each signed-in user can access only their own record.
+2. In Supabase Auth, enable the Google provider. In Google Cloud, enable the Calendar API and configure an OAuth web client with the redirect URI shown by Supabase. Add the local site URL `http://localhost:3000` to Supabase's allowed redirect URLs.
+3. Allow the Google OAuth scopes `openid`, `email`, `profile`, and `https://www.googleapis.com/auth/calendar.events`. Add your account as a test user if the consent screen is in testing mode.
+4. Copy `.env.example` to `.env.local` and set `NEXT_PUBLIC_SUPABASE_URL` and `NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY` to the project's URL and publishable/anon key. Never put a Supabase service-role key or Google client secret in this file.
+5. Restart `npm run dev`, then use **Connect Google** in the app. That single sign-in enables Supabase data sync and requests calendar access. Calendar events are read only when you choose Calendar/Refresh; a task is only written to Calendar when you press its ↗ button.
+
+Calendar events use the primary calendar. Tasks, workout logs, and focus history sync as one private JSON record. The deployed project has Supabase Auth and database schema configured; a fresh clone still needs the setup steps above.
+
+## Dayflow CLI for Hermes
+
+The local CLI can read and update the signed-in Supabase user's Dayflow record. Run `npm run dayflow -- auth login` once; finish Google sign-in in the browser. The refresh token is kept in Windows Credential Manager, not in the repository. CLI requests use the publishable key plus the user's refreshed session and remain subject to the table's RLS policies; no service-role key is used.
+
+Examples: `npm run dayflow -- tasks list`, `npm run dayflow -- tasks list --list Work`, `npm run dayflow -- tasks add "Prepare project update" --list "Deep work"`, `npm run dayflow -- tasks complete <task-id>`, `npm run dayflow -- lists add "Errands"`, `npm run dayflow -- lists rename <list-id> --name "Home"`, `npm run dayflow -- workouts log --kind Walk --minutes 30 --date 2026-10-02`, and `npm run dayflow -- focus log --minutes 25 --tag "Deep Work"`. Focus logs accept `--tag`, `--seconds`, and `--timer-type countdown|stopwatch`. Task commands accept `--list` with either a list id or its exact name. Sign out with `npm run dayflow -- auth logout`. Sign-in needs `http://localhost:3000` to be free and allowlisted in Supabase.
+
+### Gym logging from the CLI
+
+`npm run dayflow -- gym days` lists each training day with the exercise ids used by `gym log`, then log a finished session:
+
+```sh
+npm run dayflow -- gym log --day day1-chest-arms --date 2026-10-02 \
+  --exercise machine-chest-press:3x10@40 --exercise preacher-curl:12@25,10@25
+```
+
+Repeat `--exercise <exercise-id>:<spec>` once per movement. A spec is either `sets x reps @ kg` (`3x10@40`) or an explicit set list (`12@25,10@25`); leave off `@kg` for bodyweight. `gym list` shows saved sessions, and tags passed to `focus log --tag` are added to the same reusable tag list the web picker reads.
+
+### Install the CLI from npm
+
+The CLI is published as the scoped package `@gouthamjm1997/dayflow` (`npm i -g @gouthamjm1997/dayflow`), which provides the `dayflow` command. It talks to your own Supabase project, so an installed copy reads its settings from the environment or a config file instead of the repository's `.env.local`:
+
+- `NEXT_PUBLIC_SUPABASE_URL` and `NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY`, or
+- `~/.dayflow/config.json` containing `{"url": "…", "publishableKey": "…"}`; override that path with `DAYFLOW_CONFIG`.
+
+Sign-in opens `http://localhost:3000` by default; set `DAYFLOW_REDIRECT_URL` (and allowlist it in Supabase) if that port is busy. Publishing needs your npm login and a fresh version: `npm login`, then `npm publish` from this repository.
+
+## Privacy / limitations
+
+Workout notes are personal wellness data. Cloud records are protected by Supabase row-level policies. There is no medical guidance, user export, or account deletion UI. The Google Calendar permission allows reading and editing events; the app only reads today's agenda and creates events for tasks you explicitly send.
+
+The gym plan and set history use the same local-first/signed-in cloud data record as other Dayflow data. Google Fit/Health Connect steps and calorie sync is not connected: Google's Fit APIs are scheduled for deprecation in 2026, and new developer sign-ups closed in May 2024. Health Connect access requires a separate Android integration rather than this browser app.

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@gouthamjm1997/dayflow",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Dayflow CLI — plan tasks, log focus sessions, and record gym sets against your own Supabase Dayflow project.",
+  "type": "module",
+  "license": "UNLICENSED",
+  "bin": {
+    "dayflow": "scripts/dayflow.mjs"
+  },
+  "files": [
+    "scripts/dayflow.mjs",
+    "src/dayflow-cli.mjs",
+    "src/dayflow-cli-auth.mjs",
+    "src/dayflow-data.mjs",
+    "src/gym-plan.mjs",
+    "src/task-lists.mjs",
+    "src/supabase-data.mjs",
+    ".env.example",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/gauthamjm007/dayflow.git"
+  },
+  "engines": {
+    "node": ">=20.9"
+  },
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "test": "node --test",
+    "dayflow": "node scripts/dayflow.mjs"
+  },
+  "dependencies": {
+    "@napi-rs/keyring": "^2.1.0",
+    "@supabase/ssr": "^0.12.7",
+    "@supabase/supabase-js": "^2.117.2",
+    "next": "^16.3.8",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0"
+  },
+  "devDependencies": {
+    "happy-dom": "^20.14.5"
+  }
+}

package/scripts/dayflow.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process'
+import { createServer } from 'node:http'
+import { readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createClient } from '@supabase/supabase-js'
+import { createRefreshTokenStore, exchangeDayflowCode, renewDayflowSession } from '../src/dayflow-cli-auth.mjs'
+import { executeDayflowCommand, parseDayflowCommand } from '../src/dayflow-cli.mjs'
+
+const REDIRECT_URL = process.env.DAYFLOW_REDIRECT_URL || 'http://localhost:3000'
+const REDIRECT_PORT = Number(new URL(REDIRECT_URL).port) || 80
+const CONFIG_PATH = process.env.DAYFLOW_CONFIG || join(homedir(), '.dayflow', 'config.json')
+const tokenStore = createRefreshTokenStore()
+const repoRoot = dirname(dirname(fileURLToPath(import.meta.url)))
+
+function readSupabaseConfig() {
+  const values = {
+    NEXT_PUBLIC_SUPABASE_URL: process.env.NEXT_PUBLIC_SUPABASE_URL ?? '',
+    NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY: process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY ?? '',
+  }
+  const fill = (source) => {
+    if (!source || typeof source !== 'object') return
+    for (const [key, alternate] of [['NEXT_PUBLIC_SUPABASE_URL', 'url'], ['NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY', 'publishableKey']]) {
+      if (values[key]) continue
+      const value = source[key] ?? source[alternate]
+      if (typeof value === 'string' && value.trim()) values[key] = value.trim()
+    }
+  }
+  try {
+    fill(JSON.parse(readFileSync(CONFIG_PATH, 'utf8')))
+  } catch {
+    // The config file is optional; environment variables or a repository .env.local may supply the settings.
+  }
+  try {
+    const contents = readFileSync(join(repoRoot, '.env.local'), 'utf8')
+    const fromFile = {}
+    for (const line of contents.split(/\r?\n/)) {
+      const match = line.match(/^\s*(NEXT_PUBLIC_SUPABASE_URL|NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY)\s*=\s*(.*)\s*$/)
+      if (match) fromFile[match[1]] = match[2].replace(/^['"]|['"]$/g, '')
+    }
+    fill(fromFile)
+  } catch {
+    // A published install has no repository .env.local; use the config file or environment instead.
+  }
+  if (!values.NEXT_PUBLIC_SUPABASE_URL || !values.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY) {
+    throw new Error(`Supabase URL/publishable key not found. Set NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY, add them to ${CONFIG_PATH}, or keep them in the repository .env.local.`)
+  }
+  return { url: values.NEXT_PUBLIC_SUPABASE_URL, key: values.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY }
+}
+
+function createAuthClient(config, storage) {
+  return createClient(config.url, config.key, {
+    auth: {
+      flowType: 'pkce',
+      persistSession: false,
+      autoRefreshToken: false,
+      detectSessionInUrl: false,
+      ...(storage ? { storage } : {}),
+    },
+  })
+}
+
+function openBrowser(url) {
+  const command = process.platform === 'win32' ? 'cmd.exe' : process.platform === 'darwin' ? 'open' : 'xdg-open'
+  const args = process.platform === 'win32' ? ['/d', '/c', 'start', '""', `"${url.replaceAll('"', '')}"`] : [url]
+  const child = spawn(command, args, { detached: true, stdio: 'ignore', windowsHide: true, windowsVerbatimArguments: process.platform === 'win32' })
+  child.on('error', () => {})
+  child.unref()
+}
+
+async function login(config) {
+  const pkceValues = new Map()
+  const storage = {
+    async getItem(key) { return pkceValues.get(key) ?? null },
+    async setItem(key, value) { pkceValues.set(key, value) },
+    async removeItem(key) { pkceValues.delete(key) },
+  }
+  const authClient = createAuthClient(config, storage)
+  const { data, error } = await authClient.auth.signInWithOAuth({
+    provider: 'google',
+    options: { redirectTo: REDIRECT_URL, skipBrowserRedirect: true, scopes: 'email profile' },
+  })
+  if (error || !data?.url) throw new Error('Could not start Google sign-in. Check the Supabase Google provider settings.')
+
+  await new Promise((resolve, reject) => {
+    let settled = false
+    let signedInUser = null
+    let timer
+    const finish = (error) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      if (server.listening) server.close()
+      if (error) reject(error)
+      else resolve()
+    }
+    const server = createServer(async (request, response) => {
+      const callbackUrl = new URL(request.url ?? '/', REDIRECT_URL)
+      if (callbackUrl.pathname === '/connected' && signedInUser) {
+        response.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' })
+        response.end('<!doctype html><title>Dayflow CLI connected</title><p>Dayflow CLI connected. You can close this tab and return to the terminal.</p>')
+        finish()
+        return
+      }
+      const oauthError = callbackUrl.searchParams.get('error_description') ?? callbackUrl.searchParams.get('error')
+      if (oauthError) {
+        response.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' })
+        response.end('Google sign-in was not completed. Return to the terminal and try again.')
+        finish(new Error('Google sign-in was not completed.'))
+        return
+      }
+      const code = callbackUrl.searchParams.get('code')
+      if (!code) {
+        response.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' })
+        response.end('Waiting for Dayflow sign-in.')
+        return
+      }
+      try {
+        const result = await exchangeDayflowCode(authClient, code, tokenStore)
+        signedInUser = result.userId
+        response.writeHead(303, { Location: '/connected' })
+        response.end()
+      } catch {
+        response.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' })
+        response.end('Dayflow sign-in failed. Return to the terminal and try again.')
+        finish(new Error('Dayflow sign-in failed.'))
+      }
+    })
+    server.once('error', (error) => finish(error.code === 'EADDRINUSE'
+      ? new Error(`Port ${REDIRECT_PORT} is busy. Stop the local app server and retry dayflow auth login, or set DAYFLOW_REDIRECT_URL to a free port.`)
+      : error))
+    timer = setTimeout(() => finish(new Error('Google sign-in timed out. Run dayflow auth login again.')), 5 * 60 * 1000)
+    server.listen(REDIRECT_PORT, () => {
+      process.stdout.write('Opening Google sign-in. Complete it in the browser window.\n')
+      if (process.env.DAYFLOW_AUTH_MANUAL === '1') {
+        process.stdout.write(`Manual sign-in URL (short-lived): ${data.url}\n`)
+      }
+      openBrowser(data.url)
+    })
+  })
+  process.stdout.write('Dayflow CLI is signed in. The refresh token is stored in Windows Credential Manager.\n')
+}
+
+function printHelp() {
+  process.stdout.write([
+    'Dayflow CLI',
+    'Run as `dayflow <command>` when installed globally, or `npm run dayflow -- <command>` in this repository.',
+    '  auth login|status|logout',
+    '  tasks list [--list <list-id|name>]',
+    '  tasks add "Title" [--at "YYYY-MM-DDTHH:mm"] [--list <list-id|name>]',
+    '  tasks complete <task-id>',
+    '  tasks delete <task-id>',
+    '  tasks update <task-id> [--title "Title"] [--at "YYYY-MM-DDTHH:mm"] [--list <list-id|name>]',
+    '  lists list',
+    '  lists add "List name"',
+    '  lists rename <list-id> --name "List name"',
+    '  lists delete <list-id>',
+    '  workouts list',
+    '  workouts log --kind Walk --minutes 30 --date YYYY-MM-DD [--title "Title"] [--notes "..."]',
+    '  focus list',
+    '  focus log --minutes 25 [--task-id <task-id>] [--task-title "..."] [--tag <name>] [--seconds <n>] [--timer-type countdown|stopwatch]',
+    '  gym days',
+    '  gym list',
+    '  gym log --day <day-id> --date YYYY-MM-DD --exercise <exercise-id>:8@40 [--exercise ...]',
+    '',
+    'Config: NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY,',
+    `or ${CONFIG_PATH} holding {"url": "...", "publishableKey": "..."} (override with DAYFLOW_CONFIG).`,
+    `Sign-in redirect: ${REDIRECT_URL} (override with DAYFLOW_REDIRECT_URL).`,
+  ].join('\n') + '\n')
+}
+
+export async function runDayflowCli(argv = process.argv.slice(2)) {
+  if (!argv.length || argv[0] === '--help' || argv[0] === 'help') {
+    printHelp()
+    return
+  }
+  if (argv[0] === 'auth' && argv[1] === 'logout') {
+    tokenStore.clear()
+    process.stdout.write('Dayflow CLI signed out on this PC.\n')
+    return
+  }
+  const config = readSupabaseConfig()
+  if (argv[0] === 'auth' && argv[1] === 'login') return login(config)
+  if (argv[0] === 'auth' && argv[1] === 'status') {
+    const client = createAuthClient(config)
+    const session = await renewDayflowSession(client, tokenStore.get())
+    tokenStore.set(session.refreshToken)
+    process.stdout.write('Dayflow CLI is authenticated and can access your account.\n')
+    return
+  }
+
+  const command = parseDayflowCommand(argv)
+  const authClient = createAuthClient(config)
+  const session = await renewDayflowSession(authClient, tokenStore.get())
+  tokenStore.set(session.refreshToken)
+  const result = await executeDayflowCommand(authClient, session.userId, command)
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`)
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1])) {
+  runDayflowCli().catch((error) => {
+    process.stderr.write(`Dayflow CLI: ${error.message}\n`)
+    process.exitCode = 1
+  })
+}

package/src/dayflow-cli-auth.mjs

@@ -0,0 +1,48 @@
+import { Entry } from '@napi-rs/keyring'
+
+export function createRefreshTokenStore(entry = new Entry('Dayflow CLI', 'supabase-refresh-token')) {
+  return {
+    get() {
+      try {
+        return entry.getPassword() || null
+      } catch {
+        return null
+      }
+    },
+    set(token) {
+      if (!token) throw new Error('Cannot store an empty Dayflow refresh token.')
+      entry.setPassword(token)
+    },
+    clear() {
+      try {
+        entry.deletePassword()
+      } catch {
+        return false
+      }
+      return true
+    },
+  }
+}
+
+export async function exchangeDayflowCode(client, code, tokenStore) {
+  if (!code) throw new Error('Google sign-in did not return an authorization code.')
+  const { data, error } = await client.auth.exchangeCodeForSession(code)
+  if (error || !data?.session?.refresh_token || !data.session.user?.id) {
+    throw new Error('Dayflow sign-in failed. Run dayflow auth login again.')
+  }
+  tokenStore.set(data.session.refresh_token)
+  return { userId: data.session.user.id }
+}
+
+export async function renewDayflowSession(client, refreshToken) {
+  if (!refreshToken) throw new Error('No Dayflow login is stored. Run dayflow auth login.')
+  const { data, error } = await client.auth.refreshSession({ refresh_token: refreshToken })
+  if (error || !data?.session?.access_token || !data.session.refresh_token || !data.session.user?.id) {
+    throw new Error('Dayflow login expired or could not be refreshed. Run dayflow auth login again.')
+  }
+  return {
+    accessToken: data.session.access_token,
+    refreshToken: data.session.refresh_token,
+    userId: data.session.user.id,
+  }
+}

package/src/dayflow-cli.mjs

@@ -0,0 +1,188 @@
+import { GYM_DAYS } from './gym-plan.mjs'
+import { applyDayflowMutation, getDayflowPayload } from './dayflow-data.mjs'
+import { resolveTaskList } from './task-lists.mjs'
+
+const toInput = (options, mappings) => {
+  const input = {}
+  for (const [option, field] of mappings) {
+    if (options[option] !== undefined) input[field] = options[option]
+  }
+  return input
+}
+
+const setSpec = (reps, weight) => ({ reps, weight: weight === undefined ? 0 : Number(weight), completed: true })
+
+export function parseExerciseSpec(entry) {
+  const text = String(entry ?? '').trim()
+  const separator = text.indexOf(':')
+  if (separator < 1) {
+    throw new Error(`Unsupported exercise "${text}". Use <exercise-id>:<reps@kg,...> or <exercise-id>:<sets>x<reps>@<kg>.`)
+  }
+  const exerciseId = text.slice(0, separator).trim()
+  const spec = text.slice(separator + 1).trim()
+  if (!exerciseId || !spec) {
+    throw new Error(`Unsupported exercise "${text}". Add the completed sets after the exercise id.`)
+  }
+
+  const preset = spec.match(/^(\d+)\s*x\s*(\d+)(?:\s*@\s*(\d+(?:\.\d+)?))?$/i)
+  if (preset) {
+    const [, setCount, reps, weight] = preset
+    return { exerciseId, sets: Array.from({ length: Number(setCount) }, () => setSpec(Number(reps), weight)) }
+  }
+
+  const sets = spec.split(',').map((piece) => {
+    const match = String(piece).trim().match(/^(\d+)(?:\s*@\s*(\d+(?:\.\d+)?))?$/)
+    if (!match) throw new Error(`Unsupported set "${String(piece).trim()}" for ${exerciseId}. Use reps or reps@kg, separated by commas.`)
+    return setSpec(Number(match[1]), match[2])
+  })
+  return { exerciseId, sets }
+}
+
+export function parseDayflowCommand(argv) {
+  const [group, action, ...rest] = Array.isArray(argv) ? argv : []
+  const options = {}
+  const positionals = []
+
+  const assign = (key, value) => {
+    if (options[key] === undefined) options[key] = value
+    else options[key] = Array.isArray(options[key]) ? [...options[key], value] : [options[key], value]
+  }
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index]
+    if (!token.startsWith('--')) {
+      positionals.push(token)
+      continue
+    }
+    const key = token.slice(2)
+    if (!key) throw new Error('Unsupported command: empty option name.')
+    const next = rest[index + 1]
+    if (next !== undefined && !next.startsWith('--')) {
+      assign(key, next)
+      index += 1
+    } else {
+      assign(key, true)
+    }
+  }
+
+  if (options.list === true) throw new Error('Unsupported command: --list needs a list id or name.')
+
+  if (group === 'tasks' && action === 'list') {
+    const list = options.list
+    return list === undefined ? { operation: 'list_tasks' } : { operation: 'list_tasks', input: { listId: list } }
+  }
+  if (group === 'tasks' && action === 'add') {
+    const title = positionals.join(' ').trim()
+    if (!title) throw new Error('Unsupported command: task title is required.')
+    return {
+      operation: 'add_task',
+      input: { title, ...toInput(options, [['at', 'scheduledAt'], ['list', 'listId']]) },
+    }
+  }
+  if (group === 'tasks' && action === 'complete') {
+    const id = positionals[0]
+    if (!id) throw new Error('Unsupported command: task ID is required.')
+    return { operation: 'complete_task', input: { id } }
+  }
+  if (group === 'tasks' && action === 'delete') {
+    const id = positionals[0]
+    if (!id) throw new Error('Unsupported command: task ID is required.')
+    return { operation: 'delete_task', input: { id } }
+  }
+  if (group === 'tasks' && action === 'update') {
+    const id = positionals[0]
+    if (!id) throw new Error('Unsupported command: task ID is required.')
+    return {
+      operation: 'update_task',
+      input: { id, ...toInput(options, [['title', 'title'], ['at', 'scheduledAt'], ['list', 'listId']]) },
+    }
+  }
+  if (group === 'lists' && action === 'list') return { operation: 'list_task_lists' }
+  if (group === 'lists' && action === 'add') {
+    const name = positionals.join(' ').trim()
+    if (!name) throw new Error('Unsupported command: list name is required.')
+    return { operation: 'add_task_list', input: { name } }
+  }
+  if (group === 'lists' && action === 'rename') {
+    const id = positionals[0]
+    if (!id) throw new Error('Unsupported command: list ID is required.')
+    if (typeof options.name !== 'string' || !options.name.trim()) throw new Error('Unsupported command: --name is required.')
+    return { operation: 'rename_task_list', input: { id, name: options.name } }
+  }
+  if (group === 'lists' && action === 'delete') {
+    const id = positionals[0]
+    if (!id) throw new Error('Unsupported command: list ID is required.')
+    return { operation: 'delete_task_list', input: { id } }
+  }
+  if (group === 'workouts' && action === 'list') return { operation: 'list_workouts' }
+  if (group === 'workouts' && action === 'log') {
+    return {
+      operation: 'log_workout',
+      input: {
+        ...toInput(options, [['kind', 'kind'], ['title', 'title'], ['date', 'date'], ['notes', 'notes']]),
+        ...(options.minutes !== undefined ? { duration: Number(options.minutes) } : {}),
+      },
+    }
+  }
+  if (group === 'focus' && action === 'list') return { operation: 'list_focus_sessions' }
+  if (group === 'focus' && action === 'log') {
+    return {
+      operation: 'log_focus_session',
+      input: {
+        ...toInput(options, [['task-id', 'taskId'], ['task-title', 'taskTitle'], ['completed-at', 'completedAt'], ['tag', 'tag'], ['seconds', 'seconds'], ['timer-type', 'timerType']]),
+        ...(options.minutes !== undefined ? { minutes: Number(options.minutes) } : {}),
+      },
+    }
+  }
+  if (group === 'gym' && action === 'days') return { operation: 'list_gym_days' }
+  if (group === 'gym' && action === 'list') return { operation: 'list_gym_sessions' }
+  if (group === 'gym' && action === 'log') {
+    const dayId = String(options.day ?? '').trim()
+    if (!dayId) throw new Error('Unsupported command: --day is required. Run `gym days` to see the day ids.')
+    const date = String(options.date ?? '').trim()
+    if (!date) throw new Error('Unsupported command: --date is required (YYYY-MM-DD).')
+    const entries = options.exercise === undefined ? [] : Array.isArray(options.exercise) ? options.exercise : [options.exercise]
+    if (!entries.length) throw new Error('Unsupported command: add at least one --exercise <exercise-id>:<sets>.')
+    return { operation: 'log_gym_session', input: { dayId, date, exercises: entries.map(parseExerciseSpec) } }
+  }
+
+  throw new Error(`Unsupported command: ${[group, action].filter(Boolean).join(' ') || '(empty)'}`)
+}
+
+export function getGymDaySummaries() {
+  return GYM_DAYS.map((day) => ({
+    id: day.id,
+    day: day.label,
+    focus: day.focus,
+    optional: Boolean(day.optional),
+    duration: day.duration,
+    exercises: day.exercises.map((item) => ({
+      id: item.id,
+      name: item.name,
+      sets: item.sets,
+      reps: item.reps,
+      tier: item.tier || null,
+    })),
+  }))
+}
+
+export async function executeDayflowCommand(client, userId, command, options) {
+  if (command.operation === 'list_gym_days') return getGymDaySummaries()
+  const listOperation = {
+    list_tasks: 'tasks',
+    list_task_lists: 'taskLists',
+    list_workouts: 'workouts',
+    list_focus_sessions: 'focusSessions',
+    list_gym_sessions: 'gymSessions',
+  }[command.operation]
+  if (listOperation) {
+    const payload = await getDayflowPayload(client, userId)
+    const items = payload[listOperation]
+    const reference = command.input?.listId
+    if (!reference) return items
+    const list = resolveTaskList(payload.taskLists, reference)
+    if (!list) throw new Error('Task list was not found.')
+    return items.filter((task) => task.listId === list.id)
+  }
+  return applyDayflowMutation(client, userId, command.operation, command.input ?? {}, options)
+}

package/src/dayflow-data.mjs

@@ -0,0 +1,239 @@
+import { createCloudStore } from './supabase-data.mjs'
+import { GYM_DAYS, createGymSession } from './gym-plan.mjs'
+import {
+  attachTaskListIds,
+  createTaskList,
+  hasTaskListName,
+  normalizeTaskListName,
+  normalizeTaskLists,
+  resolveTaskList,
+} from './task-lists.mjs'
+
+const emptyPayload = () => ({
+  taskLists: [],
+  tasks: [],
+  workouts: [],
+  gymSessions: [],
+  focusSessions: [],
+  focusTags: [],
+  selectedFocusTaskId: null,
+})
+
+function normalizeFocusTags(tags) {
+  const cleaned = (Array.isArray(tags) ? tags : [])
+    .map((tag) => String(tag ?? '').trim().slice(0, 32))
+    .filter(Boolean)
+  return [...new Map(cleaned.map((tag) => [tag.toLocaleLowerCase(), tag])).values()]
+    .sort((a, b) => a.localeCompare(b))
+}
+
+export function normalizeDayflowPayload(payload) {
+  const source = payload && typeof payload === 'object' && !Array.isArray(payload) ? payload : {}
+  const focusSessions = Array.isArray(source.focusSessions) ? structuredClone(source.focusSessions) : []
+  const taskLists = normalizeTaskLists(source.taskLists)
+  return {
+    ...source,
+    taskLists,
+    tasks: attachTaskListIds(
+      Array.isArray(source.tasks) ? structuredClone(source.tasks) : [],
+      taskLists,
+    ),
+    workouts: Array.isArray(source.workouts) ? structuredClone(source.workouts) : [],
+    gymSessions: Array.isArray(source.gymSessions) ? structuredClone(source.gymSessions) : [],
+    focusSessions,
+    focusTags: normalizeFocusTags(Array.isArray(source.focusTags) ? source.focusTags : focusSessions.map((session) => session?.tag)),
+    selectedFocusTaskId: typeof source.selectedFocusTaskId === 'string' ? source.selectedFocusTaskId : null,
+  }
+}
+
+function resolveWritableTaskList(state, reference, { fallback = true } = {}) {
+  const value = String(reference ?? '').trim()
+  if (!value) {
+    if (!fallback) throw new Error('A task list is required.')
+    return state.taskLists[0]
+  }
+  const list = resolveTaskList(state.taskLists, value)
+  if (!list) throw new Error('Task list was not found.')
+  return list
+}
+
+export function mutateDayflowPayload(payload, operation, input, options = {}) {
+  const state = normalizeDayflowPayload(payload ?? emptyPayload())
+  const now = options.now ?? (() => new Date())
+  const makeId = options.makeId ?? (() => globalThis.crypto.randomUUID())
+  const createdAt = now().toISOString()
+
+  if (operation === 'add_task') {
+    const title = String(input.title ?? '').trim()
+    if (!title) throw new Error('A task title is required.')
+    if (title.length > 200) throw new Error('Task title must be 200 characters or fewer.')
+    const scheduledAt = String(input.scheduledAt ?? '').trim()
+    if (scheduledAt.length > 80) throw new Error('Scheduled time is too long.')
+    const list = resolveWritableTaskList(state, input.listId)
+    const task = { id: makeId(), title, scheduledAt, completed: false, listId: list.id, createdAt }
+    state.tasks.push(task)
+    return { payload: state, result: task }
+  }
+
+  if (operation === 'delete_task') {
+    const id = String(input.id ?? '').trim()
+    const taskIndex = state.tasks.findIndex((item) => item.id === id)
+    if (taskIndex < 0) throw new Error('Task was not found.')
+    const [task] = state.tasks.splice(taskIndex, 1)
+    if (state.selectedFocusTaskId === id) state.selectedFocusTaskId = null
+    return { payload: state, result: task }
+  }
+
+  if (operation === 'complete_task') {
+    const id = String(input.id ?? '').trim()
+    const task = state.tasks.find((item) => item.id === id)
+    if (!task) throw new Error('Task was not found.')
+    task.completed = true
+    return { payload: state, result: task }
+  }
+
+  if (operation === 'log_workout') {
+    const allowedKinds = new Set(['Strength', 'Walk', 'Run', 'Yoga', 'Cycling', 'Other'])
+    const kind = String(input.kind ?? '').trim()
+    if (!allowedKinds.has(kind)) throw new Error('Choose a supported workout activity.')
+    const duration = Number(input.duration)
+    if (!Number.isInteger(duration) || duration < 1 || duration > 600) {
+      throw new Error('Workout duration must be a whole number from 1 to 600 minutes.')
+    }
+    const date = String(input.date ?? '')
+    const parsedDate = new Date(`${date}T00:00:00.000Z`)
+    if (!date || Number.isNaN(parsedDate.valueOf()) || parsedDate.toISOString().slice(0, 10) !== date) {
+      throw new Error('Workout date must be a real date in YYYY-MM-DD format.')
+    }
+    const title = String(input.title ?? '').trim() || kind
+    const notes = String(input.notes ?? '').trim()
+    if (title.length > 70) throw new Error('Workout title must be 70 characters or fewer.')
+    if (notes.length > 240) throw new Error('Workout notes must be 240 characters or fewer.')
+    const workout = { id: makeId(), kind, title, duration, date, notes, createdAt }
+    state.workouts.push(workout)
+    return { payload: state, result: workout }
+  }
+
+  if (operation === 'log_gym_session') {
+    const dayId = String(input.dayId ?? '').trim()
+    const day = GYM_DAYS.find((item) => item.id === dayId)
+    if (!day || day.type !== 'strength') throw new Error('Choose a strength workout day.')
+    const planExercises = GYM_DAYS.flatMap((item) => item.exercises)
+    const exercises = (Array.isArray(input.exercises) ? input.exercises : []).map((item) => {
+      const exerciseId = String(item?.exerciseId ?? '').trim()
+      const planExercise = planExercises.find((entry) => entry.id === exerciseId)
+      if (!planExercise) throw new Error(`"${exerciseId}" is not part of the Dayflow gym plan.`)
+      return { exerciseId: planExercise.id, name: planExercise.name, sets: Array.isArray(item?.sets) ? item.sets : [] }
+    })
+    const session = createGymSession({ id: makeId(), dayId: day.id, date: String(input.date ?? ''), exercises })
+    state.gymSessions.push(session)
+    return { payload: state, result: session }
+  }
+
+  if (operation === 'log_focus_session') {
+    const minutes = Number(input.minutes)
+    if (!Number.isInteger(minutes) || minutes < 1 || minutes > 600) {
+      throw new Error('Focus duration must be a whole number from 1 to 600 minutes.')
+    }
+    const taskId = String(input.taskId ?? '').trim() || null
+    const task = taskId ? state.tasks.find((item) => item.id === taskId) : null
+    if (taskId && !task) throw new Error('Task was not found.')
+    const taskTitle = task?.title ?? (String(input.taskTitle ?? '').trim() || null)
+    const completedAt = input.completedAt ? new Date(input.completedAt) : now()
+    if (Number.isNaN(completedAt.valueOf())) throw new Error('Completion time must be a valid date.')
+    const session = {
+      taskId,
+      taskTitle,
+      minutes,
+      completedAt: completedAt.toISOString(),
+    }
+    const tag = String(input.tag ?? '').trim()
+    if (tag.length > 32) throw new Error('Focus tags must be 32 characters or fewer.')
+    if (tag) {
+      const saved = state.focusTags.find((item) => item.toLocaleLowerCase() === tag.toLocaleLowerCase()) || tag
+      session.tag = saved
+      if (!state.focusTags.includes(saved)) state.focusTags = normalizeFocusTags([...state.focusTags, saved])
+    }
+    if (input.seconds !== undefined) {
+      const seconds = Number(input.seconds)
+      if (!Number.isInteger(seconds) || seconds < 1 || seconds > 36000) {
+        throw new Error('Focus seconds must be a whole number from 1 to 36000.')
+      }
+      session.seconds = seconds
+    }
+    if (input.timerType !== undefined) {
+      if (!['countdown', 'stopwatch'].includes(input.timerType)) throw new Error('Choose a supported focus timer type.')
+      session.timerType = input.timerType
+    }
+    state.focusSessions.push(session)
+    return { payload: state, result: session }
+  }
+
+  if (operation === 'update_task') {
+    const id = String(input.id ?? '').trim()
+    const task = state.tasks.find((item) => item.id === id)
+    if (!task) throw new Error('Task was not found.')
+    const hasTitle = input.title !== undefined
+    const hasSchedule = input.scheduledAt !== undefined
+    const hasList = input.listId !== undefined
+    if (!hasTitle && !hasSchedule && !hasList) throw new Error('Provide a new title, scheduled time, or task list.')
+    if (hasTitle) {
+      const title = String(input.title).trim()
+      if (!title) throw new Error('A task title cannot be empty.')
+      if (title.length > 200) throw new Error('Task title must be 200 characters or fewer.')
+      task.title = title
+    }
+    if (hasSchedule) {
+      const scheduledAt = String(input.scheduledAt ?? '').trim()
+      if (scheduledAt.length > 80) throw new Error('Scheduled time is too long.')
+      task.scheduledAt = scheduledAt
+    }
+    if (hasList) task.listId = resolveWritableTaskList(state, input.listId, { fallback: false }).id
+    return { payload: state, result: task }
+  }
+
+  if (operation === 'add_task_list') {
+    if (hasTaskListName(state.taskLists, input.name)) throw new Error('A list with that name already exists.')
+    const list = createTaskList(input.name, { makeId, now })
+    state.taskLists.push(list)
+    return { payload: state, result: list }
+  }
+
+  if (operation === 'rename_task_list') {
+    const id = String(input.id ?? '').trim()
+    const list = state.taskLists.find((item) => item.id === id)
+    if (!list) throw new Error('Task list was not found.')
+    if (hasTaskListName(state.taskLists, input.name, id)) throw new Error('A list with that name already exists.')
+    list.name = normalizeTaskListName(input.name)
+    return { payload: state, result: list }
+  }
+
+  if (operation === 'delete_task_list') {
+    const id = String(input.id ?? '').trim()
+    const listIndex = state.taskLists.findIndex((item) => item.id === id)
+    if (listIndex < 0) throw new Error('Task list was not found.')
+    if (state.taskLists.length < 2) throw new Error('Keep at least one task list.')
+    const [list] = state.taskLists.splice(listIndex, 1)
+    const removed = state.tasks.filter((task) => task.listId === list.id)
+    state.tasks = state.tasks.filter((task) => task.listId !== list.id)
+    if (removed.some((task) => task.id === state.selectedFocusTaskId)) state.selectedFocusTaskId = null
+    return { payload: state, result: { ...list, removedTaskCount: removed.length } }
+  }
+
+  throw new Error(`Unsupported Dayflow operation: ${operation}`)
+}
+
+export async function getDayflowPayload(client, userId) {
+  if (!userId) throw new Error('A signed-in Dayflow user is required.')
+  const cloudStore = createCloudStore(client)
+  return normalizeDayflowPayload(await cloudStore.read(userId))
+}
+
+export async function applyDayflowMutation(client, userId, operation, input, options) {
+  if (!userId) throw new Error('A signed-in Dayflow user is required.')
+  const cloudStore = createCloudStore(client)
+  const currentPayload = await cloudStore.read(userId)
+  const { payload, result } = mutateDayflowPayload(currentPayload, operation, input, options)
+  await cloudStore.write(userId, payload)
+  return result
+}

package/src/gym-plan.mjs

@@ -0,0 +1,112 @@
+const exercise = (id, name, muscles, sets, reps, rest, videoUrl = '', tier = '', tip = '') => ({ id, name, muscles, sets, reps, rest, videoUrl, tier, tip })
+
+export const GYM_DAYS = [
+  {
+    id: 'day1-chest-arms', label: 'Monday', focus: 'Chest + Triceps + Biceps', type: 'strength', duration: '60–75 min',
+    groups: 'Chest · triceps · biceps', targetGroups: ['chest', 'triceps', 'biceps'],
+    exercises: [
+      exercise('machine-chest-press', 'Machine chest press', 'Chest', 3, '8–12', '2–3 min', 'https://youtu.be/fGm-ef-4PVk?t=276', 'S'),
+      exercise('incline-db-press', 'Incline dumbbell press', 'Upper chest · front delts', 3, '8–12', '2–3 min', 'https://youtu.be/fGm-ef-4PVk?t=256', 'A'),
+      exercise('seated-cable-fly', 'Seated cable pec fly', 'Chest', 2, '10–15', '1–2 min', 'https://youtu.be/fGm-ef-4PVk?t=649', 'S'),
+      exercise('triceps-pressdown', 'Bar cable triceps pressdown', 'Triceps · lateral/medial heads', 2, '10–15', '1–2 min', 'https://youtu.be/OpRMRhr0Ycc?t=129', 'A'),
+      exercise('preacher-curl', '45° preacher curl', 'Biceps', 2, '8–12', '1–2 min', 'https://youtu.be/GNO4OtYoCYk?t=265', 'S'),
+    ],
+  },
+  {
+    id: 'day2-back-deadlift', label: 'Tuesday', focus: 'Back + Deadlift + Rows', type: 'strength', duration: '60–75 min',
+    groups: 'Back · deadlift · rows', targetGroups: ['back', 'deadlift'],
+    exercises: [
+      exercise('deadlift', 'Barbell deadlift', 'Hip hinge · glutes · spinal erectors', 2, '4–6', '2–3 min', 'https://youtu.be/jLvqKgW-_G8?t=100', 'C tier for back', 'Included as requested for hinge/strength work; Jeff ranks it C-tier as a back hypertrophy exercise. Keep these crisp, not grinding.'),
+      exercise('chest-supported-row', 'Chest-supported row', 'Mid/upper back · lats', 3, '8–12', '2 min', 'https://youtu.be/jLvqKgW-_G8?t=533', 'S'),
+      exercise('neutral-grip-pulldown', 'Neutral-grip lat pulldown', 'Lats · upper back', 3, '8–12', '2 min', 'https://youtu.be/jLvqKgW-_G8?t=239', 'S'),
+      exercise('seated-cable-row', 'Seated cable row', 'Mid-back · lats', 2, '10–15', '1–2 min', 'https://youtu.be/jLvqKgW-_G8?t=562', 'S'),
+    ],
+  },
+  {
+    id: 'day3-shoulders-forearms-triceps', label: 'Wednesday', focus: 'Shoulders + Forearms + Triceps', type: 'strength', duration: '60–75 min',
+    groups: 'Front/side/rear delts · forearms · triceps', targetGroups: ['shoulders', 'forearms', 'triceps'],
+    exercises: [
+      exercise('dumbbell-shoulder-press', 'Seated dumbbell shoulder press', 'Front delts · shoulders', 2, '8–12', '2 min', 'https://youtu.be/SgyUoY0IZ7A?t=325', 'A'),
+      exercise('cable-lateral-raise', 'Cable lateral raise', 'Side delts', 3, '12–20', '1–2 min', 'https://youtu.be/SgyUoY0IZ7A?t=477', 'S+'),
+      exercise('reverse-cable-crossover', 'Reverse cable crossover', 'Rear delts', 2, '12–20', '1–2 min', 'https://youtu.be/SgyUoY0IZ7A?t=718', 'S'),
+      exercise('overhead-triceps-extension', 'Overhead cable triceps extension', 'Triceps · long head', 2, '10–15', '1–2 min', 'https://youtu.be/OpRMRhr0Ycc?t=193', 'S'),
+      exercise('wrist-curl', 'Dumbbell wrist curl', 'Forearm flexors', 2, '12–20', '1 min', 'https://youtu.be/MfMxT_jXcPE'),
+      exercise('reverse-wrist-curl', 'Dumbbell reverse wrist curl', 'Forearm extensors', 2, '12–20', '1 min', 'https://youtu.be/MfMxT_jXcPE'),
+    ],
+  },
+  {
+    id: 'day4-lower-chest-biceps', label: 'Thursday', focus: 'Lower Body + Chest + Biceps', type: 'strength', duration: '75–90 min',
+    groups: 'Quads · hamstrings · glutes · calves · chest · biceps', targetGroups: ['lower-body', 'chest', 'biceps'],
+    exercises: [
+      exercise('hack-squat', 'Hack squat', 'Quads · glutes', 3, '8–12', '2–3 min', 'https://youtu.be/kIXcoivzGf8?t=276', 'S+'),
+      exercise('romanian-deadlift', 'Romanian deadlift', 'Hamstrings · glutes', 2, '8–12', '2 min', 'https://youtu.be/3ryh7PNhz3E?t=701', 'A for glutes'),
+      exercise('seated-leg-curl', 'Seated leg curl', 'Hamstrings', 2, '10–15', '1–2 min', 'https://youtu.be/0a_fVS2s4Ho'),
+      exercise('standing-calf-raise', 'Standing calf raise', 'Calves', 2, '10–15', '1–2 min'),
+      exercise('incline-db-press', 'Incline dumbbell press', 'Upper chest', 2, '8–12', '2 min', 'https://youtu.be/fGm-ef-4PVk?t=256', 'A'),
+      exercise('seated-cable-fly', 'Seated cable pec fly', 'Chest', 2, '10–15', '1–2 min', 'https://youtu.be/fGm-ef-4PVk?t=649', 'S'),
+      exercise('bayesian-cable-curl', 'Face-away Bayesian cable curl', 'Biceps', 2, '10–15', '1–2 min', 'https://youtu.be/GNO4OtYoCYk?t=628', 'S+'),
+    ],
+  },
+  {
+    id: 'day5-back-shoulders', label: 'Friday', focus: 'Back + Shoulders', type: 'strength', duration: '60–75 min',
+    groups: 'Back · side delts · rear delts', targetGroups: ['back', 'shoulders'],
+    exercises: [
+      exercise('chest-supported-row', 'Chest-supported row', 'Mid/upper back · lats', 3, '8–12', '2 min', 'https://youtu.be/jLvqKgW-_G8?t=533', 'S'),
+      exercise('neutral-grip-pulldown', 'Neutral-grip lat pulldown', 'Lats · upper back', 3, '8–12', '2 min', 'https://youtu.be/jLvqKgW-_G8?t=239', 'S'),
+      exercise('cable-lateral-raise', 'Cable lateral raise', 'Side delts', 3, '12–20', '1–2 min', 'https://youtu.be/SgyUoY0IZ7A?t=477', 'S+'),
+      exercise('reverse-cable-crossover', 'Reverse cable crossover', 'Rear delts', 3, '12–20', '1–2 min', 'https://youtu.be/SgyUoY0IZ7A?t=718', 'S'),
+    ],
+  },
+  {
+    id: 'day6-lower-forearms', label: 'Saturday', focus: 'Lower Body + Forearms (Optional)', type: 'strength', duration: '60–75 min', optional: true,
+    groups: 'Quads · hamstrings · glutes · calves · forearms', targetGroups: ['lower-body', 'forearms'],
+    exercises: [
+      exercise('leg-press', '45° leg press', 'Quads · glutes', 3, '8–12', '2–3 min', 'https://youtu.be/kIXcoivzGf8?t=350', 'A'),
+      exercise('romanian-deadlift', 'Romanian deadlift', 'Hamstrings · glutes', 2, '8–12', '2 min', 'https://youtu.be/3ryh7PNhz3E?t=701', 'A for glutes'),
+      exercise('seated-leg-curl', 'Seated leg curl', 'Hamstrings', 2, '10–15', '1–2 min', 'https://youtu.be/0a_fVS2s4Ho'),
+      exercise('standing-calf-raise', 'Standing calf raise', 'Calves', 2, '10–15', '1–2 min'),
+      exercise('wrist-curl', 'Dumbbell wrist curl', 'Forearm flexors', 2, '12–20', '1 min', 'https://youtu.be/MfMxT_jXcPE'),
+      exercise('reverse-wrist-curl', 'Dumbbell reverse wrist curl', 'Forearm extensors', 2, '12–20', '1 min', 'https://youtu.be/MfMxT_jXcPE'),
+    ],
+  },
+]
+
+const validDate = (date) => /^\d{4}-\d{2}-\d{2}$/.test(date)
+  && !Number.isNaN(Date.parse(`${date}T00:00:00Z`))
+  && new Date(`${date}T00:00:00Z`).toISOString().slice(0, 10) === date
+
+export function createGymSession({ id, dayId, date, exercises }) {
+  if (!id) throw new Error('A gym session id is required.')
+  const day = GYM_DAYS.find((item) => item.id === dayId)
+  if (!day || day.type !== 'strength') throw new Error('Choose a strength workout day.')
+  if (!validDate(date)) throw new Error('Enter a valid session date.')
+  if (!Array.isArray(exercises)) throw new Error('Gym exercises must be a list.')
+
+  const loggedExercises = exercises.map((item) => {
+    if (!item?.exerciseId || !item.name || !Array.isArray(item.sets)) throw new Error('Each exercise needs a name and set list.')
+    const sets = item.sets.filter((set) => set.completed).map(({ reps, weight }) => {
+      const cleanReps = Number(reps)
+      const cleanWeight = Number(weight)
+      if (!Number.isInteger(cleanReps) || cleanReps < 1 || cleanReps > 100) throw new Error('Completed sets need reps between 1 and 100.')
+      if (!Number.isFinite(cleanWeight) || cleanWeight < 0 || cleanWeight > 1000) throw new Error('Enter a weight from 0 to 1000 kg.')
+      return { reps: cleanReps, weight: cleanWeight }
+    })
+    return sets.length ? { exerciseId: String(item.exerciseId), name: String(item.name), sets } : null
+  }).filter(Boolean)
+
+  if (!loggedExercises.length) throw new Error('Mark at least one completed set before saving.')
+  return { id: String(id), dayId, date, exercises: loggedExercises, createdAt: new Date().toISOString() }
+}
+
+export function getExerciseProgress(sessions, exerciseId) {
+  return sessions
+    .flatMap((session) => {
+      const sets = (session.exercises || [])
+        .filter((item) => item.exerciseId === exerciseId)
+        .flatMap((item) => item.sets || [])
+      if (!sets.length) return []
+      const best = sets.reduce((current, set) => Number(set.weight) > Number(current.weight) ? set : current)
+      return [{ date: session.date, bestWeight: Number(best.weight), bestReps: Number(best.reps) }]
+    })
+    .sort((a, b) => a.date.localeCompare(b.date))
+}

package/src/supabase-data.mjs

@@ -0,0 +1,32 @@
+export function getSupabaseConfig(env = {}) {
+  const url = String(env.NEXT_PUBLIC_SUPABASE_URL || '').trim()
+  const key = String(
+    env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY || env.NEXT_PUBLIC_SUPABASE_ANON_KEY || '',
+  ).trim()
+  return url && key ? { url, key } : null
+}
+
+export function createCloudStore(client) {
+  if (!client) throw new Error('A Supabase client is required.')
+
+  return {
+    async read(userId) {
+      if (!userId) throw new Error('A signed-in user is required to load cloud data.')
+      const { data, error } = await client
+        .from('user_data')
+        .select('payload')
+        .eq('user_id', userId)
+        .maybeSingle()
+      if (error) throw error
+      return data?.payload ?? null
+    },
+
+    async write(userId, payload) {
+      if (!userId) throw new Error('A signed-in user is required to save cloud data.')
+      const { error } = await client
+        .from('user_data')
+        .upsert({ user_id: userId, payload, updated_at: new Date().toISOString() }, { onConflict: 'user_id' })
+      if (error) throw error
+    },
+  }
+}

package/src/task-lists.mjs

@@ -0,0 +1,72 @@
+export const DEFAULT_TASK_LIST_ID = 'list-default'
+export const DEFAULT_TASK_LIST_NAME = 'My Tasks'
+export const TASK_LIST_NAME_LIMIT = 60
+
+const cleanName = (value) => String(value ?? '').trim().replace(/\s+/g, ' ')
+
+/**
+ * Keeps the saved task lists in a predictable shape and guarantees at least one list,
+ * so every task always has a section to live in.
+ */
+export function normalizeTaskLists(lists) {
+  const cleaned = (Array.isArray(lists) ? lists : [])
+    .filter((list) => list && typeof list === 'object')
+    .map((list) => ({
+      ...list,
+      id: String(list.id ?? '').trim(),
+      name: cleanName(list.name).slice(0, TASK_LIST_NAME_LIMIT),
+    }))
+    .filter((list) => list.id && list.name)
+  const unique = []
+  for (const list of cleaned) {
+    if (!unique.some((saved) => saved.id === list.id)) unique.push(list)
+  }
+  return unique.length ? unique : [{ id: DEFAULT_TASK_LIST_ID, name: DEFAULT_TASK_LIST_NAME, createdAt: '' }]
+}
+
+/** Points every task at a section that still exists, defaulting to the first list. */
+export function attachTaskListIds(tasks, lists) {
+  const normalizedLists = normalizeTaskLists(lists)
+  const known = new Set(normalizedLists.map((list) => list.id))
+  const fallback = normalizedLists[0].id
+  return (Array.isArray(tasks) ? tasks : []).map((task) => {
+    const listId = String(task?.listId ?? '').trim()
+    return known.has(listId) ? task : { ...task, listId: fallback }
+  })
+}
+
+export function normalizeTaskListName(name) {
+  const listName = cleanName(name).slice(0, TASK_LIST_NAME_LIMIT)
+  if (!listName) throw new Error('A list name is required.')
+  if (cleanName(name).length > TASK_LIST_NAME_LIMIT) {
+    throw new Error(`List names must be ${TASK_LIST_NAME_LIMIT} characters or fewer.`)
+  }
+  return listName
+}
+
+export function createTaskList(name, options = {}) {
+  const makeId = options.makeId ?? (() => globalThis.crypto.randomUUID())
+  const now = options.now ?? (() => new Date())
+  return { id: makeId(), name: normalizeTaskListName(name), createdAt: now().toISOString() }
+}
+
+/** Finds a list by id or by exact (case-insensitive) name; an ambiguous name resolves to nothing. */
+export function resolveTaskList(lists, reference) {
+  const value = String(reference ?? '').trim()
+  if (!value) return null
+  const byId = (Array.isArray(lists) ? lists : []).find((list) => list.id === value)
+  if (byId) return byId
+  const lowered = value.toLocaleLowerCase()
+  const matches = (Array.isArray(lists) ? lists : []).filter((list) => String(list.name).toLocaleLowerCase() === lowered)
+  return matches.length === 1 ? matches[0] : null
+}
+
+export function resolveTaskListId(lists, reference) {
+  return resolveTaskList(lists, reference)?.id ?? ''
+}
+
+export function hasTaskListName(lists, name, ignoreId = '') {
+  const lowered = cleanName(name).toLocaleLowerCase()
+  return (Array.isArray(lists) ? lists : [])
+    .some((list) => list.id !== ignoreId && String(list.name).toLocaleLowerCase() === lowered)
+}