TheSignup

Delete one empty one-off time slot from the signup, IMMEDIATELY. Get `slotId` from get_signup's `slots` (or get_slot_coverage). Refused, with nothing deleted: a slot that has registrations (also on a past date; remove the registrations first), a slot with an item scoped to it that has claims (remove_item with `release_claims`, or re-scope the item, first), and a date of a repeating schedule — one whose `seriesId` is set. To drop just one date of a schedule use cancel_occurrence instead. Items scoped to the slot that nobody has claimed are NOT deleted: they become whole-signup items (`scope: null`) available on every date. Notifies nobody. Returns `{ id, deleted: true }`. Deleting is by id, so it is safe to retry: a second call for the same slot is a not-found error and changes nothing.

remove_slot

Delete the signup's repeating schedule, IMMEDIATELY. Nothing participants see is destroyed: every date the schedule generated stays as an ordinary individual slot with its times, capacity and signups, and stops following the schedule (it can no longer be edited with the schedule tools, only with the slot tools). Cancelled dates stay cancelled. Notifies nobody. Returns `{ released, keptCancelled }`: how many dates were released (cancelled ones included) and how many of those were cancelled. After this the signup has no schedule, so create_slot_series can make a new one. Get `seriesId` from get_slot_coverage.

delete_slot_series

Delete one item from the signup, IMMEDIATELY. Get `itemId` from get_signup's `items`. An item people have claimed is refused as a conflict and nothing changes — unless `release_claims` is true, which deletes the item AND every claim on it and emails (and texts, when they consented) the people who held an Open claim that it is gone. Confirm with the person first: claims cannot be restored. A claim on a past or cancelled date is history: it is deleted with the item and its holder is not emailed. `message` (only used with `release_claims`) is added to the top of that email and text and is read by participants — it is not a private note. Returns `{ id, deleted: true, claims, claimants, notified }`: units that were claimed, people who held them, and who was emailed (`{ recipients, emails, sms }`); zeros for an unclaimed item. Deleting is by id, so a retry is a not-found error and emails nobody again. Fails if the account behind this connection has not verified its email address, because the call can email participants.

remove_item

Delete one Shift from the signup's repeating schedule and cancel its dates, IMMEDIATELY — there is no dry run and no second confirmation, so confirm with the person first. Name the Shift with `shiftIndex` (counting from 0; read it from get_slot_coverage) and, on a weekly schedule, `weekday` (0-6, 0 = Sunday; get_slot_coverage groups by shift without a weekday, so derive it from a date's `startTime` in the signup's timezone). Always pass `expectStart` and `expectEnd` (that Shift's current `HH:MM` start and end in the signup's timezone, from get_slot_coverage). Higher Shifts renumber down after a delete, so the same shiftIndex then names a different Shift — never retry without re-reading. If the Shift at that index has other times the call is refused as a conflict and nothing changes. Optionally `note` (a private note for organizers, never shown to participants) and `message` (added to the email and text participants receive). Every live date of that Shift is cancelled (kept, not deleted) and each participant registered on one is told it is cancelled by email, and by text when they gave a phone number and SMS consent; higher Shifts are renumbered down by one. Returns `{ confirmed, dates, affectedParticipants, notified }`: dates cancelled, registrations on them, and who was told. A Shift the schedule does not have, or the schedule's last Shift (use delete_slot_series instead), is refused and nothing changes. Fails if the account behind this connection has not verified its email address.

delete_shift

Edit one person's registration on a signup, immediately: supply only the fields to change (`name`, `email`, `phone`, `attendees`, `nameVisible`, `days`); at least one is required. `email` is written directly (no confirmation email to either address); another registration on this signup already using it is refused. `phone` null clears it, and a different number turns the person's SMS consent off. `attendees` counts the person plus anyone they bring, at most the signup's `maxAttendeesPerSignup`. `nameVisible` is whether their name shows on the public signup page. `days` is the COMPLETE list of event day ids they attend (ids are `days[].id` on get_signup), and a day you omit is REMOVED. Read the current set first: list_participants rows for this person with `eventDayId` set and `timeSlotId` and `itemId` both null, or the `days` returned by an earlier call of this tool. Removing attendance is allowed on any day, and `[]` removes all of it while their slots and items stay; repeating the same list changes nothing. Adding a day follows the Guest's rules: the signup must be accepting signups, a cancelled date is refused, a required day question must already be answered, and on a signup that requires a commitment no day can be added (attendance removed there cannot be re-added with `days`). Also refused: adding a day that has passed, and adding any day while the registration is no longer attending (`[]` still works). A day of another signup is not found. Any refusal changes nothing. Notifies nobody. `registrationId` is the registration's id: `signup.id` on a list_participants row (an Attend-only registration, one with no slot or item, has no list_participants row; `GET /v1/signups/{id}/registrations` lists it). A registration of another signup is not found. Returns the registration with its commitments. Wraps `PATCH /v1/signups/{id}/registrations/{rid}`.

update_registration

SENDS REAL EMAIL TO REAL PEOPLE. Every call delivers the subject and body you supply to the inboxes of everyone the Message Scope resolves to, immediately, with no undo and no dry-run. Ask the person you are acting for before you call it. Requires the `messages:send` scope, which exists only for this tool and this endpoint — holding `reminders:send` (fixed-body SMS to opted-in participants) or any read scope does NOT grant it. You choose WHO by naming a scope, not by naming people: `all` (everyone attending, no scopeId), `day` (everyone tied to one date, scopeId = that day's event_days id — read it off `eventDayId`/`slot.eventDayId` in list_participants), `shift` (one specific occurrence of a slot, scopeId = that time_slots id — read it off `timeSlotId`/`slot.id` in list_participants), `person` (one participant, scopeId = their registration id), `roster` (everyone who has ever held this repeating Shift, across every date it runs, scopeId = `<seriesId>#<shiftIndex>` — read seriesId/shiftIndex off get_slot_coverage), `gaps` (same people as roster, worded as an ask to cover a short date — same `<seriesId>#<shiftIndex>` scopeId). The server resolves the addresses; you cannot pass any, and an unrecognized field is rejected rather than ignored. Returns `{recipients, sent, failed}` — counts only, never addresses. One email per person however many commitments they hold. `{name}`, `{slot}` and `{item}` in the body are filled in per recipient. Metered per organization per UTC day in RECIPIENTS, not calls; a send that would cross the ceiling is refused whole and nothing goes out. Every call is written to the organization's audit log with your credential, the scope, the recipient count and the subject. Requires the account behind this connection to have a verified email address. To see who a scope covers BEFORE sending, read get_slot_coverage or list_participants under their own scopes. Wraps `POST /v1/signups/{id}/messages` — reference: https://thesignup.app/v1/docs.

message_participants

Move the repeating schedule's end date out to `newRangeEnd` (YYYY-MM-DD) and generate the dates the rule produces in the new stretch; existing dates are untouched and nobody is notified. The range can only grow, a range over 3660 days or more than 2000 dates is refused with a message saying so. Returns `{ series, slots }` — the dates just created. Extending creates new dates, so it needs a paid plan: on a free plan the call fails with "Repeating slots require the pro tier; current tier is free." — tell the person, don't retry. Nothing is written on any failure.

extend_slot_series

Live participant/slot/item fill counts and the list of unfilled slots and items. Use this to answer 'how full is X?' or 'which slots still need volunteers?' Computed per call, not cached.

get_signup_analytics

Identify which organizations this connection can act in and which scopes were granted. Call first to confirm context before doing real work. `organization` is the default org — the one used when a tool is called without `organization_id`. `organizations` lists every org reachable from this connection, each with the scopes in force there; pass one of their ids as `organization_id` on any tool to act in it. Also returns a `quotas` map keyed by scope (`ai:draft`, `messages:send`) with `used`, `limit`, `remaining`, and `period`. Unlimited quotas (Pro+) report `limit: null` and `remaining: null`. `messages:send` is never unlimited — it counts RECIPIENTS emailed today (UTC), so read `remaining` before calling message_participants on a large scope.

whoami

List every participant registered for the signup, with their slot/item bindings inlined. Returns an error if the signup isn't owned by the calling org.

list_participants

List recent signups owned by the calling org. Cursor-paginated (page size 1–100, default 20). There is no search endpoint — fetch and filter client-side, or use a known id with get_signup.

list_signups

List the signups the calling user has starred, upcoming only (past ones are omitted), soonest first. One entry per signup. `going: true` means the user also holds a spot on it: the entry then shows their earliest upcoming spot, and `status` and `spotsLeft` are null. `going: false` is a bookmark only: `status` is open, full or closed and `spotsLeft` is the places remaining (null means no limit). Starring never signs anyone up and organizers cannot see Stars. Use `url` to link the user to the signup, and register_self to sign them up.

list_starred

Move one of a registration's slot commitments to another slot on the same signup, immediately. `commitmentId` is `participant.id` on that person's list_participants row (or `commitments[].id` on the registration); it keeps its id. `toSlotId` is a slot id from get_signup_analytics (`slots[].id`) or get_slot_coverage. The new slot's day is added to the days they attend. Refused, with nothing moved, when the target slot is full (the message gives its numbers) or on a past date, when the person already holds the target slot, when the commitment is an item rather than a slot, or when the commitment is on a past or cancelled date. Notifies nobody. `registrationId` is the registration's id: `signup.id` on a list_participants row (an Attend-only registration, one with no slot or item, has no list_participants row; `GET /v1/signups/{id}/registrations` lists it). A registration of another signup is not found. Moving to the slot it is already on changes nothing. Returns the registration. Wraps `POST /v1/signups/{id}/registrations/{rid}/commitments/{commitmentId}/move`.

move_commitment

Re-time one date (Occurrence) of the repeating schedule: `slotId`, `start` and `end` as `HH:MM` in the signup's timezone (required even when unchanged), optionally `date` (YYYY-MM-DD) to move it to another day, `location` (only together with a move to another day), `note` (a private note for organizers, never shown to participants) and `message` (added to the email and text participants receive). Use this, not update_slot, for a date that belongs to a repeating schedule: the date keeps its place in the schedule (`seriesDate`, `shiftIndex`), is edited on its own from then on, and its signups and attendance move with it. Participants are emailed; `notified` says how many. A slot that is not part of a schedule is refused — use update_slot. Returns `{ slot, notified }`. Find `slotId` in get_slot_coverage's per-date cells. Fails if the account behind this connection has not verified its email address. Sending `date` may be refused ("forbidden") for people outside a pre-GA rollout — tell the person, don't retry.

move_occurrence

For a RECURRING signup, one entry per Shift — a repeating slot — rolled up across every date it runs: average fill, how many upcoming dates are staffed vs short (and which dates), unclaimed items, a cell per date, and the Regulars who usually take it. Use this to answer 'which Shift is chronically short?' or 'who normally covers Tuesday setup?'. Differs from get_signup_analytics, which is flat and event-wide and answers 'how full is this signup right now, and which individual slots and items still need people' — it has no notion of a Shift and cannot compare one date to another. Returns an empty list for a signup with no recurring slots; that is not an error. Regulars carry names and attendance counts and NO email addresses — reach someone via list_participants under its own scope.

get_slot_coverage

Transition a draft signup to `published`, opening it for registration. Idempotent — re-publishing is a no-op. Rejects (with a clear error) if the signup has been closed or canceled (a closed one is reopened with reopen_signup instead), or if the account behind this connection has not verified its email address.

publish_signup

Put a cancelled day back (one cancel_day answered with `kind: "day"`): `dayId`. Its slots, items and signups are live again. Notifies nobody. A day that is not cancelled comes back unchanged. A day with Shifts of a repeating schedule gets back the Shifts the same cancel took down (cancel_day answered `kind: "series_date"`): `restored` counts them, and `notRestored` lists `{ slotId, reason }` for any that could not come back (their Shift left the schedule, or their place is taken), which stay cancelled; use reconnect_occurrence once that is fixed. A Shift cancelled earlier on its own stays cancelled and is not listed. A day whose Shifts were all cancelled one by one, with no day cancellation, is refused — use reconnect_occurrence on each Shift (slot ids in get_slot_coverage). Returns `{ day, restored, notRestored }`. Find `dayId` in get_signup's `days`.

uncancel_day

Fetch one signup by id, including title, slug, status, dates, location, and metadata. Returns an error if the id isn't visible to the calling org.

get_signup

Sign up someone OTHER than the caller. Takes their name + email plus at least one slot or item pick. For self-service flows (signing up the calling user), use register_self instead. Returns a receipt of what was confirmed and what failed — NOT the participant's manage link or confirmation token; the participant receives their manage link by email, and this tool does not return it. Successful registrations send a confirmation email, which cannot be undone. No SMS is sent: the confirmation text requires the participant's own consent, which this tool cannot grant on their behalf. Organizer signup notifications are suppressed for this tool.

register_participant

Sign UP the calling user (not someone else). Name and email come from their account — no participant input required. Use this for self-service flows; for registering someone else, use register_participant. Can register for an open signup outside the connected organization. Successful registrations send a confirmation email and may notify the organizer; these messages cannot be undone. No SMS is sent: the confirmation text requires consent given at a signup form, which this tool does not collect.

register_self

Cancel a participant's registration. Destructive — removes the row immediately and fires a participant.canceled webhook. For participant-driven cancellation, prefer their confirmation-token link instead.

remove_participant

Take one person off the signup: every slot and item they hold and every day they attend is removed, immediately, and the registration is marked not attending. Notifies nobody. To remove only one of their slots or items use remove_participant. Refused, with nothing removed, while they hold a commitment on a past or cancelled date: that is history. `registrationId` is the registration's id: `signup.id` on a list_participants row (an Attend-only registration, one with no slot or item, has no list_participants row; `GET /v1/signups/{id}/registrations` lists it). A registration of another signup is not found. Safe to retry: a repeat returns the same end state. Returns the registration as it now stands. Wraps `DELETE /v1/signups/{id}/registrations/{rid}`.

remove_registration

Set the signup's `signupCloseDate` and, if the signup is `closed`, make it `published` again — the only way to reopen one (update_signup and set_signup_status cannot). `signupCloseDate` must be in the future: a past or present date is refused and nothing is written. ISO-8601: UTC / offset-bearing, or a naive local string (`2026-09-15T17:00`) read in the signup's own timezone. On a signup that is already `published` it only replaces `signupCloseDate` (earlier or later); on a `draft` it sets the date and the status stays `draft`. Registrations, slots and items are untouched. Notifies no participants and emits one `signup.updated` webhook, so a reopened signup is not announced to participants: use message_participants if people should know. Like publish_signup, it needs the account behind this connection to have a verified email address. Returns the signup in get_signup's shape, `days` included. WARNING: it also revives a signup that was CANCELLED (cancelling closes it), including one whose participants were told it is cancelled; the reopen sends them nothing, so message them if that matters. Calling it again with the same date leaves the same end state, so it is safe to retry.

reopen_signup

EMAIL the person their signup confirmation again, now, at the registration's address: what they hold, the days they attend, and their manage link. One email per call; it cannot be unsent, so do not call it twice for one request. Each counts against the organization's daily message-recipient ceiling. Works for an Attend-only registration; refused for a registration that is no longer attending. `registrationId` is the registration's id: `signup.id` on a list_participants row (an Attend-only registration, one with no slot or item, has no list_participants row; `GET /v1/signups/{id}/registrations` lists it). A registration of another signup is not found. Requires the account behind this connection to have a verified email address. Returns `{ sent: true }`. Wraps `POST /v1/signups/{id}/registrations/{rid}/resend_confirmation`.

resend_confirmation

Send SMS reminders to opted-in participants who haven't already received one for this signup. Returns counts (eligible/sent/failed). Subject to the org's SMS ceiling. Requires the account behind this connection to have a verified email address.

send_reminder

Set how many dates of the repeating schedule one person may take (`maxPerPerson`; 0 = no limit), on the schedule and on every date that has not been edited on its own. A cap below what someone already holds is kept — it limits further signups and removes nobody. Notifies nobody. Returns the updated `series`.

set_slot_series_max_per_person

Bookmark a signup for the calling user so it shows in list_starred and on their Agenda. Starring NEVER signs the user up and holds no spot; use register_self for that. A Star is private to the user: organizers cannot see who has starred their signup. Idempotent. Works on any published signup, including one outside the connected organization; a draft, closed or unknown signup is reported as not found, so a closed signup cannot be starred again. Takes `signupId`, the signup's id.

star_signup