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..1d17dfe
--- /dev/null
+++ b/docs/plans/2026-07-23-discord-7d2d-blood-state-design.md
@@ -0,0 +1,40 @@
+# 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 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 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.
+
+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.
+
+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 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
new file mode 100644
index 0000000..7507fe2
--- /dev/null
+++ b/docs/plans/2026-07-23-discord-7d2d-blood-state.md
@@ -0,0 +1,78 @@
+# 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 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.
+
+---
+
+### 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.
+- 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.
+- 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**
+
+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` and `BLOOD_PENDING_KEY`. Normalize both stored lists to unique announcement keys 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**
+
+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**
+
+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.
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..ee0c14f
--- /dev/null
+++ b/docs/plans/2026-07-23-discord-7d2d-monitoring-feedback-design.md
@@ -0,0 +1,47 @@
+# 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.
+- 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.
+- 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
+
+- 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.
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.
diff --git a/modules/discord-7d2d-status-bridge/module.json b/modules/discord-7d2d-status-bridge/module.json
index af3ca2a..309787f 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}." },
@@ -29,9 +30,11 @@
       "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." },
+      "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." }
     },
@@ -58,7 +61,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/src/cronjobs/blood-moon-monitor/index.js b/modules/discord-7d2d-status-bridge/src/cronjobs/blood-moon-monitor/index.js
index 1d3e164..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
@@ -1,29 +1,161 @@
 import { data } from '@takaro/helpers';
-import { BLOOD_STATE_KEY, getDiscordChannelFromHook, getStatus, isBloodMoonDay, readVariable, resolveMessage, sendDiscord, writeVariable } from './discord-7d2d-status-helpers.js';
+import {
+  acquireBloodMonitorLock,
+  BLOOD_DELIVERED_KEY,
+  BLOOD_PENDING_KEY,
+  BLOOD_STATE_KEY,
+  getCurrentModuleInstallation,
+  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, config.bloodMoonRangeDays ?? 0);
+  const previousDay = parsed.day - 1;
+  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}`;
+    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 getStatus(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));
-  await writeVariable(gameServerId, mod.moduleId, BLOOD_STATE_KEY, phase.key);
+  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);
+    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);
+
+    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);
+    }
+
+    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) {
+      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 ea9894d..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
@@ -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: {
@@ -10,6 +24,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 +39,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...',
@@ -75,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 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) {
+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;
 }
 
@@ -124,6 +150,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;
@@ -134,18 +171,30 @@ 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 };
+  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 };
+}
+
+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) {
@@ -171,6 +220,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;
@@ -181,7 +245,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) {
@@ -189,13 +347,91 @@ 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 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: safeDiscordCause(err) });
+  } catch (_err) {
+    return new Error(message);
+  }
+}
+
+export function normalizeDiscordError(channelId, err) {
+  const status = discordErrorStatus(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} or its guild was not found or is unavailable to the Takaro bot (HTTP 404${codeText}): ${guidance}`, err);
+  }
+
+  const statusText = status === null ? '' : ` (HTTP ${status})`;
+  const requestCode = safeIdentifier(err?.code);
+  const reason = requestCode ? `: request code ${requestCode}` : '';
+  return errorWithSafeCause(`Discord delivery to channel ${channelId} failed${statusText}${reason}`, err);
+}
+
+function shouldReplaceMissingMessage(err) {
+  return discordErrorCode(err) === 10008;
+}
+
 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 +467,9 @@ 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);
+      if (!shouldReplaceMissingMessage(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/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 91889fd..65c095d 100644
--- a/modules/discord-7d2d-status-bridge/test/bridge.test.ts
+++ b/modules/discord-7d2d-status-bridge/test/bridge.test.ts
@@ -26,7 +26,33 @@ 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}`;
+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_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(),
+  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();
+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 {
+  success: boolean;
+  logs: string[];
+}
 
 interface WaitForBridgeEventOptions {
   eventName: EventSearchInputAllowedFiltersEventNameEnum;
@@ -80,9 +106,21 @@ 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;
+        cronJobs: Array<{ name: string; temporalValue: 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 bloodMoonMonitor = moduleJson.versions[0].cronJobs.find((cronjob) => cronjob.name === 'bloodMoonMonitor');
+    assert.ok(bloodMoonMonitor, 'Expected disposable import to contain bloodMoonMonitor');
+    bloodMoonMonitor.temporalValue = TEST_DORMANT_CRON;
 
     const existing = await client.module.moduleControllerSearch({
       filters: { name: [TEST_MODULE_NAME] },
@@ -103,11 +141,58 @@ 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 });
+  }
+}
+
+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)),
+  );
+}
+
+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;
+  let noticeCtx: MockServerContext;
   let mod: ModuleOutputDTO;
   let installed = false;
+  let noticeInstalled = false;
   let playerName: string;
   let playerNames: string[];
 
@@ -123,13 +208,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,
@@ -137,41 +242,114 @@ 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 triggerCronjob(name: string): Promise<string[]> {
+  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) => (
+        (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, `Expected cronjob '${name}' to succeed, logs: ${JSON.stringify(logs)}`);
-    return logs;
+    return { success: result?.success ?? false, logs };
+  }
+
+  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) {
@@ -197,7 +375,8 @@ 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-' });
+    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);
@@ -214,6 +393,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;
@@ -226,6 +411,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 () => {
@@ -234,6 +420,781 @@ describe('discord-7d2d-status-bridge integration', () => {
     assert.ok(logs.length > 0);
   });
 
+  it('checks blood moon transitions every minute without changing status updates', () => {
+    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(manifest.cronJobs.bloodMoonMonitor.temporalValue, '* * * * *');
+    assert.equal(manifest.cronJobs.updateStatus.temporalValue, '*/5 * * * *');
+    assert.equal(importedBloodMoonMonitor?.temporalValue, TEST_DORMANT_CRON);
+  });
+
+  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');
+    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 () => {
+    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 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 ['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('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('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');
+    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('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');
+    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 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);
+
+    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...');
+    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 () => {
+    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 () => {
+    assert.ok(DISCORD_FORBIDDEN_CHANNEL_ID);
+    await installNoticeWithConfig({
+      monitoringChannelId: DISCORD_FORBIDDEN_CHANNEL_ID,
+      privateBloodMoonNoticeOnFirstJoin: true,
+      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 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,
+      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('[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');
+
+    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 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)}`);
+    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 () => {
     await installWithConfig();
 
@@ -351,6 +1312,120 @@ describe('discord-7d2d-status-bridge integration', () => {
     assertLogContains(logs, `Players:\n${expectedPlayers.join('\n')}`);
   });
 
+  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({
+      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('[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({
+      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, /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('[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);
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,