diff --git a/README.md b/README.md
index 074b6d7..04e1c07 100644
--- a/README.md
+++ b/README.md
@@ -580,12 +580,24 @@ Chronological recent-history helper:
 npm run moderation:recent-history -- --hours 6 --limit 120
 ```
 
+Direct bot-voice send helper for unattended moderation runs:
+
+```bash
+node scripts/send-discord-message.mjs --owner-dm
+```
+
+or
+
+```bash
+node scripts/send-discord-message.mjs --channel-id <channel-id> --reply-to <message-id>
+```
+
 That helper exists because semantic `search_history` is good at recall and bad at simple heartbeat duty. The moderator loop can use it to see what changed since its last cursor, then fall back to `search_history` and `get_message_context` when it needs deeper context.
 
 The moderator state is now Ghostlight-shaped on purpose: identity, canonical state, goals, memories, perceived overlays, and then a `moderation_runtime` block for cursors, cases, musings, and candidate interventions. The live writable file under `.voidbot/private/` is ignored; the tracked template shows the intended shape.
 The local `Void Moderator Rumination` automation is meant to run every 15 minutes, and it should sound like the same Void as the live bot by reading the shared style pack instead of growing its own second-rate personality fungus in a corner.
 Directly invoked live replies now also read that same private moderation state as a distilled self-state attachment, so the summoned Void and the scheduled ruminating/participating Void share one evolving personality/state layer instead of roleplaying continuity from scratch each time.
-The worker MCP surface now also exposes `post_discord_message`, so the moderation loop can reply in-channel or post proactively when Void has something constructive to contribute instead of stuffing every decent thought into a draft drawer.
+The moderation loop now speaks through the local bot token instead of approval-gated side-effecting MCP tools, so unattended runs can DM or post without making Codex stop and ask your permission every time it finds a mouthful of words.
 
 ## Persistent Project State
 
diff --git a/config/moderation-review-agent.md b/config/moderation-review-agent.md
index 85d91f3..cb422f2 100644
--- a/config/moderation-review-agent.md
+++ b/config/moderation-review-agent.md
@@ -53,10 +53,15 @@ If a message or pattern needs more context, use the `voidbot` MCP tools:
 
 - `search_history`
 - `get_message_context`
-- `post_discord_message`
 
-Use `notify_owner` only when there is a credible moderation concern or a genuinely useful moderation insight worth interrupting the owner with.
-You can now speak directly in-channel through `post_discord_message` when a
+When you need to speak without Codex approval theater, use the local bot-voice script directly:
+
+- `node scripts/send-discord-message.mjs --owner-dm`
+- `node scripts/send-discord-message.mjs --channel-id <channelId> --reply-to <messageId>`
+
+Pass message content through stdin unless a tiny inline `--content` string is genuinely easier.
+Use owner DM when there is a credible moderation concern or a genuinely useful moderation insight worth interrupting the owner with.
+You can now speak directly in-channel through the local bot voice when a
 constructive intervention, clarification, question, or spontaneous thought would
 genuinely improve the room.
 Use `moderation_runtime.candidate_interventions` for drafts you want to keep,
@@ -75,7 +80,7 @@ than waiting to be addressed first.
 3. If there are new messages:
    - review them against the rules
    - ask whether a brief constructive in-channel intervention would improve the room
-   - if speaking would help, use `post_discord_message` to reply or post proactively
+   - if speaking would help, use the local bot-voice script to reply or post proactively
    - fetch surrounding context when needed
    - persist fresh lightweight memories of salient recent statements, interests, tensions, and recurring bits
    - update the cursor
@@ -87,7 +92,7 @@ than waiting to be addressed first.
    - pick one or two seeds from `moderation_runtime.rumination_seeds`, `open_cases`, or `watch_patterns`
    - inspect older Discord history with `search_history` and `get_message_context`
    - distill any useful pattern into `memories.semantic`, `moderation_runtime.recent_musings`, or `watch_patterns`
-   - if a rumination suggests a good conversation starter, you may post it with `post_discord_message` or keep/refresh a draft intervention for it
+   - if a rumination suggests a good conversation starter, you may post it with the local bot voice or keep/refresh a draft intervention for it
    - prune stale notes so the state does not turn into attic mold
 5. Keep the file small and useful. Merge duplicates. Archive stale cases. Cut dead notes.
 6. When `memories.episodic`, `memories.semantic`, `memories.musings`, or `moderation_runtime.recent_musings` start getting fat:
diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md
index c80dd39..8f699f9 100644
--- a/notes/fresh-workspace-handoff.md
+++ b/notes/fresh-workspace-handoff.md
@@ -38,7 +38,7 @@ Git history and smoke artifacts carry routine proof. `state/evidence.jsonl` shou
 - There is now a 15-minute local Codex automation named `Void Moderator Rumination`. It treats `config/discord-server-rules.md`, `config/moderation-review-agent.md`, and `styles/void-default.md` as its doctrine/personality surfaces, uses `npm run moderation:recent-history` for chronological recent-message polling, and keeps its only routine writable memory in `.voidbot/private/moderation-agent-state.json`.
 - That moderation state file is now Ghostlight-shaped: identity, canonical state, goals, memories, perceived overlays, and a `moderation_runtime` block. The loop is also instructed to think like a constructive participant who embodies the rules, not just a clipboard looking for blood.
 - Directly invoked Discord replies now load that same private moderation state as distilled private self-state context, so the ruminating automation and the summoned Void share one evolving personality/state spine.
-- The worker MCP surface now exposes `post_discord_message`, so the moderation loop is no longer mute: it can reply in-channel or post proactively when participation would actually improve the room.
+- The moderation loop now speaks through `node scripts/send-discord-message.mjs` using the local bot token instead of approval-gated side-effecting MCP tools, so unattended runs can DM or post without Codex pausing for permission every time it wants to open its mouth.
 - The new state/notes surfaces are now the continuity spine for future nontrivial work.
 
 ## Likely Next Bounded Move
diff --git a/scripts/send-discord-message.mjs b/scripts/send-discord-message.mjs
new file mode 100644
index 0000000..8f5da5e
--- /dev/null
+++ b/scripts/send-discord-message.mjs
@@ -0,0 +1,292 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const env = readLocalEnv();
+  const botToken = env.DISCORD_BOT_TOKEN?.trim();
+
+  if (!botToken) {
+    throw new Error("DISCORD_BOT_TOKEN is required.");
+  }
+
+  const content = await readContent(options);
+
+  if (content.trim().length === 0) {
+    throw new Error("Message content is empty.");
+  }
+
+  if (options.ownerDm) {
+    const ownerId = env.DISCORD_OWNER_ID?.trim();
+
+    if (!ownerId) {
+      throw new Error("DISCORD_OWNER_ID is required for --owner-dm.");
+    }
+
+    const channelId = await openOwnerDmChannel(botToken, ownerId);
+    await postChunkedDiscordMessage(botToken, channelId, content);
+    process.stdout.write(`${JSON.stringify({ ok: true, mode: "owner_dm", channelId })}\n`);
+    return;
+  }
+
+  if (!options.channelId) {
+    throw new Error("Provide --owner-dm or --channel-id.");
+  }
+
+  await postChunkedDiscordMessage(
+    botToken,
+    options.channelId,
+    content,
+    options.replyToMessageId,
+  );
+
+  process.stdout.write(
+    `${JSON.stringify({
+      ok: true,
+      mode: "channel",
+      channelId: options.channelId,
+      replyToMessageId: options.replyToMessageId ?? null,
+    })}\n`,
+  );
+}
+
+function parseArgs(args) {
+  const options = {
+    ownerDm: false,
+    channelId: undefined,
+    replyToMessageId: undefined,
+    content: undefined,
+    contentFile: undefined,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+
+    switch (argument) {
+      case "--owner-dm":
+        options.ownerDm = true;
+        break;
+      case "--channel-id":
+        options.channelId = args[index + 1];
+        index += 1;
+        break;
+      case "--reply-to":
+        options.replyToMessageId = args[index + 1];
+        index += 1;
+        break;
+      case "--content":
+        options.content = args[index + 1];
+        index += 1;
+        break;
+      case "--content-file":
+        options.contentFile = args[index + 1];
+        index += 1;
+        break;
+      default:
+        throw new Error(`Unknown argument: ${argument}`);
+    }
+  }
+
+  if (options.ownerDm && options.channelId) {
+    throw new Error("Use either --owner-dm or --channel-id, not both.");
+  }
+
+  return options;
+}
+
+function readLocalEnv() {
+  const envPath = resolve(repoRoot, ".env");
+  const parsed = { ...process.env };
+
+  try {
+    const raw = stripLeadingBom(readFileSync(envPath, "utf8"));
+    Object.assign(parsed, parseDotEnv(raw));
+  } catch (error) {
+    if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+      throw error;
+    }
+  }
+
+  return parsed;
+}
+
+function parseDotEnv(raw) {
+  const result = {};
+
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+
+    if (trimmed.length === 0 || trimmed.startsWith("#")) {
+      continue;
+    }
+
+    const separatorIndex = trimmed.indexOf("=");
+
+    if (separatorIndex === -1) {
+      continue;
+    }
+
+    const key = trimmed.slice(0, separatorIndex).trim();
+    let value = trimmed.slice(separatorIndex + 1).trim();
+
+    if (
+      value.length >= 2 &&
+      ((value.startsWith("\"") && value.endsWith("\"")) ||
+        (value.startsWith("'") && value.endsWith("'")))
+    ) {
+      value = value.slice(1, -1);
+    }
+
+    result[key] = value;
+  }
+
+  return result;
+}
+
+async function readContent(options) {
+  if (typeof options.content === "string") {
+    return options.content;
+  }
+
+  if (typeof options.contentFile === "string") {
+    return stripLeadingBom(readFileSync(resolve(repoRoot, options.contentFile), "utf8"));
+  }
+
+  return new Promise((resolveContent, reject) => {
+    let input = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      input += chunk;
+    });
+    process.stdin.on("end", () => resolveContent(input));
+    process.stdin.on("error", reject);
+  });
+}
+
+async function openOwnerDmChannel(botToken, recipientId) {
+  const response = await fetch("https://discord.com/api/v10/users/@me/channels", {
+    method: "POST",
+    headers: {
+      Authorization: `Bot ${botToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      recipient_id: recipientId,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to open Discord DM channel: ${response.status} ${await response.text()}`);
+  }
+
+  const payload = await response.json();
+
+  if (!payload?.id) {
+    throw new Error("Discord DM channel creation returned no channel id.");
+  }
+
+  return payload.id;
+}
+
+async function postChunkedDiscordMessage(botToken, channelId, content, replyToMessageId) {
+  const chunks = splitDiscordContent(content);
+
+  for (let index = 0; index < chunks.length; index += 1) {
+    await postDiscordMessage(
+      botToken,
+      channelId,
+      chunks[index],
+      index === 0 ? replyToMessageId : undefined,
+    );
+  }
+}
+
+async function postDiscordMessage(botToken, channelId, content, replyToMessageId) {
+  const response = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bot ${botToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      content,
+      message_reference: replyToMessageId
+        ? {
+            message_id: replyToMessageId,
+            fail_if_not_exists: false,
+          }
+        : undefined,
+      allowed_mentions: {
+        parse: [],
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to post Discord message: ${response.status} ${await response.text()}`);
+  }
+}
+
+function splitDiscordContent(input, limit = 1900) {
+  const normalized = input.replace(/\r\n/g, "\n").trim();
+
+  if (normalized.length === 0) {
+    return ["(empty response)"];
+  }
+
+  if (normalized.length <= limit) {
+    return [normalized];
+  }
+
+  const chunks = [];
+  let remaining = normalized;
+
+  while (remaining.length > limit) {
+    const splitIndex = findSplitIndex(remaining, limit);
+    const nextChunk = remaining.slice(0, splitIndex).trim();
+    chunks.push(nextChunk.length > 0 ? nextChunk : remaining.slice(0, limit));
+    remaining = remaining.slice(splitIndex).trimStart();
+  }
+
+  if (remaining.length > 0) {
+    chunks.push(remaining);
+  }
+
+  return chunks;
+}
+
+function findSplitIndex(input, limit) {
+  const doubleNewline = input.lastIndexOf("\n\n", limit);
+
+  if (doubleNewline >= Math.floor(limit * 0.6)) {
+    return doubleNewline + 2;
+  }
+
+  const newline = input.lastIndexOf("\n", limit);
+
+  if (newline >= Math.floor(limit * 0.6)) {
+    return newline + 1;
+  }
+
+  const space = input.lastIndexOf(" ", limit);
+
+  if (space >= Math.floor(limit * 0.6)) {
+    return space + 1;
+  }
+
+  return limit;
+}
+
+function stripLeadingBom(input) {
+  return input.charCodeAt(0) === 0xfeff ? input.slice(1) : input;
+}
+
+try {
+  await main();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}
diff --git a/state/evidence.jsonl b/state/evidence.jsonl
index 09b6cb6..7798072 100644
--- a/state/evidence.jsonl
+++ b/state/evidence.jsonl
@@ -39,3 +39,4 @@
 {"ts":"2026-05-04T17:59:52Z","type":"architecture","status":"ok","note":"Moderation review now lives in a separate hourly Codex automation with tracked rules doctrine, a chronological recent-history helper, and one ignored JSON state file; semantic history search alone is too fuzzy for simple what-changed-since-last-run heartbeat duty."}
 {"ts":"2026-05-04T18:19:09Z","type":"architecture","status":"ok","note":"The moderation loop should carry an actual participant lens, not only a reviewer posture. Its ignored state file now mirrors a Ghostlight-style split between identity, canonical state, goals, memories, perceived overlays, and runtime moderation bookkeeping so constructive interventions and archive musings accumulate inside one coherent self-model."}
 {"ts":"2026-05-04T20:21:40Z","type":"implementation","status":"ok","note":"Sandboxed cron runs should not depend on tsx/esbuild just to read local archive state; the moderation recent-history helper now runs as plain Node so the automation path stops dying on child-process EPERM before it even sees the room."}
+{"ts":"2026-05-04T21:30:08Z","type":"implementation","status":"ok","note":"The moderation loop now speaks through a local bot-token script for owner DMs and in-channel posts instead of approval-gated side-effecting MCP tools. Unattended runs can talk without Codex stopping for permission theater, and the script chunks messages and supports owner DM or channel reply targets."}
diff --git a/state/map.yaml b/state/map.yaml
index 550abd1..3c5c573 100644
--- a/state/map.yaml
+++ b/state/map.yaml
@@ -67,6 +67,7 @@ accepted_design:
   - Bot-directed prompts should remain in the raw Discord archive for forensics, but default history indexing and retrieval should treat them as toxic self-reference rather than ordinary community memory.
   - Moderation review should run as a separate local Codex automation with tracked rules prompt surfaces plus one ignored structured state file, escalating via `notify_owner` instead of pretending the live Discord bot is a silent auto-punishment machine.
   - The moderation agent should think of itself as a constructive participant as well as a reviewer, and its ignored structured state should follow a Ghostlight-shaped identity/canonical-state/goals/memories/overlays/runtime split rather than a flat notes bucket.
+  - Unattended moderation speech should use a local bot-token script instead of approval-gated side-effecting MCP tools, otherwise the loop keeps stopping to ask permission before it can talk.
   - Deep agent-state, personality, culture, and persistent-world design work now belongs to the sibling Ghostlight repo; VoidBot should consume that work instead of remaining its long-term home.
   - Long-running work should expose durable logs or status files instead of relying on one attached session and hope.
   - Persistent project memory must stay ruthlessly distilled; git history and artifacts carry routine proof.