diff --git a/marketing/.gitignore b/marketing/.gitignore
--- a/marketing/.gitignore
+++ b/marketing/.gitignore
@@ -20,3 +20,6 @@ podcast/publish/
 
 # av-reels working outputs (regen-able)
 av-reels/out/
+
+# capur logo studies — regen with capur/gen-capur.mjs
+capur/out/
diff --git a/marketing/bin/caption-burn.mjs b/marketing/bin/caption-burn.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/bin/caption-burn.mjs
@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+// caption-burn.mjs — burn styled captions onto a video + attach an audio track.
+//
+// This ffmpeg build has NO libass, so captions are drawn in node-canvas over a
+// raw-frame pump (same approach as pop/menuband/bin/finalize-vo.mjs), then the
+// audio (VO) is muxed in by the encoder. Portrait-friendly defaults.
+//
+// Usage: node marketing/bin/caption-burn.mjs <video.mp4> <audio.wav> <captions.srt> <out.mp4> [W H FPS]
+
+import { readFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { createCanvas, registerFont } from "canvas";
+import { spawnFFmpegEncode } from "../../pop/lib/preview-shared.mjs";
+
+const [VIDEO, AUDIO, SRT, OUT, wArg, hArg, fpsArg, crfArg] = process.argv.slice(2);
+if (!VIDEO || !AUDIO || !SRT || !OUT) {
+  console.error("usage: caption-burn.mjs <video> <audio> <srt> <out> [W H FPS CRF]");
+  process.exit(1);
+}
+const W = Number(wArg) || 420, H = Number(hArg) || 900, FPS = Number(fpsArg) || 25;
+const CRF = Number(crfArg) || 18;
+
+try { registerFont("/System/Library/Fonts/Helvetica.ttc", { family: "Cap" }); } catch {}
+try { registerFont("/System/Library/Fonts/SFNS.ttf", { family: "Cap" }); } catch {}
+
+// ── parse SRT → cues [{s,e,t}] ──
+function parseSRT(txt) {
+  const cues = [];
+  for (const block of txt.replace(/\r/g, "").trim().split(/\n\n+/)) {
+    const lines = block.split("\n");
+    const ti = lines.findIndex((l) => l.includes("-->"));
+    if (ti === -1) continue;
+    const m = lines[ti].match(/(\d+):(\d+):(\d+)[,.](\d+)\s*-->\s*(\d+):(\d+):(\d+)[,.](\d+)/);
+    if (!m) continue;
+    const s = +m[1] * 3600 + +m[2] * 60 + +m[3] + +m[4] / 1000;
+    const e = +m[5] * 3600 + +m[6] * 60 + +m[7] + +m[8] / 1000;
+    const t = lines.slice(ti + 1).join(" ").trim();
+    if (t) cues.push({ s, e, t });
+  }
+  return cues;
+}
+const cues = parseSRT(readFileSync(SRT, "utf8"));
+console.log(`▸ ${cues.length} caption cues`);
+
+const canvas = createCanvas(W, H);
+const ctx = canvas.getContext("2d");
+const cueAt = (t) => cues.find((c) => t >= c.s && t < c.e) || null;
+
+const CAP_MAX_W = W - 48;
+const CAP_LINE_H = 30;
+const FONT = "700 24px Cap";
+function wrap(text) {
+  ctx.font = FONT;
+  const out = [];
+  let line = "";
+  for (const word of text.split(" ")) {
+    const cand = line ? `${line} ${word}` : word;
+    if (line && ctx.measureText(cand).width > CAP_MAX_W) { out.push(line); line = word; }
+    else line = cand;
+  }
+  if (line) out.push(line);
+  return out;
+}
+function drawCaption(t) {
+  const c = cueAt(t);
+  if (!c) return;
+  ctx.font = FONT;
+  ctx.textAlign = "center";
+  ctx.textBaseline = "alphabetic";
+  ctx.lineJoin = "round";
+  const lines = wrap(c.t);
+  const base = H - 78; // bottom, clear of the edge
+  lines.forEach((line, i) => {
+    const y = base - (lines.length - 1 - i) * CAP_LINE_H;
+    ctx.strokeStyle = "rgba(0,0,0,0.92)";
+    ctx.lineWidth = 6;
+    ctx.strokeText(line, W / 2, y);
+    ctx.fillStyle = "rgba(0,0,0,0.5)";
+    ctx.fillText(line, W / 2 + 1.5, y + 2);
+    ctx.fillStyle = "#ffffff";
+    ctx.fillText(line, W / 2, y);
+  });
+}
+
+console.log("▸ burning captions (node-canvas) + muxing audio …");
+const dec = spawn("ffmpeg", ["-loglevel", "error", "-i", VIDEO, "-f", "rawvideo", "-pix_fmt", "rgba", "-"],
+  { stdio: ["ignore", "pipe", "inherit"] });
+const enc = spawnFFmpegEncode({ audioPath: AUDIO, w: W, h: H, fps: FPS, outPath: OUT, crf: CRF });
+const FRAME_BYTES = W * H * 4;
+const fbuf = Buffer.alloc(FRAME_BYTES);
+const img = ctx.createImageData(W, H);
+let off = 0, fi = 0;
+for await (const ch of dec.stdout) {
+  let cOff = 0;
+  while (cOff < ch.length) {
+    const n = Math.min(FRAME_BYTES - off, ch.length - cOff);
+    ch.copy(fbuf, off, cOff, cOff + n); off += n; cOff += n;
+    if (off === FRAME_BYTES) {
+      off = 0;
+      img.data.set(fbuf); ctx.putImageData(img, 0, 0);
+      drawCaption(fi / FPS);
+      if (!enc.stdin.write(canvas.toBuffer("raw"))) await once(enc.stdin, "drain");
+      fi++;
+    }
+  }
+}
+enc.stdin.end();
+await new Promise((res, rej) => { enc.on("close", (c) => (c === 0 ? res() : rej(new Error(`ffmpeg exit ${c}`)))); });
+console.log(`✓ ${OUT} (${fi} frames, captions + audio)`);
diff --git a/marketing/capur/gen-capur.mjs b/marketing/capur/gen-capur.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/capur/gen-capur.mjs
@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+// gen-capur.mjs — CaPUR (Calisthenics Puerto Rico) logo material studies with
+// gpt-image-2, using the CaPUR wordmark as the image reference. Same technique
+// as marketing/podcast/bin/gen-pals.mjs, tuned for a wordmark (legibility QC).
+//
+// Usage: node marketing/capur/gen-capur.mjs [--only chrome,neon] [--force] [--size 1024x1024]
+//   → marketing/capur/out/<slug>.png (+ contact sheet)
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFileSync } from "node:child_process";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const REPO = resolve(HERE, "..", "..");
+const OUT = resolve(HERE, "out");
+mkdirSync(OUT, { recursive: true });
+const REF = resolve(HERE, "ref", "CaPUR.png");
+
+const argv = process.argv.slice(2);
+const flag = (k) => { const i = argv.indexOf(`--${k}`); return i >= 0 ? argv[i + 1] : null; };
+const FORCE = argv.includes("--force");
+const SIZE = flag("size") || "1024x1024";
+const ONLY = flag("only") ? new Set(flag("only").split(",")) : null;
+
+function loadKey() {
+  if (process.env.OPENAI_API_KEY) return process.env.OPENAI_API_KEY;
+  const envFile = resolve(REPO, "aesthetic-computer-vault/.devcontainer/envs/devcontainer.env");
+  const line = readFileSync(envFile, "utf8").split("\n").find((l) => l.startsWith("OPENAI_API_KEY="));
+  return line.slice("OPENAI_API_KEY=".length).trim().replace(/^['"]|['"]$/g, "");
+}
+const KEY = loadKey();
+
+const MARK = "the 'CaPUR' wordmark from the reference image — the bold stylized letters C, a, P, U, R together with the little calisthenics athlete figure doing a bar hold — reproduced faithfully and legibly as the single central emblem, its exact letterforms and the figure preserved and correctly spelled";
+const RULES = "Square composition, the emblem centered with a generous calm margin so a round or square crop never clips it. One coherent studio object, no collage. Keep the CaPUR lettering crisp, sharp, and correctly spelled. No other text, no other logos, no watermark. No motion blur; crisp high detail throughout.";
+
+const THEMES = [
+  { slug: "chrome", prompt: `A mirror-polished liquid-chrome sculpture of ${MARK}, high-gloss reflective steel like a gym pull-up bar, smooth highlights, on a cool graphite-to-silver gradient background under studio light. Sleek, athletic, premium. ${RULES}` },
+  { slug: "neon", prompt: `A glowing neon-sign version of ${MARK}, bright tropical-green and magenta neon tubes with a warm ambient glow and subtle reflection, mounted on a dark textured concrete gym wall at night. Energetic, nightlife. ${RULES}` },
+  { slug: "concrete", prompt: `${MARK} cast as a crisp raised relief in smooth pale concrete, side-lit by warm tropical daylight so the letters and figure throw soft shadows, on a minimal sunlit stucco wall. Brutalist, sunny, Puerto Rican. ${RULES}` },
+  { slug: "sunset", prompt: `A glossy enamel-badge version of ${MARK} in vivid palm-green and coral, embossed with a soft metallic edge, floating over a warm tropical sunset gradient (coral, gold, deep teal) with gentle bloom. Vibrant, beachy, uplifting. ${RULES}` },
+];
+const PICK = THEMES.filter((t) => !ONLY || ONLY.has(t.slug));
+
+async function render(theme, out) {
+  for (let a = 1; a <= 4; a++) {
+    try {
+      const fd = new FormData();
+      fd.append("model", "gpt-image-2");
+      fd.append("prompt", theme.prompt);
+      fd.append("size", SIZE);
+      fd.append("quality", "high");
+      fd.append("n", "1");
+      fd.append("image[]", new Blob([readFileSync(REF)], { type: "image/png" }), "CaPUR.png");
+      const res = await fetch("https://api.openai.com/v1/images/edits", {
+        method: "POST", headers: { Authorization: `Bearer ${KEY}` }, body: fd,
+        signal: AbortSignal.timeout(180000),
+      });
+      if (!res.ok) { const t = await res.text(); if (res.status >= 500 && a < 4) throw new Error(`HTTP ${res.status}`); throw new Error(`${res.status}: ${t.slice(0, 160)}`); }
+      const j = await res.json();
+      writeFileSync(out, Buffer.from(j.data[0].b64_json, "base64"));
+      return true;
+    } catch (e) {
+      if (a < 4) { process.stdout.write(` retry${a}`); await new Promise((r) => setTimeout(r, 1500 * a)); }
+      else { console.error(`\n    ${theme.slug} render: ${e.message}`); return false; }
+    }
+  }
+}
+
+const QC_MODEL = process.env.CAPUR_QC_MODEL || "gpt-4o";
+async function qc(out) {
+  if (process.env.CAPUR_NO_QC) return { ok: true };
+  const b64 = readFileSync(out).toString("base64");
+  const rubric = `You are grading a generated brand-logo image for "CaPUR" (a calisthenics brand). Answer ONLY strict JSON {"ok":boolean,"reason":"<=12 words"}:\n- The word must read exactly C-a-P-U-R, correctly spelled and legible. Reject if letters are garbled, misspelled, wrong count, or unreadable.\n- The emblem fills roughly the central 55-70% of the frame, centered, even margin. Reject if it bleeds edge-to-edge or is tiny.\n- Strong contrast, crisp, clearly readable. Reject if faint, blurry, or low-contrast.\n- Reject extra text, watermarks, other logos, or collage.\nBe strict about the spelling.`;
+  try {
+    const res = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST", headers: { Authorization: `Bearer ${KEY}`, "Content-Type": "application/json" },
+      signal: AbortSignal.timeout(90000),
+      body: JSON.stringify({ model: QC_MODEL, temperature: 0, max_tokens: 60, messages: [{ role: "user", content: [
+        { type: "text", text: rubric },
+        { type: "image_url", image_url: { url: `data:image/png;base64,${b64}`, detail: "low" } },
+      ] }] }),
+    });
+    const j = await res.json();
+    const m = (j.choices?.[0]?.message?.content ?? "").match(/\{[\s\S]*\}/);
+    const v = JSON.parse(m ? m[0] : "{}");
+    return { ok: !!v.ok, reason: String(v.reason || "").slice(0, 60) };
+  } catch (e) { return { ok: true, reason: "qc unavailable" }; }
+}
+
+for (const theme of PICK) {
+  const out = resolve(OUT, `${theme.slug}.png`);
+  if (existsSync(out) && !FORCE) { console.log(`  · ${theme.slug} cached`); continue; }
+  process.stdout.write(`  → ${theme.slug} …`);
+  for (let g = 1; g <= 3; g++) {
+    if (!(await render(theme, out))) { process.stdout.write(" ✗\n"); break; }
+    const v = await qc(out);
+    if (v.ok) { process.stdout.write(` ✓${g > 1 ? ` (try ${g})` : ""}\n`); break; }
+    process.stdout.write(` ⤾ ${v.reason}${g < 3 ? " — regen" : " — kept last"}\n`);
+    if (g < 3) process.stdout.write(`  → ${theme.slug} …`);
+  }
+}
+
+// contact sheet
+try {
+  const pngs = PICK.map((t) => resolve(OUT, `${t.slug}.png`)).filter(existsSync);
+  if (pngs.length) {
+    const inputs = pngs.flatMap((p) => ["-i", p]);
+    execFileSync("/opt/homebrew/bin/ffmpeg", ["-y", "-loglevel", "error", ...inputs,
+      "-filter_complex", `${pngs.map((_, i) => `[${i}]scale=420:-1[s${i}]`).join(";")};${pngs.map((_, i) => `[s${i}]`).join("")}hstack=inputs=${pngs.length}`,
+      resolve(OUT, "contact.png")]);
+    console.log(`▸ contact sheet: marketing/capur/out/contact.png`);
+  }
+} catch (e) { console.error("contact sheet:", e.message); }
diff --git a/marketing/capur/ref/CaPUR.png b/marketing/capur/ref/CaPUR.png
new file mode 100644
--- /dev/null
+++ b/marketing/capur/ref/CaPUR.png
diff --git a/slab/bin/dm-mcp.mjs b/slab/bin/dm-mcp.mjs
--- a/slab/bin/dm-mcp.mjs
+++ b/slab/bin/dm-mcp.mjs
@@ -211,18 +211,19 @@ return text(`✅ sent to ${rcpt.label}${ts ? ` (ts ${ts})` : ""}`);
   }
 
   if (ch === "imessage" || ch === "imsg") {
-    // imsg.mjs send targets the FIRST configured handle only (no arbitrary
-    // recipient), so `to` is advisory — surface that in the preview.
+    // `to` selects a named contact / raw handle from imsg.json's contacts map
+    // (imsg send --to). Omit it to hit the config's default contact.
+    const toArgs = to ? ["--to", String(to)] : [];
     if (!confirm) {
       return text(
         `PREVIEW — not sent. Re-call with confirm:true to send.\n` +
         `channel: iMessage   machine: ${isLocal(machine) ? "local" : machine}\n` +
-        `to: the handle configured in ~/.config/slab/imsg.json` +
-        `${to ? ` (note: imsg send ignores an arbitrary \`to\`=${to})` : ""}\n--- message ---\n${body}`,
+        `to: ${to ? `contact/handle "${to}" (from imsg.json contacts)` : "the default contact in ~/.config/slab/imsg.json"}\n` +
+        `--- message ---\n${body}`,
       );
     }
-    const { stdout } = await runBridge(IMSG, ["send", body], machine, { timeoutMs: 30000 });
-    return text(`✅ iMessage sent${stdout.trim() ? `: ${stdout.trim()}` : ""}`);
+    const { stdout } = await runBridge(IMSG, ["send", body, ...toArgs], machine, { timeoutMs: 30000 });
+    return text(`✅ iMessage sent${to ? ` to "${to}"` : ""}${stdout.trim() ? `: ${stdout.trim()}` : ""}`);
   }
 
   throw new Error(`unknown channel "${channel}" (use "signal" or "imessage")`);
diff --git a/slab/bin/imsg.mjs b/slab/bin/imsg.mjs
--- a/slab/bin/imsg.mjs
+++ b/slab/bin/imsg.mjs
@@ -61,15 +61,14 @@ function loadConfig() {
   if (!existsSync(CONFIG_PATH)) return null;
   try {
     const cfg = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
-    if (
-      !cfg ||
-      cfg.displayName === "REPLACE_ME" ||
-      !Array.isArray(cfg.handles) ||
-      cfg.handles.length === 0 ||
-      cfg.handles.some((h) => /REPLACE|example\.com|5551234567/.test(h))
-    ) {
-      return null; // present but still a stub
-    }
+    const stub = (h) => /REPLACE|example\.com|5551234567/.test(h);
+    const okHandles = (hs) => Array.isArray(hs) && hs.length > 0 && !hs.some(stub);
+    // Valid if the legacy default contact is filled in, OR a `contacts` map has
+    // at least one real entry (new multi-contact schema).
+    const legacyOk = cfg && cfg.displayName !== "REPLACE_ME" && okHandles(cfg.handles);
+    const contactsOk = cfg && cfg.contacts && typeof cfg.contacts === "object" &&
+      Object.values(cfg.contacts).some((c) => c && okHandles(c.handles));
+    if (!cfg || (!legacyOk && !contactsOk)) return null; // present but still a stub
     return cfg;
   } catch {
     return null;
@@ -85,6 +84,54 @@ });
   }
 }
 
+// ─── contacts ────────────────────────────────────────────────────────────
+// A config may declare many named contacts (`contacts: { artur: {...} }`) with
+// an optional `default`; the legacy top-level {displayName, handles} is treated
+// as the "default" contact so old single-contact configs keep working.
+
+function contactsMap(cfg) {
+  const m = {};
+  if (cfg && cfg.contacts && typeof cfg.contacts === "object") {
+    for (const [k, v] of Object.entries(cfg.contacts)) {
+      if (v && Array.isArray(v.handles) && v.handles.length) {
+        m[k.toLowerCase()] = { displayName: v.displayName || k, handles: v.handles };
+      }
+    }
+  }
+  return m;
+}
+
+function defaultContact(cfg) {
+  if (!cfg) return null;
+  const m = contactsMap(cfg);
+  if (cfg.default && m[String(cfg.default).toLowerCase()]) return m[String(cfg.default).toLowerCase()];
+  if (Array.isArray(cfg.handles) && cfg.handles.length) {
+    return { displayName: cfg.displayName || "default", handles: cfg.handles };
+  }
+  return Object.values(m)[0] || null;
+}
+
+// Resolve who a `--to` argument names: a contact key/displayName, a raw handle
+// (+E164 or an email), or — when omitted — the default contact.
+function resolveRecipient(cfg, toArg) {
+  if (!toArg) {
+    const d = defaultContact(cfg);
+    if (!d) throw new Error("no default contact configured");
+    return d;
+  }
+  const m = contactsMap(cfg);
+  const key = String(toArg).toLowerCase();
+  if (m[key]) return m[key];
+  const hit = Object.entries(m).find(
+    ([k, v]) => k.includes(key) || (v.displayName || "").toLowerCase().includes(key),
+  );
+  if (hit) return hit[1];
+  if (/^\+[0-9]{6,}$/.test(toArg) || /@/.test(toArg)) {
+    return { displayName: String(toArg), handles: [String(toArg)] };
+  }
+  throw new Error(`no contact matched "${toArg}" — known: ${Object.keys(m).join(", ") || "(none)"}`);
+}
+
 // ─── chat.db ─────────────────────────────────────────────────────────────
 
 function sqlite(query) {
@@ -137,7 +184,8 @@ const APPLE_EPOCH = 978307200; // 2001-01-01 → unix seconds
 const appleNsToUnix = (ns) => Math.floor(Number(ns) / 1e9) + APPLE_EPOCH;
 
 function handleList(cfg) {
-  return cfg.handles
+  const c = defaultContact(cfg);
+  return (c ? c.handles : [])
     .map((h) => `'${String(h).replace(/'/g, "''")}'`)
     .join(",");
 }
@@ -219,8 +267,8 @@ }
 
 // ─── send ────────────────────────────────────────────────────────────────
 
-function sendMessage(cfg, body) {
-  const to = String(cfg.handles[0]);
+function sendMessage(handles, body) {
+  const to = String(handles[0]);
   // buddy-of-first-service path is the most reliable across macOS versions.
   const script = `
 on run argv
@@ -345,7 +393,7 @@ rl.on("line", (line) => {
     const body = line.trim();
     if (!body) return;
     try {
-      sendMessage(cfg, body);
+      sendMessage(defaultContact(cfg).handles, body);
       process.stdout.write(`\x1b[36m  you ›\x1b[0m ${body}\n`);
     } catch (e) {
       process.stdout.write(`\x1b[31m  send failed: ${e.message}\x1b[0m\n`);
@@ -416,12 +464,18 @@ if (!cfg) {
         console.error(`No contact configured. Edit ${CONFIG_PATH}`);
         process.exit(1);
       }
-      const body = rest.join(" ").trim();
+      // Optional `--to <name|handle>` selects a contact; default otherwise.
+      const args = [...rest];
+      let toArg = null;
+      const ti = args.indexOf("--to");
+      if (ti >= 0) { toArg = args[ti + 1]; args.splice(ti, 2); }
+      const body = args.join(" ").trim();
       if (!body) {
-        console.error("usage: imsg send <text>");
+        console.error("usage: imsg send <text> [--to <name|handle>]");
         process.exit(1);
       }
-      sendMessage(cfg, body);
+      const rcpt = resolveRecipient(cfg, toArg);
+      sendMessage(rcpt.handles, body);
       break;
     }
     case "tail":
@@ -429,7 +483,7 @@ await cmdTail();
       break;
     case "open": {
       const cfg = loadConfig();
-      const to = cfg ? cfg.handles[0] : "";
+      const to = cfg ? (defaultContact(cfg)?.handles[0] || "") : "";
       spawnSync("/usr/bin/open", [`imessage://${to}`], { stdio: "ignore" });
       break;
     }