[Developer] #204 Phase 1 MVP — Flutter app skeleton complete

- Drift 21 tables (8 catalog + 11 user + habit_dose_variants + meta_kv)
  with R1~R10 CHECK constraints and 19 indexes
- 8 hand-crafted seed JSON catalogs in app/assets/seed/
  (refs 84, protocols 34, methodologies 21, frame_patterns 30,
   reward_menu_items 30, break_protocols 8, common_frames 5, diet_patterns 5)
- 6 domain functions: recommend_variant, compute_streak,
  validate_frame_level, active_habit_quota, weekly_minimum_ratio,
  seed_importer (transactional, idempotent)
- 4 vertical-slice Riverpod screens: HabitList, HabitCreate, CheckIn, Streak
- 31 unit tests passing; flutter analyze clean
- OQ-5 streak semantics: missing entry ≠ explicit blank
  (missing = end of history; only TrackerValue.blank triggers Never-miss-twice)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app/lib/data/db/daos/habit_dao.dart

@@ -0,0 +1,147 @@
+import 'dart:convert';
+
+import 'package:drift/drift.dart';
+
+import '../../../core/id.dart';
+import '../../../domain/models/habit.dart';
+import '../../../domain/rules/xor_protocol.dart';
+import '../app_database.dart';
+import '../tables/user_tables.dart';
+
+part 'habit_dao.g.dart';
+
+class HabitDraft {
+  final String userId;
+  final HabitType type;
+  final String title;
+  final String? protocolId;
+  final String? breakProtocolId;
+  final FrameLevel frameLevel;
+  final String frameFramedText;
+  final String? frameOriginalText;
+  final String? anchorWhen;
+  final String? anchorAfterWhat;
+  final String? anchorWhere;
+  final String startedAt;
+  final String? phaseId;
+  final List<VariantDraft> variants;
+
+  const HabitDraft({
+    required this.userId,
+    required this.type,
+    required this.title,
+    required this.frameLevel,
+    required this.frameFramedText,
+    required this.startedAt,
+    this.protocolId,
+    this.breakProtocolId,
+    this.frameOriginalText,
+    this.anchorWhen,
+    this.anchorAfterWhat,
+    this.anchorWhere,
+    this.phaseId,
+    this.variants = const [],
+  });
+}
+
+class VariantDraft {
+  final String label;
+  final String doseText;
+  final List<String> contextTags;
+  final List<String> conditionTags;
+  final bool isMinimum;
+  final int sortOrder;
+
+  const VariantDraft({
+    required this.label,
+    required this.doseText,
+    this.contextTags = const [],
+    this.conditionTags = const [],
+    this.isMinimum = false,
+    this.sortOrder = 0,
+  });
+}
+
+@DriftAccessor(tables: [Habits, HabitDoseVariants])
+class HabitDao extends DatabaseAccessor<AppDatabase> with _$HabitDaoMixin {
+  HabitDao(super.db);
+
+  /// Insert habit + variants atomically.
+  Future<String> insertWithVariants(HabitDraft draft) async {
+    assertXorProtocol(
+      type: draft.type,
+      protocolId: draft.protocolId,
+      breakProtocolId: draft.breakProtocolId,
+    );
+    final habitId = generateUlid('hb');
+    await transaction(() async {
+      await into(habits).insert(HabitsCompanion.insert(
+        id: habitId,
+        userId: draft.userId,
+        type: draft.type.dbValue,
+        status: 'active',
+        title: draft.title,
+        protocolId: Value(draft.protocolId),
+        breakProtocolId: Value(draft.breakProtocolId),
+        frameLevel: draft.frameLevel.dbValue,
+        frameFramedText: draft.frameFramedText,
+        frameOriginalText: Value(draft.frameOriginalText),
+        anchorWhen: Value(draft.anchorWhen),
+        anchorAfterWhat: Value(draft.anchorAfterWhat),
+        anchorWhere: Value(draft.anchorWhere),
+        startedAt: draft.startedAt,
+        phaseId: Value(draft.phaseId),
+      ));
+      for (final v in draft.variants) {
+        await into(habitDoseVariants).insert(HabitDoseVariantsCompanion.insert(
+          variantId: generateUlid('dv'),
+          habitId: habitId,
+          label: v.label,
+          doseText: v.doseText,
+          contextTagsJson: Value(jsonEncode(v.contextTags)),
+          conditionTagsJson: Value(jsonEncode(v.conditionTags)),
+          isMinimum: Value(v.isMinimum),
+          sortOrder: Value(v.sortOrder),
+        ));
+      }
+    });
+    return habitId;
+  }
+
+  Future<int> countActive({
+    required String userId,
+    required HabitType type,
+    String? excludeHabitId,
+  }) async {
+    final query = select(habits)
+      ..where((t) => t.userId.equals(userId))
+      ..where((t) => t.status.equals('active'))
+      ..where((t) => t.type.equals(type.dbValue));
+    if (excludeHabitId != null) {
+      query.where((t) => t.id.isNotValue(excludeHabitId));
+    }
+    final rows = await query.get();
+    return rows.length;
+  }
+
+  Future<List<Habit>> activeHabitsForUser(String userId) {
+    return (select(habits)
+          ..where((t) => t.userId.equals(userId))
+          ..where((t) => t.status.equals('active')))
+        .get();
+  }
+
+  Future<List<HabitDoseVariant>> variantsForHabit(String habitId) {
+    return (select(habitDoseVariants)
+          ..where((t) => t.habitId.equals(habitId))
+          ..orderBy([(t) => OrderingTerm.asc(t.sortOrder)]))
+        .get();
+  }
+
+  Future<List<HabitDoseVariant>> variantsByIds(Set<String> ids) {
+    if (ids.isEmpty) return Future.value(const []);
+    return (select(habitDoseVariants)
+          ..where((t) => t.variantId.isIn(ids)))
+        .get();
+  }
+}

app/lib/data/db/daos/habit_dao.g.dart

@@ -0,0 +1,12 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'habit_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$HabitDaoMixin on DatabaseAccessor<AppDatabase> {
+  $UsersTable get users => attachedDatabase.users;
+  $PhasesTable get phases => attachedDatabase.phases;
+  $HabitsTable get habits => attachedDatabase.habits;
+  $HabitDoseVariantsTable get habitDoseVariants =>
+      attachedDatabase.habitDoseVariants;
+}

app/lib/data/db/daos/meta_dao.dart

@@ -0,0 +1,23 @@
+import 'package:drift/drift.dart';
+
+import '../app_database.dart';
+import '../tables/user_tables.dart';
+
+part 'meta_dao.g.dart';
+
+@DriftAccessor(tables: [MetaKv])
+class MetaDao extends DatabaseAccessor<AppDatabase> with _$MetaDaoMixin {
+  MetaDao(super.db);
+
+  Future<String?> find(String key) async {
+    final row = await (select(metaKv)..where((t) => t.key.equals(key)))
+        .getSingleOrNull();
+    return row?.value;
+  }
+
+  Future<void> put(String key, String value) async {
+    await into(metaKv).insertOnConflictUpdate(
+      MetaKvCompanion.insert(key: key, value: value),
+    );
+  }
+}

app/lib/data/db/daos/meta_dao.g.dart

@@ -0,0 +1,8 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'meta_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$MetaDaoMixin on DatabaseAccessor<AppDatabase> {
+  $MetaKvTable get metaKv => attachedDatabase.metaKv;
+}

app/lib/data/db/daos/tracker_dao.dart

@@ -0,0 +1,80 @@
+import 'package:drift/drift.dart';
+
+import '../../../core/id.dart';
+import '../../../core/time.dart';
+import '../app_database.dart';
+import '../tables/user_tables.dart';
+
+part 'tracker_dao.g.dart';
+
+class TrackerEntryDraft {
+  final String habitId;
+  final String date; // YYYY-MM-DD
+  final String value; // done | blank
+  final String? variantId;
+  final String? ctxLocation;
+  final String? ctxCondition;
+  final String? note;
+
+  const TrackerEntryDraft({
+    required this.habitId,
+    required this.date,
+    required this.value,
+    this.variantId,
+    this.ctxLocation,
+    this.ctxCondition,
+    this.note,
+  });
+}
+
+@DriftAccessor(tables: [TrackerEntries])
+class TrackerDao extends DatabaseAccessor<AppDatabase> with _$TrackerDaoMixin {
+  TrackerDao(super.db);
+
+  Future<String> recordCheckIn(TrackerEntryDraft draft) async {
+    final id = generateUlid('te');
+    await into(trackerEntries).insert(TrackerEntriesCompanion.insert(
+      id: id,
+      habitId: draft.habitId,
+      date: draft.date,
+      value: draft.value,
+      loggedAt: Value(nowKst().toIso8601String()),
+      variantId: Value(draft.variantId),
+      ctxLocation: Value(draft.ctxLocation),
+      ctxCondition: Value(draft.ctxCondition),
+      note: Value(draft.note),
+    ));
+    return id;
+  }
+
+  Future<List<TrackerEntry>> entriesForHabit(String habitId) {
+    return (select(trackerEntries)
+          ..where((t) => t.habitId.equals(habitId))
+          ..orderBy([(t) => OrderingTerm.asc(t.date)]))
+        .get();
+  }
+
+  /// Done entries in [start, end) for one user.
+  /// [start]/[end] are YYYY-MM-DD strings.
+  Future<List<TrackerEntry>> findDoneInRangeForUser({
+    required String userId,
+    required String startDate,
+    required String endDate,
+    String? habitId,
+  }) async {
+    final habitIds = await (select(db.habits)
+          ..where((t) => t.userId.equals(userId)))
+        .map((h) => h.id)
+        .get();
+    if (habitIds.isEmpty) return const [];
+    final query = select(trackerEntries)
+      ..where((t) => t.habitId.isIn(habitIds))
+      ..where((t) => t.value.equals('done'))
+      ..where((t) =>
+          t.date.isBiggerOrEqualValue(startDate) & t.date.isSmallerThanValue(endDate));
+    if (habitId != null) {
+      query.where((t) => t.habitId.equals(habitId));
+    }
+    return query.get();
+  }
+}

app/lib/data/db/daos/tracker_dao.g.dart

@@ -0,0 +1,13 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'tracker_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$TrackerDaoMixin on DatabaseAccessor<AppDatabase> {
+  $UsersTable get users => attachedDatabase.users;
+  $PhasesTable get phases => attachedDatabase.phases;
+  $HabitsTable get habits => attachedDatabase.habits;
+  $HabitDoseVariantsTable get habitDoseVariants =>
+      attachedDatabase.habitDoseVariants;
+  $TrackerEntriesTable get trackerEntries => attachedDatabase.trackerEntries;
+}