vibo-mcp 2.3.1 → 2.4.1

package/dist/tools/section-manage.js

@@ -0,0 +1,288 @@
+import { z } from 'zod';
+import { McpToolError, minifiedResult, confirmTokenParam, toolAnnotations } from '@chrischall/mcp-utils';
+import { CREATE_SECTION, REMOVE_SECTION, REORDER_SECTIONS, UPDATE_SECTION } from '../gql.js';
+import { planMoves, missingIds } from '../reorder.js';
+import { confirmWrite, CONFIRM_NOTE } from './shared.js';
+import { fetchSections, fetchEventPermissions, findSection, isHost, } from './lookups.js';
+/**
+ * The web app's section-name limit (`nameMustBeCharactersOrLess`, count 45).
+ * Vibo's API stores longer names (60 was accepted live), so this keeps names
+ * the web UI can still edit.
+ */
+export const SECTION_NAME_MAX = 45;
+/**
+ * The web app's "Add section" defaults (its create-form initial values), so a
+ * section made here behaves like one made in the UI.
+ */
+const DEFAULT_SECTION_SETTINGS = {
+    timeEnabled: true,
+    songsEnabled: true,
+    notesEnabled: true,
+    canHostsOrderSongs: true,
+    canHostDeleteSection: true,
+    notesVisibleForHosts: true,
+    canHostChangeSectionName: true,
+    canHostChangeSectionTime: true,
+};
+/** The UI's "Who will see this section" choices → settings, verbatim from its bundle. */
+const VISIBILITY_SETTINGS = {
+    host: { visibleForGuests: false, visibleForHosts: true }, // "Me and DJ"
+    public: { visibleForGuests: true, visibleForHosts: true }, // "Guests"
+};
+/** Section types a delete must be forced for: the DJ's built-in list and timeline dividers. */
+const PROTECTED_TYPES = new Set(['dontPlay', 'headline']);
+const TIME_PATTERN = /^(0?[1-9]|1[0-2]):([0-5]\d)\s*([ap])\.?m\.?$/i;
+/** "5:00 PM" / "05:00pm" → "05:00 pm" (the form Vibo stores); undefined when not a 12-hour time. */
+export function normalizeTime(time) {
+    const m = TIME_PATTERN.exec(time.trim());
+    if (!m)
+        return undefined;
+    return `${m[1].padStart(2, '0')}:${m[2]} ${m[3].toLowerCase()}m`;
+}
+function assertCanWriteTimeline(perms, flag, what) {
+    if (!isHost(perms))
+        return;
+    if (perms.isLocked) {
+        throw new McpToolError(`This event is locked, so hosts can't ${what}. Nothing was sent.`, {
+            hint: 'The DJ locks an event close to the date; ask them to unlock it or make the change.',
+        });
+    }
+    if (perms.settings?.[flag] === false) {
+        throw new McpToolError(`The DJ has turned off "${flag}" for this event, so hosts can't ${what}. Nothing was sent.`, {
+            hint: "It's an event setting only the DJ can change — ask them to enable it or make the change.",
+        });
+    }
+}
+const sectionLabel = (s) => ({ _id: s._id, name: s.name });
+export function registerSectionManageTools(server, client) {
+    server.registerTool('vibo_create_section', {
+        description: `Create a new timeline section. Name is required, max ${SECTION_NAME_MAX} characters (Vibo's limit, checked ` +
+            'before anything is sent). Place it with afterSectionId (directly after that section) or position ' +
+            '(0-based index; 0 = first); with neither it goes at the end of the timeline, like the web app. ' +
+            'visibility "host" (default) = "Me and DJ", "public" = visible to guests too. Vibo gives a section a host ' +
+            "creates \"hosts can order songs\" = off, which only the DJ can turn on. Returns the new section _id. " +
+            CONFIRM_NOTE,
+        annotations: toolAnnotations({ title: 'Create Vibo section', readOnly: false, destructive: false }),
+        inputSchema: z.object({
+            eventId: z.string().describe('Event id.'),
+            name: z.string().describe(`Section name, 1–${SECTION_NAME_MAX} characters.`),
+            visibility: z
+                .enum(['host', 'public'])
+                .optional()
+                .describe('"host" (default) = Me and DJ only; "public" = guests can see it too.'),
+            time: z.string().optional().describe('Scheduled time as "hh:mm am/pm", e.g. "05:30 pm".'),
+            note: z.string().optional().describe('Note to the DJ (set right after creating, via updateSection).'),
+            afterSectionId: z.string().optional().describe('Put the new section directly after this section _id.'),
+            position: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe('0-based timeline index for the new section; past the end appends. Use instead of afterSectionId.'),
+            confirmToken: confirmTokenParam,
+        }),
+    }, async ({ eventId, name, visibility, time, note, afterSectionId, position, confirmToken }, ctx) => {
+        const trimmed = name.trim();
+        if (!trimmed) {
+            throw new McpToolError('Section name is empty.', { hint: 'Pass a name of 1–45 characters.' });
+        }
+        if (trimmed.length > SECTION_NAME_MAX) {
+            throw new McpToolError(`Section name is ${trimmed.length} characters; Vibo allows at most ${SECTION_NAME_MAX}. Nothing was sent.`, { hint: `Shorten the name to ${SECTION_NAME_MAX} characters or fewer.` });
+        }
+        let normalizedTime;
+        if (time !== undefined && time.trim() !== '') {
+            normalizedTime = normalizeTime(time);
+            if (!normalizedTime) {
+                throw new McpToolError(`"${time}" is not a 12-hour time.`, { hint: 'Use "hh:mm am/pm", e.g. "05:30 pm".' });
+            }
+        }
+        if (afterSectionId !== undefined && position !== undefined) {
+            throw new McpToolError('Pass afterSectionId or position, not both.', {
+                hint: 'afterSectionId places it after a named section; position places it at a 0-based index.',
+            });
+        }
+        const [perms, sections] = await Promise.all([fetchEventPermissions(client, eventId), fetchSections(client, eventId)]);
+        assertCanWriteTimeline(perms, 'canHostCreateSections', 'add sections');
+        // Resolve placement to the one knob createSection has: insertBeforeSectionId.
+        let insertBefore;
+        let placedAfter; // null = start of the timeline
+        if (afterSectionId !== undefined) {
+            const anchor = findSection(sections, afterSectionId);
+            insertBefore = sections[sections.indexOf(anchor) + 1];
+            placedAfter = anchor;
+        }
+        else if (position !== undefined) {
+            insertBefore = sections[position];
+            placedAfter = position === 0 ? null : (sections[Math.min(position, sections.length) - 1] ?? null);
+        }
+        else {
+            placedAfter = sections[sections.length - 1] ?? null;
+        }
+        const payload = {
+            type: 'simple',
+            name: trimmed,
+            settings: {
+                ...DEFAULT_SECTION_SETTINGS,
+                ...(perms.settings?.sectionSongsLimit != null ? { songsLimit: perms.settings.sectionSongsLimit } : {}),
+                ...(perms.settings?.sectionMustPlayLimit != null ? { mustPlayLimit: perms.settings.sectionMustPlayLimit } : {}),
+                ...VISIBILITY_SETTINGS[visibility ?? 'host'],
+            },
+        };
+        if (normalizedTime)
+            payload.time = normalizedTime;
+        if (insertBefore)
+            payload.insertBeforeSectionId = insertBefore._id;
+        const willSend = { eventId, payload };
+        if (note !== undefined)
+            willSend.thenUpdateSection = { payload: { note } };
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_create_section',
+            mutation: note !== undefined ? 'createSection, then updateSection (note)' : 'createSection',
+            message: `Review and confirm creating section "${trimmed}":`,
+            confirmToken,
+            target: eventId,
+            willSend,
+            context: { placedAfter: placedAfter ? sectionLabel(placedAfter) : 'start of timeline' },
+        });
+        if (gate)
+            return gate;
+        const created = (await client.gql(CREATE_SECTION, {
+            eventId,
+            payload,
+        })).createSection;
+        let noteResult;
+        if (note !== undefined) {
+            noteResult = (await client.gql(UPDATE_SECTION, {
+                eventId,
+                sectionId: created._id,
+                payload: { note },
+            })).updateSection?.note;
+        }
+        // Belt and braces: if Vibo ever ignores insertBeforeSectionId (it honoured
+        // it live), move the section into place. A stale re-read that doesn't show
+        // the new section yet is reported, not guessed at.
+        let placement = 'unverified';
+        const after = await fetchSections(client, eventId);
+        const order = after.map((s) => s._id);
+        if (order.includes(created._id) && (!placedAfter || order.includes(placedAfter._id))) {
+            const { moves } = planMoves(order, [created._id], placedAfter?._id ?? null);
+            for (const m of moves) {
+                await client.gql(REORDER_SECTIONS, { eventId, sourceSectionId: m.source, targetSectionId: m.target });
+            }
+            placement = moves.length ? 'fixed-by-reorder' : 'as-requested';
+        }
+        return minifiedResult({
+            ...created,
+            ...(note !== undefined ? { note: noteResult ?? note } : {}),
+            placedAfter: placedAfter ? sectionLabel(placedAfter) : null,
+            placement,
+        });
+    });
+    server.registerTool('vibo_delete_section', {
+        description: 'Delete a timeline section, with every song, answer and comment in it — this cannot be undone. The preview ' +
+            'names the section and how many songs and answered questions it holds. Sections of type "dontPlay" (the ' +
+            "DJ's do-not-play list) and \"headline\" (timeline dividers) are refused unless force:true. " +
+            CONFIRM_NOTE,
+        annotations: toolAnnotations({ title: 'Delete Vibo section', readOnly: false, destructive: true }),
+        inputSchema: z.object({
+            eventId: z.string().describe('Event id.'),
+            sectionId: z.string().describe('Section _id from vibo_list_sections.'),
+            force: z.boolean().optional().describe('Required to delete a "dontPlay" or "headline" section.'),
+            confirmToken: confirmTokenParam,
+        }),
+    }, async ({ eventId, sectionId, force, confirmToken }, ctx) => {
+        const section = findSection(await fetchSections(client, eventId), sectionId);
+        if (PROTECTED_TYPES.has(section.type) && !force) {
+            throw new McpToolError(`"${section.name}" is a ${section.type} section${section.type === 'dontPlay' ? " (the DJ's do-not-play list)" : ' (a timeline divider)'}; refusing to delete it. Nothing was sent.`, { hint: 'Pass force:true only if the user explicitly wants this section gone.' });
+        }
+        if (section.canRemove === false) {
+            throw new McpToolError(`Vibo reports you can't delete "${section.name}". Nothing was sent.`, {
+                hint: 'The DJ controls who may delete each section ("Who can delete section"); ask them to allow it or delete it.',
+            });
+        }
+        const summary = {
+            name: section.name,
+            type: section.type,
+            songsCount: section.songsCount,
+            questionsAnswered: `${section.answeredCount}/${section.questionsCount}`,
+        };
+        const vars = { eventId, sectionId };
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_delete_section',
+            mutation: 'removeSection',
+            message: `Delete section "${section.name}"? It holds ${section.songsCount} song(s) and ` +
+                `${section.answeredCount} of ${section.questionsCount} answered question(s). This cannot be undone.`,
+            confirmToken,
+            target: sectionId,
+            willSend: vars,
+            context: summary,
+        });
+        if (gate)
+            return gate;
+        const data = await client.gql(REMOVE_SECTION, vars);
+        if (data.removeSection !== true) {
+            throw new McpToolError(`Vibo did not confirm deleting "${section.name}" (removeSection returned ${String(data.removeSection)}).`, {
+                hint: 'Re-check with vibo_list_sections before retrying.',
+            });
+        }
+        return minifiedResult({ deleted: true, section: { _id: sectionId, ...summary } });
+    });
+    server.registerTool('vibo_reorder_sections', {
+        description: 'Move one or more timeline sections to directly after targetSectionId (omit it to move them to the start), ' +
+            'keeping the given order. Mirrors vibo_reorder_songs. Sends one reorderSections call per section that ' +
+            'actually moves. ' +
+            CONFIRM_NOTE,
+        annotations: toolAnnotations({ title: 'Reorder Vibo sections', readOnly: false, destructive: false }),
+        inputSchema: z.object({
+            eventId: z.string().describe('Event id.'),
+            sourceSectionIds: z.array(z.string()).min(1).describe('Section _ids to move, in the order they should end up.'),
+            targetSectionId: z.string().optional().describe('Place the moved sections right after this section _id; omit for the start.'),
+            confirmToken: confirmTokenParam,
+        }),
+    }, async ({ eventId, sourceSectionIds, targetSectionId, confirmToken }, ctx) => {
+        if (new Set(sourceSectionIds).size !== sourceSectionIds.length) {
+            throw new McpToolError('sourceSectionIds contains a duplicate.', { hint: 'List each section once.' });
+        }
+        if (targetSectionId !== undefined && sourceSectionIds.includes(targetSectionId)) {
+            throw new McpToolError('targetSectionId is also one of the sections being moved.', {
+                hint: 'Pick a target outside sourceSectionIds (the moved sections keep their given order).',
+            });
+        }
+        const [perms, sections] = await Promise.all([fetchEventPermissions(client, eventId), fetchSections(client, eventId)]);
+        const order = sections.map((s) => s._id);
+        const missing = missingIds([...sourceSectionIds, ...(targetSectionId ? [targetSectionId] : [])], order);
+        if (missing.length) {
+            throw new McpToolError(`Not in this event's timeline: ${missing.join(', ')}. Nothing was sent.`, {
+                hint: 'Get section ids from vibo_list_sections for the same eventId.',
+            });
+        }
+        assertCanWriteTimeline(perms, 'canHostReorderSections', 'reorder sections');
+        const byId = new Map(sections.map((s) => [s._id, s]));
+        const { moves, finalOrder } = planMoves(order, sourceSectionIds, targetSectionId ?? null);
+        const after = targetSectionId ? sectionLabel(byId.get(targetSectionId)) : 'start of timeline';
+        if (moves.length === 0) {
+            return minifiedResult({ changed: false, message: 'Those sections are already in that order.', after });
+        }
+        const calls = moves.map((m) => ({ sourceSectionId: m.source, targetSectionId: m.target }));
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_reorder_sections',
+            mutation: 'reorderSections',
+            message: `Review and confirm moving ${sourceSectionIds.length} section(s):`,
+            confirmToken,
+            target: eventId,
+            willSend: { eventId, calls },
+            context: { moving: sourceSectionIds.map((id) => byId.get(id).name), after },
+        });
+        if (gate)
+            return gate;
+        for (const c of calls) {
+            await client.gql(REORDER_SECTIONS, { eventId, ...c });
+        }
+        return minifiedResult({
+            changed: true,
+            callsSent: calls.length,
+            after,
+            newPositions: sourceSectionIds.map((id) => ({ ...sectionLabel(byId.get(id)), index: finalOrder.indexOf(id) })),
+        });
+    });
+}

package/dist/tools/session.js

@@ -7,7 +7,7 @@ import { GET_ME } from '../gql.js';
 // exist — a deployment without them should not wire it in.
 export function registerSessionTools(server, client) {
     server.registerTool('vibo_capture_session', {
-        description: "Capture your Vibo login from a signed-in web.vibodj.com browser tab via the fetchproxy bridge — for accounts that sign in with Apple/Google/Facebook (no password). Requires the fetchproxy browser extension installed and you signed into https://web.vibodj.com; approve the pair code shown on first use. The token is saved locally and reused on future calls.",
+        description: "Capture your Vibo login from a signed-in web.vibodj.com browser tab via ContextMint Bridge — for accounts that sign in with Apple/Google/Facebook (no password). Requires the ContextMint Bridge browser extension installed and you signed into https://web.vibodj.com; approve the pair code shown on first use. The token is saved locally and reused on future calls.",
         annotations: toolAnnotations({ title: 'Capture Vibo session (SSO)', readOnly: false, destructive: false }),
     }, async () => {
         const { accessToken, refreshToken } = await captureViboSession();

package/dist/tools/shared.js

@@ -37,10 +37,15 @@ export const CONFIRM_NOTE = 'Asks the user to confirm first: a confirmation prom
  * Gate a write behind a confirmation: an elicitation prompt where the client
  * can show one, else the two-phase confirm-token flow (MCP_CONFIRM_MODE).
  * `undefined` means proceed; anything else is the result to return unchanged.
- * Nothing here makes a network call, so phase 1 never writes.
+ * Nothing here makes a network call, so phase 1 never writes (a tool may READ
+ * before calling this, to validate ids or fill `context`).
  */
 export function confirmWrite(ctx, options) {
-    const preview = { action: options.mutation, willSend: options.willSend };
+    const preview = {
+        action: options.mutation,
+        willSend: options.willSend,
+        ...(options.context ? { context: options.context } : {}),
+    };
     return requireConfirmationWithFallback(ctx, confirmationFromEnv({
         action: options.tool.replace(/^vibo_/, 'vibo.'),
         message: options.message,
@@ -49,7 +54,7 @@ export function confirmWrite(ctx, options) {
         confirmToken: options.confirmToken,
         subject: () => ({
             target: options.target,
-            payload: options.payload ?? options.willSend,
+            payload: options.payload ?? (options.context ? { willSend: options.willSend, context: options.context } : options.willSend),
             preview,
         }),
     }));

package/dist/tools/song-management.js

@@ -1,10 +1,19 @@
 import { z } from 'zod';
 import { McpToolError, minifiedResult, confirmTokenParam, toolAnnotations } from '@chrischall/mcp-utils';
 import { REMOVE_SECTION_SONGS, UPDATE_SECTION_SONGS, MOVE_SECTION_SONGS, REORDER_SONGS } from '../gql.js';
+import { planMoves } from '../reorder.js';
 import { confirmWrite, CONFIRM_NOTE } from './shared.js';
+import { fetchSections, fetchEventPermissions, fetchSectionSongs, findSection, assertSongsInSection, isHost, } from './lookups.js';
+/**
+ * Vibo's song-comment limit, measured live: 90 is stored, 91 is refused with
+ * "Comment should be less then 90 characters". Counted in UTF-16 units (an
+ * emoji is 2), which is what String#length gives.
+ */
+export const SONG_COMMENT_MAX = 90;
 export function registerSongManagementTools(server, client) {
     server.registerTool('vibo_remove_song_from_section', {
-        description: 'Remove one or more songs from a section. ' + CONFIRM_NOTE,
+        description: 'Remove one or more songs from a section. Every id is checked against the section first; if any is not ' +
+            'there, nothing is sent and the missing ids are listed. ' + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Remove songs from Vibo section', readOnly: false, destructive: true }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
@@ -16,6 +25,10 @@ export function registerSongManagementTools(server, client) {
             confirmToken: confirmTokenParam,
         }),
     }, async ({ eventId, sectionId, songIds, confirmToken }, ctx) => {
+        // Vibo answers success:true for ids that aren't in the section and removes
+        // nothing, so check them ourselves before asking the user to confirm.
+        const songs = await fetchSectionSongs(client, eventId, sectionId);
+        assertSongsInSection(songIds, songs);
         const vars = { eventId, sectionId, songIds };
         const gate = await confirmWrite(ctx, {
             tool: 'vibo_remove_song_from_section',
@@ -24,6 +37,12 @@ export function registerSongManagementTools(server, client) {
             confirmToken,
             target: sectionId,
             willSend: vars,
+            context: {
+                songs: songIds.map((id) => {
+                    const s = songs.find((x) => x._id === id);
+                    return `${s.title ?? '?'} — ${s.artist ?? '?'}`;
+                }),
+            },
         });
         if (gate)
             return gate;
@@ -31,7 +50,9 @@ export function registerSongManagementTools(server, client) {
         return minifiedResult(data.removeSectionSongsV2);
     });
     server.registerTool('vibo_update_song', {
-        description: 'Update songs in a section: mark must-play, flag as do-not-play, and/or set a comment. Provide at least one field. ' + CONFIRM_NOTE,
+        description: 'Update songs in a section: mark must-play, flag as do-not-play, and/or set a comment. Provide at least one field. ' +
+            `A comment can be at most ${SONG_COMMENT_MAX} characters (Vibo's limit; emoji count double; checked before anything is sent). ` +
+            CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Update Vibo section songs', readOnly: false, destructive: false }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
@@ -42,7 +63,7 @@ export function registerSongManagementTools(server, client) {
                 .describe('Song _ids from vibo_get_section_songs.'),
             isMustPlay: z.boolean().optional(),
             isFlagged: z.boolean().optional().describe('mark do-not-play / flagged'),
-            comment: z.string().optional(),
+            comment: z.string().optional().describe(`Comment for the DJ, at most ${SONG_COMMENT_MAX} characters.`),
             confirmToken: confirmTokenParam,
         }),
     }, async ({ eventId, sectionId, songIds, isMustPlay, isFlagged, comment, confirmToken }, ctx) => {
@@ -58,6 +79,9 @@ export function registerSongManagementTools(server, client) {
                 hint: 'Pass isMustPlay, isFlagged, and/or comment to update the songs.',
             });
         }
+        if (comment !== undefined && comment.length > SONG_COMMENT_MAX) {
+            throw new McpToolError(`Comment is ${comment.length} characters; Vibo allows at most ${SONG_COMMENT_MAX}. Nothing was sent.`, { hint: `Shorten it to ${SONG_COMMENT_MAX} characters or fewer, or put the longer text in a section note.` });
+        }
         const vars = { eventId, sectionId, songIds, payload };
         const gate = await confirmWrite(ctx, {
             tool: 'vibo_update_song',
@@ -101,7 +125,12 @@ export function registerSongManagementTools(server, client) {
         return minifiedResult(data.moveSectionSongsV2);
     });
     server.registerTool('vibo_reorder_songs', {
-        description: 'Reorder songs within a section. ' + CONFIRM_NOTE,
+        description: 'Reorder songs within a section: move sourceSongIds (in the given order) to directly after targetSongId, ' +
+            'or to the top when it is omitted. Checks the ids against the section and, for a host, that the DJ allows ' +
+            "hosts to order this section's songs. That setting is OFF for every section a host creates and only the " +
+            'DJ can turn it on, so a host usually cannot reorder songs in sections they added. Sends one ' +
+            'reorderSongsBatch call per song that actually moves. ' +
+            CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Reorder Vibo section songs', readOnly: false, destructive: false }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
@@ -109,26 +138,57 @@ export function registerSongManagementTools(server, client) {
             sourceSongIds: z
                 .array(z.string())
                 .min(1)
-                .describe('Song _ids from vibo_get_section_songs.'),
+                .describe('Song _ids from vibo_get_section_songs, in the order they should end up.'),
             targetSongId: z
                 .string()
                 .optional()
-                .describe('place the moved songs after this song _id; omit for start'),
+                .describe('place the moved songs directly after this song _id; omit for the top'),
             confirmToken: confirmTokenParam,
         }),
     }, async ({ eventId, sectionId, sourceSongIds, targetSongId, confirmToken }, ctx) => {
-        const vars = { eventId, sectionId, sourceSongIds, targetSongId: targetSongId ?? null };
+        if (new Set(sourceSongIds).size !== sourceSongIds.length) {
+            throw new McpToolError('sourceSongIds contains a duplicate.', { hint: 'List each song once.' });
+        }
+        if (targetSongId !== undefined && sourceSongIds.includes(targetSongId)) {
+            throw new McpToolError('targetSongId is also one of the songs being moved.', {
+                hint: 'Pick a target outside sourceSongIds.',
+            });
+        }
+        const [perms, sections, songs] = await Promise.all([
+            fetchEventPermissions(client, eventId),
+            fetchSections(client, eventId),
+            fetchSectionSongs(client, eventId, sectionId),
+        ]);
+        const section = findSection(sections, sectionId);
+        // Vibo refuses a host's reorder with "Action is not allowed for user" when
+        // the section's "hosts can order songs" is off — which it is for every
+        // section a host creates (measured live; a host's attempt to turn it on
+        // is accepted and ignored). The web app hides drag handles there too.
+        if (isHost(perms) && section.settings?.canHostsOrderSongs === false) {
+            throw new McpToolError(`The DJ has turned off host song ordering for "${section.name}", so Vibo refuses reorders from hosts there. Nothing was sent.`, {
+                hint: "It's the section's canHostsOrderSongs setting. Vibo turns it off for sections a host creates, and only the DJ " +
+                    'can turn it on (a host update is ignored). Ask the DJ, or leave a comment on the song instead.',
+            });
+        }
+        assertSongsInSection([...sourceSongIds, ...(targetSongId ? [targetSongId] : [])], songs);
+        const { moves } = planMoves(songs.map((s) => s._id), sourceSongIds, targetSongId ?? null);
+        if (moves.length === 0) {
+            return minifiedResult({ changed: false, message: 'Those songs are already in that order.' });
+        }
+        const calls = moves.map((m) => ({ sourceSongIds: [m.source], targetSongId: m.target }));
         const gate = await confirmWrite(ctx, {
             tool: 'vibo_reorder_songs',
             mutation: 'reorderSongsBatch',
             message: 'Review and confirm this reorder:',
             confirmToken,
             target: sectionId,
-            willSend: vars,
+            willSend: { eventId, sectionId, calls },
         });
         if (gate)
             return gate;
-        const data = await client.gql(REORDER_SONGS, vars);
-        return minifiedResult(data.reorderSongsBatch);
+        for (const c of calls) {
+            await client.gql(REORDER_SONGS, { eventId, sectionId, ...c });
+        }
+        return minifiedResult({ changed: true, callsSent: calls.length });
     });
 }

package/dist/tools/songs.js

@@ -1,9 +1,17 @@
 import { z } from 'zod';
-import { minifiedResult, confirmTokenParam, toolAnnotations } from '@chrischall/mcp-utils';
+import { McpToolError, minifiedResult, confirmTokenParam, toolAnnotations } from '@chrischall/mcp-utils';
 import { viewArg, viewResponse } from '../view.js';
 import { GET_SECTION_SONGS, SEARCH_SONGS, ADD_SONG_TO_SECTION, TOGGLE_LIKE } from '../gql.js';
 import { annotateSearchResults } from '../song-search.js';
 import { limitSchema, skipSchema, pagination, confirmWrite, CONFIRM_NOTE } from './shared.js';
+import { fetchSectionSongs } from './lookups.js';
+/**
+ * Waits before each post-add re-read. Vibo's re-reads can be briefly stale
+ * (CLAUDE.md, "Write-verification re-reads can be cached"), so one miss is not
+ * proof; three spread over ~2s is. Exported so tests can zero them.
+ */
+export const addVerifyDelaysMs = [0, 700, 1500];
+const sleep = (ms) => (ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve());
 export function registerSongTools(server, client) {
     server.registerTool('vibo_get_section_songs', {
         description: "List the songs requested in a section, with who added each, like counts, must-play / do-not-play flags, comments, and streaming links. Sort by likesCount, createdAt, or title.",
@@ -95,7 +103,9 @@ export function registerSongTools(server, client) {
             'include viboSongId/title/artist when known). Before adding, check that result\'s ' +
             '`quality.confidence`: adding a `likely-not-original` result puts a cover, karaoke ' +
             'track or junk-metadata re-upload in front of a live DJ. If nothing looks original, ' +
-            'report the closest matches back rather than adding a best guess. ' + CONFIRM_NOTE,
+            'report the closest matches back rather than adding a best guess. After adding, re-reads the section and ' +
+            'reports an error if the song is not actually there (Vibo has answered added:true without adding). ' +
+            CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Add song to Vibo section', readOnly: false, destructive: false }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
@@ -130,7 +140,38 @@ export function registerSongTools(server, client) {
             sectionId,
             payload,
         });
-        return minifiedResult(data.addSongToSection);
+        const res = data.addSongToSection ?? {};
+        if (res.added === false) {
+            throw new McpToolError('Vibo did not add the song (added: false).', {
+                hint: 'It may already be in this section, be on the do-not-play list, or the section may be full. ' +
+                    'Check with vibo_get_section_songs.',
+            });
+        }
+        // Don't trust added:true alone — confirm the song is really in the section.
+        // With no id to match on, say so rather than claim a failure: a false
+        // "NOT added" invites a retry that would add the song twice.
+        if (!res.songId && !viboSongId) {
+            return minifiedResult({
+                ...res,
+                verified: false,
+                note: 'Vibo returned no songId and no viboSongId was passed, so the add could not be checked by re-reading. Check with vibo_get_section_songs before retrying.',
+            });
+        }
+        const isOurs = (s) => (!!res.songId && s._id === res.songId) || (!!viboSongId && s.viboSongId === viboSongId);
+        let found;
+        for (const delay of addVerifyDelaysMs) {
+            await sleep(delay);
+            found = (await fetchSectionSongs(client, eventId, sectionId)).find(isOurs);
+            if (found)
+                break;
+        }
+        if (!found) {
+            throw new McpToolError('Vibo answered added:true, but the song is not in the section when re-read, so it was NOT added.', {
+                hint: 'Retry once; if it still fails, add it in the Vibo app. Details: ' +
+                    JSON.stringify({ songId: res.songId ?? null, viboSongId: viboSongId ?? null, totalCount: res.totalCount }),
+            });
+        }
+        return minifiedResult({ ...res, verified: true, song: found });
     });
     server.registerTool('vibo_toggle_song_like', {
         description: 'Like or unlike a song in a section. ' + CONFIRM_NOTE,