@hraness/dawg 0.6.0 → 0.7.0

package/src/agent/tools.ts

@@ -1,4 +1,8 @@
+import { portableSchema } from "./portable-schema.ts";
+import { midiToPitch } from "../../core/pitch.ts";
+import { isGuideInstrument, vocalChainPatch } from "../../core/clips.ts";
 import { INSTRUMENT_WORDS } from "../../core/instruments.ts";
+import type { TrackVocoder } from "../../core/vocoder.ts";
 import {
   DEFAULT_STRING_PRESET,
   STRING_INSTRUMENT,
@@ -14,6 +18,15 @@ import {
   type TrackModal,
 } from "../../core/resonators.ts";
 import { applyModalCommand, type ModalCommand } from "../commands/modal.ts";
+import { applyWindCommand, type WindCommand } from "../commands/wind.ts";
+import {
+  type TrackWind,
+  WIND_ALIASES,
+  WIND_PARAMS,
+  WIND_PRESET_NAMES,
+  windParamName,
+  windPresetFor,
+} from "../../core/winds.ts";
 import {
   AUTOMATION_PARAMETERS,
   automationPoints,
@@ -46,9 +59,11 @@ import {
 } from "../commands/keys.ts";
 import {
   KEYS_PRESETS,
+  ORGAN_ALIASES,
   KEYS_SIMPLE,
   isKeysPreset,
   keysParamName,
+  pianoWrite,
 } from "../../core/keys.ts";
 import {
   setSampleControls,
@@ -72,6 +87,8 @@ import {
   applyFxCommand,
   effectPatch,
   effectValues,
+  FORMANT_VOWEL_HINT,
+  formantGotVowel,
   parseEffectName,
   parseParamName,
   parseFxCommand,
@@ -91,11 +108,15 @@ import { RHYTHM_TOOLS } from "./rhythm-tools.ts";
 import { CHORD_TOOLS } from "./chord-tools.ts";
 import { EXPRESSION_TOOLS } from "./expression-tools.ts";
 import { TUNING_TOOLS } from "./tuning-tools.ts";
+import { CALIBRATION_TOOLS } from "./calibration-tools.ts";
 import { MASTER_TOOLS } from "./master-tools.ts";
+import { STYLE_TOOLS } from "./style-tools.ts";
 import { DRUM_TOOLS } from "./drum-tools.ts";
 import { TIME_TOOLS } from "./time-tools.ts";
 import { SECTION_TOOLS } from "./section-tools.ts";
 import { GRANULAR_TOOLS } from "./granular-tools.ts";
+import { RESAMPLE_TOOLS } from "./resample-tool.ts";
+import { VOICE_TOOLS } from "./voice-tools.ts";
 import type { MediaResult, MediaRunContext } from "../media/types.ts";
 import { instrumentPatch, pitchToMidi } from "./ops.ts";
 import { TUNING_LIMITS } from "../../core/tuning.ts";
@@ -243,17 +264,17 @@ export type ToolContext = Readonly<{
 export type AgentTool = Readonly<{
   name: string;
   description: string;
+  /**
+   * Callable but not advertised: a duplicate kept so older transcripts and
+   * models still work. `chatTools` and the xcb catalog leave it out.
+   */
+  hidden?: boolean;
   parameters: Record<string, unknown>;
   plan: (args: Record<string, unknown>, context: ToolContext) => ToolPlan;
 }>;
 
-/** A model-supplied argument that the tool refused; never mutates the score. */
-export class ToolArgumentError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "ToolArgumentError";
-  }
-}
+import { ToolArgumentError } from "./tool-error.ts";
+export { ToolArgumentError };
 
 const MAX_NOTES_PER_CALL = 128;
 const MAX_EXPLAIN_CHARS = 2_000;
@@ -392,7 +413,7 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
   {
     name: "update_notes",
     description:
-      "Move, resize, transpose, re-velocity or detune existing notes by id. Times are in beats.",
+      "Move, resize, transpose, re-velocity or detune existing notes by id. Times are in beats. To transpose, prefer transpose (semitones relative to the note's current pitch, e.g. 2 up a whole step, -12 down an octave) over an absolute pitch.",
     parameters: {
       type: "object",
       properties: {
@@ -412,6 +433,13 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
                   { type: "string", maxLength: 4 },
                 ],
               },
+              transpose: {
+                type: "integer",
+                minimum: -127,
+                maximum: 127,
+                description:
+                  "Semitones relative to the current pitch (not with pitch)",
+              },
               velocity: { type: "number", minimum: 0, maximum: 1 },
               cents: {
                 type: "number",
@@ -430,6 +458,9 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
     },
     plan(args, context) {
       const tpb = context.score.ticksPerBeat;
+      // Pitch changes as before→after, so the model sees what it did and
+      // does not transpose again from the refreshed brief.
+      const moves: string[] = [];
       const operations = list(args, "updates", 1, MAX_NOTES_PER_CALL).map(
         (value, index): ScoreOperation => {
           const update = record(value, `updates[${index}]`);
@@ -447,8 +478,41 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
           });
           if (duration !== undefined)
             patch.durationTicks = Math.max(1, Math.round(duration * tpb));
+          const before = context.score.notes.find((n) => n.id === noteId);
           if (update.pitch !== undefined)
             patch.pitch = pitch(update.pitch, `updates[${index}].pitch`);
+          // Small models fill every field: transpose 0 beside a pitch means
+          // no shift, and a pitch that equals the transposed note agrees.
+          if (
+            patch.pitch !== undefined &&
+            update.transpose !== undefined &&
+            update.transpose !== 0 &&
+            patch.pitch !== (before?.pitch ?? 0) + Number(update.transpose)
+          )
+            throw new ToolArgumentError(
+              `updates[${index}] sets both pitch and transpose; use one`,
+            );
+          if (update.transpose !== undefined && patch.pitch === undefined) {
+            const shift = update.transpose;
+            if (typeof shift !== "number" || !Number.isInteger(shift))
+              throw new ToolArgumentError(
+                `updates[${index}].transpose must be whole semitones`,
+              );
+            const moved = (before?.pitch ?? 0) + shift;
+            if (moved < 0 || moved > 127)
+              throw new ToolArgumentError(
+                `updates[${index}].transpose moves ${noteId} to MIDI ${moved}, outside 0..127`,
+              );
+            patch.pitch = moved;
+          }
+          if (
+            patch.pitch !== undefined &&
+            before &&
+            patch.pitch !== before.pitch
+          )
+            moves.push(
+              `${noteId} ${midiToPitch(before.pitch)}→${midiToPitch(patch.pitch)}`,
+            );
           const velocity = optionalNumber(update, "velocity", {
             min: 0,
             max: 1,
@@ -467,14 +531,18 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
       return {
         kind: "score",
         operations,
-        summary: `~${operations.length} note${operations.length === 1 ? "" : "s"}`,
+        summary: `~${operations.length} note${operations.length === 1 ? "" : "s"}${
+          moves.length === 0
+            ? ""
+            : ` · pitch ${moves.slice(0, 8).join(", ")}${moves.length > 8 ? ` +${moves.length - 8} more` : ""}`
+        }`,
       };
     },
   },
   {
     name: "set_instrument",
     description:
-      "Change a track's instrument voice. Mallets and bells (modal): modal (marimba) vibes xylophone glock celesta chimes kalimba mbira steelpan bowl gong timpani; set_modal shapes them.",
+      "Change a track's instrument voice. Mallets and bells (modal): modal (marimba) vibes xylophone glock celesta chimes kalimba mbira steelpan bowl gong timpani, gamelan saron gangsa bonang …; set_modal shapes them. Electric keys: epiano suitcase dyno wurli clav funkclav (set_keys). Winds and brass (wind engine): flute recorder clarinet oboe bassoon sax trumpet trombone tuba horn …; set_wind shapes them.",
     parameters: {
       type: "object",
       properties: {
@@ -490,7 +558,8 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
       const track = context.score.tracks.find((t) => t.id === trackId);
       if (track && typeof args.instrument === "string") {
         const word = args.instrument.toLowerCase();
-        const preset = word === "piano" ? "grand" : word;
+        // `rhodes`, `wurlitzer`, `clavinet` name their electric presets.
+        const preset = pianoWrite(word)?.preset ?? word;
         if (isKeysPreset(preset)) {
           const patch = keysPresetPatch(track, preset);
           return {
@@ -507,13 +576,24 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
       return {
         kind: "score",
         operations: [
-          { type: "updateTrack", trackId, patch: { ...patch, ...rig } },
+          {
+            type: "updateTrack",
+            trackId,
+            patch: {
+              // `vocal` (0.7): the vocal chain fills unset effects.
+              ...(isGuideInstrument(patch.instrument)
+                ? vocalChainPatch(track)
+                : {}),
+              ...patch,
+              ...rig,
+            },
+          },
         ],
         trackId,
         summary:
           patch.instrument === "marimba" && !patch.modal
             ? `${trackId} → marimba (legacy tone) · set_modal preset marimba for the mallet engine`
-            : `${trackId} → ${patch.string?.preset ?? patch.modal?.preset ?? patch.instrument}`,
+            : `${trackId} → ${patch.string?.preset ?? patch.modal?.preset ?? patch.wind?.preset ?? patch.instrument}`,
       };
     },
   },
@@ -587,7 +667,7 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
         parameter: {
           type: "string",
           description:
-            "volume, pan, filter, resonance, delay-feedback, delay-mix, or <effect>-<param>",
+            "volume, pan, filter, resonance, delay-feedback, delay-mix, <effect>-<param>, or grain-<param> on a granular track",
         },
         mode: { type: "string", enum: ["replace", "merge"] },
         points: {
@@ -713,7 +793,7 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
   {
     name: "set_rig",
     description:
-      "Guitar rig on a track (stomp → amp head with noise gate → speaker cab, before tremolo). rig loads a whole rig (clean crunch punk ragged lead metal fuzz octave funk wah bachata spring bassdrive reese jangle alt) or reset removes it; stomp/head/cab set stage params (stomp type fuzz|face|od|rat|octave gain tone level; head type clean|chime|crunch|lead|high|solid|bass gain bass mid treble presence master sag gate(dB); cab type 1x12|2x12|4x12|1x10|open|8x10|1x15|di mic), or null removes a stage. Heads are level-matched. `amp` is Strudel gain, not this.",
+      "Guitar rig on a track (stomp → amp head with noise gate → speaker cab, before tremolo). rig loads a whole rig (clean crunch punk ragged lead metal fuzz octave funk wah bachata spring bassdrive reese jangle alt, and the shoegaze rigs shoegaze glide dreampop swell ebow that add wobble/bloom/swell/double and a long reverb) or reset removes it; stomp/head/cab set stage params (stomp type fuzz|face|od|rat|octave gain tone level; head type clean|chime|crunch|lead|high|solid|bass gain bass mid treble presence master sag gate(dB); cab type 1x12|2x12|4x12|1x10|open|8x10|1x15|di mic), or null removes a stage. Heads are level-matched. `amp` is Strudel gain, not this.",
     parameters: {
       type: "object",
       properties: {
@@ -844,7 +924,7 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
   {
     name: "set_string",
     description:
-      "Make a track a plucked string (physical model): preset picks the instrument; params override it (ring s, bright, damp, pos, mute, buzz = jawari, body, sym = sympathetic strings, stiff, exciter pick|finger|hammer|noise); null unsets one. reset keeps the preset and drops overrides; off returns the track to a plain pluck voice.",
+      "Make a track a plucked, struck or bowed string (physical model). Bowed presets (exciter bow): violin viola cello contrabass fiddle erhu kamancheh, sections violins violas cellos contrabasses, pizz trem. preset picks the instrument; params override it (ring s, bright, damp, pos, mute, buzz = jawari, body, sym = sympathetic strings, stiff, exciter pick|finger|hammer|noise|bow); null unsets one. Bowed presets take pressure speed attack vib vibmod vibdelay tremhz sord dyn. reset keeps the preset and drops overrides; off returns the track to a plain pluck voice.",
     parameters: {
       type: "object",
       properties: {
@@ -886,17 +966,25 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
   },
   {
     name: "set_keys",
-    description: `Shape a modelled piano: preset (instrument, keys and its effects), params ${KEYS_SIMPLE.join(" ")}… (null unsets; DAWG.md lists all), or reset. Stored "piano" stays legacy; set_instrument piano writes grand.`,
+    description: `Shape a modeled piano, electric keys (epiano wurli clav) or organ: preset (instrument, keys and its effects), params ${KEYS_SIMPLE.join(" ")}… (pianos: sym 0.5 adds sympathetic bloom under the sustain pedal, good for Chopin and Debussy; epiano: bark bell tone vibe; wurli: trem; clav: pickup mute; null unsets; DAWG.md lists all), or reset. Stored "piano" stays legacy; set_instrument piano writes grand. Organs (not "organ", a legacy synth): presets tonewheel combo pipe… (aliases hammond b3 farfisa church); drawbars "888800008", registers "08880", stops (plenum, flute8…), rotary; params perc percdecay percvol click scanner drive (tonewheel), voice vib vibmod drive (combo), chiff wind trem (pipe). A row the family does not read is refused.`,
     parameters: {
       type: "object",
       properties: {
         trackId: trackIdSchema,
-        preset: { type: "string", enum: Object.keys(KEYS_PRESETS) },
+        preset: {
+          type: "string",
+          enum: [...Object.keys(KEYS_PRESETS), ...Object.keys(ORGAN_ALIASES)],
+        },
         reset: { type: "boolean" },
         params: {
           type: "object",
           additionalProperties: { type: ["number", "string", "null"] },
         },
+        // f061-organ
+        drawbars: { type: "string", pattern: "^[0-8]{9}$" },
+        registers: { type: "string", pattern: "^[0-8]{5}$" },
+        stops: { type: ["array", "string"], items: { type: "string" } },
+        rotary: { type: "string", enum: ["slow", "fast", "stop"] },
       },
       additionalProperties: false,
     },
@@ -935,7 +1023,7 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
   {
     name: "set_modal",
     description:
-      "Mallets and bells on the modal engine: preset (marimba vibes xylophone glock celesta chimes kalimba mbira steelpan bowl gong timpani) switches the voice and keeps overrides; mallet yarn|cord|rubber|plastic|brass; params sets MODAL_PARAMS (hardness position ring tilt release damp motor motordepth ombak buzz click strikebend strikedecay gain), null returns one to the preset; reset clears overrides. Turns the track into instrument modal.",
+      "Mallets and bells on the modal engine: preset (marimba vibes xylophone glock celesta chimes kalimba mbira steelpan bowl gong timpani) switches the voice and keeps overrides (gamelan: crotales musicbox toypiano saron demung slenthem gangsa gender bonang kenong kethuk kempul; frame drums daf bodhran tabla); mallet yarn|cord|rubber|plastic|brass; params sets MODAL_PARAMS (hardness position ring tilt release damp motor motordepth ombak buzz click strikebend strikedecay gain), null returns one to the preset; pair names a partner modal track: this track (pengisep) sounds ombak Hz above it and the partner (pengumbang) gets ombak 0, null unpairs; reset clears overrides. Turns the track into instrument modal.",
     parameters: {
       type: "object",
       properties: {
@@ -945,6 +1033,7 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
           enum: [...MODAL_PRESET_NAMES, ...Object.keys(MODAL_ALIASES)],
         },
         mallet: { type: "string", enum: [...MODAL_MALLET_NAMES] },
+        pair: { type: ["string", "null"] },
         reset: { type: "boolean" },
         params: {
           type: "object",
@@ -974,6 +1063,11 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
           throw new ToolArgumentError("mallet must be a string");
         values.mallet = args.mallet;
       }
+      if (args.pair !== undefined) {
+        if (args.pair !== null && typeof args.pair !== "string")
+          throw new ToolArgumentError("pair must be a track id or null");
+        values.pair = args.pair;
+      }
       if (args.params !== undefined) {
         if (
           typeof args.params !== "object" ||
@@ -1019,9 +1113,20 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
         messages.push(result.message);
       }
       const next = score.tracks.find((t) => t.id === trackId)!;
+      // A pair also sets the partner (pengumbang) to ombak 0.
+      const partners = score.tracks.filter(
+        (t) =>
+          t.id !== trackId &&
+          t.modal !== context.score.tracks.find((o) => o.id === t.id)?.modal,
+      );
       return {
         kind: "score",
         operations: [
+          ...partners.map((t) => ({
+            type: "updateTrack" as const,
+            trackId: t.id,
+            patch: { modal: t.modal ?? null },
+          })),
           {
             type: "updateTrack",
             trackId,
@@ -1033,10 +1138,111 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
       };
     },
   },
+  {
+    name: "set_wind",
+    description:
+      "Winds and brass on the wind engine (breath-driven waveguides): preset (flute recorder whistle ney shakuhachi panpipe suling bansuri clarinet bassclarinet oboe bassoon sax altosax barisax trumpet harmon plunger trombone tuba horn) switches the voice and keeps overrides; params sets WIND_PARAMS (breath bright mute players growl noise attack release vib vibmod reed stopped wah wahenv flutter gain model), null returns one to the preset; players 2..8 is a section that spreads over chord tones; reset clears overrides; off returns to the legacy wind tone. Lines slur by default (a note that starts while one note is held is not re-tongued). Turns the track into the wind engine.",
+    parameters: {
+      type: "object",
+      properties: {
+        trackId: trackIdSchema,
+        preset: {
+          type: "string",
+          enum: [...WIND_PRESET_NAMES, ...Object.keys(WIND_ALIASES)],
+        },
+        reset: { type: "boolean" },
+        off: { type: "boolean" },
+        params: {
+          type: "object",
+          additionalProperties: {
+            type: ["number", "string", "boolean", "null"],
+          },
+        },
+      },
+      additionalProperties: false,
+    },
+    plan(args, context) {
+      const trackId = targetTrack(args, context);
+      const commands: WindCommand[] = [];
+      if (args.off === true) commands.push({ type: "wind-off" });
+      if (args.reset === true) commands.push({ type: "wind-reset" });
+      if (args.preset !== undefined) {
+        const preset =
+          typeof args.preset === "string"
+            ? windPresetFor(args.preset)
+            : undefined;
+        if (!preset)
+          throw new ToolArgumentError(
+            `preset must be one of ${WIND_PRESET_NAMES.join(", ")}`,
+          );
+        commands.push({ type: "wind-preset", preset });
+      }
+      const values: Record<string, number | string | boolean | null> = {};
+      if (args.params !== undefined) {
+        if (
+          typeof args.params !== "object" ||
+          args.params === null ||
+          Array.isArray(args.params)
+        )
+          throw new ToolArgumentError("params must be an object");
+        for (const [key, value] of Object.entries(args.params)) {
+          const name = windParamName(key);
+          if (!name)
+            throw new ToolArgumentError(
+              `wind has no parameter ${key} (${Object.keys(WIND_PARAMS).join(" ")})`,
+            );
+          if (
+            value !== null &&
+            typeof value !== "number" &&
+            typeof value !== "string" &&
+            typeof value !== "boolean"
+          )
+            throw new ToolArgumentError(
+              `${key} must be a number, string or boolean`,
+            );
+          values[name] = value;
+        }
+      }
+      if (Object.keys(values).length > 0)
+        commands.push({ type: "wind-set", values });
+      if (commands.length === 0) {
+        // An empty call turns the track into the wind engine.
+        const current = context.score.tracks.find((t) => t.id === trackId);
+        commands.push({
+          type: "wind-preset",
+          preset:
+            current?.instrument === "wind" && current.wind?.preset
+              ? current.wind.preset
+              : "flute",
+        });
+      }
+      let score = context.score;
+      const messages: string[] = [];
+      for (const command of commands) {
+        const result = applyWindCommand(score, trackId, command);
+        if (!result.ok) throw new ToolArgumentError(result.message);
+        if (result.next) score = result.next;
+        messages.push(result.message);
+      }
+      const next = score.tracks.find((t) => t.id === trackId)!;
+      return {
+        kind: "score",
+        operations: [
+          {
+            type: "updateTrack",
+            trackId,
+            patch: { instrument: next.instrument, wind: next.wind ?? null },
+          },
+        ],
+        trackId,
+        summary: `${trackId} ${messages.at(-1)}`,
+      };
+    },
+  },
   {
     name: "set_sample",
     description:
-      "Set a sampler voice's Strudel sample controls: begin end gain speed unit(r|c|s) loop loopBegin loopEnd clip(legato) fit loopAt accelerate squiz cut; null unsets one.",
+      "Set a sampler voice's Strudel sample controls: begin end gain speed unit(r|c|s) loop loopBegin loopEnd clip(legato) fit loopAt accelerate squiz cut, and (0.6.1) shift (semitones, length kept) formant (0 keeps the voice's formants) fadeInTime fadeTime (seconds), vel [lo,hi] (velocity layer) rr (round-robin group). null unsets one.",
     parameters: {
       type: "object",
       properties: {
@@ -1045,7 +1251,15 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
         params: {
           type: "object",
           additionalProperties: {
-            type: ["number", "string", "boolean", "null"],
+            anyOf: [
+              { type: ["number", "string", "boolean", "null"] },
+              {
+                type: "array",
+                items: { type: "integer", minimum: 0, maximum: 127 },
+                minItems: 2,
+                maxItems: 2,
+              },
+            ],
           },
         },
       },
@@ -1131,7 +1345,8 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
   },
   {
     name: "set_effects",
-    description: `Shorthand: low-pass filter, delay (beats) and reverb (mix 0.15..0.35 is a room); null removes one. Prefer set_fx.`,
+    hidden: true,
+    description: `Shorthand for set_fx (use set_fx): low-pass filter, delay (beats) and reverb (mix 0.15..0.35 is a room); null removes one.`,
     parameters: {
       type: "object",
       properties: {
@@ -1291,7 +1506,8 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
   },
   {
     name: "add_drums",
-    description: `Add one-off drum hits to a kit track (create one with create_track instrument "kit"); prefer set_rhythm for repeating beats. Voices: ${DRUM_VOICES.map((info) => info.voice).join(", ")}. Give explicit hits, and/or patterns that repeat a voice every N beats across the loop.`,
+    hidden: true,
+    description: `Use set_rhythm. Add one-off drum hits to a kit track (create one with create_track instrument "kit"); prefer set_rhythm for repeating beats. Voices: ${DRUM_VOICES.map((info) => info.voice).join(", ")}. Give explicit hits, and/or patterns that repeat a voice every N beats across the loop.`,
     parameters: {
       type: "object",
       properties: {
@@ -1343,14 +1559,14 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
       const track = context.score.tracks.find((t) => t.id === trackId)!;
       if (!isDrumInstrument(track.instrument))
         throw new ToolArgumentError(
-          `track ${trackId} is ${track.instrument}, not a drum kit; set_instrument kit or create a kit track`,
+          `track ${trackId} is ${track.instrument}, not a kit; set_instrument kit or create a kit track`,
         );
       const tpb = context.score.ticksPerBeat;
       const loopBeats = loopTicksOf(context.score) / tpb;
       const voiceOf = (value: unknown, label: string) => {
         const voice =
           typeof value === "string" ? parseDrumVoice(value) : undefined;
-        if (!voice) throw new ToolArgumentError(`${label}: unknown drum voice`);
+        if (!voice) throw new ToolArgumentError(`${label}: unknown drum`);
         return voice;
       };
       const hits: { voice: DrumVoice; beat: number; velocity: number }[] = [];
@@ -1505,7 +1721,7 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
         typeof args.instrument === "string"
           ? args.instrument.toLowerCase()
           : "";
-      const preset = word === "piano" ? "grand" : word;
+      const preset = pianoWrite(word)?.preset ?? word;
       if (isKeysPreset(preset)) {
         const patch = keysPresetPatch({}, preset);
         return {
@@ -1815,13 +2031,18 @@ export const AGENT_TOOLS: readonly AgentTool[] = Object.freeze([
   ...CHORD_TOOLS,
   ...EXPRESSION_TOOLS,
   ...TUNING_TOOLS,
+  ...CALIBRATION_TOOLS,
   ...DRUM_TOOLS,
   ...TIME_TOOLS,
   ...SECTION_TOOLS,
   ...MEDIA_TOOLS,
   ...PACK_TOOLS,
   ...MASTER_TOOLS,
+  ...STYLE_TOOLS,
   ...GRANULAR_TOOLS,
+  ...RESAMPLE_TOOLS,
+  // 0.7 Voice: one array per lane in voice-tools.ts.
+  ...VOICE_TOOLS,
   // Looks tools up at call time, so it can plan any of the above.
   previewSoundTool((name) => findAgentTool(name)),
 ] satisfies AgentTool[]);
@@ -1918,14 +2139,16 @@ export function findAgentTool(
 export function chatTools(
   tools: readonly AgentTool[] = AGENT_TOOLS,
 ): ChatTool[] {
-  return tools.map((tool) => ({
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.parameters,
-    },
-  }));
+  return tools
+    .filter((tool) => !tool.hidden)
+    .map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: portableSchema(tool.parameters),
+      },
+    }));
 }
 
 function fxToolCommand(
@@ -1951,6 +2174,14 @@ function fxToolCommand(
     throw new ToolArgumentError("set_fx needs on, preset, or params");
   }
   const params = record(args.params, "params");
+  if (
+    effect === "formant" &&
+    formantGotVowel([
+      ...Object.keys(params),
+      ...Object.values(params),
+    ] as string[])
+  )
+    throw new ToolArgumentError(FORMANT_VOWEL_HINT);
   const values: Record<string, number | string | boolean> = {};
   for (const [name, value] of Object.entries(params)) {
     const param = parseParamName(effect, name);
@@ -1969,19 +2200,54 @@ function fxToolCommand(
   return { type: "fx-set", effect, values };
 }
 
+/** f061-organ: set_keys drawbars/registers/stops/rotary as keys values. */
+function organToolValues(
+  args: Record<string, unknown>,
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const name of ["drawbars", "registers", "rotary"] as const) {
+    const value = args[name];
+    if (value === undefined) continue;
+    if (typeof value !== "string")
+      throw new ToolArgumentError(`keys ${name} must be a string`);
+    out[name] = value;
+  }
+  if (args.stops !== undefined) {
+    const words = Array.isArray(args.stops)
+      ? args.stops
+      : typeof args.stops === "string"
+        ? args.stops.split(/[\s,+]+/)
+        : undefined;
+    if (!words || !words.every((word) => typeof word === "string"))
+      throw new ToolArgumentError("keys stops must be stop names");
+    out.stops = words.join(" ");
+  }
+  return out;
+}
+
 function keysToolCommand(args: Record<string, unknown>): KeysCommand {
   if (args.reset === true) return { type: "keys-reset" };
+  const organ = organToolValues(args);
+  const organSet = Object.keys(organ).length > 0;
   if (args.preset !== undefined) {
-    if (typeof args.preset !== "string" || !isKeysPreset(args.preset))
+    const preset =
+      typeof args.preset === "string"
+        ? (pianoWrite(args.preset)?.preset ?? args.preset)
+        : undefined;
+    if (preset === undefined || !isKeysPreset(preset))
       throw new ToolArgumentError(
         `keys presets: ${Object.keys(KEYS_PRESETS).join(", ")}`,
       );
-    return { type: "keys-preset", preset: args.preset };
+    return organSet
+      ? { type: "keys-preset", preset, values: organ }
+      : { type: "keys-preset", preset };
   }
+  if (args.params === undefined && organSet)
+    return { type: "keys-set", values: organ };
   if (args.params === undefined)
     throw new ToolArgumentError("set_keys needs preset, reset, or params");
   const params = record(args.params, "params");
-  const values: Record<string, number | string | null> = {};
+  const values: Record<string, number | string | null> = { ...organ };
   for (const [name, value] of Object.entries(params)) {
     const param = keysParamName(name);
     if (!param)
@@ -2112,6 +2378,8 @@ function instrumentName(value: unknown): {
   instrument: string;
   string?: { preset: string };
   modal?: TrackModal;
+  wind?: TrackWind;
+  vocoder?: TrackVocoder;
 } {
   const word = typeof value === "string" ? value.trim() : undefined;
   if (word === STRING_INSTRUMENT)
@@ -2124,6 +2392,8 @@ function instrumentName(value: unknown): {
     patch === undefined ||
     (!patch.string &&
       !patch.modal &&
+      !patch.wind &&
+      !patch.vocoder &&
       !(AVAILABLE_INSTRUMENTS as readonly string[]).includes(patch.instrument))
   )
     throw new ToolArgumentError(

package/src/agent/usage.ts

@@ -232,7 +232,7 @@ export class SpendMeter {
 
 /**
  * The spend line: `$0.12 session · $0.48 today · opus-5.5 · gateway`;
- * `subscription · sonnet · claude`; `no model · dawg login`. Narrow widths
+ * `subscription · sonnet · claude`; `commands only`. Narrow widths
  * drop the today total, then the session total, then the provider.
  */
 export function spendLine(
@@ -245,7 +245,7 @@ export function spendLine(
   },
   width = 120,
 ): string {
-  if (options.kind === "offline") return "no model · dawg login";
+  if (options.kind === "offline") return "commands only";
   const tail = [options.model, options.provider].filter(Boolean) as string[];
   const money =
     options.kind === "subscription"