diff --git a/marketing/lib/av-sync.mjs b/marketing/lib/av-sync.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/lib/av-sync.mjs
@@ -0,0 +1,193 @@
+// av-sync.mjs — is the mouth early, or is the sound?
+//
+// Consumer cameras and old webcam captures routinely bake in an A/V offset: the
+// picture and the audio are written with timestamps that disagree by a frame or
+// four, and nobody notices until you put captions under it and the lips start
+// reading as dubbed.
+//
+// You can measure it. A talking mouth is a motion signal, and a talking voice is
+// an amplitude signal, and they are the same signal — a mouth opens when a
+// syllable lands. So: pull motion energy from the mouth region of every frame,
+// pull an RMS envelope from the audio, and slide one against the other. The lag
+// with the strongest correlation is the offset.
+//
+//   node marketing/lib/av-sync.mjs <video>            # just report
+//   import { measureAvOffset } from "./av-sync.mjs";
+//
+// Returns { offsetMs, confidence, curve }.
+//
+//   offsetMs > 0  → the PICTURE is late (visuals behind the sound). To fix, the
+//                   video must be pulled EARLIER, or the audio pushed later.
+//   offsetMs < 0  → the SOUND is late.
+//
+// `confidence` is the peak correlation over the mean of the curve. Under about
+// 1.15 the peak isn't really a peak and you should not trust the number — a shot
+// with little mouth movement, or a noisy room, will not correlate.
+//
+// TWO THINGS THAT WILL WASTE YOUR AFTERNOON:
+//
+//   · Measure the RAW CLIP, never a finished reel. Music under the voice —
+//     a 72bpm bed with a kick on 1 and 3 — pours energy into the envelope that
+//     no mouth produced, which flattens the true peak and hands the win to a
+//     spurious one. A reel that is genuinely in sync will measure as though it
+//     is not.
+//   · One pass lands within about a frame, not on the nose. The correlation is
+//     only sampled every 33ms, so the discrete peak can sit a whole frame off
+//     truth and the parabola then refines the wrong summit. On the YC clip a
+//     single pass read 123ms when the answer was 95ms. If you want it exact:
+//     apply the measurement, re-measure the corrected pair (bed-free), and add
+//     the residual back. That converges in one step.
+
+import { spawn } from "node:child_process";
+import { faceTrack } from "./reframe.mjs";
+import { decodeAudioMono, computeRmsEnvelope } from "../../pop/lib/preview-shared.mjs";
+
+const FPS = 30;
+const PROBE_W = 320; // the mouth is a big blob at this size; we want energy, not detail
+const MAX_LAG = 12; // ±400ms at 30fps — beyond this it isn't a sync error, it's an edit
+
+// Motion energy inside the mouth region, frame by frame.
+async function mouthMotion(videoPath, track) {
+  const scale = PROBE_W / track.srcW;
+  const probeH = Math.round(track.srcH * scale);
+
+  const dec = spawn("ffmpeg", [
+    "-v", "error", "-i", videoPath,
+    "-f", "rawvideo", "-pix_fmt", "gray",
+    "-vf", `fps=${FPS},scale=${PROBE_W}:${probeH}`,
+    "-",
+  ], { stdio: ["ignore", "pipe", "inherit"] });
+
+  const frameBytes = PROBE_W * probeH;
+  const energy = [];
+  let prev = null;
+  let pending = Buffer.alloc(0);
+  let f = 0;
+
+  // The face track samples at its own rate; hold the nearest box for each frame.
+  const boxAt = (t) => {
+    let s = track.samples[0];
+    for (const c of track.samples) {
+      if (c.t > t) break;
+      s = c;
+    }
+    return s;
+  };
+
+  for await (const chunk of dec.stdout) {
+    pending = pending.length ? Buffer.concat([pending, chunk]) : chunk;
+    while (pending.length >= frameBytes) {
+      const g = pending.subarray(0, frameBytes);
+      pending = pending.subarray(frameBytes);
+
+      const b = boxAt(f / FPS);
+      // The mouth lives in the bottom third of Vision's face box, centered. Using
+      // the whole face would fold in head-bobs and blinks, which don't correlate
+      // with speech and only add noise.
+      const x0 = Math.max(0, Math.round((b.x + b.w * 0.22) * scale));
+      const x1 = Math.min(PROBE_W, Math.round((b.x + b.w * 0.78) * scale));
+      const y0 = Math.max(0, Math.round((b.y + b.h * 0.62) * scale));
+      const y1 = Math.min(probeH, Math.round((b.y + b.h * 1.02) * scale));
+
+      let sum = 0;
+      let n = 0;
+      if (prev) {
+        for (let y = y0; y < y1; y += 1) {
+          const row = y * PROBE_W;
+          for (let x = x0; x < x1; x += 1) {
+            sum += Math.abs(g[row + x] - prev[row + x]);
+            n += 1;
+          }
+        }
+      }
+      energy.push(n > 0 ? sum / n : 0);
+      prev = Buffer.from(g); // subarray aliases the pool; copy or it mutates
+      f += 1;
+    }
+  }
+  return energy;
+}
+
+const normalize = (xs) => {
+  const mean = xs.reduce((a, b) => a + b, 0) / (xs.length || 1);
+  const sd = Math.sqrt(xs.reduce((a, b) => a + (b - mean) ** 2, 0) / (xs.length || 1)) || 1;
+  return xs.map((x) => (x - mean) / sd);
+};
+
+export async function measureAvOffset(videoPath, { track = null } = {}) {
+  const tr = track || faceTrack(videoPath, { fps: FPS });
+
+  const motion = normalize(await mouthMotion(videoPath, tr));
+  const { audio, sr } = decodeAudioMono(videoPath);
+  const env = normalize(Array.from(computeRmsEnvelope(audio, sr, FPS, tr.duration)));
+
+  const n = Math.min(motion.length, env.length);
+  const curve = [];
+
+  // Slide the motion signal against the audio. `lag` is how many frames the
+  // picture would need to move to line up: at lag k we compare motion[i + k]
+  // with audio[i], so a positive k that wins means the mouth is moving LATER
+  // than the sound — the picture is behind.
+  for (let lag = -MAX_LAG; lag <= MAX_LAG; lag += 1) {
+    let sum = 0;
+    let count = 0;
+    for (let i = 0; i < n; i += 1) {
+      const j = i + lag;
+      if (j < 0 || j >= n) continue;
+      sum += motion[j] * env[i];
+      count += 1;
+    }
+    curve.push({ lag, r: count > 0 ? sum / count : 0 });
+  }
+
+  const bestI = curve.reduce((bi, c, i) => (c.r > curve[bi].r ? i : bi), 0);
+  const mean = curve.reduce((a, b) => a + Math.abs(b.r), 0) / curve.length;
+
+  // The correlation is only sampled at whole frames, but the true offset is not
+  // a whole number of frames — it's whatever the camera's encoder did. Fitting a
+  // parabola through the peak and its two neighbours recovers the sub-frame
+  // position of the real maximum, which matters because we correct on the audio
+  // side, where we have sample precision to spend.
+  let lag = curve[bestI].lag;
+  const l = curve[bestI - 1];
+  const c0 = curve[bestI];
+  const r = curve[bestI + 1];
+  if (l && r) {
+    const denom = l.r - 2 * c0.r + r.r;
+    if (denom !== 0) {
+      const delta = (0.5 * (l.r - r.r)) / denom;
+      if (Math.abs(delta) <= 1) lag += delta;
+    }
+  }
+
+  return {
+    offsetMs: Math.round((lag / FPS) * 1000),
+    confidence: mean > 0 ? c0.r / mean : 0,
+    curve,
+  };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const video = process.argv[2];
+  if (!video) {
+    console.error("usage: av-sync.mjs <video>");
+    process.exit(2);
+  }
+  const { offsetMs, confidence, curve } = await measureAvOffset(video);
+
+  console.log("\nlag(ms)  correlation");
+  for (const c of curve) {
+    const ms = Math.round((c.lag / FPS) * 1000);
+    const bar = "█".repeat(Math.max(0, Math.round(c.r * 60)));
+    console.log(`${String(ms).padStart(5)}   ${bar} ${c.r.toFixed(3)}`);
+  }
+  console.log(`\noffset: ${offsetMs}ms   confidence: ${confidence.toFixed(2)}`);
+  console.log(
+    offsetMs > 0
+      ? `the PICTURE is ${offsetMs}ms late — visuals behind the sound`
+      : offsetMs < 0
+        ? `the SOUND is ${-offsetMs}ms late`
+        : "in sync",
+  );
+  if (confidence < 1.15) console.log("⚠ weak peak — don't trust this; too little mouth motion or too much noise");
+}
diff --git a/marketing/lib/face-track.swift b/marketing/lib/face-track.swift
new file mode 100644
--- /dev/null
+++ b/marketing/lib/face-track.swift
@@ -0,0 +1,106 @@
+// face-track.swift — sample a video and report where the face is.
+//
+// AVFoundation walks the frames, Vision finds the faces. We print one JSON
+// record per sample; smoothing and framing decisions belong to reframe.mjs,
+// not here. This file only answers "where was the face at time t."
+//
+//   swift marketing/lib/face-track.swift <video> [--fps 10] > track.json
+//
+// Coordinates come out of Vision normalized with a bottom-left origin; we
+// flip Y and emit top-left-origin pixels, which is what canvas wants.
+
+import AVFoundation
+import Foundation
+import Vision
+
+struct Sample: Codable {
+  let t: Double
+  let x: Double
+  let y: Double
+  let w: Double
+  let h: Double
+  let confidence: Double
+}
+
+let args = CommandLine.arguments
+guard args.count > 1 else {
+  FileHandle.standardError.write("usage: face-track.swift <video> [--fps N]\n".data(using: .utf8)!)
+  exit(2)
+}
+let videoPath = args[1]
+var sampleFps = 10.0
+if let i = args.firstIndex(of: "--fps"), i + 1 < args.count, let v = Double(args[i + 1]) {
+  sampleFps = v
+}
+
+let url = URL(fileURLWithPath: videoPath)
+let asset = AVURLAsset(url: url)
+
+guard let track = asset.tracks(withMediaType: .video).first else {
+  FileHandle.standardError.write("no video track\n".data(using: .utf8)!)
+  exit(1)
+}
+
+let naturalSize = track.naturalSize.applying(track.preferredTransform)
+let srcW = abs(naturalSize.width)
+let srcH = abs(naturalSize.height)
+let duration = CMTimeGetSeconds(asset.duration)
+
+let reader = try AVAssetReader(asset: asset)
+let output = AVAssetReaderTrackOutput(
+  track: track,
+  outputSettings: [kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA]
+)
+output.alwaysCopiesSampleData = false
+reader.add(output)
+reader.startReading()
+
+let request = VNDetectFaceRectanglesRequest()
+var samples: [Sample] = []
+let interval = 1.0 / sampleFps
+var nextSampleAt = 0.0
+
+while let buf = output.copyNextSampleBuffer() {
+  let t = CMTimeGetSeconds(CMSampleBufferGetPresentationTimeStamp(buf))
+  guard t >= nextSampleAt, let pixels = CMSampleBufferGetImageBuffer(buf) else { continue }
+  nextSampleAt += interval
+
+  let handler = VNImageRequestHandler(cvPixelBuffer: pixels, orientation: .up, options: [:])
+  try? handler.perform([request])
+
+  // Several faces in frame is not our problem — take the biggest, which for a
+  // talking head is the speaker and not a poster on the wall behind them.
+  guard
+    let face = (request.results ?? []).max(by: {
+      $0.boundingBox.width * $0.boundingBox.height < $1.boundingBox.width * $1.boundingBox.height
+    })
+  else { continue }
+
+  let b = face.boundingBox
+  samples.append(
+    Sample(
+      t: t,
+      x: Double(b.origin.x) * Double(srcW),
+      y: (1.0 - Double(b.origin.y) - Double(b.height)) * Double(srcH),  // flip to top-left
+      w: Double(b.width) * Double(srcW),
+      h: Double(b.height) * Double(srcH),
+      confidence: Double(face.confidence)
+    ))
+}
+
+struct Track: Codable {
+  let video: String
+  let srcW: Double
+  let srcH: Double
+  let duration: Double
+  let sampleFps: Double
+  let samples: [Sample]
+}
+
+let out = Track(
+  video: videoPath, srcW: Double(srcW), srcH: Double(srcH),
+  duration: duration, sampleFps: sampleFps, samples: samples)
+
+let encoder = JSONEncoder()
+encoder.outputFormatting = .prettyPrinted
+FileHandle.standardOutput.write(try encoder.encode(out))
diff --git a/marketing/lib/reframe.mjs b/marketing/lib/reframe.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/lib/reframe.mjs
@@ -0,0 +1,171 @@
+// reframe.mjs — turn a jittery face track into a calm vertical crop.
+//
+// Vision tells us where the face is on every sampled frame. Pointing the crop
+// straight at those numbers looks awful: the box twitches every frame and the
+// footage reads as handheld-by-a-nervous-person. What we want is a camera
+// operator — someone who holds still, and when the subject really does move,
+// follows late and settles soft.
+//
+// So the raw boxes go through four stages, in this order:
+//
+//   1. resample  — Vision samples at its own rate; we need one box per frame.
+//   2. median    — kill single-frame outliers (a hand near the chin, a blink of
+//                  a false positive) without smearing real motion.
+//   3. deadband  — inside a slack radius the camera simply does not move. This
+//                  is what buys the "locked off" feel; smoothing alone can't.
+//   4. spring    — outside the slack, chase the target with a critically damped
+//                  spring, so it eases in and eases out and never overshoots.
+//
+// Clamping happens last, against the source edges, so the crop can never show
+// letterbox.
+//
+//   import { faceTrack, buildReframer } from "../lib/reframe.mjs";
+//   const track = await faceTrack("clip.mov");
+//   const at = buildReframer(track, { w: 1080, h: 1920, fps: 30 });
+//   const { sx, sy, sw, sh } = at(t);   // source rect to draw for time t
+
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const DETECTOR = join(HERE, "face-track.swift");
+
+// Vision costs real seconds, and a track only depends on the file and the
+// sample rate — so it caches. Delete the json to force a re-detect.
+export function faceTrack(videoPath, { fps = 10, cachePath = null } = {}) {
+  const cache = cachePath || join(HERE, "..", "talking-head", "out", ".track.json");
+  if (existsSync(cache)) {
+    const cached = JSON.parse(readFileSync(cache, "utf8"));
+    if (cached.video === videoPath && cached.sampleFps === fps) return cached;
+  }
+  const json = execFileSync("swift", [DETECTOR, videoPath, "--fps", String(fps)], {
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "ignore"], // swift's deprecation warnings are noise
+  });
+  const track = JSON.parse(json);
+  mkdirSync(dirname(cache), { recursive: true });
+  writeFileSync(cache, json);
+  return track;
+}
+
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+
+function medianOf(values) {
+  const s = [...values].sort((a, b) => a - b);
+  return s[s.length >> 1];
+}
+
+export function buildReframer(
+  track,
+  {
+    w = 1080, // output width
+    h = 1920, // output height
+    fps = 30,
+    zoom = 1.0, // 1.0 = full source height (sharpest); >1 pushes in on the face
+    headroom = 0.42, // where the face center sits vertically, 0 = top, 1 = bottom
+    slack = 26, // deadband radius in source px — under this, the camera holds
+    stiffness = 2.6, // spring rate; lower is lazier
+    medianWindow = 5,
+  } = {},
+) {
+  const { srcW, srcH, duration, samples } = track;
+
+  // The crop is the tallest 9:16 box that fits, divided by zoom.
+  const aspect = w / h;
+  let sh = Math.min(srcH, srcW / aspect) / zoom;
+  let sw = sh * aspect;
+  if (sw > srcW) {
+    sw = srcW;
+    sh = sw / aspect;
+  }
+
+  const frames = Math.max(1, Math.round(duration * fps));
+
+  // 1. Resample onto the frame grid. Faces can vanish for a beat (a turn of the
+  //    head, a hand across the mouth); we hold the last good center rather than
+  //    snapping to frame center, which would look like a flinch.
+  const targets = new Array(frames);
+  let cursor = 0;
+  let lastKnown =
+    samples.length > 0
+      ? { cx: samples[0].x + samples[0].w / 2, cy: samples[0].y + samples[0].h / 2 }
+      : { cx: srcW / 2, cy: srcH / 2 };
+
+  for (let f = 0; f < frames; f += 1) {
+    const t = f / fps;
+    while (cursor < samples.length - 1 && samples[cursor + 1].t <= t) cursor += 1;
+    const a = samples[cursor];
+    const b = samples[cursor + 1];
+    if (a && b && b.t > a.t && t >= a.t) {
+      const k = clamp((t - a.t) / (b.t - a.t), 0, 1);
+      const acx = a.x + a.w / 2;
+      const bcx = b.x + b.w / 2;
+      const acy = a.y + a.h / 2;
+      const bcy = b.y + b.h / 2;
+      lastKnown = { cx: acx + (bcx - acx) * k, cy: acy + (bcy - acy) * k };
+    } else if (a) {
+      lastKnown = { cx: a.x + a.w / 2, cy: a.y + a.h / 2 };
+    }
+    targets[f] = { ...lastKnown };
+  }
+
+  // 2. Median filter. A mean would drag the camera toward outliers; a median
+  //    ignores them outright while leaving sustained motion intact.
+  const half = medianWindow >> 1;
+  const smoothed = targets.map((_, f) => {
+    const lo = Math.max(0, f - half);
+    const hi = Math.min(frames - 1, f + half);
+    const window = targets.slice(lo, hi + 1);
+    return {
+      cx: medianOf(window.map((p) => p.cx)),
+      cy: medianOf(window.map((p) => p.cy)),
+    };
+  });
+
+  // 3 + 4. Deadband, then spring. Integrated forward once, at build time, so
+  //        that lookups are a plain array read and the pan is identical on
+  //        every render.
+  const dt = 1 / fps;
+  const damping = 2 * Math.sqrt(stiffness); // critical damping: no overshoot
+  const path = new Array(frames);
+  let px = smoothed[0].cx;
+  let py = smoothed[0].cy;
+  let vx = 0;
+  let vy = 0;
+
+  for (let f = 0; f < frames; f += 1) {
+    const { cx, cy } = smoothed[f];
+
+    // Only aim at the part of the error that escapes the slack radius. Inside
+    // it the target *is* where we already are, so the spring has nothing to do.
+    const ex = cx - px;
+    const ey = cy - py;
+    const dist = Math.hypot(ex, ey);
+    let aimX = px;
+    let aimY = py;
+    if (dist > slack) {
+      const pull = (dist - slack) / dist;
+      aimX = px + ex * pull;
+      aimY = py + ey * pull;
+    }
+
+    vx += (stiffness * (aimX - px) - damping * vx) * dt;
+    vy += (stiffness * (aimY - py) - damping * vy) * dt;
+    px += vx * dt;
+    py += vy * dt;
+
+    // The face sits at `headroom` down the frame, not dead center — centering a
+    // head vertically always looks like it's sinking.
+    const sx = clamp(px - sw / 2, 0, srcW - sw);
+    const sy = clamp(py - sh * headroom, 0, srcH - sh);
+    path[f] = { sx, sy, sw, sh };
+  }
+
+  return function at(t) {
+    const f = clamp(Math.round(t * fps), 0, frames - 1);
+    return path[f];
+  };
+}
diff --git a/marketing/lib/side-stamps.mjs b/marketing/lib/side-stamps.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/lib/side-stamps.mjs
@@ -0,0 +1,350 @@
+// side-stamps.mjs — AC's side-stamp chrome, as a thing you can call.
+//
+// Two pals watermarks hug the left and right edges, rotated a quarter turn to
+// face inward, with the title climbing the margin beside each one. Everything
+// wiggles, bobs and swivels on a slow loop, and every glyph carries a VHS
+// chromatic fringe — magenta and cyan ghosts split a few pixels either side of
+// a bright core, with a glow that breathes on whatever envelope you feed it.
+//
+//   const stamps = await makeSideStamps({ w: 1080, h: 1920, fps: 30, frames,
+//                                         title: "prompt.ac", assetsDir });
+//   stamps.draw(ctx, t, env, tint);   // env 0..1 — audio or motion, your choice
+//
+// `tint` is optional: pass { core, hi } (each an [r,g,b]) to recolor the stamps
+// per frame — e.g. sampled from the footage and pushed to dayglow, so the chrome
+// answers the picture instead of ignoring it. Omit it and the defaults stand.
+//
+// `env` does more than glow: it bounces. The stamps swell and settle on it, so
+// they move with the voice rather than on a metronome.
+//
+// This treatment was written five times (pop/menuband, pop/momboba, pop/marimba,
+// pop/big-pictures, marketing/kidlisp-reels) before it was written once. Those
+// copies still exist and still work; new reels should call this instead, and the
+// old ones can migrate whenever someone is in there anyway.
+//
+// The defaults carry @jeffrey's tuning notes from the kidlisp reels: the stamps
+// move SLOWLY (speed 0.18 — they read as too fast much above that).
+
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createCanvas, loadImage } from "canvas";
+
+import { prerenderTitleChars, magickRenderText } from "../../pop/lib/preview-shared.mjs";
+
+const REPO = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const TAU = Math.PI * 2;
+
+export async function makeSideStamps({
+  w,
+  h,
+  fps,
+  frames,
+  assetsDir,
+  title = "aesthetic.computer",
+  // A bright core with a hot highlight, plus the two fringe colors. The kidlisp
+  // reels run lime; white reads cleaner over skin and photographic footage.
+  core = [235, 240, 250],
+  coreHi = [255, 255, 255],
+  chromaR = [255, 60, 120],
+  chromaB = [70, 170, 255],
+  chromaPx = 3,
+  speed = 0.18,
+  stampSize = 145,
+  edgeX = 92,
+  titlePx = 72,
+  charScale = 0.62,
+  leftCy = null, // where the title column sits; defaults to low-left / high-right
+  rightCy = null,
+  // Pass a clock to make the climbing text a live readout instead of a fixed
+  // word: { atlas } from makeChromaGlyphs, { textAt(t) } → the string for time t,
+  // plus its own { scale, kern }. When present it replaces `title` on the margins.
+  clock = null,
+} = {}) {
+  const PALS_HALF = stampSize / 2;
+  const CHARS_EDGE_X = edgeX + 12;
+  const BOUNCE_BUF = 26;
+
+  // ── raster the pals ──────────────────────────────────────────────────────
+  // Rasterized at 2× and drawn down, so the stamp stays clean. The blurred copy
+  // is what the chromatic ghosts and the glow are drawn from — a soft source
+  // makes the fringe read as light rather than as a second, offset logo.
+  mkdirSync(assetsDir, { recursive: true }); // rsvg won't create its output dir
+
+  const svg = join(REPO, "system", "public", "purple-pals.svg");
+  const png = join(assetsDir, "pals-watermark.png");
+  const blurPng = join(assetsDir, "pals-watermark-blur.png");
+  const size = 212 * 2;
+
+  const r = spawnSync("rsvg-convert", ["-w", String(size), "-h", String(size), "-o", png, svg]);
+  if (r.status !== 0 || !existsSync(png)) {
+    throw new Error(
+      `pals watermark failed to rasterize: ${r.error?.message || r.stderr?.toString().trim() || "rsvg-convert not found"}`,
+    );
+  }
+  const palsImg = await loadImage(png);
+  const rb = spawnSync("magick", [png, "-channel", "A", "-blur", "0x1.5", "+channel", blurPng]);
+  const palsBlur = rb.status === 0 && existsSync(blurPng) ? await loadImage(blurPng) : palsImg;
+
+  // With a clock, the climbing text is the ticking readout — skip the static
+  // title, and size the column from a representative clock string so the pals
+  // (which park above and below it) sit in the right place all minute.
+  let chars = [];
+  let CHAR_SPAN;
+  if (clock) {
+    CHAR_SPAN = clock.atlas.measure(clock.sample || "0000.00.00 00:00:00", clock.scale, clock.kern);
+  } else {
+    const t = await prerenderTitleChars({
+      text: title, ptSize: titlePx, palette: ["#FFFFFF"], shadowColor: null, assetsDir,
+    });
+    chars = t.chars;
+    CHAR_SPAN = t.totalWidth * charScale;
+  }
+  // Two column layouts, chosen by what the text IS.
+  //
+  //   · A short title (the /pop look): the column sits at a fixed height and the
+  //     pals badge hugs the far end of it — the arrangement every other AC reel
+  //     uses, so a talking-head reel reads as one of the family.
+  //   · A long clock: anchor the badge in the corner instead and let the readout
+  //     climb inward from it, or a 19-character timestamp shoves the badge clean
+  //     off the edge.
+  let LEFT_PALS_CY;
+  let RIGHT_PALS_CY;
+  let LEFT_CHARS_CY;
+  let RIGHT_CHARS_CY;
+  if (clock) {
+    LEFT_PALS_CY = leftCy ?? h - PALS_HALF - 78;
+    RIGHT_PALS_CY = rightCy ?? PALS_HALF + 78;
+    LEFT_CHARS_CY = LEFT_PALS_CY - PALS_HALF - BOUNCE_BUF - CHAR_SPAN / 2;
+    RIGHT_CHARS_CY = RIGHT_PALS_CY + PALS_HALF + BOUNCE_BUF + CHAR_SPAN / 2;
+  } else {
+    LEFT_CHARS_CY = leftCy ?? h * 0.84;
+    RIGHT_CHARS_CY = rightCy ?? h * 0.16;
+    LEFT_PALS_CY = LEFT_CHARS_CY - CHAR_SPAN / 2 - BOUNCE_BUF - PALS_HALF;
+    RIGHT_PALS_CY = RIGHT_CHARS_CY + CHAR_SPAN / 2 + BOUNCE_BUF + PALS_HALF;
+  }
+
+  // Scratch canvases for tinting. Reused rather than reallocated — this runs
+  // per glyph per frame, and at 1774 frames the garbage adds up.
+  const wm = createCanvas(8, 8);
+  const wmCtx = wm.getContext("2d");
+  const glyph = createCanvas(2, 2);
+  const glyphCtx = glyph.getContext("2d");
+
+  // Recolor an alpha mask by filling through it — `source-in` keeps the source's
+  // alpha and takes the fill's color, which is how a white raster becomes any
+  // color we like without shipping five copies of the asset.
+  const tint = (canvas, ctx2, src, c) => {
+    canvas.width = src.width;
+    canvas.height = src.height;
+    ctx2.globalCompositeOperation = "source-over";
+    ctx2.clearRect(0, 0, src.width, src.height);
+    ctx2.drawImage(src, 0, 0);
+    ctx2.globalCompositeOperation = "source-in";
+    ctx2.fillStyle = `rgb(${c[0]},${c[1]},${c[2]})`;
+    ctx2.fillRect(0, 0, src.width, src.height);
+    ctx2.globalCompositeOperation = "source-over";
+    return canvas;
+  };
+  const tintPals = (src, c) => tint(wm, wmCtx, src, c);
+  const tintGlyph = (src, c) => tint(glyph, glyphCtx, src, c);
+
+  // The fringe is atmosphere; the core is the thing. So the ghosts are drawn from
+  // the BLURRED raster and kept faint, and the core is drawn from the SHARP one
+  // at full opacity, twice — the fringe reads as light bleeding around a mark
+  // that is itself crisp. Earlier this drew the core at 0.6 alpha over its own
+  // ghosts, which is what made the stamps look soft and washed instead of inked.
+  const drawChroma = (ctx, tintFn, sharp, soft, dx, dy, dw, dh, env, col, colHi) => {
+    ctx.globalCompositeOperation = "source-over";
+    ctx.globalAlpha = 0.30;
+    ctx.drawImage(tintFn(sharp, [8, 10, 6]), dx + 2.5, dy + 3, dw, dh);
+
+    ctx.globalCompositeOperation = "screen";
+    ctx.globalAlpha = 0.22;
+    ctx.drawImage(tintFn(soft, chromaR), dx - chromaPx, dy, dw, dh);
+    ctx.globalAlpha = 0.22;
+    ctx.drawImage(tintFn(soft, chromaB), dx + chromaPx, dy, dw, dh);
+    if (env > 0.02) {
+      ctx.globalAlpha = 0.10 + 0.26 * env; // the bloom breathes with the voice
+      ctx.drawImage(tintFn(soft, colHi), dx, dy, dw, dh);
+    }
+
+    // Opaque, on top, sharp — this is the pass that gives it its edge.
+    ctx.globalCompositeOperation = "source-over";
+    ctx.globalAlpha = 1;
+    ctx.drawImage(tintFn(sharp, col), dx, dy, dw, dh);
+    ctx.globalAlpha = 0.35 + 0.35 * env; // a second hit to bite, harder when loud
+    ctx.drawImage(tintFn(sharp, colHi), dx, dy, dw, dh);
+    ctx.globalAlpha = 1;
+  };
+
+  // A spring, so the bounce overshoots and settles instead of tracking the
+  // envelope rigidly — the envelope is what he's doing, this is how the stamp
+  // *reacts* to it, and the lag between the two is the whole charm.
+  let bounce = 0;
+  let bounceV = 0;
+
+  function draw(ctx, t, env = 0, tint = null) {
+    const u = (t * fps) / frames;
+    const col = tint?.core || core;
+    const colHi = tint?.hi || coreHi;
+
+    const dt = 1 / fps;
+    bounceV += (34 * (env - bounce) - 9 * bounceV) * dt;
+    bounce += bounceV * dt;
+    const pop = 1 + 0.22 * bounce; // swell on the beat of his voice
+
+    // Layered sines at unrelated frequencies, so the loop never lands on an
+    // obvious beat — it reads as drift rather than as animation.
+    const wig = 13 * Math.sin(TAU * 24 * speed * u + 0.7) + 4 * Math.sin(TAU * 9 * speed * u);
+    const bob = 3 * Math.sin(TAU * 17 * speed * u + 2.1) + 1.5 * Math.sin(TAU * 31 * speed * u);
+    const swiv = 0.05 * Math.sin(TAU * 19 * speed * u) + 0.025 * Math.sin(TAU * 38 * speed * u + 1.4);
+    const kick = 14 * bounce; // and shove away from the edge as they swell
+
+    const s = stampSize * pop;
+    for (const spot of [
+      { cx: edgeX - wig + kick, cy: LEFT_PALS_CY + bob, rot: Math.PI / 2 + swiv },
+      { cx: w - edgeX + wig - kick, cy: RIGHT_PALS_CY - bob, rot: -Math.PI / 2 - swiv },
+    ]) {
+      ctx.save();
+      ctx.translate(spot.cx, spot.cy);
+      ctx.rotate(spot.rot + bounce * 0.04);
+      drawChroma(ctx, tintPals, palsImg, palsBlur, -s / 2, -s / 2, s, s, env, col, colHi);
+      ctx.restore();
+    }
+
+    // The title climbs each margin, facing inward — and every letter is its own
+    // creature. Each one gets its own phase, so it swells, leans and drifts on a
+    // schedule the letter beside it knows nothing about. The word never pumps as
+    // a block; it ripples, and the ripple runs along the word as he speaks.
+    //
+    // The list of letters is resolved per frame, so the climbing text can be a
+    // running clock as easily as a fixed word — the ticking seconds get the same
+    // bounce and fringe as everything else, which is the point.
+    const [glyphList, span, glyphScale] = clock
+      ? layoutClock(clock.textAt(t))
+      : [chars, CHAR_SPAN, charScale];
+
+    const twig = 11 * Math.sin(TAU * 30 * speed * u + 3.6) + 4 * Math.sin(TAU * 12 * speed * u + 1.1);
+    for (const spot of [
+      { cx: CHARS_EDGE_X - twig + kick * 0.6, cy: LEFT_CHARS_CY, rot: Math.PI / 2 },
+      { cx: w - CHARS_EDGE_X + twig - kick * 0.6, cy: RIGHT_CHARS_CY, rot: -Math.PI / 2 },
+    ]) {
+      ctx.save();
+      ctx.translate(spot.cx, spot.cy);
+      ctx.rotate(spot.rot);
+      const startX = -span / 2;
+
+      for (const [i, ch] of glyphList.entries()) {
+        if (!ch.img) continue;
+        // Phase offset per letter: the wave travels down the word instead of
+        // hitting it all at once.
+        const ph = TAU * (t * 1.1 - i * 0.13);
+        const swell = 1 + (0.10 + 0.20 * bounce) * Math.sin(ph);
+        const lean = 0.10 * Math.sin(ph + 1.2) * (0.4 + bounce);
+        const drift = 4 * Math.sin(ph * 0.7 + i);
+
+        const dw = ch.img.width * glyphScale;
+        const dh = ch.img.height * glyphScale;
+        const cx = startX + ch.prefixWidth * glyphScale + dw / 2;
+
+        ctx.save();
+        ctx.translate(cx, drift); // each letter rides its own little wave
+        ctx.rotate(lean);
+        ctx.scale(swell, swell);
+        drawChroma(ctx, tintGlyph, ch.img, ch.img, -dw / 2, -dh / 2, dw, dh, env, col, colHi);
+        ctx.restore();
+      }
+      ctx.restore();
+    }
+
+    ctx.globalCompositeOperation = "source-over";
+    ctx.globalAlpha = 1;
+  }
+
+  // Lay a clock string out on the fly: cumulative x offsets in unscaled px, the
+  // same shape the prerendered title chars have, so the draw loop treats both the
+  // same way.
+  function layoutClock(text) {
+    const list = [];
+    let prefix = 0;
+    for (const ch of text) {
+      const g = clock.atlas.glyphs.get(ch);
+      if (g) list.push({ img: g, prefixWidth: prefix });
+      prefix += (g ? g.width : clock.atlas.spaceW) + clock.kern;
+    }
+    return [list, prefix - clock.kern, clock.scale];
+  }
+
+  return { draw, drawChroma, tintGlyph };
+}
+
+// The same inked, fringed, per-character treatment — but for text that CHANGES,
+// like a clock. Prerendering every string a ticking timestamp passes through
+// would mean hundreds of magick calls; prerendering the dozen characters it is
+// made of means twelve. Glyphs are composed at draw time.
+export async function makeChromaGlyphs({
+  charset = "0123456789.: ",
+  ptSize = 96,
+  assetsDir,
+  font = null,
+} = {}) {
+  mkdirSync(assetsDir, { recursive: true });
+  const glyphs = new Map();
+
+  for (const ch of charset) {
+    if (ch === " ") {
+      glyphs.set(ch, null); // a space is a width, not a picture
+      continue;
+    }
+    const safe = ch.charCodeAt(0).toString(16);
+    glyphs.set(ch, await magickRenderText(ch, {
+      ptSize, font, fill: "#FFFFFF",
+      outPath: join(assetsDir, `g-${safe}.png`),
+    }));
+  }
+
+  const spaceW = ptSize * 0.32;
+  const measure = (text, scale = 1, kern = 0) => {
+    let width = 0;
+    for (const ch of text) {
+      const g = glyphs.get(ch);
+      width += (g ? g.width * scale : spaceW * scale) + kern;
+    }
+    return width;
+  };
+
+  return { glyphs, measure, spaceW };
+}
+
+// Take a color the camera actually saw and push it until it fluoresces: keep the
+// hue, throw saturation and value to the top. The picture stays photographic and
+// the chrome laid over it goes highlighter-bright, which is the whole trick —
+// they agree on hue, so it reads as belonging, and disagree on everything else,
+// so it reads as ink.
+export function dayglow([r, g, b], { value = 255 } = {}) {
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const d = max - min;
+
+  let hue = 0;
+  if (d > 0) {
+    if (max === r) hue = ((g - b) / d + 6) % 6;
+    else if (max === g) hue = (b - r) / d + 2;
+    else hue = (r - g) / d + 4;
+    hue /= 6;
+  }
+
+  // Full saturation, full value — hsv(h, 1, 1) back to rgb.
+  const i = Math.floor(hue * 6) % 6;
+  const f = hue * 6 - Math.floor(hue * 6);
+  const q = Math.round(value * (1 - f));
+  const tt = Math.round(value * f);
+  const v = Math.round(value);
+  const table = [
+    [v, tt, 0], [q, v, 0], [0, v, tt],
+    [0, q, v], [tt, 0, v], [v, 0, q],
+  ];
+  return table[i];
+}
diff --git a/marketing/lib/sosoft-side-identity.mjs b/marketing/lib/sosoft-side-identity.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/lib/sosoft-side-identity.mjs
@@ -0,0 +1,91 @@
+// SO SOFT + Pals side identity for Social Software reels.
+// Extends the shared AC stamp language with the two-box mark prototyped in
+// prompt.mjs: SO and SOFT remain separate outlined objects, joined by a live
+// line that changes posture rather than becoming a static sponsor bug.
+
+import { createCanvas, registerFont } from "canvas";
+import { resolve } from "node:path";
+import { makeSideStamps } from "./side-stamps.mjs";
+
+export async function makeSosoftSideIdentity({ w, h, fps, frames, assetsDir } = {}) {
+  try {
+    registerFont(resolve("slab/menuband/Sources/MenuBand/Resources/ywft-processing-bold.ttf"), {
+      family: "YWFT Processing",
+      weight: "bold",
+    });
+  } catch {}
+
+  const pals = await makeSideStamps({
+    w, h, fps, frames, assetsDir,
+    title: "SCORES FOR SOCIAL SOFTWARE",
+    edgeX: 78,
+    stampSize: 128,
+    titlePx: 58,
+    charScale: 0.48,
+    leftCy: h * 0.78,
+    rightCy: h * 0.22,
+    speed: 0.14,
+  });
+
+  const mark = createCanvas(360, 150);
+  const m = mark.getContext("2d");
+  let spring = 0, velocity = 0;
+
+  function renderMark(t, env) {
+    const dt = 1 / fps;
+    velocity += (28 * (env - spring) - 8 * velocity) * dt;
+    spring += velocity * dt;
+    m.clearRect(0, 0, mark.width, mark.height);
+    m.font = "bold 42px YWFT Processing, Arial";
+    m.textBaseline = "middle";
+    m.textAlign = "center";
+    m.lineJoin = "round";
+
+    const phase = Math.floor(t / 4.5) % 3;
+    const drift = Math.sin(t * 0.75) * 5;
+    const boxes = phase === 0
+      ? [{ text: "SO", x: 38, y: 54 + drift, w: 76 }, { text: "SOFT", x: 188, y: 54 - drift, w: 134 }]
+      : phase === 1
+        ? [{ text: "SO", x: 106 + drift, y: 20, w: 76 }, { text: "SOFT", x: 106 - drift, y: 88, w: 134 }]
+        : [{ text: "SO", x: 32, y: 18 + drift, w: 76 }, { text: "SOFT", x: 188, y: 82 - drift, w: 134 }];
+    const a = boxes[0], b = boxes[1];
+    const cyA = a.y + 27, cyB = b.y + 27;
+
+    // Cyan/magenta ghosts bind the SO SOFT mark to the Pals reel chrome.
+    for (const [dx, color, alpha] of [[-3, "#ff3c78", .34], [3, "#46aaff", .34], [0, "#fffdf3", 1]]) {
+      m.globalAlpha = alpha;
+      m.strokeStyle = color;
+      m.fillStyle = color;
+      m.lineWidth = dx === 0 ? 3 : 5;
+      m.beginPath();
+      m.moveTo(a.x + a.w + dx, cyA);
+      const midX = (a.x + a.w + b.x) / 2 + dx;
+      m.bezierCurveTo(midX, cyA + Math.sin(t * 2) * 11, midX, cyB - Math.sin(t * 2) * 11, b.x + dx, cyB);
+      m.stroke();
+      for (const box of boxes) {
+        m.strokeRect(box.x + dx, box.y, box.w, 54);
+        m.fillText(box.text, box.x + box.w / 2 + dx, box.y + 29);
+      }
+    }
+    m.globalAlpha = 1;
+  }
+
+  function draw(ctx, t, env = 0, tint = null) {
+    pals.draw(ctx, t, env, tint);
+    renderMark(t, env);
+    const pulse = 1 + spring * 0.12;
+    const y = h * 0.51 + Math.sin(t * 0.55) * 22;
+    for (const side of [-1, 1]) {
+      ctx.save();
+      ctx.translate(side < 0 ? 26 : w - 26, y);
+      ctx.rotate(side < 0 ? Math.PI / 2 : -Math.PI / 2);
+      ctx.scale(pulse, pulse);
+      ctx.globalAlpha = 0.92;
+      ctx.drawImage(mark, -180, -75);
+      ctx.restore();
+    }
+    ctx.globalAlpha = 1;
+  }
+
+  return { draw };
+}
diff --git a/marketing/lib/words.mjs b/marketing/lib/words.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/lib/words.mjs
@@ -0,0 +1,55 @@
+// words.mjs — whisper tokens in, real words out.
+//
+// whisper.cpp with `-ml 1` gives one segment per *token*, not per word, so
+// "Y Combinator" arrives as ["Y", " Com", "bin", "ator"] and a naive caption
+// renderer would flash "ator" at you. The tell is the leading space: a token
+// that starts one begins a new word, and everything after it — subword pieces,
+// clitics like "'m", trailing commas — belongs to the word before it.
+//
+//   whisper-cli -m <model> -f audio.wav -oj -ojf -ml 1 -of out
+//   import { wordsFromWhisper } from "../lib/words.mjs";
+//   const words = wordsFromWhisper("out.json");   // [{ text, fromMs, toMs }]
+//
+// The {text, fromMs, toMs} shape is the repo's caption schema — the same one
+// marketing/bin/align-captions.mjs writes and captions-train.mjs consumes.
+
+import { readFileSync } from "node:fs";
+
+export function wordsFromWhisper(jsonPath) {
+  const raw = JSON.parse(readFileSync(jsonPath, "utf8"));
+  const words = [];
+
+  for (const seg of raw.transcription) {
+    const piece = seg.text;
+    if (!piece || !piece.trim()) continue;
+
+    const startsWord = piece.startsWith(" ");
+    const text = piece.trim();
+    const from = seg.offsets.from;
+    const to = seg.offsets.to;
+
+    // A token with no leading space continues the word we're already building —
+    // unless there is no such word yet, at which point it starts one.
+    if (startsWord || words.length === 0) {
+      words.push({ text, fromMs: from, toMs: to });
+    } else {
+      const prev = words[words.length - 1];
+      prev.text += text;
+      prev.toMs = to; // the word isn't finished until its last piece is
+    }
+  }
+
+  // Bare punctuation ("," on its own) is not a word; glue it back on so it
+  // doesn't get its own karaoke beat.
+  const merged = [];
+  for (const w of words) {
+    if (/^[^\w'"“”‘’(]+$/.test(w.text) && merged.length > 0) {
+      const prev = merged[merged.length - 1];
+      prev.text += w.text;
+      prev.toMs = Math.max(prev.toMs, w.toMs);
+    } else {
+      merged.push(w);
+    }
+  }
+  return merged;
+}
diff --git a/marketing/podcast/bin/jingle.mjs b/marketing/podcast/bin/jingle.mjs
--- a/marketing/podcast/bin/jingle.mjs
+++ b/marketing/podcast/bin/jingle.mjs
@@ -231,7 +231,10 @@ const dur = Math.max(4, durationSec);
   const L = new Float32Array(Math.ceil(dur * SR));
   const R = new Float32Array(L.length);
   const rnd = lcg(0x51ED9);
-  const bpm = BED_BPM, beat = 60 / bpm, bar = beat * 4;
+  const bpm = (opts.bpm || BED_BPM), beat = 60 / bpm, bar = beat * 4;
+  // `semitones` transposes all pitched material (chords + melody), leaving the
+  // drums where they are — so the bed can meet a vocal in any key. Default 0 = C.
+  const tr = 2 ** ((opts.semitones || 0) / 12);
 
   // Chord pad — I · vi · IV · V, two bars each, gently overlapping.
   const prog = [
@@ -244,9 +247,9 @@ let ci = 0;
   for (let t = 0; t < dur; t += bar * 2) {
     const [r, th, fi] = prog[ci++ % prog.length];
     const d = Math.min(bar * 2 + 0.7, dur - t + 0.7);
-    addPad(L, R, r, t, d, 0.17);    // chords — the harmonic bed, well up
-    addPad(L, R, th, t, d, 0.12);
-    addPad(L, R, fi, t, d, 0.145);
+    addPad(L, R, r * tr, t, d, 0.17);    // chords — the harmonic bed, well up
+    addPad(L, R, th * tr, t, d, 0.12);
+    addPad(L, R, fi * tr, t, d, 0.145);
   }
 
   // Rhythm — swappable drum kit (default "felt" = the current sound).
@@ -258,10 +261,64 @@ const penta = [261.63, 293.66, 329.63, 392.00, 440.00, 523.25];
   let mi = 2;
   for (let t = 0.5; t < dur; t += beat * (rnd() < 0.5 ? 2 : 3)) {
     mi = Math.max(0, Math.min(penta.length - 1, mi + (rnd() < 0.5 ? -1 : 1) * (rnd() < 0.3 ? 2 : 1)));
-    addBell(L, R, penta[mi], t, 3.4, 0.24, rnd() * 0.6 - 0.3, 0.4); // bright=0.4 → warm
+    addBell(L, R, penta[mi] * tr, t, 3.4, 0.24, rnd() * 0.6 - 0.3, 0.4); // bright=0.4 → warm
   }
 
   normalize(L, R, 0.72);
+  writeFileSync(outPath, encodeWav(L, R));
+  return outPath;
+}
+
+// A sine-wave bed: the same I·vi·IV·V harmony as renderBed, but nothing struck
+// and nothing rhythmic — just pure sine tones, slow-attack and slow-release, so
+// chords bleed into each other like breathing. No drums, no bells, no melody.
+// It sits under a voice as a warm pad rather than a track. A faint octave-up
+// sine and a slow tremolo keep it from sounding like a test tone.
+export function renderSineBed(durationSec, outPath) {
+  const dur = Math.max(4, durationSec);
+  const L = new Float32Array(Math.ceil(dur * SR));
+  const R = new Float32Array(L.length);
+  const bar = (60 / BED_BPM) * 4;
+
+  const prog = [
+    [130.81, 164.81, 196.00], // C  (C3 E3 G3)
+    [110.00, 130.81, 164.81], // Am (A2 C3 E3)
+    [ 87.31, 110.00, 130.81], // F  (F2 A2 C3)
+    [ 98.00, 123.47, 146.83], // G  (G2 B2 D3)
+  ];
+
+  // One sine voice: fade in over `fade`, hold, fade out — the long overlaps mean
+  // no chord ever starts or stops abruptly. A little detuned octave adds shimmer,
+  // a slow tremolo adds life, and a gentle pan spreads the three chord tones.
+  const sine = (f, at, len, gain, pan) => {
+    const start = Math.floor(at * SR);
+    const n = Math.floor(len * SR);
+    const fade = Math.min(len * 0.45, 1.1);
+    const gl = gain * (1 - Math.max(0, pan)) * 0.5;
+    const gr = gain * (1 + Math.min(0, pan)) * 0.5;
+    for (let i = 0; i < n; i += 1) {
+      const j = start + i;
+      if (j >= L.length) break;
+      const t = i / SR;
+      const a = Math.min(1, t / fade, (len - t) / fade); // trapezoid envelope
+      const trem = 1 + 0.05 * Math.sin(2 * Math.PI * 0.18 * t); // slow breathing
+      const s = (Math.sin(2 * Math.PI * f * t) + 0.18 * Math.sin(2 * Math.PI * f * 2.003 * t)) * a * trem;
+      L[j] += s * gl;
+      R[j] += s * gr;
+    }
+  };
+
+  let ci = 0;
+  for (let t = 0; t < dur; t += bar * 2) {
+    const [r, th, fi] = prog[ci++ % prog.length];
+    const len = Math.min(bar * 2 + 1.4, dur - t + 1.4); // overlap the next chord
+    sine(r, t, len, 0.16, 0);
+    sine(th, t, len, 0.12, -0.35);
+    sine(fi, t, len, 0.12, 0.35);
+    sine(r / 2, t, len, 0.10, 0); // a soft sub-octave drone under the root
+  }
+
+  normalize(L, R, 0.6); // quieter than the felt bed — it's a wash, not a track
   writeFileSync(outPath, encodeWav(L, R));
   return outPath;
 }
diff --git a/marketing/sosoft-reel/README.md b/marketing/sosoft-reel/README.md
--- a/marketing/sosoft-reel/README.md
+++ b/marketing/sosoft-reel/README.md
@@ -37,4 +37,11 @@ 5. Align words/captions with `marketing/bin/align-captions.mjs` and the shared word utilities.
 6. Build the vertical composite using shared reframing and side-stamp libraries.
 7. Master the delivery to −14 LUFS and check phone playback.
 
+## Social derivatives
+
+- `node identity-proof.mjs [seconds]` renders a short proof of the combined
+  Pals + animated SO SOFT double-box side identity over the delivery master.
+- `node export-carousel.mjs` masters the ten selected work stills as a numbered
+  1080×1350 Instagram multi-swipe set in `out/carousel/`.
+
 See [SCRIPT.md](SCRIPT.md) and [index.json](index.json).
diff --git a/marketing/sosoft-reel/export-carousel.mjs b/marketing/sosoft-reel/export-carousel.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/sosoft-reel/export-carousel.mjs
@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+// Master the ten canonical work stills as a 4:5 Instagram multi-swipe set.
+
+import { mkdirSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import sharp from "sharp";
+
+const ROOT = dirname(fileURLToPath(import.meta.url));
+const OUT = resolve(ROOT, "out/carousel");
+const SELECTS = resolve(ROOT, "out/selects");
+const items = JSON.parse(readFileSync(resolve(ROOT, "index.json"), "utf8")).items;
+mkdirSync(OUT, { recursive: true });
+
+const escape = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const files = [
+  "01-notepat.jpg", "02-vigil-score.jpg", "03-software-as-a-choreography.jpg",
+  "04-sonic-architecture.jpg", "05-cues-for-losing-direction.jpg", "06-line-piece-1.jpg",
+  "07-biophoni-a.jpg", "08-a-cosmographic-score-for-folding-back-into-the-kernel.jpg",
+  "09-music-for-world-computers.jpg", "10-the-radio-is-an-altar-portal.jpg",
+];
+
+for (let i = 0; i < files.length; i++) {
+  const item = items[i];
+  const meta = await sharp(resolve(SELECTS, files[i])).metadata();
+  const horizontal = meta.width / meta.height > 1.2;
+  const label = Buffer.from(`<svg width="1080" height="1350" xmlns="http://www.w3.org/2000/svg">
+    <style>.a{font:700 31px Arial,sans-serif;letter-spacing:1.2px}.t{font:700 42px Arial,sans-serif}.n{font:700 25px Arial,sans-serif}</style>
+    <rect x="0" y="1180" width="1080" height="170" fill="#111" fill-opacity=".88"/>
+    <text x="54" y="1232" class="a" fill="#fff">${escape(item.artist.toUpperCase())}</text>
+    <text x="54" y="1288" class="t" fill="#fff">${escape(item.title)}</text>
+    <rect x="902" y="1210" width="56" height="42" fill="none" stroke="#fff" stroke-width="3"/><text x="930" y="1240" text-anchor="middle" class="n" fill="#fff">SO</text>
+    <path d="M958 1231 C974 1216 986 1246 1002 1231" fill="none" stroke="#fff" stroke-width="3"/>
+    <rect x="1002" y="1210" width="70" height="42" fill="none" stroke="#fff" stroke-width="3"/><text x="1037" y="1240" text-anchor="middle" class="n" fill="#fff">SOFT</text>
+    <text x="1026" y="1310" text-anchor="end" class="n" fill="#fff">${String(i + 1).padStart(2, "0")} / 10</text>
+  </svg>`);
+  let image = sharp(resolve(SELECTS, files[i])).rotate().toColourspace("srgb").modulate({ saturation: 1.025, brightness: 0.985 }).sharpen({ sigma: 0.55 });
+  image = horizontal
+    ? image.resize(1080, 1350, { fit: "contain", background: "#f6f3ec" })
+    : image.resize(1080, 1350, { fit: "cover", position: "attention" });
+  await image.composite([{ input: label, top: 0, left: 0 }]).jpeg({ quality: 94, chromaSubsampling: "4:4:4", progressive: true }).withMetadata({ density: 72 }).toFile(resolve(OUT, files[i]));
+}
+console.log(`${OUT} (${files.length} slides, 1080x1350)`);
diff --git a/marketing/sosoft-reel/identity-proof.mjs b/marketing/sosoft-reel/identity-proof.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/sosoft-reel/identity-proof.mjs
@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from "node:child_process";
+import { once } from "node:events";
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createCanvas } from "canvas";
+import { makeSosoftSideIdentity } from "../lib/sosoft-side-identity.mjs";
+
+const ROOT = dirname(fileURLToPath(import.meta.url));
+const input = resolve(ROOT, "delivery/scores-for-social-software-master-vertical.mp4");
+const output = resolve(ROOT, "out/sosoft-side-identity-proof.mp4");
+const assetsDir = resolve(ROOT, "out/sosoft-identity-assets");
+mkdirSync(assetsDir, { recursive: true });
+const W = 1080, H = 1920, FPS = 30, SECONDS = Number(process.argv[2] || 8);
+const FRAMES = Math.ceil(SECONDS * FPS), BYTES = W * H * 4;
+const canvas = createCanvas(W, H), ctx = canvas.getContext("2d");
+const image = ctx.createImageData(W, H), frame = Buffer.alloc(BYTES);
+const identity = await makeSosoftSideIdentity({ w: W, h: H, fps: FPS, frames: FRAMES, assetsDir });
+const dec = spawn("ffmpeg", ["-v", "error", "-t", String(SECONDS), "-i", input, "-f", "rawvideo", "-pix_fmt", "rgba", "-"], { stdio: ["ignore", "pipe", "inherit"] });
+const enc = spawn("ffmpeg", ["-y", "-v", "error", "-f", "rawvideo", "-pix_fmt", "bgra", "-s", `${W}x${H}`, "-r", String(FPS), "-i", "-", "-t", String(SECONDS), "-i", input, "-map", "0:v", "-map", "1:a?", "-c:v", "libx264", "-crf", "18", "-preset", "veryfast", "-pix_fmt", "yuv420p", "-c:a", "aac", "-b:a", "192k", "-shortest", "-movflags", "+faststart", output], { stdio: ["pipe", "inherit", "inherit"] });
+let off = 0, fi = 0;
+for await (const chunk of dec.stdout) {
+  let at = 0;
+  while (at < chunk.length && fi < FRAMES) {
+    const n = Math.min(BYTES - off, chunk.length - at);
+    chunk.copy(frame, off, at, at + n); off += n; at += n;
+    if (off === BYTES) {
+      off = 0; image.data.set(frame); ctx.putImageData(image, 0, 0);
+      const t = fi / FPS;
+      const env = Math.max(0, Math.sin(t * Math.PI * 2 * 1.8)) ** 5;
+      identity.draw(ctx, t, env);
+      if (!enc.stdin.write(canvas.toBuffer("raw"))) await once(enc.stdin, "drain");
+      fi++;
+    }
+  }
+}
+enc.stdin.end();
+await new Promise((ok, fail) => enc.on("close", (code) => code === 0 ? ok() : fail(new Error(`encode ${code}`))));
+const probe = spawnSync("ffprobe", ["-v", "error", "-show_entries", "format=duration", "-of", "default=nw=1:nk=1", output], { encoding: "utf8" });
+console.log(`${output} (${probe.stdout.trim()}s)`);
diff --git a/marketing/talking-head/bin/compose-melody.mjs b/marketing/talking-head/bin/compose-melody.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/talking-head/bin/compose-melody.mjs
@@ -0,0 +1,105 @@
+// compose-melody.mjs — turn a spoken transcript into a singable .np score.
+//
+// The YC monologue is 169 words. Hand-picking 169 notes would be a week of
+// composition; letting the pitch follow the speech would be no melody at all.
+// The middle path: a designed line that knows about SENTENCES. Each sentence
+// gets a melodic arch — lift off the tonic, rise to a peak somewhere past the
+// middle, settle back down and cadence on the tonic at the period. That's the
+// shape of a sung phrase, and pinning it to the text's own sentences means the
+// melody breathes where the speaker breathed.
+//
+//   node compose-melody.mjs <alignment.json> --out yc.np --words words.json
+//
+// Reads the ElevenLabs alignment (its `.words` are the sung word list + timing),
+// writes the .np score and the words.json score-pitch needs.
+//
+// Key: D major pentatonic in a baritone octave — D3 E3 F#3 A3 B3 D4 E4 F#4 —
+// which is where jeffrey's voice sits and where WORLD's shift reads as singing,
+// not as artifacted speech (per pop/dance/bin/sing.mjs).
+
+import { readFileSync, writeFileSync } from "node:fs";
+
+const argv = process.argv.slice(2);
+const flag = (n, d = null) => {
+  const i = argv.indexOf(`--${n}`);
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : d;
+};
+const alignPath = argv.find((a) => !a.startsWith("--"));
+const outNp = flag("out", "yc.np");
+const outWords = flag("words", "words.json");
+
+const align = JSON.parse(readFileSync(alignPath, "utf8"));
+const words = align.words; // [{ text, fromMs, toMs }]
+
+// The scale, low to high, as note names. Index into this and you're always in
+// key. Two octaves of D-major pentatonic covers a comfortable sung range.
+const SCALE = ["D3", "E3", "F#3", "A3", "B3", "D4", "E4", "F#4", "A4"];
+const TONIC = 0; // index of D3
+const FIFTH = 3; // index of A3 — where phrases lift off from
+
+// A gentle arch across `n` words: start near the fifth, climb to a peak past the
+// middle, fall to the tonic on the last word. Returns `n` scale indices.
+function arch(n) {
+  if (n === 1) return [TONIC];
+  const peak = Math.min(SCALE.length - 1, FIFTH + 3); // F#4 region
+  const peakAt = Math.floor(n * 0.62); // crest a bit past middle
+  const out = [];
+  for (let i = 0; i < n; i += 1) {
+    let idx;
+    if (i <= peakAt) {
+      idx = FIFTH + Math.round(((peak - FIFTH) * i) / Math.max(1, peakAt));
+    } else {
+      const k = (i - peakAt) / Math.max(1, n - 1 - peakAt);
+      idx = peak - Math.round((peak - TONIC) * k); // descend to tonic
+    }
+    out.push(Math.max(0, Math.min(SCALE.length - 1, idx)));
+  }
+  out[out.length - 1] = TONIC; // always cadence home
+  return out;
+}
+
+// Break the word list into sentences on terminal punctuation, so each arch maps
+// to a real spoken phrase.
+const sentences = [];
+let cur = [];
+for (const w of words) {
+  cur.push(w);
+  if (/[.!?]$/.test(w.text.trim())) {
+    sentences.push(cur);
+    cur = [];
+  }
+}
+if (cur.length) sentences.push(cur);
+
+// A short sentence sung as a full octave arch sounds jumpy; a long one sung flat
+// sounds dull. Softening the arch on very short sentences keeps it singable.
+const lines = [];
+const npWords = [];
+for (const s of sentences) {
+  const contour = arch(s.length);
+  const notes = s.map((w, i) => {
+    // strip punctuation for the syllable text the aligner matches on
+    const syl = w.text.trim().replace(/[^A-Za-z']/g, "") || "la";
+    npWords.push(w.text);
+    // a beat per word; the last word of a sentence rings longer (a breath)
+    const beats = i === s.length - 1 ? 3 : 1;
+    return `${SCALE[contour[i]]}:${syl}*${beats}`;
+  });
+  lines.push(notes.join(" "));
+}
+
+const np = [
+  "# yc-2018 — the YC application, sung.",
+  "# One melodic arch per sentence: lift off the fifth, crest past the middle,",
+  "# cadence home on the tonic. D-major pentatonic, baritone octave.",
+  "# notation: NOTE:syllable*beats",
+  "",
+  "verse",
+  ...lines,
+  "",
+].join("\n");
+
+writeFileSync(outNp, np);
+writeFileSync(outWords, JSON.stringify(words, null, 2));
+console.log(`✓ ${outNp} — ${sentences.length} sentences, ${words.length} words`);
+console.log(`✓ ${outWords}`);
diff --git a/marketing/talking-head/bin/reel.mjs b/marketing/talking-head/bin/reel.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/talking-head/bin/reel.mjs
@@ -0,0 +1,771 @@
+// reel.mjs — a talking head becomes a vertical reel.
+//
+// Takes any 16:9 clip of a person speaking and returns a 1080×1920 reel: the
+// camera follows their face, their words appear as they say them, and an
+// instrumental bed sits underneath, ducked so it never fights the voice.
+//
+//   node marketing/talking-head/bin/reel.mjs ~/Desktop/YC.mov \
+//     --out marketing/talking-head/out/yc-reel.mp4 --kit felt
+//
+//   --kit felt|brush|wood|eight0eight|pulse   bed instrumentation (jingle.mjs)
+//   --bedgain 0.42        how loud the bed sits under the voice
+//   --accent "#3dff88"    karaoke fill color
+//   --zoom 1.0            1.0 = full-height crop, the sharpest framing
+//   --sync auto|<ms>      A/V offset correction; see below
+//   --title Name          text climbing the side stamps
+//   --no-stamps           drop the pals chrome
+//   --no-bed              speech only
+//   --no-grade            skip the color polish
+//   --seconds N           render only the first N seconds (for quick looks)
+//
+// LIP SYNC. Consumer captures bake in an A/V offset, and this one does: the YC
+// clip runs its picture about 100ms behind its sound, which reads as dubbing the
+// moment you put captions under it. `--sync auto` measures the offset by
+// cross-correlating mouth motion against the audio envelope (see lib/av-sync.mjs)
+// and holds the sound back to meet the lips. Pass a number of ms to override, or
+// 0 to leave the footage alone.
+//
+// The correction is applied to the AUDIO, not the video, and that is deliberate:
+// video can only be shifted in whole frames (33ms at a time here), so correcting
+// on that side can never land closer than half a frame — measure 100ms and you
+// must choose between 3 frames and 4. Audio shifts by samples. So the picture is
+// left exactly as shot and the sound is delayed onto it, which also keeps every
+// frame of the clip instead of eating its head.
+//
+// Three constraints from the house drove the rest, and they're worth knowing
+// before you edit this:
+//
+//   · This ffmpeg has no drawtext and no libass. Text cannot be burned in by
+//     ffmpeg at all. Glyphs are baked to PNGs by ImageMagick and composited
+//     per-frame onto a canvas — the same detour captions-train.mjs and
+//     stamp-reel.mjs take, and the reason preview-shared.mjs exists.
+//   · The crop is done on the canvas, not by ffmpeg's `crop` filter, because we
+//     want a smoothed sub-pixel pan (see reframe.mjs) and a filter expression
+//     can't hold state between frames.
+//   · Reels bring their own furniture — no progress bar, no timecode. That rule
+//     is in kidlisp-reels/SCORE.md and av-reels/README.md both.
+
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { createCanvas, createImageData } from "canvas";
+
+import { faceTrack, buildReframer } from "../../lib/reframe.mjs";
+import { measureAvOffset } from "../../lib/av-sync.mjs";
+import { wordsFromWhisper } from "../../lib/words.mjs";
+import { makeSideStamps, makeChromaGlyphs, dayglow } from "../../lib/side-stamps.mjs";
+import {
+  magickRenderText, spawnFFmpegEncode, decodeAudioMono, computeRmsEnvelope,
+} from "../../../pop/lib/preview-shared.mjs";
+import { renderBed, renderSineBed } from "../../podcast/bin/jingle.mjs";
+
+const W = 1080;
+const H = 1920;
+const FPS = 30;
+
+// Plain Arial Bold, per @jeffrey — the geometric YWFT face is AC's, but captions
+// on a person's face want to disappear into legibility, not perform. The .ttc
+// collections resolve to their Regular weight, so we ask for the bold file.
+const CAP_FONT = [
+  "/System/Library/Fonts/Supplemental/Arial Bold.ttf",
+  "/System/Library/Fonts/HelveticaNeue.ttc",
+  "/System/Library/Fonts/Helvetica.ttc",
+].find(existsSync) || "Helvetica";
+
+// Type is baked large and drawn small — a 120px glyph scaled down to 56 stays
+// crisp, where a 56px glyph scaled up would not.
+//
+// Captions here sit on a moving person in a patterned shirt, so they carry both
+// an outline and a hard drop shadow. Either alone loses against the footage: the
+// shadow dies on dark cloth, the outline dies on the black mic. Together the
+// glyph always has an edge somewhere.
+const CAP = {
+  renderPx: 150,
+  drawPx: 78, // big — the captions ARE the composition now, sitting over the face
+  // Wide, since they no longer dodge the shirt patch — they sit up on the face,
+  // between the side-stamp columns.
+  maxLineW: 800,
+  wordGap: 20,
+  bandY: 0.46, // up on the face, near center — over him, where the eye already is
+  lead: 0.12, // let a phrase arrive a beat before its first word lands
+  tail: 0.30, // and linger a beat after its last one
+  cream: "#fcf7c5",
+  shadow: "#000000",
+  shadowSpec: "100x0+6+7", // hard offset, no blur — captions-train's look
+  stroke: "#000000",
+  strokeWidth: 6,
+};
+
+// A gentle polish, not a rescue: the source measures near-neutral (a mild warm
+// cast, sane brightness), so this only firms up the contrast and lifts the
+// saturation enough to survive a phone screen.
+const GRADE = "eq=contrast=1.07:saturation=1.12:brightness=0.012";
+
+// Sharpening happens AFTER the canvas has blown 405×720 up to 1080×1920, because
+// sharpening before an upscale just gives you bigger, softer halos. Denoise runs
+// first: a 2018 webcam is grainy, and an unsharp mask with no denoise in front of
+// it is a grain amplifier.
+//
+// `cas` is contrast-adaptive — it finds edges and leaves flat areas alone, which
+// is exactly what upscaled footage needs and exactly what unsharp gets wrong
+// (unsharp haloes a cheek as eagerly as it sharpens an eye). It does the lifting;
+// unsharp only adds a little bite behind it.
+//
+// None of this invents detail. There are 405×720 real pixels here and no filter
+// makes more — for actual new detail you need a learned upscaler (see --fal).
+const CRISP = "hqdn3d=1.5:1.2:6:6,cas=strength=0.65,unsharp=5:5:0.45:5:5:0.0";
+
+// The tape starts mid-word — there is no runway before "My", the recording began
+// on the M. Nothing downstream can restore what was never captured, so instead we
+// give the ear a moment to arrive: hold the first frame, let the bed come up, and
+// fade the voice in so its clipped attack reads as a start rather than a splice.
+let LEAD_FRAMES = 15; // exactly 0.5s at 30fps — keep this in FRAMES; 0 in song mode
+const VOICE_FADE = 0.09;
+
+// He is quiet, close-mic'd, and in a hard room. In order: lose the rumble, lose
+// the hiss, tame the S's the presence boost is about to expose, scoop the boxy
+// 250Hz the wall put there, lift the 3kHz where consonants live, add a little
+// air, then even out the level so the quiet half of a sentence lands as hard as
+// the loud half.
+const VOICE_CHAIN = [
+  "highpass=f=85",
+  "afftdn=nf=-25",
+  "deesser=i=0.35",
+  "equalizer=f=250:t=q:w=1.2:g=-3",
+  "equalizer=f=3200:t=q:w=1.4:g=3.5",
+  "treble=g=2.5:f=8500",
+  "acompressor=threshold=-20dB:ratio=3:attack=8:release=200:makeup=2",
+  "loudnorm=I=-16:TP=-1.5:LRA=9",
+].join(",");
+
+// ── args ────────────────────────────────────────────────────────────────────
+const argv = process.argv.slice(2);
+const flag = (name, dflt = null) => {
+  const i = argv.indexOf(`--${name}`);
+  return i >= 0 && argv[i + 1] && !argv[i + 1].startsWith("--") ? argv[i + 1] : dflt;
+};
+const has = (name) => argv.includes(`--${name}`);
+
+const SRC = resolve(argv.find((a) => !a.startsWith("--")) || "");
+if (!SRC || !existsSync(SRC)) {
+  console.error("usage: reel.mjs <video> [--out path] [--audio-from orig.mov] [--kit felt] [--sync auto|ms]");
+  process.exit(2);
+}
+
+// Video and audio can come from different files. That's the whole point of the
+// fal upscale path: Topaz gives back a sharper PICTURE but re-encodes the sound,
+// so `--audio-from` keeps the picture from the upscaled clip and the audio (and
+// the clip's real 2018 date) from the untouched original. Default: same file.
+const AUDIO_SRC = resolve(flag("audio-from", SRC));
+if (!existsSync(AUDIO_SRC)) {
+  console.error(`--audio-from not found: ${AUDIO_SRC}`);
+  process.exit(2);
+}
+
+const slug = basename(flag("audio-from", SRC)).replace(/\.[^.]+$/, "").toLowerCase();
+const OUT_DIR = join(dirname(new URL(import.meta.url).pathname), "..", "out");
+const OUT = resolve(flag("out", join(OUT_DIR, `${slug}-reel.mp4`)));
+const WORK = join(OUT_DIR, `.work-${slug}`);
+const KIT = flag("kit", "felt");
+const BED_GAIN = parseFloat(flag("bedgain", "0.42"));
+const ACCENT = flag("accent", "#3dff88");
+const ZOOM = parseFloat(flag("zoom", "1.0"));
+const STAMP_TITLE = flag("title", "prompt.AC");
+const SYNC_ARG = flag("sync", "auto");
+const LIMIT = flag("seconds") ? parseFloat(flag("seconds")) : null;
+const USE_BED = !has("no-bed");
+const USE_STAMPS = !has("no-stamps");
+const USE_GRADE = !has("no-grade");
+
+// A learned upscaler (Topaz) rebuilds the background and hair beautifully but
+// waxes the skin — it reads real edges as detail and smooth skin as noise to
+// remove, so the face comes back soft while everything around it sharpens. When
+// the video is upscaled and the original is on hand (--audio-from), we blend the
+// ORIGINAL's face — real pores and grain — back over just the face region,
+// feathered, keeping the upscale everywhere else. `--face 0` disables it.
+const FACE_RESTORE = SRC !== AUDIO_SRC && !flag("song") && parseFloat(flag("face", "1.0")) > 0;
+const FACE_STRENGTH = Math.min(1, Math.max(0, parseFloat(flag("face", "1.0"))));
+
+// SONG MODE. When the picture is a finished piece (a warped sing-along) and the
+// audio is a finished mix, none of the spoken-take machinery applies — no voice
+// conditioning, no bed, no A/V-sync guess, no held lead-in. `--song <mix.wav>`
+// uses the audio as-is and `--words <sung.json>` times the captions to it. The
+// crop, karaoke captions, stamps and timer are all still wanted, so only the
+// audio front-end is bypassed.
+const SONG = flag("song") ? resolve(flag("song")) : null;
+const WORDS_FILE = flag("words") ? resolve(flag("words")) : null;
+if (SONG) LEAD_FRAMES = 0; // the warp already timed the picture; no runway needed
+
+mkdirSync(WORK, { recursive: true });
+mkdirSync(dirname(OUT), { recursive: true });
+
+const sh = (cmd, args) => {
+  const r = spawnSync(cmd, args, { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" });
+  if (r.status !== 0) throw new Error(`${cmd} failed: ${r.stderr?.slice(0, 400)}`);
+  return r.stdout;
+};
+
+// ── 1. face track ───────────────────────────────────────────────────────────
+console.log("· tracking face (Vision)");
+const track = faceTrack(SRC, { fps: 30, cachePath: join(WORK, "track.json") });
+console.log(`  ${track.samples.length} samples, ${
+  ((track.samples.length / Math.round(track.duration * 30)) * 100).toFixed(0)}% detection`);
+
+// ── 2. measure the A/V offset ───────────────────────────────────────────────
+// Do this before anything else consumes the timeline: everything downstream —
+// the captions, the crop, the mix — assumes picture and sound already agree.
+let SYNC_MS = 0;
+if (SONG) {
+  // the song's audio and its warped picture already share a clock
+} else if (SYNC_ARG === "auto") {
+  console.log("· measuring A/V offset (mouth motion × audio envelope)");
+  const { offsetMs, confidence } = await measureAvOffset(SRC, { track });
+  if (confidence < 1.15) {
+    console.log(`  weak correlation (${confidence.toFixed(2)}) — leaving sync alone`);
+  } else if (offsetMs > 0) {
+    SYNC_MS = offsetMs;
+    console.log(`  picture is ${offsetMs}ms late (confidence ${confidence.toFixed(2)}) — holding sound back to meet it`);
+  } else {
+    console.log(`  sound is ${-offsetMs}ms late (confidence ${confidence.toFixed(2)}) — leaving alone`);
+  }
+} else {
+  SYNC_MS = Math.max(0, parseFloat(SYNC_ARG));
+  if (SYNC_MS) console.log(`· delaying sound ${SYNC_MS}ms (manual)`);
+}
+
+// Trust the frame COUNT, not the container's duration. They disagree — this clip
+// holds 1773 frames (59.10s at 30fps) but declares itself 59.12s long — and if
+// you cut the audio to the declared duration you end up with 20ms of sound after
+// the last picture, which a player shows as a black flash at the end.
+const nbFrames = parseInt(
+  sh("ffprobe", ["-v", "error", "-select_streams", "v",
+    "-show_entries", "stream=nb_frames", "-of", "csv=p=0", SRC]).trim(),
+  10,
+);
+const FULL = Number.isFinite(nbFrames) && nbFrames > 0 ? nbFrames / FPS : track.duration;
+const DUR = LIMIT ? Math.min(LIMIT, FULL) : FULL;
+
+// ── 3. transcribe ───────────────────────────────────────────────────────────
+// whisper at token granularity (-ml 1); words.mjs stitches the pieces back up.
+const VOICE = join(WORK, "voice.wav");
+const MONO = join(WORK, "mono16k.wav");
+const WHISPER_JSON = join(WORK, "whisper.json");
+const MODEL = resolve("recap/models/ggml-large-v3-turbo.bin");
+
+let words;
+if (WORDS_FILE) {
+  // Caption timings supplied (the sung word alignment) — accept either a bare
+  // word array or an alignment doc with a `.words` array.
+  const doc = JSON.parse(readFileSync(WORDS_FILE, "utf8"));
+  const arr = Array.isArray(doc) ? doc : doc.words;
+  words = arr.map((w) => ({ text: w.text, fromMs: w.fromMs ?? w.from, toMs: w.toMs ?? w.to }));
+  console.log(`· captions from ${basename(WORDS_FILE)} — ${words.length} words`);
+} else {
+  // The voice is cleaned and levelled before anything else touches it. A 2018
+  // webcam recording is quiet, uneven, and full of room tone, and the bed's duck
+  // (below) keys off this signal — feed it the raw audio and the compressor
+  // triggers on the hiss, pinning the bed down for the whole minute so you never
+  // hear it.
+  console.log("· extracting + conditioning voice");
+  sh("ffmpeg", ["-v", "error", "-y", "-i", AUDIO_SRC,
+    "-af", VOICE_CHAIN,
+    "-ac", "2", "-ar", "44100", "-c:a", "pcm_s16le", VOICE]);
+  sh("ffmpeg", ["-v", "error", "-y", "-i", AUDIO_SRC, "-ac", "1", "-ar", "16000", MONO]);
+
+  if (!existsSync(WHISPER_JSON)) {
+    console.log("· transcribing (whisper)");
+    sh("whisper-cli", [
+      "-m", MODEL, "-f", MONO, "-oj", "-ojf", "-ml", "1", "-l", "en",
+      "-of", WHISPER_JSON.replace(/\.json$/, ""),
+    ]);
+  }
+  words = wordsFromWhisper(WHISPER_JSON);
+  console.log(`  ${words.length} words`);
+}
+
+const at = buildReframer(track, { w: W, h: H, fps: FPS, zoom: ZOOM });
+
+// ── 4. bed + mix ────────────────────────────────────────────────────────────
+// The voice is pushed later by two separate amounts, and it matters that they're
+// distinct: LEAD is an editorial runway (a held frame, so the ear can arrive
+// before the clipped first word), while SYNC is the measured A/V error. `adelay`
+// moves the voice by whole samples, so the lips can be met exactly rather than to
+// the nearest frame — video can only shift in whole frames, audio cannot.
+//
+// LEAD is derived from LEAD_FRAMES, never the other way round. The held picture
+// can only ever be an integer number of frames, so the sound must be delayed by
+// exactly that many — deriving one from a rounded copy of the other is how a
+// silent 33ms of drift gets in.
+const LEAD = LEAD_FRAMES / FPS;
+const voiceStart = LEAD + SYNC_MS / 1000;
+const delayMs = Math.round(voiceStart * 1000);
+const TOTAL = LEAD + DUR;
+
+// Fade the truncated attack in, so it reads as a start rather than a splice.
+const cond = `adelay=${delayMs}|${delayMs},afade=t=in:st=${voiceStart.toFixed(3)}:d=${VOICE_FADE}`;
+
+const AUDIO = SONG || join(WORK, "final.wav");
+if (SONG) {
+  // The audio is finished — use it as-is, and the captions already carry the
+  // right times (LEAD is 0 here, so the shift below is a no-op).
+  console.log(`· song audio: ${basename(SONG)}`);
+} else if (USE_BED) {
+  const BED = join(WORK, "bed.wav");
+  if (KIT === "sine") {
+    console.log("· scoring bed (sine pad)");
+    renderSineBed(TOTAL + 1, BED);
+  } else {
+    console.log(`· scoring bed (${KIT} @ 72bpm)`);
+    renderBed(TOTAL + 1, BED, { kit: KIT });
+  }
+
+  console.log("· mixing (sidechain duck)");
+  // threshold 0.05 (≈ -26dB), not produce.mjs's 0.02: now that the voice is
+  // normalized its silences are genuinely silent, and a higher threshold means
+  // only real speech pushes the bed down. The bed swells back in every gap —
+  // including the lead-in, where it plays alone and covers the runway.
+  // Master to -14 LUFS last — phones play the reel, not a studio monitor.
+  // asplit is NOT optional. The voice is needed twice — once as the key that
+  // tells the compressor when to duck, and once as the thing you actually hear —
+  // and a filter label in ffmpeg feeds exactly ONE consumer. Naming [vx] in two
+  // places does not fan it out and does not error; it silently produces a mix
+  // with the voice in it TWICE, once delayed and once not. That is invisible when
+  // the delay is 95ms (it just sounds a bit smeared) and unmissable at 595ms,
+  // where the words arrive half a second before the lips.
+  sh("ffmpeg", [
+    "-v", "error", "-y", "-i", VOICE, "-i", BED,
+    "-filter_complex",
+    `[0:a]${cond},apad,asplit=2[vx][vkey];` +
+      `[1:a]volume=${BED_GAIN},aphaser=type=t:speed=0.25:decay=0.4[bedfx];` +
+      `[bedfx][vkey]sidechaincompress=threshold=0.05:ratio=6:attack=6:release=380[bd];` +
+      `[vx][bd]amix=inputs=2:duration=longest:normalize=0[mix];` +
+      `[mix]atrim=0:${TOTAL},loudnorm=I=-14:TP=-1:LRA=11[out]`,
+    "-map", "[out]", "-ac", "2", "-c:a", "pcm_s16le", AUDIO,
+  ]);
+} else {
+  sh("ffmpeg", ["-v", "error", "-y", "-i", VOICE,
+    "-af", `${cond},atrim=0:${TOTAL}`, "-ac", "2", "-c:a", "pcm_s16le", AUDIO]);
+}
+
+// The captions ride the voice, so they move with it.
+for (const w of words) {
+  w.fromMs += delayMs;
+  w.toMs += delayMs;
+}
+
+// ── 5. bake the glyphs ──────────────────────────────────────────────────────
+// Two PNGs per word: cream, and accent. The karaoke fill is the accent one
+// revealed left-to-right by a clip rect, so both must register pixel-exactly.
+console.log(`· baking glyphs (${basename(CAP_FONT)})`);
+const GLYPHS = join(WORK, "glyphs");
+mkdirSync(GLYPHS, { recursive: true });
+
+const scale = CAP.drawPx / CAP.renderPx;
+for (const [i, w] of words.entries()) {
+  const safe = String(i).padStart(3, "0");
+  // Identical geometry for both, so the accent registers pixel-exactly over the
+  // cream when the fill sweeps across it — same stroke, same shadow, same size.
+  const shared = {
+    ptSize: CAP.renderPx,
+    font: CAP_FONT,
+    shadow: CAP.shadow,
+    shadowSpec: CAP.shadowSpec,
+    stroke: CAP.stroke,
+    strokeWidth: CAP.strokeWidth,
+  };
+  w.imgCream = await magickRenderText(w.text, {
+    ...shared, fill: CAP.cream, outPath: join(GLYPHS, `${safe}-c.png`),
+  });
+  w.imgAccent = await magickRenderText(w.text, {
+    ...shared, fill: ACCENT, outPath: join(GLYPHS, `${safe}-a.png`),
+  });
+  w.dw = w.imgCream.width * scale;
+  w.dh = w.imgCream.height * scale;
+  // Whisper read the *audio*, which is the thing we trust; the sound was held
+  // back to meet the lips, so the words move with it.
+  w.from = w.fromMs / 1000;
+  w.to = w.toMs / 1000;
+}
+
+// ── the clock ───────────────────────────────────────────────────────────────
+// Not a playback timecode — the clip's own wall clock, running. It starts at the
+// moment the tape was made and ticks forward in real time as the reel plays, so
+// the seconds ticking past are the seconds he actually sat there in 2018.
+//
+// It rides the side stamps: instead of a fixed word climbing the margins, the
+// live readout does, in YWFT with the same bounce and chroma fringe as the pals.
+// Built from a glyph ATLAS — a running clock passes through some sixty distinct
+// strings, which would be hundreds of magick calls, but is only ever made of
+// thirteen characters. From the ORIGINAL — the upscale re-stamps today's date.
+const created = sh("ffprobe", ["-v", "error", "-show_entries", "format_tags=creation_time",
+  "-of", "csv=p=0", AUDIO_SRC]).trim();
+// UTC, as the container recorded it. Reading it in local time would restamp an
+// eight-year-old tape with wherever the rendering machine happens to be.
+const t0 = created ? new Date(created) : null;
+
+// Clock time is SOURCE time — it should read the same second whether or not the
+// reel opens on a held frame, so the caller passes srcT, not reel t.
+const clockText = (srcT) => {
+  const d = new Date(t0.getTime() + srcT * 1000);
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getUTCFullYear()}.${p(d.getUTCMonth() + 1)}.${p(d.getUTCDate())} ` +
+    `${p(d.getUTCHours())}:${p(d.getUTCMinutes())}:${p(d.getUTCSeconds())}`;
+};
+if (t0) console.log(`  clock starts ${clockText(0)}`);
+
+// ── 6. group into phrases ───────────────────────────────────────────────────
+// A phrase is as many words as fit on one line. It appears when its first word
+// is spoken and leaves when its last one ends, so the eye never tracks a line
+// that has already gone quiet.
+const phrases = [];
+let cur = [];
+let curW = 0;
+for (const w of words) {
+  const add = w.dw + (cur.length ? CAP.wordGap : 0);
+  if (cur.length && curW + add > CAP.maxLineW) {
+    phrases.push(cur);
+    cur = [];
+    curW = 0;
+  }
+  cur.push(w);
+  curW += w.dw + (cur.length > 1 ? CAP.wordGap : 0);
+}
+if (cur.length) phrases.push(cur);
+
+for (const p of phrases) {
+  p.from = p[0].from;
+  p.to = p[p.length - 1].to;
+  p.width = p.reduce((s, w, i) => s + w.dw + (i ? CAP.wordGap : 0), 0);
+}
+console.log(`  ${phrases.length} phrases`);
+
+// The phrase on screen is the last one to have *started*, never merely the first
+// one that matches. Consecutive phrases overlap — one is still fading out as the
+// next leads in — and matching first-wins would let the dying phrase hold the
+// screen while the incoming line never appeared at all.
+const phraseAt = (t) => {
+  let best = null;
+  for (const p of phrases) {
+    if (t < p.from - CAP.lead) break; // phrases are in time order
+    best = p;
+  }
+  if (!best || t > best.to + CAP.tail) return null;
+  return best;
+};
+
+// ── 7. render ───────────────────────────────────────────────────────────────
+const SRC_FRAMES = Math.round(DUR * FPS);
+const FRAMES = LEAD_FRAMES + SRC_FRAMES;
+const SRC_W = track.srcW;
+const SRC_H = track.srcH;
+const FRAME_BYTES = SRC_W * SRC_H * 4;
+
+// The stamps' glow rides the finished mix, so they pulse with his voice rather
+// than on a timer.
+const { audio, sr } = decodeAudioMono(AUDIO);
+const envelope = computeRmsEnvelope(audio, sr, FPS, TOTAL);
+const envAt = (f) => envelope[Math.min(envelope.length - 1, Math.max(0, f))] || 0;
+
+// The side stamps carry the /pop look: the title word climbs the columns beside
+// the pals, exactly as every other AC reel. The clock is separate furniture, up
+// in the corner (below) — the two don't share a home.
+const stamps = await makeSideStamps({
+  w: W, h: H, fps: FPS, frames: FRAMES,
+  assetsDir: join(WORK, "stamps"),
+  title: STAMP_TITLE,
+});
+
+// The clock's own glyph atlas, drawn top-left each frame (see the loop).
+const clockAtlas = t0
+  ? await makeChromaGlyphs({ charset: "0123456789.: ", ptSize: 128, assetsDir: join(WORK, "clock") })
+  : null;
+const CLOCK_SCALE = 0.42; // a little timer, not a headline
+const CLOCK_KERN = 1;
+const CLOCK_MARGIN = 40; // gap from the right and bottom edges
+const CLOCK_BASELINE = H - 70; // vertical center of the timer, near the bottom
+
+console.log(`· rendering ${FRAMES} frames → ${basename(OUT)}`);
+
+// The picture is played exactly as shot — the sync correction was spent on the
+// audio, where it could be exact.
+const dec = spawn("ffmpeg", [
+  "-v", "error", "-i", SRC,
+  "-f", "rawvideo", "-pix_fmt", "rgba",
+  "-vf", USE_GRADE ? `fps=${FPS},${GRADE}` : `fps=${FPS}`,
+  "-t", String(DUR), "-",
+], { stdio: ["ignore", "pipe", "inherit"] });
+
+// The second decoder — the original, for its real face texture. Same grade so
+// the blended skin matches the base's color, same fps so frame N lines up with
+// frame N of the upscale (Topaz preserved the 1:1 frame timing).
+let ORIG_W = 0;
+let ORIG_H = 0;
+let ORIG_BYTES = 0;
+let decO = null;
+if (FACE_RESTORE) {
+  [ORIG_W, ORIG_H] = sh("ffprobe", ["-v", "error", "-select_streams", "v",
+    "-show_entries", "stream=width,height", "-of", "csv=p=0", AUDIO_SRC])
+    .trim().split(",").map(Number);
+  ORIG_BYTES = ORIG_W * ORIG_H * 4;
+  decO = spawn("ffmpeg", [
+    "-v", "error", "-i", AUDIO_SRC,
+    "-f", "rawvideo", "-pix_fmt", "rgba",
+    "-vf", USE_GRADE ? `fps=${FPS},${GRADE}` : `fps=${FPS}`,
+    "-t", String(DUR), "-",
+  ], { stdio: ["ignore", "pipe", "inherit"] });
+  console.log(`  face-restore: original ${ORIG_W}×${ORIG_H} → face @ ${FACE_STRENGTH}`);
+}
+
+// Not preview-shared's spawnFFmpegEncode — that one takes no filters, and the
+// sharpening has to happen here, on the far side of the upscale.
+const enc = spawn("ffmpeg", [
+  "-hide_banner", "-loglevel", "error", "-y",
+  "-f", "rawvideo", "-pix_fmt", "bgra", // node-canvas raw is native byte order
+  "-s", `${W}x${H}`, "-r", String(FPS), "-i", "-",
+  "-i", AUDIO,
+  ...(USE_GRADE ? ["-vf", CRISP] : []),
+  "-c:v", "libx264", "-preset", "slow", "-crf", "16",
+  "-c:a", "aac", "-b:a", "192k",
+  "-pix_fmt", "yuv420p", "-shortest", "-movflags", "+faststart",
+  OUT,
+], { stdio: ["pipe", "inherit", "inherit"] });
+
+const src = createCanvas(SRC_W, SRC_H);
+const sctx = src.getContext("2d");
+const dst = createCanvas(W, H);
+const ctx = dst.getContext("2d");
+ctx.imageSmoothingEnabled = true;
+ctx.imageSmoothingQuality = "high"; // it's a 2.67× upscale; it needs the help
+
+// Face-restore scratch: the original frame, and an offscreen where the original
+// face is feathered before it's laid over the base.
+const srcO = FACE_RESTORE ? createCanvas(ORIG_W, ORIG_H) : null;
+const sctxO = srcO ? srcO.getContext("2d") : null;
+const faceCv = FACE_RESTORE ? createCanvas(W, H) : null;
+const faceCtx = faceCv ? faceCv.getContext("2d") : null;
+if (faceCtx) {
+  faceCtx.imageSmoothingEnabled = true;
+  faceCtx.imageSmoothingQuality = "high";
+}
+const O2U = FACE_RESTORE ? ORIG_W / SRC_W : 1; // upscaled coords → original coords
+
+// The face box (upscaled coords) for a source time, smoothed against jitter and
+// grown past Vision's tight crop to take in forehead and jaw — the parts that
+// went soft, not just the features.
+const faceSamples = track.samples;
+const faceBox = (st) => {
+  let s = faceSamples[0];
+  for (const c of faceSamples) { if (c.t > st) break; s = c; }
+  const gx = s.w * 0.28;
+  const gy = s.h * 0.22;
+  return { x: s.x - gx, y: s.y - gy, w: s.w + gx * 2, h: s.h + gy * 2 };
+};
+
+let frame = 0;
+
+// A 16×16 thumbnail of the cropped frame, which is plenty to ask "what color is
+// this shot." We take the hue of the most *colorful* pixels rather than the mean:
+// average a face, a blue shirt and a green wall together and you get mud, and mud
+// has no hue to push.
+const SAMP = 16;
+const samp = createCanvas(SAMP, SAMP);
+const sampCtx = samp.getContext("2d");
+let hueR = 0;
+let hueG = 0;
+let hueB = 0; // EMA'd, or the tint strobes frame to frame
+
+const sampleTint = () => {
+  const d = sampCtx.getImageData(0, 0, SAMP, SAMP).data;
+  let wr = 0;
+  let wg = 0;
+  let wb = 0;
+  let wsum = 0;
+  for (let i = 0; i < d.length; i += 4) {
+    const r = d[i];
+    const g = d[i + 1];
+    const b = d[i + 2];
+    const sat = Math.max(r, g, b) - Math.min(r, g, b); // colorfulness = weight
+    wr += r * sat;
+    wg += g * sat;
+    wb += b * sat;
+    wsum += sat;
+  }
+  if (wsum < 1) return null;
+  const k = 0.06; // slow — the chrome drifts through the shot's palette
+  hueR += (wr / wsum - hueR) * k;
+  hueG += (wg / wsum - hueG) * k;
+  hueB += (wb / wsum - hueB) * k;
+  return {
+    core: dayglow([hueR, hueG, hueB]),
+    hi: dayglow([hueR, hueG, hueB], { value: 255 }).map((c) => Math.min(255, c + 90)),
+  };
+};
+
+const write = (buf) =>
+  new Promise((res) => (enc.stdin.write(buf) ? res() : enc.stdin.once("drain", res)));
+
+// `frame` is reel time. The footage is DUR long but the reel is LEAD longer, so
+// anything that reads the source — the camera, the pixels — asks in SOURCE time,
+// while everything laid on top (captions, stamps, clock) asks in reel time. The
+// sound was delayed by exactly LEAD_FRAMES too, which is what keeps the lips on
+// the words across the join.
+const drawFrame = async (rgba, rgbaO) => {
+  const t = frame / FPS;
+  const srcT = Math.max(0, t - LEAD);
+
+  sctx.putImageData(createImageData(new Uint8ClampedArray(rgba), SRC_W, SRC_H), 0, 0);
+
+  const { sx, sy, sw, sh: cropH } = at(srcT);
+  ctx.drawImage(src, sx, sy, sw, cropH, 0, 0, W, H);
+
+  // Face restore: lay the original's real skin over the waxed upscale, but only
+  // inside the face and only where it's needed. The blend fades from strong at
+  // the center to nothing at the box edge (a radial mask), so there is no seam
+  // between restored skin and upscaled jaw/hair.
+  if (FACE_RESTORE && rgbaO) {
+    sctxO.putImageData(createImageData(new Uint8ClampedArray(rgbaO), ORIG_W, ORIG_H), 0, 0);
+    const fb = faceBox(srcT);
+    // face box (upscaled coords) → output coords via the same crop mapping
+    const ox = ((fb.x - sx) / sw) * W;
+    const oy = ((fb.y - sy) / cropH) * H;
+    const ow = (fb.w / sw) * W;
+    const oh = (fb.h / cropH) * H;
+
+    if (ow > 2 && oh > 2) {
+      faceCtx.clearRect(0, 0, W, H);
+      // the original's matching region, upscaled to sit exactly over the base
+      faceCtx.drawImage(
+        srcO, fb.x * O2U, fb.y * O2U, fb.w * O2U, fb.h * O2U,
+        ox, oy, ow, oh,
+      );
+      // feather to transparent at the edges
+      const cx = ox + ow / 2;
+      const cy = oy + oh / 2;
+      // A big full-strength core, feathering only near the very edge — so most of
+      // the face is real texture and only the rim crossfades into the upscale.
+      const grad = faceCtx.createRadialGradient(cx, cy, Math.min(ow, oh) * 0.44, cx, cy, Math.max(ow, oh) * 0.68);
+      grad.addColorStop(0, "rgba(0,0,0,1)");
+      grad.addColorStop(1, "rgba(0,0,0,0)");
+      faceCtx.globalCompositeOperation = "destination-in";
+      faceCtx.fillStyle = grad;
+      faceCtx.fillRect(ox - ow, oy - oh, ow * 3, oh * 3);
+      faceCtx.globalCompositeOperation = "source-over";
+
+      ctx.globalAlpha = FACE_STRENGTH;
+      ctx.drawImage(faceCv, 0, 0);
+      ctx.globalAlpha = 1;
+    }
+  }
+
+  sampCtx.drawImage(src, sx, sy, sw, cropH, 0, 0, SAMP, SAMP);
+  const tint = sampleTint();
+
+  const p = phraseAt(t);
+  if (p) {
+    // Fade in over the lead, out over the tail — a hard cut on a caption reads
+    // as a glitch at 30fps.
+    const fade = Math.min(1, (t - (p.from - CAP.lead)) / 0.18, (p.to + CAP.tail - t) / 0.28);
+    let x = (W - p.width) / 2;
+    const y = H * CAP.bandY;
+
+    for (const w of p) {
+      const spoken = Math.min(1, Math.max(0, (t - w.from) / Math.max(0.001, w.to - w.from)));
+      // Every word in the phrase stays legible; the accent sweep — not opacity —
+      // is what tells you where the voice is. Dimming the not-yet-spoken words
+      // enough to be visible on a flat cover leaves them invisible on skin.
+      ctx.globalAlpha = Math.max(0, fade) * (spoken > 0 ? 1 : 0.86);
+      ctx.drawImage(w.imgCream, x, y, w.dw, w.dh);
+
+      if (spoken > 0) {
+        ctx.save();
+        ctx.beginPath();
+        ctx.rect(x, y, w.dw * spoken, w.dh); // the fill sweeps with the voice
+        ctx.clip();
+        ctx.drawImage(w.imgAccent, x, y, w.dw, w.dh);
+        ctx.restore();
+      }
+      x += w.dw + CAP.wordGap;
+    }
+    ctx.globalAlpha = 1;
+  }
+
+  if (USE_STAMPS) stamps.draw(ctx, t, envAt(frame), tint);
+
+  // A little timer, bottom-right, ticking in real 2018 seconds — SOURCE time, so
+  // it holds on the opening frame and starts when the footage does. Right-aligned
+  // (measured, then laid out backward from the right margin) so its right edge
+  // stays pinned as the digits change width. Same chroma fringe as the stamps.
+  if (clockAtlas) {
+    const text = clockText(srcT);
+    const env = envAt(frame);
+    const col = tint?.core || [235, 240, 250];
+    const colHi = tint?.hi || [255, 255, 255];
+    const width = clockAtlas.measure(text, CLOCK_SCALE, CLOCK_KERN);
+    let x = W - CLOCK_MARGIN - width;
+    for (const [i, ch] of [...text].entries()) {
+      const g = clockAtlas.glyphs.get(ch);
+      if (!g) {
+        x += clockAtlas.spaceW * CLOCK_SCALE + CLOCK_KERN;
+        continue;
+      }
+      const dw = g.width * CLOCK_SCALE;
+      const dh = g.height * CLOCK_SCALE;
+      const ph = t * 1.6 - i * 0.16;
+      const bobY = 2 * Math.sin(ph * 2);
+      const swell = 1 + 0.05 * Math.sin(ph * 2 + 0.6) * (0.5 + env);
+      ctx.save();
+      ctx.translate(x + dw / 2, CLOCK_BASELINE + bobY);
+      ctx.scale(swell, swell);
+      stamps.drawChroma(ctx, stamps.tintGlyph, g, g, -dw / 2, -dh / 2, dw, dh, env, col, colHi);
+      ctx.restore();
+      x += dw + CLOCK_KERN;
+    }
+  }
+
+  await write(dst.toBuffer("raw"));
+  frame += 1;
+  if (frame % 150 === 0) process.stdout.write(`\r  ${frame}/${FRAMES}`);
+};
+
+// Pull one fixed-size frame at a time from a decoder's byte stream. With two
+// decoders (upscale + original) they have to advance in lockstep, so an on-demand
+// reader is cleaner than accumulating each stream's chunks independently.
+const makeReader = (stream, bytes) => {
+  const it = stream[Symbol.asyncIterator]();
+  let buf = Buffer.alloc(0);
+  let done = false;
+  return async () => {
+    while (buf.length < bytes && !done) {
+      const { value, done: d } = await it.next();
+      if (d) { done = true; break; }
+      buf = buf.length ? Buffer.concat([buf, value]) : value;
+    }
+    if (buf.length < bytes) return null;
+    const f = buf.subarray(0, bytes);
+    buf = buf.subarray(bytes);
+    return f;
+  };
+};
+
+const nextUp = makeReader(dec.stdout, FRAME_BYTES);
+const nextOrig = decO ? makeReader(decO.stdout, ORIG_BYTES) : async () => null;
+
+for (let sf = 0; sf < SRC_FRAMES; sf += 1) {
+  const up = await nextUp();
+  if (!up) break;
+  const orig = await nextOrig();
+
+  // Open on a held frame — the runway the recording never gave us. Both decoders
+  // are held on their first frame together so the face restore stays aligned.
+  if (sf === 0) {
+    for (let i = 0; i < LEAD_FRAMES; i += 1) await drawFrame(up, orig);
+  }
+  await drawFrame(up, orig);
+}
+
+enc.stdin.end();
+await new Promise((res) => enc.on("close", res));
+process.stdout.write(`\r  ${frame}/${FRAMES}\n`);
+
+rmSync(GLYPHS, { recursive: true, force: true });
+console.log(`✓ ${OUT}`);
diff --git a/marketing/talking-head/bin/vertical.mjs b/marketing/talking-head/bin/vertical.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/talking-head/bin/vertical.mjs
@@ -0,0 +1,91 @@
+// vertical.mjs — face-tracked 9:16 crop of any clip, audio kept.
+//
+// The song video comes out 16:9 (it's warped original footage). This turns it
+// vertical the same way reel.mjs does: Vision finds the face every frame,
+// reframe.mjs smooths that into a calm pan, and we crop a 1080×1920 window that
+// follows him. The audio (the whole song) rides along untouched.
+//
+//   node vertical.mjs <video> --out reel.mp4 [--zoom 1.0]
+//
+// No chrome here — this is just the reframe. Captions/stamps/timer come from the
+// full compose step.
+
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { createCanvas, createImageData } from "canvas";
+import { faceTrack, buildReframer } from "../../lib/reframe.mjs";
+
+const W = 1080;
+const H = 1920;
+const FPS = 30;
+
+const argv = process.argv.slice(2);
+const flag = (n, d = null) => {
+  const i = argv.indexOf(`--${n}`);
+  return i >= 0 && argv[i + 1] && !argv[i + 1].startsWith("--") ? argv[i + 1] : d;
+};
+const SRC = resolve(argv.find((a) => !a.startsWith("--")));
+const OUT = resolve(flag("out", "vertical.mp4"));
+const ZOOM = parseFloat(flag("zoom", "1.0"));
+if (!existsSync(SRC)) { console.error(`✗ not found: ${SRC}`); process.exit(1); }
+
+const sh = (c, a) => spawnSync(c, a, { encoding: "utf8" }).stdout;
+const DUR = parseFloat(sh("ffprobe", ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", SRC]).trim());
+
+console.log("· tracking face (Vision)");
+const track = faceTrack(SRC, { fps: FPS, cachePath: `${OUT}.track.json` });
+const at = buildReframer(track, { w: W, h: H, fps: FPS, zoom: ZOOM });
+console.log(`  ${track.samples.length} samples, ${((track.samples.length / Math.round(DUR * FPS)) * 100).toFixed(0)}% detection`);
+
+const SRC_W = track.srcW;
+const SRC_H = track.srcH;
+const FB = SRC_W * SRC_H * 4;
+const FRAMES = Math.round(DUR * FPS);
+
+const dec = spawn("ffmpeg", ["-v", "error", "-i", SRC, "-f", "rawvideo", "-pix_fmt", "rgba",
+  "-vf", `fps=${FPS}`, "-"], { stdio: ["ignore", "pipe", "inherit"] });
+const enc = spawn("ffmpeg", ["-hide_banner", "-loglevel", "error", "-y",
+  "-f", "rawvideo", "-pix_fmt", "bgra", "-s", `${W}x${H}`, "-r", String(FPS), "-i", "-",
+  "-i", SRC, "-map", "0:v", "-map", "1:a",
+  "-c:v", "libx264", "-preset", "veryfast", "-crf", "18", "-pix_fmt", "yuv420p",
+  "-c:a", "aac", "-b:a", "192k", "-shortest", "-movflags", "+faststart", OUT],
+  { stdio: ["pipe", "inherit", "inherit"] });
+
+const srcCv = createCanvas(SRC_W, SRC_H);
+const sctx = srcCv.getContext("2d");
+const dst = createCanvas(W, H);
+const ctx = dst.getContext("2d");
+ctx.imageSmoothingEnabled = true;
+ctx.imageSmoothingQuality = "high";
+
+const write = (b) => new Promise((r) => (enc.stdin.write(b) ? r() : enc.stdin.once("drain", r)));
+const it = dec.stdout[Symbol.asyncIterator]();
+let buf = Buffer.alloc(0);
+let done = false;
+const nextFrame = async () => {
+  while (buf.length < FB && !done) {
+    const { value, done: d } = await it.next();
+    if (d) { done = true; break; }
+    buf = buf.length ? Buffer.concat([buf, value]) : value;
+  }
+  if (buf.length < FB) return null;
+  const f = buf.subarray(0, FB);
+  buf = buf.subarray(FB);
+  return f;
+};
+
+console.log(`· cropping ${FRAMES} frames → ${basename(OUT)}`);
+for (let f = 0; f < FRAMES; f += 1) {
+  const rgba = await nextFrame();
+  if (!rgba) break;
+  sctx.putImageData(createImageData(new Uint8ClampedArray(rgba), SRC_W, SRC_H), 0, 0);
+  const { sx, sy, sw, sh } = at(f / FPS);
+  ctx.drawImage(srcCv, sx, sy, sw, sh, 0, 0, W, H);
+  await write(dst.toBuffer("raw"));
+  if (f % 150 === 0) process.stdout.write(`\r  ${f}/${FRAMES}`);
+}
+enc.stdin.end();
+dec.kill("SIGKILL");
+await new Promise((r) => enc.on("close", r));
+process.stdout.write(`\r  ${FRAMES}/${FRAMES}\n✓ ${OUT}\n`);
diff --git a/marketing/talking-head/bin/warp-to-sing.mjs b/marketing/talking-head/bin/warp-to-sing.mjs
new file mode 100644
--- /dev/null
+++ b/marketing/talking-head/bin/warp-to-sing.mjs
@@ -0,0 +1,212 @@
+// warp-to-sing.mjs — stretch a talking-head video so the mouth rides a sung take.
+//
+// The sick test. We have the same 169 words twice: once as the man actually
+// spoke them (his lips, in the video) and once sung (ElevenLabs → WORLD, on a
+// melody). Singing stretches words unevenly — a held note on "designer" runs
+// four times the length of the spoken word. So we rubber-band the VIDEO onto the
+// sung clock: every spoken word's frames are stretched or squeezed to fill its
+// sung word's slot, and his mouth ends up roughly tracking the melody.
+//
+//   node warp-to-sing.mjs <video> \
+//     --spoken yc.json           (whisper on the ORIGINAL audio — spoken timing)
+//     --sung   sung-alignment.json  (the sung word timing)
+//     --audio  jeffrey-sung.mp3   (laid under the warped picture)
+//     --out    warped.mp4
+//
+// The map is piecewise-linear through (sungStart[i] → spokenStart[i]) anchors,
+// monotonic, so the source can be streamed: for each output frame we pull source
+// frames until we reach its mapped time — holding the last one when the sung word
+// runs long (stretch), skipping ahead when it runs short (compress).
+
+import { spawn, spawnSync } from "node:child_process";
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+const argv = process.argv.slice(2);
+const flag = (n, d = null) => {
+  const i = argv.indexOf(`--${n}`);
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : d;
+};
+
+const SRC = resolve(argv.find((a) => !a.startsWith("--")));
+const SPOKEN = resolve(flag("spoken"));
+const SUNG = resolve(flag("sung"));
+const AUDIO = resolve(flag("audio"));
+const OUT = resolve(flag("out", "warped.mp4"));
+const FPS = 30;
+for (const [p, n] of [[SRC, "video"], [SPOKEN, "--spoken"], [SUNG, "--sung"], [AUDIO, "--audio"]]) {
+  if (!existsSync(p)) { console.error(`✗ ${n} not found: ${p}`); process.exit(1); }
+}
+
+const sh = (c, a) => {
+  const r = spawnSync(c, a, { encoding: "utf8" });
+  if (r.status !== 0) throw new Error(`${c}: ${r.stderr?.slice(0, 300)}`);
+  return r.stdout;
+};
+
+// whisper words (seconds) from the spoken side, with START and END. words.mjs'
+// merge logic inline: a leading space (or the first token) begins a word, and
+// each token extends the current word's end.
+function spokenWords() {
+  const segs = JSON.parse(readFileSync(SPOKEN, "utf8")).transcription;
+  const out = [];
+  for (const s of segs) {
+    if (!s.text.trim()) continue;
+    if (s.text.startsWith(" ") || out.length === 0) {
+      out.push({ from: s.offsets.from / 1000, to: s.offsets.to / 1000 });
+    } else {
+      out[out.length - 1].to = s.offsets.to / 1000;
+    }
+  }
+  return out;
+}
+// sung words — accept either a bare word array or an alignment doc with `.words`
+const sungDoc = JSON.parse(readFileSync(SUNG, "utf8"));
+const sungWords = Array.isArray(sungDoc) ? sungDoc : sungDoc.words;
+const sung = sungWords.map((w) => ({ from: (w.fromMs ?? w.from) / 1000, to: (w.toMs ?? w.to) / 1000 }));
+const spoken = spokenWords();
+
+const n = Math.min(spoken.length, sung.length);
+
+// Each WORD is a segment: the sung word's slot maps to the spoken word's video,
+// at one steady rate across the whole word (no mid-word speed change — that was
+// the glitch). Boundaries are pinned at BOTH ends so a held note stretches the
+// whole word's mouth movement rather than freezing on a frame.
+//
+// The boundaries are SNAPPED to the frame grid — output times to the output
+// frame period, source times to the source frame period — so every segment maps
+// an integer run of source frames onto an integer run of output frames. That is
+// the "quantize to frame timings" step: it removes the sub-frame drift where a
+// word boundary lands 40% into a frame and the remap fights the sampler.
+//
+// All times stay in double-precision seconds. A double resolves time to well
+// under a nanosecond across a 60-second clip, so the frame/sample grids never
+// disagree at the boundary — the snap is the only quantization, and it's exact.
+const sungDur = parseFloat(sh("ffprobe", ["-v", "error", "-show_entries", "format=duration",
+  "-of", "csv=p=0", AUDIO]).trim());
+const srcDur = parseFloat(sh("ffprobe", ["-v", "error", "-show_entries", "format=duration",
+  "-of", "csv=p=0", SRC]).trim());
+
+// Build explicit SEGMENTS, each mapping an output-frame span to a source-frame
+// span, snapped to the frame grid (so every segment is a whole number of frames
+// on both sides — the "quantize to frame timings" step). Two kinds:
+//
+//   word — the frames while a word is spoken. We play its real frames, in order,
+//          because that's where the mouth actually moves; a held note just plays
+//          them slower.
+//   gap  — a pause between words. The source is a near-still face here, so
+//          playing it looks frozen. Instead we CROSSFADE evenly between the two
+//          connecting frames — the last frame of the word before and the first
+//          of the word after — so the mouth morphs continuously across the pause
+//          instead of stopping. This is the "interpolate equally between the
+//          connected frames" fix.
+const OF = (t) => Math.round(t * FPS); // seconds → frame index (nanosecond-safe)
+const segs = [];
+let oCur = 0;
+let sCur = 0;
+const addSeg = (oEnd, sEnd, gap) => {
+  if (oEnd <= oCur) return;
+  segs.push({ o0: oCur, o1: oEnd, s0: sCur, s1: sEnd, gap });
+  oCur = oEnd;
+  sCur = sEnd;
+};
+for (let i = 0; i < n; i += 1) {
+  // lead-in to the first word, and every pause, is a gap
+  if (OF(sung[i].from) > oCur) addSeg(OF(sung[i].from), OF(spoken[i].from), true);
+  addSeg(OF(sung[i].to), OF(spoken[i].to), false); // the word itself
+}
+addSeg(OF(sungDur), OF(srcDur), true); // tail
+
+const [W, Hh] = sh("ffprobe", ["-v", "error", "-select_streams", "v",
+  "-show_entries", "stream=width,height", "-of", "csv=p=0", SRC]).trim().split(",").map(Number);
+const FB = W * Hh * 4;
+const gaps = segs.filter((s) => s.gap).length;
+console.log(`· ${W}×${Hh} · ${segs.length} segments (${gaps} gaps morphed) · sung ${sungDur.toFixed(1)}s ← spoken ${srcDur.toFixed(1)}s`);
+
+const dec = spawn("ffmpeg", ["-v", "error", "-i", SRC, "-f", "rawvideo", "-pix_fmt", "rgba",
+  "-vf", `fps=${FPS}`, "-"], { stdio: ["ignore", "pipe", "inherit"] });
+const enc = spawn("ffmpeg", ["-hide_banner", "-loglevel", "error", "-y",
+  "-f", "rawvideo", "-pix_fmt", "rgba", "-s", `${W}x${Hh}`, "-r", String(FPS), "-i", "-",
+  "-i", AUDIO, "-map", "0:v", "-map", "1:a",
+  "-c:v", "libx264", "-preset", "ultrafast", "-crf", "20", "-pix_fmt", "yuv420p",
+  "-c:a", "aac", "-b:a", "192k", "-shortest", "-movflags", "+faststart", OUT],
+  { stdio: ["pipe", "inherit", "inherit"] });
+
+const write = (b) => new Promise((r) => (enc.stdin.write(b) ? r() : enc.stdin.once("drain", r)));
+
+const outFrames = OF(sungDur);
+
+// A rolling cache of decoded source frames, keyed by frame index. We read forward
+// and evict below the oldest frame still needed. Gaps need their far endpoint
+// frame held while the near one is shown, so eviction lags by the current
+// segment's start.
+const it = dec.stdout[Symbol.asyncIterator]();
+let buf = Buffer.alloc(0);
+let decDone = false;
+let maxRead = -1;
+const cache = new Map();
+const readTo = async (idx) => {
+  while (maxRead < idx && !decDone) {
+    while (buf.length < FB && !decDone) {
+      const { value, done } = await it.next();
+      if (done) { decDone = true; break; }
+      buf = buf.length ? Buffer.concat([buf, value]) : value;
+    }
+    if (buf.length < FB) { decDone = true; break; }
+    maxRead += 1;
+    cache.set(maxRead, Uint8Array.prototype.slice.call(buf, 0, FB));
+    buf = buf.subarray(FB);
+  }
+};
+const frame = async (idx) => {
+  const i = Math.max(0, idx);
+  await readTo(i);
+  return cache.get(Math.min(i, maxRead));
+};
+
+// Per-pixel linear crossfade a→b by f, into outBuf.
+const outBuf = Buffer.allocUnsafe(FB);
+const blendInto = (a, b, f) => {
+  if (f < 0.001 || a === b) { outBuf.set(a); return; }
+  if (f > 0.999) { outBuf.set(b); return; }
+  const inv = 1 - f;
+  for (let p = 0; p < FB; p += 1) outBuf[p] = (a[p] * inv + b[p] * f) | 0;
+};
+
+let minNeeded = 0;
+for (const s of segs) {
+  const oLen = s.o1 - s.o0;
+  for (let k = 0; k < oLen; k += 1) {
+    const of = s.o0 + k;
+    if (of >= outFrames) break;
+    const p = oLen > 0 ? k / oLen : 0; // 0..1 through the segment
+
+    if (s.gap) {
+      // even crossfade between the two connecting frames — no dwell
+      minNeeded = s.s0;
+      const a = await frame(s.s0);
+      const b = await frame(s.s1);
+      blendInto(a, b, p);
+    } else {
+      // step through the word's real frames at constant rate, blending neighbors
+      const sf = s.s0 + p * (s.s1 - s.s0);
+      const i0 = Math.floor(sf);
+      minNeeded = i0;
+      const a = await frame(i0);
+      const b = await frame(i0 + 1);
+      blendInto(a, b, sf - i0);
+    }
+
+    await write(outBuf);
+    for (const key of cache.keys()) if (key < minNeeded) cache.delete(key);
+    if (of % 150 === 0) process.stdout.write(`\r  ${of}/${outFrames}`);
+  }
+}
+// The output is done, but the decoder still has frames to hand over (a spoken
+// clip is longer than we consumed once time is squeezed). Nobody's reading them,
+// so its pipe would block forever and the process would hang until something
+// kills it. Kill it ourselves.
+enc.stdin.end();
+dec.kill("SIGKILL");
+await new Promise((r) => enc.on("close", r));
+process.stdout.write(`\r  ${outFrames}/${outFrames}\n✓ ${OUT}\n`);
diff --git a/marketing/talking-head/yc-2018.txt b/marketing/talking-head/yc-2018.txt
new file mode 100644
--- /dev/null
+++ b/marketing/talking-head/yc-2018.txt
@@ -0,0 +1,1 @@
+My name is Jeffrey, and I'm a painting theorist, contemporary artist, and software designer. And largely what I do is I make creative software, and then I perform with that software. A lot of it's related to digital painting and visuals. And what I would like to do at Y Combinator is learn a bit more about business and also apply to get the funding to basically turn some of my software into real products that a lot of people can use. And art students across U.S. and Europe really respond to my software, and I think that I could build really amazing products if I had the funding. And also I think this software company would not necessarily compete with Autodesk or Adobe and would create its own market for really interesting performative kinds of uses of computers. Anyway, so a little bit more about me is I'm a Yale graduate, and I've been teaching and working for the last several years in different art schools. Okay, thanks.
diff --git a/social-software/scores-for-social-software/CATALOG.md b/social-software/scores-for-social-software/CATALOG.md
new file mode 100644
--- /dev/null
+++ b/social-software/scores-for-social-software/CATALOG.md
@@ -0,0 +1,38 @@
+# Working media description
+
+## Collection-level description
+
+This archive documents two moments in the life of **Scores for Social Software**: the cohort's June 13 closing event at Fuser and a later July 16 documentation shoot. Together, the material moves between presentation, performance, interface demonstration, installation detail, gathering, and retrospective documentation. It should be mastered as an event archive with multiple authors and works, not as a single undifferentiated photo roll.
+
+## SSF-20260613 — Fuser presentation
+
+**Extent:** 78 JPEG photographs plus one 7m39.9s, 1920×1080 H.264/AAC video explicitly named for Chelly Jin.
+
+**Identified context:** The official program describes a two-hour closing event at Fuser following a ten-week working group. Ten cohort works were presented. The still photographs use Pixel-style timestamp filenames spanning roughly 10:48–13:30 local filename time; their precise clock relationship and ordering need verification from embedded metadata.
+
+**Initial description:** A multi-work gathering in which scores are presented through talks, performances, sound, interfaces, objects, and collective attention. The catalog pass should divide these images into presentation/work sequences and use the official program only as a candidate ordering—not assume every photographed person or work from appearance.
+
+## SSF-20260716 — documentation shoot
+
+**Extent:** 174 HEIC photographs, one 11m27.7s 3840×2160 HEVC/AAC video at 60 fps, and one 1.2s 1280×720 H.264/AAC clip.
+
+**Identified context:** iPhone metadata places the main sequence between 11:51 and 14:30 on July 16, 2026. There is a clear filename/time break after `IMG_4889.MOV`, followed by `IMG_4926–4966`. GPS is retained in the source files but intentionally omitted from the public-facing catalog.
+
+**Initial description:** A sustained documentation session containing repeated views and likely action sequences. The filename runs suggest an early setup/detail phase, a long video take, and a later return or second setup. Contact-sheet review will establish shot groups, strongest frames, depicted actions, and the relationship between the long take and stills.
+
+## Video transcription queue
+
+| ID | Source | Duration | First-pass task |
+|---|---|---:|---|
+| SSF-VID-001 | `ChellyJin_SoSoftPresentation.mp4` | 00:07:39.893 | verbatim transcript, slide/action changes, speaker confirmation |
+| SSF-VID-002 | `IMG_4889.MOV` | 00:11:27.683 | transcript, shot/action log, sync against adjacent stills |
+| SSF-VID-003 | `barking.MP4.mp4` | 00:00:01.200 | identify content and relationship to shoot |
+| SSF-VID-004 | `Biophonia_SoSoft_Fuser_V2.mp4` | 00:04:35.000 | presentation/action log; match canonical *Biophonía* stills |
+
+## Description queue
+
+1. Segment today’s stills into visually coherent takes.
+2. Segment the 78 Fuser photographs by work/presenter.
+3. Produce one neutral observed description and one contextual note per segment.
+4. Mark selects, near-duplicates, technical failures, and permission questions.
+5. Reconcile names/titles against emails, participant confirmation, and transcripts.
diff --git a/social-software/scores-for-social-software/README.md b/social-software/scores-for-social-software/README.md
new file mode 100644
--- /dev/null
+++ b/social-software/scores-for-social-software/README.md
@@ -0,0 +1,35 @@
+# Scores for Social Software — media archive
+
+Working catalog for Jeffrey Alan Scudder's contribution to Social Software Cycle 2 and the larger cohort archive.
+
+## Archive groups
+
+1. **Fuser presentation — 2026-06-13.** Closing event at Fuser, 1811 Blake Ave, Los Angeles. The downloaded ZIP contains 78 still photographs; `ChellyJin_SoSoftPresentation.mp4` is a 7m40s presentation recording.
+2. **Documentation shoot — 2026-07-16.** 174 iPhone photographs, one 11m28s 4K/60 video (`IMG_4889.MOV`), and one 1.2s clip (`barking.MP4.mp4`). These are treated as one shoot even though they arrived loose in Downloads.
+
+Original media remains in `/Users/jas/Downloads`. This repository stores metadata, descriptions, and lightweight contact sheets; it does not silently rename, recompress, or relocate masters.
+
+## Context
+
+- Social Software defines a score as a way of choreographing events in time through text, diagrams, or other instructions, and social software as a system that organizes behavior, coordinates people, or structures interaction.
+- Cycle 2 ran for ten weeks and concluded with cohort performances and presentations at Fuser.
+- Jeffrey's listed project was **NOTEPAT**.
+- The cohort publication is part of the cycle's stated outcome.
+
+See [SOURCES.md](SOURCES.md) for evidence and [CATALOG.md](CATALOG.md) for the working media description.
+
+## Catalog rules
+
+- `observed` means visible/audible in the media.
+- `identified` means supported by a filename, metadata, event program, email, text, or participant confirmation.
+- `inferred` means plausible but awaiting confirmation.
+- Descriptions should name actions, interfaces, spatial arrangements, and transitions before attempting interpretation.
+- People should not be identified from appearance alone.
+- Preserve original filenames and SHA-256 hashes as the stable identity of every asset.
+
+## Next context passes
+
+- Ingest relevant email threads and attachments.
+- Search prior Claude sessions/memories for Notepat and Cycle 2 development notes.
+- Transcribe the two substantial videos and align their segments with still-image sequences.
+- Ask participants to verify names, works, and image permissions before publication.
diff --git a/social-software/scores-for-social-software/SOURCES.md b/social-software/scores-for-social-software/SOURCES.md
new file mode 100644
--- /dev/null
+++ b/social-software/scores-for-social-software/SOURCES.md
@@ -0,0 +1,51 @@
+# Sources and provenance
+
+## Primary media
+
+| Source | Date represented | Role | Status |
+|---|---:|---|---|
+| `/Users/jas/Downloads/IMG_4753…IMG_4889` | 2026-07-16 | Documentation shoot, sequence A | inventoried |
+| `/Users/jas/Downloads/IMG_4926…IMG_4966` | 2026-07-16 | Documentation shoot, sequence B | inventoried |
+| `/Users/jas/Downloads/barking.MP4.mp4` | 2026-07-16 | Very short related clip | inventoried |
+| `/Users/jas/Downloads/Social Software — Cycle 2 — Scores for Social Software-1-001.zip` | 2026-06-13 | 78 photographs of the Fuser event | inventoried |
+| `/Users/jas/Downloads/ChellyJin_SoSoftPresentation.mp4` | 2026-06-13 | Chelly Jin presentation recording | inventoried |
+| `/Users/jas/Downloads/Biophonia_SoSoft_Fuser_V2.mp4` | 2026-06-12/13 | Thomas Noya, *Biophonía*, presentation master (4m35s) | inventoried |
+
+## Repository context
+
+- [`letters/casey-reas-air-spring-2026.md`](../../letters/casey-reas-air-spring-2026.md) — invitation, residency scope, publication idea, and Cycle 2 confirmation.
+- [`quotes/AE-2026-001-ucla-social-software/AE-2026-001.tex`](../../quotes/AE-2026-001-ucla-social-software/AE-2026-001.tex) — documentation-services scope.
+- [`papers/arxiv-score-analysis/score-analysis.tex`](../../papers/arxiv-score-analysis/score-analysis.tex) — existing writing on scores.
+- [`papers/arxiv-comp-strats/comp-strats.tex`](../../papers/arxiv-comp-strats/comp-strats.tex) — related Aesthetic Computer text.
+
+## Web context
+
+- <https://sosoft.arts.ucla.edu/featured/cycle-2>
+- <https://sosoft.arts.ucla.edu/featured/cycle-2-conclusion>
+- <https://sosoft.arts.ucla.edu/people>
+- <https://sosoft.arts.ucla.edu/docs>
+
+Captured for this catalog on 2026-07-16. Web claims should be rechecked before publication.
+
+## Context waiting to be ingested
+
+| Source | Likely contribution | Access/status |
+|---|---|---|
+| Email correspondence with Casey Reas, Lauren Lee McCarthy, cohort, and organizers | dates, intentions, logistics, titles, permissions | mail connector unavailable in current session |
+| Prior Claude sessions and memories | development chronology, language, decisions, recollections | locate and review; do not treat generated summaries as primary evidence |
+| Participant recollections | identification and interpretation | interview/confirmation pass needed |
+
+## Known event program
+
+The official closing-event page lists:
+
+- Jeffrey Alan Scudder — *Notepat*
+- Æther Cavendish — *Vigil Score*
+- Chelly Jin — *Software as a Choreography*
+- Jordan Silver — *Sonic Architecture*
+- Em Lugo — *Cues for Losing Direction*
+- Darlyn Phan — *Line Piece 1*
+- Thomas Noya — *Biophonía*
+- Banyi Huang — *A Cosmographic Score for Folding Back into the Kernel*
+- Alex Espinosa — *Music for World Computers*
+- Mavyn Vu — *The Radio Is an Altar : Portal*