diff --git a/README.md b/README.md
index ddc4fa1..de9c5e0 100644
--- a/README.md
+++ b/README.md
@@ -322,6 +322,65 @@ but its data-chunk size will say zero — most players will refuse to
 play it. Stop the router cleanly (or click Record off) before pulling
 the plug.
 
+### Composite recording — true on-air timeline
+
+The per-port `*.tx.wav` files above are written straight from each TNC
+as it *bursts* its TX audio (samoyed can emit a 500 ms frame onto its
+UDP socket in a few wall-clock ms), so they faithfully carry the
+modulated waveform but are **not** a real-time timeline — you can't line
+two of them up and trust the gaps.
+
+A **composite recording** fixes that. It captures a chosen set of
+transmitters into a *single*, sample-aligned, multi-channel WAV — one
+transmitter per channel — and paces every channel through one real-time
+clock (the same mechanism that feeds audio into the receivers). For the
+canonical two-station setup that's a **stereo** file with one station's
+transmitted audio in each ear. The result is an accurate timeline of
+what was on the air: overlapping transmissions overlap in time,
+inter-burst gaps are real silence, and both channels share one start
+time. Drop it into Audacity and you can see at a glance who was keying
+when — ideal for inspecting hidden-node collisions (put the two hidden
+stations in left/right).
+
+The audio is the clean transmitter output (full-scale, before any
+per-link path loss, noise, or the capture-effect mixer) — it's what each
+station actually put on the air, not what any particular receiver heard.
+
+**`sim-router`** — pass `-composite a.vhf,b.vhf` together with `-record DIR`
+(the base dir for the output). Recording starts as soon as the router
+comes up and stops on a clean shutdown:
+
+```
+sim-router -config configs/hidden-node.yaml -record /tmp/sim-rec \
+  -composite a.vhf,c.vhf
+# /tmp/sim-rec/composite-20260604T120000.000Z.wav  (stereo: a.vhf left, c.vhf right)
+```
+
+List more than two ports for a multi-track WAV (one channel each, in the
+order given).
+
+**`sim-web`** — with `-record DIR` set, a **Composite recording** panel
+appears on the control page: pick the Left-ear and Right-ear
+transmitters, click **Start recording**, then **Stop recording** when
+done, and **Download .wav**.
+
+#### HTTP API (for external software)
+
+Drive it from a test harness or any HTTP client. All endpoints live
+under `/api/record/composite/` and need `sim-web` started with
+`-record DIR` and the router running.
+
+| Method & path | Body | Effect |
+|---|---|---|
+| `POST /api/record/composite/start` | `{"ports":["a.vhf","c.vhf"]}` (optional) | Start a recording. Each port is one channel, in order (index 0 = left). Omit the body to default to the topology's first two ports. |
+| `POST /api/record/composite/stop` | — | Finalise the file (patches the WAV header) and return its status. |
+| `GET /api/record/composite/status` | — | Current state: `available`, `active`, `channels`, `path`, `duration_s`, and `download_url` once a file is complete. |
+| `GET /api/record/composite/download` | — | Stream the most recently completed composite WAV as an attachment. |
+
+A typical external run: `POST .../start` → exercise your stations over
+KISS → `POST .../stop` → `GET .../download`. The `composite` block is
+also included in `GET /api/status`.
+
 ## Why FM capture-effect mixing (and not linear sum)
 
 A linear-sum mixer is simpler and is what most "audio bus" libraries
diff --git a/cmd/sim-router/main.go b/cmd/sim-router/main.go
index a2a76de..2639083 100644
--- a/cmd/sim-router/main.go
+++ b/cmd/sim-router/main.go
@@ -17,6 +17,7 @@ import (
 	"os"
 	"os/exec"
 	"os/signal"
+	"strings"
 	"syscall"
 
 	"github.com/packethacking/net-sim/internal/config"
@@ -30,6 +31,7 @@ func main() {
 	direwolfPath := flag.String("direwolf", "", "path to direwolf (default: search $PATH)")
 	workDir := flag.String("workdir", "", "scratch dir for per-port config files / FIFOs (default: a unique subdir of $TMPDIR)")
 	recordDir := flag.String("record", "", "if set, record all per-port TX and RX audio to a timestamped subdirectory of this path")
+	composite := flag.String("composite", "", "comma-separated transmitter ports (e.g. a.vhf,b.vhf) to composite into one real-time, sample-aligned WAV (one TX per channel — stereo for two). Requires -record for the output dir")
 	flag.Parse()
 
 	if *cfgPath == "" {
@@ -38,6 +40,16 @@ func main() {
 		os.Exit(2)
 	}
 
+	if *composite != "" && *recordDir == "" {
+		fmt.Fprintln(os.Stderr, "sim-router: -composite requires -record DIR (for the output directory)")
+		os.Exit(2)
+	}
+	compositePorts, err := parseCompositePorts(*composite)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "sim-router:", err)
+		os.Exit(2)
+	}
+
 	logLevel := slog.LevelInfo
 	if *verbose {
 		logLevel = slog.LevelDebug
@@ -89,6 +101,16 @@ func main() {
 		os.Exit(1)
 	}
 
+	if len(compositePorts) > 0 {
+		path, err := r.StartCompositeRecording(compositePorts)
+		if err != nil {
+			logger.Error("start composite recording", "err", err)
+			_ = r.Stop()
+			os.Exit(1)
+		}
+		logger.Info("composite recording", "file", path, "channels", *composite)
+	}
+
 	// Run until SIGINT/SIGTERM or a child dies (router cancels its own ctx).
 	sig := make(chan os.Signal, 1)
 	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
@@ -143,6 +165,28 @@ func resolveDirewolf(explicit string) (string, error) {
 	return "", errors.New("direwolf not found in $PATH or common locations")
 }
 
+// parseCompositePorts turns a comma-separated "a.vhf,b.vhf" list into
+// PortRefs. Empty input yields no refs (composite disabled). Order is
+// preserved: the first port is channel 0 (left ear in the stereo case).
+func parseCompositePorts(s string) ([]config.PortRef, error) {
+	if strings.TrimSpace(s) == "" {
+		return nil, nil
+	}
+	var refs []config.PortRef
+	for _, part := range strings.Split(s, ",") {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		dot := strings.IndexByte(part, '.')
+		if dot <= 0 || dot >= len(part)-1 {
+			return nil, fmt.Errorf("invalid -composite port %q (want <node>.<port>)", part)
+		}
+		refs = append(refs, config.PortRef{NodeID: part[:dot], PortID: part[dot+1:]})
+	}
+	return refs, nil
+}
+
 func resolveWorkDir(explicit string) (string, error) {
 	if explicit != "" {
 		return explicit, os.MkdirAll(explicit, 0o755)
diff --git a/cmd/sim-web/composite_test.go b/cmd/sim-web/composite_test.go
new file mode 100644
index 0000000..68abf03
--- /dev/null
+++ b/cmd/sim-web/composite_test.go
@@ -0,0 +1,151 @@
+package main
+
+import (
+	"encoding/json"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func testApp(recordBase string) *app {
+	return &app{
+		recordBase: recordBase,
+		logger:     slog.New(slog.NewTextHandler(io.Discard, nil)),
+	}
+}
+
+func decodeComposite(t *testing.T, body io.Reader) compositeStatus {
+	t.Helper()
+	var cs compositeStatus
+	if err := json.NewDecoder(body).Decode(&cs); err != nil {
+		t.Fatalf("decode composite status: %v", err)
+	}
+	return cs
+}
+
+func TestCompositeStatusUnavailableWithoutRecordDir(t *testing.T) {
+	a := testApp("")
+	rec := httptest.NewRecorder()
+	a.handleCompositeStatus(rec, httptest.NewRequest(http.MethodGet, "/api/record/composite/status", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status code = %d, want 200", rec.Code)
+	}
+	cs := decodeComposite(t, rec.Body)
+	if cs.Available {
+		t.Error("Available should be false when no -record dir")
+	}
+	if cs.Active {
+		t.Error("Active should be false")
+	}
+}
+
+func TestCompositeStatusAvailableWithRecordDir(t *testing.T) {
+	a := testApp(t.TempDir())
+	rec := httptest.NewRecorder()
+	a.handleCompositeStatus(rec, httptest.NewRequest(http.MethodGet, "/api/record/composite/status", nil))
+	cs := decodeComposite(t, rec.Body)
+	if !cs.Available {
+		t.Error("Available should be true when -record dir set")
+	}
+}
+
+func TestCompositeStartRejectedWhenRecordingDisabled(t *testing.T) {
+	a := testApp("")
+	rec := httptest.NewRecorder()
+	a.handleCompositeStart(rec, httptest.NewRequest(http.MethodPost, "/api/record/composite/start", nil))
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status code = %d, want 400", rec.Code)
+	}
+}
+
+func TestCompositeStartRejectedWhenRouterStopped(t *testing.T) {
+	a := testApp(t.TempDir())
+	rec := httptest.NewRecorder()
+	a.handleCompositeStart(rec, httptest.NewRequest(http.MethodPost, "/api/record/composite/start", nil))
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status code = %d, want 400 (router not running)", rec.Code)
+	}
+	if !strings.Contains(rec.Body.String(), "not running") {
+		t.Errorf("body = %q, want mention of router not running", rec.Body.String())
+	}
+}
+
+func TestCompositeStartRejectsBadJSON(t *testing.T) {
+	a := testApp(t.TempDir())
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodPost, "/api/record/composite/start", strings.NewReader("{not json"))
+	a.handleCompositeStart(rec, req)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status code = %d, want 400 (bad json)", rec.Code)
+	}
+}
+
+func TestCompositeStartRejectsBadPortRef(t *testing.T) {
+	a := testApp(t.TempDir())
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodPost, "/api/record/composite/start",
+		strings.NewReader(`{"ports":["nodotsep"]}`))
+	a.handleCompositeStart(rec, req)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status code = %d, want 400 (bad port ref)", rec.Code)
+	}
+}
+
+func TestCompositeStartWrongMethod(t *testing.T) {
+	a := testApp(t.TempDir())
+	rec := httptest.NewRecorder()
+	a.handleCompositeStart(rec, httptest.NewRequest(http.MethodGet, "/api/record/composite/start", nil))
+	if rec.Code != http.StatusMethodNotAllowed {
+		t.Fatalf("status code = %d, want 405", rec.Code)
+	}
+}
+
+func TestCompositeDownloadNotFoundWhenNoFile(t *testing.T) {
+	a := testApp(t.TempDir())
+	rec := httptest.NewRecorder()
+	a.handleCompositeDownload(rec, httptest.NewRequest(http.MethodGet, "/api/record/composite/download", nil))
+	if rec.Code != http.StatusNotFound {
+		t.Fatalf("status code = %d, want 404", rec.Code)
+	}
+}
+
+func TestStatusIncludesCompositeBlock(t *testing.T) {
+	a := testApp(t.TempDir())
+	rec := httptest.NewRecorder()
+	a.handleStatus(rec, httptest.NewRequest(http.MethodGet, "/api/status", nil))
+	var resp map[string]any
+	if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode status: %v", err)
+	}
+	comp, ok := resp["composite"].(map[string]any)
+	if !ok {
+		t.Fatalf("status JSON missing composite object; got %v", resp)
+	}
+	if comp["available"] != true {
+		t.Errorf("composite.available = %v, want true", comp["available"])
+	}
+}
+
+func TestParsePortRefs(t *testing.T) {
+	refs, err := parsePortRefs([]string{"a.vhf", " b.uhf-link ", ""})
+	if err != nil {
+		t.Fatalf("parsePortRefs: %v", err)
+	}
+	if len(refs) != 2 {
+		t.Fatalf("got %d refs, want 2 (empty skipped)", len(refs))
+	}
+	if refs[0].NodeID != "a" || refs[0].PortID != "vhf" {
+		t.Errorf("refs[0] = %+v, want a/vhf", refs[0])
+	}
+	if refs[1].NodeID != "b" || refs[1].PortID != "uhf-link" {
+		t.Errorf("refs[1] = %+v, want b/uhf-link", refs[1])
+	}
+	for _, bad := range []string{"nodot", ".leading", "trailing."} {
+		if _, err := parsePortRefs([]string{bad}); err == nil {
+			t.Errorf("parsePortRefs(%q) should error", bad)
+		}
+	}
+}
diff --git a/cmd/sim-web/index.html b/cmd/sim-web/index.html
index 40cd824..f0f85fe 100644
--- a/cmd/sim-web/index.html
+++ b/cmd/sim-web/index.html
@@ -163,6 +163,22 @@ <h3>More</h3>
   <span id="rec-status" class="muted"></span>
 </div>
 
+<div id="composite" class="block" hidden style="max-width: 50rem;">
+  <div class="block-head">
+    <span class="title">Composite recording &nbsp;<small class="muted">true on-air timeline — one transmitter per channel</small></span>
+    <span id="comp-state" class="muted"></span>
+  </div>
+  <div class="row" style="margin:.25rem 0;">
+    <span class="field"><label for="comp-left">Left ear</label>
+      <select id="comp-left" onchange="compSel.left=this.value"></select></span>
+    <span class="field"><label for="comp-right">Right ear</label>
+      <select id="comp-right" onchange="compSel.right=this.value"></select></span>
+    <button id="comp-btn" class="primary" onclick="apiCompositeToggle()">Start recording</button>
+    <button id="comp-dl" onclick="apiCompositeDownload()" disabled>Download .wav</button>
+  </div>
+  <small class="muted" id="comp-hint"></small>
+</div>
+
 <div id="msg"></div>
 
 <div id="ports"></div>
@@ -198,6 +214,11 @@ <h3>More</h3>
 let topology = null;     // the JSON view of /etc/sim/network.yaml
 let activeTab = "form";
 
+// Composite-recording UI state (persists across the 2s status poll so the
+// dropdown selection isn't clobbered while the user is choosing).
+let compSel = { left: null, right: null };
+let compActive = false;
+
 function setMsg(text, ok) {
   const m = $("msg");
   m.className = ok ? "ok" : "err";
@@ -262,6 +283,98 @@ <h3>More</h3>
   await act(want ? "/api/record/start" : "/api/record/stop");
 }
 
+// ---- composite (true on-air timeline) recording -------------------------
+
+async function apiCompositeToggle() {
+  if (compActive) {
+    await act("/api/record/composite/stop");
+  } else {
+    const ports = [compSel.left, compSel.right].filter(Boolean);
+    if (ports.length < 1) { setMsg("choose at least one transmitter", false); return; }
+    await actJSON("/api/record/composite/start", { ports });
+  }
+  refreshStatus();
+}
+
+function apiCompositeDownload() { window.location = "/api/record/composite/download"; }
+
+async function actJSON(path, body) {
+  try {
+    const r = await fetch(path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!r.ok) throw new Error(await r.text());
+    setMsg(path + " ok", true);
+  } catch (e) {
+    setMsg(path + ": " + e.message, false);
+  }
+}
+
+// renderComposite reflects the composite-recorder status into the panel.
+// Only shown when sim-web was started with -record DIR.
+function renderComposite(s) {
+  const c = s.composite || {};
+  const panel = $("composite");
+  if (!c.available) { panel.hidden = true; return; }
+  panel.hidden = false;
+
+  const ports   = (s.ports || []).map(p => p.node + "." + p.port);
+  const running = !!s.running;
+  compActive    = !!c.active;
+
+  const leftSel = $("comp-left"), rightSel = $("comp-right");
+  if (compSel.left  === null && ports.length) compSel.left  = ports[0];
+  if (compSel.right === null && ports.length) compSel.right = ports[Math.min(1, ports.length - 1)];
+  fillSel(leftSel,  ports, compSel.left);
+  fillSel(rightSel, ports, compSel.right);
+  compSel.left  = leftSel.value  || null;
+  compSel.right = rightSel.value || null;
+
+  const canPick = running && !compActive;
+  leftSel.disabled = !canPick;
+  rightSel.disabled = !canPick;
+
+  const btn = $("comp-btn"), dl = $("comp-dl"), state = $("comp-state"), hint = $("comp-hint");
+
+  if (compActive) {
+    btn.textContent = "Stop recording";
+    btn.className = "danger";
+    btn.disabled = false;
+    const dur = (c.duration_s || 0).toFixed(1);
+    const chans = (c.channels && c.channels.length) ? "  [" + c.channels.join(" | ") + "]" : "";
+    state.textContent = "● REC " + dur + "s" + chans;
+    state.style.color = "#ffb3b3";
+    hint.textContent = c.path ? ("writing " + c.path.split("/").pop()) : "";
+  } else {
+    btn.textContent = "Start recording";
+    btn.className = "primary";
+    btn.disabled = !running;
+    state.textContent = "";
+    state.style.color = "";
+    hint.textContent = running
+      ? "Captures each chosen transmitter into one channel of a single, sample-aligned WAV paced in real time — overlapping transmissions overlap in time, gaps are real silence. Two stations → stereo, one per ear. Load it in Audacity to see who was on the air when."
+      : "Start the simulator, then choose two transmitters.";
+  }
+  dl.disabled = !c.download_url;
+}
+
+// fillSel (re)builds a port <select> only when the option set changed, so
+// the 2s status poll doesn't collapse an open dropdown or lose selection.
+function fillSel(sel, ports, want) {
+  const cur = Array.from(sel.options).map(o => o.value).join("\n");
+  if (cur !== ports.join("\n")) {
+    sel.innerHTML = "";
+    for (const p of ports) {
+      const o = document.createElement("option");
+      o.value = p; o.textContent = p;
+      sel.appendChild(o);
+    }
+  }
+  if (want != null && Array.from(sel.options).some(o => o.value === want)) sel.value = want;
+}
+
 async function act(path) {
   try {
     const r = await fetch(path, { method: "POST" });
@@ -315,6 +428,8 @@ <h3>More</h3>
       recStatus.textContent = "";
     }
 
+    renderComposite(s);
+
     if (s.last_error) setMsg(s.last_error, false);
   } catch {/* ignore: status polls every 2s, transient errors are fine */}
 }
diff --git a/cmd/sim-web/main.go b/cmd/sim-web/main.go
index 4092593..c49e6e8 100644
--- a/cmd/sim-web/main.go
+++ b/cmd/sim-web/main.go
@@ -17,6 +17,7 @@ import (
 	"encoding/json"
 	"errors"
 	"flag"
+	"fmt"
 	"html/template"
 	"io"
 	"log/slog"
@@ -25,6 +26,8 @@ import (
 	"os"
 	"os/exec"
 	"os/signal"
+	"path/filepath"
+	"strings"
 	"sync"
 	"syscall"
 	"time"
@@ -68,7 +71,7 @@ func main() {
 	direwolf := flag.String("direwolf", "", "direwolf binary (default: discover)")
 	workDir := flag.String("workdir", "", "scratch dir for per-port config files / FIFOs (default: temp)")
 	autostart := flag.Bool("autostart", false, "start the router immediately on launch")
-	recordDir := flag.String("record", "", "if set, enables the Record toggle in the UI; recordings land in timestamped subdirectories of this path")
+	recordDir := flag.String("record", "", "if set, enables the Record toggle and Composite recording panel in the UI; recordings land under this path")
 	flag.Parse()
 
 	logger := slog.New(slog.NewTextHandler(os.Stderr, nil))
@@ -135,6 +138,10 @@ func main() {
 	mux.HandleFunc("/api/record/start", app.handleRecordStart)
 	mux.HandleFunc("/api/record/stop", app.handleRecordStop)
 	mux.HandleFunc("/api/record/status", app.handleRecordStatus)
+	mux.HandleFunc("/api/record/composite/start", app.handleCompositeStart)
+	mux.HandleFunc("/api/record/composite/stop", app.handleCompositeStop)
+	mux.HandleFunc("/api/record/composite/status", app.handleCompositeStatus)
+	mux.HandleFunc("/api/record/composite/download", app.handleCompositeDownload)
 
 	srv := &http.Server{
 		Addr:              *addr,
@@ -191,6 +198,12 @@ type app struct {
 	// recording on and then clicked Apply&Restart gets a fresh session
 	// in the new run rather than having to re-toggle.
 	recordEnabled bool
+
+	// lastComposite is the path of the most recently *completed* composite
+	// recording (set when StopCompositeRecording returns). The download
+	// endpoint serves this file; the in-progress file isn't downloadable
+	// until stopped (its WAV header isn't patched yet).
+	lastComposite string
 }
 
 type pageData struct {
@@ -240,10 +253,10 @@ func (a *app) handleObserved(w http.ResponseWriter, _ *http.Request) {
 // handleStats is a cheap polling endpoint for the live-map HUD.
 //
 // Returns:
-//   * sim_cpu_pct  — aggregate CPU% across all containers attached to
+//   - sim_cpu_pct  — aggregate CPU% across all containers attached to
 //     any of this container's Docker networks (sum, scaled by online
 //     CPUs). NaN unless /var/run/docker.sock is mounted in.
-//   * host_cpu_pct — host-wide CPU% from /proc/stat. NaN on non-Linux.
+//   - host_cpu_pct — host-wide CPU% from /proc/stat. NaN on non-Linux.
 //
 // The visualiser prefers sim_cpu_pct and falls back to host if the
 // daemon socket isn't reachable.
@@ -477,14 +490,30 @@ type statusResponse struct {
 	LastError string           `json:"last_error,omitempty"`
 	LastEvent string           `json:"last_event,omitempty"`
 	Record    recordStatus     `json:"record"`
+	Composite compositeStatus  `json:"composite"`
+}
+
+// compositeStatus is the JSON view of the composite (multi-channel TX
+// timeline) recorder. "channels" is the ordered port list — index 0 is the
+// left ear in the stereo case. It is also returned standalone from
+// /api/record/composite/{start,stop,status}.
+type compositeStatus struct {
+	Available   bool     `json:"available"`              // -record DIR was set
+	Active      bool     `json:"active"`                 // a recording is in progress
+	Channels    []string `json:"channels,omitempty"`     // ordered port refs, one per WAV channel
+	Path        string   `json:"path,omitempty"`         // file currently being written
+	DurationS   float64  `json:"duration_s,omitempty"`   // seconds captured so far
+	Error       string   `json:"error,omitempty"`        // write error, if the stream faulted
+	LastPath    string   `json:"last_path,omitempty"`    // most recent completed file
+	DownloadURL string   `json:"download_url,omitempty"` // present when a completed file exists
 }
 
 type recordStatus struct {
-	Available bool   `json:"available"`         // -record DIR was set on the CLI
-	Enabled   bool   `json:"enabled"`           // user has toggled recording on
-	Active    bool   `json:"active"`            // a session is currently capturing
-	Base      string `json:"base,omitempty"`    // configured base dir
-	Dir       string `json:"dir,omitempty"`     // current session dir, when active
+	Available bool   `json:"available"`      // -record DIR was set on the CLI
+	Enabled   bool   `json:"enabled"`        // user has toggled recording on
+	Active    bool   `json:"active"`         // a session is currently capturing
+	Base      string `json:"base,omitempty"` // configured base dir
+	Dir       string `json:"dir,omitempty"`  // current session dir, when active
 }
 
 type portStatusItem struct {
@@ -532,10 +561,33 @@ func (a *app) writeStatus(w http.ResponseWriter) {
 		resp.Record.Dir = a.router.RecordingDir()
 	}
 
+	resp.Composite = a.compositeStatusLocked()
+
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(resp)
 }
 
+// compositeStatusLocked builds the composite-recorder status. The caller
+// must hold a.mu.
+func (a *app) compositeStatusLocked() compositeStatus {
+	cs := compositeStatus{Available: a.recordBase != ""}
+	if a.router != nil {
+		rs := a.router.CompositeStatus()
+		cs.Active = rs.Active
+		cs.Path = rs.Path
+		cs.Error = rs.Err
+		cs.DurationS = rs.Duration.Seconds()
+		for _, ref := range rs.Channels {
+			cs.Channels = append(cs.Channels, ref.String())
+		}
+	}
+	if a.lastComposite != "" {
+		cs.LastPath = a.lastComposite
+		cs.DownloadURL = "/api/record/composite/download"
+	}
+	return cs
+}
+
 func (a *app) handleRecordStart(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodPost {
 		http.Error(w, "method", http.StatusMethodNotAllowed)
@@ -581,6 +633,129 @@ func (a *app) handleRecordStatus(w http.ResponseWriter, _ *http.Request) {
 	a.writeStatus(w)
 }
 
+// compositeStartReq is the optional JSON body for /api/record/composite/start.
+// ports is an ordered list of "<node>.<port>" refs — one WAV channel each,
+// index 0 = left ear. Omit it (or send an empty body) to default to the
+// topology's first two ports, i.e. a stereo "one station per ear" file.
+type compositeStartReq struct {
+	Ports []string `json:"ports"`
+}
+
+// handleCompositeStart begins a composite (multi-channel TX timeline)
+// recording. POST, optional JSON body (see compositeStartReq).
+func (a *app) handleCompositeStart(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "method", http.StatusMethodNotAllowed)
+		return
+	}
+	var req compositeStartReq
+	if body, err := io.ReadAll(io.LimitReader(r.Body, 1<<16)); err == nil && len(body) > 0 {
+		if err := json.Unmarshal(body, &req); err != nil {
+			http.Error(w, "invalid json: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+	}
+	refs, err := parsePortRefs(req.Ports)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	a.mu.Lock()
+	if a.recordBase == "" {
+		a.mu.Unlock()
+		http.Error(w, "recording disabled: sim-web was started without -record DIR", http.StatusBadRequest)
+		return
+	}
+	rt := a.router
+	a.mu.Unlock()
+	if rt == nil {
+		http.Error(w, "router not running: Start the simulator first", http.StatusBadRequest)
+		return
+	}
+	if _, err := rt.StartCompositeRecording(refs); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	a.writeCompositeStatus(w)
+}
+
+// handleCompositeStop finalises the current composite recording and reports
+// the resulting file (now downloadable). POST.
+func (a *app) handleCompositeStop(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "method", http.StatusMethodNotAllowed)
+		return
+	}
+	a.mu.Lock()
+	rt := a.router
+	a.mu.Unlock()
+	if rt != nil {
+		res, err := rt.StopCompositeRecording()
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		if res.Path != "" {
+			a.mu.Lock()
+			a.lastComposite = res.Path
+			a.mu.Unlock()
+		}
+	}
+	a.writeCompositeStatus(w)
+}
+
+func (a *app) handleCompositeStatus(w http.ResponseWriter, _ *http.Request) {
+	a.writeCompositeStatus(w)
+}
+
+func (a *app) writeCompositeStatus(w http.ResponseWriter) {
+	a.mu.Lock()
+	cs := a.compositeStatusLocked()
+	a.mu.Unlock()
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Cache-Control", "no-store")
+	_ = json.NewEncoder(w).Encode(cs)
+}
+
+// handleCompositeDownload serves the most recently completed composite WAV
+// as a file attachment. The in-progress file isn't offered because its WAV
+// header isn't patched until the recording is stopped.
+func (a *app) handleCompositeDownload(w http.ResponseWriter, r *http.Request) {
+	a.mu.Lock()
+	path := a.lastComposite
+	a.mu.Unlock()
+	if path == "" {
+		http.Error(w, "no completed composite recording yet — start one, transmit, then stop it", http.StatusNotFound)
+		return
+	}
+	if _, err := os.Stat(path); err != nil {
+		http.Error(w, "composite file missing: "+err.Error(), http.StatusNotFound)
+		return
+	}
+	w.Header().Set("Content-Type", "audio/wav")
+	w.Header().Set("Content-Disposition", `attachment; filename="`+filepath.Base(path)+`"`)
+	http.ServeFile(w, r, path)
+}
+
+// parsePortRefs turns "<node>.<port>" strings into PortRefs. An empty list
+// is allowed (the router defaults it to the first two ports).
+func parsePortRefs(ss []string) ([]config.PortRef, error) {
+	var refs []config.PortRef
+	for _, s := range ss {
+		s = strings.TrimSpace(s)
+		if s == "" {
+			continue
+		}
+		dot := strings.IndexByte(s, '.')
+		if dot <= 0 || dot >= len(s)-1 {
+			return nil, fmt.Errorf("invalid port ref %q (want <node>.<port>)", s)
+		}
+		refs = append(refs, config.PortRef{NodeID: s[:dot], PortID: s[dot+1:]})
+	}
+	return refs, nil
+}
+
 func (a *app) start() error {
 	a.mu.Lock()
 	defer a.mu.Unlock()
@@ -690,4 +865,3 @@ func resolveDirewolf(explicit string) (string, error) {
 	}
 	return "", errors.New("direwolf not found in $PATH or common locations")
 }
-
diff --git a/internal/audio/multiwav_test.go b/internal/audio/multiwav_test.go
new file mode 100644
index 0000000..c7569a1
--- /dev/null
+++ b/internal/audio/multiwav_test.go
@@ -0,0 +1,105 @@
+package audio
+
+import (
+	"encoding/binary"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestMultiWAVWriterStereoHeader(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "out.wav")
+
+	w, err := NewMultiWAVWriter(path, 2)
+	if err != nil {
+		t.Fatalf("NewMultiWAVWriter: %v", err)
+	}
+
+	// 3 interleaved stereo frames of BlockSamples each.
+	const nBlocks = 3
+	frameBytes := BlockBytes * 2 // 2 channels
+	for i := 0; i < nBlocks; i++ {
+		left := mkBlock(int16(1000 * (i + 1)))
+		right := mkBlock(int16(-1000 * (i + 1)))
+		if _, err := w.Write(Interleave([]Block{left, right})); err != nil {
+			t.Fatalf("Write: %v", err)
+		}
+	}
+	if err := w.Close(); err != nil {
+		t.Fatalf("Close: %v", err)
+	}
+
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("ReadFile: %v", err)
+	}
+
+	wantData := uint32(nBlocks * frameBytes)
+	if got := uint32(len(b)); got != wavHeaderBytes+wantData {
+		t.Fatalf("file length = %d, want %d", got, wavHeaderBytes+wantData)
+	}
+	if got := binary.LittleEndian.Uint16(b[22:24]); got != 2 {
+		t.Errorf("num channels = %d, want 2", got)
+	}
+	if got := binary.LittleEndian.Uint32(b[24:28]); got != SampleRate {
+		t.Errorf("sample rate = %d, want %d", got, SampleRate)
+	}
+	// byteRate = SampleRate * channels * 2
+	if got := binary.LittleEndian.Uint32(b[28:32]); got != SampleRate*2*2 {
+		t.Errorf("byte rate = %d, want %d", got, SampleRate*2*2)
+	}
+	// blockAlign = channels * 2
+	if got := binary.LittleEndian.Uint16(b[32:34]); got != 4 {
+		t.Errorf("block align = %d, want 4", got)
+	}
+	if got := binary.LittleEndian.Uint32(b[40:44]); got != wantData {
+		t.Errorf("data chunk size = %d, want %d", got, wantData)
+	}
+
+	// First interleaved frame: L sample = +1000, R sample = -1000.
+	l0 := int16(uint16(b[44]) | uint16(b[45])<<8)
+	r0 := int16(uint16(b[46]) | uint16(b[47])<<8)
+	if l0 != 1000 || r0 != -1000 {
+		t.Errorf("first frame = (L=%d,R=%d), want (1000,-1000)", l0, r0)
+	}
+}
+
+func TestInterleaveStereo(t *testing.T) {
+	// Two 2-sample mono blocks: L=[1,2], R=[3,4] → [1,3,2,4].
+	left := Block{1, 0, 2, 0}  // int16 LE: 1, 2
+	right := Block{3, 0, 4, 0} // int16 LE: 3, 4
+	out := Interleave([]Block{left, right})
+	want := []int16{1, 3, 2, 4}
+	if len(out) != len(want)*2 {
+		t.Fatalf("interleaved length = %d bytes, want %d", len(out), len(want)*2)
+	}
+	for i, w := range want {
+		got := int16(uint16(out[i*2]) | uint16(out[i*2+1])<<8)
+		if got != w {
+			t.Errorf("sample %d = %d, want %d", i, got, w)
+		}
+	}
+}
+
+func TestInterleaveAbsentChannelIsSilence(t *testing.T) {
+	// One channel has audio, the other is nil → that channel must still
+	// occupy its slot, padded with silence, so channels stay aligned.
+	left := mkBlock(5000)
+	out := Interleave([]Block{left, nil})
+	if len(out) != BlockBytes*2 {
+		t.Fatalf("interleaved length = %d, want %d", len(out), BlockBytes*2)
+	}
+	// Frame 0: L=5000, R=0.
+	l0 := int16(uint16(out[0]) | uint16(out[1])<<8)
+	r0 := int16(uint16(out[2]) | uint16(out[3])<<8)
+	if l0 != 5000 || r0 != 0 {
+		t.Errorf("frame 0 = (L=%d,R=%d), want (5000,0)", l0, r0)
+	}
+}
+
+func TestNewMultiWAVWriterRejectsZeroChannels(t *testing.T) {
+	if _, err := NewMultiWAVWriter(filepath.Join(t.TempDir(), "x.wav"), 0); err == nil {
+		t.Error("NewMultiWAVWriter(0) should error")
+	}
+}
diff --git a/internal/audio/wav.go b/internal/audio/wav.go
index 469f7d8..0a02b5b 100644
--- a/internal/audio/wav.go
+++ b/internal/audio/wav.go
@@ -30,7 +30,7 @@ func NewWAVWriter(path string) (*WAVWriter, error) {
 	if err != nil {
 		return nil, err
 	}
-	if err := writeWAVHeader(f, 0); err != nil {
+	if err := writeWAVHeader(f, 0, 1); err != nil {
 		_ = f.Close()
 		_ = os.Remove(path)
 		return nil, fmt.Errorf("write wav header: %w", err)
@@ -60,22 +60,116 @@ func (w *WAVWriter) Close() error {
 	// Best-effort header patch even if a previous Write errored: a partial
 	// file with the correct size in the header is still useful.
 	if _, err := w.f.Seek(0, io.SeekStart); err == nil {
-		_ = writeWAVHeader(w.f, w.written)
+		_ = writeWAVHeader(w.f, w.written, 1)
 	}
 	return w.f.Close()
 }
 
+// MultiWAVWriter streams interleaved N-channel 16-bit-LE PCM at
+// audio.SampleRate to a WAV file. It is the multi-track sibling of
+// WAVWriter — same crash-safety contract (header patched on Close) — used
+// by the composite recorder to write one transmitter per channel into a
+// single sample-aligned file.
+//
+// Callers hand Write fully-interleaved frames (sample 0 of every channel,
+// then sample 1 of every channel, …). Interleave builds those from a set
+// of per-channel mono blocks.
+type MultiWAVWriter struct {
+	f        *os.File
+	channels uint16
+	written  uint32 // bytes of PCM written so far (data chunk size)
+	closed   bool
+}
+
+// NewMultiWAVWriter creates path and writes an N-channel WAV header.
+// channels must be >= 1.
+func NewMultiWAVWriter(path string, channels int) (*MultiWAVWriter, error) {
+	if channels < 1 {
+		return nil, fmt.Errorf("wav: channels must be >= 1, got %d", channels)
+	}
+	f, err := os.Create(path)
+	if err != nil {
+		return nil, err
+	}
+	if err := writeWAVHeader(f, 0, uint16(channels)); err != nil {
+		_ = f.Close()
+		_ = os.Remove(path)
+		return nil, fmt.Errorf("write wav header: %w", err)
+	}
+	return &MultiWAVWriter{f: f, channels: uint16(channels)}, nil
+}
+
+// Write appends interleaved PCM bytes verbatim. The caller is responsible
+// for handing in correctly-formatted little-endian int16 frames matching
+// the channel count — Interleave produces exactly that.
+func (w *MultiWAVWriter) Write(b []byte) (int, error) {
+	if w.closed {
+		return 0, os.ErrClosed
+	}
+	n, err := w.f.Write(b)
+	w.written += uint32(n)
+	return n, err
+}
+
+// Close patches the two size fields and closes the file. Idempotent.
+func (w *MultiWAVWriter) Close() error {
+	if w.closed {
+		return nil
+	}
+	w.closed = true
+	if _, err := w.f.Seek(0, io.SeekStart); err == nil {
+		_ = writeWAVHeader(w.f, w.written, w.channels)
+	}
+	return w.f.Close()
+}
+
+// Interleave merges len(blocks) equal-length mono blocks into one
+// interleaved frame group: sample 0 of channel 0, sample 0 of channel 1,
+// …, sample 1 of channel 0, … Each input block is raw LE int16 mono PCM
+// (typically a BlockBytes-sized audio.Block). A nil or short block is
+// treated as silence so a channel with no audio this tick still advances
+// in lock-step with the others — that lock-step is what keeps every
+// channel sample-aligned to the same start time.
+func Interleave(blocks []Block) []byte {
+	n := len(blocks)
+	if n == 0 {
+		return nil
+	}
+	// Frame count is governed by the longest block; shorter/absent blocks
+	// pad with silence. In normal operation every block is BlockBytes.
+	maxBytes := 0
+	for _, b := range blocks {
+		if len(b) > maxBytes {
+			maxBytes = len(b)
+		}
+	}
+	samples := maxBytes / 2
+	out := make([]byte, samples*n*2)
+	for ch, b := range blocks {
+		for s := 0; s < samples; s++ {
+			lo, hi := byte(0), byte(0)
+			if i := s * 2; i+1 < len(b) {
+				lo, hi = b[i], b[i+1]
+			}
+			o := (s*n + ch) * 2
+			out[o] = lo
+			out[o+1] = hi
+		}
+	}
+	return out
+}
+
 // writeWAVHeader writes the canonical 44-byte RIFF/WAVE/fmt /data header
-// for mono 16-bit LE PCM at SampleRate. dataSize is the byte length of
-// the data chunk's PCM payload (0 at file creation; patched on Close).
-func writeWAVHeader(w io.Writer, dataSize uint32) error {
+// for numChannels-channel 16-bit LE PCM at SampleRate. dataSize is the
+// byte length of the data chunk's PCM payload (0 at file creation;
+// patched on Close).
+func writeWAVHeader(w io.Writer, dataSize uint32, numChannels uint16) error {
 	const (
-		numChannels   = 1
 		bitsPerSample = 16
-		byteRate      = SampleRate * numChannels * (bitsPerSample / 8)
-		blockAlign    = numChannels * (bitsPerSample / 8)
 		audioFormat   = 1 // PCM
 	)
+	byteRate := SampleRate * uint32(numChannels) * (bitsPerSample / 8)
+	blockAlign := numChannels * (bitsPerSample / 8)
 	hdr := make([]byte, 0, wavHeaderBytes)
 	hdr = append(hdr, []byte("RIFF")...)
 	hdr = binary.LittleEndian.AppendUint32(hdr, 36+dataSize)
diff --git a/internal/router/composite.go b/internal/router/composite.go
new file mode 100644
index 0000000..a2fb16c
--- /dev/null
+++ b/internal/router/composite.go
@@ -0,0 +1,375 @@
+package router
+
+import (
+	"errors"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/packethacking/net-sim/internal/audio"
+	"github.com/packethacking/net-sim/internal/config"
+)
+
+// compositeRecorder captures a chosen set of transmitters into a single,
+// real-time-paced, sample-aligned multi-channel WAV — one transmitter per
+// channel. For the canonical two-station case that is a stereo file with
+// one station's transmitted audio in each ear.
+//
+// Why this is separate from recordSession's per-port .tx.wav files: those
+// are written straight from txReader as samoyed *bursts* the audio (a
+// 500 ms frame can land in a few wall-clock ms), so they faithfully carry
+// the modulated waveform but are NOT a real-time timeline. The composite
+// recorder instead drains each transmitter's blocks through its own
+// real-time ticker — exactly the model rxFeeder uses to pace audio into
+// samoyed — so the resulting file is an accurate timeline of what was on
+// the air: overlapping transmissions overlap in time, inter-burst gaps are
+// preserved as real silence, and because every channel is advanced one
+// block per tick by a single goroutine they share one clock and one start
+// time.
+type compositeRecorder struct {
+	path     string
+	channels []config.PortRef
+	logger   *slog.Logger
+	started  time.Time
+
+	idx    map[config.PortRef]int // port → channel index
+	queues []chan audio.Block     // one per channel; single producer each
+	writer *audio.MultiWAVWriter
+
+	frames atomic.Int64 // interleaved frames written (one per block/channel-group)
+
+	done     chan struct{} // closed by stop() to request a graceful drain+close
+	stopped  chan struct{} // closed by the run goroutine when it has fully exited
+	stopOnce sync.Once
+
+	mu  sync.Mutex
+	err error // first write error, if any
+}
+
+// compositeQueueBlocks bounds each channel's pending-audio buffer. samoyed
+// emits a whole transmission as a near-instant burst, so the buffer must
+// hold the largest single keyup we expect to reconstruct in real time.
+// 60 s is far longer than any AX.25 burst yet only ~5 MB per channel.
+const compositeQueueBlocks = 60 * audio.SampleRate / audio.BlockSamples
+
+// compositeResult is returned from StopCompositeRecording for status
+// reporting and so callers (and external software) know what was written.
+type compositeResult struct {
+	Path     string
+	Channels []config.PortRef
+	Bytes    int64
+	Duration time.Duration
+}
+
+// CompositeStatus is a snapshot of the composite recorder for the HTTP
+// status endpoint.
+type CompositeStatus struct {
+	Active   bool
+	Path     string
+	Channels []config.PortRef
+	Duration time.Duration
+	Err      string
+}
+
+func newCompositeRecorder(base string, channels []config.PortRef, logger *slog.Logger) (*compositeRecorder, error) {
+	if base == "" {
+		return nil, errors.New("composite: no record base dir configured")
+	}
+	if len(channels) == 0 {
+		return nil, errors.New("composite: no transmitter ports selected")
+	}
+	if err := os.MkdirAll(base, 0o755); err != nil {
+		return nil, fmt.Errorf("composite: mkdir %q: %w", base, err)
+	}
+	idx := make(map[config.PortRef]int, len(channels))
+	for i, ref := range channels {
+		if _, dup := idx[ref]; dup {
+			return nil, fmt.Errorf("composite: port %s listed for more than one channel", ref)
+		}
+		idx[ref] = i
+	}
+
+	stamp := time.Now().UTC().Format("20060102T150405.000Z")
+	path := filepath.Join(base, "composite-"+stamp+".wav")
+	w, err := audio.NewMultiWAVWriter(path, len(channels))
+	if err != nil {
+		return nil, fmt.Errorf("composite: open %s: %w", path, err)
+	}
+
+	cr := &compositeRecorder{
+		path:     path,
+		channels: append([]config.PortRef(nil), channels...),
+		logger:   logger,
+		started:  time.Now(),
+		idx:      idx,
+		queues:   make([]chan audio.Block, len(channels)),
+		writer:   w,
+		done:     make(chan struct{}),
+		stopped:  make(chan struct{}),
+	}
+	for i := range cr.queues {
+		cr.queues[i] = make(chan audio.Block, compositeQueueBlocks)
+	}
+	go cr.run()
+	logger.Info("composite recording started", "file", path, "channels", channelStrings(channels))
+	return cr, nil
+}
+
+// feed routes one TX block to the channel ref maps to, if any. Called from
+// each port's txReader hot path. A port not in this recording is a cheap
+// map-miss. Each channel has a single producer (that port's txReader), so
+// the only contention is with the draining run goroutine, handled by the
+// buffered channel.
+func (cr *compositeRecorder) feed(ref config.PortRef, blk audio.Block) {
+	i, ok := cr.idx[ref]
+	if !ok {
+		return
+	}
+	q := cr.queues[i]
+	select {
+	case q <- blk:
+		return
+	default:
+	}
+	// Full: drop oldest to make room. Means a single keyup exceeded
+	// compositeQueueBlocks of audio — rare, and worth a line.
+	select {
+	case <-q:
+	default:
+	}
+	select {
+	case q <- blk:
+	default:
+	}
+	cr.logger.Warn("composite: queue overflow, dropping oldest", "port", ref)
+}
+
+// run is the real-time pacer. One block per channel per tick, interleaved
+// into the WAV. Idle channels emit silence so the timeline keeps advancing
+// and every channel stays sample-aligned.
+func (cr *compositeRecorder) run() {
+	defer close(cr.stopped)
+	period := time.Duration(audio.BlockSamples) * time.Second / audio.SampleRate
+	ticker := time.NewTicker(period)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-cr.done:
+			cr.drainRemaining()
+			cr.closeWriter()
+			return
+		case <-ticker.C:
+			if !cr.writeFrame() {
+				cr.closeWriter()
+				return
+			}
+		}
+	}
+}
+
+// collect pops at most one block from every channel queue, substituting
+// silence for idle channels. any reports whether at least one channel had
+// real audio this round (used by the stop-time drain to know when empty).
+func (cr *compositeRecorder) collect() (blocks []audio.Block, any bool) {
+	blocks = make([]audio.Block, len(cr.queues))
+	for i, q := range cr.queues {
+		select {
+		case b := <-q:
+			if len(b) == 0 {
+				b = audio.Silence()
+			}
+			blocks[i] = b
+			any = true
+		default:
+			blocks[i] = audio.Silence()
+		}
+	}
+	return blocks, any
+}
+
+// writeFrame writes one interleaved frame group. Returns false on a write
+// error (after recording it), which tells run to stop.
+func (cr *compositeRecorder) writeFrame() bool {
+	blocks, _ := cr.collect()
+	if _, err := cr.writer.Write(audio.Interleave(blocks)); err != nil {
+		cr.setErr(err)
+		cr.logger.Warn("composite: write failed, stopping", "file", cr.path, "err", err)
+		return false
+	}
+	cr.frames.Add(1)
+	return true
+}
+
+// drainRemaining flushes any blocks still queued at graceful stop, keeping
+// channels aligned (idle ones padded with silence) so the tail of an
+// in-flight transmission isn't lost.
+func (cr *compositeRecorder) drainRemaining() {
+	for {
+		blocks, any := cr.collect()
+		if !any {
+			return
+		}
+		if _, err := cr.writer.Write(audio.Interleave(blocks)); err != nil {
+			cr.setErr(err)
+			return
+		}
+		cr.frames.Add(1)
+	}
+}
+
+func (cr *compositeRecorder) closeWriter() {
+	if err := cr.writer.Close(); err != nil {
+		cr.setErr(err)
+	}
+}
+
+func (cr *compositeRecorder) setErr(err error) {
+	cr.mu.Lock()
+	if cr.err == nil {
+		cr.err = err
+	}
+	cr.mu.Unlock()
+}
+
+// stop requests a graceful drain + close and blocks until the run
+// goroutine has finished writing the file (so the WAV header is patched
+// and the file is safe to read / download). Idempotent.
+func (cr *compositeRecorder) stop() compositeResult {
+	cr.stopOnce.Do(func() { close(cr.done) })
+	<-cr.stopped
+	frames := cr.frames.Load()
+	res := compositeResult{
+		Path:     cr.path,
+		Channels: cr.channels,
+		Bytes:    frames * int64(len(cr.channels)) * 2,
+		Duration: time.Duration(frames) * time.Second * audio.BlockSamples / audio.SampleRate,
+	}
+	cr.logger.Info("composite recording stopped", "file", cr.path,
+		"duration", res.Duration.Round(time.Millisecond))
+	return res
+}
+
+func (cr *compositeRecorder) status() CompositeStatus {
+	frames := cr.frames.Load()
+	cr.mu.Lock()
+	errStr := ""
+	if cr.err != nil {
+		errStr = cr.err.Error()
+	}
+	cr.mu.Unlock()
+	return CompositeStatus{
+		Active:   true,
+		Path:     cr.path,
+		Channels: cr.channels,
+		Duration: time.Duration(frames) * time.Second * audio.BlockSamples / audio.SampleRate,
+		Err:      errStr,
+	}
+}
+
+func channelStrings(refs []config.PortRef) []string {
+	out := make([]string, len(refs))
+	for i, r := range refs {
+		out[i] = r.String()
+	}
+	return out
+}
+
+// --- Router-level API ------------------------------------------------------
+
+// StartCompositeRecording begins a composite recording of the given
+// transmitter ports — one WAV channel per port, in the order given (channel
+// 0 = first port = left ear in the stereo case). If ports is empty it
+// defaults to the topology's first two ports, which is exactly the
+// "two-station, one per ear" case. Returns the file path being written.
+//
+// It is an error to call this when a composite recording is already
+// running, when no RecordDir is configured, or when a named port doesn't
+// exist in the topology.
+func (r *Router) StartCompositeRecording(ports []config.PortRef) (string, error) {
+	r.compositeMu.Lock()
+	defer r.compositeMu.Unlock()
+	if r.opts.RecordDir == "" {
+		return "", errors.New("composite: no RecordDir configured")
+	}
+	if r.composite.Load() != nil {
+		return "", errors.New("composite: already recording")
+	}
+
+	valid := r.portRefSet()
+	if len(ports) == 0 {
+		ports = r.defaultCompositePorts()
+	}
+	if len(ports) == 0 {
+		return "", errors.New("composite: topology has no ports to record")
+	}
+	for _, p := range ports {
+		if _, ok := valid[p]; !ok {
+			return "", fmt.Errorf("composite: unknown port %s", p)
+		}
+	}
+
+	cr, err := newCompositeRecorder(r.opts.RecordDir, ports, r.logger)
+	if err != nil {
+		return "", err
+	}
+	r.composite.Store(cr)
+	return cr.path, nil
+}
+
+// StopCompositeRecording finalises the current composite recording (drains
+// in-flight audio, patches the WAV header) and returns its result. No error
+// and a zero result if nothing was recording.
+func (r *Router) StopCompositeRecording() (compositeResult, error) {
+	r.compositeMu.Lock()
+	defer r.compositeMu.Unlock()
+	cr := r.composite.Swap(nil)
+	if cr == nil {
+		return compositeResult{}, nil
+	}
+	return cr.stop(), nil
+}
+
+// CompositeActive reports whether a composite recording is in progress.
+func (r *Router) CompositeActive() bool { return r.composite.Load() != nil }
+
+// CompositeStatus returns a snapshot of the composite recorder, or a
+// zero-value (Active=false) status when none is running.
+func (r *Router) CompositeStatus() CompositeStatus {
+	if cr := r.composite.Load(); cr != nil {
+		return cr.status()
+	}
+	return CompositeStatus{}
+}
+
+// AllPortRefs returns every port in the topology in declaration order.
+func (r *Router) AllPortRefs() []config.PortRef {
+	var refs []config.PortRef
+	for _, n := range r.cfg.Nodes {
+		for _, p := range n.Ports {
+			refs = append(refs, config.PortRef{NodeID: n.ID, PortID: p.ID})
+		}
+	}
+	return refs
+}
+
+func (r *Router) portRefSet() map[config.PortRef]struct{} {
+	set := map[config.PortRef]struct{}{}
+	for _, ref := range r.AllPortRefs() {
+		set[ref] = struct{}{}
+	}
+	return set
+}
+
+// defaultCompositePorts picks the first up-to-two ports for the no-argument
+// "two-station, one per ear" default.
+func (r *Router) defaultCompositePorts() []config.PortRef {
+	all := r.AllPortRefs()
+	if len(all) > 2 {
+		all = all[:2]
+	}
+	return all
+}
diff --git a/internal/router/composite_test.go b/internal/router/composite_test.go
new file mode 100644
index 0000000..a16b4e3
--- /dev/null
+++ b/internal/router/composite_test.go
@@ -0,0 +1,255 @@
+package router
+
+import (
+	"encoding/binary"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/packethacking/net-sim/internal/audio"
+	"github.com/packethacking/net-sim/internal/config"
+)
+
+func twoNodeCfg() *config.Config {
+	return &config.Config{
+		Nodes: []config.Node{
+			{ID: "a", Ports: []config.Port{{ID: "vhf"}}},
+			{ID: "b", Ports: []config.Port{{ID: "vhf"}}},
+			{ID: "c", Ports: []config.Port{{ID: "vhf"}}},
+		},
+	}
+}
+
+func newTestRouter(t *testing.T) *Router {
+	t.Helper()
+	return &Router{
+		opts:   Options{RecordDir: t.TempDir()},
+		cfg:    twoNodeCfg(),
+		logger: quietLogger(),
+	}
+}
+
+// readWAVChannels returns the channel count from a WAV header.
+func readWAVChannels(t *testing.T, path string) uint16 {
+	t.Helper()
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read %s: %v", path, err)
+	}
+	if len(b) < 44 {
+		t.Fatalf("%s too short: %d bytes", path, len(b))
+	}
+	return binary.LittleEndian.Uint16(b[22:24])
+}
+
+func wavDataBytes(t *testing.T, path string) uint32 {
+	t.Helper()
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read %s: %v", path, err)
+	}
+	return binary.LittleEndian.Uint32(b[40:44])
+}
+
+func TestCompositeStartStopProducesStereoFile(t *testing.T) {
+	r := newTestRouter(t)
+
+	a := config.PortRef{NodeID: "a", PortID: "vhf"}
+	b := config.PortRef{NodeID: "b", PortID: "vhf"}
+
+	path, err := r.StartCompositeRecording([]config.PortRef{a, b})
+	if err != nil {
+		t.Fatalf("StartCompositeRecording: %v", err)
+	}
+	// Reliable teardown of the ticker goroutine even if an assertion below
+	// fails before the explicit stop (StopCompositeRecording is idempotent).
+	defer r.StopCompositeRecording()
+	if !r.CompositeActive() {
+		t.Fatal("CompositeActive should be true after start")
+	}
+
+	// Feed only channel A (left). After stop+drain, both channels must
+	// still be present and equal length (B padded with silence).
+	cr := r.composite.Load()
+	const n = 8
+	for i := 0; i < n; i++ {
+		cr.feed(a, mkBlockN(int16(2000+i)))
+	}
+
+	res, err := r.StopCompositeRecording()
+	if err != nil {
+		t.Fatalf("StopCompositeRecording: %v", err)
+	}
+	if r.CompositeActive() {
+		t.Fatal("CompositeActive should be false after stop")
+	}
+	if res.Path != path {
+		t.Errorf("result path = %q, want %q", res.Path, path)
+	}
+	if got := readWAVChannels(t, path); got != 2 {
+		t.Errorf("channels = %d, want 2 (stereo)", got)
+	}
+
+	// At least the 8 fed blocks must have been written (real-time ticks
+	// may have added silence frames before stop; never fewer than 8).
+	wantMin := uint32(n * audio.BlockBytes * 2) // 2 channels
+	if got := wavDataBytes(t, path); got < wantMin {
+		t.Errorf("data bytes = %d, want >= %d", got, wantMin)
+	}
+	// Data must be a whole number of stereo frames.
+	if got := wavDataBytes(t, path); got%uint32(audio.BlockBytes*2) != 0 {
+		t.Errorf("data bytes = %d not a multiple of stereo frame size", got)
+	}
+}
+
+// mkBlockN builds a full BlockBytes mono block at a constant level.
+func mkBlockN(level int16) audio.Block {
+	b := make(audio.Block, audio.BlockBytes)
+	for i := 0; i+1 < audio.BlockBytes; i += 2 {
+		b[i] = byte(uint16(level))
+		b[i+1] = byte(uint16(level) >> 8)
+	}
+	return b
+}
+
+func TestCompositeDefaultsToFirstTwoPorts(t *testing.T) {
+	r := newTestRouter(t)
+	path, err := r.StartCompositeRecording(nil)
+	if err != nil {
+		t.Fatalf("StartCompositeRecording(nil): %v", err)
+	}
+	defer r.StopCompositeRecording()
+
+	cr := r.composite.Load()
+	if len(cr.channels) != 2 {
+		t.Fatalf("default channels = %d, want 2", len(cr.channels))
+	}
+	if cr.channels[0].String() != "a.vhf" || cr.channels[1].String() != "b.vhf" {
+		t.Errorf("default channels = %v, want [a.vhf b.vhf]", cr.channels)
+	}
+	if got := readWAVChannels(t, path); got != 2 {
+		t.Errorf("channels = %d, want 2", got)
+	}
+}
+
+func TestCompositeRejectsUnknownPort(t *testing.T) {
+	r := newTestRouter(t)
+	_, err := r.StartCompositeRecording([]config.PortRef{{NodeID: "x", PortID: "y"}})
+	if err == nil {
+		t.Fatal("StartCompositeRecording with unknown port should error")
+	}
+}
+
+func TestCompositeRejectsDoubleStart(t *testing.T) {
+	r := newTestRouter(t)
+	if _, err := r.StartCompositeRecording(nil); err != nil {
+		t.Fatalf("first start: %v", err)
+	}
+	defer r.StopCompositeRecording()
+	if _, err := r.StartCompositeRecording(nil); err == nil {
+		t.Error("second StartCompositeRecording should fail (already recording)")
+	}
+}
+
+func TestCompositeRejectsNoRecordDir(t *testing.T) {
+	r := &Router{opts: Options{}, cfg: twoNodeCfg(), logger: quietLogger()}
+	if _, err := r.StartCompositeRecording(nil); err == nil {
+		t.Error("StartCompositeRecording with no RecordDir should error")
+	}
+}
+
+func TestCompositeStopWhenIdleIsNoError(t *testing.T) {
+	r := newTestRouter(t)
+	res, err := r.StopCompositeRecording()
+	if err != nil {
+		t.Errorf("StopCompositeRecording with no session: %v", err)
+	}
+	if res.Path != "" {
+		t.Errorf("idle stop result path = %q, want empty", res.Path)
+	}
+}
+
+func TestCompositeRejectsDuplicatePort(t *testing.T) {
+	r := newTestRouter(t)
+	a := config.PortRef{NodeID: "a", PortID: "vhf"}
+	if _, err := r.StartCompositeRecording([]config.PortRef{a, a}); err == nil {
+		t.Error("StartCompositeRecording with a duplicate port should error")
+	}
+}
+
+// TestCompositeRealTimePacing verifies the recorder advances the timeline
+// in real time even when channels are idle: after running ~150 ms with no
+// fed audio, the file should hold roughly that many silent frames.
+func TestCompositeRealTimePacing(t *testing.T) {
+	r := newTestRouter(t)
+	path, err := r.StartCompositeRecording(nil)
+	if err != nil {
+		t.Fatalf("start: %v", err)
+	}
+	defer r.StopCompositeRecording()
+	time.Sleep(150 * time.Millisecond)
+	r.StopCompositeRecording()
+
+	frames := wavDataBytes(t, path) / uint32(audio.BlockBytes*2)
+	// 150 ms / 10 ms = ~15 frames. Allow generous slack for scheduling.
+	if frames < 5 || frames > 60 {
+		t.Errorf("frames after ~150ms = %d, want roughly 15 (5..60)", frames)
+	}
+}
+
+// TestCompositeConcurrentFeed exercises the real producer/consumer path:
+// two goroutines feed two channels while the ticker goroutine drains and
+// writes them. Run under -race this catches any unsynchronised access to
+// the queues / writer / counters.
+func TestCompositeConcurrentFeed(t *testing.T) {
+	r := newTestRouter(t)
+	a := config.PortRef{NodeID: "a", PortID: "vhf"}
+	b := config.PortRef{NodeID: "b", PortID: "vhf"}
+	path, err := r.StartCompositeRecording([]config.PortRef{a, b})
+	if err != nil {
+		t.Fatalf("start: %v", err)
+	}
+	defer r.StopCompositeRecording()
+	cr := r.composite.Load()
+
+	done := make(chan struct{})
+	feeder := func(ref config.PortRef) {
+		defer func() { done <- struct{}{} }()
+		for i := 0; i < 200; i++ {
+			cr.feed(ref, mkBlockN(int16(i)))
+			time.Sleep(time.Millisecond)
+		}
+	}
+	go feeder(a)
+	go feeder(b)
+	<-done
+	<-done
+
+	res, err := r.StopCompositeRecording()
+	if err != nil {
+		t.Fatalf("stop: %v", err)
+	}
+	if got := readWAVChannels(t, path); got != 2 {
+		t.Errorf("channels = %d, want 2", got)
+	}
+	// 200 blocks per channel were fed; the file must contain at least that
+	// many frames (drain flushes any backlog at stop).
+	if frames := wavDataBytes(t, path) / uint32(audio.BlockBytes*2); frames < 200 {
+		t.Errorf("frames = %d, want >= 200", frames)
+	}
+	if res.Bytes <= 0 {
+		t.Errorf("result bytes = %d, want > 0", res.Bytes)
+	}
+}
+
+func TestAllPortRefs(t *testing.T) {
+	r := newTestRouter(t)
+	refs := r.AllPortRefs()
+	if len(refs) != 3 {
+		t.Fatalf("AllPortRefs = %d, want 3", len(refs))
+	}
+	if filepath.Base(refs[0].String()) != "a.vhf" {
+		t.Errorf("first ref = %s, want a.vhf", refs[0])
+	}
+}
diff --git a/internal/router/router.go b/internal/router/router.go
index d5bb256..b782b4f 100644
--- a/internal/router/router.go
+++ b/internal/router/router.go
@@ -122,6 +122,12 @@ type Router struct {
 	session  atomic.Pointer[recordSession]
 	recordMu sync.Mutex
 
+	// composite is the active composite (multi-channel TX timeline)
+	// recorder, or nil. Read on the txReader hot path, so atomic.
+	// compositeMu serialises Start/StopCompositeRecording and shutdown.
+	composite   atomic.Pointer[compositeRecorder]
+	compositeMu sync.Mutex
+
 	// txTrackers — one per port — record the wall-clock time of each
 	// port's last above-threshold TX block. The txWatchdog goroutine
 	// fires tx_end when a tracker hasn't been bumped within
@@ -340,6 +346,9 @@ func (r *Router) shutdown() error {
 	if s := r.session.Swap(nil); s != nil {
 		s.Close()
 	}
+	if cr := r.composite.Swap(nil); cr != nil {
+		cr.stop()
+	}
 	return nil
 }
 
@@ -462,6 +471,9 @@ func (r *Router) txReader(ctx context.Context, ref config.PortRef, c *tnc.Child)
 			if s := r.session.Load(); s != nil {
 				s.WriteTX(ref, blk)
 			}
+			if cr := r.composite.Load(); cr != nil {
+				cr.feed(ref, blk)
+			}
 			if r.opts.AudioTap != nil {
 				key := ref.String() + "|tx"
 				if r.opts.AudioTap.HasSubscribers(key) {