@hraness/dawg 0.7.0 → 0.8.0

package/src/main.ts

@@ -1,6 +1,9 @@
 #!/usr/bin/env bun
 import { TOPIC_ALIASES } from "./lang/glossary.ts";
 import { isGuideInstrument, vocalChainPatch } from "../core/clips.ts";
+import { newId } from "../core/ids.ts";
+import { deepEqual, DiffError, diffScores } from "../core/diff.ts";
+import { currentActor } from "./identity/actor.ts";
 import { isSingWord } from "../core/sing.ts";
 import { commandParses, parseExact } from "./commands/parses.ts";
 import { paramRangeError } from "./commands/param-range.ts";
@@ -35,7 +38,7 @@ import {
   unknownInstrumentMessage,
 } from "./audio/instrument-check.ts";
 import { randomUUID } from "node:crypto";
-import { readFileSync, writeSync } from "node:fs";
+import { appendFileSync, readFileSync, writeSync } from "node:fs";
 import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, relative, resolve } from "node:path";
@@ -51,8 +54,14 @@ import {
   editedTrack,
   foreignEvents,
   otherWindowName,
+  paneLetters,
 } from "./session/origin.ts";
-import { compositionDigest, monotonicEpochMs } from "./session/protocol.ts";
+import {
+  compositionDigest,
+  monotonicEpochMs,
+  type PaneView,
+  type PresenceEntry,
+} from "./session/protocol.ts";
 import {
   formatSessionLine,
   listSessions,
@@ -87,6 +96,7 @@ import { kitCatalog } from "./audio/kits.ts";
 import { applyEditCommand, parseEditCommand } from "./commands/edit.ts";
 import { applyTimeCommand, parseTimeCommand } from "./commands/time.ts";
 import {
+  barAt,
   barStartTick,
   bpmAtTick,
   hasMeterChanges,
@@ -145,6 +155,7 @@ import {
   applyKeysCommand,
   newPianoTrack,
   parseKeysCommand,
+  parseRecordCommand,
 } from "./commands/keys.ts";
 import {
   applyTuningCommand,
@@ -169,6 +180,12 @@ import {
   loopSpan,
   parseSectionCommand,
 } from "./commands/arrange.ts";
+import {
+  applyRangeCommand,
+  parseRangeCommand,
+  type RangeClipboard,
+} from "./commands/range.ts";
+import { rangeLabel } from "../core/range.ts";
 import {
   helpMiss,
   helpText,
@@ -181,6 +198,7 @@ import {
 import {
   historyReceipt,
   historyTarget,
+  paneHistoryStep,
   REDO_KIND,
   UNDO_KIND,
 } from "./commands/history.ts";
@@ -291,7 +309,12 @@ import {
   tuiSetModel,
 } from "./auth/tui.ts";
 import { TransportClock, transportMapFor } from "./audio/clock.ts";
-import { AudioEngine } from "./audio/engine.ts";
+import {
+  AudioEngine,
+  detectAudioBackend,
+  type AudioBackendInfo,
+} from "./audio/engine.ts";
+import { audioMenuState, runAudioCommand } from "./audio/audio-command.ts";
 import {
   DEFAULT_GRID,
   GRIDS,
@@ -303,9 +326,32 @@ import {
   EditMenu,
   menuUsage,
   menuSectionPath,
+  type MenuAudioDevices,
   type MenuContext,
 } from "./tui/menu.ts";
+import { KNOB_PAGE_WORDS, knobPageId } from "./tui/knob-map.ts";
+import {
+  beatOfBar,
+  cutArmed,
+  focusCommand,
+  foldBase,
+  knobNoun,
+  tapeKey,
+  tapeKnobs,
+  type TapeContext,
+} from "./tui/tape-mode.ts";
+import { tapeView } from "./tui/tape-view.ts";
+import { TAPE_ZOOMS, type TapeView, type TapeZoom } from "../tui/tape.ts";
+import type { HitTarget } from "../tui/hits.ts";
+import { knobKey, type KnobState } from "../tui/knobs.ts";
+import {
+  clipboardPath,
+  loadClipboard,
+  saveClipboard,
+} from "./session/clipboard.ts";
+import { extractRange } from "../core/range.ts";
 import {
+  drawerAside,
   drawerView,
   faderChoose,
   faderCommand,
@@ -340,7 +386,13 @@ import {
   type KeySection,
 } from "../tui/grammar.ts";
 import { renderAudition } from "./audio/audition.ts";
-import { exportScore, playbackTime, scoreBeatAt } from "./audio/arrange.ts";
+import {
+  exportScore,
+  loopedSection,
+  playbackTime,
+  scoreBeatAt,
+} from "./audio/arrange.ts";
+import { loopFlash, reelGlyph } from "../tui/delight.ts";
 import { formatForm } from "../core/sections.ts";
 import type { ArrangeStripView } from "../tui/arrange-strip.ts";
 import { renderScorePcm } from "./audio/wav.ts";
@@ -381,6 +433,7 @@ import {
   packCredits,
   writeCredits,
 } from "./audio/packs.ts";
+import { SharedLiveEngine, type LiveLink } from "./session/shared-live.ts";
 import {
   addNote,
   applyScoreOperation,
@@ -413,12 +466,15 @@ import {
 import {
   CARD_GLOW_MS,
   composeFrame,
+  isTooSmall,
+  tooSmallKey,
   TuiApp,
   type AppView,
   type LoudnessView,
   type SyncState,
   type TypesIndicator,
 } from "../tui/app.ts";
+import type { DrawerView } from "../tui/drawer.ts";
 import { fail, note, ok, toneOf, warn, type Receipt } from "../tui/activity.ts";
 import { systemRunner } from "./auth/runner.ts";
 import type { MediaServices } from "./media/types.ts";
@@ -428,6 +484,8 @@ import { formatDiagnostic } from "../core/sdk/eval.ts";
 import { isProject } from "./project/init.ts";
 import {
   parseLaunchArgs,
+  parsePaneArgs,
+  type PaneArgs,
   parseSimpleArgv,
   resolveTrackArg,
 } from "./launch-args.ts";
@@ -685,8 +743,11 @@ const session = await ensureSession(initial.toJSON(), {
   ...sessionOptions,
   ...(ephemeralWorkspace ? { workspace: ephemeralWorkspace } : {}),
 });
+// Who is at this window; also salts collision-free ids (core/ids.ts).
+const actor = await currentActor();
 // dawgd when connected, the file-lock path otherwise (see src/session/port.ts).
 let port = await openSessionPort<ReturnType<TrackScore["toJSON"]>>({
+  actor,
   paths: session.paths,
   sessionId: session.record.sessionId,
   label: explicitTrack ?? "window",
@@ -731,6 +792,8 @@ if (!draftTrack) await ensureFocusedTrack();
 
 const clock = new TransportClock(score.tempoBpm);
 let audio = port.player;
+let audioInfoCache: AudioBackendInfo | undefined;
+let audioMenuCache: { at: number; state: MenuAudioDevices } | undefined;
 /** Session and today's spend, from the usage each response reports. */
 const meter = new SpendMeter(configDir());
 void meter.load().catch(() => undefined);
@@ -748,6 +811,16 @@ const tui = new TuiApp({
 });
 let syncState: SyncState = port.sync;
 let windowCount = 1;
+/** Pin and follow (§12.5): set by `dawg pane …`, `pin` and `follow`. */
+const paneOptions: { pinned: boolean; follow: string | undefined } = {
+  pinned: false,
+  follow: undefined,
+};
+/** Every pane on this session, as the last presence push listed them. */
+let panePresence: readonly PresenceEntry[] = [];
+/** The last view this pane reported (JSON), so unchanged views stay quiet. */
+let reportedView = "";
+let sharedLive: { link: LiveLink; engine: SharedLiveEngine } | undefined;
 /** Project file sync when `dawg.json` is in the working directory. */
 let projectSync: ProjectSync | undefined;
 let packStore: PackStore | undefined;
@@ -792,14 +865,47 @@ const AGENT_PREVIEW_VOICE = 0x7fff_0002;
 const CHORDS_COMMAND = /^\/chords\s+(.+)$/i;
 /** Whether the chord settings screen was open at the last menu redraw. */
 let chordScreenWas = false;
+/** The range clipboard (`copy bass 5-6`, then `paste at 9`); per window. */
+let rangeClipboard: RangeClipboard | undefined;
+/**
+ * TAPE (op1-ux §6): on, its zoom, its knob strip, the last view painted
+ * (mouse hits map cells to bars through it), a ruler drag in progress, and
+ * the pending cut (the score before and after its clear) so the first
+ * paste after it runs `move` against the score the cut came from.
+ */
+const tape: {
+  on: boolean;
+  zoom: TapeZoom;
+  knobs: KnobState;
+  view?: TapeView | undefined;
+  drag?: { from: number; to: number; left: number; first: number } | undefined;
+  cut?: { before: TrackScore; after?: TrackScore | undefined } | undefined;
+  /** Set by `x`: the score before it, until its `clear` lands. */
+  cutArmed?: TrackScore | undefined;
+  /** Set by the first `v` after a cut: its `move` reads `cut.before`. */
+  foldArmed?: boolean | undefined;
+  /**
+   * Where a paste's queued `jump` will put the playhead (a score beat),
+   * so a quick `v v v` tiles before that jump has run.
+   */
+  pending?: { beat: number; until: number } | undefined;
+} = { on: false, zoom: "beat", knobs: { selected: 0 } };
 let stageCapture: { next?: TrackScore; committed?: TrackScore } | undefined;
 /** Redraw soon (the audition reports renders between frames). */
 let requestFrame: () => void = () => undefined;
 /** Queue a prompt to run as if typed (set by the interactive loop). */
 let runPromptLater: (command: string) => void = () => undefined;
+/** Queue several prompts, in order, ahead of anything already queued. */
+let runPromptsLater: (commands: readonly string[]) => void = () => undefined;
 /** The fader drawer's focus and typing, while one is open over the menu. */
 let fader: FaderState | undefined;
 /** Show-me state (see the show-me section below). */
+/** A TAPE gesture's typed command, echoed dimly in the prompt row. */
+const gestureEcho: {
+  text?: string | undefined;
+  clear?: ReturnType<typeof setTimeout> | undefined;
+} = {};
+
 const showMe: {
   level: ShowMeLevel;
   ghost?: string | undefined;
@@ -1004,6 +1110,7 @@ function snapshot(
       : value.tempoBpm,
     key: value.key ?? undefined,
     loopBeats: loopTicksOf(value) / value.ticksPerBeat,
+    ...(value.loop ? { loopRange: value.loop } : {}),
     beatsPerBar: value.beatsPerBar,
     ...(hasMeterChanges(value)
       ? {
@@ -1074,12 +1181,16 @@ function appView(value: TrackScore, beat: number): AppView {
     showMe:
       showMe.ghost || showMe.caption
         ? { ghost: showMe.ghost, caption: showMe.caption }
-        : undefined,
+        : gestureEcho.text
+          ? { caption: gestureEcho.text }
+          : undefined,
     sync: syncState,
     sessionName: record.meta.name,
     windows: windowCount,
+    pane: port.pane,
     types: typesIndicator,
     play: play?.on ? play.header() : undefined,
+    tape: tape.on && !play?.on ? currentTapeView(value, beat) : undefined,
     loudness: masterLoudness(value),
   };
 }
@@ -1403,6 +1514,9 @@ async function runInteractive(): Promise<void> {
   // Builds a frame only when something can have changed (tui/frame-gate.ts):
   // an idle editor no longer rebuilds the whole view 30 times a second.
   const frameGate = new FrameGate(IDLE_HEARTBEAT_MS, MIN_FRAME_GAP_MS);
+  // `DAWG_FRAME_LOG=<file>`: one `WxH ms bytes` line per frame (the size
+  // matrix in test/sizes-lib.ts reads frame times from it).
+  const frameLog = process.env.DAWG_FRAME_LOG;
   const unwatchActivity = tui.activity.subscribe(() => frameGate.markDirty());
   const animating = (): boolean => {
     if (clock.playing || play?.on || auditionLoop?.looping) return true;
@@ -1418,6 +1532,7 @@ async function runInteractive(): Promise<void> {
   };
   const tick = (force = false) => {
     if (screenSuspended) return;
+    reportView();
     if (
       !frameGate.shouldBuild({
         nowMs: Date.now(),
@@ -1430,6 +1545,7 @@ async function runInteractive(): Promise<void> {
           record.meta.name,
           syncState,
           windowCount,
+          panePresence,
           typesIndicator,
           menu.open,
           euclid.open,
@@ -1448,7 +1564,12 @@ async function runInteractive(): Promise<void> {
     // The gate already paces frames; the app's own throttle would drop an
     // approved frame that lands just after a forced one, and the gate would
     // not ask again until the heartbeat.
-    tui.render(appView(score, clock.beatAt()), { force: true });
+    const out = tui.render(appView(score, clock.beatAt()), { force: true });
+    if (frameLog)
+      appendFileSync(
+        frameLog,
+        `${stdout.columns ?? 0}x${stdout.rows ?? 0} ${tui.lastRenderMs.toFixed(3)} ${out.length}\n`,
+      );
   };
   requestFrame = () => tick(true);
   // The first wrap is remembered per song in .dawg metadata, never the score.
@@ -1462,6 +1583,10 @@ async function runInteractive(): Promise<void> {
     queuedPrompts.unshift(command);
     void drainQueue();
   };
+  runPromptsLater = (commands) => {
+    queuedPrompts.unshift(...commands);
+    void drainQueue();
+  };
   reportAgentActivity = () => {
     tui.activity.applyAgentEvent({ type: "start", model: providerName });
   };
@@ -1488,10 +1613,7 @@ async function runInteractive(): Promise<void> {
   };
   stdout.on("resize", onResize);
   const ownWrites = new OwnWrites();
-  let presenceClients: readonly {
-    clientId: string;
-    focusedTrackId?: string | null;
-  }[] = [];
+  let presenceClients: readonly PresenceEntry[] = [];
   let applying: Promise<void> = Promise.resolve();
   const applyLatest = (latest: typeof record): Promise<void> =>
     (applying = applying.then(() => applyRecord(latest)));
@@ -1544,10 +1666,33 @@ async function runInteractive(): Promise<void> {
         const from = shownRevision(record, previousRevision);
         const to = shownRevision(record);
         await ownWrites.settled();
-        const foreign = foreignEvents(latest, previousRevision, ownWrites).some(
-          (event) => event.kind !== "transport",
+        const foreignList = foreignEvents(
+          latest,
+          previousRevision,
+          ownWrites,
+        ).filter((event) => event.kind !== "transport");
+        const foreign = foreignList.length > 0;
+        // dawgd stamps each event's author: another pane's edit is its
+        // letter and what it touched, only when it touches this pane's
+        // track (§12.7); no "synced from another window" card.
+        const letters = paneLetters(
+          foreignList,
+          presenceClients,
+          port.clientId,
         );
-        if (to !== from && foreign)
+        if (to !== from && foreign && letters.length > 0) {
+          const edited = editedTrack(before, scoreFromJSON(latest.composition));
+          if (edited === undefined || edited === requestedTrack)
+            tui.activity.pushCard(
+              `${letters.join(" ")} ✓ ${
+                edited
+                  ? (score.tracks.find((track) => track.id === edited)?.name ??
+                    edited)
+                  : "song"
+              }`,
+              { tone: "info", baseRevision: from, resultRevision: to },
+            );
+        } else if (to !== from && foreign)
           tui.activity.pushCard(
             `synced · ${otherWindowName(presenceClients, port.clientId, {
               editedTrackId: editedTrack(
@@ -1571,6 +1716,8 @@ async function runInteractive(): Promise<void> {
     } else if (update.type === "meta") adoptMeta(update.meta);
     else if (update.type === "presence") {
       presenceClients = update.clients;
+      followPresence(panePresence, update.clients);
+      panePresence = update.clients;
       windowCount = update.clients.length;
     } else if (update.type === "sync") syncState = update.sync;
     else if (update.type === "transport") {
@@ -1603,6 +1750,7 @@ async function runInteractive(): Promise<void> {
       .presence()
       .then((clients) => {
         presenceClients = clients;
+        panePresence = clients;
         windowCount = Math.max(1, clients.length);
       })
       .catch(() => undefined);
@@ -1616,6 +1764,7 @@ async function runInteractive(): Promise<void> {
     syncState = port.sync;
     unsubscribe = subscribeLive();
     refreshPresence();
+    reportedView = "";
   };
   if (freshWorkspace)
     tui.activity.pushCard("created .dawg/ · add it to .gitignore", {
@@ -1638,6 +1787,7 @@ async function runInteractive(): Promise<void> {
   void currentProvider().then(() => tick(true));
   tickUi = () => tick(true);
   reportSampleProblems(score);
+  if (launchArgs?.pane) void openPane(launchArgs.pane).then(() => tick(true));
   // Input arrives through a detachable listener (not `for await`), so /login
   // can hand the terminal to an interactive shell flow and take it back.
   const inbox: string[] = [];
@@ -1718,6 +1868,22 @@ async function runInteractive(): Promise<void> {
             ];
       while (values.length) {
         const value = values.shift()!;
+        // Below the minimum size only quit and play work; the hidden UI keeps
+        // its state for when the terminal grows back (tui/app.ts).
+        if (
+          isTooSmall({ width: stdout.columns ?? 80, height: stdout.rows ?? 24 })
+        ) {
+          const key = tooSmallKey(value);
+          if (key === "quit") {
+            exiting = true;
+            break;
+          }
+          if (key === "play")
+            void toggleTransport()
+              .catch((error: unknown) => transportFailed(error))
+              .finally(() => tick(true));
+          continue;
+        }
         // A mouse report acts on what the last frame painted under it; some
         // become keys (a list row, a wheel notch) and run through below.
         if (typeof value === "string" && isMouseSequence(value)) {
@@ -1728,6 +1894,14 @@ async function runInteractive(): Promise<void> {
         }
         // The fader drawer owns every key while it is up.
         if (typeof value === "string" && fader && menu.open) {
+          // Tab flips the knob front page and every param (design §8.6).
+          if (value === "\t" && menu.knobPage && fader.typing === undefined) {
+            const label = menu.pageKnobs(menuContext(), fader.label);
+            if (label) fader.label = label;
+            refreshMenu();
+            tick(true);
+            continue;
+          }
           const result = faderKeyPress(
             fader,
             menu.faderFields(menuContext()),
@@ -1803,7 +1977,10 @@ async function runInteractive(): Promise<void> {
               }
             } else if (result.type === "audition")
               auditionKeyPressed(result.key);
-            else if (result.type === "fader") openFader(result.label);
+            else if (result.type === "fader")
+              openFader(
+                menu.openKnobs(menuContext(), result.label) ?? result.label,
+              );
             else if (result.type === "revert") revertStaged();
             else if (result.type === "hover")
               hoverItem(result.command, result.key);
@@ -1852,6 +2029,20 @@ async function runInteractive(): Promise<void> {
           tick(true);
           continue;
         }
+        if (typeof value === "string" && tape.on && tapeInput(value)) {
+          tick(true);
+          continue;
+        }
+        // Ctrl-T opens TAPE (op1-ux §6); again (or esc) goes home.
+        if (value === "\u0014" && tui.ui.overlay === undefined) {
+          if (tape.on) receipt(exitTape());
+          else
+            void enterTape()
+              .then((outcome) => receipt(outcome))
+              .finally(() => tick(true));
+          tick(true);
+          continue;
+        }
         // Ctrl-P enters play mode. A bare `p` would steal the first letter of
         // `pan`, `pattern`, `play` and every prose request starting with p.
         if (value === "\u0010" && tui.ui.overlay === undefined) {
@@ -2074,7 +2265,7 @@ async function submit(prompt: string): Promise<string | Receipt> {
       return {
         label: track.id,
         value: `/track ${track.id}`,
-        detail: `${track.instrument}${samples}${track.muted ? " · muted" : ""}${track.solo ? " · solo" : ""}`,
+        detail: `${track.instrument}${samples}${track.muted ? " · muted" : ""}${track.solo ? " · solo" : ""}${paneMarks(track.id)}`,
         current: track.id === requestedTrack,
       };
     });
@@ -2116,6 +2307,13 @@ async function submit(prompt: string): Promise<string | Receipt> {
       `${lines.length} note${lines.length === 1 ? "" : "s"} · ${requestedTrack} · remove <id>`,
     );
   }
+  const tapeCommand = command.match(/^\/tape(?:\s+(on|off))?$/i);
+  if (tapeCommand) {
+    const wanted = tapeCommand[1]?.toLowerCase();
+    if (wanted === "off" || (wanted === undefined && tape.on))
+      return exitTape();
+    return enterTape();
+  }
   const playCommand = command.match(
     /^\/play(?:\s+(on|off|degrees|in-key|chromatic))?$/i,
   );
@@ -2147,6 +2345,23 @@ async function submit(prompt: string): Promise<string | Receipt> {
     );
     return result.ok ? ok(result.message) : fail(result.message);
   }
+  const audioCommand = command.match(/^\/audio(?:\s+(.*))?$/i);
+  if (audioCommand) {
+    const result = await runAudioCommand(audioCommand[1] ?? "", {
+      info: audioInfo(),
+      setOutput: (name) => {
+        if (audio instanceof AudioEngine) audio.setDevice(name);
+        monitorEngine?.setDevice(name);
+      },
+      background: (task) => void task,
+    });
+    audioMenuCache = undefined;
+    if (result.ok && result.lines && /^\/audio(\s+test)?\s*$/i.test(command))
+      tui.openText(/test/i.test(command) ? "audio test" : "audio", [
+        ...result.lines,
+      ]);
+    return result.ok ? ok(result.message) : fail(result.message);
+  }
   const showMeCommand = command.match(/^\/show-?me(?:\s+(\S+))?$/i);
   if (showMeCommand) {
     if (!showMeCommand[1])
@@ -2188,8 +2403,11 @@ async function submit(prompt: string): Promise<string | Receipt> {
     )
   ) {
     const context = menuContext();
-    const label =
+    const opened =
       menu.showFader(context, command) ?? songFader(context, command);
+    // Bare `volume` (and every scalar) opens on its knob page, when its
+    // level has one and the param is a knob: the four knobs up front.
+    const label = opened && (menu.openKnobs(context, opened) ?? opened);
     if (label) {
       const field = menu
         .faderFields(context)
@@ -2204,10 +2422,37 @@ async function submit(prompt: string): Promise<string | Receipt> {
       openFader(label, true);
       refreshMenu();
       return ok(
-        `${label}${value ? ` · ${value}` : ""} · ←→ adjust · enter keep · esc revert`,
+        `${label}${value ? ` · ${value}` : ""} · ${
+          menu.knobPage === "knobs"
+            ? "↑↓ knob · ←→ turn · tab all"
+            : "←→ adjust · enter keep · esc revert"
+        }`,
       );
     }
   }
+  // `mix`: the drawer's mixer page, every track's level as a fader.
+  // `knobs [sound|mix|master|tempo|fx <effect>]`: a page's four knobs.
+  const knobsCommand = command.match(/^\/?(?:(mix)|knobs(?:\s+(.+))?)$/i);
+  if (knobsCommand) {
+    const context = menuContext();
+    const track = context.score.tracks.find((t) => t.id === context.trackId);
+    const label = knobsCommand[1]
+      ? openMixer(context)
+      : openKnobPage(context, knobsCommand[2], track);
+    if (!label)
+      return fail(
+        knobsCommand[1]
+          ? "mix · no tracks yet · track <name>"
+          : `knobs ${knobsCommand[2] ?? ""} · no such page · knobs ${KNOB_PAGE_WORDS.join("|")}`,
+      );
+    openFader(label, true);
+    refreshMenu();
+    return ok(
+      knobsCommand[1]
+        ? "mix · ↑↓ track · ←→ level · tab this track · enter keep · esc revert"
+        : `knobs · ${menu.knobPageId} · ↑↓ knob · ←→ turn · tab all params`,
+    );
+  }
   const menuCommand = command.match(/^\/menu(?:\s+(\S+))?$/i);
   if (menuCommand) {
     const section = menuCommand[1]?.toLowerCase();
@@ -2228,12 +2473,18 @@ async function submit(prompt: string): Promise<string | Receipt> {
       ? ok(message)
       : fail("usage: /grid 1/4|1/8|1/8T|1/16|1/16T|1/32");
   }
+  const paneReceipt = paneCommand(command);
+  if (paneReceipt) return paneReceipt;
   if (/^\/status$/i.test(command))
     return ok(
       `status · ${record.meta.name} · rev ${record.revision} · ${compositionDigest(record.composition)} · ${port.mode === "daemon" ? "shared via dawgd" : "saved locally · no daemon"}`,
     );
-  if (/^\/?undo$/i.test(command)) return stepHistory("undo");
-  if (/^\/?redo$/i.test(command)) return stepHistory("redo");
+  const history = /^\/?(undo|redo)(?:\s+(all))?$/i.exec(command);
+  if (history)
+    return stepHistory(
+      history[1]!.toLowerCase() as "undo" | "redo",
+      history[2] ? "all" : "pane",
+    );
   const trackCommand = command.match(
     /^\/?(?:add\s+)?track\s+([a-z0-9._-]{1,64})$/i,
   );
@@ -2466,7 +2717,7 @@ async function submit(prompt: string): Promise<string | Receipt> {
       score,
       requestedTrack,
       progression,
-      () => randomUUID().slice(0, 12),
+      () => newId("n"),
     );
     if (result.next && result.kind)
       await commitScore(result.next, result.kind, result.payload);
@@ -2476,7 +2727,7 @@ async function submit(prompt: string): Promise<string | Receipt> {
   if (strum) {
     if (strum.type === "strum") await materializeDraft();
     const result = applyStrumCommand(score, requestedTrack, strum, () =>
-      randomUUID().slice(0, 12),
+      newId("n"),
     );
     if (result.next && result.kind)
       await commitScore(result.next, result.kind, result.payload);
@@ -2541,6 +2792,8 @@ async function submit(prompt: string): Promise<string | Receipt> {
       await commitScore(result.next, result.kind, result.payload);
     return result.ok ? ok(result.message) : fail(result.message);
   }
+  const recordCommand = parseRecordCommand(command);
+  if (recordCommand) return keysRecord(recordCommand);
   const keysCommand = parseKeysCommand(command);
   if (keysCommand) {
     const reads =
@@ -2609,6 +2862,16 @@ async function submit(prompt: string): Promise<string | Receipt> {
     const result = applySynthCommand(score, requestedTrack, synth);
     if (result.next && result.kind)
       await commitScore(result.next, result.kind, result.payload);
+    // Bare `synth` (design §8.6) also opens the sound page's four knobs.
+    if (synth.type === "synth-list" && result.ok && !stageCapture) {
+      const context = menuContext();
+      const track = context.score.tracks.find((t) => t.id === context.trackId);
+      const label = openKnobPage(context, "sound", track);
+      if (label) {
+        openFader(label, true);
+        refreshMenu();
+      }
+    }
     return readOrDone(result);
   }
   const stringCommand = parseStringCommand(command);
@@ -2692,30 +2955,79 @@ async function submit(prompt: string): Promise<string | Receipt> {
       await commitScore(result.next, result.kind, result.payload);
     return readOrDone(result);
   }
-  // `loop <section> | <a>-<b> | off`: what playback loops, a section.
+  // Range commands (op1-ux §6.4): copy/move/clear/paste/reverse bars,
+  // bars insert|remove, loop next|prev, jump.
+  const rangeCommand = parseRangeCommand(command, score);
+  if (rangeCommand) {
+    const reads =
+      rangeCommand.type === "range-usage" ||
+      rangeCommand.type === "jump-bar" ||
+      rangeCommand.type === "jump-section" ||
+      (rangeCommand.type === "range-copy" && rangeCommand.to === undefined);
+    if (!reads) await materializeDraft();
+    // TAPE's first paste after a cut (§6.2): the `move` reads the bars from
+    // the score before the cut's clear, so cut and paste land as one move.
+    const folded =
+      rangeCommand.type === "range-move" &&
+      tape.foldArmed &&
+      tape.cut &&
+      cutArmed(tape.cut.after, score)
+        ? foldBase(tape.cut.before, score)
+        : undefined;
+    tape.foldArmed = undefined;
+    const cutBase =
+      rangeCommand.type === "range-clear" ? tape.cutArmed : undefined;
+    if (rangeCommand.type === "range-clear") tape.cutArmed = undefined;
+    const result = applyRangeCommand(
+      folded ?? score,
+      {
+        trackId: requestedTrack,
+        playheadBar: playheadBar(),
+        ...(rangeClipboard ? { clipboard: rangeClipboard } : {}),
+      },
+      rangeCommand,
+    );
+    if (result.delegate) return submit(result.delegate);
+    if (result.clipboard) {
+      rangeClipboard = result.clipboard;
+      tape.cut = undefined;
+      void saveClipboard(paneClipboardPath(), rangeClipboard).catch(
+        () => undefined,
+      );
+    }
+    if (result.next && result.kind)
+      await commitScore(result.next, result.kind, result.payload);
+    if (cutBase && result.next) tape.cut = { before: cutBase, after: score };
+    else if (result.next && result.kind) tape.cut = undefined;
+    if (result.seekBeat !== undefined) await seekTransport(result.seekBeat);
+    return readOrDone(result);
+  }
+  // `loop <a>-<b> | <section> | off`: what playback loops. Bars set the
+  // loop range (score.loop); a name loops that section.
   const loop = parseLoopCommand(command);
   if (loop) {
     if (loop.type === "loop-show")
       return note(
-        score.loopSection
-          ? `loop · ${score.loopSection} · loop off plays the song`
-          : `loop · the song · ${LOOP_USAGE}`,
+        score.loop
+          ? `loop · bars ${rangeLabel(score.loop)} · loop off plays the song`
+          : score.loopSection
+            ? `loop · ${score.loopSection} · loop off plays the song`
+            : `loop · the song · ${LOOP_USAGE}`,
       );
-    if (loop.type === "loop-off") return submit("section loop off");
+    if (loop.type === "loop-off") {
+      if (score.loop) {
+        await materializeDraft();
+        await commitScore(score.withLoop(null), "score.loop", { loop: null });
+        return ok("loop · off · playing the song");
+      }
+      return submit("section loop off");
+    }
     if (loop.type === "loop-section")
       return submit(`section loop ${loop.name}`);
-    const span = score.sections.find(
-      (section) =>
-        section.startBar + 1 === loop.from &&
-        section.startBar + section.bars === loop.to,
-    );
-    if (span) return submit(`section loop ${span.name}`);
-    // No section spans the bars: mark (or move) the section named `loop`
-    // and loop it, as one revision.
-    await materializeDraft();
-    const result = loopSpan(score, requestedTrack, loop.from, loop.to);
+    const result = loopSpan(score, loop.from, loop.to);
     if (!result.ok) return fail(result.message);
-    await commitScore(result.next, "score.sections", { loop: result.name });
+    await materializeDraft();
+    await commitScore(result.next, "score.loop", { loop: result.next.loop });
     return ok(result.message);
   }
   const arrange = parseSectionCommand(command, score);
@@ -2736,7 +3048,7 @@ async function submit(prompt: string): Promise<string | Receipt> {
   if (music) {
     await materializeDraft();
     const result = applyMusicCommand(score, requestedTrack, music, () =>
-      randomUUID().slice(0, 12),
+      newId("n"),
     );
     if (result.next && result.kind)
       await commitScore(result.next, result.kind, result.payload);
@@ -2958,6 +3270,22 @@ async function submit(prompt: string): Promise<string | Receipt> {
       ? vocalChainPatch(score.tracks.find((t) => t.id === requestedTrack))
       : {};
     const patch = { ...chain, ...rigged };
+    // `volume drums 0.5` names its track; it must exist.
+    if (parsed.trackId !== undefined) {
+      const target = score.tracks.find(
+        (candidate) =>
+          candidate.id === parsed.trackId ||
+          candidate.name.toLowerCase() === parsed.trackId,
+      );
+      if (!target) return fail(`no track ${parsed.trackId}`);
+      const next = applyScoreOperation(score, {
+        type: "updateTrack",
+        trackId: target.id,
+        patch,
+      });
+      await commitScore(next, "score.track", { trackId: target.id, patch });
+      return `track · ${target.id}`;
+    }
     const next = applyScoreOperation(score, {
       type: "updateTrack",
       trackId: requestedTrack,
@@ -3079,7 +3407,7 @@ async function submit(prompt: string): Promise<string | Receipt> {
     const latest = attempt === 0 ? record : await port.load();
     const latestScore = scoreFromJSON(latest.composition);
     const note = {
-      id: `${requestedTrack}-${latest.revision + 1}-${randomUUID().slice(0, 6)}`,
+      id: newId(requestedTrack),
       trackId: requestedTrack,
       startTick: Math.round(parsed.start * latestScore.ticksPerBeat),
       durationTicks: Math.max(
@@ -3116,17 +3444,26 @@ async function submit(prompt: string): Promise<string | Receipt> {
  * not in the score yet. A track another live window has focused stays
  * theirs; focus goes through the port so presence is right everywhere.
  */
-async function focusTrack(trackId: string): Promise<Receipt> {
+async function focusTrack(
+  trackId: string,
+  options: { follow?: boolean } = {},
+): Promise<Receipt> {
   if (trackId === requestedTrack && !draftTrack)
     return warn(`already on ${trackId}`);
+  if (paneOptions.pinned)
+    return warn(`pinned to ${requestedTrack} · unpin to change`);
+  // Typing a track yourself stops following (§12.5).
+  if (!options.follow && paneOptions.follow) paneOptions.follow = undefined;
+  // Focus is not exclusive (§12.5): a track another pane shows is a soft
+  // note on the receipt, never a refusal.
   const clients = await port.presence().catch(() => []);
-  if (
-    clients.some(
-      (client) =>
-        client.clientId !== port.clientId && client.focusedTrackId === trackId,
-    )
-  )
-    return warn(`${trackId} is open in another window`);
+  const sharing = clients.find(
+    (client) =>
+      client.clientId !== port.clientId && client.focusedTrackId === trackId,
+  );
+  const shared = sharing
+    ? ` · ${sharing.pane ? `pane ${sharing.pane}` : "another pane"} is on ${trackId} too`
+    : "";
   const existing = score.tracks.find((track) => track.id === trackId);
   const exists = existing !== undefined;
   // `track cloud`, `track hold-2`: a new granular track with that preset.
@@ -3165,11 +3502,11 @@ async function focusTrack(trackId: string): Promise<Receipt> {
       `track · ${trackId} is a ${existing.instrument} track · grain ${grainPreset} makes it granular`,
     );
   return ok(
-    exists
+    (exists
       ? `track · ${trackId}`
       : grainPreset
         ? `track created · ${trackId} · granular ${grainPreset} · nothing to download`
-        : `track created · ${trackId}`,
+        : `track created · ${trackId}`) + shared,
   );
 }
 
@@ -3892,6 +4229,7 @@ async function switchSession(sessionId: string): Promise<void> {
     setCurrent: true,
   });
   port = await openSessionPort<ReturnType<TrackScore["toJSON"]>>({
+    actor,
     paths: next.paths,
     sessionId,
     label: "window",
@@ -3918,13 +4256,269 @@ function liveEngine(): LiveEngine | undefined {
   return previewEngine();
 }
 
+/**
+ * The engine play mode sounds through: dawgd's shared engine when the
+ * daemon offers one (every pane's notes and one click mix there, §12.3),
+ * else this window's own monitor. Never both.
+ */
+function playEngine(): LiveEngine | undefined {
+  const link = port.liveLink();
+  if (!link) return previewEngine();
+  if (sharedLive?.link !== link)
+    sharedLive = { link, engine: new SharedLiveEngine(link) };
+  return sharedLive.engine;
+}
+
+/**
+ * What this pane shows, for the other panes' presence markers (§12.7):
+ * sent only when it changes, and only to a daemon that has panes.
+ */
+function paneView(): PaneView {
+  const session = play;
+  const view: PaneView = {
+    screen: session?.on
+      ? "play"
+      : tape.on
+        ? "tape"
+        : fader
+          ? "sound"
+          : menu.open
+            ? "menu"
+            : "home",
+  };
+  if (fader) view.param = fader.label.slice(0, 64);
+  if (session?.on) view.playing = true;
+  if (session?.recording)
+    view.recording = session.replace ? "replace" : "overdub";
+  if (paneOptions.pinned) view.pinned = true;
+  if (paneOptions.follow) view.follow = paneOptions.follow;
+  return view;
+}
+function reportView(): void {
+  const view = paneView();
+  const key = JSON.stringify(view);
+  if (key === reportedView) return;
+  reportedView = key;
+  port.setView(view);
+}
+
+/**
+ * `dawg pane <screen> …` at launch: focus its track, then open the screen
+ * through the same commands a person would type, so the pane starts where
+ * the shell line said.
+ */
+async function openPane(pane: PaneArgs): Promise<void> {
+  paneOptions.pinned = pane.pin;
+  paneOptions.follow = pane.follow;
+  let result: string | Receipt | undefined;
+  if (pane.screen === "play") result = await enterPlay();
+  else if (pane.screen === "tape") result = await enterTape();
+  else if (pane.screen === "sound")
+    result = await submit(pane.param ?? "volume");
+  else if (pane.screen === "menu")
+    result = await submit(`/menu${pane.param ? ` ${pane.param}` : ""}`);
+  if (result !== undefined) receipt(result);
+}
+
+/**
+ * Other panes on `trackId`, for a track row's gutter (§12.7): their letters,
+ * a red-dot `●` after a pane that is recording. Empty for a solo window.
+ */
+function paneMarks(trackId: string): string {
+  const marks = panePresence
+    .filter(
+      (entry) =>
+        entry.clientId !== port.clientId &&
+        entry.pane &&
+        entry.focusedTrackId === trackId,
+    )
+    .map((entry) => `${entry.pane}${entry.recording ? "●" : ""}`);
+  return marks.length ? `  ${marks.join(" ")}` : "";
+}
+
+/**
+ * Another pane recording on `trackId` (§12.4): `pane B`, else undefined.
+ * Play refuses to replace a pass while one is, naming it.
+ */
+function recordingPane(trackId: string): string | undefined {
+  const other = panePresence.find(
+    (entry) =>
+      entry.clientId !== port.clientId &&
+      entry.recording !== undefined &&
+      entry.focusedTrackId === trackId,
+  );
+  if (!other) return undefined;
+  return other.pane ? `pane ${other.pane}` : "another pane";
+}
+
+/** A drawer row another pane has open on this track shows its letter. */
+function withPaneMarks(view: DrawerView): DrawerView {
+  const others = panePresence.filter(
+    (entry) =>
+      entry.clientId !== port.clientId &&
+      entry.pane &&
+      entry.param &&
+      entry.screen === "sound" &&
+      entry.focusedTrackId === requestedTrack,
+  );
+  if (others.length === 0) return view;
+  return {
+    ...view,
+    fields: view.fields.map((field) => {
+      const peers = others
+        .filter((entry) => entry.param === field.label)
+        .map((entry) => entry.pane)
+        .join(" ");
+      return peers ? { ...field, peers } : field;
+    }),
+  };
+}
+
+/** One pane's line for `pane`: letter, screen, track, parameter, state. */
+function paneLine(entry: PresenceEntry): string {
+  const bits = [
+    `${entry.pane ?? "·"} ${entry.screen ?? "home"}`,
+    entry.focusedTrackId ?? "no track",
+  ];
+  if (entry.param) bits.push(entry.param);
+  if (entry.recording) bits.push(`● ${entry.recording}`);
+  if (entry.pinned) bits.push("pinned");
+  if (entry.follow) bits.push(`follows ${entry.follow}`);
+  if (entry.clientId === port.clientId) bits.push("this pane");
+  return bits.join(" · ");
+}
+
+/**
+ * `pane` lists panes; `pane <screen> [track]…` prints the shell line that
+ * opens one (dawg can't open terminal windows portably), with the tmux
+ * split line inside tmux, and copies it via OSC 52. `pin`, `unpin`,
+ * `follow [letter]`, `unfollow`. Undefined: not a pane command.
+ */
+function paneCommand(command: string): Receipt | undefined {
+  const text = command.trim();
+  if (/^\/?panes?$/i.test(text)) {
+    if (port.mode !== "daemon")
+      return ok("solo pane · no daemon · DAWG_DAEMON=0 is set");
+    const entries = [...panePresence].sort((a, b) =>
+      (a.pane ?? "~").localeCompare(b.pane ?? "~"),
+    );
+    if (entries.length === 0) return ok("1 pane · this one");
+    return ok(`${entries.length} panes │ ${entries.map(paneLine).join(" │ ")}`);
+  }
+  const open = text.match(/^\/?pane\s+(.+)$/i);
+  if (open) {
+    const parsed = parsePaneArgs(open[1]!.split(/\s+/));
+    if (!parsed.ok) return fail(parsed.problem);
+    const line = `dawg pane ${open[1]!.trim().toLowerCase()}`;
+    copyToClipboard(line);
+    return ok(
+      process.env.TMUX
+        ? `run · tmux split-window ${line} · copied`
+        : `run in another terminal · ${line} · copied`,
+    );
+  }
+  if (/^\/?pin$/i.test(text)) {
+    paneOptions.pinned = true;
+    paneOptions.follow = undefined;
+    return ok(`pinned to ${requestedTrack} · unpin releases`);
+  }
+  if (/^\/?unpin$/i.test(text)) {
+    if (!paneOptions.pinned) return warn("not pinned");
+    paneOptions.pinned = false;
+    return ok("unpinned");
+  }
+  const follow = text.match(/^\/?follow(?:\s+([a-z]))?$/i);
+  if (follow) {
+    if (port.mode !== "daemon") return warn("follow needs dawgd · solo pane");
+    paneOptions.pinned = false;
+    paneOptions.follow = follow[1]?.toUpperCase() ?? "*";
+    followPresence([], panePresence);
+    return ok(
+      paneOptions.follow === "*"
+        ? "following the latest pane's track"
+        : `following pane ${paneOptions.follow}`,
+    );
+  }
+  if (/^\/?unfollow$/i.test(text)) {
+    if (!paneOptions.follow) return warn("not following");
+    paneOptions.follow = undefined;
+    return ok("unfollowed");
+  }
+  return undefined;
+}
+
+/** OSC 52: the terminal copies `text` where it supports it; else a no-op. */
+function copyToClipboard(text: string): void {
+  if (!stdout.isTTY) return;
+  stdout.write(`\u001b]52;c;${Buffer.from(text).toString("base64")}\u0007`);
+}
+
+/**
+ * A following pane takes the track its target focuses: one letter, or for
+ * `*` the other pane whose focus changed most recently. Pinned panes never
+ * move on someone else's focus.
+ */
+function followPresence(
+  before: readonly PresenceEntry[],
+  after: readonly PresenceEntry[],
+): void {
+  const target = paneOptions.follow;
+  if (!target || paneOptions.pinned) return;
+  const others = after.filter((entry) => entry.clientId !== port.clientId);
+  let next: string | null | undefined;
+  if (target !== "*")
+    next = others.find((entry) => entry.pane === target)?.focusedTrackId;
+  else {
+    const moved = others.filter(
+      (entry) =>
+        before.find((old) => old.clientId === entry.clientId)
+          ?.focusedTrackId !== entry.focusedTrackId,
+    );
+    next = (moved.at(-1) ?? (before.length === 0 ? others.at(-1) : undefined))
+      ?.focusedTrackId;
+  }
+  if (!next || next === requestedTrack) return;
+  void focusTrack(next, { follow: true }).then((result) => {
+    if (result.ok) {
+      receipt(
+        ok(
+          `follows ${target === "*" ? "latest pane" : `pane ${target}`} · ${next}`,
+        ),
+      );
+      tickUi();
+    }
+  });
+}
+
 /** The engine this window hears itself through (its own in daemon mode). */
 function previewEngine(): AudioEngine {
   if (audio instanceof AudioEngine) return audio;
-  monitorEngine ??= new AudioEngine({ projectRoot: process.cwd() });
+  monitorEngine ??= new AudioEngine({
+    projectRoot: process.cwd(),
+    onStatus: (status) => {
+      if (status.state === "device")
+        tui.activity.pushCard(`audio · ${status.message}`, { tone: "warning" });
+    },
+  });
   return monitorEngine;
 }
 
+/** This machine's player, without starting an engine just to ask. */
+function audioInfo(): AudioBackendInfo {
+  if (audio instanceof AudioEngine) return audio.info;
+  if (monitorEngine) return monitorEngine.info;
+  audioInfoCache ??= detectAudioBackend();
+  return audioInfoCache;
+}
+
+/** Project › audio's rows; device lists are re-read at most every 3 s. */
+function audioMenu(): MenuAudioDevices {
+  const now = performance.now();
+  if (!audioMenuCache || now - audioMenuCache.at > 3000)
+    audioMenuCache = { at: now, state: audioMenuState(audioInfo()) };
+  return audioMenuCache.state;
+}
+
 /** The play session for the focused track (re-made when focus moves). */
 function menuContext(): MenuContext {
   const session = play;
@@ -3949,6 +4543,7 @@ function menuContext(): MenuContext {
     clickOn: session?.clickOn ?? false,
     countInBars: session?.countInBars ?? 1,
     showMe: showMe.level,
+    audio: audioMenu(),
     chords: stagedChordSettings() ?? session?.chords.settings ?? chordSettings,
     projectRoot: process.cwd(),
   };
@@ -3973,6 +4568,7 @@ function keysScreen(): readonly KeySection[] | undefined {
   if (prompt.value.length > 0) return undefined;
   if (play?.on)
     return play.chords.on ? [...KEYS.play, ...KEYS.chords] : KEYS.play;
+  if (tape.on) return KEYS.tape;
   return KEYS.prompt;
 }
 
@@ -4456,14 +5052,20 @@ function refreshMenu(): void {
     if (fields.length === 0) closeFader();
     else {
       const focusedField = fields[focusIndex(fader, fields)];
-      tui.drawer = drawerView(fader, fields, menu.faderCommitted(context), {
+      const drawer = drawerView(fader, fields, menu.faderCommitted(context), {
         title: menu.crumbs,
         dirty: context.audition?.dirty ?? false,
         status: context.audition?.status,
         atOnce:
           focusedField !== undefined &&
           !stageableNow(faderCommand(focusedField)),
+        knobs: menu.knobPage,
       });
+      tui.drawer = withPaneMarks(
+        menu.knobPage === "knobs"
+          ? { ...drawer, aside: drawerAside(menu.pageFields(context), fields) }
+          : drawer,
+      );
     }
   }
   const view = menu.view(context);
@@ -4531,6 +5133,50 @@ async function exportWav(path: string, stems: boolean): Promise<Receipt> {
   }
 }
 
+/** `mix`: Mix › mixer in the drawer, on the focused track's level. */
+function openMixer(context: MenuContext): string | undefined {
+  if (context.score.tracks.length === 0) return undefined;
+  menu.show(context, "mix");
+  if (!menu.enter(context, "mixer")) {
+    menu.close();
+    return undefined;
+  }
+  const first = menu.openKnobs(context);
+  const fields = menu.faderFields(context);
+  const here = fields.find((field) => field.label.includes("›"));
+  if (!first || fields.length === 0) {
+    menu.close();
+    return undefined;
+  }
+  return here?.label ?? first;
+}
+
+/** `knobs <page>`: open that page's level and its four knobs. */
+function openKnobPage(
+  context: MenuContext,
+  word: string | undefined,
+  track: TrackScore["tracks"][number] | undefined,
+): string | undefined {
+  const page = knobPageId(word, track);
+  if (!page) return undefined;
+  if (page.startsWith("fx:")) {
+    if (!menu.showFader(context, `fx ${page.slice(3)}`)) return undefined;
+  } else {
+    const section = page.startsWith("sound:")
+      ? "sound"
+      : page === "tempo"
+        ? "project"
+        : page;
+    menu.show(context, section);
+  }
+  const label = menu.openKnobs(context);
+  if (!label || menu.knobPageId !== page) {
+    menu.close();
+    return undefined;
+  }
+  return label;
+}
+
 /** `tempo`, `bars`, `meter`: open Project and name its fader, if it has one. */
 function songFader(context: MenuContext, command: string): string | undefined {
   // Bare song scalars and the Project fader each opens.
@@ -4628,6 +5274,10 @@ function mouseInput(event: MouseEvent): string[] {
   const frame = tui.frame;
   if (!frame) return [];
   const target = frame.hits.at(event.x, event.y)?.target;
+  if (tape.on && !play?.on && !tui.ui.overlay && !menu.open) {
+    const handled = tapeMouse(event, target);
+    if (handled) return handled;
+  }
   if (event.kind === "wheel") {
     const fields = fader && menu.open ? menu.faderFields(menuContext()) : [];
     if (
@@ -4784,12 +5434,325 @@ async function enterPlay(): Promise<Receipt> {
   );
 }
 
+/**
+ * `keys record [replace|off]` (op1-ux §4.7, r / R on TAPE): opens PLAY on
+ * the focused track and arms recording. With a loop set, every pass over
+ * it commits once, so one undo step; esc goes back to TAPE.
+ */
+async function keysRecord(
+  mode: "overdub" | "replace" | "off",
+): Promise<Receipt> {
+  if (mode === "off" && !play?.on) return ok("record off");
+  if (!play?.on) {
+    const entered = await enterPlay();
+    if (!play?.on) return entered;
+  }
+  const result = playSession().recordCommand(mode);
+  reportView();
+  return result.ok ? ok(result.message) : fail(result.message);
+}
+
 async function exitPlay(): Promise<Receipt> {
   if (!play?.on) return ok("play mode is off");
   await play.exit();
   return ok("play off");
 }
 
+// ── TAPE (op1-ux §6) ─────────────────────────────────────────────────
+
+/** This pane's clipboard file in `.dawg` (§6.3); undefined in a demo. */
+function paneClipboardPath(): string | undefined {
+  if (demo || !record.sessionId) return undefined;
+  return clipboardPath(process.cwd(), record.sessionId, port.pane);
+}
+
+/** The paste's target beat until its `jump` lands (or a moment passes). */
+function pendingTapeBeat(value: TrackScore): number | undefined {
+  const pending = tape.pending;
+  if (!pending) return undefined;
+  const here = scoreBeatAt(value, clock.beatAt());
+  if (Date.now() > pending.until || clock.playing || here >= pending.beat) {
+    tape.pending = undefined;
+    return undefined;
+  }
+  return pending.beat;
+}
+
+/** What TAPE's reducer and view read: the score, focus, playhead, clipboard. */
+function tapeContext(
+  value: TrackScore = score,
+  beat = clock.beatAt(),
+): TapeContext {
+  const board = rangeClipboard;
+  return {
+    score: value,
+    trackId: requestedTrack,
+    beat: pendingTapeBeat(value) ?? scoreBeatAt(value, beat),
+    clipboard: board ? { source: board.source, range: board.range } : undefined,
+    cut: cutArmed(tape.cut?.after, value),
+  };
+}
+
+function currentTapeView(value: TrackScore, beat: number): TapeView {
+  const view = tapeView({
+    ...tapeContext(value, beat),
+    // A pending paste's jump has not landed: its bar's first pass shows.
+    transportBeat: pendingTapeBeat(value) === undefined ? beat : undefined,
+    zoom: tape.zoom,
+    selected: tape.knobs.selected,
+    marks: paneMarks,
+  });
+  // §9.1 and §9.3: reels turn on the transport beat; the loop brackets
+  // flash as each pass closes. Both are still with `/motion off`.
+  const reducedMotion = tui.ui.reducedMotion;
+  const withDelight: TapeView = {
+    ...view,
+    reel: reelGlyph({
+      playing: clock.playing,
+      beat,
+      reducedMotion,
+      unicode: tui.capabilities.unicode,
+    }),
+    loopFlash: loopFlash({
+      playing: clock.playing,
+      beat,
+      loopBeats: loopedSection(value)
+        ? loopTicksOf(value) / value.ticksPerBeat
+        : undefined,
+      bpm: bpmAtTick(value, scoreBeatAt(value, beat) * value.ticksPerBeat),
+      reducedMotion,
+    }),
+  };
+  tape.view = withDelight;
+  return withDelight;
+}
+
+/** Whether the clipboard's source bars differ from what the score holds now. */
+function clipboardStale(): boolean {
+  const board = rangeClipboard;
+  if (!board) return false;
+  try {
+    const ids = board.clip.all ? undefined : [board.source];
+    const now = extractRange(score, ids, board.range);
+    return JSON.stringify(now) !== JSON.stringify(board.clip);
+  } catch {
+    return true;
+  }
+}
+
+/** Typed commands from a TAPE gesture: each echoes and runs as if typed. */
+function runTyped(commands: readonly string[]): void {
+  echoGesture(commands);
+  runPromptsLater(commands);
+}
+
+/**
+ * The prompt row echoes a gesture's typed command dimly for one beat
+ * (op1-ux §10.1: type what you see), at least long enough to read.
+ */
+function echoGesture(commands: readonly string[]): void {
+  if (commands.length === 0) return;
+  gestureEcho.text = commands.join(" · ");
+  if (gestureEcho.clear) clearTimeout(gestureEcho.clear);
+  const beatMs = 60_000 / Math.max(1, score.tempoBpm);
+  gestureEcho.clear = setTimeout(
+    () => {
+      gestureEcho.text = undefined;
+      gestureEcho.clear = undefined;
+      requestFrame();
+    },
+    Math.max(800, beatMs),
+  );
+  gestureEcho.clear.unref?.();
+  requestFrame();
+}
+
+async function enterTape(): Promise<Receipt> {
+  if (play?.on) await play.exit();
+  if (tape.on) return ok("tape · esc goes home");
+  closeFader();
+  if (menu.open) menu.close();
+  tape.on = true;
+  tape.knobs.selected = 0;
+  if (!rangeClipboard) {
+    rangeClipboard = await loadClipboard(paneClipboardPath());
+  }
+  return ok(
+    `tape · ${score.tracks.length} track${score.tracks.length === 1 ? "" : "s"} · ${score.bars} bars · ? keys · esc home`,
+  );
+}
+
+function exitTape(): Receipt {
+  if (!tape.on) return ok("tape is off");
+  tape.on = false;
+  tape.view = undefined;
+  tape.drag = undefined;
+  return ok("home");
+}
+
+/**
+ * One key on TAPE. True when TAPE consumed it; false sends it on (the
+ * prompt once a command is typed, overlays, ctrl keys).
+ */
+function tapeInput(value: string): boolean {
+  if (!tape.on || play?.on) return false;
+  if (tui.ui.overlay !== undefined || menu.open) return false;
+  if (prompt.value.length > 0) return false;
+  if (value === "/" || value === "\u0003") return false;
+  const base = tapeContext();
+  // After a cut the source bars are empty on purpose: not stale.
+  const context = { ...base, stale: !base.cut && clipboardStale() };
+  const action = tapeKey(context, value);
+  switch (action.type) {
+    case "run":
+      if (action.cut) tape.cutArmed = score;
+      runTyped(action.commands);
+      return true;
+    case "paste": {
+      if (action.fold) tape.foldArmed = true;
+      const commands = [action.command];
+      // The playhead moves past the paste so `v v v` tiles.
+      if (action.end < score.bars) {
+        commands.push(`jump ${action.end + 1}`);
+        tape.pending = {
+          beat: beatOfBar(score, action.end),
+          until: Date.now() + 2000,
+        };
+      }
+      runTyped(commands);
+      return true;
+    }
+    case "note":
+      tui.activity.pushCard(action.message, { tone: "info" });
+      return true;
+    case "zoom": {
+      const index = TAPE_ZOOMS.indexOf(tape.zoom) + action.direction;
+      tape.zoom =
+        TAPE_ZOOMS[Math.max(0, Math.min(TAPE_ZOOMS.length - 1, index))]!;
+      return true;
+    }
+    case "focus": {
+      const command = focusCommand(score, action.row);
+      if (command) runTyped([command]);
+      return true;
+    }
+    case "transport":
+      void toggleTransport().catch((error: unknown) => transportFailed(error));
+      return true;
+    case "keys":
+      showKeys();
+      return true;
+    case "exit":
+      receipt(exitTape());
+      return true;
+    case "pass":
+      break;
+  }
+  const knob = knobKey(tape.knobs, tapeKnobs(context), value);
+  if (knob.type === "run") {
+    runTyped([knob.command]);
+    return true;
+  }
+  if (knob.type === "open") {
+    runTyped([knobNoun(context, knob.knob)]);
+    return true;
+  }
+  if (knob.type === "handled") return true;
+  // Unmapped printable keys are swallowed (as in play mode); control keys
+  // (enter, ctrl-z, ctrl-k) keep their bindings.
+  return value.length === 1 && value >= " " && value !== "\u007f";
+}
+
+/**
+ * The mouse on TAPE: a ruler click jumps there and a ruler drag sets the
+ * loop, a row click focuses it, the clipboard chip pastes, and the wheel
+ * turns the selected knob. Each runs its typed command. Undefined: not a
+ * TAPE gesture, so the ordinary mouse path takes it.
+ */
+function tapeMouse(
+  event: MouseEvent,
+  target: HitTarget | undefined,
+): string[] | undefined {
+  if (event.kind === "wheel") {
+    if (!target || (target.kind !== "tape-ruler" && target.kind !== "tape-row"))
+      return undefined;
+    // The wheel walks the playhead a bar at a time (never a tempo knob).
+    const bar = playheadBar();
+    const next = Math.max(
+      0,
+      Math.min(score.bars - 1, bar + (event.delta < 0 ? -1 : 1)),
+    );
+    if (next !== bar) runTyped([`jump ${next + 1}`]);
+    return [];
+  }
+  const drag = tape.drag;
+  if (drag && (event.kind === "drag" || event.kind === "up")) {
+    const view = tape.view;
+    const first = drag.first;
+    const bar =
+      view && first !== undefined
+        ? tapeBarAt(event.x, drag.left, first)
+        : undefined;
+    if (bar !== undefined) drag.to = bar;
+    if (event.kind === "up") {
+      tape.drag = undefined;
+      if (drag.to !== drag.from) {
+        const start = Math.min(drag.from, drag.to);
+        const end = Math.max(drag.from, drag.to);
+        runTyped([`loop ${start + 1}-${end + 1}`]);
+      }
+    }
+    return [];
+  }
+  if (event.kind !== "down" || event.button !== "left" || !target)
+    return undefined;
+  if (target.kind === "tape-ruler") {
+    const bar = tapeBarAt(event.x, target.left, target.firstCell);
+    if (bar === undefined) return [];
+    tape.drag = {
+      from: bar,
+      to: bar,
+      left: target.left,
+      first: target.firstCell,
+    };
+    runTyped([`jump ${bar + 1}`]);
+    return [];
+  }
+  if (target.kind === "tape-row") {
+    // A drag along a row sets the loop over those bars, like the ruler.
+    const bar = tapeBarAt(event.x, target.left, target.firstCell);
+    if (bar !== undefined)
+      tape.drag = {
+        from: bar,
+        to: bar,
+        left: target.left,
+        first: target.firstCell,
+      };
+    const command = focusCommand(score, target.row);
+    if (command && score.tracks[target.row]?.id !== requestedTrack)
+      runTyped([command]);
+    return [];
+  }
+  if (target.kind === "tape-clipboard") {
+    tapeInput("v");
+    return [];
+  }
+  return undefined;
+}
+
+/** The bar under a TAPE column, from the last painted view. */
+function tapeBarAt(
+  x: number,
+  left: number,
+  firstCell: number,
+): number | undefined {
+  const view = tape.view;
+  if (!view) return undefined;
+  const cell = x - left + firstCell;
+  if (cell < 0 || cell >= view.cellBars.length) return undefined;
+  return view.cellBars[cell];
+}
+
 /**
  * One key in play mode. True when play mode consumed it; false sends it on
  * to the normal bindings (overlays, a command being typed, Ctrl-C, arrows).
@@ -4828,8 +5791,11 @@ function playHost() {
     playing: () => clock.playing,
     beatAt: (ms: number) => clock.beatAt(ms),
     scoreBeat: (beat: number) => scoreBeatAt(score, beat),
-    engine: liveEngine,
+    engine: playEngine,
     samples: () => liveSampleBank,
+    // A take is a plain commitScore (it diffs into operations, so dawgd
+    // rebases a pass over other panes' edits); a stale record reloads and
+    // replays the take's operations on what landed meanwhile.
     async commit(
       next: TrackScore,
       kind: string,
@@ -4839,15 +5805,7 @@ function playHost() {
       let target = next;
       for (let attempt = 0; attempt < 3; attempt += 1) {
         try {
-          record = await port.appendOperations(
-            record,
-            { kind, payload },
-            operations,
-            target.toJSON(),
-          );
-          score = scoreFromJSON(record.composition);
-          if (clock.playing) void audio.play(score);
-          projectSync?.scoreChanged(score);
+          await commitScore(target, kind, payload);
           return;
         } catch (error) {
           if (!(error instanceof SessionConflictError)) throw error;
@@ -4861,6 +5819,7 @@ function playHost() {
       }
       throw new Error("session busy");
     },
+    recordingElsewhere: (trackId: string) => recordingPane(trackId),
     async startTransport(beat: number): Promise<void> {
       if (port.mode === "daemon") {
         await port.transport("play", { beat });
@@ -4886,7 +5845,7 @@ function playHost() {
             tone === "success" ? shownRevision(record) : undefined,
         });
     },
-    newNoteId: () => randomUUID().slice(0, 12),
+    newNoteId: () => newId("n"),
   };
 }
 
@@ -4907,15 +5866,48 @@ async function commitScore(
     if (retimed) clock.follow(score);
     return;
   }
-  record = await port.append(record, { kind, payload }, next.toJSON());
-  score = next;
-  if (retimed) clock.follow(score);
+  // Every edit travels as score operations (snapshot when the diff cannot
+  // express it), so dawgd rebases it over other panes' concurrent edits per
+  // (track, property) and the log replays as operations (design §12.6).
+  const operations = diffOps(score, next);
+  if (operations) {
+    record = await port.appendOperations(
+      record,
+      { kind, payload },
+      operations,
+      next.toJSON(),
+    );
+    // A rebased edit lands on top of what other panes wrote meanwhile.
+    score = deepEqual(record.composition, next.toJSON())
+      ? next
+      : scoreFromJSON(record.composition);
+  } else {
+    record = await port.append(record, { kind, payload }, next.toJSON());
+    score = next;
+  }
+  if (retimed || score !== next) clock.follow(score);
   if (clock.playing) void audio.play(score);
   projectSync?.scoreChanged(score);
   reportSampleProblems(score);
   void updateCredits(score);
 }
 
+/** The ops from `previous` to `next`, or undefined when they do not diff. */
+function diffOps(
+  previous: TrackScore,
+  next: TrackScore,
+): readonly ScoreOperation[] | undefined {
+  try {
+    const operations = diffScores(previous, next);
+    return operations.length > 0 && operations.length <= 256
+      ? operations
+      : undefined;
+  } catch (error) {
+    if (error instanceof DiffError) return undefined;
+    throw error;
+  }
+}
+
 /** True when the transport clock must follow `next` (tempo, meter, loop). */
 function timingChanged(previous: TrackScore, next: TrackScore): boolean {
   return (
@@ -4968,39 +5960,91 @@ function syncHost(): SyncHost {
   };
 }
 
-async function stepHistory(direction: "undo" | "redo"): Promise<Receipt> {
+/**
+ * Undo and redo (design §12.6). By default a pane steps its own edits: the
+ * newest edit this client made, inverted and rebased over whatever other
+ * panes did since. `undo all` / `redo all` step the shared history, whoever
+ * made the edit, and the receipt names the other pane. A lone pane (or one
+ * that has made no edit since it opened) falls back to the shared history,
+ * so single-pane sessions behave exactly as before.
+ */
+async function stepHistory(
+  direction: "undo" | "redo",
+  scope: "pane" | "all" = "pane",
+): Promise<Receipt> {
   const latest = await port.load();
   // A fork's undo continues into its parent's history past the fork point.
-  const target = historyTarget(
-    latest.composition,
-    await historyEvents(process.cwd(), latest),
-    direction,
+  const events = await historyEvents(process.cwd(), latest);
+  const before = scoreFromJSON(latest.composition);
+  const kind = direction === "undo" ? UNDO_KIND : REDO_KIND;
+  const key = direction === "undo" ? "undoneRevision" : "redoneRevision";
+  const otherPanes = panePresence.filter(
+    (entry) => entry.clientId !== port.clientId,
   );
-  if (!target) return warn(`nothing to ${direction}`);
+  let next: TrackScore;
+  let revision: number;
+  let author = "";
+  if (scope === "pane") {
+    const step = paneHistoryStep(
+      latest.composition,
+      events,
+      direction,
+      port.clientId,
+    );
+    if (!step || (!step.ok && step.others.length === 0)) {
+      if (otherPanes.length === 0) return stepHistory(direction, "all");
+      if (!step)
+        return warn(
+          `nothing of this pane's to ${direction} · ${direction} all steps everyone's`,
+        );
+    }
+    if (!step.ok) {
+      if (step.reason === "session-wide")
+        return warn(`that edit is session-wide · ${direction} all`);
+      const who = step.others.map(paneName).join(", ");
+      return warn(
+        `${who} changed ${step.reason.replace(/ changed$/, "")} since · ${direction} all ${direction === "undo" ? "undoes" : "redoes"} theirs too`,
+      );
+    }
+    next = step.next;
+    revision = step.revision;
+  } else {
+    const target = historyTarget(latest.composition, events, direction);
+    if (!target) return warn(`nothing to ${direction}`);
+    next = scoreFromJSON(target.composition);
+    revision = target.revision;
+    const writer = events.find((event) => event.revision === revision)?.actor
+      ?.clientId;
+    if (writer && writer !== port.clientId && otherPanes.length > 0)
+      author = ` (${paneName(writer)})`;
+  }
   try {
-    const restored = scoreFromJSON(target.composition);
-    record = await port.append(
+    const event = {
+      kind,
+      payload: { [key]: revision, ...(scope === "pane" ? {} : { scope }) },
+    };
+    let operations: readonly ScoreOperation[] = [];
+    try {
+      operations = diffScores(before, next);
+    } catch (error) {
+      if (!(error instanceof DiffError)) throw error;
+    }
+    record = await port.appendOperations(
       latest,
-      {
-        kind: direction === "undo" ? UNDO_KIND : REDO_KIND,
-        payload: {
-          [direction === "undo" ? "undoneRevision" : "redoneRevision"]:
-            target.revision,
-        },
-      },
-      restored.toJSON(),
+      event,
+      operations,
+      next.toJSON(),
     );
     // Compare with what was undone, which another window may have written.
-    const before = scoreFromJSON(latest.composition);
-    score = restored;
+    score = scoreFromJSON(record.composition);
     if (clock.playing) void audio.play(score);
     return ok(
       historyReceipt(
         direction,
         before,
-        restored,
-        shownRevision(record, target.revision),
-      ),
+        score,
+        shownRevision(record, revision),
+      ) + author,
     );
   } catch (error) {
     if (error instanceof SessionConflictError)
@@ -5011,6 +6055,12 @@ async function stepHistory(direction: "undo" | "redo"): Promise<Receipt> {
   }
 }
 
+/** `pane B` for a client in presence, `another pane` once it has left. */
+function paneName(clientId: string): string {
+  const pane = panePresence.find((entry) => entry.clientId === clientId)?.pane;
+  return pane ? `pane ${pane}` : "another pane";
+}
+
 /** Space, the menu and a header click all report a failed toggle the same way. */
 function transportFailed(error: unknown): void {
   tui.activity.pushCard(
@@ -5091,6 +6141,12 @@ async function setTransport(
 }
 
 /** Move the playhead to transport `beat`, playing or not (section jump). */
+/** The bar under the playhead, 0-based on the score. */
+function playheadBar(): number {
+  const beat = scoreBeatAt(score, clock.beatAt());
+  return barAt(score, Math.max(0, Math.round(beat * score.ticksPerBeat))).bar;
+}
+
 async function seekTransport(beat: number): Promise<void> {
   if (port.mode === "daemon") {
     await port.transport("seek", { beat });