Refine moderator voting

[vcarl]

• Slow down resolution timer. Starting at 24hr is too fast, too few votes to get it down to immediate execution.
• Add a second-tier "escalate" that requires a minimum time after escalation, then executes the majority vote.
• Post result as a new message, forward it to #mod-log
  • Disable voting when resolution is executed, but keep buttons.

[vcarl]

Some notes from claude that are useful here, as well. We need to improve the testing story here, is real bad

Extract Pure Business Logic

Make the core voting decisions testable by separating them from Discord I/O.

Handlers become thin adapters that (1) gather data, (2) call pure functions, (3) apply side effects.

Core Interfaces

// ============ Inputs (plain data, no Discord types) ============

interface EscalationContext {
  escalationId: string;
  reportedUserId: string;
  initiatorId: string;
  modRoleId: string;
  quorum: number;
  votingStrategy: VotingStrategy | null;
  createdAt: string;
  isResolved: boolean;
}

interface VoteInput {
  resolution: Resolution;
  voterId: string;
}

// Outputs (discriminated unions for clear handling)

type VoteOutcome =
  | { type: "error"; code: "not_found" | "already_resolved" | "not_mod" }
  | { type: "early_resolution"; resolution: Resolution; tally: VoteTally }
  | { type: "continue_voting"; tally: VoteTally };

interface MessageConfig {
  content: string;
  showExpediteButton: boolean;
  showMajorityButton: boolean;
  disabledResolutions: Resolution[];
}

Core Functions

Function	Input	Output	Behavior
determineVoteOutcome	context, votes, newVote, hasModRole	VoteOutcome	Validates permissions, simulates vote, checks for early resolution
buildMessageConfig	context, tally, isEarlyResolution	MessageConfig	Generates all UI decisions without Discord API calls
determineTimeoutResolution	tally	Resolution	Decides what happens on timeout (plurality or track)

Key Behaviors to Test

determineVoteOutcome:

• Returns error/not_mod when voter lacks role
• Returns error/already_resolved for closed escalations
• Returns early_resolution for simple strategy at quorum
• Returns continue_voting for majority strategy (always)
• Returns continue_voting on tie even at quorum
• Correctly tallies the new vote in returned tally

buildMessageConfig:

• Shows expedite button only when early resolution with clear winner
• Hides majority button when already using majority strategy
• Disables non-tied options during tie-at-quorum
• Generates correct status text per strategy

determineTimeoutResolution:

• Returns track for no votes
• Returns track for tied votes
• Returns leader when clear winner exists

Handler Pattern (After Refactor)

┌─────────────────────────────────────────────────────────────┐
│  Handler (I/O boundary)                                     │
├─────────────────────────────────────────────────────────────┤
│  1. Extract: guildId, escalationId, voterId from interaction│
│  2. Fetch: escalation, settings, votes from DB              │
│  3. Build: EscalationContext from fetched data              │
│  4. Call: determineVoteOutcome(ctx, votes, input, hasMod)   │
│  5. Switch on outcome.type:                                 │
│     - error → interaction.reply(ephemeral)                  │
│     - early_resolution → recordVote + update(confirmed)     │
│     - continue_voting → recordVote + update(voting)         │
└─────────────────────────────────────────────────────────────┘

Possible file changes

File	Action
app/commands/escalate/voting-core.ts	New - Pure functions
app/commands/escalate/voting-core.test.ts	New - Comprehensive tests
app/commands/escalate/handlers.ts	Refactor to use core functions
app/discord/escalationResolver.ts	Use determineTimeoutResolution

---

Solution 2: Time Abstraction

Make time-dependent logic testable without waiting real hours.

Replace Date.now() with an injectable provider; tests swap in a controllable mock.

Core Interface

interface TimeProvider {
  now(): number;        // Epoch milliseconds
  toISOString(): string; // Current time as ISO string
}

// Mock extends with test helpers
interface MockTimeProvider extends TimeProvider {
  setTime(time: Date | string | number): void;
  advanceByHours(hours: number): void;
  advanceByMinutes(minutes: number): void;
}

Module API

// Production use
import { now, nowISO } from "#~/helpers/time.server";

const elapsed = now() - startTime;
const timestamp = nowISO();

// Test use
import {
  createMockTimeProvider,
  setTimeProvider,
  resetTimeProvider
} from "#~/helpers/time.server";

beforeEach(() => {
  setTimeProvider(createMockTimeProvider("2024-01-01T00:00:00Z"));
});

afterEach(() => {
  resetTimeProvider();
});

it("resolves after 36 hours", () => {
  const mock = createMockTimeProvider("2024-01-01T00:00:00Z");
  mock.advanceByHours(36);
  setTimeProvider(mock);

  expect(shouldAutoResolve(createdAt, 1)).toBe(true);
});

Functions That Need Time Provider

Function	Current	After
shouldAutoResolve	Date.now()	now()
getRemainingHours	Date.now()	now()
executeScheduledResolution	new Date()	new Date(now())

Key Test Scenarios

Scenario	Setup	Assertion
Just created	advanceByHours(0)	shouldAutoResolve → false
1 hour before timeout	advanceByHours(35) with 1 vote	shouldAutoResolve → false
Exactly at timeout	advanceByHours(36) with 1 vote	shouldAutoResolve → true
1ms before timeout	setTime(timeout - 1)	shouldAutoResolve → false
Way past timeout	advanceByHours(100)	shouldAutoResolve → true

Possible file changes

File	Action
app/helpers/time.server.ts	New - TimeProvider module
app/helpers/escalationVotes.ts	Replace Date.now() with now()
app/helpers/escalationVotes.test.ts	Rewrite with time mocking
app/discord/escalationResolver.ts	Use now() for timestamps
vitest.config.ts or tests/setup.ts	Add resetTimeProvider() in afterEach