feat: journal dashboard widgets, agent polish, and edit-mode live previews

Journal dashboard widgets and quick-add; rich-text quick-add dialogs.

Dashboard draft sync for live edit previews; assistant bubble + API tools.

Journal UX: stress slider, mood grid, query cap fix.

src/app/api/agent/chat/route.ts

@@ -1,10 +1,13 @@
 import { z } from "zod";
 import { apiError, apiJson } from "@/lib/api-handler";
 import { resolveApiAuth } from "@/lib/api-auth";
+import { getAssistantEnabled } from "@/lib/assistant-preference";
 import { isLlmConfigured } from "@/lib/llm";
+import { encodeSseEvent } from "@/modules/agent/server/progress";
 import { runAgentChat } from "@/modules/agent/server/run";
 
 const chatInput = z.object({
+  stream: z.boolean().optional(),
   messages: z
     .array(
       z.object({
@@ -18,10 +21,15 @@ const chatInput = z.object({
 
 export async function POST(request: Request) {
   const auth = await resolveApiAuth(request);
-  if (!auth) {
+  if (!auth?.userId) {
     return apiError("Unauthorized", 401);
   }
 
+  const assistantEnabled = await getAssistantEnabled(auth.userId);
+  if (!assistantEnabled) {
+    return apiError("Assistant not enabled", 403);
+  }
+
   let body: unknown;
   try {
     body = await request.json();
@@ -34,6 +42,47 @@ export async function POST(request: Request) {
     return apiError(parsed.error.issues[0]?.message ?? "Validation error", 400);
   }
 
+  if (parsed.data.stream) {
+    const stream = new ReadableStream<Uint8Array>({
+      async start(controller) {
+        const encoder = new TextEncoder();
+        const send = (event: Parameters<typeof encodeSseEvent>[0]) => {
+          controller.enqueue(encoder.encode(encodeSseEvent(event)));
+        };
+
+        try {
+          const result = await runAgentChat({
+            messages: parsed.data.messages,
+            request,
+            onProgress: send,
+          });
+
+          send({
+            type: "done",
+            message: {
+              role: "assistant",
+              content: result.message.content,
+            },
+            toolCalls: result.toolCalls,
+          });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Agent request failed";
+          send({ type: "error", message });
+        } finally {
+          controller.close();
+        }
+      },
+    });
+
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+      },
+    });
+  }
+
   try {
     const result = await runAgentChat({
       messages: parsed.data.messages,

src/app/api/v1/garden/care-schedules/[id]/calendar/route.ts

@@ -0,0 +1,13 @@
+import { apiJson, withApiHandler } from "@/lib/api-handler";
+import { scheduleOnCalendarForScope } from "@/modules/garden/server/actions";
+import { scheduleOnCalendarInput } from "@/modules/garden/server/schemas";
+
+export async function POST(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return withApiHandler(request, async (scope, req) => {
+    const body: unknown = await req.json();
+    const parsed = scheduleOnCalendarInput.parse({ ...(body as object), scheduleId: id });
+    await scheduleOnCalendarForScope(scope, parsed);
+    return apiJson({ ok: true }, 201);
+  });
+}

src/app/api/v1/garden/care-schedules/[id]/route.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { apiJson, withApiHandler } from "@/lib/api-handler";
+import {
+  deleteCareScheduleForScope,
+  toggleCareScheduleForScope,
+} from "@/modules/garden/server/actions";
+import { careScheduleToggleInput } from "@/modules/garden/server/schemas";
+
+export async function PATCH(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return withApiHandler(request, async (scope, req) => {
+    const body: unknown = await req.json();
+    const parsed = careScheduleToggleInput.parse({ ...(body as object), id });
+    await toggleCareScheduleForScope(scope, parsed);
+    return apiJson({ ok: true });
+  });
+}
+
+export async function DELETE(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return withApiHandler(request, async (scope) => {
+    z.string().uuid().parse(id);
+    await deleteCareScheduleForScope(scope, { id });
+    return apiJson({ ok: true });
+  });
+}

src/app/api/v1/garden/overdue-care/push/route.ts

@@ -0,0 +1,9 @@
+import { apiJson, withApiHandler } from "@/lib/api-handler";
+import { pushOverdueToTaskListForScope } from "@/modules/garden/server/actions";
+
+export async function POST(request: Request) {
+  return withApiHandler(request, async (scope) => {
+    const result = await pushOverdueToTaskListForScope(scope);
+    return apiJson(result, 201);
+  });
+}

src/app/api/v1/garden/plants/[id]/care-logs/route.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { apiJson, withApiHandler } from "@/lib/api-handler";
+import { logCareForScope } from "@/modules/garden/server/actions";
+import { careLogInput } from "@/modules/garden/server/schemas";
+import { getCareLogsForScope } from "@/modules/garden/server/queries";
+
+export async function GET(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return withApiHandler(request, async (scope, req) => {
+    z.string().uuid().parse(id);
+    const url = new URL(req.url);
+    const limitRaw = url.searchParams.get("limit");
+    const limit = limitRaw ? z.coerce.number().int().min(1).max(100).parse(limitRaw) : 20;
+    const logs = await getCareLogsForScope(scope.householdId, id, limit);
+    return apiJson(logs);
+  });
+}
+
+export async function POST(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return withApiHandler(request, async (scope, req) => {
+    z.string().uuid().parse(id);
+    const body: unknown = await req.json();
+    const parsed = careLogInput.parse({ ...(body as object), plantId: id });
+    const log = await logCareForScope(scope, parsed);
+    return apiJson(
+      {
+        id: log.id,
+        careType: log.careType,
+        notes: log.notes,
+        performedAt: log.performedAt.toISOString(),
+        performedBy: log.performedBy,
+      },
+      201,
+    );
+  });
+}

src/app/api/v1/garden/plants/[id]/care-schedules/route.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { apiJson, withApiHandler } from "@/lib/api-handler";
+import { upsertCareScheduleForScope } from "@/modules/garden/server/actions";
+import { careScheduleInput } from "@/modules/garden/server/schemas";
+import { getCareSchedulesForScope } from "@/modules/garden/server/queries";
+
+export async function GET(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return withApiHandler(request, async (scope) => {
+    z.string().uuid().parse(id);
+    const schedules = await getCareSchedulesForScope(scope.householdId, id);
+    return apiJson(schedules);
+  });
+}
+
+export async function POST(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return withApiHandler(request, async (scope, req) => {
+    z.string().uuid().parse(id);
+    const body: unknown = await req.json();
+    const parsed = careScheduleInput.parse({ ...(body as object), plantId: id });
+    const schedule = await upsertCareScheduleForScope(scope, parsed);
+    return apiJson(
+      {
+        id: schedule.id,
+        careType: schedule.careType,
+        intervalDays: schedule.intervalDays,
+        lastPerformedAt: schedule.lastPerformedAt?.toISOString() ?? null,
+        nextDueAt: schedule.nextDueAt?.toISOString() ?? null,
+        enabled: schedule.enabled,
+      },
+      201,
+    );
+  });
+}

src/app/api/v1/journal/entries/route.ts

@@ -4,8 +4,11 @@ import { journalEntryInput } from "@/modules/journal/server/schemas";
 import { listJournalEntriesForScope } from "@/modules/journal/server/queries";
 
 export async function GET(request: Request) {
-  return withApiHandler(request, async (scope) => {
-    const entries = await listJournalEntriesForScope(scope);
+  return withApiHandler(request, async (scope, req) => {
+    const url = new URL(req.url);
+    const limitParam = url.searchParams.get("limit");
+    const limit = limitParam ? Math.min(Math.max(Number(limitParam) || 20, 1), 100) : undefined;
+    const entries = await listJournalEntriesForScope(scope, limit ? { limit } : undefined);
     return apiJson(entries);
   });
 }

src/app/api/v1/openapi/route.ts

@@ -0,0 +1,14 @@
+import { readFile } from "fs/promises";
+import path from "path";
+import { withApiHandler } from "@/lib/api-handler";
+
+export async function GET(request: Request) {
+  return withApiHandler(request, async () => {
+    const specPath = path.join(process.cwd(), "docs", "api", "openapi.yaml");
+    const spec = await readFile(specPath, "utf8");
+    return new Response(spec, {
+      status: 200,
+      headers: { "Content-Type": "application/yaml; charset=utf-8" },
+    });
+  });
+}

src/app/api/v1/share-links/[id]/route.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import { apiJson, withApiHandler } from "@/lib/api-handler";
+import { revokeShareLinkForScope } from "@/modules/_core/share-api";
+
+export async function DELETE(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return withApiHandler(request, async (scope) => {
+    z.string().uuid().parse(id);
+    await revokeShareLinkForScope(scope, id);
+    return apiJson({ ok: true });
+  });
+}

src/app/api/v1/share-links/route.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { apiJson, withApiHandler } from "@/lib/api-handler";
+import {
+  createShareLinkForScope,
+  listShareLinksForScope,
+  listShareableEntityTypes,
+} from "@/modules/_core/share-api";
+
+const createShareLinkInput = z.object({
+  entityType: z.string().trim().min(1),
+  entityId: z.string().uuid(),
+  expiresAt: z.string().datetime().nullable().optional(),
+  capabilities: z
+    .object({
+      read: z.boolean().optional(),
+      write: z.boolean().optional(),
+    })
+    .optional(),
+});
+
+export async function GET(request: Request) {
+  return withApiHandler(request, async (scope, req) => {
+    const url = new URL(req.url);
+    const entityType = url.searchParams.get("entityType") ?? undefined;
+    const entityId = url.searchParams.get("entityId") ?? undefined;
+
+    if (url.searchParams.get("entityTypes") === "true") {
+      return apiJson(listShareableEntityTypes());
+    }
+
+    const links = await listShareLinksForScope(scope, { entityType, entityId });
+    return apiJson(links);
+  });
+}
+
+export async function POST(request: Request) {
+  return withApiHandler(request, async (scope, req) => {
+    const body: unknown = await req.json();
+    const parsed = createShareLinkInput.parse(body);
+    const expiresAt = parsed.expiresAt ? new Date(parsed.expiresAt) : null;
+
+    const result = await createShareLinkForScope(scope, parsed.entityType, parsed.entityId, {
+      expiresAt,
+      capabilities: parsed.capabilities,
+    });
+
+    return apiJson(
+      {
+        url: result.url,
+        expiresAt: result.expiresAt?.toISOString() ?? null,
+      },
+      201,
+    );
+  });
+}