create-crm-starter 0.1.0

package/template/extras/checklists/_shared/src/lib/checklists/sample-data.ts

@@ -0,0 +1,56 @@
+import type { ChecklistTemplate } from './types';
+
+export const sampleTemplates: ChecklistTemplate[] = [
+  {
+    id: 'tpl_hvac_tune_up',
+    name: 'HVAC tune-up',
+    description: 'Standard maintenance checklist for annual tune-ups',
+    items: [
+      { id: 'i1', label: 'Replace air filter', kind: 'checkbox', required: true, sortOrder: 0 },
+      { id: 'i2', label: 'Clean condenser coil', kind: 'checkbox', required: true, sortOrder: 1 },
+      { id: 'i3', label: 'Check refrigerant pressure', kind: 'text', required: true, sortOrder: 2, helperText: 'PSI reading' },
+      { id: 'i4', label: 'Inspect electrical connections', kind: 'checkbox', required: true, sortOrder: 3 },
+      { id: 'i5', label: 'Photo of completed work', kind: 'photo', required: true, sortOrder: 4 },
+      { id: 'i6', label: 'Customer walkthrough completed', kind: 'checkbox', required: false, sortOrder: 5 },
+    ],
+    itemCount: 6,
+    requiredCount: 5,
+    attachedJobCount: 7,
+    createdAt: '2025-08-15T10:00:00Z',
+  },
+  {
+    id: 'tpl_panel_upgrade',
+    name: 'Electrical panel upgrade',
+    description: 'Code-required inspection items for panel replacement',
+    items: [
+      { id: 'p1', label: 'Main breaker rating verified', kind: 'checkbox', required: true, sortOrder: 0 },
+      { id: 'p2', label: 'Grounding electrode bonded', kind: 'checkbox', required: true, sortOrder: 1 },
+      { id: 'p3', label: 'Service entrance conductors sized correctly', kind: 'text', required: true, sortOrder: 2, helperText: 'AWG + ampacity' },
+      { id: 'p4', label: 'Working clearance meets code', kind: 'checkbox', required: true, sortOrder: 3 },
+      { id: 'p5', label: 'GFCI/AFCI protection installed', kind: 'checkbox', required: true, sortOrder: 4 },
+      { id: 'p6', label: 'Panel directory labeled', kind: 'checkbox', required: true, sortOrder: 5 },
+      { id: 'p7', label: 'Permit number posted', kind: 'text', required: true, sortOrder: 6 },
+      { id: 'p8', label: 'Final inspection photo', kind: 'photo', required: true, sortOrder: 7 },
+    ],
+    itemCount: 8,
+    requiredCount: 8,
+    attachedJobCount: 3,
+    createdAt: '2025-09-01T14:00:00Z',
+  },
+  {
+    id: 'tpl_plumb_drain',
+    name: 'Drain cleaning',
+    description: 'Pre/post checks for drain service calls',
+    items: [
+      { id: 'd1', label: 'Pre-service photo', kind: 'photo', required: true, sortOrder: 0 },
+      { id: 'd2', label: 'Cleaning method used', kind: 'text', required: true, sortOrder: 1, helperText: 'Auger / hydro-jet / enzyme' },
+      { id: 'd3', label: 'Post-service photo', kind: 'photo', required: true, sortOrder: 2 },
+      { id: 'd4', label: 'Water test passed', kind: 'checkbox', required: true, sortOrder: 3 },
+      { id: 'd5', label: 'Customer notified of any concerns', kind: 'checkbox', required: false, sortOrder: 4 },
+    ],
+    itemCount: 5,
+    requiredCount: 4,
+    attachedJobCount: 12,
+    createdAt: '2025-10-20T09:00:00Z',
+  },
+];

package/template/extras/checklists/_shared/src/lib/checklists/types.ts

@@ -0,0 +1,47 @@
+export const CHECKLIST_ITEM_KINDS = ['checkbox', 'text', 'photo'] as const;
+export type ChecklistItemKind = (typeof CHECKLIST_ITEM_KINDS)[number];
+
+export const CHECKLIST_ITEM_KIND_LABEL: Record<ChecklistItemKind, string> = {
+  checkbox: 'Checkbox',
+  text: 'Text answer',
+  photo: 'Photo upload',
+};
+
+export interface ChecklistTemplateItem {
+  id: string;
+  label: string;
+  kind: ChecklistItemKind;
+  required: boolean;
+  sortOrder: number;
+  helperText?: string;
+}
+
+export interface ChecklistTemplate {
+  id: string;
+  name: string;
+  description?: string;
+  items: ChecklistTemplateItem[];
+  itemCount: number;        // = items.length, denormalized for list view
+  requiredCount: number;    // count of items where required=true
+  attachedJobCount: number; // how many jobs use this template currently
+  createdAt: string;
+}
+
+export interface JobChecklistItem extends ChecklistTemplateItem {
+  completed: boolean;
+  completedAt?: string;
+  /** For kind='text' answers. */
+  value?: string;
+}
+
+export interface JobChecklist {
+  id: string;
+  jobId: string;
+  templateId?: string;
+  templateName: string;
+  items: JobChecklistItem[];
+  /** Computed: all required items completed. Drives the "blocks job finish" UI. */
+  allRequiredComplete: boolean;
+  /** Computed: total completion percent (0-100). */
+  progressPct: number;
+}

package/template/extras/checklists/drizzle/src/app/(dashboard)/checklists/new/page.tsx

@@ -0,0 +1,10 @@
+import { NewTemplateForm } from '@/components/checklists/new-template-form';
+
+export default function NewChecklistTemplatePage() {
+  return (
+    <div className="mx-auto max-w-3xl space-y-6">
+      <h1 className="text-3xl font-bold tracking-tight">New checklist template</h1>
+      <NewTemplateForm />
+    </div>
+  );
+}

package/template/extras/checklists/drizzle/src/components/checklists/new-template-form.tsx

@@ -0,0 +1,158 @@
+'use client';
+
+import { useState, useTransition } from 'react';
+import Link from 'next/link';
+import { Button } from '@/components/ui/button';
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { createChecklistTemplate } from '@/lib/checklists/actions';
+import { CHECKLIST_ITEM_KINDS, CHECKLIST_ITEM_KIND_LABEL, type ChecklistItemKind } from '@/lib/checklists/types';
+
+interface DraftItem {
+  key: string;
+  label: string;
+  kind: ChecklistItemKind;
+  required: boolean;
+  helperText: string;
+}
+
+const NEW_ITEM = (): DraftItem => ({
+  key: crypto.randomUUID(),
+  label: '',
+  kind: 'checkbox',
+  required: true,
+  helperText: '',
+});
+
+export function NewTemplateForm() {
+  const [pending, start] = useTransition();
+  const [error, setError] = useState<string | null>(null);
+  const [name, setName] = useState('');
+  const [description, setDescription] = useState('');
+  const [items, setItems] = useState<DraftItem[]>([NEW_ITEM()]);
+
+  function updateItem(key: string, patch: Partial<DraftItem>) {
+    setItems((prev) => prev.map((it) => (it.key === key ? { ...it, ...patch } : it)));
+  }
+  function removeItem(key: string) {
+    setItems((prev) => (prev.length === 1 ? prev : prev.filter((it) => it.key !== key)));
+  }
+  function addItem() {
+    setItems((prev) => [...prev, NEW_ITEM()]);
+  }
+
+  function handleSubmit(e: React.FormEvent) {
+    e.preventDefault();
+    setError(null);
+    if (!name.trim()) { setError('Name is required.'); return; }
+    const filled = items.filter((it) => it.label.trim());
+    if (filled.length === 0) { setError('Add at least one item with a label.'); return; }
+    start(async () => {
+      try {
+        await createChecklistTemplate({
+          name,
+          description: description || undefined,
+          items: filled.map(({ key: _key, ...rest }) => ({
+            label: rest.label,
+            kind: rest.kind,
+            required: rest.required,
+            helperText: rest.helperText || undefined,
+          })),
+        });
+      } catch (err) {
+        setError((err as Error).message);
+      }
+    });
+  }
+
+  return (
+    <form onSubmit={handleSubmit} className="space-y-6">
+      <Card>
+        <CardHeader>
+          <CardTitle>Template basics</CardTitle>
+          <CardDescription>Name and an optional description.</CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          <div className="space-y-2">
+            <Label htmlFor="name">Name *</Label>
+            <Input id="name" required value={name} onChange={(e) => setName(e.target.value)} placeholder="e.g. HVAC tune-up" />
+          </div>
+          <div className="space-y-2">
+            <Label htmlFor="description">Description</Label>
+            <Input id="description" value={description} onChange={(e) => setDescription(e.target.value)} placeholder="What jobs is this for?" />
+          </div>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Items</CardTitle>
+          <CardDescription>Required items block job &quot;Finished&quot; until completed.</CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-3">
+          {items.map((it) => (
+            <div key={it.key} className="border-input space-y-2 rounded-md border p-3">
+              <div className="grid grid-cols-[1fr_8rem_2.5rem] gap-2">
+                <Input
+                  value={it.label}
+                  onChange={(e) => updateItem(it.key, { label: e.target.value })}
+                  placeholder="Item label"
+                />
+                <select
+                  value={it.kind}
+                  onChange={(e) => updateItem(it.key, { kind: e.target.value as ChecklistItemKind })}
+                  className="border-input bg-background h-10 w-full rounded-md border px-2 text-sm"
+                >
+                  {CHECKLIST_ITEM_KINDS.map((k) => (
+                    <option key={k} value={k}>{CHECKLIST_ITEM_KIND_LABEL[k]}</option>
+                  ))}
+                </select>
+                <Button
+                  type="button"
+                  variant="ghost"
+                  size="icon"
+                  onClick={() => removeItem(it.key)}
+                  disabled={items.length === 1}
+                  aria-label="Remove"
+                >
+                  ✕
+                </Button>
+              </div>
+              <div className="flex items-center justify-between gap-2">
+                <Input
+                  value={it.helperText}
+                  onChange={(e) => updateItem(it.key, { helperText: e.target.value })}
+                  placeholder="Helper text (optional)"
+                  className="text-xs"
+                />
+                <label className="flex cursor-pointer items-center gap-2 text-xs whitespace-nowrap">
+                  <input
+                    type="checkbox"
+                    checked={it.required}
+                    onChange={(e) => updateItem(it.key, { required: e.target.checked })}
+                  />
+                  Required
+                </label>
+              </div>
+            </div>
+          ))}
+          <Button type="button" variant="outline" size="sm" onClick={addItem}>
+            + Add item
+          </Button>
+        </CardContent>
+      </Card>
+
+      {error && <p className="text-destructive text-sm">{error}</p>}
+
+      <div className="flex justify-end gap-3">
+        <Button type="button" variant="outline" asChild>
+          <Link href="/checklists">Cancel</Link>
+        </Button>
+        <Button type="submit" disabled={pending}>
+          {pending ? 'Creating…' : 'Create template'}
+        </Button>
+      </div>
+    </form>
+  );
+}

package/template/extras/checklists/drizzle/src/components/jobs/job-checklists-client.tsx

@@ -0,0 +1,202 @@
+'use client';
+
+import { useState, useTransition } from 'react';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import {
+  attachChecklistToJob,
+  detachJobChecklist,
+  setJobChecklistItem,
+} from '@/lib/checklists/actions';
+import type { JobChecklist, JobChecklistItem } from '@/lib/checklists/types';
+
+interface ClientProps {
+  jobId: string;
+  initialAttached: JobChecklist[];
+  templates: { id: string; name: string }[];
+}
+
+export function JobChecklistsClient({ jobId, initialAttached, templates }: ClientProps) {
+  const [attached, setAttached] = useState(initialAttached);
+  const [pending, start] = useTransition();
+  const [error, setError] = useState<string | null>(null);
+  const [selectedTemplate, setSelectedTemplate] = useState(templates[0]?.id ?? '');
+
+  function handleAttach() {
+    if (!selectedTemplate) return;
+    setError(null);
+    start(async () => {
+      try {
+        await attachChecklistToJob(jobId, selectedTemplate);
+        // Optimistic-ish reload — the server revalidated the page so a
+        // soft navigation would refresh attached[]. We just clear the
+        // picker to indicate the action happened.
+        location.reload();
+      } catch (err) {
+        setError((err as Error).message);
+      }
+    });
+  }
+
+  function handleDetach(checklistId: string) {
+    if (!confirm('Detach this checklist? Completion state will be lost.')) return;
+    start(async () => {
+      try {
+        await detachJobChecklist(checklistId);
+        setAttached((prev) => prev.filter((c) => c.id !== checklistId));
+      } catch (err) {
+        setError((err as Error).message);
+      }
+    });
+  }
+
+  function handleToggle(checklistId: string, item: JobChecklistItem) {
+    start(async () => {
+      try {
+        await setJobChecklistItem(checklistId, item.id, { completed: !item.completed });
+        setAttached((prev) =>
+          prev.map((c) =>
+            c.id !== checklistId
+              ? c
+              : {
+                  ...c,
+                  items: c.items.map((it) =>
+                    it.id !== item.id ? it : { ...it, completed: !it.completed },
+                  ),
+                },
+          ),
+        );
+      } catch (err) {
+        setError((err as Error).message);
+      }
+    });
+  }
+
+  function handleTextChange(checklistId: string, item: JobChecklistItem, value: string) {
+    setAttached((prev) =>
+      prev.map((c) =>
+        c.id !== checklistId
+          ? c
+          : { ...c, items: c.items.map((it) => (it.id !== item.id ? it : { ...it, value })) },
+      ),
+    );
+  }
+
+  function handleTextBlur(checklistId: string, item: JobChecklistItem) {
+    start(async () => {
+      try {
+        await setJobChecklistItem(checklistId, item.id, { value: item.value ?? '' });
+      } catch (err) {
+        setError((err as Error).message);
+      }
+    });
+  }
+
+  return (
+    <Card>
+      <CardHeader className="flex flex-row items-center justify-between space-y-0">
+        <CardTitle>Checklists ({attached.length})</CardTitle>
+        {templates.length > 0 && (
+          <div className="flex items-center gap-2">
+            <select
+              value={selectedTemplate}
+              onChange={(e) => setSelectedTemplate(e.target.value)}
+              className="border-input bg-background h-9 rounded-md border px-2 text-sm"
+            >
+              {templates.map((t) => (
+                <option key={t.id} value={t.id}>{t.name}</option>
+              ))}
+            </select>
+            <Button size="sm" onClick={handleAttach} disabled={pending}>
+              Attach
+            </Button>
+          </div>
+        )}
+      </CardHeader>
+      <CardContent className="space-y-4">
+        {error && <p className="text-destructive text-sm">{error}</p>}
+        {attached.length === 0 ? (
+          <p className="text-muted-foreground text-sm">
+            No checklists attached.{' '}
+            {templates.length === 0 && (
+              <>Create a template at <code>/checklists/new</code> first.</>
+            )}
+          </p>
+        ) : (
+          attached.map((cl) => {
+            const completedCount = cl.items.filter((i) => i.completed).length;
+            return (
+              <div key={cl.id} className="border-border space-y-3 rounded-md border p-3">
+                <div className="flex items-center justify-between">
+                  <div>
+                    <div className="font-semibold">{cl.templateName}</div>
+                    <div className="text-muted-foreground text-xs">
+                      {completedCount} / {cl.items.length} complete
+                      {!cl.allRequiredComplete && (
+                        <span className="text-destructive ml-2">· Required items pending</span>
+                      )}
+                    </div>
+                  </div>
+                  <div className="flex items-center gap-2">
+                    <Badge variant={cl.allRequiredComplete ? 'default' : 'destructive'}>
+                      {cl.progressPct}%
+                    </Badge>
+                    <button
+                      type="button"
+                      onClick={() => handleDetach(cl.id)}
+                      className="text-muted-foreground hover:text-destructive text-xs underline"
+                    >
+                      Detach
+                    </button>
+                  </div>
+                </div>
+                <div className="space-y-2">
+                  {[...cl.items]
+                    .sort((a, b) => a.sortOrder - b.sortOrder)
+                    .map((item) => (
+                      <div key={item.id} className="flex items-start gap-3">
+                        <input
+                          type="checkbox"
+                          checked={item.completed}
+                          onChange={() => handleToggle(cl.id, item)}
+                          disabled={pending}
+                          className="mt-1 h-4 w-4 cursor-pointer"
+                        />
+                        <div className="flex-1">
+                          <div className={`flex flex-wrap items-center gap-2 text-sm ${item.completed ? 'text-muted-foreground line-through' : ''}`}>
+                            {item.label}
+                            {item.required && !item.completed && (
+                              <Badge variant="destructive" className="text-[10px]">required</Badge>
+                            )}
+                          </div>
+                          {item.helperText && (
+                            <div className="text-muted-foreground mt-0.5 text-xs">{item.helperText}</div>
+                          )}
+                          {item.kind === 'text' && (
+                            <Input
+                              value={item.value ?? ''}
+                              onChange={(e) => handleTextChange(cl.id, item, e.target.value)}
+                              onBlur={() => handleTextBlur(cl.id, item)}
+                              placeholder="Answer…"
+                              className="mt-1 text-xs"
+                            />
+                          )}
+                          {item.kind === 'photo' && (
+                            <div className="text-muted-foreground mt-1 text-[11px]">
+                              Photo uploads in the Photos section above count toward this item.
+                            </div>
+                          )}
+                        </div>
+                      </div>
+                    ))}
+                </div>
+              </div>
+            );
+          })
+        )}
+      </CardContent>
+    </Card>
+  );
+}

package/template/extras/checklists/drizzle/src/components/jobs/job-checklists-section.tsx

@@ -0,0 +1,24 @@
+import { asc, isNull } from 'drizzle-orm';
+import { db } from '@/db/client';
+import { checklistTemplates } from '@/db/schema';
+import { getJobChecklists } from '@/lib/checklists/data';
+import { JobChecklistsClient } from './job-checklists-client';
+
+export async function JobChecklistsSection({ jobId }: { jobId: string }) {
+  const [attached, templates] = await Promise.all([
+    getJobChecklists(jobId),
+    db
+      .select({ id: checklistTemplates.id, name: checklistTemplates.name })
+      .from(checklistTemplates)
+      .where(isNull(checklistTemplates.archivedAt))
+      .orderBy(asc(checklistTemplates.name)),
+  ]);
+
+  return (
+    <JobChecklistsClient
+      jobId={jobId}
+      initialAttached={attached}
+      templates={templates}
+    />
+  );
+}

package/template/extras/checklists/drizzle/src/db/schema/checklists.ts

@@ -0,0 +1,52 @@
+import { jsonb, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { jobs } from './jobs';
+
+interface ChecklistItemJson {
+  id: string;
+  label: string;
+  kind: 'checkbox' | 'text' | 'photo';
+  required: boolean;
+  sortOrder: number;
+  helperText?: string;
+}
+
+interface JobChecklistItemJson extends ChecklistItemJson {
+  completed: boolean;
+  completedAt?: string;
+  value?: string;
+}
+
+/**
+ * Reusable templates — admin-editable. items is stored as jsonb because
+ * they're effectively static per-template and we never need to query
+ * within them. Soft-delete via archivedAt.
+ */
+export const checklistTemplates = pgTable('checklist_templates', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  name: text('name').notNull(),
+  description: text('description'),
+  items: jsonb('items').$type<ChecklistItemJson[]>().notNull().default([]),
+  archivedAt: timestamp('archived_at'),
+  createdAt: timestamp('created_at').notNull().defaultNow(),
+  updatedAt: timestamp('updated_at').notNull().defaultNow(),
+});
+
+/**
+ * Per-job instance — copies the template's items at attach time so
+ * template edits don't retroactively change in-flight job checklists.
+ * Completion state lives inline on each item.
+ */
+export const jobChecklists = pgTable('job_checklists', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  jobId: uuid('job_id').notNull().references(() => jobs.id, { onDelete: 'cascade' }),
+  templateId: uuid('template_id').references(() => checklistTemplates.id, { onDelete: 'set null' }),
+  templateName: text('template_name').notNull(),
+  items: jsonb('items').$type<JobChecklistItemJson[]>().notNull().default([]),
+  attachedAt: timestamp('attached_at').notNull().defaultNow(),
+  updatedAt: timestamp('updated_at').notNull().defaultNow(),
+});
+
+export type ChecklistTemplateRow = typeof checklistTemplates.$inferSelect;
+export type NewChecklistTemplate = typeof checklistTemplates.$inferInsert;
+export type JobChecklistRow = typeof jobChecklists.$inferSelect;
+export type NewJobChecklist = typeof jobChecklists.$inferInsert;

package/template/extras/checklists/drizzle/src/lib/checklists/actions.ts

@@ -0,0 +1,112 @@
+'use server';
+
+import crypto from 'node:crypto';
+import { eq } from 'drizzle-orm';
+import { redirect } from 'next/navigation';
+import { revalidatePath } from 'next/cache';
+import { db } from '@/db/client';
+import { checklistTemplates, jobChecklists } from '@/db/schema';
+import type { ChecklistTemplateItem, JobChecklistItem } from './types';
+
+export interface CreateTemplateInput {
+  name: string;
+  description?: string;
+  items: Array<Omit<ChecklistTemplateItem, 'id' | 'sortOrder'>>;
+}
+
+export async function createChecklistTemplate(input: CreateTemplateInput): Promise<void> {
+  if (!input.name.trim()) throw new Error('Name is required');
+  if (input.items.length === 0) throw new Error('Add at least one item');
+
+  const items: ChecklistTemplateItem[] = input.items.map((it, i) => ({
+    id: crypto.randomBytes(4).toString('hex'),
+    label: it.label.trim(),
+    kind: it.kind,
+    required: it.required,
+    helperText: it.helperText?.trim() || undefined,
+    sortOrder: i,
+  }));
+
+  const [row] = await db
+    .insert(checklistTemplates)
+    .values({
+      name: input.name.trim(),
+      description: input.description?.trim() || null,
+      items,
+    })
+    .returning({ id: checklistTemplates.id });
+
+  revalidatePath('/checklists');
+  redirect(`/checklists/${row.id}`);
+}
+
+/**
+ * Server action — attaches a template to a job by copying the template's
+ * items into a new job_checklists row with completed=false for each.
+ */
+export async function attachChecklistToJob(jobId: string, templateId: string): Promise<void> {
+  const [template] = await db
+    .select()
+    .from(checklistTemplates)
+    .where(eq(checklistTemplates.id, templateId))
+    .limit(1);
+  if (!template) throw new Error('Template not found');
+
+  const items: JobChecklistItem[] = (template.items as ChecklistTemplateItem[]).map((it) => ({
+    ...it,
+    completed: false,
+  }));
+
+  await db.insert(jobChecklists).values({
+    jobId,
+    templateId: template.id,
+    templateName: template.name,
+    items,
+  });
+
+  revalidatePath(`/jobs/${jobId}`);
+}
+
+export async function setJobChecklistItem(
+  jobChecklistId: string,
+  itemId: string,
+  patch: { completed?: boolean; value?: string },
+): Promise<void> {
+  const [row] = await db
+    .select()
+    .from(jobChecklists)
+    .where(eq(jobChecklists.id, jobChecklistId))
+    .limit(1);
+  if (!row) throw new Error('Checklist not found');
+
+  const items = (row.items as JobChecklistItem[]).map((it) => {
+    if (it.id !== itemId) return it;
+    const next = { ...it };
+    if (patch.completed !== undefined) {
+      next.completed = patch.completed;
+      next.completedAt = patch.completed ? new Date().toISOString() : undefined;
+    }
+    if (patch.value !== undefined) {
+      next.value = patch.value;
+    }
+    return next;
+  });
+
+  await db
+    .update(jobChecklists)
+    .set({ items, updatedAt: new Date() })
+    .where(eq(jobChecklists.id, jobChecklistId));
+
+  revalidatePath(`/jobs/${row.jobId}`);
+}
+
+export async function detachJobChecklist(jobChecklistId: string): Promise<void> {
+  const [row] = await db
+    .select({ jobId: jobChecklists.jobId })
+    .from(jobChecklists)
+    .where(eq(jobChecklists.id, jobChecklistId))
+    .limit(1);
+  if (!row) return;
+  await db.delete(jobChecklists).where(eq(jobChecklists.id, jobChecklistId));
+  revalidatePath(`/jobs/${row.jobId}`);
+}