moontide-mcp 2.1.0 → 2.2.0

package/README.md

@@ -41,8 +41,11 @@ change.
 - Around the code, the page shows the music in several views: the named tracks on a timeline
   where you can edit notes, the Song grid with the sections of a piece, the history as a list
   or a tree, a mixer with groups and lights whose moves rewrite the code, and a jam view with
-  the scale on a piano or a guitar.
-- A right-click on anything in the page sends Claude a request with that context.
+  the scale on a piano or a guitar. When the notes fit several scales, the jam view proposes
+  one and says why.
+- Claude can move the tempo up or down over a number of bars, instead of jumping.
+- A right-click on anything in the page sends Claude a request with that context. The Requests
+  list in the top bar shows what became of each request.
 - The same code can play real MIDI instruments from the page, through Web MIDI.
 
 Moontide does not start from scratch. The music engine is
@@ -70,6 +73,20 @@ Strudel contributors. Moontide is the bridge between Claude and a Strudel page.
    bar) says whether page requests are live (they reach Claude right away) or wait for Claude
    (they reach it with its next action). Its (i) explains how to switch.
 
+   The **Requests** button in the top bar counts the requests still in flight and opens a list:
+   one row per request, with what happened to it and how long ago. A request reads Sent, then
+   Waiting for Claude's next action or Received, then Claude has started on it, which means
+   Claude made a call after the request arrived. A change made for it reads Waiting for its
+   line while it waits for the next bar or phrase, then Applied as v12 (the version in the
+   History view); a change that failed reads Failed with the error, and one that a newer change
+   replaced or Stop canceled says so. A request Claude answers in words reads Answered or
+   Declined, with Claude's sentence. A request shows as applied only when Claude names it with
+   its change, never from timing alone. After 30 seconds without news a row reads No change yet
+   and keeps counting: that is not a failure. If the page loses its connection, open rows read
+   Connection lost. Click a row to see the whole request and what its
+   state means. Finished rows move to a short Recent list after 30 seconds. Nothing is kept
+   after the Moontide server stops.
+
 ## Install
 
 The short version, for someone who already has Node 22 or later and Claude Code:
@@ -274,6 +291,15 @@ The code can say which harmony it means with one top-level line, for example
 `const harmony = 'C:minor'`, placed above the patterns. It plays nothing and is never a
 track. The Jam view then shows two lines, "Declared:" and "Heard:", side by side.
 
+When the notes fit several scales, the Jam view proposes one and says why in a sentence, for
+example "Proposed: C major, C is the note heard most." It takes the declared scale of the playing
+section when that scale is among the ones that fit, and otherwise the scale the notes support
+most. Warnings stay on. "Scales that fit, click to switch:" lists them, and one click or Enter
+switches the whole view. Your pick holds while the same scales fit, and is forgotten on reload.
+When the scales differ in their notes and the code declares none of them, warnings are off: the
+view says why and lists the scales without a switch. The piano is coloured like the guitar, with
+the same legend, and every role also has a shape or text cue, so it reads without colour.
+
 ## Song structure
 
 Every new piece Claude writes starts with one `const song` at the top. It names the sections
@@ -309,6 +335,30 @@ Left or Right, to select a range of whole cycles, and use "Ask Claude" to send i
 
 A right-click on a section, a track, a cell or a group asks Claude about that thing.
 
+## Tempo ramp
+
+Ask Claude to speed up or slow down over a number of bars, for example "bring it up to 140 over
+eight bars". Claude sends the new code with the tempo to reach and `glideBars`, a whole number
+of bars from 1 to 64, on `set_code` or `edit_code`. The tempo then moves from the tempo that
+plays to the one in the code in equal small steps, and ends exactly on it. It starts at once, or
+at the line when the change waits for the next bar or phrase.
+
+While it runs, the tempo in the top bar shows the live tempo, an arrow and the tempo to reach.
+Hover it to see how many bars are left.
+
+Your Mixer moves, Song grid cells, Timeline edits and hand edits keep the ramp going. Code with
+another tempo cancels it, and that tempo plays at once. Code with no tempo cancels it, and the
+tempo stays where it was. A new `glideBars` replaces it. Stop cancels it too, and the next Play
+starts at the code's tempo. A reload, or another tab taking over, ends it. There is no cancel
+button of its own.
+
+A ramp is refused, and nothing changes, when nothing plays, when the code sets no tempo, or when
+it sets the tempo that already plays. A ramp is never a version: it writes nothing into the code
+or the history.
+
+The MIDI clock follows every step of a ramp. How hardware that follows the clock, such as an
+arpeggiator or a step sequencer, reacts to a ramp has not been verified.
+
 ## History
 
 Every version that plays is kept: Claude's own changes and your Ctrl+Enter edits, each with
@@ -368,6 +418,8 @@ Known limits:
 - Windows and Linux are untested by hand. Edge, Safari and Firefox are untested.
 - Internet access is needed.
 - MIDI needs Chrome or Edge.
+- How hardware that follows Moontide's MIDI clock, such as an arpeggiator or a step sequencer,
+  reacts to a tempo ramp has not been verified.
 - Run one Moontide at a time with the same history file.
 - The first start through npx downloads the package and can be slow.
 

package/dist/ask.js

@@ -58,11 +58,24 @@ export const REQUEST_LINE_MOMENT_FACT = 'About the moment field of a page reques
     'turn the note into a rest. Kind velocity has direction, softer or louder, for the note\'s velocity. ' +
     'About a request whose context has kind range: the user selected whole cycles of one lane. track is the lane, from and to ' +
     `are the first and last cycle, both included (a range covers at most ${MAX_RANGE_CYCLES} cycles), and in a piece with a song ` +
-    'section is the section of cycle from and sectionTo the section of cycle to when it differs. Such a request has no moment; ' +
+    'sections lists the sections those cycles cross in playing order, a section played twice in a row once and a section that ' +
+    'comes back after another one again, and moreSections, when present, counts the sections left out so that the list fits. ' +
+    'Such a request has no moment; ' +
     'its gesture has kind range. The gesture\'s notes lists the notes of that lane that start in those cycles, in order of ' +
     `start and then pitch (the lower first), at most ${MAX_MOMENT_NOTES}, each shaped like a moment note without state; more ` +
     'counts the notes left out, and version is the version that was playing (null when it was not known). A note that began ' +
     'before from and still sounds is not listed. A range with no notes in it is a valid request.';
+/**
+ * What the page shows for a request, as facts. Like the moment fact it goes where Claude reads page requests
+ * and nothing limits the length: the arming line, the page-requests-on text and the line in front of request
+ * lines that a tool reply hands over without an arming line. It says what the page shows and when, never what
+ * to do about it.
+ */
+export const REQUEST_LINE_STATUS_FACT = 'About the id field of a page request: the page shows the user what became of each request it sent. ' +
+    'It shows a request as applied, or as waiting for its line when the change takes over at the next bar or phrase, ' +
+    'only when the set_code, edit_code or restore_version call that answers it passes that id as answering. ' +
+    'It shows a request as answered or declined, with one sentence, only after answer_request closes it with that id. ' +
+    'A request with neither shows as no change yet. An id that is not an open request changes nothing.';
 /**
  * A log function that writes at most one line per window for each kind, to stderr. The next line
  * that does get written says how many were left out. Every log that a page or a local process can
@@ -148,7 +161,7 @@ export function listenerCommandOrReason(options) {
  */
 export function armingLine(options) {
     const head = 'Page requests: no listener is connected. A request typed in the Moontide page waits on the server and arrives in the reply of your next other Moontide tool. ' +
-        `${REQUEST_LINE_FRAMING} ${REQUEST_LINE_MOMENT_FACT}`;
+        `${REQUEST_LINE_FRAMING} ${REQUEST_LINE_MOMENT_FACT} ${REQUEST_LINE_STATUS_FACT}`;
     const result = listenerCommandOrReason(options);
     if ('reason' in result) {
         return `${head} ${result.reason}`;
@@ -199,6 +212,7 @@ export function pageRequestsOnText(options) {
             `Note: ${MONITOR_LIMIT_FACT}; when a Moontide tool reply gives this command again, run it again the same way.`,
         REQUEST_LINE_FRAMING,
         REQUEST_LINE_MOMENT_FACT,
+        REQUEST_LINE_STATUS_FACT,
     ].join('\n');
 }
 export const PAGE_REQUESTS_ALREADY_ON = 'Moontide page requests are already live: a Moontide monitor is connected and brings each request as soon as it is sent. ' +
@@ -290,6 +304,8 @@ export class AskChannel {
     /** Given only to Claude, in the arming line of a tool reply; changes at every server start. */
     listenerToken = newToken();
     send;
+    // Told when a request is accepted, handed to Claude, sent back to the queue or loses its page.
+    board;
     ackTimeoutMs;
     now;
     trusted = new Set();
@@ -307,6 +323,7 @@ export class AskChannel {
     logRefusal;
     constructor(options) {
         this.send = options.send;
+        this.board = options.board;
         this.ackTimeoutMs = options.ackTimeoutMs ?? LISTENER_ACK_TIMEOUT_MS;
         this.now = options.now ?? Date.now;
         this.logRefusal = makeThrottledLog(ASK_RATE_WINDOW_MS, this.now);
@@ -409,8 +426,11 @@ export class AskChannel {
             this.refuse(conn, msg.id, 'line-too-long');
             return;
         }
-        // The id is chosen by the page. A repeat would overwrite the in-flight slot and orphan its timer.
-        if (this.inFlight.has(msg.id) || this.queue.some((waiting) => waiting.id === msg.id)) {
+        // The id is chosen by the page. A repeat would overwrite the in-flight slot and orphan its timer, or
+        // take over the board row of a request Claude already holds, which may be another page's.
+        if (this.inFlight.has(msg.id) ||
+            this.queue.some((waiting) => waiting.id === msg.id) ||
+            this.board?.has(msg.id) === true) {
             this.logRefusal('duplicate', '[moontide] Refused a page request: its id is already in use');
             this.refuse(conn, msg.id, 'invalid', 'duplicate request id');
             return;
@@ -418,6 +438,7 @@ export class AskChannel {
         this.recent.push(now);
         const entry = { id: msg.id, line, origin: conn, answered: 'none' };
         if (this.listener !== null) {
+            this.board?.opened(msg.id, conn, { queued: false, text: msg.text, chip: msg.chip });
             this.dispatch(entry);
             return;
         }
@@ -427,6 +448,7 @@ export class AskChannel {
             return;
         }
         entry.answered = 'waiting';
+        this.board?.opened(msg.id, conn, { queued: true, text: msg.text, chip: msg.chip });
         this.queue.push(entry);
         this.send(conn, { type: 'ask-result', id: msg.id, status: 'waiting', waiting: this.queue.length }, 'the ask answer');
     }
@@ -479,6 +501,7 @@ export class AskChannel {
         this.pushPageRequestsState();
         const requeued = this.requeueInFlight();
         for (const entry of requeued) {
+            this.board?.waiting(entry.id);
             if (entry.answered === 'none') {
                 entry.answered = 'waiting';
                 if (entry.origin !== null) {
@@ -512,6 +535,7 @@ export class AskChannel {
         }
         this.inFlight.delete(ack);
         const { entry } = slot;
+        this.board?.delivered([entry.id]);
         if (entry.origin === null) {
             return;
         }
@@ -525,6 +549,7 @@ export class AskChannel {
     /** A page connection closed: its trust goes, and nobody is answered for its requests any more. */
     detachPage(conn) {
         this.trusted.delete(conn);
+        this.board?.pageGone(conn);
         for (const entry of this.queue) {
             if (entry.origin === conn) {
                 entry.origin = null;
@@ -541,17 +566,31 @@ export class AskChannel {
         }
         this.untrustedRefusals.delete(conn);
     }
+    /**
+     * A reloaded page took over these requests from the board: the ones still waiting or in flight whose
+     * page has gone now answer to it, so it is told when they are handed over or go back to waiting.
+     */
+    adoptOrigin(conn, ids) {
+        const adopted = new Set(ids);
+        const entries = [...this.queue, ...[...this.inFlight.values()].map((slot) => slot.entry)];
+        for (const entry of entries) {
+            if (entry.origin === null && adopted.has(entry.id)) {
+                entry.origin = conn;
+            }
+        }
+    }
     /**
      * Called by the tool replies: takes the WHOLE waiting queue at once and returns its request lines
      * (oldest first), telling each page its requests were handed over. Then, while no listener is
      * connected, a page has authenticated and page-requests-off has not paused it, the arming line. When
-     * there is request text but no arming line, the moment fact goes in front of the request lines.
+     * there is request text but no arming line, the moment fact and the status fact go in front of the request lines.
      */
     drainLines(options) {
         const lines = [];
         const entries = this.queue;
         this.queue = [];
         const handedOver = new Map();
+        this.board?.delivered(entries.map((entry) => entry.id));
         for (const entry of entries) {
             lines.push(entry.line);
             if (entry.origin !== null) {
@@ -564,13 +603,13 @@ export class AskChannel {
             this.send(origin, { type: 'ask-received', ids }, 'the ask hand-over');
         }
         if (!this.hasListener() && this.hasTrustedPage() && !this.armingPaused) {
-            // The arming line carries the moment fact itself.
+            // The arming line carries both facts itself.
             lines.push(armingLine({ scriptPath: options.scriptPath, port: options.port, token: this.listenerToken }));
         }
         else if (lines.length > 0) {
             // No arming line (page requests are paused, or a listener is connected): the reply still says what the
-            // moment of the request lines it carries holds.
-            lines.unshift(REQUEST_LINE_MOMENT_FACT);
+            // moment of the request lines it carries holds and what the page shows for a request.
+            lines.unshift(REQUEST_LINE_MOMENT_FACT, REQUEST_LINE_STATUS_FACT);
         }
         return lines;
     }

package/dist/mcp.js

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import { EDIT_NOTHING_PLAYING_MESSAGE, NOT_STARTED_MESSAGE } from './session.js';
 import { PAGE_WAIT_MS, START_INSTRUCTION, START_PROMPT, START_PROMPT_DESCRIPTION, START_PROMPT_TITLE, START_TOOL, START_TOOL_DESCRIPTION, notStartedForRequestsText, notStartedForRequestsToolText, pageLine, startMoontide, } from './start.js';
 import { MAX_EDITS, changedExcerpt } from './edit-code.js';
-import { MAX_PHRASE_CYCLES, MIN_PHRASE_CYCLES } from './protocol.js';
+import { MAX_ANSWER_TEXT_LENGTH, MAX_ASK_ID_LENGTH, MAX_GLIDE_BARS, MAX_PHRASE_CYCLES, MIN_GLIDE_BARS, MIN_PHRASE_CYCLES, } from './protocol.js';
 import { MAX_LABEL_LENGTH, MAX_FAVORITE_NAME_LENGTH } from './history.js';
 import { PAGE_REQUESTS_ALREADY_OFF, PAGE_REQUESTS_ALREADY_ON, PAGE_REQUESTS_OFF_DESCRIPTION, PAGE_REQUESTS_OFF_PROMPT, PAGE_REQUESTS_OFF_TEXT, PAGE_REQUESTS_OFF_TITLE, PAGE_REQUESTS_ON_DESCRIPTION, PAGE_REQUESTS_ON_PROMPT, PAGE_REQUESTS_ON_TITLE, PAGE_REQUESTS_INSTRUCTION, PAGE_REQUESTS_STATE_DESCRIPTION, PAGE_REQUESTS_TOOL, PAGE_REQUESTS_TOOL_DESCRIPTION, REQUEST_LINE_FRAMING, listenerScriptPath, noPageForRequestsText, noPageForRequestsToolText, pageRequestsOnText, } from './ask.js';
 import { REFERENCE_TOPICS, REFERENCE_TOPIC_IDS, REFERENCE_URI_PREFIX, readReferenceTopic, referenceIndexText, referenceToolDescription, structureTemplateText, } from './reference.js';
@@ -77,10 +77,12 @@ export function whenFlagLines(code) {
 // text: it holds no code and no page text. The music plays as written; nothing is refused, blocked or rewritten.
 export const NO_STRUCTURE_NOTE = 'Note: this new piece declares no song structure; every new piece declares one once at the top (see the structure topic of get_strudel_reference). It plays as written.';
 // A text match only, like GETTIME_CALL_RE: the code is never parsed, evaluated or changed on the server, and a match
-// inside a comment or a string counts too, by design. Anchored at a line start with [ \t]* (never \s*, so a run of blank
-// lines cannot make the scan quadratic) and ended on a word boundary, so `const songs`, `const song2`, `let song` and a
-// commented-out line are not a structure. The m flag only: no global flag, so test() keeps no lastIndex.
-const SONG_CONST_RE = /^[ \t]*const[ \t]+song\b/m;
+// inside a comment or a string counts too, by design. A song declared with let or var gets its own line from the page,
+// which reads only const, so the server says nothing more for it and the two lines never disagree. Anchored at a line
+// start with [ \t]* (never \s*, so a run of blank lines cannot make the scan quadratic) and ended on a word boundary, so
+// `const songs`, `const song2` and a commented-out line are not a song. The m flag only: no global flag, so test() keeps
+// no lastIndex.
+const SONG_DECLARATION_RE = /^[ \t]*(?:const|let|var)[ \t]+song\b/m;
 /** The shortest line, in characters after trimming, that counts when telling a new piece from a changed one. */
 const NEW_PIECE_MIN_LINE = 8;
 /**
@@ -105,7 +107,7 @@ function isNewPiece(previous, code) {
 }
 /** The note when `code` replaces `previousCode` as a new piece and declares no song structure, empty otherwise. */
 export function newPieceWithoutStructureLines(previousCode, code) {
-    if (SONG_CONST_RE.test(code))
+    if (SONG_DECLARATION_RE.test(code))
         return [];
     return isNewPiece(previousCode, code) ? [NO_STRUCTURE_NOTE] : [];
 }
@@ -154,6 +156,24 @@ export function tempoLine(bpm, pendingCycle) {
     const shown = Number.isInteger(bpm) ? String(bpm) : bpm.toFixed(1);
     return pendingCycle === undefined ? `Tempo: ${shown} BPM.` : `Tempo from cycle ${pendingCycle}: ${shown} BPM.`;
 }
+/**
+ * The one-line tempo ramp of a reply, said in place of the tempo line. Three states: a ramp that started with this change,
+ * a ramp that starts at the line of a waiting change (`pendingCycle` is the line), and a ramp that goes on because this
+ * change restated its target. The numbers come from the page, bounded by the protocol schema; only numbers are
+ * formatted here, so no page text enters the reply.
+ */
+export function glideLine(glide, pendingCycle) {
+    const shown = (bpm) => (Number.isInteger(bpm) ? String(bpm) : bpm.toFixed(1));
+    if (glide.state === 'running') {
+        return `Tempo ramp goes on: to ${shown(glide.toBpm)} BPM, now ${shown(glide.nowBpm)} BPM.`;
+    }
+    const length = glide.bars === 1 ? 'over 1 bar' : `over ${glide.bars} bars`;
+    if (glide.state === 'at-line') {
+        const line = pendingCycle === undefined ? 'at its line' : `from cycle ${pendingCycle}`;
+        return `Tempo ramp ${line}: from the tempo playing then to ${shown(glide.toBpm)} BPM ${length}.`;
+    }
+    return `Tempo ramp: from ${shown(glide.fromBpm)} to ${shown(glide.toBpm)} BPM ${length}.`;
+}
 /**
  * The first note of get_code while a change waits to take over: the code the reply shows is the code
  * that plays until the line.
@@ -189,16 +209,47 @@ function changeStatus(outcome, at, hadRuntimeErrors, pageUrl) {
  * the at-once note when a requested line was skipped because nothing played.
  */
 function changeNoteLines(outcome, at) {
-    const tempo = outcome.tempoChanged && outcome.bpm !== null ? [tempoLine(outcome.bpm, outcome.pending?.cycle)] : [];
+    // A change that started a ramp says the ramp in place of the tempo line: the tempo that plays has not changed yet.
+    const tempo = outcome.glide !== undefined
+        ? [glideLine(outcome.glide, outcome.pending?.cycle)]
+        : outcome.tempoChanged && outcome.bpm !== null
+            ? [tempoLine(outcome.bpm, outcome.pending?.cycle)]
+            : [];
     const atOnce = (at === 'bar' || at === 'phrase') && outcome.pending === undefined && outcome.audio !== 'stopped'
         ? [AT_ONCE_NOTE]
         : [];
     return [...tempo, ...atOnce];
 }
 const LABEL_FIELD_DESCRIPTION = 'A few words saying what this change is, for example "added a bass"; shown by list_history';
+// One description for the three tools that change the music, so Claude meets the same fact wherever it reads it.
+export const ANSWERING_FIELD_DESCRIPTION = 'The id of the page request this change answers, from its request line; the page shows that request as applied only when the change names it here';
+// Said in a reply when `answering` names no open page request. No user text, no id: the note is the same every time.
+// The music change itself is never refused or held back for it.
+export const UNKNOWN_ANSWERING_NOTE = 'Note: answering names no open page request (it is unknown or already closed), so it changed no request status; the music change is not affected by it.';
+/** The note when `answering` was given and names no open request, empty otherwise. */
+export function unknownAnsweringLines(answering, open) {
+    return answering !== undefined && !open ? [UNKNOWN_ANSWERING_NOTE] : [];
+}
+export const ANSWER_REQUEST_TOOL = 'answer_request';
+export const ANSWER_REQUEST_DESCRIPTION = 'Closes a request typed in the Moontide page without changing the music. Use outcome answered when the request was answered in words, declined when it will not or cannot be done. ' +
+    `Give one sentence of at most ${MAX_ANSWER_TEXT_LENGTH} characters; the page shows it under the request. ` +
+    'A change that answers a request names it with answering on set_code, edit_code or restore_version instead. ' +
+    'An id that is not an open request is refused and nothing changes.';
+export const ANSWER_REQUEST_ID_DESCRIPTION = 'The id of the page request to close, from its request line';
+export const ANSWER_REQUEST_OUTCOME_DESCRIPTION = 'answered when the request was answered in words, declined when it will not or cannot be done';
+export const ANSWER_REQUEST_TEXT_DESCRIPTION = `One sentence for the user, at most ${MAX_ANSWER_TEXT_LENGTH} characters; the page shows it under the request`;
+/** The reply when a request was closed, one fixed line per outcome. */
+export function answerRequestReply(outcome) {
+    return outcome === 'answered' ? 'The page request was closed as answered.' : 'The page request was closed as declined.';
+}
 const AT_FIELD_DESCRIPTION = "When the change takes over: 'now' (the default) within a fraction of a second, 'bar' on the next bar line, 'phrase' on the next phrase line (4 cycles, counted from Play). " +
     'The code is checked at once; the reply says the cycle and about how many seconds away it is.';
 const PHRASE_CYCLES_FIELD_DESCRIPTION = "How many cycles one phrase lasts, for at: 'phrase' (2 to 64, default 4)";
+// Facts only: the bounds are the only digits. It is one description for both tools that change the music's code.
+export const GLIDE_BARS_FIELD_DESCRIPTION = 'Whole bars, 1 to 64, to move the tempo smoothly from the tempo that plays to the one this code sets with setcps or setcpm; with at, it starts at the line. Refused when nothing plays, no tempo is set or it already plays. Stop, or code with another tempo or none, cancels it';
+// Said when set_code or edit_code asks for a ramp while nothing plays. The page holds the same text for the case the server
+// cannot know about (a page that has not played yet); a test checks both. Nothing was started, opened or sent.
+export const GLIDE_NOTHING_PLAYS_MESSAGE = 'Nothing plays, so there is no tempo to ramp from. Nothing was changed. Send the change again without glideBars.';
 /**
  * The tool description of edit_code. The when-to-use rule comes first; Claude Code keeps at most 2048
  * characters of a tool description.
@@ -349,6 +400,8 @@ export function createMcpServer(options) {
             'Call it before every change.',
         annotations: { readOnlyHint: true },
     }, async () => {
+        // Marks the page requests Claude already holds as started; first, so a request this reply hands over is not.
+        session.noteToolCall();
         // Before the start there is no page and no code: say how to start and start nothing. No drain, so queued
         // notices wait for the next reply.
         const server = starter.current();
@@ -382,6 +435,7 @@ export function createMcpServer(options) {
             topic: z.enum(REFERENCE_TOPIC_IDS).optional().describe('One topic to return; omit it to get the index of topics'),
         },
     }, async ({ topic }) => {
+        session.noteToolCall();
         try {
             const text = topic ? readReferenceTopic(topic) : referenceIndexText();
             return { content: [{ type: 'text', text }] };
@@ -422,19 +476,34 @@ export function createMcpServer(options) {
                 .max(MAX_PHRASE_CYCLES)
                 .optional()
                 .describe(PHRASE_CYCLES_FIELD_DESCRIPTION),
+            glideBars: z.number().int().min(MIN_GLIDE_BARS).max(MAX_GLIDE_BARS).optional().describe(GLIDE_BARS_FIELD_DESCRIPTION),
+            answering: z.string().min(1).max(MAX_ASK_ID_LENGTH).optional().describe(ANSWERING_FIELD_DESCRIPTION),
         },
-    }, async ({ code, label, at, phraseCycles }) => {
+    }, async ({ code, label, at, phraseCycles, glideBars, answering }) => {
+        session.noteToolCall();
+        // An id that is not open never reaches the change: it is told once and the music change goes ahead.
+        const answeringOpen = answering === undefined ? true : session.requestIsOpen(answering);
         try {
             // A phrase length means nothing for another timing; refused before anything reaches the page.
             if (phraseCycles !== undefined && at !== 'phrase') {
                 throw new Error("phraseCycles applies only with at: 'phrase'.");
             }
+            // A ramp needs music to leave: refused before Moontide starts, a tab opens or anything reaches the page.
+            if (glideBars !== undefined && (!session.hasActivePage() || session.isStopped())) {
+                throw new Error(GLIDE_NOTHING_PLAYS_MESSAGE);
+            }
             // The first change of the music starts Moontide and waits for the page of the tab it opens.
             await starter.ensureStarted();
             await starter.waitForPage();
             // What played before this call, read before the page changes it: the new-piece note compares the two.
             const previousCode = session.getCode();
-            const outcome = await session.evaluate(code, { label, at, phraseCycles });
+            const outcome = await session.evaluate(code, {
+                label,
+                at,
+                phraseCycles,
+                glideBars,
+                answering: answeringOpen ? answering : undefined,
+            });
             const { lines, hadRuntimeErrors } = session.drainNotices();
             // Claude must never be told "ok, playing" when something went wrong —
             // including when the user pressed Stop while this code was still starting.
@@ -454,6 +523,7 @@ export function createMcpServer(options) {
                 ...lines,
                 ...whenFlagLines(outcome.code),
                 ...newPieceWithoutStructureLines(previousCode, outcome.code),
+                ...unknownAnsweringLines(answering, answeringOpen),
                 ...getTimeAnchorLines(outcome.code),
             ]);
             return { content: [{ type: 'text', text }] };
@@ -464,7 +534,7 @@ export function createMcpServer(options) {
             // A failed set_code doesn't clear a pending hand edit, so keep surfacing it.
             const notices = session.wasEditedByHand() ? [HAND_EDIT_NOTE] : [];
             const message = err instanceof Error ? err.message : String(err);
-            throw new Error(withNoticeLines(message, [...notices, ...lines]));
+            throw new Error(withNoticeLines(message, [...notices, ...lines, ...unknownAnsweringLines(answering, answeringOpen)]));
         }
     });
     // Changes part of the code that will play by exact replacements, through the same Session path as
@@ -502,20 +572,35 @@ export function createMcpServer(options) {
                 .max(MAX_PHRASE_CYCLES)
                 .optional()
                 .describe(PHRASE_CYCLES_FIELD_DESCRIPTION),
+            glideBars: z.number().int().min(MIN_GLIDE_BARS).max(MAX_GLIDE_BARS).optional().describe(GLIDE_BARS_FIELD_DESCRIPTION),
+            answering: z.string().min(1).max(MAX_ASK_ID_LENGTH).optional().describe(ANSWERING_FIELD_DESCRIPTION),
         },
-    }, async ({ edits, base, label, at, phraseCycles }) => {
+    }, async ({ edits, base, label, at, phraseCycles, glideBars, answering }) => {
+        session.noteToolCall();
+        const answeringOpen = answering === undefined ? true : session.requestIsOpen(answering);
         try {
             // The same rule and text as set_code, before anything reaches the page.
             if (phraseCycles !== undefined && at !== 'phrase') {
                 throw new Error("phraseCycles applies only with at: 'phrase'.");
             }
+            // The same rule and text as set_code.
+            if (glideBars !== undefined && (!session.hasActivePage() || session.isStopped())) {
+                throw new Error(GLIDE_NOTHING_PLAYS_MESSAGE);
+            }
             // Nothing plays before a start, so there is nothing to edit: refuse before a tab opens for a request that cannot work.
             if (starter.current() === null) {
                 throw new Error(EDIT_NOTHING_PLAYING_MESSAGE);
             }
             await starter.ensureStarted();
             await starter.waitForPage();
-            const edit = await session.editCode(edits, { base, label, at, phraseCycles });
+            const edit = await session.editCode(edits, {
+                base,
+                label,
+                at,
+                phraseCycles,
+                glideBars,
+                answering: answeringOpen ? answering : undefined,
+            });
             const { outcome } = edit;
             const { lines, hadRuntimeErrors } = session.drainNotices();
             const status = changeStatus(outcome, at, hadRuntimeErrors, session.getPageUrl());
@@ -535,6 +620,7 @@ export function createMcpServer(options) {
                 ...otherText,
                 ...lines,
                 ...whenFlagLines(outcome.code),
+                ...unknownAnsweringLines(answering, answeringOpen),
                 ...getTimeAnchorLines(outcome.code),
             ]);
             return { content: [{ type: 'text', text }] };
@@ -543,7 +629,7 @@ export function createMcpServer(options) {
             const { lines } = session.drainNotices();
             const notices = session.wasEditedByHand() ? [HAND_EDIT_NOTE] : [];
             const message = err instanceof Error ? err.message : String(err);
-            throw new Error(withNoticeLines(message, [...notices, ...lines]));
+            throw new Error(withNoticeLines(message, [...notices, ...lines, ...unknownAnsweringLines(answering, answeringOpen)]));
         }
     });
     server.registerTool('list_history', {
@@ -558,6 +644,7 @@ export function createMcpServer(options) {
             favorites: z.boolean().optional().describe('true to list only favorites'),
         },
     }, async ({ limit, filter, favorites }) => {
+        session.noteToolCall();
         try {
             const text = session.listHistory({ limit, filter, favoritesOnly: favorites });
             const { lines } = session.drainNotices();
@@ -580,6 +667,7 @@ export function createMcpServer(options) {
                 .describe("Name to keep it under, in the user's words"),
         },
     }, async ({ id, name }) => {
+        session.noteToolCall();
         try {
             const text = session.favoriteVersion(id, name);
             const { lines } = session.drainNotices();
@@ -595,14 +683,17 @@ export function createMcpServer(options) {
         description: 'Plays a past version again, by its id from list_history, in one call: it takes over within a fraction of a second without stopping the music, with the same checks as set_code. The restore is added to the history as a new version ("restored from #id"); nothing is rewritten. Returns the code as confirmed by the page. A restore always takes over at once and replaces a change that waits for a bar or phrase line. The old version replaces the music at once; when the user asked for gradual changes this session, bring it in with set_code and a transition instead. Like set_code, it starts Moontide first when it is not started yet, but only for an id that exists in the history.',
         inputSchema: {
             id: z.number().int().positive().describe('Version id from list_history, for example 41 for #41'),
+            answering: z.string().min(1).max(MAX_ASK_ID_LENGTH).optional().describe(ANSWERING_FIELD_DESCRIPTION),
         },
-    }, async ({ id }) => {
+    }, async ({ id, answering }) => {
+        session.noteToolCall();
+        const answeringOpen = answering === undefined ? true : session.requestIsOpen(answering);
         try {
             // The history needs no page: an id that cannot be restored fails before Moontide starts or a tab opens.
             session.assertVersionExists(id);
             await starter.ensureStarted();
             await starter.waitForPage();
-            const outcome = await session.restoreVersion(id);
+            const outcome = await session.restoreVersion(id, { answering: answeringOpen ? answering : undefined });
             const { lines, hadRuntimeErrors } = session.drainNotices();
             // versionId is null only on a history-write failure — the write-failure
             // note (queued by the same recordConfirmed path set_code uses) explains why below.
@@ -612,7 +703,12 @@ export function createMcpServer(options) {
             const status = outcome.audio === 'playing' && !hadRuntimeErrors
                 ? `${head} — now playing.`
                 : `${head}. ${playStatus(outcome.audio, hadRuntimeErrors, session.getPageUrl())}`;
-            const tempo = outcome.tempoChanged && outcome.bpm !== null ? [tempoLine(outcome.bpm)] : [];
+            // A restored version that restates the target of a running ramp lets it go on, and says so in place of the tempo line.
+            const tempo = outcome.glide !== undefined
+                ? [glideLine(outcome.glide)]
+                : outcome.tempoChanged && outcome.bpm !== null
+                    ? [tempoLine(outcome.bpm)]
+                    : [];
             const notices = outcome.replacedHandEdit ? [HAND_EDIT_REPLACED_NOTE] : [];
             // The same t/f flag note and getTime() warn note as set_code, the getTime() note last.
             const text = withNoticeLines(`${status}\n\n${outcome.code}`, [
@@ -620,6 +716,7 @@ export function createMcpServer(options) {
                 ...notices,
                 ...lines,
                 ...whenFlagLines(outcome.code),
+                ...unknownAnsweringLines(answering, answeringOpen),
                 ...getTimeAnchorLines(outcome.code),
             ]);
             return { content: [{ type: 'text', text }] };
@@ -631,13 +728,36 @@ export function createMcpServer(options) {
             const { lines } = session.drainNotices();
             const notices = session.wasEditedByHand() ? [HAND_EDIT_NOTE] : [];
             const message = err instanceof Error ? err.message : String(err);
-            throw new Error(withNoticeLines(message, [...notices, ...lines]));
+            throw new Error(withNoticeLines(message, [...notices, ...lines, ...unknownAnsweringLines(answering, answeringOpen)]));
+        }
+    });
+    // Needs no started Moontide: a request id is only open while a server runs. It changes no music.
+    server.registerTool(ANSWER_REQUEST_TOOL, {
+        description: ANSWER_REQUEST_DESCRIPTION,
+        annotations: { destructiveHint: false },
+        inputSchema: {
+            id: z.string().min(1).max(MAX_ASK_ID_LENGTH).describe(ANSWER_REQUEST_ID_DESCRIPTION),
+            outcome: z.enum(['answered', 'declined']).describe(ANSWER_REQUEST_OUTCOME_DESCRIPTION),
+            text: z.string().max(MAX_ANSWER_TEXT_LENGTH).describe(ANSWER_REQUEST_TEXT_DESCRIPTION),
+        },
+    }, async ({ id, outcome, text }) => {
+        session.noteToolCall();
+        try {
+            session.answerRequest(id, outcome, text);
+            const { lines } = session.drainNotices();
+            return { content: [{ type: 'text', text: withNoticeLines(answerRequestReply(outcome), lines) }] };
+        }
+        catch (err) {
+            const { lines } = session.drainNotices();
+            const message = err instanceof Error ? err.message : String(err);
+            throw new Error(withNoticeLines(message, lines));
         }
     });
     server.registerTool('stop', {
         description: 'Stops all sound in the Moontide page right away, even when the current code is broken. The code stays in the editor; get_code still returns it, and the next set_code starts playing again. Before Moontide is started it says so and starts nothing.',
         annotations: { destructiveHint: false, idempotentHint: true },
     }, async () => {
+        session.noteToolCall();
         if (starter.current() === null) {
             throw new Error(NOT_STARTED_MESSAGE);
         }
@@ -665,6 +785,7 @@ export function createMcpServer(options) {
             instrument: z.string().min(1).max(32).optional().describe('An instrument id from instruments.json, to list its sounds'),
         },
     }, async ({ instrument }) => {
+        session.noteToolCall();
         try {
             const text = session.instrumentsReply(instrument);
             const { lines } = session.drainNotices();
@@ -685,6 +806,7 @@ export function createMcpServer(options) {
             category: z.string().max(60).optional().describe('Only sounds of this category; case and spaces do not matter'),
         },
     }, async ({ instrument, query, category }) => {
+        session.noteToolCall();
         try {
             const text = session.searchMidiSounds({ instrument, query, category });
             const { lines } = session.drainNotices();
@@ -704,6 +826,7 @@ export function createMcpServer(options) {
             overwrite: z.boolean().optional().describe('true to replace an existing user model with the same id'),
         },
     }, async ({ model, confirmed, overwrite }) => {
+        session.noteToolCall();
         try {
             const text = session.saveMidiModel({ model, confirmed, overwrite });
             const { lines } = session.drainNotices();
@@ -752,6 +875,7 @@ export function createMcpServer(options) {
                 .describe('The sounds of this part, grouped by bank and category; at most 500 sounds in the call'),
         },
     }, async ({ model, confirmed, append, more, source, programNumbering, overwrite, banks }) => {
+        session.noteToolCall();
         try {
             const text = session.saveMidiCatalog({ model, confirmed, append, more, source, programNumbering, overwrite, banks });
             const { lines } = session.drainNotices();
@@ -800,6 +924,7 @@ export function createMcpServer(options) {
             state: z.enum(['on', 'off']).describe(PAGE_REQUESTS_STATE_DESCRIPTION),
         },
     }, async ({ state }) => {
+        session.noteToolCall();
         const result = switchPageRequests({ session, state });
         if ('noPage' in result) {
             throw new Error(starter.current() === null ? notStartedForRequestsToolText() : noPageForRequestsToolText(session.getPageUrl()));
@@ -826,6 +951,7 @@ export function createMcpServer(options) {
         description: START_TOOL_DESCRIPTION,
         annotations: { destructiveHint: false, idempotentHint: true },
     }, async () => {
+        session.noteToolCall();
         const text = await startMoontide(starter);
         return { content: [{ type: 'text', text }] };
     });