@hraness/dawg 0.6.0 → 0.7.0

package/src/tui/menu.ts

@@ -8,18 +8,47 @@
  *
  * Rendering reuses the TUI's picker overlay: `view()` returns a picker.
  */
+import { TOPIC_ALIASES } from "../lang/glossary.ts";
+import {
+  voiceEffectRows,
+  voiceRootDetail,
+  voiceRootNodes,
+} from "./menu-voice.ts";
 import { commandParam, sketchFor } from "./sketch.ts";
-import { HINTS } from "../../tui/grammar.ts";
+import { nearest } from "../commands/nearest.ts";
+import {
+  ARROW_DOWN,
+  ARROW_UP,
+  HINTS,
+  KEY_BACK,
+  KEY_BACKSPACE,
+  KEY_DOWN,
+  KEY_END,
+  KEY_ENTER,
+  KEY_FORWARD,
+  KEY_HOME,
+  KEY_LEFT,
+  KEY_PAGE_DOWN,
+  KEY_PAGE_UP,
+  KEY_RESET,
+  KEY_RIGHT,
+  KEY_UP,
+} from "../../tui/grammar.ts";
 import { arrangeDetail, arrangeNodes } from "./arrange-menu.ts";
 import { auditionKey, isStageable, type AuditionKey } from "./audition.ts";
 import { performanceDetail, performanceNodes } from "./performance-menu.ts";
 import { malletsMenu, modalParameterNodes } from "./modal-menu.ts";
+import { windParameterNodes, windsMenu } from "./wind-menu.ts";
+import { singParameterNodes } from "./sing-menu.ts";
 import type { FaderSpec } from "./fader.ts";
 import {
   openingMeterCommand,
   openingUnit,
   tempoDetail,
   tempoMenuNode,
+  START_BARS,
+  START_BEATS_PER_BAR,
+  START_TEMPO_BPM,
 } from "./menu-time.ts";
 import {
   AUTOMATION_PARAMETERS,
@@ -39,6 +68,8 @@ import {
   type Track,
   type TrackAutomationParameter,
   type TrackScore,
+  CALIBRATION_LATEST,
+  createScore,
 } from "../../core/score.ts";
 import {
   CORE_EFFECTS,
@@ -47,6 +78,8 @@ import {
   RIG_PRESETS,
   RIG_STAGES,
   rigPresetOf,
+  SHOEGAZE_EFFECTS,
+  VOWEL_VALUES,
   effectPresetNames,
   effectSpec,
   type EffectName,
@@ -95,16 +128,29 @@ import {
   STRING_PARAMS,
   STRING_PRESET_NAMES,
   STRING_PRESETS,
+  BOWED_PRESET_NAMES,
+  BOW_SIMPLE_PARAMS,
+  resolveString,
   STRING_SIMPLE_PARAMS,
   stringPresetOf,
 } from "../../core/strings.ts";
 import {
   KEYS_PARAMS,
   KEYS_PRESETS,
-  KEYS_SIMPLE,
-  PIANO_FAMILIES,
+  KEYS_FAMILIES,
+  ORGAN_ROWS,
+  ORGAN_TEXT,
+  PIPE_REGISTRATIONS,
+  PIPE_STOPS,
+  isElectricFamily,
+  isKeysFamily,
+  isOrganFamily,
   isPianoFamily,
+  keysParamsFor,
+  keysSimpleFor,
+  pipeStops,
   resolvedKeys,
+  type OrganFamily,
 } from "../../core/keys.ts";
 import type { PickerItem } from "../../tui/app.ts";
 import { BUILTIN_TABLES, BUILTIN_TABLE_NAMES } from "../audio/wavetable.ts";
@@ -124,6 +170,8 @@ import {
   PROGRESSION_STYLES,
   SCALE_NAMES,
   SPREADS,
+  STROKE_PATTERN_NAMES,
+  GUITAR_TUNING_NAMES,
   keyName,
   parseKey,
 } from "../../core/chords.ts";
@@ -135,6 +183,7 @@ import {
   type Tuning,
 } from "../../core/tuning.ts";
 import { rootName, tuningStepsText } from "../commands/tuning.ts";
+import { describeGuitar } from "../commands/strum.ts";
 import {
   granularBrowseNodes,
   granularMenuDetail,
@@ -144,6 +193,7 @@ import {
 import {
   ARP_RATES,
   CHORD_MODES,
+  STROKE_SPEED_MS,
   defaultChordSettings,
   type ChordSettings,
 } from "./play-chords.ts";
@@ -157,6 +207,10 @@ export type MenuContext = Readonly<{
   grids: readonly string[];
   clickOn: boolean;
   countInBars: number;
+  /** How much agent turns show (`/showme`); absent hides the row. */
+  showMe?: string;
+  /** The session's name, for Project › session and export file names. */
+  sessionName?: string;
   /** Play mode's chord settings (defaults when absent). */
   chords?: ChordSettings;
   /** Project root, for the project's own wavetables (none when absent). */
@@ -174,6 +228,8 @@ export type MenuAudition = Readonly<{
   looping: boolean;
   /** Edits are staged (an Enter keeps them, Esc reverts them). */
   dirty: boolean;
+  /** How many edits are staged, for the drawer's A/B badge. */
+  staged?: number;
   /** The committed score, for `staged ← committed` on changed rows. */
   committed: TrackScore;
   /** The footer while auditioning. */
@@ -342,7 +398,7 @@ const TRACK_LANE_LABEL: Readonly<Record<TrackAutomationParameter, string>> = {
   resonance: "filter resonance",
   "delay-feedback": "delay feedback",
   "delay-mix": "delay mix",
-  wt: "wavetable position",
+  wt: "table position",
 };
 
 const FX_LANE_INFO = new Map(FX_LANES.map((entry) => [entry.lane, entry]));
@@ -384,7 +440,11 @@ function laneLabel(lane: AutomationParameter): string {
     info.effect === "synth" ||
     info.effect === "string" ||
     info.effect === "keys" ||
-    info.effect === "modal"
+    info.effect === "modal" ||
+    info.effect === "grain" ||
+    info.effect === "wind" ||
+    info.effect === "sing" ||
+    info.effect === "vocoder"
       ? info.effect
       : effectSpec(info.effect).label;
   return `${owner} ${info.param}${unit}`;
@@ -418,9 +478,17 @@ export function rootNodes(context: MenuContext): MenuNode[] {
       id: "sound",
       label: "Sound",
       detail: `${name} · ${track?.instrument ?? "?"}`,
-      help: "the focused track's instrument and its voice",
+      help: "the focused track's instrument, its controls and performance",
       build: soundSectionNodes,
     },
+    {
+      kind: "menu",
+      id: "voice",
+      label: "Voice",
+      detail: voiceRootDetail(context),
+      help: "sing, lyrics, clips, pitch, autotune, formant and vocoder",
+      build: voiceRootNodes,
+    },
     {
       kind: "menu",
       id: "effects",
@@ -433,26 +501,34 @@ export function rootNodes(context: MenuContext): MenuNode[] {
       kind: "menu",
       id: "rhythm",
       label: "Rhythm",
-      detail: "euclid editor · patterns · kits",
-      help: "drum hits per voice, ready-made grooves and drum kits",
+      detail: "euclid editor · grooves · kits",
+      help: "hits per drum, ready-made grooves and kits",
       build: rhythmNodes,
     },
     {
       kind: "menu",
       id: "chords",
-      label: "Chords",
+      label: "Chords and key",
       detail: chordsDetail(context),
-      help: "song key and how chords play in play mode (Ctrl-P)",
+      help: "the song key and tuning, and how chords play in play mode (Ctrl-P)",
       build: chordNodes,
     },
     {
       kind: "menu",
       id: "mix",
-      label: "Mix & automation",
+      label: "Mix",
       detail: `${tracks} track${tracks === 1 ? "" : "s"} · ${automated} lane${automated === 1 ? "" : "s"} moving`,
-      help: "volume, pan, mute and solo per track; values that change over time",
+      help: "volume, pan, mute and solo per track, automation and the master",
       build: mixSectionNodes,
     },
+    {
+      kind: "menu",
+      id: "arrange",
+      label: "Arrange",
+      detail: arrangeDetail(context),
+      help: "tracks, song sections, the form, builds, drops, fills and styles",
+      build: arrangeRootNodes,
+    },
     {
       kind: "menu",
       id: "project",
@@ -460,47 +536,92 @@ export function rootNodes(context: MenuContext): MenuNode[] {
       detail: context.score.time
         ? `${tempoDetail(context.score)} · ${context.score.bars} bars`
         : `${num(context.score.tempoBpm)} BPM · ${context.score.beatsPerBar}/4 · ${context.score.bars} bars`,
-      help: "tempo, meter, tempo map, loop length, play, click and count-in",
+      help: "play, tempo, meter, loop, click, export, session, agent and help",
       build: transportNodes,
     },
-    {
-      kind: "menu",
-      id: "arrange",
-      label: "Arrange",
-      detail: arrangeDetail(context),
-      help: "song sections, the form, builds, drops and fills",
-      build: arrangeNodes,
-    },
   ];
 }
 
-/** Old section names still open the menu where that content now lives. */
-const SECTION_ALIASES: Readonly<Record<string, readonly string[]>> = {
-  sound: ["sound"],
-  parameters: ["sound"],
-  sounds: ["sound", "browse"],
-  performance: ["sound", "performance"],
-  expression: ["sound", "performance"],
-  effects: ["effects"],
-  rhythm: ["rhythm"],
-  chords: ["chords"],
-  mix: ["mix"],
-  track: ["mix"],
-  automation: ["mix", "automation"],
-  master: ["mix", "master"],
-  project: ["project"],
-  transport: ["project"],
-  tempo: ["project", "tempo"],
-  meter: ["project", "tempo"],
-  time: ["project", "tempo"],
-  tuning: ["project", "tuning"],
-  scale: ["project", "tuning"],
-  arrange: ["arrange"],
-  sections: ["arrange"],
-  form: ["arrange"],
-};
+/**
+ * Where each `/menu <id>` opens: the ten topic ids (sound voice effects
+ * rhythm chords mix arrange project keys agent) first, then every older id,
+ * as a path of menu ids from the root. `keys` opens Project › help and
+ * guides; the ? panel itself belongs to the window.
+ */
+export const SECTION_ALIASES: Readonly<Record<string, readonly string[]>> =
+  Object.freeze(
+    withTopicAliases({
+      sound: ["sound"],
+      voice: ["voice"],
+      effects: ["effects"],
+      rhythm: ["rhythm"],
+      chords: ["chords"],
+      mix: ["mix"],
+      arrange: ["arrange"],
+      project: ["project"],
+      keys: ["project", "help"],
+      agent: ["project", "agent"],
+      // Older ids, kept as aliases.
+      parameters: ["sound"],
+      sounds: ["sound", "browse"],
+      instruments: ["sound", "browse"],
+      performance: ["sound", "performance"],
+      expression: ["sound", "performance"],
+      clips: ["voice"],
+      lyrics: ["voice"],
+      autotune: ["voice"],
+      sing: ["voice"],
+      vocoder: ["voice"],
+      formant: ["voice"],
+      grooves: ["rhythm", "patterns"],
+      groove: ["rhythm", "patterns"],
+      patterns: ["rhythm", "patterns"],
+      kits: ["rhythm", "kits"],
+      euclid: ["rhythm"],
+      tuning: ["chords", "tuning"],
+      scale: ["chords"],
+      key: ["chords"],
+      track: ["mix"],
+      automation: ["mix", "automation"],
+      master: ["mix", "master"],
+      tracks: ["arrange", "tracks"],
+      music: ["arrange"],
+      style: ["arrange", "style"],
+      styles: ["arrange", "style"],
+      genre: ["arrange", "style"],
+      sections: ["arrange", "sections"],
+      form: ["arrange"],
+      transport: ["project"],
+      tempo: ["project", "tempo"],
+      meter: ["project", "tempo"],
+      time: ["project", "tempo"],
+      export: ["project", "export"],
+      session: ["project", "session"],
+      sessions: ["project", "session"],
+      window: ["project", "help"],
+      help: ["project", "help"],
+      guides: ["project", "help"],
+      model: ["project", "agent"],
+      showme: ["project", "agent"],
+      models: ["project", "agent"],
+      fx: ["effects"],
+    }),
+  );
+
+/**
+ * Every glossary topic alias (`/help drums`, `/guide mixer`) opens the same
+ * topic in `/menu` too: a word with no deeper path here opens its topic.
+ */
+function withTopicAliases(
+  paths: Record<string, readonly string[]>,
+): Record<string, readonly string[]> {
+  const all = { ...paths };
+  for (const [word, topic] of Object.entries(TOPIC_ALIASES))
+    if (!all[word] && all[topic]) all[word] = all[topic]!;
+  return all;
+}
 
-/** Sound: instrument and voice first, then the sound browser. */
+/** Sound: the instrument and its controls first, then the instruments. */
 function soundSectionNodes(context: MenuContext): MenuNode[] {
   const track = focused(context);
   const tuning: MenuNode[] =
@@ -509,7 +630,7 @@ function soundSectionNodes(context: MenuContext): MenuNode[] {
           {
             kind: "menu",
             id: "track-tuning",
-            label: "tuning",
+            label: "track tuning",
             detail: track.tuning
               ? tuningLabel(track.tuning)
               : `song · ${tuningLabel(context.score.tuning)}`,
@@ -533,27 +654,62 @@ function soundSectionNodes(context: MenuContext): MenuNode[] {
         ]
       : [];
   const keys: MenuNode[] =
-    track && isPianoFamily(track.instrument) && track.keys
+    track && isOrganFamily(track.instrument) && track.keys
       ? [
           {
             kind: "menu",
             id: "keys",
             label: "keys",
             detail: `${track.instrument}${track.keys.preset ? ` · ${track.keys.preset}` : ""}`,
-            help: "the modelled piano: preset, touch, hammers, dampers, stretch",
+            help: "the modeled organ: preset, drawbars, registers or stops, rotary",
             build: (inner) => {
               const current = focused(inner);
-              return current
-                ? keysNodes(current, Object.keys(KEYS_PARAMS))
-                : [];
+              return current ? organNodes(current) : [];
             },
           },
         ]
+      : track && isKeysFamily(track.instrument) && track.keys
+        ? [
+            {
+              kind: "menu",
+              id: "keys",
+              label: "keys",
+              detail: `${track.instrument}${track.keys.preset ? ` · ${track.keys.preset}` : ""}`,
+              help: isElectricFamily(track.instrument)
+                ? "electric keys: preset, bark, bell, tone, vibe/trem, pickup and mute"
+                : "the modeled piano: preset, touch, hammers, dampers, stretch",
+              build: (inner) => {
+                const current = focused(inner);
+                return current
+                  ? keysNodes(current, keysParamsFor(current.instrument))
+                  : [];
+              },
+            },
+          ]
+        : [];
+  // 0.6.1: fretting for strum and the guitar perform mode, on guitar-like
+  // tracks (a string voice, a rig, or a guitar setup already stored).
+  const guitar: MenuNode[] =
+    track &&
+    (track.guitar ||
+      track.string ||
+      RIG_STAGES.some((stage) => track.fx?.[stage] !== undefined))
+      ? [
+          {
+            kind: "menu",
+            id: "guitar",
+            label: "guitar",
+            detail: describeGuitar(track.guitar),
+            help: "tuning, capo, hand stretch, ringing open strings and position for strum and chords perform guitar",
+            build: (inner) => guitarNodes(focused(inner)),
+          },
+        ]
       : [];
   return [
     ...parameterNodes(context),
     ...granular,
     ...keys,
+    ...guitar,
     ...tuning,
     {
       kind: "menu",
@@ -566,29 +722,349 @@ function soundSectionNodes(context: MenuContext): MenuNode[] {
     {
       kind: "menu",
       id: "browse",
-      label: "browse sounds",
+      label: "instruments",
       detail: soundsDetail(focused(context)),
-      help: "instruments, wavetables, sample packs",
+      help: "every instrument: keys, strings, mallets, winds, granular, wavetables, sample packs",
       build: soundNodes,
     },
   ];
 }
 
+/** Sound > guitar: Track.guitar rows plus a strum action. */
+function guitarNodes(track: Track | undefined): MenuNode[] {
+  if (!track) return [];
+  const g = track.guitar;
+  const tune = g?.tune ?? "standard";
+  const tuneName = typeof tune === "string" ? tune : tune.join(" ");
+  const int = (
+    label: string,
+    field: "capo" | "hand" | "position",
+    min: number,
+    max: number,
+    fallback: number,
+    help: string,
+  ): MenuNode => ({
+    kind: "number",
+    label,
+    help,
+    value: g?.[field] ?? fallback,
+    min,
+    max,
+    step: linear(1, min, max),
+    format: (value) => num(Math.round(value)),
+    command: (value) => `guitar ${field} ${Math.round(value)}`,
+  });
+  return [
+    {
+      kind: "choice",
+      label: "tune",
+      help: "open strings; type guitar tune D A D G A D for your own",
+      value: tuneName,
+      options: (GUITAR_TUNING_NAMES as readonly string[]).includes(tuneName)
+        ? GUITAR_TUNING_NAMES
+        : [tuneName, ...GUITAR_TUNING_NAMES],
+      command: (option) => `guitar tune ${option}`,
+    },
+    int(
+      "capo",
+      "capo",
+      0,
+      12,
+      0,
+      "capo fret; chord shapes sound this many semitones up",
+    ),
+    int("hand", "hand", 3, 6, 4, "how many frets one hand shape may span"),
+    {
+      kind: "number",
+      label: "ring",
+      help: "0 closed shapes .. 1 lets open strings ring",
+      value: g?.ring ?? 0.5,
+      min: 0,
+      max: 1,
+      step: linear(0.1, 0, 1),
+      format: (value) => num(value),
+      command: (value) => `guitar ring ${Math.round(value * 10) / 10}`,
+    },
+    int(
+      "position",
+      "position",
+      0,
+      12,
+      0,
+      "preferred fret position for voicings",
+    ),
+    {
+      kind: "action",
+      label: "strum the chords on this track",
+      command: "strum",
+      help: "replaces block chords with strummed guitar notes",
+    },
+    {
+      kind: "action",
+      label: "reset",
+      command: "guitar reset",
+      help: "standard tuning, no capo",
+    },
+  ];
+}
+
 /** Rhythm: the euclid editor, then grooves and kits. */
-function rhythmNodes(): MenuNode[] {
+function rhythmNodes(context: MenuContext): MenuNode[] {
   return [
     {
       kind: "action",
       label: "euclid editor",
       command: "/euclid",
-      help: "hits, steps and rotation per drum voice",
+      help: "hits, steps and rotation per drum",
     },
     patternsMenu(),
     kitsMenu(),
+    gridNode(context),
+  ];
+}
+
+/** The record and euclid grid (Rhythm and Project share this row). */
+function gridNode(context: MenuContext): MenuNode {
+  return {
+    kind: "choice",
+    label: "grid",
+    help: "the step play-mode recording and the euclid editor snap to",
+    value: context.grid,
+    options: context.grids,
+    command: (option) => `/grid ${option}`,
+  };
+}
+
+/** Arrange: the tracks first, then sections, form and styles. */
+function arrangeRootNodes(context: MenuContext): MenuNode[] {
+  const count = context.score.tracks.length;
+  return [
+    {
+      kind: "menu",
+      id: "tracks",
+      label: "tracks",
+      detail: `${count} track${count === 1 ? "" : "s"} · add, focus, move, remove`,
+      help: "add a track, focus one, rename, reorder or remove it",
+      build: tracksNodes,
+    },
+    ...arrangeNodes(context),
+  ];
+}
+
+/** Arrange › tracks: add, focus, rename, move and remove. */
+function tracksNodes(context: MenuContext): MenuNode[] {
+  const score = context.score;
+  const track = focused(context);
+  const nodes: MenuNode[] = [
+    {
+      kind: "entry",
+      label: "add a track",
+      value: "",
+      placeholder: "name, e.g. bass or piano b",
+      example: "/track bass",
+      help: "a new track with that name (or focus it when it exists)",
+      command: (text) => {
+        const name = text.trim().replace(/\s+/g, " ");
+        return /^[a-z0-9._ -]{1,64}$/i.test(name)
+          ? `/track ${name}`
+          : undefined;
+      },
+    },
+    ...score.tracks.map((item): MenuNode => ({
+      kind: "action",
+      label: `${item.id === context.trackId ? "● " : ""}${item.name ?? item.id}`,
+      command: `/track ${item.id}`,
+      help: `focus ${item.id} · ${item.instrument}`,
+    })),
+  ];
+  if (track) {
+    nodes.push({
+      kind: "entry",
+      label: "rename",
+      value: track.name,
+      placeholder: "new name",
+      command: (text) =>
+        text.trim() ? `track name ${text.trim()}` : undefined,
+      example: `track name ${track.name}`,
+      help: "rename the focused track",
+    });
+    if (score.tracks.length > 1) {
+      const index = score.tracks.findIndex((item) => item.id === track.id);
+      nodes.push(
+        {
+          kind: "number",
+          label: "position",
+          help: "where the focused track sits in the list",
+          value: index + 1,
+          min: 1,
+          max: score.tracks.length,
+          step: linear(1, 1, score.tracks.length),
+          format: (value) => `${num(value)} of ${score.tracks.length}`,
+          command: (value) => `/track move ${track.id} ${Math.round(value)}`,
+        },
+        {
+          kind: "action",
+          label: `remove ${track.id}`,
+          command: `/track remove ${track.id}`,
+          help: "remove the focused track (^z brings it back)",
+        },
+      );
+    }
+  }
+  return nodes;
+}
+
+/** A file-safe stem for export names: the session's song name or `song`. */
+function exportStem(context: MenuContext): string {
+  const stem = (context.sessionName ?? "song")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40);
+  return stem || "song";
+}
+
+/** Project › export: the project file and MIDI; audio renders offline. */
+function exportNodes(context: MenuContext): MenuNode[] {
+  const stem = exportStem(context);
+  return [
+    {
+      kind: "entry",
+      label: "project file",
+      value: "",
+      placeholder: `file name, e.g. ${stem}.track.json`,
+      example: `/export ${stem}.track.json`,
+      help: "the whole song as one .track.json file (open it with /import)",
+      command: (text) => {
+        const name = text.trim() || `${stem}.track.json`;
+        return /^\S+$/.test(name)
+          ? `/export ${/\.json$/i.test(name) ? name : `${name}.track.json`}`
+          : undefined;
+      },
+    },
+    {
+      kind: "entry",
+      label: "MIDI",
+      value: "",
+      placeholder: `file name, e.g. ${stem}.mid`,
+      example: `/export ${stem}.mid`,
+      help: "notes, tempo and tracks as a standard MIDI file",
+      command: (text) => {
+        const name = text.trim() || `${stem}.mid`;
+        return /^\S+$/.test(name)
+          ? `/export ${/\.midi?$/i.test(name) ? name : `${name}.mid`}`
+          : undefined;
+      },
+    },
+    {
+      kind: "info",
+      label: "WAV and stems",
+      value: `dawg render ${stem}.wav`,
+      help: "audio renders offline in the shell: dawg render out.wav (--stems for one file per track)",
+    },
+  ];
+}
+
+/** Project › session: rename, fork and resume (the window's verbs). */
+function sessionNodes(context: MenuContext): MenuNode[] {
+  return [
+    {
+      kind: "entry",
+      label: "rename",
+      value: context.sessionName ?? "",
+      placeholder: "song name (--auto names it for you)",
+      example: "/rename night drive",
+      help: "name this session; --auto hands naming back to dawg",
+      command: (text) => (text.trim() ? `/rename ${text.trim()}` : undefined),
+    },
+    {
+      kind: "action",
+      label: "fork",
+      command: "/fork",
+      help: "a copy of this session to try something; the original stays",
+    },
+    {
+      kind: "action",
+      label: "resume",
+      command: "/resume",
+      help: "pick an earlier session in this folder",
+    },
+    {
+      kind: "action",
+      label: "list sessions",
+      command: "/sessions",
+      help: "every session in this folder, newest first",
+    },
+  ];
+}
+
+/** Project › agent: the model, show-me and the model key. */
+function agentNodes(context: MenuContext): MenuNode[] {
+  return [
+    {
+      kind: "action",
+      label: "model",
+      command: "/model",
+      help: "pick the model the agent runs on",
+    },
+    ...(context.showMe === undefined
+      ? []
+      : [
+          {
+            kind: "choice" as const,
+            label: "show me",
+            help: "agent turns: its commands as ghost text, faders, keys",
+            value: context.showMe,
+            options: ["on", "quiet", "off"],
+            command: (option: string) => `/showme ${option}`,
+          },
+        ]),
+    {
+      kind: "action",
+      label: "model key",
+      command: "/model key",
+      help: "add a model key so typed requests reach the agent (dawg works offline without it)",
+    },
+    {
+      kind: "action",
+      label: "agent help",
+      command: "/help agent",
+      help: "what the agent can do and how its turns show",
+    },
   ];
 }
 
-/** Mix & automation: this track, every track, then automation lanes. */
+/** Project › help and guides: the reference, guides and keys. */
+function helpNodes(): MenuNode[] {
+  return [
+    {
+      kind: "action",
+      label: "help",
+      command: "/help",
+      help: "start here: the ten topics",
+    },
+    {
+      kind: "action",
+      label: "all commands",
+      command: "/help all",
+      help: "the full command reference",
+    },
+    {
+      kind: "action",
+      label: "guides",
+      command: "/guide",
+      help: "short walkthroughs, one screen each",
+    },
+    {
+      kind: "action",
+      label: "keys",
+      command: "/help keys",
+      help: "every key in the window (? shows them too)",
+    },
+  ];
+}
+
+/** Mix: this track, every track, automation lanes, then the master. */
 function mixSectionNodes(context: MenuContext): MenuNode[] {
   const track = focused(context);
   const automated = AUTOMATION_PARAMETERS.filter(
@@ -625,7 +1101,7 @@ function mixSectionNodes(context: MenuContext): MenuNode[] {
   ];
 }
 
-/** Mix & automation > Master: the loudness target, then each unit in order. */
+/** Mix › master: the loudness target, then each unit in order. */
 function masterNodes(context: MenuContext): MenuNode[] {
   const master = context.score.master;
   // A name only when the LUFS and the limiter ceiling both match it, and no
@@ -798,7 +1274,7 @@ function chordsDetail(context: MenuContext): string {
   return `${chords.mode} · ${key ? keyName(key) : "no key"} · ${chords.perform}`;
 }
 
-/** Play mode's chord settings and the song key (`/chords …`, `key …`). */
+/** Chords and key: the song key and tuning, then play mode's chord settings. */
 function chordNodes(context: MenuContext): MenuNode[] {
   const chords = context.chords ?? defaultChordSettings();
   const key = parseKey(context.score.key ?? undefined);
@@ -831,11 +1307,20 @@ function chordNodes(context: MenuContext): MenuNode[] {
       options: [...MODE_NAMES, ...SCALE_NAMES],
       command: (option) => `key ${tonic} ${option}`,
     },
+    {
+      kind: "menu",
+      id: "tuning",
+      label: "tuning",
+      detail: `${tuningLabel(context.score.tuning)} · ${keyLabel(context.score.key)}`,
+      help: "the song tuning: 12-TET, EDOs, just, gamelan, Scala, and the scale",
+      build: songTuningNodes,
+    },
     {
       kind: "number",
       label: "voicing",
       help: "inversion steps up or down (play mode: - =)",
       value: chords.inversion,
+      start: 0,
       min: -MAX_VOICING_STEP,
       max: MAX_VOICING_STEP,
       step: linear(1, -MAX_VOICING_STEP, MAX_VOICING_STEP),
@@ -881,6 +1366,34 @@ function chordNodes(context: MenuContext): MenuNode[] {
       options: CHORD_PATTERNS.map((pattern) => pattern.name),
       command: (option) => `/chords pattern ${option}`,
     },
+    // Strum grid and speed only act when perform is guitar.
+    ...(chords.perform !== "guitar"
+      ? []
+      : ([
+          {
+            kind: "choice",
+            label: "strokes",
+            help: "guitar strum grid (D down, U up, d u light, x chuck, - rest); type /chords strokes D-DU-UDU for your own",
+            value: chords.strokes,
+            options: (STROKE_PATTERN_NAMES as readonly string[]).includes(
+              chords.strokes,
+            )
+              ? STROKE_PATTERN_NAMES
+              : [chords.strokes, ...STROKE_PATTERN_NAMES],
+            command: (option) => `/chords strokes ${option}`,
+          },
+          {
+            kind: "number",
+            label: "speed",
+            help: "ms a full down stroke takes (0 hits every string at once); type /chords speed 1/32b to set it in beats",
+            value: chords.speed,
+            min: STROKE_SPEED_MS.min,
+            max: STROKE_SPEED_MS.max,
+            step: linear(1, STROKE_SPEED_MS.min, STROKE_SPEED_MS.max),
+            format: (value) => `${num(value)} ms`,
+            command: (value) => `/chords speed ${Math.round(value)}ms`,
+          },
+        ] satisfies MenuNode[])),
     {
       kind: "choice",
       label: "arp rate",
@@ -894,6 +1407,7 @@ function chordNodes(context: MenuContext): MenuNode[] {
       label: "arp octaves",
       help: "how many octaves an arpeggio climbs",
       value: chords.octaves,
+      start: 1,
       min: 1,
       max: 4,
       step: linear(1, 1, 4),
@@ -910,12 +1424,22 @@ function chordNodes(context: MenuContext): MenuNode[] {
     },
     {
       kind: "choice",
-      label: "style",
-      help: "the style n suggests next chords in",
+      label: "idiom",
+      help: "the musical idiom n suggests next chords in (pop, jazz, blues…)",
       value: chords.style,
       options: PROGRESSION_STYLES,
       command: (option) => `/chords style ${option}`,
     },
+    {
+      kind: "entry",
+      label: "progression",
+      value: "",
+      placeholder: "chords, e.g. i7 IV7 each 8",
+      help: "sustained, voice-led block chords on this track in the song key",
+      command: (text) =>
+        text.trim() ? `progression ${text.trim()}` : undefined,
+      example: "progression i7 IV7 each 8",
+    },
   ];
 }
 
@@ -969,7 +1493,7 @@ function trackNodes(context: MenuContext): MenuNode[] {
 }
 
 function instrumentNode(track: Track): MenuNode {
-  const options: string[] = [...AVAILABLE_INSTRUMENTS, ...PIANO_FAMILIES];
+  const options: string[] = [...AVAILABLE_INSTRUMENTS, ...KEYS_FAMILIES];
   if (!options.includes(track.instrument)) options.push(track.instrument);
   return {
     kind: "choice",
@@ -1011,7 +1535,7 @@ function panNode(track: Track): MenuNode {
         : `${num(Math.abs(value))} ${value < 0 ? "L" : "R"}`,
     command: (value) => `pan ${num(value)}`,
     reset: "pan 0",
-    help: "-1 left … 1 right · x centres",
+    help: "-1 left … 1 right · x centers",
   };
 }
 
@@ -1023,13 +1547,20 @@ function parameterNodes(context: MenuContext): MenuNode[] {
   if (isWavetableInstrument(track.instrument))
     nodes.push(...wavetableNodes(track, context.projectRoot));
   if (isStringTrack(track)) {
-    nodes.push(...stringNodes(track, STRING_SIMPLE_PARAMS));
+    nodes.push(
+      ...stringNodes(
+        track,
+        resolveString(track.string).exciter === "bow"
+          ? BOW_SIMPLE_PARAMS
+          : STRING_SIMPLE_PARAMS,
+      ),
+    );
     nodes.push({
       kind: "menu",
       id: "string:advanced",
       label: "advanced",
       detail: `all ${Object.keys(STRING_PARAMS).length} params`,
-      help: "every string parameter: exciter, loss, body, buzz, sympathetics",
+      help: "every string parameter: exciter, loss, body, buzz, sympathetics, bow (pressure, speed, attack, vib, vibdelay, tremhz, sord, dyn)",
       build: (inner) => {
         const current = focused(inner);
         return current
@@ -1072,22 +1603,40 @@ function parameterNodes(context: MenuContext): MenuNode[] {
       label: "add a voice",
       value: "/sample <path> [as <voice>]",
     });
-  } else if (isPianoFamily(track.instrument) && track.keys) {
-    nodes.push(...keysNodes(track, KEYS_SIMPLE));
+  } else if (isOrganFamily(track.instrument) && track.keys) {
+    // f061-organ: preset, Drawbars/Registers/Stops sub-menus, organ rows.
+    nodes.push(...organNodes(track));
+  } else if (isKeysFamily(track.instrument) && track.keys) {
+    nodes.push(...keysNodes(track, keysSimpleFor(track.instrument)));
+    const all = keysParamsFor(track.instrument);
     nodes.push({
       kind: "menu",
       id: "keys:all",
-      label: "all piano params",
-      detail: `all ${Object.keys(KEYS_PARAMS).length} params`,
-      help: "every modelled piano parameter",
+      label: isElectricFamily(track.instrument)
+        ? `all ${track.instrument} params`
+        : "all piano params",
+      detail: `all ${all.length} params`,
+      help: isElectricFamily(track.instrument)
+        ? "every electric keys parameter for this family"
+        : "every modeled piano parameter",
       build: (inner) => {
         const current = focused(inner);
-        return current ? keysNodes(current, Object.keys(KEYS_PARAMS)) : [];
+        return current
+          ? keysNodes(current, keysParamsFor(current.instrument))
+          : [];
       },
     });
   } else if (track.instrument === "modal") {
     // 0.6 modal percussion: preset, mallet and MODAL_PARAMS rows.
     nodes.push(...modalParameterNodes(track));
+  } else if (track.instrument === "wind" && track.wind) {
+    // 0.6.1 wind engine: preset and WIND_PARAMS rows.
+    nodes.push(...windParameterNodes(track));
+  } else if (track.instrument === "sing" && track.sing) {
+    // 0.7 sing engine: preset, SING_PARAMS rows and a Throat sub-menu.
+    nodes.push(
+      ...singParameterNodes(track, parseKey(context.score.key)?.tonic),
+    );
   } else if (!isDrumInstrument(track.instrument)) {
     nodes.push(...synthNodes(track, SYNTH_SIMPLE));
     nodes.push({
@@ -1233,10 +1782,103 @@ function sampleVoiceNodes(context: MenuContext, voice: string): MenuNode[] {
       reset: `/len off ${voice}`,
       help: SAMPLE_CONTROLS.len,
     },
+    // 0.6.1 shift: pitch without changing length, formants kept or moved,
+    // and the voice's fade in and out.
+    {
+      kind: "number",
+      label: "shift",
+      value: ref.shift,
+      start: 0,
+      off: "off",
+      min: -SCORE_LIMITS.maxSampleShift,
+      max: SCORE_LIMITS.maxSampleShift,
+      step: linear(
+        1,
+        -SCORE_LIMITS.maxSampleShift,
+        SCORE_LIMITS.maxSampleShift,
+      ),
+      format: num,
+      command: (value) => `/shift ${num(value)} ${voice}`,
+      reset: `/shift off ${voice}`,
+      help: SAMPLE_CONTROLS.shift,
+    },
+    {
+      kind: "number",
+      label: "formant",
+      value: ref.formant,
+      start: 0,
+      off: "follow",
+      min: -SCORE_LIMITS.maxSampleShift,
+      max: SCORE_LIMITS.maxSampleShift,
+      step: linear(
+        1,
+        -SCORE_LIMITS.maxSampleShift,
+        SCORE_LIMITS.maxSampleShift,
+      ),
+      format: (value) => (value === 0 ? "keep" : num(value)),
+      command: (value) => set(`formant ${num(value)}`),
+      reset: set("formant off"),
+      help: `${SAMPLE_CONTROLS.formant} · needs shift`,
+    },
+    {
+      kind: "number",
+      label: "fade in",
+      value: ref.fadeInTime,
+      start: 0.01,
+      off: "off",
+      min: 0,
+      max: SCORE_LIMITS.maxSampleFadeSeconds,
+      step: linear(0.01, 0, SCORE_LIMITS.maxSampleFadeSeconds),
+      format: num,
+      command: (value) => `/fade in ${num(value)} ${voice}`,
+      reset: `/fade in off ${voice}`,
+      help: SAMPLE_CONTROLS.fadeInTime,
+    },
+    {
+      kind: "number",
+      label: "fade out",
+      value: ref.fadeTime,
+      start: 0.1,
+      off: "off",
+      min: 0,
+      max: SCORE_LIMITS.maxSampleFadeSeconds,
+      step: linear(0.05, 0, SCORE_LIMITS.maxSampleFadeSeconds),
+      format: num,
+      command: (value) => `/fade out ${num(value)} ${voice}`,
+      reset: `/fade out off ${voice}`,
+      help: SAMPLE_CONTROLS.fadeTime,
+    },
+    // 0.6.1 layers: velocity layer (SFZ lovel/hivel) and round-robin group.
+    {
+      kind: "choice",
+      label: "velocity layer",
+      value: ref.vel ? `${ref.vel[0]}-${ref.vel[1]}` : "off",
+      options: velocityLayerOptions(ref.vel),
+      command: (option) => set(`vel ${option}`),
+      help: `${SAMPLE_CONTROLS.vel} · two layers: 0-63 and 64-127 · three: 0-42 43-84 85-127`,
+    },
+    {
+      kind: "entry",
+      label: "round robin",
+      value: ref.rr ?? "",
+      placeholder: "group name, e.g. sn",
+      command: (text) => set(`rr ${text.trim() || "off"}`),
+      example: `/sample set ${voice} rr sn`,
+      help: SAMPLE_CONTROLS.rr,
+    },
   );
   return nodes;
 }
 
+/** Common velocity splits, plus the voice's own range when it is another. */
+function velocityLayerOptions(
+  vel: readonly [number, number] | undefined,
+): string[] {
+  const options = ["off", "0-63", "64-127", "0-42", "43-84", "85-127"];
+  const own = vel ? `${vel[0]}-${vel[1]}` : undefined;
+  return own && !options.includes(own) ? [...options, own] : options;
+}
+
 /** Synth preset first, then one row per parameter. */
 /** The preset this track's voice still matches exactly, if any. */
 function matchingSynthPreset(track: Track): string | undefined {
@@ -1249,17 +1891,25 @@ function matchingSynthPreset(track: Track): string | undefined {
   )?.[0];
 }
 
-/** Modelled piano rows: the preset, then each parameter (`keys <p> <v>`). */
-function keysNodes(track: Track, params: readonly string[]): MenuNode[] {
+/** Modeled piano rows: the preset, then each parameter (`keys <p> <v>`). */
+function keysNodes(
+  track: Track,
+  params: readonly string[],
+  presets: readonly string[] = keysPresetNames(track.instrument),
+): MenuNode[] {
   const effective = resolvedKeys(track.instrument, track.keys);
   const nodes: MenuNode[] = [
     {
       kind: "choice",
       label: "preset",
       value: track.keys?.preset ?? "—",
-      options: Object.keys(KEYS_PRESETS),
+      options: presets,
       command: (preset) => `keys preset ${preset}`,
-      help: "a starting piano; every value stays editable",
+      help: isOrganFamily(track.instrument)
+        ? "a starting organ; every value stays editable"
+        : isElectricFamily(track.instrument)
+          ? "a starting electric piano or clav; every value stays editable"
+          : "a starting piano; every value stays editable",
     },
   ];
   for (const key of params) {
@@ -1300,6 +1950,174 @@ function keysNodes(track: Track, params: readonly string[]): MenuNode[] {
   return nodes;
 }
 
+// ---- f061-organ menu rows -------------------------------------------------
+
+const PIANO_PRESET_NAMES = Object.keys(KEYS_PRESETS).filter((name) =>
+  isPianoFamily(KEYS_PRESETS[name]!.instrument),
+);
+const ORGAN_PRESET_NAMES = Object.keys(KEYS_PRESETS).filter((name) =>
+  isOrganFamily(KEYS_PRESETS[name]!.instrument),
+);
+const ELECTRIC_PRESET_NAMES = Object.keys(KEYS_PRESETS).filter((name) =>
+  isElectricFamily(KEYS_PRESETS[name]!.instrument),
+);
+
+/** The presets of the track's kind of keys (pianos, electric or organs). */
+function keysPresetNames(instrument: string): readonly string[] {
+  if (isOrganFamily(instrument)) return ORGAN_PRESET_NAMES;
+  if (isElectricFamily(instrument)) return ELECTRIC_PRESET_NAMES;
+  return PIANO_PRESET_NAMES;
+}
+
+const DRAWBAR_FEET = [
+  "16'",
+  "5⅓'",
+  "8'",
+  "4'",
+  "2⅔'",
+  "2'",
+  "1⅗'",
+  "1⅓'",
+  "1'",
+];
+const REGISTER_FEET = ["16'", "8'", "4'", "2⅔'", "2'"];
+
+/**
+ * One 0-8 row per footage of a digit string (`keys drawbars 888000000`):
+ * left/right pull a bar in or out, x puts the whole set back.
+ */
+function digitNodes(
+  name: "drawbars" | "registers",
+  text: string,
+  feet: readonly string[],
+  stored: boolean,
+): MenuNode[] {
+  const digits = text.split("").map(Number);
+  const nodes: MenuNode[] = feet.map((foot, index): MenuNode => {
+    const at = (value: number) =>
+      digits.map((d, i) => (i === index ? value : d)).join("");
+    return {
+      kind: "number",
+      label: foot,
+      value: digits[index]!,
+      min: 0,
+      max: 8,
+      step: (value, direction) => Math.max(0, Math.min(8, value + direction)),
+      format: (value) =>
+        `${value}  ${"█".repeat(value)}${"·".repeat(8 - value)}`,
+      command: (value) => `keys ${name} ${at(value)}`,
+      // x resets this bar only, to its default digit.
+      reset: `keys ${name} ${at(Number(ORGAN_TEXT[name].default[index] ?? 0))}`,
+      help: `${foot} ${name === "drawbars" ? "drawbar" : "register"} 0-8`,
+    };
+  });
+  nodes.push({
+    kind: "entry",
+    label: `${name} (type)`,
+    value: stored ? text : `${text} (default)`,
+    placeholder: `${feet.length} digits 0-8`,
+    command: (typed) =>
+      new RegExp(`^[0-8]{${feet.length}}$`).test(typed.trim())
+        ? `keys ${name} ${typed.trim()}`
+        : undefined,
+    example: `keys ${name} ${text}`,
+  });
+  return nodes;
+}
+
+/** Pipe stops: a registration, then one toggle per stop. */
+function stopNodes(text: string): MenuNode[] {
+  const on = pipeStops(text);
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "registration",
+      value: Object.keys(PIPE_REGISTRATIONS).includes(text) ? text : "—",
+      options: Object.keys(PIPE_REGISTRATIONS),
+      command: (option) => `keys stops ${option}`,
+      help: "a named registration (stops drawn together)",
+    },
+  ];
+  for (const stop of PIPE_STOPS)
+    nodes.push({
+      kind: "toggle",
+      label: stop,
+      value: on.includes(stop),
+      command: (value) => {
+        const next = value
+          ? PIPE_STOPS.filter((name) => name === stop || on.includes(name))
+          : on.filter((name) => name !== stop);
+        return next.length > 0
+          ? `keys stops ${next.join(" ")}`
+          : "keys stops off";
+      },
+      help: `draw or retire the ${stop} stop`,
+    });
+  return nodes;
+}
+
+/** The organ's rows: preset, its family's sub-menu, then its parameters. */
+function organNodes(track: Track): MenuNode[] {
+  const family = track.instrument as OrganFamily;
+  const effective = resolvedKeys(track.instrument, track.keys);
+  const rows = ORGAN_ROWS[family].filter((row) => row in KEYS_PARAMS);
+  const nodes = keysNodes(track, rows, ORGAN_PRESET_NAMES);
+  const text = (name: keyof typeof ORGAN_TEXT) =>
+    String(effective[name] ?? ORGAN_TEXT[name].default);
+  const sub: MenuNode =
+    family === "tonewheel"
+      ? {
+          kind: "menu",
+          id: "keys:drawbars",
+          label: "drawbars",
+          detail: text("drawbars"),
+          help: "nine drawbars 16' to 1' (0 in, 8 full out)",
+          build: (inner) => {
+            const current = focused(inner) ?? track;
+            const value = resolvedKeys(current.instrument, current.keys);
+            return digitNodes(
+              "drawbars",
+              String(value.drawbars ?? ORGAN_TEXT.drawbars.default),
+              DRAWBAR_FEET,
+              current.keys?.drawbars !== undefined,
+            );
+          },
+        }
+      : family === "combo"
+        ? {
+            kind: "menu",
+            id: "keys:registers",
+            label: "registers",
+            detail: text("registers"),
+            help: "five combo-organ registers 16' to 2' (0 off, 8 full)",
+            build: (inner) => {
+              const current = focused(inner) ?? track;
+              const value = resolvedKeys(current.instrument, current.keys);
+              return digitNodes(
+                "registers",
+                String(value.registers ?? ORGAN_TEXT.registers.default),
+                REGISTER_FEET,
+                current.keys?.registers !== undefined,
+              );
+            },
+          }
+        : {
+            kind: "menu",
+            id: "keys:stops",
+            label: "stops",
+            detail: text("stops"),
+            help: "pipe stops and registrations",
+            build: (inner) => {
+              const current = focused(inner) ?? track;
+              const value = resolvedKeys(current.instrument, current.keys);
+              return stopNodes(String(value.stops ?? ORGAN_TEXT.stops.default));
+            },
+          };
+  // After the preset row, before the parameters.
+  nodes.splice(1, 0, sub);
+  return nodes;
+}
+
 function synthNodes(track: Track, keys: readonly string[]): MenuNode[] {
   const nodes: MenuNode[] = [];
   if (keys === SYNTH_SIMPLE)
@@ -1363,9 +2181,9 @@ function synthParamNode(track: Track, key: string, named: boolean): MenuNode {
 
 /** Plain names for the simple synth rows; the note shows the command name. */
 const SYNTH_LABEL: Readonly<Record<string, string>> = {
-  lpf: "filter cutoff",
-  lpq: "filter res",
-  lpenv: "filter env",
+  lpf: "synth filter",
+  lpq: "synth filter res",
+  lpenv: "synth filter env",
   vib: "vibrato",
   fm: "FM amount",
 };
@@ -1549,7 +2367,7 @@ function wavetableNodes(track: Track, projectRoot?: string): MenuNode[] {
     nodes.push({
       kind: "info",
       label: "position automation",
-      value: `${track.wtAutomation!.length} points · Automation › wavetable position`,
+      value: `${track.wtAutomation!.length} points · Automation › table position`,
     });
   return nodes;
 }
@@ -1564,23 +2382,44 @@ function effectNodes(context: MenuContext): MenuNode[] {
     return {
       kind: "menu",
       id: effect,
-      label: spec.label[0]!.toUpperCase() + spec.label.slice(1),
+      label: spec.label,
       detail: values ? effectSummary(effect, values) : "off",
       help: spec.doc,
       build: (inner) => effectParamNodes(inner, effect, false),
     };
   };
   const rigStages = RIG_STAGES as readonly string[];
+  // 0.6.1 shoegaze stages get their own sub-menu.
+  const gaze = SHOEGAZE_EFFECTS as readonly string[];
   const more = EFFECT_NAMES.filter(
-    (effect) => !CORE_EFFECTS.includes(effect) && !rigStages.includes(effect),
+    (effect) =>
+      !CORE_EFFECTS.includes(effect) &&
+      !rigStages.includes(effect) &&
+      !gaze.includes(effect) &&
+      // 0.7: the formant shift lives in Effects > Voice.
+      effect !== "formant",
   );
+  const gazeOn = SHOEGAZE_EFFECTS.filter((effect) =>
+    effectValues(track, effect),
+  );
+  const shoegaze: MenuNode = {
+    kind: "menu",
+    id: "shoegaze",
+    label: "shoegaze",
+    help: "wobble (tremolo-arm bend), bloom (feedback), swell (volume swell), double (two takes); `rig shoegaze` loads them all",
+    detail:
+      gazeOn.length === 0
+        ? "off"
+        : gazeOn.map((effect) => effectSpec(effect).label).join(", "),
+    build: () => SHOEGAZE_EFFECTS.map(node),
+  };
   const moreOn = more.filter((effect) => effectValues(track, effect));
   // 0.6 guitar rig: stomp → head (with its gate) → cab, plus whole rigs.
   const rigOn = RIG_STAGES.filter((stage) => effectValues(track, stage));
   const rig: MenuNode = {
     kind: "menu",
     id: "guitar rig",
-    label: "Guitar rig",
+    label: "guitar rig",
     help: "stomp box, amp head with noise gate and speaker cabinet; `rig <name>` loads a whole rig",
     detail:
       rigOn.length === 0 ? "off" : (rigPresetOf(track.fx) ?? rigOn.join(" → ")),
@@ -1602,6 +2441,20 @@ function effectNodes(context: MenuContext): MenuNode[] {
   return [
     ...CORE_EFFECTS.map(node),
     rig,
+    shoegaze,
+    // Formant and vocoder live under Voice; this row is the way there.
+    ...(voiceEffectRows(context).length > 0
+      ? [
+          {
+            kind: "menu" as const,
+            id: "voice",
+            label: "voice effects",
+            detail: "formant · vocoder · also in Voice",
+            help: "formant and vocoder for voices (the same rows as Ctrl-K › Voice)",
+            build: voiceEffectRows,
+          },
+        ]
+      : []),
     {
       kind: "menu",
       id: "more effects",
@@ -1638,16 +2491,17 @@ function withUnit(text: string, unit: string | undefined): string {
 
 function formatParam(spec: ParamSpec, value: number): string {
   if (spec.kind !== "number") return num(value);
-  return spec.step === "log" && value >= 100
-    ? `${Math.round(value)}`
-    : num(value);
+  const text =
+    spec.step === "log" && value >= 100 ? `${Math.round(value)}` : num(value);
+  // Rounding never leaves the range: attack 0.0001 types as 0.0001, not 0.
+  return Number(text) < spec.min ? String(spec.min) : text;
 }
 
 /**
  * One effect's rows: on/off, presets, then its simple parameters; the
  * `advanced` submenu holds every parameter with its Strudel names.
  */
-function effectParamNodes(
+export function effectParamNodes(
   context: MenuContext,
   effect: EffectName,
   advanced: boolean,
@@ -1738,6 +2592,37 @@ function effectParamNodes(
       });
     }
   }
+  if (!advanced && effect === "vowel") {
+    // 0.7 vowel morph: To picks the target (morph starts halfway), Morph
+    // moves between the two; both through `/vowel`.
+    const to = values?.to;
+    nodes.push(
+      {
+        kind: "choice",
+        label: "to",
+        value: typeof to === "string" ? to : "—",
+        options: ["—", ...VOWEL_VALUES],
+        command: (option) =>
+          option === "—" ? "/vowel to off" : `/vowel to ${option}`,
+        help: "a second vowel to morph toward (— keeps one vowel)",
+      },
+      {
+        kind: "number",
+        label: "morph",
+        value: typeof values?.morph === "number" ? values.morph : undefined,
+        start: 0.5,
+        off: typeof to === "string" ? "0" : "set to first",
+        min: 0,
+        max: 1,
+        step: specStep(spec.params.morph as NumberParam),
+        format: (value) => num(value),
+        command: (value) =>
+          typeof to === "string" ? `/vowel morph ${num(value)}` : `/vowel to o`,
+        help: "0 is the vowel, 1 is the to vowel; log-frequency formant glide, automatable as vowel-morph",
+        ...(typeof to === "string" ? { reset: "/vowel morph 0" } : {}),
+      },
+    );
+  }
   if (!advanced) {
     nodes.push({
       kind: "menu",
@@ -1770,8 +2655,18 @@ function automationNodes(context: MenuContext): MenuNode[] {
     if (info?.effect === "synth")
       return track.synth?.[info.param] !== undefined;
     if (info?.effect === "string") return track.string !== undefined;
-    if (info?.effect === "keys") return track.keys !== undefined;
+    // Only the lanes this family's engine reads (keys-rotary on organs,
+    // keys-hardness on pianos); the rest wait under "all lanes".
+    if (info?.effect === "keys")
+      return (
+        track.keys !== undefined &&
+        keysParamsFor(track.instrument).includes(info.param)
+      );
     if (info?.effect === "modal") return track.modal !== undefined;
+    if (info?.effect === "grain") return track.granular !== undefined;
+    if (info?.effect === "wind") return track.wind !== undefined;
+    if (info?.effect === "sing") return track.sing !== undefined;
+    if (info?.effect === "vocoder") return track.vocoder !== undefined;
     return info !== undefined && effectValues(track, info.effect) !== undefined;
   });
   const hidden = AUTOMATION_PARAMETERS.filter((lane) => !shown.includes(lane));
@@ -1897,14 +2792,14 @@ function soundsDetail(track: Track | undefined): string {
 }
 
 /**
- * The instrument browser: drum kits and soundfont instruments from the
+ * The instrument browser: kits and soundfont instruments from the
  * built-in packs (fetched on first use), and the pack list.
  */
 function kitsMenu(): MenuNode {
   return {
     kind: "menu",
     id: "kits",
-    label: "drum kits",
+    label: "kits",
     help: "make this a drum track with a synth or sample kit",
     detail: `synth ${SYNTH_KIT_NAMES.join(" ")} · samples ${Object.keys(DEFAULT_KITS).join(" ")}`,
     // Synth kits first (offline), then the pack sample kits.
@@ -1941,62 +2836,119 @@ function patternsMenu(): MenuNode {
   return {
     kind: "menu",
     id: "patterns",
-    label: "drum patterns",
-    detail: `${DRUM_PATTERNS.length} grooves`,
+    label: "grooves",
+    detail: `${DRUM_PATTERNS.length} ready-made drum parts`,
     help: "replace the drum part with a ready-made groove",
     build: () =>
       DRUM_PATTERNS.map((entry): MenuNode => ({
         kind: "action",
         label: `${entry.label}  ${entry.tempo.bpm} BPM · ${entry.tags.join(", ")}`,
-        command: `/pattern ${entry.name}`,
+        command: `/groove ${entry.name}`,
       })),
   };
 }
 
 const GRANULAR_PRESETS_COUNT = granularBrowseNodes().length;
 
-function soundNodes(): MenuNode[] {
+function soundNodes(context: MenuContext): MenuNode[] {
   return [
     {
       kind: "menu",
       id: "group:keys",
-      label: "Keys",
-      help: "modelled pianos, built in (no download)",
-      detail: Object.keys(KEYS_PRESETS).join(" "),
-      build: () =>
-        Object.entries(KEYS_PRESETS).map(([name, preset]): MenuNode => ({
-          kind: "action",
-          label: `${name.padEnd(10)} ${preset.doc}`,
-          command: `piano ${name}`,
-          help: preset.styles,
-        })),
+      label: "keys",
+      help: "modeled pianos, electric keys and organs, built in (no download)",
+      detail: `${PIANO_PRESET_NAMES.join(" ")} · electric: ${ELECTRIC_PRESET_NAMES.join(" ")} · organs: ${ORGAN_PRESET_NAMES.join(" ")}`,
+      build: () => [
+        ...PIANO_PRESET_NAMES.map((name): MenuNode => {
+          const preset = KEYS_PRESETS[name]!;
+          return {
+            kind: "action",
+            label: `${name.padEnd(10)} ${preset.doc}`,
+            command: `piano ${name}`,
+            help: preset.styles,
+          };
+        }),
+        // keys-electric (0.6.1): tine and reed pianos and the clavinet.
+        {
+          kind: "menu",
+          id: "group:keys:electric",
+          label: "electric",
+          help: "electric pianos (tine, reed) and the clavinet, modeled",
+          detail: ELECTRIC_PRESET_NAMES.join(" "),
+          build: () =>
+            Object.entries(KEYS_PRESETS)
+              .filter(([, preset]) => isElectricFamily(preset.instrument))
+              .map(([name, preset]): MenuNode => ({
+                kind: "action",
+                label: `${name.padEnd(10)} ${preset.doc}`,
+                command: `keys preset ${name}`,
+                help: preset.styles,
+              })),
+        },
+        // f061-organ
+        {
+          kind: "menu",
+          id: "group:organs",
+          label: "organs",
+          help: "tonewheel, combo and pipe organs on the keys engine",
+          detail: ORGAN_PRESET_NAMES.join(" "),
+          build: () =>
+            ORGAN_PRESET_NAMES.map((name): MenuNode => {
+              const preset = KEYS_PRESETS[name]!;
+              return {
+                kind: "action",
+                label: `${name.padEnd(10)} ${preset.doc}`,
+                command: name,
+                help: preset.styles,
+              };
+            }),
+        },
+      ],
     },
     {
       kind: "action",
-      label: "wavetable synth  basic shapes morph · built-in",
+      label: "wavetable  basic shapes morph · built-in",
       command: "wt basic",
       help: "switch this track to the morphing wavetable synth",
     },
     // 0.6 instrument groups, one per lane.
     malletsMenu(),
+    windsMenu(),
     {
       kind: "menu",
       id: "strings",
-      label: "Strings",
-      help: "plucked strings: guitars, basses, sitar, harpsichord, oud, koto…",
-      detail: `${STRING_PRESET_NAMES.length} plucked · built-in`,
-      build: () =>
-        STRING_PRESET_NAMES.map((name): MenuNode => ({
+      label: "strings",
+      help: "plucked strings: guitars, basses, sitar, harpsichord, oud, koto…; Bowed: violin to contrabass, sections",
+      detail: `${STRING_PRESET_NAMES.length - BOWED_PRESET_NAMES.length} plucked · ${BOWED_PRESET_NAMES.length} bowed · built-in`,
+      build: () => [
+        ...STRING_PRESET_NAMES.filter(
+          (name) => !BOWED_PRESET_NAMES.includes(name),
+        ).map((name): MenuNode => ({
           kind: "action",
           label: `${name.padEnd(12)} ${STRING_PRESETS[name]!.doc}`,
           command: `string ${name}`,
           help: STRING_PRESETS[name]!.styles,
         })),
+        {
+          kind: "menu",
+          id: "strings:bowed",
+          label: "bowed",
+          help: "bowed strings: violin, viola, cello, bass, fiddle, erhu, sections",
+          detail: BOWED_PRESET_NAMES.join(" "),
+          build: () =>
+            BOWED_PRESET_NAMES.map((name): MenuNode => ({
+              kind: "action",
+              label: `${name.padEnd(12)} ${STRING_PRESETS[name]!.doc}`,
+              command: `bowed ${name}`,
+              help: STRING_PRESETS[name]!.styles,
+            })),
+        },
+      ],
     },
     {
       kind: "menu",
       id: "granular-browse",
-      label: "Granular",
+      label: "granular",
       help: "grain clouds from a built-in synth or this track's own sound",
       detail: `${GRANULAR_PRESETS_COUNT} presets · built-in`,
       build: granularBrowseNodes,
@@ -2004,7 +2956,7 @@ function soundNodes(): MenuNode[] {
     {
       kind: "menu",
       id: "instruments",
-      label: "instruments",
+      label: "all instruments",
       help: "sampled piano and General MIDI instruments",
       detail: "General MIDI soundfont, piano",
       build: () => [
@@ -2022,9 +2974,9 @@ function soundNodes(): MenuNode[] {
     },
     {
       kind: "entry",
-      label: "use a sound",
+      label: "use a sample",
       value: "",
-      help: "type a pack sound name, e.g. dirt-samples/bd:3",
+      help: "type a pack sample name, e.g. dirt-samples/bd:3",
       placeholder: "<pack>/<sound>[:<n>]",
       command: (text) => (text.trim() ? `/pack use ${text.trim()}` : undefined),
       example: "/pack use dirt-samples/bd:3",
@@ -2069,6 +3021,7 @@ function transportNodes(context: MenuContext): MenuNode[] {
       label: "tempo",
       help: "beats per minute",
       value: score.tempoBpm,
+      start: START_TEMPO_BPM,
       min: SCORE_LIMITS.minTempoBpm,
       max: SCORE_LIMITS.maxTempoBpm,
       step: linear(1, SCORE_LIMITS.minTempoBpm, SCORE_LIMITS.maxTempoBpm),
@@ -2080,6 +3033,7 @@ function transportNodes(context: MenuContext): MenuNode[] {
       label: "beats per bar",
       help: "the meter",
       value: score.beatsPerBar,
+      start: START_BEATS_PER_BAR,
       min: 1,
       max: SCORE_LIMITS.maxBeatsPerBar,
       step: linear(1, 1, SCORE_LIMITS.maxBeatsPerBar),
@@ -2092,20 +3046,14 @@ function transportNodes(context: MenuContext): MenuNode[] {
       label: "loop length",
       help: "how long the loop is",
       value: score.bars,
+      start: START_BARS,
       min: 1,
       max: SCORE_LIMITS.maxBars,
       step: linear(1, 1, SCORE_LIMITS.maxBars),
       format: (value) => `${num(value)} bar${value === 1 ? "" : "s"}`,
       command: (value) => `bars ${Math.round(value)}`,
     },
-    {
-      kind: "choice",
-      label: "grid",
-      help: "the step play-mode recording and the euclid editor snap to",
-      value: context.grid,
-      options: context.grids,
-      command: (option) => `/grid ${option}`,
-    },
+    gridNode(context),
     {
       kind: "toggle",
       label: "click",
@@ -2121,17 +3069,119 @@ function transportNodes(context: MenuContext): MenuNode[] {
       options: ["0", "1", "2"],
       command: (option) => `/count-in ${option}`,
     },
+    {
+      kind: "choice",
+      label: "calibration",
+      help: "sound fixes: 1 chokes hats, tunes toms, levels keys, steadies brass · 0 keeps the legacy sound",
+      value: String(score.calibration ?? 0),
+      options: Array.from({ length: CALIBRATION_LATEST + 1 }, (_, i) =>
+        String(i),
+      ),
+      command: (option) => `/calibration ${option}`,
+    },
     {
       kind: "menu",
-      id: "tuning",
-      label: "tuning & scale",
-      detail: `${tuningLabel(score.tuning)} · ${keyLabel(score.key)}`,
-      help: "the song tuning (12-TET, EDOs, just, gamelan, Scala) and scale",
-      build: songTuningNodes,
+      id: "resample",
+      label: "resample",
+      detail: "track · section · bars → new sample track",
+      help: "render a track, an orbit or the mix to a pinned WAV on a new sampler or granular track",
+      build: resampleNodes,
+    },
+    {
+      kind: "menu",
+      id: "export",
+      label: "export",
+      detail: "project file · MIDI · WAV",
+      help: "save the song as a project file or MIDI; audio renders offline",
+      build: exportNodes,
+    },
+    {
+      kind: "menu",
+      id: "session",
+      label: "session",
+      detail: context.sessionName ?? "rename · fork · resume",
+      help: "rename, fork or resume a session",
+      build: sessionNodes,
+    },
+    {
+      kind: "menu",
+      id: "agent",
+      label: "agent",
+      detail: context.showMe
+        ? `show me ${context.showMe}`
+        : "model · model key",
+      help: "the agent's model, show-me and model key",
+      build: agentNodes,
+    },
+    {
+      kind: "menu",
+      id: "help",
+      label: "help and guides",
+      detail: "help · guides · keys",
+      help: "the command reference, the guides and the keys",
+      build: helpNodes,
     },
   ];
 }
 
+/** Project > Resample: one action per useful source and range. */
+function resampleNodes(context: MenuContext): MenuNode[] {
+  const track = focused(context);
+  const score = context.score;
+  const nodes: MenuNode[] = [];
+  if (track) {
+    nodes.push(
+      {
+        kind: "action",
+        label: `${track.id} → sampler`,
+        command: `resample ${track.id}`,
+        help: "render this track (pre-master) to a one-shot sampler track",
+      },
+      {
+        kind: "action",
+        label: `${track.id} → granular`,
+        command: `resample ${track.id} grain`,
+        help: "render this track to a granular track (cloud preset) holding one note",
+      },
+    );
+    for (const section of score.sections)
+      nodes.push({
+        kind: "action",
+        label: `${track.id} · section ${section.name}`,
+        command: `resample ${track.id} section ${section.name}`,
+        help: `render bars ${section.startBar + 1}-${section.startBar + section.bars} of this track`,
+      });
+  }
+  nodes.push(
+    {
+      kind: "entry",
+      label: "bars",
+      value: "",
+      placeholder: "a-b [grain]",
+      example: "/resample <track> bars 1-2",
+      command: (text) => {
+        const match = /^\s*(\d{1,4})(?:-(\d{1,4}))?(\s+grain)?\s*$/.exec(text);
+        if (!match || !track) return undefined;
+        return `resample ${track.id} bars ${match[1]}-${match[2] ?? match[1]}${match[3] ? " grain" : ""}`;
+      },
+      help: "render a bar range of the focused track",
+    },
+    {
+      kind: "action",
+      label: "mix → sampler",
+      command: "resample orbit 1",
+      help: "pre-master: render every track on orbit 1 (the default bus) without the song master",
+    },
+    {
+      kind: "action",
+      label: "master → sampler",
+      command: "resample master",
+      help: "render the whole song through the master chain",
+    },
+  );
+  return nodes;
+}
+
 // ── tuning ────────────────────────────────────────────────────────────
 
 /** Short name of a tuning for a choice row: its library name or table. */
@@ -2297,7 +3347,7 @@ function songTuningNodes(context: MenuContext): MenuNode[] {
       help: "the song scale: modes, minors, pentatonics, maqam, ragas, Messiaen",
       value: scale,
       options: [...MODE_NAMES, ...SCALE_NAMES],
-      command: (option) => `scale ${option}`,
+      command: (option) => `key ${option}`,
     },
     {
       kind: "choice",
@@ -2305,7 +3355,7 @@ function songTuningNodes(context: MenuContext): MenuNode[] {
       help: "the song key's tonic; keeps the scale",
       value: tonic,
       options: TONICS,
-      command: (option) => `scale ${option} ${scale}`,
+      command: (option) => `key ${option} ${scale}`,
     },
     {
       kind: "action",
@@ -2316,7 +3366,7 @@ function songTuningNodes(context: MenuContext): MenuNode[] {
     {
       kind: "action",
       label: "list scales",
-      command: "scale list",
+      command: "key list",
       help: "every mode and scale, by family",
     },
   ];
@@ -2358,14 +3408,7 @@ type Frame = {
   hovering?: boolean;
 };
 
-const KEY_UP = new Set(["\u001b[A", "\u001bOA", "k"]);
-const KEY_DOWN = new Set(["\u001b[B", "\u001bOB", "j"]);
-const KEY_LEFT = new Set(["\u001b[D", "\u001bOD", "h", "-", "_"]);
-const KEY_RIGHT = new Set(["\u001b[C", "\u001bOC", "l", "+", "="]);
-const KEY_ENTER = new Set(["\r", "\n"]);
-const KEY_BACKSPACE = new Set(["\u007f", "\b"]);
-const KEY_DELETE = new Set(["\u001b[3~", "x"]);
-const LABEL_WIDTH = 16;
+export const LABEL_WIDTH = 16;
 
 /**
  * A submenu frame whose rows are rebuilt from the parent's fresh build, so
@@ -2418,10 +3461,8 @@ export class EditMenu {
     this.stack = [{ title: "menu", build: rootNodes, index: 0, query: "" }];
     this.filtering = false;
     this.entry = undefined;
-    // Walk the section path (`automation` is Mix & automation › automation).
-    for (const id of section
-      ? (SECTION_ALIASES[section.toLowerCase()] ?? [])
-      : []) {
+    // Walk the section path (`automation` is Mix › automation).
+    for (const id of section ? (menuSectionPath(context, section) ?? []) : []) {
       const frame = this.stack.at(-1)!;
       const nodes = frame.build(context);
       const index = nodes.findIndex(
@@ -2528,9 +3569,15 @@ export class EditMenu {
     if (!frame) return [];
     const all = frame.build(context);
     const needle = frame.query.toLowerCase();
-    return needle
-      ? all.filter((node) => nodeText(node).toLowerCase().includes(needle))
-      : all;
+    if (!needle) return all;
+    const direct = all.filter((node) =>
+      nodeText(node).toLowerCase().includes(needle),
+    );
+    // At the root a filter also looks two levels down for groups
+    // (`/autotune`, `/formant`, `/tuning`) and offers them by path, after
+    // the roots that match.
+    if (this.stack.length !== 1) return direct;
+    return [...direct, ...deepGroups(all, context, needle)];
   }
 
   private selected(context: MenuContext): MenuNode | undefined {
@@ -2558,11 +3605,7 @@ export class EditMenu {
         frame.index = 0;
         return { type: "handled" };
       }
-      if (
-        KEY_ENTER.has(value) ||
-        value === "\u001b[B" ||
-        value === "\u001b[A"
-      ) {
+      if (KEY_ENTER.has(value) || value === ARROW_DOWN || value === ARROW_UP) {
         this.filtering = false;
         return this.key(value, context);
       }
@@ -2601,11 +3644,11 @@ export class EditMenu {
         frame.index = (frame.index + step + nodes.length) % nodes.length;
       return this.hovered(frame, context);
     }
-    if (value === "\u001b[5~" || value === "\u001b[H") {
+    if (KEY_PAGE_UP.has(value) || KEY_HOME.has(value)) {
       frame.index = 0;
       return this.hovered(frame, context);
     }
-    if (value === "\u001b[6~" || value === "\u001b[F") {
+    if (KEY_PAGE_DOWN.has(value) || KEY_END.has(value)) {
       frame.index = Math.max(0, nodes.length - 1);
       return this.hovered(frame, context);
     }
@@ -2624,11 +3667,19 @@ export class EditMenu {
         node.kind === "info")
     )
       return { type: "keep" };
-    if (KEY_LEFT.has(value) || KEY_RIGHT.has(value)) {
-      const direction = KEY_RIGHT.has(value) ? 1 : -1;
-      return this.nudge(node, direction);
-    }
-    if (KEY_DELETE.has(value) && node.kind === "number") {
+    // ← → adjust a value; on any other row ← h go back and → l go in
+    // (or run the action), and - + do nothing.
+    const isValue = isValueNode(node);
+    if (isValue && (KEY_LEFT.has(value) || KEY_RIGHT.has(value)))
+      return this.nudge(node, KEY_RIGHT.has(value) ? 1 : -1);
+    if (!isValue && KEY_BACK.has(value)) return this.back();
+    if (!isValue && (KEY_LEFT.has(value) || KEY_RIGHT.has(value)))
+      if (!(
+        KEY_FORWARD.has(value) &&
+        (node.kind === "menu" || node.kind === "action")
+      ))
+        return { type: "handled" };
+    if (KEY_RESET.has(value) && node.kind === "number") {
       const reset =
         node.reset ??
         (node.start !== undefined && node.value !== undefined
@@ -2636,7 +3687,7 @@ export class EditMenu {
           : undefined);
       return reset ? { type: "run", command: reset } : { type: "handled" };
     }
-    if (KEY_DELETE.has(value) && node.kind === "point")
+    if (KEY_RESET.has(value) && node.kind === "point")
       return {
         type: "run",
         command: `automate ${node.lane} remove ${num(node.beat)}`,
@@ -2648,7 +3699,7 @@ export class EditMenu {
       this.entry = { label: node.label, buffer: value };
       return { type: "handled" };
     }
-    if (KEY_ENTER.has(value) || value === " ") {
+    if (KEY_ENTER.has(value) || KEY_FORWARD.has(value) || value === " ") {
       if (node.kind === "menu") {
         // Going back lands on the opened row with the filter cleared.
         if (frame.query) {
@@ -2724,15 +3775,16 @@ export class EditMenu {
     return { type: "hover", command: node.command, key: frame.hover };
   }
 
+  /** ← on a row that is not a value: up one level (never past the root). */
+  private back(): MenuResult {
+    if (this.stack.length <= 1) return { type: "handled" };
+    const left = this.stack.pop();
+    if (left?.hover && left.hovering)
+      return { type: "unhover", key: left.hover };
+    return { type: "handled" };
+  }
+
   private nudge(node: MenuNode, direction: 1 | -1): MenuResult {
-    if (node.kind === "menu") {
-      if (direction > 0) {
-        this.stack.push(childFrame(this.stack.at(-1)!, node));
-        return { type: "handled" };
-      }
-      if (this.stack.length > 1) this.stack.pop();
-      return { type: "handled" };
-    }
     if (node.kind === "number") {
       const next =
         node.value === undefined
@@ -2765,11 +3817,6 @@ export class EditMenu {
         ? { type: "handled" }
         : { type: "run", command: node.command(next) };
     }
-    if (direction < 0 && this.stack.length > 1) {
-      const left = this.stack.pop();
-      if (left?.hover && left.hovering)
-        return { type: "unhover", key: left.hover };
-    }
     return { type: "handled" };
   }
 
@@ -2900,6 +3947,16 @@ export class EditMenu {
   }
 }
 
+/** Rows that hold a value: ← → adjust them instead of navigating. */
+function isValueNode(node: MenuNode): boolean {
+  return (
+    node.kind === "number" ||
+    node.kind === "point" ||
+    node.kind === "toggle" ||
+    node.kind === "choice"
+  );
+}
+
 /** The focused row's one-line description. */
 function describe(node: MenuNode): string {
   if (node.help) return node.help;
@@ -3061,28 +4118,155 @@ function commandText(node: MenuNode): string | undefined {
   }
 }
 
+/** Menu groups below `nodes` (two levels) whose label matches `needle`. */
+function deepGroups(
+  nodes: readonly MenuNode[],
+  context: MenuContext,
+  needle: string,
+): MenuNode[] {
+  const found: MenuNode[] = [];
+  const visit = (list: readonly MenuNode[], path: string, depth: number) => {
+    for (const node of list) {
+      if (node.kind !== "menu" || found.length >= 12) continue;
+      const label = path ? `${path} › ${node.label}` : node.label;
+      if (path && node.label.toLowerCase().includes(needle))
+        found.push({ ...node, label });
+      if (depth < 2) {
+        let children: MenuNode[] = [];
+        try {
+          children = node.build(context);
+        } catch {
+          continue;
+        }
+        visit(children, label, depth + 1);
+      }
+    }
+  };
+  visit(nodes, "", 0);
+  return found;
+}
+
 function nodeText(node: MenuNode): string {
   return `${node.label} ${valueText(node)} ${commandText(node) ?? ""}`;
 }
 
-/** Root sections, for `/menu <section>`. */
-export const MENU_SECTIONS = [
-  "sound",
-  "effects",
-  "rhythm",
-  "chords",
-  "mix",
-  "master",
-  "project",
-  "arrange",
-  // Older names, still accepted.
-  "parameters",
-  "sounds",
-  "track",
-  "automation",
-  "transport",
-  // Subsections.
-  "tempo",
-  "meter",
-  "time",
-] as const;
+/** Every id `/menu <id>` opens: the ten topics first, then older ids. */
+export const MENU_SECTIONS: readonly string[] = Object.freeze(
+  Object.keys(SECTION_ALIASES),
+);
+
+/** The ten topic ids, the roots `/menu` names first. */
+export const MENU_TOPICS: readonly string[] = Object.freeze(
+  MENU_SECTIONS.slice(0, 10),
+);
+
+/** The names `/menu` and `/help menu` list: one per topic, no aliases. */
+export const MENU_SHOWN_SECTIONS: readonly string[] = MENU_TOPICS;
+
+/** `/menu`'s usage line: the short form; `/help menu` lists every topic. */
+export const MENU_USAGE = "usage: /menu <topic or row> · /help menu lists them";
+
+/**
+ * The error for `/menu <section>` when nothing matches: the nearest topic
+ * or row name first, so it fits 80 columns, then the short usage.
+ */
+export function menuUsage(context: MenuContext, section: string): string {
+  const names = new Set<string>(MENU_SECTIONS);
+  for (const node of rootNodes(context))
+    if (node.kind === "menu") {
+      let children: MenuNode[] = [];
+      try {
+        children = node.build(context);
+      } catch {
+        continue;
+      }
+      for (const child of children)
+        if (child.kind === "menu") names.add(labelName(child.label));
+    }
+  const near = nearest(section, names);
+  return `no menu "${section}"${near ? ` · did you mean /menu ${near}?` : ""} · /menu <topic or row>`;
+}
+
+/** A row label without its padded detail: `granular  12 presets` → `granular`. */
+function labelName(label: string): string {
+  return label
+    .split(/\s{2,}/)[0]!
+    .trim()
+    .toLowerCase();
+}
+
+/**
+ * The path of menu ids `/menu <section>` walks: a topic or older id from
+ * SECTION_ALIASES, else the first menu row (three levels deep, breadth
+ * first) whose id or label is `section`. Undefined when nothing matches.
+ */
+export function menuSectionPath(
+  context: MenuContext,
+  section: string,
+): readonly string[] | undefined {
+  const needle = section.trim().toLowerCase();
+  if (!needle) return undefined;
+  const alias = SECTION_ALIASES[needle];
+  if (alias) return alias;
+  type Step = { nodes: readonly MenuNode[]; path: readonly string[] };
+  let level: Step[] = [{ nodes: rootNodes(context), path: [] }];
+  for (let depth = 0; depth < 3 && level.length; depth += 1) {
+    const next: Step[] = [];
+    for (const { nodes, path } of level) {
+      for (const node of nodes) {
+        if (node.kind !== "menu") continue;
+        const at = [...path, node.id];
+        if (node.id === needle || node.label.toLowerCase() === needle)
+          return at;
+        if (depth < 2) {
+          try {
+            next.push({ nodes: node.build(context), path: at });
+          } catch {
+            // A section that cannot build here has no rows to match.
+          }
+        }
+      }
+    }
+    level = next;
+  }
+  return undefined;
+}
+
+/** A one-track project, for breadcrumbs asked for without a window. */
+function breadcrumbContext(): MenuContext {
+  return {
+    score: createScore({
+      tempoBpm: 120,
+      bars: 8,
+      tracks: [{ id: "keys", name: "keys", instrument: "piano" }],
+      notes: [],
+    }),
+    trackId: "keys",
+    playing: false,
+    grid: "1/16",
+    grids: ["1/16"],
+    clickOn: false,
+    countInBars: 1,
+  };
+}
+
+/**
+ * `Ctrl-K › Chords and key › tuning`: where `/menu <id>` opens, from the
+ * live labels. Undefined when `id` opens nothing.
+ */
+export function menuPath(
+  id: string,
+  context: MenuContext = breadcrumbContext(),
+): string | undefined {
+  const path = menuSectionPath(context, id);
+  if (!path) return undefined;
+  const labels: string[] = [];
+  let nodes: readonly MenuNode[] = rootNodes(context);
+  for (const step of path) {
+    const node = nodes.find((row) => row.kind === "menu" && row.id === step);
+    if (node?.kind !== "menu") return undefined;
+    labels.push(node.label);
+    nodes = node.build(context);
+  }
+  return ["Ctrl-K", ...labels].join(" › ");
+}