feat(pets): add scoped records and reminders

Tool self-fetches were hairpinning to fam.ginnoir.com and failing,
so list_calendars/create_event returned 500 and the model gave up.

.env.example

@@ -57,3 +57,5 @@ LLM_API_KEY=
 LLM_MODEL=llama3.2
 # IANA timezone for assistant relative dates ("Thursday at 2"). Falls back to TZ, then America/Chicago.
 HOUSEHOLD_TIMEZONE=America/Chicago
+# Optional override for agent tool → /api/v1 self-calls (defaults to http://127.0.0.1:$PORT).
+# INTERNAL_API_BASE_URL=http://127.0.0.1:3000

AGENTS.md

@@ -76,6 +76,8 @@ src/
 
 **Rule for contributors (including future Codex and Claude Code sessions):** if a feature requires a change to `_core` to support a new entity type, that's a smell — extend the registry instead.
 
+**Completion rule for module additions and behavior changes:** include the authenticated v1 API and OpenAPI documentation, assistant tools backed by that API, and a complete reminder lifecycle for every user-visible due date. API, agent, and UI must call the same scoped server services; create/update must synchronize unfired reminders and delete must cancel them.
+
 ---
 
 ## Data model (v1)

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.6.5](https://github.com/ginnoir/famapp/compare/v0.6.4...v0.6.5) (2026-07-09)
+
+### Bug Fixes
+
+- **agent:** call api v1 via loopback instead of public url ([3e8fe2d](https://github.com/ginnoir/famapp/commit/3e8fe2d06dc31d3a1058b4b8942c46b1220a6b4c))
+
 ## [0.6.4](https://github.com/ginnoir/famapp/compare/v0.6.3...v0.6.4) (2026-07-09)
 
 ### Bug Fixes

CLAUDE.md

@@ -77,6 +77,8 @@ src/
 
 **Rule for contributors (including future Codex and Claude Code sessions):** if a feature requires a change to `_core` to support a new entity type, that's a smell — extend the registry instead.
 
+**Completion rule for module additions and behavior changes:** include the authenticated v1 API and OpenAPI documentation, assistant tools backed by that API, and a complete reminder lifecycle for every user-visible due date. API, agent, and UI must call the same scoped server services; create/update must synchronize unfired reminders and delete must cancel them.
+
 ---
 
 ## Data model (v1)

drizzle/0027_pets_module.sql

@@ -0,0 +1,70 @@
+-- Custom SQL migration file, put your code below! --
+CREATE TABLE "pets" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "household_id" uuid NOT NULL,
+  "name" text NOT NULL,
+  "species" text NOT NULL,
+  "breed" text,
+  "birth_date" date,
+  "notes" text,
+  "primary_image_url" text,
+  "images" jsonb DEFAULT '[]'::jsonb NOT NULL,
+  "created_at" timestamp with time zone DEFAULT now() NOT NULL,
+  "updated_at" timestamp with time zone DEFAULT now() NOT NULL,
+  CONSTRAINT "pets_household_id_households_id_fk" FOREIGN KEY ("household_id") REFERENCES "public"."households"("id") ON DELETE cascade ON UPDATE no action
+);
+--> statement-breakpoint
+CREATE TABLE "pet_appointments" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "pet_id" uuid NOT NULL,
+  "household_id" uuid NOT NULL,
+  "title" text NOT NULL,
+  "appointment_at" timestamp with time zone NOT NULL,
+  "clinic" text,
+  "notes" text,
+  "calendar_event_id" uuid,
+  "created_at" timestamp with time zone DEFAULT now() NOT NULL,
+  "updated_at" timestamp with time zone DEFAULT now() NOT NULL,
+  CONSTRAINT "pet_appointments_pet_id_pets_id_fk" FOREIGN KEY ("pet_id") REFERENCES "public"."pets"("id") ON DELETE cascade ON UPDATE no action,
+  CONSTRAINT "pet_appointments_household_id_households_id_fk" FOREIGN KEY ("household_id") REFERENCES "public"."households"("id") ON DELETE cascade ON UPDATE no action
+);
+--> statement-breakpoint
+CREATE TABLE "pet_vaccinations" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "pet_id" uuid NOT NULL,
+  "household_id" uuid NOT NULL,
+  "name" text NOT NULL,
+  "administered_on" date NOT NULL,
+  "due_on" date,
+  "provider" text,
+  "notes" text,
+  "created_at" timestamp with time zone DEFAULT now() NOT NULL,
+  "updated_at" timestamp with time zone DEFAULT now() NOT NULL,
+  CONSTRAINT "pet_vaccinations_pet_id_pets_id_fk" FOREIGN KEY ("pet_id") REFERENCES "public"."pets"("id") ON DELETE cascade ON UPDATE no action,
+  CONSTRAINT "pet_vaccinations_household_id_households_id_fk" FOREIGN KEY ("household_id") REFERENCES "public"."households"("id") ON DELETE cascade ON UPDATE no action
+);
+--> statement-breakpoint
+CREATE TABLE "pet_prescriptions" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "pet_id" uuid NOT NULL,
+  "household_id" uuid NOT NULL,
+  "medication" text NOT NULL,
+  "dosage" text NOT NULL,
+  "instructions" text,
+  "prescribed_on" date,
+  "expires_on" date,
+  "refills_remaining" integer,
+  "active" boolean DEFAULT true NOT NULL,
+  "created_at" timestamp with time zone DEFAULT now() NOT NULL,
+  "updated_at" timestamp with time zone DEFAULT now() NOT NULL,
+  CONSTRAINT "pet_prescriptions_pet_id_pets_id_fk" FOREIGN KEY ("pet_id") REFERENCES "public"."pets"("id") ON DELETE cascade ON UPDATE no action,
+  CONSTRAINT "pet_prescriptions_household_id_households_id_fk" FOREIGN KEY ("household_id") REFERENCES "public"."households"("id") ON DELETE cascade ON UPDATE no action
+);
+--> statement-breakpoint
+CREATE INDEX "pets_household_idx" ON "pets" USING btree ("household_id");
+--> statement-breakpoint
+CREATE INDEX "pet_appointments_pet_at_idx" ON "pet_appointments" USING btree ("pet_id", "appointment_at");
+--> statement-breakpoint
+CREATE INDEX "pet_vaccinations_pet_due_idx" ON "pet_vaccinations" USING btree ("pet_id", "due_on");
+--> statement-breakpoint
+CREATE INDEX "pet_prescriptions_pet_active_idx" ON "pet_prescriptions" USING btree ("pet_id", "active");

drizzle/meta/_journal.json

@@ -190,6 +190,13 @@
       "when": 1783561000000,
       "tag": "0026_assistant_model_route",
       "breakpoints": true
+    },
+    {
+      "idx": 27,
+      "version": "7",
+      "when": 1783648174004,
+      "tag": "0027_pets_module",
+      "breakpoints": true
     }
   ]
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "famapp",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "private": true,
   "type": "module",
   "packageManager": "pnpm@10.33.3",

src/lib/household-timezone.ts

@@ -0,0 +1,39 @@
+export function resolveHouseholdTimezone(): string {
+  return process.env.HOUSEHOLD_TIMEZONE?.trim() || process.env.TZ?.trim() || "America/Chicago";
+}
+
+function part(parts: Intl.DateTimeFormatPart[], type: Intl.DateTimeFormatPartTypes): number {
+  const value = parts.find((item) => item.type === type)?.value;
+  if (!value) throw new Error(`Missing ${type} timezone part`);
+  return Number(value);
+}
+
+export function householdDateAt(
+  isoDate: string,
+  hour: number,
+  timeZone = resolveHouseholdTimezone(),
+): Date {
+  const [year, month, day] = isoDate.split("-").map(Number);
+  if (!year || !month || !day || hour < 0 || hour > 23) throw new Error("Invalid household date");
+
+  const candidate = Date.UTC(year, month - 1, day, hour);
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23",
+  }).formatToParts(new Date(candidate));
+  const formattedAsUtc = Date.UTC(
+    part(parts, "year"),
+    part(parts, "month") - 1,
+    part(parts, "day"),
+    part(parts, "hour"),
+    part(parts, "minute"),
+    part(parts, "second"),
+  );
+  return new Date(candidate - (formattedAsUtc - candidate));
+}

src/modules/agent/server/run.ts

@@ -160,8 +160,20 @@ export async function runAgentChat(options: {
 
       try {
         result = await executeTool(toolCall.function.name, toolCall.function.arguments);
-        const parsed = JSON.parse(result) as { status?: number };
+        const parsed = JSON.parse(result) as { status?: number; body?: unknown };
         status = typeof parsed.status === "number" ? parsed.status : 200;
+        if (status >= 400) {
+          logger.warn(
+            {
+              msg: "agent.chat.tool_error",
+              round,
+              name: toolCall.function.name,
+              status,
+              body: parsed.body,
+            },
+            "agent tool returned error",
+          );
+        }
       } catch (err) {
         status = 500;
         result = JSON.stringify({

src/modules/agent/tool-executor.ts

@@ -1,3 +1,5 @@
+import logger from "@/lib/logger";
+
 type ApiCallResult = {
   status: number;
   body: unknown;
@@ -5,8 +7,22 @@ type ApiCallResult = {
 
 export type ToolExecutor = (name: string, argsJson: string) => Promise<string>;
 
+/** Loopback base for in-process tool → /api/v1 calls. Avoids hairpinning to the public URL. */
+export function resolveInternalApiBase(request: Request): string {
+  const configured = process.env.INTERNAL_API_BASE_URL?.trim();
+  if (configured) return configured.replace(/\/$/, "");
+
+  const port = process.env.PORT?.trim() || "3000";
+  const requestUrl = new URL(request.url);
+  if (requestUrl.hostname === "localhost" || requestUrl.hostname === "127.0.0.1") {
+    return requestUrl.origin;
+  }
+
+  return `http://127.0.0.1:${port}`;
+}
+
 export function createApiToolExecutor(request: Request): ToolExecutor {
-  const origin = new URL(request.url).origin;
+  const origin = resolveInternalApiBase(request);
 
   return async (name: string, argsJson: string) => {
     const args = parseArgs(argsJson);
@@ -522,14 +538,30 @@ async function callApi(
   path: string,
   body?: Record<string, unknown>,
 ): Promise<ApiCallResult> {
-  const response = await fetch(`${origin}${path}`, {
+  const url = `${origin}${path}`;
-    method,
+  const headers: Record<string, string> = {
-    headers: {
+    "Content-Type": "application/json",
-      "Content-Type": "application/json",
+  };
-      cookie: request.headers.get("cookie") ?? "",
+  const cookie = request.headers.get("cookie");
-    },
+  if (cookie) headers.cookie = cookie;
-    body: body !== undefined ? JSON.stringify(body) : undefined,
+  const authorization = request.headers.get("authorization");
-  });
+  if (authorization) headers.authorization = authorization;
+
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "fetch failed";
+    logger.error(
+      { msg: "agent.tool.fetch_failed", method, url, error: message },
+      "agent tool internal fetch failed",
+    );
+    return { status: 502, body: { error: `Internal API unreachable: ${message}`, url } };
+  }
 
   const text = await response.text();
   let parsed: unknown = null;
@@ -541,5 +573,12 @@ async function callApi(
     }
   }
 
+  if (response.status >= 400) {
+    logger.warn(
+      { msg: "agent.tool.api_error", method, url, status: response.status, body: parsed },
+      "agent tool API error",
+    );
+  }
+
   return { status: response.status, body: parsed };
 }

src/modules/pets/schema.ts

@@ -0,0 +1,102 @@
+import {
+  boolean,
+  date,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { households } from "../_core/schema";
+
+export const pets = pgTable(
+  "pets",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    householdId: uuid("household_id")
+      .notNull()
+      .references(() => households.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    species: text("species").notNull(),
+    breed: text("breed"),
+    birthDate: date("birth_date"),
+    notes: text("notes"),
+    primaryImageUrl: text("primary_image_url"),
+    images: jsonb("images").notNull().default([]).$type<string[]>(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => [index("pets_household_idx").on(table.householdId)],
+);
+
+export const petAppointments = pgTable(
+  "pet_appointments",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    petId: uuid("pet_id")
+      .notNull()
+      .references(() => pets.id, { onDelete: "cascade" }),
+    householdId: uuid("household_id")
+      .notNull()
+      .references(() => households.id, { onDelete: "cascade" }),
+    title: text("title").notNull(),
+    appointmentAt: timestamp("appointment_at", { withTimezone: true }).notNull(),
+    clinic: text("clinic"),
+    notes: text("notes"),
+    calendarEventId: uuid("calendar_event_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => [index("pet_appointments_pet_at_idx").on(table.petId, table.appointmentAt)],
+);
+
+export const petVaccinations = pgTable(
+  "pet_vaccinations",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    petId: uuid("pet_id")
+      .notNull()
+      .references(() => pets.id, { onDelete: "cascade" }),
+    householdId: uuid("household_id")
+      .notNull()
+      .references(() => households.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    administeredOn: date("administered_on").notNull(),
+    dueOn: date("due_on"),
+    provider: text("provider"),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => [index("pet_vaccinations_pet_due_idx").on(table.petId, table.dueOn)],
+);
+
+export const petPrescriptions = pgTable(
+  "pet_prescriptions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    petId: uuid("pet_id")
+      .notNull()
+      .references(() => pets.id, { onDelete: "cascade" }),
+    householdId: uuid("household_id")
+      .notNull()
+      .references(() => households.id, { onDelete: "cascade" }),
+    medication: text("medication").notNull(),
+    dosage: text("dosage").notNull(),
+    instructions: text("instructions"),
+    prescribedOn: date("prescribed_on"),
+    expiresOn: date("expires_on"),
+    refillsRemaining: integer("refills_remaining"),
+    active: boolean("active").notNull().default(true),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => [index("pet_prescriptions_pet_active_idx").on(table.petId, table.active)],
+);
+
+export type Pet = typeof pets.$inferSelect;
+export type PetAppointment = typeof petAppointments.$inferSelect;
+export type PetVaccination = typeof petVaccinations.$inferSelect;
+export type PetPrescription = typeof petPrescriptions.$inferSelect;

src/modules/pets/server/actions.ts

@@ -0,0 +1,322 @@
+"use server";
+
+import { and, eq } from "drizzle-orm";
+import { revalidatePath } from "next/cache";
+import { z } from "zod";
+import type { ApiAuthContext } from "@/lib/api-auth";
+import { db } from "@/lib/db";
+import { getCurrentSession } from "@/lib/session";
+import { logActivityForScope } from "@/modules/_core/activity";
+import { cancelReminder, listReminderOffsets } from "@/modules/_core/reminders";
+import { petAppointments, petPrescriptions, pets, petVaccinations } from "../schema";
+import { syncPetAppointmentReminders, syncPetDueDateReminder } from "./reminders";
+import {
+  appointmentInput,
+  appointmentUpdateInput,
+  petInput,
+  petUpdateInput,
+  prescriptionInput,
+  prescriptionUpdateInput,
+  vaccinationInput,
+  vaccinationUpdateInput,
+} from "./schemas";
+
+type Scope = Pick<ApiAuthContext, "householdId" | "userId">;
+const idInput = z.object({ id: z.string().uuid() });
+
+async function requirePet(scope: Scope, id: string) {
+  const [pet] = await db
+    .select()
+    .from(pets)
+    .where(and(eq(pets.id, id), eq(pets.householdId, scope.householdId)))
+    .limit(1);
+  if (!pet) throw new Error("Pet not found");
+  return pet;
+}
+
+async function requireAppointment(scope: Scope, id: string) {
+  const [row] = await db
+    .select()
+    .from(petAppointments)
+    .where(and(eq(petAppointments.id, id), eq(petAppointments.householdId, scope.householdId)))
+    .limit(1);
+  if (!row) throw new Error("Record not found");
+  return row;
+}
+async function requireVaccination(scope: Scope, id: string) {
+  const [row] = await db
+    .select()
+    .from(petVaccinations)
+    .where(and(eq(petVaccinations.id, id), eq(petVaccinations.householdId, scope.householdId)))
+    .limit(1);
+  if (!row) throw new Error("Record not found");
+  return row;
+}
+async function requirePrescription(scope: Scope, id: string) {
+  const [row] = await db
+    .select()
+    .from(petPrescriptions)
+    .where(and(eq(petPrescriptions.id, id), eq(petPrescriptions.householdId, scope.householdId)))
+    .limit(1);
+  if (!row) throw new Error("Record not found");
+  return row;
+}
+
+function revalidatePet(id: string) {
+  revalidatePath("/pets");
+  revalidatePath(`/pets/${id}`);
+}
+
+export async function createPetForScope(scope: Scope, input: z.input<typeof petInput>) {
+  const parsed = petInput.parse(input);
+  const [pet] = await db
+    .insert(pets)
+    .values({
+      householdId: scope.householdId,
+      ...parsed,
+      breed: parsed.breed ?? null,
+      birthDate: parsed.birthDate ?? null,
+      notes: parsed.notes ?? null,
+      primaryImageUrl: parsed.primaryImageUrl ?? parsed.images[0] ?? null,
+    })
+    .returning();
+  if (!pet) throw new Error("Pet was not created");
+  await logActivityForScope(scope, {
+    entityType: "pets.pet",
+    entityId: pet.id,
+    action: "create",
+    payload: { name: pet.name },
+  });
+  return pet;
+}
+export async function createPet(input: z.input<typeof petInput>) {
+  const { household, user } = await getCurrentSession();
+  const pet = await createPetForScope({ householdId: household.id, userId: user.id }, input);
+  revalidatePet(pet.id);
+  return pet;
+}
+
+export async function updatePetForScope(
+  scope: Scope,
+  input: { id: string } & z.input<typeof petUpdateInput>,
+) {
+  const parsed = idInput.and(petUpdateInput).parse(input);
+  await requirePet(scope, parsed.id);
+  const { id, ...changes } = parsed;
+  await db
+    .update(pets)
+    .set({ ...changes, updatedAt: new Date() })
+    .where(eq(pets.id, id));
+  await logActivityForScope(scope, { entityType: "pets.pet", entityId: id, action: "update" });
+}
+export async function updatePet(input: { id: string } & z.input<typeof petUpdateInput>) {
+  const { household, user } = await getCurrentSession();
+  await updatePetForScope({ householdId: household.id, userId: user.id }, input);
+  revalidatePet(input.id);
+}
+
+export async function deletePetForScope(scope: Scope, input: { id: string }) {
+  const { id } = idInput.parse(input);
+  const pet = await requirePet(scope, id);
+  await logActivityForScope(scope, {
+    entityType: "pets.pet",
+    entityId: id,
+    action: "delete",
+    payload: { name: pet.name },
+  });
+  await db.delete(pets).where(eq(pets.id, id));
+}
+export async function deletePet(input: { id: string }) {
+  const { household, user } = await getCurrentSession();
+  await deletePetForScope({ householdId: household.id, userId: user.id }, input);
+  revalidatePath("/pets");
+}
+
+export async function createAppointmentForScope(
+  scope: Scope,
+  input: z.input<typeof appointmentInput>,
+) {
+  const parsed = appointmentInput.parse(input);
+  const pet = await requirePet(scope, parsed.petId);
+  const [row] = await db
+    .insert(petAppointments)
+    .values({
+      householdId: scope.householdId,
+      petId: parsed.petId,
+      title: parsed.title,
+      appointmentAt: parsed.appointmentAt,
+      clinic: parsed.clinic ?? null,
+      notes: parsed.notes ?? null,
+    })
+    .returning();
+  if (!row) throw new Error("Appointment was not created");
+  if (scope.userId)
+    await syncPetAppointmentReminders({
+      householdId: scope.householdId,
+      appointmentId: row.id,
+      appointmentAt: row.appointmentAt,
+      createdBy: scope.userId,
+      petName: pet.name,
+      title: row.title,
+      offsets: parsed.reminderOffsets,
+    });
+  return row;
+}
+export async function updateAppointmentForScope(
+  scope: Scope,
+  input: { id: string } & z.input<typeof appointmentUpdateInput>,
+) {
+  const parsed = idInput.and(appointmentUpdateInput).parse(input);
+  const row = await requireAppointment(scope, parsed.id);
+  const pet = await requirePet(scope, row.petId);
+  const offsets = parsed.reminderOffsets ?? (await listReminderOffsets("pets.appointment", row.id));
+  const { id, reminderOffsets: _, ...changes } = parsed;
+  const [updated] = await db
+    .update(petAppointments)
+    .set({ ...changes, updatedAt: new Date() })
+    .where(eq(petAppointments.id, id))
+    .returning();
+  if (!updated) throw new Error("Appointment not found");
+  if (scope.userId)
+    await syncPetAppointmentReminders({
+      householdId: scope.householdId,
+      appointmentId: id,
+      appointmentAt: updated.appointmentAt,
+      createdBy: scope.userId,
+      petName: pet.name,
+      title: updated.title,
+      offsets,
+    });
+  return updated;
+}
+export async function deleteAppointmentForScope(scope: Scope, input: { id: string }) {
+  const { id } = idInput.parse(input);
+  await requireAppointment(scope, id);
+  await cancelReminder("pets.appointment", id);
+  await db.delete(petAppointments).where(eq(petAppointments.id, id));
+}
+
+export async function createVaccinationForScope(
+  scope: Scope,
+  input: z.input<typeof vaccinationInput>,
+) {
+  const parsed = vaccinationInput.parse(input);
+  const pet = await requirePet(scope, parsed.petId);
+  const [row] = await db
+    .insert(petVaccinations)
+    .values({
+      householdId: scope.householdId,
+      ...parsed,
+      dueOn: parsed.dueOn ?? null,
+      provider: parsed.provider ?? null,
+      notes: parsed.notes ?? null,
+    })
+    .returning();
+  if (!row) throw new Error("Vaccination was not created");
+  if (scope.userId)
+    await syncPetDueDateReminder({
+      householdId: scope.householdId,
+      entityType: "pets.vaccination",
+      entityId: row.id,
+      dueOn: row.dueOn,
+      createdBy: scope.userId,
+      title: `Vaccination due: ${pet.name}`,
+      body: row.name,
+    });
+  return row;
+}
+export async function updateVaccinationForScope(
+  scope: Scope,
+  input: { id: string } & z.input<typeof vaccinationUpdateInput>,
+) {
+  const parsed = idInput.and(vaccinationUpdateInput).parse(input);
+  const row = await requireVaccination(scope, parsed.id);
+  const pet = await requirePet(scope, row.petId);
+  const { id, ...changes } = parsed;
+  const [updated] = await db
+    .update(petVaccinations)
+    .set({ ...changes, updatedAt: new Date() })
+    .where(eq(petVaccinations.id, id))
+    .returning();
+  if (!updated) throw new Error("Vaccination not found");
+  if (scope.userId)
+    await syncPetDueDateReminder({
+      householdId: scope.householdId,
+      entityType: "pets.vaccination",
+      entityId: id,
+      dueOn: updated.dueOn,
+      createdBy: scope.userId,
+      title: `Vaccination due: ${pet.name}`,
+      body: updated.name,
+    });
+  return updated;
+}
+export async function deleteVaccinationForScope(scope: Scope, input: { id: string }) {
+  const { id } = idInput.parse(input);
+  await requireVaccination(scope, id);
+  await cancelReminder("pets.vaccination", id);
+  await db.delete(petVaccinations).where(eq(petVaccinations.id, id));
+}
+
+export async function createPrescriptionForScope(
+  scope: Scope,
+  input: z.input<typeof prescriptionInput>,
+) {
+  const parsed = prescriptionInput.parse(input);
+  const pet = await requirePet(scope, parsed.petId);
+  const [row] = await db
+    .insert(petPrescriptions)
+    .values({
+      householdId: scope.householdId,
+      ...parsed,
+      instructions: parsed.instructions ?? null,
+      prescribedOn: parsed.prescribedOn ?? null,
+      expiresOn: parsed.expiresOn ?? null,
+      refillsRemaining: parsed.refillsRemaining ?? null,
+    })
+    .returning();
+  if (!row) throw new Error("Prescription was not created");
+  if (scope.userId)
+    await syncPetDueDateReminder({
+      householdId: scope.householdId,
+      entityType: "pets.prescription",
+      entityId: row.id,
+      dueOn: row.active ? row.expiresOn : null,
+      createdBy: scope.userId,
+      title: `Prescription due: ${pet.name}`,
+      body: row.medication,
+    });
+  return row;
+}
+export async function updatePrescriptionForScope(
+  scope: Scope,
+  input: { id: string } & z.input<typeof prescriptionUpdateInput>,
+) {
+  const parsed = idInput.and(prescriptionUpdateInput).parse(input);
+  const row = await requirePrescription(scope, parsed.id);
+  const pet = await requirePet(scope, row.petId);
+  const { id, ...changes } = parsed;
+  const [updated] = await db
+    .update(petPrescriptions)
+    .set({ ...changes, updatedAt: new Date() })
+    .where(eq(petPrescriptions.id, id))
+    .returning();
+  if (!updated) throw new Error("Prescription not found");
+  if (scope.userId)
+    await syncPetDueDateReminder({
+      householdId: scope.householdId,
+      entityType: "pets.prescription",
+      entityId: id,
+      dueOn: updated.active ? updated.expiresOn : null,
+      createdBy: scope.userId,
+      title: `Prescription due: ${pet.name}`,
+      body: updated.medication,
+    });
+  return updated;
+}
+export async function deletePrescriptionForScope(scope: Scope, input: { id: string }) {
+  const { id } = idInput.parse(input);
+  await requirePrescription(scope, id);
+  await cancelReminder("pets.prescription", id);
+  await db.delete(petPrescriptions).where(eq(petPrescriptions.id, id));
+}

src/modules/pets/server/queries.ts

@@ -0,0 +1,210 @@
+import { and, asc, desc, eq, or, sql } from "drizzle-orm";
+import { db } from "@/lib/db";
+import { getCurrentSession } from "@/lib/session";
+import { petAppointments, petPrescriptions, pets, petVaccinations } from "../schema";
+
+export type PetListItemDto = {
+  id: string;
+  name: string;
+  species: string;
+  breed: string | null;
+  primaryImageUrl: string | null;
+};
+
+export type PetAppointmentDto = {
+  id: string;
+  petId: string;
+  title: string;
+  appointmentAt: string;
+  clinic: string | null;
+  notes: string | null;
+  calendarEventId: string | null;
+};
+
+export type PetVaccinationDto = {
+  id: string;
+  petId: string;
+  name: string;
+  administeredOn: string;
+  dueOn: string | null;
+  provider: string | null;
+  notes: string | null;
+};
+
+export type PetPrescriptionDto = {
+  id: string;
+  petId: string;
+  medication: string;
+  dosage: string;
+  instructions: string | null;
+  prescribedOn: string | null;
+  expiresOn: string | null;
+  refillsRemaining: number | null;
+  active: boolean;
+};
+
+export type PetDetailDto = PetListItemDto & {
+  householdId: string;
+  birthDate: string | null;
+  notes: string | null;
+  images: string[];
+  appointments: PetAppointmentDto[];
+  vaccinations: PetVaccinationDto[];
+  prescriptions: PetPrescriptionDto[];
+};
+
+const toAppointment = (row: typeof petAppointments.$inferSelect): PetAppointmentDto => ({
+  id: row.id,
+  petId: row.petId,
+  title: row.title,
+  appointmentAt: row.appointmentAt.toISOString(),
+  clinic: row.clinic,
+  notes: row.notes,
+  calendarEventId: row.calendarEventId,
+});
+const toVaccination = (row: typeof petVaccinations.$inferSelect): PetVaccinationDto => ({
+  id: row.id,
+  petId: row.petId,
+  name: row.name,
+  administeredOn: row.administeredOn,
+  dueOn: row.dueOn,
+  provider: row.provider,
+  notes: row.notes,
+});
+const toPrescription = (row: typeof petPrescriptions.$inferSelect): PetPrescriptionDto => ({
+  id: row.id,
+  petId: row.petId,
+  medication: row.medication,
+  dosage: row.dosage,
+  instructions: row.instructions,
+  prescribedOn: row.prescribedOn,
+  expiresOn: row.expiresOn,
+  refillsRemaining: row.refillsRemaining,
+  active: row.active,
+});
+
+export async function listPetsForScope(householdId: string): Promise<PetListItemDto[]> {
+  const rows = await db
+    .select()
+    .from(pets)
+    .where(eq(pets.householdId, householdId))
+    .orderBy(asc(pets.name));
+  return rows.map((row) => ({
+    id: row.id,
+    name: row.name,
+    species: row.species,
+    breed: row.breed,
+    primaryImageUrl: row.primaryImageUrl,
+  }));
+}
+
+export async function listPets() {
+  const { household } = await getCurrentSession();
+  return listPetsForScope(household.id);
+}
+
+export async function getPetForScope(
+  householdId: string,
+  id: string,
+): Promise<PetDetailDto | null> {
+  const [pet] = await db
+    .select()
+    .from(pets)
+    .where(and(eq(pets.id, id), eq(pets.householdId, householdId)))
+    .limit(1);
+  if (!pet) return null;
+  const [appointments, vaccinations, prescriptions] = await Promise.all([
+    db
+      .select()
+      .from(petAppointments)
+      .where(and(eq(petAppointments.petId, id), eq(petAppointments.householdId, householdId)))
+      .orderBy(desc(petAppointments.appointmentAt)),
+    db
+      .select()
+      .from(petVaccinations)
+      .where(and(eq(petVaccinations.petId, id), eq(petVaccinations.householdId, householdId)))
+      .orderBy(desc(petVaccinations.administeredOn)),
+    db
+      .select()
+      .from(petPrescriptions)
+      .where(and(eq(petPrescriptions.petId, id), eq(petPrescriptions.householdId, householdId)))
+      .orderBy(desc(petPrescriptions.createdAt)),
+  ]);
+  return {
+    id: pet.id,
+    householdId: pet.householdId,
+    name: pet.name,
+    species: pet.species,
+    breed: pet.breed,
+    birthDate: pet.birthDate,
+    notes: pet.notes,
+    primaryImageUrl: pet.primaryImageUrl,
+    images: pet.images,
+    appointments: appointments.map(toAppointment),
+    vaccinations: vaccinations.map(toVaccination),
+    prescriptions: prescriptions.map(toPrescription),
+  };
+}
+
+export async function getPet(id: string) {
+  const { household } = await getCurrentSession();
+  return getPetForScope(household.id, id);
+}
+
+export async function searchPets(query: string, householdId: string) {
+  const term = `%${query}%`;
+  const rows = await db
+    .select({ id: pets.id, name: pets.name, species: pets.species, breed: pets.breed })
+    .from(pets)
+    .where(
+      and(
+        eq(pets.householdId, householdId),
+        or(
+          sql`${pets.name} ilike ${term}`,
+          sql`${pets.species} ilike ${term}`,
+          sql`coalesce(${pets.breed}, '') ilike ${term}`,
+        ),
+      ),
+    )
+    .limit(10);
+  return rows.map((row) => ({
+    id: row.id,
+    title: row.name,
+    excerpt: [row.species, row.breed].filter(Boolean).join(" · "),
+    url: `/pets/${row.id}`,
+  }));
+}
+
+export async function getPetsOverviewStats(householdId: string) {
+  const [petCount] = await db
+    .select({ count: sql<number>`count(*)::int` })
+    .from(pets)
+    .where(eq(pets.householdId, householdId));
+  const [vaccinations, prescriptions] = await Promise.all([
+    db
+      .select({ count: sql<number>`count(*)::int` })
+      .from(petVaccinations)
+      .where(
+        and(
+          eq(petVaccinations.householdId, householdId),
+          sql`${petVaccinations.dueOn} <= current_date + interval '30 days'`,
+        ),
+      ),
+    db
+      .select({ count: sql<number>`count(*)::int` })
+      .from(petPrescriptions)
+      .where(
+        and(
+          eq(petPrescriptions.householdId, householdId),
+          eq(petPrescriptions.active, true),
+          sql`${petPrescriptions.expiresOn} <= current_date + interval '30 days'`,
+        ),
+      ),
+  ]);
+  return {
+    petCount: Number(petCount?.count ?? 0),
+    dueSoonCount: Number(vaccinations[0]?.count ?? 0) + Number(prescriptions[0]?.count ?? 0),
+  };
+}
+
+export { toAppointment, toPrescription, toVaccination };

src/modules/pets/server/reminders.ts

@@ -0,0 +1,54 @@
+import { fireAtForEventStart, normalizeReminderOffsets } from "@/lib/reminder-offsets";
+import { householdDateAt } from "@/lib/household-timezone";
+import {
+  cancelReminder,
+  scheduleReminder,
+  syncRemindersForEntity,
+} from "@/modules/_core/reminders";
+
+export async function syncPetAppointmentReminders(input: {
+  householdId: string;
+  appointmentId: string;
+  appointmentAt: Date;
+  createdBy: string;
+  petName: string;
+  title: string;
+  offsets: number[];
+}) {
+  await syncRemindersForEntity({
+    householdId: input.householdId,
+    entityType: "pets.appointment",
+    entityId: input.appointmentId,
+    createdBy: input.createdBy,
+    reminders: normalizeReminderOffsets(input.offsets).map((offsetMinutes) => ({
+      fireAt: fireAtForEventStart(input.appointmentAt, offsetMinutes),
+      offsetMinutes,
+      title: `Vet visit: ${input.petName}`,
+      body: input.title,
+    })),
+  });
+}
+
+export async function syncPetDueDateReminder(input: {
+  householdId: string;
+  entityType: "pets.vaccination" | "pets.prescription";
+  entityId: string;
+  dueOn: string | null;
+  createdBy: string;
+  title: string;
+  body: string;
+}) {
+  if (!input.dueOn) {
+    await cancelReminder(input.entityType, input.entityId);
+    return;
+  }
+  await scheduleReminder({
+    householdId: input.householdId,
+    entityType: input.entityType,
+    entityId: input.entityId,
+    fireAt: householdDateAt(input.dueOn, 9),
+    createdBy: input.createdBy,
+    title: input.title,
+    body: input.body,
+  });
+}

src/modules/pets/server/schemas.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+
+const isoDate = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
+const optionalText = (max: number) => z.string().trim().max(max).nullable().optional();
+
+export const petInput = z.object({
+  name: z.string().trim().min(1).max(120),
+  species: z.string().trim().min(1).max(80),
+  breed: optionalText(120),
+  birthDate: isoDate.nullable().optional(),
+  notes: optionalText(4000),
+  images: z.array(z.string().min(1)).max(10).default([]),
+  primaryImageUrl: z.string().min(1).nullable().optional(),
+});
+
+export const petUpdateInput = petInput.partial();
+
+export const appointmentInput = z.object({
+  petId: z.string().uuid(),
+  title: z.string().trim().min(1).max(160),
+  appointmentAt: z.coerce.date(),
+  clinic: optionalText(160),
+  notes: optionalText(4000),
+  reminderOffsets: z.array(z.number().int().min(0).max(43_200)).default([30]),
+});
+
+export const appointmentUpdateInput = appointmentInput.omit({ petId: true }).partial();
+
+export const vaccinationInput = z.object({
+  petId: z.string().uuid(),
+  name: z.string().trim().min(1).max(160),
+  administeredOn: isoDate,
+  dueOn: isoDate.nullable().optional(),
+  provider: optionalText(160),
+  notes: optionalText(4000),
+});
+
+export const vaccinationUpdateInput = vaccinationInput.omit({ petId: true }).partial();
+
+export const prescriptionInput = z.object({
+  petId: z.string().uuid(),
+  medication: z.string().trim().min(1).max(160),
+  dosage: z.string().trim().min(1).max(160),
+  instructions: optionalText(2000),
+  prescribedOn: isoDate.nullable().optional(),
+  expiresOn: isoDate.nullable().optional(),
+  refillsRemaining: z.number().int().min(0).max(99).nullable().optional(),
+  active: z.boolean().default(true),
+});
+
+export const prescriptionUpdateInput = prescriptionInput.omit({ petId: true }).partial();
+
+export const scheduleAppointmentInput = z.object({
+  appointmentId: z.string().uuid(),
+  calendarId: z.string().uuid(),
+});

tests/unit/agent-tools-runtime.test.ts

@@ -1,7 +1,10 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import { appendAgentRuntimeContext, resolveHouseholdTimezone } from "../../src/modules/agent/tools";
-import { createApiToolExecutor } from "../../src/modules/agent/tool-executor";
+import {
+  createApiToolExecutor,
+  resolveInternalApiBase,
+} from "../../src/modules/agent/tool-executor";
 
 describe("appendAgentRuntimeContext", () => {
   it("appends current time and timezone to the prompt", () => {
@@ -38,6 +41,34 @@ describe("resolveHouseholdTimezone", () => {
   });
 });
 
+describe("resolveInternalApiBase", () => {
+  it("uses loopback instead of the public request origin", () => {
+    const original = process.env.INTERNAL_API_BASE_URL;
+    const originalPort = process.env.PORT;
+    delete process.env.INTERNAL_API_BASE_URL;
+    process.env.PORT = "3000";
+
+    const base = resolveInternalApiBase(new Request("https://fam.ginnoir.com/api/agent/chat"));
+    assert.equal(base, "http://127.0.0.1:3000");
+
+    if (original === undefined) delete process.env.INTERNAL_API_BASE_URL;
+    else process.env.INTERNAL_API_BASE_URL = original;
+    if (originalPort === undefined) delete process.env.PORT;
+    else process.env.PORT = originalPort;
+  });
+
+  it("honors INTERNAL_API_BASE_URL when set", () => {
+    const original = process.env.INTERNAL_API_BASE_URL;
+    process.env.INTERNAL_API_BASE_URL = "http://127.0.0.1:3010/";
+
+    const base = resolveInternalApiBase(new Request("https://fam.ginnoir.com/api/agent/chat"));
+    assert.equal(base, "http://127.0.0.1:3010");
+
+    if (original === undefined) delete process.env.INTERNAL_API_BASE_URL;
+    else process.env.INTERNAL_API_BASE_URL = original;
+  });
+});
+
 describe("create_event calendar resolution", () => {
   it("uses the first calendar when calendarId and calendarName are omitted", async () => {
     const originalFetch = globalThis.fetch;
@@ -45,13 +76,13 @@ describe("create_event calendar resolution", () => {
 
     globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
       const url = String(input);
-      if (url.endsWith("/api/v1/calendars") && (!init?.method || init.method === "GET")) {
+      if (url.includes("/api/v1/calendars") && (!init?.method || init.method === "GET")) {
         return Response.json([
           { id: "cal-1", name: "Family" },
           { id: "cal-2", name: "Work" },
         ]);
       }
-      if (url.endsWith("/api/v1/events") && init?.method === "POST") {
+      if (url.includes("/api/v1/events") && init?.method === "POST") {
         const body = JSON.parse(String(init.body));
         posts.push({ path: url, body });
         return Response.json({ id: "evt-1", ...body }, { status: 201 });
@@ -59,7 +90,11 @@ describe("create_event calendar resolution", () => {
       return new Response("not found", { status: 404 });
     }) as typeof fetch;
 
-    const execute = createApiToolExecutor(new Request("http://localhost:3000/api/agent/chat"));
+    const execute = createApiToolExecutor(
+      new Request("https://fam.ginnoir.com/api/agent/chat", {
+        headers: { cookie: "authjs.session-token=test" },
+      }),
+    );
     const result = JSON.parse(
       await execute(
         "create_event",
@@ -74,6 +109,7 @@ describe("create_event calendar resolution", () => {
     assert.equal(result.status, 201);
     assert.equal(result.body.calendarId, "cal-1");
     assert.equal(posts.length, 1);
+    assert.match(posts[0]!.path, /^http:\/\/127\.0\.0\.1:3000\/api\/v1\/events/);
 
     globalThis.fetch = originalFetch;
   });
@@ -83,13 +119,13 @@ describe("create_event calendar resolution", () => {
 
     globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
       const url = String(input);
-      if (url.endsWith("/api/v1/calendars") && (!init?.method || init.method === "GET")) {
+      if (url.includes("/api/v1/calendars") && (!init?.method || init.method === "GET")) {
         return Response.json([
           { id: "cal-1", name: "Family" },
           { id: "cal-2", name: "Work" },
         ]);
       }
-      if (url.endsWith("/api/v1/events") && init?.method === "POST") {
+      if (url.includes("/api/v1/events") && init?.method === "POST") {
         const body = JSON.parse(String(init.body));
         return Response.json({ id: "evt-1", ...body }, { status: 201 });
       }
@@ -114,4 +150,22 @@ describe("create_event calendar resolution", () => {
 
     globalThis.fetch = originalFetch;
   });
+
+  it("returns a clear error when the internal API is unreachable", async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async () => {
+      throw new TypeError("fetch failed");
+    }) as typeof fetch;
+
+    const execute = createApiToolExecutor(new Request("https://fam.ginnoir.com/api/agent/chat"));
+    const result = JSON.parse(await execute("list_calendars", "{}")) as {
+      status: number;
+      body: { error?: string };
+    };
+
+    assert.equal(result.status, 502);
+    assert.match(String(result.body.error), /unreachable/i);
+
+    globalThis.fetch = originalFetch;
+  });
 });

tests/unit/household-timezone.test.ts

@@ -0,0 +1,16 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { householdDateAt } from "../../src/lib/household-timezone";
+
+test("householdDateAt preserves 9 AM across Chicago daylight saving time", () => {
+  const formatter = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "America/Chicago",
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23",
+  });
+
+  for (const date of ["2026-01-15", "2026-07-15"]) {
+    assert.equal(formatter.format(householdDateAt(date, 9, "America/Chicago")), "09:00");
+  }
+});

tests/unit/pets-schemas.test.ts

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  appointmentInput,
+  petInput,
+  prescriptionInput,
+  scheduleAppointmentInput,
+  vaccinationInput,
+} from "../../src/modules/pets/server/schemas";
+
+const PET_ID = "f5a50e32-a217-4d65-ae10-98a1f441d171";
+const CALENDAR_ID = "bd8e10c2-58f4-4db8-9326-0b50fdda47bb";
+
+test("pet and medical record schemas accept bounded valid input", () => {
+  assert.equal(petInput.parse({ name: "Mochi", species: "cat", images: [] }).name, "Mochi");
+  assert.equal(
+    appointmentInput.parse({
+      petId: PET_ID,
+      title: "Annual exam",
+      appointmentAt: "2026-08-01T15:00:00.000Z",
+    }).title,
+    "Annual exam",
+  );
+  assert.equal(
+    vaccinationInput.parse({ petId: PET_ID, name: "Rabies", administeredOn: "2026-07-01" }).name,
+    "Rabies",
+  );
+  assert.equal(
+    prescriptionInput.parse({ petId: PET_ID, medication: "Apoquel", dosage: "5 mg daily" }).active,
+    true,
+  );
+  assert.deepEqual(
+    scheduleAppointmentInput.parse({ appointmentId: PET_ID, calendarId: CALENDAR_ID }),
+    {
+      appointmentId: PET_ID,
+      calendarId: CALENDAR_ID,
+    },
+  );
+});
+
+test("pet and medical record schemas reject invalid identifiers, dates, and galleries", () => {
+  assert.throws(() => petInput.parse({ name: "", species: "cat" }));
+  assert.throws(() =>
+    petInput.parse({
+      name: "Mochi",
+      species: "cat",
+      images: Array(11).fill("/api/uploads/pets/a.jpg"),
+    }),
+  );
+  assert.throws(() =>
+    appointmentInput.parse({ petId: "not-a-uuid", title: "Exam", appointmentAt: "not-a-date" }),
+  );
+  assert.throws(() =>
+    vaccinationInput.parse({ petId: PET_ID, name: "Rabies", administeredOn: "07/01/2026" }),
+  );
+  assert.throws(() =>
+    scheduleAppointmentInput.parse({ appointmentId: "bad", calendarId: "also-bad" }),
+  );
+});