diff --git a/cli/package.json b/cli/package.json
index 94988fea..ede1535e 100644
--- a/cli/package.json
+++ b/cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@profullstack/smshub",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Rent a phone number and receive SMS / verification codes from your terminal, scripts and AI agents (CLI, TUI, MCP) via smshub.dev",
   "type": "module",
   "bin": {
diff --git a/cli/smshub.mjs b/cli/smshub.mjs
index 93766bf1..9199585c 100644
--- a/cli/smshub.mjs
+++ b/cli/smshub.mjs
@@ -12,6 +12,14 @@
 //   smshub-cli messages <number> [--since ISO] [--limit 20]
 //   smshub-cli otp <number> [--wait 60]     print the next code, nothing else
 //   smshub-cli send <to> "<message>" [--from <number>] [--media <url>]   text someone from your own number
+//   smshub-cli groups                        your contact groups
+//   smshub-cli group create "<name>" [--from <number>] [--relay] [--member +1415...[=Kim]]...   a group (members repeatable)
+//   smshub-cli group <id>                    one group and its members (id or external_ref)
+//   smshub-cli group add <id> +1415...[=Kim] [...]   add members
+//   smshub-cli group remove <id> <phone>     remove a member
+//   smshub-cli group send <id> "<message>" [--from <number>]   text every member (STOPped ones skipped)
+//   smshub-cli group relay <id> on|off       members' replies go to the whole group (SMS group chat)
+//   smshub-cli group rm <id>                 delete a group
 //   smshub-cli conversations [--line <number>] [--limit 20]   the inbox, optionally one line
 //   smshub-cli thread <conversation-id> [--limit 50]   messages in one conversation
 //   smshub-cli lines                        who shares each number (contacts book)
@@ -34,7 +42,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { createInterface } from "node:readline";
 
-const VERSION = "1.7.0";
+const VERSION = "1.8.0";
 const CONFIG_DIR = join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "smshub");
 const CONFIG_FILE = join(CONFIG_DIR, "config.json");
 
@@ -43,10 +51,12 @@ function parseArgs(argv) {
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a.startsWith("--")) {
-      const [k, v] = a.slice(2).split("=", 2);
-      if (v !== undefined) out[k] = v;
-      else if (argv[i + 1] !== undefined && !argv[i + 1].startsWith("--")) out[k] = argv[++i];
-      else out[k] = true;
+      const eq = a.indexOf("=");
+      const k = eq === -1 ? a.slice(2) : a.slice(2, eq);
+      let v = eq === -1 ? undefined : a.slice(eq + 1);
+      if (v === undefined) v = argv[i + 1] !== undefined && !argv[i + 1].startsWith("--") ? argv[++i] : true;
+      // A flag given twice (--member a --member b) keeps both.
+      out[k] = out[k] === undefined ? v : [].concat(out[k], v);
     } else out._.push(a);
   }
   return out;
@@ -404,6 +414,59 @@ const commands = {
     print(args, res, (r) => console.log(`sent ${r.from} -> ${r.to}  ${r.message?.id ?? ""}`));
   },
 
+  async groups(args) {
+    const { groups } = await api("/api/v1/groups");
+    print(args, { groups }, () => {
+      if (!groups.length) console.log('No groups. smshub-cli group create "Team" --member +14155550123=Kim');
+      for (const g of groups) console.log(`${g.id}  ${g.name.padEnd(24)} ${String(g.member_count).padStart(3)} members  ${g.from ?? "(no number)"}${g.relay ? "  relay" : ""}${g.external_ref ? `  ${g.external_ref}` : ""}`);
+    });
+  },
+
+  async group(args) {
+    const sub = args._[1];
+    const members = (list) =>
+      list.filter(Boolean).map((m) => {
+        const [phone, ...name] = String(m).split("=");
+        return { phone, ...(name.length ? { name: name.join("=") } : {}) };
+      });
+    const show = (g) => {
+      console.log(`${g.name}  (${g.id})${g.relay ? "  relay on" : ""}`);
+      console.log(`from ${g.from ?? "(none: pass --from when sending)"}${g.external_ref ? `  ref ${g.external_ref}` : ""}`);
+      for (const m of g.members ?? []) console.log(`  ${m.phone}  ${m.name ?? ""}${m.opted_out ? "  (STOPped)" : ""}`);
+    };
+    const id = (n = 2) => {
+      const v = args._[n];
+      if (!v) throw new ApiError("Which group? smshub-cli groups shows ids");
+      return encodeURIComponent(v);
+    };
+    if (sub === "create") {
+      const name = args._.slice(2).join(" ").trim();
+      if (!name) throw new ApiError('Usage: smshub-cli group create "Team" [--from <number>] [--relay] [--member +1415...=Kim]');
+      const list = [].concat(args.member ?? []).filter((m) => m !== true);
+      const body = { name, members: members(list), relay: args.relay === true };
+      if (args.from && args.from !== true) body.from = await resolveLine(String(args.from));
+      return print(args, await api("/api/v1/groups", { method: "POST", body }), show);
+    }
+    if (sub === "add") return print(args, await api(`/api/v1/groups/${id()}/members`, { method: "POST", body: { members: members(args._.slice(3)) } }), show);
+    if (sub === "remove") {
+      if (!args._[3]) throw new ApiError("Usage: smshub-cli group remove <id> <phone>");
+      return print(args, await api(`/api/v1/groups/${id()}/members/${encodeURIComponent(args._[3])}`, { method: "DELETE" }), show);
+    }
+    if (sub === "send") {
+      const message = args._.slice(3).join(" ").trim();
+      if (!message) throw new ApiError('Usage: smshub-cli group send <id> "message"');
+      const body = { message };
+      if (args.from && args.from !== true) body.from = await resolveLine(String(args.from));
+      return print(args, await api(`/api/v1/groups/${id()}/send`, { method: "POST", body }), (r) =>
+        console.log(`sent ${r.sent} from ${r.from}${r.failed ? `, ${r.failed} failed (${r.errors?.[0]?.error ?? ""})` : ""}${r.skipped ? `, ${r.skipped} skipped` : ""}`)
+      );
+    }
+    if (sub === "relay") return print(args, await api(`/api/v1/groups/${id()}`, { method: "PATCH", body: { relay: args._[3] !== "off" } }), show);
+    if (sub === "rm" || sub === "delete") return print(args, await api(`/api/v1/groups/${id()}`, { method: "DELETE" }), () => console.log("deleted"));
+    if (!sub) throw new ApiError("Usage: smshub-cli group <id> | create | add | remove | send | relay | rm");
+    return print(args, await api(`/api/v1/groups/${id(1)}`), show);
+  },
+
   async thread(args) {
     const id = args._[1];
     if (!id) throw new ApiError("Which conversation? smshub-cli conversations --json shows ids");
diff --git a/package.json b/package.json
index 2ca9b74e..32de53a3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "smshub",
-  "version": "0.1.155",
+  "version": "0.1.156",
   "private": true,
   "scripts": {
     "dev": "bun --bun next dev",
diff --git a/src/app/api/v1/groups/[id]/members/[member]/route.ts b/src/app/api/v1/groups/[id]/members/[member]/route.ts
new file mode 100644
index 00000000..4f6d5161
--- /dev/null
+++ b/src/app/api/v1/groups/[id]/members/[member]/route.ts
@@ -0,0 +1,8 @@
+import { groupsHandler } from "@/lib/groups-route";
+import { removeMember } from "@/lib/groups";
+
+/** Remove one member, by phone (E.164) or contact id. */
+export async function DELETE(request: Request, { params }: { params: Promise<{ id: string; member: string }> }) {
+  const { id, member } = await params;
+  return groupsHandler(request, (db, userId) => removeMember(db, userId, decodeURIComponent(id), decodeURIComponent(member)));
+}
diff --git a/src/app/api/v1/groups/[id]/members/route.ts b/src/app/api/v1/groups/[id]/members/route.ts
new file mode 100644
index 00000000..c8aa4cee
--- /dev/null
+++ b/src/app/api/v1/groups/[id]/members/route.ts
@@ -0,0 +1,8 @@
+import { groupsHandler } from "@/lib/groups-route";
+import { addMembers } from "@/lib/groups";
+
+/** Add members: { members: [{ phone, name? }] }. */
+export async function POST(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return groupsHandler(request, (db, userId, body) => addMembers(db, userId, decodeURIComponent(id), body.members));
+}
diff --git a/src/app/api/v1/groups/[id]/route.ts b/src/app/api/v1/groups/[id]/route.ts
new file mode 100644
index 00000000..ecbf4e60
--- /dev/null
+++ b/src/app/api/v1/groups/[id]/route.ts
@@ -0,0 +1,23 @@
+import { groupsHandler } from "@/lib/groups-route";
+import { deleteGroup, getGroup, updateGroup } from "@/lib/groups";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+/** One group with its members. `id` is the group id or its external_ref. */
+export async function GET(request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return groupsHandler(request, (db, userId) => getGroup(db, userId, decodeURIComponent(id)));
+}
+
+/** Change name, description, from, relay; `members` (when given) replaces the member list. */
+export async function PATCH(request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return groupsHandler(request, (db, userId, body) => updateGroup(db, userId, decodeURIComponent(id), body));
+}
+
+export const PUT = PATCH;
+
+export async function DELETE(request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return groupsHandler(request, (db, userId) => deleteGroup(db, userId, decodeURIComponent(id)));
+}
diff --git a/src/app/api/v1/groups/[id]/send/route.ts b/src/app/api/v1/groups/[id]/send/route.ts
new file mode 100644
index 00000000..eb2bbd81
--- /dev/null
+++ b/src/app/api/v1/groups/[id]/send/route.ts
@@ -0,0 +1,8 @@
+import { groupsHandler } from "@/lib/groups-route";
+import { sendToGroup } from "@/lib/groups";
+
+/** Text every member: { message, from?, media_url?, except?: [phones] }. Members who said STOP are skipped. */
+export async function POST(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return groupsHandler(request, (db, userId, body) => sendToGroup(db, userId, decodeURIComponent(id), body));
+}
diff --git a/src/app/api/v1/groups/route.ts b/src/app/api/v1/groups/route.ts
new file mode 100644
index 00000000..99d506b9
--- /dev/null
+++ b/src/app/api/v1/groups/route.ts
@@ -0,0 +1,15 @@
+import { groupsHandler } from "@/lib/groups-route";
+import { listGroups, saveGroup } from "@/lib/groups";
+
+/** Your contact groups. */
+export async function GET(request: Request) {
+  return groupsHandler(request, async (db, userId) => ({ groups: await listGroups(db, userId) }));
+}
+
+/**
+ * Make a group: { name, description?, from?, relay?, members?: [{ phone, name? }], external_ref? }.
+ * With external_ref already on one of your groups, that group is updated and its members replaced.
+ */
+export async function POST(request: Request) {
+  return groupsHandler(request, (db, userId, body) => saveGroup(db, userId, body), 201);
+}
diff --git a/src/app/groups/page.tsx b/src/app/groups/page.tsx
new file mode 100644
index 00000000..e7924b88
--- /dev/null
+++ b/src/app/groups/page.tsx
@@ -0,0 +1,213 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import Link from "next/link";
+
+interface Member {
+  contact_id: string;
+  phone: string;
+  name: string | null;
+  opted_out: boolean;
+}
+
+interface Group {
+  id: string;
+  name: string;
+  description: string;
+  from: string | null;
+  relay: boolean;
+  external_ref: string | null;
+  member_count: number;
+  last_sent_at: string | null;
+  members?: Member[];
+}
+
+interface NumberRow {
+  id: string;
+  number: string;
+  managed?: boolean;
+}
+
+const input = "px-3 py-2 bg-gray-800 border border-gray-700 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500";
+const button = "px-3 py-2 rounded-lg bg-blue-600 hover:bg-blue-500 text-sm disabled:opacity-50";
+const quiet = "px-3 py-2 rounded-lg bg-gray-800 hover:bg-gray-700 text-sm";
+
+async function call<T>(path: string, init?: { method?: string; body?: unknown }): Promise<T> {
+  const res = await fetch(path, {
+    method: init?.method ?? "GET",
+    headers: init?.body ? { "content-type": "application/json" } : undefined,
+    body: init?.body ? JSON.stringify(init.body) : undefined,
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error ?? `HTTP ${res.status}`);
+  return data as T;
+}
+
+/** "+14155550123 Kim" or "+14155550123=Kim", one per line or comma separated. */
+function parseMembers(text: string) {
+  return text
+    .split(/[\n,]+/)
+    .map((l) => l.trim())
+    .filter(Boolean)
+    .map((l) => {
+      const m = /^(\+?[\d\s().-]{7,})(?:\s*[=\s]\s*(.+))?$/.exec(l);
+      return m ? { phone: m[1].replace(/[\s().-]/g, ""), ...(m[2] ? { name: m[2].trim() } : {}) } : { phone: l };
+    });
+}
+
+export default function GroupsPage() {
+  const [groups, setGroups] = useState<Group[]>([]);
+  const [numbers, setNumbers] = useState<NumberRow[]>([]);
+  const [open, setOpen] = useState<Group | null>(null);
+  const [note, setNote] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [name, setName] = useState("");
+  const [from, setFrom] = useState("");
+  const [relay, setRelay] = useState(false);
+  const [membersText, setMembersText] = useState("");
+  const [addText, setAddText] = useState("");
+  const [message, setMessage] = useState("");
+
+  const load = useCallback(async () => {
+    try {
+      const [{ groups }, nums] = await Promise.all([
+        call<{ groups: Group[] }>("/api/v1/groups"),
+        call<{ numbers?: NumberRow[] }>("/api/v1/numbers").catch(() => ({ numbers: [] as NumberRow[] })),
+      ]);
+      setGroups(groups);
+      setNumbers((nums.numbers ?? []).filter((n) => !n.managed));
+    } catch (e) {
+      setNote((e as Error).message);
+    }
+  }, []);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const act = async (job: () => Promise<string | void>) => {
+    setBusy(true);
+    setNote("");
+    try {
+      const said = await job();
+      if (said) setNote(said);
+      await load();
+    } catch (e) {
+      setNote((e as Error).message);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const show = (id: string) => act(async () => setOpen(await call<Group>(`/api/v1/groups/${encodeURIComponent(id)}`)));
+
+  return (
+    <div className="min-h-screen bg-gray-950 p-8">
+      <div className="max-w-4xl mx-auto space-y-6">
+        <div className="flex items-center justify-between">
+          <h1 className="text-2xl font-bold">Groups</h1>
+          <Link href="/inbox" className="text-blue-400 hover:text-blue-300 text-sm">
+            ← Back to Inbox
+          </Link>
+        </div>
+        <p className="text-sm text-gray-400">
+          Named lists of people you text together, from your own number. Turn on relay and a member&apos;s reply to that
+          number goes to the whole group, like a group chat. Anyone who replies STOP is skipped. Also from the API
+          (<code>/api/v1/groups</code>), <code>smshub-cli group</code> and MCP.
+        </p>
+        {note && <div className="text-sm bg-gray-900 border border-gray-800 rounded-lg p-3">{note}</div>}
+
+        <form
+          className="bg-gray-900 rounded-lg p-4 border border-gray-800 space-y-3"
+          onSubmit={(e) => {
+            e.preventDefault();
+            void act(async () => {
+              const g = await call<Group>("/api/v1/groups", { method: "POST", body: { name, from: from || undefined, relay, members: parseMembers(membersText) } });
+              setName("");
+              setMembersText("");
+              setOpen(g);
+              return `Made ${g.name} with ${g.member_count} member${g.member_count === 1 ? "" : "s"}.`;
+            });
+          }}
+        >
+          <h2 className="font-medium">New group</h2>
+          <div className="flex flex-wrap gap-2">
+            <input className={input} required value={name} onChange={(e) => setName(e.target.value)} placeholder="Name" aria-label="Group name" />
+            <select className={input} value={from} onChange={(e) => setFrom(e.target.value)} aria-label="Texts from">
+              <option value="">Texts from…</option>
+              {numbers.map((n) => (
+                <option key={n.id} value={n.id}>
+                  {n.number}
+                </option>
+              ))}
+            </select>
+            <label className="flex items-center gap-2 text-sm text-gray-300">
+              <input type="checkbox" checked={relay} onChange={(e) => setRelay(e.target.checked)} /> Relay replies to the group
+            </label>
+          </div>
+          <textarea className={`${input} w-full`} rows={3} value={membersText} onChange={(e) => setMembersText(e.target.value)} placeholder={"+14155550123 Kim\n+14155550124 Lee"} aria-label="Members" />
+          <button className={button} disabled={busy}>
+            Make group
+          </button>
+        </form>
+
+        <div className="space-y-2">
+          {groups.length === 0 && <div className="text-center py-8 text-gray-500">No groups yet</div>}
+          {groups.map((g) => (
+            <button key={g.id} type="button" onClick={() => void show(g.id)} className="w-full text-left bg-gray-900 rounded-lg p-4 border border-gray-800 hover:border-gray-700">
+              <div className="flex justify-between">
+                <span className="font-medium">{g.name}</span>
+                <span className="text-xs text-gray-500">
+                  {g.member_count} member{g.member_count === 1 ? "" : "s"}
+                  {g.relay ? " · relay" : ""}
+                  {g.external_ref ? ` · ${g.external_ref}` : ""}
+                </span>
+              </div>
+              <div className="text-sm text-gray-400">{g.from ?? "No number set"}</div>
+            </button>
+          ))}
+        </div>
+
+        {open && (
+          <div className="bg-gray-900 rounded-lg p-4 border border-gray-700 space-y-3">
+            <div className="flex justify-between items-center">
+              <h2 className="font-medium">
+                {open.name} <span className="text-sm text-gray-500">from {open.from ?? "(choose a number)"}</span>
+              </h2>
+              <div className="flex gap-2">
+                <button type="button" className={quiet} onClick={() => void act(async () => { setOpen(await call<Group>(`/api/v1/groups/${open.id}`, { method: "PATCH", body: { relay: !open.relay } })); })}>
+                  Relay {open.relay ? "on" : "off"}
+                </button>
+                <button type="button" className={quiet} onClick={() => void act(async () => { await call(`/api/v1/groups/${open.id}`, { method: "DELETE" }); setOpen(null); return "Group deleted."; })}>
+                  Delete
+                </button>
+              </div>
+            </div>
+            <ul className="text-sm space-y-1">
+              {(open.members ?? []).map((m) => (
+                <li key={m.contact_id} className="flex justify-between">
+                  <span>
+                    {m.name ? `${m.name} · ` : ""}
+                    {m.phone}
+                    {m.opted_out && <span className="text-gray-500"> (STOP)</span>}
+                  </span>
+                  <button type="button" className="text-red-400 text-xs" onClick={() => void act(async () => { setOpen(await call<Group>(`/api/v1/groups/${open.id}/members/${encodeURIComponent(m.phone)}`, { method: "DELETE" })); })}>
+                    remove
+                  </button>
+                </li>
+              ))}
+            </ul>
+            <form className="flex gap-2" onSubmit={(e) => { e.preventDefault(); void act(async () => { setOpen(await call<Group>(`/api/v1/groups/${open.id}/members`, { method: "POST", body: { members: parseMembers(addText) } })); setAddText(""); }); }}>
+              <input className={`${input} flex-1`} value={addText} onChange={(e) => setAddText(e.target.value)} placeholder="+14155550125 Sam" aria-label="Add members" />
+              <button className={quiet} disabled={busy}>Add</button>
+            </form>
+            <form className="flex gap-2" onSubmit={(e) => { e.preventDefault(); void act(async () => { const r = await call<{ sent: number; failed: number; skipped: number; errors?: { error?: string }[] }>(`/api/v1/groups/${open.id}/send`, { method: "POST", body: { message } }); setMessage(""); return `Sent ${r.sent}${r.failed ? `, ${r.failed} failed (${r.errors?.[0]?.error ?? ""})` : ""}${r.skipped ? `, ${r.skipped} skipped` : ""}.`; }); }}>
+              <input className={`${input} flex-1`} required maxLength={1600} value={message} onChange={(e) => setMessage(e.target.value)} placeholder="Text everyone in this group" aria-label="Message" />
+              <button className={button} disabled={busy}>Send</button>
+            </form>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/footer.tsx b/src/components/footer.tsx
index 4ec54ca6..d8d62829 100644
--- a/src/components/footer.tsx
+++ b/src/components/footer.tsx
@@ -2,7 +2,7 @@
 
 import { usePathname } from "next/navigation";
 
-const APP_ROUTES = ["/inbox", "/settings", "/campaigns", "/contacts", "/analytics", "/org"];
+const APP_ROUTES = ["/inbox", "/settings", "/campaigns", "/contacts", "/groups", "/analytics", "/org"];
 
 /**
  * One footer row: links, copyright and the Profullstack ring, from
diff --git a/src/components/header.tsx b/src/components/header.tsx
index 60e79228..fa27725f 100644
--- a/src/components/header.tsx
+++ b/src/components/header.tsx
@@ -5,7 +5,7 @@ import Link from "next/link";
 import { usePathname } from "next/navigation";
 import { Logo } from "@/components/logo";
 
-const APP_ROUTES = ["/inbox", "/settings", "/campaigns", "/contacts", "/analytics", "/org"];
+const APP_ROUTES = ["/inbox", "/settings", "/campaigns", "/contacts", "/groups", "/analytics", "/org"];
 
 const NAV_LINKS = [
   { href: "/#features", label: "Features" },
diff --git a/src/lib/__tests__/groups.test.ts b/src/lib/__tests__/groups.test.ts
new file mode 100644
index 00000000..bd20906f
--- /dev/null
+++ b/src/lib/__tests__/groups.test.ts
@@ -0,0 +1,19 @@
+import { describe, it, expect } from "vitest";
+import { cleanMembers, MAX_GROUP_MEMBERS } from "@/lib/groups";
+
+describe("cleanMembers", () => {
+  it("normalises phones, keeps names, and de-duplicates", () => {
+    expect(cleanMembers([{ phone: "(415) 555-0123", name: " Kim " }, "+14155550124", { phone: "4155550123" }])).toEqual([
+      { phone: "+14155550123", name: "Kim" },
+      { phone: "+14155550124", name: null },
+    ]);
+  });
+
+  it("refuses a bad phone instead of skipping it, and too many members", () => {
+    expect(() => cleanMembers([{ phone: "555" }])).toThrow(/Invalid member phone/);
+    expect(() => cleanMembers("+14155550123")).toThrow(/list/);
+    const many = Array.from({ length: MAX_GROUP_MEMBERS + 1 }, (_, i) => `+1415555${String(i).padStart(4, "0")}`);
+    expect(() => cleanMembers(many)).toThrow(/at most/);
+    expect(cleanMembers(undefined)).toEqual([]);
+  });
+});
diff --git a/src/lib/developer-api.ts b/src/lib/developer-api.ts
index 6d0cb7c7..2ad18651 100644
--- a/src/lib/developer-api.ts
+++ b/src/lib/developer-api.ts
@@ -101,6 +101,51 @@ export const ENDPOINTS: Endpoint[] = [
     cli: "send",
     mcp: "send_message",
   },
+  { method: "GET", path: "/api/v1/groups", summary: "Your contact groups: named lists of people you text together.", cli: "groups", mcp: "list_groups" },
+  {
+    method: "POST",
+    path: "/api/v1/groups",
+    summary: "Make a group. With external_ref already on one of your groups, that group is updated and its members replaced (how another app keeps a group in step).",
+    params: [
+      { name: "name", in: "body", type: "string", required: true, description: "What to call it." },
+      { name: "members", in: "body", type: "string", description: "JSON list of { phone, name? }, up to 200." },
+      { name: "from", in: "body", type: "string", description: "Your own number (E.164 or id) the group texts from." },
+      { name: "relay", in: "body", type: "boolean", description: "Members' texts to that number go to the whole group (group chat over SMS)." },
+      { name: "external_ref", in: "body", type: "string", description: "Your own key for the group, e.g. groupcall:4821." },
+    ],
+    cli: "group create",
+    mcp: "save_group",
+  },
+  { method: "GET", path: "/api/v1/groups/{id}", summary: "One group with its members.", params: [id("Group id or external_ref.")], cli: "group <id>", mcp: "get_group" },
+  {
+    method: "PATCH",
+    path: "/api/v1/groups/{id}",
+    summary: "Change name, description, from or relay; members (when given) replaces the list.",
+    params: [id("Group id or external_ref."), { name: "members", in: "body", type: "string", description: "JSON list of { phone, name? }." }],
+  },
+  { method: "DELETE", path: "/api/v1/groups/{id}", summary: "Delete a group (its contacts stay).", params: [id("Group id or external_ref.")], cli: "group rm" },
+  {
+    method: "POST",
+    path: "/api/v1/groups/{id}/members",
+    summary: "Add members.",
+    params: [id("Group id or external_ref."), { name: "members", in: "body", type: "string", required: true, description: "JSON list of { phone, name? }." }],
+    cli: "group add",
+    mcp: "add_group_members",
+  },
+  { method: "DELETE", path: "/api/v1/groups/{id}/members/{member}", summary: "Remove a member, by phone or contact id.", params: [id("Group id or external_ref."), { name: "member", in: "path", type: "string", required: true, description: "Phone (E.164) or contact id." }], cli: "group remove" },
+  {
+    method: "POST",
+    path: "/api/v1/groups/{id}/send",
+    summary: "Text every member from your own number; members who said STOP are skipped. One group send counts once against 10/min.",
+    params: [
+      id("Group id or external_ref."),
+      { name: "message", in: "body", type: "string", required: true, description: "Up to 1600 characters." },
+      { name: "from", in: "body", type: "string", description: "Overrides the group's number." },
+      { name: "except", in: "body", type: "string", description: "JSON list of phones to leave out this time." },
+    ],
+    cli: "group send",
+    mcp: "send_to_group",
+  },
   {
     method: "GET",
     path: "/api/v1/conversations",
diff --git a/src/lib/groups-route.ts b/src/lib/groups-route.ts
new file mode 100644
index 00000000..d8114bc0
--- /dev/null
+++ b/src/lib/groups-route.ts
@@ -0,0 +1,34 @@
+import { NextResponse } from "next/server";
+import { createServiceClient } from "@/lib/supabase/server";
+import { resolveUser } from "@/lib/request-user";
+import { SendError } from "@/lib/messages/send";
+import type { SupabaseClient } from "@supabase/supabase-js";
+
+/** Run a groups handler for the caller (API key or session), mapping SendError to its status. */
+export async function groupsHandler(
+  request: Request,
+  run: (db: SupabaseClient, userId: string, body: Record<string, unknown>) => Promise<unknown>,
+  status = 200
+) {
+  const who = await resolveUser(request);
+  if ("error" in who) return NextResponse.json({ error: who.error }, { status: who.status });
+  let body: Record<string, unknown> = {};
+  if (request.method !== "GET" && request.method !== "DELETE") {
+    try {
+      body = ((await request.json()) ?? {}) as Record<string, unknown>;
+    } catch {
+      return NextResponse.json({ error: "Body must be JSON" }, { status: 400 });
+    }
+  }
+  try {
+    return NextResponse.json(await run(createServiceClient(), who.user.userId, body), { status });
+  } catch (error) {
+    if (error instanceof SendError) {
+      const headers: Record<string, string> = {};
+      if (error.retryAfterMs) headers["Retry-After"] = String(Math.ceil(error.retryAfterMs / 1000));
+      return NextResponse.json({ error: error.message }, { status: error.status, headers });
+    }
+    console.error("groups API error:", error);
+    return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+  }
+}
diff --git a/src/lib/groups.ts b/src/lib/groups.ts
new file mode 100644
index 00000000..77bc5c89
--- /dev/null
+++ b/src/lib/groups.ts
@@ -0,0 +1,375 @@
+/**
+ * Contact groups: named lists of people to text together, from one of your own numbers.
+ *
+ * A group send texts each member separately (an SMS "group" is many one-to-one texts), files
+ * each in the inbox like any other send, and skips members who said STOP. With `relay` on, a
+ * member's text to the group's number goes on to everyone else in the group, so the group
+ * works like a group chat. Other apps keep a group in step with something of theirs through
+ * `external_ref` (group.call keeps one per room): PUT the whole member list, then send.
+ *
+ * Every query is scoped by user_id here because the API runs with the service role.
+ */
+
+import type { SupabaseClient } from "@supabase/supabase-js";
+import { toE164 } from "@/lib/providers";
+import { checkRateLimit } from "@/lib/rate-limit";
+import { isUuid } from "@/lib/conversations";
+import { MAX_BODY, SendError, pickNumber, sendFromNumber, type NumberRow } from "@/lib/messages/send";
+
+/** Group sends a user may start in a minute (each one texts every member). */
+export const GROUP_SEND_RATE_LIMIT = { limit: 10, windowMs: 60 * 1000 };
+/** Members one group may hold, which is also the most texts one group send makes. */
+export const MAX_GROUP_MEMBERS = 200;
+export const MAX_GROUPS = 100;
+
+export interface GroupMemberInput {
+  phone?: unknown;
+  name?: unknown;
+}
+
+export interface GroupInput {
+  name?: unknown;
+  description?: unknown;
+  /** The number the group texts from (E.164 or its id). */
+  from?: unknown;
+  relay?: unknown;
+  external_ref?: unknown;
+  /** With PUT/upsert: the whole member list. */
+  members?: unknown;
+}
+
+export interface GroupMember {
+  contact_id: string;
+  phone: string;
+  name: string | null;
+  opted_out: boolean;
+  added_at: string;
+}
+
+export interface Group {
+  id: string;
+  name: string;
+  description: string;
+  from: string | null;
+  phone_number_id: string | null;
+  relay: boolean;
+  external_ref: string | null;
+  member_count: number;
+  created_at: string;
+  updated_at: string;
+  last_sent_at: string | null;
+  members?: GroupMember[];
+}
+
+interface GroupRow {
+  id: string;
+  user_id: string;
+  name: string;
+  description: string;
+  phone_number_id: string | null;
+  relay: boolean;
+  external_ref: string | null;
+  created_at: string;
+  updated_at: string;
+  last_sent_at: string | null;
+  phone_numbers?: { number: string } | null;
+}
+
+const GROUP_COLS = "id, user_id, name, description, phone_number_id, relay, external_ref, created_at, updated_at, last_sent_at, phone_numbers(number)";
+
+const str = (v: unknown, max: number) => (typeof v === "string" ? v.replace(/\s+/g, " ").trim().slice(0, max) : "");
+
+/** Phones from user input, normalised and de-duplicated; a bad one is an error, not a silent skip. */
+export function cleanMembers(input: unknown): { phone: string; name: string | null }[] {
+  if (input === undefined || input === null) return [];
+  if (!Array.isArray(input)) throw new SendError("members must be a list of { phone, name? }", 400);
+  const out = new Map<string, string | null>();
+  for (const m of input as (GroupMemberInput | string)[]) {
+    const raw = typeof m === "string" ? m : m?.phone;
+    const phone = typeof raw === "string" ? toE164(raw.trim()) : null;
+    if (!phone) throw new SendError(`Invalid member phone "${String(raw)}": use E.164, e.g. +14155551234`, 400);
+    const name = typeof m === "string" ? "" : str(m?.name, 60);
+    out.set(phone, name || out.get(phone) || null);
+  }
+  if (out.size > MAX_GROUP_MEMBERS) throw new SendError(`A group holds at most ${MAX_GROUP_MEMBERS} members`, 400);
+  return [...out].map(([phone, name]) => ({ phone, name }));
+}
+
+function toGroup(row: GroupRow, memberCount: number, members?: GroupMember[]): Group {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    from: row.phone_numbers?.number ?? null,
+    phone_number_id: row.phone_number_id,
+    relay: row.relay,
+    external_ref: row.external_ref,
+    member_count: memberCount,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    last_sent_at: row.last_sent_at,
+    ...(members ? { members } : {}),
+  };
+}
+
+async function memberRows(db: SupabaseClient, groupId: string): Promise<GroupMember[]> {
+  const { data, error } = await db
+    .from("contact_group_members")
+    .select("contact_id, opted_out, added_at, contacts(phone, name)")
+    .eq("group_id", groupId)
+    .order("added_at");
+  if (error) throw error;
+  return ((data ?? []) as unknown as { contact_id: string; opted_out: boolean; added_at: string; contacts: { phone: string; name: string | null } | null }[])
+    .filter((m) => m.contacts)
+    .map((m) => ({ contact_id: m.contact_id, phone: m.contacts!.phone, name: m.contacts!.name, opted_out: m.opted_out, added_at: m.added_at }));
+}
+
+/** A group of this user's, by id or by external_ref. */
+async function ownGroup(db: SupabaseClient, userId: string, ref: string): Promise<GroupRow> {
+  let q = db.from("contact_groups").select(GROUP_COLS).eq("user_id", userId);
+  q = isUuid(ref) ? q.eq("id", ref) : q.eq("external_ref", ref);
+  const { data, error } = await q.maybeSingle();
+  if (error) throw error;
+  if (!data) throw new SendError("Group not found", 404);
+  return data as unknown as GroupRow;
+}
+
+async function numberId(db: SupabaseClient, userId: string, from: unknown): Promise<string | null> {
+  const ref = str(from, 64);
+  if (!ref) return null;
+  const n = await pickNumber(db, userId, ref);
+  if (n.managed) throw new SendError("Rented numbers receive only; a group texts from your own Twilio or Telnyx number", 400);
+  return n.id;
+}
+
+/** The contacts for these phones, created when new; a name fills in a contact that has none. */
+async function contactIds(db: SupabaseClient, userId: string, members: { phone: string; name: string | null }[]): Promise<string[]> {
+  if (!members.length) return [];
+  const phones = members.map((m) => m.phone);
+  const { data: existing, error } = await db.from("contacts").select("id, phone, name").eq("user_id", userId).in("phone", phones);
+  if (error) throw error;
+  const byPhone = new Map((existing ?? []).map((c) => [c.phone as string, c as { id: string; phone: string; name: string | null }]));
+  const missing = members.filter((m) => !byPhone.has(m.phone));
+  if (missing.length) {
+    const { data: made, error: e2 } = await db
+      .from("contacts")
+      .insert(missing.map((m) => ({ user_id: userId, phone: m.phone, name: m.name })))
+      .select("id, phone, name");
+    if (e2) throw e2;
+    for (const c of made ?? []) byPhone.set(c.phone, c);
+  }
+  for (const m of members) {
+    const c = byPhone.get(m.phone);
+    if (c && m.name && !c.name) await db.from("contacts").update({ name: m.name }).eq("id", c.id).eq("user_id", userId);
+  }
+  return phones.map((p) => byPhone.get(p)!.id);
+}
+
+export async function listGroups(db: SupabaseClient, userId: string): Promise<Group[]> {
+  const { data, error } = await db.from("contact_groups").select(GROUP_COLS).eq("user_id", userId).order("created_at");
+  if (error) throw error;
+  const rows = (data ?? []) as unknown as GroupRow[];
+  if (!rows.length) return [];
+  const { data: counts } = await db.from("contact_group_members").select("group_id").in("group_id", rows.map((r) => r.id));
+  const n = new Map<string, number>();
+  for (const c of counts ?? []) n.set(c.group_id, (n.get(c.group_id) ?? 0) + 1);
+  return rows.map((r) => toGroup(r, n.get(r.id) ?? 0));
+}
+
+export async function getGroup(db: SupabaseClient, userId: string, ref: string): Promise<Group> {
+  const row = await ownGroup(db, userId, ref);
+  const members = await memberRows(db, row.id);
+  return toGroup(row, members.length, members);
+}
+
+/**
+ * Make a group, or with `external_ref` set and a group already on it, update that one and
+ * replace its members with `members` (when given). This is how another app keeps a group in
+ * step without remembering our ids.
+ */
+export async function saveGroup(db: SupabaseClient, userId: string, input: GroupInput): Promise<Group> {
+  const externalRef = str(input.external_ref, 120) || null;
+  const existing = externalRef
+    ? ((await db.from("contact_groups").select("id").eq("user_id", userId).eq("external_ref", externalRef).maybeSingle()).data as { id: string } | null)
+    : null;
+  if (existing) return updateGroup(db, userId, existing.id, input);
+  const name = str(input.name, 80);
+  if (!name) throw new SendError("A group needs a name", 400);
+  const { count } = await db.from("contact_groups").select("id", { count: "exact", head: true }).eq("user_id", userId);
+  if ((count ?? 0) >= MAX_GROUPS) throw new SendError(`At most ${MAX_GROUPS} groups`, 409);
+  const members = cleanMembers(input.members);
+  const { data, error } = await db
+    .from("contact_groups")
+    .insert({
+      user_id: userId,
+      name,
+      description: str(input.description, 300),
+      phone_number_id: await numberId(db, userId, input.from),
+      relay: input.relay === true,
+      external_ref: externalRef,
+    })
+    .select("id")
+    .single();
+  if (error) throw error;
+  if (members.length) await setMembers(db, userId, data.id, members);
+  return getGroup(db, userId, data.id);
+}
+
+export async function updateGroup(db: SupabaseClient, userId: string, ref: string, input: GroupInput): Promise<Group> {
+  const row = await ownGroup(db, userId, ref);
+  const patch: Record<string, unknown> = { updated_at: new Date().toISOString() };
+  if (input.name !== undefined) {
+    const name = str(input.name, 80);
+    if (!name) throw new SendError("A group needs a name", 400);
+    patch.name = name;
+  }
+  if (input.description !== undefined) patch.description = str(input.description, 300);
+  if (input.from !== undefined) patch.phone_number_id = await numberId(db, userId, input.from);
+  if (input.relay !== undefined) patch.relay = input.relay === true;
+  const { error } = await db.from("contact_groups").update(patch).eq("id", row.id).eq("user_id", userId);
+  if (error) throw error;
+  if (input.members !== undefined) await setMembers(db, userId, row.id, cleanMembers(input.members));
+  return getGroup(db, userId, row.id);
+}
+
+export async function deleteGroup(db: SupabaseClient, userId: string, ref: string): Promise<{ deleted: true }> {
+  const row = await ownGroup(db, userId, ref);
+  const { error } = await db.from("contact_groups").delete().eq("id", row.id).eq("user_id", userId);
+  if (error) throw error;
+  return { deleted: true };
+}
+
+/** Replace the member list. Members who said STOP stay opted out if they are still in it. */
+async function setMembers(db: SupabaseClient, userId: string, groupId: string, members: { phone: string; name: string | null }[]): Promise<void> {
+  const ids = await contactIds(db, userId, members);
+  const keep = new Set(ids);
+  const current = await memberRows(db, groupId);
+  const gone = current.filter((m) => !keep.has(m.contact_id)).map((m) => m.contact_id);
+  if (gone.length) await db.from("contact_group_members").delete().eq("group_id", groupId).in("contact_id", gone);
+  const have = new Set(current.map((m) => m.contact_id));
+  const add = ids.filter((id) => !have.has(id));
+  if (add.length) {
+    const { error } = await db.from("contact_group_members").insert(add.map((contact_id) => ({ group_id: groupId, contact_id })));
+    if (error) throw error;
+  }
+}
+
+export async function addMembers(db: SupabaseClient, userId: string, ref: string, input: unknown): Promise<Group> {
+  const row = await ownGroup(db, userId, ref);
+  const members = cleanMembers(input);
+  if (!members.length) throw new SendError("Give members: [{ phone, name? }]", 400);
+  const current = await memberRows(db, row.id);
+  if (current.length + members.length > MAX_GROUP_MEMBERS) throw new SendError(`A group holds at most ${MAX_GROUP_MEMBERS} members`, 400);
+  const ids = await contactIds(db, userId, members);
+  const have = new Set(current.map((m) => m.contact_id));
+  const add = ids.filter((id) => !have.has(id));
+  if (add.length) {
+    const { error } = await db.from("contact_group_members").insert(add.map((contact_id) => ({ group_id: row.id, contact_id })));
+    if (error) throw error;
+  }
+  return getGroup(db, userId, row.id);
+}
+
+export async function removeMember(db: SupabaseClient, userId: string, ref: string, phoneOrId: string): Promise<Group> {
+  const row = await ownGroup(db, userId, ref);
+  const phone = toE164(phoneOrId);
+  const member = (await memberRows(db, row.id)).find((m) => m.contact_id === phoneOrId || (phone && m.phone === phone));
+  if (!member) throw new SendError("Not a member of this group", 404);
+  await db.from("contact_group_members").delete().eq("group_id", row.id).eq("contact_id", member.contact_id);
+  return getGroup(db, userId, row.id);
+}
+
+export interface GroupSendInput {
+  message?: unknown;
+  from?: unknown;
+  media_url?: unknown;
+  /** Phones to leave out this time (whoever the message came from). */
+  except?: unknown;
+}
+
+/** Text every member who has not opted out. One group send counts once against the rate limit. */
+export async function sendToGroup(db: SupabaseClient, userId: string, ref: string, input: GroupSendInput) {
+  const message = typeof input.message === "string" ? input.message : "";
+  if (!message.trim()) throw new SendError("Missing required field: message", 400);
+  if (message.length > MAX_BODY) throw new SendError(`message is longer than ${MAX_BODY} characters`, 400);
+  const mediaUrl = typeof input.media_url === "string" && input.media_url ? input.media_url : undefined;
+  const row = await ownGroup(db, userId, ref);
+
+  const rl = checkRateLimit(`groupsend:${userId}`, GROUP_SEND_RATE_LIMIT);
+  if (!rl.allowed) throw new SendError("Rate limit exceeded", 429, rl.retryAfterMs);
+
+  const fromRef = str(input.from, 64) || row.phone_number_id;
+  const number = await pickNumber(db, userId, fromRef);
+  const except = new Set((Array.isArray(input.except) ? input.except : []).map((p) => toE164(String(p))).filter(Boolean));
+  const members = await memberRows(db, row.id);
+  const results: { to: string; ok: boolean; error?: string }[] = [];
+  let skipped = 0;
+  for (const m of members) {
+    if (m.opted_out || except.has(m.phone) || m.phone === number.number) {
+      skipped += 1;
+      continue;
+    }
+    const r = await sendFromNumber(db, userId, number, m.phone, message, mediaUrl);
+    results.push(r.ok ? { to: r.to, ok: true } : { to: r.to, ok: false, error: r.error });
+  }
+  await db.from("contact_groups").update({ last_sent_at: new Date().toISOString() }).eq("id", row.id);
+  const failed = results.filter((r) => !r.ok);
+  return {
+    group_id: row.id,
+    from: number.number,
+    sent: results.length - failed.length,
+    failed: failed.length,
+    skipped,
+    ...(failed.length ? { errors: failed.slice(0, 10) } : {}),
+    remaining: rl.remaining,
+  };
+}
+
+/**
+ * An inbound text on one of the user's numbers: STOP opts the sender out of every group on that
+ * user's account; anything else from a member of a relay group on that number goes on to the
+ * rest of the group, prefixed with who sent it. Best effort: the inbox has already stored it.
+ */
+export async function onGroupInbound(
+  db: SupabaseClient,
+  line: { id: string; user_id: string },
+  from: string,
+  body: string
+): Promise<{ relayed: number; optedOut?: boolean }> {
+  const phone = toE164(from);
+  if (!phone) return { relayed: 0 };
+  const { data: contact } = await db.from("contacts").select("id, name").eq("user_id", line.user_id).eq("phone", phone).maybeSingle();
+  if (!contact) return { relayed: 0 };
+  const word = body.trim().toLowerCase();
+  const { data: memberships } = await db
+    .from("contact_group_members")
+    .select("group_id, opted_out, contact_groups!inner(id, user_id, relay, phone_number_id, last_sent_at)")
+    .eq("contact_id", contact.id);
+  const rows = (memberships ?? []) as unknown as { group_id: string; opted_out: boolean; contact_groups: { id: string; user_id: string; relay: boolean; phone_number_id: string | null; last_sent_at: string | null } }[];
+  const mine = rows.filter((r) => r.contact_groups.user_id === line.user_id);
+  if (/^(stop|stopall|unsubscribe|cancel|end|quit)$/.test(word)) {
+    if (mine.length) await db.from("contact_group_members").update({ opted_out: true }).eq("contact_id", contact.id).in("group_id", mine.map((r) => r.group_id));
+    return { relayed: 0, optedOut: true };
+  }
+  if (/^(start|unstop)$/.test(word)) {
+    if (mine.length) await db.from("contact_group_members").update({ opted_out: false }).eq("contact_id", contact.id).in("group_id", mine.map((r) => r.group_id));
+    return { relayed: 0 };
+  }
+  // The group chat this text belongs to: a relay group on this number, the most recently used.
+  const relay = mine
+    .filter((r) => r.contact_groups.relay && r.contact_groups.phone_number_id === line.id && !r.opted_out)
+    .sort((a, b) => String(b.contact_groups.last_sent_at ?? "").localeCompare(String(a.contact_groups.last_sent_at ?? "")))[0];
+  if (!relay) return { relayed: 0 };
+  const { data: num } = await db.from("phone_numbers").select("id, number, managed, providers(type, api_key, api_secret)").eq("id", line.id).single();
+  if (!num) return { relayed: 0 };
+  const members = await memberRows(db, relay.group_id);
+  const who = contact.name || `${phone.slice(0, -4).replace(/\d/g, "•")}${phone.slice(-4)}`;
+  let relayed = 0;
+  for (const m of members) {
+    if (m.opted_out || m.phone === phone) continue;
+    const r = await sendFromNumber(db, line.user_id, num as unknown as NumberRow, m.phone, `${who}: ${body}`.slice(0, MAX_BODY));
+    if (r.ok) relayed += 1;
+  }
+  await db.from("contact_groups").update({ last_sent_at: new Date().toISOString() }).eq("id", relay.group_id);
+  return { relayed };
+}
diff --git a/src/lib/inbound.ts b/src/lib/inbound.ts
index 872c2b7b..95f24935 100644
--- a/src/lib/inbound.ts
+++ b/src/lib/inbound.ts
@@ -7,6 +7,7 @@ import type { SupabaseClient } from "@supabase/supabase-js";
 import type { InboundMessage } from "@/lib/providers/types";
 import { fireWebhooks, type UserWebhook } from "@/lib/webhooks/outbound";
 import { extractOtp } from "@/lib/managed-numbers/api";
+import { onGroupInbound } from "@/lib/groups";
 import { bookLineId, matchPrefix, type LineContact } from "@/lib/lines/contacts";
 import { sendSMS } from "@/lib/providers";
 import { noteAlertOptOut } from "@/lib/alerts/opt-out";
@@ -100,6 +101,8 @@ export async function recordInbound(
   if (routed?.contact.forward_sms && routed.contact.forward_to !== inbound.from) {
     await forwardRouted(db, phoneNumber, conversation.id, routed.contact.forward_to, inbound.from, routed.text);
   }
+  // Groups: STOP opts out of them; a member's text to a relay group's number goes on to the group.
+  if (!routed) await onGroupInbound(db, phoneNumber, inbound.from, inbound.body).catch((e) => console.error("group relay:", e));
   return { messageId: message?.id ?? null, duplicate: false };
 }
 
diff --git a/src/lib/mcp/server.ts b/src/lib/mcp/server.ts
index 1fc1a354..06248e09 100644
--- a/src/lib/mcp/server.ts
+++ b/src/lib/mcp/server.ts
@@ -7,6 +7,7 @@ import type { SupabaseClient } from "@supabase/supabase-js";
 import { getOrder, listNumbers, listOrders, numberMessages, overview } from "@/lib/managed-numbers/api";
 import { createOrder, OrderError } from "@/lib/managed-numbers/service";
 import { conversationMessages, isUuid, listConversations } from "@/lib/conversations";
+import { addMembers, getGroup, listGroups, saveGroup, sendToGroup } from "@/lib/groups";
 import { SendError, sendMessage } from "@/lib/messages/send";
 import type { RequestUser } from "@/lib/request-user";
 import { LINE_TOOLS, LineToolError } from "./line-tools";
@@ -92,6 +93,53 @@ const TOOLS: Tool[] = [
     ),
     run: (c, a) => sendMessage(c.db, c.user.userId, a),
   },
+  {
+    name: "list_groups",
+    description: "Your contact groups (named lists you text together), with member counts.",
+    inputSchema: obj({}),
+    run: (c) => listGroups(c.db, c.user.userId),
+  },
+  {
+    name: "get_group",
+    description: "One group with its members. id is the group id or its external_ref.",
+    inputSchema: obj({ id: { type: "string" } }, ["id"]),
+    run: (c, a) => getGroup(c.db, c.user.userId, String(a.id ?? "")),
+  },
+  {
+    name: "save_group",
+    description:
+      "Make a contact group, or update the one with this external_ref (its members are then replaced). from = the number it texts from; relay = members' replies go to the whole group (group chat over SMS).",
+    inputSchema: obj(
+      {
+        name: { type: "string" },
+        description: { type: "string" },
+        from: { type: "string", description: "Your own number (E.164) or its id." },
+        relay: { type: "boolean" },
+        external_ref: { type: "string", description: "Your own key for this group, e.g. groupcall:4821." },
+        members: { type: "array", items: { type: "object", properties: { phone: { type: "string" }, name: { type: "string" } }, required: ["phone"] } },
+      },
+      ["name"]
+    ),
+    run: (c, a) => saveGroup(c.db, c.user.userId, a),
+  },
+  {
+    name: "add_group_members",
+    description: "Add people to a group: members = [{ phone, name? }].",
+    inputSchema: obj(
+      { id: { type: "string" }, members: { type: "array", items: { type: "object", properties: { phone: { type: "string" }, name: { type: "string" } }, required: ["phone"] } } },
+      ["id", "members"]
+    ),
+    run: (c, a) => addMembers(c.db, c.user.userId, String(a.id ?? ""), a.members),
+  },
+  {
+    name: "send_to_group",
+    description: "Text every member of a group from your own number (members who said STOP are skipped). Counts as one send against the 10/min limit.",
+    inputSchema: obj(
+      { id: { type: "string" }, message: { type: "string", maxLength: 1600 }, from: { type: "string" }, media_url: { type: "string" } },
+      ["id", "message"]
+    ),
+    run: (c, a) => sendToGroup(c.db, c.user.userId, String(a.id ?? ""), a),
+  },
   {
     name: "rent_number",
     description:
diff --git a/src/lib/messages/send.ts b/src/lib/messages/send.ts
index ccd4531b..12b93837 100644
--- a/src/lib/messages/send.ts
+++ b/src/lib/messages/send.ts
@@ -31,14 +31,14 @@ export interface SendInput {
   media_url?: unknown;
 }
 
-interface NumberRow {
+export interface NumberRow {
   id: string;
   number: string;
   managed: boolean | null;
   providers: { type: string; api_key: string; api_secret: string | null } | null;
 }
 
-async function pickNumber(db: SupabaseClient, userId: string, ref: string | null): Promise<NumberRow> {
+export async function pickNumber(db: SupabaseClient, userId: string, ref: string | null): Promise<NumberRow> {
   let q = db
     .from("phone_numbers")
     .select("id, number, managed, providers(type, api_key, api_secret)")
@@ -75,9 +75,27 @@ export async function sendMessage(db: SupabaseClient, userId: string, input: Sen
   if (!rl.allowed) throw new SendError("Rate limit exceeded", 429, rl.retryAfterMs);
 
   const number = await pickNumber(db, userId, ref?.trim() ?? null);
+  const sent = await sendFromNumber(db, userId, number, toE164(to)!, message, mediaUrl);
+  if (!sent.ok) throw new SendError(sent.error, 502);
+  return { message: sent.message, from: number.number, to: sent.to, remaining: rl.remaining };
+}
+
+/**
+ * One text from one of the user's numbers, filed in the inbox like any other: the
+ * contact and conversation are created when new, and the message is saved sent or
+ * failed. No rate limit here; callers apply their own (one send, or one group send).
+ */
+export async function sendFromNumber(
+  db: SupabaseClient,
+  userId: string,
+  number: NumberRow,
+  toE: string,
+  message: string,
+  mediaUrl?: string
+): Promise<{ ok: true; message: unknown; to: string } | { ok: false; error: string; to: string }> {
   const provider = number.providers;
-  if (!provider) throw new SendError("This number has no provider", 400);
-  const toE = toE164(to)!;
+  if (!provider) return { ok: false, error: "This number has no provider", to: toE };
+  if (number.managed) return { ok: false, error: "Rented numbers receive only; send from your own Twilio or Telnyx number", to: toE };
 
   let { data: contact } = await db.from("contacts").select("id").eq("user_id", userId).eq("phone", toE).maybeSingle();
   if (!contact) {
@@ -122,7 +140,7 @@ export async function sendMessage(db: SupabaseClient, userId: string, input: Sen
     .select("id, conversation_id, direction, body, status, provider_message_id, created_at")
     .single();
 
-  if (!result.success) throw new SendError(result.error || "Send failed", 502);
+  if (!result.success) return { ok: false, error: result.error || "Send failed", to: toE };
   await db.from("conversations").update({ last_message_at: new Date().toISOString() }).eq("id", conversation!.id);
-  return { message: saved, from: number.number, to: toE, remaining: rl.remaining };
+  return { ok: true, message: saved, to: toE };
 }
diff --git a/src/lib/station-nav.ts b/src/lib/station-nav.ts
index 016c8fd4..76b16b4a 100644
--- a/src/lib/station-nav.ts
+++ b/src/lib/station-nav.ts
@@ -15,10 +15,11 @@ export const STATION_TABS: StationTab[] = [
   { href: "/inbox", label: "Receiver", icon: "receiver" },
   { href: "/numbers", label: "Numbers", icon: "numbers" },
   { href: "/settings/lines", label: "Lines", icon: "lines" },
+  { href: "/groups", label: "Groups", icon: "lines" },
   { href: "/settings", label: "Settings", icon: "settings" },
 ];
 
-const APP_PREFIXES = ["/inbox", "/numbers", "/settings", "/contacts", "/campaigns", "/analytics", "/org"];
+const APP_PREFIXES = ["/inbox", "/numbers", "/settings", "/contacts", "/groups", "/campaigns", "/analytics", "/org"];
 const AUTH_PREFIXES = ["/login", "/register", "/forgot-password", "/reset-password"];
 
 function under(pathname: string, prefix: string): boolean {
diff --git a/supabase/migrations/021_contact_groups.sql b/supabase/migrations/021_contact_groups.sql
new file mode 100644
index 00000000..a73aa142
--- /dev/null
+++ b/supabase/migrations/021_contact_groups.sql
@@ -0,0 +1,46 @@
+-- Contact groups: named lists of people to text together, optionally as a group chat.
+--
+-- A group belongs to one user and may name the number it texts from. With relay on, a text from
+-- a member to that number is passed on to every other member ("Kim: running late"), so a group
+-- works like an SMS group chat. external_ref lets another app keep one group per thing of its own
+-- (group.call keeps one per room: "groupcall:4821") and upsert it by that reference.
+
+CREATE TABLE IF NOT EXISTS public.contact_groups (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  phone_number_id UUID REFERENCES public.phone_numbers(id) ON DELETE SET NULL,
+  relay BOOLEAN NOT NULL DEFAULT false,
+  external_ref TEXT,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  last_sent_at TIMESTAMPTZ
+);
+CREATE INDEX IF NOT EXISTS idx_contact_groups_user ON public.contact_groups(user_id);
+CREATE UNIQUE INDEX IF NOT EXISTS contact_groups_user_ref ON public.contact_groups(user_id, external_ref) WHERE external_ref IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS public.contact_group_members (
+  group_id UUID NOT NULL REFERENCES public.contact_groups(id) ON DELETE CASCADE,
+  contact_id UUID NOT NULL REFERENCES public.contacts(id) ON DELETE CASCADE,
+  added_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  opted_out BOOLEAN NOT NULL DEFAULT false,
+  PRIMARY KEY (group_id, contact_id)
+);
+CREATE INDEX IF NOT EXISTS idx_contact_group_members_contact ON public.contact_group_members(contact_id);
+
+ALTER TABLE public.contact_groups ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.contact_group_members ENABLE ROW LEVEL SECURITY;
+
+DROP POLICY IF EXISTS "Users manage their own groups" ON public.contact_groups;
+CREATE POLICY "Users manage their own groups" ON public.contact_groups FOR ALL
+  USING (auth.uid() = user_id) WITH CHECK (auth.uid() = user_id);
+
+-- A member row is the owner's when the group is theirs, and the contact is theirs too.
+DROP POLICY IF EXISTS "Users manage their own group members" ON public.contact_group_members;
+CREATE POLICY "Users manage their own group members" ON public.contact_group_members FOR ALL
+  USING (EXISTS (SELECT 1 FROM public.contact_groups g WHERE g.id = group_id AND g.user_id = auth.uid()))
+  WITH CHECK (
+    EXISTS (SELECT 1 FROM public.contact_groups g WHERE g.id = group_id AND g.user_id = auth.uid())
+    AND EXISTS (SELECT 1 FROM public.contacts c WHERE c.id = contact_id AND c.user_id = auth.uid())
+  );