feat: lease expiration notifications via cron + API

client/src/components/property/ExpiringLeases.tsx

@@ -0,0 +1,83 @@
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table';
+import { Skeleton } from '@/components/ui/skeleton';
+import { Clock } from 'lucide-react';
+import { useExpiringLeases } from '@/hooks/use-property';
+import { formatCurrency } from '@/lib/utils';
+
+function urgencyBadge(days: number) {
+  if (days <= 30) return <Badge variant="destructive">{days}d</Badge>;
+  if (days <= 60) return <Badge variant="default">{days}d</Badge>;
+  return <Badge variant="secondary">{days}d</Badge>;
+}
+
+export default function ExpiringLeases() {
+  const { data: leases, isLoading } = useExpiringLeases(90);
+
+  if (isLoading) {
+    return (
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base flex items-center gap-2">
+            <Clock className="h-4 w-4" /> Expiring Leases
+          </CardTitle>
+        </CardHeader>
+        <CardContent>
+          <Skeleton className="h-24" />
+        </CardContent>
+      </Card>
+    );
+  }
+
+  if (!leases || leases.length === 0) {
+    return (
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base flex items-center gap-2">
+            <Clock className="h-4 w-4" /> Expiring Leases
+          </CardTitle>
+        </CardHeader>
+        <CardContent>
+          <p className="text-sm text-muted-foreground">No leases expiring in the next 90 days.</p>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle className="text-base flex items-center gap-2">
+          <Clock className="h-4 w-4" /> Expiring Leases ({leases.length})
+        </CardTitle>
+      </CardHeader>
+      <CardContent>
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHead>Tenant</TableHead>
+              <TableHead>Property</TableHead>
+              <TableHead>Unit</TableHead>
+              <TableHead className="text-right">Rent</TableHead>
+              <TableHead>End Date</TableHead>
+              <TableHead className="text-right">Remaining</TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {leases.map((l) => (
+              <TableRow key={l.leaseId}>
+                <TableCell className="font-medium">{l.tenantName}</TableCell>
+                <TableCell>{l.propertyName}</TableCell>
+                <TableCell>{l.unitNumber || '\u2014'}</TableCell>
+                <TableCell className="text-right">{formatCurrency(parseFloat(l.monthlyRent))}</TableCell>
+                <TableCell>{new Date(l.endDate).toLocaleDateString()}</TableCell>
+                <TableCell className="text-right">{urgencyBadge(l.daysRemaining)}</TableCell>
+              </TableRow>
+            ))}
+          </TableBody>
+        </Table>
+      </CardContent>
+    </Card>
+  );
+}

client/src/hooks/use-property.ts

@@ -269,6 +269,29 @@ export function useUpdateLease(propertyId: string, leaseId: string) {
   });
 }
 
+export interface ExpiringLease {
+  leaseId: string;
+  tenantName: string;
+  tenantEmail: string | null;
+  tenantPhone: string | null;
+  endDate: string;
+  monthlyRent: string;
+  unitNumber: string | null;
+  propertyId: string;
+  propertyName: string;
+  address: string;
+  daysRemaining: number;
+}
+
+export function useExpiringLeases(days = 90) {
+  const tenantId = useTenantId();
+  return useQuery<ExpiringLease[]>({
+    queryKey: [`/api/leases/expiring?days=${days}`, tenantId],
+    enabled: !!tenantId,
+    staleTime: 10 * 60 * 1000,
+  });
+}
+
 export function useSendPropertyAdvice(propertyId: string) {
   return useMutation<AIAdviceResponse, Error, string>({
     mutationFn: (message: string) =>

client/src/pages/Dashboard.tsx

@@ -8,7 +8,8 @@ import {
 } from 'lucide-react';
 import { useTenant, useTenantId } from '@/contexts/TenantContext';
 import { formatCurrency } from '@/lib/utils';
-import { usePortfolioSummary } from '@/hooks/use-property';
+import { usePortfolioSummary, useExpiringLeases } from '@/hooks/use-property';
+import ExpiringLeases from '@/components/property/ExpiringLeases';
 import { useActionQueue, type ActionItem, type ActionSeverity } from '@/hooks/use-action-queue';
 import { useConnectionHealth } from '@/hooks/use-connection-health';
 import { useConsolidatedReport } from '@/hooks/use-reports';
@@ -593,9 +594,10 @@ export default function Dashboard() {
           )}
         </div>
 
-        {/* Right column: health + connections + orbital */}
+        {/* Right column: health + leases + connections + orbital */}
         <div className="space-y-5">
           <DataHealth />
+          {tenantId && <ExpiringLeases />}
           <ConnectionPulse />
           <OrbitalPreview />
         </div>

deploy/system-wrangler.toml

@@ -47,6 +47,9 @@ command = "npx vite build --outDir dist/public"
 directory = "../dist/public"
 binding = "ASSETS"
 
+[triggers]
+crons = ["0 9 * * *"]  # Daily at 9:00 AM UTC — lease expiration check
+
 [limits]
 cpu_ms = 50
 
@@ -81,6 +84,9 @@ NODE_ENV = "development"
 APP_VERSION = "2.0.0"
 CHITTYCONNECT_API_BASE = "https://connect.chitty.cc"
 
+[env.dev.triggers]
+crons = ["0 9 * * *"]
+
 [[env.dev.tail_consumers]]
 service = "chittytrack"
 
@@ -109,6 +115,9 @@ NODE_ENV = "staging"
 APP_VERSION = "2.0.0"
 CHITTYCONNECT_API_BASE = "https://connect.chitty.cc"
 
+[env.staging.triggers]
+crons = ["0 9 * * *"]
+
 [[env.staging.tail_consumers]]
 service = "chittytrack"
 
@@ -141,6 +150,9 @@ NODE_ENV = "production"
 APP_VERSION = "2.0.0"
 CHITTYCONNECT_API_BASE = "https://connect.chitty.cc"
 
+[env.production.triggers]
+crons = ["0 9 * * *"]
+
 [[env.production.tail_consumers]]
 service = "chittytrack"
 

server/app.ts

@@ -33,6 +33,7 @@ import { reportRoutes } from './routes/reports';
 import { googleRoutes, googleCallbackRoute } from './routes/google';
 import { commsRoutes } from './routes/comms';
 import { workflowRoutes } from './routes/workflows';
+import { leaseRoutes } from './routes/leases';
 import { createDb } from './db/connection';
 import { SystemStorage } from './storage/system';
 
@@ -93,7 +94,7 @@ export function createApp() {
     '/api/accounts', '/api/transactions', '/api/properties',
     '/api/integrations', '/api/tasks', '/api/ai-messages', '/api/ai', '/api/summary',
     '/api/mercury', '/api/github', '/api/charges', '/api/forensics', '/api/portfolio', '/api/import', '/api/reports',
-    '/api/google', '/api/comms', '/api/workflows', '/mcp',
+    '/api/google', '/api/comms', '/api/workflows', '/api/leases', '/mcp',
   ];
   app.use('/api/tenants', ...authAndContext);
   app.use('/api/tenants/*', ...authAndContext);
@@ -124,6 +125,7 @@ export function createApp() {
   app.route('/', googleRoutes);
   app.route('/', commsRoutes);
   app.route('/', workflowRoutes);
+  app.route('/', leaseRoutes);
   app.route('/', mcpRoutes);
 
   // ── Fallback: try static assets, then 404 ──

server/lib/lease-expiration.ts

@@ -0,0 +1,103 @@
+/**
+ * Lease expiration notification service.
+ *
+ * Runs via Cloudflare Cron Triggers (scheduled handler in worker.ts).
+ * Checks for leases expiring within 30/60/90 days and:
+ *   1. Creates a task linked to the lease (deduped by relatedTo/relatedId + title)
+ *   2. Optionally sends email (SendGrid) and SMS (Twilio) to the tenant
+ */
+
+import type { Env } from '../env';
+import { createDb } from '../db/connection';
+import { SystemStorage } from '../storage/system';
+import { SendGridClient, EMAIL_TEMPLATES } from './sendgrid';
+import { TwilioClient, TEMPLATES as SMS_TEMPLATES } from './twilio';
+
+const NOTIFICATION_WINDOWS = [
+  { days: 90, taskTitle: 'Lease expiring in 90 days', smsTemplate: 'lease_reminder_90' as const },
+  { days: 60, taskTitle: 'Lease expiring in 60 days', smsTemplate: 'lease_reminder_60' as const },
+  { days: 30, taskTitle: 'Lease expiring in 30 days', smsTemplate: 'lease_reminder_30' as const },
+];
+
+function formatDate(d: Date | string): string {
+  const date = typeof d === 'string' ? new Date(d) : d;
+  return date.toISOString().split('T')[0];
+}
+
+export async function processLeaseExpirations(env: Env): Promise<{
+  checked: number;
+  tasksCreated: number;
+  emailsSent: number;
+  smsSent: number;
+}> {
+  const db = createDb(env.DATABASE_URL);
+  const storage = new SystemStorage(db);
+
+  const stats = { checked: 0, tasksCreated: 0, emailsSent: 0, smsSent: 0 };
+
+  // Set up optional notification clients
+  const sendgrid = env.SENDGRID_API_KEY && env.SENDGRID_FROM_EMAIL
+    ? new SendGridClient({ apiKey: env.SENDGRID_API_KEY, fromEmail: env.SENDGRID_FROM_EMAIL })
+    : null;
+  const twilio = env.TWILIO_ACCOUNT_SID && env.TWILIO_AUTH_TOKEN && env.TWILIO_PHONE_NUMBER
+    ? new TwilioClient({ accountSid: env.TWILIO_ACCOUNT_SID, authToken: env.TWILIO_AUTH_TOKEN, fromNumber: env.TWILIO_PHONE_NUMBER })
+    : null;
+
+  // Process each notification window (90, 60, 30 days)
+  for (const window of NOTIFICATION_WINDOWS) {
+    const expiring = await storage.getExpiringLeases(window.days);
+    stats.checked += expiring.length;
+
+    for (const { lease, unit, property } of expiring) {
+      // Dedup: check if a task already exists for this lease + window
+      const existingTasks = await storage.getTasksByRelation('lease', lease.id);
+      const alreadyNotified = existingTasks.some((t) => t.title === window.taskTitle);
+      if (alreadyNotified) continue;
+
+      // Create task for property manager
+      await storage.createTask({
+        tenantId: property.tenantId,
+        title: window.taskTitle,
+        description: `${lease.tenantName}'s lease at ${property.name} (Unit ${unit.unitNumber || 'N/A'}) expires ${formatDate(lease.endDate)}.`,
+        dueDate: lease.endDate,
+        priority: window.days <= 30 ? 'urgent' : window.days <= 60 ? 'high' : 'medium',
+        status: 'pending',
+        relatedTo: 'lease',
+        relatedId: lease.id,
+        metadata: {
+          notificationWindow: window.days,
+          leaseEndDate: formatDate(lease.endDate),
+          propertyId: property.id,
+          unitId: unit.id,
+        },
+      });
+      stats.tasksCreated++;
+
+      const endDateStr = formatDate(lease.endDate);
+
+      // Send email notification if tenant has email and SendGrid is configured
+      if (sendgrid && lease.tenantEmail) {
+        try {
+          const email = EMAIL_TEMPLATES.lease_reminder(lease.tenantName, property.name, endDateStr);
+          await sendgrid.sendEmail({ to: lease.tenantEmail, ...email });
+          stats.emailsSent++;
+        } catch (err) {
+          console.error(`Failed to send lease reminder email to ${lease.tenantEmail}:`, err);
+        }
+      }
+
+      // Send SMS notification if tenant has phone and Twilio is configured
+      if (twilio && lease.tenantPhone) {
+        try {
+          const smsBody = SMS_TEMPLATES[window.smsTemplate](lease.tenantName, endDateStr);
+          await twilio.sendSms(lease.tenantPhone, smsBody);
+          stats.smsSent++;
+        } catch (err) {
+          console.error(`Failed to send lease reminder SMS to ${lease.tenantPhone}:`, err);
+        }
+      }
+    }
+  }
+
+  return stats;
+}

server/routes/leases.ts

@@ -0,0 +1,34 @@
+import { Hono } from 'hono';
+import type { HonoEnv } from '../env';
+
+export const leaseRoutes = new Hono<HonoEnv>();
+
+// GET /api/leases/expiring — list leases expiring within N days (default 90)
+leaseRoutes.get('/api/leases/expiring', async (c) => {
+  const storage = c.get('storage');
+  const days = parseInt(c.req.query('days') || '90', 10);
+
+  if (isNaN(days) || days < 1 || days > 365) {
+    return c.json({ error: 'days must be between 1 and 365' }, 400);
+  }
+
+  const expiring = await storage.getExpiringLeases(days);
+
+  return c.json(
+    expiring.map(({ lease, unit, property }) => ({
+      leaseId: lease.id,
+      tenantName: lease.tenantName,
+      tenantEmail: lease.tenantEmail,
+      tenantPhone: lease.tenantPhone,
+      endDate: lease.endDate,
+      monthlyRent: lease.monthlyRent,
+      unitNumber: unit.unitNumber,
+      propertyId: property.id,
+      propertyName: property.name,
+      address: property.address,
+      daysRemaining: Math.ceil(
+        (new Date(lease.endDate).getTime() - Date.now()) / (24 * 60 * 60 * 1000),
+      ),
+    })),
+  );
+});

server/storage/system.ts

@@ -351,6 +351,40 @@ export class SystemStorage {
       .where(and(inArray(schema.leases.unitId, unitIds), eq(schema.leases.status, 'active')));
   }
 
+  async getExpiringLeases(withinDays: number) {
+    const now = new Date();
+    const cutoff = new Date(now.getTime() + withinDays * 24 * 60 * 60 * 1000);
+    return this.db
+      .select({
+        lease: schema.leases,
+        unit: schema.units,
+        property: schema.properties,
+      })
+      .from(schema.leases)
+      .innerJoin(schema.units, eq(schema.leases.unitId, schema.units.id))
+      .innerJoin(schema.properties, eq(schema.units.propertyId, schema.properties.id))
+      .where(
+        and(
+          eq(schema.leases.status, 'active'),
+          sql`${schema.leases.endDate} >= ${now}`,
+          sql`${schema.leases.endDate} <= ${cutoff}`,
+        ),
+      )
+      .orderBy(schema.leases.endDate);
+  }
+
+  async getTasksByRelation(relatedTo: string, relatedId: string) {
+    return this.db
+      .select()
+      .from(schema.tasks)
+      .where(
+        and(
+          eq(schema.tasks.relatedTo, relatedTo),
+          eq(schema.tasks.relatedId, relatedId),
+        ),
+      );
+  }
+
   // ── PROPERTY FINANCIALS ──
 
   async getPropertyTransactions(propertyId: string, tenantId: string, since?: string, until?: string) {