@hraness/dawg 0.6.1 → 0.8.0

package/src/main.ts

@@ -1,11 +1,46 @@
 #!/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";
+import { noteName as midiNoteName } from "./media/notes.ts";
 import {
+  EVERYDAY_VERBS,
+  EXPORT_USAGE,
+  elsewhereHint,
+  FREE_TEXT_HINTS,
+  noTrack,
+  stemsReceipt,
+  LOOP_USAGE,
+  WINDOW_VERBS,
+  NO_AGENT,
+  RANGES,
+  canonicalWindowForm,
+  friendlyCoreError,
+  knownVerbs,
+  nearest,
+  noNote,
+  parseExportCommand,
+  parseLoopCommand,
+  recover,
+  usageCard,
+  usageError,
+  verbOf,
+} from "./commands/grammar.ts";
+import {
+  instrumentListLines,
   isUnknownInstrument,
   plainSineAdvice,
+  unknownInstrumentMessage,
 } from "./audio/instrument-check.ts";
 import { randomUUID } from "node:crypto";
-import { readFileSync, writeSync } from "node:fs";
-import { readFile, stat, writeFile } from "node:fs/promises";
+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";
 import { stdin, stdout } from "node:process";
 import {
@@ -14,7 +49,19 @@ import {
   type SessionRecord,
 } from "./session/store.ts";
 import { openSessionPort } from "./session/port.ts";
-import { compositionDigest, monotonicEpochMs } from "./session/protocol.ts";
+import {
+  OwnWrites,
+  editedTrack,
+  foreignEvents,
+  otherWindowName,
+  paneLetters,
+} from "./session/origin.ts";
+import {
+  compositionDigest,
+  monotonicEpochMs,
+  type PaneView,
+  type PresenceEntry,
+} from "./session/protocol.ts";
 import {
   formatSessionLine,
   listSessions,
@@ -49,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,
@@ -69,6 +117,10 @@ import {
   rigTrackFields,
   rigWordPatch,
 } from "./commands/rig.ts";
+import {
+  applyProgressionCommand,
+  parseProgressionCommand,
+} from "./commands/progression.ts";
 import {
   applyGuitarCommand,
   applyStrumCommand,
@@ -85,6 +137,11 @@ import {
   parseWindCommand,
   windListLines,
 } from "./commands/wind.ts";
+import {
+  applySingCommand,
+  parseSingCommand,
+  singListLines,
+} from "./commands/sing.ts";
 import { applySynthCommand, parseSynthCommand } from "./commands/synth.ts";
 import { applyStringCommand, parseStringCommand } from "./commands/string.ts";
 import { instrumentPatchForWord, isModalWord } from "../core/resonators.ts";
@@ -98,6 +155,7 @@ import {
   applyKeysCommand,
   newPianoTrack,
   parseKeysCommand,
+  parseRecordCommand,
 } from "./commands/keys.ts";
 import {
   applyTuningCommand,
@@ -105,26 +163,45 @@ import {
   parseTuningCommand,
   type TuningCommand,
 } from "./commands/tuning.ts";
+import {
+  applyCalibrationCommand,
+  parseCalibrationCommand,
+} from "./commands/calibration.ts";
 import { TuningError, displayTag, resolveTuning } from "../core/tuning.ts";
 import {
   applyMasterCommand,
   measurementLine,
   parseMasterCommand,
 } from "./commands/master.ts";
+import { applyStyleCommand, parseStyleCommand } from "./commands/style.ts";
 import { exportSampleRate, measureScoreOffThread } from "./audio/measure.ts";
 import {
   applySectionCommand,
+  loopSpan,
   parseSectionCommand,
 } from "./commands/arrange.ts";
 import {
-  HELP_TOPICS,
+  applyRangeCommand,
+  parseRangeCommand,
+  type RangeClipboard,
+} from "./commands/range.ts";
+import { rangeLabel } from "../core/range.ts";
+import {
+  helpMiss,
   helpText,
+  helpTitle,
   helpTopicLines,
   nearestCommand,
   typoFix,
   usageHint,
 } from "./commands/help.ts";
-import { historyTarget, REDO_KIND, UNDO_KIND } from "./commands/history.ts";
+import {
+  historyReceipt,
+  historyTarget,
+  paneHistoryStep,
+  REDO_KIND,
+  UNDO_KIND,
+} from "./commands/history.ts";
 
 import {
   SamplePlacementError,
@@ -139,6 +216,30 @@ import {
 } from "./commands/sample.ts";
 import { applyFitCommand, fitVoice, parseFitCommand } from "./commands/fit.ts";
 import { applyShiftCommand, parseShiftCommand } from "./commands/shift.ts";
+import { parseVocalCommand, runVocalCommand } from "./commands/vocal.ts";
+import {
+  applyFormantCommand,
+  parseFormantCommand,
+  parseVowelCommand,
+} from "./commands/formant.ts";
+import {
+  applyLyrics,
+  parseClipCommand,
+  parseLyricsCommand,
+  runClipCommand,
+  setClipImportDeps,
+} from "./commands/clips.ts";
+import { pitchTraceFor } from "./commands/vocal-pitch.ts";
+import {
+  applyVocoderCommand,
+  parseVocoderCommand,
+  vocoderListLines,
+} from "./commands/vocoder.ts";
+import {
+  applyAutotuneCommand,
+  autotuneListLines,
+  parseAutotuneCommand,
+} from "./commands/autotune.ts";
 import { parseResampleCommand, runResample } from "./commands/resample.ts";
 import { suggestFitMode } from "./audio/dsp/onset.ts";
 import {
@@ -148,7 +249,14 @@ import {
   type SampleBank,
   type SampleProblem,
 } from "./audio/samples.ts";
+import {
+  ANALYSIS_CACHE_BYTES,
+  analysisCacheStatus,
+  analysisDir,
+  pruneAnalysisCache,
+} from "./audio/analysis.ts";
 import { drumSnapshotFields, samplerSnapshotFields } from "../tui/drums.ts";
+import { clipSnapshots, loadClipPeaks } from "../tui/clip-row.ts";
 import { highwayLayers } from "../tui/layers.ts";
 import { drumVoicePitch, isDrumInstrument } from "../core/drums.ts";
 import {
@@ -157,6 +265,7 @@ import {
   type AgentEvent,
   type AgentHost,
 } from "./agent/agent.ts";
+import { routeDuringTurn } from "./agent/steer.ts";
 import {
   isApiSelection,
   providerFingerprint,
@@ -175,8 +284,24 @@ import {
   spendLine as formatSpendLine,
   webHostFor,
 } from "./agent/usage.ts";
-import { configDir } from "./auth/credentials.ts";
-import { runAuthCommand, runFirstRunLogin, runTuiLogin } from "./auth/cli.ts";
+import { configDir, readConfig, writeConfig } from "./auth/credentials.ts";
+import type { CommandOutcome } from "./agent/command-agent.ts";
+import {
+  GLIDE_STEP_MS,
+  NoteScheduler,
+  finishHint,
+  gestureFor,
+  glideValues,
+  agentPathsAllowed,
+  isAgentCommand,
+  isBrokenCommand,
+  brokenCommandReceipt,
+  parseShowMe,
+  toolCaption,
+  type ShowMeLevel,
+} from "./agent/show-me.ts";
+import { firstRunCard, runAuthCommand, runTuiLogin } from "./auth/cli.ts";
+import { musicalReceipt } from "./session/receipt.ts";
 import {
   modelPickerItems,
   tuiAuthCommand,
@@ -184,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,
@@ -192,10 +322,39 @@ import {
   PlaySession,
   type LiveEngine,
 } from "./tui/play-session.ts";
-import { EditMenu, MENU_SECTIONS, type MenuContext } from "./tui/menu.ts";
 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,
   faderKeyPress,
   faderSetPosition,
   faderStep,
@@ -217,9 +376,23 @@ import {
   isStageable,
 } from "./tui/audition.ts";
 import { EuclidEditor, type EuclidContext } from "./tui/euclid.ts";
-import { HINTS, KEYS, keyLines, type KeySection } from "../tui/grammar.ts";
+import {
+  ARROW_DOWN,
+  ARROW_UP,
+  closesKeys,
+  HINTS,
+  KEYS,
+  keyLines,
+  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";
@@ -260,11 +433,13 @@ import {
   packCredits,
   writeCredits,
 } from "./audio/packs.ts";
+import { SharedLiveEngine, type LiveLink } from "./session/shared-live.ts";
 import {
   addNote,
   applyScoreOperation,
   createScore,
   isSamplerInstrument,
+  isTrackAudible,
   PACK_PREFIX,
   scoreFromJSON,
   SCORE_LIMITS,
@@ -277,22 +452,44 @@ import { decodeLoop, encodeLoop } from "../core/loop.ts";
 import { scoreToMidi } from "../core/midi.ts";
 import type { TrackScoreSnapshot } from "../tui/render.ts";
 import { PromptModel } from "../tui/prompt.ts";
-import { TerminalInputDecoder } from "../tui/input.ts";
 import {
+  ESCAPE_FLUSH_MS,
+  INPUT_FLUSH,
+  PASTE_FLUSH_MS,
+  TerminalInputDecoder,
+} from "../tui/input.ts";
+import {
+  FrameGate,
+  IDLE_HEARTBEAT_MS,
+  MIN_FRAME_GAP_MS,
+} from "../tui/frame-gate.ts";
+import {
+  CARD_GLOW_MS,
   composeFrame,
+  isTooSmall,
+  tooSmallKey,
   TuiApp,
   type AppView,
   type LoudnessView,
   type SyncState,
   type TypesIndicator,
 } from "../tui/app.ts";
-import { fail, ok, toneOf, warn, type Receipt } from "../tui/activity.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";
 import { encodeBuffer } from "../tui/screen.ts";
 import { parseThemeName } from "../tui/theme.ts";
 import { formatDiagnostic } from "../core/sdk/eval.ts";
 import { isProject } from "./project/init.ts";
+import {
+  parseLaunchArgs,
+  parsePaneArgs,
+  type PaneArgs,
+  parseSimpleArgv,
+  resolveTrackArg,
+} from "./launch-args.ts";
+import { RENDER_USAGE, runRenderCommand } from "./render.ts";
 import { typecheckProject } from "./project/typecheck.ts";
 import {
   startProjectSync,
@@ -300,112 +497,100 @@ import {
   type SyncHost,
 } from "./project/sync.ts";
 
+/** Set while `submit` runs a grammar reading, so it reads only once. */
+let recovering = false;
+
+/** Slash words `submit` handles itself (no parser in commandParses). */
+const SLASH_HANDLED: ReadonlySet<string> = new Set([
+  ...WINDOW_VERBS,
+  "chords",
+  "click",
+  "help",
+]);
+
 /** Whether a bare command parses (no side effects): for typo suggestions. */
 function parsesLocally(text: string): boolean {
-  return [
-    parsePrompt,
-    parseMusicCommand,
-    parseEditCommand,
-    parseRhythmCommand,
-    parseFxCommand,
-    parseSynthCommand,
-    parseStringCommand,
-    parseGranularCommand,
-    parseKeysCommand,
-    parseExpressionCommand,
-    parseMasterCommand,
-    (value: string) => parseSectionCommand(value, score),
-    parsePatternCommand,
-    parseKitCommand,
-    parsePackCommand,
-    parseSampleCommand,
-    parseFitCommand,
-    parseShiftCommand,
-    parseResampleCommand,
-    parseWavetableCommand,
-    parseTimeCommand,
-    parseTuningCommand,
-    parseRigCommand,
-    parseModalCommand,
-    parseGuitarCommand,
-    parseStrumCommand,
-    parseWindCommand,
-  ].some((parse) => parse(text) !== undefined);
+  return commandParses(text, score);
 }
 
 const ESC = "\u001b[";
 /** `/sessions` rows shown in the overlay. */
 const MAX_LISTED_SESSIONS = 64;
 
-const SUBCOMMANDS = [
-  "login",
-  "logout",
-  "auth",
-  "sessions",
-  "render",
-  "init",
-  "check",
-];
-const VALUE_FLAGS = ["--session", "--track", "--import", "--export", "--theme"];
-const FLAGS = [
-  ...VALUE_FLAGS,
-  "--new",
-  "--demo",
-  "--help",
-  "-h",
-  "--version",
-  "-v",
-  "--reduce-motion",
-  "--no-mouse",
-];
+/** Wraps a usage line at spaces before `width`, indenting continuations. */
+function wrapUsage(text: string, width: number, indent: string): string {
+  const lines: string[] = [];
+  let line = "";
+  for (const word of text.split(" ")) {
+    const prefix = lines.length === 0 ? "  " : indent;
+    if (line && prefix.length + line.length + 1 + word.length > width) {
+      lines.push(line);
+      line = word;
+    } else line = line ? `${line} ${word}` : word;
+  }
+  lines.push(line);
+  return lines.join(`\n${indent}`);
+}
 const HELP_TEXT = `dawg · local-first terminal music workstation
 
 Usage:
   dawg [--new] [--session <name|id>] [--track <name>]
-  dawg --import <file> --export <file>
+  dawg --import <file> --export <file>   convert a loop file (no session)
   dawg sessions
-  dawg render <out.wav|out.mid> [--session <name|id>] [--import <file>]
-               [--normalize <lufs|streaming|club|loud|…>] [--measure]
-  dawg init [dir]      project files: song.ts, tracks/<slug>/track.ts, .dawg/sdk
+  ${wrapUsage(RENDER_USAGE.replace(/^usage: /, ""), 76, "               ")}
+  dawg init [dir]      song.ts, tracks/<slug>/track.ts and .dawg/sdk
   dawg check           typecheck + evaluate the project; exit 1 on problems
-  dawg media doctor|download|stems|analyze|notes|sample|lyrics …  (dawg media --help)
+  dawg <command> --help  usage: sessions render init check media model
+  dawg doctor          audio backend, native sink and devices
+  dawg media doctor|download|stems|analyze|notes|sample|lyrics  (--help)
   dawg --version
 
-Usage flags:
+Display options:
   --reduce-motion   static hit/sustain states (also DAWG_REDUCE_MOTION=1)
   --theme <name>    default | high-contrast | mono (NO_COLOR forces mono)
   --no-mouse        keys only; no click/wheel reporting (also DAWG_MOUSE=0)
 
 Prompt:
-  Enter submit · Shift-Enter newline · Alt-Enter queue · Ctrl-Q toggle queue
-  Ctrl-Z undo · Ctrl-Y redo · Ctrl-O transcript · Esc cancel/close · Ctrl-C exit
+  Enter submit · Shift-Enter newline · Alt-Enter next · Ctrl-Q now / next
+  Ctrl-Z undo · Ctrl-Y redo · Ctrl-O transcript · Esc close · Ctrl-C exit
   Space on an empty prompt toggles playback
 
 Commands (bare music words; app commands take a slash):
 ${helpText()}
 
-Sign in (the choice is saved and reused until you log out):
-  dawg login                   find existing setups and pick a provider
-  dawg login gateway|openrouter|codex|claude
-  dawg model [alias]           pick a model, with the estimated cost per prompt
+Agent (optional; the choice is saved and reused until you log out):
+  dawg model key               find existing setups and pick a provider
+  dawg model key gateway|openrouter|codex|claude
+  dawg model [alias]           pick a model, with the cost per prompt
   dawg logout [provider] · dawg auth status [--check]
 Unrecognized requests go to the agent once a provider is configured
 (DAWG_PROVIDER=gateway|openrouter|codex|claude|auto, DAWG_MODEL=<alias>;
 DAWG_AI=0 disables the agent).`;
 const args = new Set(process.argv.slice(2));
-const requestedSession = optionValue("--session");
-const explicitTrack = optionValue("--track");
+/** One parse for every launch flag; problems are reported below. */
+const launch = parseLaunchArgs(process.argv.slice(2));
+const launchArgs = launch.ok ? launch.args : undefined;
+const requestedSession = launchArgs?.session;
+/** `--track` normalized as `/track` does; matched to an existing track below. */
+let explicitTrack = launchArgs?.track?.id;
 /** The focused track; claimed at startup unless `--track` is given. */
 let requestedTrack = explicitTrack ?? "main";
 const initialInstrument = isDrumInstrument(requestedTrack) ? "kit" : "sine";
-const importPath = optionValue("--import");
-const exportPath = optionValue("--export");
+const importPath = launchArgs?.importPath;
+const exportPath = launchArgs?.exportPath;
+// `dawg model key [provider]` is the canonical spelling of `dawg login`.
+if (process.argv[2] === "model" && process.argv[3] === "key")
+  process.exit(await runAuthCommand(["login", ...process.argv.slice(4)]));
 if (["login", "logout", "auth", "model"].includes(process.argv[2] ?? ""))
   process.exit(await runAuthCommand(process.argv.slice(2)));
 {
   // An unknown DAWG_MODEL is an error, never a silent fallback.
   const fromEnv = process.env.DAWG_MODEL?.trim();
-  if (fromEnv && !resolveModelChoice("gateway", fromEnv)) {
+  if (
+    fromEnv &&
+    !resolveModelChoice("gateway", fromEnv) &&
+    !resolveModelChoice("openrouter", fromEnv)
+  ) {
     process.stderr.write(
       `dawg: unknown DAWG_MODEL "${fromEnv.slice(0, 40)}"; use one of ${MODEL_CATALOG.map((row) => row.alias).join(", ")} or a vendor/model ID\n`,
     );
@@ -413,10 +598,14 @@ if (["login", "logout", "auth", "model"].includes(process.argv[2] ?? ""))
   }
 }
 if (process.argv[2] === "sessions") {
-  if (args.has("--help") || args.has("-h"))
-    stdout.write(
-      "usage: dawg sessions · lists this workspace's sessions, newest first (* marks the current one)\n",
-    );
+  const usage =
+    "usage: dawg sessions · lists this workspace's sessions, newest first (* marks the current one)";
+  const parsed = parseSimpleArgv(process.argv.slice(3), 0);
+  if (parsed.kind === "error") {
+    process.stderr.write(`${parsed.problem} · ${usage}\n`);
+    process.exit(2);
+  }
+  if (parsed.kind === "help") stdout.write(`${usage}\n`);
   else await printSessions(process.cwd(), stdout);
   process.exit(0);
 }
@@ -429,6 +618,10 @@ if (process.argv[2] === "init" || process.argv[2] === "check") {
     await command(process.argv.slice(2), process.cwd(), stdout, process.stderr),
   );
 }
+if (process.argv[2] === "doctor") {
+  const { runDoctorCommand } = await import("./audio/doctor.ts");
+  process.exit(await runDoctorCommand(process.argv.slice(3), stdout));
+}
 if (process.argv[2] === "media") {
   const { runMediaCommand } = await import("./media/cli.ts");
   process.exit(
@@ -461,18 +654,37 @@ if (args.has("--help") || args.has("-h")) {
 }
 // Argument mistakes are rejected here, before `.dawg/` could be created.
 {
-  const problem = argumentProblem(process.argv.slice(2));
-  if (problem) {
-    process.stderr.write(`${problem} · dawg --help\n`);
+  if (!launch.ok) {
+    process.stderr.write(`${launch.problem} · dawg --help\n`);
     process.exit(2);
   }
 }
+// `--import X --export Y` converts one loop file to another: no session.
+if (importPath && exportPath) {
+  try {
+    const converted = decodeLoop(await readLoopFile(importPath));
+    await writeFile(resolve(exportPath), encodeLoop(converted), "utf8");
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const midi = /\.midi?$/i.test(importPath)
+      ? " · MIDI files are not imported; --import takes a .track.json loop"
+      : "";
+    process.stderr.write(
+      `dawg: cannot import ${importPath} · ${reason.split("\n")[0]!.slice(0, 160)}${midi}\n`,
+    );
+    process.exit(1);
+  }
+  stdout.write(`converted ${importPath} → ${exportPath}\n`);
+  process.exit(0);
+}
 const demo =
   args.has("--demo") || process.env.DAWG_DEMO === "1" || !stdin.isTTY;
-// First run with no provider (or a saved one that stopped working): the
-// sign-in picker, in the shell, before the TUI takes the screen.
-if (!demo && process.env.DAWG_AI !== "0" && stdout.isTTY)
-  await runFirstRunLogin();
+// Music first: the TUI opens directly. The first session with no provider
+// (or a saved one that stopped working) gets one card instead of a picker.
+const launchCard =
+  !demo && process.env.DAWG_AI !== "0" && stdout.isTTY
+    ? firstRunCard().catch(() => undefined)
+    : undefined;
 
 const initial = createScore({
   tracks: [
@@ -521,9 +733,21 @@ if (importPath) {
     process.exit(1);
   }
 }
-const session = await ensureSession(initial.toJSON(), sessionOptions);
+// A demo frame only renders: with no workspace yet (and nothing imported),
+// it runs on a throwaway session so the cwd gets no `.dawg/`.
+const ephemeralWorkspace =
+  demo && freshWorkspace && !importPath && selectedSession === undefined
+    ? await mkdtemp(join(tmpdir(), "dawg-demo-"))
+    : undefined;
+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",
@@ -533,6 +757,12 @@ let port = await openSessionPort<ReturnType<TrackScore["toJSON"]>>({
 let record: SessionRecord<ReturnType<TrackScore["toJSON"]>> =
   port.mode === "daemon" ? await port.load() : session.record;
 let score = scoreFromJSON(record.composition);
+if (importPath && importedScore) score = importedScore;
+// `--track Bass` focuses an existing `bass` (or a track named "Bass").
+if (launchArgs?.track) {
+  explicitTrack = resolveTrackArg(score.tracks, launchArgs.track);
+  requestedTrack = explicitTrack;
+}
 if (importPath && importedScore) {
   score = importedScore;
   record = await port.append(
@@ -562,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);
@@ -573,12 +805,22 @@ const tui = new TuiApp({
     rows: () => stdout.rows ?? 24,
   },
   prompt,
-  theme: parseThemeName(optionValue("--theme") ?? process.env.DAWG_THEME),
+  theme: launchArgs?.theme ?? parseThemeName(process.env.DAWG_THEME),
   reducedMotion:
     args.has("--reduce-motion") || process.env.DAWG_REDUCE_MOTION === "1",
 });
 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;
@@ -623,15 +865,65 @@ 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;
-const KEY_UP = "\u001b[A";
-const KEY_DOWN = "\u001b[B";
+/** 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;
+  caption?: string | undefined;
+  commands: string[];
+  notes: NoteScheduler;
+  clear?: ReturnType<typeof setTimeout> | undefined;
+} = {
+  level: parseShowMe(process.env.DAWG_SHOWME ?? "") ?? "on",
+  commands: [],
+  notes: new NoteScheduler(() => score.tempoBpm),
+};
+if (!process.env.DAWG_SHOWME)
+  void readConfig({ dir: configDir() })
+    .then((config) => {
+      if (config.showMe) showMe.level = config.showMe;
+    })
+    .catch(() => undefined);
 /** The fader bar a left-button drag started on. */
 let dragging: { field: number; left: number; width: number } | undefined;
 /** The open drawer came from a command, not the menu. */
@@ -664,7 +956,8 @@ let handoff: <T>(flow: () => Promise<T>) => Promise<T> = (flow) => flow();
 function spendLine(): string {
   const width = stdout.columns ?? 80;
   if (!providerName || providerName === "offline")
-    return width >= 40 ? "no model · dawg login" : "";
+    // A state, not a nag: the first session's card already named /login.
+    return width >= 40 ? formatSpendLine({ kind: "offline" }) : "";
   const [model, provider] = providerName.split(" · ");
   return formatSpendLine(
     {
@@ -689,6 +982,10 @@ if (demo) {
     "add C4 at 0 for 1",
     0,
   );
+  if (ephemeralWorkspace) {
+    await port.close().catch(() => undefined);
+    await rm(ephemeralWorkspace, { recursive: true, force: true });
+  }
   process.exit(0);
 }
 
@@ -699,36 +996,8 @@ if (exportPath) {
 
 await runInteractive();
 
-/** Describes an unknown subcommand or option in `argv`, or undefined. */
-function argumentProblem(argv: readonly string[]): string | undefined {
-  if (argv[0] && !argv[0].startsWith("-") && !SUBCOMMANDS.includes(argv[0]))
-    return `unknown command · ${argv[0]}`;
-  if (argv[0] && SUBCOMMANDS.includes(argv[0])) return undefined;
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index]!;
-    if (VALUE_FLAGS.includes(arg)) {
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("-") && !FLAGS.includes(arg))
-      return `unknown option · ${arg}`;
-    if (!arg.startsWith("-")) return `unknown command · ${arg}`;
-  }
-  return undefined;
-}
-
 async function packageVersion(): Promise<string> {
-  const raw = await readFile(
-    new URL("../package.json", import.meta.url),
-    "utf8",
-  );
-  return (JSON.parse(raw) as { version?: string }).version ?? "0.0.0";
-}
-
-function optionValue(name: string): string | undefined {
-  const index = process.argv.indexOf(name);
-  const value = index >= 0 ? process.argv[index + 1] : undefined;
-  return value && !value.startsWith("--") ? value : undefined;
+  return (await import("./version.ts")).VERSION;
 }
 
 function seedDemo(value: TrackScore, trackId: string): TrackScore {
@@ -818,21 +1087,30 @@ function snapshot(
         muted: focused?.muted,
         ...(tag?.cents !== undefined ? { cents: tag.cents } : {}),
         ...(tag?.name !== undefined ? { centsFrom: tag.name } : {}),
+        ...(note.lyric !== undefined ? { lyric: note.lyric } : {}),
       };
     });
+  // 0.7 clips: the clip row; peaks load off the frame path, then redraw.
+  const clips = clipSnapshots(value, requestedTrack);
+  if (clips)
+    void loadClipPeaks(process.cwd(), focused).then((changed) => {
+      if (changed) requestFrame();
+    });
   return {
     notes,
+    ...(clips ? { clips } : {}),
     trackName:
       value.tracks.find((track) => track.id === requestedTrack)?.name ??
       requestedTrack,
     trackId: requestedTrack,
     sessionId: record.sessionId,
-    revision: record.revision,
+    revision: shownRevision(record),
     bpm: value.time?.tempo
       ? bpmAtTick(value, beat * value.ticksPerBeat)
       : value.tempoBpm,
     key: value.key ?? undefined,
     loopBeats: loopTicksOf(value) / value.ticksPerBeat,
+    ...(value.loop ? { loopRange: value.loop } : {}),
     beatsPerBar: value.beatsPerBar,
     ...(hasMeterChanges(value)
       ? {
@@ -846,6 +1124,7 @@ function snapshot(
     currentBeat: scoreBeatAt(value, beat),
     playing: clock.playing,
     activity,
+    ...(focused?.instrument === "vocal" ? { vocal: true } : {}),
     ...drumSnapshotFields(
       value.tracks.find((track) => track.id === requestedTrack)?.instrument,
       notes,
@@ -857,6 +1136,7 @@ function snapshot(
     ...(table && table.linear && table.size !== 12
       ? { tuningPeriod: { size: table.size, root: table.root } }
       : {}),
+    pitchTrace: pitchTraceFor(requestedTrack, value),
     layers:
       tui.highwayView === "all"
         ? highwayLayers(
@@ -898,11 +1178,19 @@ function appView(value: TrackScore, beat: number): AppView {
       providerName && providerName !== "offline" ? providerName : undefined,
     spend: spendLine(),
     agentOffline: providerName === "offline" || process.env.DAWG_AI === "0",
+    showMe:
+      showMe.ghost || showMe.caption
+        ? { ghost: showMe.ghost, caption: showMe.caption }
+        : 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),
   };
 }
@@ -1001,17 +1289,20 @@ function receipt(result: string | Receipt, base?: Baseline): void {
     tui.activity.pushError(message);
     return;
   }
+  // A receipt that names its own undo key needs no second hint.
   const hint =
-    scoreChanged && undoHintsShown < MAX_UNDO_HINTS
+    scoreChanged &&
+    undoHintsShown < MAX_UNDO_HINTS &&
+    !message.endsWith("ctrl-z undo")
       ? message.startsWith("undid")
-        ? "^y redo"
-        : "^z undo"
+        ? "ctrl-y redo"
+        : "ctrl-z undo"
       : undefined;
   if (hint) undoHintsShown += 1;
   tui.activity.pushCard(message, {
     tone,
-    baseRevision: changed ? base.revision : undefined,
-    resultRevision: changed ? record.revision : undefined,
+    baseRevision: changed ? shownRevision(record, base.revision) : undefined,
+    resultRevision: changed ? shownRevision(record) : undefined,
     hint,
     trackId: requestedTrack,
   });
@@ -1023,6 +1314,10 @@ function describeError(command: string, error: unknown): string {
   const message = error instanceof Error ? error.message : String(error);
   if (detail?.code === "ENOENT" && typeof detail.path === "string")
     return `no such file · ${relative(process.cwd(), detail.path)}`;
+  // `tempo 900` → `tempo 900 · tempo takes 20…300 BPM · tempo 128`: no raw
+  // core keys (`tempoBpm`) on a card.
+  const friendly = friendlyCoreError(truncateForCard(command), message);
+  if (friendly) return friendly;
   const verb = command.trim().split(/\s+/)[0]?.replace(/^\//, "") || "command";
   return `${verb} failed · ${message}`;
 }
@@ -1049,25 +1344,108 @@ function mouseOn(): string {
   return mouseEnabled() ? MOUSE_ON : "";
 }
 
+/**
+ * Mouse off, plain colors, plain paste, cursor shown, main screen.  A
+ * function, not a const: `await runInteractive()` runs above this line.
+ */
+function terminalRestore(): string {
+  return `${MOUSE_OFF}${ESC}0m${ESC}?2004l${ESC}?25h${ESC}?1049l`;
+}
+
+/** `dawg: <stack>` for a crash printed after leaving the alternate screen. */
+function crashText(error: unknown): string {
+  const text =
+    error instanceof Error ? (error.stack ?? error.message) : String(error);
+  return `dawg: ${text}\n`;
+}
+
 async function runInteractive(): Promise<void> {
-  // A crash or a stray process.exit must not leave the terminal reporting
-  // mouse events into the shell.
-  process.once("exit", () => {
-    if (mouseEnabled()) writeSync(1, MOUSE_OFF);
-  });
-  // Nor may a kill or a closed terminal: restore it, then exit as killed.
+  // Every way out (quit, a failing teardown step, a crash, a kill, a stray
+  // process.exit) restores the whole terminal, once, synchronously: the
+  // shell must not stay on the alternate screen with paste brackets on.
+  let terminalRestored = false;
+  const restoreTerminal = () => {
+    if (terminalRestored) return;
+    terminalRestored = true;
+    try {
+      stdin.setRawMode?.(false);
+    } catch {
+      // stdin may already be closed.
+    }
+    try {
+      writeSync(1, terminalRestore());
+    } catch {
+      // The terminal may already be gone (SIGHUP).
+    }
+  };
+  process.once("exit", restoreTerminal);
+  // A kill or a closed terminal: restore it, then exit as killed.
   for (const [signal, code] of [
     ["SIGTERM", 143],
     ["SIGHUP", 129],
   ] as const)
     process.once(signal, () => {
+      restoreTerminal();
+      process.exit(code);
+    });
+  // An exception nothing caught leaves the editor in an unknown state: leave
+  // the alternate screen first, so the stack lands in the shell, then exit.
+  const onUncaught = (error: unknown) => {
+    restoreTerminal();
+    try {
+      writeSync(2, crashText(error));
+    } catch {
+      // Nowhere left to report it.
+    }
+    process.exit(1);
+  };
+  // A rejected fire-and-forget promise is one failed action, not a broken
+  // editor: report it on the activity strip and repaint over anything the
+  // runtime wrote.
+  const onRejection = (error: unknown) => {
+    if (terminalRestored || screenSuspended) {
       try {
-        writeSync(1, `${MOUSE_OFF}${ESC}0m${ESC}?2004l${ESC}?25h${ESC}?1049l`);
+        writeSync(2, crashText(error));
       } catch {
-        // The terminal may already be gone (SIGHUP).
+        // Nowhere left to report it.
       }
-      process.exit(code);
-    });
+      return;
+    }
+    tui.activity.pushError(
+      `failed · ${error instanceof Error ? error.message : String(error)}`,
+    );
+    tui.invalidate();
+    requestFrame();
+  };
+  // Runtime warnings and console output would land on top of the frame; the
+  // writer never repaints rows it did not change.  Route them to the
+  // transcript instead, and repaint.
+  const onWarning = (warning: Error) => {
+    if (screenSuspended || terminalRestored) return;
+    tui.activity.pushNote(`warning · ${warning.message}`, "error");
+    tui.invalidate();
+    requestFrame();
+  };
+  const consoleError = console.error;
+  const consoleWarn = console.warn;
+  const consoleToTranscript =
+    (original: (...data: unknown[]) => void) =>
+    (...data: unknown[]) => {
+      if (screenSuspended || terminalRestored) return original(...data);
+      tui.activity.pushNote(
+        data
+          .map((item) => (item instanceof Error ? item.message : String(item)))
+          .join(" "),
+        "error",
+      );
+      tui.invalidate();
+      requestFrame();
+    };
+  process.on("uncaughtException", onUncaught);
+  process.on("unhandledRejection", onRejection);
+  process.on("warning", onWarning);
+  console.error = consoleToTranscript(consoleError);
+  console.warn = consoleToTranscript(consoleWarn);
   stdin.setRawMode?.(true);
   stdin.resume();
   // Alternate screen, hidden cursor, bracketed paste.
@@ -1078,7 +1456,8 @@ async function runInteractive(): Promise<void> {
   const runPrompt = async (text: string): Promise<void> => {
     const ui = tui.command(text);
     if (ui !== undefined) {
-      tui.activity.pushCard(ui, { tone: "info" });
+      if (typeof ui === "string") tui.activity.pushCard(ui, { tone: "info" });
+      else tui.activity.pushCard(ui.text, { tone: toneOf(ui) });
       return;
     }
     tui.activity.pushRequest(text);
@@ -1102,6 +1481,16 @@ async function runInteractive(): Promise<void> {
     }
   };
   let agentReported = false;
+  /** A typed command during an agent turn; leaves the turn's receipt alone. */
+  const runLocalBesideAgent = async (text: string): Promise<void> => {
+    tui.activity.pushRequest(text);
+    const base = baseline();
+    try {
+      receipt(await submit(text), base);
+    } catch (error) {
+      tui.activity.pushError(describeError(text, error));
+    }
+  };
   const drainQueue = async (): Promise<void> => {
     if (processingQueue) return;
     processingQueue = true;
@@ -1122,26 +1511,97 @@ async function runInteractive(): Promise<void> {
       tui.activity.setQueueDepth(queuedPrompts.length);
     }
   };
+  // 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;
+    const activity = tui.activity;
+    if (activity.spinner || activity.streaming) return true;
+    if (tui.delight.animating(Date.now())) return true;
+    const latest = activity.latest;
+    return (
+      !tui.ui.reducedMotion &&
+      latest !== undefined &&
+      Date.now() - latest.atMs < CARD_GLOW_MS
+    );
+  };
   const tick = (force = false) => {
     if (screenSuspended) return;
+    reportView();
+    if (
+      !frameGate.shouldBuild({
+        nowMs: Date.now(),
+        force,
+        animating: animating(),
+        keys: [
+          score,
+          record.revision,
+          record.sessionId,
+          record.meta.name,
+          syncState,
+          windowCount,
+          panePresence,
+          typesIndicator,
+          menu.open,
+          euclid.open,
+          tui.ui.overlay,
+        ],
+      })
+    )
+      return;
     followCommitted();
+    tui.delight.song(record.sessionId, record.meta.heardLoop === true);
     play?.tick();
     // Values in the menu follow the score as edits land.
     if (menu.open) refreshMenu();
     if (euclid.open) refreshEuclid();
     refreshAuditionPicker();
-    tui.render(appView(score, clock.beatAt()), { force });
+    // 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.
+    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.
+  tui.onFirstLoop = () => {
+    void port
+      .updateMeta({ heardLoop: true })
+      .then((result) => adoptMeta(result.meta))
+      .catch(() => undefined);
+  };
   runPromptLater = (command) => {
     queuedPrompts.unshift(command);
     void drainQueue();
   };
+  runPromptsLater = (commands) => {
+    queuedPrompts.unshift(...commands);
+    void drainQueue();
+  };
   reportAgentActivity = () => {
     tui.activity.applyAgentEvent({ type: "start", model: providerName });
   };
   agentEventSink = (event) => {
     if (event.type === "usage") return;
+    if (event.type === "command-typing") {
+      showMeTyping(event.text);
+      return;
+    }
+    if (event.type === "command") return;
+    if (event.type === "tool-start") {
+      const caption = toolCaption(event.name);
+      if (caption) showMeCaption(caption);
+    }
+    if (event.type === "done" || event.type === "error") showMeFinish();
     tui.activity.applyAgentEvent(event);
     if (event.type === "done" || event.type === "error") agentReported = true;
   };
@@ -1152,13 +1612,18 @@ async function runInteractive(): Promise<void> {
     tick(true);
   };
   stdout.on("resize", onResize);
+  const ownWrites = new OwnWrites();
+  let presenceClients: readonly PresenceEntry[] = [];
   let applying: Promise<void> = Promise.resolve();
   const applyLatest = (latest: typeof record): Promise<void> =>
     (applying = applying.then(() => applyRecord(latest)));
   const applyRecord = async (latest: typeof record): Promise<void> => {
     try {
+      // Queued before a /fork or /resume swapped the session: stale.
+      if (latest.sessionId !== record.sessionId) return;
       if (latest.revision > record.revision) {
         const previousRevision = record.revision;
+        const before = score;
         record = latest;
         if (stageCapture)
           stageCapture.committed = scoreFromJSON(record.composition);
@@ -1195,11 +1660,50 @@ async function runInteractive(): Promise<void> {
           else if (payload.action === "toggle") await setTransport("toggle");
         }
         projectSync?.scoreChanged(score);
-        tui.activity.pushCard("synced from another window", {
-          tone: "info",
-          baseRevision: previousRevision,
-          resultRevision: record.revision,
-        });
+        // Another window's play/pause is followed, not announced, and this
+        // window's own writes (which can echo back before the append
+        // resolves) are never "synced".
+        const from = shownRevision(record, previousRevision);
+        const to = shownRevision(record);
+        await ownWrites.settled();
+        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 && 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(
+                before,
+                scoreFromJSON(latest.composition),
+              ),
+              trackName: (id) =>
+                score.tracks.find((track) => track.id === id)?.name ?? id,
+            })}`,
+            { tone: "info", baseRevision: from, resultRevision: to },
+          );
       }
     } catch {
       // An invalid composition is skipped; the next update retries.
@@ -1210,8 +1714,12 @@ async function runInteractive(): Promise<void> {
       void applyLatest(update.record);
       adoptMeta(update.record.meta);
     } else if (update.type === "meta") adoptMeta(update.meta);
-    else if (update.type === "presence") windowCount = update.clients.length;
-    else if (update.type === "sync") syncState = update.sync;
+    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") {
       // Every window renders the same hit line from dawgd's timestamp.
       const { playing, beat, bpm, atMs } = update.transport;
@@ -1225,11 +1733,24 @@ async function runInteractive(): Promise<void> {
       });
     }
   };
-  let unsubscribe = port.subscribe(onUpdate);
+  // Each subscription answers only while its port is the live one: /fork and
+  // /resume swap the port, and a load the old port started before the swap
+  // could otherwise land afterwards and pull the old session's name and
+  // score into the new one.
+  const subscribeLive = (): (() => void) => {
+    const bound = port;
+    ownWrites.attach(bound);
+    return bound.subscribe((update) => {
+      if (bound === port) onUpdate(update);
+    });
+  };
+  let unsubscribe = subscribeLive();
   const refreshPresence = () =>
     void port
       .presence()
       .then((clients) => {
+        presenceClients = clients;
+        panePresence = clients;
         windowCount = Math.max(1, clients.length);
       })
       .catch(() => undefined);
@@ -1241,12 +1762,14 @@ async function runInteractive(): Promise<void> {
   rebindPort = () => {
     unsubscribe();
     syncState = port.sync;
-    unsubscribe = port.subscribe(onUpdate);
+    unsubscribe = subscribeLive();
     refreshPresence();
+    reportedView = "";
   };
   if (freshWorkspace)
     tui.activity.pushCard("created .dawg/ · add it to .gitignore", {
       tone: "info",
+      once: true,
     });
   if (attachNotice)
     tui.activity.pushCard(attachNotice, {
@@ -1256,11 +1779,15 @@ async function runInteractive(): Promise<void> {
     });
   if (port.status !== "file session")
     tui.activity.pushCard(port.status, { tone: "info" });
+  void launchCard?.then((card) => {
+    if (card) tui.activity.pushCard(card.text, { tone: card.tone, once: true });
+  });
   if (await isProject(process.cwd()))
     projectSync = startProjectSync(syncHost());
   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[] = [];
@@ -1277,8 +1804,28 @@ async function runInteractive(): Promise<void> {
   stdin.on("end", onEnd);
   async function* chunks(): AsyncGenerator<string> {
     for (;;) {
-      while (inbox.length === 0)
-        await new Promise<void>((resolve) => (wake = resolve));
+      while (inbox.length === 0) {
+        // A partial escape (Alt+[, a cut-off paste) is flushed after a short
+        // idle so it never holds back the keys behind it.
+        const held = inputDecoder.pending();
+        const idle =
+          held === "paste"
+            ? PASTE_FLUSH_MS
+            : held === "escape"
+              ? ESCAPE_FLUSH_MS
+              : undefined;
+        let timeout: ReturnType<typeof setTimeout> | undefined;
+        const timedOut = await new Promise<boolean>((resolve) => {
+          wake = () => resolve(false);
+          if (idle !== undefined)
+            timeout = setTimeout(() => resolve(true), idle);
+        });
+        clearTimeout(timeout);
+        if (timedOut && inbox.length === 0) {
+          wake = undefined;
+          yield INPUT_FLUSH;
+        }
+      }
       wake = undefined;
       const next = inbox.shift()!;
       if (next === "\u0000eof") return;
@@ -1293,7 +1840,7 @@ async function runInteractive(): Promise<void> {
     stdin.pause();
     stdin.setRawMode?.(false);
     // Leave the alternate screen; restore the cursor and plain paste.
-    stdout.write(`${MOUSE_OFF}${ESC}0m${ESC}?2004l${ESC}?25h${ESC}?1049l`);
+    stdout.write(terminalRestore());
     try {
       return await flow();
     } finally {
@@ -1312,12 +1859,31 @@ async function runInteractive(): Promise<void> {
     let exiting = false;
     for await (const text of chunks()) {
       // A read that is exactly ESC is the Esc key, not the start of a sequence.
-      const values = [
-        ...inputDecoder.push(text),
-        ...(text === "\u001b" ? inputDecoder.flush() : []),
-      ];
+      const values =
+        text === INPUT_FLUSH
+          ? inputDecoder.flush()
+          : [
+              ...inputDecoder.push(text),
+              ...(text === "\u001b" ? inputDecoder.flush() : []),
+            ];
       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)) {
@@ -1328,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()),
@@ -1341,9 +1915,9 @@ async function runInteractive(): Promise<void> {
             continue;
           }
         }
-        // The `?` panel closes on any key (Ctrl-C still quits).
+        // The `?` panel closes on esc or ?; other keys wait (Ctrl-C quits).
         if (tui.ui.keys && typeof value === "string" && value !== "\u0003") {
-          tui.closeKeys();
+          if (closesKeys(value)) tui.closeKeys();
           tick(true);
           continue;
         }
@@ -1403,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);
@@ -1452,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) {
@@ -1474,12 +2065,7 @@ async function runInteractive(): Promise<void> {
           // Never await a daemon round trip here: the key loop must stay
           // live for Esc, quit and redraws while the toggle is in flight.
           void toggleTransport()
-            .catch((error: unknown) => {
-              tui.activity.pushCard(
-                `transport failed · ${error instanceof Error ? error.message : String(error)}`,
-                { tone: "error" },
-              );
-            })
+            .catch((error: unknown) => transportFailed(error))
             .finally(() => tick(true));
         } else {
           const input = tui.input(value);
@@ -1508,7 +2094,9 @@ async function runInteractive(): Promise<void> {
             if (auditionLoop?.looping && isStageable(input.value))
               hoverItem(input.value, `picker:${input.picker}`);
             else if (input.picker === "pattern")
-              previewPattern(input.value.replace(/^\/pattern\s+/, ""));
+              previewPattern(
+                input.value.replace(/^\/(?:pattern|groove)\s+/, ""),
+              );
           } else if (input.type === "pick-audition") {
             pickerAuditionKey(input.key);
           } else if (input.type === "pick-cancel") {
@@ -1560,6 +2148,16 @@ async function runInteractive(): Promise<void> {
           else if (action?.kind === "cancel" && agentTurn) {
             agentTurn.controller.abort();
             tui.activity.setSpinner("cancelling");
+          } else if (
+            action?.kind === "submit" &&
+            action.value &&
+            agentTurn &&
+            routeDuringTurn(action.value, parsesLocally) === "local"
+          ) {
+            // A typed command never waits on the agent: it commits its own
+            // revision now, and the agent's next call re-reads the score.
+            const value = action.value;
+            void runLocalBesideAgent(value).finally(() => tick(true));
           } else if (action?.kind === "submit" && action.value && agentTurn) {
             // Enter during a turn steers it; Alt-Enter still queues a follow-up.
             agentTurn.steering.push(action.value);
@@ -1590,17 +2188,36 @@ async function runInteractive(): Promise<void> {
     stdin.off("end", onEnd);
     clearInterval(timer);
     clearInterval(presenceTimer);
-    await projectSync?.stop();
-    namer.dispose();
     stdout.off("resize", onResize);
-    unsubscribe();
-    await play?.exit().catch(() => undefined);
-    await monitorEngine?.dispose().catch(() => undefined);
-    audio.stop();
-    await port.close();
-    stdin.setRawMode?.(false);
+    // The terminal first: a teardown step that throws (a read-only .dawg,
+    // a dead engine) must not leave the shell on the alternate screen.
+    restoreTerminal();
     stdin.pause();
-    stdout.write(`${MOUSE_OFF}${ESC}0m${ESC}?2004l${ESC}?25h${ESC}?1049l`);
+    console.error = consoleError;
+    console.warn = consoleWarn;
+    process.off("warning", onWarning);
+    unwatchActivity();
+    // Each step on its own: one failure does not skip the rest.
+    const failures: unknown[] = [];
+    const steps: Array<() => unknown> = [
+      () => projectSync?.stop(),
+      () => namer.dispose(),
+      () => unsubscribe(),
+      () => play?.exit(),
+      () => monitorEngine?.dispose(),
+      () => audio.stop(),
+      () => port.close(),
+    ];
+    for (const step of steps) {
+      try {
+        await step();
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    process.off("unhandledRejection", onRejection);
+    process.off("uncaughtException", onUncaught);
+    if (failures.length > 0) throw failures[0];
   }
 }
 
@@ -1615,23 +2232,23 @@ function unknownCommand(command: string): string {
 
 async function submit(prompt: string): Promise<string | Receipt> {
   const command = prompt.trim();
+  // Canonical names for window commands: `model key` (login), `models`,
+  // `voice` (the Voice topic).
+  const canonical = canonicalWindowForm(command);
+  if (canonical) return submit(canonical);
   const helpCommand = command.match(/^\/?(?:help|\?)(?:\s+(\S+))?$/i);
   if (helpCommand) {
     const topic = helpCommand[1];
+    // The panel's inner width (tui/app.ts paintText): rows clip there with
+    // an ellipsis, the same as every other panel.
+    const columns = stdout.columns ?? 80;
     const lines = helpTopicLines(
       topic,
-      Math.max(40, (stdout.columns ?? 80) - 10),
-    );
-    if (!lines)
-      return fail(
-        `no help topic ${topic} · /help all · ${HELP_TOPICS.join(" ")}`,
-      );
-    tui.openText(topic ? `help · ${topic.toLowerCase()}` : "help", lines);
-    return ok(
-      topic
-        ? `help · ${topic.toLowerCase()}`
-        : "help · /help all for every command",
+      Math.max(10, columns - (columns >= 60 ? 8 : 4)),
     );
+    if (!lines) return fail(helpMiss(topic!));
+    tui.openText(helpTitle(topic), lines);
+    return ok(topic ? helpTitle(topic) : "help · help all for every command");
   }
   if (/^\/?tracks$/i.test(command)) {
     const problems = await sampleProblems(score);
@@ -1648,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,
       };
     });
@@ -1663,7 +2280,39 @@ async function submit(prompt: string): Promise<string | Receipt> {
         items.findIndex((item) => item.current),
       ),
     });
-    return ok(`${items.length} track${items.length === 1 ? "" : "s"}`);
+    return note(`${items.length} track${items.length === 1 ? "" : "s"}`);
+  }
+  if (/^\/?(?:instruments|instrument\s+(?:list|ls|presets))$/i.test(command)) {
+    // `instrument list`: every word `instrument <name>` takes, by family.
+    const columns = stdout.columns ?? 80;
+    const lines = instrumentListLines(
+      Math.max(10, columns - (columns >= 60 ? 8 : 4)),
+    );
+    tui.openText("instruments", lines);
+    return note("instruments · instrument <name> on the focused track");
+  }
+  if (/^\/?notes(?:\s+(?:list|ls))?$/i.test(command)) {
+    // `notes`: the focused track's note ids, the names `remove <id>` takes.
+    const notes = score.notes
+      .filter((entry) => entry.trackId === requestedTrack)
+      .slice()
+      .sort((a, b) => a.startTick - b.startTick);
+    const lines = notes.map(
+      (entry) =>
+        `${entry.id} · ${midiNoteName(entry.pitch)} · beat ${+(entry.startTick / score.ticksPerBeat).toFixed(2)}`,
+    );
+    if (lines.length === 0) return note(`notes · ${requestedTrack} has none`);
+    tui.openText(`notes · ${requestedTrack}`, lines);
+    return note(
+      `${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,
@@ -1696,6 +2345,41 @@ 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])
+      return ok(`show me · ${showMe.level} · /showme on|quiet|off`);
+    const level = parseShowMe(showMeCommand[1]);
+    if (!level) return fail("usage · /showme on|quiet|off");
+    showMe.level = level;
+    void writeConfig({ dir: configDir() }, { showMe: level }).catch(
+      () => undefined,
+    );
+    return ok(
+      level === "off"
+        ? "show me off · the agent edits with tools"
+        : level === "quiet"
+          ? "show me quiet · the agent types commands, no captions"
+          : "show me on · the agent types commands, slides faders, plays keys",
+    );
+  }
   const countIn = command.match(/^\/count-?in\s+([0-2])$/i);
   if (countIn) return ok(playSession().setCountIn(Number(countIn[1])));
   const euclidCommand = command.match(/^\/euclid(?:\s+(\S+))?$/i);
@@ -1710,21 +2394,75 @@ async function submit(prompt: string): Promise<string | Receipt> {
   }
   const tryCommand = command.match(/^\/try(?:\s+(.+))?$/i);
   if (tryCommand) return tryPrompt(tryCommand[1]?.trim() ?? "");
-  // A bare parameter (`volume`, `pan`, `fx filter`, `fx reverb mix`)
-  // opens the fader drawer on it, with its related params stacked below.
-  if (/^\/?(?:volume|pan|fx\s+\S+(?:\s+\S+)?)$/i.test(command)) {
-    const label = menu.showFader(menuContext(), command);
+  // A bare scalar (`volume`, `pan`, `fx reverb mix`, and the song's
+  // `tempo`, `bars` and `meter`) opens the fader drawer on it, with its
+  // related params stacked below.
+  if (
+    /^\/?(?:volume|pan|tempo|bpm|bars|meter|fx\s+\S+(?:\s+\S+)?)$/i.test(
+      command,
+    )
+  ) {
+    const context = menuContext();
+    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)
+        .find((candidate) => candidate.label === label);
+      // The receipt names the value it opened on: `tempo · 120 BPM · …`.
+      const value =
+        field?.kind === "number"
+          ? field.value !== undefined
+            ? field.format(field.value)
+            : field.off
+          : undefined;
       openFader(label, true);
       refreshMenu();
-      return ok(`${label} · ←→ adjust · enter keep · esc revert`);
+      return ok(
+        `${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();
-    if (section && !(MENU_SECTIONS as readonly string[]).includes(section))
-      return fail(`/menu [${MENU_SECTIONS.join("|")}]`);
+    // §4: the keys topic has no menu page; it opens the ? panel.
+    if (section && (section === "keys" || TOPIC_ALIASES[section] === "keys")) {
+      tui.showKeys("keys", keyLines(KEYS.prompt));
+      return ok("keys");
+    }
+    if (section && !menuSectionPath(menuContext(), section))
+      return fail(menuUsage(menuContext(), section));
     openMenu(section);
     return ok("menu");
   }
@@ -1735,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,
   );
@@ -1754,6 +2498,73 @@ async function submit(prompt: string): Promise<string | Receipt> {
     if (requestedTrack !== grainTrack[1]!.toLowerCase()) return focused;
     return submit(grainTrack[2]!);
   }
+  // `/track rm <name>` (aliases remove, delete) and `/track move <name>
+  // <position>`: the human surface for the removeTrack and moveTrack
+  // operations. Removing a track also drops any vocoder src or autotune from
+  // that named it; ^z brings everything back.
+  const trackEdit = command.match(
+    /^\/?track\s+(rm|remove|delete|move)\s+(.{1,64}?)\s*$/i,
+  );
+  if (trackEdit) {
+    const verb = trackEdit[1]!.toLowerCase() === "move" ? "move" : "rm";
+    let rest = trackEdit[2]!.trim();
+    let position: number | undefined;
+    if (verb === "move") {
+      const tail = rest.match(/^(.+?)\s+(\d{1,3})$/);
+      if (!tail)
+        return fail(`usage · /track move <name> <1..${score.tracks.length}>`);
+      rest = tail[1]!;
+      position = Number(tail[2]);
+    }
+    const wanted = rest
+      .replace(/^["']|["']$/g, "")
+      .trim()
+      .replace(/\s+/g, " ")
+      .toLowerCase();
+    const found = score.tracks.find(
+      (track) =>
+        track.id.toLowerCase() === wanted ||
+        track.id.toLowerCase() === wanted.replace(/ /g, "-") ||
+        (track.name ?? "").toLowerCase() === wanted,
+    );
+    if (!found) return fail(noTrack(rest));
+    if (verb === "move") {
+      if (position! < 1 || position! > score.tracks.length)
+        return fail(`usage · /track move <name> <1..${score.tracks.length}>`);
+      const next = applyScoreOperation(score, {
+        type: "moveTrack",
+        trackId: found.id,
+        index: position! - 1,
+      });
+      await commitScore(next, "track.move", { trackId: found.id });
+      await projectSync?.flushScore();
+      return ok(`moved ${found.id} to position ${position}`);
+    }
+    if (score.tracks.length <= 1)
+      return fail("the last track stays · /clear empties it");
+    const next = applyScoreOperation(score, {
+      type: "removeTrack",
+      trackId: found.id,
+    });
+    const dropped = score.tracks
+      .filter((track) => track.id !== found.id)
+      .filter((track) => {
+        const after = next.tracks.find((t) => t.id === track.id);
+        return (
+          (track.vocoder?.src !== undefined &&
+            after?.vocoder?.src === undefined) ||
+          (track.autotune?.from !== undefined &&
+            after?.autotune?.from === undefined)
+        );
+      })
+      .map((track) => track.id);
+    await commitScore(next, "track.remove", { trackId: found.id });
+    await projectSync?.flushScore();
+    if (found.id === requestedTrack) await focusTrack(next.tracks[0]!.id);
+    return ok(
+      `removed ${found.id}${dropped.length ? ` · dropped references on ${dropped.join(", ")}` : ""} · ctrl-z undoes`,
+    );
+  }
   // `/track piano b`: a name with spaces focuses the track of that name, or
   // creates `piano-b` named "piano b".
   const namedTrack = command.match(/^\/track\s+([a-z0-9._ -]{1,64})$/i);
@@ -1778,12 +2589,90 @@ async function submit(prompt: string): Promise<string | Receipt> {
   }
   const resample = parseResampleCommand(command);
   if (resample) return resampleCommand(resample);
+  // 0.7 clips: `/clip` edits and `/lyrics` on the focused track.
+  const clipCommand = parseClipCommand(command);
+  if (clipCommand) {
+    if ("error" in clipCommand) return fail(clipCommand.error);
+    const result = await runClipCommand(clipCommand, {
+      score,
+      trackId: requestedTrack,
+      cwd: process.cwd(),
+    });
+    if (!result.ok) return fail(result.message);
+    if (result.next && result.kind) {
+      await commitScore(result.next, result.kind, {
+        trackId: requestedTrack,
+        ...result.payload,
+      });
+      await projectSync?.flushScore();
+    }
+    return ok(result.message);
+  }
+  const lyricsCommand = parseLyricsCommand(command);
+  if (lyricsCommand) {
+    const result = applyLyrics(score, requestedTrack, lyricsCommand);
+    if (!result.ok) return fail(result.message);
+    if (result.next && result.kind) {
+      await commitScore(result.next, result.kind, {
+        trackId: requestedTrack,
+        ...result.payload,
+      });
+      await projectSync?.flushScore();
+    }
+    return ok(result.message);
+  }
+  // 0.7 autotune: `/autotune …` (and `/tune <preset>` pointing here).
+  // `/vocal autotune …` takes the same path (presets panel, draft, commit).
+  const autotune = parseAutotuneCommand(
+    command.replace(/^\/?vocal\s+(?=autotune\b)/i, ""),
+  );
+  if (autotune) {
+    if (autotune.type === "autotune-list")
+      tui.openText("autotune presets", autotuneListLines());
+    if (autotune.type !== "autotune-usage" && autotune.type !== "autotune-list")
+      await materializeDraft();
+    const result = applyAutotuneCommand(score, requestedTrack, autotune);
+    if (result.next && result.kind)
+      await commitScore(result.next, result.kind, result.payload);
+    return result.ok ? ok(result.message) : fail(result.message);
+  }
+  // 0.7 Voice: `/vocal <verb>`; lanes register verbs in VOCAL_VERBS.
+  setClipImportDeps({
+    media: {
+      ...mediaServices(),
+      signal: new AbortController().signal,
+      progress: () => undefined,
+    },
+  });
+  const vocal = parseVocalCommand(command);
+  if (vocal) {
+    if (vocal.kind === "verb") await materializeDraft();
+    const result = await runVocalCommand(vocal, {
+      score,
+      trackId: requestedTrack,
+      cwd: process.cwd(),
+    });
+    if (!result.ok) return fail(result.message);
+    if (result.next && result.kind) {
+      await commitScore(result.next, result.kind, {
+        trackId: requestedTrack,
+        ...result.payload,
+      });
+      await projectSync?.flushScore();
+    }
+    // A verb that made or chose another track (a vocoder carrier): focus it.
+    if (result.trackId && result.trackId !== requestedTrack) {
+      await port.focus(result.trackId);
+      requestedTrack = result.trackId;
+    }
+    return ok(result.message);
+  }
   const pack = parsePackCommand(command);
   if (pack) return packCommand(pack);
   const pattern = parsePatternCommand(command);
   if (pattern) return patternCommand(pattern);
   const kit = parseKitCommand(command);
-  if (kit) return kitCommand(kit, /^\/kit\s*$/i.test(command.trim()));
+  if (kit) return kitCommand(kit, /^\/?kits?\s*$/i.test(command.trim()));
   const wavetable = parseWavetableCommand(command);
   if (wavetable) return wavetableCommand(wavetable);
   const sessionReply = await sessionCommand(command);
@@ -1821,11 +2710,24 @@ 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 progression = parseProgressionCommand(command);
+  if (progression) {
+    if (progression.type === "progression") await materializeDraft();
+    const result = applyProgressionCommand(
+      score,
+      requestedTrack,
+      progression,
+      () => newId("n"),
+    );
+    if (result.next && result.kind)
+      await commitScore(result.next, result.kind, result.payload);
+    return result.ok ? ok(result.message) : fail(result.message);
+  }
   const strum = parseStrumCommand(command);
   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);
@@ -1836,6 +2738,15 @@ async function submit(prompt: string): Promise<string | Receipt> {
     if (rig.type !== "rig-show" && rig.type !== "rig-hint")
       await materializeDraft();
     const result = applyRigCommand(score, requestedTrack, rig);
+    if (result.next && result.kind)
+      await commitScore(result.next, result.kind, result.payload);
+    return readOrDone(result);
+  }
+  // 0.7 `/formant` and `/vowel`: short forms of `fx formant|vowel`.
+  const formant = parseFormantCommand(command) ?? parseVowelCommand(command);
+  if (formant) {
+    if (formant.type === "fx") await materializeDraft();
+    const result = applyFormantCommand(score, requestedTrack, formant);
     if (result.next && result.kind)
       await commitScore(result.next, result.kind, result.payload);
     return result.ok ? ok(result.message) : fail(result.message);
@@ -1857,6 +2768,8 @@ async function submit(prompt: string): Promise<string | Receipt> {
     const result = applyFxCommand(score, requestedTrack, fx, pinnedIr);
     if (result.next && result.kind)
       await commitScore(result.next, result.kind, result.payload);
+    // Bare `fx` reads the chain (`•`); it changes nothing.
+    if (result.ok && fx.type === "fx-list") return note(result.message);
     return result.ok ? ok(result.message) : fail(result.message);
   }
   const unknownFx = unknownFxMessage(command);
@@ -1872,6 +2785,15 @@ async function submit(prompt: string): Promise<string | Receipt> {
   }
   const tuning = parseTuningCommand(command);
   if (tuning) return tuningCommand(tuning);
+  const calibration = parseCalibrationCommand(command);
+  if (calibration) {
+    const result = applyCalibrationCommand(score, calibration);
+    if (result.next && result.kind)
+      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 =
@@ -1893,7 +2815,26 @@ 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 windCommand = parseWindCommand(command);
+  const vocoderCommand = parseVocoderCommand(command);
+  if (vocoderCommand) {
+    if (vocoderCommand.type === "vocoder-list")
+      tui.openText("vocoder presets", vocoderListLines());
+    if (
+      vocoderCommand.type !== "vocoder-list" &&
+      vocoderCommand.type !== "vocoder-usage"
+    )
+      await materializeDraft();
+    const result = applyVocoderCommand(score, requestedTrack, vocoderCommand);
+    if (result.next && result.kind)
+      await commitScore(result.next, result.kind, result.payload);
+    // `/vocoder` on a vocal makes a carrier track: focus it.
+    if (result.trackId && result.trackId !== requestedTrack) {
+      await port.focus(result.trackId);
+      requestedTrack = result.trackId;
+    }
+    return result.ok ? ok(result.message) : fail(result.message);
+  }
+  const windCommand = parseWindCommand(command);
   if (windCommand) {
     if (windCommand.type === "wind-list")
       tui.openText("wind presets", windListLines());
@@ -1904,13 +2845,34 @@ 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 singCommand = parseSingCommand(command);
+  if (singCommand) {
+    if (singCommand.type === "sing-list")
+      tui.openText("sing presets", singListLines());
+    if (singCommand.type !== "sing-show" && singCommand.type !== "sing-list")
+      await materializeDraft();
+    const result = applySingCommand(score, requestedTrack, singCommand);
+    if (result.next && result.kind)
+      await commitScore(result.next, result.kind, result.payload);
+    return result.ok ? ok(result.message) : fail(result.message);
+  }
   const synth = parseSynthCommand(command);
   if (synth) {
     if (synth.type !== "synth-list") await materializeDraft();
     const result = applySynthCommand(score, requestedTrack, synth);
     if (result.next && result.kind)
       await commitScore(result.next, result.kind, result.payload);
-    return result.ok ? ok(result.message) : fail(result.message);
+    // 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);
   if (stringCommand) {
@@ -1922,7 +2884,7 @@ async function submit(prompt: string): Promise<string | Receipt> {
     const result = applyStringCommand(score, requestedTrack, stringCommand);
     if (result.next && result.kind)
       await commitScore(result.next, result.kind, result.payload);
-    return result.ok ? ok(result.message) : fail(result.message);
+    return readOrDone(result);
   }
   const grainHint = grainSrcHint(command);
   if (grainHint) return fail(grainHint);
@@ -1935,6 +2897,50 @@ 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 styleCommand = parseStyleCommand(
+    /^\/?styles?\s+presets$/i.test(command) ? "style list" : command,
+  );
+  if (styleCommand) {
+    const writes =
+      styleCommand.type === "style-apply" ||
+      styleCommand.type === "style-again";
+    // Bare `style` opens Arrange › style; `style list|ls|presets` lists.
+    if (
+      styleCommand.type === "style-families" &&
+      /^\/?styles?$/i.test(command)
+    ) {
+      openMenu("style");
+      return ok(
+        "style · ↑/↓ browse · enter makes the song · style list prints it",
+      );
+    }
+    if (writes) await materializeDraft();
+    const result = applyStyleCommand(score, styleCommand);
+    if (result.next && result.kind)
+      await commitScore(result.next, result.kind, result.payload);
+    if (result.log) tui.activity.pushNote(result.log);
+    if (!result.ok) return fail(result.message);
+    // A multi-line listing opens as text; the card keeps its first line
+    // so lines never run together on the one-line strip.
+    if (!writes && result.message.includes("\n")) {
+      const [head = "styles", ...rest] = result.message.split("\n");
+      tui.openText(head, rest);
+      return note(head);
+    }
+    // A new song: focus its first melodic track, so play and the menu
+    // land on something tonal instead of a track the style replaced.
+    const melodic = writes
+      ? result.next?.tracks.find((track) => !isDrumInstrument(track.instrument))
+      : undefined;
+    if (melodic && melodic.id !== requestedTrack) {
+      await port.focus(melodic.id);
+      requestedTrack = melodic.id;
+      draftTrack = false;
+    }
+    return ok(
+      melodic ? `${result.message} · focused ${melodic.id}` : result.message,
+    );
+  }
   const masterCommand = parseMasterCommand(command);
   if (masterCommand) {
     if (masterCommand.type === "master-measure")
@@ -1947,7 +2953,82 @@ async function submit(prompt: string): Promise<string | Receipt> {
     const result = applyMasterCommand(score, masterCommand);
     if (result.next && result.kind)
       await commitScore(result.next, result.kind, result.payload);
-    return result.ok ? ok(result.message) : fail(result.message);
+    return readOrDone(result);
+  }
+  // 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.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") {
+      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 result = loopSpan(score, loop.from, loop.to);
+    if (!result.ok) return fail(result.message);
+    await materializeDraft();
+    await commitScore(result.next, "score.loop", { loop: result.next.loop });
+    return ok(result.message);
   }
   const arrange = parseSectionCommand(command, score);
   if (arrange) {
@@ -1961,32 +3042,33 @@ async function submit(prompt: string): Promise<string | Receipt> {
     if (result.next && result.kind)
       await commitScore(result.next, result.kind, result.payload);
     if (result.seekBeat !== undefined) await seekTransport(result.seekBeat);
-    return result.ok ? ok(result.message) : fail(result.message);
+    return readOrDone(result);
   }
   const music = parseMusicCommand(command);
   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);
     return result.ok ? ok(result.message) : fail(result.message);
   }
-  const exportCommand = command.match(/^\/?export\s+([^\s]+)$/i);
+  const exportCommand = parseExportCommand(command);
   if (exportCommand) {
-    const path = resolve(exportCommand[1]!);
-    if (/\.midi?$/i.test(path)) {
+    const path = resolve(exportCommand.path);
+    if (exportCommand.format === "mid") {
       await writeFile(path, scoreToMidi(exportScore(score)));
-      return `exported midi · ${exportCommand[1]}`;
+      return `exported midi · ${exportCommand.path}`;
     }
-    // Audio comes from the offline renderer, never JSON under an audio name.
-    if (/\.(wav|aiff?|flac|mp3|ogg|m4a)$/i.test(path))
-      return fail(
-        `/export writes .track.json or .mid · render audio with: dawg render ${exportCommand[1]}`,
-      );
+    // Audio goes through the `dawg render` path, the same bytes as the CLI.
+    if (exportCommand.format === "wav")
+      return exportWav(exportCommand.path, exportCommand.stems);
+    // Other audio names are not formats dawg writes.
+    if (/\.(aiff?|flac|mp3|ogg|m4a)$/i.test(path))
+      return fail(`export · ${exportCommand.path} · ${EXPORT_USAGE}`);
     await writeFile(path, encodeLoop(score), "utf8");
-    return `exported · ${exportCommand[1]}`;
+    return `exported · ${exportCommand.path}`;
   }
   const importCommand = command.match(/^\/?import\s+([^\s]+)$/i);
   if (importCommand) {
@@ -2021,14 +3103,14 @@ async function submit(prompt: string): Promise<string | Receipt> {
         tui.activity.setSpinner(undefined);
       }
     }
-    const receiptText = await tuiSetModel(modelMatch[1]);
+    const result = await tuiSetModel(modelMatch[1]);
     provider = undefined;
     await currentProvider();
-    return receiptText;
+    return result.ok ? result.text : fail(result.text);
   }
   if (/^\/login\b/i.test(prompt.trim())) {
     const parsed = tuiLoginArgs(prompt.trim());
-    if (typeof parsed === "string") return `login · ${parsed}`;
+    if (typeof parsed === "string") return `model key · ${parsed}`;
     await handoff(() =>
       runTuiLogin(
         parsed.target === "auto" ? "pick" : parsed.target,
@@ -2038,8 +3120,8 @@ async function submit(prompt: string): Promise<string | Receipt> {
     provider = undefined;
     await currentProvider();
     return providerName === "offline"
-      ? "login · not signed in · direct commands still work"
-      : `signed in · ${providerName}`;
+      ? "no agent key · model key adds one · direct commands still work"
+      : `agent key · ${providerName}`;
   }
   if (/^\/(logout|auth)\b/i.test(prompt.trim())) {
     tui.activity.setSpinner(prompt.trim().split(/\s+/)[0]!.slice(1));
@@ -2054,8 +3136,46 @@ async function submit(prompt: string): Promise<string | Receipt> {
       tui.activity.setSpinner(undefined);
     }
   }
+  // The grammar's second reading (design §3): a line no handler took runs
+  // in its other spellings — `/x` ≡ `x`, aliases, `rm|remove|delete`,
+  // `list|presets|ls` — so only lines that failed before get one.
+  // A line the core prompt parser takes is already understood.
+  if (!recovering && !parsePrompt(prompt)) {
+    const retry = recover(
+      command,
+      (candidate) =>
+        parseExact(candidate, score) !== undefined ||
+        // Window verbs get only the slash toggle, never a listing word.
+        (candidate.startsWith("/") &&
+          SLASH_HANDLED.has(verbOf(candidate)) &&
+          candidate.split(/\s+/).length === command.trim().split(/\s+/).length),
+    );
+    if (retry !== undefined) {
+      recovering = true;
+      try {
+        return await submit(retry);
+      } finally {
+        recovering = false;
+      }
+    }
+  }
+  // Bare `rename`, `fork`, `resume`, `login` take free text: a hint only.
+  const freeText = FREE_TEXT_HINTS[command.toLowerCase()];
+  if (freeText !== undefined) return note(freeText);
+  const elsewhere = elsewhereHint(command);
+  if (elsewhere !== undefined) return note(elsewhere);
   // `/model` belongs to its own handler above; every other slash word that
   // reached here is unknown or misused, and never a question for the agent.
+  // `/instrument aah` is `instrument aah`; `instrument sing choir` is
+  // `instrument choir`.
+  const singWord = command.match(/^\/?instrument\s+sing\s+([a-z]+)$/i);
+  if (singWord && isSingWord(singWord[1]!.toLowerCase()))
+    return submit(`instrument ${singWord[1]!.toLowerCase()}`);
+  if (/^\/instrument\s/i.test(command) && parsePrompt(command.slice(1)))
+    return submit(command.slice(1));
+  // A synth or effect number out of range names its range.
+  const range = paramRangeError(command);
+  if (range) return fail(range);
   if (command.startsWith("/") && !/^\/model\b/i.test(command)) {
     const hint = usageHint(command);
     return fail(
@@ -2070,6 +3190,10 @@ async function submit(prompt: string): Promise<string | Receipt> {
     // A one-letter slip on a command whose arguments parse stays local.
     const fix = typoFix(command, parsesLocally);
     if (fix) return fail(`${truncateForCard(command)} · did you mean ${fix}?`);
+    // A grammar verb (not everyday English) never reaches the agent.
+    const verb = verbOf(command);
+    if (knownVerbs().has(verb) && !EVERYDAY_VERBS.has(verb))
+      return fail(usageCard(truncateForCard(command), `/help ${verb}`));
     if (process.env.DAWG_AI === "0")
       return fail(`unrecognized · ${truncateForCard(command)} · /help`);
     await materializeDraft();
@@ -2099,6 +3223,9 @@ async function submit(prompt: string): Promise<string | Receipt> {
     return parsed.action;
   }
   if (parsed.type === "set-tempo") {
+    const range = RANGES.tempo!;
+    if (parsed.tempoBpm < range.min || parsed.tempoBpm > range.max)
+      return fail(usageError(truncateForCard(command), range));
     const next = score.withTempo(parsed.tempoBpm);
     await commitScore(next, "score.tempo", { tempoBpm: parsed.tempoBpm });
     clock.follow(next);
@@ -2126,15 +3253,10 @@ async function submit(prompt: string): Promise<string | Receipt> {
   if (parsed.type === "track") {
     // An unknown word would store and play a plain sine: say so instead.
     const word = parsed.patch.instrument;
-    if (word !== undefined && isUnknownInstrument(word)) {
-      const advice = plainSineAdvice(word) ?? "";
-      const near = advice.match(/did you mean (\S+)\?/)?.[1];
-      return fail(
-        `instrument ${truncateForCard(word)} · not a dawg instrument${near ? ` · did you mean ${near}?` : ""} · /menu sounds lists them`,
-      );
-    }
+    if (word !== undefined && isUnknownInstrument(word))
+      return fail(unknownInstrumentMessage(word));
     // `instrument jangle`: a guitar alias also loads its rig.
-    const patch = parsed.word
+    const rigged = parsed.word
       ? {
           ...parsed.patch,
           ...rigWordPatch(
@@ -2143,6 +3265,27 @@ async function submit(prompt: string): Promise<string | Receipt> {
           ),
         }
       : parsed.patch;
+    // `instrument vocal` (0.7): the vocal chain fills unset effects.
+    const chain = isGuideInstrument(parsed.patch.instrument)
+      ? 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,
@@ -2163,6 +3306,13 @@ async function submit(prompt: string): Promise<string | Receipt> {
         ? plainSineAdvice(word)
         : undefined;
     if (sine) return `track · ${requestedTrack} · ${sine}`;
+    const added = [
+      chain.filter ? "hpf 90 Hz" : "",
+      chain.fx?.compressor ? "compressor 3:1" : "",
+      chain.reverb ? "plate 0.14" : "",
+    ].filter(Boolean);
+    if (added.length)
+      return `track · ${requestedTrack} · vocal · added ${added.join(", ")} · fx … off to remove`;
     return `track · ${requestedTrack}`;
   }
   if (parsed.type === "automation") {
@@ -2207,6 +3357,9 @@ async function submit(prompt: string): Promise<string | Receipt> {
     return `cleared · ${requestedTrack}`;
   }
   if (parsed.type === "remove-note") {
+    // A receipt never claims a removal that did not happen.
+    if (!score.notes.some((note) => note.id === parsed.noteId))
+      return fail(noNote(parsed.noteId));
     const next = applyScoreOperation(score, {
       type: "removeNote",
       noteId: parsed.noteId,
@@ -2254,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(
@@ -2291,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.
@@ -2324,6 +3486,10 @@ async function focusTrack(trackId: string): Promise<Receipt> {
         ...newPianoTrack(trackId),
         // `track vibes`: a 0.6 modal word names the track and its preset.
         ...(isModalWord(trackId) ? instrumentPatchForWord(trackId) : {}),
+        // `track vocal` (0.7): a clip track with the vocal chain.
+        ...(isGuideInstrument(trackId)
+          ? { instrument: "vocal", ...vocalChainPatch(undefined) }
+          : {}),
       },
     });
     await commitScore(next, "track.create", { trackId });
@@ -2336,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,
   );
 }
 
@@ -2624,11 +3790,19 @@ async function packCommand(command: PackCommand): Promise<Receipt> {
         const store = packs();
         const a = await store.pruneCache(to(store.maxFileCacheBytes));
         const b = await library.pruneCache(to(library.maxCacheBytes));
-        freed = { files: a.removed + b.removed, bytes: a.freed + b.freed };
+        const c = await pruneAnalysisCache(
+          analysisDir(process.cwd()),
+          to(ANALYSIS_CACHE_BYTES),
+        );
+        freed = {
+          files: a.removed + b.removed + c.removed,
+          bytes: a.freed + b.freed + c.freed,
+        };
       }
       const lines = cacheLines({
         packs: await packs().cacheStatus(),
         assets: await library.cacheStatus(),
+        analysis: await analysisCacheStatus(process.cwd()),
         ...(freed ? { freed } : {}),
       });
       tui.openText("cache", lines);
@@ -2703,27 +3877,38 @@ async function packCommand(command: PackCommand): Promise<Receipt> {
   }
 }
 
+/**
+ * A command result as a receipt: a refusal is ✗, a change is ✓, and a read
+ * that changed nothing (a listing or a show) is •.
+ */
+function readOrDone(
+  result: Readonly<{ ok: boolean; message: string; next?: unknown }>,
+): Receipt {
+  if (!result.ok) return fail(result.message);
+  return result.next ? ok(result.message) : note(result.message);
+}
+
 async function patternCommand(command: PatternCommand): Promise<Receipt> {
   if (command.kind === "list") {
-    tui.openText("patterns", DRUM_PATTERNS.map(patternLine));
-    return ok(`patterns · ${DRUM_PATTERNS.length} · /pattern <name>`);
+    tui.openText("grooves", DRUM_PATTERNS.map(patternLine));
+    return note(`grooves · ${DRUM_PATTERNS.length} · groove <name>`);
   }
   if (command.kind === "browse") {
     tui.openPicker({
       id: "pattern",
-      title: "drum patterns",
+      title: "grooves",
       hint: HINTS.audition,
       audition: true,
       items: DRUM_PATTERNS.map((entry) => ({
         label: `${entry.label.padEnd(22)} ${entry.tempo.bpm} BPM · ${entry.tags.join(", ")}`,
-        value: `/pattern ${entry.name}`,
+        value: `/groove ${entry.name}`,
       })),
       filterable: true,
       index: 0,
     });
     patternPreview = undefined;
     previewPattern(DRUM_PATTERNS[0]?.name);
-    return ok("patterns · ↑/↓ preview · Enter applies on the focused track");
+    return note("grooves · ↑/↓ preview · Enter applies on the focused track");
   }
   await materializeDraft();
   const result = applyDrumPattern(
@@ -2784,7 +3969,7 @@ function openKitPicker(): Receipt {
   }));
   tui.openPicker({
     id: "kit",
-    title: "drum kits",
+    title: "kits",
     hint: HINTS.audition,
     audition: true,
     items,
@@ -2816,7 +4001,7 @@ async function kitCommand(command: KitCommand, bare = false): Promise<Receipt> {
       .map((entry) => `${entry.name} · synth · ${entry.detail}`);
     lines.push(...kitListLines(await packs().bankAliases(ALIASED_PACK)));
     tui.openText("kits", lines);
-    return ok("kits · /kit <name or nickname> on the focused drum track");
+    return note("kits · /kit <name or nickname> on the focused drum track");
   }
   await materializeDraft();
   const trackId = kitTarget(score, requestedTrack);
@@ -2927,12 +4112,10 @@ function adoptMeta(meta: typeof record.meta): void {
   record = { ...record, meta };
   if (meta.name !== announcedName) {
     announcedName = meta.name;
-    tui.activity.pushCard(
-      meta.nameSource === "auto"
-        ? `${meta.name} (auto-named) · rename with /rename <name>`
-        : `session · ${meta.name}`,
-      { tone: "info" },
-    );
+    // The auto-name joins the receipt that earned it, as a quiet suffix.
+    if (meta.nameSource === "auto")
+      tui.activity.attachNote(`named “${meta.name}” · /rename`);
+    else tui.activity.pushCard(`session · ${meta.name}`, { tone: "info" });
   }
 }
 
@@ -3046,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",
@@ -3072,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;
@@ -3096,11 +4536,14 @@ function menuContext(): MenuContext {
       committedChords: chordSettings,
     },
     trackId: requestedTrack,
+    sessionName: record.meta.name,
     playing: clock.playing,
     grid: session?.grid ?? DEFAULT_GRID,
     grids: GRIDS.map((grid) => grid.label),
     clickOn: session?.clickOn ?? false,
     countInBars: session?.countInBars ?? 1,
+    showMe: showMe.level,
+    audio: audioMenu(),
     chords: stagedChordSettings() ?? session?.chords.settings ?? chordSettings,
     projectRoot: process.cwd(),
   };
@@ -3125,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;
 }
 
@@ -3390,7 +4834,7 @@ async function startAuditionLoop(): Promise<void> {
   loop.focus(requestedTrack);
   // One sound at a time: the song stops while the loop plays.
   if (clock.playing) await setTransport("pause");
-  previewEngine().setLeadMs(PLAY_LEAD_MS);
+  previewEngine().setLeadMs(previewEngine().playLeadMs);
   loop.start();
 }
 
@@ -3606,12 +5050,23 @@ function refreshMenu(): void {
   if (fader) {
     const fields = menu.faderFields(context);
     if (fields.length === 0) closeFader();
-    else
-      tui.drawer = drawerView(fader, fields, menu.faderCommitted(context), {
+    else {
+      const focusedField = fields[focusIndex(fader, fields)];
+      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);
   tui.openPicker({
@@ -3629,6 +5084,117 @@ function refreshMenu(): void {
 // ── the fader drawer ─────────────────────────────────────────────────
 
 /** Enter on a number row (or a bare `volume`, `fx filter`): the drawer. */
+/**
+ * `export song.wav [stems]`: render the song as `dawg render song.wav` would
+ * (the offline renderer, deterministic), then with `stems` one WAV per
+ * audible track beside it (`song-bass.wav`), each that track soloed.
+ */
+async function exportWav(path: string, stems: boolean): Promise<Receipt> {
+  const directory = await mkdtemp(join(tmpdir(), "dawg-export-"));
+  const errors: string[] = [];
+  const sink = { write: (text: string) => errors.push(text.trim()) };
+  const quiet = { write: () => undefined };
+  const render = async (song: TrackScore, target: string): Promise<boolean> => {
+    const file = join(directory, "song.track.json");
+    await writeFile(file, encodeLoop(song), "utf8");
+    const code = await runRenderCommand(
+      ["render", target, "--import", file],
+      process.cwd(),
+      quiet,
+      sink,
+    );
+    return code === 0;
+  };
+  tui.activity.setSpinner(`export ${path}`);
+  try {
+    if (!(await render(score, path)))
+      return fail(errors.at(-1) ?? `export failed · ${path}`);
+    if (!stems) return ok(`exported · ${path}`);
+    const written: string[] = [];
+    const base = path.replace(/\.wav$/i, "");
+    for (const track of score.tracks) {
+      if (!isTrackAudible(score, track.id)) continue;
+      let solo = score;
+      for (const other of score.tracks)
+        solo = applyScoreOperation(solo, {
+          type: "updateTrack",
+          trackId: other.id,
+          patch: { solo: other.id === track.id },
+        });
+      const target = `${base}-${track.id}.wav`;
+      if (!(await render(solo, target)))
+        return fail(errors.at(-1) ?? `export failed · ${target}`);
+      written.push(target);
+    }
+    return ok(stemsReceipt(path, written));
+  } finally {
+    tui.activity.setSpinner(undefined);
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+
+/** `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.
+  const faders: Readonly<Record<string, string>> = {
+    tempo: "tempo",
+    bpm: "tempo",
+    bars: "loop length",
+    meter: "beats per bar",
+  };
+  const label = faders[command.replace(/^\//, "").toLowerCase()];
+  if (!label) return undefined;
+  menu.show(context, "project");
+  if (menu.faderFields(context).some((field) => field.label === label))
+    return label;
+  menu.close();
+  return undefined;
+}
+
 /**
  * Open the drawer on `label`. `standalone` drawers came from a command or a
  * click, not from inside the menu, so closing one closes the menu too.
@@ -3708,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 (
@@ -3731,7 +5301,7 @@ function mouseInput(event: MouseEvent): string[] {
       return [];
     }
     if (fader) return [];
-    if (tui.ui.overlay) return [event.delta < 0 ? KEY_UP : KEY_DOWN];
+    if (tui.ui.overlay) return [event.delta < 0 ? ARROW_UP : ARROW_DOWN];
     return [];
   }
   // A drag keeps moving the fader it started on, even past the bar's ends.
@@ -3821,7 +5391,9 @@ function mouseInput(event: MouseEvent): string[] {
     }
     case "transport":
       if (tui.ui.overlay) return [];
-      void toggleTransport().finally(() => requestFrame());
+      void toggleTransport()
+        .catch((error: unknown) => transportFailed(error))
+        .finally(() => requestFrame());
       return [];
     case "tracks":
       if (tui.ui.overlay) return [];
@@ -3852,22 +5424,335 @@ function playSession(): PlaySession {
 }
 
 async function enterPlay(): Promise<Receipt> {
-  if (play?.on) return ok(`play · ${play.track} · esc leaves`);
+  if (play?.on) return ok(`play mode · ${play.track} · esc leaves`);
   await materializeDraft();
   const session = playSession();
   await session.enter();
   if (hasSamplerTracks(score)) void sampleProblems(score);
   return ok(
-    `play · ${session.track} · ${session.keyboard.range} · ? keys · esc leaves`,
+    `play mode · ${session.track} · ${session.layout.drums ? "kit" : session.keyboard.range} · ? keys · esc leaves`,
   );
 }
 
+/**
+ * `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).
@@ -3888,9 +5773,7 @@ function playKey(value: string): boolean {
     else if (result.command === "transport") {
       if (!session.startWithCountIn())
         void toggleTransport().catch((error: unknown) =>
-          tui.activity.pushError(
-            `transport failed · ${error instanceof Error ? error.message : String(error)}`,
-          ),
+          transportFailed(error),
         );
     } else if (result.command === "menu") return false;
     return true;
@@ -3908,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,
@@ -3919,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;
@@ -3941,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 });
@@ -3952,16 +5831,21 @@ function playHost() {
     async stopTransport(): Promise<void> {
       await setTransport("pause");
     },
+    ghost(pitch: number) {
+      tui.delight.ghost(pitch, Date.now());
+      requestFrame();
+    },
     card(text: string, tone: "info" | "success" | "warning" | "error") {
       if (tone === "error") tui.activity.pushError(text);
       else
         tui.activity.pushCard(text, {
           tone,
           trackId: requestedTrack,
-          resultRevision: tone === "success" ? record.revision : undefined,
+          resultRevision:
+            tone === "success" ? shownRevision(record) : undefined,
         });
     },
-    newNoteId: () => randomUUID().slice(0, 12),
+    newNoteId: () => newId("n"),
   };
 }
 
@@ -3982,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 (
@@ -4005,6 +5922,9 @@ function timingChanged(previous: TrackScore, next: TrackScore): boolean {
 function syncHost(): SyncHost {
   return {
     project: process.cwd(),
+    // The files belong to one session at a time; another session's window
+    // stays detached instead of reprinting over them.
+    sessionId: () => record.sessionId,
     current: () => score,
     async commit(plan, summary) {
       const baseRevision = record.revision;
@@ -4030,7 +5950,8 @@ function syncHost(): SyncHost {
         tui.activity.pushCard(text, {
           tone,
           hint,
-          resultRevision: tone === "success" ? record.revision : undefined,
+          resultRevision:
+            tone === "success" ? shownRevision(record) : undefined,
         });
     },
     types(state) {
@@ -4039,32 +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(),
     );
-    score = restored;
+    // Compare with what was undone, which another window may have written.
+    score = scoreFromJSON(record.composition);
     if (clock.playing) void audio.play(score);
     return ok(
-      `${direction === "undo" ? "undid" : "redid"} · rev ${target.revision}`,
+      historyReceipt(
+        direction,
+        before,
+        score,
+        shownRevision(record, revision),
+      ) + author,
     );
   } catch (error) {
     if (error instanceof SessionConflictError)
@@ -4075,7 +6055,42 @@ async function stepHistory(direction: "undo" | "redo"): Promise<Receipt> {
   }
 }
 
-/** The space-bar toggle: flip the transport, then record it for other windows. */
+/** `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(
+    `transport failed · ${error instanceof Error ? error.message : String(error)}`,
+    { tone: "error" },
+  );
+}
+
+/**
+ * The revision dawg shows (header, receipts, undo): edits to the song.
+ * Play and pause are logged so other windows follow them, but they are not
+ * edits, so they never move the number: a revision shows as itself minus
+ * the transport events at or before it.
+ */
+function shownRevision(
+  value: typeof record,
+  revision = value.revision,
+): number {
+  let transports = 0;
+  for (const event of value.events)
+    if (event.revision <= revision && event.kind === "transport")
+      transports += 1;
+  return revision - transports;
+}
+
+/**
+ * The space-bar toggle: flip the transport, then record it for other
+ * windows. The log entry keeps windows in step; the header's revision
+ * (`shownRevision`) skips it, since play/pause is not an edit.
+ */
 async function toggleTransport(): Promise<void> {
   await setTransport("toggle");
   try {
@@ -4126,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 });
@@ -4145,11 +6166,11 @@ async function runAgent(text: string): Promise<string | Receipt> {
   if (agentTurn) return warn("agent busy · Esc cancels");
   const selection = await currentProvider();
   if (selection.kind === "offline")
-    return fail(
-      `unrecognized · ${truncateForCard(text)} · ${selection.reason}`,
-    );
+    return fail(`${truncateForCard(text)} · ${NO_AGENT}`);
   const turn = { controller: new AbortController(), steering: [] as string[] };
   agentTurn = turn;
+  // The turn ends on one musical receipt of what it changed.
+  const before = score;
   reportAgentActivity(`${providerName} · thinking…`);
   // xcb admits a pending account on its first call, which takes longer.
   let admitting = selection.kind === "xcb" && selection.admissionPending;
@@ -4182,6 +6203,8 @@ async function runAgent(text: string): Promise<string | Receipt> {
           }
           return;
         }
+        if (event.type === "done")
+          tui.activity.setTurnReceipt(musicalReceipt(before, score));
         agentEventSink(event);
       },
     });
@@ -4213,7 +6236,7 @@ function currentProvider(): Promise<ProviderSelection> {
     provider = selectProvider().catch((): ProviderSelection => ({
       kind: "offline",
       choice: "auto",
-      reason: "provider unavailable; run `dawg login`",
+      reason: "provider unavailable; run `dawg model key`",
     }));
   }
   return provider.then((selection) => {
@@ -4225,9 +6248,9 @@ function currentProvider(): Promise<ProviderSelection> {
       !invalidNoticeShown
     ) {
       invalidNoticeShown = true;
-      tui.activity.pushCard(`sign-in stopped working · ${selection.reason}`, {
+      tui.activity.pushCard(`agent key stopped working · ${selection.reason}`, {
         tone: "warning",
-        hint: "/login",
+        hint: "/model key",
       });
     }
     providerStamp.offline = selection.kind === "offline";
@@ -4302,6 +6325,180 @@ function agentPreviewHost(): PreviewHost {
   };
 }
 
+// ── show-me ──────────────────────────────────────────────────────────
+
+/**
+ * Show-me (docs/show-me.md): with an API provider the agent writes prompt
+ * commands, streamed. The line being written is ghost text in the empty
+ * prompt bar at the model's own speed; each complete line runs through
+ * `submit()`, the path a typed Enter takes, at once. A parameter value
+ * glides there over ~150 ms while the loop plays (you hear it), notes and
+ * hits sound as they arrive (in time when the stream is ahead of the tempo,
+ * as step entry when it is behind), and the caption names the key or fader
+ * a person would use. Nothing waits for the turn to end.
+ */
+
+function showMeTyping(text: string): void {
+  showMe.ghost = text || undefined;
+  if (text && showMe.level === "on") showMe.caption = undefined;
+  requestFrame();
+}
+
+function showMeCaption(text: string | undefined): void {
+  if (showMe.level !== "on") return;
+  showMe.caption = text;
+  if (showMe.clear) clearTimeout(showMe.clear);
+  showMe.clear = undefined;
+  requestFrame();
+}
+
+/** End of a turn: the ghost goes, the caption becomes the do-it-yourself hint. */
+function showMeFinish(): void {
+  showMe.ghost = undefined;
+  showMe.notes.reset();
+  const hint = finishHint(showMe.commands);
+  showMe.commands = [];
+  if (hint && showMe.level === "on") {
+    showMeCaption(hint);
+    showMe.clear = setTimeout(() => {
+      showMe.caption = undefined;
+      showMe.clear = undefined;
+      requestFrame();
+    }, 8_000);
+  } else {
+    showMe.caption = undefined;
+    requestFrame();
+  }
+}
+
+/**
+ * Slide a fader to its new value the way the drawer does: each eased step is
+ * the field's own command, staged on a scratch score and played, so the loop
+ * moves through the values. Only while the loop plays (otherwise nothing is
+ * heard and the glide would only cost time); never longer than ~150 ms.
+ */
+async function glideFader(param: string, target: number): Promise<void> {
+  if (!clock.playing || !stdout.isTTY) return;
+  const scratch = new EditMenu();
+  const context = { ...menuContext(), score };
+  const label = scratch.showFader(context, param);
+  if (!label) return;
+  const field = scratch
+    .faderFields(context)
+    .find((candidate) => candidate.label === label);
+  scratch.close();
+  if (field?.kind !== "number") return;
+  const from = field.value ?? field.start ?? target;
+  const steps = glideValues(from, target).slice(0, -1);
+  for (const value of steps) {
+    const staged = await applyStaged(score, field.command(value));
+    if (staged.next && clock.playing) void audio.play(staged.next);
+    await Bun.sleep(GLIDE_STEP_MS);
+  }
+}
+
+/** Sound one streamed note on the audition voice (the loop is stopped). */
+function soundStreamedNote(
+  value: TrackScore,
+  trackId: string,
+  pitch: number,
+  startBeat: number,
+): void {
+  if (clock.playing) return; // The loop itself plays it.
+  const engine = liveEngine();
+  if (!engine?.canMonitor) return;
+  const tick = Math.round(startBeat * value.ticksPerBeat);
+  const note = value.notes.find(
+    (candidate) =>
+      candidate.trackId === trackId &&
+      candidate.pitch === pitch &&
+      candidate.startTick === tick,
+  );
+  if (!note) return;
+  try {
+    const json = value.toJSON() as unknown as Record<string, unknown>;
+    const single = scoreFromJSON({
+      ...json,
+      notes: [{ ...note, startTick: 0 }],
+    });
+    const pcm = renderAudition({
+      score: single,
+      trackId,
+      sampleRate: engine.sampleRate,
+      ...(liveSampleBank ? { samples: liveSampleBank } : {}),
+    });
+    if (!pcm) return;
+    void engine
+      .monitor(true)
+      .then(() => engine.noteOn(AUDITION_VOICE, pcm))
+      .catch(() => undefined);
+  } catch {
+    // A note that cannot render is still in the score.
+  }
+}
+
+/** The command host the show-me agent loop runs lines through. */
+function showMeCommandHost(): AgentHost["commands"] {
+  return {
+    isCommand: (line) =>
+      isAgentCommand(line, score) || isBrokenCommand(line, score),
+    async run(line): Promise<CommandOutcome> {
+      if (!agentPathsAllowed(line)) {
+        const revision = shownRevision(record);
+        return {
+          ok: false,
+          message: `${line} · the agent works only inside this folder`,
+          baseRevision: revision,
+          resultRevision: revision,
+        };
+      }
+      if (isBrokenCommand(line, score)) {
+        // A command that does not parse is a red receipt, never prose.
+        const base = baseline();
+        receipt(fail(brokenCommandReceipt(line)), base);
+        return {
+          ok: false,
+          message: brokenCommandReceipt(line),
+          baseRevision: base.revision,
+          resultRevision: base.revision,
+        };
+      }
+      const gesture = gestureFor(line, { score, trackId: requestedTrack });
+      showMeCaption(gesture.caption);
+      showMe.commands.push(line);
+      if (gesture.kind === "fader" && showMe.level === "on")
+        await glideFader(gesture.param, gesture.value);
+      const base = baseline();
+      tui.activity.pushNote(`agent › ${line}`, "request");
+      let result: string | Receipt;
+      try {
+        result = await submit(line);
+      } catch (error) {
+        result = fail(describeError(line, error));
+      }
+      receipt(result, base);
+      if (gesture.kind === "keys" && showMe.level === "on") {
+        const trackId = requestedTrack;
+        const after = score;
+        for (const note of gesture.notes) {
+          const { atMs } = showMe.notes.schedule(note.start, performance.now());
+          const delay = Math.max(0, atMs - performance.now());
+          setTimeout(
+            () => soundStreamedNote(after, trackId, note.pitch, note.start),
+            delay,
+          );
+        }
+      }
+      return {
+        ok: toneOf(result) !== "error",
+        message: typeof result === "string" ? result : result.text,
+        baseRevision: shownRevision(record, base.revision),
+        resultRevision: shownRevision(record),
+      };
+    },
+  };
+}
+
 function agentHost(
   turn: { steering: string[] },
   selection: ProviderSelection,
@@ -4376,6 +6573,9 @@ function agentHost(
       }
     },
     takeSteering: () => turn.steering.splice(0),
+    ...(showMe.level !== "off" && stdout.isTTY
+      ? { commands: showMeCommandHost() }
+      : {}),
     workspace: { root: process.cwd() },
     // A written project source is applied before the tool result returns,
     // so the model reads the outcome and any type errors in the same step.