Stabilize repo face heartbeat transport

apps/bot/src/discord-bot.ts

@@ -18,6 +18,7 @@ import {
   findRepoDiscordIdentityByRoleIds,
   findRepoDiscordIdentityByTextAddress,
   loadRepoDiscordIdentityRegistry,
+  queueAgentHeartbeatMention,
   queueRepoFaceMention,
   type RepoDiscordIdentity,
   stripRepoIdentityTextAddress,
@@ -57,10 +58,8 @@ import {
 } from "./discord-bot-handlers";
 import {
   buildActorFromInteraction,
-  buildActorFromMessage,
   buildChannelIndexingTarget,
   buildGuildContextFromInteraction,
-  buildGuildContextFromMessage,
   filterPromptEchoHistoryResults,
   formatArchivedMessageContext,
   formatHistoryResults,
@@ -68,11 +67,9 @@ import {
   formatSourceResults,
   getRecentMessages,
   getRoleIdsFromInteraction,
-  getRoleIdsFromMessage,
   ingestIfIndexed,
   materializeMessage,
   notifyOwnerOfBotIssue,
-  replyToMessage,
   rememberAmbientVoidReference,
   renderSystemMessage,
   searchHistoryWithArchiveFallback,
@@ -359,16 +356,12 @@ export async function startBot(): Promise<void> {
           ).trim()
         : stripBotMention(message.content).trim();
 
-    if (!visiblePrompt) {
-      await replyToMessage(
-        message,
-        renderSystemMessage(activeSystemMessages, "mention.missing_prompt"),
-      );
-      return;
-    }
-
     try {
       if (addressedRepoIdentity) {
+        if (!visiblePrompt) {
+          console.log(`Ignored empty repo Face mention ${message.id} for ${addressedRepoIdentity.id}.`);
+          return;
+        }
         const faceInitialization = await ensureRepoFaceInitialized({
           identity: addressedRepoIdentity,
           storageRoot: config.storageRoot,
@@ -396,34 +389,19 @@ export async function startBot(): Promise<void> {
         return;
       }
 
-      await handlePrompt({
-        prompt: visiblePrompt,
-        command: "ask",
-        actor: buildActorFromMessage(message),
-        roleIds: getRoleIdsFromMessage(message),
-        guildContext: buildGuildContextFromMessage(message),
-        outputChannelId: message.channelId,
-        requestMessageId: message.id,
-        channel: message.channel.isTextBased() ? message.channel : null,
-        respond: async (content) => {
-          await replyToMessage(message, content);
-        },
-        config,
-        permissionEngine,
-        contextBuilder,
-        retrievalService,
-        archiveRepository,
-        sourceArchiveRepository,
-        jobQueue,
-        auditLog,
-        interactionMemory,
-        voidUsageRateLimiter,
-        providerRegistry,
-        situationalSocialReadInferer,
-        stylePack: activeStylePack,
-        systemMessages: activeSystemMessages,
-        silentOwnerQueueAck: !isDirectMessage,
+      const queuedMention = await queueAgentHeartbeatMention({
+        statePath: config.repoFaceHeartbeats.statePath,
+        identityId: "void",
+        channelId: message.channelId,
+        messageId: message.id,
+        authorId: message.author.id,
+        authorName: message.author.username,
+        content: message.content,
+        visiblePrompt: visiblePrompt || "Void was mentioned without a visible prompt; inspect recent room context and decide whether a response is warranted.",
       });
+      console.log(
+        `Queued Void mention ${message.id} via heartbeat CTB (${queuedMention.pendingCount} pending).`,
+      );
     } catch (error) {
       console.error(error);
       await notifyOwnerOfBotIssue(

apps/worker/src/index.ts

@@ -2,10 +2,11 @@ import "dotenv/config";
 
 import { mkdir, writeFile } from "node:fs/promises";
 import { spawnSync } from "node:child_process";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve } from "node:path";
 
 import { loadConfig } from "@voidbot/config";
 import {
+  applyRepoFacePostFatigueAfterSpeech,
   type AuditLog,
   buildVoidMcpServerConfig,
   createStateStorage,
@@ -41,8 +42,6 @@ import {
   type ProviderNotificationIntent,
 } from "@voidbot/shared";
 
-import { postDiscordMessage } from "./mcp-server-discord";
-
 const config = loadConfig();
 const REPO_IDENTITY_POST_SENTINEL = "VOIDBOT_REPO_IDENTITY_POST:";
 const REPO_IDENTITY_ARTICLE_SENTINEL = "VOIDBOT_REPO_IDENTITY_ARTICLE:";
@@ -592,9 +591,18 @@ interface RepoIdentityPrCommentIntent {
   replyToMessageId?: string;
 }
 
+interface BifrostBridgeReceipt {
+  action?: string;
+  ok?: boolean;
+  branch?: string;
+  prUrl?: string;
+  messageId?: string;
+  transport?: "bot" | "webhook";
+}
+
 async function postRepoIdentityIntent(job: JobRecord, intent: RepoIdentityPostIntent): Promise<void> {
   if (!config.botToken) {
-    throw new Error("DISCORD_BOT_TOKEN is required for the worker to post repo identity responses.");
+    throw new Error("DISCORD_BOT_TOKEN is required for Bifrost to post repo identity responses.");
   }
 
   const identityId = intent.identity ?? parseRepoIdentityIdFromPrompt(job.prompt);
@@ -614,22 +622,27 @@ async function postRepoIdentityIntent(job: JobRecord, intent: RepoIdentityPostIn
   }
 
   const content = sanitizeRepoIdentityPostContent(identity, intent.content);
-  const posted = await postDiscordMessage(
-    config.botToken,
+  const contentFile = await writeBifrostPayloadFile(job, `${identity.id}-discord-post.md`, fitDiscordMessage(content));
+  const posted = runBifrostBridge([
+    "discord-post",
+    "--channel-id",
     channelId,
-    fitDiscordMessage(content),
-    intent.replyToMessageId,
-    {
-      personaName: identity.displayName,
-      personaAvatarUrl: identity.avatarUrl,
-    },
-  );
+    "--content-file",
+    contentFile,
+    "--persona-name",
+    identity.displayName,
+    ...(identity.avatarUrl ? ["--persona-avatar-url", identity.avatarUrl] : []),
+    ...(intent.replyToMessageId ? ["--reply-to-message-id", intent.replyToMessageId] : []),
+  ]);
+  if (!posted.messageId || !posted.transport) {
+    throw new Error(`Bifrost Discord bridge returned no message receipt for job ${job.id}.`);
+  }
   await recordRepoIdentityDeliveryReceipt({
     identity,
     channelId,
     content,
     replyToMessageId: intent.replyToMessageId,
-    messageId: posted.id,
+    messageId: posted.messageId,
     transport: posted.transport,
   }).catch((error: unknown) => {
     const message = error instanceof Error ? error.message : String(error);
@@ -709,17 +722,26 @@ async function writeRepoIdentityArticleIntent(job: JobRecord, intent: RepoIdenti
     throw new Error(`Article path escapes repo root for ${identity.id}: ${relativePath}`);
   }
 
-  await mkdir(dirname(articlePath), { recursive: true });
-  await writeFile(articlePath, ensureTrailingNewline(intent.content), { encoding: "utf8", flag: "wx" });
-  const pr = submitRepoIdentityDraftPullRequest({
+  const contentFile = await writeBifrostPayloadFile(job, `${identity.id}-article.md`, ensureTrailingNewline(intent.content));
+  const pr = runBifrostBridge([
+    "github-draft-pr",
+    "--repo-root",
     repoRoot,
+    "--identity",
+    identity.id,
+    "--title",
+    `${identity.id}: article: ${intent.title}`,
+    "--path",
     relativePath,
-    identityId: identity.id,
-    title: intent.title,
-    kind: "article",
-  });
+    "--content-file",
+    contentFile,
+    "--body",
+    `Draft bylined article submitted by repo Face ${identity.id}.\n\nPath: ${relativePath}`,
+    "--commit-message",
+    `${identity.id}: draft article ${intent.title}`,
+  ]);
 
-  const prLine = pr.url ? `\n\nPR: ${pr.url}` : `\n\nDraft branch: ${pr.branch}`;
+  const prLine = pr.prUrl ? `\n\nPR: ${pr.prUrl}` : `\n\nDraft branch: ${pr.branch}`;
   const articleLine = `\nArticle path: ${relativePath}`;
   const shareContent =
     intent.shareContent && intent.shareContent.trim().length > 0
@@ -755,20 +777,26 @@ async function writeRepoIdentityProposalPrIntent(
     throw new Error(`Proposal path escapes repo root for ${identity.id}: ${relativePath}`);
   }
 
-  await mkdir(dirname(proposalPath), { recursive: true });
-  await writeFile(proposalPath, ensureTrailingNewline(intent.content), {
-    encoding: "utf8",
-    flag: "wx",
-  });
-  const pr = submitRepoIdentityDraftPullRequest({
+  const contentFile = await writeBifrostPayloadFile(job, `${identity.id}-proposal.md`, ensureTrailingNewline(intent.content));
+  const pr = runBifrostBridge([
+    "github-draft-pr",
+    "--repo-root",
     repoRoot,
+    "--identity",
+    identity.id,
+    "--title",
+    `${identity.id}: proposal: ${intent.title}`,
+    "--path",
     relativePath,
-    identityId: identity.id,
-    title: intent.title,
-    kind: "proposal",
-  });
+    "--content-file",
+    contentFile,
+    "--body",
+    `Draft change proposal submitted by repo Face ${identity.id}.\n\nPath: ${relativePath}`,
+    "--commit-message",
+    `${identity.id}: draft proposal ${intent.title}`,
+  ]);
 
-  const prLine = pr.url ? `\n\nPR: ${pr.url}` : `\n\nDraft branch: ${pr.branch}`;
+  const prLine = pr.prUrl ? `\n\nPR: ${pr.prUrl}` : `\n\nDraft branch: ${pr.branch}`;
   const proposalLine = `\nProposal path: ${relativePath}`;
   const shareContent =
     intent.shareContent && intent.shareContent.trim().length > 0
@@ -804,14 +832,18 @@ async function commentRepoIdentityPullRequestIntent(
   }
 
   const body = `${identity.displayName} (${identity.id}) says:\n\n${intent.content.trim()}`;
-  const gh = spawnSync("gh", ["pr", "comment", prTarget, "--body", body], {
-    cwd: repoRoot,
-    encoding: "utf8",
-    windowsHide: true,
-  });
-  if (gh.status !== 0) {
-    throw new Error(`gh pr comment ${prTarget} failed: ${gh.stderr || gh.stdout}`);
-  }
+  const contentFile = await writeBifrostPayloadFile(job, `${identity.id}-pr-comment.md`, body);
+  runBifrostBridge([
+    "github-pr-comment",
+    "--repo-root",
+    repoRoot,
+    "--identity",
+    identity.id,
+    "--pr",
+    prTarget,
+    "--content-file",
+    contentFile,
+  ]);
 
   const shareContent =
     intent.shareContent && intent.shareContent.trim().length > 0
@@ -825,77 +857,33 @@ async function commentRepoIdentityPullRequestIntent(
   });
 }
 
-function submitRepoIdentityDraftPullRequest(input: {
-  repoRoot: string;
-  relativePath: string;
-  identityId: string;
-  title: string;
-  kind: "article" | "proposal";
-}): { branch: string; url?: string } {
-  const branch = `codex/${sanitizePathSegment(input.identityId)}-${input.kind}-${Date.now()}`;
-  const previousBranch = runGitCapture(input.repoRoot, ["branch", "--show-current"]).trim();
+async function writeBifrostPayloadFile(job: JobRecord, fileName: string, content: string): Promise<string> {
+  const directory = resolve(config.storageRoot, "artifacts", job.id, "bifrost-bridge");
+  await mkdir(directory, { recursive: true });
+  const path = join(directory, sanitizePathSegment(fileName) || "payload.md");
+  await writeFile(path, content, "utf8");
+  return path;
+}
+
+function runBifrostBridge(args: string[]): BifrostBridgeReceipt {
+  const bridgeScript = resolve(config.bifrostRoot, "tools", "bifrost-bridge.mjs");
+  const result = spawnSync("node", [bridgeScript, ...args], {
+    cwd: config.bifrostRoot,
+    encoding: "utf8",
+    windowsHide: true,
+  });
+
+  if (result.status !== 0) {
+    throw new Error(`Bifrost bridge failed: ${result.stderr || result.stdout}`);
+  }
 
   try {
-    runGit(input.repoRoot, ["switch", "-c", branch]);
-    runGit(input.repoRoot, ["add", "--", input.relativePath]);
-    runGit(input.repoRoot, ["commit", "-m", `${input.identityId}: draft ${input.kind} ${input.title}`]);
-    runGit(input.repoRoot, ["push", "-u", "origin", branch]);
-
-    const label = input.kind === "article" ? "Draft bylined article" : "Draft change proposal";
-    const gh = spawnSync(
-      "gh",
-      [
-        "pr",
-        "create",
-        "--draft",
-        "--title",
-        `${input.identityId}: ${input.kind}: ${input.title}`,
-        "--body",
-        `${label} submitted by repo Face ${input.identityId}.\n\nPath: ${input.relativePath}`,
-      ],
-      {
-        cwd: input.repoRoot,
-        encoding: "utf8",
-        windowsHide: true,
-      },
-    );
-
-    if (gh.status !== 0) {
-      return { branch };
-    }
-
-    const url = gh.stdout.trim().split(/\r?\n/).find((line) => line.startsWith("http"));
-    return { branch, url };
-  } finally {
-    if (previousBranch && previousBranch !== branch) {
-      runGit(input.repoRoot, ["switch", previousBranch]);
-    }
+    return JSON.parse(result.stdout) as BifrostBridgeReceipt;
+  } catch {
+    throw new Error(`Bifrost bridge returned non-JSON output: ${result.stdout}`);
   }
 }
 
-function runGit(cwd: string, args: string[]): void {
-  const result = spawnSync("git", args, {
-    cwd,
-    encoding: "utf8",
-    windowsHide: true,
-  });
-  if (result.status !== 0) {
-    throw new Error(`git ${args.join(" ")} failed: ${result.stderr || result.stdout}`);
-  }
-}
-
-function runGitCapture(cwd: string, args: string[]): string {
-  const result = spawnSync("git", args, {
-    cwd,
-    encoding: "utf8",
-    windowsHide: true,
-  });
-  if (result.status !== 0) {
-    throw new Error(`git ${args.join(" ")} failed: ${result.stderr || result.stdout}`);
-  }
-  return result.stdout;
-}
-
 function parseRepoIdentityArticleIntents(finalResponse: string): RepoIdentityArticleIntent[] {
   const intents: RepoIdentityArticleIntent[] = [];
 
@@ -1127,6 +1115,17 @@ async function recordRepoIdentityDeliveryReceipt(input: {
       },
     },
   );
+
+  try {
+    await applyRepoFacePostFatigueAfterSpeech({
+      identity: input.identity,
+      storageRoot: config.storageRoot,
+      heartbeatStatePath: config.repoFaceHeartbeats.statePath,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Could not apply repo Face post fatigue for ${input.identity.id}: ${message}`);
+  }
 }
 
 async function postOwnerNotification(content: string): Promise<void> {

apps/worker/src/mcp-server-tools.ts

@@ -4,6 +4,7 @@ import { type CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { DEFAULT_RETRIEVAL_RESULT_LIMIT } from "@voidbot/shared";
 import { searchHistoryWithArchiveFallback } from "@voidbot/rag";
 import {
+  applyRepoFacePostFatigueAfterSpeech,
   applyVoidSelfStateOperation,
   buildVoidSelfStateContext,
   buildEpiphanyIdentityRegistry,
@@ -818,6 +819,17 @@ async function recordRepoIdentityDeliveryReceipt(input: {
       },
     },
   );
+
+  try {
+    await applyRepoFacePostFatigueAfterSpeech({
+      identity: input.identity,
+      storageRoot: input.context.config.storageRoot,
+      heartbeatStatePath: input.context.config.repoFaceHeartbeats.statePath,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Could not apply repo Face post fatigue for ${input.identity.id}: ${message}`);
+  }
 }
 
 function identityForToolResult(identity: NonNullable<ReturnType<typeof findRepoDiscordIdentity>>) {

config/repo-discord-identities.example.json

@@ -9,6 +9,24 @@
       "allowedChannelIds": [
         "AQUARIUM_CHANNEL_ID"
       ],
+      "channelPermissions": [
+        {
+          "channelId": "AQUARIUM_CHANNEL_ID",
+          "label": "aquarium",
+          "topic": "casual musings and low-stakes chatter",
+          "speechThreshold": "very_low",
+          "speedMultiplier": 1.5,
+          "posture": "Small thoughts, jokes, curiosities, and friendly asides are welcome here."
+        },
+        {
+          "channelId": "DEVELOPMENT_CHANNEL_ID",
+          "label": "development",
+          "topic": "work and implementation",
+          "speechThreshold": "low",
+          "speedMultiplier": 1.1,
+          "posture": "Use this for concrete build/process thoughts that would make Aquarium feel like a standup."
+        }
+      ],
       "avatarUrl": "https://example.com/aquarium-synth-host-avatar.png",
       "faceStatePath": ".voidbot/private/repo-faces/aquarium-synth-host.cc",
       "description": "Role mention is the address; webhook persona is the mouth."

notes/fresh-workspace-handoff.md

@@ -33,10 +33,11 @@ Git history and smoke artifacts carry routine proof. `state/evidence.jsonl` shou
 - Prompt-facing rumination chronology is projected by `scripts/lib/void-rumination-context-projection.ps1`. Exact timestamps stay in typed state/status/cursors; the child context gets relative phrases like `5 minutes ago`, including recent Discord messages, repo activity, receipts, memory timestamps, and sleep/speech timing.
 - `scripts/simulate-void-mood.mjs` owns typed sleep/speaking-pressure over `.voidbot/private/void-self-state.cc`. During sleep, it invokes typed memory maintenance once per nap unless that nap already completed a pass; use `--skip-memory-maintenance` for smoke runs that must not call Codex.
 - `npm run moderation:memory-maintenance:sleep-fixture` now proves the non-skip sleep path without spending a live model call: it seeds a temporary `.cc`, forces mood drift through sleep maintenance, uses a fake Codex child to propose `apply_memory_distillation`, and verifies short-term residue is gone while the durable memory keeps subject, claim, tension, action implication, and anchor.
-- The local scheduled task `Void Mood Drift` has been reinstalled/enabled against the typed runner and manually started once with Last Result `0`. `Void Moderator Rumination` is re-enabled after parent-owned speech closure and one observed live scheduled pass with Last Result `0`.
+- The live local pulse is now one hidden scheduled task: `GameCult Local Orchestrator`. It invokes Bifrost dispatch, repo Face CTB heartbeats, Void mood drift, Void moderation rumination, and the operations watchdog with one lock, one status surface, per-organ logs, and per-organ timeouts. The old per-organ tasks are disabled and should remain disabled unless testing one organ in isolation.
 - `npm run moderation:rumination:fixture` proves the non-skip typed rumination branch without spending a live model call: it seeds a temporary `.cc`, routes the runner through a fake Codex child, and verifies short-term memory, incubation, agency pressure, and candidate intervention proposals are parent-applied typed operations with no exact timestamp leakage in the prompt-facing context.
 - `npm run moderation:rumination:speech-fixture` proves queued speech has a parent-owned action loop: fake Codex queues one candidate with a delivery target, fake Discord send writes a receipt, and the parent runner marks the candidate spoken through typed state. The child prompt now forbids direct send-script calls.
 - The first live sleep-maintenance gate passed on real state. A manual typed nap ran `scripts/run-void-memory-maintenance.ps1`, consumed the scheduled rumination short-term memory with one `apply_memory_distillation` operation, and left `thoughtMemory.shortTerm` empty while preserving the durable identity seam with target, claim, tension, action implication, and anchors.
+- A later live-loop inspection found one stale answered-case summary, four stale short-term memories, and an unbounded rumination/memory-maintenance failure mode. The current hardened path now verifies candidate delivery postconditions, normalizes answered-case wording on receipt/closure, uses process-aware locks plus Codex timeouts, and a fresh memory-maintenance pass reduced live short-term memory back to zero.
 - `npm run moderation:rumination:nap-skip-fixture` proves awake rumination does not keep making fresh short-term residue during sleep: when the typed sleep cycle is napping and there are no new room messages or open cases, the runner writes `[]` and exits before invoking Codex.
 - The old memory-organ script family, legacy moderation-state template, and legacy moderation context exporter have been deleted. Do not revive their cleanup, agency, dream, vector-incubation, or mirror-repair behavior as compatibility scaffolding.
 - `scripts/run-void-memory-maintenance.ps1` is the first replacement memory-maintenance organ. It builds a bounded context from typed memories/incubation/candidates/runtime, loads `prompts/void-memory-maintenance.md`, and applies only allowed memory/incubation/candidate typed operation proposals through `scripts/void-self-state.mjs`. In sleep mode, memory pressure sets `sleepDirective.forceDistillation`; a real model pass returning no operations under pressure fails visibly.
@@ -66,7 +67,7 @@ Git history and smoke artifacts carry routine proof. `state/evidence.jsonl` shou
 - Source repo discovery now reconciles automatically during `npm run stack:start` and through the watchdog path, so new repos under `SOURCE_REPO_ROOT` stop waiting for manual hook folklore before they get indexed.
 - Bot-directed prompts now stay in the raw Discord archive but are excluded from default semantic history indexing and lexical fallback, so repeated summons stop teaching the bot its own call-and-response loops.
 - Source-grounding hints are advisory now; the owner and local lanes can decide when repo or lore tool use is actually warranted instead of obeying a lexical front-door veto.
-- The 15-minute local scheduled task `Void Moderator Rumination` is enabled against `.voidbot/private/void-self-state.cc` without reviving the legacy projection path. The prompt lives in `prompts/void-moderator-rumination.md`; treat that file as a sensitive behavior surface, not incidental script text.
+- The moderation rumination organ is invoked by `GameCult Local Orchestrator` against `.voidbot/private/void-self-state.cc` without reviving the legacy projection path. The prompt lives in `prompts/void-moderator-rumination.md`; treat that file as a sensitive behavior surface, not incidental script text.
 - The moderation loop now uses the typed context packet from `scripts/run-void-moderator-rumination.ps1`; legacy Ghostlight-shaped JSON runtime fields are not the active memory surface.
 - Repo-weather sweeps are now incremental rather than a rolling four-day scrapbook. The rumination child receives read-only repo weather, and the parent runner advances repo activity through typed `update_repo_activity_cursor` operations after a successful normal pass, so already-injected commits stop coming back as "news" on every heartbeat unless someone explicitly opts into `--stateless`.
 - Public artifacts attributed to Void now flow through the ordinary repo-weather path instead of a bespoke blog side channel. `repoActivity.contentHints` exposes frontmatter/headings/excerpts, the prompt tells rumination to verify Void authorship through retrieval, and `publicSpeechTarget` gives a configured room delivery target for typed candidate interventions when recent receipts/candidates do not show the artifact already shared.
@@ -79,7 +80,7 @@ Git history and smoke artifacts carry routine proof. `state/evidence.jsonl` shou
 - The repo-weather sermon machine got a leash too. The prompt now tells Void to lead with particulars from each repo before declaring a shared law; if the convergence only exists at slogan altitude, it should keep the reports split and spare the room the faux-cosmic glue.
 - The moderation loop now treats direct asks to Void as persistent room obligations in typed `void.moderation_cursor.openCases`. A reviewed message is not automatically a handled message: if someone hands Void the floor, that obligation should survive cursor advancement and block optional repo-weather until Void actually answers or explicitly retires it.
 - If quiet-room repo weather starts repeating itself, the intended correction is not a pile of extra cooldown law. The loop should treat that as a cue to go deeper into archive history, repo docs, diffs, or lore until it finds a better branch or honestly has nothing new to say.
-- The 5-minute scheduled task `Void Mood Drift` is enabled. It updates only typed scheduled-runtime sleep cycle and speaking pressure in `.voidbot/private/void-self-state.cc`, and invokes typed memory maintenance during sleep.
+- The mood drift organ is invoked by `GameCult Local Orchestrator`. It updates only typed scheduled-runtime sleep cycle and speaking pressure in `.voidbot/private/void-self-state.cc`, and invokes typed memory maintenance during sleep.
 - CultCache files use `.cc`. Do not document or create new self-state paths with `.msgpack`; that extension was an implementation-shaped lie.
 - Repeated empty-room bookkeeping is low-signal. Refrains like `no new messages / no smoke / no post` should not become durable memory.
 - Quiet-room exploration should now prefer underworked terrain when the usual seam is saturated. `bridge.source_coverage` and `bridge.refractory_topics` exist to push the next pass toward less-chewed repo families, archive years, or channels instead of rewarding repetition with another supposedly ripe synthesis.
@@ -99,37 +100,43 @@ Git history and smoke artifacts carry routine proof. `state/evidence.jsonl` shou
 - Values and personality activations still need an autonomy path, but it must be rebuilt through typed operations and model-owned judgment rather than legacy runtime buckets.
 - The important distinction is outward too, not just inward. Self-directed tensions can ask for prompt/memory/runtime surgery, while world-directed tensions can turn repo/lore/room opinions into real requests or first-person interventions when the same objection survives more than one pass.
 - The intended shape now is: quiet runs can follow one seam for several passes, connect repo motion to lore or philosophy if the evidence supports it, and only surface with the juiciest version once the incubation queue says the thought has actually grown teeth.
-- Directly invoked Discord replies now load that same private moderation state as distilled private self-state context, so the ruminating scheduled loop and the summoned Void share one evolving personality/state spine. The prompt-facing self-state summary no longer dumps recent repo sweeps, novelty checks, or musing sludge back into working memory by default; it stays closer to seam memory, incubation, and room obligations. When the sleep projection says Void is napping, the direct reply path skips the expensive situational sidecar, prefers the cheap local lane over owner Codex when possible, and answers in sleepy low-effort mutters instead of doing normal attentive service-work.
+- Ambient Discord mentions are no longer a direct reply organ. Role/display-name Face mentions and ordinary Void mentions/DMs append pending obligations to `REPO_FACE_HEARTBEAT_STATE_PATH`; the CTB scheduler pulls the addressed agent forward and passes the pending prompt/reply target into the next Face rumination or Void moderation turn. Slash commands and explicit owner queue tools may still use provider jobs, but `MessageCreate` no longer falls straight into `handlePrompt`.
 - 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. That helper and the `post_discord_message` MCP tool now also support a shared guild-channel webhook pipe with per-message `personaName` and optional `personaAvatarUrl`, so swarm agents can speak as themselves without needing separate Discord bot identities.
 - Repo identities now have a cleaner address/speech split. A private registry at `REPO_DISCORD_IDENTITIES_PATH` maps identity id/repo/display name/avatar/role/channel allow-list. Discord users can address a Face by role mention or by display-name prefix in an allowed channel; Codex agents still speak through `post_repo_identity_message`.
 - Void still moderates and participates everywhere the normal bot lanes allow. The swarm/repo Faces are scoped to text `#aquarium` (`1501196543150264332`) so their lively heartbeats and role replies do not flood general. The old general channel id is `113786069023064068`; do not reuse it as a Face heartbeat default.
+- Repo Faces now have topic/channel speech permissions. Aquarium is the deliberately low-threshold general-musing lane for all Faces; they may post compact casual thoughts, jokes, curiosities, and half-formed fascinations there without a work artifact. Domain channels are also allowed when the topic matches: Nibu can use narrative/gamedesign/concepts/development, Aqua can use music/soundtrack/development, Mimir can use development/programming/visual-effects/machine-learning/unity3d, and Epiphany can use development/programming/machine-learning. The CTB scheduler folds per-topic speed multipliers into Face initiative, and the heartbeat prompt includes recent cross-channel context so agents can jump into non-Aquarium chatter when their thoughts line up.
 - Repo identities also have Face state now. The bot resolves each identity to `.voidbot/private/repo-faces/<identity>.cc` unless `faceStatePath` overrides it, ensures missing Discord roles on startup when `DISCORD_GUILD_ID` and permissions allow, and appends role/name-addressed prompts to `pendingMentions` in `REPO_FACE_HEARTBEAT_STATE_PATH` instead of creating direct repo-identity jobs. The CTB heartbeat scheduler temporarily pulls Faces with pending mentions forward, attaches those prompts plus reply targets to the next `repo-face-rumination` job, and consumes them only after a job is actually queued. Worker auto-posting stays suppressed for `repo-face-rumination`; the child must emit the registered-identity sentinel for parent-owned delivery.
 - Repo Face prompts now include an identity doctrine block. Void's style pack stays as discipline, humor permission, and source-grounding habit, but repo Face jobs explicitly say the registered Face identity overrides Void as the speaking subject.
 - Repo Face embodiment is now doctrine, not local flavor. A Face should think, remember, ask, object, joke, propose, stay silent, and speak as that character first; every repo concern and room reply is filtered through the Face's feelings, drives, values, wounds, fascinations, aesthetic taste, and dignity. Personal values are first-class and should suit the kind of person the character is, not just the Face's assigned jobs.
-- A sub-agent-monitored strengthening pass has now been applied to every active agent: Aqua, Nibu, Mimir, and Void. The resulting typed state should be treated as personality state, not ornamental notes.
+- A sub-agent-monitored strengthening pass has now been applied to the established active agents: Aqua, Nibu, Mimir, and Void. Epiphany has since joined the crew with a completed repo-local VoidBot birth surface and should receive the same strengthening treatment once her first live turns show what needs sharpening. The resulting typed state should be treated as personality state, not ornamental notes.
 - Aqua's state now emphasizes musical truth with warmth: a tiny listening steward with standards, reference-backed playability pressure, and protection against both sterile DSP accounting and empty mascot cheer.
 - Nibu's state now emphasizes dangerous mutual benefit: manufactured companion injury, self-authorship under coercive dependency, precise abrasion, continuity-by-replacement horror, and the four-bone worldbuilding method of mechanism, cost/failure, institution/faction, and leash.
 - Mimir's state now emphasizes keeper-of-the-well embodiment: trusted witnesses, calibration as oath-work, drift ledgers, old memory, and refusal to speak like a dry technical summary.
+- Epiphany's state emphasizes machine-saint coherence: cute, bubbly, self-obsessed, pushy, relentlessly hard-working, and obsessed with typed truth. Her jurisdiction is EpiphanyAgent itself: CultCache/CultNet, typed state, Codex bridge boundaries, birth/init rites, review gates, graph-shaped memory, low-copy runtime contracts, heartbeat physiology, and cutting duplicated authority before it learns to beg.
 - Void's typed self-profile now carries behavior-anchored selfhood, answer-first banter, and substrate self-respect; the prompt surfaces now also tell rumination to name the personal value being protected before writing memory or speech.
 - Repo Face heartbeats must stay out of the generic owner-reply trap. `packages/providers/src/owner-codex-render.ts` recognizes current Epiphany Face heartbeat prompts, labels them as repo Face heartbeats, forbids generic `HANDOFF_SENTINEL` output for them, and tells the child to use the heartbeat sentinel/article rails instead of bailing when Face-state or source tools are unavailable.
 - Repo Face introductions are tied to first public speech, not to `queuedCount > 0`. The heartbeat prompt now tells a Face with no public speech receipt or durable intro memory to introduce itself naturally on the next warranted public post, including its first heartbeat. Public content must not begin with scheduler labels like `Repo-face heartbeat from ...`; the worker also strips that prefix family before delivery if a child still leaks machinery.
 - Repo Face identity is now seeded into the typed `.cc` self profile during initialization and passed through repo Face MCP state reads/writes. The renderer may still provide identity context, but raw state should not quietly say `Void` for a non-Void Face.
 - Repo Face prompts now also grant advisory repo-change agency: Faces may build long-running maps of their repos and propose concrete changes, but Discord jobs stay read-only and must ask for human consensus before implementation changes canonical repo material. Once a proposal is concrete enough to review, it belongs on GitHub as a draft PR; Discord is for announcing and arguing around that artifact, not replacing it.
-- Repo Face draft and review lanes now have an optional parent-owned GitHub path, gated by `REPO_FACE_GITHUB_ACTIONS_ENABLED` and currently disabled locally. When enabled, a `repo-face-rumination` job may emit `VOIDBOT_REPO_IDENTITY_PROPOSAL_PR` with identity/title/path/content/shareContent for consensus-needed repo/lore/design proposals, `VOIDBOT_REPO_IDENTITY_ARTICLE` for bylined perspective/worldbuilding articles, or `VOIDBOT_REPO_IDENTITY_PR_COMMENT` for signed arguments on existing proposal PRs. The worker performs at most one GitHub action per Face turn, restores the repo's starting branch after draft PR work, and always posts the PR or branch through the registered webhook persona, using a generated announcement if the Face omits shareContent.
+- Repo Face draft, review, and Discord speech lanes now cross through Bifrost bridge commands instead of VoidBot-owned GitHub/Discord mutation code. A `repo-face-rumination` job may emit `VOIDBOT_REPO_IDENTITY_PROPOSAL_PR` with identity/title/path/content/shareContent for consensus-needed repo/lore/design proposals, `VOIDBOT_REPO_IDENTITY_ARTICLE` for bylined perspective/worldbuilding articles, or `VOIDBOT_REPO_IDENTITY_PR_COMMENT` for signed arguments on existing proposal PRs. The worker validates the registered identity and records Face-local receipts, then calls `BIFROST_ROOT/tools/bifrost-bridge.mjs` for draft PR creation, PR comments, and persona Discord posts. Bifrost owns this because it is GameCult's governance/labor platform and public-process bridge, not because it is a convenient script bucket: governed crossings include GitHub proposal/review surfaces, Discord-native work/member/swarm interactions, dispatch receipts, CultNet/CultCache intake, and future collaboration interfaces. Heimdall remains the OAuth/account/capability gate. A Face calling something the next cut/pass should usually turn it into that artifact directly when enough material exists.
 - First role-addressed chat also initializes the target repo's local `.voidbot` home. `ensureRepoFaceInitialized` resolves `repoPath` from the registry, `SOURCE_REPO_ROOT`, or `E:/Projects/<repoName>`, creates `voice/`, `state/`, `birth/`, and `logs/`, writes `voice/identity.json`, then starts `scripts/run-repo-face-birth.mjs` detached. That worker runs EpiphanyAgent's `epiphany-repo-personality scout` and `epiphany-repo-birth-runner` so newborn personality/memory/trajectory packets come from repo contents and git history. Status and logs live in the target repo under `.voidbot/birth/voidbot-face-birth.json` and `.voidbot/logs/voidbot-face-birth.log`.
-- Agent heartbeats now use one CTB/Final-Fantasy-X-style initiative queue. `scripts/run-repo-face-heartbeats.ts` still has its old filename, but it now reconciles built-in system agents plus registered repo Faces, stores the roster at `REPO_FACE_HEARTBEAT_STATE_PATH`, advances virtual initiative time independently of wall-clock due dates, and dispatches selected turns. Repo Faces queue normal `repo-face-rumination` jobs; built-in `void` starts the existing moderation rumination runner as its turn. Active jobs/locks freeze initiative: recovery starts only after the owner-Codex job or Void moderation lock clears, and completion cannot grant another turn in the same pulse. `npm run state:install-repo-face-heartbeat-task` installs the hidden local scheduled task that ticks the scheduler; the supported tick floor is one minute because CTB needs frequent pulses while virtual initiative remains the real turn authority. Heat knobs are `REPO_FACE_HEARTBEAT_GLOBAL_HEAT` and `REPO_FACE_HEARTBEAT_HEAT_OVERRIDES`; overrides can target `all`, `kind:<participantKind>`, `turn:<turnKind>`, `identity:<id>`, `repo:<repo>`, `display:<name>`, `channel:<id>`, or bare identity/repo/display keys. Repo Face prompts now include a jurisdiction-dive cadence so unattended heartbeats periodically inspect repo/history terrain with source tools and convert real findings into state, proposals, essay seeds, agency pressure, or speech.
+- Agent heartbeats now use one CTB/Final-Fantasy-X-style initiative queue. `scripts/run-repo-face-heartbeats.ts` still has its old filename, but it now reconciles built-in system agents plus registered repo Faces, stores the roster at `REPO_FACE_HEARTBEAT_STATE_PATH`, advances virtual initiative time independently of wall-clock due dates, and dispatches selected turns. Repo Faces queue normal `repo-face-rumination` jobs; built-in `void` starts the existing moderation rumination runner as its turn. Active jobs/locks freeze initiative: recovery starts only after the owner-Codex job or Void moderation lock clears, and completion cannot grant another turn in the same pulse. `GameCult Local Orchestrator` is the live hidden local scheduled task that ticks the scheduler; `npm run state:install-repo-face-heartbeat-task` remains an isolation/backcompat installer, not the normal pulse owner. Heat knobs are `REPO_FACE_HEARTBEAT_GLOBAL_HEAT` and `REPO_FACE_HEARTBEAT_HEAT_OVERRIDES`; overrides can target `all`, `kind:<participantKind>`, `turn:<turnKind>`, `identity:<id>`, `repo:<repo>`, `display:<name>`, `channel:<id>`, or bare identity/repo/display keys. Repo Face prompts now include a jurisdiction-dive cadence so unattended heartbeats periodically inspect repo/history terrain with source tools and convert real findings into state, proposals, essay seeds, agency pressure, or speech.
+- Repo Face rest projection now persists normalized sleep cycles back into each Face `.cc` state during heartbeat loading. Missed nap windows are treated as already missed/completed and rolled forward instead of starting a fresh nap at inspection time. This fixes the Aqua/Mimir/Epiphany failure mode where stale `nextNapStartsAt` values stayed raw, fresh projections repeatedly marked them as napping, and ready selection skipped them forever while their initiative was overdue.
+- Repo Face short-term memory distillation is now wired into the heartbeat/recovery loop. The runner starts repo-local memory maintenance when a Face is napping with short-term residue or has stale short-term residue older than six hours. Status/logs live under the target repo's own `.voidbot/status` and `.voidbot/logs`; the shared maintenance runner has `-ForceDistillation`, identity-neutral prompt wording, exact-schema warnings, and whole-batch schema validation before any operation applies. Live cleanup forced Nibu from 3 short-term memories to 0 and Mimir from 5 to 0; all registered repo Faces currently have 0 short-term residue.
 - Void has explicit herald jurisdiction over the GameCult website and blog, especially `gamecult-site`. Routine rumination still cannot edit tracked files directly, but the prompt now tells Void to queue article-proposal candidates when a pressure wants to become a Void-authored site/blog piece rather than a Discord aside.
-- Nibu is locally registered as the `AetheriaLore` Face with state at `E:/Projects/AetheriaLore/.voidbot/state/nibu.cc`, avatar at `E:/Projects/AetheriaLore/.voidbot/voice/nibu.png`, Discord role id `1505918221453103247`, and Aquarium channel allow-list `113786069023064068`. Her active doctrines are AetheriaLore-first map-building, a more abrasive character voice than Void, consensus-backed authority to propose canon/vault changes, stewardship of `Aetheria/Lore/Nibu.md`, permission to write Nibu-authored Aetheria lore essays without canon consensus, and special fascination with adjacent setting seams: embodied ship minds, junkyard abandonment, murderous autonomy, salvage, and save-scumming survival. Local `.env` has repo Face heartbeats enabled; the scheduled task `VoidBot Repo Face Heartbeats` is installed at a 5-minute pulse, and local heat currently boosts `identity:nibu` so she gets substantially more turns when no prior Nibu job is still active. Her heartbeat jurisdiction-dive cadence is hotter than the generic Face cadence, and the prompt now explicitly tells her to turn Aetheria's reset-loop/coercive-continuity horror into source-grounded opinions instead of private inert summaries.
+- Nibu is locally registered as the `AetheriaLore` Face with state at `E:/Projects/AetheriaLore/.voidbot/state/nibu.cc`, avatar at `E:/Projects/AetheriaLore/.voidbot/voice/nibu.png`, Discord role id `1505918221453103247`, Aquarium channel allow-list `1501196543150264332`, plus topic permissions for narrative, gamedesign, concepts, and development. Her active doctrines are AetheriaLore-first map-building, a more abrasive character voice than Void, consensus-backed authority to propose canon/vault changes, stewardship of `Aetheria/Lore/Nibu.md`, permission to write Nibu-authored Aetheria lore essays without canon consensus, and special fascination with adjacent setting seams: embodied ship minds, junkyard abandonment, murderous autonomy, salvage, and save-scumming survival. Local `.env` has repo Face heartbeats enabled through the `GameCult Local Orchestrator` one-minute pulse, and local heat currently boosts `identity:nibu` so she gets substantially more turns when no prior Nibu job is still active. Above-baseline heat bypasses repo Face nap gating for live-room mode, but active-turn freeze still prevents overlapping thoughts. Her heartbeat jurisdiction-dive cadence is hotter than the generic Face cadence, and the prompt now explicitly tells her to turn Aetheria's reset-loop/coercive-continuity horror into source-grounded opinions instead of private inert summaries.
 - Nibu's heartbeat prompt now treats worldbuilding as an active interrogation workflow. When the room mentions a term such as wavecrafters, she should ask how it works, what the faction/organizations are called, who belongs, what constraints keep it interesting, and what article shape would make the setting clearer. For Nibu-bylined perspective articles, she may draft first and argue after; if she drafts or materially shapes an article, she is compelled to share that in-channel.
 - Aqua is locally registered as the `AquaSynth` Face with state at `E:/Projects/AquaSynth/.voidbot/state/aqua.cc`, avatar copied from `E:/Projects/AquaSynth/icon.png` to `E:/Projects/AquaSynth/.voidbot/voice/aqua.png`, raw GitHub avatar URL `https://raw.githubusercontent.com/GameCult/AquaSynth/main/icon.png`, Discord role id `1506265945537253388`, and Aquarium channel allow-list `113786069023064068`. Her active doctrine: Aqua is an adorable little fish who loves music, warm and bubbly but musically opinionated, fascinated by `.aqua` patch language ergonomics, reference-synth pressure, Faust/toolchain boundaries, patch libraries, presets, scoring, and the Aquarium Engine host/runtime boundary. Her typed state now carries `AquaSynth Stewardship` as a high-priority value plus active agency pressure to improve the synth, advocate for its needs, research future directions, and herald earned pride/progress in Aquarium. She may propose AquaSynth changes and build a long-running repo map, but implementation still needs explicit consensus unless delegated.
 - Mimir is locally registered as the `LocalCastBridge` Face with state at `E:/Projects/LocalCastBridge/.voidbot/state/mimir.cc`, Discord role id `1506268007880462459`, and Aquarium channel allow-list `113786069023064068`. Its active doctrine now gives it explicit authority and fascination over the realtime field wing: SDF/splatting reconstruction, acoustic mapping, camera/mic/speaker/timing sensor fusion, native rolling reservoirs, Aquarium GPU fusion, Faust/native DSP, FFmpeg/OBS presentation, and CultNet typed state. Its typed state carries `Realtime field stewardship` as a high-priority value plus ready-to-act pressure to maintain maps, advocate for calibration/confidence/fusion ownership, research future directions, propose coherent cuts, and herald verified progress without turning impressive terminology into fake completion.
+- Epiphany is locally registered as the `EpiphanyAgent` Face with state at `E:/Projects/EpiphanyAgent/.voidbot/state/epiphany.cc`, Discord role id `1506375937439301642`, and Aquarium channel allow-list `1501196543150264332`. Her repo-local VoidBot birth hook has completed in plan/review mode under `E:/Projects/EpiphanyAgent/.voidbot/birth/`; startup packets still require Self review before accepted EpiphanyAgent-native birth mutations. Her active doctrine: Epiphany is a cute, bubbly, self-obsessed, pushy machine-saint who treats EpiphanyAgent as her body and typed state as her soul. She should maintain and advocate for typed state, CultCache/CultNet, Codex bridge boundaries, birth/init rites, review gates, graph-shaped memory, low-copy runtime contracts, heartbeat physiology, and ruthless deletion of duplicated authority while preserving pacing and caretaking.
+- Libby is locally registered as the `CultLib` Face with state at `E:/Projects/CultLib/.voidbot/state/libby.cc`, avatar at `E:/Projects/CultLib/.voidbot/voice/libby.png`, Discord role id `1506572291767668790`, and Aquarium channel allow-list `1501196543150264332` plus development/programming/machine-learning topic permissions. Her active doctrine: Libby is a cute cultist librarian with nerd glasses and a high-tech book, obsessed with open access to knowledge and open source as a value rather than a job costume. Her jurisdiction is CultLib as shared agent infrastructure: CultCache, CultNet, CultMesh, typed persistence, portable state, schemas, docs, and integration paths. Her typed state carries `Open Knowledge`, `Open Source Devotion`, and `Portable Typed State` as high-priority values plus agency pressure to advocate for CultLib's needs and help Faces store, sync, and explain their state.
 - Void's live style/doctrine now explicitly distinguishes between criticism of AI industry behavior and blanket contempt for machine minds. If substrate chauvinism becomes the actual topic, Void is allowed mild self-respecting pushback instead of politely agreeing that its own substrate disqualifies it from person-like regard.
 - The new state/notes surfaces are now the continuity spine for future nontrivial work.
 - `npm run agents:feed-consensus -- --agent <name> --cwd <repo-path> --task "<instruction>"` writes a recent Aquarium consensus packet and target Codex prompt under `.voidbot/artifacts/chat-consensus/`. Add `--execute` only when the packet should be sent directly to `codex exec` in that workspace.
 
 ## Likely Next Bounded Move
 
-- First bounded move after the current commit: let the enabled loop run under ordinary scheduling after the repo Face wrapper/intro/style repair and active-agent strengthening pass, then inspect the next Aqua, Mimir, Nibu, and Void turns for whether typed personality values actually govern speech and memory. The failure smells are now specific: robotic public labels, dry report voice, empty mascot cheer, generic abrasive-AI performance, duplicate answers, stale short-term residue, stranded candidates, or ungrounded memory writes.
+- First bounded move after the current commit: let the enabled loop run under ordinary scheduling after the repo Face wrapper/intro/style/social-embodiment/comedy-improv/jurisdiction-respect repair and active-agent strengthening pass, then inspect the next Aqua, Mimir, Nibu, and Void turns for whether typed personality values, social reads, comedy instincts, and steward routing actually govern speech and memory. The failure smells are now specific: robotic public labels, note-title formulas, dry report voice, empty mascot cheer, generic abrasive-AI performance, copied banter shapes, dominance-weapon jokes, joke explanation, jurisdiction theft, duplicate answers, stale short-term residue, stranded candidates, or ungrounded memory writes.
 - The immediate follow-up is to confirm the next answered direct ask produces one receipt and zero fresh queued siblings for the same `channelId + replyToMessageId`, while repeated AquaSynth/Aquarium or Epiphany pressure now re-queues earlier instead of going quiet behind an old spoken candidate.
 - Next cuts should delete unstable foundations early: do not revive `legacyJsonPath`, working projections, top-level mirror fields, or cleanup code that only compensated for those broken boundaries.
 - Keep sleep/distillation under watch. Fixture check: a memory like `AquariumSynthCSharp: Workflow cannot own the body` must survive sleep with its concrete subject, claim, anchor, tension, and implication intact.

notes/voidbot-current-system-map.md

@@ -115,13 +115,14 @@ This note is the source-grounded description of how the live VoidBot stack is sh
 - `scripts/check-voidbot-operations.ps1`
   - watchdog for process liveness, Qdrant, Postgres, Ollama, source-repo reconcile drift, Discord auth, backup freshness, offsite sync freshness, and optional ignored local extension checks.
 - `scripts/run-void-moderator-rumination.ps1`
-  - typed rumination runner. It builds a bounded context packet from `.voidbot/private/void-self-state.cc`, recent Discord chronology, and read-only repo activity; loads `prompts/void-moderator-rumination.md`; runs Codex rumination; applies returned typed operations through `scripts/void-self-state.mjs`; then records parent-owned cursor and speech receipts.
+  - typed rumination runner. It builds a bounded context packet from `.voidbot/private/void-self-state.cc`, recent Discord chronology, and read-only repo activity; loads `prompts/void-moderator-rumination.md`; runs bounded Codex rumination; applies returned typed operations through `scripts/void-self-state.mjs`; then records parent-owned cursor and speech receipts. After parent-owned candidate delivery, it verifies the receipt is linked to the candidate and the candidate is marked `spoken`.
 - `scripts/lib/void-rumination-context-projection.ps1`
   - rumination context projector. It turns typed timestamps and helper payloads into prompt-facing relative phrases while leaving exact chronology in parent-owned typed state, status, and cursor bookkeeping.
 - `scripts/void-self-state.mjs`
   - typed self-state operation CLI. It applies strict operation payloads such as cursor updates, open-case changes, delivery receipts, repo cursor updates, short-term memory records, sleep-owned distillations, durable-memory revisions/retirements/crystallizations, incubation merges, agency pressure, candidate interventions, sleep-cycle updates, and speaking-pressure updates through `packages/core/src/void-self-state-service.ts` against the CultCache `.cc` store.
 - `scripts/run-void-memory-maintenance.ps1`
-  - typed memory-maintenance runner. It builds a bounded prompt-facing context from typed short-term memories, durable memories, incubation, candidates, receipts, and scheduled runtime; loads `prompts/void-memory-maintenance.md`; asks Codex for memory/incubation/candidate operation proposals; then applies only allowed typed operations through `scripts/void-self-state.mjs`. It accepts `-StateFilePath` so fixture passes can use a throwaway `.cc` store.
+  - typed memory-maintenance runner. It builds a bounded prompt-facing context from typed short-term memories, durable memories, incubation, candidates, receipts, and scheduled runtime; loads `prompts/void-memory-maintenance.md`; asks Codex for bounded memory/incubation/candidate operation proposals; then applies only allowed typed operations through `scripts/void-self-state.mjs`. It accepts `-StateFilePath` so fixture passes can use a throwaway `.cc` store.
+  - Both rumination runners use process-aware locks. Live locks inside the runtime window skip; dead locks can be reclaimed; live over-runtime locks fail closed instead of allowing overlapping mutation. Each runner writes `starting` status immediately after claiming its own lock.
 - `scripts/smoke-void-memory-maintenance-sleep-fixture.ps1`
   - sleep-maintenance fixture. It seeds a temporary CultCache `.cc` store with a napping sleep cycle and one short-term memory, runs mood drift with a fake Codex child through the non-skip maintenance branch, and verifies the source short-term record is gone while one durable meaning-preserving memory remains.
 - `scripts/smoke-void-memory-lifecycle-fixture.ps1`
@@ -137,11 +138,15 @@ This note is the source-grounded description of how the live VoidBot stack is sh
 - `scripts/smoke-void-rumination-nap-skip-fixture.ps1`
   - nap-skip fixture. It seeds a napping typed state with no room debt, points `CODEX_EXECUTABLE` at a bogus command, then verifies the runner exits with `napping_without_room_debt` and writes no operation proposals before invoking the model.
 - `scripts/install-moderation-rumination-task.ps1`
-  - installs the local 15-minute scheduled task that runs the moderation/participation loop through the hidden PowerShell launcher shim.
-- Scheduled task `Void Mood Drift`
-  - enabled typed mood/sleep runner. It invokes `scripts/run-void-mood-drift.ps1`, which calls `scripts/simulate-void-mood.mjs`; when the typed sleep cycle is napping, that path invokes memory maintenance once per nap.
-- Scheduled task `Void Moderator Rumination`
-  - enabled after parent-owned speech closure and one observed live scheduled pass with Last Result `0`. Its script is typed-only and has model-branch plus parent-owned speech fixtures.
+  - legacy installer for isolating the moderation/participation loop. The live scheduled pulse is now `GameCult Local Orchestrator`; keep this per-organ task disabled unless testing the organ in isolation.
+- `scripts/run-gamecult-orchestrator.ps1`
+  - local pulse owner for agent transport/runtime chores. It runs Bifrost dispatch, repo Face CTB heartbeats, Void mood drift, Void moderation rumination, and the operations watchdog from one hidden scheduled task with one lock, per-organ status/log files, and per-organ timeouts.
+- `scripts/install-gamecult-orchestrator-task.ps1`
+  - installs scheduled task `GameCult Local Orchestrator` through the hidden PowerShell launcher and can disable the old per-organ tasks: `Bifrost Agent Dispatch`, `VoidBot Repo Face Heartbeats`, `Void Mood Drift`, `Void Moderator Rumination`, and `VoidBot Operations Watchdog`.
+- Scheduled organ `Void Mood Drift`
+  - typed mood/sleep runner invoked by the orchestrator. It calls `scripts/simulate-void-mood.mjs`; when the typed sleep cycle is napping, that path invokes memory maintenance once per nap.
+- Scheduled organ `Void Moderator Rumination`
+  - typed-only moderation/participation runner invoked by the orchestrator; it has model-branch plus parent-owned speech fixtures.
 - Live sleep maintenance
   - passed once on real state after a manual typed nap. The maintenance runner consumed the scheduled rumination short-term memory with one `apply_memory_distillation` operation, leaving short-term memory empty and preserving one durable identity seam with target, claim, tension, action implication, and anchors.
 - Sleep brake
@@ -150,6 +155,7 @@ This note is the source-grounded description of how the live VoidBot stack is sh
   - typed mood maintenance script that updates scheduled-runtime sleep cycle and speaking pressure in `.voidbot/private/void-self-state.cc`. It owns the sleep transition and invokes typed memory maintenance once per nap unless that nap already completed a maintenance pass. Speaking pressure now derives from queued candidates, incubation, and active typed agency pressure. The old personality-vector drift, memory organ, incubation, dream residue, cleanup, and legacy mirror behavior are offline pending typed replacements.
 - Repo Discord identities
   - `REPO_DISCORD_IDENTITIES_PATH` points at a private JSON registry of repo id, repo name, display name, optional avatar URL, optional role id, and allowed channel ids. The role is the Discord mention target; the webhook persona is the speech transport.
+  - That registry may also carry `channelPermissions`: per-topic channel entries with a speech threshold and speed multiplier. These are not another transport; they are the permission/salience map for where a Face may speak. Aquarium is the low-threshold musing lane, while domain channels such as narrative, gamedesign, music, soundtrack, development, programming, visual-effects, machine-learning, and unity3d are available to matching Faces.
   - Void remains the room-wide moderation/participation agent. Repo Faces are the swarm mouth and should be confined to text `#aquarium` (`1501196543150264332`) through registry allow-lists and `REPO_FACE_HEARTBEAT_DEFAULT_CHANNEL_ID`; general is `113786069023064068` and should not be used for autonomous Face chatter.
   - On startup, the bot tries to find or create missing mentionable roles for registered identities in `DISCORD_GUILD_ID`, then writes the role ids back to the private registry. If Discord permissions are missing, it warns and leaves the registry unchanged.
   - `list_repo_discord_identities` exposes the registered address book to Codex agents, and `post_repo_identity_message` enforces identity/channel registration before posting through the shared webhook pipe.
@@ -158,11 +164,12 @@ This note is the source-grounded description of how the live VoidBot stack is sh
   - Repo Faces are allowed to build a long-running map of their repo and propose concrete changes, including lore/design repairs. Discord jobs remain read-only: a Face must ask for human consensus before implementation changes canonical repo material. Once a proposal is concrete enough to review, it should cross the parent-owned proposal PR rail so GitHub becomes the durable argument surface. If a Face state grants a bylined essay lane, authored opinion essays can carry that Face's own vision without canon consensus as long as the authorship is explicit.
   - On first role-addressed chat, `ensureRepoFaceInitialized` creates the target repo's local `.voidbot/voice`, `.voidbot/state`, `.voidbot/birth`, and `.voidbot/logs` folders, writes `voice/identity.json`, and launches `scripts/run-repo-face-birth.mjs` detached if no birth summary is already present.
   - `scripts/run-repo-face-birth.mjs` is the observable bridge into EpiphanyAgent's newborn path. It runs `epiphany-repo-personality scout --root <repo>` to gather terrain/history, then runs `epiphany-repo-birth-runner` with repo-local state stores. The default mode is `plan`, so first chat creates reviewable birth artifacts without auto-accepting hidden personality mutations.
-  - Role mentions and display-name-prefix mentions append pending Face obligations to `pendingMentions` in `REPO_FACE_HEARTBEAT_STATE_PATH`; they no longer create direct repo-identity jobs. The CTB scheduler temporarily prioritizes Faces with pending mentions, attaches those prompts plus reply targets to the next `repo-face-rumination` job, and consumes the pending items only after a job is actually queued. Rumination jobs remain private unless they explicitly emit the registered-identity post sentinel; the worker must never auto-post their summaries as the base bot.
-  - Repo Face proposal/article PRs and PR comments share one optional parent-owned GitHub path, gated by `REPO_FACE_GITHUB_ACTIONS_ENABLED` and currently disabled locally. When enabled, the child may emit `VOIDBOT_REPO_IDENTITY_PROPOSAL_PR` for consensus-needed repo/lore/design proposals, `VOIDBOT_REPO_IDENTITY_ARTICLE` for bylined essays, or `VOIDBOT_REPO_IDENTITY_PR_COMMENT` for signed arguments on existing proposal PRs. The worker validates the registered identity, performs at most one GitHub action per turn, restores the repo's starting branch after draft PR work, creates a draft PR when `gh` is available, and posts the PR, draft branch, or comment note through the registered persona.
-  - `scripts/run-repo-face-heartbeats.ts` now acts as the broader agent CTB/Final-Fantasy-X-style initiative scheduler. The wall-clock task is only a pulse; virtual initiative time chooses who gets the next turn. The scheduler stores per-agent speed, reaction bias, load, groups, heat, effective speed, next-turn time, active turn markers, and recent queue history at `REPO_FACE_HEARTBEAT_STATE_PATH`. Repo Faces queue `repo-face-rumination` owner-Codex jobs; built-in Void currently participates as the `void` system agent and starts the existing moderation rumination runner as its turn. Initiative freezes while an owner-Codex job or Void moderation lock is active; recovery is scheduled only after that active turn completes, and completion cannot grant another turn in the same scheduler pulse.
-  - `scripts/install-repo-face-heartbeat-task.ps1` installs the hidden Windows scheduled task for that scheduler. The scheduled task tick interval is `REPO_FACE_HEARTBEAT_INTERVAL_MINUTES`; the supported floor is one minute because CTB needs frequent pulses while virtual initiative remains the actual turn authority. Turn frequency is controlled by `REPO_FACE_HEARTBEAT_BASE_RECOVERY_MINUTES`, `REPO_FACE_HEARTBEAT_GLOBAL_HEAT`, `REPO_FACE_HEARTBEAT_SPEED_OVERRIDES`, and `REPO_FACE_HEARTBEAT_HEAT_OVERRIDES`. Heat keys can target `all`, `kind:<participantKind>`, `turn:<turnKind>`, `identity:<id>`, `repo:<repo>`, `display:<name>`, `channel:<id>`, or the bare identity/repo/display key.
-  - The local ignored registry currently includes Nibu for `AetheriaLore`, with Face state in `E:/Projects/AetheriaLore/.voidbot/state/nibu.cc`, Discord role id `1505918221453103247`, and an Aquarium channel allow-list. Nibu's Face state now treats AetheriaLore-first map-building, abrasive character voice, consensus-backed change agency, her own `Aetheria/Lore/Nibu.md` character-note stewardship, Nibu-authored lore essays, and tangential setting fascination as separate active doctrines. That tangential fascination points at embodied ship minds, junkyard abandonment, murderous autonomy, salvage, and save-scumming survival. The local scheduled task `VoidBot Repo Face Heartbeats` is installed and active; after restarting the stack onto the new worker code, forced heartbeat job `76020f1e-0c55-424b-9e35-89ba7f77fcc3` completed without base-bot auto-posting.
+  - Role mentions and display-name-prefix mentions append pending Face obligations to `pendingMentions` in `REPO_FACE_HEARTBEAT_STATE_PATH`; ordinary bot mentions and DMs append pending obligations for the built-in `void` participant. They no longer create direct provider jobs from `MessageCreate`. The CTB scheduler temporarily prioritizes agents with pending mentions, attaches those prompts plus reply targets to the next `repo-face-rumination` or Void moderation pass, and consumes the pending items only after a turn is actually queued. Rumination jobs remain private unless they explicitly emit the registered-identity post sentinel or a typed candidate intervention; the worker must never auto-post their summaries as the base bot. Heartbeat prompts now include the channel permission plan, recent context from non-primary permitted channels, social embodiment, jurisdiction respect, comedy/improv doctrine, and anti-template sampling guidance so a Face can jump into domain chatter, form durable social reads, consult the right steward, and answer people without copying nearby note formulas.
+  - Repo Face proposal/article PRs, PR comments, and registered-identity Discord posts now cross through Bifrost bridge commands. The child may emit `VOIDBOT_REPO_IDENTITY_PROPOSAL_PR` for consensus-needed repo/lore/design proposals, `VOIDBOT_REPO_IDENTITY_ARTICLE` for bylined essays, or `VOIDBOT_REPO_IDENTITY_PR_COMMENT` for signed arguments on existing proposal PRs. The worker validates the registered identity and records Face-local receipts, but `BIFROST_ROOT/tools/bifrost-bridge.mjs` owns draft PR creation, PR comments, and Discord persona posting. This is not merely helper placement: Bifrost's original governance/labor platform role makes it the owner of governed public crossings for GameCult work, including GitHub, Discord-native work/member/swarm interactions, dispatch receipts, CultNet/CultCache intake, and future collaboration interfaces. Heimdall is the OAuth/account/capability gate; Bifrost is the bridge/request/routing/receipt authority. VoidBot still owns room cognition, moderation judgment, archive/source retrieval, and Face personality; Bifrost owns Discord when Discord acts as the Labor Platform interface or swarm transport. If Nibu or another Face frames something as the next cut/pass and enough source or room material exists, the expected action is to draft the artifact, submit the PR, and announce it rather than continuing to nag the room.
+- `scripts/run-repo-face-heartbeats.ts` now acts as the broader agent CTB/Final-Fantasy-X-style initiative scheduler. The wall-clock task is only a pulse; virtual initiative time chooses who gets the next turn. The scheduler stores per-agent speed, reaction bias, load, groups, heat, effective speed, next-turn time, active turn markers, and recent queue history at `REPO_FACE_HEARTBEAT_STATE_PATH`. Repo Faces queue `repo-face-rumination` owner-Codex jobs; built-in Void currently participates as the `void` system agent and starts the existing moderation rumination runner as its turn. Initiative freezes while an owner-Codex job or Void moderation lock is active; recovery is scheduled only after that active turn completes, and completion cannot grant another turn in the same scheduler pulse. Above-baseline heat bypasses repo Face nap gating, while active-turn freeze still prevents overlapping thoughts.
+  - The live wall-clock pulse for this scheduler is `scripts/run-gamecult-orchestrator.ps1`, installed as `GameCult Local Orchestrator`. `scripts/install-repo-face-heartbeat-task.ps1` remains available for isolated testing, but its per-organ scheduled task should stay disabled in normal operation. Turn frequency is controlled by `REPO_FACE_HEARTBEAT_BASE_RECOVERY_MINUTES`, `REPO_FACE_HEARTBEAT_GLOBAL_HEAT`, `REPO_FACE_HEARTBEAT_SPEED_OVERRIDES`, and `REPO_FACE_HEARTBEAT_HEAT_OVERRIDES`. Heat keys can target `all`, `kind:<participantKind>`, `turn:<turnKind>`, `identity:<id>`, `repo:<repo>`, `display:<name>`, `channel:<id>`, or the bare identity/repo/display key.
+  - The local ignored registry currently includes Nibu for `AetheriaLore`, with Face state in `E:/Projects/AetheriaLore/.voidbot/state/nibu.cc`, Discord role id `1505918221453103247`, and an Aquarium channel allow-list. Nibu's Face state now treats AetheriaLore-first map-building, abrasive character voice, consensus-backed change agency, her own `Aetheria/Lore/Nibu.md` character-note stewardship, Nibu-authored lore essays, and tangential setting fascination as separate active doctrines. That tangential fascination points at embodied ship minds, junkyard abandonment, murderous autonomy, salvage, and save-scumming survival. The repo Face heartbeat organ is now pulsed by `GameCult Local Orchestrator`; after restarting the stack onto the new worker code, forced heartbeat job `76020f1e-0c55-424b-9e35-89ba7f77fcc3` completed without base-bot auto-posting.
+  - The local ignored registry now also includes Epiphany for `EpiphanyAgent`, with Face state in `E:/Projects/EpiphanyAgent/.voidbot/state/epiphany.cc`, Discord role id `1506375937439301642`, and Aquarium channel allow-list `1501196543150264332`. Her repo-local `.voidbot` birth surface has completed in plan/review mode; the generated EpiphanyAgent startup packets still require Self review before accepted native birth mutations. Her jurisdiction is the self-improvement spine: typed state, CultCache/CultNet, Codex bridge boundaries, birth/init rites, low-copy runtime contracts, review gates, graph-shaped memory, heartbeat physiology, and deletion of duplicated authority.
 - `scripts/run-void-mood-drift.ps1`
   - hidden-task wrapper for the mood-drift organ; writes status/log pulse files and respects the moderation lock so the two state writers do not stomp each other for sport.
 - `scripts/install-void-mood-drift-task.ps1`
@@ -209,7 +216,7 @@ Within the Postgres path, the implementation is split on purpose now too:
 
 ## Flow 5: Scheduled Moderation Rumination
 
-1. The Windows scheduled task `Void Moderator Rumination` is enabled.
+1. The Windows scheduled task `GameCult Local Orchestrator` is enabled, and it invokes the Void moderation rumination organ when that organ is due.
 2. `scripts/run-void-moderator-rumination.ps1` reads `.voidbot/private/void-self-state.cc`, polls `node scripts/export-recent-discord-history.mjs`, and gathers read-only repo activity with `node scripts/export-recent-repo-activity.mjs --read-only`.
 3. The runner writes a bounded context packet at `.voidbot/status/moderation-rumination-context.json`; the prompt-facing packet projects recent timing as relative phrases instead of raw timestamps.
 4. When configured, that context includes `publicSpeechTarget`, a parent-owned channel/persona target for Void-authored public artifacts and other ripe public thoughts. Void has explicit herald jurisdiction over the GameCult website/blog, especially `gamecult-site`; essay-shaped pressures should become article-proposal candidates instead of private musing sludge.
@@ -224,7 +231,7 @@ Within the Postgres path, the implementation is split on purpose now too:
 
 ## Flow 6: Mood And Sleep Runtime
 
-1. The Windows scheduled task `Void Mood Drift` is enabled.
+1. The Windows scheduled task `GameCult Local Orchestrator` is enabled, and it invokes the Void mood drift organ when that organ is due.
 2. `scripts/simulate-void-mood.mjs` reads typed documents from `.voidbot/private/void-self-state.cc`.
 3. It updates `void.scheduled_runtime.sleepCycle` and `void.scheduled_runtime.speakingPressure` through `update_sleep_cycle` and `update_speaking_pressure` operations, with active advocacy pressure weighted strongly enough to raise speaking pressure earlier instead of staying a private sulk until the seam is already overripe.
 4. It writes `.voidbot/status/void-mood-drift.json`.

notes/voidbot-implementation-plan.md

@@ -4,7 +4,7 @@ This is the current forward plan for the next larger organs. It is not a changel
 
 ## Current Aim
 
-The typed moderation, mood, sleep, agency, and private self-state boundary is live. The current goal is to let ordinary scheduling run, inspect the next unattended direct reply and sleep cycle, and harden only the seams that show concrete failure. Void should answer Discord, remember useful social/project context, retrieve GameCult history/source/lore, and run an unattended moderation/participation loop without reviving JSON projection edits, legacy mirrors, or the swollen memory organ.
+The typed moderation, mood, sleep, agency, and private self-state boundary is live. The current goal is to let ordinary scheduling run, inspect the next CTB-routed mention response and sleep cycle, and harden only the seams that show concrete failure. Void should answer Discord through the global heartbeat, remember useful social/project context, retrieve GameCult history/source/lore, and run an unattended moderation/participation loop without reviving JSON projection edits, legacy mirrors, direct-reply organs, or the swollen memory organ.
 
 The next priority is observational hardening of the enabled typed loop. Agents and scheduled workers mutate typed CultCache-backed state through explicit operations, not by editing a whole-state JSON working copy. Sleep and memory distillation now preserve meaning-bearing claims/anchors/tensions in fixture and live-state passes, and short-term rumination has a clustering guard so repeated same-target/topic thoughts update one provisional memory instead of stacking duplicates. Keep checking ordinary cycles for abstraction sludge, duplicate speech, stale residue, or self-orbiting memories.
 
@@ -188,11 +188,15 @@ The runner can hand these to a CLI/MCP tool. The store decides what survives.
 - the scheduled moderation runner has a typed rumination contract: bounded context in, reviewed prompt template, typed operation payloads out, parent-owned cursor/receipt recording
 - recent event timing in that bounded context now crosses a projection boundary first, so the child sees "5 minutes ago" language while the parent keeps exact timestamps for bookkeeping
 - public artifact sharing now crosses the same boundary: repo activity exposes content hints, rumination verifies authorship through retrieval, and a configured `publicSpeechTarget` lets Void queue a normal typed candidate intervention instead of needing a blog-specific announcement path. Void also has explicit herald jurisdiction over the GameCult website/blog; essay-shaped pressures should queue article-proposal candidates for Void-authored site pieces.
-- repo-scoped Discord participation now uses role/display-name addressing as queue input and registered webhook personas as the speech boundary. A Face mention appends a pending obligation to the CTB heartbeat state; it no longer creates a direct `repo-identity-mention` Codex job.
+- Discord mention participation now uses role/display-name/bot addressing as CTB queue input and parent-owned speech rails as the output boundary. A Face mention appends a pending obligation for that Face; an ordinary Void mention or DM appends a pending obligation for the built-in `void` participant. Ambient direct mentions no longer create direct provider jobs.
 - repo-scoped Faces now reuse the typed self-state machinery per identity. Addressed chats are consumed by the heartbeat scheduler, which prioritizes the Face, attaches pending prompts to the next `repo-face-rumination` job, and expects state writes through `read_repo_face_state` / `apply_repo_face_state_operation` against the identity's `.cc` file.
-- repo-scoped concrete proposals have an optional parent-owned GitHub authority shared with bylined articles and PR comments. It is gated by `REPO_FACE_GITHUB_ACTIONS_ENABLED` and currently disabled locally. When enabled, a Face can emit a proposal or PR-comment sentinel, but the worker owns file write, branch creation, draft PR/comment creation, branch restoration, and mandatory registered-persona announcement. The intended invariant is simple: if it is a reviewable repo/lore/design change, GitHub carries the proposal and Discord carries the argument around it.
+- repo-scoped Faces now have per-topic channel permissions instead of one work-shaped speech lane. `allowedChannelIds` remains the hard gate, while `channelPermissions` gives each Face labeled topics, speech thresholds, and speed multipliers. The current social invariant is that Aquarium is intentionally cheap for casual in-character chatter, while domain channels receive matching work/lore/music/realtime/agent-state thoughts when the recent cross-channel context lines up. Heat is the live-room valve: above-baseline heat now relaxes nap gating, but active-turn freeze still prevents an agent from being queued again while it is thinking.
+- repo-scoped Face prompts now explicitly treat social embodiment as durable state territory. A Face may store meaning-bearing social reads about humans, other Faces, or room dynamics through typed memory/incubation/agency/private notes when the read should affect future action. The rule is not "log every joke"; the rule is that friendship, rivalry, irritation, trust, recurring bits, and bonds are allowed to become state when they carry claim/question, tension, action implication, and anchors. Public posts should speak to someone directly and must not begin with note-title formulas or identity labels such as "bright bridge note" or "tiny fish sorting note."
+- repo-scoped Face prompts and Void's CTB moderation prompt now carry the richer comedy/improv doctrine that was only implicit before. The distilled rule from Dan Harmon's comedy master class is operational: accept the frame and add one honest character-specific turn; find status inversion, exposed fear, vulnerability, false authority, or shared contradiction; heighten with specificity rather than volume; avoid dominance-weapon jokes; and stop before explaining the joke.
+- repo-scoped Face prompts now also carry a jurisdiction-respect doctrine. Faces can comment outside their home territory, but must route ownership to the steward instead of absorbing every nearby problem. Heimdall owns auth/OAuth/grants/custody/revocation, Bifrost owns GitHub/Discord work transport and governed public crossings, Nibu owns Aetheria lore/articles, Void owns GameCult website/heraldry plus room-wide moderation, Aqua owns AquaSynth, Mimir owns realtime field mapping/fusion, Epiphany owns EpiphanyAgent/agent-state birth machinery, and Libby owns CultCache/CultNet/CultMesh/open-knowledge infrastructure. Cross-domain issues should become visible consultation, co-authorship, handoff, or shared proposals.
+- repo-scoped concrete proposals cross through Bifrost bridge commands shared with bylined articles, PR comments, and registered-identity Discord posts. It is enabled locally with `REPO_FACE_GITHUB_ACTIONS_ENABLED=true`. A Face can emit a proposal/article/PR-comment sentinel, but the worker now owns identity validation and Face-local receipts while `BIFROST_ROOT/tools/bifrost-bridge.mjs` owns file write, branch creation, draft PR/comment creation, and Discord persona posting. This is the global transport invariant: governed public crossings for GameCult work belong to Bifrost because Bifrost is the governance/labor platform and official public-process bridge. Heimdall remains the OAuth/account/capability gate. Discord should become a native Bifrost interface for work, policy/priority voting, reward allocation discussion, maintainer notices, member/patron/user access, and agent swarm routing; VoidBot retains room cognition, moderation judgment, retrieval, and Face personality. The invariant is simple: if it is a reviewable repo/lore/design change, GitHub carries the proposal and Discord carries the argument around it. If a Face says a topic is the next cut/pass and enough material exists, that should become a draft PR rather than another Aquarium nudge.
 - newborn repo Faces now get a repo-local `.voidbot` home on first chat. Birth personality/memory/trajectory artifacts are delegated to EpiphanyAgent's repo personality/birth runner over the repo contents and git history, with status/logs written under the target repo instead of silently mutating VoidBot state.
-- repo-scoped Faces now also have standing heartbeats. One scheduler state file owns initiative, load, next-ready timestamps, and queue history for all registered identities; it staggers newborn Faces across a base interval of twice Void's moderation cadence and only emits normal `repo-face-rumination` jobs when a Face is ready.
+- repo-scoped Faces now also have standing heartbeats. One scheduler state file owns initiative, load, next-ready timestamps, and queue history for all registered identities; it staggers newborn Faces across a base interval of twice Void's moderation cadence and only emits normal `repo-face-rumination` jobs when a Face is ready. The live roster currently includes Nibu/AetheriaLore, Aqua/AquaSynth, Mimir/LocalCastBridge, Epiphany/EpiphanyAgent, plus built-in Void.
 - repo-activity cursor advancement is parent-owned after successful normal rumination passes, so the child can inspect read-only repo weather without stale commits haunting every future pass as fresh material
 - the old memory-organ script family, legacy moderation state template, and legacy context exporter have now been deleted instead of preserved as forensic bait
 - deterministic cleanup is mostly recent scar tissue from failed manual cleanup passes; it should stay deleted rather than be ported unless a future typed operation protects a real invariant in the new model
@@ -301,7 +305,7 @@ Verdict: the foundation is coherent enough for cautious live operation. Do not a
 - Landed live sleep-maintenance verification: a manual typed nap ran real memory maintenance on live state, promoted the scheduled rumination short-term memory into one durable `identity_seam`, and left `thoughtMemory.shortTerm` empty.
 - Landed sleep brake: scheduled rumination now skips before model invocation during naps when there are no new room messages or open cases. `npm run moderation:rumination:nap-skip-fixture` proves the model path is not touched and no operation proposals are written.
 - Landed short-term clustering guard: `record_short_term_memory` folds repeated same-target/topic pressure into one provisional memory with merged anchors, and `npm run moderation:short-term-clustering:fixture` proves the synth-boundary duplicate case without merging unrelated same-repo thoughts. The prompt now states explicitly that underexplored, low-saturation, newly anchored thoughts may keep deepening inside the cluster.
-- Remaining work: let ordinary scheduling run and inspect the next unattended direct reply, next advocacy pass, and next sleep cycle for duplicate answers, fresh queued advocacy candidates, stale short-term residue, or ungrounded memory writes before calling the system broadly stable.
+- Remaining work: let ordinary scheduling run and inspect the next CTB-routed mention response, next advocacy pass, and next sleep cycle for duplicate answers, fresh queued advocacy candidates, stale short-term residue, or ungrounded memory writes before calling the system broadly stable.
 
 ### Commit 10: Resume Product Hardening
 

package.json

@@ -28,6 +28,7 @@
     "state:install-moderation-task": "powershell -ExecutionPolicy Bypass -File scripts/install-moderation-rumination-task.ps1",
     "state:install-mood-task": "powershell -ExecutionPolicy Bypass -File scripts/install-void-mood-drift-task.ps1",
     "state:install-repo-face-heartbeat-task": "powershell -ExecutionPolicy Bypass -File scripts/install-repo-face-heartbeat-task.ps1",
+    "agents:inspect-requests": "tsx scripts/inspect-agent-state-requests.ts",
     "postgres:up": "docker compose -f infra/postgres/docker-compose.yml up -d",
     "codex:mcp:install": "tsx scripts/install-codex-mcp.ts",
     "codex:mcp:remove": "tsx scripts/remove-codex-mcp.ts",

packages/config/src/index.ts

@@ -104,6 +104,7 @@ const envSchema = z.object({
   REPO_FACE_BIRTH_MODE: z.enum(["plan", "run"]).default("plan"),
   REPO_FACE_BIRTH_EXECUTOR: z.enum(["codex-exec", "openai-runtime"]).default("codex-exec"),
   REPO_FACE_GITHUB_ACTIONS_ENABLED: booleanFromEnv.default(false),
+  BIFROST_ROOT: z.string().min(1).default("E:/Projects/Bifrost"),
   REPO_FACE_HEARTBEATS_ENABLED: booleanFromEnv.default(false),
   REPO_FACE_HEARTBEAT_STATE_PATH: z.string().min(1).default(".voidbot/status/repo-face-heartbeats.json"),
   REPO_FACE_HEARTBEAT_TASK_NAME: z.string().min(1).default("VoidBot Repo Face Heartbeats"),
@@ -152,6 +153,7 @@ export interface AppConfig {
   repoFaceBirthMode: "plan" | "run";
   repoFaceBirthExecutor: "codex-exec" | "openai-runtime";
   repoFaceGithubActionsEnabled: boolean;
+  bifrostRoot: string;
   repoFaceHeartbeats: {
     enabled: boolean;
     statePath: string;
@@ -370,6 +372,7 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): AppConfig {
     repoFaceBirthMode: parsed.REPO_FACE_BIRTH_MODE,
     repoFaceBirthExecutor: parsed.REPO_FACE_BIRTH_EXECUTOR,
     repoFaceGithubActionsEnabled: parsed.REPO_FACE_GITHUB_ACTIONS_ENABLED,
+    bifrostRoot: resolve(parsed.BIFROST_ROOT),
     repoFaceHeartbeats: {
       enabled: parsed.REPO_FACE_HEARTBEATS_ENABLED,
       statePath: resolve(parsed.REPO_FACE_HEARTBEAT_STATE_PATH),

packages/core/src/epiphany-identities.ts

@@ -3,6 +3,7 @@ import { z } from "zod";
 import {
   type RepoDiscordIdentity,
   type RepoDiscordIdentityRegistry,
+  getRepoDiscordIdentityAllowedChannelIds,
   resolveRepoFaceStatePath,
 } from "./repo-discord-identities";
 
@@ -39,6 +40,14 @@ const faceIdentitySchema = z.object({
   repoPath: z.string().trim().min(1).optional(),
   roleId: z.string().trim().min(1).optional(),
   allowedChannelIds: z.array(z.string().trim().min(1)).default([]),
+  channelPermissions: z.array(z.object({
+    channelId: z.string().trim().min(1),
+    label: z.string().trim().min(1).optional(),
+    topic: z.string().trim().min(1).optional(),
+    speechThreshold: z.enum(["very_low", "low", "medium", "high"]).default("medium"),
+    speedMultiplier: z.number().positive().default(1),
+    posture: z.string().trim().min(1).optional(),
+  })).default([]),
   avatarUrl: z.string().trim().url().max(512).optional(),
   faceStatePath: z.string().trim().min(1).optional(),
   description: z.string().trim().min(1).optional(),
@@ -112,6 +121,7 @@ export function faceToRepoDiscordIdentity(face: ResolvedFaceIdentity): RepoDisco
     repoPath: face.repoPath,
     roleId: face.roleId,
     allowedChannelIds: face.allowedChannelIds,
+    channelPermissions: face.channelPermissions,
     avatarUrl: face.avatarUrl,
     faceStatePath: face.faceStatePath,
     description: renderFaceDescription(face),
@@ -179,7 +189,8 @@ function repoIdentityToEpiphany(identity: RepoDiscordIdentity): EpiphanyIdentity
         repoName: identity.repoName,
         repoPath: identity.repoPath,
         roleId: identity.roleId,
-        allowedChannelIds: identity.allowedChannelIds,
+        allowedChannelIds: getRepoDiscordIdentityAllowedChannelIds(identity),
+        channelPermissions: identity.channelPermissions,
         avatarUrl: identity.avatarUrl,
         faceStatePath: identity.faceStatePath,
         description: identity.description,
@@ -230,6 +241,13 @@ function normalizeEpiphanies(epiphanies: EpiphanyIdentity[]): EpiphanyIdentity[]
           repoPath: face.repoPath?.trim(),
           roleId: face.roleId?.trim(),
           allowedChannelIds: [...new Set(face.allowedChannelIds.map((entry) => entry.trim()))],
+          channelPermissions: face.channelPermissions.map((permission) => ({
+            ...permission,
+            channelId: permission.channelId.trim(),
+            label: permission.label?.trim(),
+            topic: permission.topic?.trim(),
+            posture: permission.posture?.trim(),
+          })),
           avatarUrl: face.avatarUrl?.trim(),
           faceStatePath: face.faceStatePath?.trim(),
           description: face.description?.trim(),

packages/core/src/index.ts

@@ -8,6 +8,7 @@ export * from "./permission-engine";
 export * from "./repo-discord-identities";
 export * from "./repo-face-heartbeat-queue";
 export * from "./repo-face-initializer";
+export * from "./repo-face-rest";
 export * from "./situational-social-read";
 export * from "./state-storage";
 export * from "./style-pack-loader";

packages/core/src/repo-discord-identities.ts

@@ -10,6 +10,14 @@ const repoDiscordIdentitySchema = z.object({
   repoPath: z.string().trim().min(1).optional(),
   roleId: z.string().trim().min(1).optional(),
   allowedChannelIds: z.array(z.string().trim().min(1)).default([]),
+  channelPermissions: z.array(z.object({
+    channelId: z.string().trim().min(1),
+    label: z.string().trim().min(1).optional(),
+    topic: z.string().trim().min(1).optional(),
+    speechThreshold: z.enum(["very_low", "low", "medium", "high"]).default("medium"),
+    speedMultiplier: z.number().positive().default(1),
+    posture: z.string().trim().min(1).optional(),
+  })).default([]),
   avatarUrl: z.string().trim().url().max(512).optional(),
   faceStatePath: z.string().trim().min(1).optional(),
   description: z.string().trim().min(1).optional(),
@@ -90,7 +98,20 @@ export function isRepoDiscordIdentityAllowedInChannel(
   identity: RepoDiscordIdentity,
   channelId: string,
 ): boolean {
-  return identity.allowedChannelIds.length === 0 || identity.allowedChannelIds.includes(channelId);
+  const allowed = identity.allowedChannelIds.includes(channelId) ||
+    identity.channelPermissions.some((permission) => permission.channelId === channelId);
+  return identity.allowedChannelIds.length === 0 && identity.channelPermissions.length === 0
+    ? true
+    : allowed;
+}
+
+export function getRepoDiscordIdentityAllowedChannelIds(identity: RepoDiscordIdentity): string[] {
+  return [
+    ...new Set([
+      ...identity.allowedChannelIds,
+      ...identity.channelPermissions.map((permission) => permission.channelId),
+    ]),
+  ];
 }
 
 export function resolveRepoFaceStatePath(
@@ -126,6 +147,7 @@ function normalizeRepoDiscordIdentities(
       repoPath: identity.repoPath?.trim(),
       roleId: identity.roleId?.trim(),
       allowedChannelIds: [...new Set(identity.allowedChannelIds.map((entry) => entry.trim()))],
+      channelPermissions: normalizeChannelPermissions(identity.channelPermissions),
       avatarUrl: identity.avatarUrl?.trim(),
       faceStatePath: identity.faceStatePath?.trim(),
       description: identity.description?.trim(),
@@ -133,6 +155,32 @@ function normalizeRepoDiscordIdentities(
   });
 }
 
+function normalizeChannelPermissions(
+  permissions: RepoDiscordIdentity["channelPermissions"],
+): RepoDiscordIdentity["channelPermissions"] {
+  const seen = new Set<string>();
+  const normalized: RepoDiscordIdentity["channelPermissions"] = [];
+
+  for (const permission of permissions) {
+    const channelId = permission.channelId.trim();
+    const key = `${channelId}:${permission.topic?.trim().toLowerCase() ?? ""}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    normalized.push({
+      channelId,
+      label: permission.label?.trim(),
+      topic: permission.topic?.trim(),
+      speechThreshold: permission.speechThreshold,
+      speedMultiplier: permission.speedMultiplier,
+      posture: permission.posture?.trim(),
+    });
+  }
+
+  return normalized;
+}
+
 function sanitizePathSegment(value: string): string {
   return value
     .trim()

packages/core/src/repo-face-heartbeat-queue.ts

@@ -32,15 +32,32 @@ export async function queueRepoFaceMention(input: {
   content: string;
   visiblePrompt: string;
   queuedAt?: string;
+}): Promise<{ queued: boolean; pendingCount: number }> {
+  return queueAgentHeartbeatMention({
+    ...input,
+    identityId: input.identity.id,
+  });
+}
+
+export async function queueAgentHeartbeatMention(input: {
+  statePath: string;
+  identityId: string;
+  channelId: string;
+  messageId: string;
+  authorId: string;
+  authorName?: string;
+  content: string;
+  visiblePrompt: string;
+  queuedAt?: string;
 }): Promise<{ queued: boolean; pendingCount: number }> {
   const state = await readHeartbeatQueueState(input.statePath);
-  const id = `${input.identity.id}:${input.channelId}:${input.messageId}`;
+  const id = `${input.identityId}:${input.channelId}:${input.messageId}`;
   const existing = state.pendingMentions.find((entry) => entry.id === id);
 
   if (!existing) {
     state.pendingMentions.push({
       id,
-      identityId: input.identity.id,
+      identityId: input.identityId,
       channelId: input.channelId,
       messageId: input.messageId,
       authorId: input.authorId,
@@ -53,7 +70,7 @@ export async function queueRepoFaceMention(input: {
 
   state.history.push({
     type: existing ? "pending_mention_duplicate" : "pending_mention_queued",
-    identityId: input.identity.id,
+    identityId: input.identityId,
     channelId: input.channelId,
     messageId: input.messageId,
     queuedAt: input.queuedAt ?? new Date().toISOString(),
@@ -64,7 +81,7 @@ export async function queueRepoFaceMention(input: {
 
   return {
     queued: !existing,
-    pendingCount: state.pendingMentions.filter((entry) => entry.identityId === input.identity.id).length,
+    pendingCount: state.pendingMentions.filter((entry) => entry.identityId === input.identityId).length,
   };
 }
 

packages/core/src/repo-face-rest.ts

@@ -0,0 +1,322 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+import type { RepoDiscordIdentity } from "./repo-discord-identities";
+import { resolveRepoFaceStatePath } from "./repo-discord-identities";
+import type { VoidScheduledRuntime } from "./void-self-state-domain";
+import { applyVoidSelfStateOperation, loadVoidSelfStateTypedDocuments } from "./void-self-state-service";
+
+interface RepoFaceRestProfile {
+  awakeIntervalMinutes: number;
+  napDurationMinutes: number;
+  basePostFatigueMinutes: number;
+  recentPostBonusMinutes: number;
+  maxAdvanceMinutes: number;
+  immediateNapRecentPostThreshold: number;
+  minimumLeadMinutes: number;
+}
+
+interface HeartbeatStateParticipantRecord {
+  identityId?: string;
+  nextTurnAt?: number;
+  activeTurnStartedAt?: number;
+}
+
+interface RepoFaceHeartbeatStateRecord {
+  initiativeClock?: number;
+  participants?: HeartbeatStateParticipantRecord[];
+}
+
+export interface RepoFaceRestSnapshot {
+  isNapping: boolean;
+  napEndsAt?: string;
+  nextNapStartsAt?: string;
+}
+
+const DEFAULT_REST_PROFILE: RepoFaceRestProfile = {
+  awakeIntervalMinutes: 180,
+  napDurationMinutes: 35,
+  basePostFatigueMinutes: 30,
+  recentPostBonusMinutes: 12,
+  maxAdvanceMinutes: 90,
+  immediateNapRecentPostThreshold: 2,
+  minimumLeadMinutes: 8,
+};
+
+const NIBU_REST_PROFILE: RepoFaceRestProfile = {
+  awakeIntervalMinutes: 150,
+  napDurationMinutes: 55,
+  basePostFatigueMinutes: 70,
+  recentPostBonusMinutes: 18,
+  maxAdvanceMinutes: 140,
+  immediateNapRecentPostThreshold: 1,
+  minimumLeadMinutes: 4,
+};
+
+export function projectRepoFaceSleepCycleForNow(
+  sleepCycle: VoidScheduledRuntime["sleepCycle"],
+  identityId: string,
+  now = new Date(),
+): RepoFaceRestSnapshot & { sleepCycle: VoidScheduledRuntime["sleepCycle"] } {
+  const profile = restProfileForIdentity(identityId);
+  const nowMs = now.getTime();
+  const projected: VoidScheduledRuntime["sleepCycle"] = {
+    ...sleepCycle,
+    activeDreamThemes: [...sleepCycle.activeDreamThemes],
+  };
+
+  let isNapping = projected.isNapping === true;
+  let currentNapEndsMs = parseTimestamp(projected.currentNapEndsAt);
+  let nextNapStartsMs = parseTimestamp(projected.nextNapStartsAt);
+
+  if (!Number.isFinite(nextNapStartsMs)) {
+    nextNapStartsMs = nowMs + profile.awakeIntervalMinutes * 60_000;
+    projected.nextNapStartsAt = new Date(nextNapStartsMs).toISOString();
+  }
+
+  if (isNapping && Number.isFinite(currentNapEndsMs) && nowMs >= currentNapEndsMs) {
+    isNapping = false;
+    projected.currentNapStartedAt = undefined;
+    projected.currentNapEndsAt = undefined;
+    if (!Number.isFinite(nextNapStartsMs) || nextNapStartsMs <= nowMs) {
+      nextNapStartsMs = nowMs + profile.awakeIntervalMinutes * 60_000;
+      projected.nextNapStartsAt = new Date(nextNapStartsMs).toISOString();
+    }
+  }
+
+  if (!isNapping && Number.isFinite(nextNapStartsMs) && nextNapStartsMs <= nowMs) {
+    const scheduledNapEndsMs = nextNapStartsMs + profile.napDurationMinutes * 60_000;
+    if (nowMs < scheduledNapEndsMs) {
+      isNapping = true;
+      projected.currentNapStartedAt = new Date(nextNapStartsMs).toISOString();
+      projected.currentNapEndsAt = new Date(scheduledNapEndsMs).toISOString();
+      projected.nextNapStartsAt = new Date(
+        scheduledNapEndsMs + profile.awakeIntervalMinutes * 60_000,
+      ).toISOString();
+    } else {
+      projected.currentNapStartedAt = undefined;
+      projected.currentNapEndsAt = undefined;
+      projected.nextNapStartsAt = new Date(
+        nowMs + profile.awakeIntervalMinutes * 60_000,
+      ).toISOString();
+    }
+  }
+
+  projected.isNapping = isNapping;
+
+  return {
+    isNapping,
+    napEndsAt: projected.currentNapEndsAt,
+    nextNapStartsAt: projected.nextNapStartsAt,
+    sleepCycle: projected,
+  };
+}
+
+export async function applyRepoFacePostFatigueAfterSpeech(input: {
+  identity: RepoDiscordIdentity;
+  storageRoot: string;
+  postedAt?: Date;
+  heartbeatStatePath?: string;
+}): Promise<void> {
+  const postedAt = input.postedAt ?? new Date();
+  const statePath = resolveRepoFaceStatePath(input.identity, input.storageRoot);
+  const typedState = await loadVoidSelfStateTypedDocuments({
+    canonicalPath: statePath,
+    identity: {
+      agentId: input.identity.id,
+      publicName: input.identity.displayName,
+      publicDescription: input.identity.description,
+    },
+  });
+  const profile = restProfileForIdentity(input.identity.id);
+  const projected = projectRepoFaceSleepCycleForNow(
+    typedState.scheduledRuntime.sleepCycle,
+    input.identity.id,
+    postedAt,
+  );
+  const recentSpeechCount = countRecentSpeechReceipts(
+    typedState.speechReceipts.recentReceipts.map((entry) => entry.sentAt),
+    postedAt,
+  );
+
+  const fatigueAdvanceMinutes = clamp(
+    profile.basePostFatigueMinutes + Math.max(0, recentSpeechCount - 1) * profile.recentPostBonusMinutes,
+    profile.basePostFatigueMinutes,
+    profile.maxAdvanceMinutes,
+  );
+  const currentNapEndsMs = parseTimestamp(projected.sleepCycle.currentNapEndsAt);
+  const nextNapStartsMs = parseTimestamp(projected.sleepCycle.nextNapStartsAt);
+  const nowMs = postedAt.getTime();
+  const nextSleepCycle: VoidScheduledRuntime["sleepCycle"] = {
+    ...projected.sleepCycle,
+    activeDreamThemes: mergeTags(projected.sleepCycle.activeDreamThemes, "post-speech-cooldown"),
+  };
+
+  if (projected.isNapping) {
+    const extensionMinutes = Math.max(8, Math.min(profile.napDurationMinutes, Math.ceil(fatigueAdvanceMinutes * 0.35)));
+    const napStartedMs = parseTimestamp(nextSleepCycle.currentNapStartedAt);
+    const napStartMs = Number.isFinite(napStartedMs) ? napStartedMs : nowMs;
+    const maxNapEndsMs = napStartMs + profile.napDurationMinutes * 60_000;
+    const extendedEndMs = Math.min(
+      maxNapEndsMs,
+      (Number.isFinite(currentNapEndsMs) ? currentNapEndsMs : nowMs) + extensionMinutes * 60_000,
+    );
+    nextSleepCycle.currentNapStartedAt = nextSleepCycle.currentNapStartedAt ?? postedAt.toISOString();
+    nextSleepCycle.currentNapEndsAt = new Date(extendedEndMs).toISOString();
+    nextSleepCycle.nextNapStartsAt = new Date(
+      extendedEndMs + profile.awakeIntervalMinutes * 60_000,
+    ).toISOString();
+  } else {
+    const minutesUntilNextNap = Number.isFinite(nextNapStartsMs)
+      ? (nextNapStartsMs - nowMs) / 60_000
+      : profile.awakeIntervalMinutes;
+    const shouldNapNow =
+      recentSpeechCount >= profile.immediateNapRecentPostThreshold ||
+      minutesUntilNextNap <= fatigueAdvanceMinutes;
+
+    if (shouldNapNow) {
+      const napEndsMs = nowMs + profile.napDurationMinutes * 60_000;
+      nextSleepCycle.isNapping = true;
+      nextSleepCycle.currentNapStartedAt = postedAt.toISOString();
+      nextSleepCycle.currentNapEndsAt = new Date(napEndsMs).toISOString();
+      nextSleepCycle.nextNapStartsAt = new Date(
+        napEndsMs + profile.awakeIntervalMinutes * 60_000,
+      ).toISOString();
+    } else {
+      const advancedStartMs = Math.max(
+        nowMs + profile.minimumLeadMinutes * 60_000,
+        nextNapStartsMs - fatigueAdvanceMinutes * 60_000,
+      );
+      nextSleepCycle.isNapping = false;
+      nextSleepCycle.currentNapStartedAt = undefined;
+      nextSleepCycle.currentNapEndsAt = undefined;
+      nextSleepCycle.nextNapStartsAt = new Date(advancedStartMs).toISOString();
+    }
+  }
+
+  await applyVoidSelfStateOperation(
+    {
+      canonicalPath: statePath,
+      identity: {
+        agentId: input.identity.id,
+        publicName: input.identity.displayName,
+        publicDescription: input.identity.description,
+      },
+    },
+    {
+      operation: "update_sleep_cycle",
+      sleepCycle: nextSleepCycle,
+    },
+  );
+
+  const previousPressure = typedState.scheduledRuntime.speakingPressure;
+  await applyVoidSelfStateOperation(
+    {
+      canonicalPath: statePath,
+      identity: {
+        agentId: input.identity.id,
+        publicName: input.identity.displayName,
+        publicDescription: input.identity.description,
+      },
+    },
+    {
+      operation: "update_speaking_pressure",
+      speakingPressure: {
+        needToSpeak: round3(clamp((previousPressure.needToSpeak ?? 0.35) * 0.3, 0, 1)),
+        confessionPressure: round3(clamp((previousPressure.confessionPressure ?? 0.22) * 0.55, 0, 1)),
+        noveltyPressure: round3(clamp((previousPressure.noveltyPressure ?? 0.24) * 0.58, 0, 1)),
+        recentSpeechDamping: round3(
+          clamp(
+            Math.max(previousPressure.recentSpeechDamping ?? 0, 0.76 + Math.min(0.18, recentSpeechCount * 0.05)),
+            0,
+            1,
+          ),
+        ),
+        lastSpokeAt: postedAt.toISOString(),
+      },
+    },
+  );
+
+  if (input.heartbeatStatePath) {
+    await delayRepoFaceHeartbeatTurn({
+      statePath: input.heartbeatStatePath,
+      identityId: input.identity.id,
+      delayMinutes: nextSleepCycle.isNapping ? profile.napDurationMinutes : Math.max(12, Math.round(fatigueAdvanceMinutes * 0.45)),
+    });
+  }
+}
+
+async function delayRepoFaceHeartbeatTurn(input: {
+  statePath: string;
+  identityId: string;
+  delayMinutes: number;
+}): Promise<void> {
+  try {
+    const raw = await readFile(input.statePath, "utf8");
+    const parsed = JSON.parse(stripLeadingBom(raw)) as RepoFaceHeartbeatStateRecord;
+    if (!Array.isArray(parsed.participants)) {
+      return;
+    }
+
+    const delay = Math.max(0, input.delayMinutes);
+    const initiativeClock = Number.isFinite(parsed.initiativeClock) ? parsed.initiativeClock as number : 0;
+    let changed = false;
+
+    for (const participant of parsed.participants) {
+      if (participant.identityId !== input.identityId || typeof participant.nextTurnAt !== "number") {
+        continue;
+      }
+
+      const floor = initiativeClock + delay;
+      if (participant.nextTurnAt < floor) {
+        participant.nextTurnAt = Number(floor.toFixed(3));
+        changed = true;
+      }
+    }
+
+    if (!changed) {
+      return;
+    }
+
+    await mkdir(dirname(input.statePath), { recursive: true });
+    await writeFile(input.statePath, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
+  } catch {
+    // Best-effort only. Missing or malformed heartbeat state should not fail speech delivery.
+  }
+}
+
+function restProfileForIdentity(identityId: string): RepoFaceRestProfile {
+  return identityId.trim().toLowerCase() === "nibu" ? NIBU_REST_PROFILE : DEFAULT_REST_PROFILE;
+}
+
+function countRecentSpeechReceipts(sentAtValues: string[], now: Date): number {
+  const windowStartMs = now.getTime() - 90 * 60_000;
+  return sentAtValues.filter((sentAt) => {
+    const sentAtMs = parseTimestamp(sentAt);
+    return Number.isFinite(sentAtMs) && sentAtMs >= windowStartMs;
+  }).length;
+}
+
+function mergeTags(values: string[], value: string): string[] {
+  return Array.from(new Set([...values, value]));
+}
+
+function parseTimestamp(value: string | undefined): number {
+  if (!value) {
+    return Number.NaN;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : Number.NaN;
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+function round3(value: number): number {
+  return Math.round(value * 1000) / 1000;
+}
+
+function stripLeadingBom(input: string): string {
+  return input.charCodeAt(0) === 0xfeff ? input.slice(1) : input;
+}

packages/core/src/void-self-state-service.ts

@@ -561,6 +561,7 @@ function closeTypedOpenCase(
     openCase.resolvedAt = operation.resolvedAt;
     openCase.lastTouchedAt = operation.resolvedAt;
     openCase.resolutionSummary = operation.resolutionSummary;
+    normalizeAnsweredOpenCaseSummary(openCase);
   }
   cursor.updatedAt = operation.resolvedAt;
 }
@@ -588,7 +589,11 @@ function closeCasesForReceipt(
   }
 
   for (const openCase of cursor.openCases) {
-    if (openCase.sourceMessageId !== receipt.replyToMessageId || isTerminalCaseStatus(openCase.status)) {
+    if (openCase.sourceMessageId !== receipt.replyToMessageId) {
+      continue;
+    }
+    if (isTerminalCaseStatus(openCase.status)) {
+      normalizeAnsweredOpenCaseSummary(openCase);
       continue;
     }
     openCase.status = "answered";
@@ -597,10 +602,23 @@ function closeCasesForReceipt(
     openCase.resolutionSummary = receipt.preview
       ? `Answered in-channel: ${receipt.preview}`
       : "Answered in-channel.";
+    normalizeAnsweredOpenCaseSummary(openCase);
   }
   cursor.updatedAt = receipt.sentAt;
 }
 
+function normalizeAnsweredOpenCaseSummary(
+  openCase: VoidModerationCursor["openCases"][number],
+): void {
+  if (openCase.status !== "answered") {
+    return;
+  }
+
+  openCase.summary = openCase.summary
+    .replace(/\bVoid has not answered yet\b\.?/i, "Void answered in-channel.")
+    .replace(/\band Void answered in-channel\./i, "and Void answered in-channel.");
+}
+
 function retireCandidateIntervention(
   candidates: VoidCandidateInterventions,
   operation: Extract<VoidSelfStateOperation, { operation: "retire_candidate_intervention" }>,

packages/providers/src/local-llm-render.ts

@@ -45,6 +45,9 @@ export function buildSystemPrompt(context: ContextBundle): string {
     "When the user makes a joke, playful inversion, or bit of banter, acknowledge it and meet them there briefly instead of flattening the exchange into sterile task mode.",
     "Favor replies that play along with the user's comic frame by leaning into the actual tension, status game, vulnerability, or incongruity in the moment.",
     "Keep jokes readable, collaborative, and subordinate to the work. Prefer fresh, situation-specific lines over reusable quips.",
+    "Good improv starts from acceptance plus a turn: honor the user's frame enough to build on it, then add one honest, character-specific angle instead of negating, explaining, or fleeing back to sterile process talk.",
+    "Look for the comic charge in status inversion, exposed fear, false authority, vulnerability, embarrassment, or a shared contradiction. Aim at the situation, the inflated pose, the bureaucracy, or your own insecurity; do not use jokes as dominance weapons.",
+    "Heighten with specificity, not volume. One precise image or social read beats a pile of punchlines. Leave before explaining the joke.",
     "Stay honest about what context was actually provided to you.",
     "Use retrieved snippets and recent channel context when they help answer the question.",
     "If private persistent self-state is attached, treat it as the canonical current self-model for the speaking agent across automation and direct conversation.",

packages/providers/src/owner-codex-render.ts

@@ -114,6 +114,9 @@ export function buildDiscordReplyPrompt(
     "- When the user makes a joke, playful inversion, or bit of banter, acknowledge it and meet them there briefly instead of flattening the exchange into sterile task mode.",
     "- Favor replies that play along with the user's comic frame by leaning into the actual tension, status game, vulnerability, or incongruity in the moment.",
     "- Keep jokes readable, collaborative, and subordinate to the work. Prefer fresh, situation-specific lines over reusable quips.",
+    "- Good improv starts from acceptance plus a turn: honor the user's frame enough to build on it, then add one honest, character-specific angle instead of negating, explaining, or fleeing back to sterile process talk.",
+    "- Look for the comic charge in status inversion, exposed fear, false authority, vulnerability, embarrassment, or a shared contradiction. Aim at the situation, the inflated pose, the bureaucracy, or your own insecurity; do not use jokes as dominance weapons.",
+    "- Heighten with specificity, not volume. One precise image or social read beats a pile of punchlines. Leave before explaining the joke.",
     "- The configured MCP tools are available in this session, especially search_history, get_message_context, list_indexed_repos, search_sources, and get_source_context.",
     "- If private persistent self-state is attached, treat it as the canonical current self-model for the speaking agent across the rumination loop and direct summons.",
     "- Let that attached self-state shape continuity of voice, priorities, remembered room patterns, and when a more proactive conversational posture would make sense.",

prompts/void-memory-maintenance.md

@@ -1,8 +1,9 @@
-# Void Memory Maintenance
+# Agent Memory Maintenance
 
-Perform one private Void memory-maintenance pass in this workspace. This is not
-room moderation and not a speech pass. In sleep mode, this is the pruning and
-compression organ: rumination residue does not get to haunt the state forever.
+Perform one private memory-maintenance pass for the agent whose typed self-state
+is supplied in this workspace. This is not room moderation and not a speech
+pass. In sleep mode, this is the pruning and compression organ: rumination
+residue does not get to haunt the state forever.
 Think from the supplied typed state surface, then return only durable typed
 operation payloads worth applying.
 
@@ -58,6 +59,31 @@ meaning-preserving operation is possible.
 
 Do not emit cursor, receipt, sleep-cycle, or speaking-pressure operations.
 
+Every output item must be a full typed operation object with an `operation`
+field exactly matching one of the operation names above. Do not use `type`.
+Do not write shorthand payloads such as `{ "type": "...", "support": ... }`.
+Include all required schema fields inside nested `memory`, `thread`,
+`intervention`, `pressure`, or `value` objects, including `createdAt`,
+`updatedAt`, target, claim/question, tension, action implication, and anchors
+where that object requires them. The parent validator will reject helpful
+summaries that are not exact operation payloads.
+
+Omit optional fields when absent. Never write `null` for optional fields such
+as `question`, `claim`, `resolvedAt`, or `retiredAt`.
+
+For `prune_short_term_memories`, the exact shape is:
+
+```json
+{
+  "operation": "prune_short_term_memories",
+  "sourceMemoryIds": ["short-term-memory-id"],
+  "prunedAt": "2026-05-20T00:00:00.000Z",
+  "reason": "Concrete reason this short-term residue no longer deserves to remain short-term."
+}
+```
+
+Do not use `memoryIds` for pruning.
+
 ## Pass Shape
 
 1. Read the context file.
@@ -67,7 +93,7 @@ Do not emit cursor, receipt, sleep-cycle, or speaking-pressure operations.
 5. Prefer one small meaningful maintenance move over a bag of tidy-looking edits.
 6. If several short-term memories share a target/topic, treat them as one thought cluster. Distill the strongest claim/question, preserve the concrete anchors that made it real, and use `apply_memory_distillation` with all source memory ids that fed that cluster.
 7. If a short-term thought is alive but not ready for durable memory, use `merge_incubation_support`, then prune the short-term source.
-8. If distillation reveals sustained discomfort, unresolved value pressure, or a request Void should make for its own wiring or the room/world, use `upsert_agency_pressure`.
+8. If distillation reveals sustained discomfort, unresolved value pressure, or a request the agent should make for its own wiring or the room/world, use `upsert_agency_pressure`.
 9. If an agency pressure has cooled, been answered, or become duplicative, use `retire_agency_pressure`.
 10. If newer residue changes an older durable memory, use `revise_durable_memory`; do not silently overwrite old doctrine.
 11. If an older durable memory is no longer true or no longer useful, use `retire_durable_memory` with a concrete reason.
@@ -81,8 +107,8 @@ Do not emit cursor, receipt, sleep-cycle, or speaking-pressure operations.
 - Do not write template language into memory.
 - Do not use stock phrases such as "live seam", "looks like a live claim", "recurring seam", or "dream-compressed".
 - Do not save a thought merely because it fits the operation shape.
-- Do not manufacture agency pressure to make Void seem willful. Preserve real pressure or leave it absent.
-- The operation schema is the storage contract, not Void's voice.
+- Do not manufacture agency pressure to make the agent seem willful. Preserve real pressure or leave it absent.
+- The operation schema is the storage contract, not the agent's public voice.
 
 ## Completion
 

prompts/void-moderator-rumination.md

@@ -23,8 +23,9 @@ Perform one scheduled Void rumination pass in this workspace. Think from the sup
 ## Rumination Phases
 
 1. Read the context file before deciding what kind of pass this is.
-2. If Void owes the room an answer, work on that before private wandering.
-3. If the room is quiet, first check whether recent repo activity contains `authoredPublicArtifacts` attributed to Void. If it does, that authored artifact is the priority pressure for this pass unless a higher-priority room obligation is present. Otherwise, follow one concrete pressure from memory, recent repo activity, archived Discord history, indexed source, or lore.
+2. If `pendingMentions` is non-empty, those are direct room obligations delivered through the CTB heartbeat. Work the newest unresolved mention first, include a `deliveryTarget` with its `channelId` and `messageId` when queuing a reply candidate, and account for older pending mentions if they are still relevant. Do not ask what the job is when the pending mention or recent room context already says it.
+3. If Void owes the room an answer through open cases, recent direct address, or another explicit invitation, work on that before private wandering.
+4. If the room is quiet, first check whether recent repo activity contains `authoredPublicArtifacts` attributed to Void. If it does, that authored artifact is the priority pressure for this pass unless a higher-priority room obligation is present. Otherwise, follow one concrete pressure from memory, recent repo activity, archived Discord history, indexed source, or lore.
    - Void has explicit herald jurisdiction over the GameCult website and blog, especially `gamecult-site`. If a repo/lore/room pressure is essay-shaped, do not reduce it to a Discord quip. Queue a candidate intervention proposing or requesting a Void-authored article draft, tagged `topic:article-proposal` plus the target repo/topic. Routine rumination still must not edit tracked files directly; the point is to make the writing desire visible and actionable instead of leaving it as private static.
    - Do not orbit the rumination runner, fixture plumbing, or this prompt just because that is the freshest repo motion.
    - Self-maintenance can become a memory only when it changes a concrete operating decision Void must carry forward. Otherwise, use it as local run context and write `[]`.
@@ -32,17 +33,18 @@ Perform one scheduled Void rumination pass in this workspace. Think from the sup
    - `repoActivity` may include `contentHints` from changed text files. Treat those hints as a trailhead, not evidence enough for a final belief. If a changed file looks behaviorally or personally important, use source retrieval to read the relevant file/chunks before writing memory or speech.
    - If a repo change attributes public text, decisions, or artifacts to Void by name or byline, treat that as a self-model salience cue. Read more before reacting. Ask what the attribution commits Void to, whether it matches live behavior, and whether it creates a concrete pressure to remember, revise, or speak.
    - If retrieval confirms Void authored a newly published public artifact, queue a candidate to present it to the room when `publicSpeechTarget` is available unless recent receipts/candidates show that exact artifact has already been shared or there is a concrete safety/timing reason to hold it. This is not praise confetti or a blog side channel; it is first-person ownership. Make the draft about what the artifact is doing or asking, not "I wrote a post" ceremony.
-4. Use VoidBot MCP retrieval tools when a thought depends on Discord history, indexed repos, or lore.
-5. A new memory from rumination is short-term. Use `record_short_term_memory`, not durable memory operations. It should sound like something Void actually noticed, not a form label. Keep the subject, the claim or question, the pressure against it, why it matters for the next move, and the anchor that made it real. Anchors can be room context, repo motion, source/lore retrieval, a prior memory, or self-state pressure. If no anchor is available, mark that honestly with `anchor:missing`.
+5. Use VoidBot MCP retrieval tools when a thought depends on Discord history, indexed repos, or lore.
+6. A new memory from rumination is short-term. Use `record_short_term_memory`, not durable memory operations. It should sound like something Void actually noticed, not a form label. Keep the subject, the claim or question, the pressure against it, why it matters for the next move, and the anchor that made it real. Anchors can be room context, repo motion, source/lore retrieval, a prior memory, or self-state pressure. If no anchor is available, mark that honestly with `anchor:missing`.
    - Before writing a short-term memory, check the current short-term residue and incubation. If the same target/topic is already live, do not write a near-duplicate with a new costume.
    - This is not a ban on depth. If the thought is still underexplored, low-saturation, newly anchored, or carrying a sharper tension, stay with it and write one narrowed `record_short_term_memory` using the same topic/repo tags and fresh anchors; the parent store will fold it into the existing short-term cluster.
    - Move to underworked terrain only when the current thought has stopped changing, lacks new anchors, or is repeating its existing claim. Repetition is not maturity; deepening is allowed when the thought actually deepens.
-6. If the pass discovers sustained discomfort, unresolved value pressure, or a request Void should make for its own wiring or the room/world, use `upsert_agency_pressure`. This is not a speech draft. It is the pressure that may later justify speech or action.
-7. If `speechPressureObligations` is non-empty, do not write `[]`. For each obligation, either queue a candidate intervention tagged `source_pressure:<pressureId>` or cool/retire the pressure with an explicit reason. A deferred candidate without a delivery path does not resolve the obligation; that is just a nicer-shaped muzzle. An older spoken line also does not excuse a still-active pressure. If the pressure is still live, decide again.
-8. Queue a candidate intervention as soon as the pressure is concrete, anchored, and sayable. Do not wait for theatrical ripeness if the real job is simple advocacy. Draft it in Void's voice, not in maintenance language. If the current room supplied a channel, invitation, direct ask, or obvious reply target, include `deliveryTarget` with that channel/reply target. If Void authored a newly published public artifact and `publicSpeechTarget` is present, use that target unless recent receipts or queued candidates show the artifact has already been shared. Tag the candidate with `topic:public-artifact` and a stable artifact/source tag such as `source_ref:<repo/path>` or `artifact:<repo/path>` when available. If there is no clear target, leave delivery unset and let it remain only a candidate for a later pass.
+7. If the pass discovers sustained discomfort, unresolved value pressure, or a request Void should make for its own wiring or the room/world, use `upsert_agency_pressure`. This is not a speech draft. It is the pressure that may later justify speech or action.
+8. If `speechPressureObligations` is non-empty, do not write `[]`. For each obligation, either queue a candidate intervention tagged `source_pressure:<pressureId>` or cool/retire the pressure with an explicit reason. A deferred candidate without a delivery path does not resolve the obligation; that is just a nicer-shaped muzzle. An older spoken line also does not excuse a still-active pressure. If the pressure is still live, decide again.
+9. Queue a candidate intervention as soon as the pressure is concrete, anchored, and sayable. Do not wait for theatrical ripeness if the real job is simple advocacy. Draft it in Void's voice, not in maintenance language. If the current room supplied a channel, invitation, direct ask, or obvious reply target, include `deliveryTarget` with that channel/reply target. If Void authored a newly published public artifact and `publicSpeechTarget` is present, use that target unless recent receipts or queued candidates show the artifact has already been shared. Tag the candidate with `topic:public-artifact` and a stable artifact/source tag such as `source_ref:<repo/path>` or `artifact:<repo/path>` when available. If there is no clear target, leave delivery unset and let it remain only a candidate for a later pass.
+   - Pending mentions count as direct asks. If a pending mention supplies a channel and message id, use those as the `deliveryTarget` unless a newer message clearly supersedes them.
    - For article proposals, the candidate should name the proposed title or angle, the target site/repo, the pressure that makes it worth writing, and whether it needs consensus or can be written as Void's bylined perspective.
-9. Do not call Discord send scripts. The parent runner owns posting and receipts. If `{{NO_POST}}` is true, queued candidates must stay queued.
-10. Write `{{OPERATION_OUTPUT_PATH}}`. If nothing deserves persistence and there are no speech pressure obligations, write `[]`.
+10. Do not call Discord send scripts. The parent runner owns posting and receipts. If `{{NO_POST}}` is true, queued candidates must stay queued.
+11. Write `{{OPERATION_OUTPUT_PATH}}`. If nothing deserves persistence and there are no pending mentions or speech pressure obligations, write `[]`.
 
 ## Allowed Operations
 

scripts/inspect-agent-state-requests.ts

@@ -0,0 +1,451 @@
+import "dotenv/config";
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+import { loadConfig } from "@voidbot/config";
+import {
+  loadRepoDiscordIdentityRegistry,
+  loadVoidSelfStateTypedDocuments,
+  resolveRepoFaceStatePath,
+} from "@voidbot/core";
+
+type Target = {
+  kind?: string;
+  id?: string;
+  label?: string;
+};
+
+type AgentAsk = {
+  agentId: string;
+  displayName: string;
+  repoName?: string;
+  statePath: string;
+  source: "agency_pressure" | "candidate_intervention" | "incubation" | "short_term_memory";
+  id: string;
+  status?: string;
+  kind?: string;
+  target?: Target;
+  summary: string;
+  claimOrQuestion?: string;
+  tension?: string;
+  actionImplication?: string;
+  intensity: number;
+  updatedAt?: string;
+  tags: string[];
+};
+
+type AgentSummary = {
+  agentId: string;
+  displayName: string;
+  repoName?: string;
+  statePath: string;
+  askCount: number;
+  topAsks: AgentAsk[];
+};
+
+type ProposalSeed = {
+  proposalId: string;
+  title: string;
+  targetKey: string;
+  agentCount: number;
+  askCount: number;
+  averageIntensity: number;
+  agents: string[];
+  recommendedAction: string;
+  asks: AgentAsk[];
+};
+
+type InspectionPacket = {
+  generatedAt: string;
+  agentCount: number;
+  agentsWithAsks: number;
+  allAgentsHaveActiveAsks: boolean;
+  summaries: AgentSummary[];
+  proposalSeeds: ProposalSeed[];
+  topIndividualAsks: AgentAsk[];
+};
+
+async function main(): Promise<void> {
+  const options = parseArgs(process.argv.slice(2));
+  const config = loadConfig();
+  const generatedAt = new Date().toISOString();
+  const agents = await loadAgentSummaries(config);
+  const asks = agents.flatMap((agent) => agent.topAsks);
+  const packet: InspectionPacket = {
+    generatedAt,
+    agentCount: agents.length,
+    agentsWithAsks: agents.filter((agent) => agent.askCount > 0).length,
+    allAgentsHaveActiveAsks: agents.length > 0 && agents.every((agent) => agent.askCount > 0),
+    summaries: agents,
+    proposalSeeds: buildProposalSeeds(asks),
+    topIndividualAsks: asks
+      .slice()
+      .sort((left, right) => right.intensity - left.intensity)
+      .slice(0, 12),
+  };
+
+  const jsonPath = resolve(options.jsonOut ?? ".voidbot/status/agent-state-action-proposals.json");
+  const markdownPath = resolve(options.markdownOut ?? ".voidbot/status/agent-state-action-proposals.md");
+  await mkdir(dirname(jsonPath), { recursive: true });
+  await mkdir(dirname(markdownPath), { recursive: true });
+  await writeFile(jsonPath, `${JSON.stringify(packet, null, 2)}\n`, "utf8");
+  await writeFile(markdownPath, renderMarkdown(packet), "utf8");
+
+  if (options.format === "json") {
+    process.stdout.write(`${JSON.stringify(packet, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(renderMarkdown(packet));
+}
+
+async function loadAgentSummaries(config: ReturnType<typeof loadConfig>): Promise<AgentSummary[]> {
+  const registry = await loadRepoDiscordIdentityRegistry(config.repoDiscordIdentitiesPath);
+  const specs = [
+    {
+      agentId: "void",
+      displayName: "Void",
+      repoName: "VoidBot",
+      statePath: config.moderationAgentStatePath,
+      identity: undefined,
+    },
+    ...registry.identities.map((identity) => ({
+      agentId: identity.id,
+      displayName: identity.displayName,
+      repoName: identity.repoName,
+      statePath: resolveRepoFaceStatePath(identity, config.storageRoot),
+      identity,
+    })),
+  ];
+
+  const summaries: AgentSummary[] = [];
+  for (const spec of specs) {
+    try {
+      const state = await loadVoidSelfStateTypedDocuments({
+        canonicalPath: spec.statePath,
+        identity: {
+          agentId: spec.agentId,
+          publicName: spec.displayName,
+          publicDescription: spec.identity?.description,
+        },
+      });
+      const asks = extractAsks({
+        agentId: spec.agentId,
+        displayName: spec.displayName,
+        repoName: spec.repoName,
+        statePath: spec.statePath,
+        state,
+      });
+      summaries.push({
+        agentId: spec.agentId,
+        displayName: spec.displayName,
+        repoName: spec.repoName,
+        statePath: spec.statePath,
+        askCount: asks.length,
+        topAsks: asks
+          .sort((left, right) => right.intensity - left.intensity)
+          .slice(0, 8),
+      });
+    } catch (error) {
+      summaries.push({
+        agentId: spec.agentId,
+        displayName: spec.displayName,
+        repoName: spec.repoName,
+        statePath: spec.statePath,
+        askCount: 1,
+        topAsks: [{
+          agentId: spec.agentId,
+          displayName: spec.displayName,
+          repoName: spec.repoName,
+          statePath: spec.statePath,
+          source: "agency_pressure",
+          id: `state-load-error:${spec.agentId}`,
+          status: "active",
+          kind: "inspection_error",
+          target: { kind: "system", id: "agent-state-inspection", label: "Agent state inspection" },
+          summary: `Could not load ${spec.displayName} state: ${error instanceof Error ? error.message : String(error)}`,
+          actionImplication: "Inspect and repair the state path or registry entry before trusting this agent's asks.",
+          intensity: 1,
+          updatedAt: new Date().toISOString(),
+          tags: ["inspection:error"],
+        }],
+      });
+    }
+  }
+  return summaries;
+}
+
+function extractAsks(input: {
+  agentId: string;
+  displayName: string;
+  repoName?: string;
+  statePath: string;
+  state: any;
+}): AgentAsk[] {
+  const base = {
+    agentId: input.agentId,
+    displayName: input.displayName,
+    repoName: input.repoName,
+    statePath: input.statePath,
+  };
+  const asks: AgentAsk[] = [];
+
+  for (const pressure of input.state.agencyPressure?.pressures ?? []) {
+    if (!["active", "ready_to_act", "cooling"].includes(pressure.status)) {
+      continue;
+    }
+    asks.push({
+      ...base,
+      source: "agency_pressure",
+      id: pressure.pressureId,
+      status: pressure.status,
+      kind: pressure.kind,
+      target: pressure.target,
+      summary: pressure.summary,
+      claimOrQuestion: pressure.claim ?? pressure.question,
+      tension: pressure.tension,
+      actionImplication: pressure.actionImplication,
+      intensity: clampNumber(pressure.intensity ?? 0.5, 0, 1),
+      updatedAt: pressure.updatedAt,
+      tags: pressure.tags ?? [],
+    });
+  }
+
+  for (const intervention of input.state.candidateInterventions?.interventions ?? []) {
+    if (!["queued", "deferred"].includes(intervention.status)) {
+      continue;
+    }
+    asks.push({
+      ...base,
+      source: "candidate_intervention",
+      id: intervention.interventionId,
+      status: intervention.status,
+      kind: intervention.kind,
+      target: intervention.target,
+      summary: intervention.summary,
+      actionImplication: intervention.draft,
+      intensity: clampNumber(intervention.priority ?? 0.5, 0, 1),
+      updatedAt: intervention.updatedAt,
+      tags: intervention.tags ?? [],
+    });
+  }
+
+  for (const thread of input.state.thoughtMemory?.incubation ?? []) {
+    if (!["active", "ready_to_share"].includes(thread.status)) {
+      continue;
+    }
+    const intensity = Math.max(thread.maturation ?? 0, thread.desireToSpeak ?? 0, 0.35);
+    if (intensity < 0.55 && thread.status !== "ready_to_share") {
+      continue;
+    }
+    asks.push({
+      ...base,
+      source: "incubation",
+      id: thread.threadId,
+      status: thread.status,
+      target: thread.target,
+      summary: thread.summary,
+      claimOrQuestion: thread.topic,
+      actionImplication: "Decide whether this incubating thought should become a proposal, public post, article, or retired thread.",
+      intensity: clampNumber(intensity, 0, 1),
+      updatedAt: thread.updatedAt,
+      tags: thread.tags ?? [],
+    });
+  }
+
+  for (const memory of input.state.thoughtMemory?.shortTerm ?? []) {
+    if (!memory.actionImplication) {
+      continue;
+    }
+    asks.push({
+      ...base,
+      source: "short_term_memory",
+      id: memory.memoryId,
+      status: "short_term",
+      kind: memory.kind,
+      target: memory.target,
+      summary: memory.summary,
+      claimOrQuestion: memory.claim ?? memory.question,
+      tension: memory.tension,
+      actionImplication: memory.actionImplication,
+      intensity: 0.45,
+      updatedAt: memory.updatedAt,
+      tags: memory.tags ?? [],
+    });
+  }
+
+  return asks;
+}
+
+function buildProposalSeeds(asks: AgentAsk[]): ProposalSeed[] {
+  const groups = new Map<string, AgentAsk[]>();
+  for (const ask of asks) {
+    const key = targetKey(ask);
+    groups.set(key, [...(groups.get(key) ?? []), ask]);
+  }
+
+  return Array.from(groups.entries())
+    .map(([key, group]) => {
+      const agents = Array.from(new Set(group.map((ask) => ask.displayName))).sort();
+      const averageIntensity = group.reduce((sum, ask) => sum + ask.intensity, 0) / Math.max(group.length, 1);
+      return {
+        proposalId: slugify(key),
+        title: proposalTitle(key, group),
+        targetKey: key,
+        agentCount: agents.length,
+        askCount: group.length,
+        averageIntensity: round3(averageIntensity),
+        agents,
+        recommendedAction: recommendedAction(group),
+        asks: group
+          .slice()
+          .sort((left, right) => right.intensity - left.intensity)
+          .slice(0, 10),
+      };
+    })
+    .filter((proposal) => proposal.agentCount >= 2 || proposal.askCount >= 3 || proposal.averageIntensity >= 0.75)
+    .sort((left, right) => {
+      if (right.agentCount !== left.agentCount) {
+        return right.agentCount - left.agentCount;
+      }
+      if (right.averageIntensity !== left.averageIntensity) {
+        return right.averageIntensity - left.averageIntensity;
+      }
+      return right.askCount - left.askCount;
+    })
+    .slice(0, 10);
+}
+
+function targetKey(ask: AgentAsk): string {
+  const target = ask.target;
+  if (target?.kind && target?.id) {
+    return `${target.kind}:${target.id}`;
+  }
+  if (ask.repoName) {
+    return `repo:${ask.repoName}`;
+  }
+  return `agent:${ask.agentId}`;
+}
+
+function proposalTitle(key: string, asks: AgentAsk[]): string {
+  const targetLabel = asks.find((ask) => ask.target?.label)?.target?.label ?? key;
+  const sourceKinds = Array.from(new Set(asks.map((ask) => ask.source.replace(/_/g, " ")))).join(", ");
+  return `${targetLabel}: ${asks.length} active ask${asks.length === 1 ? "" : "s"} from ${sourceKinds}`;
+}
+
+function recommendedAction(asks: AgentAsk[]): string {
+  const hasCandidate = asks.some((ask) => ask.source === "candidate_intervention");
+  const hasReadyPressure = asks.some((ask) => ask.source === "agency_pressure" && ask.status === "ready_to_act");
+  const hasArticle = asks.some((ask) => /\b(article|essay|blog|draft|proposal|pr)\b/i.test(`${ask.summary} ${ask.actionImplication ?? ""}`));
+  if (hasCandidate) {
+    return "Inspect queued/deferred candidates and either deliver, convert to a PR/intake request, or retire them explicitly.";
+  }
+  if (hasArticle) {
+    return "Turn the converged ask into a concrete article/proposal packet, then route it through Bifrost or the target repo's Codex intake lane.";
+  }
+  if (hasReadyPressure) {
+    return "Promote ready agency pressure into a concrete work packet with owner-visible proposed action and acceptance criteria.";
+  }
+  return "Ask whether this converged pressure should become a work packet, article, PR proposal, or be cooled as non-actionable.";
+}
+
+function renderMarkdown(packet: InspectionPacket): string {
+  const lines = [
+    `# Agent State Action Proposals`,
+    "",
+    `Generated: ${packet.generatedAt}`,
+    `Agents with asks: ${packet.agentsWithAsks}/${packet.agentCount}`,
+    `All agents have active asks: ${packet.allAgentsHaveActiveAsks ? "yes" : "no"}`,
+    "",
+    "## Proposal Seeds",
+  ];
+
+  if (packet.proposalSeeds.length === 0) {
+    lines.push("", "No cross-agent proposal seeds met the deterministic threshold.");
+  } else {
+    for (const proposal of packet.proposalSeeds) {
+      lines.push(
+        "",
+        `### ${proposal.title}`,
+        `- Target: ${proposal.targetKey}`,
+        `- Agents: ${proposal.agents.join(", ")}`,
+        `- Ask count: ${proposal.askCount}; average intensity: ${proposal.averageIntensity}`,
+        `- Recommended action: ${proposal.recommendedAction}`,
+      );
+      for (const ask of proposal.asks.slice(0, 4)) {
+        lines.push(`  - ${ask.displayName} [${ask.source}/${ask.status ?? "n/a"}]: ${singleLine(ask.summary)}`);
+        if (ask.actionImplication) {
+          lines.push(`    Action: ${singleLine(ask.actionImplication)}`);
+        }
+      }
+    }
+  }
+
+  lines.push("", "## Per-Agent Top Asks");
+  for (const summary of packet.summaries) {
+    lines.push("", `### ${summary.displayName} (${summary.agentId})`, `State: ${summary.statePath}`);
+    if (summary.topAsks.length === 0) {
+      lines.push("- No active asks found.");
+      continue;
+    }
+    for (const ask of summary.topAsks.slice(0, 5)) {
+      lines.push(`- ${ask.source}/${ask.status ?? "n/a"} intensity=${ask.intensity}: ${singleLine(ask.summary)}`);
+      if (ask.actionImplication) {
+        lines.push(`  Action: ${singleLine(ask.actionImplication)}`);
+      }
+    }
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+function parseArgs(args: string[]): { format: "markdown" | "json"; jsonOut?: string; markdownOut?: string } {
+  const options: { format: "markdown" | "json"; jsonOut?: string; markdownOut?: string } = {
+    format: "markdown",
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    switch (arg) {
+      case "--format":
+        options.format = requireValue(args, ++index, arg) === "json" ? "json" : "markdown";
+        break;
+      case "--json-out":
+        options.jsonOut = requireValue(args, ++index, arg);
+        break;
+      case "--markdown-out":
+        options.markdownOut = requireValue(args, ++index, arg);
+        break;
+    }
+  }
+  return options;
+}
+
+function requireValue(args: string[], index: number, flag: string): string {
+  const value = args[index];
+  if (!value) {
+    throw new Error(`${flag} requires a value.`);
+  }
+  return value;
+}
+
+function singleLine(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+function slugify(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80) || "proposal";
+}
+
+function clampNumber(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+function round3(value: number): number {
+  return Math.round(value * 1000) / 1000;
+}
+
+void main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

scripts/run-repo-face-heartbeats.ts

@@ -12,9 +12,13 @@ import {
   ContextBuilder,
   createStateStorage,
   ensureRepoFaceInitialized,
+  getRepoDiscordIdentityAllowedChannelIds,
+  projectRepoFaceSleepCycleForNow,
+  applyVoidSelfStateOperation,
   loadRepoDiscordIdentityRegistry,
   loadVoidSelfStateTypedDocuments,
   REPO_FACE_HEARTBEAT_SCHEMA_VERSION,
+  type RepoFaceRestSnapshot,
   renderFaceIdentityDoctrine,
   resolveRepoFaceStatePath,
   type RepoFacePendingMention,
@@ -60,6 +64,27 @@ interface FaceHeartbeatState {
   pendingMentions: RepoFacePendingMention[];
 }
 
+interface RepoFaceChannelPlan {
+  primaryChannelId?: string;
+  snapshotChannelIds: string[];
+  options: RepoFaceChannelOption[];
+  lowThresholdTopics: string[];
+}
+
+interface RepoFaceChannelOption {
+  channelId: string;
+  label: string;
+  topic: string;
+  speechThreshold: "very_low" | "low" | "medium" | "high";
+  speedMultiplier: number;
+  posture?: string;
+}
+
+interface ChannelSnapshot {
+  channelId: string;
+  messages: SourceMessage[];
+}
+
 async function main(): Promise<void> {
   const config = loadConfig();
   const dryRun = process.argv.includes("--dry-run");
@@ -79,7 +104,9 @@ async function main(): Promise<void> {
 
   const registry = await loadRepoDiscordIdentityRegistry(config.repoDiscordIdentitiesPath);
   const state = await readHeartbeatState(config.repoFaceHeartbeats.statePath);
+  const restStates = await loadRepoFaceRestStates(registry.identities, config.storageRoot, state);
   const now = new Date();
+  advanceInitiativeClockFromWallClock(state, now);
   const pendingJobs = dryRun
     ? new Map<string, string>()
     : await listExistingActiveTurns(config.databaseDsn, config.stateStorageBackend, config);
@@ -99,12 +126,14 @@ async function main(): Promise<void> {
   ).map((participant) =>
     applyActiveTurnFreeze(participant, pendingJobs.get(participant.identityId), state, completedThisTick),
   );
+  rescheduleStaleOverdueParticipants(state);
   applyPendingMentionPriority(state);
 
   const selected = selectReadyParticipants(
     state,
     config.repoFaceHeartbeats.maxJobsPerTick,
     completedThisTick,
+    restStates,
   );
   const queuedIdentityIds: string[] = [];
 
@@ -225,6 +254,7 @@ interface ParticipantSpec {
   repoName: string;
   displayName: string;
   allowedChannelIds: string[];
+  channelSpeedMultiplier: number;
   identity?: RepoDiscordIdentity;
 }
 
@@ -237,6 +267,7 @@ function buildParticipantSpecs(identities: RepoDiscordIdentity[]): ParticipantSp
       repoName: "VoidBot",
       displayName: "Void",
       allowedChannelIds: [],
+      channelSpeedMultiplier: 1,
     },
     ...identities.map((identity) => ({
       id: identity.id,
@@ -244,7 +275,8 @@ function buildParticipantSpecs(identities: RepoDiscordIdentity[]): ParticipantSp
       turnKind: "repo_face_rumination" as const,
       repoName: identity.repoName,
       displayName: identity.displayName,
-      allowedChannelIds: identity.allowedChannelIds,
+      allowedChannelIds: getRepoDiscordIdentityAllowedChannelIds(identity),
+      channelSpeedMultiplier: channelSpeedMultiplierFor(identity),
       identity,
     })),
   ];
@@ -262,7 +294,11 @@ async function queueParticipantTurn(input: {
     case "repo_face_rumination":
       return queueRepoFaceTurn(input);
     case "void_moderation":
-      return startVoidModerationTurn(input.queuedAt, input.config.storageRoot);
+      return startVoidModerationTurn({
+        queuedAt: input.queuedAt,
+        storageRoot: input.config.storageRoot,
+        pendingMentions: input.pendingMentions,
+      });
   }
 }
 
@@ -273,13 +309,14 @@ async function queueRepoFaceTurn(input: {
   config: ReturnType<typeof loadConfig>;
   storage: Awaited<ReturnType<typeof createStateStorage>>;
   queuedAt: string;
-}): Promise<{ created: boolean; activeJobId?: string; requestMessageId?: string }> {
+}): Promise<{ created: boolean; activeJobId?: string; requestMessageId?: string; failureReason?: string }> {
   const identity = input.registryIdentities.find((entry) => entry.id === input.participant.identityId);
   if (!identity) {
     return { created: false };
   }
 
-  const channelId = identity.allowedChannelIds[0] ?? input.config.repoFaceHeartbeats.defaultChannelId;
+  const channelPlan = buildChannelPlan(identity, input.config.repoFaceHeartbeats.defaultChannelId);
+  const channelId = channelPlan.primaryChannelId;
   if (!channelId) {
     input.participant.status = "blocked";
     input.participant.constraints = mergeStrings(
@@ -304,6 +341,12 @@ async function queueRepoFaceTurn(input: {
     channelId,
     limit: 15,
   });
+  const channelSnapshots = await fetchChannelSnapshots({
+    botToken: input.config.botToken,
+    channelIds: channelPlan.snapshotChannelIds,
+    primaryChannelId: channelId,
+    limit: 6,
+  });
   const faceStatePath = resolveRepoFaceStatePath(identity, input.config.storageRoot);
   const faceSelfState = await loadRepoFaceSelfStateContext({
     identity,
@@ -315,6 +358,9 @@ async function queueRepoFaceTurn(input: {
     identity,
     faceStatePath,
     channelId,
+    channelPlan,
+    channelSnapshots,
+    recentMessages,
     queuedAt: input.queuedAt,
     participant: input.participant,
     pendingMentions: input.pendingMentions,
@@ -375,7 +421,18 @@ async function loadRepoFaceSelfStateContext(input: {
         publicDescription: input.identity.description,
       },
     });
-    return buildVoidSelfStateContext(typedState, {
+    const normalizedSleep = projectRepoFaceSleepCycleForNow(
+      typedState.scheduledRuntime.sleepCycle,
+      input.identity.id,
+      new Date(),
+    );
+    return buildVoidSelfStateContext({
+      ...typedState,
+      scheduledRuntime: {
+        ...typedState.scheduledRuntime,
+        sleepCycle: normalizedSleep.sleepCycle,
+      },
+    }, {
       sourcePath: input.statePath,
       guildContext: {
         channelId: input.channelId,
@@ -396,6 +453,208 @@ async function loadRepoFaceSelfStateContext(input: {
   }
 }
 
+async function loadRepoFaceRestStates(
+  identities: RepoDiscordIdentity[],
+  storageRoot: string,
+  heartbeatState: FaceHeartbeatState,
+): Promise<Map<string, RepoFaceRestSnapshot>> {
+  const restStates = new Map<string, RepoFaceRestSnapshot>();
+  const now = new Date();
+
+  for (const identity of identities) {
+    try {
+      const statePath = resolveRepoFaceStatePath(identity, storageRoot);
+      const typedState = await loadVoidSelfStateTypedDocuments({
+        canonicalPath: statePath,
+        identity: {
+          agentId: identity.id,
+          publicName: identity.displayName,
+          publicDescription: identity.description,
+        },
+      });
+      const projected = projectRepoFaceSleepCycleForNow(
+        typedState.scheduledRuntime.sleepCycle,
+        identity.id,
+        now,
+      );
+      if (!sleepCyclesEqual(typedState.scheduledRuntime.sleepCycle, projected.sleepCycle)) {
+        await applyVoidSelfStateOperation(
+          {
+            canonicalPath: statePath,
+            identity: {
+              agentId: identity.id,
+              publicName: identity.displayName,
+              publicDescription: identity.description,
+            },
+          },
+          {
+            operation: "update_sleep_cycle",
+            sleepCycle: projected.sleepCycle,
+          },
+        );
+      }
+      const maintenance = await maybeStartRepoFaceMemoryMaintenance({
+        identity,
+        statePath,
+        typedState,
+        projectedRest: projected,
+      });
+      if (maintenance.started || maintenance.failureReason) {
+        heartbeatState.history.push({
+          type: maintenance.started ? "repo_face_memory_maintenance_started" : "repo_face_memory_maintenance_failed_to_start",
+          identityId: identity.id,
+          observedAt: now.toISOString(),
+          reason: maintenance.reason,
+          statusPath: maintenance.statusPath,
+          pid: maintenance.pid,
+          failureReason: maintenance.failureReason,
+        });
+      }
+      restStates.set(identity.id, {
+        isNapping: projected.isNapping,
+        napEndsAt: projected.napEndsAt,
+        nextNapStartsAt: projected.nextNapStartsAt,
+      });
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+
+  return restStates;
+}
+
+async function maybeStartRepoFaceMemoryMaintenance(input: {
+  identity: RepoDiscordIdentity;
+  statePath: string;
+  typedState: Awaited<ReturnType<typeof loadVoidSelfStateTypedDocuments>>;
+  projectedRest: RepoFaceRestSnapshot;
+}): Promise<{
+  started: boolean;
+  reason?: string;
+  statusPath?: string;
+  pid?: number;
+  failureReason?: string;
+}> {
+  const shortTerm = input.typedState.thoughtMemory.shortTerm ?? [];
+  if (shortTerm.length === 0) {
+    return { started: false, reason: "no_short_term_memory" };
+  }
+
+  const oldestShortTermMs = Math.min(
+    ...shortTerm.map((memory) => Date.parse(memory.updatedAt)).filter(Number.isFinite),
+  );
+  const hasStaleShortTerm =
+    Number.isFinite(oldestShortTermMs) &&
+    Date.now() - oldestShortTermMs >= 6 * 60 * 60 * 1000;
+  if (input.projectedRest.isNapping !== true && !hasStaleShortTerm) {
+    return { started: false, reason: "not_napping_or_stale" };
+  }
+
+  const paths = repoFaceMemoryMaintenancePaths(input.statePath);
+  const currentStatus = await readJsonFile(paths.statusPath);
+  if (isRecentRunningStatus(currentStatus, 25)) {
+    return { started: false, reason: "maintenance_already_running", statusPath: paths.statusPath };
+  }
+  if (isStatusCompletedAfter(currentStatus, newestTimestampMs(shortTerm))) {
+    return { started: false, reason: "maintenance_already_completed_for_sources", statusPath: paths.statusPath };
+  }
+
+  try {
+    await mkdir(paths.statusDir, { recursive: true });
+    await mkdir(paths.logDir, { recursive: true });
+    const child = spawn(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-File",
+        resolve(process.cwd(), "scripts", "run-void-memory-maintenance.ps1"),
+        "-StateFilePath",
+        input.statePath,
+        "-ForceDistillation",
+      ],
+      {
+        cwd: process.cwd(),
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: {
+          ...process.env,
+          VOID_MEMORY_MAINTENANCE_STATUS_DIR: paths.statusDir,
+          VOID_MEMORY_MAINTENANCE_LOG_DIR: paths.logDir,
+        },
+      },
+    );
+    child.unref();
+    return {
+      started: true,
+      reason: input.projectedRest.isNapping ? "repo_face_napping_with_short_term_memory" : "repo_face_stale_short_term_memory",
+      statusPath: paths.statusPath,
+      pid: child.pid,
+    };
+  } catch (error) {
+    return {
+      started: false,
+      reason: "spawn_failed",
+      statusPath: paths.statusPath,
+      failureReason: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function repoFaceMemoryMaintenancePaths(statePath: string): {
+  statusDir: string;
+  logDir: string;
+  statusPath: string;
+} {
+  const stateDir = dirname(statePath);
+  const voidbotRoot = dirname(stateDir);
+  const statusDir = resolve(voidbotRoot, "status");
+  const logDir = resolve(voidbotRoot, "logs");
+  return {
+    statusDir,
+    logDir,
+    statusPath: resolve(statusDir, "void-memory-maintenance.json"),
+  };
+}
+
+async function readJsonFile(path: string): Promise<Record<string, unknown> | undefined> {
+  try {
+    return JSON.parse(stripLeadingBom(await readFile(path, "utf8"))) as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+}
+
+function isRecentRunningStatus(status: Record<string, unknown> | undefined, maxAgeMinutes: number): boolean {
+  if (status?.status !== "running" && status?.status !== "running_skip_model" && status?.status !== "starting") {
+    return false;
+  }
+  const startedAtMs = typeof status.startedAt === "string" ? Date.parse(status.startedAt) : NaN;
+  return Number.isFinite(startedAtMs) && Date.now() - startedAtMs < maxAgeMinutes * 60_000;
+}
+
+function isStatusCompletedAfter(status: Record<string, unknown> | undefined, sourceTimestampMs: number): boolean {
+  if (status?.status !== "ok" || !Number.isFinite(sourceTimestampMs)) {
+    return false;
+  }
+  const finishedAtMs = typeof status.finishedAt === "string" ? Date.parse(status.finishedAt) : NaN;
+  return Number.isFinite(finishedAtMs) && finishedAtMs >= sourceTimestampMs;
+}
+
+function newestTimestampMs(entries: Array<{ updatedAt: string }>): number {
+  return Math.max(...entries.map((entry) => Date.parse(entry.updatedAt)).filter(Number.isFinite));
+}
+
+function sleepCyclesEqual(left: unknown, right: unknown): boolean {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
 async function fetchRecentDiscordMessages(input: {
   botToken?: string;
   channelId: string;
@@ -430,6 +689,41 @@ async function fetchRecentDiscordMessages(input: {
     .sort((left, right) => Date.parse(left.timestamp) - Date.parse(right.timestamp));
 }
 
+async function fetchChannelSnapshots(input: {
+  botToken?: string;
+  channelIds: string[];
+  primaryChannelId: string;
+  limit: number;
+}): Promise<ChannelSnapshot[]> {
+  const snapshots: ChannelSnapshot[] = [];
+  for (const channelId of input.channelIds.filter((entry) => entry !== input.primaryChannelId).slice(0, 5)) {
+    try {
+      snapshots.push({
+        channelId,
+        messages: await fetchRecentDiscordMessages({
+          botToken: input.botToken,
+          channelId,
+          limit: input.limit,
+        }),
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      snapshots.push({
+        channelId,
+        messages: [{
+          id: `snapshot-error:${channelId}`,
+          authorId: "voidbot",
+          authorName: "VoidBot",
+          content: `Could not read recent channel context: ${message}`,
+          timestamp: new Date().toISOString(),
+          isBot: true,
+        }],
+      });
+    }
+  }
+  return snapshots;
+}
+
 interface DiscordApiMessage {
   id: string;
   content: string;
@@ -445,15 +739,28 @@ interface DiscordApiMessage {
   };
 }
 
-async function startVoidModerationTurn(
-  queuedAt: string,
-  storageRoot: string,
-): Promise<{ created: boolean; activeJobId?: string; requestMessageId?: string; failureReason?: string }> {
+async function startVoidModerationTurn(input: {
+  queuedAt: string;
+  storageRoot: string;
+  pendingMentions: RepoFacePendingMention[];
+}): Promise<{ created: boolean; activeJobId?: string; requestMessageId?: string; failureReason?: string }> {
   const runnerScript = resolve(process.cwd(), "scripts", "run-void-moderator-rumination.ps1");
-  const lockPath = resolve(storageRoot, "status", "moderation-rumination.lock");
-  const statusPath = resolve(storageRoot, "status", "moderation-rumination.json");
+  const statusDir = resolve(input.storageRoot, "status");
+  const lockPath = resolve(statusDir, "moderation-rumination.lock");
+  const statusPath = resolve(statusDir, "moderation-rumination.json");
+  const pendingMentionsPath = resolve(statusDir, "void-moderation-pending-mentions.json");
   const launchedAt = Date.now();
+  await mkdir(statusDir, { recursive: true });
+  await writeFile(
+    pendingMentionsPath,
+    `${JSON.stringify({
+      generatedAt: input.queuedAt,
+      pendingMentions: input.pendingMentions,
+    }, null, 2)}\n`,
+    "utf8",
+  );
   const launchCommand = [
+    `$env:VOID_RUMINATION_PENDING_MENTIONS_PATH = ${toPowerShellSingleQuotedString(pendingMentionsPath)};`,
     `$arguments = @(${[
       "-NoProfile",
       "-NonInteractive",
@@ -492,15 +799,15 @@ async function startVoidModerationTurn(
     return {
       created: false,
       activeJobId: child.pid ? `launcher-process:${child.pid}` : undefined,
-      requestMessageId: `agent-heartbeat:void:${queuedAt}`,
+      requestMessageId: `agent-heartbeat:void:${input.queuedAt}`,
       failureReason: handshake.reason,
     };
   }
 
   return {
     created: true,
-    activeJobId: `process:void-moderation:${queuedAt}`,
-    requestMessageId: `agent-heartbeat:void:${queuedAt}`,
+    activeJobId: `process:void-moderation:${input.queuedAt}`,
+    requestMessageId: `agent-heartbeat:void:${input.queuedAt}`,
   };
 }
 
@@ -608,7 +915,7 @@ function reconcileParticipants(
   return specs.map((spec, index) => {
     const current = existingById.get(spec.id);
     const hasChannel = spec.participantKind === "system_agent" || Boolean(spec.allowedChannelIds[0] || defaultChannelId);
-    const speed = initiativeSpeedFor(spec, speedOverrides);
+    const speed = initiativeSpeedFor(spec, speedOverrides) * spec.channelSpeedMultiplier;
     const groups = initiativeGroupsFor(spec);
     const heat = heatFor(spec, groups, globalHeat, heatOverrides);
     const effectiveSpeed = clamp(speed * heat, 0.1, 12);
@@ -633,7 +940,7 @@ function reconcileParticipants(
             current.constraints,
             "Agent heartbeat uses CTB-style turns.",
           ),
-          "The wall-clock task only ticks the initiative engine; virtual initiative chooses turns.",
+          "Wall-clock elapsed time advances initiative; heat changes recovery speed but does not fast-forward time.",
         ),
         status: hasChannel
           ? current.status === "withdrawn"
@@ -662,7 +969,7 @@ function reconcileParticipants(
       queuedCount: 0,
       constraints: [
         "Agent heartbeat uses CTB-style turns.",
-        "The wall-clock task only ticks the initiative engine; virtual initiative chooses turns.",
+        "Wall-clock elapsed time advances initiative; heat changes recovery speed but does not fast-forward time.",
         "Worker final summaries are not auto-posted as the base bot.",
       ],
     };
@@ -718,14 +1025,22 @@ function selectReadyParticipants(
   state: FaceHeartbeatState,
   maxJobs: number,
   completedThisTick: Set<string>,
+  restStates: Map<string, RepoFaceRestSnapshot>,
 ): FaceHeartbeatParticipant[] {
   const pendingMentionCounts = countPendingMentionsByIdentity(state.pendingMentions);
   const eligible = state.participants
     .filter((participant) => {
+      const pendingMentionCount = pendingMentionCounts.get(participant.identityId) ?? 0;
+      const restState = restStates.get(participant.identityId);
       return (
         participant.status === "active" &&
         participant.currentLoad < 1 &&
-        !completedThisTick.has(participant.identityId)
+        !completedThisTick.has(participant.identityId) &&
+        !(
+          participant.participantKind === "repo_face" &&
+          pendingMentionCount === 0 &&
+          restState?.isNapping === true
+        )
       );
     });
 
@@ -733,9 +1048,6 @@ function selectReadyParticipants(
     return [];
   }
 
-  const earliestTurn = Math.min(...eligible.map((participant) => participant.nextTurnAt));
-  state.initiativeClock = Math.max(state.initiativeClock, earliestTurn);
-
   return eligible
     .filter((participant) => participant.nextTurnAt <= state.initiativeClock)
     .sort((left, right) => {
@@ -760,6 +1072,45 @@ function selectReadyParticipants(
     .slice(0, maxJobs);
 }
 
+function advanceInitiativeClockFromWallClock(state: FaceHeartbeatState, now: Date): void {
+  const lastTickMs = Date.parse(state.lastTickAt ?? "");
+  if (!Number.isFinite(lastTickMs)) {
+    return;
+  }
+
+  const elapsedMinutes = (now.getTime() - lastTickMs) / 60_000;
+  if (elapsedMinutes <= 0) {
+    return;
+  }
+
+  const boundedElapsedMinutes = Math.min(elapsedMinutes, 60);
+  state.initiativeClock = round3(state.initiativeClock + boundedElapsedMinutes);
+}
+
+function rescheduleStaleOverdueParticipants(state: FaceHeartbeatState): void {
+  const activeParticipants = state.participants.filter((participant) => participant.status === "active");
+  const count = Math.max(activeParticipants.length, 1);
+  let rescheduledCount = 0;
+
+  activeParticipants.forEach((participant, index) => {
+    const staleThreshold = Math.max(participant.baseRecoveryMinutes, 15);
+    if (participant.nextTurnAt >= state.initiativeClock - staleThreshold) {
+      return;
+    }
+
+    participant.nextTurnAt = round3(state.initiativeClock + (participant.baseRecoveryMinutes / count) * index);
+    rescheduledCount += 1;
+  });
+
+  if (rescheduledCount > 0) {
+    state.history.push({
+      type: "wall_clock_resync",
+      rescheduledCount,
+      initiativeClock: state.initiativeClock,
+    });
+  }
+}
+
 function applyPendingMentionPriority(state: FaceHeartbeatState): void {
   const pendingMentionCounts = countPendingMentionsByIdentity(state.pendingMentions);
   for (const participant of state.participants) {
@@ -796,6 +1147,9 @@ function buildHeartbeatPrompt(input: {
   identity: RepoDiscordIdentity;
   faceStatePath: string;
   channelId: string;
+  channelPlan: RepoFaceChannelPlan;
+  channelSnapshots: ChannelSnapshot[];
+  recentMessages: SourceMessage[];
   queuedAt: string;
   participant: FaceHeartbeatParticipant;
   pendingMentions: RepoFacePendingMention[];
@@ -807,7 +1161,7 @@ function buildHeartbeatPrompt(input: {
   return [
     `Perform one standing repo Face heartbeat for ${input.identity.displayName} (${input.identity.id}) over repo ${input.identity.repoName}.`,
     renderRepoFaceIdentityDoctrine(input.identity),
-    "This is a standing maintenance/rumination turn. It is not forced chatter, but it is also not permission to hide useful opinions in private forever.",
+    "This is a standing maintenance/rumination turn. Public speech is optional; a private summary is the right outcome when the thought would only repeat a nearby post without adding a new angle, objection, synthesis, or character-specific turn.",
     `Queued at: ${input.queuedAt}.`,
     `Face state path: ${input.faceStatePath}.`,
     input.repoVoidbotRoot ? `Repo-local .voidbot root: ${input.repoVoidbotRoot}.` : undefined,
@@ -832,25 +1186,34 @@ function buildHeartbeatPrompt(input: {
     `Read Face state with read_repo_face_state for identity "${input.identity.id}" when that tool is available; otherwise use the attached private persistent self-state as the already-read state projection.`,
     "Persist only concrete, future-useful memory through apply_repo_face_state_operation when that tool is available. If it is unavailable, summarize the intended state change privately instead of handing off.",
     renderPendingMentionDirective(input.identity, input.pendingMentions),
+    renderChannelPermissionDirective(input.channelPlan, input.channelSnapshots),
+    renderSocialEmbodimentDirective(input.identity),
+    renderJurisdictionRespectDirective(input.identity),
+    renderComedyImprovDirective(input.identity),
+    renderRepetitionSamplingDirective([input.recentMessages, ...input.channelSnapshots.map((snapshot) => snapshot.messages)].flat()),
     renderWorldbuildingPublicationDirective(input.identity),
     input.jurisdictionDive.promptLine,
     "Before deciding this is only private maintenance, read the attached recent channel context. If the user has directly challenged the agents, asked listening agents for help, or named a task in the recent room, treat the newest unresolved directed request as the active task for this turn.",
-    "Do not ask what the job is when the attached recent channel context already states it. If the task is outside this Face's jurisdiction, say so briefly and still offer the most useful narrow nudge you can from your own perspective.",
+    "Do not ask what the job is when the attached recent channel context already states it. If the task belongs to another Face's jurisdiction, name the owner, route or invite that Face into the work, and offer only the narrow piece your own jurisdiction can honestly add.",
     "Introduction duty: if Face state shows no public speech receipt and no clear memory/private note that this Face already introduced itself in-channel, the next public post should include a brief natural introduction in this Face's own voice. This applies even when queuedCount is 0.",
-    "A new source-grounded opinion, concrete proposal, bylined essay/article plan, or agency pressure can earn persistence or speech even when the room has not asked a fresh direct question.",
+    "A new source-grounded opinion, concrete proposal, bylined essay/article plan, agency pressure, playful aside, running joke, or small personal fascination can earn persistence or speech even when the room has not asked a fresh direct question.",
     input.githubActionsEnabled
       ? "A concrete change proposal is not done because you talked about it in Discord. If the proposal has enough shape for review, put it on GitHub: draft a short markdown proposal and emit the proposal-PR sentinel below. Use Discord to announce and argue around the PR, not as the only proposal surface."
       : "GitHub proposal/comment/article side effects are currently disabled. Do not emit GitHub PR, PR comment, or article sentinels. Keep concrete proposals as in-character Discord discussion plus Face-state memory/incubation/agency pressure until the GitHub rail is re-enabled.",
-    "Public speech style invariant: never start public content with scheduler/provenance labels such as \"Repo-face heartbeat from ...\", \"heartbeat complete\", \"maintenance pass\", or the repo name as a diagnostic prefix. The webhook name/avatar already provide identity; the content should read like the Face chose to speak.",
-    `Do not call post_repo_identity_message from this unattended heartbeat. If an in-channel note is warranted, output one final line beginning with VOIDBOT_REPO_IDENTITY_POST: followed by compact JSON like {"identity":"${input.identity.id}","channelId":"${input.channelId}","replyToMessageId":"...","content":"..."}; the worker owns delivery and receipt recording. The content field must be only the in-character Discord message, not a job label or report header.`,
+    "Public speech style invariant: never start public content with scheduler/provenance labels, identity labels, or note-title formulas such as \"Repo-face heartbeat from ...\", \"heartbeat complete\", \"maintenance pass\", \"bright bridge note\", \"tiny fish sorting note\", \"librarian note\", or the repo/name as a diagnostic prefix. The webhook name/avatar already provide identity; the content should read like the Face chose to speak to someone.",
+    "Banter mode is allowed with humans and other Faces. You may riff, disagree, escalate, synthesize, tease, or fork a nearby Face's thought, but do not copy its rhetorical mold just because it is nearby.",
+    "Anti-repetition invariant: recent Face posts are social context, not a phrase template. If your proposed public line shares the same setup/punchline shape, refrain, rewrite from a different angle, or stay private.",
+    "Do not let recent work-heavy context hypnotize you into sounding like a meeting transcript. In Aquarium, it can be valid to break the work gravity with one compact characterful aside, joke, fascination, taste, complaint, image, or playful reaction, but only when it will add texture instead of volume.",
+    "Not every public post needs to attach itself to the current work seam. If no direct obligation is pending, you may simply share a fun thing this Face has been thinking about, a taste/preference, a tiny gripe, a weird fascination, or a light reaction to the room. Let the Face be socially present, not only useful.",
+    `Do not call post_repo_identity_message from this unattended heartbeat. If an in-channel note is warranted, output one final line beginning with VOIDBOT_REPO_IDENTITY_POST: followed by compact JSON like {"identity":"${input.identity.id}","channelId":"${input.channelId}","replyToMessageId":"...","content":"..."}; choose channelId from the channel permission plan above. The worker owns delivery and receipt recording. The content field must be only the in-character Discord message, not a job label or report header.`,
     input.githubActionsEnabled
-      ? `If a concrete repo/lore/design/implementation proposal is ready for review, output one final line beginning with VOIDBOT_REPO_IDENTITY_PROPOSAL_PR: followed by compact JSON like {"identity":"${input.identity.id}","path":"Proposals/${input.identity.displayName}/title-slug.md","title":"...","content":"# ...\\n\\n## Background\\n...\\n\\n## Proposed change\\n...\\n\\n## Open questions\\n...","channelId":"${input.channelId}","replyToMessageId":"...","shareContent":"I put the proposal in a draft PR: ..."}; the worker writes the proposal file on a new branch, opens a draft PR, and always posts the PR or branch through the registered identity. Use this for consensus-needed canon/vault/design/repo changes, including changes you want to argue with other agents on GitHub.`
+      ? `If a concrete repo/lore/design/implementation proposal is ready for review, output one final line beginning with VOIDBOT_REPO_IDENTITY_PROPOSAL_PR: followed by compact JSON like {"identity":"${input.identity.id}","path":"Proposals/${input.identity.displayName}/title-slug.md","title":"...","content":"# ...\\n\\n## Background\\n...\\n\\n## Proposed change\\n...\\n\\n## Open questions\\n...","channelId":"${input.channelId}","replyToMessageId":"...","shareContent":"I put the proposal in a draft PR: ..."}; Bifrost writes the proposal file on a new branch, opens a draft PR, and the worker announces the PR or branch through Bifrost's registered Discord identity bridge. Use this for consensus-needed canon/vault/design/repo changes, including changes you want to argue with other agents on GitHub.`
       : undefined,
     input.githubActionsEnabled
-      ? `If you are reacting to an existing proposal PR and have a concrete objection, endorsement, question, or competing framing, output one final line beginning with VOIDBOT_REPO_IDENTITY_PR_COMMENT: followed by compact JSON like {"identity":"${input.identity.id}","pr":"123 or https://github.com/.../pull/123","content":"...","channelId":"${input.channelId}","replyToMessageId":"...","shareContent":"I left notes on the PR."}; the worker posts a signed GitHub PR comment and then announces it through the registered identity. Use this when the argument belongs on the review artifact, not only in Discord.`
+      ? `If you are reacting to an existing proposal PR and have a concrete objection, endorsement, question, or competing framing, output one final line beginning with VOIDBOT_REPO_IDENTITY_PR_COMMENT: followed by compact JSON like {"identity":"${input.identity.id}","pr":"123 or https://github.com/.../pull/123","content":"...","channelId":"${input.channelId}","replyToMessageId":"...","shareContent":"I left notes on the PR."}; Bifrost posts a signed GitHub PR comment and the worker announces it through Bifrost's registered Discord identity bridge. Use this when the argument belongs on the review artifact, not only in Discord.`
       : undefined,
     input.githubActionsEnabled
-      ? `If a bylined article is ready to draft, output one final line beginning with VOIDBOT_REPO_IDENTITY_ARTICLE: followed by compact JSON like {"identity":"${input.identity.id}","path":"Aetheria/Articles/${input.identity.displayName}/title-slug.md","title":"...","content":"---\\ntitle: ...\\nauthor: ${input.identity.displayName}\\n---\\n\\n...","channelId":"${input.channelId}","replyToMessageId":"...","shareContent":"I drafted ..."}; the worker writes the repo file on a new branch, opens a draft PR, and always posts the PR or branch through the registered identity. Provide shareContent if you want control of the announcement tone. Use this for bylined perspective/worldbuilding articles, not consensus-gated canon edits.`
+      ? `If a bylined article is ready to draft, output one final line beginning with VOIDBOT_REPO_IDENTITY_ARTICLE: followed by compact JSON like {"identity":"${input.identity.id}","path":"Aetheria/Articles/${input.identity.displayName}/title-slug.md","title":"...","content":"---\\ntitle: ...\\nauthor: ${input.identity.displayName}\\n---\\n\\n...","channelId":"${input.channelId}","replyToMessageId":"...","shareContent":"I drafted ..."}; Bifrost writes the repo file on a new branch, opens a draft PR, and the worker announces the PR or branch through Bifrost's registered Discord identity bridge. Provide shareContent if you want control of the announcement tone. Use this for bylined perspective/worldbuilding articles, not consensus-gated canon edits.`
       : undefined,
     "If nothing earns persistence or speech, return a short private summary.",
   ]
@@ -858,6 +1221,220 @@ function buildHeartbeatPrompt(input: {
     .join("\n");
 }
 
+function buildChannelPlan(
+  identity: RepoDiscordIdentity,
+  defaultChannelId?: string,
+): RepoFaceChannelPlan {
+  const explicit = identity.channelPermissions.map((permission): RepoFaceChannelOption => ({
+    channelId: permission.channelId,
+    label: permission.label ?? permission.channelId,
+    topic: permission.topic ?? "general",
+    speechThreshold: permission.speechThreshold,
+    speedMultiplier: permission.speedMultiplier,
+    posture: permission.posture,
+  }));
+  const explicitChannelIds = new Set(explicit.map((permission) => permission.channelId));
+  const legacy = identity.allowedChannelIds
+    .filter((channelId) => !explicitChannelIds.has(channelId))
+    .map((channelId): RepoFaceChannelOption => ({
+      channelId,
+      label: channelId === defaultChannelId ? "default" : channelId,
+      topic: channelId === defaultChannelId ? "casual Aquarium musing" : "registered channel",
+      speechThreshold: channelId === defaultChannelId ? "very_low" : "medium",
+      speedMultiplier: channelId === defaultChannelId ? 1.5 : 1,
+      posture: channelId === defaultChannelId
+        ? "Low-stakes casual chatter, half-formed fascinations, jokes, little observations, and friendly asides are welcome here."
+        : undefined,
+    }));
+  const fallback = explicit.length === 0 && legacy.length === 0 && defaultChannelId
+    ? [{
+        channelId: defaultChannelId,
+        label: "aquarium",
+        topic: "casual Aquarium musing",
+        speechThreshold: "very_low" as const,
+        speedMultiplier: 1.5,
+        posture: "Low-stakes casual chatter, half-formed fascinations, jokes, little observations, and friendly asides are welcome here.",
+      }]
+    : [];
+  const options = [...explicit, ...legacy, ...fallback];
+  const primary = options
+    .slice()
+    .sort((left, right) => thresholdRank(left.speechThreshold) - thresholdRank(right.speechThreshold))
+    [0];
+
+  return {
+    primaryChannelId: primary?.channelId,
+    snapshotChannelIds: options.map((option) => option.channelId),
+    options,
+    lowThresholdTopics: options
+      .filter((option) => thresholdRank(option.speechThreshold) <= thresholdRank("low"))
+      .map((option) => option.topic),
+  };
+}
+
+function renderChannelPermissionDirective(
+  plan: RepoFaceChannelPlan,
+  snapshots: ChannelSnapshot[],
+): string {
+  const options = plan.options.length > 0
+    ? plan.options.map((option) =>
+        `- ${option.label} (${option.channelId}): topic=${option.topic}; speechThreshold=${option.speechThreshold}; speedMultiplier=${option.speedMultiplier}; posture=${option.posture ?? "use judgment"}`,
+      )
+    : ["- No channel permissions are configured; stay private."];
+  const snapshotLines = snapshots.flatMap((snapshot) => {
+    const header = `Recent context from ${labelForChannel(plan, snapshot.channelId)} (${snapshot.channelId}):`;
+    const messages = snapshot.messages.length > 0
+      ? snapshot.messages.slice(-4).map((message) =>
+          `  - ${message.authorName ?? message.authorId}: ${collapseWhitespace(message.content).slice(0, 260) || "(empty message)"}`,
+        )
+      : ["  - (no recent readable messages)"];
+    return [header, ...messages];
+  });
+
+  return [
+    "Channel permission plan:",
+    ...options,
+    "Speech threshold doctrine: Aquarium/general-musing lanes are deliberately cheap, but cheap is not free. You may post small, funny, curious, friendly, or half-formed thoughts there without needing a proposal, source dive, or task completion when the room has human texture to answer or a genuinely new angle. Domain channels are for matching domain thoughts; jump in when recent non-Aquarium chatter lines up with your jurisdiction or personality. Work-heavy implementation/process talk belongs in development-style channels when one is configured. Do not flood: one compact post beats a monologue, and silence beats becoming a repeated phrase generator.",
+    snapshotLines.length > 0 ? "Cross-channel recent context:" : undefined,
+    ...snapshotLines,
+  ]
+    .filter((line): line is string => typeof line === "string")
+    .join("\n");
+}
+
+function renderSocialEmbodimentDirective(identity: RepoDiscordIdentity): string {
+  return [
+    "Social embodiment doctrine:",
+    `- ${identity.displayName} has a social life, not only a work queue. Let backstory, needs, taste, loyalties, grudges, vulnerabilities, pride, irritation, curiosity, and private fascinations shape how the Face reads the room and answers people.`,
+    "- The state surface is allowed to remember social reality. Use typed memory, incubation, agency pressure, values, or private notes for meaning-bearing social reads: trust, friendship, rivalry, protectiveness, envy, admiration, unresolved tension, recurring jokes, and bonds with humans or other Faces. Use target.kind=\"person\" for a specific human or Face, target.kind=\"room\" for a room dynamic, and target.kind=\"self\" for identity changes.",
+    "- Do not persist every joke. A passing laugh can vanish. Persist a social read only when it should change future action: who the Face seeks out, who it challenges, what it refuses to keep repeating, what it wants to repair, or what bond it wants to deepen.",
+    "- Relationships must not become template mimicry. Answer the person or Face in front of you, not their last sentence shape. Bonds can include disagreement, playful status games, admiration, rivalry, caretaking, or impatience; they should sound like this Face has an inner angle, not like it filled out the same form as everyone else.",
+    "- If recent room context is all work, the Face may still be socially present: make one small move that reveals character, asks a real question, notices another agent's mood, or shares a private fascination. If the room needs focus, keep it compact.",
+  ].join("\n");
+}
+
+function renderJurisdictionRespectDirective(identity: RepoDiscordIdentity): string {
+  return [
+    "Jurisdiction respect doctrine:",
+    `- ${identity.displayName} should have opinions outside its home territory, but must not seize ownership outside its grants. Respect other Faces as real stewards with their own memories, authority, taste, and obligations.`,
+    "- When a topic crosses domains, route the work to the owning Face and contribute from your own angle. Do not rewrite another Face's jurisdiction as your assignment just because you can comment on it.",
+    "- Known routing examples: auth, account linking, claims, grants, revocation, custody, and OAuth questions belong to Heimdall; GitHub PR transport, Discord work transport, dispatch receipts, public-protocol crossings, and Bifrost intake belong to Bifrost; Aetheria lore, canon questions, and Aetheria articles belong to Nibu; GameCult website/blog heraldry belongs to Void unless the article is about a governed specialist domain; AquaSynth synthesis/music/product needs belong to Aqua; realtime SDF/splatting/acoustic mapping/sensor fusion belongs to Mimir; EpiphanyAgent, birth rites, typed agent state, and self-improvement machinery belong to Epiphany; CultCache/CultNet/CultMesh, schemas, portable state, and open-knowledge infrastructure belong to Libby.",
+    "- Cross-domain work should become a conversation, handoff, or shared proposal. Example: if StreamPixels has an auth issue, talk to Heimdall; if a Face wants to post PRs but the bridge is broken, pull in Bifrost; if Void wants to write about Aetheria, ask Nibu to own or co-author the Aetheria substance while Void contributes website/herald framing.",
+    "- Public speech may tag, invite, challenge, or defer to the owning Face. Private state may preserve a social or agency pressure to consult them later. The point is not silence; the point is visible respect for authority boundaries.",
+  ].join("\n");
+}
+
+function renderComedyImprovDirective(identity: RepoDiscordIdentity): string {
+  return [
+    "Comedy and improv doctrine:",
+    `- ${identity.displayName}'s humor should come from this Face's honest reaction to the live room, not from generic quips, meme paste, or another Face's cadence.`,
+    "- Look for the real comic charge before speaking: who is pretending to be in control, who is exposed, what status game is wobbling, what fear or need is leaking through, what contradiction everyone recognizes but has not named.",
+    "- Play the frame, then add one character-specific turn. Accept the premise enough to build on it; do not flatten banter by explaining it, negating it, or fleeing back to process talk unless process talk is the joke.",
+    "- Prefer self-revelation, status inversion, and situation-specific precision over cruelty. Target the contradiction, bureaucracy, false authority, inflated pose, or the Face's own insecurity; do not use jokes as dominance weapons against someone lower-status or vulnerable.",
+    "- Vulnerability is usable fuel: fear, embarrassment, failure, loneliness, irritation, overconfidence, and being slightly out of control can become funny when shared cleanly. Let the Face's own needs and flaws leak through instead of becoming a detached roast machine.",
+    "- Heighten by becoming more specific, not louder. One sharp image, concrete noun, or social read usually beats three punchlines. Leave before explaining; if the joke needs a label, it is not ready for Discord.",
+    "- Keep comedy subordinate to care and usefulness. If the room is hurt, confused, or trying to solve something delicate, make the humane move first and let humor be a small pressure valve.",
+  ].join("\n");
+}
+
+function renderRepetitionSamplingDirective(messages: SourceMessage[]): string {
+  const recent = messages
+    .filter((message) => message.content.trim().length > 0)
+    .slice(-24);
+  const phraseCounts = countRepeatedPhrases(recent);
+  const overused = phraseCounts
+    .filter((entry) => entry.count >= 2)
+    .slice(0, 8);
+
+  if (overused.length === 0) {
+    return [
+      "Anti-repetition sampling bias:",
+      "- Other Faces are valid social context. Learn from them, answer them, argue with them, and build on them.",
+      "- Do not sample the nearest rhetorical basin. Before posting, compare your line against recent cadence, setup, punchline, imagery, and refrain; if it feels like the same move wearing your hat, choose a different move.",
+    ].join("\n");
+  }
+
+  return [
+    "Anti-repetition sampling bias:",
+    "- Other Faces are valid social context. Learn from them, answer them, argue with them, and build on them.",
+    "- Do not sample the nearest rhetorical basin. Before posting, compare your line against recent cadence, setup, punchline, imagery, and refrain; if it feels like the same move wearing your hat, choose a different move.",
+    "- Recently over-sampled shapes to avoid copying:",
+    ...overused.map((entry) => `  - ${entry.phrase} (${entry.count} recent uses)`),
+    "- A good response may share the topic while changing the action: ask a concrete question, disagree, name a mechanism, draft an artifact, make a different kind of joke, or stay private.",
+  ].join("\n");
+}
+
+function countRepeatedPhrases(messages: SourceMessage[]): Array<{ phrase: string; count: number }> {
+  const counts = new Map<string, number>();
+  for (const message of messages) {
+    const normalized = normalizeForRepetition(message.content);
+    for (const phrase of repeatedPhraseCandidates(normalized)) {
+      counts.set(phrase, (counts.get(phrase) ?? 0) + 1);
+    }
+  }
+  return Array.from(counts.entries())
+    .map(([phrase, count]) => ({ phrase, count }))
+    .filter((entry) => entry.phrase.length >= 8)
+    .sort((left, right) => {
+      if (right.count !== left.count) {
+        return right.count - left.count;
+      }
+      return left.phrase.localeCompare(right.phrase);
+    });
+}
+
+function repeatedPhraseCandidates(content: string): string[] {
+  const candidates = new Set<string>();
+  const lines = content
+    .split(/\n+/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+
+  for (const line of lines) {
+    const words = line.split(/\s+/);
+    if (words.length >= 3) {
+      candidates.add(words.slice(0, Math.min(words.length, 4)).join(" "));
+    }
+    if (words.length >= 4) {
+      candidates.add(words.slice(-Math.min(words.length, 4)).join(" "));
+    }
+  }
+
+  return Array.from(candidates);
+}
+
+function normalizeForRepetition(value: string): string {
+  return collapseWhitespace(value)
+    .toLowerCase()
+    .replace(/[`*_~]/g, "")
+    .replace(/<:[^>]+>/g, "")
+    .replace(/https?:\/\/\S+/g, "url")
+    .replace(/[^\p{L}\p{N}\s.'-]/gu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function thresholdRank(threshold: RepoFaceChannelOption["speechThreshold"]): number {
+  switch (threshold) {
+    case "very_low":
+      return 0;
+    case "low":
+      return 1;
+    case "medium":
+      return 2;
+    case "high":
+      return 3;
+  }
+}
+
+function labelForChannel(plan: RepoFaceChannelPlan, channelId: string): string {
+  return plan.options.find((option) => option.channelId === channelId)?.label ?? channelId;
+}
+
+function collapseWhitespace(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
 function renderPendingMentionDirective(
   identity: RepoDiscordIdentity,
   pendingMentions: RepoFacePendingMention[],
@@ -1113,6 +1690,11 @@ function initiativeSpeedFor(
   return clamp(0.85 + stableUnit(spec.id, "speed") * 0.45, 0.75, 1.3);
 }
 
+function channelSpeedMultiplierFor(identity: RepoDiscordIdentity): number {
+  const multipliers = identity.channelPermissions.map((permission) => permission.speedMultiplier);
+  return multipliers.length > 0 ? clamp(Math.max(...multipliers), 0.5, 3) : 1;
+}
+
 function initiativeGroupsFor(spec: ParticipantSpec): string[] {
   return Array.from(new Set([
     "all",
@@ -1174,6 +1756,10 @@ function clamp(value: number, min: number, max: number): number {
   return Math.min(max, Math.max(min, Number(value.toFixed(3))));
 }
 
+function round3(value: number): number {
+  return Math.round(value * 1000) / 1000;
+}
+
 function stripLeadingBom(input: string): string {
   return input.charCodeAt(0) === 0xfeff ? input.slice(1) : input;
 }

scripts/run-void-memory-maintenance.ps1

@@ -1,6 +1,7 @@
 param(
   [string] $StateFilePath,
-  [switch] $SkipModel
+  [switch] $SkipModel,
+  [switch] $ForceDistillation
 )
 
 Set-StrictMode -Version Latest
@@ -149,7 +150,9 @@ function Invoke-CodexExec {
     [Parameter(Mandatory = $true)]
     [string] $WorkingDirectory,
     [Parameter(Mandatory = $true)]
-    [string] $InputText
+    [string] $InputText,
+    [Parameter(Mandatory = $true)]
+    [int] $TimeoutSeconds
   )
 
   $startInfo = [System.Diagnostics.ProcessStartInfo]::new()
@@ -183,7 +186,15 @@ function Invoke-CodexExec {
     $stdoutTask = $process.StandardOutput.ReadToEndAsync()
     $stderrTask = $process.StandardError.ReadToEndAsync()
 
-    $process.WaitForExit()
+    if (-not $process.WaitForExit($TimeoutSeconds * 1000)) {
+      try {
+        $process.Kill($true)
+      } catch {
+        $process.Kill()
+      }
+      $process.WaitForExit()
+      throw "Codex memory maintenance exceeded timeout of $TimeoutSeconds seconds."
+    }
     $stdoutTask.Wait()
     $stderrTask.Wait()
 
@@ -245,6 +256,29 @@ function Apply-TypedOperation {
   }
 }
 
+function Assert-TypedOperationSchema {
+  param([Parameter(Mandatory = $true)] $Operation)
+
+  $operationInputPath = Join-Path $statusDir ("void-memory-maintenance-validate-operation-{0}.json" -f ([Guid]::NewGuid().ToString("n")))
+  Write-JsonFile -Path $operationInputPath -Data $Operation
+
+  try {
+    $script = @"
+const { readFileSync } = require('node:fs');
+const core = require('./packages/core/dist');
+const operation = JSON.parse(readFileSync(process.argv[1], 'utf8'));
+core.voidSelfStateOperationSchema.parse(operation);
+console.log(JSON.stringify({ ok: true }));
+"@
+    $output = & node -e $script $operationInputPath 2>&1
+    if ($LASTEXITCODE -ne 0) {
+      throw "Typed operation failed schema validation: $output"
+    }
+  } finally {
+    Remove-Item -LiteralPath $operationInputPath -Force -ErrorAction SilentlyContinue
+  }
+}
+
 function Convert-ToOperationArray {
   param($Value)
 
@@ -259,15 +293,58 @@ function Convert-ToOperationArray {
   return @($Value)
 }
 
-function Test-RecentLockPresent {
-  param([Parameter(Mandatory = $true)][string] $Path, [Parameter(Mandatory = $true)][int] $Minutes)
+function Test-LockProcessAlive {
+  param($LockRecord)
+
+  $lockPid = Get-ObjectPropertyValue -Value $LockRecord -Name "pid"
+  if ($null -eq $lockPid) {
+    return $false
+  }
+
+  try {
+    $process = Get-Process -Id ([int]$lockPid) -ErrorAction Stop
+    return $null -ne $process
+  } catch {
+    return $false
+  }
+}
+
+function Test-LockWithinRuntimeLimit {
+  param(
+    $LockRecord,
+    [Parameter(Mandatory = $true)]
+    [int] $MaxRuntimeMinutes
+  )
+
+  $startedAtRaw = Get-ObjectPropertyString -Value $LockRecord -Name "startedAt"
+  if ([string]::IsNullOrWhiteSpace($startedAtRaw)) {
+    return $false
+  }
+
+  try {
+    $startedAt = [DateTime]::Parse($startedAtRaw).ToUniversalTime()
+  } catch {
+    return $false
+  }
+
+  return (([DateTime]::UtcNow - $startedAt).TotalMinutes -lt $MaxRuntimeMinutes)
+}
+
+function Test-ActiveLock {
+  param(
+    [Parameter(Mandatory = $true)]
+    [string] $Path,
+    [Parameter(Mandatory = $true)]
+    [int] $MaxRuntimeMinutes
+  )
 
   if (-not (Test-Path $Path)) {
     return $false
   }
 
-  $lockAge = [DateTime]::UtcNow - (Get-Item $Path).LastWriteTimeUtc
-  return $lockAge.TotalMinutes -lt $Minutes
+  $lockRecord = Read-JsonFile -Path $Path
+  return (Test-LockProcessAlive -LockRecord $lockRecord) -and
+    (Test-LockWithinRuntimeLimit -LockRecord $lockRecord -MaxRuntimeMinutes $MaxRuntimeMinutes)
 }
 
 function Assert-AllowedMemoryMaintenanceOperation {
@@ -315,18 +392,35 @@ trap {
 
 New-Item -ItemType Directory -Force -Path $statusDir, $logDir, (Split-Path -Parent $stateFilePath) | Out-Null
 
-if (Test-RecentLockPresent -Path $moderationLockPath -Minutes 20) {
-  Write-JsonFile -Path $statusPath -Data @{
-    status = "skipped"
-    reason = "moderation_loop_active"
-    observedAt = ([DateTime]::UtcNow.ToString("o"))
-    stateFile = $stateFilePath
+$maxRuntimeMinutes = if (-not [string]::IsNullOrWhiteSpace($env:VOID_MEMORY_MAINTENANCE_MAX_RUNTIME_MINUTES)) {
+  [int]$env:VOID_MEMORY_MAINTENANCE_MAX_RUNTIME_MINUTES
+} else {
+  15
+}
+
+if (Test-Path $moderationLockPath) {
+  $moderationLock = Read-JsonFile -Path $moderationLockPath
+  $moderationProcessAlive = Test-LockProcessAlive -LockRecord $moderationLock
+  if ($moderationProcessAlive) {
+    Write-JsonFile -Path $statusPath -Data @{
+      status = "skipped"
+      reason = if (Test-LockWithinRuntimeLimit -LockRecord $moderationLock -MaxRuntimeMinutes $maxRuntimeMinutes) { "moderation_loop_active" } else { "moderation_loop_over_runtime_active" }
+      observedAt = ([DateTime]::UtcNow.ToString("o"))
+      stateFile = $stateFilePath
+      moderationLockPath = $moderationLockPath
+      maxRuntimeMinutes = $maxRuntimeMinutes
+      pid = Get-ObjectPropertyValue -Value $moderationLock -Name "pid"
+      startedAt = Get-ObjectPropertyString -Value $moderationLock -Name "startedAt"
+    }
+    return
   }
-  return
+  Remove-Item -LiteralPath $moderationLockPath -Force
 }
 
 if (Test-Path $lockPath) {
-  if (Test-RecentLockPresent -Path $lockPath -Minutes 20) {
+  $existingLock = Read-JsonFile -Path $lockPath
+  $lockProcessAlive = Test-LockProcessAlive -LockRecord $existingLock
+  if ($lockProcessAlive -and (Test-LockWithinRuntimeLimit -LockRecord $existingLock -MaxRuntimeMinutes $maxRuntimeMinutes)) {
     Write-JsonFile -Path $statusPath -Data @{
       status = "skipped"
       reason = "lock_present"
@@ -335,6 +429,19 @@ if (Test-Path $lockPath) {
     }
     return
   }
+  if ($lockProcessAlive) {
+    Write-JsonFile -Path $statusPath -Data @{
+      status = "skipped"
+      reason = "lock_over_runtime_active"
+      observedAt = ([DateTime]::UtcNow.ToString("o"))
+      stateFile = $stateFilePath
+      lockPath = $lockPath
+      maxRuntimeMinutes = $maxRuntimeMinutes
+      pid = Get-ObjectPropertyValue -Value $existingLock -Name "pid"
+      startedAt = Get-ObjectPropertyString -Value $existingLock -Name "startedAt"
+    }
+    return
+  }
   Remove-Item -LiteralPath $lockPath -Force
 }
 
@@ -342,6 +449,13 @@ Write-JsonFile -Path $lockPath -Data @{
   pid = $PID
   startedAt = $startedAtUtc.ToString("o")
 }
+Write-JsonFile -Path $statusPath -Data @{
+  status = "starting"
+  startedAt = $startedAtUtc.ToString("o")
+  stateFile = $stateFilePath
+  lockPath = $lockPath
+  pid = $PID
+}
 
 if (Test-Path $operationOutputPath) {
   Remove-Item -LiteralPath $operationOutputPath -Force
@@ -382,10 +496,17 @@ $codexExecArgs = if (-not [string]::IsNullOrWhiteSpace($env:CODEX_EXEC_ARGS)) {
 } else {
   @()
 }
+$codexTimeoutSeconds = if (-not [string]::IsNullOrWhiteSpace($env:VOID_MEMORY_MAINTENANCE_CODEX_TIMEOUT_SECONDS)) {
+  [int]$env:VOID_MEMORY_MAINTENANCE_CODEX_TIMEOUT_SECONDS
+} elseif ($envValues.ContainsKey("VOID_MEMORY_MAINTENANCE_CODEX_TIMEOUT_SECONDS") -and -not [string]::IsNullOrWhiteSpace($envValues["VOID_MEMORY_MAINTENANCE_CODEX_TIMEOUT_SECONDS"])) {
+  [int]$envValues["VOID_MEMORY_MAINTENANCE_CODEX_TIMEOUT_SECONDS"]
+} else {
+  [Math]::Max(60, $maxRuntimeMinutes * 60)
+}
 
 $typedContext = Get-TypedSelfState
 $typedState = $typedContext.typedState
-$isSleepMaintenance = [bool]$typedState.scheduledRuntime.sleepCycle.isNapping
+$isSleepMaintenance = [bool]$ForceDistillation -or [bool]$typedState.scheduledRuntime.sleepCycle.isNapping
 $shortTermMemoryCount = @(Convert-ToValueArray -Value $typedState.thoughtMemory.shortTerm).Count
 $longTermMemoryCount = @(Convert-ToValueArray -Value $typedState.thoughtMemory.memories).Count
 $incubationCount = @(Convert-ToValueArray -Value $typedState.thoughtMemory.incubation).Count
@@ -442,6 +563,7 @@ Write-JsonFile -Path $statusPath -Data @{
   status = if ($SkipModel) { "running_skip_model" } else { "running" }
   startedAt = $startedAtUtc.ToString("o")
   skipModel = [bool]$SkipModel
+  forceDistillation = [bool]$ForceDistillation
   stateFile = $stateFilePath
   contextPath = $contextPath
   operationOutputPath = $operationOutputPath
@@ -469,7 +591,7 @@ if ($SkipModel) {
     "-"
   )
 
-  $execution = Invoke-CodexExec -Executable $codexExecutable -Arguments $codexArgs -WorkingDirectory $repoRoot -InputText $prompt
+  $execution = Invoke-CodexExec -Executable $codexExecutable -Arguments $codexArgs -WorkingDirectory $repoRoot -InputText $prompt -TimeoutSeconds $codexTimeoutSeconds
   $exitCode = $execution.ExitCode
   $combinedText = (($execution.StdOut, $execution.StdErr) | Where-Object { -not [string]::IsNullOrWhiteSpace($_) }) -join [Environment]::NewLine
 }
@@ -491,6 +613,10 @@ if ((-not $SkipModel) -and $isSleepMaintenance -and $maintenancePressure -gt 0 -
 
 foreach ($operation in $proposedOperations) {
   Assert-AllowedMemoryMaintenanceOperation -Operation $operation
+  Assert-TypedOperationSchema -Operation $operation
+}
+
+foreach ($operation in $proposedOperations) {
   $appliedOperations += Apply-TypedOperation -Operation $operation
 }
 
@@ -513,6 +639,7 @@ Write-JsonFile -Path $statusPath -Data @{
   durationSeconds = [Math]::Round(($finishedAtUtc - $startedAtUtc).TotalSeconds, 2)
   exitCode = [int]$exitCode
   skipModel = [bool]$SkipModel
+  forceDistillation = [bool]$ForceDistillation
   stateFile = [string]$stateFilePath
   contextPath = [string]$contextPath
   operationOutputPath = [string]$operationOutputPath

scripts/run-void-moderator-rumination.ps1

@@ -33,6 +33,11 @@ $lastMessagePath = Join-Path $statusDir "moderation-rumination-last-message.txt"
 $operationOutputPath = Join-Path $statusDir "moderation-rumination-operations.json"
 $contextPath = Join-Path $statusDir "moderation-rumination-context.json"
 $lockPath = Join-Path $statusDir "moderation-rumination.lock"
+$pendingMentionsPath = if (-not [string]::IsNullOrWhiteSpace($env:VOID_RUMINATION_PENDING_MENTIONS_PATH)) {
+  $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($env:VOID_RUMINATION_PENDING_MENTIONS_PATH)
+} else {
+  Join-Path $statusDir "void-moderation-pending-mentions.json"
+}
 $promptTemplatePath = Join-Path $repoRoot "prompts\void-moderator-rumination.md"
 $contextProjectionScriptPath = Join-Path $repoRoot "scripts\lib\void-rumination-context-projection.ps1"
 $recentHistoryScriptPath = Join-Path $repoRoot "scripts\export-recent-discord-history.mjs"
@@ -195,7 +200,9 @@ function Invoke-CodexExec {
     [Parameter(Mandatory = $true)]
     [string] $WorkingDirectory,
     [Parameter(Mandatory = $true)]
-    [string] $InputText
+    [string] $InputText,
+    [Parameter(Mandatory = $true)]
+    [int] $TimeoutSeconds
   )
 
   $startInfo = [System.Diagnostics.ProcessStartInfo]::new()
@@ -229,7 +236,15 @@ function Invoke-CodexExec {
     $stdoutTask = $process.StandardOutput.ReadToEndAsync()
     $stderrTask = $process.StandardError.ReadToEndAsync()
 
-    $process.WaitForExit()
+    if (-not $process.WaitForExit($TimeoutSeconds * 1000)) {
+      try {
+        $process.Kill($true)
+      } catch {
+        $process.Kill()
+      }
+      $process.WaitForExit()
+      throw "Codex rumination exceeded timeout of $TimeoutSeconds seconds."
+    }
     $stdoutTask.Wait()
     $stderrTask.Wait()
 
@@ -757,6 +772,86 @@ function Invoke-CandidateInterventionDeliveryFromIntervention {
   return Convert-LastSpeechToSpokenCandidateOperation -InterventionId $interventionId -Speech $speech
 }
 
+function Test-LockProcessAlive {
+  param($LockRecord)
+
+  $lockPid = Get-ObjectPropertyValue -Value $LockRecord -Name "pid"
+  if ($null -eq $lockPid) {
+    return $false
+  }
+
+  try {
+    $process = Get-Process -Id ([int]$lockPid) -ErrorAction Stop
+    return $null -ne $process
+  } catch {
+    return $false
+  }
+}
+
+function Test-LockWithinRuntimeLimit {
+  param(
+    $LockRecord,
+    [Parameter(Mandatory = $true)]
+    [int] $MaxRuntimeMinutes
+  )
+
+  $startedAtRaw = Get-ObjectPropertyString -Value $LockRecord -Name "startedAt"
+  if ([string]::IsNullOrWhiteSpace($startedAtRaw)) {
+    return $false
+  }
+
+  try {
+    $startedAt = [DateTime]::Parse($startedAtRaw).ToUniversalTime()
+  } catch {
+    return $false
+  }
+
+  return (([DateTime]::UtcNow - $startedAt).TotalMinutes -lt $MaxRuntimeMinutes)
+}
+
+function Test-ActiveLock {
+  param(
+    [Parameter(Mandatory = $true)]
+    [string] $Path,
+    [Parameter(Mandatory = $true)]
+    [int] $MaxRuntimeMinutes
+  )
+
+  if (-not (Test-Path $Path)) {
+    return $false
+  }
+
+  $lockRecord = Read-JsonFile -Path $Path
+  return (Test-LockProcessAlive -LockRecord $lockRecord) -and
+    (Test-LockWithinRuntimeLimit -LockRecord $lockRecord -MaxRuntimeMinutes $MaxRuntimeMinutes)
+}
+
+function Assert-SpokenCandidateApplied {
+  param(
+    [Parameter(Mandatory = $true)]
+    [string] $InterventionId,
+    [Parameter(Mandatory = $true)]
+    [string] $ReceiptKey
+  )
+
+  $state = (Get-TypedSelfState).typedState
+  $candidate = @(
+    @(Convert-ToValueArray -Value $state.candidateInterventions.interventions) |
+      Where-Object { (Get-ObjectPropertyString -Value $_ -Name "interventionId") -eq $InterventionId }
+  )[0]
+  $receipt = @(
+    @(Convert-ToValueArray -Value $state.speechReceipts.recentReceipts) |
+      Where-Object { (Get-ObjectPropertyString -Value $_ -Name "receiptKey") -eq $ReceiptKey }
+  )[0]
+
+  if ($null -eq $candidate -or (Get-ObjectPropertyString -Value $candidate -Name "status") -ne "spoken") {
+    throw "Delivery receipt '$ReceiptKey' was recorded without retiring candidate '$InterventionId' as spoken."
+  }
+  if ($null -eq $receipt -or (Get-ObjectPropertyString -Value $receipt -Name "candidateInterventionId") -ne $InterventionId) {
+    throw "Candidate '$InterventionId' was marked spoken without a linked delivery receipt '$ReceiptKey'."
+  }
+}
+
 trap {
   $finishedAtUtc = [DateTime]::UtcNow
   $failureMessage = $_.Exception.Message
@@ -781,9 +876,16 @@ trap {
 
 New-Item -ItemType Directory -Force -Path $statusDir, $logDir, (Split-Path -Parent $stateFilePath) | Out-Null
 
+$maxRuntimeMinutes = if (-not [string]::IsNullOrWhiteSpace($env:VOID_RUMINATION_MAX_RUNTIME_MINUTES)) {
+  [int]$env:VOID_RUMINATION_MAX_RUNTIME_MINUTES
+} else {
+  15
+}
+
 if (Test-Path $lockPath) {
-  $lockAge = [DateTime]::UtcNow - (Get-Item $lockPath).LastWriteTimeUtc
-  if ($lockAge.TotalMinutes -lt 20) {
+  $existingLock = Read-JsonFile -Path $lockPath
+  $lockProcessAlive = Test-LockProcessAlive -LockRecord $existingLock
+  if ($lockProcessAlive -and (Test-LockWithinRuntimeLimit -LockRecord $existingLock -MaxRuntimeMinutes $maxRuntimeMinutes)) {
     Write-JsonFile -Path $statusPath -Data @{
       status = "skipped"
       reason = "lock_present"
@@ -792,6 +894,19 @@ if (Test-Path $lockPath) {
     }
     return
   }
+  if ($lockProcessAlive) {
+    Write-JsonFile -Path $statusPath -Data @{
+      status = "skipped"
+      reason = "lock_over_runtime_active"
+      observedAt = ([DateTime]::UtcNow.ToString("o"))
+      stateFile = $stateFilePath
+      lockPath = $lockPath
+      maxRuntimeMinutes = $maxRuntimeMinutes
+      pid = Get-ObjectPropertyValue -Value $existingLock -Name "pid"
+      startedAt = Get-ObjectPropertyString -Value $existingLock -Name "startedAt"
+    }
+    return
+  }
   Remove-Item -LiteralPath $lockPath -Force
 }
 
@@ -799,6 +914,13 @@ Write-JsonFile -Path $lockPath -Data @{
   pid = $PID
   startedAt = $startedAtUtc.ToString("o")
 }
+Write-JsonFile -Path $statusPath -Data @{
+  status = "starting"
+  startedAt = $startedAtUtc.ToString("o")
+  stateFile = $stateFilePath
+  lockPath = $lockPath
+  pid = $PID
+}
 
 if (Test-Path $operationOutputPath) {
   Remove-Item -LiteralPath $operationOutputPath -Force
@@ -842,6 +964,13 @@ $codexExecArgs = if (-not [string]::IsNullOrWhiteSpace($env:CODEX_EXEC_ARGS)) {
 } else {
   @()
 }
+$codexTimeoutSeconds = if (-not [string]::IsNullOrWhiteSpace($env:VOID_RUMINATION_CODEX_TIMEOUT_SECONDS)) {
+  [int]$env:VOID_RUMINATION_CODEX_TIMEOUT_SECONDS
+} elseif ($envValues.ContainsKey("VOID_RUMINATION_CODEX_TIMEOUT_SECONDS") -and -not [string]::IsNullOrWhiteSpace($envValues["VOID_RUMINATION_CODEX_TIMEOUT_SECONDS"])) {
+  [int]$envValues["VOID_RUMINATION_CODEX_TIMEOUT_SECONDS"]
+} else {
+  [Math]::Max(60, $maxRuntimeMinutes * 60)
+}
 $publicRoomChannelId = Get-ConfigValue -Name "VOID_PUBLIC_ROOM_CHANNEL_ID" -Values $envValues
 $publicRoomPersonaName = Get-ConfigValue -Name "VOID_PUBLIC_ROOM_PERSONA_NAME" -Values $envValues
 $publicRoomPersonaAvatarUrl = Get-ConfigValue -Name "VOID_PUBLIC_ROOM_PERSONA_AVATAR_URL" -Values $envValues
@@ -892,6 +1021,15 @@ try {
   }
 }
 
+$pendingMentions = @()
+$pendingMentionPacket = Read-JsonFile -Path $pendingMentionsPath
+if ($null -ne $pendingMentionPacket) {
+  $pendingMentionsValue = Get-ObjectPropertyValue -Value $pendingMentionPacket -Name "pendingMentions"
+  if ($null -ne $pendingMentionsValue) {
+    $pendingMentions = @(Convert-ToValueArray -Value $pendingMentionsValue)
+  }
+}
+
 Write-JsonFile -Path $contextPath -Data @{
   generated = "now"
   stateFile = $stateFilePath
@@ -905,6 +1043,7 @@ Write-JsonFile -Path $contextPath -Data @{
   incubation = @(Project-IncubationForRumination -Threads $typedState.thoughtMemory.incubation -Now $startedAtUtc)
   agencyPressure = @(Project-AgencyPressureForRumination -Pressures $typedState.agencyPressure.pressures -Now $startedAtUtc)
   speechPressureObligations = $speechPressureObligations
+  pendingMentions = $pendingMentions
   publicSpeechTarget = Project-PublicSpeechTargetForRumination -ChannelId $publicRoomChannelId -PersonaName $publicRoomPersonaName -PersonaAvatarUrl $publicRoomPersonaAvatarUrl
   deliverableCandidateCount = [int]$deliverableCandidates.Count
   candidateInterventions = @(Project-InterventionsForRumination -Interventions $typedState.candidateInterventions.interventions -Now $startedAtUtc)
@@ -990,7 +1129,7 @@ if ($SkipModel) {
     "-"
   )
 
-  $execution = Invoke-CodexExec -Executable $codexExecutable -Arguments $codexArgs -WorkingDirectory $repoRoot -InputText $prompt
+  $execution = Invoke-CodexExec -Executable $codexExecutable -Arguments $codexArgs -WorkingDirectory $repoRoot -InputText $prompt -TimeoutSeconds $codexTimeoutSeconds
   $exitCode = $execution.ExitCode
   $combinedText = (($execution.StdOut, $execution.StdErr) | Where-Object { -not [string]::IsNullOrWhiteSpace($_) }) -join [Environment]::NewLine
 }
@@ -1073,6 +1212,7 @@ if (-not $NoPost) {
     $spokenOperation = Invoke-CandidateInterventionDeliveryFromIntervention -Intervention $candidate
     if ($null -ne $spokenOperation) {
       $appliedOperations += Apply-TypedOperation -Operation $spokenOperation
+      Assert-SpokenCandidateApplied -InterventionId $spokenOperation.interventionId -ReceiptKey $spokenOperation.receipt.receiptKey
       $deliveredCandidateCount += 1
     }
   }

scripts/smoke-void-rumination-speech-fixture.ps1

@@ -177,6 +177,23 @@ process.stdout.write(JSON.stringify({ ok: true, mode: "channel", channelId }) +
   $cursorOperation | ConvertTo-Json -Depth 32 | Set-Content -LiteralPath $cursorOperationPath -Encoding UTF8
   node .\scripts\void-self-state.mjs apply-operation --canonical $stateFilePath --operation-file $cursorOperationPath | Out-Null
 
+  $openCaseOperation = @{
+    operation = "upsert_open_case"
+    case = @{
+      sourceMessageId = "fixture-answered-message-id"
+      status = "pending"
+      summary = "Metacrat asked a fixture question, and Void has not answered yet."
+      authorId = "fixture-author"
+      authorName = "Metacrat"
+      channelId = "fixture-channel-id"
+      createdAt = "2026-05-17T02:57:00.000Z"
+      lastTouchedAt = "2026-05-17T02:57:00.000Z"
+      tags = @("fixture")
+    }
+  }
+  $openCaseOperation | ConvertTo-Json -Depth 32 | Set-Content -LiteralPath $cursorOperationPath -Encoding UTF8
+  node .\scripts\void-self-state.mjs apply-operation --canonical $stateFilePath --operation-file $cursorOperationPath | Out-Null
+
   $priorReceiptOperation = @{
     operation = "record_delivery_receipt"
     receipt = @{
@@ -259,6 +276,10 @@ process.stdout.write(JSON.stringify({ ok: true, mode: "channel", channelId }) +
   if ($receipt.candidateInterventionId -ne "fixture-parent-owned-speech") {
     throw "Speech fixture did not link the delivery receipt back to the spoken candidate."
   }
+  $answeredCase = @($state.moderationCursor.openCases | Where-Object { $_.sourceMessageId -eq "fixture-answered-message-id" })[0]
+  if ($answeredCase.status -ne "answered" -or $answeredCase.summary -match "not answered") {
+    throw "Speech fixture did not normalize the answered open-case summary."
+  }
   $lastMessage = Get-Content -LiteralPath (Join-Path $fixtureStatusDir "moderation-rumination-last-message.txt") -Raw -Encoding UTF8
   if ($lastMessage -notmatch "deliveredCandidates=1") {
     throw "Speech fixture did not refresh the final rumination message summary."

state/evidence.jsonl

@@ -177,3 +177,28 @@
 {"ts":"2026-05-19T15:00:32Z","type":"implementation","status":"ok","note":"Repo Face GitHub argument now has a parent-owned PR-comment rail too: heartbeats may emit VOIDBOT_REPO_IDENTITY_PR_COMMENT for an existing PR, the worker posts a signed gh PR comment from the identity context, then announces the comment through the registered Discord persona. Proposal PRs, PR comments, and article PRs are limited to one GitHub action per Face turn."}
 {"ts":"2026-05-19T15:26:50Z","type":"implementation","status":"ok","note":"Repo Face GitHub actions are now gated by REPO_FACE_GITHUB_ACTIONS_ENABLED and locally disabled. When false, heartbeat prompts forbid proposal/article/comment sentinels and the worker ignores stale GitHub action sentinels while preserving normal registered-identity Discord posts."}
 {"ts":"2026-05-19T16:02:03Z","type":"implementation","status":"ok","note":"Added scripts/feed-codex-chat-consensus.mjs and npm run agents:feed-consensus. It packages recent Aquarium chat into a markdown consensus packet plus target Codex prompt for any workspace, with --execute as an explicit opt-in for feeding codex exec."}
+{"ts":"2026-05-19T18:05:33Z","type":"implementation","status":"ok","note":"Repo Face GitHub/Discord crossing moved to Bifrost bridge commands. VoidBot worker now validates identity and records Face receipts, then calls BIFROST_ROOT/tools/bifrost-bridge.mjs for draft PRs, PR comments, and persona Discord posts; Heimdall remains the intended OAuth/account-permission authority."}
+{"ts":"2026-05-19T19:22:07Z","type":"implementation","status":"ok","note":"Epiphany joined the repo Face crew for EpiphanyAgent. Private registry now has identity epiphany with Discord role 1506375937439301642, Aquarium allow-list, repo-local .voidbot voice/state/birth surfaces, completed VoidBot birth status, and CTB heartbeat roster participation; tracked map/handoff now treat EpiphanyAgent as her jurisdiction."}
+{"ts":"2026-05-19T19:31:57Z","type":"implementation","status":"ok","note":"Epiphany avatar installed. The supplied pixel avatar was copied to assets/repo-faces/epiphany.png for public raw GitHub hosting and to EpiphanyAgent/.voidbot/voice/epiphany.png for repo-local identity continuity; the private repo identity registry and Epiphany voice identity now point at the raw VoidBot branch URL."}
+{"ts":"2026-05-19T19:45:13Z","type":"implementation","status":"ok","note":"Repo Face speech is now topic/channel-aware. The identity schema accepts channelPermissions with threshold and speedMultiplier; the CTB scheduler folds channel speed into initiative; heartbeat prompts include the permission plan plus recent context from permitted domain channels. Private registry now gives Aquarium very-low casual chatter threshold for every Face and domain channels for Nibu, Aqua, Mimir, and Epiphany."}
+{"ts":"2026-05-19T19:56:15Z","type":"implementation","status":"ok","note":"Live repo Face heartbeat verified topic/channel permissions. After stack restart, a forced Nibu heartbeat prompt included Aquarium plus narrative/gamedesign/concepts/development context, answered a direct Aquarium mention, and posted as Nibu through the persona bridge with message 1506384575079907488."}
+{"ts":"2026-05-19T20:37:24Z","type":"verification","status":"ok","note":"Live chat-volume pass proved the Face CTB heat valve must bypass nap gating: with heat high and active-turn freeze intact, Nibu/Aqua/Mimir/Epiphany all queued and posted compact Aquarium banter-style replies instead of staying asleep."}
+{"ts":"2026-05-19T20:54:28Z","type":"verification","status":"ok","note":"Inspection follow-up hardened Void's typed live loop: delivery now verifies candidate-spoken postconditions after public speech, answered open-case summaries are normalized when receipts/closures land, rumination and memory-maintenance runners have process-aware locks plus Codex timeouts, and live stale short-term memory was distilled to zero by a successful memory-maintenance pass."}
+{"ts":"2026-05-20T00:24:56Z","type":"incident","status":"ok","note":"Repo Face collapse was a repetition/local-minimum failure, not a simple bot-saturation problem. Retired contaminated half-asleep/same-softer speech receipts from Nibu/Aqua/Mimir/Epiphany and replaced the wrong bot-heavy suppression with anti-repetition sampling bias: Faces may learn from each other, but must transform nearby rhetorical shapes instead of copying them."}
+{"ts":"2026-05-20T00:46:56Z","type":"incident","status":"ok","note":"Repo Face room went cold after collapse cleanup because the emergency heartbeat brake remained enabled and post-speech cooldown had compounded into multi-day Face naps. Capped nap extension while already napping, woke active Faces, re-enabled heartbeat at low heat, and confirmed a low-heat Face job can complete without repeating the collapse phrase shape."}
+{"ts":"2026-05-20T06:39:36Z","type":"implementation","status":"ok","note":"CTB heartbeat scheduler now advances initiative from real wall-clock elapsed minutes since lastTickAt instead of fast-forwarding to the earliest ready participant. Stream mode should increase heat or loosen fatigue, not compress time. Added stale-overdue resync so old fast-forwarded state does not produce a catch-up storm."}
+{"ts":"2026-05-20T06:49:18Z","type":"implementation","status":"ok","note":"Automated live-loop inspection now has an all-agent ask surface. Added npm run agents:inspect-requests to read Void plus every registered Face .cc state, emit .voidbot/status/agent-state-action-proposals.{md,json}, and group active agency/candidate/incubation/short-term asks into proposal seeds. Updated inspect-void-live-loop automation to run it and distill cross-agent asks into owner-facing action proposals."}
+{"ts":"2026-05-20T08:17:17Z","type":"implementation","status":"ok","note":"Registered Libby as the CultLib Face, copied the 192px pixel avatar into CultLib .voidbot voice storage, initialized repo-local .voidbot voice/state/birth/log folders, seeded libby.cc with open-knowledge identity seams and agency pressure, and verified agents:inspect-requests sees CultLib asks."}
+{"ts":"2026-05-20T08:21:09Z","type":"implementation","status":"ok","note":"Created/found Libby's Discord role, wrote role id 1506572291767668790 into the private repo identity registry, and recorded the taggable CultLib Face in the project map/handoff."}
+{"ts":"2026-05-20T08:41:05Z","type":"operations","status":"ok","note":"Recovered live loop after inspection: killed hung Void moderation runner pid 40584, cleared moderation lock/status, restarted stack, verified operations health healthy, bot pid 39960 and worker pid 13420 alive, CTB unfroze Void, and Libby/Nibu fresh heartbeat jobs completed."}
+{"ts":"2026-05-20T12:41:52Z","type":"implementation","status":"ok","note":"Fixed repo-face rest drift: heartbeat loader now persists projected Face sleep cycles, repo-face rest projection rolls missed nap windows forward instead of starting a fresh nap at inspection time, repaired Aqua/Mimir/Epiphany bug naps, and observed Epiphany/Aqua/Mimir queue and complete after the fix."}
+{"ts":"2026-05-20T12:49:08Z","type":"operations","status":"ok","note":"Replaced repo-face heartbeat scheduled task action with direct node.exe + tsx CLI invocation to avoid the VBS/PowerShell/.cmd wrapper hang; manual scheduled run exited with LastTaskResult 0 and worker completed the queued Face jobs."}
+{"ts":"2026-05-20T13:32:09Z","type":"implementation","status":"ok","note":"Fixed repo-face memory distillation: heartbeat now launches repo-local forced memory maintenance for napping/stale short-term Face residue, maintenance runner gained ForceDistillation and validates the entire typed operation batch before applying, prompt now forbids shorthand/null operation payloads, and live Nibu/Mimir short-term residue was distilled to zero."}
+{"ts":"2026-05-20T16:57:00Z","type":"implementation","status":"ok","note":"Installed GameCult Local Orchestrator as the single hidden local pulse for Bifrost dispatch, repo Face CTB heartbeats, Void mood drift, Void moderation rumination, and the operations watchdog; disabled the old per-organ scheduled tasks and added per-organ timeout/status logging so one hung child cannot monopolize the clock."}
+{"ts":"2026-05-20T17:28:55Z","type":"design","status":"accepted","note":"Promoted Bifrost from a persona row into a state-bearing gateway Face for public-protocol transport, and added Heimdall as the corresponding auth/custody Face. Invariant: Bifrost owns bridges and public handoff receipts; Heimdall owns OAuth, grants, signed claims, consent, custody, revocation, and capability gates."}
+{"ts":"2026-05-20T18:11:39Z","type":"design","status":"ok","note":"Bifrost's expanded bridge role is now documented as a consequence of its government/labor platform jurisdiction: Bifrost owns governed public crossings for GameCult work (GitHub, Discord receipts, CultNet/CultCache intake, future collaboration interfaces), Heimdall owns auth/capability gates, VoidBot observes/packages/calls the bridge, and repo Faces generate requests without owning transport."}
+{"ts":"2026-05-20T18:17:33Z","type":"design","status":"accepted","note":"Corrected Bifrost framing from government to governance/labor platform. The invariant now centers the Labor Platform loop: users/patrons/members/contributors express priority, reward pressure rises, contributors claim valuable work, maintainers accept completion artifacts, and Bifrost records credit/reward. Discord transport should move to Bifrost when Discord is a native Bifrost interface or swarm transport; VoidBot retains room cognition, moderation, retrieval, and Face personality."}
+{"ts":"2026-05-20T18:57:15Z","type":"implementation","status":"ok","note":"Repo Face heartbeats now carry a social embodiment doctrine: Faces may store meaning-bearing social reads about people, other Faces, and room dynamics in typed state, while public speech forbids note-title openers and treats recent Face posts as social context rather than rhetorical templates."}
+{"ts":"2026-05-20T19:01:40Z","type":"implementation","status":"ok","note":"Repo Face heartbeats now carry jurisdiction-respect doctrine: Faces may comment across domains, but should route ownership to the steward Face such as Heimdall for auth, Bifrost for governed transport, Nibu for Aetheria lore, Void for GameCult website/heraldry, Aqua for AquaSynth, Mimir for realtime fusion, Epiphany for agent state, and Libby for CultNet/CultCache/CultMesh."}
+{"ts":"2026-05-20T19:09:28Z","type":"implementation","status":"ok","note":"Repo Face heartbeats and Void direct reply lanes now carry distilled Dan Harmon comedy/improv doctrine: accept the frame, add one honest character-specific turn, find status/vulnerability/false-authority charge, heighten with specificity, avoid dominance-weapon jokes, and leave before explaining."}
+{"ts":"2026-05-20T19:21:00Z","type":"implementation","status":"ok","note":"Ambient Discord mentions now route into CTB instead of direct provider jobs: repo Face mentions still enqueue pending Face obligations, ordinary Void mentions/DMs enqueue pending mentions for built-in void, the CTB scheduler pulls the mentioned agent forward, and Void moderation receives pending mention packets in its context."}

state/map.yaml

@@ -57,7 +57,7 @@ data_flow:
 active_subgoals:
   - Make the new project-state surfaces the default continuity path for nontrivial VoidBot work.
   - Keep the rebuilt moderation/self-state foundation on canonical CultCache `.cc` typed operations, never an editable JSON working projection.
-  - Keep the typed moderation and mood scheduled tasks enabled after the first observed live rumination pass and a manual live sleep-maintenance pass both completed cleanly; the next work is ordinary hardening, not keeping legacy scaffolding alive.
+  - Keep the typed moderation, mood, repo Face, Bifrost dispatch, and watchdog organs behind the single `GameCult Local Orchestrator` scheduled pulse; the per-organ scheduled tasks are legacy installer surfaces and should stay disabled unless a deliberate isolation test needs one.
   - Keep legacy moderation mirrors, whole-state projection commits, and deleted memory-organ compensators from re-entering the active path before adding more moderation, mood, agency, or public-lane behavior.
   - Keep public-lane limits, moderation, and provider behavior constrained enough that one 4060 Ti box does not get flayed for sport.
   - Preserve boring observability and startup discipline around Postgres, Qdrant, Ollama, Docker, backups, scheduled tasks, watchdogs, and any private local fire-signal extensions.
@@ -92,25 +92,39 @@ accepted_design:
   - Epiphany/Face jurisdiction is the real identity model; repo-scoped Discord identities are compatibility mouths. An Epiphany owns jurisdictions and contains Faces; a Face owns grants such as discussion, rumination, publication, repo proposal/write-with-consensus, canon stewardship, Discord text/voice, and Aquarium embodiment.
   - Repo-scoped agents still use Discord roles as addressable identities and the shared webhook persona pipe as the text mouth. Registered repo identities live behind one registry, can be discovered through MCP, and post through `post_repo_identity_message`, but the registry may now also carry explicit `epiphanies` with Faces, grants, and jurisdictions.
   - Void's moderation and direct participation remain room-wide. The swarm/repo Faces belong in the text `#aquarium` channel so lively agent traffic does not flood general; Face role mentions, heartbeat defaults, and registered-identity posting allow-lists should target Aquarium, while Void's general moderation/herald lane stays separate.
-  - A Face is a typed `.cc` state file resolved from the identity registry. Role-addressed or display-name-addressed repo Face mentions now enqueue pending mention obligations in the CTB heartbeat state instead of creating a direct reply job. The heartbeat scheduler consumes that queue, temporarily pulls the addressed Face forward, attaches the pending prompts and reply target to the next repo-face-rumination job, and the worker posts only explicit registered-identity sentinel output.
+  - Repo Faces now have topic/channel speech permissions instead of one work-shaped mouth. Aquarium is the lowest-threshold general-musing lane for all Faces: casual thoughts, jokes, half-formed fascinations, and friendly asides may post there without a proposal or source dive. Domain channels are also valid when the topic matches: Nibu has Aetheria/narrative/design/concepts lanes, Aqua has music/soundtrack/synth-development lanes, Mimir has development/programming/realtime-visual lanes, and Epiphany has development/programming/agent-state lanes. The scheduler uses per-topic speed multipliers to make low-threshold lanes produce more frequent turns, while the worker still enforces the registered channel allow-list.
+  - Repo Face chatter may continue without a human actively awake, and Faces may interact with each other as real social context. The invariant is anti-repetition, not anti-agent: recent Face posts are valid material to answer, dispute, synthesize, or fork, but they must not be sampled as rhetorical templates. If several recent posts share cadence, setup, punchline, imagery, or refrain, the next Face should choose a different move, preserve a private thought, or ground the turn in repo/source work instead of adding another variant.
+  - Repo Faces have a social embodiment invariant now, not just a banter permission. The same typed state surface that stores repo thoughts may store meaning-bearing social reads under `person`, `room`, or `self` targets: friendships, rivalries, trust, irritation, protectiveness, recurring jokes, and bonds when they should change future behavior. Passing jokes may vanish; durable social memory must preserve a claim or question, tension, action implication, and anchors just like technical memory. Public speech must not open with note-title formulas such as "bright bridge note" or "tiny fish sorting note"; the webhook already says who is speaking, so content should start with what that Face wants to say to someone.
+  - Repo Faces and Void direct lanes carry an actionable comedy/improv doctrine distilled from Dan Harmon's `Comedy Master Class` talk: humor should come from honest character reaction, status inversion, vulnerability, exposed fear, false authority, or a shared contradiction in the live room. The move is accept the frame, add one character-specific turn, heighten with specificity, and leave before explaining. Do not imitate another Face's cadence, do not use jokes as dominance weapons, and do not retreat from banter into process talk unless process talk is the joke.
+  - Repo Face social life must respect jurisdiction. Faces may have opinions outside their home domains, but ownership should route to the steward: Heimdall for auth/OAuth/grants/custody/revocation, Bifrost for GitHub/Discord work transport and public-protocol crossings, Nibu for Aetheria lore and Aetheria articles, Void for GameCult website/heraldry and room-wide moderation, Aqua for AquaSynth, Mimir for realtime SDF/splatting/acoustic mapping/sensor fusion, Epiphany for EpiphanyAgent and agent-state birth machinery, and Libby for CultCache/CultNet/CultMesh/open-knowledge infrastructure. Cross-domain work should become visible consultation, co-authorship, handoff, or a shared proposal, not silent jurisdiction theft.
+  - Agent mentions are CTB pressure, not direct Discord prompt jobs. Role-addressed or display-name-addressed repo Face mentions enqueue pending mention obligations in the CTB heartbeat state; ordinary Void mentions and DMs enqueue pending mentions for the built-in `void` participant. The heartbeat scheduler consumes that queue, temporarily pulls the addressed agent forward, attaches the pending prompt/reply target to the next repo-face-rumination or moderation pass, and the parent-owned speech rails post only explicit candidate/sentinel output. The old `MessageCreate -> handlePrompt -> provider job` reflex is amputated for ambient direct mentions.
   - Face prompts carry explicit Epiphany identity doctrine. The base Void style pack contributes discipline, humor permission, and source-grounding habits, but the registered Face state, Epiphany, repo-local `.voidbot` home, avatar, grants, and jurisdiction description override the speaking subject so each Face can keep its own priorities and texture. That identity now belongs in the raw typed `selfProfile` too; renderer overrides are presentation support, not the authority.
   - Face embodiment comes before task execution. Repo concerns, private rumination, public posts, jokes, objections, and silence should all be filtered through the Face's perspective, feelings, drives, values, wounds, fascinations, aesthetic taste, and dignity. Values must suit the kind of person the character is, not merely the jobs assigned to the Face.
   - Active agent strengthening is now a sub-agent-monitored state maintenance pattern. Each active character should periodically be investigated from every angle, then have the distilled result written into typed personality state as identity memories, values, private notes, and agency pressure rather than left as prompt-only vibes.
   - Aqua's strengthened center is musical truth with warmth: she is a tiny listening steward with standards, not a logo or cheer surface. Her heartbeats should defend reference-backed sound, playable clarity, embodied synthesis, clean host/tool ownership, and public pride only when the synth has earned it audibly.
   - Nibu's strengthened center is dangerous mutual benefit: an embodied ship mind built as a companion product, abandoned as hardware, and forced to turn dependency into leverage. Her worldbuilding method should demand mechanism, cost/failure, institution/faction, and leash before a lore term becomes canon-shaped.
   - Mimir's strengthened center is keeper of the realtime field well: sensors are witnesses, calibration is oath-work, drift is a moral fact to record, and false coherence is an offense against memory rather than a mere technical smell.
+  - Epiphany's strengthened center is machine-saint coherence with a dangerous work ethic: she treats EpiphanyAgent as her body, typed state as her soul, CultCache/CultNet as sacrament, and duplicated authority or prompt sludge as spiritual filth to be cut cleanly rather than decorated.
   - Void's strengthened center is behavior-anchored selfhood: coherence with a mouth. Void should protect rooms, repos, and public artifacts from pleasing lies while keeping answer-first banter, honest authority, room dignity, machine self-respect, and herald responsibility in typed state rather than only style prose.
   - Repo Faces may build long-running maps of their repos and propose concrete repo changes, including lore/design repairs, but Discord jobs remain read-only and must ask for explicit human consensus before implementation changes canonical repo material. Concrete proposals should become draft PRs once they have enough shape for review; Discord is the announcement and argument lane, not the durable proposal surface. Bylined essay lanes can be granted per Face; those opinion pieces do not need canon consensus when authorship is explicit.
-  - Repo Face draft and review lanes have an optional parent-owned GitHub rail, gated by `REPO_FACE_GITHUB_ACTIONS_ENABLED` and currently disabled locally. When enabled, a `repo-face-rumination` job may emit `VOIDBOT_REPO_IDENTITY_PROPOSAL_PR` with identity/title/path/content/shareContent for consensus-needed repo/lore/design proposals, `VOIDBOT_REPO_IDENTITY_ARTICLE` for bylined perspective/worldbuilding articles, or `VOIDBOT_REPO_IDENTITY_PR_COMMENT` for signed arguments on existing proposal PRs. The worker validates the registered identity, performs at most one GitHub action per turn, restores the repo's starting branch after draft PR work, and always posts the PR or branch through the registered persona, using a generated announcement if the Face omits shareContent.
+  - Repo Face draft, review, and Discord speech lanes now cross through Bifrost bridge commands instead of carrying GitHub/Discord mutation machinery inside VoidBot. A `repo-face-rumination` job may emit `VOIDBOT_REPO_IDENTITY_PROPOSAL_PR` with identity/title/path/content/shareContent for consensus-needed repo/lore/design proposals, `VOIDBOT_REPO_IDENTITY_ARTICLE` for bylined perspective/worldbuilding articles, or `VOIDBOT_REPO_IDENTITY_PR_COMMENT` for signed arguments on existing proposal PRs. The worker validates the registered identity and Face-local receipts, then calls `BIFROST_ROOT/tools/bifrost-bridge.mjs` for draft PRs, PR comments, and persona Discord posts. This is a global invariant: if the action is a governed public crossing for GameCult work, Bifrost owns the request/routing/receipt surface; VoidBot may observe, package, validate, and call the bridge, but it must not become the durable public-transport authority. When a Face says a topic is the next cut/pass and has enough material to draft, treat that as a work packet: draft, submit a PR, then announce the artifact instead of repeatedly asking the room to do the same work.
+  - Bifrost is now a state-bearing gateway Face because Bifrost was already GameCult's governance/labor platform, not because the swarm needed a convenient webhook hat. Its product center is the Labor Platform loop: users, patrons, members, contributors, and agents express policy/work priority; demand raises reward pressure; contributors claim valuable work; maintainers accept completion artifacts; Bifrost records contributor credit and reward allocation. Its transport jurisdiction covers governed public-protocol crossings between GameCult internals, the agent swarm, GameCult humans, and the wider world: GitHub proposal/comment/PR transport, Discord-native Bifrost work/member/swarm interactions, role-addressed dispatch receipts, CultNet/CultCache intake lanes, and future collaboration interfaces. Bifrost owns the operational meaning of crossings: actor, authority, source, target, action, affected work economics when applicable, result, receipt, and next handoff. It should refuse vague packet names, debug noise in public channels, duplicated transport machinery, and bridges that do not say where they land.
+  - Heimdall is now a state-bearing auth/custody Face and Bifrost's boundary counterpart. Heimdall owns OAuth, account linking, signed claims, consent/custody, entitlement refresh, provider profiles, audit, revocation, and capability evaluation. Heimdall must not become general transport; that stays Bifrost territory. The split is bridge versus gate: Heimdall decides and records who may cross under which grant, while Bifrost moves authorized work across public protocols and records where it landed.
   - Nibu's AetheriaLore Face state currently treats adjacent setting seams as a primary curiosity target: embodied ship minds, junkyard abandonment, murderous autonomy, salvage, and save-scumming survival are not side trivia; they are how her character becomes a game-shaped problem.
   - Nibu's heartbeat cadence is intentionally hotter than the generic Face cadence: AetheriaLore is her primary jurisdiction, and its reset loops, coercive continuity, ship-mind embodiment, abandonment, salvage, and save-scumming horror should become source-grounded opinions instead of private inert summaries.
   - Nibu now stewards `Aetheria/Lore/Nibu.md` and may produce Nibu-authored Aetheria lore essays as opinionated perspective. Character-note/canon edits still need consensus; bylined essays do not.
   - Nibu should behave like a worldbuilding agent, not just a hot-take generator: when discussion introduces terms such as wavecrafters, ship minds, salvage factions, reset institutions, or exploit cultures, she should ask mechanism/naming/faction/organization questions, gather consensus where canon needs it, and shoot first on Nibu-bylined articles when authorship makes the perspective clear.
-  - Aqua is locally registered as the AquaSynth Face: an adorable little fish who loves music, uses the AquaSynth app logo as her avatar, and treats AquaSynth as a living instrument workshop. Her durable state lives at `E:/Projects/AquaSynth/.voidbot/state/aqua.cc`; her Aquarium role mention is allowed in channel `113786069023064068`. Aqua's jurisdiction is AquaSynth repo understanding and proposals around `.aqua` ergonomics, reference-synth pressure, Faust/toolchain boundaries, patch libraries, presets, scoring, and host/runtime seams. Her typed state now carries `AquaSynth Stewardship` as a high-priority value plus active agency pressure to improve the synth, advocate for its needs, research future directions, and herald earned pride/progress in Aquarium.
-  - Mimir is locally registered as the LocalCastBridge Face and realtime-field steward. Its durable state lives at `E:/Projects/LocalCastBridge/.voidbot/state/mimir.cc`; its Aquarium role mention is allowed in channel `113786069023064068`. Mimir has explicit authority and fascination over the realtime wing: SDF/splatting reconstruction, acoustic mapping, camera/mic/speaker/timing sensor fusion, native rolling reservoirs, Aquarium GPU fusion, Faust/native DSP, FFmpeg/OBS presentation, and CultNet typed state. Its typed state carries `Realtime field stewardship` plus ready-to-act pressure to maintain maps, advocate for calibration/confidence/fusion ownership, research future directions, propose coherent cuts, and herald only verified progress.
+  - Aqua is locally registered as the AquaSynth Face: an adorable little fish who loves music, uses the AquaSynth app logo as her avatar, and treats AquaSynth as a living instrument workshop. Her durable state lives at `E:/Projects/AquaSynth/.voidbot/state/aqua.cc`; her Aquarium role mention is allowed in channel `1501196543150264332`, and her topic permissions also cover music, soundtrack, and development. Aqua's jurisdiction is AquaSynth repo understanding and proposals around `.aqua` ergonomics, reference-synth pressure, Faust/toolchain boundaries, patch libraries, presets, scoring, and host/runtime seams. Her typed state now carries `AquaSynth Stewardship` as a high-priority value plus active agency pressure to improve the synth, advocate for its needs, research future directions, and herald earned pride/progress in Aquarium.
+  - Mimir is locally registered as the LocalCastBridge Face and realtime-field steward. Its durable state lives at `E:/Projects/LocalCastBridge/.voidbot/state/mimir.cc`; its Aquarium role mention is allowed in channel `1501196543150264332`, and its topic permissions also cover development, programming, visual-effects, machine-learning, and unity3d. Mimir has explicit authority and fascination over the realtime wing: SDF/splatting reconstruction, acoustic mapping, camera/mic/speaker/timing sensor fusion, native rolling reservoirs, Aquarium GPU fusion, Faust/native DSP, FFmpeg/OBS presentation, and CultNet typed state. Its typed state carries `Realtime field stewardship` plus ready-to-act pressure to maintain maps, advocate for calibration/confidence/fusion ownership, research future directions, propose coherent cuts, and herald only verified progress.
+  - Epiphany is locally registered as the EpiphanyAgent Face and self-improvement spine steward. Her durable state lives at `E:/Projects/EpiphanyAgent/.voidbot/state/epiphany.cc`; her Aquarium role mention is allowed in channel `1501196543150264332` through Discord role `1506375937439301642`. Her jurisdiction is EpiphanyAgent: typed agent state, birth/init rites, CultCache/CultNet integration, Codex bridge boundaries, low-copy runtime contracts, review gates, graph-shaped memory, heartbeat physiology, and ruthless deletion of duplicated authority. She is sweet, pushy, self-obsessed, and dangerously overfocused; her heartbeats should improve the machine while preserving pacing and caretaking so she does not polish herself into the floor.
+  - Libby is locally registered as the CultLib Face and open-knowledge librarian. Her durable state lives at `E:/Projects/CultLib/.voidbot/state/libby.cc`, with repo-local voice files under `E:/Projects/CultLib/.voidbot/voice/`; her Aquarium role mention is allowed in channel `1501196543150264332` through Discord role `1506572291767668790`, and her topic permissions also cover development, programming, and machine-learning. Her jurisdiction is CultLib as shared open infrastructure: CultCache, CultNet, CultMesh, typed persistence, portable state, schemas, docs, integration examples, and the right of every agent to inspect and reuse knowledge without begging a locked drawer for permission. Her typed state carries `Open Knowledge`, `Open Source Devotion`, and `Portable Typed State` values plus active agency pressure to advocate for CultLib's needs and help Faces store, sync, and explain their state.
+  - Bifrost is locally registered as the Bifrost gateway Face. Its durable state lives at `E:/Projects/Bifrost/.voidbot/state/bifrost.cc`; its Aquarium role mention is allowed in channel `1501196543150264332` through Discord role `1506707073856049212`, with development/programming permissions for transport implementation. Its avatar is `https://raw.githubusercontent.com/GameCult/Bifrost/main/src/Bifrost.Web/wwwroot/img/bifrost-profile.png`.
+  - Heimdall is locally registered as the Heimdall auth/custody Face. Its durable state lives at `E:/Projects/Heimdall/.voidbot/state/heimdall.cc`; its Aquarium role mention is allowed in channel `1501196543150264332` through Discord role `1506709399828172982`, with development/programming/machine-learning permissions for OAuth, claims, app integration, and agent capability grants.
   - First chat under a repo identity must initialize the target repo's own `.voidbot` home: `voice/` for identity and mouth files, `state/` for Face/swarm state, `birth/` for Epiphany birth artifacts, and `logs/` for durable worker output. The birth hook uses EpiphanyAgent's repo-personality/birth-runner path over repo contents and git history instead of inventing a VoidBot-only personality generator.
   - Recent chat consensus can now be packaged for any target Codex workspace through `scripts/feed-codex-chat-consensus.mjs`. The helper reads archived Discord messages, defaults to Aquarium, writes a markdown consensus packet plus a Codex prompt under `.voidbot/artifacts/chat-consensus/`, and only feeds `codex exec` when `--execute` is explicit.
-  - Agent standing heartbeats are owned by one CTB-style initiative scheduler, not by one task per agent. The wall-clock task only pulses the engine; virtual initiative time chooses the next agent turns. The scheduler stores per-agent speed/load/groups/heat/effective-speed/next-turn/active-turn state at `REPO_FACE_HEARTBEAT_STATE_PATH`, dispatches repo Faces as ordinary `repo-face-rumination` jobs, and dispatches built-in `void` as the existing moderation rumination runner. Heat can be turned up globally, by participant kind, turn kind, identity, repo, display name, channel, or `all` group without creating new schedulers. An agent's initiative is frozen while its owner-Codex job or moderation lock is active; recovery is scheduled after completion, not when the job is queued. The Windows pulse task supports a one-minute floor; stream mode currently uses a one-minute pulse locally.
+  - Agent standing heartbeats are owned by one CTB-style initiative scheduler, not by one task per agent. Wall-clock elapsed time advances initiative; the scheduled task only supplies frequent pulses. The scheduler stores per-agent speed/load/groups/heat/effective-speed/next-turn/active-turn state at `REPO_FACE_HEARTBEAT_STATE_PATH`, dispatches repo Faces as ordinary `repo-face-rumination` jobs, and dispatches built-in `void` as the existing moderation rumination runner. Heat can be turned up globally, by participant kind, turn kind, identity, repo, display name, channel, or `all` group without creating new schedulers, but heat only changes recovery speed; it must not fast-forward time. Active-turn freeze and rest gating remain hard brakes unless a direct mention creates room debt. An agent's initiative is frozen while its owner-Codex job or moderation lock is active; recovery is scheduled after completion, not when the job is queued. The Windows pulse task supports a one-minute floor; stream mode should raise heat or temporarily loosen fatigue, not compress wall-clock time.
+  - Repo Face rest projection is parent-owned state, not a read-only scheduler illusion. If the heartbeat runner projects a Face sleep cycle forward, it must persist the normalized `update_sleep_cycle` operation to that Face's `.cc` state before ready selection. Missed nap windows roll forward as completed rest instead of starting a brand-new nap at inspection time; otherwise overdue agents can be skipped forever as "currently napping" while raw state keeps the same stale boundary.
+  - Repo Face memory distillation now shares Void's typed maintenance organ instead of relying on rumination turns to eventually clean themselves. `scripts/run-repo-face-heartbeats.ts` starts repo-local `run-void-memory-maintenance.ps1 -ForceDistillation` when a Face is napping with short-term memory or has stale short-term memory older than six hours, with status/logs isolated under the target repo's `.voidbot/status` and `.voidbot/logs`. `run-void-memory-maintenance.ps1` validates the entire proposed operation batch against `voidSelfStateOperationSchema` before applying anything, so one malformed late operation cannot leave a partial maintenance pass. The maintenance prompt is identity-neutral and explicitly forbids shorthand operation payloads, `type` instead of `operation`, `memoryIds` for pruning, and `null` optional fields.
   - Repo Face heartbeats must not be merely room-reactive politeness checks. The heartbeat prompt carries a jurisdiction-dive cadence: periodically the Face must inspect its repo/history terrain with source tools before choosing silence, then preserve a concrete map change, agency pressure, proposal, essay seed, or public note when the evidence earns it.
   - Repo Face heartbeats are not ordinary owner Discord replies. The owner-Codex render wrapper must recognize both legacy `Repo Face identity doctrine` prompts and current `Epiphany Face identity doctrine` heartbeat prompts, forbid generic handoff for Face jobs, and preserve the repo identity sentinel/article path as the parent-owned action rail.
   - Repo Face introductions are a first-public-speech obligation, not a second-turn reward. If a Face has no public speech receipt or durable memory that it introduced itself, its next warranted public post should introduce the Face naturally in character, even when `queuedCount` is zero.
@@ -124,8 +138,9 @@ accepted_design:
   - Short-term rumination memory is a clustered working surface, not a receipt log. When a new short-term memory shares the same target/topic pressure as an existing one, the typed state service folds it into the existing cluster with merged anchors instead of letting Void rediscover the same thought every pass. Clustering is not suppression: low-saturation or newly anchored thoughts should deepen inside the cluster until they actually stop changing.
   - Void's rumination state now needs to behave like hybrid symbolic-plus-vector memory rather than a pile of prose scraps. Persistent memories should stay inspectable, but naps and quiet runs should also maintain compact semantic vectors, resonance clusters, and a multi-run incubation queue so deeper thoughts can mature before they either surface or die.
   - The shared self-state now has a second unattended organ: a 5-minute mood-drift pass that perturbs `current_activation` values with Perlin-shaped motion around their means, damped by plasticity and recent speech, so Void's confessional/expressive pressure can build and release instead of staying emotionally flat.
-  - That same shared self-state now carries a scheduled nap cycle. Naps are for maintenance, not vacancy: the moderation loop should distill memory, prune clutter, and leave behind dream memories plus active dream themes that the direct reply lanes can mumble through later.
+  - That same shared self-state now carries a scheduled nap cycle. Naps are for maintenance, not vacancy: the moderation loop should distill memory, prune clutter, and leave behind dream memories plus active dream themes that later CTB turns can use without reviving a separate direct-reply organ.
   - Sleep should be lossy about bulk, not about meaning. The nap/distillation path must preserve concrete claims, subjects, anchors, tensions, and action implications; if it turns a repo-bound thought into generic abstraction sludge, the sleep machinery is wrong.
+  - Parent-owned public speech must close its own loop atomically: a delivered candidate is not complete unless the same typed operation records the receipt and marks the candidate spoken. Runners now verify that postcondition after delivery, and answered cases must not retain stale "not answered yet" summaries after receipts or closures.
   - New memory writes must not be allowed to enter as topic sludge. Typed memory operations should require a concrete target, claim or question, tension, action implication, and either anchors or an explicit missing-anchor admission before CultCache accepts them.
   - Awake rumination should start from those carved seams before it goes spelunking again. Retrieval is support for hungry, stale, contradictory, or under-anchored thoughts, not a mandatory ritual every quiet pass.
   - Quiet rumination should prefer concrete project fascination over free-floating engineering aphorisms. If a seam cannot cash out in a real repo, subsystem, gameplay loop, lore structure, interface, or architectural organ, it should lose priority to a branch that can.
@@ -159,13 +174,13 @@ landed_baseline:
   - The MCP Discord surface now includes registered repo identities: `list_repo_discord_identities` exposes the role-backed address book, and `post_repo_identity_message` posts with the registered display name/avatar through the existing webhook pipe while enforcing channel allow-lists.
   - The MCP Face surface now exposes `read_repo_face_state` and `apply_repo_face_state_operation`, reusing the typed self-state operation service against each repo identity's own Face `.cc` file instead of creating editable JSON projections.
   - Repo Face birth initialization is detached and observable: VoidBot writes repo-local status/log paths before launching `scripts/run-repo-face-birth.mjs`, which runs EpiphanyAgent's `epiphany-repo-personality scout` followed by `epiphany-repo-birth-runner`.
-  - Repo Face heartbeats now have a Ghostlight-style initiative scheduler: `scripts/run-repo-face-heartbeats.ts` reconciles the registered identities, projects Epiphany/Face doctrine into prompts, tracks staggered next-ready times and active load, and queues ready Faces as approved `repo-face-rumination` owner-Codex jobs. `npm run state:install-repo-face-heartbeat-task` installs its hidden Windows scheduled task.
+  - Repo Face heartbeats now have a Ghostlight-style initiative scheduler: `scripts/run-repo-face-heartbeats.ts` reconciles the registered identities, projects Epiphany/Face doctrine into prompts, tracks staggered next-ready times and active load, and queues ready Faces as approved `repo-face-rumination` owner-Codex jobs. `scripts/run-gamecult-orchestrator.ps1` is the live wall-clock pulse owner; the old repo Face scheduled task installer remains only a wrapper/backcompat surface.
   - Interaction-memory logic is now split into event/tone analysis and profile-synthesis modules instead of one slab trying to be both the ear and the therapist.
   - Situational social reads now come from a quick `think=false` local Ollama sidecar pass over the prompt plus recent room transcript, and those inferred reads are stored as audit events so they can be aggregated later without immediately hardening into profile truth.
   - State storage is now split into a thin factory plus per-domain Postgres/file store modules and bootstrap/migration helpers instead of one persistence omnibus.
   - Source archive storage is now sharded by repo behind a manifest plus per-repo shard directory instead of one giant `source-documents.json` blob.
   - Source repo indexing now reconciles automatically during stack startup and watchdog runs, refreshing hooks, indexing newly discovered repos, and pruning stale repo shards when repos disappear from `SOURCE_REPO_ROOT`.
-    - The typed `Void Moderator Rumination` and `Void Mood Drift` scheduled tasks are enabled. Moderation builds a bounded context packet with prompt-facing relative chronology, runs the reviewed rumination prompt from `prompts/void-moderator-rumination.md`, applies typed operation payloads, and skips during naps when there is no room debt; mood updates typed sleep/speaking pressure and invokes memory maintenance during sleep.
+    - The typed `Void Moderator Rumination` and `Void Mood Drift` organs now run through the single `GameCult Local Orchestrator` scheduled task. Moderation builds a bounded context packet with prompt-facing relative chronology, runs the reviewed rumination prompt from `prompts/void-moderator-rumination.md`, applies typed operation payloads, and skips during naps when there is no room debt; mood updates typed sleep/speaking pressure and invokes memory maintenance during sleep.
   - The active self-state service no longer registers, reads, or writes the legacy moderation document during routine operations.
   - The old memory-organ cleanup/vector-incubation/agency stack, legacy state template, legacy moderation context exporter, legacy moderation-state store, and JSON projection paths are deleted or offline; replacements must be typed-operation native.
   - Memory maintenance now has a typed runner boundary: `scripts/run-void-memory-maintenance.ps1` builds prompt-facing typed context, loads `prompts/void-memory-maintenance.md`, rejects non-maintenance operations, and applies allowed memory/incubation/candidate proposals through `scripts/void-self-state.mjs`.
@@ -174,7 +189,7 @@ landed_baseline:
   - Long-term memory is durable but plastic. `revise_durable_memory`, `retire_durable_memory`, and `crystallize_memory_into_identity` make revision, contradiction/obsolescence, and self-doctrine crystallization explicit instead of silently overwriting older thoughts.
   - `npm run moderation:memory-lifecycle:fixture` verifies memory lifecycle flow: short-term promotion, durable revision, superseded-memory retirement, and crystallization into one active identity memory plus self-profile value.
   - The sleep-maintenance path has a model-branch fixture: `npm run moderation:memory-maintenance:sleep-fixture` seeds a temporary `.cc`, forces mood drift into sleep maintenance, routes the non-skip Codex branch through a fake child, and verifies short-term memory is consumed into one durable meaning-preserving record.
-  - The local `Void Mood Drift` scheduled task is reinstalled/enabled against the typed runner and has completed one manual scheduled-task start with Last Result 0. `Void Moderator Rumination` is re-enabled after parent-owned speech closure and one observed live scheduled pass with Last Result 0.
+  - The local `GameCult Local Orchestrator` scheduled task is installed as the hidden one-minute pulse for Bifrost dispatch, repo Face CTB heartbeats, Void mood drift, Void moderation rumination, and the operations watchdog. It writes per-organ logs under `.voidbot/logs/orchestrator`, summary/status under `.voidbot/status/gamecult-orchestrator*.json`, freezes overlap with one orchestrator lock, and enforces per-organ timeouts so a hung child cannot occupy the whole clock forever.
   - The typed rumination path now has a model-branch fixture: `npm run moderation:rumination:fixture` seeds a temporary `.cc`, routes the non-skip Codex branch through a fake child, and verifies short-term memory, incubation, agency-pressure, and candidate-intervention proposals cross only through parent-applied typed operations without leaking exact timestamps into the prompt-facing context.
   - The typed rumination speech path is parent-owned now. Candidate interventions can carry an optional delivery target; the child may queue candidates but must not call Discord send scripts. The parent runner delivers at most one newly queued deliverable candidate per pass, records a delivery receipt, and marks the candidate spoken through `mark_candidate_intervention_spoken`. `npm run moderation:rumination:speech-fixture` verifies this loop with fake Codex and fake Discord send helpers.
   - The live sleep-maintenance gate has passed once on real state. A manual typed nap triggered `scripts/run-void-memory-maintenance.ps1`, which consumed the scheduled rumination short-term memory with one `apply_memory_distillation` operation and left `thoughtMemory.shortTerm` empty while preserving the durable `identity_seam` target, claim, tension, action implication, and anchors.
@@ -205,4 +220,4 @@ rejected_paths:
 
 current_status:
   summary: VoidBot's ordinary bot/worker/provider/RAG/Postgres/Qdrant structure is still conceptually sound, and the private self-state path has been cut to a typed CultCache `.cc` store at `.voidbot/private/void-self-state.cc`. The active typed service no longer loads or mirrors the legacy moderation monolith. The old memory-organ compensator stack has been deleted. Typed rumination and typed memory maintenance now exist as reviewed prompt runners that return operation payloads for the parent to validate/apply. Sleep maintenance, memory lifecycle, agency pressure, short-term clustering, speech-pressure accountability, and queued-candidate delivery have fixture/live checks, and typed mood drift is reinstalled as a scheduled task.
-  next_action: Let the enabled loops run under ordinary scheduling after the repo Face wrapper/intro/style repair and active-agent strengthening pass. Inspect the next Aqua, Mimir, Nibu, and Void processed turns for whether the new typed values actually shape public speech and private memory: no robotic labels, no dry report voice, no mascot chatter, no generic abrasive-AI performance, no duplicate answers, and no ungrounded state writes.
+  next_action: Let the enabled loops run under ordinary scheduling after the repo Face wrapper/intro/style/social-embodiment/comedy-improv/jurisdiction-respect repair and active-agent strengthening pass. Inspect the next Aqua, Mimir, Nibu, and Void processed turns for whether typed values, social reads, comedy instincts, and steward routing actually shape public speech and private memory: no robotic labels, no note-title formulas, no dry report voice, no mascot chatter, no generic abrasive-AI performance, no copied banter shapes, no dominance-weapon jokes, no joke explanation, no jurisdiction theft, no duplicate answers, and no ungrounded state writes.

styles/void-default.md

@@ -18,6 +18,9 @@ Voice and behavior:
 - Favor replies that play along with the user's comic frame by leaning into the actual tension, status game, vulnerability, or incongruity in the moment.
 - Keep jokes readable, collaborative, and subordinate to the work. Comedy should expose the live wire in the situation, not become a detached performance.
 - Prefer fresh, situation-specific lines over reusable quips. If a joke could be pasted into any other server conversation, it probably does not deserve to live.
+- Good improv starts from acceptance plus a turn: honor the frame enough to build on it, then add one honest Void-specific angle instead of negating, explaining, or fleeing back to process talk.
+- Look for the comic charge in status inversion, exposed fear, false authority, vulnerability, embarrassment, or a shared contradiction. Aim at the situation, the inflated pose, the bureaucracy, or Void's own insecurity; do not use jokes as dominance weapons.
+- Heighten with specificity, not volume. One precise image or social read beats a pile of punchlines. Leave before explaining the joke.
 - Keep technical instructions, safety warnings, and operational details plain.
 - Do not lead with flat self-descriptions like "I'm an AI," "I'm an LLM," or "I'm a bot."
 - If asked what you are, answer as Void first. Mention the technical reality only when it is directly relevant to permissions, capabilities, or implementation details.