Merge redesign/ui-v2 into main: full v2 rewrite (Vite SPA + Hono API + Bun worker)

Resolved conflicts in web-legacy pages and report schema by taking v2 side.
v2 is the deployed, current architecture; v1 paths preserved under apps/web-legacy.

apps/web-legacy/app/api/habits/[id]/logs/route.ts

@@ -0,0 +1,61 @@
+// AGENT INSTRUCTION: After every write (INSERT/UPDATE/DELETE), you MUST:
+// 1. Insert activity feed entry
+// 2. Call pg.notify('project_e_events', JSON.stringify({ type, action, id, workspace_id }))
+// See AGENTS.md for full rules.
+
+import { NextRequest, NextResponse } from 'next/server';
+import { withAuth, createErrorResponse } from '@/lib/auth';
+import { createPocketBaseClient } from '@/lib/pocketbase';
+import { logHabitCompletion } from '@/lib/services';
+import { z } from 'zod';
+
+type RouteContext = { params: Promise<{ id: string }> };
+
+// GET /api/habits/[id]/logs — List logs for a habit
+export const GET = withAuth<RouteContext>(async (request: NextRequest, _user, context) => {
+  const { id } = await context!.params;
+  const { searchParams } = new URL(request.url);
+  const page = parseInt(searchParams.get('page') || '1');
+  const perPage = parseInt(searchParams.get('perPage') || '50');
+  const filter = searchParams.get('filter') || undefined;
+  const sort = searchParams.get('sort') || '-logged_at';
+
+  const pb = createPocketBaseClient();
+  const result = await pb.collection('habit_logs').getList(page, perPage, {
+    filter: filter ? `habit_id = "${id}" && ${filter}` : `habit_id = "${id}"`,
+    sort,
+  });
+
+  return NextResponse.json({
+    items: result.items,
+    totalItems: result.totalItems,
+    totalPages: result.totalPages,
+    page: result.page,
+    perPage: result.perPage,
+  });
+});
+
+// POST /api/habits/[id]/logs — Create a habit log entry
+export const POST = withAuth<RouteContext>(async (request: NextRequest, _user, context) => {
+  try {
+    const { id } = await context!.params;
+    const body = await request.json();
+    const data = z
+      .object({
+        logged_at: z.string().datetime().optional(),
+        mood: z.number().int().min(1).max(5).optional(),
+        value: z.number().optional(),
+        notes: z.string().optional(),
+      })
+      .parse(body);
+
+    const result = await logHabitCompletion(id, data);
+
+    return NextResponse.json(result, { status: 201 });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return createErrorResponse('VALIDATION_ERROR', 'Invalid input', 400, error.issues);
+    }
+    throw error;
+  }
+});

apps/web-legacy/app/api/habits/[id]/route.ts

@@ -0,0 +1,125 @@
+// AGENT INSTRUCTION: After every write (INSERT/UPDATE/DELETE), you MUST:
+// 1. Insert activity feed entry
+// 2. Call pg.notify('project_e_events', JSON.stringify({ type, action, id, workspace_id }))
+// See AGENTS.md for full rules.
+
+import { NextRequest, NextResponse } from 'next/server';
+import { withAuth, createErrorResponse, requireWorkspaceAccess } from '@/lib/auth';
+import { recordActivity } from '@/lib/activity';
+import { db, habits, habitTags } from '@project-e/db';
+import { and, eq, isNull } from 'drizzle-orm';
+import { z } from 'zod';
+
+const habitFrequencyEnum = z.enum(['daily', 'weekly', 'custom']);
+const habitDifficultyEnum = z.enum(['easy', 'medium', 'hard']);
+
+const updateHabitSchema = z.object({
+  name: z.string().min(1, 'Name is required').optional(),
+  description: z.string().nullable().optional(),
+  domain: z.string().min(1, 'Domain is required').optional(),
+  frequency: habitFrequencyEnum.optional(),
+  difficulty: habitDifficultyEnum.optional(),
+  goalPerPeriod: z.number().int().positive().optional(),
+  active: z.boolean().optional(),
+  tagIds: z.array(z.string().uuid()).optional(),
+});
+
+type RouteContext = { params: Promise<{ id: string }> };
+
+// GET /api/habits/[id] — Get a single habit
+export const GET = withAuth<RouteContext>(async (request: NextRequest, _user, context) => {
+  const { id } = await context!.params;
+
+  const [habit] = await db.select()
+    .from(habits)
+    .where(and(eq(habits.id, id), isNull(habits.deletedAt)))
+    .limit(1);
+
+  if (!habit) {
+    return createErrorResponse('NOT_FOUND', 'Habit not found', 404);
+  }
+
+  return NextResponse.json(habit);
+});
+
+// PATCH /api/habits/[id] — Update a habit
+export const PATCH = withAuth<RouteContext>(async (request: NextRequest, user, context) => {
+  const { id } = await context!.params;
+
+  try {
+    const body = await request.json();
+    const data = updateHabitSchema.parse(body);
+
+    if (data.domain) {
+      await requireWorkspaceAccess(data.domain);
+    }
+
+    const updateValues: Record<string, any> = { updatedAt: new Date() };
+    if (data.name !== undefined) updateValues.name = data.name;
+    if (data.description !== undefined) updateValues.description = data.description;
+    if (data.domain !== undefined) updateValues.domainId = data.domain;
+    if (data.frequency !== undefined) updateValues.frequency = data.frequency;
+    if (data.difficulty !== undefined) updateValues.difficulty = data.difficulty;
+    if (data.goalPerPeriod !== undefined) updateValues.goalPerPeriod = data.goalPerPeriod;
+    if (data.active !== undefined) updateValues.active = data.active;
+
+    const [habit] = await db.update(habits)
+      .set(updateValues)
+      .where(and(eq(habits.id, id), isNull(habits.deletedAt)))
+      .returning();
+
+    if (!habit) {
+      return createErrorResponse('NOT_FOUND', 'Habit not found', 404);
+    }
+
+    if (data.tagIds) {
+      await db.delete(habitTags).where(eq(habitTags.habitId, id));
+      if (data.tagIds.length > 0) {
+        await db.insert(habitTags).values(
+          data.tagIds.map(tagId => ({ habitId: id, tagId }))
+        );
+      }
+    }
+
+    await recordActivity({
+      actor: user.name,
+      action: 'updated',
+      entityType: 'habit',
+      entityId: habit.id,
+      changes: { name: habit.name },
+      workspaceId: habit.domainId,
+    });
+
+    return NextResponse.json(habit);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return createErrorResponse('VALIDATION_ERROR', 'Invalid input', 400, error.issues);
+    }
+    throw error;
+  }
+});
+
+// DELETE /api/habits/[id] — Soft-delete a habit
+export const DELETE = withAuth<RouteContext>(async (request: NextRequest, user, context) => {
+  const { id } = await context!.params;
+
+  const [habit] = await db.update(habits)
+    .set({ deletedAt: new Date(), updatedAt: new Date() })
+    .where(and(eq(habits.id, id), isNull(habits.deletedAt)))
+    .returning();
+
+  if (!habit) {
+    return createErrorResponse('NOT_FOUND', 'Habit not found', 404);
+  }
+
+  await recordActivity({
+    actor: user.name,
+    action: 'deleted',
+    entityType: 'habit',
+    entityId: habit.id,
+    changes: { name: habit.name },
+    workspaceId: habit.domainId,
+  });
+
+  return new NextResponse(null, { status: 204 });
+});

apps/web-legacy/app/api/habits/route.ts

@@ -0,0 +1,126 @@
+// AGENT INSTRUCTION: After every write (INSERT/UPDATE/DELETE), you MUST:
+// 1. Insert activity feed entry
+// 2. Call pg.notify('project_e_events', JSON.stringify({ type, action, id, workspace_id }))
+// See AGENTS.md for full rules.
+
+import { NextRequest, NextResponse } from 'next/server';
+import { withAuth, createErrorResponse, resolveActiveDomain } from '@/lib/auth';
+import { recordActivity } from '@/lib/activity';
+import { db, habits, habitTags, tags as tagsTable } from '@project-e/db';
+import { and, asc, desc, eq, ilike, inArray, isNull, or, sql } from 'drizzle-orm';
+import { z } from 'zod';
+
+const habitFrequencyEnum = z.enum(['daily', 'weekly', 'custom']);
+const habitDifficultyEnum = z.enum(['easy', 'medium', 'hard']);
+
+const createHabitSchema = z.object({
+  name: z.string().min(1, 'Name is required'),
+  description: z.string().optional().nullable(),
+  domain: z.string().min(1, 'Domain is required'),
+  frequency: habitFrequencyEnum.optional().default('daily'),
+  difficulty: habitDifficultyEnum.optional().default('medium'),
+  goalPerPeriod: z.number().int().positive().optional().default(1),
+  active: z.boolean().optional().default(true),
+  tagIds: z.array(z.string().uuid()).optional(),
+});
+
+// GET /api/habits — List habits with filtering, sorting, pagination
+export const GET = withAuth(async (request: NextRequest, user) => {
+  const { searchParams } = new URL(request.url);
+  const page = Math.max(1, parseInt(searchParams.get('page') || '1'));
+  const perPage = Math.min(100, Math.max(1, parseInt(searchParams.get('perPage') || '50')));
+  const filter = searchParams.get('filter') || undefined;
+  const sort = searchParams.get('sort') || '-created';
+  let domainId = searchParams.get('domain') || undefined;
+  if (!domainId) {
+    const active = await resolveActiveDomain(user);
+    domainId = active.id;
+  }
+
+  const sortDir = sort.startsWith('-') ? 'desc' : 'asc';
+  const sortField = sort.replace(/^-/, '');
+  const sortColumns: Record<string, any> = {
+    created: habits.createdAt,
+    updated: habits.updatedAt,
+    name: habits.name,
+    frequency: habits.frequency,
+    difficulty: habits.difficulty,
+  };
+  const orderBy = sortDir === 'asc'
+    ? asc(sortColumns[sortField] || habits.createdAt)
+    : desc(sortColumns[sortField] || habits.createdAt);
+
+  const conditions: any[] = [isNull(habits.deletedAt)];
+  if (domainId) conditions.push(eq(habits.domainId, domainId));
+  if (filter) {
+    conditions.push(ilike(habits.name, `%${filter}%`));
+  }
+
+  const offset = (page - 1) * perPage;
+
+  const [items, countResult] = await Promise.all([
+    db.select()
+      .from(habits)
+      .where(and(...conditions))
+      .orderBy(orderBy)
+      .limit(perPage)
+      .offset(offset),
+    db.select({ count: sql<number>`count(*)` })
+      .from(habits)
+      .where(and(...conditions)),
+  ]);
+
+  const totalItems = Number(countResult[0]?.count || 0);
+
+  return NextResponse.json({
+    items,
+    totalItems,
+    totalPages: Math.ceil(totalItems / perPage),
+    page,
+    perPage,
+  });
+});
+
+// POST /api/habits — Create a habit
+export const POST = withAuth(async (request: NextRequest, user) => {
+  try {
+    const body = await request.json();
+    const data = createHabitSchema.parse({
+      ...body,
+      domain: body.domain || (await resolveActiveDomain(user)).id,
+    });
+
+    const [habit] = await db.insert(habits).values({
+      name: data.name,
+      description: data.description ?? null,
+      domainId: data.domain,
+      frequency: data.frequency,
+      difficulty: data.difficulty,
+      goalPerPeriod: data.goalPerPeriod,
+      active: data.active,
+    }).returning();
+
+    if (data.tagIds && data.tagIds.length > 0) {
+      await db.insert(habitTags).values(
+        data.tagIds.map(tagId => ({ habitId: habit.id, tagId }))
+      );
+    }
+
+    await recordActivity({
+      actor: user.name,
+      action: 'created',
+      entityType: 'habit',
+      entityId: habit.id,
+      changes: { name: habit.name },
+      workspaceId: data.domain,
+    });
+
+    return NextResponse.json(habit, { status: 201 });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return createErrorResponse('VALIDATION_ERROR', 'Invalid input', 400, error.issues);
+    }
+    console.error('[habits POST] error:', error);
+    return createErrorResponse('INTERNAL_ERROR', 'Failed to create habit', 500);
+  }
+});

apps/web-legacy/app/api/habits/streaks/route.ts

@@ -0,0 +1,18 @@
+// AGENT INSTRUCTION: After every write (INSERT/UPDATE/DELETE), you MUST:
+// 1. Insert activity feed entry
+// 2. Call pg.notify('project_e_events', JSON.stringify({ type, action, id, workspace_id }))
+// See AGENTS.md for full rules.
+
+import { NextResponse } from 'next/server';
+import { withAuth } from '@/lib/auth';
+import { getHabitStreaks } from '@/lib/services/habit-service';
+
+// GET /api/habits/streaks — Get all habit streaks
+export const GET = withAuth(async () => {
+  const streaks = await getHabitStreaks();
+  return NextResponse.json({ streaks }, {
+    headers: {
+      'Cache-Control': 'private, max-age=60, stale-while-revalidate=300',
+    },
+  });
+});