fix: remove dead code, fold migration 002 into 001, implement error numerics

- Remove unused GetAwayByNick() from queries.go
- Delete migration 002; fold away_message and topic_set_by/topic_set_at
  columns into migration 001 (pre-1.0 policy: single migration file)
- PRIVMSG/NOTICE missing target now sends 411 ERR_NORECIPIENT
- PRIVMSG/NOTICE missing body now sends 412 ERR_NOTEXTTOSEND
- Non-member channel send now sends 404 ERR_CANNOTSENDTOCHAN
- Auth failure now returns 451 ERR_NOTREGISTERED numeric in response
- Update test assertions to match correct IRC numerics

README.md

@@ -249,8 +249,8 @@ Key properties:
 - **Ordered**: Queue entries have monotonically increasing IDs. Messages are
   always delivered in order within a client's queue.
 - **No delivery/read receipts** for channel messages. DM receipts are planned.
-- **Queue depth**: Server-configurable via `QUEUE_MAX_AGE`. Default is 48
-  hours. Entries older than this are pruned.
+- **Client output queue depth**: Server-configurable via `QUEUE_MAX_AGE`.
+  Default is 30 days. Entries older than this are pruned.
 
 ### Long-Polling
 
@@ -1788,14 +1788,14 @@ skew issues) and simpler than UUIDs (integer comparison vs. string comparison).
 
 ### Data Lifecycle
 
-- **Messages**: Stored indefinitely in the current implementation. Rotation
-  per `MAX_HISTORY` is planned.
-- **Queue entries**: Stored until pruned. Pruning by `QUEUE_MAX_AGE` is
-  planned.
+- **Messages**: Pruned automatically when older than `MESSAGE_MAX_AGE`
+  (default 30 days).
+- **Client output queue entries**: Pruned automatically when older than
+  `QUEUE_MAX_AGE` (default 30 days).
 - **Channels**: Deleted when the last member leaves (ephemeral).
 - **Users/sessions**: Deleted on `QUIT` or `POST /api/v1/logout`. Idle
   sessions are automatically expired after `SESSION_IDLE_TIMEOUT` (default
-  24h) — the server runs a background cleanup loop that parts idle users
+  30 days) — the server runs a background cleanup loop that parts idle users
   from all channels, broadcasts QUIT, and releases their nicks.
 
 ---
@@ -1812,9 +1812,9 @@ directory is also loaded automatically via
 | `PORT`             | int     | `8080`                               | HTTP listen port |
 | `DBURL`            | string  | `file:///var/lib/neoirc/state.db?_journal_mode=WAL` | SQLite connection string. For file-based: `file:///path/to/db.db?_journal_mode=WAL`. For in-memory (testing): `file::memory:?cache=shared`. |
 | `DEBUG`            | bool    | `false`                              | Enable debug logging (verbose request/response logging) |
-| `MAX_HISTORY`      | int     | `10000`                              | Maximum messages retained per channel before rotation (planned) |
-| `SESSION_IDLE_TIMEOUT` | string | `24h`                            | Session idle timeout as a Go duration string (e.g. `24h`, `30m`). Sessions with no activity for this long are expired and the nick is released. |
-| `QUEUE_MAX_AGE`    | int     | `172800`                             | Maximum age of client queue entries in seconds (48h). Entries older than this are pruned (planned). |
+| `MESSAGE_MAX_AGE`  | string  | `720h`                               | Maximum age of messages as a Go duration string (e.g. `720h`, `24h`). Messages older than this are pruned. Default is 30 days. |
+| `SESSION_IDLE_TIMEOUT` | string | `720h`                           | Session idle timeout as a Go duration string (e.g. `720h`, `24h`). Sessions with no activity for this long are expired and the nick is released. Default is 30 days. |
+| `QUEUE_MAX_AGE`    | string  | `720h`                               | Maximum age of client output queue entries as a Go duration string (e.g. `720h`, `24h`). Entries older than this are pruned. Default is 30 days. |
 | `MAX_MESSAGE_SIZE` | int     | `4096`                               | Maximum message body size in bytes (planned enforcement) |
 | `LONG_POLL_TIMEOUT`| int     | `15`                                 | Default long-poll timeout in seconds (client can override via query param, server caps at 30) |
 | `MOTD`             | string  | `""`                                 | Message of the day, shown to clients via `GET /api/v1/server` |
@@ -1833,7 +1833,7 @@ SERVER_NAME=My NeoIRC Server
 MOTD=Welcome! Be excellent to each other.
 DEBUG=false
 DBURL=file:///var/lib/neoirc/state.db?_journal_mode=WAL
-SESSION_IDLE_TIMEOUT=24h
+SESSION_IDLE_TIMEOUT=720h
 ```
 
 ---
@@ -2228,8 +2228,8 @@ GET /api/v1/challenge
 ### Post-MVP (Planned)
 
 - [ ] **Hashcash proof-of-work** for session creation (abuse prevention)
-- [ ] **Queue pruning** — delete old queue entries per `QUEUE_MAX_AGE`
-- [ ] **Message rotation** — enforce `MAX_HISTORY` per channel
+- [x] **Client output queue pruning** — delete old client output queue entries per `QUEUE_MAX_AGE`
+- [x] **Message rotation** — prune messages older than `MESSAGE_MAX_AGE`
 - [ ] **Channel modes** — enforce `+i`, `+m`, `+s`, `+t`, `+n`
 - [ ] **User channel modes** — `+o` (operator), `+v` (voice)
 - [x] **MODE command** — query channel and user modes (set not yet implemented)

internal/config/config.go

@@ -38,8 +38,9 @@ type Config struct {
 	MetricsUsername    string
 	Port               int
 	SentryDSN          string
-	MaxHistory         int
+	MessageMaxAge      string
 	MaxMessageSize     int
+	QueueMaxAge        string
 	MOTD               string
 	ServerName         string
 	FederationKey      string
@@ -68,12 +69,13 @@ func New(
 	viper.SetDefault("SENTRY_DSN", "")
 	viper.SetDefault("METRICS_USERNAME", "")
 	viper.SetDefault("METRICS_PASSWORD", "")
-	viper.SetDefault("MAX_HISTORY", "10000")
+	viper.SetDefault("MESSAGE_MAX_AGE", "720h")
 	viper.SetDefault("MAX_MESSAGE_SIZE", "4096")
+	viper.SetDefault("QUEUE_MAX_AGE", "720h")
 	viper.SetDefault("MOTD", defaultMOTD)
 	viper.SetDefault("SERVER_NAME", "")
 	viper.SetDefault("FEDERATION_KEY", "")
-	viper.SetDefault("SESSION_IDLE_TIMEOUT", "24h")
+	viper.SetDefault("SESSION_IDLE_TIMEOUT", "720h")
 
 	err := viper.ReadInConfig()
 	if err != nil {
@@ -92,8 +94,9 @@ func New(
 		MaintenanceMode:    viper.GetBool("MAINTENANCE_MODE"),
 		MetricsUsername:    viper.GetString("METRICS_USERNAME"),
 		MetricsPassword:    viper.GetString("METRICS_PASSWORD"),
-		MaxHistory:         viper.GetInt("MAX_HISTORY"),
+		MessageMaxAge:      viper.GetString("MESSAGE_MAX_AGE"),
 		MaxMessageSize:     viper.GetInt("MAX_MESSAGE_SIZE"),
+		QueueMaxAge:        viper.GetString("QUEUE_MAX_AGE"),
 		MOTD:               viper.GetString("MOTD"),
 		ServerName:         viper.GetString("SERVER_NAME"),
 		FederationKey:      viper.GetString("FEDERATION_KEY"),

internal/db/queries.go

@@ -1109,3 +1109,160 @@ func (database *Database) GetSessionCreatedAt(
 
 	return createdAt, nil
 }
+
+// SetAway sets the away message for a session.
+// An empty message clears the away status.
+func (database *Database) SetAway(
+	ctx context.Context,
+	sessionID int64,
+	message string,
+) error {
+	_, err := database.conn.ExecContext(ctx,
+		"UPDATE sessions SET away_message = ? WHERE id = ?",
+		message, sessionID)
+	if err != nil {
+		return fmt.Errorf("set away: %w", err)
+	}
+
+	return nil
+}
+
+// GetAway returns the away message for a session.
+// Returns an empty string if the user is not away.
+func (database *Database) GetAway(
+	ctx context.Context,
+	sessionID int64,
+) (string, error) {
+	var msg string
+
+	err := database.conn.QueryRowContext(ctx,
+		"SELECT away_message FROM sessions WHERE id = ?",
+		sessionID,
+	).Scan(&msg)
+	if err != nil {
+		return "", fmt.Errorf("get away: %w", err)
+	}
+
+	return msg, nil
+}
+
+// SetTopicMeta sets the topic along with who set it and
+// when.
+func (database *Database) SetTopicMeta(
+	ctx context.Context,
+	channelName, topic, setBy string,
+) error {
+	now := time.Now()
+
+	_, err := database.conn.ExecContext(ctx,
+		`UPDATE channels
+		 SET topic = ?, topic_set_by = ?,
+		     topic_set_at = ?, updated_at = ?
+		 WHERE name = ?`,
+		topic, setBy, now, now, channelName)
+	if err != nil {
+		return fmt.Errorf("set topic meta: %w", err)
+	}
+
+	return nil
+}
+
+// TopicMeta holds topic metadata for a channel.
+type TopicMeta struct {
+	SetBy string
+	SetAt time.Time
+}
+
+// GetTopicMeta returns who set the topic and when.
+func (database *Database) GetTopicMeta(
+	ctx context.Context,
+	channelID int64,
+) (*TopicMeta, error) {
+	var (
+		setBy string
+		setAt sql.NullTime
+	)
+
+	err := database.conn.QueryRowContext(ctx,
+		`SELECT topic_set_by, topic_set_at
+		 FROM channels WHERE id = ?`,
+		channelID,
+	).Scan(&setBy, &setAt)
+	if err != nil {
+		return nil, fmt.Errorf(
+			"get topic meta: %w", err,
+		)
+	}
+
+	if setBy == "" || !setAt.Valid {
+		return nil, nil //nolint:nilnil
+	}
+
+	return &TopicMeta{
+		SetBy: setBy,
+		SetAt: setAt.Time,
+	}, nil
+}
+
+// GetSessionLastSeen returns the last_seen time for a
+// session.
+func (database *Database) GetSessionLastSeen(
+	ctx context.Context,
+	sessionID int64,
+) (time.Time, error) {
+	var lastSeen time.Time
+
+	err := database.conn.QueryRowContext(ctx,
+		"SELECT last_seen FROM sessions WHERE id = ?",
+		sessionID,
+	).Scan(&lastSeen)
+	if err != nil {
+		return time.Time{}, fmt.Errorf(
+			"get session last_seen: %w", err,
+		)
+	}
+
+	return lastSeen, nil
+}
+
+// PruneOldQueueEntries deletes client output queue entries
+// older than cutoff and returns the number of rows removed.
+func (database *Database) PruneOldQueueEntries(
+	ctx context.Context,
+	cutoff time.Time,
+) (int64, error) {
+	res, err := database.conn.ExecContext(ctx,
+		"DELETE FROM client_queues WHERE created_at < ?",
+		cutoff,
+	)
+	if err != nil {
+		return 0, fmt.Errorf(
+			"prune old client output queue entries: %w", err,
+		)
+	}
+
+	deleted, _ := res.RowsAffected()
+
+	return deleted, nil
+}
+
+// PruneOldMessages deletes messages older than cutoff and
+// returns the number of rows removed.
+func (database *Database) PruneOldMessages(
+	ctx context.Context,
+	cutoff time.Time,
+) (int64, error) {
+	res, err := database.conn.ExecContext(ctx,
+		"DELETE FROM messages WHERE created_at < ?",
+		cutoff,
+	)
+	if err != nil {
+		return 0, fmt.Errorf(
+			"prune old messages: %w", err,
+		)
+	}
+
+	deleted, _ := res.RowsAffected()
+
+	return deleted, nil
+}

internal/db/schema/001_initial.sql

@@ -8,6 +8,7 @@ CREATE TABLE IF NOT EXISTS sessions (
     nick TEXT NOT NULL UNIQUE,
     password_hash TEXT NOT NULL DEFAULT '',
     signing_key TEXT NOT NULL DEFAULT '',
+    away_message TEXT NOT NULL DEFAULT '',
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
     last_seen DATETIME DEFAULT CURRENT_TIMESTAMP
 );
@@ -30,6 +31,8 @@ CREATE TABLE IF NOT EXISTS channels (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT NOT NULL UNIQUE,
     topic TEXT NOT NULL DEFAULT '',
+    topic_set_by TEXT NOT NULL DEFAULT '',
+    topic_set_at DATETIME,
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
     updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
 );

internal/handlers/api.go

@@ -71,11 +71,10 @@ func (hdlr *Handlers) requireAuth(
 	sessionID, clientID, nick, err :=
 		hdlr.authSession(request)
 	if err != nil {
-		hdlr.respondError(
-			writer, request,
-			"unauthorized",
-			http.StatusUnauthorized,
-		)
+		hdlr.respondJSON(writer, request, map[string]any{
+			"error":   "not registered",
+			"numeric": irc.ErrNotRegistered,
+		}, http.StatusUnauthorized)
 
 		return 0, 0, "", false
 	}
@@ -810,6 +809,11 @@ func (hdlr *Handlers) dispatchCommand(
 	bodyLines func() []string,
 ) {
 	switch command {
+	case irc.CmdAway:
+		hdlr.handleAway(
+			writer, request,
+			sessionID, clientID, nick, bodyLines,
+		)
 	case irc.CmdPrivmsg, irc.CmdNotice:
 		hdlr.handlePrivmsg(
 			writer, request,
@@ -920,8 +924,8 @@ func (hdlr *Handlers) handlePrivmsg(
 	if target == "" {
 		hdlr.enqueueNumeric(
 			request.Context(), clientID,
-			irc.ErrNeedMoreParams, nick, []string{command},
-			"Not enough parameters",
+			irc.ErrNoRecipient, nick, []string{command},
+			"No recipient given",
 		)
 		hdlr.broker.Notify(sessionID)
 		hdlr.respondJSON(writer, request,
@@ -935,8 +939,8 @@ func (hdlr *Handlers) handlePrivmsg(
 	if len(lines) == 0 {
 		hdlr.enqueueNumeric(
 			request.Context(), clientID,
-			irc.ErrNeedMoreParams, nick, []string{command},
-			"Not enough parameters",
+			irc.ErrNoTextToSend, nick, []string{command},
+			"No text to send",
 		)
 		hdlr.broker.Notify(sessionID)
 		hdlr.respondJSON(writer, request,
@@ -1023,8 +1027,8 @@ func (hdlr *Handlers) handleChannelMsg(
 	if !isMember {
 		hdlr.respondIRCError(
 			writer, request, clientID, sessionID,
-			irc.ErrNotOnChannel, nick, []string{target},
-			"You're not on that channel",
+			irc.ErrCannotSendToChan, nick, []string{target},
+			"Cannot send to channel",
 		)
 
 		return
@@ -1120,6 +1124,19 @@ func (hdlr *Handlers) handleDirectMsg(
 		return
 	}
 
+	// If the target is away, send RPL_AWAY to the sender.
+	awayMsg, awayErr := hdlr.params.Database.GetAway(
+		request.Context(), targetSID,
+	)
+	if awayErr == nil && awayMsg != "" {
+		hdlr.enqueueNumeric(
+			request.Context(), clientID,
+			irc.RplAway, nick,
+			[]string{target}, awayMsg,
+		)
+		hdlr.broker.Notify(sessionID)
+	}
+
 	hdlr.respondJSON(writer, request,
 		map[string]string{"id": msgUUID, "status": "sent"},
 		http.StatusOK)
@@ -1230,14 +1247,25 @@ func (hdlr *Handlers) deliverJoinNumerics(
 ) {
 	ctx := request.Context()
 
-	chInfo, err := hdlr.params.Database.GetChannelByName(
-		ctx, channel,
+	hdlr.deliverTopicNumerics(
+		ctx, clientID, sessionID, nick, channel, chID,
 	)
-	if err == nil {
-		_ = chInfo // chInfo is the ID; topic comes from DB.
-	}
 
-	// Get topic from channel info.
+	hdlr.deliverNamesNumerics(
+		ctx, clientID, nick, channel, chID,
+	)
+
+	hdlr.broker.Notify(sessionID)
+}
+
+// deliverTopicNumerics sends RPL_TOPIC or RPL_NOTOPIC,
+// plus RPL_TOPICWHOTIME when topic metadata is available.
+func (hdlr *Handlers) deliverTopicNumerics(
+	ctx context.Context,
+	clientID, sessionID int64,
+	nick, channel string,
+	chID int64,
+) {
 	channels, listErr := hdlr.params.Database.ListChannels(
 		ctx, sessionID,
 	)
@@ -1259,14 +1287,39 @@ func (hdlr *Handlers) deliverJoinNumerics(
 			ctx, clientID, irc.RplTopic, nick,
 			[]string{channel}, topic,
 		)
+
+		topicMeta, tmErr := hdlr.params.Database.
+			GetTopicMeta(ctx, chID)
+		if tmErr == nil && topicMeta != nil {
+			hdlr.enqueueNumeric(
+				ctx, clientID,
+				irc.RplTopicWhoTime, nick,
+				[]string{
+					channel,
+					topicMeta.SetBy,
+					strconv.FormatInt(
+						topicMeta.SetAt.Unix(), 10,
+					),
+				},
+				"",
+			)
+		}
 	} else {
 		hdlr.enqueueNumeric(
 			ctx, clientID, irc.RplNoTopic, nick,
 			[]string{channel}, "No topic is set",
 		)
 	}
+}
 
-	// Get member list for NAMES reply.
+// deliverNamesNumerics sends RPL_NAMREPLY and
+// RPL_ENDOFNAMES for a channel.
+func (hdlr *Handlers) deliverNamesNumerics(
+	ctx context.Context,
+	clientID int64,
+	nick, channel string,
+	chID int64,
+) {
 	members, memErr := hdlr.params.Database.ChannelMembers(
 		ctx, chID,
 	)
@@ -1289,8 +1342,6 @@ func (hdlr *Handlers) deliverJoinNumerics(
 		ctx, clientID, irc.RplEndOfNames, nick,
 		[]string{channel}, "End of /NAMES list",
 	)
-
-	hdlr.broker.Notify(sessionID)
 }
 
 func (hdlr *Handlers) handlePart(
@@ -1574,8 +1625,8 @@ func (hdlr *Handlers) executeTopic(
 	body json.RawMessage,
 	chID int64,
 ) {
-	setErr := hdlr.params.Database.SetTopic(
-		request.Context(), channel, topic,
+	setErr := hdlr.params.Database.SetTopicMeta(
+		request.Context(), channel, topic, nick,
 	)
 	if setErr != nil {
 		hdlr.log.Error(
@@ -1602,6 +1653,25 @@ func (hdlr *Handlers) executeTopic(
 		request.Context(), clientID,
 		irc.RplTopic, nick, []string{channel}, topic,
 	)
+
+	// 333 RPL_TOPICWHOTIME
+	topicMeta, tmErr := hdlr.params.Database.
+		GetTopicMeta(request.Context(), chID)
+	if tmErr == nil && topicMeta != nil {
+		hdlr.enqueueNumeric(
+			request.Context(), clientID,
+			irc.RplTopicWhoTime, nick,
+			[]string{
+				channel,
+				topicMeta.SetBy,
+				strconv.FormatInt(
+					topicMeta.SetAt.Unix(), 10,
+				),
+			},
+			"",
+		)
+	}
+
 	hdlr.broker.Notify(sessionID)
 
 	hdlr.respondJSON(writer, request,
@@ -1991,6 +2061,11 @@ func (hdlr *Handlers) executeWhois(
 		"neoirc server",
 	)
 
+	// 317 RPL_WHOISIDLE
+	hdlr.deliverWhoisIdle(
+		ctx, clientID, nick, queryNick, targetSID,
+	)
+
 	// 319 RPL_WHOISCHANNELS
 	hdlr.deliverWhoisChannels(
 		ctx, clientID, nick, queryNick, targetSID,
@@ -2400,3 +2475,95 @@ func (hdlr *Handlers) HandleServerInfo() http.HandlerFunc {
 		}, http.StatusOK)
 	}
 }
+
+// handleAway handles the AWAY command. An empty body
+// clears the away status; a non-empty body sets it.
+func (hdlr *Handlers) handleAway(
+	writer http.ResponseWriter,
+	request *http.Request,
+	sessionID, clientID int64,
+	nick string,
+	bodyLines func() []string,
+) {
+	ctx := request.Context()
+
+	lines := bodyLines()
+
+	awayMsg := ""
+	if len(lines) > 0 {
+		awayMsg = strings.Join(lines, " ")
+	}
+
+	err := hdlr.params.Database.SetAway(
+		ctx, sessionID, awayMsg,
+	)
+	if err != nil {
+		hdlr.log.Error("set away failed", "error", err)
+		hdlr.respondError(
+			writer, request,
+			"internal error",
+			http.StatusInternalServerError,
+		)
+
+		return
+	}
+
+	if awayMsg == "" {
+		// 305 RPL_UNAWAY
+		hdlr.enqueueNumeric(
+			ctx, clientID, irc.RplUnaway, nick, nil,
+			"You are no longer marked as being away",
+		)
+	} else {
+		// 306 RPL_NOWAWAY
+		hdlr.enqueueNumeric(
+			ctx, clientID, irc.RplNowAway, nick, nil,
+			"You have been marked as being away",
+		)
+	}
+
+	hdlr.broker.Notify(sessionID)
+	hdlr.respondJSON(writer, request,
+		map[string]string{"status": "ok"},
+		http.StatusOK)
+}
+
+// deliverWhoisIdle sends RPL_WHOISIDLE (317) with idle
+// time and signon time.
+func (hdlr *Handlers) deliverWhoisIdle(
+	ctx context.Context,
+	clientID int64,
+	nick, queryNick string,
+	targetSID int64,
+) {
+	lastSeen, lsErr := hdlr.params.Database.
+		GetSessionLastSeen(ctx, targetSID)
+	if lsErr != nil {
+		return
+	}
+
+	createdAt, caErr := hdlr.params.Database.
+		GetSessionCreatedAt(ctx, targetSID)
+	if caErr != nil {
+		return
+	}
+
+	idleSeconds := int64(time.Since(lastSeen).Seconds())
+	if idleSeconds < 0 {
+		idleSeconds = 0
+	}
+
+	signonUnix := strconv.FormatInt(
+		createdAt.Unix(), 10,
+	)
+
+	hdlr.enqueueNumeric(
+		ctx, clientID, irc.RplWhoisIdle, nick,
+		[]string{
+			queryNick,
+			strconv.FormatInt(idleSeconds, 10),
+			signonUnix,
+		},
+		"seconds idle, signon time",
+	)
+}

internal/handlers/api_test.go

@@ -810,9 +810,9 @@ func TestMessageMissingBody(t *testing.T) {
 
 	msgs, _ := tserver.pollMessages(token, lastID)
 
-	if !findNumeric(msgs, "461") {
+	if !findNumeric(msgs, "412") {
 		t.Fatalf(
-			"expected ERR_NEEDMOREPARAMS (461), got %v",
+			"expected ERR_NOTEXTTOSEND (412), got %v",
 			msgs,
 		)
 	}
@@ -834,9 +834,9 @@ func TestMessageMissingTo(t *testing.T) {
 
 	msgs, _ := tserver.pollMessages(token, lastID)
 
-	if !findNumeric(msgs, "461") {
+	if !findNumeric(msgs, "411") {
 		t.Fatalf(
-			"expected ERR_NEEDMOREPARAMS (461), got %v",
+			"expected ERR_NORECIPIENT (411), got %v",
 			msgs,
 		)
 	}
@@ -869,9 +869,9 @@ func TestNonMemberCannotSend(t *testing.T) {
 
 	msgs, _ := tserver.pollMessages(aliceToken, lastID)
 
-	if !findNumeric(msgs, "442") {
+	if !findNumeric(msgs, "404") {
 		t.Fatalf(
-			"expected ERR_NOTONCHANNEL (442), got %v",
+			"expected ERR_CANNOTSENDTOCHAN (404), got %v",
 			msgs,
 		)
 	}

internal/handlers/handlers.go

@@ -31,7 +31,7 @@ type Params struct {
 	Healthcheck *healthcheck.Healthcheck
 }
 
-const defaultIdleTimeout = 24 * time.Hour
+const defaultIdleTimeout = 30 * 24 * time.Hour
 
 // Handlers manages HTTP request handling.
 type Handlers struct {
@@ -200,4 +200,77 @@ func (hdlr *Handlers) runCleanup(
 			"deleted", deleted,
 		)
 	}
+
+	hdlr.pruneQueuesAndMessages(ctx)
+}
+
+// parseDurationConfig parses a Go duration string,
+// returning zero on empty input and logging on error.
+func (hdlr *Handlers) parseDurationConfig(
+	name, raw string,
+) time.Duration {
+	if raw == "" {
+		return 0
+	}
+
+	dur, err := time.ParseDuration(raw)
+	if err != nil {
+		hdlr.log.Error(
+			"invalid duration config, skipping",
+			"name", name, "value", raw, "error", err,
+		)
+
+		return 0
+	}
+
+	return dur
+}
+
+// pruneQueuesAndMessages removes old client output queue
+// entries per QUEUE_MAX_AGE and old messages per
+// MESSAGE_MAX_AGE.
+func (hdlr *Handlers) pruneQueuesAndMessages(
+	ctx context.Context,
+) {
+	queueMaxAge := hdlr.parseDurationConfig(
+		"QUEUE_MAX_AGE",
+		hdlr.params.Config.QueueMaxAge,
+	)
+	if queueMaxAge > 0 {
+		queueCutoff := time.Now().Add(-queueMaxAge)
+
+		pruned, err := hdlr.params.Database.
+			PruneOldQueueEntries(ctx, queueCutoff)
+		if err != nil {
+			hdlr.log.Error(
+				"client output queue pruning failed", "error", err,
+			)
+		} else if pruned > 0 {
+			hdlr.log.Info(
+				"pruned old client output queue entries",
+				"deleted", pruned,
+			)
+		}
+	}
+
+	messageMaxAge := hdlr.parseDurationConfig(
+		"MESSAGE_MAX_AGE",
+		hdlr.params.Config.MessageMaxAge,
+	)
+	if messageMaxAge > 0 {
+		msgCutoff := time.Now().Add(-messageMaxAge)
+
+		pruned, err := hdlr.params.Database.
+			PruneOldMessages(ctx, msgCutoff)
+		if err != nil {
+			hdlr.log.Error(
+				"message pruning failed", "error", err,
+			)
+		} else if pruned > 0 {
+			hdlr.log.Info(
+				"pruned old messages",
+				"deleted", pruned,
+			)
+		}
+	}
 }

internal/irc/commands.go

@@ -2,6 +2,7 @@ package irc
 
 // IRC command names (RFC 1459 / RFC 2812).
 const (
+	CmdAway    = "AWAY"
 	CmdJoin    = "JOIN"
 	CmdList    = "LIST"
 	CmdLusers  = "LUSERS"