From dedcbd087c1dcad058fe1b2f723c0679f1fad530 Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 20:58:53 +0200
Subject: [PATCH 01/17] docs: design discord monitoring feedback fix

---
 ...discord-7d2d-monitoring-feedback-design.md | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 docs/plans/2026-07-23-discord-7d2d-monitoring-feedback-design.md

diff --git a/docs/plans/2026-07-23-discord-7d2d-monitoring-feedback-design.md b/docs/plans/2026-07-23-discord-7d2d-monitoring-feedback-design.md
new file mode 100644
index 0000000..2fa4332
--- /dev/null
+++ b/docs/plans/2026-07-23-discord-7d2d-monitoring-feedback-design.md
@@ -0,0 +1,48 @@
+# Discord 7D2D Monitoring Feedback Design
+
+## Goal
+
+Make `discord-7d2d-status-bridge` behave honestly and usefully in the user's real setup: monitoring delivery must either reach the configured Discord text channel or explain exactly why Discord rejected it, Blood Moon phase notices should be detected promptly, and an optional private Blood Moon notice should be sent when the first player joins.
+
+## Confirmed failure
+
+The user's `updateStatus` execution successfully reads players, server details, and `gettime`, then receives HTTP 403 from `POST /discord/channels/:id/message`. `bloodMoonMonitor` reports success during ordinary phases because it updates state without sending a Discord message. Existing integration tests use an empty monitoring channel and therefore exercise the skip path rather than outbound Discord delivery.
+
+The module cannot grant Discord permissions or make Takaro's bot join an inaccessible private or archived thread. It can preserve the channel-ID/Takaro-bot flow, expose a direct delivery check, and turn generic 403 failures into actionable diagnostics. Real acceptance still requires a regular Discord text channel that the Takaro bot can view and send to.
+
+## Design
+
+### Discord monitoring delivery
+
+- Keep `monitoringChannelId`; do not introduce webhooks.
+- Add a `discordbridgecheck` command that sends a small test message to the monitoring channel and privately confirms success to the invoking player.
+- Centralize Discord API error classification in the shared helper.
+- For HTTP 403, log and throw an actionable error that names the channel and asks the operator to use a normal text channel and grant the Takaro bot `View Channel`, `Send Messages`, and `Read Message History`. Explicitly call out private or archived threads.
+- Preserve other API errors and include their status/code without leaking credentials.
+- Do not silently fall back to the chat channel, because that would break the requested channel separation.
+
+### Blood Moon timing
+
+- Change `bloodMoonMonitor` from every five minutes to every minute. The cron remains transition-based, so it sends at most once per phase and does not spam.
+- Keep status-message refresh at five minutes to avoid unnecessary player/time/API traffic.
+- Document that interval `1` means every in-game day; detection happens on the first one-minute cron tick after the configured in-game boundary.
+
+### Private first-player notice
+
+- Add `privateBloodMoonNoticeOnFirstJoin`, defaulting to `false` so existing installations do not gain unsolicited private messages.
+- Add an optional `privateBloodMoonTodayMessage` override with English and Polish presets.
+- On `player-connected`, reuse the status helper. If the option is enabled, today is a Blood Moon day, and the joining player is the only online player, send the resolved message with `player.pm`.
+- Discord join monitoring and the private in-game notice remain independent: a Discord delivery failure must still fail visibly, while the private notice uses the game messaging path.
+
+## Testing
+
+- Extend the real Takaro integration suite first and observe failures before implementation.
+- Replace empty-channel false positives for monitoring behavior with assertions that distinguish `skipped` from attempted delivery.
+- Use a configured QA Discord channel for a real send when `TAKARO_DISCORD_TEST_CHANNEL_ID` is present; never fake the Takaro helper or replace source strings.
+- Cover the actionable 403 diagnostic through a real execution log where the environment provides an inaccessible channel.
+- Cover first-player private notice, non-Blood-Moon suppression, and second-player suppression through real Takaro hooks and event/game logs.
+- Run TypeScript build, focused integration tests, export conversion, and mandatory Paper/bot verification. A live 7D2D run is required for precise `gettime`/Blood Moon claims; Paper proves only the game-agnostic join/private-message and Discord delivery paths.
+
+## Delivery boundary
+
+The module fix is complete only when source and real-Takaro tests pass and a real Discord POST succeeds in the QA channel. The affected user's channel can still require a one-time Discord configuration correction if Takaro receives 403 for that specific channel; the new command and error text will identify that directly.

From 6a7320f9a7cf3d19ee515770c85da5db329630b4 Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 20:59:58 +0200
Subject: [PATCH 02/17] docs: refine bridge feedback data flow

---
 .../2026-07-23-discord-7d2d-monitoring-feedback-design.md      | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/docs/plans/2026-07-23-discord-7d2d-monitoring-feedback-design.md b/docs/plans/2026-07-23-discord-7d2d-monitoring-feedback-design.md
index 2fa4332..ee0c14f 100644
--- a/docs/plans/2026-07-23-discord-7d2d-monitoring-feedback-design.md
+++ b/docs/plans/2026-07-23-discord-7d2d-monitoring-feedback-design.md
@@ -15,7 +15,6 @@ The module cannot grant Discord permissions or make Takaro's bot join an inacces
 ### Discord monitoring delivery
 
 - Keep `monitoringChannelId`; do not introduce webhooks.
-- Add a `discordbridgecheck` command that sends a small test message to the monitoring channel and privately confirms success to the invoking player.
 - Centralize Discord API error classification in the shared helper.
 - For HTTP 403, log and throw an actionable error that names the channel and asks the operator to use a normal text channel and grant the Takaro bot `View Channel`, `Send Messages`, and `Read Message History`. Explicitly call out private or archived threads.
 - Preserve other API errors and include their status/code without leaking credentials.
@@ -31,7 +30,7 @@ The module cannot grant Discord permissions or make Takaro's bot join an inacces
 
 - Add `privateBloodMoonNoticeOnFirstJoin`, defaulting to `false` so existing installations do not gain unsolicited private messages.
 - Add an optional `privateBloodMoonTodayMessage` override with English and Polish presets.
-- On `player-connected`, reuse the status helper. If the option is enabled, today is a Blood Moon day, and the joining player is the only online player, send the resolved message with `player.pm`.
+- The one-minute Blood Moon monitor remains the source of truth by persisting its current phase. On `player-connected`, read that phase and query only the online-player list. If the option is enabled, the phase is `today` or `start`, and the joining player is the only online player, send the resolved message with `player.pm`.
 - Discord join monitoring and the private in-game notice remain independent: a Discord delivery failure must still fail visibly, while the private notice uses the game messaging path.
 
 ## Testing

From 293040ebff7cec1394d5f387d73f97eff9ab5e63 Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 21:01:35 +0200
Subject: [PATCH 03/17] docs: plan discord monitoring feedback fix

---
 ...-07-23-discord-7d2d-monitoring-feedback.md | 211 ++++++++++++++++++
 1 file changed, 211 insertions(+)
 create mode 100644 docs/plans/2026-07-23-discord-7d2d-monitoring-feedback.md

diff --git a/docs/plans/2026-07-23-discord-7d2d-monitoring-feedback.md b/docs/plans/2026-07-23-discord-7d2d-monitoring-feedback.md
new file mode 100644
index 0000000..f3654aa
--- /dev/null
+++ b/docs/plans/2026-07-23-discord-7d2d-monitoring-feedback.md
@@ -0,0 +1,211 @@
+# Discord 7D2D Monitoring Feedback Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Make Discord monitoring failures actionable, prove real outbound delivery, detect Blood Moon transitions every minute, and optionally privately notify the first joining player on a Blood Moon day.
+
+**Architecture:** Keep Takaro's channel-ID Discord API and add error normalization in the shared helper. Persist the Blood Moon phase from the one-minute monitor and let the join hook read that phase plus the online-player count, avoiding an extra `gettime` call on every join. All automated coverage continues to import/install/execute through the real Takaro API.
+
+**Tech Stack:** JavaScript Takaro functions, TypeScript Node test runner, `@takaro/apiclient`, Takaro mock game server, Paper bot service, Discord API through Takaro.
+
+---
+
+### Task 1: Establish an honest focused baseline
+
+**Files:**
+- Test: `modules/discord-7d2d-status-bridge/test/bridge.test.ts`
+
+**Step 1: Reuse repository-local runtime configuration**
+
+Link the main checkout's ignored `.env` and installed `node_modules` into the isolated worktree. Do not print credential values.
+
+**Step 2: Build the current branch**
+
+Run: `npm run build`
+
+Expected: TypeScript build succeeds.
+
+**Step 3: Run the current focused integration suite**
+
+Run: `T_WS_CONTINUOUS_RECONNECT=false T_WS_HEARTBEAT_INTERVAL_MS=120000 LOGGING_LEVEL=warn node --test-force-exit --test-concurrency 1 --import=ts-node-maintained/register/esm --test modules/discord-7d2d-status-bridge/test/bridge.test.ts`
+
+Expected: Existing tests pass or any infrastructure failure is recorded before feature work.
+
+### Task 2: Replace Discord skip-path false positives with real delivery evidence
+
+**Files:**
+- Modify: `modules/discord-7d2d-status-bridge/test/bridge.test.ts`
+- Modify: `modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js`
+
+**Step 1: Write the failing real-delivery assertions**
+
+Add an optional `TAKARO_DISCORD_TEST_CHANNEL_ID` test path that installs the disposable module with that monitoring channel, triggers `updateStatus`, and requires both:
+
+```ts
+assertLogContains(logs, `/discord/channels/${channelId}/message 200 OK`);
+assert.ok(!logs.some((message) => message.includes('skipped message:')));
+```
+
+Add a failed-execution helper so a configured inaccessible channel can assert `success: false` and inspect logs rather than failing inside the test harness first.
+
+**Step 2: Run the focused test and verify RED against the reported channel**
+
+Run the focused command with `TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID` set from the user's reported execution context.
+
+Expected: FAIL because the current logs end in generic `403 Forbidden` without actionable channel guidance.
+
+**Step 3: Implement minimal Discord error normalization**
+
+Wrap the real API call in `sendDiscord` and derive `status`, Takaro error code, and Discord error code from the Axios response without logging tokens or headers. For 403, throw an error containing:
+
+```text
+Discord channel <id> is forbidden. Use a normal text channel and grant the Takaro bot View Channel, Send Messages, and Read Message History; private or archived threads may still reject the bot.
+```
+
+Preserve the original error as `cause`. Do not fall back to the chat channel.
+
+Apply the same normalization when updating the persistent message; if update fails, retain the existing replacement-send behavior and emit the normalized reason.
+
+**Step 4: Re-run and verify GREEN**
+
+Expected: the inaccessible-channel execution fails with the actionable diagnostic, and the configured QA channel records a real HTTP 200.
+
+**Step 5: Commit**
+
+```bash
+git add modules/discord-7d2d-status-bridge/test/bridge.test.ts modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
+git commit -m "fix: diagnose Discord monitoring delivery"
+```
+
+### Task 3: Detect Blood Moon phase transitions every minute
+
+**Files:**
+- Modify: `modules/discord-7d2d-status-bridge/test/bridge.test.ts`
+- Modify: `modules/discord-7d2d-status-bridge/module.json`
+
+**Step 1: Write the failing imported-module assertion**
+
+After importing the disposable module, find `bloodMoonMonitor` in `mod.latestVersion.cronJobs` and assert:
+
+```ts
+assert.equal(bloodMoonCron.temporalValue, '* * * * *');
+```
+
+Also assert `updateStatus` remains `*/5 * * * *`.
+
+**Step 2: Run and verify RED**
+
+Expected: FAIL with actual `*/5 * * * *` for `bloodMoonMonitor`.
+
+**Step 3: Implement the schedule change**
+
+Change only `bloodMoonMonitor.temporalValue` to `* * * * *` and update its description to state that phase transitions are checked every minute. Keep state-key duplicate suppression unchanged.
+
+**Step 4: Re-run and verify GREEN**
+
+Expected: schedule assertion passes and existing Blood Moon execution behavior remains green.
+
+**Step 5: Commit**
+
+```bash
+git add modules/discord-7d2d-status-bridge/module.json modules/discord-7d2d-status-bridge/test/bridge.test.ts
+git commit -m "fix: check blood moon phases every minute"
+```
+
+### Task 4: Privately notify the first joining player
+
+**Files:**
+- Modify: `modules/discord-7d2d-status-bridge/test/bridge.test.ts`
+- Modify: `modules/discord-7d2d-status-bridge/module.json`
+- Modify: `modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js`
+- Modify: `modules/discord-7d2d-status-bridge/src/hooks/monitor-join/index.js`
+
+**Step 1: Write failing real-Takaro tests**
+
+Add config-schema assertions for:
+
+```json
+"privateBloodMoonNoticeOnFirstJoin": { "type": "boolean", "default": false }
+"privateBloodMoonTodayMessage": { "type": "string", "maxLength": 500, "default": "" }
+```
+
+Using a one-player disposable mock server and a real Takaro variable record with key `discord7d2d:bloodState` and JSON value `"today:7"`, trigger `player-connected` with the option enabled. Require a successful `/gameserver/:id/message` call and a diagnostic log containing the resolved private message.
+
+Add negative executions for:
+
+- option disabled;
+- phase `normal:6`;
+- more than one online player.
+
+Require no private-message diagnostic in all negative cases.
+
+**Step 2: Run and verify RED**
+
+Expected: schema fields and private notice logs are absent.
+
+**Step 3: Add config and localized messages**
+
+Add English preset `Blood Moon is today.` and Polish preset `Dzisiaj będzie Krwawy Księżyc.` under `privateBloodMoonTodayMessage`. Allow a non-empty user override via existing `resolveMessage` behavior.
+
+**Step 4: Implement the join data flow**
+
+In `monitorJoin`:
+
+1. Keep existing Discord join monitoring.
+2. Return from private-notice logic unless the new option is true and `player` exists.
+3. Read `BLOOD_STATE_KEY` through the real variable API.
+4. Continue only for phase strings beginning `today:` or `start:`.
+5. Call `getOnlinePlayers(gameServerId)` and continue only when `onlinePlayers === 1`.
+6. Send `resolveMessage(config, 'privateBloodMoonTodayMessage')` with `player.pm`.
+7. Log a stable success marker after the API call for integration evidence.
+
+The Discord send and private game send must be independent. A missing monitoring channel remains a skip, while a configured-but-forbidden Discord channel remains a visible failure.
+
+**Step 5: Run and verify GREEN**
+
+Expected: positive English, Polish/override, and all suppression cases pass through real Takaro executions.
+
+**Step 6: Commit**
+
+```bash
+git add modules/discord-7d2d-status-bridge/module.json modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js modules/discord-7d2d-status-bridge/src/hooks/monitor-join/index.js modules/discord-7d2d-status-bridge/test/bridge.test.ts
+git commit -m "feat: notify first player of blood moon day"
+```
+
+### Task 5: Verify export, Takaro, Discord, and game boundaries
+
+**Files:**
+- Verify: `modules/discord-7d2d-status-bridge/**`
+
+**Step 1: Run static verification**
+
+```bash
+npm run build
+npm run typecheck
+node --check modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
+node --check modules/discord-7d2d-status-bridge/src/hooks/monitor-join/index.js
+node dist/scripts/module-to-json.js modules/discord-7d2d-status-bridge /tmp/discord-7d2d-status-bridge-feedback.json
+git diff --check origin/main...HEAD
+```
+
+Expected: all commands succeed; the export retains the canonical name and a non-empty description.
+
+**Step 2: Run the complete focused integration suite**
+
+Run the Task 1 focused command with the designated QA Discord channel.
+
+Expected: all focused tests pass, a real Discord POST returns 200, and no outbound assertion is satisfied by `skipped message`.
+
+**Step 3: Run mandatory Paper/bot verification**
+
+Start `paper`, `bot`, and `redis`; use the actual `BOT_PORT` from `.env` without printing secrets. Install a disposable supported-games-neutral export, connect one bot, seed a real phase variable, trigger the join hook, and verify the private message through both the Takaro execution event and bot-visible game output.
+
+Expected: the bot receives the private Blood Moon message and the hook event is successful. State clearly that Paper does not prove 7D2D `gettime` parsing.
+
+**Step 4: Run 7D2D live proof when the active lane is reachable**
+
+Install the disposable module on the designated QA 7D2D server, trigger/observe a phase boundary, and verify the one-minute cron plus Discord delivery. Do not claim precise 7D2D acceptance without this evidence.
+
+**Step 5: Review and commit any verification-only documentation**
+
+Keep runtime artifacts and temporary exports outside the repository. Confirm `git status --short` contains only intended source/test/design files.

From 30466dc802b4695f836ee39d15bb5fc00d0de604 Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 21:07:35 +0200
Subject: [PATCH 04/17] test: isolate bridge integration resources

---
 modules/discord-7d2d-status-bridge/test/bridge.test.ts | 4 ++--
 test/helpers/mock-server.ts                            | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/modules/discord-7d2d-status-bridge/test/bridge.test.ts b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
index 91889fd..684895b 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -26,7 +26,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const MODULE_DIR = path.resolve(__dirname, '..');
 const MODULE_TO_JSON_SCRIPT = path.resolve(__dirname, '..', '..', '..', 'dist', 'scripts', 'module-to-json.js');
-const TEST_MODULE_NAME = `test-discord-7d2d-status-bridge-${process.pid}`;
+const TEST_MODULE_NAME = `qa-discord-7d2d-status-bridge-${process.pid}`;
 
 interface WaitForBridgeEventOptions {
   eventName: EventSearchInputAllowedFiltersEventNameEnum;
@@ -197,7 +197,7 @@ describe('discord-7d2d-status-bridge integration', () => {
     client = await createClient();
     await cleanupTestModules(client);
     await cleanupTestGameServers(client);
-    ctx = await startMockServer(client);
+    ctx = await startMockServer(client, { serverNamePrefix: 'qa-discord-bridge-' });
     mod = await pushDisposableBridgeModule(client);
     playerNames = await Promise.all(ctx.players.map(async (playerOnGameserver) => {
       const player = await client.player.playerControllerGetOne(playerOnGameserver.playerId);
diff --git a/test/helpers/mock-server.ts b/test/helpers/mock-server.ts
index 73602c0..cf332a8 100644
--- a/test/helpers/mock-server.ts
+++ b/test/helpers/mock-server.ts
@@ -35,6 +35,7 @@ async function retry<T>(fn: () => Promise<T>, maxAttempts: number, delayMs: numb
 
 export interface StartMockServerOptions {
   totalPlayers?: number;
+  serverNamePrefix?: string;
 }
 
 export async function startMockServer(
@@ -57,7 +58,7 @@ export async function startMockServer(
     mockserver: {
       registrationToken,
       identityToken,
-      name: `test-server-${identityToken}`,
+      name: `${options.serverNamePrefix ?? 'test-server-'}${identityToken}`,
     },
     ws: {
       url: wsUrl,

From f33509457b9bef8b7d3ffc47be91374945b2312e Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 21:17:02 +0200
Subject: [PATCH 05/17] fix: diagnose Discord monitoring delivery

---
 .../functions/discord-7d2d-status-helpers.js  | 39 +++++++++++-
 .../test/bridge.test.ts                       | 60 ++++++++++++++++++-
 2 files changed, 94 insertions(+), 5 deletions(-)

diff --git a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
index ea9894d..b4a58f4 100644
--- a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
+++ b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
@@ -189,13 +189,47 @@ export function getDiscordChannelFromHook(data, configuredChannelId, hookName) {
   return data?.module?.systemConfig?.hooks?.[hookName]?.discordChannelId || data?.discordChannelId || data?.eventData?.discordChannelId || data?.eventData?.channelId || '';
 }
 
+function discordErrorStatus(err) {
+  const status = err?.response?.status ?? err?.status;
+  return Number.isInteger(status) ? status : null;
+}
+
+function errorWithCause(message, cause) {
+  try {
+    return new Error(message, { cause });
+  } catch (_err) {
+    return new Error(message);
+  }
+}
+
+export function normalizeDiscordError(channelId, err) {
+  const status = discordErrorStatus(err);
+  const guidance = 'use a normal text channel and grant the Takaro bot View Channel, Send Messages, and Read Message History; private or archived threads may still reject the bot.';
+  if (status === 403) {
+    return errorWithCause(`Discord delivery to channel ${channelId} was forbidden (HTTP 403): ${guidance}`, err);
+  }
+  if (status === 404) {
+    return errorWithCause(`Discord channel ${channelId} was not found or is unavailable to the Takaro bot (HTTP 404): ${guidance}`, err);
+  }
+
+  const reason = err instanceof Error && err.message
+    ? err.message
+    : (typeof err === 'string' && err ? err : 'Unknown error');
+  const statusText = status === null ? '' : ` (HTTP ${status})`;
+  return errorWithCause(`Discord delivery to channel ${channelId} failed${statusText}: ${reason}`, err);
+}
+
 export async function sendDiscord(channelId, message) {
   const safeMessage = sanitizeDiscordMessage(message);
   if (!channelId) {
     console.log(`discord-7d2d-status: no Discord channel configured, skipped message: ${safeMessage}`);
     return null;
   }
-  return takaro.discord.discordControllerSendMessage(channelId, { message: safeMessage });
+  try {
+    return await takaro.discord.discordControllerSendMessage(channelId, { message: safeMessage });
+  } catch (err) {
+    throw normalizeDiscordError(channelId, err);
+  }
 }
 
 export function sanitizeDiscordMessage(message) {
@@ -231,7 +265,8 @@ export async function updatePersistentDiscordMessage(gameServerId, moduleId, cha
       await takaro.discord.discordControllerUpdateMessage(channelId, existingId, { message: safeMessage });
       return existingId;
     } catch (err) {
-      console.error(`discord-7d2d-status: failed to update Discord status message ${existingId}, sending replacement: ${err}`);
+      const reason = normalizeDiscordError(channelId, err);
+      console.error(`discord-7d2d-status: failed to update Discord status message ${existingId}, sending replacement: ${reason.message}`);
     }
   }
   const sent = await sendDiscord(channelId, safeMessage);
diff --git a/modules/discord-7d2d-status-bridge/test/bridge.test.ts b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
index 684895b..cdaef5f 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -27,6 +27,13 @@ const __dirname = path.dirname(__filename);
 const MODULE_DIR = path.resolve(__dirname, '..');
 const MODULE_TO_JSON_SCRIPT = path.resolve(__dirname, '..', '..', '..', 'dist', 'scripts', 'module-to-json.js');
 const TEST_MODULE_NAME = `qa-discord-7d2d-status-bridge-${process.pid}`;
+const DISCORD_TEST_CHANNEL_ID = process.env.TAKARO_DISCORD_TEST_CHANNEL_ID?.trim();
+const DISCORD_FORBIDDEN_CHANNEL_ID = process.env.TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID?.trim();
+
+interface BridgeExecutionResult {
+  success: boolean;
+  logs: string[];
+}
 
 interface WaitForBridgeEventOptions {
   eventName: EventSearchInputAllowedFiltersEventNameEnum;
@@ -153,7 +160,7 @@ describe('discord-7d2d-status-bridge integration', () => {
     return logs;
   }
 
-  async function triggerCronjob(name: string): Promise<string[]> {
+  async function triggerCronjobExecution(name: string): Promise<BridgeExecutionResult> {
     const cronjob = mod.latestVersion.cronJobs.find((candidate) => candidate.name === name);
     assert.ok(cronjob, `Expected cronjob '${name}' to exist`);
     const beforeTrigger = new Date();
@@ -170,8 +177,13 @@ describe('discord-7d2d-status-bridge integration', () => {
     });
     const result = (event.meta as { result?: { success?: boolean; logs?: Array<{ msg: string }> } }).result;
     const logs = (result?.logs ?? []).map((entry) => entry.msg);
-    assert.equal(result?.success, true, `Expected cronjob '${name}' to succeed, logs: ${JSON.stringify(logs)}`);
-    return logs;
+    return { success: result?.success ?? false, logs };
+  }
+
+  async function triggerCronjob(name: string): Promise<string[]> {
+    const execution = await triggerCronjobExecution(name);
+    assert.equal(execution.success, true, `Expected cronjob '${name}' to succeed, logs: ${JSON.stringify(execution.logs)}`);
+    return execution.logs;
   }
 
   async function waitForOnlineCount(expected: number) {
@@ -351,6 +363,48 @@ describe('discord-7d2d-status-bridge integration', () => {
     assertLogContains(logs, `Players:\n${expectedPlayers.join('\n')}`);
   });
 
+  it('delivers a status message through the real Takaro Discord API', {
+    skip: DISCORD_TEST_CHANNEL_ID ? false : 'Set TAKARO_DISCORD_TEST_CHANNEL_ID to run real Discord delivery coverage',
+  }, async () => {
+    assert.ok(DISCORD_TEST_CHANNEL_ID);
+    await installWithConfig({
+      monitoringChannelId: DISCORD_TEST_CHANNEL_ID,
+      updateStatusMessage: false,
+    });
+
+    const execution = await triggerCronjobExecution('updateStatus');
+
+    assert.equal(execution.success, true, `Expected Discord delivery to succeed, logs: ${JSON.stringify(execution.logs)}`);
+    assert.ok(
+      !execution.logs.some((message) => message.includes('skipped message:')),
+      `A skipped message is not Discord delivery evidence: ${JSON.stringify(execution.logs)}`,
+    );
+    assertLogContains(execution.logs, `/discord/channels/${DISCORD_TEST_CHANNEL_ID}/message 200 OK`);
+  });
+
+  it('explains how to fix a forbidden Discord monitoring channel', {
+    skip: DISCORD_FORBIDDEN_CHANNEL_ID ? false : 'Set TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID to run forbidden-channel coverage',
+  }, async () => {
+    assert.ok(DISCORD_FORBIDDEN_CHANNEL_ID);
+    await installWithConfig({
+      monitoringChannelId: DISCORD_FORBIDDEN_CHANNEL_ID,
+      updateStatusMessage: false,
+    });
+
+    const execution = await triggerCronjobExecution('updateStatus');
+
+    assert.equal(execution.success, false, `Expected Discord delivery to fail, logs: ${JSON.stringify(execution.logs)}`);
+    const diagnostic = execution.logs.find((message) => (
+      message.includes(DISCORD_FORBIDDEN_CHANNEL_ID) && message.includes('normal text channel')
+    ));
+    assert.ok(diagnostic, `Expected an actionable diagnostic naming the forbidden channel, logs: ${JSON.stringify(execution.logs)}`);
+    assert.match(diagnostic, /normal text channel/);
+    assert.match(diagnostic, /View Channel/);
+    assert.match(diagnostic, /Send Messages/);
+    assert.match(diagnostic, /Read Message History/);
+    assert.match(diagnostic, /private or archived threads may still reject the bot/);
+  });
+
   it('uses localized or overridden empty-player-list text', async () => {
     await ctx.server.executeConsoleCommand('disconnectAll');
     await waitForOnlineCount(0);

From 432d1371b227b900c4fb38ff34c5ba4a98e1bcb4 Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 21:37:36 +0200
Subject: [PATCH 06/17] fix: harden Discord delivery failures

---
 .../functions/discord-7d2d-status-helpers.js  | 61 ++++++++++++++---
 .../test/bridge.test.ts                       | 67 +++++++++++++++++--
 2 files changed, 114 insertions(+), 14 deletions(-)

diff --git a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
index b4a58f4..69abfcf 100644
--- a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
+++ b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
@@ -194,9 +194,44 @@ function discordErrorStatus(err) {
   return Number.isInteger(status) ? status : null;
 }
 
-function errorWithCause(message, cause) {
+function safeIdentifier(value) {
+  return typeof value === 'string' && /^[A-Za-z0-9_-]{1,64}$/.test(value) ? value : null;
+}
+
+function discordApiError(err) {
+  const value = err?.response?.data?.meta?.error;
+  return value && typeof value === 'object' ? value : null;
+}
+
+function discordErrorCode(err) {
+  const apiError = discordApiError(err);
+  if (!apiError) return null;
+  for (const value of [apiError.code, apiError.message, apiError.details]) {
+    if (Number.isInteger(value) && value >= 1000) return value;
+    if (typeof value !== 'string') continue;
+    if (/^\d{4,6}$/.test(value)) return Number(value);
+    const match = value.match(/(?:DiscordAPIError|discord(?:\s+error)?\s+code|["']?code["']?)[^0-9]{0,16}(\d{4,6})/i);
+    if (match) return Number(match[1]);
+  }
+  return null;
+}
+
+function safeDiscordCause(err) {
+  const details = [];
+  const status = discordErrorStatus(err);
+  const discordCode = discordErrorCode(err);
+  const takaroCode = safeIdentifier(discordApiError(err)?.code);
+  const requestCode = safeIdentifier(err?.code);
+  if (status !== null) details.push(`HTTP ${status}`);
+  if (discordCode !== null) details.push(`Discord code ${discordCode}`);
+  if (takaroCode && !/^\d+$/.test(takaroCode)) details.push(`Takaro code ${takaroCode}`);
+  if (requestCode) details.push(`request code ${requestCode}`);
+  return new Error(details.length > 0 ? `Discord request failed (${details.join(', ')})` : 'Discord request failed');
+}
+
+function errorWithSafeCause(message, err) {
   try {
-    return new Error(message, { cause });
+    return new Error(message, { cause: safeDiscordCause(err) });
   } catch (_err) {
     return new Error(message);
   }
@@ -204,19 +239,24 @@ function errorWithCause(message, cause) {
 
 export function normalizeDiscordError(channelId, err) {
   const status = discordErrorStatus(err);
-  const guidance = 'use a normal text channel and grant the Takaro bot View Channel, Send Messages, and Read Message History; private or archived threads may still reject the bot.';
+  const discordCode = discordErrorCode(err);
+  const codeText = discordCode === null ? '' : `, Discord code ${discordCode}`;
+  const guidance = 'verify the Discord guild is enabled and authorized in Takaro; use a normal text channel and grant the Takaro bot View Channel, Send Messages, and Read Message History; private or archived threads may still reject the bot.';
   if (status === 403) {
-    return errorWithCause(`Discord delivery to channel ${channelId} was forbidden (HTTP 403): ${guidance}`, err);
+    return errorWithSafeCause(`Takaro or Discord refused delivery to channel ${channelId} (HTTP 403${codeText}): ${guidance}`, err);
   }
   if (status === 404) {
-    return errorWithCause(`Discord channel ${channelId} was not found or is unavailable to the Takaro bot (HTTP 404): ${guidance}`, err);
+    return errorWithSafeCause(`Discord channel ${channelId} was not found or is unavailable to the Takaro bot (HTTP 404${codeText}): ${guidance}`, err);
   }
 
-  const reason = err instanceof Error && err.message
-    ? err.message
-    : (typeof err === 'string' && err ? err : 'Unknown error');
   const statusText = status === null ? '' : ` (HTTP ${status})`;
-  return errorWithCause(`Discord delivery to channel ${channelId} failed${statusText}: ${reason}`, err);
+  const requestCode = safeIdentifier(err?.code);
+  const reason = requestCode ? `: request code ${requestCode}` : '';
+  return errorWithSafeCause(`Discord delivery to channel ${channelId} failed${statusText}${reason}`, err);
+}
+
+function isMissingDiscordMessage(err) {
+  return discordErrorStatus(err) === 404 || discordErrorCode(err) === 10008;
 }
 
 export async function sendDiscord(channelId, message) {
@@ -266,7 +306,8 @@ export async function updatePersistentDiscordMessage(gameServerId, moduleId, cha
       return existingId;
     } catch (err) {
       const reason = normalizeDiscordError(channelId, err);
-      console.error(`discord-7d2d-status: failed to update Discord status message ${existingId}, sending replacement: ${reason.message}`);
+      if (!isMissingDiscordMessage(err)) throw reason;
+      console.error(`discord-7d2d-status: prior Discord status message ${existingId} is missing, sending replacement: ${reason.message}`);
     }
   }
   const sent = await sendDiscord(channelId, safeMessage);
diff --git a/modules/discord-7d2d-status-bridge/test/bridge.test.ts b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
index cdaef5f..4796086 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -29,6 +29,9 @@ const MODULE_TO_JSON_SCRIPT = path.resolve(__dirname, '..', '..', '..', 'dist',
 const TEST_MODULE_NAME = `qa-discord-7d2d-status-bridge-${process.pid}`;
 const DISCORD_TEST_CHANNEL_ID = process.env.TAKARO_DISCORD_TEST_CHANNEL_ID?.trim();
 const DISCORD_FORBIDDEN_CHANNEL_ID = process.env.TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID?.trim();
+if (DISCORD_TEST_CHANNEL_ID && DISCORD_FORBIDDEN_CHANNEL_ID && DISCORD_TEST_CHANNEL_ID === DISCORD_FORBIDDEN_CHANNEL_ID) {
+  throw new Error('Live Discord smoke gates require distinct accessible and forbidden channel IDs');
+}
 
 interface BridgeExecutionResult {
   success: boolean;
@@ -110,6 +113,24 @@ async function pushDisposableBridgeModule(client: Client): Promise<ModuleOutputD
   }
 }
 
+async function setModuleVariable(
+  client: Client,
+  gameServerId: string,
+  moduleId: string,
+  key: string,
+  value: unknown,
+) {
+  const serialized = JSON.stringify(value);
+  const existing = await client.variable.variableControllerSearch({
+    filters: { key: [key], gameServerId: [gameServerId], moduleId: [moduleId] },
+  });
+  if (existing.data.data[0]) {
+    await client.variable.variableControllerUpdate(existing.data.data[0].id, { value: serialized });
+  } else {
+    await client.variable.variableControllerCreate({ key, value: serialized, gameServerId, moduleId });
+  }
+}
+
 describe('discord-7d2d-status-bridge integration', () => {
   let client: Client;
   let ctx: MockServerContext;
@@ -174,6 +195,9 @@ describe('discord-7d2d-status-bridge integration', () => {
       gameserverId: ctx.gameServer.id,
       moduleId: mod.id,
       after: beforeTrigger,
+      predicate: (candidate) => (
+        (candidate.meta as { cronjob?: { id?: string } }).cronjob?.id === cronjob.id
+      ),
     });
     const result = (event.meta as { result?: { success?: boolean; logs?: Array<{ msg: string }> } }).result;
     const logs = (result?.logs ?? []).map((entry) => entry.msg);
@@ -363,8 +387,8 @@ describe('discord-7d2d-status-bridge integration', () => {
     assertLogContains(logs, `Players:\n${expectedPlayers.join('\n')}`);
   });
 
-  it('delivers a status message through the real Takaro Discord API', {
-    skip: DISCORD_TEST_CHANNEL_ID ? false : 'Set TAKARO_DISCORD_TEST_CHANNEL_ID to run real Discord delivery coverage',
+  it('[live smoke] delivers a status message through the real Takaro Discord API', {
+    skip: DISCORD_TEST_CHANNEL_ID ? false : 'Live smoke gate skipped: set TAKARO_DISCORD_TEST_CHANNEL_ID',
   }, async () => {
     assert.ok(DISCORD_TEST_CHANNEL_ID);
     await installWithConfig({
@@ -382,8 +406,8 @@ describe('discord-7d2d-status-bridge integration', () => {
     assertLogContains(execution.logs, `/discord/channels/${DISCORD_TEST_CHANNEL_ID}/message 200 OK`);
   });
 
-  it('explains how to fix a forbidden Discord monitoring channel', {
-    skip: DISCORD_FORBIDDEN_CHANNEL_ID ? false : 'Set TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID to run forbidden-channel coverage',
+  it('[live smoke] explains both Takaro and Discord authorization for a forbidden monitoring channel', {
+    skip: DISCORD_FORBIDDEN_CHANNEL_ID ? false : 'Live smoke gate skipped: set TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID',
   }, async () => {
     assert.ok(DISCORD_FORBIDDEN_CHANNEL_ID);
     await installWithConfig({
@@ -399,12 +423,47 @@ describe('discord-7d2d-status-bridge integration', () => {
     ));
     assert.ok(diagnostic, `Expected an actionable diagnostic naming the forbidden channel, logs: ${JSON.stringify(execution.logs)}`);
     assert.match(diagnostic, /normal text channel/);
+    assert.match(diagnostic, /Takaro or Discord/);
+    assert.match(diagnostic, /guild is enabled and authorized in Takaro/);
     assert.match(diagnostic, /View Channel/);
     assert.match(diagnostic, /Send Messages/);
     assert.match(diagnostic, /Read Message History/);
     assert.match(diagnostic, /private or archived threads may still reject the bot/);
   });
 
+  it('[live smoke] does not replace a persistent status message when its update is forbidden', {
+    skip: DISCORD_FORBIDDEN_CHANNEL_ID ? false : 'Live smoke gate skipped: set TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID',
+  }, async () => {
+    assert.ok(DISCORD_FORBIDDEN_CHANNEL_ID);
+    const previousMessageId = '999999999999999999';
+    await installWithConfig({ monitoringChannelId: DISCORD_FORBIDDEN_CHANNEL_ID });
+    await setModuleVariable(
+      client,
+      ctx.gameServer.id,
+      mod.id,
+      `discord7d2d:statusMessage:${DISCORD_FORBIDDEN_CHANNEL_ID}`,
+      previousMessageId,
+    );
+
+    const execution = await triggerCronjobExecution('updateStatus');
+
+    assert.equal(execution.success, false, `Expected Discord update to fail, logs: ${JSON.stringify(execution.logs)}`);
+    assertLogContains(
+      execution.logs,
+      `/discord/channels/${DISCORD_FORBIDDEN_CHANNEL_ID}/messages/${previousMessageId}`,
+    );
+    assert.equal(
+      execution.logs.filter((message) => (
+        message.includes(`POST /discord/channels/${DISCORD_FORBIDDEN_CHANNEL_ID}/message`)
+      )).length,
+      0,
+      `A forbidden update must not send a replacement message: ${JSON.stringify(execution.logs)}`,
+    );
+    const diagnostic = execution.logs.find((message) => message.includes('Takaro or Discord'));
+    assert.ok(diagnostic, `Expected an authorization-layer diagnostic, logs: ${JSON.stringify(execution.logs)}`);
+    assert.match(diagnostic, /guild is enabled and authorized in Takaro/);
+  });
+
   it('uses localized or overridden empty-player-list text', async () => {
     await ctx.server.executeConsoleCommand('disconnectAll');
     await waitForOnlineCount(0);

From 53ce6fb218d65ba6de641457313fcb43935e10ec Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 21:46:32 +0200
Subject: [PATCH 07/17] fix: replace only unknown Discord messages

---
 .../functions/discord-7d2d-status-helpers.js  | 12 +++--
 .../test/bridge.test.ts                       | 44 ++++++++++++++++++-
 2 files changed, 50 insertions(+), 6 deletions(-)

diff --git a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
index 69abfcf..64d85f7 100644
--- a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
+++ b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
@@ -242,11 +242,15 @@ export function normalizeDiscordError(channelId, err) {
   const discordCode = discordErrorCode(err);
   const codeText = discordCode === null ? '' : `, Discord code ${discordCode}`;
   const guidance = 'verify the Discord guild is enabled and authorized in Takaro; use a normal text channel and grant the Takaro bot View Channel, Send Messages, and Read Message History; private or archived threads may still reject the bot.';
+  if (discordCode === 10008) {
+    const errorDetails = status === null ? 'Discord code 10008' : `HTTP ${status}, Discord code 10008`;
+    return errorWithSafeCause(`Discord reported Unknown Message for the prior status message in channel ${channelId} (${errorDetails}): the previous status message no longer exists.`, err);
+  }
   if (status === 403) {
     return errorWithSafeCause(`Takaro or Discord refused delivery to channel ${channelId} (HTTP 403${codeText}): ${guidance}`, err);
   }
   if (status === 404) {
-    return errorWithSafeCause(`Discord channel ${channelId} was not found or is unavailable to the Takaro bot (HTTP 404${codeText}): ${guidance}`, err);
+    return errorWithSafeCause(`Discord channel ${channelId} or its guild was not found or is unavailable to the Takaro bot (HTTP 404${codeText}): ${guidance}`, err);
   }
 
   const statusText = status === null ? '' : ` (HTTP ${status})`;
@@ -255,8 +259,8 @@ export function normalizeDiscordError(channelId, err) {
   return errorWithSafeCause(`Discord delivery to channel ${channelId} failed${statusText}${reason}`, err);
 }
 
-function isMissingDiscordMessage(err) {
-  return discordErrorStatus(err) === 404 || discordErrorCode(err) === 10008;
+function shouldReplaceMissingMessage(err) {
+  return discordErrorCode(err) === 10008;
 }
 
 export async function sendDiscord(channelId, message) {
@@ -306,7 +310,7 @@ export async function updatePersistentDiscordMessage(gameServerId, moduleId, cha
       return existingId;
     } catch (err) {
       const reason = normalizeDiscordError(channelId, err);
-      if (!isMissingDiscordMessage(err)) throw reason;
+      if (!shouldReplaceMissingMessage(err)) throw reason;
       console.error(`discord-7d2d-status: prior Discord status message ${existingId} is missing, sending replacement: ${reason.message}`);
     }
   }
diff --git a/modules/discord-7d2d-status-bridge/test/bridge.test.ts b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
index 4796086..358af32 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -29,8 +29,11 @@ const MODULE_TO_JSON_SCRIPT = path.resolve(__dirname, '..', '..', '..', 'dist',
 const TEST_MODULE_NAME = `qa-discord-7d2d-status-bridge-${process.pid}`;
 const DISCORD_TEST_CHANNEL_ID = process.env.TAKARO_DISCORD_TEST_CHANNEL_ID?.trim();
 const DISCORD_FORBIDDEN_CHANNEL_ID = process.env.TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID?.trim();
-if (DISCORD_TEST_CHANNEL_ID && DISCORD_FORBIDDEN_CHANNEL_ID && DISCORD_TEST_CHANNEL_ID === DISCORD_FORBIDDEN_CHANNEL_ID) {
-  throw new Error('Live Discord smoke gates require distinct accessible and forbidden channel IDs');
+const DISCORD_NOT_FOUND_CHANNEL_ID = process.env.TAKARO_DISCORD_NOT_FOUND_CHANNEL_ID?.trim();
+const LIVE_DISCORD_CHANNEL_IDS = [DISCORD_TEST_CHANNEL_ID, DISCORD_FORBIDDEN_CHANNEL_ID, DISCORD_NOT_FOUND_CHANNEL_ID]
+  .filter((channelId): channelId is string => Boolean(channelId));
+if (new Set(LIVE_DISCORD_CHANNEL_IDS).size !== LIVE_DISCORD_CHANNEL_IDS.length) {
+  throw new Error('Live Discord smoke gates require distinct channel IDs');
 }
 
 interface BridgeExecutionResult {
@@ -464,6 +467,43 @@ describe('discord-7d2d-status-bridge integration', () => {
     assert.match(diagnostic, /guild is enabled and authorized in Takaro/);
   });
 
+  it('[live smoke] does not replace a persistent status message for a generic channel 404', {
+    skip: DISCORD_NOT_FOUND_CHANNEL_ID ? false : 'Live smoke gate skipped: set TAKARO_DISCORD_NOT_FOUND_CHANNEL_ID',
+  }, async () => {
+    assert.ok(DISCORD_NOT_FOUND_CHANNEL_ID);
+    const previousMessageId = '888888888888888888';
+    await installWithConfig({ monitoringChannelId: DISCORD_NOT_FOUND_CHANNEL_ID });
+    await setModuleVariable(
+      client,
+      ctx.gameServer.id,
+      mod.id,
+      `discord7d2d:statusMessage:${DISCORD_NOT_FOUND_CHANNEL_ID}`,
+      previousMessageId,
+    );
+
+    const execution = await triggerCronjobExecution('updateStatus');
+
+    assert.equal(execution.success, false, `Expected Discord update to fail, logs: ${JSON.stringify(execution.logs)}`);
+    assertLogContains(execution.logs, 'HTTP 404');
+    assert.equal(
+      execution.logs.filter((message) => (
+        message.includes(`POST /discord/channels/${DISCORD_NOT_FOUND_CHANNEL_ID}/message`)
+      )).length,
+      0,
+      `A generic channel 404 must not send a replacement message: ${JSON.stringify(execution.logs)}`,
+    );
+    assert.ok(
+      !execution.logs.some((message) => message.includes('prior Discord status message') && message.includes('is missing')),
+      `A generic channel 404 must not be described as a missing prior message: ${JSON.stringify(execution.logs)}`,
+    );
+    const diagnostic = execution.logs.find((message) => (
+      message.includes(`channel ${DISCORD_NOT_FOUND_CHANNEL_ID} or its guild`)
+    ));
+    assert.ok(diagnostic, `Expected a channel-or-guild 404 diagnostic, logs: ${JSON.stringify(execution.logs)}`);
+    assert.match(diagnostic, /not found or is unavailable/);
+    assert.doesNotMatch(diagnostic, /Unknown Message/);
+  });
+
   it('uses localized or overridden empty-player-list text', async () => {
     await ctx.server.executeConsoleCommand('disconnectAll');
     await waitForOnlineCount(0);

From 6a828be16f8178c14ef0dfb292a393ce745af616 Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 21:51:57 +0200
Subject: [PATCH 08/17] fix: check blood moon phases every minute

---
 modules/discord-7d2d-status-bridge/module.json         | 2 +-
 modules/discord-7d2d-status-bridge/test/bridge.test.ts | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/modules/discord-7d2d-status-bridge/module.json b/modules/discord-7d2d-status-bridge/module.json
index af3ca2a..f69ea27 100644
--- a/modules/discord-7d2d-status-bridge/module.json
+++ b/modules/discord-7d2d-status-bridge/module.json
@@ -58,7 +58,7 @@
   },
   "cronJobs": {
     "updateStatus": { "temporalValue": "*/5 * * * *", "description": "Updates the persistent Discord server status message.", "function": "src/cronjobs/update-status/index.js" },
-    "bloodMoonMonitor": { "temporalValue": "*/5 * * * *", "description": "Checks 7D2D time and sends blood moon day/start/end notices.", "function": "src/cronjobs/blood-moon-monitor/index.js" }
+    "bloodMoonMonitor": { "temporalValue": "* * * * *", "description": "Checks 7D2D phase transitions every minute and sends blood moon day/start/end notices.", "function": "src/cronjobs/blood-moon-monitor/index.js" }
   },
   "functions": {
     "discord-7d2d-status-helpers": { "function": "src/functions/discord-7d2d-status-helpers.js" }
diff --git a/modules/discord-7d2d-status-bridge/test/bridge.test.ts b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
index 358af32..b3f5cea 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -273,6 +273,14 @@ describe('discord-7d2d-status-bridge integration', () => {
     assert.ok(logs.length > 0);
   });
 
+  it('checks blood moon transitions every minute without changing status updates', () => {
+    const bloodMoonMonitor = mod.latestVersion.cronJobs.find((cronjob) => cronjob.name === 'bloodMoonMonitor');
+    const updateStatus = mod.latestVersion.cronJobs.find((cronjob) => cronjob.name === 'updateStatus');
+
+    assert.equal(bloodMoonMonitor?.temporalValue, '* * * * *');
+    assert.equal(updateStatus?.temporalValue, '*/5 * * * *');
+  });
+
   it('uses English monitoring messages by default', async () => {
     await installWithConfig();
 

From 498e405cdc45a4a4c7fed9dadb57ae460e75928e Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 22:01:56 +0200
Subject: [PATCH 09/17] perf: lighten blood moon phase polling

---
 .../src/cronjobs/blood-moon-monitor/index.js  |  7 ++---
 .../functions/discord-7d2d-status-helpers.js  | 19 ++++++++-----
 .../test/bridge.test.ts                       | 27 +++++++++++++++++++
 3 files changed, 43 insertions(+), 10 deletions(-)

diff --git a/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js b/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
index 1d3e164..0d37ac7 100644
--- a/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
+++ b/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
@@ -1,5 +1,5 @@
 import { data } from '@takaro/helpers';
-import { BLOOD_STATE_KEY, getDiscordChannelFromHook, getStatus, isBloodMoonDay, readVariable, resolveMessage, sendDiscord, writeVariable } from './discord-7d2d-status-helpers.js';
+import { BLOOD_STATE_KEY, getDiscordChannelFromHook, getTimeStatus, isBloodMoonDay, readVariable, resolveMessage, sendDiscord, writeVariable } from './discord-7d2d-status-helpers.js';
 
 function phaseFor(status, config) {
   const parsed = status.parsed;
@@ -19,10 +19,11 @@ async function main() {
   const { gameServerId, module: mod } = data;
   const config = mod.userConfig;
   const channelId = getDiscordChannelFromHook(data, config.monitoringChannelId, 'bloodMoonMonitor');
-  const status = await getStatus(gameServerId, config);
+  const status = await getTimeStatus(gameServerId, config);
   const phase = phaseFor(status, config);
   const prev = await readVariable(gameServerId, mod.moduleId, BLOOD_STATE_KEY, null);
-  if (phase.messageKey && prev !== phase.key) await sendDiscord(channelId, resolveMessage(config, phase.messageKey));
+  if (prev === phase.key) return;
+  if (phase.messageKey) await sendDiscord(channelId, resolveMessage(config, phase.messageKey));
   await writeVariable(gameServerId, mod.moduleId, BLOOD_STATE_KEY, phase.key);
 }
 
diff --git a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
index 64d85f7..ed81876 100644
--- a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
+++ b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
@@ -134,18 +134,23 @@ export async function executeTimeCommand(gameServerId, command = 'gettime') {
   return JSON.stringify(data);
 }
 
-export async function getStatus(gameServerId, config) {
-  const [players, serverName, rawTime] = await Promise.all([
-    getOnlinePlayers(gameServerId),
-    getServerName(gameServerId),
-    executeTimeCommand(gameServerId, config.timeConsoleCommand ?? 'gettime'),
-  ]);
+export async function getTimeStatus(gameServerId, config) {
+  const rawTime = await executeTimeCommand(gameServerId, config.timeConsoleCommand ?? 'gettime');
   const parsed = parse7d2dTime(rawTime);
   if (!parsed) console.warn(`discord-7d2d-status: could not parse 7D2D time: ${rawTime}`);
   const day = parsed?.day ?? '?';
   const time = parsed?.time ?? '?';
   const active = isBloodMoonActive(parsed, config.firstHordeDay ?? 7, config.hordeIntervalDays ?? 7, config.bloodMoonStartHour ?? 22, config.bloodMoonEndHour ?? 4);
-  return { ...players, serverName, rawTime, parsed, day, time, bloodMoonActive: active };
+  return { rawTime, parsed, day, time, bloodMoonActive: active };
+}
+
+export async function getStatus(gameServerId, config) {
+  const [players, serverName, timeStatus] = await Promise.all([
+    getOnlinePlayers(gameServerId),
+    getServerName(gameServerId),
+    getTimeStatus(gameServerId, config),
+  ]);
+  return { ...players, serverName, ...timeStatus };
 }
 
 export function renderTemplate(template, status, config) {
diff --git a/modules/discord-7d2d-status-bridge/test/bridge.test.ts b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
index b3f5cea..4e1d39f 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -281,6 +281,33 @@ describe('discord-7d2d-status-bridge integration', () => {
     assert.equal(updateStatus?.temporalValue, '*/5 * * * *');
   });
 
+  it('polls blood moon time without loading players or server metadata', async () => {
+    const execution = await triggerCronjobExecution('bloodMoonMonitor');
+
+    assert.equal(execution.success, true, `Expected blood moon polling to succeed, logs: ${JSON.stringify(execution.logs)}`);
+    assert.ok(
+      !execution.logs.some((message) => message.includes('POST /gameserver/player/search')),
+      `Blood moon polling must not search players: ${JSON.stringify(execution.logs)}`,
+    );
+    assert.ok(
+      !execution.logs.some((message) => message.includes(`GET /gameserver/${ctx.gameServer.id}`)),
+      `Blood moon polling must not fetch server metadata: ${JSON.stringify(execution.logs)}`,
+    );
+  });
+
+  it('does not rewrite an unchanged blood moon phase', async () => {
+    await triggerCronjob('bloodMoonMonitor');
+    const repeated = await triggerCronjobExecution('bloodMoonMonitor');
+
+    assert.equal(repeated.success, true, `Expected repeated blood moon polling to succeed, logs: ${JSON.stringify(repeated.logs)}`);
+    assert.ok(
+      !repeated.logs.some((message) => (
+        /POST \/variables(?:\s|$)/.test(message) || message.includes('PUT /variables/')
+      )),
+      `An unchanged blood moon phase must not be written again: ${JSON.stringify(repeated.logs)}`,
+    );
+  });
+
   it('uses English monitoring messages by default', async () => {
     await installWithConfig();
 

From 5d3c19d7e0bccd1b8a36ccc0b03c0bd0c4d8bda1 Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 22:20:20 +0200
Subject: [PATCH 10/17] feat: notify first player of blood moon day

---
 .../discord-7d2d-status-bridge/module.json    |   2 +
 .../functions/discord-7d2d-status-helpers.js  |   2 +
 .../src/hooks/monitor-join/index.js           |  28 ++-
 .../test/bridge.test.ts                       | 208 +++++++++++++++++-
 4 files changed, 228 insertions(+), 12 deletions(-)

diff --git a/modules/discord-7d2d-status-bridge/module.json b/modules/discord-7d2d-status-bridge/module.json
index f69ea27..ba4e113 100644
--- a/modules/discord-7d2d-status-bridge/module.json
+++ b/modules/discord-7d2d-status-bridge/module.json
@@ -15,6 +15,7 @@
       "monitorJoins": { "type": "boolean", "default": true },
       "monitorLeaves": { "type": "boolean", "default": true },
       "monitorDeaths": { "type": "boolean", "default": true },
+      "privateBloodMoonNoticeOnFirstJoin": { "type": "boolean", "default": false, "description": "Privately notify the first player online when the persisted Blood Moon phase is today or starting." },
       "joinMessageTemplate": { "type": "string", "maxLength": 500, "default": "", "description": "Optional join-message override. Placeholder: {player}." },
       "leaveMessageTemplate": { "type": "string", "maxLength": 500, "default": "", "description": "Optional leave-message override. Placeholder: {player}." },
       "deathMessageTemplate": { "type": "string", "maxLength": 500, "default": "", "description": "Optional death-message override. Placeholder: {player}." },
@@ -32,6 +33,7 @@
       "bloodMoonStartHour": { "type": "integer", "minimum": 0, "maximum": 23, "default": 22 },
       "bloodMoonEndHour": { "type": "integer", "minimum": 0, "maximum": 23, "default": 4 },
       "bloodMoonTodayMessage": { "type": "string", "maxLength": 500, "default": "", "description": "Optional blood-moon-day message override." },
+      "privateBloodMoonTodayMessage": { "type": "string", "maxLength": 500, "default": "", "description": "Optional private first-player Blood Moon notice override. The selected language preset is used when empty." },
       "bloodMoonStartingMessage": { "type": "string", "maxLength": 500, "default": "", "description": "Optional blood-moon-starting message override." },
       "bloodMoonEndingMessage": { "type": "string", "maxLength": 500, "default": "", "description": "Optional blood-moon-ending message override." }
     },
diff --git a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
index ed81876..9b20b7e 100644
--- a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
+++ b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
@@ -10,6 +10,7 @@ export const MESSAGE_PRESETS = {
     deathMessageTemplate: '{player} died.',
     deathWithReasonMessageTemplate: '{player} died: {reason}',
     bloodMoonTodayMessage: 'Today is the Blood Moon day...',
+    privateBloodMoonTodayMessage: 'Today is the Blood Moon day...',
     bloodMoonStartingMessage: 'Blood Moon is starting...',
     bloodMoonEndingMessage: 'Blood Moon is ending...',
     serverStartingMessageTemplate: 'Server starting...',
@@ -24,6 +25,7 @@ export const MESSAGE_PRESETS = {
     deathMessageTemplate: '{player} nie żyje.',
     deathWithReasonMessageTemplate: '{player} nie żyje: {reason}',
     bloodMoonTodayMessage: 'Dzisiaj zapowiadają Krwawy Księżyc...',
+    privateBloodMoonTodayMessage: 'Dzisiaj zapowiadają Krwawy Księżyc...',
     bloodMoonStartingMessage: 'Krwawy Księżyc wschodzi...',
     bloodMoonEndingMessage: 'Krwawy Księżyc zachodzi...',
     serverStartingMessageTemplate: 'Serwer startuje...',
diff --git a/modules/discord-7d2d-status-bridge/src/hooks/monitor-join/index.js b/modules/discord-7d2d-status-bridge/src/hooks/monitor-join/index.js
index 73f9ead..391a14c 100644
--- a/modules/discord-7d2d-status-bridge/src/hooks/monitor-join/index.js
+++ b/modules/discord-7d2d-status-bridge/src/hooks/monitor-join/index.js
@@ -1,9 +1,33 @@
 import { data } from '@takaro/helpers';
-import { getDiscordChannelFromHook, renderMessage, resolveMessage, sendDiscord } from './discord-7d2d-status-helpers.js';
+import {
+  BLOOD_STATE_KEY,
+  getDiscordChannelFromHook,
+  getOnlinePlayers,
+  readVariable,
+  renderMessage,
+  resolveMessage,
+  sendDiscord,
+} from './discord-7d2d-status-helpers.js';
+
+async function sendPrivateBloodMoonNotice(gameServerId, mod, player) {
+  const config = mod.userConfig;
+  if (config.privateBloodMoonNoticeOnFirstJoin !== true || !player) return;
+
+  const phase = await readVariable(gameServerId, mod.moduleId, BLOOD_STATE_KEY, null);
+  if (typeof phase !== 'string' || (!phase.startsWith('today:') && !phase.startsWith('start:'))) return;
+
+  const { onlinePlayers } = await getOnlinePlayers(gameServerId);
+  if (onlinePlayers !== 1) return;
+
+  const message = resolveMessage(config, 'privateBloodMoonTodayMessage');
+  await player.pm(message);
+  console.log(`discord-7d2d-status: private blood moon first-join notice sent: ${message}`);
+}
 
 async function main() {
-  const { player, module: mod } = data;
+  const { gameServerId, player, module: mod } = data;
   const config = mod.userConfig;
+  await sendPrivateBloodMoonNotice(gameServerId, mod, player);
   if (config.monitorJoins === false) return;
   const channelId = getDiscordChannelFromHook(data, config.monitoringChannelId, 'monitorJoin');
   const playerName = player?.name || resolveMessage(config, 'unknownPlayerText');
diff --git a/modules/discord-7d2d-status-bridge/test/bridge.test.ts b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
index 4e1d39f..1198798 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -137,8 +137,10 @@ async function setModuleVariable(
 describe('discord-7d2d-status-bridge integration', () => {
   let client: Client;
   let ctx: MockServerContext;
+  let noticeCtx: MockServerContext;
   let mod: ModuleOutputDTO;
   let installed = false;
+  let noticeInstalled = false;
   let playerName: string;
   let playerNames: string[];
 
@@ -154,13 +156,33 @@ describe('discord-7d2d-status-bridge integration', () => {
     installed = true;
   }
 
-  async function triggerHook(
+  async function installNoticeWithConfig(userConfig: Record<string, unknown> = {}) {
+    if (noticeInstalled) {
+      await uninstallModule(client, mod.id, noticeCtx.gameServer.id);
+      noticeInstalled = false;
+    }
+    await installModule(client, mod.latestVersion.id, noticeCtx.gameServer.id, {
+      userConfig: { chatChannelId: '', monitoringChannelId: '', ...userConfig },
+      systemConfig: { hooks: { discordChatRelay: { discordChannelId: '1' } } },
+    });
+    noticeInstalled = true;
+  }
+
+  async function triggerHookExecution(
     eventType: HookTriggerDTOEventTypeEnum,
-    options: { playerId?: string; eventMeta?: Record<string, unknown>; expectedLog?: string } = {},
-  ): Promise<string[]> {
+    options: {
+      playerId?: string;
+      eventMeta?: Record<string, unknown>;
+      expectedLog?: string;
+      serverContext?: MockServerContext;
+    } = {},
+  ): Promise<BridgeExecutionResult> {
+    const hook = mod.latestVersion.hooks.find((candidate) => candidate.eventType === eventType);
+    assert.ok(hook, `Expected hook for '${eventType}' to exist`);
+    const target = options.serverContext ?? ctx;
     const beforeTrigger = new Date();
     await client.hook.hookControllerTrigger({
-      gameServerId: ctx.gameServer.id,
+      gameServerId: target.gameServer.id,
       moduleId: mod.id,
       playerId: options.playerId,
       eventType,
@@ -168,20 +190,36 @@ describe('discord-7d2d-status-bridge integration', () => {
     });
     const event = await waitForBridgeEvent(client, {
       eventName: EventSearchInputAllowedFiltersEventNameEnum.HookExecuted,
-      gameserverId: ctx.gameServer.id,
+      gameserverId: target.gameServer.id,
       moduleId: mod.id,
       after: beforeTrigger,
-      predicate: options.expectedLog
-        ? (candidate) => {
+      predicate: (candidate) => {
+        const meta = candidate.meta as { hook?: { id?: string }; result?: { logs?: Array<{ msg: string }> } };
+        if (meta.hook?.id !== hook.id) return false;
+        if (options.expectedLog) {
           const result = (candidate.meta as { result?: { logs?: Array<{ msg: string }> } }).result;
           return (result?.logs ?? []).some((entry) => entry.msg.includes(options.expectedLog!));
         }
-        : undefined,
+        return true;
+      },
     });
     const result = (event.meta as { result?: { success?: boolean; logs?: Array<{ msg: string }> } }).result;
     const logs = (result?.logs ?? []).map((entry) => entry.msg);
-    assert.equal(result?.success, true, `Expected hook '${eventType}' to succeed, logs: ${JSON.stringify(logs)}`);
-    return logs;
+    return { success: result?.success ?? false, logs };
+  }
+
+  async function triggerHook(
+    eventType: HookTriggerDTOEventTypeEnum,
+    options: {
+      playerId?: string;
+      eventMeta?: Record<string, unknown>;
+      expectedLog?: string;
+      serverContext?: MockServerContext;
+    } = {},
+  ): Promise<string[]> {
+    const execution = await triggerHookExecution(eventType, options);
+    assert.equal(execution.success, true, `Expected hook '${eventType}' to succeed, logs: ${JSON.stringify(execution.logs)}`);
+    return execution.logs;
   }
 
   async function triggerCronjobExecution(name: string): Promise<BridgeExecutionResult> {
@@ -237,6 +275,7 @@ describe('discord-7d2d-status-bridge integration', () => {
     await cleanupTestModules(client);
     await cleanupTestGameServers(client);
     ctx = await startMockServer(client, { serverNamePrefix: 'qa-discord-bridge-' });
+    noticeCtx = await startMockServer(client, { serverNamePrefix: 'qa-discord-notice-', totalPlayers: 1 });
     mod = await pushDisposableBridgeModule(client);
     playerNames = await Promise.all(ctx.players.map(async (playerOnGameserver) => {
       const player = await client.player.playerControllerGetOne(playerOnGameserver.playerId);
@@ -253,6 +292,12 @@ describe('discord-7d2d-status-bridge integration', () => {
 
   after(async () => {
     if (mod && ctx) {
+      if (noticeInstalled && noticeCtx) {
+        await uninstallModule(client, mod.id, noticeCtx.gameServer.id).catch((err) => {
+          const status = (err as { response?: { status?: number } }).response?.status;
+          console.error(`Cleanup: failed to uninstall bridge notice test module (HTTP ${status ?? 'unknown'})`);
+        });
+      }
       if (installed) {
         await uninstallModule(client, mod.id, ctx.gameServer.id).catch((err) => {
           const status = (err as { response?: { status?: number } }).response?.status;
@@ -265,6 +310,7 @@ describe('discord-7d2d-status-bridge integration', () => {
       });
     }
     if (ctx) await stopMockServer(ctx.server, client, ctx.gameServer.id);
+    if (noticeCtx) await stopMockServer(noticeCtx.server, client, noticeCtx.gameServer.id);
   });
 
   it('imports under a disposable name and scopes hook events to that module', async () => {
@@ -281,6 +327,148 @@ describe('discord-7d2d-status-bridge integration', () => {
     assert.equal(updateStatus?.temporalValue, '*/5 * * * *');
   });
 
+  it('imports the opt-in private Blood Moon notice config with safe defaults', () => {
+    const configSchema = JSON.parse(mod.latestVersion.configSchema) as {
+      properties?: Record<string, { type?: string; default?: unknown; maxLength?: number; description?: string }>;
+    };
+    const enabled = configSchema.properties?.privateBloodMoonNoticeOnFirstJoin;
+    const message = configSchema.properties?.privateBloodMoonTodayMessage;
+
+    assert.deepEqual(
+      { type: enabled?.type, default: enabled?.default },
+      { type: 'boolean', default: false },
+    );
+    assert.ok(enabled?.description, 'Expected the private notice toggle to have a description');
+    assert.deepEqual(
+      { type: message?.type, maxLength: message?.maxLength, default: message?.default },
+      { type: 'string', maxLength: 500, default: '' },
+    );
+    assert.ok(message?.description, 'Expected the private notice message to have a description');
+  });
+
+  it('privately sends the exact English Blood Moon Today wording to the first online player', async () => {
+    await installNoticeWithConfig({
+      monitorJoins: false,
+      privateBloodMoonNoticeOnFirstJoin: true,
+    });
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'today:7');
+
+    const logs = await triggerHook('player-connected', {
+      playerId: noticeCtx.players[0].playerId,
+      serverContext: noticeCtx,
+    });
+
+    assertLogContains(logs, `/gameserver/${noticeCtx.gameServer.id}/message 200 OK`);
+    assertLogContains(logs, 'private blood moon first-join notice sent: Today is the Blood Moon day...');
+    assert.ok(
+      !logs.some((message) => message.includes(`/gameserver/${noticeCtx.gameServer.id}/command`)),
+      `Join notice must use persisted phase without executing gettime: ${JSON.stringify(logs)}`,
+    );
+  });
+
+  it('uses the exact Polish Blood Moon Today wording for a persisted start phase', async () => {
+    await installNoticeWithConfig({ language: 'pl', privateBloodMoonNoticeOnFirstJoin: true });
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'start:7');
+
+    const logs = await triggerHook('player-connected', {
+      playerId: noticeCtx.players[0].playerId,
+      serverContext: noticeCtx,
+    });
+
+    assertLogContains(logs, `/gameserver/${noticeCtx.gameServer.id}/message 200 OK`);
+    assertLogContains(logs, 'private blood moon first-join notice sent: Dzisiaj zapowiadają Krwawy Księżyc...');
+  });
+
+  it('supports a non-empty private Blood Moon message override', async () => {
+    await installNoticeWithConfig({
+      privateBloodMoonNoticeOnFirstJoin: true,
+      privateBloodMoonTodayMessage: 'Custom private Blood Moon warning',
+    });
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'today:7');
+
+    const logs = await triggerHook('player-connected', {
+      playerId: noticeCtx.players[0].playerId,
+      serverContext: noticeCtx,
+    });
+
+    assertLogContains(logs, 'private blood moon first-join notice sent: Custom private Blood Moon warning');
+  });
+
+  it('does not privately notify when the option is disabled by default', async () => {
+    await installNoticeWithConfig();
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'today:7');
+
+    const logs = await triggerHook('player-connected', {
+      playerId: noticeCtx.players[0].playerId,
+      serverContext: noticeCtx,
+    });
+
+    assert.ok(!logs.some((message) => message.includes('private blood moon first-join notice sent:')));
+    assert.ok(!logs.some((message) => message.includes(`/gameserver/${noticeCtx.gameServer.id}/message`)));
+  });
+
+  it('does not privately notify for missing, normal, or ended Blood Moon state', async () => {
+    await installNoticeWithConfig({ privateBloodMoonNoticeOnFirstJoin: true });
+    for (const phase of [null, 'normal:6', 'end:7']) {
+      await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', phase);
+
+      const logs = await triggerHook('player-connected', {
+        playerId: noticeCtx.players[0].playerId,
+        serverContext: noticeCtx,
+      });
+
+      assert.ok(
+        !logs.some((message) => message.includes('private blood moon first-join notice sent:')),
+        `Phase ${JSON.stringify(phase)} must not send a private notice: ${JSON.stringify(logs)}`,
+      );
+      assert.ok(
+        !logs.some((message) => message.includes(`/gameserver/${noticeCtx.gameServer.id}/message`)),
+        `Phase ${JSON.stringify(phase)} must not call the game message API: ${JSON.stringify(logs)}`,
+      );
+    }
+  });
+
+  it('does not privately notify a missing player', async () => {
+    await installNoticeWithConfig({ privateBloodMoonNoticeOnFirstJoin: true });
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'today:7');
+
+    const logs = await triggerHook('player-connected', { serverContext: noticeCtx });
+
+    assert.ok(!logs.some((message) => message.includes('private blood moon first-join notice sent:')));
+    assert.ok(!logs.some((message) => message.includes(`/gameserver/${noticeCtx.gameServer.id}/message`)));
+  });
+
+  it('does not privately notify when more than one player is online', async () => {
+    await installWithConfig({ privateBloodMoonNoticeOnFirstJoin: true });
+    await setModuleVariable(client, ctx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'today:7');
+
+    const logs = await triggerHook('player-connected', { playerId: ctx.players[0].playerId });
+
+    assert.ok(!logs.some((message) => message.includes('private blood moon first-join notice sent:')));
+    assert.ok(!logs.some((message) => message.includes(`/gameserver/${ctx.gameServer.id}/message`)));
+  });
+
+  it('[live smoke] delivers the private notice before a configured Discord join failure remains visible', {
+    skip: DISCORD_FORBIDDEN_CHANNEL_ID ? false : 'Live smoke gate skipped: set TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID',
+  }, async () => {
+    assert.ok(DISCORD_FORBIDDEN_CHANNEL_ID);
+    await installNoticeWithConfig({
+      monitoringChannelId: DISCORD_FORBIDDEN_CHANNEL_ID,
+      privateBloodMoonNoticeOnFirstJoin: true,
+    });
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'today:7');
+
+    const execution = await triggerHookExecution('player-connected', {
+      playerId: noticeCtx.players[0].playerId,
+      serverContext: noticeCtx,
+    });
+
+    assert.equal(execution.success, false, `Configured Discord failure must fail the hook: ${JSON.stringify(execution.logs)}`);
+    assertLogContains(execution.logs, `/gameserver/${noticeCtx.gameServer.id}/message 200 OK`);
+    assertLogContains(execution.logs, 'private blood moon first-join notice sent: Today is the Blood Moon day...');
+    assertLogContains(execution.logs, `Takaro or Discord refused delivery to channel ${DISCORD_FORBIDDEN_CHANNEL_ID}`);
+  });
+
   it('polls blood moon time without loading players or server metadata', async () => {
     const execution = await triggerCronjobExecution('bloodMoonMonitor');
 

From 98a2abbc95cf3ebc34ab259798b4b005e3b2107b Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 22:37:51 +0200
Subject: [PATCH 11/17] test: cover missing blood moon state

---
 .../test/bridge.test.ts                       | 39 ++++++++++++++++++-
 1 file changed, 37 insertions(+), 2 deletions(-)

diff --git a/modules/discord-7d2d-status-bridge/test/bridge.test.ts b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
index 1198798..5c50c1a 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -134,6 +134,20 @@ async function setModuleVariable(
   }
 }
 
+async function deleteModuleVariable(
+  client: Client,
+  gameServerId: string,
+  moduleId: string,
+  key: string,
+) {
+  const existing = await client.variable.variableControllerSearch({
+    filters: { key: [key], gameServerId: [gameServerId], moduleId: [moduleId] },
+  });
+  await Promise.all(
+    existing.data.data.map((variable) => client.variable.variableControllerDelete(variable.id)),
+  );
+}
+
 describe('discord-7d2d-status-bridge integration', () => {
   let client: Client;
   let ctx: MockServerContext;
@@ -407,9 +421,30 @@ describe('discord-7d2d-status-bridge integration', () => {
     assert.ok(!logs.some((message) => message.includes(`/gameserver/${noticeCtx.gameServer.id}/message`)));
   });
 
-  it('does not privately notify for missing, normal, or ended Blood Moon state', async () => {
+  it('does not privately notify when the Blood Moon state variable is absent', async () => {
+    await installNoticeWithConfig({ privateBloodMoonNoticeOnFirstJoin: true });
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState');
+    const variables = await client.variable.variableControllerSearch({
+      filters: {
+        key: ['discord7d2d:bloodState'],
+        gameServerId: [noticeCtx.gameServer.id],
+        moduleId: [mod.id],
+      },
+    });
+    assert.equal(variables.data.data.length, 0, 'Expected no persisted Blood Moon state record');
+
+    const logs = await triggerHook('player-connected', {
+      playerId: noticeCtx.players[0].playerId,
+      serverContext: noticeCtx,
+    });
+
+    assert.ok(!logs.some((message) => message.includes('private blood moon first-join notice sent:')));
+    assert.ok(!logs.some((message) => message.includes(`/gameserver/${noticeCtx.gameServer.id}/message`)));
+  });
+
+  it('does not privately notify for normal or ended Blood Moon state', async () => {
     await installNoticeWithConfig({ privateBloodMoonNoticeOnFirstJoin: true });
-    for (const phase of [null, 'normal:6', 'end:7']) {
+    for (const phase of ['normal:6', 'end:7']) {
       await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', phase);
 
       const logs = await triggerHook('player-connected', {

From 9ad7081a4344d8d0703ca19c2a440bba87eb25dc Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 22:48:14 +0200
Subject: [PATCH 12/17] docs: design blood moon delivery state

---
 ...6-07-23-discord-7d2d-blood-state-design.md | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 docs/plans/2026-07-23-discord-7d2d-blood-state-design.md

diff --git a/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md b/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md
new file mode 100644
index 0000000..5cb12cc
--- /dev/null
+++ b/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md
@@ -0,0 +1,32 @@
+# Discord 7D2D Blood State Design
+
+## Goal
+
+Keep the private first-player Blood Moon notice current even when Discord delivery fails, while retrying failed Discord announcements without duplicating successful ones.
+
+## State model
+
+- `discord7d2d:bloodState` stores only the currently observed phase used by the join hook.
+- `discord7d2d:bloodDelivered` stores up to 32 unique announcement keys that Discord has accepted, or that the existing empty-channel skip path has completed.
+- Announcement keys remain `today:<day>`, `start:<day>`, and `end:<day>` so legacy `bloodState` values can migrate without translation.
+
+Each cron execution persists the observed phase before attempting Discord. It then migrates any announcement-shaped legacy `bloodState` value into delivered history, derives pending announcements, and processes them in order. Each successful announcement is recorded immediately. A failed send is not recorded, so the next cron retries it without repeating earlier successes.
+
+## Phase and announcement derivation
+
+Observed state and announcements are separate outputs. For ordinary intervals, behavior remains today, start, and end at the existing boundaries. When consecutive days are Blood Moon days, the previous Blood Moon remains active until the configured end hour. At or after that boundary, the current observed state becomes `today:<current day>` and the cron can expose both `end:<previous day>` and `today:<current day>` as ordered announcements.
+
+For interval `1`, day 8 at 05:00 therefore produces:
+
+- observed state: `today:8`;
+- announcements: `end:7`, then `today:8`.
+
+## Migration
+
+When the delivered-history variable does not exist, any legacy announcement-shaped `bloodState` value is recorded as delivered before current pending work is compared. The old implementation wrote that state only after successful or skipped delivery, so this prevents a current announcement from repeating immediately after upgrade. Normal and unknown legacy states do not imply a delivered announcement.
+
+## Integration proof
+
+The active WebSocket mock server has no configurable `gettime` response. The disposable test import will extend only its config schema to permit deterministic `say Day <n> <time>` commands. The production code will still execute through Takaro's real command API, and the real mock server returns a parseable `Sent message: Day ...` response. No helper methods, Takaro clients, or module source will be mocked.
+
+Tests will prove observed-state-first behavior, retry bookkeeping, migration, and interval-one overlap through real Takaro variables and cron executions. A configured forbidden Discord channel remains environment-gated.

From 425f2044c82fdaa74783fa892f68a19303272ac2 Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 22:48:41 +0200
Subject: [PATCH 13/17] docs: plan reliable blood moon state

---
 .../2026-07-23-discord-7d2d-blood-state.md    | 70 +++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 docs/plans/2026-07-23-discord-7d2d-blood-state.md

diff --git a/docs/plans/2026-07-23-discord-7d2d-blood-state.md b/docs/plans/2026-07-23-discord-7d2d-blood-state.md
new file mode 100644
index 0000000..e53f001
--- /dev/null
+++ b/docs/plans/2026-07-23-discord-7d2d-blood-state.md
@@ -0,0 +1,70 @@
+# Discord 7D2D Blood State Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Separate observed Blood Moon phase from Discord delivery history so private notices stay current and failed announcements retry without duplicates.
+
+**Architecture:** Continue storing the observed phase in `discord7d2d:bloodState` for join-hook compatibility. Store up to 32 delivered announcement keys in `discord7d2d:bloodDelivered`; persist observation and migration before sending, then record each successful announcement immediately.
+
+**Tech Stack:** JavaScript Takaro functions, TypeScript Node test runner, real Takaro API, Takaro WebSocket mock game server.
+
+---
+
+### Task 1: Prove state, retry, migration, and consecutive-day behavior
+
+**Files:**
+- Modify: `modules/discord-7d2d-status-bridge/test/bridge.test.ts`
+
+**Step 1: Extend only the disposable imported schema**
+
+Allow deterministic test commands such as `say Day 7 12:00` and `say Day 8 05:00` in the disposable module's `timeConsoleCommand` enum. Keep the production schema unchanged.
+
+**Step 2: Write failing real-Takaro tests**
+
+- Run a cron with a parseable day/time response and assert observed state plus delivered-history values.
+- Seed a legacy announcement-shaped state with no delivered history and assert no duplicate current announcement.
+- For interval `1` at day 8 05:00, assert observed `today:8` and ordered completion of `end:7`, then `today:8`, once each.
+- With the environment-provided forbidden Discord channel, assert the cron fails after persisting observed state, leaves the failed announcement pending, retries it, and the join hook can still PM from the current observed state.
+
+**Step 3: Run RED**
+
+Run the focused integration tests through the real Takaro API with Bearer/Authorization redaction. Expect failures because delivery history does not exist, observed state is currently written after Discord, and interval-one phase derivation returns `end:7` all day.
+
+### Task 2: Implement separated state and delivery tracking
+
+**Files:**
+- Modify: `modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js`
+- Modify: `modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js`
+
+**Step 1: Add delivered-history state**
+
+Export `BLOOD_DELIVERED_KEY`. Normalize stored history to a unique string list capped at 32 entries.
+
+**Step 2: Derive observation and announcements separately**
+
+Return one observed key and an ordered list of announcement descriptors. Consecutive-day end overlap must yield `today:8` plus `end:7`, `today:8` at day 8 05:00.
+
+**Step 3: Order persistence and delivery**
+
+Read legacy state/history, persist observed state first, migrate any legacy announcement-shaped state before pending comparison, then send pending announcements in order. Persist each successful key immediately; do not record failures.
+
+**Step 4: Run GREEN and refactor**
+
+Run the focused state tests, then the complete module suite. Keep current cron timing and Discord diagnostics unchanged.
+
+### Task 3: Verify and commit
+
+**Files:**
+- Verify: `modules/discord-7d2d-status-bridge/**`
+
+**Step 1: Static verification**
+
+Run `npm run build`, `npm run typecheck`, both changed JavaScript files through `node --check`, and `git diff --check`.
+
+**Step 2: Focused integration verification**
+
+Run the complete bridge integration suite with output redaction. Report any environment-gated Discord cases separately.
+
+**Step 3: Commit**
+
+Commit source and tests with a message describing reliable Blood Moon state tracking.

From ac7fc27f31ce24ffa9623ee130846ec4b0c3acf2 Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 23:35:38 +0200
Subject: [PATCH 14/17] fix: make blood moon monitoring delivery reliable

---
 ...6-07-23-discord-7d2d-blood-state-design.md |  10 +-
 .../2026-07-23-discord-7d2d-blood-state.md    |  11 +-
 .../src/cronjobs/blood-moon-monitor/index.js  | 144 ++++-
 .../functions/discord-7d2d-status-helpers.js  | 125 ++++-
 .../test/bridge.test.ts                       | 497 +++++++++++++++++-
 5 files changed, 754 insertions(+), 33 deletions(-)

diff --git a/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md b/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md
index 5cb12cc..23ffbe3 100644
--- a/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md
+++ b/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md
@@ -7,10 +7,14 @@ Keep the private first-player Blood Moon notice current even when Discord delive
 ## State model
 
 - `discord7d2d:bloodState` stores only the currently observed phase used by the join hook.
-- `discord7d2d:bloodDelivered` stores up to 32 unique announcement keys that Discord has accepted, or that the existing empty-channel skip path has completed.
+- `discord7d2d:bloodDelivered` stores up to 32 unique announcement keys that Discord has actually accepted.
+- `discord7d2d:bloodPending` stores up to 32 unique, chronologically ordered announcements that still need delivery.
+- `discord7d2d:bloodMonitorLock` serializes the complete observation and delivery state machine per server and module.
 - Announcement keys remain `today:<day>`, `start:<day>`, and `end:<day>` so legacy `bloodState` values can migrate without translation.
 
-Each cron execution persists the observed phase before attempting Discord. It then migrates any announcement-shaped legacy `bloodState` value into delivered history, derives pending announcements, and processes them in order. Each successful announcement is recorded immediately. A failed send is not recorded, so the next cron retries it without repeating earlier successes.
+Each cron execution persists the observed phase before attempting Discord. It then migrates any announcement-shaped legacy `bloodState` value into delivered history, merges newly due announcements into pending state, persists the merged pending list, and processes it in order. Each successful announcement is recorded in delivered history before it is removed from pending state. A failed send or an unconfigured-channel skip remains pending across later phase and day transitions without repeating earlier successes.
+
+Before reading game time or any state, each cron atomically creates the scoped lock with a unique owner token and expiry. A competing execution uses bounded 50-250ms backoff and never enters the state machine until it owns the lock. Because Takaro's function VM does not expose timers, the backoff uses standard `Atomics.wait` rather than issuing artificial API traffic. The owner re-checks and renews its lease after status retrieval, after state reads, before each state mutation, and around every pending send. The 120-second lease is comfortably above Takaro's 30-second production function limit, while renewal also protects longer local executions. Expired or malformed locks are reclaimed by record ID, and `finally` releases only a lock whose current owner token still matches. Acquisition timeout and non-404 release failures remain visible execution failures. Ordinary variable creation also recovers from a create conflict by re-reading the same scoped key and updating the winning record after a small bounded backoff.
 
 ## Phase and announcement derivation
 
@@ -29,4 +33,4 @@ When the delivered-history variable does not exist, any legacy announcement-shap
 
 The active WebSocket mock server has no configurable `gettime` response. The disposable test import will extend only its config schema to permit deterministic `say Day <n> <time>` commands. The production code will still execute through Takaro's real command API, and the real mock server returns a parseable `Sent message: Day ...` response. No helper methods, Takaro clients, or module source will be mocked.
 
-Tests will prove observed-state-first behavior, retry bookkeeping, migration, and interval-one overlap through real Takaro variables and cron executions. A configured forbidden Discord channel remains environment-gated.
+Tests will prove observed-state-first behavior, retry bookkeeping, migration, interval-one overlap, stale-lock recovery, bounded acquisition timeout that preserves another owner, and concurrent serialization without lost pending keys through real Takaro variables and cron executions. A configured forbidden Discord channel remains environment-gated.
diff --git a/docs/plans/2026-07-23-discord-7d2d-blood-state.md b/docs/plans/2026-07-23-discord-7d2d-blood-state.md
index e53f001..4477658 100644
--- a/docs/plans/2026-07-23-discord-7d2d-blood-state.md
+++ b/docs/plans/2026-07-23-discord-7d2d-blood-state.md
@@ -4,7 +4,7 @@
 
 **Goal:** Separate observed Blood Moon phase from Discord delivery history so private notices stay current and failed announcements retry without duplicates.
 
-**Architecture:** Continue storing the observed phase in `discord7d2d:bloodState` for join-hook compatibility. Store up to 32 delivered announcement keys in `discord7d2d:bloodDelivered`; persist observation and migration before sending, then record each successful announcement immediately.
+**Architecture:** Continue storing the observed phase in `discord7d2d:bloodState` for join-hook compatibility. Store up to 32 delivered keys in `discord7d2d:bloodDelivered` and 32 chronologically ordered retry keys in `discord7d2d:bloodPending`; persist observation, migration, and merged pending state before sending, then record each successful announcement before removing it from pending.
 
 **Tech Stack:** JavaScript Takaro functions, TypeScript Node test runner, real Takaro API, Takaro WebSocket mock game server.
 
@@ -24,6 +24,11 @@ Allow deterministic test commands such as `say Day 7 12:00` and `say Day 8 05:00
 - Run a cron with a parseable day/time response and assert observed state plus delivered-history values.
 - Seed a legacy announcement-shaped state with no delivered history and assert no duplicate current announcement.
 - For interval `1` at day 8 05:00, assert observed `today:8` and ordered completion of `end:7`, then `today:8`, once each.
+- Advance a failed `today:7` execution to `start:7` and assert both remain pending in chronological order.
+- Trigger concurrent cron executions against absent variables and assert create conflicts recover without duplicate keys.
+- Seed an expired monitor lock and assert it is reclaimed and released through the real variable API.
+- Trigger concurrent cron executions with existing pending work and assert one waits for the scoped lock without losing any keys.
+- Seed another active owner and assert acquisition backs off for the bounded interval, fails clearly, and preserves that owner's record.
 - With the environment-provided forbidden Discord channel, assert the cron fails after persisting observed state, leaves the failed announcement pending, retries it, and the join hook can still PM from the current observed state.
 
 **Step 3: Run RED**
@@ -38,7 +43,7 @@ Run the focused integration tests through the real Takaro API with Bearer/Author
 
 **Step 1: Add delivered-history state**
 
-Export `BLOOD_DELIVERED_KEY`. Normalize stored history to a unique string list capped at 32 entries.
+Export `BLOOD_DELIVERED_KEY` and `BLOOD_PENDING_KEY`. Normalize both stored lists to unique announcement keys capped at 32 entries.
 
 **Step 2: Derive observation and announcements separately**
 
@@ -46,7 +51,7 @@ Return one observed key and an ordered list of announcement descriptors. Consecu
 
 **Step 3: Order persistence and delivery**
 
-Read legacy state/history, persist observed state first, migrate any legacy announcement-shaped state before pending comparison, then send pending announcements in order. Persist each successful key immediately; do not record failures.
+Acquire a scoped unique variable lock before reading game time or state. Use an owner token plus expiry, bounded polling with 50-250ms backoff, stale deletion by record ID, owner-checked renewal around external work and mutations, and owner-checked `finally` release. Keep the lease above Takaro's production function runtime bound. Read legacy state/history, persist observed state first, migrate any legacy announcement-shaped state, merge and persist pending work, then send pending announcements in order. Persist each successful key before removing it from pending; keep failures and skips pending. Recover scoped variable create conflicts with a bounded re-search and backoff.
 
 **Step 4: Run GREEN and refactor**
 
diff --git a/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js b/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
index 0d37ac7..bc611a7 100644
--- a/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
+++ b/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
@@ -1,30 +1,146 @@
 import { data } from '@takaro/helpers';
-import { BLOOD_STATE_KEY, getDiscordChannelFromHook, getTimeStatus, isBloodMoonDay, readVariable, resolveMessage, sendDiscord, writeVariable } from './discord-7d2d-status-helpers.js';
+import {
+  acquireBloodMonitorLock,
+  BLOOD_DELIVERED_KEY,
+  BLOOD_PENDING_KEY,
+  BLOOD_STATE_KEY,
+  getDiscordChannelFromHook,
+  getTimeStatus,
+  isBloodMoonDay,
+  readVariable,
+  releaseBloodMonitorLock,
+  renewBloodMonitorLock,
+  resolveMessage,
+  sendDiscord,
+  writeVariable,
+} from './discord-7d2d-status-helpers.js';
 
-function phaseFor(status, config) {
+const MAX_ANNOUNCEMENT_KEYS = 32;
+const MESSAGE_KEY_BY_PREFIX = {
+  today: 'bloodMoonTodayMessage',
+  start: 'bloodMoonStartingMessage',
+  end: 'bloodMoonEndingMessage',
+};
+
+function stateFor(status, config) {
   const parsed = status.parsed;
-  if (!parsed) return { key: 'unknown', messageKey: null };
+  if (!parsed) return { observedKey: 'unknown', announcements: [] };
   const first = config.firstHordeDay ?? 7;
   const interval = config.hordeIntervalDays ?? 7;
   const start = config.bloodMoonStartHour ?? 22;
   const end = config.bloodMoonEndHour ?? 4;
-  if (isBloodMoonDay(parsed.day, first, interval) && parsed.hour !== null && parsed.hour >= start) return { key: `start:${parsed.day}`, messageKey: 'bloodMoonStartingMessage' };
-  if (parsed.hour !== null && parsed.hour < end && parsed.day > 1 && isBloodMoonDay(parsed.day - 1, first, interval)) return { key: `start:${parsed.day - 1}`, messageKey: null };
-  if (parsed.hour !== null && parsed.hour >= end && parsed.day > 1 && isBloodMoonDay(parsed.day - 1, first, interval)) return { key: `end:${parsed.day - 1}`, messageKey: 'bloodMoonEndingMessage' };
-  if (isBloodMoonDay(parsed.day, first, interval)) return { key: `today:${parsed.day}`, messageKey: 'bloodMoonTodayMessage' };
-  return { key: `normal:${parsed.day}`, messageKey: null };
+  const currentIsHorde = isBloodMoonDay(parsed.day, first, interval);
+  const previousDay = parsed.day - 1;
+  const previousIsHorde = parsed.day > 1 && isBloodMoonDay(previousDay, first, interval);
+
+  if (currentIsHorde && parsed.hour !== null && parsed.hour >= start) {
+    const key = `start:${parsed.day}`;
+    return { observedKey: key, announcements: [key] };
+  }
+  if (previousIsHorde && parsed.hour !== null && parsed.hour < end) {
+    return { observedKey: `start:${previousDay}`, announcements: [] };
+  }
+
+  const announcements = [];
+  if (previousIsHorde && parsed.hour !== null && parsed.hour >= end) {
+    announcements.push(`end:${previousDay}`);
+  }
+  if (currentIsHorde) {
+    const key = `today:${parsed.day}`;
+    announcements.push(key);
+    return { observedKey: key, announcements };
+  }
+  if (previousIsHorde && parsed.hour !== null && parsed.hour >= end) {
+    return { observedKey: `end:${previousDay}`, announcements };
+  }
+  return { observedKey: `normal:${parsed.day}`, announcements };
+}
+
+function isAnnouncementKey(value) {
+  return typeof value === 'string' && /^(?:today|start|end):\d+$/.test(value);
+}
+
+function normalizeAnnouncementKeys(value) {
+  if (!Array.isArray(value)) return [];
+  const unique = [];
+  for (const key of value) {
+    if (!isAnnouncementKey(key) || unique.includes(key)) continue;
+    unique.push(key);
+  }
+  return unique.slice(-MAX_ANNOUNCEMENT_KEYS);
+}
+
+function sameHistory(left, right) {
+  return Array.isArray(left)
+    && left.length === right.length
+    && left.every((key, index) => key === right[index]);
+}
+
+function addAnnouncementKey(history, key) {
+  return normalizeAnnouncementKeys([...history, key]);
+}
+
+function messageKeyFor(announcementKey) {
+  if (!isAnnouncementKey(announcementKey)) return null;
+  return MESSAGE_KEY_BY_PREFIX[announcementKey.split(':', 1)[0]] ?? null;
 }
 
 async function main() {
   const { gameServerId, module: mod } = data;
   const config = mod.userConfig;
   const channelId = getDiscordChannelFromHook(data, config.monitoringChannelId, 'bloodMoonMonitor');
-  const status = await getTimeStatus(gameServerId, config);
-  const phase = phaseFor(status, config);
-  const prev = await readVariable(gameServerId, mod.moduleId, BLOOD_STATE_KEY, null);
-  if (prev === phase.key) return;
-  if (phase.messageKey) await sendDiscord(channelId, resolveMessage(config, phase.messageKey));
-  await writeVariable(gameServerId, mod.moduleId, BLOOD_STATE_KEY, phase.key);
+  const lockOwner = await acquireBloodMonitorLock(gameServerId, mod.moduleId);
+
+  try {
+    const status = await getTimeStatus(gameServerId, config);
+    await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
+    const state = stateFor(status, config);
+    const previousObserved = await readVariable(gameServerId, mod.moduleId, BLOOD_STATE_KEY, null);
+    const storedDelivered = await readVariable(gameServerId, mod.moduleId, BLOOD_DELIVERED_KEY, null);
+    const storedPending = await readVariable(gameServerId, mod.moduleId, BLOOD_PENDING_KEY, null);
+    await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
+
+    if (previousObserved !== state.observedKey) {
+      await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
+      await writeVariable(gameServerId, mod.moduleId, BLOOD_STATE_KEY, state.observedKey);
+    }
+
+    let delivered = normalizeAnnouncementKeys(storedDelivered);
+    if (storedDelivered === null && isAnnouncementKey(previousObserved)) {
+      delivered = addAnnouncementKey(delivered, previousObserved);
+    }
+    if (!sameHistory(storedDelivered, delivered)) {
+      await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
+      await writeVariable(gameServerId, mod.moduleId, BLOOD_DELIVERED_KEY, delivered);
+    }
+
+    let pending = normalizeAnnouncementKeys(storedPending)
+      .filter((key) => !delivered.includes(key));
+    for (const newlyDue of state.announcements) {
+      if (delivered.includes(newlyDue)) continue;
+      pending = addAnnouncementKey(pending, newlyDue);
+    }
+    if (!sameHistory(storedPending, pending)) {
+      await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
+      await writeVariable(gameServerId, mod.moduleId, BLOOD_PENDING_KEY, pending);
+    }
+
+    for (const pendingKey of [...pending]) {
+      const messageKey = messageKeyFor(pendingKey);
+      if (!messageKey) continue;
+      await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
+      const result = await sendDiscord(channelId, resolveMessage(config, messageKey));
+      if (result === null) continue;
+      delivered = addAnnouncementKey(delivered, pendingKey);
+      await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
+      await writeVariable(gameServerId, mod.moduleId, BLOOD_DELIVERED_KEY, delivered);
+      pending = pending.filter((key) => key !== pendingKey);
+      await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
+      await writeVariable(gameServerId, mod.moduleId, BLOOD_PENDING_KEY, pending);
+    }
+  } finally {
+    await releaseBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
+  }
 }
 
 await main();
diff --git a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
index 9b20b7e..84f7e5b 100644
--- a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
+++ b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
@@ -2,6 +2,20 @@ import { takaro } from '@takaro/helpers';
 
 export const STATUS_MESSAGE_KEY_PREFIX = 'discord7d2d:statusMessage:';
 export const BLOOD_STATE_KEY = 'discord7d2d:bloodState';
+export const BLOOD_DELIVERED_KEY = 'discord7d2d:bloodDelivered';
+export const BLOOD_PENDING_KEY = 'discord7d2d:bloodPending';
+export const BLOOD_MONITOR_LOCK_KEY = 'discord7d2d:bloodMonitorLock';
+
+const BLOOD_MONITOR_LOCK_EXPIRY_MS = 120000;
+const BLOOD_MONITOR_LOCK_MAX_ATTEMPTS = 60;
+const BLOOD_MONITOR_LOCK_WAIT_MS = 5000;
+
+async function waitWithoutTimers(milliseconds) {
+  // Takaro's function VM does not expose setTimeout. Atomics.wait provides a
+  // bounded backoff without issuing extra API requests or busy-spinning.
+  const signal = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+  Atomics.wait(signal, 0, 0, milliseconds);
+}
 
 export const MESSAGE_PRESETS = {
   en: {
@@ -178,6 +192,21 @@ async function findVariable(gameServerId, moduleId, key) {
   return res.data.data[0] ?? null;
 }
 
+function parseVariableRecord(record) {
+  if (!record) return null;
+  try { return JSON.parse(record.value); } catch (_err) { return null; }
+}
+
+async function deleteVariableRecord(record) {
+  if (!record) return;
+  try {
+    await takaro.variable.variableControllerDelete(record.id);
+  } catch (err) {
+    const status = err?.response?.status ?? err?.status;
+    if (status !== 404) throw err;
+  }
+}
+
 export async function readVariable(gameServerId, moduleId, key, fallback = null) {
   const record = await findVariable(gameServerId, moduleId, key);
   if (!record) return fallback;
@@ -188,7 +217,101 @@ export async function writeVariable(gameServerId, moduleId, key, value) {
   const existing = await findVariable(gameServerId, moduleId, key);
   const serialized = JSON.stringify(value);
   if (existing) await takaro.variable.variableControllerUpdate(existing.id, { value: serialized });
-  else await takaro.variable.variableControllerCreate({ key, value: serialized, gameServerId, moduleId });
+  else {
+    try {
+      await takaro.variable.variableControllerCreate({ key, value: serialized, gameServerId, moduleId });
+    } catch (err) {
+      const status = err?.response?.status ?? err?.status;
+      if (status !== 409) throw err;
+      for (let attempt = 0; attempt < 3; attempt += 1) {
+        const winner = await findVariable(gameServerId, moduleId, key);
+        if (winner) {
+          await takaro.variable.variableControllerUpdate(winner.id, { value: serialized });
+          return;
+        }
+        if (attempt < 2) await waitWithoutTimers(50 * (attempt + 1));
+      }
+      throw new Error(`Variable '${key}' was created concurrently but could not be found`);
+    }
+  }
+}
+
+export async function acquireBloodMonitorLock(gameServerId, moduleId) {
+  const owner = `blood-monitor:${Date.now()}:${Math.random().toString(36).slice(2)}`;
+  const waitDeadline = Date.now() + BLOOD_MONITOR_LOCK_WAIT_MS;
+  let loggedWait = false;
+
+  for (let attempt = 0; attempt < BLOOD_MONITOR_LOCK_MAX_ATTEMPTS; attempt += 1) {
+    const now = Date.now();
+    try {
+      await takaro.variable.variableControllerCreate({
+        key: BLOOD_MONITOR_LOCK_KEY,
+        value: JSON.stringify({
+          owner,
+          acquiredAt: now,
+          expiresAt: now + BLOOD_MONITOR_LOCK_EXPIRY_MS,
+        }),
+        gameServerId,
+        moduleId,
+      });
+      return owner;
+    } catch (err) {
+      const status = err?.response?.status ?? err?.status;
+      if (status !== 409) throw err;
+    }
+
+    const existing = await findVariable(gameServerId, moduleId, BLOOD_MONITOR_LOCK_KEY);
+    const lock = parseVariableRecord(existing);
+    const expiresAt = Number(lock?.expiresAt);
+    if (existing && (!Number.isFinite(expiresAt) || expiresAt <= Date.now())) {
+      console.warn(`discord-7d2d-status: reclaiming stale Blood Moon monitor lock owned by ${lock?.owner ?? 'unknown'}`);
+      await deleteVariableRecord(existing);
+      continue;
+    }
+
+    if (!loggedWait) {
+      console.log('discord-7d2d-status: Blood Moon monitor lock busy; waiting');
+      loggedWait = true;
+    }
+    if (attempt < BLOOD_MONITOR_LOCK_MAX_ATTEMPTS - 1 && Date.now() < waitDeadline) {
+      const backoffMs = Math.min(50 * (attempt + 1), 250);
+      await waitWithoutTimers(Math.min(backoffMs, waitDeadline - Date.now()));
+    }
+    if (Date.now() >= waitDeadline) break;
+  }
+
+  throw new Error(
+    `Timed out waiting for Blood Moon monitor lock after ${BLOOD_MONITOR_LOCK_WAIT_MS}ms`,
+  );
+}
+
+export async function renewBloodMonitorLock(gameServerId, moduleId, owner) {
+  const existing = await findVariable(gameServerId, moduleId, BLOOD_MONITOR_LOCK_KEY);
+  const lock = parseVariableRecord(existing);
+  if (!existing || lock?.owner !== owner) {
+    throw new Error('Lost Blood Moon monitor lock ownership before completing state mutation');
+  }
+
+  const now = Date.now();
+  if (Number(lock.expiresAt) <= now) {
+    throw new Error('Blood Moon monitor lock lease expired before renewal');
+  }
+  await takaro.variable.variableControllerUpdate(existing.id, {
+    value: JSON.stringify({
+      ...lock,
+      owner,
+      renewedAt: now,
+      expiresAt: now + BLOOD_MONITOR_LOCK_EXPIRY_MS,
+    }),
+  });
+}
+
+export async function releaseBloodMonitorLock(gameServerId, moduleId, owner) {
+  const existing = await findVariable(gameServerId, moduleId, BLOOD_MONITOR_LOCK_KEY);
+  const lock = parseVariableRecord(existing);
+  if (existing && lock?.owner === owner) {
+    await deleteVariableRecord(existing);
+  }
 }
 
 export function getDiscordChannelFromHook(data, configuredChannelId, hookName) {
diff --git a/modules/discord-7d2d-status-bridge/test/bridge.test.ts b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
index 5c50c1a..e81448d 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -27,6 +27,10 @@ const __dirname = path.dirname(__filename);
 const MODULE_DIR = path.resolve(__dirname, '..');
 const MODULE_TO_JSON_SCRIPT = path.resolve(__dirname, '..', '..', '..', 'dist', 'scripts', 'module-to-json.js');
 const TEST_MODULE_NAME = `qa-discord-7d2d-status-bridge-${process.pid}`;
+const TEST_TIME_DAY_7_NOON = 'say Day 7 12:00';
+const TEST_TIME_DAY_7_START = 'say Day 7 22:00';
+const TEST_TIME_DAY_8_AFTER_END = 'say Day 8 05:00';
+const TEST_TIME_COMMANDS = [TEST_TIME_DAY_7_NOON, TEST_TIME_DAY_7_START, TEST_TIME_DAY_8_AFTER_END];
 const DISCORD_TEST_CHANNEL_ID = process.env.TAKARO_DISCORD_TEST_CHANNEL_ID?.trim();
 const DISCORD_FORBIDDEN_CHANNEL_ID = process.env.TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID?.trim();
 const DISCORD_NOT_FOUND_CHANNEL_ID = process.env.TAKARO_DISCORD_NOT_FOUND_CHANNEL_ID?.trim();
@@ -93,9 +97,15 @@ async function pushDisposableBridgeModule(client: Client): Promise<ModuleOutputD
     const moduleJson = JSON.parse(fs.readFileSync(tempFile, 'utf-8')) as {
       name: string;
       supportedGames?: string[];
+      versions: Array<{ configSchema: string }>;
     };
     moduleJson.name = TEST_MODULE_NAME;
     moduleJson.supportedGames = [];
+    const configSchema = JSON.parse(moduleJson.versions[0].configSchema) as {
+      properties: { timeConsoleCommand: { enum: string[] } };
+    };
+    configSchema.properties.timeConsoleCommand.enum.push(...TEST_TIME_COMMANDS);
+    moduleJson.versions[0].configSchema = JSON.stringify(configSchema);
 
     const existing = await client.module.moduleControllerSearch({
       filters: { name: [TEST_MODULE_NAME] },
@@ -148,6 +158,19 @@ async function deleteModuleVariable(
   );
 }
 
+async function readModuleVariable(
+  client: Client,
+  gameServerId: string,
+  moduleId: string,
+  key: string,
+) {
+  const existing = await client.variable.variableControllerSearch({
+    filters: { key: [key], gameServerId: [gameServerId], moduleId: [moduleId] },
+  });
+  const record = existing.data.data[0];
+  return record ? JSON.parse(record.value) as unknown : undefined;
+}
+
 describe('discord-7d2d-status-bridge integration', () => {
   let client: Client;
   let ctx: MockServerContext;
@@ -236,18 +259,21 @@ describe('discord-7d2d-status-bridge integration', () => {
     return execution.logs;
   }
 
-  async function triggerCronjobExecution(name: string): Promise<BridgeExecutionResult> {
+  async function triggerCronjobExecution(
+    name: string,
+    serverContext: MockServerContext = ctx,
+  ): Promise<BridgeExecutionResult> {
     const cronjob = mod.latestVersion.cronJobs.find((candidate) => candidate.name === name);
     assert.ok(cronjob, `Expected cronjob '${name}' to exist`);
     const beforeTrigger = new Date();
     await client.cronjob.cronJobControllerTrigger({
-      gameServerId: ctx.gameServer.id,
+      gameServerId: serverContext.gameServer.id,
       moduleId: mod.id,
       cronjobId: cronjob.id,
     });
     const event = await waitForBridgeEvent(client, {
       eventName: EventSearchInputAllowedFiltersEventNameEnum.CronjobExecuted,
-      gameserverId: ctx.gameServer.id,
+      gameserverId: serverContext.gameServer.id,
       moduleId: mod.id,
       after: beforeTrigger,
       predicate: (candidate) => (
@@ -259,12 +285,58 @@ describe('discord-7d2d-status-bridge integration', () => {
     return { success: result?.success ?? false, logs };
   }
 
-  async function triggerCronjob(name: string): Promise<string[]> {
-    const execution = await triggerCronjobExecution(name);
+  async function triggerCronjob(
+    name: string,
+    serverContext: MockServerContext = ctx,
+  ): Promise<string[]> {
+    const execution = await triggerCronjobExecution(name, serverContext);
     assert.equal(execution.success, true, `Expected cronjob '${name}' to succeed, logs: ${JSON.stringify(execution.logs)}`);
     return execution.logs;
   }
 
+  async function triggerConcurrentCronjobExecutions(
+    name: string,
+    count: number,
+    serverContext: MockServerContext = ctx,
+  ): Promise<BridgeExecutionResult[]> {
+    const cronjob = mod.latestVersion.cronJobs.find((candidate) => candidate.name === name);
+    assert.ok(cronjob, `Expected cronjob '${name}' to exist`);
+    const beforeTrigger = new Date();
+    await Promise.all(Array.from({ length: count }, () => (
+      client.cronjob.cronJobControllerTrigger({
+        gameServerId: serverContext.gameServer.id,
+        moduleId: mod.id,
+        cronjobId: cronjob.id,
+      })
+    )));
+
+    const deadline = Date.now() + 30000;
+    while (Date.now() < deadline) {
+      const events = await client.event.eventControllerSearch({
+        filters: {
+          eventName: [EventSearchInputAllowedFiltersEventNameEnum.CronjobExecuted],
+          gameserverId: [serverContext.gameServer.id],
+          moduleId: [mod.id],
+        },
+        greaterThan: { createdAt: beforeTrigger.toISOString() },
+      });
+      const matching = events.data.data.filter((candidate) => (
+        (candidate.meta as { cronjob?: { id?: string } }).cronjob?.id === cronjob.id
+      ));
+      if (matching.length >= count) {
+        return matching.slice(0, count).map((event) => {
+          const result = (event.meta as { result?: { success?: boolean; logs?: Array<{ msg: string }> } }).result;
+          return {
+            success: result?.success ?? false,
+            logs: (result?.logs ?? []).map((entry) => entry.msg),
+          };
+        });
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    throw new Error(`Timed out waiting for ${count} concurrent '${name}' executions`);
+  }
+
   async function waitForOnlineCount(expected: number) {
     const deadline = Date.now() + 30000;
     while (Date.now() < deadline) {
@@ -483,6 +555,320 @@ describe('discord-7d2d-status-bridge integration', () => {
     assert.ok(!logs.some((message) => message.includes(`/gameserver/${ctx.gameServer.id}/message`)));
   });
 
+  it('persists observed phase but keeps an unconfigured-channel announcement pending', async () => {
+    await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_NOON });
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending');
+
+    const first = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(first.success, true, `Expected first Blood Moon observation to succeed: ${JSON.stringify(first.logs)}`);
+    assert.equal(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState'),
+      'today:7',
+    );
+    assert.deepEqual(
+      (await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered')) ?? [],
+      [],
+    );
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending'),
+      ['today:7'],
+    );
+    const observedWriteLog = first.logs.findIndex((message) => /POST \/variables(?:\s|$)/.test(message));
+    const firstAnnouncementLog = first.logs.findIndex((message) => (
+      message.includes('skipped message: Today is the Blood Moon day...')
+    ));
+    assert.ok(observedWriteLog >= 0, `Expected observed-state variable creation: ${JSON.stringify(first.logs)}`);
+    assert.ok(
+      firstAnnouncementLog > observedWriteLog,
+      `Observed state must be persisted before announcement delivery: ${JSON.stringify(first.logs)}`,
+    );
+
+    const repeated = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(repeated.success, true, `Expected repeated Blood Moon observation to succeed: ${JSON.stringify(repeated.logs)}`);
+    assertLogContains(repeated.logs, 'skipped message: Today is the Blood Moon day...');
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending'),
+      ['today:7'],
+    );
+  });
+
+  it('retains failed announcements in chronological order across a phase transition', async () => {
+    await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_NOON });
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending');
+
+    const today = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+    assert.equal(today.success, true, `Expected today observation to succeed: ${JSON.stringify(today.logs)}`);
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending'),
+      ['today:7'],
+    );
+
+    await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_START });
+    const starting = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(starting.success, true, `Expected start observation to succeed: ${JSON.stringify(starting.logs)}`);
+    assert.equal(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState'),
+      'start:7',
+    );
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending'),
+      ['today:7', 'start:7'],
+    );
+    const todayLog = starting.logs.findIndex((message) => message.includes('skipped message: Today is the Blood Moon day...'));
+    const startLog = starting.logs.findIndex((message) => message.includes('skipped message: Blood Moon is starting...'));
+    assert.ok(todayLog >= 0, `Expected pending today retry: ${JSON.stringify(starting.logs)}`);
+    assert.ok(startLog > todayLog, `Expected start after pending today: ${JSON.stringify(starting.logs)}`);
+
+    const repeated = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+    assert.equal(repeated.success, true, `Expected repeated start observation to succeed: ${JSON.stringify(repeated.logs)}`);
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending'),
+      ['today:7', 'start:7'],
+    );
+  });
+
+  it('serializes concurrent cron state machines without losing pending announcements', async () => {
+    await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_NOON });
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodMonitorLock');
+    const existingPending = Array.from({ length: 3 }, (_value, index) => `end:${index + 1}`);
+    await setModuleVariable(
+      client,
+      noticeCtx.gameServer.id,
+      mod.id,
+      'discord7d2d:bloodPending',
+      existingPending,
+    );
+
+    const executions = await triggerConcurrentCronjobExecutions('bloodMoonMonitor', 2, noticeCtx);
+
+    for (const execution of executions) {
+      assert.equal(execution.success, true, `Concurrent cron must serialize successfully: ${JSON.stringify(execution.logs)}`);
+    }
+    assert.ok(
+      executions.some((execution) => execution.logs.some((message) => message.includes('Blood Moon monitor lock busy; waiting'))),
+      `Expected one concurrent execution to wait for the lock: ${JSON.stringify(executions)}`,
+    );
+    assert.equal(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState'),
+      'today:7',
+    );
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered'),
+      [],
+    );
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending'),
+      [...existingPending, 'today:7'],
+    );
+    assert.equal(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodMonitorLock'),
+      undefined,
+      'The lock must be released after both executions finish',
+    );
+  });
+
+  it('reclaims an expired Blood Moon monitor lock by record id', async () => {
+    await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_NOON });
+    await setModuleVariable(
+      client,
+      noticeCtx.gameServer.id,
+      mod.id,
+      'discord7d2d:bloodMonitorLock',
+      { owner: 'abandoned-execution', acquiredAt: 1, expiresAt: 2 },
+    );
+
+    const execution = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(execution.success, true, `Expired lock recovery must succeed: ${JSON.stringify(execution.logs)}`);
+    assertLogContains(execution.logs, 'reclaiming stale Blood Moon monitor lock owned by abandoned-execution');
+    assert.equal(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodMonitorLock'),
+      undefined,
+      'The replacement owner must release its lock',
+    );
+  });
+
+  it('waits with bounded backoff and does not release another lock owner on timeout', async () => {
+    await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_NOON });
+    const otherOwner = {
+      owner: 'active-other-execution',
+      acquiredAt: Date.now(),
+      expiresAt: Date.now() + 60000,
+    };
+    await setModuleVariable(
+      client,
+      noticeCtx.gameServer.id,
+      mod.id,
+      'discord7d2d:bloodMonitorLock',
+      otherOwner,
+    );
+    const startedAt = Date.now();
+
+    const execution = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+    const elapsedMs = Date.now() - startedAt;
+
+    assert.equal(execution.success, false, `Lock acquisition timeout must fail clearly: ${JSON.stringify(execution.logs)}`);
+    assertLogContains(execution.logs, 'Blood Moon monitor lock busy; waiting');
+    assertLogContains(execution.logs, 'Timed out waiting for Blood Moon monitor lock after 5000ms');
+    assert.ok(elapsedMs >= 4500, `Expected real bounded backoff, but execution returned after ${elapsedMs}ms`);
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodMonitorLock'),
+      otherOwner,
+      'An acquisition failure must not release the active owner',
+    );
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodMonitorLock');
+  });
+
+  it('migrates a matching legacy announcement without duplicating it', async () => {
+    await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_NOON });
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'today:7');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending');
+
+    const execution = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(execution.success, true, `Expected legacy migration to succeed: ${JSON.stringify(execution.logs)}`);
+    assert.ok(
+      !execution.logs.some((message) => message.includes('Today is the Blood Moon day...')),
+      `The current legacy announcement must not duplicate during migration: ${JSON.stringify(execution.logs)}`,
+    );
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered'),
+      ['today:7'],
+    );
+  });
+
+  it('migrates an earlier legacy announcement before recording current work', async () => {
+    await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_NOON });
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'start:6');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending');
+
+    const execution = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(execution.success, true, `Expected legacy migration and current delivery to succeed: ${JSON.stringify(execution.logs)}`);
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered'),
+      ['start:6'],
+    );
+    assertLogContains(execution.logs, 'skipped message: Today is the Blood Moon day...');
+  });
+
+  it('bounds delivered Blood Moon announcement history to 32 unique keys', async () => {
+    await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_NOON });
+    const oversizedHistory = [
+      'start:1',
+      'start:1',
+      ...Array.from({ length: 34 }, (_value, index) => `end:${index + 1}`),
+    ];
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'normal:6');
+    await setModuleVariable(
+      client,
+      noticeCtx.gameServer.id,
+      mod.id,
+      'discord7d2d:bloodDelivered',
+      oversizedHistory,
+    );
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending', []);
+
+    const execution = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(execution.success, true, `Expected bounded delivery tracking to succeed: ${JSON.stringify(execution.logs)}`);
+    const delivered = await readModuleVariable(
+      client,
+      noticeCtx.gameServer.id,
+      mod.id,
+      'discord7d2d:bloodDelivered',
+    ) as string[];
+    assert.equal(delivered.length, 32);
+    assert.equal(new Set(delivered).size, delivered.length);
+    assert.equal(delivered.at(-1), 'end:34');
+    assert.ok(!delivered.includes('today:7'));
+  });
+
+  it('bounds pending Blood Moon announcements to 32 unique chronological keys', async () => {
+    await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_NOON });
+    const oversizedPending = [
+      'start:1',
+      'start:1',
+      ...Array.from({ length: 34 }, (_value, index) => `end:${index + 1}`),
+    ];
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'normal:6');
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered', []);
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending', oversizedPending);
+
+    const execution = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(execution.success, true, `Expected bounded pending tracking to succeed: ${JSON.stringify(execution.logs)}`);
+    const pending = await readModuleVariable(
+      client,
+      noticeCtx.gameServer.id,
+      mod.id,
+      'discord7d2d:bloodPending',
+    ) as string[];
+    assert.equal(pending.length, 32);
+    assert.equal(new Set(pending).size, pending.length);
+    assert.equal(pending.at(-1), 'today:7');
+  });
+
+  it('keeps interval-one current state while prior end and current today remain pending in order', async () => {
+    await installNoticeWithConfig({
+      hordeIntervalDays: 1,
+      firstHordeDay: 7,
+      timeConsoleCommand: TEST_TIME_DAY_8_AFTER_END,
+      privateBloodMoonNoticeOnFirstJoin: true,
+      monitorJoins: false,
+    });
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'start:7');
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered', ['start:7']);
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending', []);
+
+    const first = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(first.success, true, `Expected interval-one overlap to succeed: ${JSON.stringify(first.logs)}`);
+    assert.equal(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState'),
+      'today:8',
+    );
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered'),
+      ['start:7'],
+    );
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending'),
+      ['end:7', 'today:8'],
+    );
+    const endLog = first.logs.findIndex((message) => message.includes('skipped message: Blood Moon is ending...'));
+    const todayLog = first.logs.findIndex((message) => message.includes('skipped message: Today is the Blood Moon day...'));
+    assert.ok(endLog >= 0, `Expected prior end announcement: ${JSON.stringify(first.logs)}`);
+    assert.ok(todayLog > endLog, `Expected current today announcement after prior end: ${JSON.stringify(first.logs)}`);
+
+    const repeated = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+    assert.equal(repeated.success, true, `Expected interval-one repeat to succeed: ${JSON.stringify(repeated.logs)}`);
+    assertLogContains(repeated.logs, 'skipped message: Blood Moon is ending...');
+    assertLogContains(repeated.logs, 'skipped message: Today is the Blood Moon day...');
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending'),
+      ['end:7', 'today:8'],
+    );
+
+    const joinLogs = await triggerHook('player-connected', {
+      playerId: noticeCtx.players[0].playerId,
+      serverContext: noticeCtx,
+    });
+    assertLogContains(joinLogs, `/gameserver/${noticeCtx.gameServer.id}/message 200 OK`);
+    assertLogContains(joinLogs, 'private blood moon first-join notice sent: Today is the Blood Moon day...');
+  });
+
   it('[live smoke] delivers the private notice before a configured Discord join failure remains visible', {
     skip: DISCORD_FORBIDDEN_CHANNEL_ID ? false : 'Live smoke gate skipped: set TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID',
   }, async () => {
@@ -490,8 +876,35 @@ describe('discord-7d2d-status-bridge integration', () => {
     await installNoticeWithConfig({
       monitoringChannelId: DISCORD_FORBIDDEN_CHANNEL_ID,
       privateBloodMoonNoticeOnFirstJoin: true,
+      timeConsoleCommand: TEST_TIME_DAY_7_NOON,
     });
-    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'today:7');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending');
+
+    const firstCron = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(firstCron.success, false, `Configured Discord failure must fail the cron: ${JSON.stringify(firstCron.logs)}`);
+    assert.equal(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState'),
+      'today:7',
+      'Observed phase must persist before Discord delivery',
+    );
+    assert.deepEqual(
+      (await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered')) ?? [],
+      [],
+      'A failed Discord announcement must remain pending',
+    );
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending'),
+      ['today:7'],
+    );
+    assertLogContains(firstCron.logs, `/discord/channels/${DISCORD_FORBIDDEN_CHANNEL_ID}/message`);
+
+    const retryCron = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(retryCron.success, false, `Pending Discord announcement must retry: ${JSON.stringify(retryCron.logs)}`);
+    assertLogContains(retryCron.logs, `/discord/channels/${DISCORD_FORBIDDEN_CHANNEL_ID}/message`);
 
     const execution = await triggerHookExecution('player-connected', {
       playerId: noticeCtx.players[0].playerId,
@@ -504,6 +917,50 @@ describe('discord-7d2d-status-bridge integration', () => {
     assertLogContains(execution.logs, `Takaro or Discord refused delivery to channel ${DISCORD_FORBIDDEN_CHANNEL_ID}`);
   });
 
+  it('[live smoke] records successful interval-one announcements individually and does not duplicate them', {
+    skip: DISCORD_TEST_CHANNEL_ID ? false : 'Live smoke gate skipped: set TAKARO_DISCORD_TEST_CHANNEL_ID',
+  }, async () => {
+    assert.ok(DISCORD_TEST_CHANNEL_ID);
+    await installNoticeWithConfig({
+      hordeIntervalDays: 1,
+      firstHordeDay: 7,
+      monitoringChannelId: DISCORD_TEST_CHANNEL_ID,
+      timeConsoleCommand: TEST_TIME_DAY_8_AFTER_END,
+    });
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'start:7');
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered', ['start:7']);
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending', []);
+
+    const first = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(first.success, true, `Expected Blood Moon Discord delivery to succeed: ${JSON.stringify(first.logs)}`);
+    const successfulSends = first.logs
+      .map((message, index) => ({ message, index }))
+      .filter(({ message }) => message.includes(`/discord/channels/${DISCORD_TEST_CHANNEL_ID}/message 200 OK`));
+    assert.equal(successfulSends.length, 2, `Expected prior end and current today Discord sends: ${JSON.stringify(first.logs)}`);
+    assert.ok(
+      first.logs.slice(successfulSends[0].index + 1, successfulSends[1].index)
+        .some((message) => message.includes('PUT /variables/')),
+      `First successful announcement must be recorded before the second send completes: ${JSON.stringify(first.logs)}`,
+    );
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered'),
+      ['start:7', 'end:7', 'today:8'],
+    );
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending'),
+      [],
+    );
+
+    const repeated = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(repeated.success, true, `Expected completed announcement check to succeed: ${JSON.stringify(repeated.logs)}`);
+    assert.ok(
+      !repeated.logs.some((message) => message.includes(`/discord/channels/${DISCORD_TEST_CHANNEL_ID}/message`)),
+      `A successful announcement must not duplicate: ${JSON.stringify(repeated.logs)}`,
+    );
+  });
+
   it('polls blood moon time without loading players or server metadata', async () => {
     const execution = await triggerCronjobExecution('bloodMoonMonitor');
 
@@ -520,15 +977,31 @@ describe('discord-7d2d-status-bridge integration', () => {
 
   it('does not rewrite an unchanged blood moon phase', async () => {
     await triggerCronjob('bloodMoonMonitor');
+    const before = await client.variable.variableControllerSearch({
+      filters: {
+        key: ['discord7d2d:bloodState'],
+        gameServerId: [ctx.gameServer.id],
+        moduleId: [mod.id],
+      },
+    });
+    const beforeState = before.data.data[0];
+    assert.ok(beforeState, 'Expected the first cron to persist Blood Moon state');
+
     const repeated = await triggerCronjobExecution('bloodMoonMonitor');
 
     assert.equal(repeated.success, true, `Expected repeated blood moon polling to succeed, logs: ${JSON.stringify(repeated.logs)}`);
-    assert.ok(
-      !repeated.logs.some((message) => (
-        /POST \/variables(?:\s|$)/.test(message) || message.includes('PUT /variables/')
-      )),
-      `An unchanged blood moon phase must not be written again: ${JSON.stringify(repeated.logs)}`,
-    );
+    const after = await client.variable.variableControllerSearch({
+      filters: {
+        key: ['discord7d2d:bloodState'],
+        gameServerId: [ctx.gameServer.id],
+        moduleId: [mod.id],
+      },
+    });
+    const afterState = after.data.data[0];
+    assert.ok(afterState, 'Expected the Blood Moon state record to remain present');
+    assert.equal(afterState.id, beforeState.id);
+    assert.equal(afterState.value, beforeState.value);
+    assert.equal(afterState.updatedAt, beforeState.updatedAt, 'An unchanged Blood Moon phase must not be rewritten');
   });
 
   it('uses English monitoring messages by default', async () => {

From dbd0de7684506148e807460adfd2fdc3dcbb64e6 Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Thu, 23 Jul 2026 23:56:31 +0200
Subject: [PATCH 15/17] fix: ignore stale blood moon job config

---
 ...6-07-23-discord-7d2d-blood-state-design.md |   4 +-
 .../2026-07-23-discord-7d2d-blood-state.md    |   4 +-
 .../src/cronjobs/blood-moon-monitor/index.js  |  19 ++-
 .../functions/discord-7d2d-status-helpers.js  |  11 ++
 .../test/bridge.test.ts                       | 123 +++++++++++++++++-
 5 files changed, 152 insertions(+), 9 deletions(-)

diff --git a/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md b/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md
index 23ffbe3..0fdbfea 100644
--- a/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md
+++ b/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md
@@ -16,6 +16,8 @@ Each cron execution persists the observed phase before attempting Discord. It th
 
 Before reading game time or any state, each cron atomically creates the scoped lock with a unique owner token and expiry. A competing execution uses bounded 50-250ms backoff and never enters the state machine until it owns the lock. Because Takaro's function VM does not expose timers, the backoff uses standard `Atomics.wait` rather than issuing artificial API traffic. The owner re-checks and renews its lease after status retrieval, after state reads, before each state mutation, and around every pending send. The 120-second lease is comfortably above Takaro's 30-second production function limit, while renewal also protects longer local executions. Expired or malformed locks are reclaimed by record ID, and `finally` releases only a lock whose current owner token still matches. Acquisition timeout and non-404 release failures remain visible execution failures. Ordinary variable creation also recovers from a create conflict by re-reading the same scoped key and updating the winning record after a small bounded backoff.
 
+Takaro queue jobs contain an installation snapshot captured when they are enqueued. Reinstalling while an older job is queued cannot cancel that job, so after acquiring the lock the monitor fetches the current module installation and uses its current user and system config for time parsing, phase decisions, and channel resolution. A queued execution that outlives an uninstall receives a 404, exits without mutating state, and still releases its lock.
+
 ## Phase and announcement derivation
 
 Observed state and announcements are separate outputs. For ordinary intervals, behavior remains today, start, and end at the existing boundaries. When consecutive days are Blood Moon days, the previous Blood Moon remains active until the configured end hour. At or after that boundary, the current observed state becomes `today:<current day>` and the cron can expose both `end:<previous day>` and `today:<current day>` as ordered announcements.
@@ -33,4 +35,4 @@ When the delivered-history variable does not exist, any legacy announcement-shap
 
 The active WebSocket mock server has no configurable `gettime` response. The disposable test import will extend only its config schema to permit deterministic `say Day <n> <time>` commands. The production code will still execute through Takaro's real command API, and the real mock server returns a parseable `Sent message: Day ...` response. No helper methods, Takaro clients, or module source will be mocked.
 
-Tests will prove observed-state-first behavior, retry bookkeeping, migration, interval-one overlap, stale-lock recovery, bounded acquisition timeout that preserves another owner, and concurrent serialization without lost pending keys through real Takaro variables and cron executions. A configured forbidden Discord channel remains environment-gated.
+Tests will prove observed-state-first behavior, retry bookkeeping, migration, interval-one overlap, stale-lock recovery, bounded acquisition timeout that preserves another owner, current-config resolution for an older queued job, uninstall-gap handling, and concurrent serialization without lost pending keys through real Takaro variables and cron executions. The disposable import moves automatic Blood Moon scheduling to a far-future expression so every execution under test is explicitly triggered; the production manifest schedule is asserted separately. A configured forbidden Discord channel remains environment-gated.
diff --git a/docs/plans/2026-07-23-discord-7d2d-blood-state.md b/docs/plans/2026-07-23-discord-7d2d-blood-state.md
index 4477658..7e1bed8 100644
--- a/docs/plans/2026-07-23-discord-7d2d-blood-state.md
+++ b/docs/plans/2026-07-23-discord-7d2d-blood-state.md
@@ -29,6 +29,8 @@ Allow deterministic test commands such as `say Day 7 12:00` and `say Day 8 05:00
 - Seed an expired monitor lock and assert it is reclaimed and released through the real variable API.
 - Trigger concurrent cron executions with existing pending work and assert one waits for the scoped lock without losing any keys.
 - Seed another active owner and assert acquisition backs off for the bounded interval, fails clearly, and preserves that owner's record.
+- Hold an older queued execution across reinstall and assert it resolves the current installation config instead of writing stale state.
+- Uninstall while a queued execution is held and assert the eventual 404 exits without state mutation while releasing the lock.
 - With the environment-provided forbidden Discord channel, assert the cron fails after persisting observed state, leaves the failed announcement pending, retries it, and the join hook can still PM from the current observed state.
 
 **Step 3: Run RED**
@@ -51,7 +53,7 @@ Return one observed key and an ordered list of announcement descriptors. Consecu
 
 **Step 3: Order persistence and delivery**
 
-Acquire a scoped unique variable lock before reading game time or state. Use an owner token plus expiry, bounded polling with 50-250ms backoff, stale deletion by record ID, owner-checked renewal around external work and mutations, and owner-checked `finally` release. Keep the lease above Takaro's production function runtime bound. Read legacy state/history, persist observed state first, migrate any legacy announcement-shaped state, merge and persist pending work, then send pending announcements in order. Persist each successful key before removing it from pending; keep failures and skips pending. Recover scoped variable create conflicts with a bounded re-search and backoff.
+Acquire a scoped unique variable lock before reading game time or state. Use an owner token plus expiry, bounded polling with 50-250ms backoff, stale deletion by record ID, owner-checked renewal around external work and mutations, and owner-checked `finally` release. Keep the lease above Takaro's production function runtime bound. Fetch the current installation after lock acquisition so an older queued snapshot cannot apply stale user or system config; treat a 404 during an uninstall gap as a safe no-op. Read legacy state/history, persist observed state first, migrate any legacy announcement-shaped state, merge and persist pending work, then send pending announcements in order. Persist each successful key before removing it from pending; keep failures and skips pending. Recover scoped variable create conflicts with a bounded re-search and backoff.
 
 **Step 4: Run GREEN and refactor**
 
diff --git a/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js b/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
index bc611a7..3b09d91 100644
--- a/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
+++ b/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
@@ -4,6 +4,7 @@ import {
   BLOOD_DELIVERED_KEY,
   BLOOD_PENDING_KEY,
   BLOOD_STATE_KEY,
+  getCurrentModuleInstallation,
   getDiscordChannelFromHook,
   getTimeStatus,
   isBloodMoonDay,
@@ -87,11 +88,25 @@ function messageKeyFor(announcementKey) {
 
 async function main() {
   const { gameServerId, module: mod } = data;
-  const config = mod.userConfig;
-  const channelId = getDiscordChannelFromHook(data, config.monitoringChannelId, 'bloodMoonMonitor');
   const lockOwner = await acquireBloodMonitorLock(gameServerId, mod.moduleId);
 
   try {
+    const installation = await getCurrentModuleInstallation(gameServerId, mod.moduleId);
+    await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
+    if (!installation) {
+      console.log('discord-7d2d-status: module installation no longer exists, skipped Blood Moon monitor');
+      return;
+    }
+    const config = installation.userConfig ?? {};
+    const currentData = {
+      ...data,
+      module: {
+        ...mod,
+        userConfig: config,
+        systemConfig: installation.systemConfig ?? {},
+      },
+    };
+    const channelId = getDiscordChannelFromHook(currentData, config.monitoringChannelId, 'bloodMoonMonitor');
     const status = await getTimeStatus(gameServerId, config);
     await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
     const state = stateFor(status, config);
diff --git a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
index 84f7e5b..4f15243 100644
--- a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
+++ b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
@@ -140,6 +140,17 @@ export async function getServerName(gameServerId) {
   }
 }
 
+export async function getCurrentModuleInstallation(gameServerId, moduleId) {
+  try {
+    const res = await takaro.module.moduleInstallationsControllerGetModuleInstallation(moduleId, gameServerId);
+    return res.data.data ?? null;
+  } catch (err) {
+    const status = err?.response?.status ?? err?.status;
+    if (status === 404) return null;
+    throw err;
+  }
+}
+
 export async function executeTimeCommand(gameServerId, command = 'gettime') {
   const res = await takaro.gameserver.gameServerControllerExecuteCommand(gameServerId, { command });
   const data = res?.data?.data ?? res?.data ?? res;
diff --git a/modules/discord-7d2d-status-bridge/test/bridge.test.ts b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
index e81448d..15f59fe 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -31,6 +31,7 @@ const TEST_TIME_DAY_7_NOON = 'say Day 7 12:00';
 const TEST_TIME_DAY_7_START = 'say Day 7 22:00';
 const TEST_TIME_DAY_8_AFTER_END = 'say Day 8 05:00';
 const TEST_TIME_COMMANDS = [TEST_TIME_DAY_7_NOON, TEST_TIME_DAY_7_START, TEST_TIME_DAY_8_AFTER_END];
+const TEST_FAR_FUTURE_CRON = '0 0 1 1 *';
 const DISCORD_TEST_CHANNEL_ID = process.env.TAKARO_DISCORD_TEST_CHANNEL_ID?.trim();
 const DISCORD_FORBIDDEN_CHANNEL_ID = process.env.TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID?.trim();
 const DISCORD_NOT_FOUND_CHANNEL_ID = process.env.TAKARO_DISCORD_NOT_FOUND_CHANNEL_ID?.trim();
@@ -97,7 +98,10 @@ async function pushDisposableBridgeModule(client: Client): Promise<ModuleOutputD
     const moduleJson = JSON.parse(fs.readFileSync(tempFile, 'utf-8')) as {
       name: string;
       supportedGames?: string[];
-      versions: Array<{ configSchema: string }>;
+      versions: Array<{
+        configSchema: string;
+        cronJobs: Array<{ name: string; temporalValue: string }>;
+      }>;
     };
     moduleJson.name = TEST_MODULE_NAME;
     moduleJson.supportedGames = [];
@@ -106,6 +110,9 @@ async function pushDisposableBridgeModule(client: Client): Promise<ModuleOutputD
     };
     configSchema.properties.timeConsoleCommand.enum.push(...TEST_TIME_COMMANDS);
     moduleJson.versions[0].configSchema = JSON.stringify(configSchema);
+    const bloodMoonMonitor = moduleJson.versions[0].cronJobs.find((cronjob) => cronjob.name === 'bloodMoonMonitor');
+    assert.ok(bloodMoonMonitor, 'Expected disposable import to contain bloodMoonMonitor');
+    bloodMoonMonitor.temporalValue = TEST_FAR_FUTURE_CRON;
 
     const existing = await client.module.moduleControllerSearch({
       filters: { name: [TEST_MODULE_NAME] },
@@ -406,11 +413,14 @@ describe('discord-7d2d-status-bridge integration', () => {
   });
 
   it('checks blood moon transitions every minute without changing status updates', () => {
-    const bloodMoonMonitor = mod.latestVersion.cronJobs.find((cronjob) => cronjob.name === 'bloodMoonMonitor');
-    const updateStatus = mod.latestVersion.cronJobs.find((cronjob) => cronjob.name === 'updateStatus');
+    const manifest = JSON.parse(fs.readFileSync(path.join(MODULE_DIR, 'module.json'), 'utf-8')) as {
+      cronJobs: Record<string, { temporalValue: string }>;
+    };
+    const importedBloodMoonMonitor = mod.latestVersion.cronJobs.find((cronjob) => cronjob.name === 'bloodMoonMonitor');
 
-    assert.equal(bloodMoonMonitor?.temporalValue, '* * * * *');
-    assert.equal(updateStatus?.temporalValue, '*/5 * * * *');
+    assert.equal(manifest.cronJobs.bloodMoonMonitor.temporalValue, '* * * * *');
+    assert.equal(manifest.cronJobs.updateStatus.temporalValue, '*/5 * * * *');
+    assert.equal(importedBloodMoonMonitor?.temporalValue, TEST_FAR_FUTURE_CRON);
   });
 
   it('imports the opt-in private Blood Moon notice config with safe defaults', () => {
@@ -728,6 +738,109 @@ describe('discord-7d2d-status-bridge integration', () => {
     await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodMonitorLock');
   });
 
+  it('uses the current installation config when an older queued execution acquires the lock later', async () => {
+    await installNoticeWithConfig({
+      hordeIntervalDays: 1,
+      firstHordeDay: 7,
+      timeConsoleCommand: TEST_TIME_DAY_7_NOON,
+    });
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'start:7');
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered', ['start:7']);
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending', []);
+    await setModuleVariable(
+      client,
+      noticeCtx.gameServer.id,
+      mod.id,
+      'discord7d2d:bloodMonitorLock',
+      { owner: 'test-config-change', acquiredAt: Date.now(), expiresAt: Date.now() + 60000 },
+    );
+    const cronjob = mod.latestVersion.cronJobs.find((candidate) => candidate.name === 'bloodMoonMonitor');
+    assert.ok(cronjob);
+    const beforeTrigger = new Date();
+
+    await client.cronjob.cronJobControllerTrigger({
+      gameServerId: noticeCtx.gameServer.id,
+      moduleId: mod.id,
+      cronjobId: cronjob.id,
+    });
+    await installNoticeWithConfig({
+      hordeIntervalDays: 1,
+      firstHordeDay: 7,
+      timeConsoleCommand: TEST_TIME_DAY_8_AFTER_END,
+    });
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodMonitorLock');
+
+    const event = await waitForBridgeEvent(client, {
+      eventName: EventSearchInputAllowedFiltersEventNameEnum.CronjobExecuted,
+      gameserverId: noticeCtx.gameServer.id,
+      moduleId: mod.id,
+      after: beforeTrigger,
+      predicate: (candidate) => (
+        (candidate.meta as { cronjob?: { id?: string } }).cronjob?.id === cronjob.id
+      ),
+    });
+    const result = (event.meta as { result?: { success?: boolean; logs?: Array<{ msg: string }> } }).result;
+    const logs = (result?.logs ?? []).map((entry) => entry.msg);
+    assert.equal(result?.success, true, `Queued execution must succeed with current config: ${JSON.stringify(logs)}`);
+    assert.equal(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState'),
+      'today:8',
+      'A queued old installation snapshot must not overwrite current Blood Moon state',
+    );
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending'),
+      ['end:7', 'today:8'],
+    );
+  });
+
+  it('exits safely when a queued execution outlives its module installation', async () => {
+    await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_NOON });
+    await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'normal:6');
+    await setModuleVariable(
+      client,
+      noticeCtx.gameServer.id,
+      mod.id,
+      'discord7d2d:bloodMonitorLock',
+      { owner: 'test-uninstall-gap', acquiredAt: Date.now(), expiresAt: Date.now() + 60000 },
+    );
+    const cronjob = mod.latestVersion.cronJobs.find((candidate) => candidate.name === 'bloodMoonMonitor');
+    assert.ok(cronjob);
+    const beforeTrigger = new Date();
+
+    await client.cronjob.cronJobControllerTrigger({
+      gameServerId: noticeCtx.gameServer.id,
+      moduleId: mod.id,
+      cronjobId: cronjob.id,
+    });
+    await uninstallModule(client, mod.id, noticeCtx.gameServer.id);
+    noticeInstalled = false;
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodMonitorLock');
+
+    const event = await waitForBridgeEvent(client, {
+      eventName: EventSearchInputAllowedFiltersEventNameEnum.CronjobExecuted,
+      gameserverId: noticeCtx.gameServer.id,
+      moduleId: mod.id,
+      after: beforeTrigger,
+      predicate: (candidate) => (
+        (candidate.meta as { cronjob?: { id?: string } }).cronjob?.id === cronjob.id
+      ),
+    });
+    const result = (event.meta as { result?: { success?: boolean; logs?: Array<{ msg: string }> } }).result;
+    const logs = (result?.logs ?? []).map((entry) => entry.msg);
+    assert.equal(result?.success, true, `Uninstalled queued execution must exit safely: ${JSON.stringify(logs)}`);
+    assertLogContains(logs, 'module installation no longer exists, skipped Blood Moon monitor');
+    assert.equal(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState'),
+      'normal:6',
+      'An uninstalled queued execution must not mutate observed state',
+    );
+    assert.equal(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodMonitorLock'),
+      undefined,
+      'An uninstalled queued execution must still release its lock',
+    );
+  });
+
   it('migrates a matching legacy announcement without duplicating it', async () => {
     await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_NOON });
     await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'today:7');

From 2938535c4a0415c104f620e91188cd4adebfdb30 Mon Sep 17 00:00:00 2001
From: El-Limon <hendrikvbr@gmail.com>
Date: Fri, 24 Jul 2026 00:07:32 +0200
Subject: [PATCH 16/17] fix: persist blood moon migration before observation

---
 ...6-07-23-discord-7d2d-blood-state-design.md |  6 ++-
 .../2026-07-23-discord-7d2d-blood-state.md    |  3 +-
 .../src/cronjobs/blood-moon-monitor/index.js  | 10 ++--
 .../test/bridge.test.ts                       | 54 +++++++++++++++++--
 4 files changed, 62 insertions(+), 11 deletions(-)

diff --git a/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md b/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md
index 0fdbfea..1d17dfe 100644
--- a/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md
+++ b/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md
@@ -12,7 +12,9 @@ Keep the private first-player Blood Moon notice current even when Discord delive
 - `discord7d2d:bloodMonitorLock` serializes the complete observation and delivery state machine per server and module.
 - Announcement keys remain `today:<day>`, `start:<day>`, and `end:<day>` so legacy `bloodState` values can migrate without translation.
 
-Each cron execution persists the observed phase before attempting Discord. It then migrates any announcement-shaped legacy `bloodState` value into delivered history, merges newly due announcements into pending state, persists the merged pending list, and processes it in order. Each successful announcement is recorded in delivered history before it is removed from pending state. A failed send or an unconfigured-channel skip remains pending across later phase and day transitions without repeating earlier successes.
+Each cron execution first derives and persists delivered history, including migration of any announcement-shaped legacy `bloodState`. Only after that migration is durable does it overwrite the observed phase used by the join hook. It then merges newly due announcements into pending state, persists the merged pending list, and processes it in order. This order prevents a crash after the observed-state write from making an unsent current announcement look like a delivered legacy announcement on the next run. Each successful announcement is recorded in delivered history before it is removed from pending state. A failed send or an unconfigured-channel skip remains pending across later phase and day transitions without repeating earlier successes.
+
+Delivery is intentionally at least once across the external side-effect boundary: if Discord accepts a message and the function crashes before the delivered-history write completes, a later retry can duplicate that message. Discord does not provide an idempotency key for this send operation, so the module prefers a visible duplicate over permanently losing an announcement.
 
 Before reading game time or any state, each cron atomically creates the scoped lock with a unique owner token and expiry. A competing execution uses bounded 50-250ms backoff and never enters the state machine until it owns the lock. Because Takaro's function VM does not expose timers, the backoff uses standard `Atomics.wait` rather than issuing artificial API traffic. The owner re-checks and renews its lease after status retrieval, after state reads, before each state mutation, and around every pending send. The 120-second lease is comfortably above Takaro's 30-second production function limit, while renewal also protects longer local executions. Expired or malformed locks are reclaimed by record ID, and `finally` releases only a lock whose current owner token still matches. Acquisition timeout and non-404 release failures remain visible execution failures. Ordinary variable creation also recovers from a create conflict by re-reading the same scoped key and updating the winning record after a small bounded backoff.
 
@@ -35,4 +37,4 @@ When the delivered-history variable does not exist, any legacy announcement-shap
 
 The active WebSocket mock server has no configurable `gettime` response. The disposable test import will extend only its config schema to permit deterministic `say Day <n> <time>` commands. The production code will still execute through Takaro's real command API, and the real mock server returns a parseable `Sent message: Day ...` response. No helper methods, Takaro clients, or module source will be mocked.
 
-Tests will prove observed-state-first behavior, retry bookkeeping, migration, interval-one overlap, stale-lock recovery, bounded acquisition timeout that preserves another owner, current-config resolution for an older queued job, uninstall-gap handling, and concurrent serialization without lost pending keys through real Takaro variables and cron executions. The disposable import moves automatic Blood Moon scheduling to a far-future expression so every execution under test is explicitly triggered; the production manifest schedule is asserted separately. A configured forbidden Discord channel remains environment-gated.
+Tests will prove migration-before-observation crash ordering, observed-state-before-pending/delivery behavior, retry bookkeeping, interval-one overlap, stale-lock recovery, bounded acquisition timeout that preserves another owner, current-config resolution for an older queued job, uninstall-gap handling, and concurrent serialization without lost pending keys through real Takaro variables and cron executions. The disposable import moves automatic Blood Moon scheduling to a valid dormant expression based on the prior UTC day, whose next occurrence is outside the test run, so every execution under test is explicitly triggered; the production manifest schedule is asserted separately. A configured forbidden Discord channel remains environment-gated.
diff --git a/docs/plans/2026-07-23-discord-7d2d-blood-state.md b/docs/plans/2026-07-23-discord-7d2d-blood-state.md
index 7e1bed8..7507fe2 100644
--- a/docs/plans/2026-07-23-discord-7d2d-blood-state.md
+++ b/docs/plans/2026-07-23-discord-7d2d-blood-state.md
@@ -23,6 +23,7 @@ Allow deterministic test commands such as `say Day 7 12:00` and `say Day 8 05:00
 
 - Run a cron with a parseable day/time response and assert observed state plus delivered-history values.
 - Seed a legacy announcement-shaped state with no delivered history and assert no duplicate current announcement.
+- Assert real variable-operation logs persist migrated delivery history before overwriting observed state, then persist pending work before Discord.
 - For interval `1` at day 8 05:00, assert observed `today:8` and ordered completion of `end:7`, then `today:8`, once each.
 - Advance a failed `today:7` execution to `start:7` and assert both remain pending in chronological order.
 - Trigger concurrent cron executions against absent variables and assert create conflicts recover without duplicate keys.
@@ -53,7 +54,7 @@ Return one observed key and an ordered list of announcement descriptors. Consecu
 
 **Step 3: Order persistence and delivery**
 
-Acquire a scoped unique variable lock before reading game time or state. Use an owner token plus expiry, bounded polling with 50-250ms backoff, stale deletion by record ID, owner-checked renewal around external work and mutations, and owner-checked `finally` release. Keep the lease above Takaro's production function runtime bound. Fetch the current installation after lock acquisition so an older queued snapshot cannot apply stale user or system config; treat a 404 during an uninstall gap as a safe no-op. Read legacy state/history, persist observed state first, migrate any legacy announcement-shaped state, merge and persist pending work, then send pending announcements in order. Persist each successful key before removing it from pending; keep failures and skips pending. Recover scoped variable create conflicts with a bounded re-search and backoff.
+Acquire a scoped unique variable lock before reading game time or state. Use an owner token plus expiry, bounded polling with 50-250ms backoff, stale deletion by record ID, owner-checked renewal around external work and mutations, and owner-checked `finally` release. Keep the lease above Takaro's production function runtime bound. Fetch the current installation after lock acquisition so an older queued snapshot cannot apply stale user or system config; treat a 404 during an uninstall gap as a safe no-op. Read legacy state/history, derive and persist migrated delivery history before overwriting observed state, then merge and persist pending work before sending announcements in order. Persist each successful key before removing it from pending; keep failures and skips pending. Recover scoped variable create conflicts with a bounded re-search and backoff.
 
 **Step 4: Run GREEN and refactor**
 
diff --git a/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js b/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
index 3b09d91..c376f03 100644
--- a/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
+++ b/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
@@ -115,11 +115,6 @@ async function main() {
     const storedPending = await readVariable(gameServerId, mod.moduleId, BLOOD_PENDING_KEY, null);
     await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
 
-    if (previousObserved !== state.observedKey) {
-      await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
-      await writeVariable(gameServerId, mod.moduleId, BLOOD_STATE_KEY, state.observedKey);
-    }
-
     let delivered = normalizeAnnouncementKeys(storedDelivered);
     if (storedDelivered === null && isAnnouncementKey(previousObserved)) {
       delivered = addAnnouncementKey(delivered, previousObserved);
@@ -129,6 +124,11 @@ async function main() {
       await writeVariable(gameServerId, mod.moduleId, BLOOD_DELIVERED_KEY, delivered);
     }
 
+    if (previousObserved !== state.observedKey) {
+      await renewBloodMonitorLock(gameServerId, mod.moduleId, lockOwner);
+      await writeVariable(gameServerId, mod.moduleId, BLOOD_STATE_KEY, state.observedKey);
+    }
+
     let pending = normalizeAnnouncementKeys(storedPending)
       .filter((key) => !delivered.includes(key));
     for (const newlyDue of state.announcements) {
diff --git a/modules/discord-7d2d-status-bridge/test/bridge.test.ts b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
index 15f59fe..c212eda 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -31,7 +31,14 @@ const TEST_TIME_DAY_7_NOON = 'say Day 7 12:00';
 const TEST_TIME_DAY_7_START = 'say Day 7 22:00';
 const TEST_TIME_DAY_8_AFTER_END = 'say Day 8 05:00';
 const TEST_TIME_COMMANDS = [TEST_TIME_DAY_7_NOON, TEST_TIME_DAY_7_START, TEST_TIME_DAY_8_AFTER_END];
-const TEST_FAR_FUTURE_CRON = '0 0 1 1 *';
+const dormantCronDate = new Date(Date.now() - 24 * 60 * 60 * 1000);
+const TEST_DORMANT_CRON = [
+  dormantCronDate.getUTCMinutes(),
+  dormantCronDate.getUTCHours(),
+  dormantCronDate.getUTCDate(),
+  dormantCronDate.getUTCMonth() + 1,
+  '*',
+].join(' ');
 const DISCORD_TEST_CHANNEL_ID = process.env.TAKARO_DISCORD_TEST_CHANNEL_ID?.trim();
 const DISCORD_FORBIDDEN_CHANNEL_ID = process.env.TAKARO_DISCORD_FORBIDDEN_CHANNEL_ID?.trim();
 const DISCORD_NOT_FOUND_CHANNEL_ID = process.env.TAKARO_DISCORD_NOT_FOUND_CHANNEL_ID?.trim();
@@ -112,7 +119,7 @@ async function pushDisposableBridgeModule(client: Client): Promise<ModuleOutputD
     moduleJson.versions[0].configSchema = JSON.stringify(configSchema);
     const bloodMoonMonitor = moduleJson.versions[0].cronJobs.find((cronjob) => cronjob.name === 'bloodMoonMonitor');
     assert.ok(bloodMoonMonitor, 'Expected disposable import to contain bloodMoonMonitor');
-    bloodMoonMonitor.temporalValue = TEST_FAR_FUTURE_CRON;
+    bloodMoonMonitor.temporalValue = TEST_DORMANT_CRON;
 
     const existing = await client.module.moduleControllerSearch({
       filters: { name: [TEST_MODULE_NAME] },
@@ -420,7 +427,7 @@ describe('discord-7d2d-status-bridge integration', () => {
 
     assert.equal(manifest.cronJobs.bloodMoonMonitor.temporalValue, '* * * * *');
     assert.equal(manifest.cronJobs.updateStatus.temporalValue, '*/5 * * * *');
-    assert.equal(importedBloodMoonMonitor?.temporalValue, TEST_FAR_FUTURE_CRON);
+    assert.equal(importedBloodMoonMonitor?.temporalValue, TEST_DORMANT_CRON);
   });
 
   it('imports the opt-in private Blood Moon notice config with safe defaults', () => {
@@ -865,6 +872,15 @@ describe('discord-7d2d-status-bridge integration', () => {
     await setModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState', 'start:6');
     await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered');
     await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending');
+    const stateRecords = await client.variable.variableControllerSearch({
+      filters: {
+        key: ['discord7d2d:bloodState'],
+        gameServerId: [noticeCtx.gameServer.id],
+        moduleId: [mod.id],
+      },
+    });
+    const stateRecord = stateRecords.data.data[0];
+    assert.ok(stateRecord, 'Expected seeded legacy state record');
 
     const execution = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
 
@@ -874,6 +890,38 @@ describe('discord-7d2d-status-bridge integration', () => {
       ['start:6'],
     );
     assertLogContains(execution.logs, 'skipped message: Today is the Blood Moon day...');
+    const commandFinished = execution.logs.findIndex((message) => (
+      message.includes(`/gameserver/${noticeCtx.gameServer.id}/command 200 OK`)
+    ));
+    const deliveredCreated = execution.logs.findIndex((message, index) => (
+      index > commandFinished && /POST \/variables(?:\s|$)/.test(message)
+    ));
+    const observedUpdated = execution.logs.findIndex((message) => (
+      message.includes(`PUT /variables/${stateRecord.id}`)
+    ));
+    const pendingCreated = execution.logs.findIndex((message, index) => (
+      index > observedUpdated && /POST \/variables(?:\s|$)/.test(message)
+    ));
+    const announcementAttempted = execution.logs.findIndex((message) => (
+      message.includes('skipped message: Today is the Blood Moon day...')
+    ));
+    assert.ok(commandFinished >= 0, `Expected current-time command proof: ${JSON.stringify(execution.logs)}`);
+    assert.ok(
+      deliveredCreated > commandFinished,
+      `Delivered history must initialize after deriving current state: ${JSON.stringify(execution.logs)}`,
+    );
+    assert.ok(
+      observedUpdated > deliveredCreated,
+      `Delivered history must persist before observed state changes: ${JSON.stringify(execution.logs)}`,
+    );
+    assert.ok(
+      pendingCreated > observedUpdated,
+      `Observed state must persist before pending work: ${JSON.stringify(execution.logs)}`,
+    );
+    assert.ok(
+      announcementAttempted > pendingCreated,
+      `Pending work must persist before Discord delivery: ${JSON.stringify(execution.logs)}`,
+    );
   });
 
   it('bounds delivered Blood Moon announcement history to 32 unique keys', async () => {

From d7c20a0ebf740e11b8557ff9f7dd073546dc552c Mon Sep 17 00:00:00 2001
From: Harambe <harambe@gettakaro.dev>
Date: Fri, 24 Jul 2026 14:26:04 +0000
Subject: [PATCH 17/17] feat(discord-7d2d-status): support blood moon range

---
 .../discord-7d2d-status-bridge/module.json    |  1 +
 .../src/cronjobs/blood-moon-monitor/index.js  |  4 +--
 .../functions/discord-7d2d-status-helpers.js  | 29 +++++++++++++----
 .../test/bridge.test.ts                       | 32 ++++++++++++++++++-
 4 files changed, 57 insertions(+), 9 deletions(-)

diff --git a/modules/discord-7d2d-status-bridge/module.json b/modules/discord-7d2d-status-bridge/module.json
index ba4e113..309787f 100644
--- a/modules/discord-7d2d-status-bridge/module.json
+++ b/modules/discord-7d2d-status-bridge/module.json
@@ -30,6 +30,7 @@
       "timeConsoleCommand": { "type": "string", "enum": ["gettime"], "default": "gettime" },
       "hordeIntervalDays": { "type": "integer", "minimum": 1, "default": 7 },
       "firstHordeDay": { "type": "integer", "minimum": 1, "default": 7 },
+      "bloodMoonRangeDays": { "type": "integer", "minimum": 0, "default": 0, "description": "7D2D BloodMoonRange setting in days. Use 0 for exact fixed hordes; use 1 when a day-7 horde may happen on days 6-8." },
       "bloodMoonStartHour": { "type": "integer", "minimum": 0, "maximum": 23, "default": 22 },
       "bloodMoonEndHour": { "type": "integer", "minimum": 0, "maximum": 23, "default": 4 },
       "bloodMoonTodayMessage": { "type": "string", "maxLength": 500, "default": "", "description": "Optional blood-moon-day message override." },
diff --git a/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js b/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
index c376f03..24cf571 100644
--- a/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
+++ b/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
@@ -30,9 +30,9 @@ function stateFor(status, config) {
   const interval = config.hordeIntervalDays ?? 7;
   const start = config.bloodMoonStartHour ?? 22;
   const end = config.bloodMoonEndHour ?? 4;
-  const currentIsHorde = isBloodMoonDay(parsed.day, first, interval);
+  const currentIsHorde = isBloodMoonDay(parsed.day, first, interval, config.bloodMoonRangeDays ?? 0);
   const previousDay = parsed.day - 1;
-  const previousIsHorde = parsed.day > 1 && isBloodMoonDay(previousDay, first, interval);
+  const previousIsHorde = parsed.day > 1 && isBloodMoonDay(previousDay, first, interval, config.bloodMoonRangeDays ?? 0);
 
   if (currentIsHorde && parsed.hour !== null && parsed.hour >= start) {
     const key = `start:${parsed.day}`;
diff --git a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
index 4f15243..f9d9f0b 100644
--- a/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
+++ b/modules/discord-7d2d-status-bridge/src/functions/discord-7d2d-status-helpers.js
@@ -91,14 +91,24 @@ export function nextHordeDay(currentDay, firstHordeDay = 7, interval = 7) {
   return firstHordeDay + Math.ceil((currentDay - firstHordeDay) / interval) * interval;
 }
 
-export function isBloodMoonDay(day, firstHordeDay = 7, interval = 7) {
-  return nextHordeDay(day, firstHordeDay, interval) === day;
+export function normalizeBloodMoonRangeDays(range = 0) {
+  const value = Number(range);
+  if (!Number.isFinite(value) || value < 0) return 0;
+  return Math.floor(value);
 }
 
-export function isBloodMoonActive(parsed, firstHordeDay = 7, interval = 7, startHour = 22, endHour = 4) {
+export function isBloodMoonDay(day, firstHordeDay = 7, interval = 7, rangeDays = 0) {
+  const range = normalizeBloodMoonRangeDays(rangeDays);
+  const next = nextHordeDay(day, firstHordeDay, interval);
+  if (Math.abs(next - day) <= range) return true;
+  const previous = next - interval;
+  return previous >= firstHordeDay && Math.abs(day - previous) <= range;
+}
+
+export function isBloodMoonActive(parsed, firstHordeDay = 7, interval = 7, startHour = 22, endHour = 4, rangeDays = 0) {
   if (!parsed || parsed.hour === null) return false;
-  if (isBloodMoonDay(parsed.day, firstHordeDay, interval) && parsed.hour >= startHour) return true;
-  if (parsed.hour < endHour && parsed.day > 1 && isBloodMoonDay(parsed.day - 1, firstHordeDay, interval)) return true;
+  if (isBloodMoonDay(parsed.day, firstHordeDay, interval, rangeDays) && parsed.hour >= startHour) return true;
+  if (parsed.hour < endHour && parsed.day > 1 && isBloodMoonDay(parsed.day - 1, firstHordeDay, interval, rangeDays)) return true;
   return false;
 }
 
@@ -167,7 +177,14 @@ export async function getTimeStatus(gameServerId, config) {
   if (!parsed) console.warn(`discord-7d2d-status: could not parse 7D2D time: ${rawTime}`);
   const day = parsed?.day ?? '?';
   const time = parsed?.time ?? '?';
-  const active = isBloodMoonActive(parsed, config.firstHordeDay ?? 7, config.hordeIntervalDays ?? 7, config.bloodMoonStartHour ?? 22, config.bloodMoonEndHour ?? 4);
+  const active = isBloodMoonActive(
+    parsed,
+    config.firstHordeDay ?? 7,
+    config.hordeIntervalDays ?? 7,
+    config.bloodMoonStartHour ?? 22,
+    config.bloodMoonEndHour ?? 4,
+    config.bloodMoonRangeDays ?? 0,
+  );
   return { rawTime, parsed, day, time, bloodMoonActive: active };
 }
 
diff --git a/modules/discord-7d2d-status-bridge/test/bridge.test.ts b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
index c212eda..65c095d 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -27,10 +27,11 @@ const __dirname = path.dirname(__filename);
 const MODULE_DIR = path.resolve(__dirname, '..');
 const MODULE_TO_JSON_SCRIPT = path.resolve(__dirname, '..', '..', '..', 'dist', 'scripts', 'module-to-json.js');
 const TEST_MODULE_NAME = `qa-discord-7d2d-status-bridge-${process.pid}`;
+const TEST_TIME_DAY_6_START = 'say Day 6 22:00';
 const TEST_TIME_DAY_7_NOON = 'say Day 7 12:00';
 const TEST_TIME_DAY_7_START = 'say Day 7 22:00';
 const TEST_TIME_DAY_8_AFTER_END = 'say Day 8 05:00';
-const TEST_TIME_COMMANDS = [TEST_TIME_DAY_7_NOON, TEST_TIME_DAY_7_START, TEST_TIME_DAY_8_AFTER_END];
+const TEST_TIME_COMMANDS = [TEST_TIME_DAY_6_START, TEST_TIME_DAY_7_NOON, TEST_TIME_DAY_7_START, TEST_TIME_DAY_8_AFTER_END];
 const dormantCronDate = new Date(Date.now() - 24 * 60 * 60 * 1000);
 const TEST_DORMANT_CRON = [
   dormantCronDate.getUTCMinutes(),
@@ -447,6 +448,12 @@ describe('discord-7d2d-status-bridge integration', () => {
       { type: 'string', maxLength: 500, default: '' },
     );
     assert.ok(message?.description, 'Expected the private notice message to have a description');
+    const range = configSchema.properties?.bloodMoonRangeDays;
+    assert.deepEqual(
+      { type: range?.type, default: range?.default },
+      { type: 'integer', default: 0 },
+    );
+    assert.match(range?.description ?? '', /BloodMoonRange/i);
   });
 
   it('privately sends the exact English Blood Moon Today wording to the first online player', async () => {
@@ -613,6 +620,29 @@ describe('discord-7d2d-status-bridge integration', () => {
     );
   });
 
+  it('honors BloodMoonRange by treating adjacent configured days as possible horde days', async () => {
+    await installNoticeWithConfig({
+      timeConsoleCommand: TEST_TIME_DAY_6_START,
+      bloodMoonRangeDays: 1,
+    });
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodDelivered');
+    await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending');
+
+    const execution = await triggerCronjobExecution('bloodMoonMonitor', noticeCtx);
+
+    assert.equal(execution.success, true, `Expected range-aware Blood Moon observation to succeed: ${JSON.stringify(execution.logs)}`);
+    assert.equal(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState'),
+      'start:6',
+    );
+    assert.deepEqual(
+      await readModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodPending'),
+      ['start:6'],
+    );
+    assertLogContains(execution.logs, 'skipped message: Blood Moon is starting...');
+  });
+
   it('retains failed announcements in chronological order across a phase transition', async () => {
     await installNoticeWithConfig({ timeConsoleCommand: TEST_TIME_DAY_7_NOON });
     await deleteModuleVariable(client, noticeCtx.gameServer.id, mod.id, 'discord7d2d:bloodState');