Add support tickets that work with private threads

Members open a ticket from a panel in the ticket channel: one button per
category (a dropdown past five), then a short form. Each ticket is a private
thread named after the category, number and opener, with a first message
that mentions the category's staff role so its members join, and Claim and
Close buttons.

- Claim: staff (the category's role, or Manage Threads / Manage Server)
  take a ticket; the first message shows who has it.
- Close: the opener or staff close it, with an optional reason. The thread
  is locked and archived, and the log channel gets a summary and a .txt
  transcript of the whole thread.
- /ticket add|remove|claim|close inside a ticket; /tickets setup,
  /tickets category add|remove|list and /tickets panel for admins.
- Per-member limit on open tickets (default 1), per-server ticket numbers
  handed out atomically, a deleted thread closes its ticket.
- The dashboard asks the bot to post or refresh the panel through
  ticket_commands (LISTEN/NOTIFY, like music); the listener reconnects if
  the database connection drops.
- Setup warns about missing bot permissions in the ticket and log channels.

The flows live in internal/tickets behind small Discord and store
interfaces, with unit tests on fakes; the repo and the listener have
integration tests (-tags integration, TICKETS_TEST_DB).

Needs the ticket tables (velox-dashboard-api migration 000016_tickets).
.gitignore gains the /tldr benchmark rules so private chat exports and
benchmark results on disk can't be committed from this branch.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

.dockerignore

@@ -0,0 +1,7 @@
+.git
+.gitignore
+.env
+*.md
+Dockerfile
+docker-compose*.yml
+.dockerignore

.gitignore

@@ -1,3 +1,10 @@
-.env
+*.env
 .cursor
 tmp/
+
+# Local /tldr benchmark: chat dumps and results never get committed.
+bench-out/
+internal/tldr/tldrbench/private/
+
+# Real chat dumps used by the benchmark never get committed.
+internal/tldr/tldrbench/testdata/private/

Dockerfile

@@ -0,0 +1,21 @@
+# Build stage
+FROM golang:1.26.1-alpine AS builder
+
+WORKDIR /app
+
+COPY go.mod go.sum ./
+RUN go mod download
+
+COPY . .
+RUN CGO_ENABLED=0 GOOS=linux go build -o /velox-bot .
+
+# Run stage
+FROM alpine:3.19
+
+RUN apk add --no-cache ca-certificates tzdata
+
+WORKDIR /app
+
+COPY --from=builder /velox-bot .
+
+ENTRYPOINT ["./velox-bot"]

README.md

@@ -0,0 +1,136 @@
+# Velox Bot
+
+A Discord bot written in Go with a PostgreSQL backing store.
+
+It currently includes:
+
+- Fun commands (`/ping`, `/joke`, `/dice`, `/rps`, …)
+- Leveling system (opt-in per server via `/slvl toggle`)
+- Meeting rooms (voice lobby → auto-created temporary voice channels)
+- Scheduling (1:1 sessions with DM invites + reaction-based accept/decline/reschedule)
+- Projects (list/create projects + helpers)
+- Support tickets (a panel with categories, a private thread per ticket, claim/close, transcripts to a log channel)
+- Music (Lavalink-powered `/play`, `/queue`, `/volume`)
+- Twitch live notifications (per-guild `/config` setup)
+- Welcome messages, DMs, and default role assignment (per-guild `/config` setup)
+- Focused moderation tools (`/moderation purge|timeout|untimeout|kick|ban|unban|slowmode`)
+- Server logging system (edits/deletes/joins/leaves/roles/ban/kick/mod actions)
+
+When the bot is added to a new server for the first time, toggleable systems are defaulted to **disabled** and a setup DM is sent to the inviter (or server owner fallback) with enable instructions.
+
+## Requirements
+
+- Go (see `go.mod`)
+- PostgreSQL 16+ (or use the provided `docker-compose.yml`)
+- (Optional) [Air](https://github.com/air-verse/air) for live reload during development
+- (Optional) Lavalink if you want music commands
+
+## Configuration
+
+The app loads environment variables from `.env` (see `internal/config/config.go`).
+
+Required:
+
+- `BOT_TOKEN`: Discord bot token
+- `APP_ID`: Discord application ID
+- `GUILD_ID`: Target guild/server ID (commands are registered per-guild)
+- `DB_HOST`: Postgres connection string (pgx), e.g. `postgres://velox:velox_pwd@localhost:5432/velox?sslmode=disable`
+
+Optional (music):
+
+- `LAVALINK_HOST`: Lavalink WebSocket/HTTP host (depends on your Lavalink setup)
+- `LAVALINK_PASSWORD`: Lavalink password
+
+Optional (Twitch live notifications):
+
+- `TWITCH_CLIENT_ID`: Twitch Client ID used to query live status
+
+## Database setup
+
+If you use the compose file:
+
+```bash
+docker compose up -d
+```
+
+Then apply the schema:
+
+```bash
+psql "postgres://velox:velox_pwd@localhost:5432/velox?sslmode=disable" -f schema.sql
+```
+
+## Run
+
+Plain Go:
+
+```bash
+go run .
+```
+
+With live reload (Air):
+
+```bash
+air
+```
+
+If you use `just`, a small workflow is included:
+
+```bash
+just up      # start postgres
+just start   # start postgres + run air
+just down    # stop postgres
+```
+
+## Commands (high-level)
+
+- **Fun**
+  - `/ping`, `/joke [type]`, `/coinflip`, `/dice <expr>`
+  - `/rps <hand>`, `/rpsstats`, `/rpsleaderboard` (server only)
+- **Help**
+  - `/help` (sends a DM with command reference)
+- **Leveling**
+  - `/slvl ...` admin/config
+  - `/rank`, `/leaderboard`, `/rewards`
+- **Meetings** (**Manage Server**)
+  - `/meeting set-lobby`, `/meeting lock`, `/meeting lock-private`, `/meeting unlock`, `/meeting invite`, `/meeting uninvite`
+- **Timezone**
+  - `/timezone set`, `/timezone show`
+- **Scheduling**
+  - `/schedule create`, `/schedule list`, `/schedule reschedule`
+- **Projects**
+  - `/projects list`, `/projects create`, `/projects add-helper`
+- **Tickets**
+  - `/tickets setup channel:#tickets [log-channel] [staff-role]` — Where tickets open and closed ones are logged (**Manage Server**)
+  - `/tickets category add|remove|list` — One panel button per category, each with its own staff role (**Manage Server**)
+  - `/tickets panel` — Post or refresh the panel (**Manage Server**)
+  - `/ticket add`, `/ticket close [reason]` — Opener or staff; `/ticket claim`, `/ticket remove` — staff
+  - The bot needs View Channel, Send Messages, Embed Links, Create Private Threads, Send Messages in Threads and Manage Threads in the ticket channel, and Attach Files in the log channel. Give the staff role Manage Threads there too, so staff see every ticket.
+- **Music** (requires **DJ** role)
+  - `/play`, `/queue`, `/volume`
+- **Moderation** (focused + practical)
+  - `/moderation purge amount:<1-100>` — Fast recent message cleanup (**Manage Messages**)
+  - `/moderation timeout user:@someone duration:<10m|1h|...> [reason]` — Temporary member timeout (**Moderate Members**)
+  - `/moderation kick user:@someone [reason]` — Kick member (**Kick Members**)
+  - `/moderation ban user:@someone [delete_days] [reason]` — Ban member (**Ban Members**)
+  - `/moderation unban user_id:<id> [reason]` — Unban by user ID (**Ban Members**)
+  - `/moderation untimeout user:@someone [reason]` — Remove timeout (**Moderate Members**)
+  - `/moderation slowmode channel:#channel seconds:<0-21600>` — Control channel flood (**Manage Channels**)
+- **Twitch live notifications** (**Manage Server**)
+  - `/config addstreamer username:<twitch-name>` — Add a streamer for notifications
+  - `/config removestreamer username:<twitch-name>` — Remove a streamer
+  - `/config settwitchnotificationchannel channel:#channel` — Channel for live pings
+- **Welcome / onboarding** (**Manage Server**)
+  - `/config setwelcomechannel channel:#channel` — Channel for welcome messages
+  - `/config setwelcomemessage message:"..."` — Server welcome template (supports `{user}`, `{server}`)
+  - `/config setwelcomedm message:"..."` — DM welcome template (supports `{user}`, `{server}`)
+  - `/config setwelcomegif url:<image-url>` — GIF/image used in welcome embed
+  - `/config setdefaultrole role:@role` — Role automatically granted on join
+- **Logging** (**Manage Server**)
+  - `/config setlogchannel channel:#channel` — Set where logs are sent
+  - `/config enablelogging` — Enable event/moderation logs
+  - `/config disablelogging` — Disable event/moderation logs
+
+## Notes
+
+- Slash commands are registered to the configured `GUILD_ID` on startup.
+- Some features require server permissions (e.g. **Manage Server**) or roles (e.g. **DJ** for music).

docker-compose.yml

@@ -1,5 +1,3 @@
-version: "3.9"
-
 services:
   db:
     image: postgres:16
@@ -19,5 +17,20 @@ services:
       timeout: 5s
       retries: 5
 
+  bot:
+    build: .
+    container_name: velox-bot
+    restart: unless-stopped
+    env_file: .env
+    environment:
+      DB_HOST: ${DB_HOST:-postgres://velox:velox_pwd@db:5432/velox?sslmode=disable}
+      LAVALINK_HOST: ${LAVALINK_HOST:-ws://lavalink:2333}
+      LAVALINK_PASSWORD: ${LAVALINK_PASSWORD:-youshallnotpass}
+    depends_on:
+      db:
+        condition: service_healthy
+    networks:
+      - default
+
 volumes:
   velox_pgdata:

go.mod

@@ -15,6 +15,7 @@ require (
 require (
 	github.com/disgoorg/json v1.2.0 // indirect
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
+	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect

go.sum

@@ -13,6 +13,8 @@ github.com/fogleman/gg v1.3.0 h1:/7zJX8F6AaYQc57WQCyN9cAIz+4bCJGO9B+dyW29am8=
 github.com/fogleman/gg v1.3.0/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=

internal/bot/bot.go

@@ -1,11 +1,15 @@
 package bot
 
 import (
+	"context"
 	"log"
+	"time"
 	"velox-bot/internal/commands"
+	"velox-bot/internal/db/repos/musicrepo"
 	"velox-bot/internal/db/services"
 	"velox-bot/internal/events"
 	"velox-bot/internal/music"
+	"velox-bot/internal/tickets"
 
 	"github.com/bwmarrin/discordgo"
 )
@@ -17,11 +21,13 @@ type Bot struct {
 	Commands           []*discordgo.ApplicationCommand
 	registeredCommands []*discordgo.ApplicationCommand
 	Services           *services.Services
+	MusicRepo          *musicrepo.Repo
+	DBHost             string
 	LavalinkHost       string
 	LavalinkPass       string
 }
 
-func NewBot(token, appID, guildID, lavalinkHost, lavalinkPass string, cmds []*discordgo.ApplicationCommand, services *services.Services) (*Bot, error) {
+func NewBot(token, appID, guildID, lavalinkHost, lavalinkPass string, cmds []*discordgo.ApplicationCommand, services *services.Services, musicRepo *musicrepo.Repo, dbHost string) (*Bot, error) {
 	session, err := discordgo.New("Bot " + token)
 	if err != nil {
 		return nil, err
@@ -30,14 +36,15 @@ func NewBot(token, appID, guildID, lavalinkHost, lavalinkPass string, cmds []*di
 	// Intents needed for:
 	// - InteractionCreate (slash commands): Guilds
 	// - MessageCreate (leveling): GuildMessages
+	// - GuildMemberAdd (welcome messages): GuildMembers
 	// - VoiceStateUpdate (meeting lobby): GuildVoiceStates
-	// - MessageReactionAdd (scheduling via reactions): GuildMessageReactions + DirectMessageReactions
 	session.Identify.Intents = discordgo.IntentsGuilds |
+		discordgo.IntentsGuildBans |
+		discordgo.IntentsGuildMembers |
 		discordgo.IntentsGuildMessages |
+		discordgo.IntentsMessageContent |
 		discordgo.IntentsGuildVoiceStates |
-		discordgo.IntentsGuildMessageReactions |
-		discordgo.IntentsDirectMessages |
-		discordgo.IntentsDirectMessageReactions
+		discordgo.IntentsDirectMessages
 
 	return &Bot{
 		Session:      session,
@@ -45,6 +52,8 @@ func NewBot(token, appID, guildID, lavalinkHost, lavalinkPass string, cmds []*di
 		GuildID:      guildID,
 		Commands:     cmds,
 		Services:     services,
+		MusicRepo:    musicRepo,
+		DBHost:       dbHost,
 		LavalinkHost: lavalinkHost,
 		LavalinkPass: lavalinkPass,
 	}, nil
@@ -55,7 +64,25 @@ func (b *Bot) Start() error {
 		return err
 	}
 
-	_ = music.Init(b.Session, b.AppID, b.LavalinkHost, b.LavalinkPass)
+	_ = music.Init(b.Session, b.MusicRepo, b.AppID, b.LavalinkHost, b.LavalinkPass)
+
+	go func() {
+		if err := music.StartCommandListener(context.Background(), b.DBHost, b.MusicRepo); err != nil {
+			log.Printf("music: command listener stopped: %v", err)
+		}
+	}()
+
+	if st := tickets.Default(); st != nil {
+		go func() {
+			// The connection can drop (database restart, network blip):
+			// reconnect instead of silently ignoring the dashboard from then on.
+			for {
+				err := tickets.StartCommandListener(context.Background(), b.DBHost, b.Session, st)
+				log.Printf("tickets: command listener stopped: %v (retrying in 10s)", err)
+				time.Sleep(10 * time.Second)
+			}
+		}()
+	}
 
 	b.registeredCommands = make([]*discordgo.ApplicationCommand, len(b.Commands))
 	for _, cmd := range b.Commands {
@@ -73,6 +100,48 @@ func (b *Bot) Start() error {
 		events.HandleMessageCreate(s, m, b.Services)
 	})
 
+	b.Session.AddHandler(func(s *discordgo.Session, m *discordgo.GuildMemberAdd) {
+		events.HandleBotAddedOnGuild(s, m, b.Services)
+
+		// Ignore bot members for welcome/log onboarding of normal users.
+		if m != nil && m.Member != nil && m.User != nil && m.User.Bot {
+			return
+		}
+
+		events.HandleGuildMemberAdd(s, m, b.Services)
+		events.HandleGuildMemberAddLog(s, m, b.Services)
+	})
+
+	b.Session.AddHandler(func(s *discordgo.Session, m *discordgo.GuildMemberRemove) {
+		events.HandleGuildMemberRemoveLog(s, m, b.Services)
+	})
+
+	b.Session.AddHandler(func(s *discordgo.Session, m *discordgo.GuildMemberUpdate) {
+		events.HandleGuildMemberUpdateLog(s, m, b.Services)
+	})
+
+	b.Session.AddHandler(func(s *discordgo.Session, m *discordgo.MessageUpdate) {
+		events.HandleMessageUpdateLog(s, m, b.Services)
+	})
+
+	b.Session.AddHandler(func(s *discordgo.Session, m *discordgo.MessageDelete) {
+		events.HandleMessageDeleteLog(s, m, b.Services)
+	})
+
+	b.Session.AddHandler(func(s *discordgo.Session, m *discordgo.GuildBanAdd) {
+		events.HandleGuildBanAddLog(s, m, b.Services)
+	})
+
+	b.Session.AddHandler(func(s *discordgo.Session, m *discordgo.GuildBanRemove) {
+		events.HandleGuildBanRemoveLog(s, m, b.Services)
+	})
+
+	b.Session.AddHandler(func(s *discordgo.Session, t *discordgo.ThreadDelete) {
+		if st := tickets.Default(); st != nil && t.Channel != nil {
+			tickets.ThreadDeleted(context.Background(), st, t.ID)
+		}
+	})
+
 	b.Session.AddHandler(func(s *discordgo.Session, vs *discordgo.VoiceStateUpdate) {
 		events.HandleVoiceStateUpdate(s, vs, b.Services)
 		music.OnVoiceStateUpdate(vs)
@@ -82,11 +151,8 @@ func (b *Bot) Start() error {
 		music.OnVoiceServerUpdate(ev)
 	})
 
-	b.Session.AddHandler(func(s *discordgo.Session, r *discordgo.MessageReactionAdd) {
-		events.HandleMessageReactionAdd(s, r, b.Services)
-	})
-
 	events.StartScheduleReminderLoop(b.Session, b.Services)
+	events.StartTwitchLiveLoop(b.Session, b.Services)
 
 	return nil
 }

internal/commands/commands.go

@@ -1,13 +1,17 @@
 package commands
 
 import (
+	"strings"
+	"velox-bot/internal/commands/config"
 	"velox-bot/internal/commands/fun"
 	"velox-bot/internal/commands/help"
 	cmdlevel "velox-bot/internal/commands/level"
 	"velox-bot/internal/commands/meeting"
+	"velox-bot/internal/commands/moderation"
 	cmdmusic "velox-bot/internal/commands/music"
 	"velox-bot/internal/commands/projects"
 	"velox-bot/internal/commands/schedule"
+	cmdtickets "velox-bot/internal/commands/tickets"
 	"velox-bot/internal/commands/timezone"
 	"velox-bot/internal/music"
 
@@ -30,10 +34,15 @@ var AllCommands = []*discordgo.ApplicationCommand{
 	cmdmusic.Play,
 	cmdmusic.Queue,
 	cmdmusic.Volume,
+	cmdmusic.Music,
 	meeting.Meeting,
+	moderation.Moderation,
 	timezone.Timezone,
 	schedule.Schedule,
 	projects.Projects,
+	config.Config,
+	cmdtickets.Tickets,
+	cmdtickets.Ticket,
 }
 
 var handlers = map[string]func(s *discordgo.Session, i *discordgo.InteractionCreate){
@@ -50,12 +59,17 @@ var handlers = map[string]func(s *discordgo.Session, i *discordgo.InteractionCre
 	"leaderboard":    cmdlevel.LeaderboardHandler,
 	"rewards":        cmdlevel.RewardsHandler,
 	"meeting":        meeting.MeetingHandler,
+	"moderation":     moderation.ModerationHandler,
 	"timezone":       timezone.TimezoneHandler,
 	"schedule":       schedule.ScheduleHandler,
 	"projects":       projects.ProjectsHandler,
 	"play":           cmdmusic.PlayHandler,
 	"queue":          cmdmusic.QueueHandler,
 	"volume":         cmdmusic.VolumeHandler,
+	"music":          cmdmusic.MusicHandler,
+	"config":         config.ConfigHandler,
+	"tickets":        cmdtickets.TicketsHandler,
+	"ticket":         cmdtickets.TicketHandler,
 }
 
 func HandleInteraction(s *discordgo.Session, i *discordgo.InteractionCreate) {
@@ -66,8 +80,26 @@ func HandleInteraction(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		}
 	case discordgo.InteractionMessageComponent:
 		data := i.MessageComponentData()
-		if len(data.CustomID) >= 6 && data.CustomID[:6] == "music:" {
+		switch {
+		case strings.HasPrefix(data.CustomID, "music:"):
 			music.HandleComponent(s, i)
+		case strings.HasPrefix(data.CustomID, "schedule:"):
+			schedule.HandleComponent(s, i)
+		case strings.HasPrefix(data.CustomID, "projects:"):
+			projects.HandleComponent(s, i)
+		case strings.HasPrefix(data.CustomID, "tickets:"):
+			cmdtickets.HandleComponent(s, i)
+		}
+	case discordgo.InteractionModalSubmit:
+		data := i.ModalSubmitData()
+		switch {
+		case strings.HasPrefix(data.CustomID, "schedule:"):
+			schedule.HandleModalSubmit(s, i)
+		case strings.HasPrefix(data.CustomID, "projects:"):
+			projects.HandleModalSubmit(s, i)
+		case strings.HasPrefix(data.CustomID, "tickets:"):
+			cmdtickets.HandleModalSubmit(s, i)
 		}
 	}
+
 }

internal/commands/config/public/config.go

@@ -0,0 +1,578 @@
+package public
+
+import (
+	"context"
+	"log"
+	"strconv"
+	"strings"
+
+	"velox-bot/internal/db/services"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+var Config = &discordgo.ApplicationCommand{
+	Name:        "config",
+	Description: "Server configuration",
+	Options: []*discordgo.ApplicationCommandOption{
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "addstreamer",
+			Description: "Add a Twitch streamer for live notifications",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionString,
+					Name:        "username",
+					Description: "Twitch username (without https://)",
+					Required:    true,
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "removestreamer",
+			Description: "Remove a Twitch streamer from live notifications",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionString,
+					Name:        "username",
+					Description: "Twitch username to remove",
+					Required:    true,
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "settwitchnotificationchannel",
+			Description: "Set the channel for Twitch live notifications",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:         discordgo.ApplicationCommandOptionChannel,
+					Name:         "channel",
+					Description:  "Text channel for notifications",
+					Required:     true,
+					ChannelTypes: []discordgo.ChannelType{discordgo.ChannelTypeGuildText, discordgo.ChannelTypeGuildNews},
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "setwelcomechannel",
+			Description: "Set the channel for welcome messages",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:         discordgo.ApplicationCommandOptionChannel,
+					Name:         "channel",
+					Description:  "Text channel for welcomes",
+					Required:     true,
+					ChannelTypes: []discordgo.ChannelType{discordgo.ChannelTypeGuildText, discordgo.ChannelTypeGuildNews},
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "setwelcomemessage",
+			Description: "Set the welcome message template shown in the server",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionString,
+					Name:        "message",
+					Description: "Use {user} where the new member mention should appear",
+					Required:    true,
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "setwelcomedm",
+			Description: "Set the welcome DM template sent to new members",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionString,
+					Name:        "message",
+					Description: "Use {user} where the new member mention should appear",
+					Required:    true,
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "setwelcomegif",
+			Description: "Set the GIF/image URL used in welcome messages",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionString,
+					Name:        "url",
+					Description: "Direct image or GIF URL",
+					Required:    true,
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "setdefaultrole",
+			Description: "Set the default role given to new members",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionRole,
+					Name:        "role",
+					Description: "Role to assign on join",
+					Required:    true,
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "setlogchannel",
+			Description: "Set the moderation log channel",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:         discordgo.ApplicationCommandOptionChannel,
+					Name:         "channel",
+					Description:  "Text channel for logs",
+					Required:     true,
+					ChannelTypes: []discordgo.ChannelType{discordgo.ChannelTypeGuildText, discordgo.ChannelTypeGuildNews},
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "enablelogging",
+			Description: "Enable server logging events",
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "disablelogging",
+			Description: "Disable server logging events",
+		},
+	},
+}
+
+func ConfigHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if i.GuildID == "" {
+		respondEphemeral(s, i, "This command can only be used in a server.")
+		return
+	}
+	if i.Member == nil || (i.Member.Permissions&discordgo.PermissionManageGuild) == 0 {
+		respondEphemeral(s, i, "You need the **Manage Server** permission to use this.")
+		return
+	}
+	if services.Global == nil {
+		respondEphemeral(s, i, "Configuration services are not available.")
+		return
+	}
+
+	data := i.ApplicationCommandData()
+	if len(data.Options) == 0 {
+		respondEphemeral(s, i, "Missing subcommand.")
+		return
+	}
+
+	switch data.Options[0].Name {
+	case "addstreamer":
+		log.Printf("twitch: /config addstreamer invoked by %s in guild %s", i.Member.User.ID, i.GuildID)
+		handleAddStreamer(s, i)
+	case "removestreamer":
+		log.Printf("twitch: /config removestreamer invoked by %s in guild %s", i.Member.User.ID, i.GuildID)
+		handleRemoveStreamer(s, i)
+	case "settwitchnotificationchannel":
+		log.Printf("twitch: /config settwitchnotificationchannel invoked by %s in guild %s", i.Member.User.ID, i.GuildID)
+		handleSetChannel(s, i)
+	case "setwelcomechannel":
+		log.Printf("welcome: /config setwelcomechannel invoked by %s in guild %s", i.Member.User.ID, i.GuildID)
+		handleSetWelcomeChannel(s, i)
+	case "setwelcomemessage":
+		log.Printf("welcome: /config setwelcomemessage invoked by %s in guild %s", i.Member.User.ID, i.GuildID)
+		handleSetWelcomeMessage(s, i)
+	case "setwelcomedm":
+		log.Printf("welcome: /config setwelcomedm invoked by %s in guild %s", i.Member.User.ID, i.GuildID)
+		handleSetWelcomeDM(s, i)
+	case "setwelcomegif":
+		log.Printf("welcome: /config setwelcomegif invoked by %s in guild %s", i.Member.User.ID, i.GuildID)
+		handleSetWelcomeGIF(s, i)
+	case "setdefaultrole":
+		log.Printf("defaultrole: /config setdefaultrole invoked by %s in guild %s", i.Member.User.ID, i.GuildID)
+		handleSetDefaultRole(s, i)
+	case "setlogchannel":
+		log.Printf("log: /config setlogchannel invoked by %s in guild %s", i.Member.User.ID, i.GuildID)
+		handleSetLogChannel(s, i)
+	case "enablelogging":
+		log.Printf("log: /config enablelogging invoked by %s in guild %s", i.Member.User.ID, i.GuildID)
+		handleSetLoggingEnabled(s, i, true)
+	case "disablelogging":
+		log.Printf("log: /config disablelogging invoked by %s in guild %s", i.Member.User.ID, i.GuildID)
+		handleSetLoggingEnabled(s, i, false)
+	default:
+		respondEphemeral(s, i, "Unknown subcommand.")
+	}
+}
+
+func handleAddStreamer(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid guild ID.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var username string
+	for _, o := range opt.Options {
+		if o.Name == "username" {
+			username = strings.TrimSpace(o.StringValue())
+		}
+	}
+	username = strings.TrimPrefix(username, "https://www.twitch.tv/")
+	username = strings.TrimPrefix(username, "http://www.twitch.tv/")
+	username = strings.TrimPrefix(username, "twitch.tv/")
+	username = strings.TrimSpace(username)
+
+	if username == "" {
+		respondEphemeral(s, i, "Username cannot be empty.")
+		return
+	}
+
+	if err := services.Global.Twitch.UpsertStreamer(context.Background(), guildID, username); err != nil {
+		respondEphemeral(s, i, "Failed to add streamer.")
+		return
+	}
+
+	respondEphemeral(s, i, "Added `"+username+"` for Twitch live notifications.")
+}
+
+func handleRemoveStreamer(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid guild ID.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var username string
+	for _, o := range opt.Options {
+		if o.Name == "username" {
+			username = strings.TrimSpace(o.StringValue())
+		}
+	}
+	username = strings.TrimSpace(username)
+	if username == "" {
+		respondEphemeral(s, i, "Username cannot be empty.")
+		return
+	}
+
+	if err := services.Global.Twitch.RemoveStreamer(context.Background(), guildID, username); err != nil {
+		respondEphemeral(s, i, "Failed to remove streamer.")
+		return
+	}
+
+	respondEphemeral(s, i, "Removed `"+username+"` from Twitch live notifications.")
+}
+
+func handleSetChannel(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid guild ID.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var chOpt *discordgo.ApplicationCommandInteractionDataOption
+	for _, o := range opt.Options {
+		if o.Name == "channel" {
+			chOpt = o
+			break
+		}
+	}
+	if chOpt == nil {
+		respondEphemeral(s, i, "Missing channel option.")
+		return
+	}
+
+	ch := chOpt.ChannelValue(s)
+	if ch == nil {
+		respondEphemeral(s, i, "Invalid channel.")
+		return
+	}
+
+	chID, err := strconv.ParseInt(ch.ID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid channel ID.")
+		return
+	}
+
+	if err := services.Global.Twitch.SetNotificationChannel(context.Background(), guildID, chID); err != nil {
+		respondEphemeral(s, i, "Failed to set notification channel.")
+		return
+	}
+
+	respondEphemeral(s, i, "Twitch notifications will be sent to "+ch.Mention()+".")
+}
+
+func handleSetWelcomeChannel(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if services.Global.Welcome == nil {
+		respondEphemeral(s, i, "Welcome configuration is not available.")
+		return
+	}
+
+	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid guild ID.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var chOpt *discordgo.ApplicationCommandInteractionDataOption
+	for _, o := range opt.Options {
+		if o.Name == "channel" {
+			chOpt = o
+			break
+		}
+	}
+	if chOpt == nil {
+		respondEphemeral(s, i, "Missing channel option.")
+		return
+	}
+
+	ch := chOpt.ChannelValue(s)
+	if ch == nil {
+		respondEphemeral(s, i, "Invalid channel.")
+		return
+	}
+
+	chID, err := strconv.ParseInt(ch.ID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid channel ID.")
+		return
+	}
+
+	if err := services.Global.Welcome.SetChannel(context.Background(), guildID, chID); err != nil {
+		respondEphemeral(s, i, "Failed to set welcome channel.")
+		return
+	}
+
+	respondEphemeral(s, i, "Welcome messages will be sent to "+ch.Mention()+".")
+}
+
+func handleSetWelcomeMessage(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if services.Global.Welcome == nil {
+		respondEphemeral(s, i, "Welcome configuration is not available.")
+		return
+	}
+
+	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid guild ID.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var msg string
+	for _, o := range opt.Options {
+		if o.Name == "message" {
+			msg = strings.TrimSpace(o.StringValue())
+		}
+	}
+	if msg == "" {
+		respondEphemeral(s, i, "Message cannot be empty.")
+		return
+	}
+
+	if err := services.Global.Welcome.SetMessage(context.Background(), guildID, msg); err != nil {
+		respondEphemeral(s, i, "Failed to set welcome message.")
+		return
+	}
+
+	respondEphemeral(s, i, "Welcome message updated.")
+}
+
+func handleSetWelcomeDM(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if services.Global.Welcome == nil {
+		respondEphemeral(s, i, "Welcome configuration is not available.")
+		return
+	}
+
+	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid guild ID.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var msg string
+	for _, o := range opt.Options {
+		if o.Name == "message" {
+			msg = strings.TrimSpace(o.StringValue())
+		}
+	}
+	if msg == "" {
+		respondEphemeral(s, i, "DM message cannot be empty.")
+		return
+	}
+
+	if err := services.Global.Welcome.SetDM(context.Background(), guildID, msg); err != nil {
+		respondEphemeral(s, i, "Failed to set welcome DM.")
+		return
+	}
+
+	respondEphemeral(s, i, "Welcome DM updated.")
+}
+
+func handleSetWelcomeGIF(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if services.Global.Welcome == nil {
+		respondEphemeral(s, i, "Welcome configuration is not available.")
+		return
+	}
+
+	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid guild ID.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var url string
+	for _, o := range opt.Options {
+		if o.Name == "url" {
+			url = strings.TrimSpace(o.StringValue())
+		}
+	}
+	if url == "" {
+		respondEphemeral(s, i, "URL cannot be empty.")
+		return
+	}
+
+	if err := services.Global.Welcome.SetGIF(context.Background(), guildID, url); err != nil {
+		respondEphemeral(s, i, "Failed to set welcome GIF.")
+		return
+	}
+
+	respondEphemeral(s, i, "Welcome GIF updated.")
+}
+
+func handleSetDefaultRole(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if services.Global.DefaultRole == nil {
+		respondEphemeral(s, i, "Default role configuration is not available.")
+		return
+	}
+
+	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid guild ID.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var roleOpt *discordgo.ApplicationCommandInteractionDataOption
+	for _, o := range opt.Options {
+		if o.Name == "role" {
+			roleOpt = o
+			break
+		}
+	}
+	if roleOpt == nil {
+		respondEphemeral(s, i, "Missing role option.")
+		return
+	}
+
+	role := roleOpt.RoleValue(s, i.GuildID)
+	if role == nil {
+		respondEphemeral(s, i, "Invalid role.")
+		return
+	}
+
+	roleID, err := strconv.ParseInt(role.ID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid role ID.")
+		return
+	}
+
+	if err := services.Global.DefaultRole.SetRole(context.Background(), guildID, roleID); err != nil {
+		respondEphemeral(s, i, "Failed to set default role.")
+		return
+	}
+
+	respondEphemeral(s, i, "Default role set to "+role.Mention()+".")
+}
+
+func handleSetLogChannel(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if services.Global.LogSettings == nil {
+		respondEphemeral(s, i, "Log settings service is not available.")
+		return
+	}
+
+	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid guild ID.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var chOpt *discordgo.ApplicationCommandInteractionDataOption
+	for _, o := range opt.Options {
+		if o.Name == "channel" {
+			chOpt = o
+			break
+		}
+	}
+	if chOpt == nil {
+		respondEphemeral(s, i, "Missing channel option.")
+		return
+	}
+
+	ch := chOpt.ChannelValue(s)
+	if ch == nil {
+		respondEphemeral(s, i, "Invalid channel.")
+		return
+	}
+
+	channelID, err := strconv.ParseInt(ch.ID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid channel ID.")
+		return
+	}
+
+	if err := services.Global.LogSettings.SetChannel(context.Background(), guildID, channelID); err != nil {
+		respondEphemeral(s, i, "Failed to set log channel.")
+		return
+	}
+	if err := services.Global.LogSettings.SetEnabled(context.Background(), guildID, true); err != nil {
+		respondEphemeral(s, i, "Log channel set, but failed to enable logging.")
+		return
+	}
+
+	respondEphemeral(s, i, "Logging enabled in "+ch.Mention()+".")
+}
+
+func handleSetLoggingEnabled(s *discordgo.Session, i *discordgo.InteractionCreate, enabled bool) {
+	if services.Global.LogSettings == nil {
+		respondEphemeral(s, i, "Log settings service is not available.")
+		return
+	}
+
+	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid guild ID.")
+		return
+	}
+
+	if err := services.Global.LogSettings.SetEnabled(context.Background(), guildID, enabled); err != nil {
+		respondEphemeral(s, i, "Failed to update logging state.")
+		return
+	}
+
+	if enabled {
+		respondEphemeral(s, i, "Logging is now enabled.")
+		return
+	}
+	respondEphemeral(s, i, "Logging is now disabled.")
+}
+
+func respondEphemeral(s *discordgo.Session, i *discordgo.InteractionCreate, msg string) {
+	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{
+			Content: msg,
+			Flags:   discordgo.MessageFlagsEphemeral,
+		},
+	})
+}
+

internal/commands/config/registry.go

@@ -0,0 +1,14 @@
+package config
+
+import (
+	"velox-bot/internal/commands/config/public"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+var (
+	Config *discordgo.ApplicationCommand = public.Config
+)
+
+func ConfigHandler(s *discordgo.Session, i *discordgo.InteractionCreate) { public.ConfigHandler(s, i) }
+

internal/commands/help/help.go

@@ -42,80 +42,116 @@ func HelpHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
 
 	embed := &discordgo.MessageEmbed{
 		Title:       "Velox Bot Help",
-		Description: "Here is the help for the bot.",
+		Description: "Command reference. Some commands require server permissions or roles.",
 		Color:       0xFFA500,
 		Fields: []*discordgo.MessageEmbedField{
 			{
-				Name:  "Fun Commands",
-				Value: "Small utility + games.",
+				Name: "Fun",
+				Value: "" +
+					"`/ping` — Pong!\n" +
+					"`/joke [type]` — Random joke (optional category)\n" +
+					"`/coinflip` — Flip a coin\n" +
+					"`/dice <expr>` — Roll dice (e.g. `d20`, `2d20+1`, `2#d20+1`)\n" +
+					"`/rps <hand>` — Rock Paper Scissors (server only)\n" +
+					"`/rpsstats` — Your RPS score (server only)\n" +
+					"`/rpsleaderboard` — Top RPS scores (server only)",
 			},
 			{
-				Name:  "/ping",
-				Value: "Pong!",
+				Name: "Music (requires **DJ** role)",
+				Value: "" +
+					"`/play <query>` — Play a song (search or URL)\n" +
+					"`/queue` — Show the current queue\n" +
+					"`/volume <0-150>` — Set playback volume",
 			},
 			{
-				Name:  "/joke [type]",
-				Value: "Get a random joke (optional category).",
+				Name: "Scheduling (1:1 sessions)",
+				Value: "" +
+					"`/schedule create user:@someone datetime:\"YYYY-MM-DD HH:MM\" [description]` — Create a session\n" +
+					"`/schedule list` — List your upcoming sessions\n" +
+					"`/schedule reschedule id:<id> datetime:\"YYYY-MM-DD HH:MM\"` — Request a new time\n\n" +
+					"Invites are sent via DM; react with ✅ / ❌ / 🔁 to respond.",
 			},
 			{
-				Name:  "/coinflip",
-				Value: "Flip a coin.",
+				Name: "Timezone",
+				Value: "" +
+					"`/timezone set <IANA>` — Set your timezone (e.g. `Europe/Lisbon`)\n" +
+					"`/timezone show` — Show your timezone",
 			},
 			{
-				Name:  "/dice <expr>",
-				Value: "Roll dice expressions (e.g. `d20`, `2d20+1`, `2#d20+1`).",
+				Name: "Projects",
+				Value: "" +
+					"`/projects list` — List active projects\n" +
+					"`/projects create name:\"...\" [description]` — Create a project (**Manage Server**)\n" +
+					"`/projects add-helper project-id:<id> user:@someone` — Add helper (**Manage Server**)",
 			},
 			{
-				Name:  "/rps <hand>",
-				Value: "Play Rock Paper Scissors (server only).",
+				Name: "Tickets",
+				Value: "" +
+					"Open a ticket from the panel: you get a private thread with the staff.\n" +
+					"`/ticket add user:@someone` — Add someone to your ticket\n" +
+					"`/ticket close [reason]` — Close the ticket (opener or staff)\n" +
+					"`/ticket claim`, `/ticket remove user:@someone` — Staff only\n" +
+					"`/tickets setup`, `/tickets category add|remove|list`, `/tickets panel` — Set up (**Manage Server**)",
 			},
 			{
-				Name:  "/rpsstats",
-				Value: "Show your RPS score (server only).",
+				Name: "Meetings (**Manage Server**)",
+				Value: "" +
+					"`/meeting set-lobby channel:#voice` — Set voice lobby used to create meetings\n" +
+					"`/meeting lock` — Lock your meeting room\n" +
+					"`/meeting lock-private` — Lock + hide your meeting room\n" +
+					"`/meeting unlock` — Unlock your meeting room\n" +
+					"`/meeting invite user:@someone` — Allow a user to join\n" +
+					"`/meeting uninvite user:@someone` — Remove a user's permission",
 			},
 			{
-				Name:  "/rpsleaderboard",
-				Value: "Show top RPS scores (server only).",
+				Name: "Moderation (focused tools)",
+				Value: "" +
+					"`/moderation purge amount:<1-100>` — Delete recent messages (**Manage Messages**)\n" +
+					"`/moderation timeout user:@someone duration:<10m|1h|...> [reason]` — Timeout member (**Moderate Members**)\n" +
+					"`/moderation kick user:@someone [reason]` — Kick member (**Kick Members**)\n" +
+					"`/moderation ban user:@someone [delete_days] [reason]` — Ban member (**Ban Members**)\n" +
+					"`/moderation unban user_id:<id> [reason]` — Unban by user ID (**Ban Members**)\n" +
+					"`/moderation untimeout user:@someone [reason]` — Remove timeout (**Moderate Members**)\n" +
+					"`/moderation slowmode channel:#channel seconds:<0-21600>` — Set slowmode (**Manage Channels**)",
 			},
 			{
-				Name:  "/help",
-				Value: "Get help with the bot.",
+				Name: "Leveling",
+				Value: "" +
+					"`/slvl toggle` — Enable/disable leveling (**Manage Server**)\n" +
+					"`/slvl set user:@someone level:<n>` — Set user level (**Manage Server**)\n" +
+					"`/slvl set-channel channel:#channel` — Level-up message channel (**Manage Server**)\n" +
+					"`/slvl set-message message:\"...\"` — Custom level-up message (**Manage Server**)\n" +
+					"`/slvl set-reward level:<n> role:@role` — Role rewards (**Manage Server**)\n" +
+					"`/rank [user]` — Your rank card (server only)\n" +
+					"`/leaderboard` — Top levels (server only)\n" +
+					"`/rewards` — List configured rewards (server only)",
 			},
 			{
-				Name:  "Leveling System",
-				Value: `The leveling system is a system that allows users to gain XP and level up. The system is based on the amount of messages sent in a server. The more messages you send, the more XP you gain. The more XP you gain, the higher your level will be. The leveling system is disabled by default, however you can enable/disable it by using the /slvl toggle command. You can also configure the leveling system by using the /slvl command.`,
+				Name: "Twitch live notifications (**Manage Server**)",
+				Value: "" +
+					"`/config addstreamer username:<twitch-name>` — Add a streamer\n" +
+					"`/config removestreamer username:<twitch-name>` — Remove a streamer\n" +
+					"`/config settwitchnotificationchannel channel:#channel` — Set notification channel",
 			},
 			{
-				Name:  "/slvl toggle",
-				Value: "Toggle the leveling system.",
+				Name: "Welcome / onboarding (**Manage Server**)",
+				Value: "" +
+					"`/config setwelcomechannel channel:#channel` — Channel for welcome messages\n" +
+					"`/config setwelcomemessage message:\"...\"` — Welcome text (supports `{user}`, `{server}`)\n" +
+					"`/config setwelcomedm message:\"...\"` — DM template (supports `{user}`, `{server}`)\n" +
+					"`/config setwelcomegif url:<image-url>` — GIF/image used in welcome embed\n" +
+					"`/config setdefaultrole role:@role` — Role granted to new members",
 			},
 			{
-				Name:  "/slvl set",
-				Value: "Set the level of a user.",
+				Name: "Logging (**Manage Server**)",
+				Value: "" +
+					"`/config setlogchannel channel:#channel` — Set log output channel\n" +
+					"`/config enablelogging` — Enable event/moderation logging\n" +
+					"`/config disablelogging` — Disable event/moderation logging",
 			},
 			{
-				Name:  "/slvl set-channel",
-				Value: "Set the channel for level-up messages.",
-			},
-			{
-				Name:  "/slvl set-message",
-				Value: "Set the custom level-up message.",
-			},
-			{
-				Name:  "/slvl set-reward",
-				Value: "Set a role reward for a level.",
-			},
-			{
-				Name:  "/rank [user]",
-				Value: "Show a rank card (server only).",
-			},
-			{
-				Name:  "/leaderboard",
-				Value: "Show top levels (server only).",
-			},
-			{
-				Name:  "/rewards",
-				Value: "List configured level rewards (server only).",
+				Name:  "Other",
+				Value: "`/help` — Show this help in DMs",
 			},
 		},
 		Author: &author,

internal/commands/moderation/public/moderation.go

@@ -0,0 +1,578 @@
+package public
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"velox-bot/internal/db/services"
+	"velox-bot/internal/modlog"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+var Moderation = &discordgo.ApplicationCommand{
+	Name:        "moderation",
+	Description: "High-value moderation tools",
+	Options: []*discordgo.ApplicationCommandOption{
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "purge",
+			Description: "Delete recent messages in this channel (max 100)",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionInteger,
+					Name:        "amount",
+					Description: "How many recent messages to delete (1-100)",
+					Required:    true,
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "timeout",
+			Description: "Temporarily timeout a member",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionUser,
+					Name:        "user",
+					Description: "User to timeout",
+					Required:    true,
+				},
+				{
+					Type:        discordgo.ApplicationCommandOptionString,
+					Name:        "duration",
+					Description: "Duration like 10m, 1h, 2h30m (max 28d)",
+					Required:    true,
+				},
+				{
+					Type:        discordgo.ApplicationCommandOptionString,
+					Name:        "reason",
+					Description: "Optional reason",
+					Required:    false,
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "kick",
+			Description: "Kick a member from the server",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionUser,
+					Name:        "user",
+					Description: "User to kick",
+					Required:    true,
+				},
+				{
+					Type:        discordgo.ApplicationCommandOptionString,
+					Name:        "reason",
+					Description: "Optional reason",
+					Required:    false,
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "ban",
+			Description: "Ban a member from the server",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionUser,
+					Name:        "user",
+					Description: "User to ban",
+					Required:    true,
+				},
+				{
+					Type:        discordgo.ApplicationCommandOptionInteger,
+					Name:        "delete_days",
+					Description: "Delete message history (0-7 days)",
+					Required:    false,
+				},
+				{
+					Type:        discordgo.ApplicationCommandOptionString,
+					Name:        "reason",
+					Description: "Optional reason",
+					Required:    false,
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "unban",
+			Description: "Unban a user by ID",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionString,
+					Name:        "user_id",
+					Description: "User ID to unban",
+					Required:    true,
+				},
+				{
+					Type:        discordgo.ApplicationCommandOptionString,
+					Name:        "reason",
+					Description: "Optional reason",
+					Required:    false,
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "untimeout",
+			Description: "Remove timeout from a member",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionUser,
+					Name:        "user",
+					Description: "User to untimeout",
+					Required:    true,
+				},
+				{
+					Type:        discordgo.ApplicationCommandOptionString,
+					Name:        "reason",
+					Description: "Optional reason",
+					Required:    false,
+				},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "slowmode",
+			Description: "Set channel slowmode (0 disables)",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:         discordgo.ApplicationCommandOptionChannel,
+					Name:         "channel",
+					Description:  "Text channel to update",
+					Required:     true,
+					ChannelTypes: []discordgo.ChannelType{discordgo.ChannelTypeGuildText, discordgo.ChannelTypeGuildNews},
+				},
+				{
+					Type:        discordgo.ApplicationCommandOptionInteger,
+					Name:        "seconds",
+					Description: "Slowmode delay in seconds (0-21600)",
+					Required:    true,
+				},
+			},
+		},
+	},
+}
+
+func ModerationHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if i.GuildID == "" {
+		respondEphemeral(s, i, "This command can only be used in a server.")
+		return
+	}
+
+	data := i.ApplicationCommandData()
+	if len(data.Options) == 0 {
+		respondEphemeral(s, i, "Missing subcommand.")
+		return
+	}
+
+	switch data.Options[0].Name {
+	case "purge":
+		handlePurge(s, i)
+	case "timeout":
+		handleTimeout(s, i)
+	case "kick":
+		handleKick(s, i)
+	case "ban":
+		handleBan(s, i)
+	case "unban":
+		handleUnban(s, i)
+	case "untimeout":
+		handleUntimeout(s, i)
+	case "slowmode":
+		handleSlowmode(s, i)
+	default:
+		respondEphemeral(s, i, "Unknown subcommand.")
+	}
+}
+
+func handlePurge(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !hasPerm(i, discordgo.PermissionManageMessages) {
+		respondEphemeral(s, i, "You need **Manage Messages** for this command.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var amount int64
+	for _, o := range opt.Options {
+		if o.Name == "amount" {
+			amount = o.IntValue()
+			break
+		}
+	}
+	if amount < 1 || amount > 100 {
+		respondEphemeral(s, i, "Amount must be between 1 and 100.")
+		return
+	}
+
+	msgs, err := s.ChannelMessages(i.ChannelID, int(amount), "", "", "")
+	if err != nil {
+		respondEphemeral(s, i, "Failed to fetch messages.")
+		return
+	}
+	if len(msgs) == 0 {
+		respondEphemeral(s, i, "No messages found to delete.")
+		return
+	}
+
+	tooOldCutoff := time.Now().Add(-14 * 24 * time.Hour)
+	ids := make([]string, 0, len(msgs))
+	for _, m := range msgs {
+		if m == nil {
+			continue
+		}
+		if m.Timestamp.Before(tooOldCutoff) {
+			continue
+		}
+		ids = append(ids, m.ID)
+	}
+	if len(ids) == 0 {
+		respondEphemeral(s, i, "No messages can be bulk deleted (older than 14 days).")
+		return
+	}
+
+	if len(ids) == 1 {
+		if err := s.ChannelMessageDelete(i.ChannelID, ids[0]); err != nil {
+			respondEphemeral(s, i, "Failed to delete message.")
+			return
+		}
+		respondEphemeral(s, i, "Deleted 1 message.")
+		sendModerationActionLog(s, i, "Purge", fmt.Sprintf("Deleted 1 message in <#%s>.", i.ChannelID), "")
+		return
+	}
+
+	if err := s.ChannelMessagesBulkDelete(i.ChannelID, ids); err != nil {
+		respondEphemeral(s, i, "Failed to bulk delete messages.")
+		return
+	}
+
+	respondEphemeral(s, i, fmt.Sprintf("Deleted %d messages.", len(ids)))
+	sendModerationActionLog(s, i, "Purge", fmt.Sprintf("Deleted %d messages in <#%s>.", len(ids), i.ChannelID), "")
+}
+
+func handleTimeout(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !hasPerm(i, discordgo.PermissionModerateMembers) {
+		respondEphemeral(s, i, "You need **Moderate Members** for this command.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var userOpt *discordgo.ApplicationCommandInteractionDataOption
+	var durationInput string
+	var reason string
+	for _, o := range opt.Options {
+		switch o.Name {
+		case "user":
+			userOpt = o
+		case "duration":
+			durationInput = strings.TrimSpace(o.StringValue())
+		case "reason":
+			reason = strings.TrimSpace(o.StringValue())
+		}
+	}
+	if userOpt == nil {
+		respondEphemeral(s, i, "Missing user option.")
+		return
+	}
+	target := userOpt.UserValue(s)
+	if target == nil {
+		respondEphemeral(s, i, "Invalid user.")
+		return
+	}
+
+	dur, err := time.ParseDuration(durationInput)
+	if err != nil || dur <= 0 {
+		respondEphemeral(s, i, "Invalid duration. Examples: `10m`, `1h`, `2h30m`.")
+		return
+	}
+	maxTimeout := 28 * 24 * time.Hour
+	if dur > maxTimeout {
+		respondEphemeral(s, i, "Duration cannot exceed 28 days.")
+		return
+	}
+
+	until := time.Now().UTC().Add(dur)
+	if err := s.GuildMemberTimeout(i.GuildID, target.ID, &until); err != nil {
+		respondEphemeral(s, i, "Failed to timeout user. Check role hierarchy and permissions.")
+		return
+	}
+
+	if reason == "" {
+		respondEphemeral(s, i, fmt.Sprintf("Timed out %s for `%s`.", target.Mention(), dur.String()))
+		sendModerationActionLog(s, i, "Timeout", fmt.Sprintf("Target: %s\nDuration: `%s`", target.Mention(), dur.String()), "")
+		return
+	}
+	respondEphemeral(s, i, fmt.Sprintf("Timed out %s for `%s`. Reason: %s", target.Mention(), dur.String(), reason))
+	sendModerationActionLog(s, i, "Timeout", fmt.Sprintf("Target: %s\nDuration: `%s`", target.Mention(), dur.String()), reason)
+}
+
+func handleKick(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !hasPerm(i, discordgo.PermissionKickMembers) {
+		respondEphemeral(s, i, "You need **Kick Members** for this command.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var userOpt *discordgo.ApplicationCommandInteractionDataOption
+	var reason string
+	for _, o := range opt.Options {
+		switch o.Name {
+		case "user":
+			userOpt = o
+		case "reason":
+			reason = strings.TrimSpace(o.StringValue())
+		}
+	}
+	if userOpt == nil {
+		respondEphemeral(s, i, "Missing user option.")
+		return
+	}
+	target := userOpt.UserValue(s)
+	if target == nil {
+		respondEphemeral(s, i, "Invalid user.")
+		return
+	}
+	if i.Member != nil && i.Member.User != nil && target.ID == i.Member.User.ID {
+		respondEphemeral(s, i, "You cannot kick yourself.")
+		return
+	}
+	if s != nil && s.State != nil && s.State.User != nil && target.ID == s.State.User.ID {
+		respondEphemeral(s, i, "I can't kick myself.")
+		return
+	}
+
+	if err := s.GuildMemberDeleteWithReason(i.GuildID, target.ID, reason); err != nil {
+		respondEphemeral(s, i, "Failed to kick user. Check role hierarchy and permissions.")
+		return
+	}
+
+	if reason == "" {
+		respondEphemeral(s, i, "Kicked "+target.Mention()+".")
+		sendModerationActionLog(s, i, "Kick", "Target: "+target.Mention(), "")
+		return
+	}
+	respondEphemeral(s, i, "Kicked "+target.Mention()+". Reason: "+reason)
+	sendModerationActionLog(s, i, "Kick", "Target: "+target.Mention(), reason)
+}
+
+func handleBan(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !hasPerm(i, discordgo.PermissionBanMembers) {
+		respondEphemeral(s, i, "You need **Ban Members** for this command.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var userOpt *discordgo.ApplicationCommandInteractionDataOption
+	var deleteDays int64
+	var reason string
+	for _, o := range opt.Options {
+		switch o.Name {
+		case "user":
+			userOpt = o
+		case "delete_days":
+			deleteDays = o.IntValue()
+		case "reason":
+			reason = strings.TrimSpace(o.StringValue())
+		}
+	}
+	if userOpt == nil {
+		respondEphemeral(s, i, "Missing user option.")
+		return
+	}
+	target := userOpt.UserValue(s)
+	if target == nil {
+		respondEphemeral(s, i, "Invalid user.")
+		return
+	}
+	if deleteDays < 0 || deleteDays > 7 {
+		respondEphemeral(s, i, "delete_days must be between 0 and 7.")
+		return
+	}
+	if i.Member != nil && i.Member.User != nil && target.ID == i.Member.User.ID {
+		respondEphemeral(s, i, "You cannot ban yourself.")
+		return
+	}
+	if s != nil && s.State != nil && s.State.User != nil && target.ID == s.State.User.ID {
+		respondEphemeral(s, i, "I can't ban myself.")
+		return
+	}
+
+	if err := s.GuildBanCreateWithReason(i.GuildID, target.ID, reason, int(deleteDays)); err != nil {
+		respondEphemeral(s, i, "Failed to ban user. Check role hierarchy and permissions.")
+		return
+	}
+
+	if reason == "" {
+		respondEphemeral(s, i, fmt.Sprintf("Banned %s (deleted %d days of messages).", target.Mention(), deleteDays))
+		sendModerationActionLog(s, i, "Ban", fmt.Sprintf("Target: %s\nDeleted message days: %d", target.Mention(), deleteDays), "")
+		return
+	}
+	respondEphemeral(s, i, fmt.Sprintf("Banned %s (deleted %d days of messages). Reason: %s", target.Mention(), deleteDays, reason))
+	sendModerationActionLog(s, i, "Ban", fmt.Sprintf("Target: %s\nDeleted message days: %d", target.Mention(), deleteDays), reason)
+}
+
+func handleUnban(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !hasPerm(i, discordgo.PermissionBanMembers) {
+		respondEphemeral(s, i, "You need **Ban Members** for this command.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var userID string
+	var reason string
+	for _, o := range opt.Options {
+		switch o.Name {
+		case "user_id":
+			userID = strings.TrimSpace(o.StringValue())
+		case "reason":
+			reason = strings.TrimSpace(o.StringValue())
+		}
+	}
+	if userID == "" {
+		respondEphemeral(s, i, "Missing user ID.")
+		return
+	}
+
+	if err := s.GuildBanDelete(i.GuildID, userID); err != nil {
+		respondEphemeral(s, i, "Failed to unban user. Make sure the user ID is valid and banned.")
+		return
+	}
+
+	if reason == "" {
+		respondEphemeral(s, i, "Unbanned user ID `"+userID+"`.")
+		sendModerationActionLog(s, i, "Unban", "Target user ID: `"+userID+"`", "")
+		return
+	}
+	respondEphemeral(s, i, "Unbanned user ID `"+userID+"`. Reason: "+reason)
+	sendModerationActionLog(s, i, "Unban", "Target user ID: `"+userID+"`", reason)
+}
+
+func handleUntimeout(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !hasPerm(i, discordgo.PermissionModerateMembers) {
+		respondEphemeral(s, i, "You need **Moderate Members** for this command.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var userOpt *discordgo.ApplicationCommandInteractionDataOption
+	var reason string
+	for _, o := range opt.Options {
+		switch o.Name {
+		case "user":
+			userOpt = o
+		case "reason":
+			reason = strings.TrimSpace(o.StringValue())
+		}
+	}
+	if userOpt == nil {
+		respondEphemeral(s, i, "Missing user option.")
+		return
+	}
+	target := userOpt.UserValue(s)
+	if target == nil {
+		respondEphemeral(s, i, "Invalid user.")
+		return
+	}
+
+	if err := s.GuildMemberTimeout(i.GuildID, target.ID, nil); err != nil {
+		respondEphemeral(s, i, "Failed to remove timeout. Check role hierarchy and permissions.")
+		return
+	}
+
+	if reason == "" {
+		respondEphemeral(s, i, "Removed timeout from "+target.Mention()+".")
+		sendModerationActionLog(s, i, "Timeout Removed", "Target: "+target.Mention(), "")
+		return
+	}
+	respondEphemeral(s, i, "Removed timeout from "+target.Mention()+". Reason: "+reason)
+	sendModerationActionLog(s, i, "Timeout Removed", "Target: "+target.Mention(), reason)
+}
+
+func handleSlowmode(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !hasPerm(i, discordgo.PermissionManageChannels) {
+		respondEphemeral(s, i, "You need **Manage Channels** for this command.")
+		return
+	}
+
+	opt := i.ApplicationCommandData().Options[0]
+	var chOpt *discordgo.ApplicationCommandInteractionDataOption
+	var seconds int64
+	for _, o := range opt.Options {
+		switch o.Name {
+		case "channel":
+			chOpt = o
+		case "seconds":
+			seconds = o.IntValue()
+		}
+	}
+	if chOpt == nil {
+		respondEphemeral(s, i, "Missing channel option.")
+		return
+	}
+	if seconds < 0 || seconds > 21600 {
+		respondEphemeral(s, i, "Seconds must be between 0 and 21600.")
+		return
+	}
+	ch := chOpt.ChannelValue(s)
+	if ch == nil {
+		respondEphemeral(s, i, "Invalid channel.")
+		return
+	}
+
+	secondsInt := int(seconds)
+	_, err := s.ChannelEditComplex(ch.ID, &discordgo.ChannelEdit{
+		RateLimitPerUser: &secondsInt,
+	})
+	if err != nil {
+		respondEphemeral(s, i, "Failed to update slowmode.")
+		return
+	}
+
+	if seconds == 0 {
+		respondEphemeral(s, i, "Disabled slowmode in "+ch.Mention()+".")
+		sendModerationActionLog(s, i, "Slowmode", "Channel: "+ch.Mention()+"\nSet to: `0s`", "")
+		return
+	}
+	respondEphemeral(s, i, fmt.Sprintf("Set slowmode in %s to %d seconds.", ch.Mention(), seconds))
+	sendModerationActionLog(s, i, "Slowmode", fmt.Sprintf("Channel: %s\nSet to: `%ds`", ch.Mention(), seconds), "")
+}
+
+func hasPerm(i *discordgo.InteractionCreate, perm int64) bool {
+	return i.Member != nil && (i.Member.Permissions&perm) == perm
+}
+
+func respondEphemeral(s *discordgo.Session, i *discordgo.InteractionCreate, msg string) {
+	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{
+			Content: msg,
+			Flags:   discordgo.MessageFlagsEphemeral,
+		},
+	})
+}
+
+func sendModerationActionLog(s *discordgo.Session, i *discordgo.InteractionCreate, action, details, reason string) {
+	if services.Global == nil {
+		return
+	}
+	moderator := "Unknown"
+	if i != nil && i.Member != nil && i.Member.User != nil {
+		moderator = i.Member.User.Mention()
+	}
+	desc := "Moderator: " + moderator + "\n" + details
+	if strings.TrimSpace(reason) != "" {
+		desc += "\nReason: " + reason
+	}
+	embed := &discordgo.MessageEmbed{
+		Title:       "Moderation Action: " + action,
+		Color:       0x5865F2,
+		Description: desc,
+		Timestamp:   time.Now().Format(time.RFC3339),
+	}
+	_ = modlog.Send(s, services.Global, i.GuildID, embed)
+}
+

internal/commands/moderation/registry.go

@@ -0,0 +1,16 @@
+package moderation
+
+import (
+	"velox-bot/internal/commands/moderation/public"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+var (
+	Moderation *discordgo.ApplicationCommand = public.Moderation
+)
+
+func ModerationHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	public.ModerationHandler(s, i)
+}
+

internal/commands/music/public/play.go

@@ -2,8 +2,7 @@ package public
 
 import (
 	"fmt"
-	"net/url"
-	"strings"
+	"velox-bot/internal/commands/music/shared"
 	"velox-bot/internal/music"
 
 	"github.com/bwmarrin/discordgo"
@@ -23,6 +22,10 @@ var Play = &discordgo.ApplicationCommand{
 }
 
 func PlayHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !shared.RequireMusicEnabled(s, i) {
+		return
+	}
+
 	data := i.ApplicationCommandData()
 	if len(data.Options) == 0 {
 		return
@@ -44,13 +47,6 @@ func PlayHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		return
 	}
 
-	// If user provided plain text, turn it into a YouTube search
-	if !strings.HasPrefix(query, "http://") && !strings.HasPrefix(query, "https://") && !strings.HasPrefix(query, "ytsearch:") {
-		query = "ytsearch:" + query
-	} else {
-		query = normalizeYouTubeRadioURL(query)
-	}
-
 	vs, err := findUserVoiceState(s, i.GuildID, i.Member.User.ID)
 	if err != nil {
 		_, _ = s.InteractionResponseEdit(i.Interaction, &discordgo.WebhookEdit{
@@ -59,7 +55,7 @@ func PlayHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		return
 	}
 
-	entry, started, err := music.EnqueueAndPlay(i.GuildID, vs.ChannelID, i.ChannelID, query, i.Member.User.Username)
+	entry, started, err := music.EnqueueAndPlay(i.GuildID, vs.ChannelID, i.ChannelID, query, i.Member.User.Username, i.Member.User.ID)
 	if err != nil {
 		_, _ = s.InteractionResponseEdit(i.Interaction, &discordgo.WebhookEdit{
 			Content: ptr(fmt.Sprintf("Error: %v", err)),
@@ -85,37 +81,6 @@ func PlayHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
 
 func ptr[T any](v T) *T { return new(v) }
 
-// normalizeYouTubeRadioURL strips auto-generated "radio/mix" params like:
-// https://www.youtube.com/watch?v=ID&list=RDID&start_radio=1 -> https://www.youtube.com/watch?v=ID
-// It intentionally does NOT strip normal playlist URLs.
-func normalizeYouTubeRadioURL(raw string) string {
-	u, err := url.Parse(raw)
-	if err != nil || u == nil {
-		return raw
-	}
-
-	host := strings.ToLower(u.Host)
-	if !strings.Contains(host, "youtube.com") || u.Path != "/watch" {
-		return raw
-	}
-
-	q := u.Query()
-	v := q.Get("v")
-	if v == "" {
-		return raw
-	}
-
-	list := q.Get("list")
-	_, hasStartRadio := q["start_radio"]
-	if !hasStartRadio && !strings.HasPrefix(list, "RD") {
-		return raw
-	}
-
-	u.RawQuery = url.Values{"v": []string{v}}.Encode()
-	u.Fragment = ""
-	return u.String()
-}
-
 func findUserVoiceState(s *discordgo.Session, guildID, userID string) (*discordgo.VoiceState, error) {
 	g, err := s.State.Guild(guildID)
 	if err != nil {

internal/commands/music/public/queue.go

@@ -3,6 +3,7 @@ package public
 import (
 	"fmt"
 	"strings"
+	"velox-bot/internal/commands/music/shared"
 	"velox-bot/internal/music"
 
 	"github.com/bwmarrin/discordgo"
@@ -14,6 +15,9 @@ var Queue = &discordgo.ApplicationCommand{
 }
 
 func QueueHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !shared.RequireMusicEnabled(s, i) {
+		return
+	}
 	if !memberHasDJRole(s, i.GuildID, i.Member) {
 		_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
 			Type: discordgo.InteractionResponseChannelMessageWithSource,
@@ -74,4 +78,3 @@ func QueueHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		},
 	})
 }
-

internal/commands/music/public/toggle.go

@@ -0,0 +1,63 @@
+package public
+
+import (
+	"context"
+	"velox-bot/internal/commands/music/shared"
+	"velox-bot/internal/db/services"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+var Music = &discordgo.ApplicationCommand{
+	Name:        "music",
+	Description: "Music settings",
+	Options: []*discordgo.ApplicationCommandOption{
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "toggle",
+			Description: "Turn the music player on or off for this server",
+		},
+	},
+}
+
+func MusicHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if i.GuildID == "" {
+		shared.RespondEphemeral(s, i, "This command can only be used in a server.")
+		return
+	}
+	if !shared.RequireManageGuild(s, i) {
+		return
+	}
+	if !shared.RequireMusicService(s, i) {
+		return
+	}
+
+	data := i.ApplicationCommandData()
+	if len(data.Options) == 0 {
+		shared.RespondEphemeral(s, i, "Missing subcommand.")
+		return
+	}
+
+	switch data.Options[0].Name {
+	case "toggle":
+		handleToggle(s, i)
+	}
+}
+
+func handleToggle(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	guildID, ok := shared.ParseGuildID(s, i)
+	if !ok {
+		return
+	}
+
+	enabled, err := services.Global.MusicSettings.ToggleMusic(context.Background(), guildID)
+	if err != nil {
+		shared.RespondEphemeral(s, i, "Failed to toggle music playback.")
+		return
+	}
+	status := "disabled"
+	if enabled {
+		status = "enabled"
+	}
+	shared.RespondEphemeral(s, i, "Music playback "+status+" for this server.")
+}

internal/commands/music/public/volume.go

@@ -2,6 +2,7 @@ package public
 
 import (
 	"fmt"
+	"velox-bot/internal/commands/music/shared"
 	"velox-bot/internal/music"
 
 	"github.com/bwmarrin/discordgo"
@@ -23,6 +24,9 @@ var Volume = &discordgo.ApplicationCommand{
 }
 
 func VolumeHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !shared.RequireMusicEnabled(s, i) {
+		return
+	}
 	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
 		Type: discordgo.InteractionResponseDeferredChannelMessageWithSource,
 		Data: &discordgo.InteractionResponseData{
@@ -60,4 +64,3 @@ func VolumeHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
 }
 
 func ptrFloat(v float64) *float64 { return &v }
-

internal/commands/music/registry.go

@@ -7,9 +7,10 @@ import (
 )
 
 var (
-	Play  *discordgo.ApplicationCommand = public.Play
-	Queue *discordgo.ApplicationCommand = public.Queue
+	Play   *discordgo.ApplicationCommand = public.Play
+	Queue  *discordgo.ApplicationCommand = public.Queue
 	Volume *discordgo.ApplicationCommand = public.Volume
+	Music  *discordgo.ApplicationCommand = public.Music
 )
 
 func PlayHandler(s *discordgo.Session, i *discordgo.InteractionCreate) { public.PlayHandler(s, i) }
@@ -17,4 +18,4 @@ func QueueHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
 	public.QueueHandler(s, i)
 }
 func VolumeHandler(s *discordgo.Session, i *discordgo.InteractionCreate) { public.VolumeHandler(s, i) }
-
+func MusicHandler(s *discordgo.Session, i *discordgo.InteractionCreate) { public.MusicHandler(s, i) }

internal/commands/music/shared/shared.go

@@ -0,0 +1,61 @@
+package shared
+
+import (
+	"context"
+	"strconv"
+	"velox-bot/internal/db/services"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+func RequireMusicEnabled(s *discordgo.Session, i *discordgo.InteractionCreate) bool {
+	guildID, ok := ParseGuildID(s, i)
+	if !ok {
+		return false
+	}
+	enabled, err := services.Global.MusicSettings.IsMusicEnabled(context.Background(), guildID)
+	if err != nil {
+		RespondEphemeral(s, i, "Failed to load music settings.")
+		return false
+	}
+	if !enabled {
+		RespondEphemeral(s, i, "Music is disabled on this server. Use /music toggle to enable it.")
+		return false
+	}
+	return true
+}
+
+func RequireManageGuild(s *discordgo.Session, i *discordgo.InteractionCreate) bool {
+	if i.Member == nil || (i.Member.Permissions&discordgo.PermissionManageGuild) == 0 {
+		RespondEphemeral(s, i, "You need the **Manage Server** permission to use this.")
+		return false
+	}
+	return true
+}
+
+func RequireMusicService(s *discordgo.Session, i *discordgo.InteractionCreate) bool {
+	if services.Global == nil || services.Global.MusicSettings == nil {
+		RespondEphemeral(s, i, "Music service is not available.")
+		return false
+	}
+	return true
+}
+
+func ParseGuildID(s *discordgo.Session, i *discordgo.InteractionCreate) (int64, bool) {
+	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
+	if err != nil {
+		RespondEphemeral(s, i, "Invalid guild ID.")
+		return 0, false
+	}
+	return guildID, true
+}
+
+func RespondEphemeral(s *discordgo.Session, i *discordgo.InteractionCreate, msg string) {
+	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{
+			Content: msg,
+			Flags:   discordgo.MessageFlagsEphemeral,
+		},
+	})
+}

internal/commands/projects/public/components.go

@@ -0,0 +1,222 @@
+package public
+
+import (
+	"context"
+	"strconv"
+	"strings"
+
+	"velox-bot/internal/commands/projects/shared"
+	"velox-bot/internal/db/services"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// HandleComponent routes the select menus shown after /projects add-helper
+// and /projects close.
+func HandleComponent(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	parts := strings.Split(i.MessageComponentData().CustomID, ":")
+	if len(parts) < 2 {
+		return
+	}
+
+	switch parts[1] {
+	case "add_helper_project_select":
+		handleAddHelperProjectSelect(s, i)
+	case "add_helper_user_select":
+		handleAddHelperUserSelect(s, i, parts)
+	case "close_select":
+		handleCloseSelect(s, i)
+	}
+}
+
+// handleAddHelperProjectSelect is step 1: a project was picked, now show a
+// native Discord user-select to pick who helps - the actual AddHelper call
+// happens in handleAddHelperUserSelect once both are known.
+func handleAddHelperProjectSelect(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !shared.RequireManageGuild(s, i) {
+		return
+	}
+
+	values := i.MessageComponentData().Values
+	if len(values) == 0 {
+		return
+	}
+	projectID := values[0]
+
+	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseUpdateMessage,
+		Data: &discordgo.InteractionResponseData{
+			Content: "Who should help with this project?",
+			Components: []discordgo.MessageComponent{
+				discordgo.ActionsRow{
+					Components: []discordgo.MessageComponent{
+						discordgo.SelectMenu{
+							MenuType:    discordgo.UserSelectMenu,
+							CustomID:    "projects:add_helper_user_select:" + projectID,
+							Placeholder: "Select a user",
+						},
+					},
+				},
+			},
+		},
+	})
+}
+
+// handleAddHelperUserSelect is step 2: a user was picked from the native
+// select menu, so both the project (carried in the CustomID) and the user
+// (the selected value) are now known - perform the actual AddHelper call.
+func handleAddHelperUserSelect(s *discordgo.Session, i *discordgo.InteractionCreate, parts []string) {
+	if !shared.RequireManageGuild(s, i) {
+		return
+	}
+	if len(parts) < 3 {
+		return
+	}
+	projectID, err := strconv.ParseInt(parts[2], 10, 64)
+	if err != nil {
+		return
+	}
+
+	guildID, ok := shared.ParseGuildID(s, i)
+	if !ok {
+		return
+	}
+
+	values := i.MessageComponentData().Values
+	if len(values) == 0 {
+		return
+	}
+	userID := values[0]
+	userID64, err := strconv.ParseInt(userID, 10, 64)
+	if err != nil {
+		return
+	}
+
+	ctx := context.Background()
+	project, err := services.Global.Projects.GetProject(ctx, guildID, projectID)
+	if err != nil {
+		shared.RespondEphemeral(s, i, "Failed to load project.")
+		return
+	}
+	if project == nil {
+		shared.RespondEphemeral(s, i, "That project no longer exists in this server.")
+		return
+	}
+
+	if err := services.Global.Projects.AddHelper(ctx, projectID, userID64); err != nil {
+		shared.RespondEphemeral(s, i, "Failed to add helper to project.")
+		return
+	}
+
+	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseUpdateMessage,
+		Data: &discordgo.InteractionResponseData{
+			Content:    "Added <@" + userID + "> as helper to project **" + project.Name + "**.",
+			Components: []discordgo.MessageComponent{},
+		},
+	})
+}
+
+func handleCloseSelect(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !shared.RequireManageGuild(s, i) {
+		return
+	}
+
+	guildID, ok := shared.ParseGuildID(s, i)
+	if !ok {
+		return
+	}
+
+	values := i.MessageComponentData().Values
+	if len(values) == 0 {
+		return
+	}
+	projectID, err := strconv.ParseInt(values[0], 10, 64)
+	if err != nil {
+		return
+	}
+
+	ctx := context.Background()
+	project, err := services.Global.Projects.GetProject(ctx, guildID, projectID)
+	if err != nil {
+		shared.RespondEphemeral(s, i, "Failed to load project.")
+		return
+	}
+	if project == nil {
+		shared.RespondEphemeral(s, i, "That project no longer exists in this server.")
+		return
+	}
+
+	if err := services.Global.Projects.DeactivateProject(ctx, guildID, projectID); err != nil {
+		shared.RespondEphemeral(s, i, "Failed to close project.")
+		return
+	}
+
+	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseUpdateMessage,
+		Data: &discordgo.InteractionResponseData{
+			Content:    "Closed project **" + project.Name + "**.",
+			Components: []discordgo.MessageComponent{},
+		},
+	})
+}
+
+// HandleModalSubmit handles the /projects create modal.
+func HandleModalSubmit(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	parts := strings.Split(i.ModalSubmitData().CustomID, ":")
+	if len(parts) < 2 || parts[1] != "create_modal" {
+		return
+	}
+
+	if !shared.RequireManageGuild(s, i) {
+		return
+	}
+	guildID, ok := shared.ParseGuildID(s, i)
+	if !ok {
+		return
+	}
+	if i.Member == nil || i.Member.User == nil {
+		shared.RespondEphemeral(s, i, "Missing member info.")
+		return
+	}
+
+	values := modalTextInputValues(i.ModalSubmitData().Components)
+	name := strings.TrimSpace(values["name"])
+	description := strings.TrimSpace(values["description"])
+	if name == "" {
+		shared.RespondEphemeral(s, i, "Project name cannot be empty.")
+		return
+	}
+
+	creatorID, err := strconv.ParseInt(i.Member.User.ID, 10, 64)
+	if err != nil {
+		shared.RespondEphemeral(s, i, "Invalid user ID.")
+		return
+	}
+
+	id, err := services.Global.Projects.CreateProject(context.Background(), guildID, creatorID, name, description)
+	if err != nil {
+		shared.RespondEphemeral(s, i, "Failed to create project.")
+		return
+	}
+
+	shared.RespondEphemeral(s, i, "Created project **"+name+"** with ID `"+strconv.FormatInt(id, 10)+"`.")
+}
+
+func modalTextInputValues(components []discordgo.MessageComponent) map[string]string {
+	values := make(map[string]string)
+	for _, c := range components {
+		row, ok := c.(*discordgo.ActionsRow)
+		if !ok {
+			continue
+		}
+		for _, rc := range row.Components {
+			ti, ok := rc.(*discordgo.TextInput)
+			if !ok {
+				continue
+			}
+			values[ti.CustomID] = ti.Value
+		}
+	}
+	return values
+}

internal/commands/projects/public/projects.go

@@ -24,39 +24,16 @@ var Projects = &discordgo.ApplicationCommand{
 			Type:        discordgo.ApplicationCommandOptionSubCommand,
 			Name:        "create",
 			Description: "Create a new active project",
-			Options: []*discordgo.ApplicationCommandOption{
-				{
-					Type:        discordgo.ApplicationCommandOptionString,
-					Name:        "name",
-					Description: "Project name",
-					Required:    true,
-				},
-				{
-					Type:        discordgo.ApplicationCommandOptionString,
-					Name:        "description",
-					Description: "Short description (optional)",
-					Required:    false,
-				},
-			},
 		},
 		{
 			Type:        discordgo.ApplicationCommandOptionSubCommand,
 			Name:        "add-helper",
 			Description: "Add a helper to an existing project",
-			Options: []*discordgo.ApplicationCommandOption{
-				{
-					Type:        discordgo.ApplicationCommandOptionInteger,
-					Name:        "project-id",
-					Description: "ID of the project",
-					Required:    true,
-				},
-				{
-					Type:        discordgo.ApplicationCommandOptionUser,
-					Name:        "user",
-					Description: "User to add as helper",
-					Required:    true,
-				},
-			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "close",
+			Description: "Close (deactivate) a project",
 		},
 	},
 }
@@ -79,6 +56,8 @@ func ProjectsHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		handleCreate(s, i)
 	case "add-helper":
 		handleAddHelper(s, i)
+	case "close":
+		handleClose(s, i)
 	default:
 		shared.RespondEphemeral(s, i, "Unknown subcommand.")
 	}
@@ -154,56 +133,53 @@ func mentionUser(id int64) string {
 	return "<@" + strconv.FormatInt(id, 10) + ">"
 }
 
+// handleCreate just opens the modal - the actual creation happens on
+// submit, in HandleModalSubmit (components.go).
 func handleCreate(s *discordgo.Session, i *discordgo.InteractionCreate) {
 	if !shared.RequireManageGuild(s, i) {
 		return
 	}
 
-	guildID, ok := shared.ParseGuildID(s, i)
-	if !ok {
-		return
-	}
-	if i.Member == nil || i.Member.User == nil {
-		shared.RespondEphemeral(s, i, "Missing member info.")
-		return
-	}
-
-	data := i.ApplicationCommandData()
-	if len(data.Options) == 0 {
-		shared.RespondEphemeral(s, i, "Missing options.")
-		return
-	}
-	opt := data.Options[0]
-
-	var name, description string
-	for _, o := range opt.Options {
-		switch o.Name {
-		case "name":
-			name = o.StringValue()
-		case "description":
-			description = o.StringValue()
-		}
-	}
-	if strings.TrimSpace(name) == "" {
-		shared.RespondEphemeral(s, i, "Project name cannot be empty.")
-		return
-	}
-
-	creatorID, err := strconv.ParseInt(i.Member.User.ID, 10, 64)
-	if err != nil {
-		shared.RespondEphemeral(s, i, "Invalid user ID.")
-		return
-	}
-
-	id, err := services.Global.Projects.CreateProject(context.Background(), guildID, creatorID, name, description)
-	if err != nil {
-		shared.RespondEphemeral(s, i, "Failed to create project.")
-		return
-	}
-
-	shared.RespondEphemeral(s, i, "Created project **"+name+"** with ID `"+strconv.FormatInt(id, 10)+"`.")
+	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseModal,
+		Data: &discordgo.InteractionResponseData{
+			CustomID: "projects:create_modal",
+			Title:    "Create a project",
+			Components: []discordgo.MessageComponent{
+				discordgo.ActionsRow{
+					Components: []discordgo.MessageComponent{
+						discordgo.TextInput{
+							CustomID: "name",
+							Label:    "Project name",
+							Style:    discordgo.TextInputShort,
+							Required: true,
+						},
+					},
+				},
+				discordgo.ActionsRow{
+					Components: []discordgo.MessageComponent{
+						discordgo.TextInput{
+							CustomID: "description",
+							Label:    "Description (optional)",
+							Style:    discordgo.TextInputParagraph,
+							Required: false,
+						},
+					},
+				},
+			},
+		},
+	})
 }
 
+// handleAddHelper collects the user via Discord's native user-option (a
+// modal can't hold one of these), then responds with a select menu of the
+// guild's active projects instead of making the caller remember/type a
+// numeric project ID - the actual add-helper call happens on selection, in
+// HandleComponent (components.go).
+// handleAddHelper is the first of two dropdown steps: pick a project here,
+// then HandleComponent (components.go) follows up with a native Discord
+// user-select to pick who helps, and performs the actual AddHelper call
+// once both are known.
 func handleAddHelper(s *discordgo.Session, i *discordgo.InteractionCreate) {
 	if !shared.RequireManageGuild(s, i) {
 		return
@@ -214,55 +190,110 @@ func handleAddHelper(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		return
 	}
 
-	data := i.ApplicationCommandData()
-	if len(data.Options) == 0 {
-		shared.RespondEphemeral(s, i, "Missing options.")
-		return
-	}
-	opt := data.Options[0]
-
-	var projectID int64
-	var userID string
-	for _, o := range opt.Options {
-		switch o.Name {
-		case "project-id":
-			projectID = o.IntValue()
-		case "user":
-			if u := o.UserValue(s); u != nil {
-				userID = u.ID
-			}
-		}
-	}
-	if projectID <= 0 {
-		shared.RespondEphemeral(s, i, "Invalid project ID.")
-		return
-	}
-	if userID == "" {
-		shared.RespondEphemeral(s, i, "Invalid user.")
-		return
-	}
-
-	exists, err := services.Global.Projects.ProjectExistsInGuild(context.Background(), guildID, projectID)
+	options, err := activeProjectOptions(context.Background(), guildID)
 	if err != nil {
-		shared.RespondEphemeral(s, i, "Failed to load project.")
+		shared.RespondEphemeral(s, i, "Failed to load projects.")
 		return
 	}
-	if !exists {
-		shared.RespondEphemeral(s, i, "Project `"+strconv.FormatInt(projectID, 10)+"` not found in this server.")
+	if len(options) == 0 {
+		shared.RespondEphemeral(s, i, "There are no active projects to add a helper to.")
 		return
 	}
 
-	userID64, err := strconv.ParseInt(userID, 10, 64)
-	if err != nil {
-		shared.RespondEphemeral(s, i, "Invalid user ID.")
-		return
-	}
-
-	if err := services.Global.Projects.AddHelper(context.Background(), projectID, userID64); err != nil {
-		shared.RespondEphemeral(s, i, "Failed to add helper to project. ("+err.Error()+")")
-		return
-	}
-
-	shared.RespondEphemeral(s, i, "Added <@"+userID+"> as helper to project `"+strconv.FormatInt(projectID, 10)+"`.")
+	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{
+			Content: "Which project should get a new helper?",
+			Flags:   discordgo.MessageFlagsEphemeral,
+			Components: []discordgo.MessageComponent{
+				discordgo.ActionsRow{
+					Components: []discordgo.MessageComponent{
+						discordgo.SelectMenu{
+							CustomID:    "projects:add_helper_project_select",
+							Placeholder: "Select a project",
+							Options:     options,
+						},
+					},
+				},
+			},
+		},
+	})
 }
 
+// handleClose responds with a select menu of the guild's active projects -
+// same reasoning as handleAddHelper, picking from a live list beats typing
+// an ID. The actual deactivation happens on selection, in HandleComponent.
+func handleClose(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !shared.RequireManageGuild(s, i) {
+		return
+	}
+
+	guildID, ok := shared.ParseGuildID(s, i)
+	if !ok {
+		return
+	}
+
+	options, err := activeProjectOptions(context.Background(), guildID)
+	if err != nil {
+		shared.RespondEphemeral(s, i, "Failed to load projects.")
+		return
+	}
+	if len(options) == 0 {
+		shared.RespondEphemeral(s, i, "There are no active projects to close.")
+		return
+	}
+
+	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{
+			Content: "Which project should be closed?",
+			Flags:   discordgo.MessageFlagsEphemeral,
+			Components: []discordgo.MessageComponent{
+				discordgo.ActionsRow{
+					Components: []discordgo.MessageComponent{
+						discordgo.SelectMenu{
+							CustomID:    "projects:close_select",
+							Placeholder: "Select a project",
+							Options:     options,
+						},
+					},
+				},
+			},
+		},
+	})
+}
+
+// activeProjectOptions builds select-menu options for the guild's active
+// projects, truncating name/description to Discord's option limits
+// (label: 100 chars, description: 100 chars).
+func activeProjectOptions(ctx context.Context, guildID int64) ([]discordgo.SelectMenuOption, error) {
+	const limit = 25 // Discord's own cap on select menu options
+	items, err := services.Global.Projects.ListActive(ctx, guildID, limit)
+	if err != nil {
+		return nil, err
+	}
+
+	options := make([]discordgo.SelectMenuOption, 0, len(items))
+	for _, p := range items {
+		if p == nil {
+			continue
+		}
+		name := p.Name
+		if name == "" {
+			name = "Unnamed project"
+		}
+		options = append(options, discordgo.SelectMenuOption{
+			Label:       truncate(name, 100),
+			Value:       strconv.FormatInt(p.ID, 10),
+			Description: truncate(p.Description, 100),
+		})
+	}
+	return options, nil
+}
+
+func truncate(s string, max int) string {
+	if len(s) <= max {
+		return s
+	}
+	return s[:max]
+}

internal/commands/projects/registry.go

@@ -12,3 +12,9 @@ var (
 
 func ProjectsHandler(s *discordgo.Session, i *discordgo.InteractionCreate) { public.ProjectsHandler(s, i) }
 
+func HandleComponent(s *discordgo.Session, i *discordgo.InteractionCreate) { public.HandleComponent(s, i) }
+
+func HandleModalSubmit(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	public.HandleModalSubmit(s, i)
+}
+

internal/commands/schedule/public/components.go

@@ -0,0 +1,794 @@
+package public
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strconv"
+	"strings"
+	"time"
+	"velox-bot/internal/commands/schedule/shared"
+	"velox-bot/internal/db/repos/schedulerepo"
+	"velox-bot/internal/db/services"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+func scheduleActionButtons(scheduleID int64) []discordgo.MessageComponent {
+
+	idStr := strconv.FormatInt(scheduleID, 10)
+
+	return []discordgo.MessageComponent{
+		discordgo.ActionsRow{
+			Components: []discordgo.MessageComponent{
+				discordgo.Button{
+					Label:    "Accept",
+					Style:    discordgo.SuccessButton,
+					CustomID: "schedule:accept:" + idStr,
+				},
+				discordgo.Button{
+					Label:    "Decline",
+					Style:    discordgo.DangerButton,
+					CustomID: "schedule:decline:" + idStr,
+				},
+				discordgo.Button{
+					Label:    "Reschedule",
+					Style:    discordgo.SecondaryButton,
+					CustomID: "schedule:reschedule:" + idStr,
+				},
+			},
+		},
+	}
+}
+
+func rescheduleProposalButtons(scheduleID int64) []discordgo.MessageComponent {
+	idStr := strconv.FormatInt(scheduleID, 10)
+
+	return []discordgo.MessageComponent{
+		discordgo.ActionsRow{
+			Components: []discordgo.MessageComponent{
+				discordgo.Button{
+					Label:    "Accept",
+					Style:    discordgo.SuccessButton,
+					CustomID: "schedule:accept_reschedule:" + idStr,
+				},
+				discordgo.Button{
+					Label:    "Decline",
+					Style:    discordgo.DangerButton,
+					CustomID: "schedule:decline_reschedule:" + idStr,
+				},
+				discordgo.Button{
+					Label:    "Propose different time",
+					Style:    discordgo.SecondaryButton,
+					CustomID: "schedule:reschedule:" + idStr,
+				},
+			},
+		},
+	}
+}
+
+const createUserSelectCustomID = "schedule:create_user_select"
+
+func HandleComponent(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if i.MessageComponentData().CustomID == createUserSelectCustomID {
+		handleCreateUserSelect(s, i)
+		return
+	}
+
+	ctx := context.Background()
+	action, scheduleID := parseComponentCustomID(i.MessageComponentData().CustomID)
+
+	userIDStr := interactionUserID(i)
+	userID, err := strconv.ParseInt(userIDStr, 10, 64)
+	if err != nil {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Error parsing user ID.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	sch, err := services.Global.Schedule.GetByID(ctx, scheduleID)
+	if err != nil || sch == nil {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Error retrieving schedule.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	var status schedulerepo.ScheduleStatus
+	var message string
+
+	switch action {
+	case "accept":
+		if userID != sch.InviteeID {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "You are not authorized to perform this action.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+		if sch.Status != schedulerepo.StatusPending {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "This schedule is no longer pending.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+
+		status = schedulerepo.StatusAccepted
+		message = "✅ Accepted"
+	case "decline":
+		if userID != sch.InviteeID {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "You are not authorized to perform this action.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+		if sch.Status != schedulerepo.StatusPending {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "This schedule is no longer pending.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+		status = schedulerepo.StatusDeclined
+		message = "❌ Declined"
+	case "reschedule":
+		if userID != sch.InviteeID && userID != sch.RequesterID {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "You are not authorized to perform this action.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+
+		if sch.Status != schedulerepo.StatusPending && sch.Status != schedulerepo.StatusAccepted {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "This schedule can't be rescheduled right now.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseModal,
+			Data: &discordgo.InteractionResponseData{
+				CustomID: "schedule:reschedule_modal:" + strconv.FormatInt(scheduleID, 10),
+				Title:    "Propose a new time",
+				Components: []discordgo.MessageComponent{
+					discordgo.ActionsRow{
+						Components: []discordgo.MessageComponent{
+							discordgo.TextInput{
+								CustomID:    "date",
+								Label:       "Date (YYYY-MM-DD)",
+								Style:       discordgo.TextInputShort,
+								Required:    true,
+								Placeholder: "2026-01-02",
+							},
+						},
+					},
+					discordgo.ActionsRow{
+						Components: []discordgo.MessageComponent{
+							discordgo.TextInput{
+								CustomID:    "time",
+								Label:       "Time (HH:MM, your timezone)",
+								Style:       discordgo.TextInputShort,
+								Required:    true,
+								Placeholder: "15:04",
+							},
+						},
+					},
+				},
+			},
+		})
+		return
+	case "accept_reschedule":
+		if sch.ProposedBy == nil {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "There is no reschedule proposal to accept.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+
+		if (userID != sch.RequesterID && userID != sch.InviteeID) || userID == *sch.ProposedBy {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "You are not authorized to perform this action.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+
+		if sch.Status != schedulerepo.StatusRescheduleRequested {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "There is no reschedule request to accept.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+
+		err = services.Global.Schedule.AcceptReschedule(ctx, scheduleID)
+		if err != nil {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "Error accepting reschedule.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseUpdateMessage,
+			Data: &discordgo.InteractionResponseData{
+				Content:    "✅ Reschedule accepted",
+				Components: []discordgo.MessageComponent{},
+			},
+		})
+
+		newTime := *sch.ProposedAt
+		utcStr := newTime.UTC().Format("2006-01-02 15:04")
+
+		loc, zone, _, err := services.Global.UserSettings.GetTimezone(ctx, *sch.ProposedBy)
+		if err != nil {
+			loc = time.UTC
+			zone = "UTC"
+		}
+		localStr := newTime.In(loc).Format("2006-01-02 15:04")
+
+		content := "Your proposed time for the session was accepted: " +
+			utcStr + " UTC (" + localStr + " " + zone + ")."
+
+		dmCh, err := s.UserChannelCreate(strconv.FormatInt(*sch.ProposedBy, 10))
+		if err == nil {
+			if _, err := s.ChannelMessageSend(dmCh.ID, content); err != nil {
+				log.Printf("schedule: failed to DM proposer about accepted reschedule: %v", err)
+			}
+		}
+		return
+	case "decline_reschedule":
+		if sch.ProposedBy == nil {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "There is no reschedule proposal to accept.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+
+		if (userID != sch.RequesterID && userID != sch.InviteeID) || userID == *sch.ProposedBy {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "You are not authorized to perform this action.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+
+		if sch.Status != schedulerepo.StatusRescheduleRequested {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "There is no reschedule request to accept.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+
+		err = services.Global.Schedule.DeclineReschedule(ctx, scheduleID)
+		if err != nil {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "Error declining reschedule.",
+					Flags:   discordgo.MessageFlagsEphemeral,
+				},
+			})
+			return
+		}
+
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseUpdateMessage,
+			Data: &discordgo.InteractionResponseData{
+				Content:    "❌ Reschedule declined",
+				Components: []discordgo.MessageComponent{},
+			},
+		})
+
+		utcStr := sch.ScheduledAt.UTC().Format("2006-01-02 15:04")
+
+		loc, zone, _, err := services.Global.UserSettings.GetTimezone(ctx, *sch.ProposedBy)
+		if err != nil {
+			loc = time.UTC
+			zone = "UTC"
+		}
+		localStr := sch.ScheduledAt.In(loc).Format("2006-01-02 15:04")
+
+		content := "Your proposed new time was declined. The session remains scheduled for " +
+			utcStr + " UTC (" + localStr + " " + zone + ")."
+
+		dmCh, err := s.UserChannelCreate(strconv.FormatInt(*sch.ProposedBy, 10))
+		if err == nil {
+			if _, err := s.ChannelMessageSend(dmCh.ID, content); err != nil {
+				log.Printf("schedule: failed to DM proposer about declined reschedule: %v", err)
+			}
+		}
+		return
+	default:
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Unknown action.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	err = services.Global.Schedule.UpdateStatus(ctx, scheduleID, status)
+	if err != nil {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Error updating schedule.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseUpdateMessage,
+		Data: &discordgo.InteractionResponseData{
+			Content:    message,
+			Components: []discordgo.MessageComponent{},
+		},
+	})
+
+	statusText := map[schedulerepo.ScheduleStatus]string{
+		schedulerepo.StatusAccepted:            "accepted ✅",
+		schedulerepo.StatusDeclined:            "declined ❌",
+		schedulerepo.StatusRescheduleRequested: "requested rescheduling 🔁",
+	}[status]
+
+	utcStr := sch.ScheduledAt.UTC().Format("2006-01-02 15:04")
+
+	// Notify requester with local time if configured.
+	if services.Global.UserSettings != nil {
+		loc, zone, _, err := services.Global.UserSettings.GetTimezone(ctx, sch.RequesterID)
+		if err != nil {
+			loc = sch.ScheduledAt.UTC().Location()
+			zone = "UTC"
+		}
+		localStr := sch.ScheduledAt.In(loc).Format("2006-01-02 15:04")
+		content := "Your session request with <@" + strconv.FormatInt(sch.InviteeID, 10) + "> for " +
+			utcStr + " UTC (" + localStr + " " + zone + ") has been " + statusText + "."
+
+		requesterID := strconv.FormatInt(sch.RequesterID, 10)
+		dmCh, err := s.UserChannelCreate(requesterID)
+		if err == nil {
+			if _, err := s.ChannelMessageSend(dmCh.ID, content); err != nil {
+				log.Printf("schedule: failed to DM requester about status change: %v", err)
+			}
+		}
+	}
+}
+
+func handleCreateUserSelect(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	values := i.MessageComponentData().Values
+	if len(values) == 0 {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "No user selected.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+	targetUserID := values[0]
+
+	if targetUserID == interactionUserID(i) {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "You cannot schedule a session with yourself.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseModal,
+		Data: &discordgo.InteractionResponseData{
+			CustomID: "schedule:create_modal:" + targetUserID,
+			Title:    "Schedule a session",
+			Components: []discordgo.MessageComponent{
+				discordgo.ActionsRow{
+					Components: []discordgo.MessageComponent{
+						discordgo.TextInput{
+							CustomID:    "date",
+							Label:       "Date (YYYY-MM-DD)",
+							Style:       discordgo.TextInputShort,
+							Required:    true,
+							Placeholder: "2026-01-02",
+						},
+					},
+				},
+				discordgo.ActionsRow{
+					Components: []discordgo.MessageComponent{
+						discordgo.TextInput{
+							CustomID:    "time",
+							Label:       "Time (HH:MM, your timezone)",
+							Style:       discordgo.TextInputShort,
+							Required:    true,
+							Placeholder: "15:04",
+						},
+					},
+				},
+				discordgo.ActionsRow{
+					Components: []discordgo.MessageComponent{
+						discordgo.TextInput{
+							CustomID: "description",
+							Label:    "Description (optional)",
+							Style:    discordgo.TextInputShort,
+							Required: false,
+						},
+					},
+				},
+			},
+		},
+	})
+}
+
+func modalTextInputValues(components []discordgo.MessageComponent) map[string]string {
+	values := make(map[string]string)
+	for _, c := range components {
+		row, ok := c.(*discordgo.ActionsRow)
+		if !ok {
+			continue
+		}
+		for _, rc := range row.Components {
+			ti, ok := rc.(*discordgo.TextInput)
+			if !ok {
+				continue
+			}
+			values[ti.CustomID] = ti.Value
+		}
+	}
+	return values
+}
+
+func handleCreateModalSubmit(ctx context.Context, s *discordgo.Session, i *discordgo.InteractionCreate, inviteeID int64) {
+	guildID, ok := shared.ParseGuildID(s, i)
+	if !ok {
+		return
+	}
+
+	requesterID, err := strconv.ParseInt(interactionUserID(i), 10, 64)
+	if err != nil {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Invalid user ID.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	if requesterID == inviteeID {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "You cannot schedule a session with yourself.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	values := modalTextInputValues(i.ModalSubmitData().Components)
+	dateStr := strings.TrimSpace(values["date"])
+	timeStr := strings.TrimSpace(values["time"])
+	desc := strings.TrimSpace(values["description"])
+
+	loc, zone, _, err := services.Global.UserSettings.GetTimezone(ctx, requesterID)
+	if err != nil {
+		loc = time.UTC
+		zone = "UTC"
+	}
+
+	when, err := shared.ParseScheduleDatetime(dateStr+" "+timeStr, loc)
+	if err != nil {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Invalid date/time. Use YYYY-MM-DD for the date and HH:MM for the time, in your timezone (" + zone + ").",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+	when = when.In(time.UTC)
+
+	scheduleID, err := services.Global.Schedule.CreateSchedule(ctx, guildID, requesterID, inviteeID, when, desc)
+	if err != nil {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Failed to create schedule.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	dmCh, err := s.UserChannelCreate(strconv.FormatInt(inviteeID, 10))
+	if err != nil {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Session created, but failed to DM the invited user (are DMs disabled?).",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	embed := &discordgo.MessageEmbed{
+		Title:       "New session request",
+		Description: fmt.Sprintf("You have been invited to a session by <@%d>.", requesterID),
+		Color:       0x4caf50,
+	}
+	utcStr := when.Format("2006-01-02 15:04")
+	locInv, zoneInv, _, err := services.Global.UserSettings.GetTimezone(ctx, inviteeID)
+	if err != nil {
+		locInv = time.UTC
+		zoneInv = "UTC"
+	}
+	localInvStr := when.In(locInv).Format("2006-01-02 15:04")
+	embed.Fields = []*discordgo.MessageEmbedField{
+		{Name: "When (UTC)", Value: utcStr},
+		{Name: "When (" + zoneInv + ")", Value: localInvStr},
+	}
+	if desc != "" {
+		embed.Fields = append(embed.Fields, &discordgo.MessageEmbedField{
+			Name:  "Description",
+			Value: desc,
+		})
+	}
+
+	_, err = s.ChannelMessageSendComplex(dmCh.ID, &discordgo.MessageSend{
+		Content:    "Respond to this session request:",
+		Embed:      embed,
+		Components: scheduleActionButtons(scheduleID),
+	})
+	if err != nil {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Session created, but failed to DM the invited user.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{
+			Content: "Session request created and sent to <@" + strconv.FormatInt(inviteeID, 10) + ">.",
+			Flags:   discordgo.MessageFlagsEphemeral,
+		},
+	})
+}
+
+func HandleModalSubmit(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	ctx := context.Background()
+	action, idOrUserID := parseComponentCustomID(i.ModalSubmitData().CustomID)
+
+	if action == "create_modal" {
+		handleCreateModalSubmit(ctx, s, i, idOrUserID)
+		return
+	}
+
+	scheduleID := idOrUserID
+	if scheduleID == 0 {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Invalid schedule ID.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	modalValues := modalTextInputValues(i.ModalSubmitData().Components)
+	datetimeInput := strings.TrimSpace(modalValues["date"]) + " " + strings.TrimSpace(modalValues["time"])
+	sch, err := services.Global.Schedule.GetByID(ctx, scheduleID)
+	if err != nil || sch == nil {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Error retrieving schedule.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	userIDStr := interactionUserID(i)
+	userID, err := strconv.ParseInt(userIDStr, 10, 64)
+	if err != nil {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Error parsing user ID.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	if userID != sch.InviteeID && userID != sch.RequesterID {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "You are not authorized to perform this action.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	loc, _, _, err := services.Global.UserSettings.GetTimezone(ctx, userID)
+	if err != nil {
+		loc = sch.ScheduledAt.UTC().Location()
+	}
+
+	newTime, err := shared.ParseScheduleDatetime(datetimeInput, loc)
+	if err != nil {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Invalid date/time. Use YYYY-MM-DD for the date and HH:MM for the time.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	//Convert time to UTC before storing in the database
+	newTime = newTime.UTC()
+
+	err = services.Global.Schedule.ProposeReschedule(ctx, scheduleID, newTime, userID)
+	if err != nil {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Error proposing reschedule.",
+				Flags:   discordgo.MessageFlagsEphemeral,
+			},
+		})
+		return
+	}
+
+	otherID := sch.RequesterID
+	if userID == sch.RequesterID {
+		otherID = sch.InviteeID
+	}
+
+	dmCh, err := s.UserChannelCreate(strconv.FormatInt(otherID, 10))
+	if err != nil {
+		shared.RespondEphemeral(s, i, "Failed to DM the invited user (are DMs disabled?).")
+		return
+	}
+
+	embed := &discordgo.MessageEmbed{
+		Title:       "Reschedule Proposal",
+		Description: fmt.Sprintf("<@%d> has proposed a new time for your session request. Please respond.", userID),
+		Color:       0x4caf50,
+	}
+
+	// Show both UTC and invitee-local time if available.
+	utcStr := newTime.Format("2006-01-02 15:04")
+	locInv, zoneInv, _, err := services.Global.UserSettings.GetTimezone(context.Background(), otherID)
+	if err != nil {
+		locInv = time.UTC
+		zoneInv = "UTC"
+	}
+	localInvStr := newTime.In(locInv).Format("2006-01-02 15:04")
+	embed.Fields = []*discordgo.MessageEmbedField{
+		{
+			Name:  "When (UTC)",
+			Value: utcStr,
+		},
+		{
+			Name:  "When (" + zoneInv + ")",
+			Value: localInvStr,
+		},
+	}
+
+	_, err = s.ChannelMessageSendComplex(dmCh.ID, &discordgo.MessageSend{
+		Content:    "A new time has been proposed for your session:",
+		Embed:      embed,
+		Components: rescheduleProposalButtons(scheduleID),
+	})
+	if err != nil {
+		shared.RespondEphemeral(s, i, "Failed to DM the other participant.")
+		return
+	}
+
+	shared.RespondEphemeral(s, i, "Proposed new time sent to <@"+strconv.FormatInt(otherID, 10)+">.")
+
+}
+
+func parseComponentCustomID(customID string) (string, int64) {
+	parts := strings.Split(customID, ":")
+	if len(parts) != 3 {
+		return "", 0
+	}
+
+	action := parts[1]
+	scheduleID, err := strconv.ParseInt(parts[2], 10, 64)
+	if err != nil {
+		return "", 0
+	}
+
+	return action, scheduleID
+}
+
+func interactionUserID(i *discordgo.InteractionCreate) string {
+	if i.Member != nil && i.Member.User != nil {
+		return i.Member.User.ID
+	}
+	if i.User != nil {
+		return i.User.ID
+	}
+	return ""
+}

internal/commands/schedule/public/schedule.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"velox-bot/internal/commands/schedule/shared"
+	"velox-bot/internal/db/repos/schedulerepo"
 	"velox-bot/internal/db/services"
 
 	"github.com/bwmarrin/discordgo"
@@ -21,26 +22,6 @@ var Schedule = &discordgo.ApplicationCommand{
 			Type:        discordgo.ApplicationCommandOptionSubCommand,
 			Name:        "create",
 			Description: "Create a new session with a user",
-			Options: []*discordgo.ApplicationCommandOption{
-				{
-					Type:        discordgo.ApplicationCommandOptionUser,
-					Name:        "user",
-					Description: "User to invite",
-					Required:    true,
-				},
-				{
-					Type:        discordgo.ApplicationCommandOptionString,
-					Name:        "datetime",
-					Description: "When (UTC), format: 2006-01-02 15:04",
-					Required:    true,
-				},
-				{
-					Type:        discordgo.ApplicationCommandOptionString,
-					Name:        "description",
-					Description: "What is this session about? (optional)",
-					Required:    false,
-				},
-			},
 		},
 		{
 			Type:        discordgo.ApplicationCommandOptionSubCommand,
@@ -93,8 +74,7 @@ func ScheduleHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
 }
 
 func handleCreate(s *discordgo.Session, i *discordgo.InteractionCreate) {
-	guildID, ok := shared.ParseGuildID(s, i)
-	if !ok {
+	if _, ok := shared.ParseGuildID(s, i); !ok {
 		return
 	}
 	if i.Member == nil || i.Member.User == nil {
@@ -102,133 +82,24 @@ func handleCreate(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		return
 	}
 
-	data := i.ApplicationCommandData()
-	if len(data.Options) == 0 {
-		shared.RespondEphemeral(s, i, "Missing options.")
-		return
-	}
-	opt := data.Options[0]
-
-	var (
-		targetUser *discordgo.User
-		whenStr    string
-		desc       string
-	)
-	for _, o := range opt.Options {
-		switch o.Name {
-		case "user":
-			targetUser = o.UserValue(s)
-		case "datetime":
-			whenStr = o.StringValue()
-		case "description":
-			desc = o.StringValue()
-		}
-	}
-
-	if targetUser == nil {
-		shared.RespondEphemeral(s, i, "Invalid user.")
-		return
-	}
-	if targetUser.ID == i.Member.User.ID {
-		shared.RespondEphemeral(s, i, "You cannot schedule a session with yourself.")
-		return
-	}
-
-	requesterID, err := strconv.ParseInt(i.Member.User.ID, 10, 64)
-	if err != nil {
-		shared.RespondEphemeral(s, i, "Invalid user ID.")
-		return
-	}
-	inviteeID, err := strconv.ParseInt(targetUser.ID, 10, 64)
-	if err != nil {
-		shared.RespondEphemeral(s, i, "Invalid target user ID.")
-		return
-	}
-
-	whenStr = strings.TrimSpace(whenStr)
-	if whenStr == "" {
-		shared.RespondEphemeral(s, i, "Datetime cannot be empty.")
-		return
-	}
-
-	// Resolve requester's timezone and parse input using explicit layout in that zone.
-	loc, zone, _, err := services.Global.UserSettings.GetTimezone(context.Background(), requesterID)
-	if err != nil {
-		loc = time.UTC
-		zone = "UTC"
-	}
-	// Expect layout "2006-01-02 15:04" in the user's timezone.
-	when, err := time.ParseInLocation("2006-01-02 15:04", whenStr, loc)
-	if err != nil {
-		shared.RespondEphemeral(s, i, "Invalid datetime. Use `2006-01-02 15:04` in your timezone ("+zone+").")
-		return
-	}
-	when = when.In(time.UTC)
-
-	ctx := context.Background()
-	scheduleID, err := services.Global.Schedule.CreateSchedule(ctx, guildID, requesterID, inviteeID, when, desc)
-	if err != nil {
-		shared.RespondEphemeral(s, i, "Failed to create schedule.")
-		return
-	}
-
-	// Send DM to invitee.
-	dmCh, err := s.UserChannelCreate(targetUser.ID)
-	if err != nil {
-		shared.RespondEphemeral(s, i, "Failed to DM the invited user (are DMs disabled?).")
-		return
-	}
-
-	embed := &discordgo.MessageEmbed{
-		Title:       "New session request",
-		Description: fmt.Sprintf("You have been invited to a session by <@%s>.", i.Member.User.ID),
-		Color:       0x4caf50,
-	}
-	// Show both UTC and invitee-local time if available.
-	utcStr := when.Format("2006-01-02 15:04")
-	locInv, zoneInv, _, err := services.Global.UserSettings.GetTimezone(context.Background(), inviteeID)
-	if err != nil {
-		locInv = time.UTC
-		zoneInv = "UTC"
-	}
-	localInvStr := when.In(locInv).Format("2006-01-02 15:04")
-	embed.Fields = []*discordgo.MessageEmbedField{
-		{
-			Name:  "When (UTC)",
-			Value: utcStr,
+	s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{
+			Content: "Who do you want to schedule a session with?",
+			Flags:   discordgo.MessageFlagsEphemeral,
+			Components: []discordgo.MessageComponent{
+				discordgo.ActionsRow{
+					Components: []discordgo.MessageComponent{
+						discordgo.SelectMenu{
+							MenuType:    discordgo.UserSelectMenu,
+							CustomID:    createUserSelectCustomID,
+							Placeholder: "Select a user",
+						},
+					},
+				},
+			},
 		},
-		{
-			Name:  "When (" + zoneInv + ")",
-			Value: localInvStr,
-		},
-	}
-	if desc != "" {
-		embed.Fields = append(embed.Fields, &discordgo.MessageEmbedField{
-			Name:  "Description",
-			Value: desc,
-		})
-	}
-
-	msg, err := s.ChannelMessageSendComplex(dmCh.ID, &discordgo.MessageSend{
-		Content: "React with ✅ to accept, ❌ to decline, or 🔁 to request rescheduling.",
-		Embed:   embed,
 	})
-	if err != nil {
-		shared.RespondEphemeral(s, i, "Failed to DM the invited user.")
-		return
-	}
-
-	// Add reactions for interaction.
-	for _, emoji := range []string{"✅", "❌", "🔁"} {
-		_ = s.MessageReactionAdd(dmCh.ID, msg.ID, emoji)
-	}
-
-	// Store linkage between message and schedule.
-	msgID64, _ := strconv.ParseInt(msg.ID, 10, 64)
-	chID64, _ := strconv.ParseInt(dmCh.ID, 10, 64)
-	_ = services.Global.Schedule.AddMessage(ctx, scheduleID, msgID64, chID64, true)
-
-	shared.RespondEphemeral(s, i, "Session request created and sent to "+targetUser.Mention()+".")
 }
 
 func handleList(s *discordgo.Session, i *discordgo.InteractionCreate) {
@@ -338,6 +209,11 @@ func handleReschedule(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		return
 	}
 
+	if sch.Status != schedulerepo.StatusPending && sch.Status != schedulerepo.StatusAccepted {
+		shared.RespondEphemeral(s, i, "This session can't be rescheduled right now.")
+		return
+	}
+
 	// Use rescheduler's timezone for parsing.
 	loc, zone, _, err := services.Global.UserSettings.GetTimezone(ctx, userID)
 	if err != nil {
@@ -345,19 +221,18 @@ func handleReschedule(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		zone = "UTC"
 	}
 	// Expect explicit layout "2006-01-02 15:04" in user's timezone.
-	when, err := time.ParseInLocation("2006-01-02 15:04", whenStr, loc)
+	when, err := shared.ParseScheduleDatetime(whenStr, loc)
 	if err != nil {
-		shared.RespondEphemeral(s, i, "Invalid datetime. Use `2006-01-02 15:04` in your timezone ("+zone+").")
+		shared.RespondEphemeral(s, i, err.Error()+" (use `2006-01-02 15:04` in your timezone: "+zone+")")
 		return
 	}
 	when = when.In(time.UTC)
 
-	if err := services.Global.Schedule.Reschedule(ctx, sch.ID, when); err != nil {
-		shared.RespondEphemeral(s, i, "Failed to reschedule session.")
+	if err := services.Global.Schedule.ProposeReschedule(ctx, sch.ID, when, userID); err != nil {
+		shared.RespondEphemeral(s, i, "Failed to propose reschedule.")
 		return
 	}
 
-	// Notify participants via DM and send new request DM to invitee.
 	whenFmt := when.Format("2006-01-02 15:04")
 
 	otherID := sch.InviteeID
@@ -365,75 +240,50 @@ func handleReschedule(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		otherID = sch.RequesterID
 	}
 
-	// DM both about the change, including their local times if available.
-	for _, uid := range []int64{sch.RequesterID, sch.InviteeID} {
-		locU, zoneU, _, err := services.Global.UserSettings.GetTimezone(ctx, uid)
-		if err != nil {
-			locU = time.UTC
-			zoneU = "UTC"
-		}
-		localU := when.In(locU).Format("2006-01-02 15:04")
-		msg := fmt.Sprintf("Session `%d` has been rescheduled to %s UTC (%s %s) with <@%d>.", sch.ID, whenFmt, localU, zoneU, otherID)
-		if sch.Description != "" {
-			msg += "\nTopic: " + sch.Description
-		}
-		ch, err := s.UserChannelCreate(strconv.FormatInt(uid, 10))
-		if err != nil {
-			continue
-		}
-		_, _ = s.ChannelMessageSend(ch.ID, msg)
+	dmCh, err := s.UserChannelCreate(strconv.FormatInt(otherID, 10))
+	if err != nil {
+		shared.RespondEphemeral(s, i, "Proposal saved, but failed to DM the other participant (are DMs disabled?).")
+		return
 	}
 
-	// Send new "request" DM to invitee with reactions again.
-	inviteeStr := strconv.FormatInt(sch.InviteeID, 10)
-	inviteeUser, err := s.User(inviteeStr)
-	if err == nil && inviteeUser != nil {
-		dmCh, err := s.UserChannelCreate(inviteeStr)
-		if err == nil {
-			embed := &discordgo.MessageEmbed{
-				Title:       "Rescheduled session",
-				Description: fmt.Sprintf("Session `%d` has been rescheduled by <@%s>.", sch.ID, i.Member.User.ID),
-				Color:       0xffc107,
-			}
-			// Show both UTC and invitee-local time if available.
-			locInv, zoneInv, _, errTZ := services.Global.UserSettings.GetTimezone(ctx, sch.InviteeID)
-			if errTZ != nil {
-				locInv = time.UTC
-				zoneInv = "UTC"
-			}
-			localInvStr := when.In(locInv).Format("2006-01-02 15:04")
-			embed.Fields = []*discordgo.MessageEmbedField{
-				{
-					Name:  "When (UTC)",
-					Value: whenFmt,
-				},
-				{
-					Name:  "When (" + zoneInv + ")",
-					Value: localInvStr,
-				},
-			}
-			if sch.Description != "" {
-				embed.Fields = append(embed.Fields, &discordgo.MessageEmbedField{
-					Name:  "Description",
-					Value: sch.Description,
-				})
-			}
-			msgObj, err := s.ChannelMessageSendComplex(dmCh.ID, &discordgo.MessageSend{
-				Content: "React with ✅ to accept, ❌ to decline, or 🔁 to request another reschedule.",
-				Embed:   embed,
-			})
-			if err == nil && msgObj != nil {
-				for _, emoji := range []string{"✅", "❌", "🔁"} {
-					_ = s.MessageReactionAdd(dmCh.ID, msgObj.ID, emoji)
-				}
-				msgID64, _ := strconv.ParseInt(msgObj.ID, 10, 64)
-				chID64, _ := strconv.ParseInt(dmCh.ID, 10, 64)
-				_ = services.Global.Schedule.AddMessage(ctx, sch.ID, msgID64, chID64, true)
-			}
-		}
+	embed := &discordgo.MessageEmbed{
+		Title:       "Reschedule proposed",
+		Description: fmt.Sprintf("<@%s> has proposed a new time for your session.", i.Member.User.ID),
+		Color:       0x4caf50,
+	}
+	// Show both UTC and the other participant's local time if available.
+	locOther, zoneOther, _, errTZ := services.Global.UserSettings.GetTimezone(ctx, otherID)
+	if errTZ != nil {
+		locOther = time.UTC
+		zoneOther = "UTC"
+	}
+	localOtherStr := when.In(locOther).Format("2006-01-02 15:04")
+	embed.Fields = []*discordgo.MessageEmbedField{
+		{
+			Name:  "When (UTC)",
+			Value: whenFmt,
+		},
+		{
+			Name:  "When (" + zoneOther + ")",
+			Value: localOtherStr,
+		},
+	}
+	if sch.Description != "" {
+		embed.Fields = append(embed.Fields, &discordgo.MessageEmbedField{
+			Name:  "Description",
+			Value: sch.Description,
+		})
 	}
 
-	shared.RespondEphemeral(s, i, "Session rescheduled to "+whenFmt+" UTC.")
+	_, err = s.ChannelMessageSendComplex(dmCh.ID, &discordgo.MessageSend{
+		Content:    "A new time has been proposed for your session:",
+		Embed:      embed,
+		Components: rescheduleProposalButtons(sch.ID),
+	})
+	if err != nil {
+		shared.RespondEphemeral(s, i, "Proposal saved, but failed to DM the other participant.")
+		return
+	}
+
+	shared.RespondEphemeral(s, i, "Proposed new time sent to <@"+strconv.FormatInt(otherID, 10)+">.")
 }
-
-

internal/commands/schedule/registry.go

@@ -10,5 +10,13 @@ var (
 	Schedule *discordgo.ApplicationCommand = public.Schedule
 )
 
-func ScheduleHandler(s *discordgo.Session, i *discordgo.InteractionCreate) { public.ScheduleHandler(s, i) }
+func ScheduleHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	public.ScheduleHandler(s, i)
+}
+func HandleComponent(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	public.HandleComponent(s, i)
+}
 
+func HandleModalSubmit(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	public.HandleModalSubmit(s, i)
+}

internal/commands/schedule/shared/shared.go

@@ -1,13 +1,22 @@
 package shared
 
 import (
+	"fmt"
 	"strconv"
+	"time"
 
 	"velox-bot/internal/db/services"
 
 	"github.com/bwmarrin/discordgo"
 )
 
+var scheduleDatetimeLayouts = []string{
+	"2006-01-02 15:04",
+	"2006-01-02T15:04",
+	"2006-01-02 15:04:05",
+	"01/02/2006 15:04",
+}
+
 func RespondEphemeral(s *discordgo.Session, i *discordgo.InteractionCreate, msg string) {
 	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
 		Type: discordgo.InteractionResponseChannelMessageWithSource,
@@ -18,6 +27,15 @@ func RespondEphemeral(s *discordgo.Session, i *discordgo.InteractionCreate, msg
 	})
 }
 
+func ParseScheduleDatetime(input string, loc *time.Location) (time.Time, error) {
+	for _, layout := range scheduleDatetimeLayouts {
+		if t, err := time.ParseInLocation(layout, input, loc); err == nil {
+			return t, nil
+		}
+	}
+	return time.Time{}, fmt.Errorf("invalid schedule datetime format")
+}
+
 func RequireGuild(s *discordgo.Session, i *discordgo.InteractionCreate) bool {
 	if i.GuildID == "" {
 		RespondEphemeral(s, i, "This command can only be used in a server.")
@@ -42,4 +60,3 @@ func ParseGuildID(s *discordgo.Session, i *discordgo.InteractionCreate) (int64,
 	}
 	return guildID, true
 }
-

internal/commands/tickets/public/tickets.go

@@ -0,0 +1,514 @@
+package public
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"strconv"
+	"strings"
+	"time"
+
+	"velox-bot/internal/db/repos/ticketrepo"
+	"velox-bot/internal/tickets"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// The session must provide everything the ticket flows call.
+var _ tickets.Discord = (*discordgo.Session)(nil)
+
+// Repo is the full ticket store, including the admin calls that only the
+// slash commands make. Set by Init.
+var Repo *ticketrepo.Repo
+
+func Init(r *ticketrepo.Repo) {
+	Repo = r
+	tickets.Init(r)
+}
+
+var (
+	manageGuild   = int64(discordgo.PermissionManageGuild)
+	guildOnly     = &[]discordgo.InteractionContextType{discordgo.InteractionContextGuild}
+	textChannels  = []discordgo.ChannelType{discordgo.ChannelTypeGuildText}
+	opTimeout     = 2 * time.Minute
+	genericFailed = "Something went wrong. Try again in a moment, and tell an admin if it keeps happening."
+)
+
+// Tickets is the admin command for setting the system up.
+var Tickets = &discordgo.ApplicationCommand{
+	Name:                     "tickets",
+	Description:              "Set up support tickets",
+	DefaultMemberPermissions: &manageGuild,
+	Contexts:                 guildOnly,
+	Options: []*discordgo.ApplicationCommandOption{
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "setup",
+			Description: "Choose where tickets are opened and where closed tickets are logged",
+			Options: []*discordgo.ApplicationCommandOption{
+				{Type: discordgo.ApplicationCommandOptionChannel, Name: "channel", Description: "Where the panel goes and ticket threads are created", Required: true, ChannelTypes: textChannels},
+				{Type: discordgo.ApplicationCommandOptionChannel, Name: "log-channel", Description: "Where closed tickets and their transcripts are posted", ChannelTypes: textChannels},
+				{Type: discordgo.ApplicationCommandOptionRole, Name: "staff-role", Description: "Creates a Support category handled by this role, if there are no categories yet"},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommandGroup,
+			Name:        "category",
+			Description: "Manage ticket categories",
+			Options: []*discordgo.ApplicationCommandOption{
+				{
+					Type:        discordgo.ApplicationCommandOptionSubCommand,
+					Name:        "add",
+					Description: "Add a category (one button on the panel)",
+					Options: []*discordgo.ApplicationCommandOption{
+						{Type: discordgo.ApplicationCommandOptionString, Name: "name", Description: "e.g. Support, Report, Appeal", Required: true, MaxLength: 40},
+						{Type: discordgo.ApplicationCommandOptionRole, Name: "staff-role", Description: "Who handles these tickets"},
+						{Type: discordgo.ApplicationCommandOptionString, Name: "emoji", Description: "Shown on the button", MaxLength: 64},
+						{Type: discordgo.ApplicationCommandOptionString, Name: "description", Description: "Shown on the panel", MaxLength: 200},
+					},
+				},
+				{
+					Type:        discordgo.ApplicationCommandOptionSubCommand,
+					Name:        "remove",
+					Description: "Remove a category",
+					Options: []*discordgo.ApplicationCommandOption{
+						{Type: discordgo.ApplicationCommandOptionString, Name: "name", Description: "The category's name", Required: true},
+					},
+				},
+				{Type: discordgo.ApplicationCommandOptionSubCommand, Name: "list", Description: "Show the categories"},
+			},
+		},
+		{
+			Type:        discordgo.ApplicationCommandOptionSubCommand,
+			Name:        "panel",
+			Description: "Post the ticket panel, or update it after changing categories",
+		},
+	},
+}
+
+// Ticket is used inside a ticket thread.
+var Ticket = &discordgo.ApplicationCommand{
+	Name:        "ticket",
+	Description: "Manage the ticket you're in",
+	Contexts:    guildOnly,
+	Options: []*discordgo.ApplicationCommandOption{
+		{
+			Type: discordgo.ApplicationCommandOptionSubCommand, Name: "add", Description: "Add someone to this ticket",
+			Options: []*discordgo.ApplicationCommandOption{{Type: discordgo.ApplicationCommandOptionUser, Name: "user", Description: "Who to add", Required: true}},
+		},
+		{
+			Type: discordgo.ApplicationCommandOptionSubCommand, Name: "remove", Description: "Remove someone from this ticket (staff only)",
+			Options: []*discordgo.ApplicationCommandOption{{Type: discordgo.ApplicationCommandOptionUser, Name: "user", Description: "Who to remove", Required: true}},
+		},
+		{Type: discordgo.ApplicationCommandOptionSubCommand, Name: "claim", Description: "Take this ticket (staff only)"},
+		{
+			Type: discordgo.ApplicationCommandOptionSubCommand, Name: "close", Description: "Close this ticket",
+			Options: []*discordgo.ApplicationCommandOption{{Type: discordgo.ApplicationCommandOptionString, Name: "reason", Description: "Why it's being closed", MaxLength: 300}},
+		},
+	},
+}
+
+func reply(s *discordgo.Session, i *discordgo.InteractionCreate, msg string) {
+	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{Content: msg, Flags: discordgo.MessageFlagsEphemeral, AllowedMentions: &discordgo.MessageAllowedMentions{}},
+	})
+}
+
+func deferReply(s *discordgo.Session, i *discordgo.InteractionCreate) bool {
+	err := s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseDeferredChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{Flags: discordgo.MessageFlagsEphemeral},
+	})
+	return err == nil
+}
+
+func edit(s *discordgo.Session, i *discordgo.InteractionCreate, msg string) {
+	_, _ = s.InteractionResponseEdit(i.Interaction, &discordgo.WebhookEdit{Content: &msg, AllowedMentions: &discordgo.MessageAllowedMentions{}})
+}
+
+// message turns an error into what the user sees; unexpected ones are logged.
+func message(where string, err error) string {
+	var ue tickets.UserError
+	if errors.As(err, &ue) {
+		return string(ue)
+	}
+	log.Printf("tickets: %s: %v", where, err)
+	return genericFailed
+}
+
+func actor(i *discordgo.InteractionCreate) tickets.Actor {
+	a := tickets.Actor{Member: i.Member}
+	if i.Member != nil {
+		a.Perms = i.Member.Permissions
+	}
+	return a
+}
+
+func guildID(i *discordgo.InteractionCreate) int64 {
+	n, _ := strconv.ParseInt(i.GuildID, 10, 64)
+	return n
+}
+
+func TicketsHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if Repo == nil {
+		reply(s, i, "Tickets aren't available right now.")
+		return
+	}
+	data := i.ApplicationCommandData()
+	if len(data.Options) == 0 {
+		return
+	}
+	sub := data.Options[0]
+	switch sub.Name {
+	case "setup":
+		handleSetup(s, i, sub.Options)
+	case "panel":
+		handlePanel(s, i)
+	case "category":
+		if len(sub.Options) == 0 {
+			return
+		}
+		switch sub.Options[0].Name {
+		case "add":
+			handleCategoryAdd(s, i, sub.Options[0].Options)
+		case "remove":
+			handleCategoryRemove(s, i, sub.Options[0].Options)
+		case "list":
+			handleCategoryList(s, i)
+		}
+	}
+}
+
+func opts(o []*discordgo.ApplicationCommandInteractionDataOption) map[string]*discordgo.ApplicationCommandInteractionDataOption {
+	m := map[string]*discordgo.ApplicationCommandInteractionDataOption{}
+	for _, x := range o {
+		m[x.Name] = x
+	}
+	return m
+}
+
+// permissionWarning names what the bot is missing in a channel, or "".
+func permissionWarning(s *discordgo.Session, channelID string, need int64, what string) string {
+	have, err := s.UserChannelPermissions(s.State.User.ID, channelID)
+	if err != nil {
+		return ""
+	}
+	if missing := tickets.MissingPerms(have, need); len(missing) > 0 {
+		return fmt.Sprintf("\n⚠️ I'm missing these permissions in <#%s> (%s): %s.", channelID, what, strings.Join(missing, ", "))
+	}
+	return ""
+}
+
+func handleSetup(s *discordgo.Session, i *discordgo.InteractionCreate, o []*discordgo.ApplicationCommandInteractionDataOption) {
+	ctx, cancel := context.WithTimeout(context.Background(), opTimeout)
+	defer cancel()
+	args := opts(o)
+	g := guildID(i)
+
+	ch := args["channel"].ChannelValue(nil).ID
+	var logID int64
+	logMention := "none"
+	if l, ok := args["log-channel"]; ok {
+		lc := l.ChannelValue(nil).ID
+		logID, _ = strconv.ParseInt(lc, 10, 64)
+		logMention = "<#" + lc + ">"
+	}
+	chID, _ := strconv.ParseInt(ch, 10, 64)
+	if err := Repo.SetChannels(ctx, g, chID, logID); err != nil {
+		reply(s, i, message("setup", err))
+		return
+	}
+
+	cats, err := Repo.ListCategories(ctx, g)
+	if err != nil {
+		reply(s, i, message("setup", err))
+		return
+	}
+	created := ""
+	if r, ok := args["staff-role"]; ok && len(cats) == 0 {
+		role := r.RoleValue(nil, i.GuildID)
+		roleID, _ := strconv.ParseInt(role.ID, 10, 64)
+		if _, err := Repo.AddCategory(ctx, ticketrepo.Category{GuildID: g, Name: "Support", Emoji: "🎫", StaffRoleID: roleID}); err != nil {
+			reply(s, i, message("setup", err))
+			return
+		}
+		created = fmt.Sprintf("\nCreated a **Support** category handled by <@&%s>.", role.ID)
+		cats = append(cats, ticketrepo.Category{Name: "Support"})
+	}
+
+	msg := fmt.Sprintf("Tickets will open as private threads in <#%s>. Closed tickets are logged to %s.%s", ch, logMention, created)
+	msg += permissionWarning(s, ch, tickets.NeedTicketChannel, "ticket channel")
+	if logID != 0 {
+		msg += permissionWarning(s, strconv.FormatInt(logID, 10), tickets.NeedLogChannel, "log channel")
+	}
+	if len(cats) == 0 {
+		msg += "\nNext: add a category with `/tickets category add`, then post the panel with `/tickets panel`."
+	} else {
+		msg += "\nNext: post the panel with `/tickets panel`."
+	}
+	msg += "\nTip: give your staff role **Manage Threads** in that channel so they can see every ticket, even ones they weren't pinged in."
+	reply(s, i, msg)
+}
+
+func handlePanel(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !deferReply(s, i) {
+		return
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), opTimeout)
+	defer cancel()
+	msg, err := tickets.PostPanel(ctx, s, Repo, guildID(i))
+	if err != nil {
+		edit(s, i, message("panel", err))
+		return
+	}
+	edit(s, i, fmt.Sprintf("The ticket panel is up: https://discord.com/channels/%s/%s/%s", i.GuildID, msg.ChannelID, msg.ID))
+}
+
+func handleCategoryAdd(s *discordgo.Session, i *discordgo.InteractionCreate, o []*discordgo.ApplicationCommandInteractionDataOption) {
+	ctx, cancel := context.WithTimeout(context.Background(), opTimeout)
+	defer cancel()
+	args := opts(o)
+	g := guildID(i)
+
+	cats, err := Repo.ListCategories(ctx, g)
+	if err != nil {
+		reply(s, i, message("category add", err))
+		return
+	}
+	name := strings.TrimSpace(args["name"].StringValue())
+	for _, c := range cats {
+		if strings.EqualFold(c.Name, name) {
+			reply(s, i, fmt.Sprintf("There's already a category called **%s**.", c.Name))
+			return
+		}
+	}
+	if len(cats) >= 25 {
+		reply(s, i, "A panel can hold at most 25 categories.")
+		return
+	}
+
+	c := ticketrepo.Category{GuildID: g, Name: name}
+	if r, ok := args["staff-role"]; ok {
+		c.StaffRoleID, _ = strconv.ParseInt(r.RoleValue(nil, i.GuildID).ID, 10, 64)
+	}
+	if e, ok := args["emoji"]; ok {
+		c.Emoji = strings.TrimSpace(e.StringValue())
+	}
+	if d, ok := args["description"]; ok {
+		c.Description = strings.TrimSpace(d.StringValue())
+	}
+	if _, err := Repo.AddCategory(ctx, c); err != nil {
+		reply(s, i, message("category add", err))
+		return
+	}
+	reply(s, i, fmt.Sprintf("Added **%s**. Run `/tickets panel` to show it on the panel.", name))
+}
+
+func handleCategoryRemove(s *discordgo.Session, i *discordgo.InteractionCreate, o []*discordgo.ApplicationCommandInteractionDataOption) {
+	ctx, cancel := context.WithTimeout(context.Background(), opTimeout)
+	defer cancel()
+	name := strings.TrimSpace(opts(o)["name"].StringValue())
+	ok, err := Repo.DeleteCategoryByName(ctx, guildID(i), name)
+	switch {
+	case err != nil:
+		reply(s, i, message("category remove", err))
+	case !ok:
+		reply(s, i, fmt.Sprintf("There's no category called **%s**.", name))
+	default:
+		reply(s, i, fmt.Sprintf("Removed **%s**. Open tickets keep working. Run `/tickets panel` to update the panel.", name))
+	}
+}
+
+func handleCategoryList(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	ctx, cancel := context.WithTimeout(context.Background(), opTimeout)
+	defer cancel()
+	cats, err := Repo.ListCategories(ctx, guildID(i))
+	if err != nil {
+		reply(s, i, message("category list", err))
+		return
+	}
+	if len(cats) == 0 {
+		reply(s, i, "No categories yet. Add one with `/tickets category add`.")
+		return
+	}
+	var b strings.Builder
+	for _, c := range cats {
+		line := "• "
+		if c.Emoji != "" {
+			line += c.Emoji + " "
+		}
+		line += "**" + c.Name + "**"
+		if c.StaffRoleID != 0 {
+			line += fmt.Sprintf(" → <@&%d>", c.StaffRoleID)
+		} else {
+			line += " → no staff role (only Manage Threads)"
+		}
+		if c.Description != "" {
+			line += ": " + c.Description
+		}
+		b.WriteString(line + "\n")
+	}
+	reply(s, i, b.String())
+}
+
+func TicketHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if Repo == nil {
+		reply(s, i, "Tickets aren't available right now.")
+		return
+	}
+	data := i.ApplicationCommandData()
+	if len(data.Options) == 0 {
+		return
+	}
+	sub := data.Options[0]
+	args := opts(sub.Options)
+	ctx, cancel := context.WithTimeout(context.Background(), opTimeout)
+	defer cancel()
+
+	switch sub.Name {
+	case "add", "remove":
+		user := args["user"].UserValue(nil)
+		if user == nil {
+			return
+		}
+		if !deferReply(s, i) {
+			return
+		}
+		var err error
+		if sub.Name == "add" {
+			err = tickets.AddMember(ctx, s, Repo, i.ChannelID, actor(i), user.ID)
+		} else {
+			err = tickets.RemoveMember(ctx, s, Repo, i.ChannelID, actor(i), user.ID)
+		}
+		if err != nil {
+			edit(s, i, message("ticket "+sub.Name, err))
+			return
+		}
+		edit(s, i, "Done.")
+	case "claim":
+		claim(s, i)
+	case "close":
+		reason := ""
+		if r, ok := args["reason"]; ok {
+			reason = r.StringValue()
+		}
+		closeTicket(s, i, reason)
+	}
+}
+
+func claim(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !deferReply(s, i) {
+		return
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), opTimeout)
+	defer cancel()
+	if err := tickets.Claim(ctx, s, Repo, i.ChannelID, actor(i)); err != nil {
+		edit(s, i, message("claim", err))
+		return
+	}
+	edit(s, i, "You're handling this ticket now.")
+}
+
+func closeTicket(s *discordgo.Session, i *discordgo.InteractionCreate, reason string) {
+	if !deferReply(s, i) {
+		return
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), opTimeout)
+	defer cancel()
+	if err := tickets.Close(ctx, s, Repo, i.ChannelID, actor(i), reason); err != nil {
+		edit(s, i, message("close", err))
+		return
+	}
+	edit(s, i, "Ticket closed.")
+}
+
+// HandleComponent handles the panel buttons and dropdown and the Claim and
+// Close buttons in a ticket.
+func HandleComponent(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if Repo == nil {
+		reply(s, i, "Tickets aren't available right now.")
+		return
+	}
+	data := i.MessageComponentData()
+	switch {
+	case strings.HasPrefix(data.CustomID, "tickets:open:"):
+		showOpenForm(s, i, strings.TrimPrefix(data.CustomID, "tickets:open:"))
+	case data.CustomID == "tickets:select" && len(data.Values) > 0:
+		showOpenForm(s, i, data.Values[0])
+	case data.CustomID == "tickets:claim":
+		claim(s, i)
+	case data.CustomID == "tickets:close":
+		ctx, cancel := context.WithTimeout(context.Background(), opTimeout)
+		defer cancel()
+		if err := tickets.CheckCanClose(ctx, Repo, i.ChannelID, actor(i)); err != nil {
+			reply(s, i, message("close", err))
+			return
+		}
+		_ = s.InteractionRespond(i.Interaction, tickets.CloseForm())
+	}
+}
+
+func showOpenForm(s *discordgo.Session, i *discordgo.InteractionCreate, rawCategory string) {
+	catID, err := strconv.ParseInt(rawCategory, 10, 64)
+	if err != nil || i.Member == nil || i.Member.User == nil {
+		return
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), opTimeout)
+	defer cancel()
+	userID, _ := strconv.ParseInt(i.Member.User.ID, 10, 64)
+	_, cat, err := tickets.CheckCanOpen(ctx, Repo, guildID(i), userID, catID)
+	if err != nil {
+		reply(s, i, message("open", err))
+		return
+	}
+	_ = s.InteractionRespond(i.Interaction, tickets.OpenForm(cat))
+}
+
+func field(data discordgo.ModalSubmitInteractionData, name string) string {
+	for _, row := range data.Components {
+		r, ok := row.(*discordgo.ActionsRow)
+		if !ok {
+			continue
+		}
+		for _, c := range r.Components {
+			if in, ok := c.(*discordgo.TextInput); ok && in.CustomID == name {
+				return strings.TrimSpace(in.Value)
+			}
+		}
+	}
+	return ""
+}
+
+// HandleModalSubmit handles the opening and closing forms.
+func HandleModalSubmit(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if Repo == nil {
+		reply(s, i, "Tickets aren't available right now.")
+		return
+	}
+	data := i.ModalSubmitData()
+	switch {
+	case strings.HasPrefix(data.CustomID, "tickets:openform:"):
+		catID, err := strconv.ParseInt(strings.TrimPrefix(data.CustomID, "tickets:openform:"), 10, 64)
+		if err != nil || i.Member == nil || i.Member.User == nil {
+			return
+		}
+		if !deferReply(s, i) {
+			return
+		}
+		ctx, cancel := context.WithTimeout(context.Background(), opTimeout)
+		defer cancel()
+		thread, err := tickets.Open(ctx, s, Repo, tickets.OpenRequest{
+			GuildID: guildID(i), CategoryID: catID, User: i.Member.User,
+			Subject: field(data, "subject"), Details: field(data, "details"),
+		})
+		if err != nil {
+			edit(s, i, message("open", err))
+			return
+		}
+		edit(s, i, fmt.Sprintf("Your ticket is open: <#%s>. The staff will be with you there.", thread.ID))
+	case data.CustomID == "tickets:closeform":
+		closeTicket(s, i, field(data, "reason"))
+	}
+}

internal/commands/tickets/registry.go

@@ -0,0 +1,29 @@
+package tickets
+
+import (
+	"velox-bot/internal/commands/tickets/public"
+	"velox-bot/internal/db/repos/ticketrepo"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+var (
+	Tickets *discordgo.ApplicationCommand = public.Tickets
+	Ticket  *discordgo.ApplicationCommand = public.Ticket
+)
+
+func Init(r *ticketrepo.Repo) { public.Init(r) }
+
+func TicketsHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	public.TicketsHandler(s, i)
+}
+
+func TicketHandler(s *discordgo.Session, i *discordgo.InteractionCreate) { public.TicketHandler(s, i) }
+
+func HandleComponent(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	public.HandleComponent(s, i)
+}
+
+func HandleModalSubmit(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	public.HandleModalSubmit(s, i)
+}

internal/config/config.go

@@ -8,18 +8,18 @@ import (
 )
 
 type Config struct {
-	BotToken      string
-	AppID         string
-	GuildID       string
-	DBHost        string
-	LavalinkHost  string
-	LavalinkPass  string
+	BotToken       string
+	AppID          string
+	GuildID        string
+	DBHost         string
+	LavalinkHost   string
+	LavalinkPass   string
+	TwitchClientID string
 }
 
 func LoadConfig() (*Config, error) {
-	if err := godotenv.Load(); err != nil {
-		return nil, err
-	}
+	// Load .env if present (e.g. local dev). Ignore if missing (e.g. Docker injects env vars).
+	_ = godotenv.Load()
 
 	token := os.Getenv("BOT_TOKEN")
 	if token == "" {
@@ -32,9 +32,6 @@ func LoadConfig() (*Config, error) {
 	}
 
 	guildID := os.Getenv("GUILD_ID")
-	if guildID == "" {
-		return nil, fmt.Errorf("GUILD_ID is not set")
-	}
 
 	dbHost := os.Getenv("DB_HOST")
 	if dbHost == "" {
@@ -44,12 +41,18 @@ func LoadConfig() (*Config, error) {
 	lavalinkHost := os.Getenv("LAVALINK_HOST")
 	lavalinkPass := os.Getenv("LAVALINK_PASSWORD")
 
+	twitchClientID := os.Getenv("TWITCH_CLIENT_ID")
+	if twitchClientID == "" {
+		return nil, fmt.Errorf("TWITCH_CLIENT_ID is not set")
+	}
+
 	return &Config{
-		BotToken:     token,
-		AppID:        appID,
-		GuildID:      guildID,
-		DBHost:       dbHost,
-		LavalinkHost: lavalinkHost,
-		LavalinkPass: lavalinkPass,
+		BotToken:       token,
+		AppID:          appID,
+		GuildID:        guildID,
+		DBHost:         dbHost,
+		LavalinkHost:   lavalinkHost,
+		LavalinkPass:   lavalinkPass,
+		TwitchClientID: twitchClientID,
 	}, nil
 }

internal/db/repos/defaultrolerepo/repo.go

@@ -0,0 +1,47 @@
+package defaultrolerepo
+
+import (
+	"context"
+	"database/sql"
+)
+
+type Repo struct {
+	db *sql.DB
+}
+
+func NewRepo(db *sql.DB) *Repo {
+	return &Repo{db: db}
+}
+
+// GetRole returns the configured default role ID for a guild, or 0 if none.
+func (r *Repo) GetRole(ctx context.Context, guildID int64) (int64, error) {
+	const q = `
+		SELECT role_id
+		FROM defaultrole
+		WHERE guild_id = $1
+	`
+	var roleID sql.NullInt64
+	if err := r.db.QueryRowContext(ctx, q, guildID).Scan(&roleID); err != nil {
+		if err == sql.ErrNoRows {
+			return 0, nil
+		}
+		return 0, err
+	}
+	if !roleID.Valid {
+		return 0, nil
+	}
+	return roleID.Int64, nil
+}
+
+// SetRole upserts the default role for a guild.
+func (r *Repo) SetRole(ctx context.Context, guildID, roleID int64) error {
+	const q = `
+		INSERT INTO defaultrole (guild_id, role_id)
+		VALUES ($1, $2)
+		ON CONFLICT (guild_id)
+		DO UPDATE SET role_id = EXCLUDED.role_id
+	`
+	_, err := r.db.ExecContext(ctx, q, guildID, roleID)
+	return err
+}
+

internal/db/repos/musicrepo/repo.go

@@ -0,0 +1,144 @@
+package musicrepo
+
+import (
+	"context"
+	"database/sql"
+	"time"
+)
+
+type QueueEntry struct {
+	Title       string
+	URL         string
+	RequestedBy int64
+
+	// ClientID is the track's stable identity (set once by the manager
+	// when a track is first queued), used to upsert this row across
+	// syncs instead of assigning it a fresh DB id every single time.
+	ClientID string
+}
+
+type Repo struct {
+	db *sql.DB
+}
+
+func NewRepo(db *sql.DB) *Repo {
+	return &Repo{db: db}
+}
+
+func (r *Repo) SetNowPlaying(ctx context.Context, guildID int64, title, url string, durationSeconds int, startedAt time.Time, paused bool, volume int, repeatSong, repeatQueue bool) error {
+	const q = `
+		INSERT INTO music_now_playing (guild_id, track_title, track_url, duration_seconds, started_at, paused, volume, repeat_song, repeat_queue)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+		ON CONFLICT (guild_id) DO UPDATE SET
+			track_title = $2, track_url = $3, duration_seconds = $4, started_at = $5,
+			paused = $6, volume = $7, repeat_song = $8, repeat_queue = $9
+	`
+	_, err := r.db.ExecContext(ctx, q, guildID, title, url, durationSeconds, startedAt, paused, volume, repeatSong, repeatQueue)
+	return err
+}
+
+func (r *Repo) ClearNowPlaying(ctx context.Context, guildID int64) error {
+	const q = `DELETE FROM music_now_playing WHERE guild_id = $1`
+	_, err := r.db.ExecContext(ctx, q, guildID)
+	return err
+}
+
+// ReplaceQueue syncs music_queue with the current in-memory queue by
+// upserting each entry on its stable ClientID, rather than deleting and
+// recreating every row on every call. That matters because music_queue.id
+// is only an internal DB identity, remove/reorder commands target a
+// track by ClientID, and that has to survive a track just sitting in the
+// queue unchanged across syncs.
+func (r *Repo) ReplaceQueue(ctx context.Context, guildID int64, entries []QueueEntry) error {
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	existing := make(map[string]bool)
+	rows, err := tx.QueryContext(ctx, `SELECT client_id FROM music_queue WHERE guild_id = $1`, guildID)
+	if err != nil {
+		return err
+	}
+	for rows.Next() {
+		var clientID string
+		if err := rows.Scan(&clientID); err != nil {
+			rows.Close()
+			return err
+		}
+		existing[clientID] = true
+	}
+	if err := rows.Err(); err != nil {
+		rows.Close()
+		return err
+	}
+	rows.Close()
+
+	keep := make(map[string]bool, len(entries))
+	for i, entry := range entries {
+		keep[entry.ClientID] = true
+		const q = `
+			INSERT INTO music_queue (guild_id, position, track_title, track_url, requested_by, client_id)
+			VALUES ($1, $2, $3, $4, $5, $6)
+			ON CONFLICT (guild_id, client_id) DO UPDATE SET
+				position = EXCLUDED.position,
+				track_title = EXCLUDED.track_title,
+				track_url = EXCLUDED.track_url,
+				requested_by = EXCLUDED.requested_by
+		`
+		if _, err := tx.ExecContext(ctx, q, guildID, i, entry.Title, entry.URL, entry.RequestedBy, entry.ClientID); err != nil {
+			return err
+		}
+	}
+
+	for clientID := range existing {
+		if keep[clientID] {
+			continue
+		}
+		const q = `DELETE FROM music_queue WHERE guild_id = $1 AND client_id = $2`
+		if _, err := tx.ExecContext(ctx, q, guildID, clientID); err != nil {
+			return err
+		}
+	}
+
+	return tx.Commit()
+}
+
+type MusicCommand struct {
+	ID          int64
+	GuildID     int64
+	CommandType string
+	Payload     []byte
+	RequestedBy int64
+}
+
+func (r *Repo) ListUnprocessedCommands(ctx context.Context) ([]MusicCommand, error) {
+	const q = `SELECT id, guild_id, command_type, payload, requested_by FROM music_commands WHERE processed_at IS NULL ORDER BY id ASC`
+
+	rows, err := r.db.QueryContext(ctx, q)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var commands []MusicCommand
+	for rows.Next() {
+		var cmd MusicCommand
+		if err := rows.Scan(&cmd.ID, &cmd.GuildID, &cmd.CommandType, &cmd.Payload, &cmd.RequestedBy); err != nil {
+			return nil, err
+		}
+		commands = append(commands, cmd)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return commands, nil
+}
+
+func (r *Repo) MarkCommandProcessed(ctx context.Context, id int64) error {
+	const q = `UPDATE music_commands SET processed_at = NOW() WHERE id = $1`
+	_, err := r.db.ExecContext(ctx, q, id)
+	return err
+}

internal/db/repos/projectsrepo/repo.go

@@ -61,6 +61,35 @@ func (r *Repo) AddHelper(ctx context.Context, projectID, userID int64) error {
 	return err
 }
 
+func (r *Repo) DeactivateProject(ctx context.Context, guildID, projectID int64) error {
+	const q = `
+		UPDATE projects
+		SET is_active = FALSE
+		WHERE id = $1 AND guild_id = $2
+	`
+	_, err := r.db.ExecContext(ctx, q, projectID, guildID)
+	return err
+}
+
+// GetProject fetches a single project, scoped to guildID so a project ID
+// from one server can't be used to reach into another's data.
+func (r *Repo) GetProject(ctx context.Context, guildID, projectID int64) (*Project, error) {
+	const q = `
+		SELECT id, name, description, created_by
+		FROM projects
+		WHERE id = $1 AND guild_id = $2
+	`
+	row := r.db.QueryRowContext(ctx, q, projectID, guildID)
+	p := &Project{GuildID: guildID, IsActive: true}
+	if err := row.Scan(&p.ID, &p.Name, &p.Description, &p.CreatedBy); err != nil {
+		if err == sql.ErrNoRows {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return p, nil
+}
+
 func (r *Repo) ProjectExistsInGuild(ctx context.Context, guildID, projectID int64) (bool, error) {
 	const q = `
 		SELECT 1
@@ -79,6 +108,37 @@ func (r *Repo) ProjectExistsInGuild(ctx context.Context, guildID, projectID int6
 	}
 }
 
+// ListActiveProjects is a lighter version of ListActiveProjectsWithMembers,
+// without the member-join query - for callers (like building a select menu
+// of projects to pick from) that only need name/id, not creator/helpers.
+func (r *Repo) ListActiveProjects(ctx context.Context, guildID int64, limit int) ([]*Project, error) {
+	const q = `
+		SELECT id, name, description, created_by
+		FROM projects
+		WHERE guild_id = $1 AND is_active = TRUE
+		ORDER BY created_at DESC
+		LIMIT $2
+	`
+	rows, err := r.db.QueryContext(ctx, q, guildID, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []*Project
+	for rows.Next() {
+		p := &Project{GuildID: guildID, IsActive: true}
+		if err := rows.Scan(&p.ID, &p.Name, &p.Description, &p.CreatedBy); err != nil {
+			return nil, err
+		}
+		out = append(out, p)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (r *Repo) ListActiveProjectsWithMembers(ctx context.Context, guildID int64, limit int) ([]*ProjectWithMembers, error) {
 	const qProjects = `
 		SELECT id, name, description, created_by

internal/db/repos/schedulerepo/repo.go

@@ -20,15 +20,18 @@ const (
 )
 
 type Schedule struct {
-	ID          int64
-	GuildID     int64
-	RequesterID int64
-	InviteeID   int64
-	ScheduledAt time.Time
-	Status      ScheduleStatus
-	Description string
-	ReminderSent bool
-	CreatedAt   time.Time
+	ID                  int64
+	GuildID             int64
+	RequesterID         int64
+	InviteeID           int64
+	ScheduledAt         time.Time
+	ProposedAt          *time.Time
+	ProposedBy          *int64
+	PreRescheduleStatus *ScheduleStatus
+	Status              ScheduleStatus
+	Description         string
+	ReminderSent        bool
+	CreatedAt           time.Time
 }
 
 func NewRepo(db *sql.DB) *Repo {
@@ -48,35 +51,6 @@ func (r *Repo) CreateSchedule(ctx context.Context, guildID, requesterID, invitee
 	return id, nil
 }
 
-func (r *Repo) AddMessage(ctx context.Context, scheduleID, messageID, channelID int64, isDM bool) error {
-	const q = `
-		INSERT INTO schedule_messages (schedule_id, message_id, channel_id, is_dm)
-		VALUES ($1, $2, $3, $4)
-		ON CONFLICT (schedule_id, message_id) DO NOTHING
-	`
-	_, err := r.db.ExecContext(ctx, q, scheduleID, messageID, channelID, isDM)
-	return err
-}
-
-func (r *Repo) GetByMessageID(ctx context.Context, messageID int64) (*Schedule, error) {
-	const q = `
-		SELECT s.id, s.guild_id, s.requester_id, s.invitee_id, s.scheduled_at, s.status, s.description, s.reminder_sent, s.created_at
-		FROM schedules s
-		JOIN schedule_messages m ON m.schedule_id = s.id
-		WHERE m.message_id = $1
-		LIMIT 1
-	`
-	row := r.db.QueryRowContext(ctx, q, messageID)
-	var sch Schedule
-	if err := row.Scan(&sch.ID, &sch.GuildID, &sch.RequesterID, &sch.InviteeID, &sch.ScheduledAt, &sch.Status, &sch.Description, &sch.ReminderSent, &sch.CreatedAt); err != nil {
-		if err == sql.ErrNoRows {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return &sch, nil
-}
-
 func (r *Repo) UpdateStatus(ctx context.Context, scheduleID int64, status ScheduleStatus) error {
 	const q = `
 		UPDATE schedules
@@ -119,13 +93,13 @@ func (r *Repo) ListForUser(ctx context.Context, guildID, userID int64, limit int
 
 func (r *Repo) GetByID(ctx context.Context, id int64) (*Schedule, error) {
 	const q = `
-		SELECT id, guild_id, requester_id, invitee_id, scheduled_at, status, description, reminder_sent, created_at
+		SELECT id, guild_id, requester_id, invitee_id, scheduled_at, proposed_at, proposed_by, pre_reschedule_status, status, description, reminder_sent, created_at
 		FROM schedules
 		WHERE id = $1
 	`
 	row := r.db.QueryRowContext(ctx, q, id)
 	var sch Schedule
-	if err := row.Scan(&sch.ID, &sch.GuildID, &sch.RequesterID, &sch.InviteeID, &sch.ScheduledAt, &sch.Status, &sch.Description, &sch.ReminderSent, &sch.CreatedAt); err != nil {
+	if err := row.Scan(&sch.ID, &sch.GuildID, &sch.RequesterID, &sch.InviteeID, &sch.ScheduledAt, &sch.ProposedAt, &sch.ProposedBy, &sch.PreRescheduleStatus, &sch.Status, &sch.Description, &sch.ReminderSent, &sch.CreatedAt); err != nil {
 		if err == sql.ErrNoRows {
 			return nil, nil
 		}
@@ -186,4 +160,43 @@ func (r *Repo) MarkReminded(ctx context.Context, scheduleID int64) error {
 	return err
 }
 
+func (r *Repo) ProposeReschedule(ctx context.Context, scheduleID int64, newTime time.Time, proposedBy int64) error {
+	const q = `
+		UPDATE schedules
+		SET proposed_at = $1,
+		    proposed_by = $2,
+		    pre_reschedule_status = status,
+		    status = 'reschedule_requested'
+		WHERE id = $3
+	`
+	_, err := r.db.ExecContext(ctx, q, newTime, proposedBy, scheduleID)
+	return err
+}
 
+func (r *Repo) AcceptReschedule(ctx context.Context, scheduleID int64) error {
+	const q = `
+		UPDATE schedules
+		SET scheduled_at = proposed_at,
+		    proposed_at = NULL,
+		    proposed_by = NULL,
+		    pre_reschedule_status = NULL,
+		    status = 'accepted',
+		    reminder_sent = FALSE
+		WHERE id = $1
+	`
+	_, err := r.db.ExecContext(ctx, q, scheduleID)
+	return err
+}
+
+func (r *Repo) DeclineReschedule(ctx context.Context, scheduleID int64) error {
+	const q = `
+		UPDATE schedules
+		SET proposed_at = NULL,
+		    proposed_by = NULL,
+		    status = pre_reschedule_status,
+		    pre_reschedule_status = NULL
+		WHERE id = $1
+	`
+	_, err := r.db.ExecContext(ctx, q, scheduleID)
+	return err
+}

internal/db/repos/settingsrepo/repo.go

@@ -15,6 +15,12 @@ type LevelReward struct {
 	RoleID  int64
 }
 
+type LogSettings struct {
+	GuildID   int64
+	ChannelID int64
+	IsEnabled bool
+}
+
 func NewRepo(db *sql.DB) *Repo {
 	return &Repo{db: db}
 }
@@ -240,6 +246,80 @@ func (r *Repo) SetLevelUpMessage(ctx context.Context, guildID int64, message str
 	return err
 }
 
+func (r *Repo) SetLogChannel(ctx context.Context, guildID int64, channelID int64) error {
+	const q = `
+		INSERT INTO logsettings (guild_id, log_channel_id, is_enabled)
+		VALUES ($1, $2, TRUE)
+		ON CONFLICT (guild_id)
+		DO UPDATE SET log_channel_id = EXCLUDED.log_channel_id
+	`
+	_, err := r.db.ExecContext(ctx, q, guildID, channelID)
+	return err
+}
+
+func (r *Repo) SetLogEnabled(ctx context.Context, guildID int64, enabled bool) error {
+	const q = `
+		INSERT INTO logsettings (guild_id, is_enabled)
+		VALUES ($1, $2)
+		ON CONFLICT (guild_id)
+		DO UPDATE SET is_enabled = EXCLUDED.is_enabled
+	`
+	_, err := r.db.ExecContext(ctx, q, guildID, enabled)
+	return err
+}
+
+func (r *Repo) GetLogSettings(ctx context.Context, guildID int64) (*LogSettings, error) {
+	const q = `
+		SELECT log_channel_id, is_enabled
+		FROM logsettings
+		WHERE guild_id = $1
+	`
+	row := r.db.QueryRowContext(ctx, q, guildID)
+	var channelID sql.NullInt64
+	var enabled sql.NullBool
+	switch err := row.Scan(&channelID, &enabled); err {
+	case nil:
+		out := &LogSettings{
+			GuildID:   guildID,
+			ChannelID: 0,
+			IsEnabled: false,
+		}
+		if channelID.Valid {
+			out.ChannelID = channelID.Int64
+		}
+		if enabled.Valid {
+			out.IsEnabled = enabled.Bool
+		}
+		return out, nil
+	case sql.ErrNoRows:
+		return &LogSettings{
+			GuildID:   guildID,
+			ChannelID: 0,
+			IsEnabled: false,
+		}, nil
+	default:
+		return nil, err
+	}
+}
+
+func (r *Repo) HasLogSettings(ctx context.Context, guildID int64) (bool, error) {
+	const q = `
+		SELECT 1
+		FROM logsettings
+		WHERE guild_id = $1
+	`
+	row := r.db.QueryRowContext(ctx, q, guildID)
+	var one int
+	switch err := row.Scan(&one); err {
+	case nil:
+		return true, nil
+	case sql.ErrNoRows:
+		return false, nil
+	default:
+		return false, err
+	}
+}
+
 func (r *Repo) GetLevelUpMessage(ctx context.Context, guildID int64) (string, error) {
 	const q = `
 		SELECT message
@@ -260,3 +340,22 @@ func (r *Repo) GetLevelUpMessage(ctx context.Context, guildID int64) (string, er
 		return "", err
 	}
 }
+
+func (r *Repo) IsMusicEnabled(ctx context.Context, guildID int64) (bool, error) {
+	const q = `SELECT is_enabled FROM music_settings WHERE guild_id = $1`
+	var enabled bool
+	err := r.db.QueryRowContext(ctx, q, guildID).Scan(&enabled)
+	if err == sql.ErrNoRows {
+		return false, nil
+	}
+	if err != nil {
+		return false, err
+	}
+	return enabled, nil
+}
+
+func (r *Repo) SetMusicEnabled(ctx context.Context, guildID int64, enabled bool) error {
+	const q = `INSERT INTO music_settings (guild_id, is_enabled) VALUES ($1, $2) ON CONFLICT (guild_id) DO UPDATE SET is_enabled = $2`
+	_, err := r.db.ExecContext(ctx, q, guildID, enabled)
+	return err
+}

internal/db/repos/ticketrepo/repo.go

@@ -0,0 +1,301 @@
+// Package ticketrepo stores the ticket system's settings, categories, tickets
+// and the dashboard's requests to the bot. Discord IDs are int64; 0 means
+// "not set" for optional ones.
+package ticketrepo
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"time"
+)
+
+type Repo struct {
+	db *sql.DB
+}
+
+func NewRepo(db *sql.DB) *Repo {
+	return &Repo{db: db}
+}
+
+const (
+	DefaultPanelTitle       = "Need help?"
+	DefaultPanelDescription = "Pick a category below to open a private ticket with the staff team."
+	DefaultMaxOpenPerUser   = 1
+
+	StatusOpen   = "open"
+	StatusClosed = "closed"
+)
+
+type Settings struct {
+	GuildID          int64
+	Enabled          bool
+	ChannelID        int64
+	LogChannelID     int64
+	PanelMessageID   int64
+	PanelTitle       string
+	PanelDescription string
+	MaxOpenPerUser   int
+	// Configured is false when the guild has no settings row yet; the other
+	// fields then hold the defaults.
+	Configured bool
+}
+
+type Category struct {
+	ID          int64
+	GuildID     int64
+	Name        string
+	Emoji       string
+	Description string
+	StaffRoleID int64
+	Position    int
+}
+
+type Ticket struct {
+	ID           int64
+	GuildID      int64
+	Number       int
+	CategoryID   int64
+	CategoryName string
+	ThreadID     int64
+	IntroMessage int64
+	OpenerID     int64
+	Subject      string
+	Status       string
+	ClaimedBy    int64
+	ClosedBy     int64
+	CloseReason  string
+	CreatedAt    time.Time
+	ClosedAt     time.Time // zero while open
+}
+
+type Command struct {
+	ID          int64
+	GuildID     int64
+	CommandType string
+	RequestedBy int64
+}
+
+func nullID(v int64) sql.NullInt64 {
+	return sql.NullInt64{Int64: v, Valid: v != 0}
+}
+
+func nullText(v string) sql.NullString {
+	return sql.NullString{String: v, Valid: v != ""}
+}
+
+func (r *Repo) GetSettings(ctx context.Context, guildID int64) (*Settings, error) {
+	const q = `
+		SELECT enabled, channel_id, log_channel_id, panel_message_id, panel_title, panel_description, max_open_per_user
+		FROM ticket_settings WHERE guild_id = $1`
+	var ch, logCh, panel sql.NullInt64
+	s := &Settings{GuildID: guildID}
+	err := r.db.QueryRowContext(ctx, q, guildID).Scan(&s.Enabled, &ch, &logCh, &panel, &s.PanelTitle, &s.PanelDescription, &s.MaxOpenPerUser)
+	switch {
+	case errors.Is(err, sql.ErrNoRows):
+		return &Settings{
+			GuildID:          guildID,
+			Enabled:          true,
+			PanelTitle:       DefaultPanelTitle,
+			PanelDescription: DefaultPanelDescription,
+			MaxOpenPerUser:   DefaultMaxOpenPerUser,
+		}, nil
+	case err != nil:
+		return nil, err
+	}
+	s.ChannelID, s.LogChannelID, s.PanelMessageID = ch.Int64, logCh.Int64, panel.Int64
+	s.Configured = true
+	return s, nil
+}
+
+// SetChannels saves where tickets live and where transcripts go. A zero log
+// channel clears it.
+func (r *Repo) SetChannels(ctx context.Context, guildID, channelID, logChannelID int64) error {
+	const q = `
+		INSERT INTO ticket_settings (guild_id, channel_id, log_channel_id)
+		VALUES ($1, $2, $3)
+		ON CONFLICT (guild_id) DO UPDATE SET
+			channel_id = EXCLUDED.channel_id,
+			log_channel_id = EXCLUDED.log_channel_id`
+	_, err := r.db.ExecContext(ctx, q, guildID, nullID(channelID), nullID(logChannelID))
+	return err
+}
+
+func (r *Repo) SetPanelMessage(ctx context.Context, guildID, messageID int64) error {
+	const q = `
+		INSERT INTO ticket_settings (guild_id, panel_message_id) VALUES ($1, $2)
+		ON CONFLICT (guild_id) DO UPDATE SET panel_message_id = EXCLUDED.panel_message_id`
+	_, err := r.db.ExecContext(ctx, q, guildID, nullID(messageID))
+	return err
+}
+
+// NextNumber hands out the guild's next ticket number. It is a single
+// statement, so two tickets opened at the same moment never share a number.
+func (r *Repo) NextNumber(ctx context.Context, guildID int64) (int, error) {
+	const q = `
+		INSERT INTO ticket_settings (guild_id, next_number) VALUES ($1, 2)
+		ON CONFLICT (guild_id) DO UPDATE SET next_number = ticket_settings.next_number + 1
+		RETURNING next_number - 1`
+	var n int
+	err := r.db.QueryRowContext(ctx, q, guildID).Scan(&n)
+	return n, err
+}
+
+const categoryCols = `id, guild_id, name, COALESCE(emoji, ''), description, COALESCE(staff_role_id, 0), position`
+
+func scanCategory(row interface{ Scan(...any) error }) (Category, error) {
+	var c Category
+	err := row.Scan(&c.ID, &c.GuildID, &c.Name, &c.Emoji, &c.Description, &c.StaffRoleID, &c.Position)
+	return c, err
+}
+
+func (r *Repo) ListCategories(ctx context.Context, guildID int64) ([]Category, error) {
+	q := `SELECT ` + categoryCols + ` FROM ticket_categories WHERE guild_id = $1 ORDER BY position, id`
+	rows, err := r.db.QueryContext(ctx, q, guildID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []Category
+	for rows.Next() {
+		c, err := scanCategory(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, c)
+	}
+	return out, rows.Err()
+}
+
+// GetCategory returns nil when the category does not exist in that guild.
+func (r *Repo) GetCategory(ctx context.Context, guildID, id int64) (*Category, error) {
+	q := `SELECT ` + categoryCols + ` FROM ticket_categories WHERE guild_id = $1 AND id = $2`
+	c, err := scanCategory(r.db.QueryRowContext(ctx, q, guildID, id))
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &c, nil
+}
+
+// AddCategory appends a category after the existing ones.
+func (r *Repo) AddCategory(ctx context.Context, c Category) (*Category, error) {
+	q := `
+		INSERT INTO ticket_categories (guild_id, name, emoji, description, staff_role_id, position)
+		VALUES ($1, $2, $3, $4, $5,
+			(SELECT COALESCE(MAX(position) + 1, 0) FROM ticket_categories WHERE guild_id = $1))
+		RETURNING ` + categoryCols
+	out, err := scanCategory(r.db.QueryRowContext(ctx, q, c.GuildID, c.Name, nullText(c.Emoji), c.Description, nullID(c.StaffRoleID)))
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+// DeleteCategoryByName removes a category (case-insensitively) and reports
+// whether one was found. Tickets keep their copied category name.
+func (r *Repo) DeleteCategoryByName(ctx context.Context, guildID int64, name string) (bool, error) {
+	const q = `DELETE FROM ticket_categories WHERE guild_id = $1 AND lower(name) = lower($2)`
+	res, err := r.db.ExecContext(ctx, q, guildID, name)
+	if err != nil {
+		return false, err
+	}
+	n, err := res.RowsAffected()
+	return n > 0, err
+}
+
+func (r *Repo) CountOpenByOpener(ctx context.Context, guildID, openerID int64) (int, error) {
+	const q = `SELECT COUNT(*) FROM tickets WHERE guild_id = $1 AND opener_id = $2 AND status = 'open'`
+	var n int
+	err := r.db.QueryRowContext(ctx, q, guildID, openerID).Scan(&n)
+	return n, err
+}
+
+func (r *Repo) CreateTicket(ctx context.Context, t Ticket) (int64, error) {
+	const q = `
+		INSERT INTO tickets (guild_id, number, category_id, category_name, thread_id, intro_message_id, opener_id, subject)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+		RETURNING id`
+	var id int64
+	err := r.db.QueryRowContext(ctx, q, t.GuildID, t.Number, nullID(t.CategoryID), t.CategoryName, t.ThreadID, nullID(t.IntroMessage), t.OpenerID, t.Subject).Scan(&id)
+	return id, err
+}
+
+const ticketCols = `id, guild_id, number, COALESCE(category_id, 0), category_name, thread_id, COALESCE(intro_message_id, 0), opener_id, subject, status,
+	COALESCE(claimed_by, 0), COALESCE(closed_by, 0), COALESCE(close_reason, ''), created_at, closed_at`
+
+func scanTicket(row interface{ Scan(...any) error }) (Ticket, error) {
+	var t Ticket
+	var closedAt sql.NullTime
+	err := row.Scan(&t.ID, &t.GuildID, &t.Number, &t.CategoryID, &t.CategoryName, &t.ThreadID, &t.IntroMessage, &t.OpenerID, &t.Subject, &t.Status,
+		&t.ClaimedBy, &t.ClosedBy, &t.CloseReason, &t.CreatedAt, &closedAt)
+	t.ClosedAt = closedAt.Time
+	return t, err
+}
+
+// GetTicketByThread returns nil when the thread is not a ticket.
+func (r *Repo) GetTicketByThread(ctx context.Context, threadID int64) (*Ticket, error) {
+	q := `SELECT ` + ticketCols + ` FROM tickets WHERE thread_id = $1`
+	t, err := scanTicket(r.db.QueryRowContext(ctx, q, threadID))
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &t, nil
+}
+
+// Claim sets the ticket's handler unless someone already has it, and returns
+// whoever holds it afterwards (the caller when the claim worked).
+func (r *Repo) Claim(ctx context.Context, threadID, staffID int64) (int64, error) {
+	const q = `
+		UPDATE tickets SET claimed_by = COALESCE(claimed_by, $2)
+		WHERE thread_id = $1 AND status = 'open'
+		RETURNING claimed_by`
+	var holder int64
+	err := r.db.QueryRowContext(ctx, q, threadID, staffID).Scan(&holder)
+	if errors.Is(err, sql.ErrNoRows) {
+		return 0, nil
+	}
+	return holder, err
+}
+
+// Close marks an open ticket closed and reports whether this call closed it,
+// so two people pressing Close at once only produce one transcript.
+func (r *Repo) Close(ctx context.Context, threadID, closedBy int64, reason string) (bool, error) {
+	const q = `
+		UPDATE tickets SET status = 'closed', closed_by = $2, close_reason = $3, closed_at = NOW()
+		WHERE thread_id = $1 AND status = 'open'`
+	res, err := r.db.ExecContext(ctx, q, threadID, nullID(closedBy), nullText(reason))
+	if err != nil {
+		return false, err
+	}
+	n, err := res.RowsAffected()
+	return n > 0, err
+}
+
+func (r *Repo) ListUnprocessedCommands(ctx context.Context) ([]Command, error) {
+	const q = `SELECT id, guild_id, command_type, requested_by FROM ticket_commands WHERE processed_at IS NULL ORDER BY id`
+	rows, err := r.db.QueryContext(ctx, q)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []Command
+	for rows.Next() {
+		var c Command
+		if err := rows.Scan(&c.ID, &c.GuildID, &c.CommandType, &c.RequestedBy); err != nil {
+			return nil, err
+		}
+		out = append(out, c)
+	}
+	return out, rows.Err()
+}
+
+func (r *Repo) MarkCommandProcessed(ctx context.Context, id int64) error {
+	_, err := r.db.ExecContext(ctx, `UPDATE ticket_commands SET processed_at = NOW() WHERE id = $1`, id)
+	return err
+}

internal/db/repos/ticketrepo/repo_integration_test.go

@@ -0,0 +1,206 @@
+//go:build integration
+
+// Runs against a real Postgres with the dashboard API's migrations applied:
+//
+//	TICKETS_TEST_DB=postgres://... go test -tags integration ./internal/db/repos/ticketrepo
+package ticketrepo
+
+import (
+	"context"
+	"database/sql"
+	"os"
+	"sync"
+	"testing"
+
+	_ "github.com/jackc/pgx/v5/stdlib"
+)
+
+func testRepo(t *testing.T) (*Repo, int64) {
+	t.Helper()
+	dsn := os.Getenv("TICKETS_TEST_DB")
+	if dsn == "" {
+		t.Skip("TICKETS_TEST_DB not set")
+	}
+	db, err := sql.Open("pgx", dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { db.Close() })
+
+	const guild = 424242
+	for _, q := range []string{
+		`DELETE FROM tickets WHERE guild_id = $1`,
+		`DELETE FROM ticket_categories WHERE guild_id = $1`,
+		`DELETE FROM ticket_settings WHERE guild_id = $1`,
+		`DELETE FROM ticket_commands WHERE guild_id = $1`,
+	} {
+		if _, err := db.Exec(q, guild); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return NewRepo(db), guild
+}
+
+func TestSettingsDefaultsAndChannels(t *testing.T) {
+	r, g := testRepo(t)
+	ctx := context.Background()
+
+	s, err := r.GetSettings(ctx, g)
+	if err != nil || s.Configured || !s.Enabled || s.PanelTitle != DefaultPanelTitle || s.MaxOpenPerUser != 1 {
+		t.Fatalf("defaults wrong: %+v %v", s, err)
+	}
+	if err := r.SetChannels(ctx, g, 111, 222); err != nil {
+		t.Fatal(err)
+	}
+	if err := r.SetPanelMessage(ctx, g, 333); err != nil {
+		t.Fatal(err)
+	}
+	s, _ = r.GetSettings(ctx, g)
+	if !s.Configured || s.ChannelID != 111 || s.LogChannelID != 222 || s.PanelMessageID != 333 {
+		t.Fatalf("saved settings wrong: %+v", s)
+	}
+	// Clearing the log channel.
+	_ = r.SetChannels(ctx, g, 111, 0)
+	s, _ = r.GetSettings(ctx, g)
+	if s.LogChannelID != 0 {
+		t.Errorf("log channel not cleared: %+v", s)
+	}
+}
+
+func TestNextNumberIsUniqueUnderConcurrency(t *testing.T) {
+	r, g := testRepo(t)
+	ctx := context.Background()
+
+	var mu sync.Mutex
+	seen := map[int]bool{}
+	var wg sync.WaitGroup
+	for i := 0; i < 20; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			n, err := r.NextNumber(ctx, g)
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			mu.Lock()
+			defer mu.Unlock()
+			if seen[n] {
+				t.Errorf("number %d handed out twice", n)
+			}
+			seen[n] = true
+		}()
+	}
+	wg.Wait()
+	for n := 1; n <= 20; n++ {
+		if !seen[n] {
+			t.Errorf("number %d missing: numbers should be 1..20", n)
+		}
+	}
+}
+
+func TestCategories(t *testing.T) {
+	r, g := testRepo(t)
+	ctx := context.Background()
+
+	a, err := r.AddCategory(ctx, Category{GuildID: g, Name: "Support", Emoji: "🛟", StaffRoleID: 9})
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, _ := r.AddCategory(ctx, Category{GuildID: g, Name: "Appeal", Description: "Ban appeals"})
+	if a.Position != 0 || b.Position != 1 || b.Emoji != "" || b.StaffRoleID != 0 {
+		t.Fatalf("positions or defaults wrong: %+v %+v", a, b)
+	}
+	list, _ := r.ListCategories(ctx, g)
+	if len(list) != 2 || list[0].Name != "Support" || list[1].Description != "Ban appeals" {
+		t.Fatalf("list wrong: %+v", list)
+	}
+	if c, _ := r.GetCategory(ctx, g, a.ID); c == nil || c.Emoji != "🛟" {
+		t.Errorf("get wrong: %+v", c)
+	}
+	if c, _ := r.GetCategory(ctx, g+1, a.ID); c != nil {
+		t.Error("a category must not be readable from another guild")
+	}
+	if ok, _ := r.DeleteCategoryByName(ctx, g, "support"); !ok {
+		t.Error("delete should match case-insensitively")
+	}
+	if ok, _ := r.DeleteCategoryByName(ctx, g, "nope"); ok {
+		t.Error("deleting a missing category should report false")
+	}
+}
+
+func TestTicketLifecycle(t *testing.T) {
+	r, g := testRepo(t)
+	ctx := context.Background()
+
+	cat, _ := r.AddCategory(ctx, Category{GuildID: g, Name: "Support"})
+	id, err := r.CreateTicket(ctx, Ticket{GuildID: g, Number: 1, CategoryID: cat.ID, CategoryName: "Support", ThreadID: 5001, IntroMessage: 6001, OpenerID: 77, Subject: "Help"})
+	if err != nil || id == 0 {
+		t.Fatal(err)
+	}
+	if n, _ := r.CountOpenByOpener(ctx, g, 77); n != 1 {
+		t.Errorf("open count = %d", n)
+	}
+
+	if holder, _ := r.Claim(ctx, 5001, 10); holder != 10 {
+		t.Errorf("first claim should win, holder = %d", holder)
+	}
+	if holder, _ := r.Claim(ctx, 5001, 11); holder != 10 {
+		t.Errorf("second claim must not take over, holder = %d", holder)
+	}
+
+	if ok, _ := r.Close(ctx, 5001, 10, "solved"); !ok {
+		t.Error("first close should succeed")
+	}
+	if ok, _ := r.Close(ctx, 5001, 11, ""); ok {
+		t.Error("closing twice must report false")
+	}
+	tk, _ := r.GetTicketByThread(ctx, 5001)
+	if tk == nil || tk.Status != StatusClosed || tk.ClosedBy != 10 || tk.CloseReason != "solved" || tk.ClosedAt.IsZero() || tk.ClaimedBy != 10 || tk.IntroMessage != 6001 {
+		t.Fatalf("closed ticket wrong: %+v", tk)
+	}
+	if n, _ := r.CountOpenByOpener(ctx, g, 77); n != 0 {
+		t.Errorf("closed ticket still counted as open")
+	}
+	if holder, _ := r.Claim(ctx, 5001, 12); holder != 0 {
+		t.Error("a closed ticket cannot be claimed")
+	}
+
+	// Deleting the category keeps the ticket and its copied name.
+	_, _ = r.DeleteCategoryByName(ctx, g, "Support")
+	tk, _ = r.GetTicketByThread(ctx, 5001)
+	if tk.CategoryID != 0 || tk.CategoryName != "Support" {
+		t.Errorf("ticket after category delete: %+v", tk)
+	}
+	if tk, _ := r.GetTicketByThread(ctx, 999); tk != nil {
+		t.Error("unknown thread should return nil")
+	}
+}
+
+func TestCommands(t *testing.T) {
+	r, g := testRepo(t)
+	ctx := context.Background()
+	if _, err := r.db.Exec(`INSERT INTO ticket_commands (guild_id, command_type, requested_by) VALUES ($1, 'post_panel', 5)`, g); err != nil {
+		t.Fatal(err)
+	}
+	cmds, err := r.ListUnprocessedCommands(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var mine *Command
+	for i := range cmds {
+		if cmds[i].GuildID == g {
+			mine = &cmds[i]
+		}
+	}
+	if mine == nil || mine.CommandType != "post_panel" || mine.RequestedBy != 5 {
+		t.Fatalf("command not listed: %+v", cmds)
+	}
+	_ = r.MarkCommandProcessed(ctx, mine.ID)
+	cmds, _ = r.ListUnprocessedCommands(ctx)
+	for _, c := range cmds {
+		if c.ID == mine.ID {
+			t.Error("processed command still listed")
+		}
+	}
+}

internal/db/repos/twitchrepo/repo.go

@@ -0,0 +1,143 @@
+package twitchrepo
+
+import (
+	"context"
+	"database/sql"
+)
+
+type Repo struct {
+	db *sql.DB
+}
+
+func NewRepo(db *sql.DB) *Repo {
+	return &Repo{db: db}
+}
+
+func (r *Repo) ListGuilds(ctx context.Context) ([]int64, error) {
+	const q = `SELECT DISTINCT guild_id FROM twitch`
+	rows, err := r.db.QueryContext(ctx, q)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var ids []int64
+	for rows.Next() {
+		var gid int64
+		if err := rows.Scan(&gid); err != nil {
+			return nil, err
+		}
+		ids = append(ids, gid)
+	}
+	return ids, rows.Err()
+}
+
+func (r *Repo) ListUsersForGuild(ctx context.Context, guildID int64) ([]string, error) {
+	const q = `SELECT twitch_user FROM twitch WHERE guild_id = $1`
+	rows, err := r.db.QueryContext(ctx, q, guildID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var users []string
+	for rows.Next() {
+		var u string
+		if err := rows.Scan(&u); err != nil {
+			return nil, err
+		}
+		users = append(users, u)
+	}
+	return users, rows.Err()
+}
+
+func (r *Repo) GetStatus(ctx context.Context, guildID int64, username string) (string, bool, error) {
+	const q = `SELECT status FROM twitch WHERE guild_id = $1 AND twitch_user = $2`
+	var status string
+	err := r.db.QueryRowContext(ctx, q, guildID, username).Scan(&status)
+	if err == sql.ErrNoRows {
+		return "", false, nil
+	}
+	if err != nil {
+		return "", false, err
+	}
+	return status, true, nil
+}
+
+func (r *Repo) UpsertStreamer(ctx context.Context, guildID int64, username string) error {
+	const q = `
+		INSERT INTO twitch (twitch_user, guild_id, status)
+		VALUES ($1, $2, 'not live')
+		ON CONFLICT (twitch_user, guild_id)
+		DO NOTHING
+	`
+	_, err := r.db.ExecContext(ctx, q, username, guildID)
+	return err
+}
+
+func (r *Repo) RemoveStreamer(ctx context.Context, guildID int64, username string) error {
+	const q = `DELETE FROM twitch WHERE guild_id = $1 AND twitch_user = $2`
+	_, err := r.db.ExecContext(ctx, q, guildID, username)
+	return err
+}
+
+func (r *Repo) UpdateStatus(ctx context.Context, guildID int64, username, status string) error {
+	const q = `UPDATE twitch SET status = $1 WHERE guild_id = $2 AND twitch_user = $3`
+	_, err := r.db.ExecContext(ctx, q, status, guildID, username)
+	return err
+}
+
+func (r *Repo) GetNotificationChannel(ctx context.Context, guildID int64) (int64, bool, error) {
+	const q = `SELECT twitch_channel_id FROM twitch_config WHERE guild_id = $1`
+	var chID sql.NullInt64
+	if err := r.db.QueryRowContext(ctx, q, guildID).Scan(&chID); err != nil {
+		if err == sql.ErrNoRows {
+			return 0, false, nil
+		}
+		return 0, false, err
+	}
+	if !chID.Valid {
+		return 0, false, nil
+	}
+	return chID.Int64, true, nil
+}
+
+func (r *Repo) SetNotificationChannel(ctx context.Context, guildID, channelID int64) error {
+	const q = `
+		INSERT INTO twitch_config (guild_id, twitch_channel_id)
+		VALUES ($1, $2)
+		ON CONFLICT (guild_id)
+		DO UPDATE SET twitch_channel_id = EXCLUDED.twitch_channel_id
+	`
+	_, err := r.db.ExecContext(ctx, q, guildID, channelID)
+	return err
+}
+
+// IsEnabled reports whether Twitch notifications are enabled for guildID.
+// A guild with no twitch_config row yet defaults to enabled, matching the
+// column's own DEFAULT TRUE - "never configured" and "explicitly on" are
+// the same state until someone actually flips it off.
+func (r *Repo) IsEnabled(ctx context.Context, guildID int64) (bool, error) {
+	const q = `SELECT enabled FROM twitch_config WHERE guild_id = $1`
+	var enabled bool
+	err := r.db.QueryRowContext(ctx, q, guildID).Scan(&enabled)
+	if err == sql.ErrNoRows {
+		return true, nil
+	}
+	if err != nil {
+		return false, err
+	}
+	return enabled, nil
+}
+
+func (r *Repo) SetEnabled(ctx context.Context, guildID int64, enabled bool) error {
+	const q = `
+		INSERT INTO twitch_config (guild_id, enabled)
+		VALUES ($1, $2)
+		ON CONFLICT (guild_id)
+		DO UPDATE SET enabled = EXCLUDED.enabled
+	`
+	_, err := r.db.ExecContext(ctx, q, guildID, enabled)
+	return err
+}
+

internal/db/repos/welcomerepo/repo.go

@@ -0,0 +1,111 @@
+package welcomerepo
+
+import (
+	"context"
+	"database/sql"
+)
+
+type Repo struct {
+	db *sql.DB
+}
+
+type Settings struct {
+	GuildID          int64
+	ChannelID        int64
+	WelcomeMessage   string
+	WelcomeDM        string
+	WelcomeGIFURL    string
+	HasConfiguration bool
+}
+
+func NewRepo(db *sql.DB) *Repo {
+	return &Repo{db: db}
+}
+
+func (r *Repo) GetSettings(ctx context.Context, guildID int64) (*Settings, error) {
+	const q = `
+		SELECT welcome_channel_id, welcome_message, welcome_dm, welcome_gif_url
+		FROM welcome
+		WHERE guild_id = $1
+	`
+	row := r.db.QueryRowContext(ctx, q, guildID)
+	var ch sql.NullInt64
+	var msg, dm, gif sql.NullString
+
+	switch err := row.Scan(&ch, &msg, &dm, &gif); err {
+	case nil:
+		s := &Settings{
+			GuildID:          guildID,
+			ChannelID:        0,
+			WelcomeMessage:   "",
+			WelcomeDM:        "",
+			WelcomeGIFURL:    "",
+			HasConfiguration: true,
+		}
+		if ch.Valid {
+			s.ChannelID = ch.Int64
+		}
+		if msg.Valid {
+			s.WelcomeMessage = msg.String
+		}
+		if dm.Valid {
+			s.WelcomeDM = dm.String
+		}
+		if gif.Valid {
+			s.WelcomeGIFURL = gif.String
+		}
+		return s, nil
+	case sql.ErrNoRows:
+		return &Settings{
+			GuildID:          guildID,
+			HasConfiguration: false,
+		}, nil
+	default:
+		return nil, err
+	}
+}
+
+func (r *Repo) UpsertChannel(ctx context.Context, guildID, channelID int64) error {
+	const q = `
+		INSERT INTO welcome (guild_id, welcome_channel_id)
+		VALUES ($1, $2)
+		ON CONFLICT (guild_id)
+		DO UPDATE SET welcome_channel_id = EXCLUDED.welcome_channel_id
+	`
+	_, err := r.db.ExecContext(ctx, q, guildID, channelID)
+	return err
+}
+
+func (r *Repo) UpsertMessage(ctx context.Context, guildID int64, message string) error {
+	const q = `
+		INSERT INTO welcome (guild_id, welcome_message)
+		VALUES ($1, $2)
+		ON CONFLICT (guild_id)
+		DO UPDATE SET welcome_message = EXCLUDED.welcome_message
+	`
+	_, err := r.db.ExecContext(ctx, q, guildID, message)
+	return err
+}
+
+func (r *Repo) UpsertDM(ctx context.Context, guildID int64, dm string) error {
+	const q = `
+		INSERT INTO welcome (guild_id, welcome_dm)
+		VALUES ($1, $2)
+		ON CONFLICT (guild_id)
+		DO UPDATE SET welcome_dm = EXCLUDED.welcome_dm
+	`
+	_, err := r.db.ExecContext(ctx, q, guildID, dm)
+	return err
+}
+
+func (r *Repo) UpsertGIF(ctx context.Context, guildID int64, gifURL string) error {
+	const q = `
+		INSERT INTO welcome (guild_id, welcome_gif_url)
+		VALUES ($1, $2)
+		ON CONFLICT (guild_id)
+		DO UPDATE SET welcome_gif_url = EXCLUDED.welcome_gif_url
+	`
+	_, err := r.db.ExecContext(ctx, q, guildID, gifURL)
+	return err
+}
+

internal/db/services/defaultrole/service.go

@@ -0,0 +1,24 @@
+package defaultrole
+
+import (
+	"context"
+
+	"velox-bot/internal/db/repos/defaultrolerepo"
+)
+
+type Service struct {
+	repo *defaultrolerepo.Repo
+}
+
+func New(repo *defaultrolerepo.Repo) *Service {
+	return &Service{repo: repo}
+}
+
+func (s *Service) GetRole(ctx context.Context, guildID int64) (int64, error) {
+	return s.repo.GetRole(ctx, guildID)
+}
+
+func (s *Service) SetRole(ctx context.Context, guildID, roleID int64) error {
+	return s.repo.SetRole(ctx, guildID, roleID)
+}
+

internal/db/services/logsettings/service.go

@@ -0,0 +1,32 @@
+package logsettings
+
+import (
+	"context"
+
+	"velox-bot/internal/db/repos/settingsrepo"
+)
+
+type Service struct {
+	settings *settingsrepo.Repo
+}
+
+func New(settings *settingsrepo.Repo) *Service {
+	return &Service{settings: settings}
+}
+
+func (s *Service) SetChannel(ctx context.Context, guildID, channelID int64) error {
+	return s.settings.SetLogChannel(ctx, guildID, channelID)
+}
+
+func (s *Service) SetEnabled(ctx context.Context, guildID int64, enabled bool) error {
+	return s.settings.SetLogEnabled(ctx, guildID, enabled)
+}
+
+func (s *Service) GetSettings(ctx context.Context, guildID int64) (*settingsrepo.LogSettings, error) {
+	return s.settings.GetLogSettings(ctx, guildID)
+}
+
+func (s *Service) HasSettings(ctx context.Context, guildID int64) (bool, error) {
+	return s.settings.HasLogSettings(ctx, guildID)
+}
+

internal/db/services/musicsettings/service.go

@@ -0,0 +1,32 @@
+package musicsettings
+
+import (
+	"context"
+	"velox-bot/internal/db/repos/settingsrepo"
+)
+
+type Service struct {
+	settings *settingsrepo.Repo
+}
+
+func New(settings *settingsrepo.Repo) *Service {
+	return &Service{settings: settings}
+}
+
+func (s *Service) ToggleMusic(ctx context.Context, guildID int64) (bool, error) {
+	enabled, err := s.settings.IsMusicEnabled(ctx, guildID)
+	if err != nil {
+		return false, err
+	}
+
+	newEnabled := !enabled
+	if err := s.settings.SetMusicEnabled(ctx, guildID, newEnabled); err != nil {
+		return false, err
+	}
+
+	return newEnabled, nil
+}
+
+func (s *Service) IsMusicEnabled(ctx context.Context, guildID int64) (bool, error) {
+	return s.settings.IsMusicEnabled(ctx, guildID)
+}

internal/db/services/projects/service.go

@@ -26,7 +26,19 @@ func (s *Service) ListActiveWithMembers(ctx context.Context, guildID int64, limi
 	return s.repo.ListActiveProjectsWithMembers(ctx, guildID, limit)
 }
 
+func (s *Service) ListActive(ctx context.Context, guildID int64, limit int) ([]*projectsrepo.Project, error) {
+	return s.repo.ListActiveProjects(ctx, guildID, limit)
+}
+
 func (s *Service) ProjectExistsInGuild(ctx context.Context, guildID, projectID int64) (bool, error) {
 	return s.repo.ProjectExistsInGuild(ctx, guildID, projectID)
 }
 
+func (s *Service) GetProject(ctx context.Context, guildID, projectID int64) (*projectsrepo.Project, error) {
+	return s.repo.GetProject(ctx, guildID, projectID)
+}
+
+func (s *Service) DeactivateProject(ctx context.Context, guildID, projectID int64) error {
+	return s.repo.DeactivateProject(ctx, guildID, projectID)
+}
+

internal/db/services/schedule/service.go

@@ -19,14 +19,6 @@ func (s *Service) CreateSchedule(ctx context.Context, guildID, requesterID, invi
 	return s.repo.CreateSchedule(ctx, guildID, requesterID, inviteeID, when, description)
 }
 
-func (s *Service) AddMessage(ctx context.Context, scheduleID, messageID, channelID int64, isDM bool) error {
-	return s.repo.AddMessage(ctx, scheduleID, messageID, channelID, isDM)
-}
-
-func (s *Service) GetByMessageID(ctx context.Context, messageID int64) (*schedulerepo.Schedule, error) {
-	return s.repo.GetByMessageID(ctx, messageID)
-}
-
 func (s *Service) UpdateStatus(ctx context.Context, scheduleID int64, status schedulerepo.ScheduleStatus) error {
 	return s.repo.UpdateStatus(ctx, scheduleID, status)
 }
@@ -51,3 +43,14 @@ func (s *Service) Reschedule(ctx context.Context, id int64, when time.Time) erro
 	return s.repo.Reschedule(ctx, id, when)
 }
 
+func (s *Service) ProposeReschedule(ctx context.Context, scheduleID int64, newTime time.Time, proposedBy int64) error {
+	return s.repo.ProposeReschedule(ctx, scheduleID, newTime, proposedBy)
+}
+
+func (s *Service) AcceptReschedule(ctx context.Context, id int64) error {
+	return s.repo.AcceptReschedule(ctx, id)
+}
+
+func (s *Service) DeclineReschedule(ctx context.Context, id int64) error {
+	return s.repo.DeclineReschedule(ctx, id)
+}

internal/db/services/services.go

@@ -1,13 +1,18 @@
 package services
 
 import (
+	"velox-bot/internal/db/services/defaultrole"
 	"velox-bot/internal/db/services/level"
 	"velox-bot/internal/db/services/levelsettings"
+	"velox-bot/internal/db/services/logsettings"
 	"velox-bot/internal/db/services/meeting"
-	"velox-bot/internal/db/services/schedule"
-	"velox-bot/internal/db/services/usersettings"
+	"velox-bot/internal/db/services/musicsettings"
 	"velox-bot/internal/db/services/projects"
 	"velox-bot/internal/db/services/rps"
+	"velox-bot/internal/db/services/schedule"
+	"velox-bot/internal/db/services/twitch"
+	"velox-bot/internal/db/services/usersettings"
+	"velox-bot/internal/db/services/welcome"
 )
 
 type Services struct {
@@ -18,11 +23,16 @@ type Services struct {
 	UserSettings  *usersettings.Service
 	Projects      *projects.Service
 	RPS           *rps.Service
+	Twitch        *twitch.Service
+	Welcome       *welcome.Service
+	DefaultRole   *defaultrole.Service
+	LogSettings   *logsettings.Service
+	MusicSettings *musicsettings.Service
 }
 
 var Global *Services
 
-func NewServices(level *level.Service, levelSettings *levelsettings.Service, meeting *meeting.Service, schedule *schedule.Service, userSettings *usersettings.Service, projects *projects.Service, rps *rps.Service) *Services {
+func NewServices(level *level.Service, levelSettings *levelsettings.Service, meeting *meeting.Service, schedule *schedule.Service, userSettings *usersettings.Service, projects *projects.Service, rps *rps.Service, twitchSvc *twitch.Service, welcomeSvc *welcome.Service, defaultRoleSvc *defaultrole.Service, logSettingsSvc *logsettings.Service, musicSvc *musicsettings.Service) *Services {
 	s := &Services{
 		Level:         level,
 		LevelSettings: levelSettings,
@@ -31,6 +41,11 @@ func NewServices(level *level.Service, levelSettings *levelsettings.Service, mee
 		UserSettings:  userSettings,
 		Projects:      projects,
 		RPS:           rps,
+		Twitch:        twitchSvc,
+		Welcome:       welcomeSvc,
+		DefaultRole:   defaultRoleSvc,
+		LogSettings:   logSettingsSvc,
+		MusicSettings: musicSvc,
 	}
 	Global = s
 	return s

internal/db/services/twitch/service.go

@@ -0,0 +1,117 @@
+package twitch
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"velox-bot/internal/db/repos/twitchrepo"
+)
+
+type Service struct {
+	repo         *twitchrepo.Repo
+	client       *http.Client
+	twitchClient string
+}
+
+func New(repo *twitchrepo.Repo, twitchClientID string) *Service {
+	return &Service{
+		repo: repo,
+		client: &http.Client{
+			Timeout: 5 * time.Second,
+		},
+		twitchClient: twitchClientID,
+	}
+}
+
+func (s *Service) ListGuilds(ctx context.Context) ([]int64, error) {
+	return s.repo.ListGuilds(ctx)
+}
+
+func (s *Service) ListUsersForGuild(ctx context.Context, guildID int64) ([]string, error) {
+	return s.repo.ListUsersForGuild(ctx, guildID)
+}
+
+func (s *Service) GetStatus(ctx context.Context, guildID int64, username string) (string, bool, error) {
+	return s.repo.GetStatus(ctx, guildID, username)
+}
+
+func (s *Service) UpdateStatus(ctx context.Context, guildID int64, username, status string) error {
+	return s.repo.UpdateStatus(ctx, guildID, username, status)
+}
+
+func (s *Service) UpsertStreamer(ctx context.Context, guildID int64, username string) error {
+	return s.repo.UpsertStreamer(ctx, guildID, username)
+}
+
+func (s *Service) RemoveStreamer(ctx context.Context, guildID int64, username string) error {
+	return s.repo.RemoveStreamer(ctx, guildID, username)
+}
+
+func (s *Service) GetNotificationChannel(ctx context.Context, guildID int64) (int64, bool, error) {
+	return s.repo.GetNotificationChannel(ctx, guildID)
+}
+
+func (s *Service) SetNotificationChannel(ctx context.Context, guildID, channelID int64) error {
+	return s.repo.SetNotificationChannel(ctx, guildID, channelID)
+}
+
+func (s *Service) IsEnabled(ctx context.Context, guildID int64) (bool, error) {
+	return s.repo.IsEnabled(ctx, guildID)
+}
+
+func (s *Service) SetEnabled(ctx context.Context, guildID int64, enabled bool) error {
+	return s.repo.SetEnabled(ctx, guildID, enabled)
+}
+
+func (s *Service) IsUserStreaming(ctx context.Context, username string) (bool, error) {
+	type gqlRequest struct {
+		Query     string                 `json:"query"`
+		Variables map[string]any         `json:"variables"`
+	}
+	type gqlResponse struct {
+		Data struct {
+			User *struct {
+				Stream *struct {
+					ID string `json:"id"`
+				} `json:"stream"`
+			} `json:"user"`
+		} `json:"data"`
+	}
+
+	q := fmt.Sprintf(`query { user(login: "%s") { stream { id } } }`, username)
+	body, err := json.Marshal(gqlRequest{
+		Query:     q,
+		Variables: map[string]any{},
+	})
+	if err != nil {
+		return false, err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, "https://gql.twitch.tv/gql", bytes.NewReader(body))
+	if err != nil {
+		return false, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Client-Id", s.twitchClient)
+
+	resp, err := s.client.Do(req)
+	if err != nil {
+		return false, err
+	}
+	defer resp.Body.Close()
+
+	var respBody gqlResponse
+	if err := json.NewDecoder(resp.Body).Decode(&respBody); err != nil {
+		return false, err
+	}
+
+	if respBody.Data.User == nil {
+		return false, nil
+	}
+	return respBody.Data.User.Stream != nil, nil
+}
+

internal/db/services/welcome/service.go

@@ -0,0 +1,36 @@
+package welcome
+
+import (
+	"context"
+
+	"velox-bot/internal/db/repos/welcomerepo"
+)
+
+type Service struct {
+	repo *welcomerepo.Repo
+}
+
+func New(repo *welcomerepo.Repo) *Service {
+	return &Service{repo: repo}
+}
+
+func (s *Service) GetSettings(ctx context.Context, guildID int64) (*welcomerepo.Settings, error) {
+	return s.repo.GetSettings(ctx, guildID)
+}
+
+func (s *Service) SetChannel(ctx context.Context, guildID, channelID int64) error {
+	return s.repo.UpsertChannel(ctx, guildID, channelID)
+}
+
+func (s *Service) SetMessage(ctx context.Context, guildID int64, message string) error {
+	return s.repo.UpsertMessage(ctx, guildID, message)
+}
+
+func (s *Service) SetDM(ctx context.Context, guildID int64, dm string) error {
+	return s.repo.UpsertDM(ctx, guildID, dm)
+}
+
+func (s *Service) SetGIF(ctx context.Context, guildID int64, gifURL string) error {
+	return s.repo.UpsertGIF(ctx, guildID, gifURL)
+}
+

internal/events/event_handlers.go

@@ -11,6 +11,8 @@ import (
 )
 
 func HandleMessageCreate(s *discordgo.Session, m *discordgo.MessageCreate, services *services.Services) {
+	CacheMessageFromCreate(m)
+
 	if m.Author.Bot || m.GuildID == "" {
 		return
 	}

internal/events/logging.go

@@ -0,0 +1,376 @@
+package events
+
+import (
+	"fmt"
+	"log"
+	"slices"
+	"strings"
+	"sync"
+	"time"
+
+	"velox-bot/internal/db/services"
+	"velox-bot/internal/modlog"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+type cachedMessage struct {
+	Content  string
+	AuthorID string
+}
+
+var messageCache sync.Map // map[messageID]cachedMessage
+
+func HandleMessageUpdateLog(s *discordgo.Session, m *discordgo.MessageUpdate, svc *services.Services) {
+	if s == nil || m == nil || m.Message == nil || m.GuildID == "" || svc == nil {
+		return
+	}
+	if m.Author != nil && m.Author.Bot {
+		return
+	}
+
+	before := ""
+	if m.BeforeUpdate != nil {
+		before = strings.TrimSpace(m.BeforeUpdate.Content)
+	}
+	if before == "" {
+		if prev, ok := getCachedMessage(m.ID); ok {
+			before = strings.TrimSpace(prev.Content)
+		}
+	}
+	after := strings.TrimSpace(m.Content)
+	if before == after {
+		return
+	}
+
+	jumpURL := fmt.Sprintf("https://discord.com/channels/%s/%s/%s", m.GuildID, m.ChannelID, m.ID)
+	authorMention := "Unknown"
+	if m.Author != nil {
+		authorMention = m.Author.Mention()
+	}
+
+	embed := &discordgo.MessageEmbed{
+		Title:       "Message Edited",
+		Color:       0xF1C40F,
+		Description: fmt.Sprintf("Author: %s\nChannel: <#%s>\n[Jump to message](%s)", authorMention, m.ChannelID, jumpURL),
+		Fields: []*discordgo.MessageEmbedField{
+			{Name: "Before", Value: truncateOrPlaceholder(before), Inline: false},
+			{Name: "After", Value: truncateOrPlaceholder(after), Inline: false},
+		},
+		Timestamp: time.Now().Format(time.RFC3339),
+	}
+	if err := modlog.Send(s, svc, m.GuildID, embed); err != nil {
+		log.Printf("log: failed to send message edit log: %v", err)
+	}
+
+	cacheMessage(m.ID, after, authorIDOrEmpty(m.Author))
+}
+
+func HandleMessageDeleteLog(s *discordgo.Session, m *discordgo.MessageDelete, svc *services.Services) {
+	if s == nil || m == nil || m.Message == nil || m.GuildID == "" || svc == nil {
+		return
+	}
+
+	authorID := ""
+	authorLabel := "Unknown"
+	content := ""
+	if m.BeforeDelete != nil {
+		if m.BeforeDelete.Author != nil {
+			authorID = m.BeforeDelete.Author.ID
+			authorLabel = m.BeforeDelete.Author.Mention()
+		}
+		content = strings.TrimSpace(m.BeforeDelete.Content)
+	}
+	if content == "" {
+		if prev, ok := getCachedMessage(m.ID); ok {
+			content = strings.TrimSpace(prev.Content)
+			if authorID == "" && prev.AuthorID != "" {
+				authorID = prev.AuthorID
+				authorLabel = "<@" + prev.AuthorID + ">"
+			}
+		}
+	}
+	if authorID == "" && m.Author != nil {
+		authorID = m.Author.ID
+		authorLabel = m.Author.Mention()
+	}
+	if authorID == "" {
+		authorLabel = "Unknown"
+	}
+
+	embed := &discordgo.MessageEmbed{
+		Title:       "Message Deleted",
+		Color:       0xE74C3C,
+		Description: fmt.Sprintf("Author: %s\nChannel: <#%s>\nMessage ID: `%s`", authorLabel, m.ChannelID, m.ID),
+		Fields: []*discordgo.MessageEmbedField{
+			{Name: "Content", Value: truncateOrPlaceholder(content), Inline: false},
+		},
+		Timestamp: time.Now().Format(time.RFC3339),
+	}
+	if err := modlog.Send(s, svc, m.GuildID, embed); err != nil {
+		log.Printf("log: failed to send message delete log: %v", err)
+	}
+	deleteCachedMessage(m.ID)
+}
+
+func HandleGuildMemberAddLog(s *discordgo.Session, m *discordgo.GuildMemberAdd, svc *services.Services) {
+	if s == nil || m == nil || m.Member == nil || m.User == nil || m.GuildID == "" || svc == nil {
+		return
+	}
+	embed := &discordgo.MessageEmbed{
+		Title:       "Member Joined",
+		Color:       0x2ECC71,
+		Description: fmt.Sprintf("%s joined the server.\nUser ID: `%s`", m.User.Mention(), m.User.ID),
+		Timestamp:   time.Now().Format(time.RFC3339),
+	}
+	if err := modlog.Send(s, svc, m.GuildID, embed); err != nil {
+		log.Printf("log: failed to send member join log: %v", err)
+	}
+}
+
+func HandleGuildMemberRemoveLog(s *discordgo.Session, m *discordgo.GuildMemberRemove, svc *services.Services) {
+	if s == nil || m == nil || m.Member == nil || m.User == nil || m.GuildID == "" || svc == nil {
+		return
+	}
+
+	// Try to classify this leave as a kick via recent audit log.
+	kickEntry, kickMod := findRecentAuditEntryForTarget(s, m.GuildID, m.User.ID, discordgo.AuditLogActionMemberKick)
+	title := "Member Left"
+	color := 0x95A5A6
+	description := fmt.Sprintf("%s left the server.\nUser ID: `%s`", m.User.Mention(), m.User.ID)
+	if kickEntry != nil {
+		title = "Member Kicked"
+		color = 0xE67E22
+		description = fmt.Sprintf("%s was kicked.\nUser ID: `%s`", m.User.Mention(), m.User.ID)
+		if kickMod != nil {
+			description += "\nModerator: " + kickMod.Mention()
+		}
+		if strings.TrimSpace(kickEntry.Reason) != "" {
+			description += "\nReason: " + kickEntry.Reason
+		}
+	}
+
+	embed := &discordgo.MessageEmbed{
+		Title:       title,
+		Color:       color,
+		Description: description,
+		Timestamp:   time.Now().Format(time.RFC3339),
+	}
+	if err := modlog.Send(s, svc, m.GuildID, embed); err != nil {
+		log.Printf("log: failed to send member remove log: %v", err)
+	}
+}
+
+func HandleGuildMemberUpdateLog(s *discordgo.Session, m *discordgo.GuildMemberUpdate, svc *services.Services) {
+	if s == nil || m == nil || m.Member == nil || m.User == nil || m.GuildID == "" || svc == nil || m.BeforeUpdate == nil {
+		return
+	}
+
+	added := diffRoleIDs(m.BeforeUpdate.Roles, m.Roles)
+	removed := diffRoleIDs(m.Roles, m.BeforeUpdate.Roles)
+	if len(added) == 0 && len(removed) == 0 {
+		return
+	}
+
+	fields := make([]*discordgo.MessageEmbedField, 0, 2)
+	if len(added) > 0 {
+		fields = append(fields, &discordgo.MessageEmbedField{
+			Name:   "Roles Added",
+			Value:  joinRoleMentions(added),
+			Inline: false,
+		})
+	}
+	if len(removed) > 0 {
+		fields = append(fields, &discordgo.MessageEmbedField{
+			Name:   "Roles Removed",
+			Value:  joinRoleMentions(removed),
+			Inline: false,
+		})
+	}
+
+	embed := &discordgo.MessageEmbed{
+		Title:       "Member Roles Updated",
+		Color:       0x3498DB,
+		Description: fmt.Sprintf("Member: %s (`%s`)", m.User.Mention(), m.User.ID),
+		Fields:      fields,
+		Timestamp:   time.Now().Format(time.RFC3339),
+	}
+	if err := modlog.Send(s, svc, m.GuildID, embed); err != nil {
+		log.Printf("log: failed to send member update log: %v", err)
+	}
+}
+
+func HandleGuildBanAddLog(s *discordgo.Session, m *discordgo.GuildBanAdd, svc *services.Services) {
+	if s == nil || m == nil || m.User == nil || m.GuildID == "" || svc == nil {
+		return
+	}
+
+	entry, moderator := findRecentAuditEntryForTarget(s, m.GuildID, m.User.ID, discordgo.AuditLogActionMemberBanAdd)
+	desc := fmt.Sprintf("%s was banned.\nUser ID: `%s`", m.User.Mention(), m.User.ID)
+	if moderator != nil {
+		desc += "\nModerator: " + moderator.Mention()
+	}
+	if entry != nil && strings.TrimSpace(entry.Reason) != "" {
+		desc += "\nReason: " + entry.Reason
+	}
+
+	embed := &discordgo.MessageEmbed{
+		Title:       "Member Banned",
+		Color:       0xC0392B,
+		Description: desc,
+		Timestamp:   time.Now().Format(time.RFC3339),
+	}
+	if err := modlog.Send(s, svc, m.GuildID, embed); err != nil {
+		log.Printf("log: failed to send ban add log: %v", err)
+	}
+}
+
+func HandleGuildBanRemoveLog(s *discordgo.Session, m *discordgo.GuildBanRemove, svc *services.Services) {
+	if s == nil || m == nil || m.User == nil || m.GuildID == "" || svc == nil {
+		return
+	}
+
+	entry, moderator := findRecentAuditEntryForTarget(s, m.GuildID, m.User.ID, discordgo.AuditLogActionMemberBanRemove)
+	desc := fmt.Sprintf("%s was unbanned.\nUser ID: `%s`", m.User.Mention(), m.User.ID)
+	if moderator != nil {
+		desc += "\nModerator: " + moderator.Mention()
+	}
+	if entry != nil && strings.TrimSpace(entry.Reason) != "" {
+		desc += "\nReason: " + entry.Reason
+	}
+
+	embed := &discordgo.MessageEmbed{
+		Title:       "Member Unbanned",
+		Color:       0x27AE60,
+		Description: desc,
+		Timestamp:   time.Now().Format(time.RFC3339),
+	}
+	if err := modlog.Send(s, svc, m.GuildID, embed); err != nil {
+		log.Printf("log: failed to send ban remove log: %v", err)
+	}
+}
+
+func findRecentAuditEntryForTarget(s *discordgo.Session, guildID, targetID string, action discordgo.AuditLogAction) (*discordgo.AuditLogEntry, *discordgo.User) {
+	if s == nil || guildID == "" || targetID == "" {
+		return nil, nil
+	}
+	logs, err := s.GuildAuditLog(guildID, "", "", int(action), 10)
+	if err != nil || logs == nil {
+		return nil, nil
+	}
+
+	var chosen *discordgo.AuditLogEntry
+	now := time.Now().UTC()
+	for _, e := range logs.AuditLogEntries {
+		if e == nil || e.TargetID != targetID || e.ActionType == nil || *e.ActionType != action {
+			continue
+		}
+		ts, err := discordgo.SnowflakeTimestamp(e.ID)
+		if err != nil {
+			continue
+		}
+		// Keep only very recent entries to reduce false positives.
+		if now.Sub(ts) > 2*time.Minute {
+			continue
+		}
+		chosen = e
+		break
+	}
+	if chosen == nil {
+		return nil, nil
+	}
+
+	for _, u := range logs.Users {
+		if u != nil && u.ID == chosen.UserID {
+			return chosen, u
+		}
+	}
+	return chosen, nil
+}
+
+func truncateOrPlaceholder(s string) string {
+	v := strings.TrimSpace(s)
+	if v == "" {
+		return "*empty*"
+	}
+	if len(v) <= 1000 {
+		return v
+	}
+	return v[:997] + "..."
+}
+
+func diffRoleIDs(base, compare []string) []string {
+	out := make([]string, 0)
+	for _, id := range base {
+		if id == "" {
+			continue
+		}
+		if !slices.Contains(compare, id) {
+			out = append(out, id)
+		}
+	}
+	return out
+}
+
+func joinRoleMentions(roleIDs []string) string {
+	if len(roleIDs) == 0 {
+		return "*none*"
+	}
+	const max = 12
+	parts := make([]string, 0, len(roleIDs))
+	for idx, id := range roleIDs {
+		if idx >= max {
+			parts = append(parts, fmt.Sprintf("... and %d more", len(roleIDs)-max))
+			break
+		}
+		parts = append(parts, "<@&"+id+">")
+	}
+	return strings.Join(parts, ", ")
+}
+
+func CacheMessageFromCreate(m *discordgo.MessageCreate) {
+	if m == nil || m.Message == nil || m.ID == "" {
+		return
+	}
+	cacheMessage(m.ID, strings.TrimSpace(m.Content), authorIDOrEmpty(m.Author))
+}
+
+func cacheMessage(messageID, content, authorID string) {
+	if messageID == "" {
+		return
+	}
+	messageCache.Store(messageID, cachedMessage{
+		Content:  content,
+		AuthorID: authorID,
+	})
+}
+
+func getCachedMessage(messageID string) (cachedMessage, bool) {
+	if messageID == "" {
+		return cachedMessage{}, false
+	}
+	raw, ok := messageCache.Load(messageID)
+	if !ok {
+		return cachedMessage{}, false
+	}
+	msg, ok := raw.(cachedMessage)
+	if !ok {
+		return cachedMessage{}, false
+	}
+	return msg, true
+}
+
+func deleteCachedMessage(messageID string) {
+	if messageID == "" {
+		return
+	}
+	messageCache.Delete(messageID)
+}
+
+func authorIDOrEmpty(u *discordgo.User) string {
+	if u == nil {
+		return ""
+	}
+	return u.ID
+}
+

internal/events/onboarding.go

@@ -0,0 +1,163 @@
+package events
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strconv"
+	"strings"
+	"time"
+
+	"velox-bot/internal/db/services"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// HandleBotAddedOnGuild applies safe defaults when this bot is added to a guild
+// and DMs setup instructions to the inviter (or guild owner fallback).
+func HandleBotAddedOnGuild(s *discordgo.Session, m *discordgo.GuildMemberAdd, svc *services.Services) {
+	if s == nil || m == nil || m.Member == nil || m.User == nil || svc == nil {
+		return
+	}
+	if s.State == nil || s.State.User == nil {
+		return
+	}
+	if m.User.ID != s.State.User.ID {
+		return
+	}
+
+	guildID64, err := strconv.ParseInt(m.GuildID, 10, 64)
+	if err != nil {
+		return
+	}
+
+	// Treat an existing logsettings row as "already onboarded once".
+	alreadyOnboarded := false
+	if svc.LogSettings != nil {
+		exists, err := svc.LogSettings.HasSettings(context.Background(), guildID64)
+		if err == nil {
+			alreadyOnboarded = exists
+		}
+	}
+	if alreadyOnboarded {
+		return
+	}
+
+	// Explicitly disable toggleable systems by default.
+	if svc.LevelSettings != nil {
+		if err := svc.LevelSettings.SetLevelSystemEnabled(context.Background(), guildID64, false); err != nil {
+			log.Printf("onboarding: failed to set default level state for guild %s: %v", m.GuildID, err)
+		}
+	}
+	if svc.LogSettings != nil {
+		if err := svc.LogSettings.SetEnabled(context.Background(), guildID64, false); err != nil {
+			log.Printf("onboarding: failed to set default log state for guild %s: %v", m.GuildID, err)
+		}
+	}
+
+	recipientID := findRecentBotAdderID(s, m.GuildID)
+	if recipientID == "" {
+		recipientID = guildOwnerID(s, m.GuildID)
+	}
+	if recipientID == "" {
+		log.Printf("onboarding: unable to resolve DM recipient for guild %s", m.GuildID)
+		return
+	}
+
+	dmCh, err := s.UserChannelCreate(recipientID)
+	if err != nil {
+		log.Printf("onboarding: failed creating DM for user %s: %v", recipientID, err)
+		return
+	}
+
+	guildName := m.GuildID
+	if g, err := s.State.Guild(m.GuildID); err == nil && g != nil && strings.TrimSpace(g.Name) != "" {
+		guildName = g.Name
+	} else if g, err := s.Guild(m.GuildID); err == nil && g != nil && strings.TrimSpace(g.Name) != "" {
+		guildName = g.Name
+	}
+
+	embed := &discordgo.MessageEmbed{
+		Title: "Thanks for adding Velox Bot!",
+		Color: 0x5865F2,
+		Description: fmt.Sprintf(
+			"Server: **%s**\n\nFor safety, toggleable systems start **disabled by default**.\nUse these commands in your server to enable features:",
+			guildName,
+		),
+		Fields: []*discordgo.MessageEmbedField{
+			{
+				Name: "Level System",
+				Value: "`/slvl toggle`",
+				Inline: false,
+			},
+			{
+				Name: "Logging System",
+				Value: "" +
+					"`/config setlogchannel channel:#channel`\n" +
+					"`/config enablelogging`",
+				Inline: false,
+			},
+			{
+				Name: "Welcome System",
+				Value: "" +
+					"`/config setwelcomechannel channel:#channel`\n" +
+					"`/config setwelcomemessage message:\"...\"`\n" +
+					"`/config setwelcomedm message:\"...\"`",
+				Inline: false,
+			},
+		},
+		Footer: &discordgo.MessageEmbedFooter{
+			Text: "Tip: run /help in any server channel for the full command reference.",
+		},
+		Timestamp: time.Now().Format(time.RFC3339),
+	}
+
+	if _, err := s.ChannelMessageSendEmbed(dmCh.ID, embed); err != nil {
+		log.Printf("onboarding: failed sending setup DM to user %s: %v", recipientID, err)
+	}
+}
+
+func findRecentBotAdderID(s *discordgo.Session, guildID string) string {
+	if s == nil || s.State == nil || s.State.User == nil {
+		return ""
+	}
+	logs, err := s.GuildAuditLog(guildID, "", "", int(discordgo.AuditLogActionBotAdd), 10)
+	if err != nil || logs == nil {
+		return ""
+	}
+
+	botID := s.State.User.ID
+	now := time.Now().UTC()
+	for _, entry := range logs.AuditLogEntries {
+		if entry == nil || entry.TargetID != botID || entry.ActionType == nil || *entry.ActionType != discordgo.AuditLogActionBotAdd {
+			continue
+		}
+		ts, err := discordgo.SnowflakeTimestamp(entry.ID)
+		if err != nil {
+			continue
+		}
+		if now.Sub(ts) > 10*time.Minute {
+			continue
+		}
+		if entry.UserID != "" {
+			return entry.UserID
+		}
+	}
+	return ""
+}
+
+func guildOwnerID(s *discordgo.Session, guildID string) string {
+	if s == nil || guildID == "" {
+		return ""
+	}
+	if s.State != nil {
+		if g, err := s.State.Guild(guildID); err == nil && g != nil && g.OwnerID != "" {
+			return g.OwnerID
+		}
+	}
+	if g, err := s.Guild(guildID); err == nil && g != nil {
+		return g.OwnerID
+	}
+	return ""
+}
+

internal/events/schedule_reactions.go

@@ -1,95 +0,0 @@
-package events
-
-import (
-	"context"
-	"log"
-	"strconv"
-
-	"velox-bot/internal/db/repos/schedulerepo"
-	"velox-bot/internal/db/services"
-
-	"github.com/bwmarrin/discordgo"
-)
-
-// HandleMessageReactionAdd reacts to emoji on schedule DM messages:
-// ✅ accept, ❌ decline, 🔁 request reschedule.
-func HandleMessageReactionAdd(s *discordgo.Session, r *discordgo.MessageReactionAdd, svc *services.Services) {
-	if svc == nil || svc.Schedule == nil {
-		return
-	}
-	if r == nil || r.UserID == "" || r.MessageID == "" {
-		return
-	}
-
-	// Ignore bot reactions.
-	if r.Member != nil && r.Member.User != nil && r.Member.User.Bot {
-		return
-	}
-
-	msgID64, err := strconv.ParseInt(r.MessageID, 10, 64)
-	if err != nil || msgID64 == 0 {
-		return
-	}
-
-	ctx := context.Background()
-	sch, err := svc.Schedule.GetByMessageID(ctx, msgID64)
-	if err != nil || sch == nil {
-		return
-	}
-
-	// Only invitee can react to change status.
-	if r.UserID != strconv.FormatInt(sch.InviteeID, 10) {
-		return
-	}
-
-	// Only pending can be transitioned by reaction.
-	if sch.Status != schedulerepo.StatusPending {
-		return
-	}
-
-	var newStatus schedulerepo.ScheduleStatus
-	switch r.Emoji.Name {
-	case "✅":
-		newStatus = schedulerepo.StatusAccepted
-	case "❌":
-		newStatus = schedulerepo.StatusDeclined
-	case "🔁":
-		newStatus = schedulerepo.StatusRescheduleRequested
-	default:
-		return
-	}
-
-	if err := svc.Schedule.UpdateStatus(ctx, sch.ID, newStatus); err != nil {
-		log.Printf("schedule: failed to update status id=%d: %v", sch.ID, err)
-		return
-	}
-
-	statusText := map[schedulerepo.ScheduleStatus]string{
-		schedulerepo.StatusAccepted:            "accepted ✅",
-		schedulerepo.StatusDeclined:            "declined ❌",
-		schedulerepo.StatusRescheduleRequested: "requested rescheduling 🔁",
-	}[newStatus]
-
-	utcStr := sch.ScheduledAt.UTC().Format("2006-01-02 15:04")
-
-	// Notify requester with local time if configured.
-	if svc.UserSettings != nil {
-		loc, zone, _, err := svc.UserSettings.GetTimezone(ctx, sch.RequesterID)
-		if err != nil {
-			loc = sch.ScheduledAt.UTC().Location()
-			zone = "UTC"
-		}
-		localStr := sch.ScheduledAt.In(loc).Format("2006-01-02 15:04")
-		content := "Your session request with <@" + strconv.FormatInt(sch.InviteeID, 10) + "> for " +
-			utcStr + " UTC (" + localStr + " " + zone + ") has been " + statusText + "."
-
-		requesterID := strconv.FormatInt(sch.RequesterID, 10)
-		dmCh, err := s.UserChannelCreate(requesterID)
-		if err == nil {
-			if _, err := s.ChannelMessageSend(dmCh.ID, content); err != nil {
-				log.Printf("schedule: failed to DM requester about status change: %v", err)
-			}
-		}
-	}
-}
-

internal/events/twitch_live.go

@@ -0,0 +1,144 @@
+package events
+
+import (
+	"context"
+	"log"
+	"strconv"
+	"time"
+
+	"velox-bot/internal/db/services"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// StartTwitchLiveLoop periodically checks configured Twitch streamers and
+// sends live notifications to the configured channel.
+func StartTwitchLiveLoop(s *discordgo.Session, svc *services.Services) {
+	if svc == nil || svc.Twitch == nil || s == nil {
+		return
+	}
+
+	const (
+		interval     = 30 * time.Second
+		initialDelay = 10 * time.Second
+	)
+
+	go func() {
+		time.Sleep(initialDelay)
+
+		log.Printf("twitch: starting live notification loop (interval=%s)", interval)
+
+		ticker := time.NewTicker(interval)
+		defer ticker.Stop()
+
+		for range ticker.C {
+			ctx := context.Background()
+
+			guildIDs, err := svc.Twitch.ListGuilds(ctx)
+			if err != nil {
+				log.Printf("twitch: failed to list guilds: %v", err)
+				continue
+			}
+
+			if len(guildIDs) == 0 {
+				log.Printf("twitch: no guilds with configured streamers")
+			}
+
+			for _, guildID := range guildIDs {
+				log.Printf("twitch: processing guild %d", guildID)
+
+				enabled, err := svc.Twitch.IsEnabled(ctx, guildID)
+				if err != nil {
+					log.Printf("twitch: failed to check enabled state for guild %d: %v", guildID, err)
+					continue
+				}
+				if !enabled {
+					log.Printf("twitch: notifications disabled for guild %d", guildID)
+					continue
+				}
+
+				channelID, ok, err := svc.Twitch.GetNotificationChannel(ctx, guildID)
+				if err != nil {
+					log.Printf("twitch: failed to get channel for guild %d: %v", guildID, err)
+					continue
+				}
+				if !ok || channelID == 0 {
+					log.Printf("twitch: no notification channel configured for guild %d", guildID)
+					continue
+				}
+
+				users, err := svc.Twitch.ListUsersForGuild(ctx, guildID)
+				if err != nil {
+					log.Printf("twitch: failed to list users for guild %d: %v", guildID, err)
+					continue
+				}
+
+				if len(users) == 0 {
+					log.Printf("twitch: no streamers configured for guild %d", guildID)
+					continue
+				}
+
+				chIDStr := strconv.FormatInt(channelID, 10)
+
+				for _, username := range users {
+					log.Printf("twitch: checking live status for guild %d, user %s", guildID, username)
+
+					isLive, err := svc.Twitch.IsUserStreaming(ctx, username)
+					if err != nil {
+						log.Printf("twitch: failed to check stream for %s: %v", username, err)
+						continue
+					}
+
+					status, ok, err := svc.Twitch.GetStatus(ctx, guildID, username)
+					if err != nil {
+						log.Printf("twitch: failed to get status for %s: %v", username, err)
+						continue
+					}
+					if !ok {
+						status = "not live"
+					}
+
+					if isLive {
+						if status == "not live" {
+							log.Printf("twitch: %s went live in guild %d, sending notification to channel %s", username, guildID, chIDStr)
+
+							liveURL := "https://www.twitch.tv/" + username
+							content := "@everyone"
+
+							previewURL := "https://static-cdn.jtvnw.net/previews-ttv/live_user_" + username + "-640x360.jpg"
+
+							embed := &discordgo.MessageEmbed{
+								Title:       ":red_circle: " + username + " is now LIVE on Twitch!",
+								Description: "Click the link below to watch the stream.",
+								URL:         liveURL,
+								Color:       0x9146FF, // Twitch purple
+								Image: &discordgo.MessageEmbedImage{
+									URL: previewURL,
+								},
+							}
+
+							if _, err := s.ChannelMessageSendComplex(chIDStr, &discordgo.MessageSend{
+								Content: content,
+								Embed:   embed,
+							}); err != nil {
+								log.Printf("twitch: failed to send notification for %s: %v", username, err)
+								continue
+							}
+							if err := svc.Twitch.UpdateStatus(ctx, guildID, username, "live"); err != nil {
+								log.Printf("twitch: failed to update status to live for %s in guild %d: %v", username, guildID, err)
+							}
+						}
+					} else {
+						if status != "not live" {
+							log.Printf("twitch: %s is no longer live in guild %d, updating status", username, guildID)
+							if err := svc.Twitch.UpdateStatus(ctx, guildID, username, "not live"); err != nil {
+								log.Printf("twitch: failed to update status to not live for %s in guild %d: %v", username, guildID, err)
+							}
+						}
+					}
+				}
+			}
+		}
+	}()
+}
+

internal/events/welcome.go

@@ -0,0 +1,133 @@
+package events
+
+import (
+	"context"
+	"log"
+	"strconv"
+	"strings"
+
+	"velox-bot/internal/db/services"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// HandleGuildMemberAdd sends a configurable welcome message in a guild channel
+// and an optional configurable DM to the joining user.
+func HandleGuildMemberAdd(s *discordgo.Session, m *discordgo.GuildMemberAdd, svc *services.Services) {
+	if s == nil || m == nil || svc == nil || svc.Welcome == nil {
+		return
+	}
+	if m.User == nil {
+		return
+	}
+
+	ctx := context.Background()
+	guildID := mustParseInt64(m.GuildID)
+
+	settings, err := svc.Welcome.GetSettings(ctx, guildID)
+	if err != nil {
+		log.Printf("welcome: failed to load settings for guild %s: %v", m.GuildID, err)
+		return
+	}
+	hasWelcomeChannel := settings != nil && settings.ChannelID != 0
+
+	memberMention := m.User.Mention()
+
+	// Resolve guild/server name and user avatar for placeholders / visuals.
+	guildName := ""
+	userAvatarURL := ""
+	if g, err := s.State.Guild(m.GuildID); err == nil && g != nil {
+		guildName = g.Name
+	} else if g, err := s.Guild(m.GuildID); err == nil && g != nil {
+		guildName = g.Name
+	}
+	if m.User.Avatar != "" {
+		userAvatarURL = discordgo.EndpointUserAvatar(m.User.ID, m.User.Avatar)
+	}
+
+	if hasWelcomeChannel {
+		// Build guild welcome message.
+		channelID := strconv.FormatInt(settings.ChannelID, 10)
+		welcomeMsg := strings.TrimSpace(settings.WelcomeMessage)
+		if welcomeMsg == "" {
+			// Default message when none configured.
+			// "<user>! Welcome to <server>! Have fun!"
+			welcomeMsg = "<user>! Welcome to <server>! Have fun!"
+		}
+		welcomeMsg = strings.ReplaceAll(welcomeMsg, "{user}", memberMention)
+		if guildName != "" {
+			welcomeMsg = strings.ReplaceAll(welcomeMsg, "{server}", guildName)
+			welcomeMsg = strings.ReplaceAll(welcomeMsg, "<server>", guildName)
+		}
+		welcomeMsg = strings.ReplaceAll(welcomeMsg, "<user>", memberMention)
+
+		embed := &discordgo.MessageEmbed{
+			Title:       "👋 Welcome!",
+			Description: welcomeMsg,
+			Color:       0xFFA500,
+			Footer: &discordgo.MessageEmbedFooter{
+				Text: "ID: " + m.User.ID,
+			},
+		}
+		if userAvatarURL != "" {
+			embed.Author = &discordgo.MessageEmbedAuthor{
+				Name:    m.User.Username,
+				IconURL: userAvatarURL,
+			}
+			embed.Thumbnail = &discordgo.MessageEmbedThumbnail{
+				URL: userAvatarURL,
+			}
+		}
+		gif := strings.TrimSpace(settings.WelcomeGIFURL)
+		if gif == "" {
+			// Default GIF when none configured.
+			gif = "https://images-ext-1.discordapp.net/external/uJ6XfdK2WwDnei3RmNWUqSiOVboC4mK9r78TtgVE_9g/https/media.giphy.com/media/XD9o33QG9BoMis7iM4/giphy.gif"
+		}
+		embed.Image = &discordgo.MessageEmbedImage{URL: gif}
+
+		if _, err := s.ChannelMessageSendComplex(channelID, &discordgo.MessageSend{
+			Content: memberMention,
+			Embed:   embed,
+		}); err != nil {
+			log.Printf("welcome: failed to send channel welcome in guild %s: %v", m.GuildID, err)
+		}
+	}
+
+	// Optional DM.
+	dmText := ""
+	if settings != nil {
+		dmText = strings.TrimSpace(settings.WelcomeDM)
+	}
+	if dmText == "" {
+		// Default DM when none configured.
+		// "Welcome to <server>! Have fun!"
+		dmText = "Welcome to <server>! Have fun!"
+	}
+	dmText = strings.ReplaceAll(dmText, "{user}", memberMention)
+	if guildName != "" {
+		dmText = strings.ReplaceAll(dmText, "{server}", guildName)
+		dmText = strings.ReplaceAll(dmText, "<server>", guildName)
+	}
+
+	dmCh, err := s.UserChannelCreate(m.User.ID)
+	if err != nil {
+		log.Printf("welcome: failed to create DM channel for user %s: %v", m.User.ID, err)
+		return
+	}
+	if _, err := s.ChannelMessageSend(dmCh.ID, dmText); err != nil {
+		log.Printf("welcome: failed to send DM welcome to user %s: %v", m.User.ID, err)
+	}
+
+	// Default role assignment.
+	if svc.DefaultRole != nil {
+		roleID, err := svc.DefaultRole.GetRole(ctx, guildID)
+		if err != nil {
+			log.Printf("defaultrole: failed to get default role for guild %s: %v", m.GuildID, err)
+		} else if roleID != 0 {
+			if err := s.GuildMemberRoleAdd(m.GuildID, m.User.ID, strconv.FormatInt(roleID, 10)); err != nil {
+				log.Printf("defaultrole: failed to assign role %d to user %s in guild %s: %v", roleID, m.User.ID, m.GuildID, err)
+			}
+		}
+	}
+}
+

internal/modlog/modlog.go

@@ -0,0 +1,30 @@
+package modlog
+
+import (
+	"context"
+	"strconv"
+
+	"velox-bot/internal/db/services"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+func Send(s *discordgo.Session, svc *services.Services, guildID string, embed *discordgo.MessageEmbed) error {
+	if s == nil || svc == nil || svc.LogSettings == nil || embed == nil || guildID == "" {
+		return nil
+	}
+
+	gid, err := strconv.ParseInt(guildID, 10, 64)
+	if err != nil {
+		return nil
+	}
+
+	cfg, err := svc.LogSettings.GetSettings(context.Background(), gid)
+	if err != nil || cfg == nil || !cfg.IsEnabled || cfg.ChannelID == 0 {
+		return err
+	}
+
+	_, err = s.ChannelMessageSendEmbed(strconv.FormatInt(cfg.ChannelID, 10), embed)
+	return err
+}
+

internal/music/components.go

@@ -97,7 +97,10 @@ func HandleComponent(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		content = "Done."
 	}
 	if err != nil {
-		content = "Error: " + err.Error()
+		// err can carry a raw Lavalink/network failure here (Player.Update),
+		// not just our own "music manager not initialized" - don't echo
+		// that detail into the ephemeral reply.
+		content = "That didn't work. Please try again."
 	}
 
 	// send ephemeral confirmation

internal/music/listener.go

@@ -0,0 +1,133 @@
+package music
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"strconv"
+	"velox-bot/internal/db/repos/musicrepo"
+
+	"github.com/jackc/pgx/v5"
+)
+
+func StartCommandListener(ctx context.Context, connString string, repo *musicrepo.Repo) error {
+	conn, err := pgx.Connect(ctx, connString)
+	if err != nil {
+		return fmt.Errorf("connect: %w", err)
+	}
+	defer conn.Close(ctx)
+
+	_, err = conn.Exec(ctx, "LISTEN music_commands")
+	if err != nil {
+		return fmt.Errorf("exec: %w", err)
+	}
+
+	for {
+		_, err := conn.WaitForNotification(ctx)
+		if err != nil {
+			return fmt.Errorf("waitfornotification: %w", err)
+		}
+
+		processCommands(ctx, repo)
+	}
+}
+
+func processCommands(ctx context.Context, repo *musicrepo.Repo) {
+	cmds, err := repo.ListUnprocessedCommands(ctx)
+	if err != nil {
+		log.Printf("music: failed to list unprocessed commands: %v", err)
+		return
+	}
+
+	for _, cmd := range cmds {
+		if err := dispatchCommand(cmd); err != nil {
+			log.Printf("music: command %d (%s) for guild %d failed: %v", cmd.ID, cmd.CommandType, cmd.GuildID, err)
+		}
+
+		if err := repo.MarkCommandProcessed(ctx, cmd.ID); err != nil {
+			log.Printf("music: failed to mark command %d processed: %v", cmd.ID, err)
+		}
+	}
+}
+
+func dispatchCommand(cmd musicrepo.MusicCommand) error {
+	guildID := strconv.FormatInt(cmd.GuildID, 10)
+
+	switch cmd.CommandType {
+	case "skip":
+		return Skip(guildID)
+
+	case "pause":
+		return Pause(guildID, true)
+
+	case "resume":
+		return Pause(guildID, false)
+
+	case "stop":
+		return Stop(guildID)
+
+	case "set_volume":
+		var payload struct {
+			Volume int `json:"volume"`
+		}
+		if err := json.Unmarshal(cmd.Payload, &payload); err != nil {
+			return fmt.Errorf("unmarshal payload: %w", err)
+		}
+		return SetVolume(guildID, payload.Volume)
+
+	case "remove_track":
+		var payload struct {
+			QueueID string `json:"queue_id"`
+		}
+		if err := json.Unmarshal(cmd.Payload, &payload); err != nil {
+			return fmt.Errorf("unmarshal payload: %w", err)
+		}
+		return RemoveFromQueue(guildID, payload.QueueID)
+
+	case "reorder":
+		var payload struct {
+			QueueID  string `json:"queue_id"`
+			Position int    `json:"position"`
+		}
+		if err := json.Unmarshal(cmd.Payload, &payload); err != nil {
+			return fmt.Errorf("unmarshal payload: %w", err)
+		}
+		return Reorder(guildID, payload.QueueID, payload.Position)
+
+	case "repeat_song":
+		ToggleRepeatSong(guildID)
+		return nil
+
+	case "repeat_queue":
+		ToggleRepeatQueue(guildID)
+		return nil
+
+	case "add_song":
+		var payload struct {
+			Query          string `json:"query"`
+			VoiceChannelID string `json:"voice_channel_id"`
+		}
+		if err := json.Unmarshal(cmd.Payload, &payload); err != nil {
+			return fmt.Errorf("unmarshal payload: %w", err)
+		}
+		requesterID := strconv.FormatInt(cmd.RequestedBy, 10)
+
+		// A voice channel means "start fresh" (nothing was playing, the
+		// dashboard had the user pick one), otherwise this just adds to
+		// whatever's already going.
+		if payload.VoiceChannelID != "" {
+			// Voice channels have their own built-in text chat at the same
+			// channel ID, post the now-playing embed there so starting
+			// playback from the dashboard still shows up somewhere in
+			// Discord, same as starting it with /play would.
+			_, _, err := EnqueueAndPlay(guildID, payload.VoiceChannelID, payload.VoiceChannelID, payload.Query, "Dashboard", requesterID)
+			return err
+		}
+		_, err := AddToQueue(guildID, payload.Query, requesterID)
+		return err
+
+	default:
+		return fmt.Errorf("unknown command type %q", cmd.CommandType)
+	}
+}

internal/music/manager.go

@@ -3,36 +3,52 @@ package music
 import (
 	"context"
 	"fmt"
+	"log"
 	"net/url"
+	"strconv"
+	"strings"
 	"sync"
 	"time"
+	"velox-bot/internal/db/repos/musicrepo"
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/disgoorg/disgolink/v3/disgolink"
 	"github.com/disgoorg/disgolink/v3/lavalink"
 	"github.com/disgoorg/snowflake/v2"
+	"github.com/google/uuid"
 )
 
 type TrackEntry struct {
 	Track       lavalink.Track
 	RequestedBy string
+	RequesterID string
+	StartedAt   time.Time
+
+	// QueueID is generated once, when the track is first added to the
+	// queue, and never changes for the rest of its life there - it's
+	// what lets syncState upsert this track's row across syncs instead
+	// of deleting and recreating it (and its DB id) every single time,
+	// which is what remove/reorder commands need to reliably target a
+	// specific track.
+	QueueID string
 }
 
 type guildPlayer struct {
-	Player           disgolink.Player
-	Queue            []TrackEntry
-	RepeatSong       bool
-	RepeatQueue      bool
-	Paused           bool
-	Volume           int
-	IdleSince        time.Time
-	TextChannelID    string
-	NowPlayingMsgID  string
+	Player          disgolink.Player
+	Queue           []TrackEntry
+	RepeatSong      bool
+	RepeatQueue     bool
+	Paused          bool
+	Volume          int
+	IdleSince       time.Time
+	TextChannelID   string
+	NowPlayingMsgID string
 }
 
 type Manager struct {
 	client  disgolink.Client
 	session *discordgo.Session
+	repo    *musicrepo.Repo
 
 	mu      sync.Mutex
 	players map[string]*guildPlayer
@@ -40,7 +56,7 @@ type Manager struct {
 
 var manager *Manager
 
-func Init(session *discordgo.Session, appID, lavalinkHost, lavalinkPass string) error {
+func Init(session *discordgo.Session, repo *musicrepo.Repo, appID, lavalinkHost, lavalinkPass string) error {
 	if lavalinkHost == "" {
 		return nil
 	}
@@ -53,6 +69,7 @@ func Init(session *discordgo.Session, appID, lavalinkHost, lavalinkPass string)
 	m := &Manager{
 		client:  disgolink.New(userID, disgolink.WithListenerFunc(onTrackEnd)),
 		session: session,
+		repo:    repo,
 		players: make(map[string]*guildPlayer),
 	}
 
@@ -67,18 +84,26 @@ func Init(session *discordgo.Session, appID, lavalinkHost, lavalinkPass string)
 		password = "youshallnotpass"
 	}
 
-	_, err = m.client.AddNode(context.Background(), disgolink.NodeConfig{
-		Name:     "main",
-		Address:  u.Host,
-		Password: password,
-		Secure:   secure,
-	})
-	if err != nil {
-		return fmt.Errorf("add lavalink node: %w", err)
-	}
+	// Connecting to the Lavalink node is a blocking network call (and, on
+	// failure, disgolink retries indefinitely with backoff) — do it in the
+	// background so bot startup isn't held hostage by it. Music commands
+	// simply fail with "not initialized" via the manager==nil checks until
+	// this completes.
+	go func() {
+		_, err := m.client.AddNode(context.Background(), disgolink.NodeConfig{
+			Name:     "main",
+			Address:  u.Host,
+			Password: password,
+			Secure:   secure,
+		})
+		if err != nil {
+			log.Printf("music: failed to connect to lavalink node: %v", err)
+			return
+		}
+		manager = m
+		go idleDisconnectLoop()
+	}()
 
-	manager = m
-	go idleDisconnectLoop()
 	return nil
 }
 
@@ -183,23 +208,126 @@ func getOrCreateGuildPlayer(guildID string) *guildPlayer {
 	return gp
 }
 
-func EnqueueAndPlay(guildID, voiceChannelID, textChannelID, query, requester string) (*TrackEntry, bool, error) {
-	if manager == nil {
-		return nil, false, fmt.Errorf("music manager not initialized")
+func syncState(guidID string) {
+	if manager == nil || manager.repo == nil {
+		return
 	}
-
-	// Join voice channel
-	if err := manager.session.ChannelVoiceJoinManual(guildID, voiceChannelID, false, false); err != nil {
-		return nil, false, fmt.Errorf("join voice channel: %w", err)
-	}
-
-	gp := getOrCreateGuildPlayer(guildID)
-	if textChannelID != "" {
-		manager.mu.Lock()
-		gp.TextChannelID = textChannelID
+	manager.mu.Lock()
+	gp, ok := manager.players[guidID]
+	if !ok {
 		manager.mu.Unlock()
+		return
 	}
 
+	queue := make([]TrackEntry, len(gp.Queue))
+	copy(queue, gp.Queue)
+	paused := gp.Paused
+	volume := gp.Volume
+	repeatSong := gp.RepeatSong
+	repeatQueue := gp.RepeatQueue
+	manager.mu.Unlock()
+
+	gID, err := strconv.ParseInt(guidID, 10, 64)
+	if err != nil {
+		return
+	}
+
+	if len(queue) == 0 {
+		err := manager.repo.ClearNowPlaying(context.Background(), gID)
+		if err != nil {
+			return
+		}
+
+		err = manager.repo.ReplaceQueue(context.Background(), gID, nil)
+		if err != nil {
+			return
+		}
+
+		return
+	}
+
+	current := queue[0]
+	title := current.Track.Info.Title
+
+	var uri string
+	if current.Track.Info.URI != nil {
+		uri = *current.Track.Info.URI
+	}
+
+	length := int(current.Track.Info.Length / 1000)
+	startedAt := current.StartedAt
+
+	err = manager.repo.SetNowPlaying(context.Background(), gID, title, uri, length, startedAt, paused, volume, repeatSong, repeatQueue)
+	if err != nil {
+		return
+	}
+
+	rest := queue[1:]
+	var queueEntries []musicrepo.QueueEntry
+	for _, entry := range rest {
+		reqID, _ := strconv.ParseInt(entry.RequesterID, 10, 64)
+		var uri string
+		if entry.Track.Info.URI != nil {
+			uri = *entry.Track.Info.URI
+		}
+		queueEntries = append(queueEntries, musicrepo.QueueEntry{
+			Title:       entry.Track.Info.Title,
+			URL:         uri,
+			RequestedBy: reqID,
+			ClientID:    entry.QueueID,
+		})
+	}
+	err = manager.repo.ReplaceQueue(context.Background(), gID, queueEntries)
+	if err != nil {
+		return
+	}
+
+}
+
+// NormalizeQuery turns plain text into a YouTube search and strips
+// auto-generated "radio/mix" params off a pasted YouTube URL
+// (https://www.youtube.com/watch?v=ID&list=RDID&start_radio=1 becomes
+// .../watch?v=ID), while leaving normal playlist URLs and non-YouTube
+// links (SoundCloud, etc.) untouched. Every entry point that accepts a
+// user-supplied query - /play and the dashboard's "add song" - should
+// normalize through this before handing the query to Lavalink.
+func NormalizeQuery(query string) string {
+	if !strings.HasPrefix(query, "http://") && !strings.HasPrefix(query, "https://") && !strings.HasPrefix(query, "ytsearch:") {
+		return "ytsearch:" + query
+	}
+
+	u, err := url.Parse(query)
+	if err != nil || u == nil {
+		return query
+	}
+
+	host := strings.ToLower(u.Host)
+	if !strings.Contains(host, "youtube.com") || u.Path != "/watch" {
+		return query
+	}
+
+	q := u.Query()
+	v := q.Get("v")
+	if v == "" {
+		return query
+	}
+
+	list := q.Get("list")
+	_, hasStartRadio := q["start_radio"]
+	if !hasStartRadio && !strings.HasPrefix(list, "RD") {
+		return query
+	}
+
+	u.RawQuery = url.Values{"v": []string{v}}.Encode()
+	u.Fragment = ""
+	return u.String()
+}
+
+// resolveTracks searches Lavalink for query (already normalized) and
+// returns a playable track list - a single track, a search result's
+// first hit, or a whole playlist (rotated to respect Lavalink's own
+// selectedTrack when present).
+func resolveTracks(query string) ([]lavalink.Track, error) {
 	var loadedTracks []lavalink.Track
 
 	manager.client.BestNode().LoadTracksHandler(
@@ -237,7 +365,7 @@ func EnqueueAndPlay(guildID, voiceChannelID, textChannelID, query, requester str
 	)
 
 	if len(loadedTracks) == 0 {
-		return nil, false, fmt.Errorf("no tracks found for query")
+		return nil, fmt.Errorf("no tracks found for query")
 	}
 
 	// Some sources may return unplayable entries; pick the first with an encoded track.
@@ -252,11 +380,38 @@ func EnqueueAndPlay(guildID, voiceChannelID, textChannelID, query, requester str
 		loadedTracks = append(loadedTracks[firstPlayableIdx:], loadedTracks[:firstPlayableIdx]...)
 	}
 
+	return loadedTracks, nil
+}
+
+func EnqueueAndPlay(guildID, voiceChannelID, textChannelID, query, requester, requesterID string) (*TrackEntry, bool, error) {
+	if manager == nil {
+		return nil, false, fmt.Errorf("music manager not initialized")
+	}
+
+	// Join voice channel
+	if err := manager.session.ChannelVoiceJoinManual(guildID, voiceChannelID, false, false); err != nil {
+		return nil, false, fmt.Errorf("join voice channel: %w", err)
+	}
+
+	gp := getOrCreateGuildPlayer(guildID)
+	if textChannelID != "" {
+		manager.mu.Lock()
+		gp.TextChannelID = textChannelID
+		manager.mu.Unlock()
+	}
+
+	loadedTracks, err := resolveTracks(NormalizeQuery(query))
+	if err != nil {
+		return nil, false, err
+	}
+
 	entries := make([]TrackEntry, len(loadedTracks))
 	for idx, t := range loadedTracks {
 		entries[idx] = TrackEntry{
 			Track:       t,
 			RequestedBy: requester,
+			RequesterID: requesterID,
+			QueueID:     uuid.New().String(),
 		}
 	}
 	firstEntry := entries[0]
@@ -268,6 +423,8 @@ func EnqueueAndPlay(guildID, voiceChannelID, textChannelID, query, requester str
 	manager.mu.Unlock()
 
 	if shouldStart {
+		gp.Queue[0].StartedAt = time.Now()
+
 		if err := gp.Player.Update(context.Background(), lavalink.WithTrack(firstEntry.Track)); err != nil {
 			return nil, false, fmt.Errorf("start track: %w", err)
 		}
@@ -276,9 +433,52 @@ func EnqueueAndPlay(guildID, voiceChannelID, textChannelID, query, requester str
 		}
 	}
 
+	syncState(guildID)
+
 	return &firstEntry, shouldStart, nil
 }
 
+// AddToQueue adds a track to a guild's existing queue without joining a
+// voice channel, unlike EnqueueAndPlay it can't start a brand new
+// session (that needs a voice channel to join, which this has no way to
+// pick), so it requires one to already be active.
+func AddToQueue(guildID, query, requesterID string) (*TrackEntry, error) {
+	if manager == nil {
+		return nil, fmt.Errorf("music manager not initialized")
+	}
+	gp := getOrCreateGuildPlayer(guildID)
+
+	manager.mu.Lock()
+	alreadyActive := len(gp.Queue) > 0
+	manager.mu.Unlock()
+	if !alreadyActive {
+		return nil, fmt.Errorf("nothing is currently playing in this server")
+	}
+
+	loadedTracks, err := resolveTracks(NormalizeQuery(query))
+	if err != nil {
+		return nil, err
+	}
+
+	entries := make([]TrackEntry, len(loadedTracks))
+	for idx, t := range loadedTracks {
+		entries[idx] = TrackEntry{
+			Track:       t,
+			RequestedBy: "Dashboard",
+			RequesterID: requesterID,
+			QueueID:     uuid.New().String(),
+		}
+	}
+
+	manager.mu.Lock()
+	gp.Queue = append(gp.Queue, entries...)
+	manager.mu.Unlock()
+
+	syncState(guildID)
+
+	return &entries[0], nil
+}
+
 func onTrackEnd(player disgolink.Player, event lavalink.TrackEndEvent) {
 	if manager == nil {
 		return
@@ -298,6 +498,7 @@ func onTrackEnd(player disgolink.Player, event lavalink.TrackEndEvent) {
 
 	// repeat current track
 	if gp.RepeatSong {
+		gp.Queue[0].StartedAt = time.Now()
 		next := gp.Queue[0]
 		textChannelID := gp.TextChannelID
 		manager.mu.Unlock()
@@ -308,12 +509,14 @@ func onTrackEnd(player disgolink.Player, event lavalink.TrackEndEvent) {
 		if textChannelID != "" {
 			postNowPlaying(guildID, textChannelID, next)
 		}
+		syncState(guildID)
 		return
 	}
 
 	// pop current and optionally cycle it to end
 	finished := gp.Queue[0]
 	gp.Queue = gp.Queue[1:]
+
 	if gp.RepeatQueue {
 		gp.Queue = append(gp.Queue, finished)
 	}
@@ -328,9 +531,11 @@ func onTrackEnd(player disgolink.Player, event lavalink.TrackEndEvent) {
 			disableNowPlaying(textChannelID, nowPlayingMsgID)
 		}
 		_ = gp.Player.Update(context.Background(), lavalink.WithNullTrack())
+		syncState(guildID)
 		return
 	}
 
+	gp.Queue[0].StartedAt = time.Now()
 	next := gp.Queue[0]
 	textChannelID := gp.TextChannelID
 	manager.mu.Unlock()
@@ -341,6 +546,7 @@ func onTrackEnd(player disgolink.Player, event lavalink.TrackEndEvent) {
 	if textChannelID != "" {
 		postNowPlaying(guildID, textChannelID, next)
 	}
+	syncState(guildID)
 }
 
 func Pause(guildID string, pause bool) error {
@@ -354,6 +560,7 @@ func Pause(guildID string, pause bool) error {
 		gp.IdleSince = time.Time{}
 	}
 	manager.mu.Unlock()
+	syncState(guildID)
 	return gp.Player.Update(context.Background(), lavalink.WithPaused(pause))
 }
 
@@ -384,9 +591,11 @@ func Skip(guildID string) error {
 		if textChannelID != "" && nowPlayingMsgID != "" {
 			disableNowPlaying(textChannelID, nowPlayingMsgID)
 		}
+		syncState(guildID)
 		return gp.Player.Update(context.Background(), lavalink.WithNullTrack())
 	}
 
+	gp.Queue[0].StartedAt = time.Now()
 	next := gp.Queue[0]
 	textChannelID := gp.TextChannelID
 	manager.mu.Unlock()
@@ -397,6 +606,7 @@ func Skip(guildID string) error {
 	if textChannelID != "" {
 		postNowPlaying(guildID, textChannelID, next)
 	}
+	syncState(guildID)
 	return nil
 }
 
@@ -418,6 +628,7 @@ func Stop(guildID string) error {
 	if textChannelID != "" && nowPlayingMsgID != "" {
 		disableNowPlaying(textChannelID, nowPlayingMsgID)
 	}
+	syncState(guildID)
 
 	return gp.Player.Update(context.Background(), lavalink.WithNullTrack())
 }
@@ -447,12 +658,15 @@ func ToggleRepeatSong(guildID string) (bool, bool) {
 	}
 	gp := getOrCreateGuildPlayer(guildID)
 	manager.mu.Lock()
-	defer manager.mu.Unlock()
 	gp.RepeatSong = !gp.RepeatSong
 	if gp.RepeatSong {
 		gp.RepeatQueue = false
 	}
-	return gp.RepeatSong, gp.RepeatQueue
+	repeatSong, repeatQueue := gp.RepeatSong, gp.RepeatQueue
+	manager.mu.Unlock()
+
+	syncState(guildID)
+	return repeatSong, repeatQueue
 }
 
 func ToggleRepeatQueue(guildID string) (bool, bool) {
@@ -461,12 +675,15 @@ func ToggleRepeatQueue(guildID string) (bool, bool) {
 	}
 	gp := getOrCreateGuildPlayer(guildID)
 	manager.mu.Lock()
-	defer manager.mu.Unlock()
 	gp.RepeatQueue = !gp.RepeatQueue
 	if gp.RepeatQueue {
 		gp.RepeatSong = false
 	}
-	return gp.RepeatSong, gp.RepeatQueue
+	repeatSong, repeatQueue := gp.RepeatSong, gp.RepeatQueue
+	manager.mu.Unlock()
+
+	syncState(guildID)
+	return repeatSong, repeatQueue
 }
 
 func repeatFlags(guildID string) (bool, bool) {
@@ -522,6 +739,73 @@ func SetVolume(guildID string, volume int) error {
 			postNowPlaying(guildID, textChannelID, *current)
 		}
 	}
+	syncState(guildID)
+	return nil
+}
+
+func RemoveFromQueue(guildID, queueID string) error {
+	if manager == nil {
+		return fmt.Errorf("music manager not initialized")
+	}
+	gp := getOrCreateGuildPlayer(guildID)
+
+	manager.mu.Lock()
+	idx := -1
+	for i, q := range gp.Queue {
+		if q.QueueID == queueID {
+			idx = i
+			break
+		}
+	}
+	if idx == -1 {
+		manager.mu.Unlock()
+		return fmt.Errorf("queue not found")
+	}
+
+	if idx == 0 {
+		manager.mu.Unlock()
+		return Skip(guildID)
+	}
+
+	gp.Queue = append(gp.Queue[:idx], gp.Queue[idx+1:]...)
+	manager.mu.Unlock()
+
+	syncState(guildID)
+	return nil
+}
+
+func Reorder(guildID, queueID string, newPosition int) error {
+	if manager == nil {
+		return fmt.Errorf("music manager not initialized")
+	}
+	gp := getOrCreateGuildPlayer(guildID)
+
+	manager.mu.Lock()
+	idx := -1
+	for i, q := range gp.Queue {
+		if q.QueueID == queueID {
+			idx = i
+			break
+		}
+	}
+	if idx == -1 {
+		manager.mu.Unlock()
+		return fmt.Errorf("queue not found")
+	}
+
+	if idx == 0 {
+		manager.mu.Unlock()
+		return Skip(guildID)
+	}
+
+	entry := gp.Queue[idx]
+	gp.Queue = append(gp.Queue[:idx], gp.Queue[idx+1:]...)
+
+	pos := max(1, min(newPosition, len(gp.Queue)))
+	gp.Queue = append(gp.Queue[:pos], append([]TrackEntry{entry}, gp.Queue[pos:]...)...)
+	manager.mu.Unlock()
+
+	syncState(guildID)
 	return nil
 }
 
@@ -534,5 +818,3 @@ func CurrentNowPlayingMessageID(guildID string) string {
 	defer manager.mu.Unlock()
 	return gp.NowPlayingMsgID
 }
-
-

internal/tickets/fakes_test.go

@@ -0,0 +1,247 @@
+package tickets
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"sync"
+	"time"
+
+	"velox-bot/internal/db/repos/ticketrepo"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// fakeStore is an in-memory ticketrepo with the same rules as the SQL.
+type fakeStore struct {
+	mu       sync.Mutex
+	settings map[int64]*ticketrepo.Settings
+	cats     []ticketrepo.Category
+	tickets  []*ticketrepo.Ticket
+	next     map[int64]int
+	cmds     []ticketrepo.Command
+	done     []int64
+}
+
+func newStore() *fakeStore {
+	return &fakeStore{settings: map[int64]*ticketrepo.Settings{}, next: map[int64]int{}}
+}
+
+func (f *fakeStore) configure(guild, channel, logCh int64) {
+	f.settings[guild] = &ticketrepo.Settings{
+		GuildID: guild, Enabled: true, ChannelID: channel, LogChannelID: logCh,
+		PanelTitle: ticketrepo.DefaultPanelTitle, PanelDescription: ticketrepo.DefaultPanelDescription,
+		MaxOpenPerUser: 1, Configured: true,
+	}
+}
+
+func (f *fakeStore) addCat(c ticketrepo.Category) ticketrepo.Category {
+	c.ID = int64(len(f.cats) + 1)
+	f.cats = append(f.cats, c)
+	return c
+}
+
+func (f *fakeStore) GetSettings(_ context.Context, g int64) (*ticketrepo.Settings, error) {
+	if s, ok := f.settings[g]; ok {
+		cp := *s
+		return &cp, nil
+	}
+	return &ticketrepo.Settings{GuildID: g, Enabled: true, PanelTitle: ticketrepo.DefaultPanelTitle, MaxOpenPerUser: 1}, nil
+}
+func (f *fakeStore) SetPanelMessage(_ context.Context, g, m int64) error {
+	f.settings[g].PanelMessageID = m
+	return nil
+}
+func (f *fakeStore) NextNumber(_ context.Context, g int64) (int, error) {
+	f.next[g]++
+	return f.next[g], nil
+}
+func (f *fakeStore) ListCategories(_ context.Context, g int64) ([]ticketrepo.Category, error) {
+	var out []ticketrepo.Category
+	for _, c := range f.cats {
+		if c.GuildID == g {
+			out = append(out, c)
+		}
+	}
+	return out, nil
+}
+func (f *fakeStore) GetCategory(_ context.Context, g, id int64) (*ticketrepo.Category, error) {
+	for _, c := range f.cats {
+		if c.GuildID == g && c.ID == id {
+			cp := c
+			return &cp, nil
+		}
+	}
+	return nil, nil
+}
+func (f *fakeStore) CountOpenByOpener(_ context.Context, g, u int64) (int, error) {
+	n := 0
+	for _, t := range f.tickets {
+		if t.GuildID == g && t.OpenerID == u && t.Status == ticketrepo.StatusOpen {
+			n++
+		}
+	}
+	return n, nil
+}
+func (f *fakeStore) CreateTicket(_ context.Context, t ticketrepo.Ticket) (int64, error) {
+	t.ID = int64(len(f.tickets) + 1)
+	t.Status = ticketrepo.StatusOpen
+	t.CreatedAt = time.Now().Add(-90 * time.Minute)
+	f.tickets = append(f.tickets, &t)
+	return t.ID, nil
+}
+func (f *fakeStore) byThread(th int64) *ticketrepo.Ticket {
+	for _, t := range f.tickets {
+		if t.ThreadID == th {
+			return t
+		}
+	}
+	return nil
+}
+func (f *fakeStore) GetTicketByThread(_ context.Context, th int64) (*ticketrepo.Ticket, error) {
+	if t := f.byThread(th); t != nil {
+		cp := *t
+		return &cp, nil
+	}
+	return nil, nil
+}
+func (f *fakeStore) Claim(_ context.Context, th, staff int64) (int64, error) {
+	t := f.byThread(th)
+	if t == nil || t.Status != ticketrepo.StatusOpen {
+		return 0, nil
+	}
+	if t.ClaimedBy == 0 {
+		t.ClaimedBy = staff
+	}
+	return t.ClaimedBy, nil
+}
+func (f *fakeStore) Close(_ context.Context, th, by int64, reason string) (bool, error) {
+	t := f.byThread(th)
+	if t == nil || t.Status != ticketrepo.StatusOpen {
+		return false, nil
+	}
+	t.Status, t.ClosedBy, t.CloseReason, t.ClosedAt = ticketrepo.StatusClosed, by, reason, time.Now()
+	return true, nil
+}
+func (f *fakeStore) ListUnprocessedCommands(context.Context) ([]ticketrepo.Command, error) {
+	var out []ticketrepo.Command
+	for _, c := range f.cmds {
+		done := false
+		for _, d := range f.done {
+			done = done || d == c.ID
+		}
+		if !done {
+			out = append(out, c)
+		}
+	}
+	return out, nil
+}
+func (f *fakeStore) MarkCommandProcessed(_ context.Context, id int64) error {
+	f.done = append(f.done, id)
+	return nil
+}
+
+// fakeDiscord records what the flows ask Discord to do.
+type fakeDiscord struct {
+	mu        sync.Mutex
+	nextID    int
+	threads   []*discordgo.ThreadStart
+	members   map[string][]string // thread -> user IDs
+	sent      map[string][]*discordgo.MessageSend
+	edits     []*discordgo.MessageEdit
+	chEdits   map[string]*discordgo.ChannelEdit
+	deleted   []string
+	files     map[string]string // file name -> contents
+	history   map[string][]*discordgo.Message
+	messages  map[string]*discordgo.Message // by "channel/message"
+	failSend  error
+	failEdit  error
+	failFetch error
+}
+
+func newDiscord() *fakeDiscord {
+	return &fakeDiscord{
+		nextID: 1000, members: map[string][]string{}, sent: map[string][]*discordgo.MessageSend{},
+		chEdits: map[string]*discordgo.ChannelEdit{}, files: map[string]string{},
+		history: map[string][]*discordgo.Message{}, messages: map[string]*discordgo.Message{},
+	}
+}
+
+func (f *fakeDiscord) newID() string {
+	f.nextID++
+	return fmt.Sprint(f.nextID)
+}
+
+func (f *fakeDiscord) ThreadStartComplex(ch string, data *discordgo.ThreadStart, _ ...discordgo.RequestOption) (*discordgo.Channel, error) {
+	f.threads = append(f.threads, data)
+	return &discordgo.Channel{ID: f.newID(), ParentID: ch, Name: data.Name, Type: data.Type}, nil
+}
+func (f *fakeDiscord) ThreadMemberAdd(th, u string, _ ...discordgo.RequestOption) error {
+	f.members[th] = append(f.members[th], u)
+	return nil
+}
+func (f *fakeDiscord) ThreadMemberRemove(th, u string, _ ...discordgo.RequestOption) error {
+	var keep []string
+	for _, m := range f.members[th] {
+		if m != u {
+			keep = append(keep, m)
+		}
+	}
+	f.members[th] = keep
+	return nil
+}
+func (f *fakeDiscord) ChannelMessageSendComplex(ch string, data *discordgo.MessageSend, _ ...discordgo.RequestOption) (*discordgo.Message, error) {
+	if f.failSend != nil {
+		return nil, f.failSend
+	}
+	for _, file := range data.Files {
+		raw, _ := io.ReadAll(file.Reader)
+		f.files[file.Name] = string(raw)
+	}
+	f.sent[ch] = append(f.sent[ch], data)
+	m := &discordgo.Message{ID: f.newID(), ChannelID: ch, Content: data.Content, Embeds: data.Embeds, Components: data.Components}
+	f.messages[ch+"/"+m.ID] = m
+	return m, nil
+}
+func (f *fakeDiscord) ChannelMessageEditComplex(e *discordgo.MessageEdit, _ ...discordgo.RequestOption) (*discordgo.Message, error) {
+	if f.failEdit != nil {
+		return nil, f.failEdit
+	}
+	f.edits = append(f.edits, e)
+	return &discordgo.Message{ID: e.ID, ChannelID: e.Channel}, nil
+}
+func (f *fakeDiscord) ChannelMessage(ch, m string, _ ...discordgo.RequestOption) (*discordgo.Message, error) {
+	if msg, ok := f.messages[ch+"/"+m]; ok {
+		return msg, nil
+	}
+	return nil, errors.New("unknown message")
+}
+func (f *fakeDiscord) ChannelMessages(ch string, limit int, before, _, _ string, _ ...discordgo.RequestOption) ([]*discordgo.Message, error) {
+	if f.failFetch != nil {
+		return nil, f.failFetch
+	}
+	// history is stored newest first, like Discord returns it.
+	all := f.history[ch]
+	start := 0
+	if before != "" {
+		for i, m := range all {
+			if m.ID == before {
+				start = i + 1
+			}
+		}
+	}
+	end := start + limit
+	if end > len(all) {
+		end = len(all)
+	}
+	return all[start:end], nil
+}
+func (f *fakeDiscord) ChannelEditComplex(ch string, data *discordgo.ChannelEdit, _ ...discordgo.RequestOption) (*discordgo.Channel, error) {
+	f.chEdits[ch] = data
+	return &discordgo.Channel{ID: ch}, nil
+}
+func (f *fakeDiscord) ChannelDelete(ch string, _ ...discordgo.RequestOption) (*discordgo.Channel, error) {
+	f.deleted = append(f.deleted, ch)
+	return &discordgo.Channel{ID: ch}, nil
+}

internal/tickets/listener.go

@@ -0,0 +1,63 @@
+package tickets
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+
+	"github.com/jackc/pgx/v5"
+)
+
+// StartCommandListener waits for the dashboard's requests (ticket_commands
+// rows, announced with NOTIFY) and carries them out. It returns when the
+// connection fails or ctx ends.
+func StartCommandListener(ctx context.Context, connString string, d Discord, st Store) error {
+	conn, err := pgx.Connect(ctx, connString)
+	if err != nil {
+		return fmt.Errorf("connect: %w", err)
+	}
+	defer conn.Close(ctx)
+
+	if _, err := conn.Exec(ctx, "LISTEN ticket_commands"); err != nil {
+		return fmt.Errorf("listen: %w", err)
+	}
+	// Anything queued while the bot was down.
+	ProcessCommands(ctx, d, st)
+
+	for {
+		if _, err := conn.WaitForNotification(ctx); err != nil {
+			return fmt.Errorf("waiting for notifications: %w", err)
+		}
+		ProcessCommands(ctx, d, st)
+	}
+}
+
+// ProcessCommands carries out every pending command once. A command that
+// fails is still marked done: retrying a panel post that failed for missing
+// permissions would only fail again, and the error is logged.
+func ProcessCommands(ctx context.Context, d Discord, st Store) {
+	cmds, err := st.ListUnprocessedCommands(ctx)
+	if err != nil {
+		log.Printf("tickets: listing dashboard commands: %v", err)
+		return
+	}
+	for _, c := range cmds {
+		switch c.CommandType {
+		case "post_panel":
+			if _, err := PostPanel(ctx, d, st, c.GuildID); err != nil {
+				var ue UserError
+				if errors.As(err, &ue) {
+					log.Printf("tickets: posting the panel for guild %d from the dashboard: %s", c.GuildID, ue)
+				} else {
+					log.Printf("tickets: posting the panel for guild %d from the dashboard: %v", c.GuildID, err)
+				}
+			}
+		default:
+			log.Printf("tickets: unknown dashboard command %q (%d)", c.CommandType, c.ID)
+		}
+		if err := st.MarkCommandProcessed(ctx, c.ID); err != nil {
+			log.Printf("tickets: marking command %d done: %v", c.ID, err)
+		}
+	}
+}

internal/tickets/listener_integration_test.go

@@ -0,0 +1,71 @@
+//go:build integration
+
+package tickets
+
+import (
+	"context"
+	"database/sql"
+	"os"
+	"testing"
+	"time"
+
+	"velox-bot/internal/db/repos/ticketrepo"
+
+	_ "github.com/jackc/pgx/v5/stdlib"
+)
+
+// The dashboard's request reaches the bot through the real trigger and
+// LISTEN/NOTIFY:
+//
+//	TICKETS_TEST_DB=postgres://... go test -tags integration ./internal/tickets
+func TestListenerPostsPanelOnNotify(t *testing.T) {
+	dsn := os.Getenv("TICKETS_TEST_DB")
+	if dsn == "" {
+		t.Skip("TICKETS_TEST_DB not set")
+	}
+	db, err := sql.Open("pgx", dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	const g = 515151
+	for _, q := range []string{`DELETE FROM ticket_commands`, `DELETE FROM ticket_categories WHERE guild_id = $1`, `DELETE FROM ticket_settings WHERE guild_id = $1`} {
+		if q == `DELETE FROM ticket_commands` {
+			_, err = db.Exec(q)
+		} else {
+			_, err = db.Exec(q, g)
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	repo := ticketrepo.NewRepo(db)
+	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+	defer cancel()
+	if err := repo.SetChannels(ctx, g, 10, 0); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := repo.AddCategory(ctx, ticketrepo.Category{GuildID: g, Name: "Support"}); err != nil {
+		t.Fatal(err)
+	}
+
+	d := newDiscord()
+	go func() { _ = StartCommandListener(ctx, dsn, d, repo) }()
+	time.Sleep(500 * time.Millisecond) // let LISTEN start
+
+	if _, err := db.Exec(`INSERT INTO ticket_commands (guild_id, command_type, requested_by) VALUES ($1, 'post_panel', 1)`, g); err != nil {
+		t.Fatal(err)
+	}
+	for ctx.Err() == nil {
+		s, _ := repo.GetSettings(ctx, g)
+		if s.PanelMessageID != 0 {
+			cmds, _ := repo.ListUnprocessedCommands(ctx)
+			if len(cmds) != 0 {
+				t.Errorf("command not marked processed: %+v", cmds)
+			}
+			return
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	t.Fatal("the panel was never posted")
+}

internal/tickets/manage.go

@@ -0,0 +1,271 @@
+package tickets
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"log"
+	"time"
+
+	"velox-bot/internal/db/repos/ticketrepo"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// Actor is whoever pressed the button or ran the command, with their
+// permissions in the ticket thread.
+type Actor struct {
+	Member *discordgo.Member
+	Perms  int64
+}
+
+func (a Actor) userID() string {
+	if a.Member == nil || a.Member.User == nil {
+		return ""
+	}
+	return a.Member.User.ID
+}
+
+// load finds the open ticket behind a thread and its category (nil when the
+// category was deleted since).
+func load(ctx context.Context, st Store, threadID string) (*ticketrepo.Ticket, *ticketrepo.Category, error) {
+	t, err := st.GetTicketByThread(ctx, mustID(threadID))
+	if err != nil {
+		return nil, nil, err
+	}
+	if t == nil {
+		return nil, nil, ErrNotATicket
+	}
+	if t.Status != ticketrepo.StatusOpen {
+		return nil, nil, ErrClosed
+	}
+	var cat *ticketrepo.Category
+	if t.CategoryID != 0 {
+		if cat, err = st.GetCategory(ctx, t.GuildID, t.CategoryID); err != nil {
+			return nil, nil, err
+		}
+	}
+	return t, cat, nil
+}
+
+// updateIntro edits the ticket's first message to show who claimed it and
+// whether it is closed. It keeps the original text (the details are only in
+// that message) and is best effort: a deleted first message doesn't stop the
+// ticket from being claimed or closed.
+func updateIntro(d Discord, t *ticketrepo.Ticket) {
+	if t.IntroMessage == 0 {
+		return
+	}
+	msg, err := d.ChannelMessage(id(t.ThreadID), id(t.IntroMessage))
+	if err != nil || len(msg.Embeds) == 0 {
+		return
+	}
+	fresh := IntroEmbed(t, "")
+	e := *msg.Embeds[0]
+	e.Color, e.Footer = fresh.Color, fresh.Footer
+	e.Fields = fresh.Fields
+	embeds := []*discordgo.MessageEmbed{&e}
+	comps := IntroComponents(t.ClaimedBy != 0, t.Status == ticketrepo.StatusClosed)
+	if _, err := d.ChannelMessageEditComplex(&discordgo.MessageEdit{
+		Channel: id(t.ThreadID), ID: id(t.IntroMessage), Embeds: &embeds, Components: &comps,
+	}); err != nil {
+		log.Printf("tickets: updating the first message of ticket %d: %v", t.ID, err)
+	}
+}
+
+// Claim marks the actor as the ticket's handler. Only staff can claim, and a
+// claimed ticket stays with its first claimer.
+func Claim(ctx context.Context, d Discord, st Store, threadID string, a Actor) error {
+	t, cat, err := load(ctx, st, threadID)
+	if err != nil {
+		return err
+	}
+	if !IsStaff(a.Member, a.Perms, cat) {
+		return ErrNotStaff
+	}
+	me := mustID(a.userID())
+	holder, err := st.Claim(ctx, t.ThreadID, me)
+	if err != nil {
+		return err
+	}
+	if holder == 0 {
+		return ErrClosed
+	}
+	if holder != me {
+		return UserError(fmt.Sprintf("<@%d> is already handling this ticket.", holder))
+	}
+	t.ClaimedBy = me
+	updateIntro(d, t)
+	_, err = d.ChannelMessageSendComplex(id(t.ThreadID), &discordgo.MessageSend{
+		Content:         fmt.Sprintf("<@%d> is handling this ticket.", me),
+		AllowedMentions: &discordgo.MessageAllowedMentions{},
+	})
+	return err
+}
+
+// CheckCanClose runs before the close form is shown.
+func CheckCanClose(ctx context.Context, st Store, threadID string, a Actor) error {
+	t, cat, err := load(ctx, st, threadID)
+	if err != nil {
+		return err
+	}
+	if mustID(a.userID()) != t.OpenerID && !IsStaff(a.Member, a.Perms, cat) {
+		return ErrNotInvolved
+	}
+	return nil
+}
+
+// Close closes the ticket: a note in the thread, a summary with the
+// transcript in the log channel, the first message's buttons disabled, and
+// the thread locked and archived. The opener or staff can close.
+func Close(ctx context.Context, d Discord, st Store, threadID string, a Actor, reason string) error {
+	t, cat, err := load(ctx, st, threadID)
+	if err != nil {
+		return err
+	}
+	me := mustID(a.userID())
+	if me != t.OpenerID && !IsStaff(a.Member, a.Perms, cat) {
+		return ErrNotInvolved
+	}
+	reason = clip(reason, maxReason)
+
+	// The transcript is taken before anything else changes in the thread.
+	transcript, count, terr := Transcript(d, t)
+
+	closed, err := st.Close(ctx, t.ThreadID, me, reason)
+	if err != nil {
+		return err
+	}
+	if !closed {
+		return ErrClosed // someone else closed it a moment ago
+	}
+	t.Status, t.ClosedBy, t.CloseReason, t.ClosedAt = ticketrepo.StatusClosed, me, reason, time.Now()
+
+	note := fmt.Sprintf("🔒 Closed by <@%d>.", me)
+	if reason != "" {
+		note += " Reason: " + reason
+	}
+	if _, err := d.ChannelMessageSendComplex(id(t.ThreadID), &discordgo.MessageSend{
+		Content: note, AllowedMentions: &discordgo.MessageAllowedMentions{},
+	}); err != nil {
+		log.Printf("tickets: posting the close note in ticket %d: %v", t.ID, err)
+	}
+
+	if terr != nil {
+		log.Printf("tickets: transcript of ticket %d: %v", t.ID, terr)
+	}
+	postLog(ctx, d, st, t, transcript, count)
+	updateIntro(d, t)
+
+	yes := true
+	if _, err := d.ChannelEditComplex(id(t.ThreadID), &discordgo.ChannelEdit{Locked: &yes, Archived: &yes}); err != nil {
+		return fmt.Errorf("locking the thread: %w", err)
+	}
+	return nil
+}
+
+// postLog sends the closed ticket's summary and transcript to the log
+// channel, if the guild has one.
+func postLog(ctx context.Context, d Discord, st Store, t *ticketrepo.Ticket, transcript []byte, count int) {
+	s, err := st.GetSettings(ctx, t.GuildID)
+	if err != nil || s.LogChannelID == 0 {
+		return
+	}
+	claimed := "Nobody"
+	if t.ClaimedBy != 0 {
+		claimed = "<@" + id(t.ClaimedBy) + ">"
+	}
+	reason := t.CloseReason
+	if reason == "" {
+		reason = "No reason given"
+	}
+	embed := &discordgo.MessageEmbed{
+		Title:       fmt.Sprintf("Ticket #%04d closed · %s", t.Number, clip(t.CategoryName, 60)),
+		Description: "**" + clip(t.Subject, maxSubject) + "**",
+		Color:       0x6b7280,
+		Fields: []*discordgo.MessageEmbedField{
+			{Name: "Opened by", Value: "<@" + id(t.OpenerID) + ">", Inline: true},
+			{Name: "Claimed by", Value: claimed, Inline: true},
+			{Name: "Closed by", Value: "<@" + id(t.ClosedBy) + ">", Inline: true},
+			{Name: "Reason", Value: clip(reason, 1024)},
+			{Name: "Thread", Value: "<#" + id(t.ThreadID) + ">", Inline: true},
+			{Name: "Messages", Value: fmt.Sprint(count), Inline: true},
+			{Name: "Open for", Value: humanDuration(t.ClosedAt.Sub(t.CreatedAt)), Inline: true},
+		},
+		Timestamp: t.ClosedAt.UTC().Format(time.RFC3339),
+	}
+	send := &discordgo.MessageSend{Embeds: []*discordgo.MessageEmbed{embed}, AllowedMentions: &discordgo.MessageAllowedMentions{}}
+	if len(transcript) > 0 {
+		send.Files = []*discordgo.File{{
+			Name:        fmt.Sprintf("ticket-%04d.txt", t.Number),
+			ContentType: "text/plain; charset=utf-8",
+			Reader:      bytes.NewReader(transcript),
+		}}
+	}
+	if _, err := d.ChannelMessageSendComplex(id(s.LogChannelID), send); err != nil {
+		log.Printf("tickets: posting ticket %d to the log channel: %v", t.ID, err)
+	}
+}
+
+func humanDuration(d time.Duration) string {
+	switch {
+	case d <= 0:
+		return "-"
+	case d < time.Hour:
+		return fmt.Sprintf("%d min", int(d.Minutes()+0.5))
+	case d < 48*time.Hour:
+		return fmt.Sprintf("%.1f h", d.Hours())
+	default:
+		return fmt.Sprintf("%.1f days", d.Hours()/24)
+	}
+}
+
+// AddMember brings someone into a ticket. The opener and staff can add.
+func AddMember(ctx context.Context, d Discord, st Store, threadID string, a Actor, userID string) error {
+	t, cat, err := load(ctx, st, threadID)
+	if err != nil {
+		return err
+	}
+	if mustID(a.userID()) != t.OpenerID && !IsStaff(a.Member, a.Perms, cat) {
+		return ErrNotInvolved
+	}
+	if err := d.ThreadMemberAdd(threadID, userID); err != nil {
+		return fmt.Errorf("adding to the thread: %w", err)
+	}
+	_, err = d.ChannelMessageSendComplex(threadID, &discordgo.MessageSend{
+		Content:         fmt.Sprintf("<@%s> added <@%s> to this ticket.", a.userID(), userID),
+		AllowedMentions: &discordgo.MessageAllowedMentions{},
+	})
+	return err
+}
+
+// RemoveMember takes someone out of a ticket. Only staff can, and never the
+// opener.
+func RemoveMember(ctx context.Context, d Discord, st Store, threadID string, a Actor, userID string) error {
+	t, cat, err := load(ctx, st, threadID)
+	if err != nil {
+		return err
+	}
+	if !IsStaff(a.Member, a.Perms, cat) {
+		return ErrNotStaff
+	}
+	if mustID(userID) == t.OpenerID {
+		return UserError("The person who opened the ticket can't be removed. Close the ticket instead.")
+	}
+	if err := d.ThreadMemberRemove(threadID, userID); err != nil {
+		return fmt.Errorf("removing from the thread: %w", err)
+	}
+	_, err = d.ChannelMessageSendComplex(threadID, &discordgo.MessageSend{
+		Content:         fmt.Sprintf("<@%s> removed <@%s> from this ticket.", a.userID(), userID),
+		AllowedMentions: &discordgo.MessageAllowedMentions{},
+	})
+	return err
+}
+
+// ThreadDeleted closes the ticket of a thread someone deleted by hand, so it
+// stops counting towards the opener's limit.
+func ThreadDeleted(ctx context.Context, st Store, threadID string) {
+	if _, err := st.Close(ctx, mustID(threadID), 0, "Thread deleted"); err != nil {
+		log.Printf("tickets: closing the ticket of deleted thread %s: %v", threadID, err)
+	}
+}

internal/tickets/open.go

@@ -0,0 +1,171 @@
+package tickets
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strconv"
+
+	"velox-bot/internal/db/repos/ticketrepo"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// CheckCanOpen runs before the form is shown, so a member who can't open a
+// ticket finds out before typing anything.
+func CheckCanOpen(ctx context.Context, st Store, guildID, userID, categoryID int64) (*ticketrepo.Settings, *ticketrepo.Category, error) {
+	s, err := st.GetSettings(ctx, guildID)
+	if err != nil {
+		return nil, nil, err
+	}
+	if !s.Configured || s.ChannelID == 0 {
+		return nil, nil, ErrNotSetUp
+	}
+	if !s.Enabled {
+		return nil, nil, ErrDisabled
+	}
+	cat, err := st.GetCategory(ctx, guildID, categoryID)
+	if err != nil {
+		return nil, nil, err
+	}
+	if cat == nil {
+		return nil, nil, ErrUnknownCategory
+	}
+	open, err := st.CountOpenByOpener(ctx, guildID, userID)
+	if err != nil {
+		return nil, nil, err
+	}
+	if open >= s.MaxOpenPerUser {
+		if s.MaxOpenPerUser == 1 {
+			return nil, nil, UserError("You already have an open ticket. Close it before opening another one.")
+		}
+		return nil, nil, UserError(fmt.Sprintf("You already have %d open tickets, the most this server allows. Close one before opening another.", open))
+	}
+	return s, cat, nil
+}
+
+type OpenRequest struct {
+	GuildID    int64
+	CategoryID int64
+	User       *discordgo.User
+	Subject    string
+	Details    string
+}
+
+// IntroComponents are the Claim and Close buttons under a ticket's first
+// message, disabled as the ticket moves on.
+func IntroComponents(claimed, closed bool) []discordgo.MessageComponent {
+	claimLabel := "Claim"
+	if claimed {
+		claimLabel = "Claimed"
+	}
+	return []discordgo.MessageComponent{discordgo.ActionsRow{Components: []discordgo.MessageComponent{
+		discordgo.Button{Label: claimLabel, Style: discordgo.SuccessButton, CustomID: idClaim, Disabled: claimed || closed, Emoji: &discordgo.ComponentEmoji{Name: "🙋"}},
+		discordgo.Button{Label: "Close", Style: discordgo.DangerButton, CustomID: idClose, Disabled: closed, Emoji: &discordgo.ComponentEmoji{Name: "🔒"}},
+	}}}
+}
+
+// IntroEmbed describes the ticket at the top of its thread.
+func IntroEmbed(t *ticketrepo.Ticket, details string) *discordgo.MessageEmbed {
+	desc := "**" + clip(t.Subject, maxSubject) + "**"
+	if details != "" {
+		desc += "\n\n" + clip(details, maxDetails)
+	}
+	claimed := "Nobody yet"
+	if t.ClaimedBy != 0 {
+		claimed = "<@" + id(t.ClaimedBy) + ">"
+	}
+	e := &discordgo.MessageEmbed{
+		Title:       fmt.Sprintf("Ticket #%04d · %s", t.Number, clip(t.CategoryName, 60)),
+		Description: desc,
+		Color:       accent,
+		Fields: []*discordgo.MessageEmbedField{
+			{Name: "Opened by", Value: "<@" + id(t.OpenerID) + ">", Inline: true},
+			{Name: "Claimed by", Value: claimed, Inline: true},
+		},
+		Footer: &discordgo.MessageEmbedFooter{Text: "Staff can claim this ticket. Anyone here can close it once it's sorted."},
+	}
+	if t.Status == ticketrepo.StatusClosed {
+		e.Color = 0x6b7280
+		e.Footer.Text = "This ticket is closed."
+	}
+	return e
+}
+
+// Open creates the ticket: a private thread in the ticket channel with the
+// opener added, a first message that mentions the category's staff role
+// (which adds that role's members to the thread), and the database row.
+func Open(ctx context.Context, d Discord, st Store, req OpenRequest) (*discordgo.Channel, error) {
+	s, cat, err := CheckCanOpen(ctx, st, req.GuildID, mustID(req.User.ID), req.CategoryID)
+	if err != nil {
+		return nil, err
+	}
+
+	number, err := st.NextNumber(ctx, req.GuildID)
+	if err != nil {
+		return nil, err
+	}
+
+	name := req.User.GlobalName
+	if name == "" {
+		name = req.User.Username
+	}
+	thread, err := d.ThreadStartComplex(id(s.ChannelID), &discordgo.ThreadStart{
+		Name:                ThreadName(cat.Name, number, name),
+		Type:                discordgo.ChannelTypeGuildPrivateThread,
+		AutoArchiveDuration: autoArchiveWeek,
+		Invitable:           false, // only staff can add people
+	})
+	if err != nil {
+		return nil, fmt.Errorf("creating the thread: %w", err)
+	}
+	// From here on a failure leaves an empty thread behind unless it's removed.
+	fail := func(err error) (*discordgo.Channel, error) {
+		if _, derr := d.ChannelDelete(thread.ID); derr != nil {
+			log.Printf("tickets: removing thread %s after a failed open: %v", thread.ID, derr)
+		}
+		return nil, err
+	}
+
+	if err := d.ThreadMemberAdd(thread.ID, req.User.ID); err != nil {
+		return fail(fmt.Errorf("adding the opener: %w", err))
+	}
+
+	t := &ticketrepo.Ticket{
+		GuildID:      req.GuildID,
+		Number:       number,
+		CategoryID:   cat.ID,
+		CategoryName: cat.Name,
+		OpenerID:     mustID(req.User.ID),
+		Subject:      clip(req.Subject, maxSubject),
+		Status:       ticketrepo.StatusOpen,
+	}
+	content := "<@" + req.User.ID + ">"
+	mentions := &discordgo.MessageAllowedMentions{Users: []string{req.User.ID}}
+	if cat.StaffRoleID != 0 {
+		content += " <@&" + id(cat.StaffRoleID) + ">"
+		mentions.Roles = []string{id(cat.StaffRoleID)}
+	}
+	intro, err := d.ChannelMessageSendComplex(thread.ID, &discordgo.MessageSend{
+		Content:         content,
+		Embeds:          []*discordgo.MessageEmbed{IntroEmbed(t, req.Details)},
+		Components:      IntroComponents(false, false),
+		AllowedMentions: mentions,
+	})
+	if err != nil {
+		return fail(fmt.Errorf("posting the first message: %w", err))
+	}
+
+	t.ThreadID = mustID(thread.ID)
+	t.IntroMessage = mustID(intro.ID)
+	if _, err := st.CreateTicket(ctx, *t); err != nil {
+		return fail(fmt.Errorf("saving the ticket: %w", err))
+	}
+	return thread, nil
+}
+
+// mustID parses a snowflake that came from Discord; those are always valid.
+func mustID(s string) int64 {
+	n, _ := strconv.ParseInt(s, 10, 64)
+	return n
+}

internal/tickets/panel.go

@@ -0,0 +1,187 @@
+package tickets
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"velox-bot/internal/db/repos/ticketrepo"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// Custom IDs. Everything starts with "tickets:" so the interaction router can
+// hand it to this package.
+const (
+	idOpenPrefix     = "tickets:open:"     // panel button, + category ID
+	idSelect         = "tickets:select"    // panel dropdown (many categories)
+	idOpenFormPrefix = "tickets:openform:" // opening form, + category ID
+	idClaim          = "tickets:claim"
+	idClose          = "tickets:close"
+	idCloseForm      = "tickets:closeform"
+
+	fieldSubject = "subject"
+	fieldDetails = "details"
+	fieldReason  = "reason"
+)
+
+var customEmojiRe = regexp.MustCompile(`^<(a?):(\w+):(\d+)>$`)
+
+// parseEmoji accepts a Unicode emoji or a custom one written as <:name:id>.
+func parseEmoji(s string) *discordgo.ComponentEmoji {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return nil
+	}
+	if m := customEmojiRe.FindStringSubmatch(s); m != nil {
+		return &discordgo.ComponentEmoji{Name: m[2], ID: m[3], Animated: m[1] == "a"}
+	}
+	return &discordgo.ComponentEmoji{Name: s}
+}
+
+// BuildPanel is the message members open tickets from: an embed with the
+// guild's text and one button per category, or a dropdown once there are
+// more categories than fit comfortably in a row.
+func BuildPanel(s *ticketrepo.Settings, cats []ticketrepo.Category) (*discordgo.MessageEmbed, []discordgo.MessageComponent) {
+	embed := &discordgo.MessageEmbed{
+		Title:       clip(s.PanelTitle, 256),
+		Description: clip(s.PanelDescription, 4000),
+		Color:       accent,
+	}
+	if len(cats) > maxCategories {
+		cats = cats[:maxCategories]
+	}
+
+	if len(cats) <= maxPanelButtons {
+		var buttons []discordgo.MessageComponent
+		for _, c := range cats {
+			buttons = append(buttons, discordgo.Button{
+				Label:    clip(c.Name, 80),
+				Style:    discordgo.PrimaryButton,
+				CustomID: idOpenPrefix + id(c.ID),
+				Emoji:    parseEmoji(c.Emoji),
+			})
+		}
+		// With few categories their descriptions go in the embed, since a
+		// button has no room for one.
+		for _, c := range cats {
+			if c.Description != "" {
+				embed.Fields = append(embed.Fields, &discordgo.MessageEmbedField{Name: clip(c.Name, 256), Value: clip(c.Description, 1024)})
+			}
+		}
+		return embed, []discordgo.MessageComponent{discordgo.ActionsRow{Components: buttons}}
+	}
+
+	var opts []discordgo.SelectMenuOption
+	for _, c := range cats {
+		opts = append(opts, discordgo.SelectMenuOption{
+			Label:       clip(c.Name, 100),
+			Value:       id(c.ID),
+			Description: clip(c.Description, 100),
+			Emoji:       parseEmoji(c.Emoji),
+		})
+	}
+	return embed, []discordgo.MessageComponent{discordgo.ActionsRow{Components: []discordgo.MessageComponent{
+		discordgo.SelectMenu{CustomID: idSelect, Placeholder: "Choose what you need help with", Options: opts},
+	}}}
+}
+
+// PostPanel posts the panel in the ticket channel, or updates the one it
+// posted before, and returns where it ended up.
+func PostPanel(ctx context.Context, d Discord, st Store, guildID int64) (*discordgo.Message, error) {
+	s, err := st.GetSettings(ctx, guildID)
+	if err != nil {
+		return nil, err
+	}
+	if s.ChannelID == 0 {
+		return nil, ErrNotSetUp
+	}
+	cats, err := st.ListCategories(ctx, guildID)
+	if err != nil {
+		return nil, err
+	}
+	if len(cats) == 0 {
+		return nil, ErrNoCategories
+	}
+	embed, comps := BuildPanel(s, cats)
+
+	if s.PanelMessageID != 0 {
+		embeds := []*discordgo.MessageEmbed{embed}
+		msg, err := d.ChannelMessageEditComplex(&discordgo.MessageEdit{
+			Channel:    id(s.ChannelID),
+			ID:         id(s.PanelMessageID),
+			Embeds:     &embeds,
+			Components: &comps,
+		})
+		if err == nil {
+			return msg, nil
+		}
+		// The old panel was deleted or the channel changed: post a new one.
+	}
+
+	msg, err := d.ChannelMessageSendComplex(id(s.ChannelID), &discordgo.MessageSend{
+		Embeds:     []*discordgo.MessageEmbed{embed},
+		Components: comps,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("posting the panel: %w", err)
+	}
+	if mid, err := strconv.ParseInt(msg.ID, 10, 64); err == nil {
+		if err := st.SetPanelMessage(ctx, guildID, mid); err != nil {
+			return msg, fmt.Errorf("saving the panel message: %w", err)
+		}
+	}
+	return msg, nil
+}
+
+// OpenForm is the short form shown after a member picks a category.
+func OpenForm(cat *ticketrepo.Category) *discordgo.InteractionResponse {
+	return &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseModal,
+		Data: &discordgo.InteractionResponseData{
+			CustomID: idOpenFormPrefix + id(cat.ID),
+			Title:    clip("Open a ticket: "+cat.Name, 45),
+			Components: []discordgo.MessageComponent{
+				discordgo.ActionsRow{Components: []discordgo.MessageComponent{discordgo.TextInput{
+					CustomID:    fieldSubject,
+					Label:       "What do you need help with?",
+					Style:       discordgo.TextInputShort,
+					Placeholder: "A short summary",
+					Required:    true,
+					MinLength:   3,
+					MaxLength:   maxSubject,
+				}}},
+				discordgo.ActionsRow{Components: []discordgo.MessageComponent{discordgo.TextInput{
+					CustomID:    fieldDetails,
+					Label:       "Details",
+					Style:       discordgo.TextInputParagraph,
+					Placeholder: "Anything the staff should know (optional)",
+					Required:    false,
+					MaxLength:   maxDetails,
+				}}},
+			},
+		},
+	}
+}
+
+// CloseForm asks for an optional reason before closing.
+func CloseForm() *discordgo.InteractionResponse {
+	return &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseModal,
+		Data: &discordgo.InteractionResponseData{
+			CustomID: idCloseForm,
+			Title:    "Close this ticket",
+			Components: []discordgo.MessageComponent{
+				discordgo.ActionsRow{Components: []discordgo.MessageComponent{discordgo.TextInput{
+					CustomID:  fieldReason,
+					Label:     "Reason (optional)",
+					Style:     discordgo.TextInputParagraph,
+					Required:  false,
+					MaxLength: maxReason,
+				}}},
+			},
+		},
+	}
+}

internal/tickets/tickets.go

@@ -0,0 +1,197 @@
+// Package tickets is the support ticket system: a panel message with one
+// button per category, a short form, and a private thread per ticket that
+// staff can claim and anyone involved can close. Closing locks and archives
+// the thread and posts a transcript to the log channel.
+//
+// The Discord and database calls go through small interfaces so the flows
+// can be tested without either; the slash command and button handlers in
+// internal/commands/tickets only translate interactions into these calls.
+package tickets
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"unicode"
+
+	"velox-bot/internal/db/repos/ticketrepo"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// Store is the subset of ticketrepo.Repo the flows use.
+type Store interface {
+	GetSettings(ctx context.Context, guildID int64) (*ticketrepo.Settings, error)
+	SetPanelMessage(ctx context.Context, guildID, messageID int64) error
+	NextNumber(ctx context.Context, guildID int64) (int, error)
+	ListCategories(ctx context.Context, guildID int64) ([]ticketrepo.Category, error)
+	GetCategory(ctx context.Context, guildID, id int64) (*ticketrepo.Category, error)
+	CountOpenByOpener(ctx context.Context, guildID, openerID int64) (int, error)
+	CreateTicket(ctx context.Context, t ticketrepo.Ticket) (int64, error)
+	GetTicketByThread(ctx context.Context, threadID int64) (*ticketrepo.Ticket, error)
+	Claim(ctx context.Context, threadID, staffID int64) (int64, error)
+	Close(ctx context.Context, threadID, closedBy int64, reason string) (bool, error)
+	ListUnprocessedCommands(ctx context.Context) ([]ticketrepo.Command, error)
+	MarkCommandProcessed(ctx context.Context, id int64) error
+}
+
+// Discord is the subset of *discordgo.Session the flows use.
+type Discord interface {
+	ThreadStartComplex(channelID string, data *discordgo.ThreadStart, options ...discordgo.RequestOption) (*discordgo.Channel, error)
+	ThreadMemberAdd(threadID, memberID string, options ...discordgo.RequestOption) error
+	ThreadMemberRemove(threadID, memberID string, options ...discordgo.RequestOption) error
+	ChannelMessageSendComplex(channelID string, data *discordgo.MessageSend, options ...discordgo.RequestOption) (*discordgo.Message, error)
+	ChannelMessageEditComplex(m *discordgo.MessageEdit, options ...discordgo.RequestOption) (*discordgo.Message, error)
+	ChannelMessage(channelID, messageID string, options ...discordgo.RequestOption) (*discordgo.Message, error)
+	ChannelMessages(channelID string, limit int, beforeID, afterID, aroundID string, options ...discordgo.RequestOption) ([]*discordgo.Message, error)
+	ChannelEditComplex(channelID string, data *discordgo.ChannelEdit, options ...discordgo.RequestOption) (*discordgo.Channel, error)
+	ChannelDelete(channelID string, options ...discordgo.RequestOption) (*discordgo.Channel, error)
+}
+
+// UserError is a problem worth showing the person who clicked, as written.
+// Anything else is logged and shown as a generic failure.
+type UserError string
+
+func (e UserError) Error() string { return string(e) }
+
+const (
+	ErrNotSetUp        = UserError("Tickets aren't set up on this server yet. An admin can run `/tickets setup`.")
+	ErrDisabled        = UserError("Tickets are turned off on this server right now.")
+	ErrNoCategories    = UserError("There are no ticket categories yet. Add one with `/tickets category add` or on the dashboard.")
+	ErrUnknownCategory = UserError("That ticket category no longer exists. Ask an admin to repost the ticket panel.")
+	ErrNotATicket      = UserError("This isn't a ticket thread.")
+	ErrClosed          = UserError("This ticket is already closed.")
+	ErrNotStaff        = UserError("Only the staff handling this kind of ticket can do that.")
+	ErrNotInvolved     = UserError("Only the person who opened this ticket or the staff can do that.")
+)
+
+var (
+	defaultStore Store
+	accent       = 0x2b7bfa
+)
+
+func Init(s Store) { defaultStore = s }
+
+func Default() Store { return defaultStore }
+
+// Limits Discord puts on what the bot sends.
+const (
+	maxThreadName   = 100
+	maxSubject      = 100
+	maxDetails      = 1000
+	maxReason       = 300
+	maxPanelButtons = 5 // more categories than this switch the panel to a dropdown
+	maxCategories   = 25
+	autoArchiveWeek = 10080
+)
+
+func id(v int64) string { return fmt.Sprintf("%d", v) }
+
+// IsStaff reports whether a member may claim, close and manage tickets of
+// this category: anyone with the category's staff role, or with Manage
+// Threads / Manage Server / Administrator (perms is the member's permission
+// set in the ticket's channel, as Discord sends it with the interaction).
+func IsStaff(member *discordgo.Member, perms int64, cat *ticketrepo.Category) bool {
+	const staffPerms = discordgo.PermissionAdministrator | discordgo.PermissionManageGuild | discordgo.PermissionManageThreads
+	if perms&staffPerms != 0 {
+		return true
+	}
+	if member == nil || cat == nil || cat.StaffRoleID == 0 {
+		return false
+	}
+	want := id(cat.StaffRoleID)
+	for _, r := range member.Roles {
+		if r == want {
+			return true
+		}
+	}
+	return false
+}
+
+// slug turns a name into lowercase ASCII words joined by dashes, for thread
+// names that read well in the channel's thread list.
+func slug(s string, max int) string {
+	var b strings.Builder
+	dash := false
+	for _, r := range strings.ToLower(s) {
+		switch {
+		case r < unicode.MaxASCII && (unicode.IsLetter(r) || unicode.IsDigit(r)):
+			if dash && b.Len() > 0 {
+				b.WriteByte('-')
+			}
+			b.WriteRune(r)
+			dash = false
+		default:
+			dash = true
+		}
+		if b.Len() >= max {
+			break
+		}
+	}
+	out := b.String()
+	if len(out) > max {
+		out = out[:max]
+	}
+	return strings.Trim(out, "-")
+}
+
+// ThreadName is "support-0042-ana": the category, the ticket number and who
+// opened it.
+func ThreadName(category string, number int, opener string) string {
+	cat := slug(category, 30)
+	if cat == "" {
+		cat = "ticket"
+	}
+	name := fmt.Sprintf("%s-%04d", cat, number)
+	if u := slug(opener, 32); u != "" {
+		name += "-" + u
+	}
+	if len(name) > maxThreadName {
+		name = name[:maxThreadName]
+	}
+	return name
+}
+
+func clip(s string, n int) string {
+	s = strings.TrimSpace(s)
+	if r := []rune(s); len(r) > n {
+		return string(r[:n-1]) + "…"
+	}
+	return s
+}
+
+// Permissions the bot needs, by channel.
+const (
+	NeedTicketChannel = discordgo.PermissionViewChannel | discordgo.PermissionSendMessages | discordgo.PermissionEmbedLinks |
+		discordgo.PermissionCreatePrivateThreads | discordgo.PermissionSendMessagesInThreads | discordgo.PermissionManageThreads
+	NeedLogChannel = discordgo.PermissionViewChannel | discordgo.PermissionSendMessages | discordgo.PermissionEmbedLinks |
+		discordgo.PermissionAttachFiles
+)
+
+var permNames = []struct {
+	bit  int64
+	name string
+}{
+	{discordgo.PermissionViewChannel, "View Channel"},
+	{discordgo.PermissionSendMessages, "Send Messages"},
+	{discordgo.PermissionEmbedLinks, "Embed Links"},
+	{discordgo.PermissionAttachFiles, "Attach Files"},
+	{discordgo.PermissionCreatePrivateThreads, "Create Private Threads"},
+	{discordgo.PermissionSendMessagesInThreads, "Send Messages in Threads"},
+	{discordgo.PermissionManageThreads, "Manage Threads"},
+}
+
+// MissingPerms names the permissions in need that have lacks. Administrator
+// counts as having everything.
+func MissingPerms(have, need int64) []string {
+	if have&discordgo.PermissionAdministrator != 0 {
+		return nil
+	}
+	var out []string
+	for _, p := range permNames {
+		if need&p.bit != 0 && have&p.bit == 0 {
+			out = append(out, p.name)
+		}
+	}
+	return out
+}

internal/tickets/tickets_test.go

@@ -0,0 +1,348 @@
+package tickets
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"velox-bot/internal/db/repos/ticketrepo"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+const (
+	guild   = int64(1)
+	channel = int64(10)
+	logCh   = int64(20)
+	staffRl = int64(30)
+)
+
+var ctx = context.Background()
+
+func member(userID string, roles ...string) *discordgo.Member {
+	return &discordgo.Member{User: &discordgo.User{ID: userID, Username: "user" + userID}, Roles: roles}
+}
+
+func TestThreadName(t *testing.T) {
+	for _, c := range []struct{ cat, user, want string }{
+		{"Support", "Ana", "support-0042-ana"},
+		{"Ban Appeal!", "João Silva", "ban-appeal-0042-jo-o-silva"},
+		{"🎫", "〈ぬべ〉", "ticket-0042"},
+		{strings.Repeat("x", 80), strings.Repeat("y", 80), strings.Repeat("x", 30) + "-0042-" + strings.Repeat("y", 32)},
+	} {
+		if got := ThreadName(c.cat, 42, c.user); got != c.want {
+			t.Errorf("ThreadName(%q, %q) = %q, want %q", c.cat, c.user, got, c.want)
+		}
+	}
+}
+
+func TestIsStaff(t *testing.T) {
+	cat := &ticketrepo.Category{StaffRoleID: staffRl}
+	if !IsStaff(member("1", "30"), 0, cat) {
+		t.Error("the staff role should count")
+	}
+	if IsStaff(member("1", "31"), 0, cat) {
+		t.Error("another role must not count")
+	}
+	for _, p := range []int64{discordgo.PermissionManageThreads, discordgo.PermissionManageGuild, discordgo.PermissionAdministrator} {
+		if !IsStaff(member("1"), p, nil) {
+			t.Errorf("permission %d should count, even with the category deleted", p)
+		}
+	}
+	if IsStaff(member("1"), discordgo.PermissionSendMessages, &ticketrepo.Category{}) {
+		t.Error("a category without a staff role must not make everyone staff")
+	}
+}
+
+func TestMissingPerms(t *testing.T) {
+	got := MissingPerms(discordgo.PermissionViewChannel|discordgo.PermissionSendMessages, NeedLogChannel)
+	if strings.Join(got, ",") != "Embed Links,Attach Files" {
+		t.Errorf("missing = %v", got)
+	}
+	if MissingPerms(discordgo.PermissionAdministrator, NeedTicketChannel) != nil {
+		t.Error("Administrator has everything")
+	}
+}
+
+func TestBuildPanel(t *testing.T) {
+	s := &ticketrepo.Settings{PanelTitle: "Help", PanelDescription: "Pick one"}
+	cats := []ticketrepo.Category{
+		{ID: 1, Name: "Support", Emoji: "🛟", Description: "General help"},
+		{ID: 2, Name: "Appeal", Emoji: "<a:party:123>"},
+	}
+	embed, comps := BuildPanel(s, cats)
+	row := comps[0].(discordgo.ActionsRow)
+	b1, b2 := row.Components[0].(discordgo.Button), row.Components[1].(discordgo.Button)
+	if embed.Title != "Help" || b1.CustomID != "tickets:open:1" || b1.Emoji.Name != "🛟" {
+		t.Errorf("first button wrong: %+v", b1)
+	}
+	if b2.Emoji.ID != "123" || b2.Emoji.Name != "party" || !b2.Emoji.Animated {
+		t.Errorf("custom emoji not parsed: %+v", b2.Emoji)
+	}
+	if len(embed.Fields) != 1 || embed.Fields[0].Value != "General help" {
+		t.Errorf("descriptions belong in the embed: %+v", embed.Fields)
+	}
+
+	var many []ticketrepo.Category
+	for i := 1; i <= 7; i++ {
+		many = append(many, ticketrepo.Category{ID: int64(i), Name: fmt.Sprint("Cat ", i)})
+	}
+	_, comps = BuildPanel(s, many)
+	menu := comps[0].(discordgo.ActionsRow).Components[0].(discordgo.SelectMenu)
+	if menu.CustomID != "tickets:select" || len(menu.Options) != 7 || menu.Options[6].Value != "7" {
+		t.Errorf("more than 5 categories should use a dropdown: %+v", menu)
+	}
+}
+
+func TestPostPanel(t *testing.T) {
+	st, d := newStore(), newDiscord()
+	if _, err := PostPanel(ctx, d, st, guild); !errors.Is(err, ErrNotSetUp) {
+		t.Errorf("err = %v, want not set up", err)
+	}
+	st.configure(guild, channel, logCh)
+	if _, err := PostPanel(ctx, d, st, guild); !errors.Is(err, ErrNoCategories) {
+		t.Errorf("err = %v, want no categories", err)
+	}
+	st.addCat(ticketrepo.Category{GuildID: guild, Name: "Support"})
+
+	msg, err := PostPanel(ctx, d, st, guild)
+	if err != nil || len(d.sent["10"]) != 1 || st.settings[guild].PanelMessageID != mustID(msg.ID) {
+		t.Fatalf("first post: err=%v sent=%d saved=%d", err, len(d.sent["10"]), st.settings[guild].PanelMessageID)
+	}
+
+	// A second post updates the same message.
+	if _, err := PostPanel(ctx, d, st, guild); err != nil || len(d.edits) != 1 || len(d.sent["10"]) != 1 {
+		t.Errorf("repost should edit: err=%v edits=%d sent=%d", err, len(d.edits), len(d.sent["10"]))
+	}
+
+	// If the old panel is gone, a new one is posted and remembered.
+	d.failEdit = errors.New("unknown message")
+	old := st.settings[guild].PanelMessageID
+	if _, err := PostPanel(ctx, d, st, guild); err != nil || len(d.sent["10"]) != 2 || st.settings[guild].PanelMessageID == old {
+		t.Errorf("deleted panel should be replaced: err=%v sent=%d", err, len(d.sent["10"]))
+	}
+}
+
+func setup() (*fakeStore, *fakeDiscord, ticketrepo.Category) {
+	st, d := newStore(), newDiscord()
+	st.configure(guild, channel, logCh)
+	cat := st.addCat(ticketrepo.Category{GuildID: guild, Name: "Support", StaffRoleID: staffRl})
+	return st, d, cat
+}
+
+func open(t *testing.T, st *fakeStore, d *fakeDiscord, cat ticketrepo.Category, userID string) *discordgo.Channel {
+	t.Helper()
+	th, err := Open(ctx, d, st, OpenRequest{
+		GuildID: guild, CategoryID: cat.ID,
+		User:    &discordgo.User{ID: userID, Username: "ana", GlobalName: "Ana"},
+		Subject: "Can't join voice", Details: "It says no permission",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return th
+}
+
+func TestCheckCanOpen(t *testing.T) {
+	st := newStore()
+	if _, _, err := CheckCanOpen(ctx, st, guild, 5, 1); !errors.Is(err, ErrNotSetUp) {
+		t.Errorf("err = %v", err)
+	}
+	st.configure(guild, channel, logCh)
+	if _, _, err := CheckCanOpen(ctx, st, guild, 5, 99); !errors.Is(err, ErrUnknownCategory) {
+		t.Errorf("err = %v", err)
+	}
+	st.settings[guild].Enabled = false
+	if _, _, err := CheckCanOpen(ctx, st, guild, 5, 1); !errors.Is(err, ErrDisabled) {
+		t.Errorf("err = %v", err)
+	}
+}
+
+func TestOpen(t *testing.T) {
+	st, d, cat := setup()
+	th := open(t, st, d, cat, "500")
+
+	start := d.threads[0]
+	if start.Type != discordgo.ChannelTypeGuildPrivateThread || start.Invitable || start.Name != "support-0001-ana" {
+		t.Errorf("thread wrong: %+v", start)
+	}
+	if strings.Join(d.members[th.ID], ",") != "500" {
+		t.Errorf("opener not added: %v", d.members[th.ID])
+	}
+	intro := d.sent[th.ID][0]
+	if intro.Content != "<@500> <@&30>" || strings.Join(intro.AllowedMentions.Roles, ",") != "30" {
+		t.Errorf("the staff role must be mentioned so its members join: %+v", intro)
+	}
+	if !strings.Contains(intro.Embeds[0].Description, "It says no permission") || intro.Embeds[0].Title != "Ticket #0001 · Support" {
+		t.Errorf("intro embed wrong: %+v", intro.Embeds[0])
+	}
+	tk := st.tickets[0]
+	if tk.Number != 1 || tk.ThreadID != mustID(th.ID) || tk.OpenerID != 500 || tk.IntroMessage == 0 || tk.Subject != "Can't join voice" {
+		t.Errorf("ticket row wrong: %+v", tk)
+	}
+
+	// The limit applies to the second ticket.
+	_, err := Open(ctx, d, st, OpenRequest{GuildID: guild, CategoryID: cat.ID, User: &discordgo.User{ID: "500"}, Subject: "again"})
+	var ue UserError
+	if !errors.As(err, &ue) || !strings.Contains(string(ue), "already have an open ticket") {
+		t.Errorf("err = %v", err)
+	}
+}
+
+func TestOpenCleansUpOnFailure(t *testing.T) {
+	st, d, cat := setup()
+	d.failSend = errors.New("missing access")
+	_, err := Open(ctx, d, st, OpenRequest{GuildID: guild, CategoryID: cat.ID, User: &discordgo.User{ID: "500"}, Subject: "help"})
+	if err == nil || len(d.deleted) != 1 || len(st.tickets) != 0 {
+		t.Errorf("a half-made ticket must be removed: err=%v deleted=%v tickets=%d", err, d.deleted, len(st.tickets))
+	}
+}
+
+func TestClaim(t *testing.T) {
+	st, d, cat := setup()
+	th := open(t, st, d, cat, "500")
+
+	if err := Claim(ctx, d, st, th.ID, Actor{Member: member("600")}); !errors.Is(err, ErrNotStaff) {
+		t.Errorf("non-staff claim: %v", err)
+	}
+	if err := Claim(ctx, d, st, th.ID, Actor{Member: member("700", "30")}); err != nil {
+		t.Fatal(err)
+	}
+	if st.tickets[0].ClaimedBy != 700 {
+		t.Errorf("claim not saved")
+	}
+	if len(d.edits) != 1 {
+		t.Fatalf("the first message should be updated")
+	}
+	e := (*d.edits[0].Embeds)[0]
+	if e.Fields[1].Value != "<@700>" || !strings.Contains(e.Description, "It says no permission") {
+		t.Errorf("updated intro lost details or claim: %+v", e)
+	}
+	if b := (*d.edits[0].Components)[0].(discordgo.ActionsRow).Components[0].(discordgo.Button); !b.Disabled || b.Label != "Claimed" {
+		t.Errorf("claim button should be disabled: %+v", b)
+	}
+
+	err := Claim(ctx, d, st, th.ID, Actor{Member: member("701"), Perms: discordgo.PermissionManageThreads})
+	if err == nil || !strings.Contains(err.Error(), "<@700> is already handling") {
+		t.Errorf("second claim: %v", err)
+	}
+	if err := Claim(ctx, d, st, "999", Actor{Member: member("700", "30")}); !errors.Is(err, ErrNotATicket) {
+		t.Errorf("claim outside a ticket: %v", err)
+	}
+}
+
+func TestClose(t *testing.T) {
+	st, d, cat := setup()
+	th := open(t, st, d, cat, "500")
+	ts := time.Date(2026, 10, 20, 18, 0, 0, 0, time.UTC)
+	d.history[th.ID] = []*discordgo.Message{ // newest first
+		{ID: "3", Content: "thanks, works now", Author: &discordgo.User{Username: "ana"}, Timestamp: ts.Add(2 * time.Minute)},
+		{ID: "2", Content: "try rejoining", Author: &discordgo.User{Username: "mod", GlobalName: "Mod"}, Timestamp: ts.Add(time.Minute),
+			Attachments: []*discordgo.MessageAttachment{{Filename: "steps.png", URL: "https://cdn/x.png"}}},
+		{ID: "1", Author: &discordgo.User{Username: "velox", Bot: true}, Embeds: []*discordgo.MessageEmbed{{Title: "Ticket #0001 · Support"}}, Timestamp: ts},
+	}
+
+	if err := Close(ctx, d, st, th.ID, Actor{Member: member("600")}, ""); !errors.Is(err, ErrNotInvolved) {
+		t.Errorf("an outsider must not close: %v", err)
+	}
+	if err := Close(ctx, d, st, th.ID, Actor{Member: member("500")}, "Solved"); err != nil {
+		t.Fatal(err)
+	}
+
+	tk := st.tickets[0]
+	if tk.Status != ticketrepo.StatusClosed || tk.ClosedBy != 500 || tk.CloseReason != "Solved" {
+		t.Errorf("ticket not closed: %+v", tk)
+	}
+	if e := d.chEdits[th.ID]; e == nil || !*e.Locked || !*e.Archived {
+		t.Errorf("thread should be locked and archived: %+v", e)
+	}
+	logged := d.sent["20"]
+	if len(logged) != 1 || !strings.Contains(logged[0].Embeds[0].Title, "Ticket #0001 closed") {
+		t.Fatalf("log channel post missing: %+v", logged)
+	}
+	transcript := d.files["ticket-0001.txt"]
+	i1, i2, i3 := strings.Index(transcript, "[embed] Ticket #0001"), strings.Index(transcript, "try rejoining"), strings.Index(transcript, "thanks, works now")
+	if i1 < 0 || i2 < i1 || i3 < i2 {
+		t.Errorf("transcript must be oldest first:\n%s", transcript)
+	}
+	if !strings.Contains(transcript, "Mod (mod)") || !strings.Contains(transcript, "[file] steps.png https://cdn/x.png") || !strings.Contains(transcript, "velox [bot]") {
+		t.Errorf("transcript details missing:\n%s", transcript)
+	}
+
+	if err := Close(ctx, d, st, th.ID, Actor{Member: member("500")}, ""); !errors.Is(err, ErrClosed) {
+		t.Errorf("closing twice: %v", err)
+	}
+	// A closed ticket no longer counts towards the limit.
+	open(t, st, d, cat, "500")
+}
+
+func TestTranscriptPages(t *testing.T) {
+	d := newDiscord()
+	var hist []*discordgo.Message
+	for i := 250; i >= 1; i-- {
+		hist = append(hist, &discordgo.Message{ID: fmt.Sprint(i), Content: fmt.Sprint("msg ", i), Author: &discordgo.User{Username: "u"}})
+	}
+	d.history["5"] = hist
+	out, n, err := Transcript(d, &ticketrepo.Ticket{ThreadID: 5, Number: 1})
+	if err != nil || n != 250 {
+		t.Fatalf("n=%d err=%v", n, err)
+	}
+	if strings.Index(string(out), "msg 1\n") > strings.Index(string(out), "msg 250\n") {
+		t.Error("pages must be stitched oldest first")
+	}
+
+	d.failFetch = errors.New("boom")
+	out, _, err = Transcript(d, &ticketrepo.Ticket{ThreadID: 5})
+	if err == nil || !strings.Contains(string(out), "only part of the thread") {
+		t.Error("a failed read should still produce a transcript that says so")
+	}
+}
+
+func TestAddAndRemoveMember(t *testing.T) {
+	st, d, cat := setup()
+	th := open(t, st, d, cat, "500")
+
+	if err := AddMember(ctx, d, st, th.ID, Actor{Member: member("600")}, "601"); !errors.Is(err, ErrNotInvolved) {
+		t.Errorf("outsider add: %v", err)
+	}
+	if err := AddMember(ctx, d, st, th.ID, Actor{Member: member("500")}, "601"); err != nil {
+		t.Errorf("the opener can add: %v", err)
+	}
+	if err := RemoveMember(ctx, d, st, th.ID, Actor{Member: member("500")}, "601"); !errors.Is(err, ErrNotStaff) {
+		t.Errorf("only staff remove: %v", err)
+	}
+	if err := RemoveMember(ctx, d, st, th.ID, Actor{Member: member("700", "30")}, "500"); err == nil {
+		t.Error("the opener can't be removed")
+	}
+	if err := RemoveMember(ctx, d, st, th.ID, Actor{Member: member("700", "30")}, "601"); err != nil {
+		t.Error(err)
+	}
+	if strings.Join(d.members[th.ID], ",") != "500" {
+		t.Errorf("members = %v", d.members[th.ID])
+	}
+}
+
+func TestThreadDeletedFreesTheLimit(t *testing.T) {
+	st, d, cat := setup()
+	th := open(t, st, d, cat, "500")
+	ThreadDeleted(ctx, st, th.ID)
+	if st.tickets[0].Status != ticketrepo.StatusClosed || st.tickets[0].CloseReason != "Thread deleted" {
+		t.Errorf("ticket = %+v", st.tickets[0])
+	}
+	open(t, st, d, cat, "500")
+}
+
+func TestProcessCommands(t *testing.T) {
+	st, d, _ := setup()
+	st.cmds = []ticketrepo.Command{{ID: 1, GuildID: guild, CommandType: "post_panel"}, {ID: 2, GuildID: 99, CommandType: "post_panel"}, {ID: 3, CommandType: "nope"}}
+	ProcessCommands(ctx, d, st)
+	if len(d.sent["10"]) != 1 {
+		t.Errorf("panel not posted")
+	}
+	if len(st.done) != 3 {
+		t.Errorf("every command must be marked done, even failed ones: %v", st.done)
+	}
+}

internal/tickets/transcript.go

@@ -0,0 +1,88 @@
+package tickets
+
+import (
+	"fmt"
+	"strings"
+
+	"velox-bot/internal/db/repos/ticketrepo"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// maxTranscriptMessages bounds how far back a transcript reads: 50 pages of
+// 100, far beyond any normal ticket.
+const maxTranscriptMessages = 5000
+
+// Transcript renders the whole thread as plain text, oldest first, and
+// reports how many messages it holds. Attachments and embeds are listed so
+// the log keeps their links and titles.
+func Transcript(d Discord, t *ticketrepo.Ticket) ([]byte, int, error) {
+	var msgs []*discordgo.Message
+	before := ""
+	var fetchErr error
+	for len(msgs) < maxTranscriptMessages {
+		page, err := d.ChannelMessages(id(t.ThreadID), 100, before, "", "")
+		if err != nil {
+			fetchErr = err
+			break
+		}
+		msgs = append(msgs, page...)
+		if len(page) < 100 {
+			break
+		}
+		before = page[len(page)-1].ID
+	}
+
+	var b strings.Builder
+	fmt.Fprintf(&b, "Ticket #%04d · %s\n", t.Number, t.CategoryName)
+	fmt.Fprintf(&b, "Subject: %s\n", t.Subject)
+	fmt.Fprintf(&b, "Opened by user %d on %s\n", t.OpenerID, t.CreatedAt.UTC().Format("2006-01-02 15:04 MST"))
+	if fetchErr != nil {
+		fmt.Fprintf(&b, "Note: only part of the thread could be read (%v)\n", fetchErr)
+	}
+	b.WriteString(strings.Repeat("-", 60) + "\n\n")
+
+	// Discord returns newest first.
+	for i := len(msgs) - 1; i >= 0; i-- {
+		writeMessage(&b, msgs[i])
+	}
+	return []byte(b.String()), len(msgs), fetchErr
+}
+
+func writeMessage(b *strings.Builder, m *discordgo.Message) {
+	name := "unknown"
+	if m.Author != nil {
+		name = m.Author.Username
+		if m.Author.GlobalName != "" {
+			name = m.Author.GlobalName + " (" + m.Author.Username + ")"
+		}
+		if m.Author.Bot {
+			name += " [bot]"
+		}
+	}
+	fmt.Fprintf(b, "[%s] %s\n", m.Timestamp.UTC().Format("2006-01-02 15:04"), name)
+
+	if content := strings.TrimSpace(m.Content); content != "" {
+		for _, line := range strings.Split(content, "\n") {
+			b.WriteString("    " + line + "\n")
+		}
+	}
+	for _, e := range m.Embeds {
+		if e == nil {
+			continue
+		}
+		title := e.Title
+		if title == "" {
+			title = clip(e.Description, 120)
+		}
+		if title != "" {
+			b.WriteString("    [embed] " + strings.ReplaceAll(title, "\n", " ") + "\n")
+		}
+	}
+	for _, a := range m.Attachments {
+		if a != nil {
+			b.WriteString("    [file] " + a.Filename + " " + a.URL + "\n")
+		}
+	}
+	b.WriteString("\n")
+}

main.go

@@ -8,22 +8,33 @@ import (
 	"syscall"
 	"velox-bot/internal/bot"
 	"velox-bot/internal/commands"
+	cmdtickets "velox-bot/internal/commands/tickets"
 	"velox-bot/internal/config"
 	"velox-bot/internal/db"
+	"velox-bot/internal/db/repos/defaultrolerepo"
 	"velox-bot/internal/db/repos/levelrepo"
+	"velox-bot/internal/db/repos/musicrepo"
 	"velox-bot/internal/db/repos/projectsrepo"
 	"velox-bot/internal/db/repos/rpsrepo"
 	"velox-bot/internal/db/repos/schedulerepo"
 	"velox-bot/internal/db/repos/settingsrepo"
+	"velox-bot/internal/db/repos/ticketrepo"
+	"velox-bot/internal/db/repos/twitchrepo"
 	"velox-bot/internal/db/repos/usersettingsrepo"
+	"velox-bot/internal/db/repos/welcomerepo"
 	"velox-bot/internal/db/services"
+	"velox-bot/internal/db/services/defaultrole"
 	"velox-bot/internal/db/services/level"
 	"velox-bot/internal/db/services/levelsettings"
+	"velox-bot/internal/db/services/logsettings"
 	"velox-bot/internal/db/services/meeting"
-	"velox-bot/internal/db/services/schedule"
-	"velox-bot/internal/db/services/usersettings"
+	"velox-bot/internal/db/services/musicsettings"
 	"velox-bot/internal/db/services/projects"
 	"velox-bot/internal/db/services/rps"
+	"velox-bot/internal/db/services/schedule"
+	"velox-bot/internal/db/services/twitch"
+	"velox-bot/internal/db/services/usersettings"
+	"velox-bot/internal/db/services/welcome"
 )
 
 func main() {
@@ -42,20 +53,30 @@ func main() {
 
 	levelRepo := levelrepo.NewRepo(db)
 	settingsRepo := settingsrepo.NewRepo(db)
+	musicRepo := musicrepo.NewRepo(db)
 	rpsRepo := rpsrepo.NewRepo(db)
 	projectsRepo := projectsrepo.NewRepo(db)
 	scheduleRepo := schedulerepo.NewRepo(db)
 	userSettingsRepo := usersettingsrepo.NewRepo(db)
+	welcomeRepo := welcomerepo.NewRepo(db)
+	twitchRepo := twitchrepo.NewRepo(db)
+	defaultRoleRepo := defaultrolerepo.NewRepo(db)
+	cmdtickets.Init(ticketrepo.NewRepo(db))
 	levelService := level.New(levelRepo, settingsRepo)
 	levelSettingsService := levelsettings.New(settingsRepo)
+	logSettingsService := logsettings.New(settingsRepo)
 	meetingService := meeting.New(settingsRepo)
 	scheduleService := schedule.New(scheduleRepo)
 	userSettingsService := usersettings.New(userSettingsRepo)
 	projectsService := projects.New(projectsRepo)
 	rpsService := rps.New(rpsRepo)
-	services := services.NewServices(levelService, levelSettingsService, meetingService, scheduleService, userSettingsService, projectsService, rpsService)
+	twitchService := twitch.New(twitchRepo, config.TwitchClientID)
+	welcomeService := welcome.New(welcomeRepo)
+	defaultRoleService := defaultrole.New(defaultRoleRepo)
+	musicSettingsService := musicsettings.New(settingsRepo)
+	services := services.NewServices(levelService, levelSettingsService, meetingService, scheduleService, userSettingsService, projectsService, rpsService, twitchService, welcomeService, defaultRoleService, logSettingsService, musicSettingsService)
 
-	bot, err := bot.NewBot(config.BotToken, config.AppID, config.GuildID, config.LavalinkHost, config.LavalinkPass, commands.AllCommands, services)
+	bot, err := bot.NewBot(config.BotToken, config.AppID, config.GuildID, config.LavalinkHost, config.LavalinkPass, commands.AllCommands, services, musicRepo, config.DBHost)
 	if err != nil {
 		log.Fatalf("Error creating bot: %v", err)
 		return

schema.sql

@@ -19,8 +19,6 @@ CREATE TABLE IF NOT EXISTS twitch (
 CREATE TABLE IF NOT EXISTS levelsettings (
     guild_id BIGINT PRIMARY KEY,
     levelsys BOOLEAN NOT NULL DEFAULT FALSE,
-    role BIGINT,
-    levelreq INT,
     message TEXT
 );
 
@@ -47,7 +45,8 @@ CREATE TABLE IF NOT EXISTS levelup (
 
 CREATE TABLE IF NOT EXISTS twitch_config (
     guild_id BIGINT PRIMARY KEY,
-    twitch_channel_id BIGINT
+    twitch_channel_id BIGINT,
+    enabled BOOLEAN NOT NULL DEFAULT TRUE
 );
 
 CREATE TABLE IF NOT EXISTS rps (
@@ -112,7 +111,14 @@ CREATE TABLE IF NOT EXISTS schedules (
     status TEXT NOT NULL DEFAULT 'pending', -- pending, accepted, declined, reschedule_requested
     description TEXT,
     reminder_sent BOOLEAN NOT NULL DEFAULT FALSE,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    -- Reschedule negotiation: a proposed new time awaiting the counterpart's
+    -- response, kept separate from scheduled_at until accepted.
+    proposed_at TIMESTAMPTZ,
+    proposed_by BIGINT,
+    -- Snapshot of status before entering reschedule_requested, so a decline
+    -- knows whether to revert to 'pending' or 'accepted'.
+    pre_reschedule_status TEXT
 );
 
 CREATE TABLE IF NOT EXISTS schedule_messages (
@@ -127,3 +133,98 @@ CREATE TABLE IF NOT EXISTS user_settings (
     user_id BIGINT PRIMARY KEY,
     timezone TEXT NOT NULL
 );
+
+--
+-- Music (dashboard queue view/control - see velox-dashboard-api's
+-- 000010_music migration, this file mirrors it)
+--
+CREATE TABLE IF NOT EXISTS music_settings (
+    guild_id BIGINT PRIMARY KEY,
+    is_enabled BOOLEAN NOT NULL DEFAULT FALSE
+);
+
+CREATE TABLE IF NOT EXISTS music_now_playing (
+    guild_id BIGINT PRIMARY KEY,
+    track_title TEXT NOT NULL,
+    track_url TEXT NOT NULL,
+    duration_seconds INT NOT NULL,
+    started_at TIMESTAMPTZ NOT NULL,
+    paused BOOLEAN NOT NULL DEFAULT FALSE,
+    volume INT NOT NULL DEFAULT 100,
+    repeat_song BOOLEAN NOT NULL DEFAULT FALSE,
+    repeat_queue BOOLEAN NOT NULL DEFAULT FALSE
+);
+
+CREATE TABLE IF NOT EXISTS music_queue (
+    id BIGSERIAL PRIMARY KEY,
+    guild_id BIGINT NOT NULL,
+    position INT NOT NULL,
+    track_title TEXT NOT NULL,
+    track_url TEXT NOT NULL,
+    requested_by BIGINT NOT NULL,
+    added_at TIMESTAMPTZ DEFAULT NOW(),
+    client_id UUID NOT NULL DEFAULT gen_random_uuid(),
+    UNIQUE (guild_id, client_id)
+);
+
+CREATE TABLE IF NOT EXISTS music_commands (
+    id BIGSERIAL PRIMARY KEY,
+    guild_id BIGINT NOT NULL,
+    command_type TEXT NOT NULL CHECK (command_type IN ('skip', 'pause', 'resume', 'set_volume', 'remove_track', 'reorder', 'repeat_song', 'repeat_queue', 'add_song', 'stop')),
+    payload JSONB,
+    requested_by BIGINT NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    processed_at TIMESTAMPTZ
+);
+
+-- Tickets (mirror of velox-dashboard-api migration 000016_tickets)
+CREATE TABLE IF NOT EXISTS ticket_settings (
+    guild_id BIGINT PRIMARY KEY,
+    enabled BOOLEAN NOT NULL DEFAULT TRUE,
+    channel_id BIGINT,
+    log_channel_id BIGINT,
+    panel_message_id BIGINT,
+    panel_title TEXT NOT NULL DEFAULT 'Need help?',
+    panel_description TEXT NOT NULL DEFAULT 'Pick a category below to open a private ticket with the staff team.',
+    max_open_per_user INT NOT NULL DEFAULT 1 CHECK (max_open_per_user BETWEEN 1 AND 10),
+    next_number INT NOT NULL DEFAULT 1
+);
+
+CREATE TABLE IF NOT EXISTS ticket_categories (
+    id BIGSERIAL PRIMARY KEY,
+    guild_id BIGINT NOT NULL,
+    name TEXT NOT NULL CHECK (char_length(name) BETWEEN 1 AND 40),
+    emoji TEXT,
+    description TEXT NOT NULL DEFAULT '',
+    staff_role_id BIGINT,
+    position INT NOT NULL DEFAULT 0,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS tickets (
+    id BIGSERIAL PRIMARY KEY,
+    guild_id BIGINT NOT NULL,
+    number INT NOT NULL,
+    category_id BIGINT REFERENCES ticket_categories (id) ON DELETE SET NULL,
+    category_name TEXT NOT NULL,
+    thread_id BIGINT NOT NULL UNIQUE,
+    intro_message_id BIGINT,
+    opener_id BIGINT NOT NULL,
+    subject TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'open' CHECK (status IN ('open', 'closed')),
+    claimed_by BIGINT,
+    closed_by BIGINT,
+    close_reason TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    closed_at TIMESTAMPTZ,
+    UNIQUE (guild_id, number)
+);
+
+CREATE TABLE IF NOT EXISTS ticket_commands (
+    id BIGSERIAL PRIMARY KEY,
+    guild_id BIGINT NOT NULL,
+    command_type TEXT NOT NULL CHECK (command_type IN ('post_panel')),
+    requested_by BIGINT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    processed_at TIMESTAMPTZ
+);