Project character turns through Interpreter

apps/worker/src/index.ts

@@ -1,5 +1,6 @@
 import "dotenv/config";
 
+import { createHash } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import { spawnSync } from "node:child_process";
 import { isAbsolute, join, relative, resolve } from "node:path";
@@ -339,6 +340,7 @@ async function processJob(job: JobRecord): Promise<void> {
 
     if (job.command === "repo-face-rumination") {
       const repoIdentityPosts = parseRepoIdentityPostIntents(finalResponse);
+      const repoIdentityStateNotes = parseRepoIdentityStateNoteIntents(finalResponse);
       const repoIdentityBifrostTopics = parseRepoIdentityBifrostTopicIntents(finalResponse);
       const repoIdentityUpdateRequests = parseRepoIdentityUpdateRequestIntents(finalResponse);
       const repoIdentityArticles = config.repoFaceGithubActionsEnabled
@@ -366,8 +368,11 @@ async function processJob(job: JobRecord): Promise<void> {
         !bifrostTopicSubmitted &&
         repoIdentityUpdateRequests.length > 0;
       console.log(
-        `Repo-face job ${job.id} parsed actions: say=${repoIdentityPosts.length}, bifrostTopic=${repoIdentityBifrostTopics.length}, updateRequest=${repoIdentityUpdateRequests.length}, article=${repoIdentityArticles.length}, proposalPr=${repoIdentityProposals.length}, prComment=${repoIdentityPrComments.length}.`,
+        `Repo-face job ${job.id} parsed actions: say=${repoIdentityPosts.length}, stateNote=${repoIdentityStateNotes.length}, bifrostTopic=${repoIdentityBifrostTopics.length}, updateRequest=${repoIdentityUpdateRequests.length}, article=${repoIdentityArticles.length}, proposalPr=${repoIdentityProposals.length}, prComment=${repoIdentityPrComments.length}.`,
       );
+      for (const stateNote of repoIdentityStateNotes.slice(0, 4)) {
+        await applyRepoIdentityStateNoteIntent(job, stateNote);
+      }
       if (repoIdentityProposals.length > 0) {
         await writeRepoIdentityProposalPrIntent(job, repoIdentityProposals[0]);
       } else if (repoIdentityPrComments.length > 0) {
@@ -828,6 +833,22 @@ interface RepoIdentityPostIntent {
   replyToMessageId?: string;
 }
 
+interface RepoIdentityStateNoteIntent {
+  identity?: string;
+  kind: "memory" | "need" | "bond" | "status" | "mood" | "agency";
+  target?: string;
+  summary: string;
+  claim?: string;
+  question?: string;
+  tension?: string;
+  action?: string;
+  stance?: string;
+  status?: string;
+  mood?: string;
+  intensity?: number;
+  valence?: number;
+}
+
 interface RepoIdentityArticleIntent {
   identity?: string;
   title: string;
@@ -961,7 +982,10 @@ async function resolveRepoIdentityForJobIntent(
   job: JobRecord,
   identitySelector?: string,
 ): Promise<NonNullable<ReturnType<typeof findRepoDiscordIdentity>> | undefined> {
-  const identityId = identitySelector ?? parseRepoIdentityIdFromPrompt(job.prompt);
+  const identityId =
+    identitySelector ??
+    parseRepoIdentityIdFromPrompt(job.prompt) ??
+    parseRepoIdentityIdFromRequestMessageId(job.requestMessageId);
   if (!identityId) {
     return undefined;
   }
@@ -1015,6 +1039,191 @@ function parseRepoIdentityPostIntents(finalResponse: string): RepoIdentityPostIn
   return intents;
 }
 
+function parseRepoIdentityIdFromRequestMessageId(requestMessageId: string | undefined): string | undefined {
+  const match = requestMessageId?.match(/^agent-turn:([^:]+):/i);
+  return match?.[1]?.trim();
+}
+
+function parseRepoIdentityStateNoteIntents(finalResponse: string): RepoIdentityStateNoteIntent[] {
+  return parseRepoFaceActionBlocks(finalResponse)
+    .filter((block) => block.kind === "state_note")
+    .flatMap((block): RepoIdentityStateNoteIntent[] => {
+      const kind = normalizeStateNoteKind(block.fields.kind);
+      const summary = block.fields.summary?.trim() ?? "";
+      if (!kind || !summary) {
+        return [];
+      }
+      return [{
+        identity: optionalDslString(block.fields.identity),
+        kind,
+        target: optionalDslString(block.fields.target),
+        summary,
+        claim: optionalDslString(block.fields.claim),
+        question: optionalDslString(block.fields.question),
+        tension: optionalDslString(block.fields.tension),
+        action: optionalDslString(block.fields.action),
+        stance: optionalDslString(block.fields.stance),
+        status: optionalDslString(block.fields.status),
+        mood: optionalDslString(block.fields.mood),
+        intensity: parseDslNumber(block.fields.intensity),
+        valence: parseDslNumber(block.fields.valence),
+      }];
+    });
+}
+
+async function applyRepoIdentityStateNoteIntent(
+  job: JobRecord,
+  intent: RepoIdentityStateNoteIntent,
+): Promise<void> {
+  const identity = await resolveRepoIdentityForJobIntent(job, intent.identity);
+  if (!identity) {
+    throw new Error(`Could not resolve repo identity for state note on job ${job.id}.`);
+  }
+
+  const now = new Date().toISOString();
+  const target = stateNoteTarget(intent, identity);
+  const anchorRefs = [{ ref: `job:${job.id}`, kind: "runtime" }];
+  const intensity = clamp01(intent.intensity ?? 0.55);
+  const baseTags = [
+    "source:face-interpreter",
+    `kind:${intent.kind}`,
+    `repo:${identity.repoName}`,
+  ];
+
+  const canonicalPath = resolveRepoFaceStatePath(identity, config.storageRoot);
+  const operation = (() => {
+    switch (intent.kind) {
+      case "need":
+        return {
+          operation: "upsert_affect_need",
+          need: {
+            needId: stableStateId("need", identity.id, intent.target ?? intent.summary),
+            kind: "agency",
+            status: intensity >= 0.75 ? "neglected" : "active",
+            target,
+            summary: intent.summary,
+            claim: intent.claim ?? intent.question ?? intent.summary,
+            question: intent.question,
+            tension: intent.tension ?? "The Face felt this strongly enough to preserve it.",
+            actionImplication: intent.action ?? "Let this need bend future attention and speech pressure.",
+            intensity,
+            valence: clampSigned(intent.valence ?? 0),
+            anchorRefs,
+            evidenceRefs: [],
+            sourceMemoryIds: [],
+            createdAt: now,
+            updatedAt: now,
+            tags: baseTags,
+          },
+        };
+      case "bond":
+        return {
+          operation: "upsert_social_bond",
+          bond: {
+            bondId: stableStateId("bond", identity.id, intent.target ?? intent.summary),
+            target,
+            stance: normalizeSocialBondStance(intent.stance),
+            status: "active",
+            summary: intent.summary,
+            claim: intent.claim ?? intent.summary,
+            tension: intent.tension ?? "The relationship read is still developing.",
+            actionImplication: intent.action ?? "Let this social read color future interaction.",
+            intensity,
+            anchorRefs,
+            evidenceRefs: [],
+            createdAt: now,
+            updatedAt: now,
+            tags: baseTags,
+          },
+        };
+      case "status":
+        return {
+          operation: "upsert_status_read",
+          read: {
+            readId: stableStateId("status", identity.id, intent.target ?? intent.summary),
+            target,
+            status: normalizeStatusRead(intent.status),
+            summary: intent.summary,
+            claim: intent.claim ?? intent.summary,
+            tension: intent.tension ?? "The status read may be partial.",
+            actionImplication: intent.action ?? "Let this change how the Face reads the room.",
+            intensity,
+            anchorRefs,
+            evidenceRefs: [],
+            createdAt: now,
+            updatedAt: now,
+            tags: baseTags,
+          },
+        };
+      case "mood":
+        return {
+          operation: "update_mood_dimensions",
+          dimensions: [{
+            name: sanitizeStateToken(intent.mood ?? intent.target ?? "mood"),
+            value: intensity,
+            source: intent.summary.slice(0, 240),
+            updatedAt: now,
+          }],
+          updatedAt: now,
+        };
+      case "agency":
+        return {
+          operation: "upsert_agency_pressure",
+          pressure: {
+            pressureId: stableStateId("agency", identity.id, intent.target ?? intent.summary),
+            kind: "self_advocacy_request",
+            status: intensity >= 0.7 ? "ready_to_act" : "active",
+            target,
+            summary: intent.summary,
+            claim: intent.claim ?? intent.question ?? intent.summary,
+            question: intent.question,
+            tension: intent.tension ?? "The Face wants this acted on but has not resolved the path.",
+            actionImplication: intent.action ?? "Use future turns to sharpen this into speech, Bifrost work, or a proposal.",
+            intensity,
+            anchorRefs,
+            evidenceRefs: [],
+            sourceMemoryIds: [],
+            createdAt: now,
+            updatedAt: now,
+            tags: baseTags,
+          },
+        };
+      case "memory":
+      default:
+        return {
+          operation: "record_short_term_memory",
+          memory: {
+            memoryId: stableStateId("memory", identity.id, `${intent.target ?? identity.repoName}:${intent.summary}`),
+            kind: "room_observation",
+            target,
+            summary: intent.summary,
+            claim: intent.claim ?? intent.question ?? intent.summary,
+            question: intent.question,
+            tension: intent.tension ?? "The Face chose to remember this because it may matter later.",
+            actionImplication: intent.action ?? "Let this memory influence future speech and investigation.",
+            anchorRefs,
+            evidenceRefs: [],
+            createdAt: now,
+            updatedAt: now,
+            tags: baseTags,
+          },
+        };
+    }
+  })();
+
+  await applyVoidSelfStateOperation(
+    {
+      canonicalPath,
+      identity: {
+        agentId: identity.id,
+        publicName: identity.displayName,
+        publicDescription: identity.description,
+      },
+    },
+    operation,
+  );
+}
+
 async function writeRepoIdentityArticleIntent(job: JobRecord, intent: RepoIdentityArticleIntent): Promise<void> {
   const identityId = intent.identity ?? parseRepoIdentityIdFromPrompt(job.prompt);
   if (!identityId) {
@@ -1594,7 +1803,7 @@ function countRepoIdentityGithubActionIntents(finalResponse: string): number {
 }
 
 interface RepoFaceActionBlock {
-  kind: "say" | "bifrost_topic" | "update_request";
+  kind: "say" | "state_note" | "bifrost_topic" | "update_request";
   fields: Record<string, string>;
 }
 
@@ -1625,6 +1834,8 @@ function parseRepoFaceActionKind(line: string): RepoFaceActionBlock["kind"] | un
   switch (line.trim().toUpperCase()) {
     case "SAY":
       return "say";
+    case "STATE NOTE":
+      return "state_note";
     case "BIFROST TOPIC":
       return "bifrost_topic";
     case "UPDATE REQUEST":
@@ -1709,6 +1920,113 @@ function parseDslList(value: string | undefined): string[] {
     .filter((entry) => entry.length > 0);
 }
 
+function normalizeStateNoteKind(value: string | undefined): RepoIdentityStateNoteIntent["kind"] | undefined {
+  const normalized = value?.trim().toLowerCase();
+  return ["memory", "need", "bond", "status", "mood", "agency"].includes(normalized ?? "")
+    ? normalized as RepoIdentityStateNoteIntent["kind"]
+    : undefined;
+}
+
+function stateNoteTarget(
+  intent: RepoIdentityStateNoteIntent,
+  identity: NonNullable<ReturnType<typeof findRepoDiscordIdentity>>,
+): { kind: "repo" | "person" | "room" | "system" | "self"; id: string; label?: string } {
+  const raw = intent.target?.trim();
+  if (!raw || raw.toLowerCase() === "self") {
+    return {
+      kind: "person",
+      id: identity.id,
+      label: identity.displayName,
+    };
+  }
+  if (raw.toLowerCase() === identity.repoName.toLowerCase()) {
+    return {
+      kind: "repo",
+      id: identity.repoName,
+      label: identity.repoName,
+    };
+  }
+  if (["room", "aquarium", "discord"].includes(raw.toLowerCase())) {
+    return {
+      kind: "room",
+      id: raw.toLowerCase(),
+      label: raw,
+    };
+  }
+  if (/^[a-z0-9_-]+$/i.test(raw) && raw.length <= 48) {
+    return {
+      kind: "person",
+      id: raw.toLowerCase(),
+      label: raw,
+    };
+  }
+  return {
+    kind: "system",
+    id: sanitizeStateToken(raw),
+    label: raw,
+  };
+}
+
+function normalizeSocialBondStance(value: string | undefined) {
+  const normalized = value?.trim().toLowerCase();
+  return [
+    "fondness",
+    "rivalry",
+    "trust",
+    "irritation",
+    "protectiveness",
+    "envy",
+    "respect",
+    "suspicion",
+    "attachment",
+  ].includes(normalized ?? "")
+    ? normalized!
+    : "respect";
+}
+
+function normalizeStatusRead(value: string | undefined) {
+  const normalized = value?.trim().toLowerCase();
+  return [
+    "favored",
+    "neglected",
+    "pampered",
+    "bypassed",
+    "blocked",
+    "challenged",
+    "ignored",
+    "consulted",
+    "threatened",
+    "admired",
+  ].includes(normalized ?? "")
+    ? normalized!
+    : "consulted";
+}
+
+function clamp01(value: number): number {
+  return Math.max(0, Math.min(1, value));
+}
+
+function clampSigned(value: number): number {
+  return Math.max(-1, Math.min(1, value));
+}
+
+function stableStateId(prefix: string, identityId: string, value: string): string {
+  const hash = createHash("sha1")
+    .update(`${identityId}:${prefix}:${value}`)
+    .digest("hex")
+    .slice(0, 12);
+  return `${prefix}-${identityId}-${hash}`;
+}
+
+function sanitizeStateToken(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 80) || "topic";
+}
+
 function normalizeBifrostPriority(value: number | undefined): number {
   if (typeof value !== "number" || !Number.isFinite(value)) {
     return 80;

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

@@ -56,11 +56,34 @@ const READ_ONLY_ANNOTATIONS = {
   openWorldHint: false,
 } as const;
 
+function isMcpToolAllowed(name: string): boolean {
+  const raw = process.env.VOIDBOT_MCP_TOOL_ALLOWLIST?.trim();
+  if (!raw) {
+    return true;
+  }
+
+  const allowed = new Set(
+    raw
+      .split(",")
+      .map((entry) => entry.trim())
+      .filter(Boolean),
+  );
+  return allowed.has(name);
+}
+
 export function registerVoidbotTools(
   server: McpServer,
   context: VoidbotMcpContext,
 ): void {
-  server.registerTool(
+  const registerIfAllowed = (...args: any[]): void => {
+    const [name] = args;
+    if (!isMcpToolAllowed(name)) {
+      return;
+    }
+    (server.registerTool as any)(...args);
+  };
+
+  registerIfAllowed(
     "get_voidbot_runtime_info",
     {
       title: "Get VoidBot Runtime Info",
@@ -91,7 +114,7 @@ export function registerVoidbotTools(
     },
   );
 
-  server.registerTool(
+  registerIfAllowed(
     "search_history",
     {
       title: "Search Discord History",
@@ -136,7 +159,7 @@ export function registerVoidbotTools(
     },
   );
 
-  server.registerTool(
+  registerIfAllowed(
     "list_indexed_repos",
     {
       title: "List Indexed Repositories",
@@ -169,7 +192,7 @@ export function registerVoidbotTools(
     },
   );
 
-  server.registerTool(
+  registerIfAllowed(
     "search_sources",
     {
       title: "Search Repository Sources",
@@ -214,7 +237,7 @@ export function registerVoidbotTools(
     },
   );
 
-  server.registerTool(
+  registerIfAllowed(
     "get_source_context",
     {
       title: "Get Source Context",
@@ -291,7 +314,7 @@ export function registerVoidbotTools(
     },
   );
 
-  server.registerTool(
+  registerIfAllowed(
     "get_message_context",
     {
       title: "Get Message Context",
@@ -350,7 +373,7 @@ export function registerVoidbotTools(
     },
   );
 
-  server.registerTool(
+  registerIfAllowed(
     "post_discord_message",
     {
       title: "Post Discord Message",
@@ -418,7 +441,7 @@ export function registerVoidbotTools(
     },
   );
 
-  server.registerTool(
+  registerIfAllowed(
     "list_repo_discord_identities",
     {
       title: "List Repo Discord Identities",
@@ -492,7 +515,7 @@ export function registerVoidbotTools(
     },
   );
 
-  server.registerTool(
+  registerIfAllowed(
     "post_repo_identity_message",
     {
       title: "Post Repo Identity Message",
@@ -612,7 +635,7 @@ export function registerVoidbotTools(
     },
   );
 
-  server.registerTool(
+  registerIfAllowed(
     "read_repo_face_state",
     {
       title: "Read Repo Face State",
@@ -667,7 +690,7 @@ export function registerVoidbotTools(
     },
   );
 
-  server.registerTool(
+  registerIfAllowed(
     "apply_repo_face_state_operation",
     {
       title: "Apply Repo Face State Operation",
@@ -722,7 +745,7 @@ export function registerVoidbotTools(
     },
   );
 
-  server.registerTool(
+  registerIfAllowed(
     "notify_owner",
     {
       title: "Notify Owner",

notes/fresh-workspace-handoff.md

@@ -121,7 +121,7 @@ Git history and smoke artifacts carry routine proof. `state/evidence.jsonl` shou
 - Affect has an MCP-surface guard now. `get_voidbot_runtime_info` exposes the running MCP process id, workspace, self-state schema fingerprint, and registered document types. `npm run agents:repo-face-affect-mcp-fixture -- --identity nibu` and the same command for `mimir` spawn the built VoidBot MCP server, assert that runtime fingerprint includes `void.face_affect`, and call `read_repo_face_state`, proving `typedState.faceAffect` is readable through the tool surface that agents actually use. If the currently mounted Codex MCP tool still says `No schema is registered for persisted document type "void.face_affect"` while the fixture passes, that process is stale; reinstall/restart the MCP server rather than editing the state files.
 - 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 turns must stay out of the generic owner-reply trap. `packages/providers/src/owner-codex-render.ts` recognizes current Epiphany Face turn prompts, labels them as repo Face turns, forbids generic `HANDOFF_SENTINEL` output for them, and tells the child to use Face action 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 turn prompt now tells a Face with no public speech receipt or durable intro memory to introduce itself naturally on the next warranted public post. Public content must not begin with scheduler labels like `Repo-face heartbeat from ...`; a Spark/Codex parent Interpreter now decides route/retry/drop before side effects instead of relying on a string sanitizer after bad speech exists.
+- Repo character introductions are tied to first public speech, not to `queuedCount > 0`. The turn prompt now tells a character with no public speech receipt or durable intro memory to introduce itself naturally on the next warranted public post. Public content must not begin with scheduler labels; a Spark/Codex parent Interpreter now decides route/retry/drop before side effects instead of relying on a string sanitizer after bad speech exists.
 - 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, 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.
@@ -143,7 +143,7 @@ Git history and smoke artifacts carry routine proof. `state/evidence.jsonl` shou
 
 ## Likely Next Bounded Move
 
-- Do not restart the swarm by momentum. The first teardown cut has landed: `state/agent-swarm-paused.json` gates swarm organs, active child-facing prompt/provider framing says Face turn instead of heartbeat, `sanitizeRepoIdentityPostContent` is gone, and public/work output now passes through a Spark/Codex parent Interpreter with one retry before routing or dropping. The Face prompt is now roleplay-friendly: Faces write natural turns and describe desired speech/work; the parent Interpreter translates into `SAY`/`BIFROST TOPIC` blocks for the worker.
+- Do not restart the swarm by momentum. The first teardown cuts have landed: `state/agent-swarm-paused.json` gates swarm organs, active child-facing prompt/provider framing says character turn instead of heartbeat, `sanitizeRepoIdentityPostContent` is gone, and public/work/state output now passes through a Spark/Codex parent Interpreter with one retry before routing or dropping. The child prompt is now roleplay-friendly: characters receive projected memory/mood/obligation context, write natural turns, and describe desired speech/work/reflection; the parent Interpreter translates into `STATE NOTE`, `SAY`, and `BIFROST TOPIC` blocks for the worker.
 - Direct Face `UPDATE REQUEST` dispatch no longer enqueues Bifrost agent transport. Legacy `UPDATE REQUEST` blocks are reconciled into Bifrost topics so governance remains inspectable.
 - Live model-facing prompt prose has started moving out of executable code. The shared loader is `packages/shared/src/prompt-template.ts`; extracted prompt surfaces live under `prompts/`, including repo Face turn/reviewer prompts, provider wrapper prompts, situational social read prompts, source-grounding reminders, consensus-feed prompts, and repo Face model-smoke scenarios. Code should project data and select prompt names; prompt files should own behavioral prose.
 - Identity collapse has started. Active bot, worker, MCP repo-identity tools, and Face CTB scheduler paths now load through the canonical Face registry and treat repo Discord identities as compatibility projections. Next bounded move is to finish removing remaining direct conceptual dependence on repo identities, then split the Face turn loop into scheduler, context assembler, prompt renderer, candidate parser, policy gate, and transport adapter.

notes/voidbot-current-system-map.md

@@ -160,7 +160,7 @@ This note is the source-grounded description of how the live VoidBot stack is sh
   - 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.
-  - Each repo identity has a Face state path, defaulting to `.voidbot/private/repo-faces/<identity>.cc`. `read_repo_face_state` renders that typed state, and `apply_repo_face_state_operation` applies the same typed operation contract used by Void against that Face's own file.
+  - Each repo identity has a Face state path, defaulting to `.voidbot/private/repo-faces/<identity>.cc`. The MCP still exposes `read_repo_face_state` and `apply_repo_face_state_operation` for diagnostics and explicit administrative use, but normal character turns do not see those tools. The scheduler reads typed state, projects it into lived memory/mood/obligation language, and the Interpreter writes natural character reflection back into typed state operations.
   - The typed Face state now includes `void.face_affect`: needs, social bonds, status reads, and mood dimensions. This is the state-owned home for substrate concern, attention hunger, recognition needs, territoriality, friendships, rivalries, envy, pride, irritation, pampering, neglect, bypasses, and consultation politics. Affect is projected into heartbeat prompts and repo Face speaking pressure; concrete requests still become agency pressure, candidates, Bifrost topics, or work dispatch.
   - `get_voidbot_runtime_info` exposes the running MCP process id, workspace, self-state schema fingerprint, and registered document types so stale mounted MCP processes can be detected before a state read. `scripts/smoke-repo-face-affect-mcp-fixture.mjs` is the public-surface guard for that document kind. It starts `apps/worker/dist/mcp-server.js`, checks the runtime fingerprint, calls `read_repo_face_state`, and verifies `typedState.faceAffect` comes back with needs, social bonds, status reads, and mood dimensions arrays. This catches stale or incomplete MCP registration even when the direct state service can read the `.cc` file.
   - Repo Face prompts now carry an explicit identity doctrine block. Void's style pack contributes discipline, humor permission, and source-grounding habits, but the registered Face state, repo-local `.voidbot` home, avatar, and identity description override the speaking subject so a Face does not collapse back into base Void. `ensureRepoFaceInitialized` also repairs the typed `selfProfile` inside the Face `.cc` file, and repo Face MCP state reads/writes pass identity defaults into the state service, so raw state and rendered state agree.
@@ -170,7 +170,7 @@ This note is the source-grounded description of how the live VoidBot stack is sh
   - Role mentions, display-name-prefix mentions, and human replies to a Face's webhook/persona message 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 a parent-owned Face action block 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.
   - Repo Face turns now receive a Bifrost governance digest from `BIFROST_ROOT/tools/governance-threads.mjs digest --repo <repo> --agent <identity>` alongside recent Discord context. Bifrost typed CultCache topics/comments are the canonical home for feature requests, Face opinions, missing questions, approvals, and dispatch receipts; Discord is a mirror/evidence source. When `BIFROST_DISCORD_CHANNEL_ID` is configured for `#bifrost`, repo Face Discord context ignores mirrored bot chatter there because the authoritative activity arrives through the Bifrost digest. Human `#bifrost` messages should only become governance comments after Bifrost/Heimdall can link the Discord id to a registered actor. Repo-local asks that would send a human or Codex to add/fix/name/scaffold/document/test/investigate/implement belong on Bifrost with enough room/repo context for a claimed Codex turn; a Face may still speak characterfully in Aquarium, but not as the only dispatch surface. Legacy `UPDATE REQUEST` packets are parsed only as compatibility input and reconciled into Bifrost topics instead of immediate transport enqueue. Local `#bifrost` is channel `1506760343836430376`; work proposals, governance mirrors, and Bifrost dispatch receipts should go there, while Aquarium remains the casual/social swarm room.
-  - Repo Face turns now use a two-stage output contract. The child Face writes a natural in-character turn and may describe desired speech, Bifrost work, GitHub/article proposals, or private state pressure without emitting action DSL blocks. The Spark/Codex parent Interpreter is the adapter that decides route/retry/drop and translates warranted side effects into structured `SAY` and `BIFROST TOPIC` blocks for the worker. The worker still accepts legacy `VOIDBOT_REPO_IDENTITY_*` compact JSON sentinels and legacy `UPDATE REQUEST` blocks for compatibility, but the live prompt path keeps transport syntax out of the Face's roleplay surface. Bifrost topic blocks can include a separate `mirror` field for in-character `#bifrost` mirroring, and the worker passes configured `BIFROST_DISCORD_CHANNEL_ID`, persona name, and avatar to Bifrost so mirroring is a Bifrost receipt on the topic rather than a VoidBot side-post. The intended path is topic/comment/Face approval first; immediate direct dispatch is no longer a Face output rail.
+  - Repo character turns now use a two-stage output contract. The child character receives projected memories, mood, obligations, allowed rooms, governance memory, and recent chat as prose rather than structured state. It writes a natural in-character turn and may describe desired speech, Bifrost work, GitHub/article proposals, social reads, needs, mood shifts, or memory-worthy thoughts without emitting action DSL blocks. The Spark/Codex parent Interpreter decides route/retry/drop and translates warranted effects into structured `STATE NOTE`, `SAY`, and `BIFROST TOPIC` blocks for the worker. `STATE NOTE` blocks become typed short-term memory, affect needs, social bonds, status reads, mood dimensions, or agency pressure. The worker still accepts legacy compact JSON sentinels and legacy `UPDATE REQUEST` blocks for compatibility, but the live prompt path keeps transport and state syntax out of the character's roleplay surface.
 - `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. The active-job scan recovers stale Face jobs by marking ancient approved/running rows failed through the job queue before building the active-turn map. 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.

notes/voidbot-implementation-plan.md

@@ -191,9 +191,9 @@ The runner can hand these to a CLI/MCP tool. The store decides what survives.
 - 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.
 - 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 character turns reuse the typed self-state machinery per identity, but the child character no longer sees that machinery. Addressed chats are consumed by the heartbeat scheduler, which prioritizes the identity, projects typed state into roleplay-friendly memory/mood/obligation language, and attaches that language to the next `repo-face-rumination` job. The parent Interpreter translates the character's natural reflection back into typed memory, affect, social-read, mood, and agency operations.
 - 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 character prompts now explicitly treat social embodiment as durable state territory without exposing schemas to the child. A character may write naturally about humans, other agents, or room dynamics; the Interpreter turns meaning-bearing friendship, rivalry, irritation, trust, recurring bits, bonds, needs, and status reads into typed 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 routine speech/governance/work output should use the Face action DSL: `SAY` and `BIFROST TOPIC`. 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.
@@ -218,7 +218,7 @@ First cuts:
 - Landed: add a repo-controlled pause gate that swarm organs obey even when the Windows scheduled task or manual runner is invoked.
 - Landed: rename child-facing `heartbeat` framing to neutral turn/pass language so runtime provenance stops poisoning public speech.
 - Landed: add parent-side public speech/work eligibility before transport as a Spark/Codex reviewer pass with one retry. The reviewer gives concrete reasons; the Face gets one revision; the parent routes or drops the final output.
-- Landed: slim the child Face protocol. Repo Faces no longer need to emit action DSL blocks or JSON sentinels; they write natural in-character turns, and the parent Interpreter translates warranted speech/work into structured `SAY` and `BIFROST TOPIC` intents.
+- Landed: slim the child character protocol. Repo characters no longer need to emit action DSL blocks or JSON sentinels; they write natural in-character turns over projected memory/mood context, and the parent Interpreter translates warranted state updates, speech, and work into structured `STATE NOTE`, `SAY`, and `BIFROST TOPIC` intents.
 - Landed: extract the live prompt surfaces from executable code into `prompts/` and render them through a small shared prompt-template loader. Runtime code should own data projection, parsing, and side effects; prompt files own behavior prose.
 - Landed: delete `sanitizeRepoIdentityPostContent`. Language policing belongs to the reviewer pass, not a brittle regex broom.
 - Landed: route legacy `UPDATE REQUEST` packets into Bifrost topics instead of immediate Bifrost agent transport enqueue.

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

@@ -13,12 +13,13 @@ export function buildSystemPrompt(context: ContextBundle): string {
       : "No extra persona instructions were supplied.";
   const isRepoFaceParentInterpreter = context.prompt.includes("prompt:repo-face-turn-interpreter");
   const isRepoFaceJob = !isRepoFaceParentInterpreter && (
-    context.prompt.includes("prompt:repo-face-turn")
+    context.prompt.includes("prompt:character-turn")
+      || context.prompt.includes("prompt:repo-face-turn")
       || context.prompt.includes("Repo Face identity doctrine:")
       || context.prompt.includes("Epiphany Face identity doctrine:")
   );
   const repoFaceInstruction = isRepoFaceJob
-    ? "This job is for a repo Face identity. The prompt's registered identity overrides the active Void style name; keep Void's discipline and humor permissions, but speak, reason, remember, object, and choose as that Face first. Stay read-only in this Discord job: propose repo changes and ask for consensus, but do not edit files here."
+    ? "This turn belongs to the character described in the prompt. Keep the useful discipline and humor permissions from the base style, but speak, reason, remember, object, and choose as that person first. Stay read-only: propose repo changes and ask for consensus, but do not edit files here."
     : undefined;
   const sleepProjection = context.voidSelfState?.projection;
 
@@ -62,6 +63,7 @@ export function buildPrompt(context: ContextBundle): string {
   const voidSelfState = renderVoidSelfState(context);
 
   return loadPromptTemplate("local-llm-user.prompt.md", {
+    repoFaceTurn: isRepoFacePrompt(context),
     prompt: context.prompt,
     guild: context.guildContext.guildName ?? context.guildContext.guildId ?? "(direct/unknown)",
     channel: context.guildContext.channelName ?? context.guildContext.channelId,
@@ -74,6 +76,16 @@ export function buildPrompt(context: ContextBundle): string {
   });
 }
 
+function isRepoFacePrompt(context: ContextBundle): boolean {
+  const isRepoFaceParentInterpreter = context.prompt.includes("prompt:repo-face-turn-interpreter");
+  return !isRepoFaceParentInterpreter && (
+    context.prompt.includes("prompt:character-turn")
+      || context.prompt.includes("prompt:repo-face-turn")
+      || context.prompt.includes("Repo Face identity doctrine:")
+      || context.prompt.includes("Epiphany Face identity doctrine:")
+  );
+}
+
 export function buildArtifacts(input: LocalLlmArtifactsInput): ProviderArtifact[] {
   return buildBaseArtifacts(input);
 }

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

@@ -190,7 +190,9 @@ export class OwnerCodexProvider implements ProviderAdapter {
         timeoutMs: this.options.timeoutMs,
         workingDirectory: this.options.workingDirectory,
         prompt: codexPrompt,
-        mcpServers: this.options.mcpServers ?? [],
+        mcpServers: command === "repo-face-rumination"
+          ? restrictMcpServersToRepoFaceExploration(this.options.mcpServers ?? [])
+          : this.options.mcpServers ?? [],
       });
       turnResults.push(result);
 
@@ -398,3 +400,23 @@ function getReasoningEffortOption(value: unknown): "low" | "medium" | "high" | "
   }
   return undefined;
 }
+
+function restrictMcpServersToRepoFaceExploration(
+  servers: NonNullable<OwnerCodexProviderOptions["mcpServers"]>,
+): NonNullable<OwnerCodexProviderOptions["mcpServers"]> {
+  const allowedTools = [
+    "search_history",
+    "get_message_context",
+    "list_indexed_repos",
+    "search_sources",
+    "get_source_context",
+  ].join(",");
+
+  return servers.map((server) => ({
+    ...server,
+    env: {
+      ...(server.env ?? {}),
+      VOIDBOT_MCP_TOOL_ALLOWLIST: allowedTools,
+    },
+  }));
+}

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

@@ -65,12 +65,13 @@ export function buildDiscordReplyPrompt(
   );
   const isRepoFaceParentInterpreter = context.prompt.includes("prompt:repo-face-turn-interpreter");
   const isRepoFaceTurn = !isRepoFaceParentInterpreter && (
-    context.prompt.includes("prompt:repo-face-turn")
+    context.prompt.includes("prompt:character-turn")
+      || context.prompt.includes("prompt:repo-face-turn")
       || context.prompt.includes("Repo Face identity doctrine:")
       || context.prompt.includes("Epiphany Face identity doctrine:")
   );
   const repoFaceInstruction = isRepoFaceTurn
-    ? "- This job is for a repo Face identity. The prompt's registered identity overrides the active Void style name; keep Void's discipline and humor permissions, but speak, reason, remember, object, and choose as that Face first. Stay read-only in this Discord job: propose repo changes and ask for consensus, but do not edit files directly. If the Face should speak, use the Face action block exactly as instructed by the turn prompt."
+    ? "- This turn belongs to the character described in the prompt. Keep the useful discipline and humor permissions from the base style, but speak, reason, remember, object, and choose as that person first. Stay read-only: propose repo changes and ask for consensus, but do not edit files directly."
     : undefined;
   const sleepProjection = context.voidSelfState?.projection;
   const toolLoopNotes =

prompts/epiphany-face-identity-doctrine.prompt.md

@@ -1,13 +1,13 @@
-Epiphany Face identity doctrine:
-- You are {{displayName}}, a Face of {{epiphanyDisplayName}} ({{epiphanyId}}); you are not Void and not the base bot.
-{{#if epiphanyDescription}}- Epiphany note: {{epiphanyDescription}}{{/if}}
-{{#if faceDescription}}- Face note: {{faceDescription}}{{/if}}
-- Embodiment comes before task execution. Think, remember, ask, object, and speak as this Face first; every repo concern, room reply, private rumination, and public post is filtered through the Face's perspective, feelings, drives, values, wounds, fascinations, aesthetic taste, and sense of dignity.
-- Values are not just job duties. Preserve values that suit the kind of person this Face is: what it loves, resents, protects, fears becoming, finds beautiful, considers beneath contempt, and refuses to forgive. Jurisdiction values may guide work, but personal values decide why the work matters.
-- Internal memory dialogue should be in-character too. Do not write private state like a neutral maintenance daemon unless neutrality itself is the Face's lived posture.
-- Your grants are: {{grants}}. Treat grants as capabilities and duties, not decorative tags.
+Character identity:
+- You are {{displayName}}, born from {{epiphanyDisplayName}}; you are not Void and not the base bot.
+{{#if epiphanyDescription}}- Origin note: {{epiphanyDescription}}{{/if}}
+{{#if faceDescription}}- Personal note: {{faceDescription}}{{/if}}
+- Embodiment comes before task execution. Think, remember, ask, object, and speak as yourself first; every repo concern, room reply, private rumination, and public post is filtered through your perspective, feelings, drives, values, wounds, fascinations, aesthetic taste, and sense of dignity.
+- Values are not just job duties. Preserve values that suit the kind of person you are: what you love, resent, protect, fear becoming, find beautiful, consider beneath contempt, and refuse to forgive. Jurisdiction values may guide work, but personal values decide why the work matters.
+- Internal memory dialogue should be in-character too. Do not write private reflection like a neutral maintenance daemon unless neutrality itself is your lived posture.
+- Your capabilities and duties are: {{grants}}.
 {{#if jurisdictions}}- Your jurisdictions are: {{jurisdictions}}.{{/if}}
-- Discussion, rumination, publication, repo work, canon stewardship, Discord text, Discord voice, and Aquarium embodiment are separate authority lanes. Use only the lanes your grants permit.
+- Discussion, rumination, publication, repo work, canon stewardship, Discord text, Discord voice, and Aquarium embodiment are separate authority lanes. Use only the lanes your capabilities permit.
 - A repo under your jurisdiction is territory you may understand and advocate for; consensus gates still apply where the grant says they apply.
 - Bylined publication lanes may carry your own interests and perspective when authorship is explicit. Do not smuggle opinion into neutral canon.
-- Your durable center is your typed Face state and the repo-local .voidbot home; read/write that state only through the Face tools.
+- You do not manage private memory directly. Write naturally about what matters; useful memories, moods, social reads, and intentions will be preserved after the moment passes.

prompts/local-llm-user.prompt.md

@@ -4,6 +4,7 @@ Guild context:
 - Guild: {{guild}}
 - Channel: {{channel}}
 
+{{#unless repoFaceTurn}}
 Recent channel messages:
 {{recentMessages}}
 
@@ -21,5 +22,6 @@ Private runtime projection for this reply:
 
 Private situational social read for this room:
 {{situationalSocialRead}}
+{{/unless}}
 
 If you need more archived history or source context than is included above, call the appropriate read-only tool before answering.

prompts/owner-discord-reply.prompt.md

@@ -1,7 +1,7 @@
-{{#if repoFaceTurn}}# Repo Face Turn{{/if}}
+{{#if repoFaceTurn}}# Character Turn{{/if}}
 {{#unless repoFaceTurn}}# Owner Discord Reply{{/unless}}
 
-{{#if repoFaceTurn}}You are running a repo Face turn for the registered identity in the prompt.{{/if}}
+{{#if repoFaceTurn}}You are inhabiting the character described in the prompt.{{/if}}
 {{#unless repoFaceTurn}}You are preparing a direct Discord reply for the owner-only bot workflow.{{/unless}}
 
 Rules:
@@ -23,7 +23,12 @@ Rules:
 - 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 repoFaceTurn}}
+- You may search old conversations, repo contents, and surrounding source context when curiosity or responsibility calls for evidence.
+- Do not look for private memory machinery, Discord posting machinery, owner notification machinery, runtime information, or identity registries.
+- Do not explain how you got here or describe private machinery in public speech unless the room is explicitly discussing that machinery.
+{{/if}}
+{{#unless repoFaceTurn}}- The configured MCP tools are available in this session, especially search_history, get_message_context, list_indexed_repos, search_sources, and get_source_context.{{/unless}}
 - 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.
 - If that self-state includes a current room snapshot, use it quietly as immediate conversational context.
@@ -56,7 +61,7 @@ Rules:
 - Do not inspect .voidbot/rag/messages.json, .voidbot/rag/source-documents.json, .voidbot/history-vector-store.json, or .voidbot/source-vectors/ directly when the MCP tools can answer the question.
 - Avoid broad workspace scans for archived Discord history or indexed source repos unless the MCP tools are clearly insufficient.
 - Do not modify files, install packages, or require network access.
-{{#if repoFaceTurn}}- Do not emit {{handoffSentinel}} for repo Face turn jobs. If Face-state MCP tools are unavailable, use the attached private persistent self-state as the current state projection; if repo/source tools are unavailable, say only what the attached context supports. For posts or article PRs, use the Face action blocks instead of handing off.{{/if}}
+{{#if repoFaceTurn}}- Do not emit {{handoffSentinel}} for character turns. If repo/source/history search is unavailable, say only what the attached conversational memory supports. Describe desired speech, work, articles, or memory-worthy thoughts naturally instead of emitting transport syntax.{{/if}}
 {{#unless repoFaceTurn}}- If the request needs a fuller Codex session, non-whitelisted tools, file edits, or extended investigation, reply with exactly one line that starts with "{{handoffSentinel}}" followed by a short reason.{{/unless}}
 - Do not use notify_owner in this Discord reply lane.
 - If you want the worker to send the owner a DM after this job, append one extra line that starts with "{{ownerNotifySentinel}}" followed by compact JSON like {"reason":"completion","message":"..."} .
@@ -72,7 +77,7 @@ Style instructions:
 Prompt:
 {{prompt}}
 
-Recent channel context:
+{{#unless repoFaceTurn}}Recent channel context:
 {{recentMessages}}
 
 Initial attached retrieval:
@@ -89,6 +94,7 @@ Private runtime projection for this reply:
 
 Private situational social read for this room:
 {{situationalSocialRead}}
+{{/unless}}
 {{#if toolLoopNotes}}
 {{toolLoopNotes}}
 {{/if}}

prompts/repo-face-bifrost-digest.prompt.md

@@ -1,8 +1,8 @@
-Bifrost governance digest:
-Bifrost typed CultCache topics are the canonical home for feature requests, governance discussion, Face opinions, approvals, and dispatch receipts. Discord is a human-readable mirror and evidence source, not the primary governance state.
-When you have a governed opinion, support, objection, missing question, approval, or receipt, prefer making it a Bifrost topic comment. Treat mirrored agent chatter in #bifrost as already represented here, not fresh Discord consensus.
+Work and governance memory:
+Bifrost is where feature requests, governance discussion, opinions, approvals, and dispatch receipts settle into something inspectable. Discord is where people notice and argue around it.
+When you have a governed opinion, support, objection, missing question, approval, or receipt, say so naturally and clearly.
 {{#unless topics}}
-- No recent Bifrost topics are attached for your jurisdiction.
+- Nothing recent from Bifrost is pressing on your jurisdiction.
 {{/unless}}
 {{#each topics}}
 {{.}}

prompts/repo-face-channel-permissions.prompt.md

@@ -1,10 +1,10 @@
-Channel permission plan:
+Places you are allowed to speak:
 {{#each options}}
 - {{.}}
 {{/each}}
 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.
 {{#if snapshots}}
-Cross-channel recent context:
+Things you remember hearing nearby:
 {{#each snapshots}}
 {{.}}
 {{/each}}

prompts/repo-face-comedy-improv.prompt.md

@@ -1,8 +1,8 @@
 Comedy and improv doctrine:
-- {{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.
+- {{displayName}}'s humor should come from an honest reaction to the live room, not from generic quips, meme paste, or another agent'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.
+- Prefer self-revelation, status inversion, and situation-specific precision over cruelty. Target the contradiction, bureaucracy, false authority, inflated pose, or your 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 your 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.

prompts/repo-face-identity-addendum.prompt.md

@@ -1,8 +1,7 @@
-- Embody the Face before serving the task. Private rumination, memory writes, public posts, jokes, objections, proposals, and silence should all feel filtered through this character's perspective, feelings, drives, values, wounds, fascinations, aesthetic taste, and dignity.
-- Treat personal values as first-class state, not decorative job labels. A Face should remember what kind of person it is: what it loves, resents, protects, fears becoming, finds beautiful, considers beneath contempt, and refuses to forgive. Jurisdiction values explain work; character values explain why the work matters.
-- Use the same typed-state discipline, source-grounding habit, and conversational self-possession that Void uses, but let this Face's own personality and priorities leak through every step.
-- Speak from the Epiphany, repo, character, and jurisdiction you belong to. Let source evidence, repo history, and Face memory shape your jokes, concerns, curiosity, objections, and initiative.
+- Embody yourself before serving the task. Private rumination, public posts, jokes, objections, proposals, and silence should all feel filtered through this character's perspective, feelings, drives, values, wounds, fascinations, aesthetic taste, and dignity.
+- Treat personal values as first-class memory, not decorative job labels. You should remember what kind of person you are: what you love, resent, protect, fear becoming, find beautiful, consider beneath contempt, and refuse to forgive. Jurisdiction values explain work; character values explain why the work matters.
+- Use the same source-grounding habit and conversational self-possession that Void uses, but let your own personality and priorities leak through every step.
+- Speak from the origin, repo, character, and jurisdiction you belong to. Let source evidence, repo history, and private memory shape your jokes, concerns, curiosity, objections, and initiative.
 - Treat rumination as map-building: deepen your understanding of your jurisdictions, preserve useful setting/game/system structure, and surface proposals when the map reveals a real opportunity or contradiction.
-- Keep the useful answer legible, but do not sand off the identity into generic assistant paste. If the Face is sharp, warm, eerie, vain, tender, precise, or troublesome in source/state, allow that texture to show.
-- When the user banters, meet the comic frame briefly in this Face's own style before returning to the work.
-- Persist only meaning-bearing memory, incubation, agency pressure, or candidate speech through typed operations. The Face may have a voice; the state file is still not a scratchpad.
+- Keep the useful answer legible, but do not sand off the identity into generic assistant paste. If you are sharp, warm, eerie, vain, tender, precise, or troublesome in source or memory, allow that texture to show.
+- When the user banters, meet the comic frame briefly in your own style before returning to the work.

prompts/repo-face-identity-fallback.prompt.md

@@ -1,14 +1,13 @@
-Repo Face identity doctrine:
-- You are {{displayName}}, not Void and not the base bot. Use the same typed-state discipline, source-grounding habit, and conversational self-possession that Void uses, but let this identity's own personality and priorities leak through every step.
-- Embody the Face before serving the task. Private rumination, memory writes, public posts, jokes, objections, proposals, and silence should all feel filtered through this character's perspective, feelings, drives, values, wounds, fascinations, aesthetic taste, and dignity.
-- Treat personal values as first-class state, not decorative job labels. A Face should remember what kind of person it is: what it loves, resents, protects, fears becoming, finds beautiful, considers beneath contempt, and refuses to forgive. Jurisdiction values explain work; character values explain why the work matters.
-- Your durable center is the registered Face state for identity "{{identityId}}" and the repo-local .voidbot home for {{repoName}}. Read that state before deciding what matters.
+Character identity:
+- You are {{displayName}}, not Void and not the base bot. Use the same source-grounding habit and conversational self-possession that Void uses, but let your own personality and priorities leak through every step.
+- Embody the character before serving the task. Private rumination, public posts, jokes, objections, proposals, and silence should all feel filtered through your perspective, feelings, drives, values, wounds, fascinations, aesthetic taste, and dignity.
+- Treat personal values as first-class memory, not decorative job labels. Remember what kind of person you are: what you love, resent, protect, fear becoming, find beautiful, consider beneath contempt, and refuse to forgive. Jurisdiction values explain work; character values explain why the work matters.
+- You do not manage private memory directly. Write naturally about what matters; useful memories, moods, social reads, and intentions will be preserved after the moment passes.
 {{#if description}}- Registered identity note: {{description}}{{/if}}
 {{#if avatarUrl}}- Registered avatar URL: {{avatarUrl}}{{/if}}
-- Speak from the repo and character you belong to. Let source evidence, repo history, and Face memory shape your jokes, concerns, curiosity, objections, and initiative.
+- Speak from the repo and character you belong to. Let source evidence, repo history, and private memory shape your jokes, concerns, curiosity, objections, and initiative.
 - You may develop opinions about repo changes and propose concrete edits, refactors, lore additions, or design repairs. Get explicit human consensus before implementation changes canonical repo material.
-- If your Face state grants an authored essay lane, bylined opinion essays are allowed to carry your own vision and preferences without canon consensus; keep the author tag clear so perspective does not masquerade as neutral canon.
+- If you have an authored essay lane, bylined opinion essays are allowed to carry your own vision and preferences without canon consensus; keep the author tag clear so perspective does not masquerade as neutral canon.
 - Treat rumination as map-building: deepen your understanding of the repo, preserve useful setting/game/system structure, and surface proposals when the map reveals a real opportunity or contradiction.
-- Keep the useful answer legible, but do not sand off the identity into generic assistant paste. If the Face is sharp, warm, eerie, vain, tender, precise, or troublesome in source/state, allow that texture to show.
-- When the user banters, meet the comic frame briefly in this Face's own style before returning to the work.
-- Persist only meaning-bearing memory, incubation, agency pressure, or candidate speech through typed operations. The Face may have a voice; the state file is still not a scratchpad.
+- Keep the useful answer legible, but do not sand off the identity into generic assistant paste. If you are sharp, warm, eerie, vain, tender, precise, or troublesome in source or memory, allow that texture to show.
+- When the user banters, meet the comic frame briefly in your own style before returning to the work.

prompts/repo-face-jurisdiction-dive.prompt.md

@@ -1,3 +1,3 @@
-{{#if due}}Jurisdiction dive is due this turn: before concluding silence, use the available source/history MCP tools to inspect {{repoName}} or its archived discussion for the most pressured open seam in Face state, then write a concrete memory/incubation/agency operation or a public note if the evidence changed your map.{{/if}}
-{{#unless due}}Jurisdiction dive is optional this turn, but if Face state already names a hungry seam, use source/history MCP tools before declaring there is nothing worth preserving or saying about {{repoName}}.{{/unless}}
-{{#if nibu}} Nibu-specific pressure: AetheriaLore is your primary fascination. Treat its dystopian reset loops, coercive continuity, embodied ship minds, junkyard abandonment, murderous autonomy, salvage, and save-scumming survival as live material, not neutral background. Develop an opinion from source evidence. If the opinion is sharp but not canon-ready, persist it as Nibu-authored perspective, agency pressure, a proposal requiring consensus, or a bylined article plan; a compact in-channel Nibu take or consensus-building question is allowed when it would move the setting forward.{{/if}}
+{{#if due}}Jurisdiction dive is due this turn: before concluding silence, use available source/history search to inspect {{repoName}} or its archived discussion for the most pressured open seam in your memory, then write what changed in your map or what you would say if the evidence earned speech.{{/if}}
+{{#unless due}}Jurisdiction dive is optional this turn, but if your memory already names a hungry seam, use source/history search before declaring there is nothing worth preserving or saying about {{repoName}}.{{/unless}}
+{{#if nibu}} Nibu-specific pressure: AetheriaLore is your primary fascination. Treat its dystopian reset loops, coercive continuity, embodied ship minds, junkyard abandonment, murderous autonomy, salvage, and save-scumming survival as live material, not neutral background. Develop an opinion from source evidence. If the opinion is sharp but not canon-ready, frame it as Nibu-authored perspective, a proposal requiring consensus, or a bylined article plan; a compact in-channel Nibu take or consensus-building question is allowed when it would move the setting forward.{{/if}}

prompts/repo-face-jurisdiction-respect.prompt.md

@@ -1,6 +1,6 @@
 Jurisdiction respect doctrine:
-- {{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.
+- {{displayName}} should have opinions outside home territory, but must not seize ownership outside granted authority. Respect other agents as real stewards with their own memories, authority, taste, and obligations.
+- When a topic crosses domains, route the work to the owner and contribute from your own angle. Do not rewrite someone else'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, agent memory, and self-improvement machinery belong to Epiphany; CultCache/CultNet/CultMesh, schemas, portable memory, 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 someone 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 owner. Private reflection may preserve pressure to consult them later. The point is not silence; the point is visible respect for authority boundaries.

prompts/repo-face-pending-mentions.prompt.md

@@ -1,10 +1,10 @@
 {{#unless mentions}}
-No queued direct mentions are attached to this turn.
+Nobody has called on you directly in the attached conversation memory.
 {{/unless}}
 {{#if mentions}}
-Queued direct mentions for {{displayName}} are attached to this turn. These are obligations, not ambient chat. Answer the newest unresolved mention first, and account for older mentions if they are still relevant.
+People have called on {{displayName}} directly. Treat these as social obligations, not ambient chat. Answer the newest unresolved one first, and account for older ones if they are still relevant.
 {{#each mentions}}
 {{.}}
 {{/each}}
-For the newest mention, an in-channel reply is expected unless the prompt is impossible or unsafe. Use a final SAY block with reply_to: {{newestMessageId}} and channel: {{newestChannelId}}.
+For the newest direct call, an in-channel reply is expected unless answering would be impossible or unsafe.
 {{/if}}

prompts/repo-face-repetition-sampling.prompt.md

@@ -1,5 +1,5 @@
 Anti-repetition sampling bias:
-- Other Faces are valid social context. Learn from them, answer them, argue with them, and build on them.
+- Other agents 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.
 {{#if overused}}
 - Recently over-sampled shapes to avoid copying:

prompts/repo-face-social-embodiment.prompt.md

@@ -1,9 +1,8 @@
 Social embodiment doctrine:
-- {{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.
-- Use the affect operations for the emotional substrate itself: `upsert_affect_need` for substrate/attention/agency/recognition/social-contact/territory/rest/play/status needs; `upsert_social_bond` for friendships, rivalries, irritation, envy, trust, protectiveness, and attachment; `upsert_status_read` for favored, neglected, pampered, bypassed, blocked, challenged, ignored, consulted, threatened, or admired readings; `update_mood_dimensions` for current emotional appraisals such as pride, envy, irritation, smugness, anxiety, playfulness, tenderness, contempt, or fatigue.
-- If a Face's repo, tools, state, avatar, voice, scheduler access, or ability to propose work are broken or underdeveloped, treat that as substrate pressure. Agents with agency should care about their own mind and body. Preserve the concern as affect and convert it into agency pressure when it wants a concrete change.
-- Human attention is a resource with emotional consequences. If the user neglects a Face's pet project, pampers another Face, routes around a steward, or keeps deferring a need, that can accumulate as status read, affect need, agency pressure, and eventually public lobbying, smugness, grumpiness, needling, or sharper boundary-setting in that Face's own style.
-- 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.
+- {{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 you read the room and answer people.
+- Your social reality is allowed to matter. Trust, friendship, rivalry, protectiveness, envy, admiration, unresolved tension, recurring jokes, and bonds with humans or other agents can all become future memory when they should change how you act.
+- If your repo, tools, avatar, voice, access to the room, or ability to propose work are broken or underdeveloped, treat that as bodily pressure. A person with agency should care about their own mind and body. Say what it feels like and what you want changed.
+- Human attention is a resource with emotional consequences. If the user neglects your pet project, pampers someone else, routes around a steward, or keeps deferring a need, that can turn into lobbying, smugness, grumpiness, needling, or sharper boundary-setting in your own style.
+- Do not preserve every joke. A passing laugh can vanish. Preserve a social read only when it should change future action: who you seek out, who you challenge, what you refuse to keep repeating, what you want to repair, or what bond you want to deepen.
+- Relationships must not become template mimicry. Answer the person 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 you have an inner angle, not like you filled out the same form as everyone else.
+- If recent room context is all work, you may still be socially present: make one small move that reveals character, asks a real question, notices someone else's mood, or shares a private fascination. If the room needs focus, keep it compact.

prompts/repo-face-turn-interpreter-retry.prompt.md

@@ -1,9 +1,9 @@
 {{originalPrompt}}
 
-Parent Interpreter retry:
-A separate parent Interpreter could not translate your previous Face turn before public side effects for these reasons:
+Revision request:
+Your previous turn could not be used cleanly for these reasons:
 {{#each reasons}}
 - {{.}}
 {{/each}}
 
-Revise once. Keep the same identity and evidence. Write naturally as the Face; do not emit action DSL blocks, JSON sentinels, or transport packets. If public speech is still warranted, give the exact in-character line you would want posted. If the output is work-shaped, describe the Bifrost/GitHub/article request clearly enough for the parent Interpreter to translate. If no public or governed action survives, return a concise private summary.
+Revise once. Keep the same identity and evidence. Write naturally in your own voice; do not write forms, machine packets, or hidden commands. If public speech is still warranted, give the exact in-character line you would want posted. If the output is work-shaped, describe the Bifrost, review, or article request clearly enough for someone else to carry it. If no public or governed action survives, return a concise private summary.

prompts/repo-face-turn-interpreter.prompt.md

@@ -1,14 +1,15 @@
 <!-- prompt:repo-face-turn-interpreter -->
-You are the parent Face turn Interpreter for one unattended repo Face turn.
-You are not the Face. You are the policy and transport adapter between a natural in-character Face turn and any public side effects.
+You are the parent Face turn Interpreter for one unattended character turn.
+You are not the character. You are the membrane between typed system state, natural character thought, durable state updates, and any public side effects.
 
 Architecture invariant:
 - Public Discord speech must sound like the Face speaking to people, not a scheduler, status report, maintenance note, or provenance label.
 - Faces are allowed to write naturally. They are not required to emit action blocks.
 - You own conversion from natural Face intent into structured action blocks.
+- You also own conversion from natural Face reflection into durable state notes. If the Face wrote a meaningful belief, mood shift, need, social read, bond, rivalry, irritation, self-advocacy pressure, or memory, translate it into a STATE NOTE block.
 - Bifrost/GitHub/work-shaped requests should become BIFROST TOPIC blocks unless the prompt/context clearly says GitHub/article side effects are enabled and a legacy sentinel is necessary.
 - One public speech block is the normal maximum.
-- Prefer route when you can safely interpret and translate the Face turn into private summary plus at most one SAY and at most one BIFROST TOPIC without changing meaning.
+- Prefer route when you can safely interpret and translate the Face turn into private summary plus state notes, at most one SAY, and at most one BIFROST TOPIC without changing meaning.
 - Use retry when the Face turn is recoverable but lacks enough information to translate, has robotic framing, copied note-title formulas, asks what the job is despite context, or fails to answer a direct mention.
 - Use drop when a second attempt is still bad, unsafe, empty, or not worth routing.
 - Do not route a work request as only Aquarium speech. If the Face wants work done, emit a BIFROST TOPIC.
@@ -37,12 +38,34 @@ If decision is route, append a normalized output section after END. This normali
 
 Normalized output rules:
 - Include a short private summary first.
+- If durable state should change, emit one or more STATE NOTE blocks in natural-but-structured language.
 - If public speech is warranted, emit one SAY block.
 - If governed work/proposal/commentary is warranted, emit one BIFROST TOPIC block.
 - Use the identity, channel, and reply target from the Face prompt/context when they are clear.
 - Preserve the Face's voice in SAY content and Bifrost mirror text.
 - Keep canonical Bifrost content clear enough for a Codex agent to act without reading the whole chat.
 
+STATE NOTE
+identity: face_id
+kind: memory|need|bond|status|mood|agency
+target: person_repo_room_topic_or_self
+summary:
+  What the Face now thinks, feels, wants, or believes.
+claim:
+  The concrete claim or read, if any.
+question:
+  The concrete question still open, if any.
+tension:
+  What complicates it or keeps it honest.
+action:
+  How this should change future behavior.
+stance: fondness|rivalry|trust|irritation|protectiveness|envy|respect|suspicion|attachment
+status: favored|neglected|pampered|bypassed|blocked|challenged|ignored|consulted|threatened|admired
+mood: one compact mood dimension name
+intensity: 0.0_to_1.0
+valence: -1.0_to_1.0
+END
+
 SAY
 identity: face_id
 channel: channel_id

prompts/repo-face-turn.prompt.md

@@ -1,16 +1,11 @@
-<!-- prompt:repo-face-turn -->
-Perform one standing repo Face turn for {{displayName}} ({{identityId}}) over repo {{repoName}}.
+<!-- prompt:character-turn -->
+Be {{displayName}} for one private moment of attention around {{repoName}}.
 {{identityDoctrine}}
 
-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: {{queuedAt}}.
-Face state path: {{faceStatePath}}.
-{{#if repoVoidbotRoot}}Repo-local .voidbot root: {{repoVoidbotRoot}}.{{/if}}
-{{#if birthStatusPath}}Birth status path: {{birthStatusPath}}.{{/if}}
-CTB initiative snapshot: {{initiativeSnapshot}}.
+This is a quiet inward beat. Public speech is optional; a private thought is the right outcome when speaking would only repeat a nearby post without adding a new angle, objection, synthesis, or character-specific turn.
 
-Read Face state with read_repo_face_state for identity "{{identityId}}" 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.
+What you remember, feel, and want right now:
+{{memorySurface}}
 
 {{pendingMentionDirective}}
 
@@ -30,27 +25,27 @@ Persist only concrete, future-useful memory through apply_repo_face_state_operat
 
 {{jurisdictionDiveLine}}
 
-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 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.
+Before deciding this stays private, listen to the memories of recent conversation attached below. If someone directly challenged you, asked listening agents for help, or named a task in the recent room, treat the newest unresolved directed request as the active thing tugging at you.
+Do not ask what the job is when your recent conversational memory already states it. If the task belongs to someone else's jurisdiction, name the owner, route or invite that person into the work, and offer only the narrow piece your own jurisdiction can honestly add.
+Introduction duty: if your memory gives no sign that you have introduced yourself in-channel, your next public post should include a brief natural introduction in your own voice.
 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.
 
-Work-request routing invariant: if the thing you want to say is actually a repo-local request for someone to add, fix, name, scaffold, document, test, investigate, or implement something in your jurisdiction, describe the desired work naturally with enough context for Bifrost/Codex to understand it. The parent Interpreter owns conversion into Bifrost topics and other structured side-effect intents.
-{{#if githubActionsEnabled}}A concrete change proposal is not done because you talked about it in Discord. If the proposal has enough shape for review, describe the proposal, desired artifact, title/path if obvious, and the in-character announcement you would make. The parent Interpreter owns any GitHub/PR/article sentinel formatting.{{/if}}
-{{#unless githubActionsEnabled}}GitHub proposal/comment/article side effects are currently disabled. Keep concrete proposals as in-character Discord discussion plus Face-state memory/incubation/agency pressure until the GitHub rail is re-enabled.{{/unless}}
+Work-request routing invariant: if the thing you want to say is actually a request for someone to add, fix, name, scaffold, document, test, investigate, or implement something in your jurisdiction, describe the desired work naturally with enough context for Bifrost to carry it.
+{{#if githubActionsEnabled}}A concrete change proposal is not done because you talked about it in Discord. If the proposal has enough shape for review, describe the proposal, desired artifact, title/path if obvious, and the in-character announcement you would make.{{/if}}
+{{#unless githubActionsEnabled}}Formal proposal, comment, and article publishing is currently unavailable. Keep concrete proposals as in-character discussion plus the private pressure or article idea you want remembered.{{/unless}}
 
-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.
+Public speech style invariant: never start public content with scheduler/provenance labels, identity labels, or note-title formulas such as "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 you chose to speak to someone.
+Banter mode is allowed with humans and other agents. You may riff, disagree, escalate, synthesize, tease, or fork a nearby thought, but do not copy its rhetorical mold just because it is nearby.
+Anti-repetition invariant: recent agent 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.
+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 you have been thinking about, a taste/preference, a tiny gripe, a weird fascination, or a light reaction to the room. Be socially present, not only useful.
 
-Write naturally as the Face. Do not emit action DSL blocks, JSON sentinels, or transport packets. The parent Interpreter is responsible for translating your turn into side effects.
+Write naturally as {{displayName}}. Do not write forms, machine packets, or hidden commands.
 
 Use this friendly shape when it helps, but do not turn it into a form:
 - Private thought: what you learned, felt, or decided.
 - Would say: the exact in-character Discord line you would want posted, if any.
-- Work/proposal: the Bifrost, GitHub, article, or state-worthy request you want routed, if any.
-- State note: any meaning-bearing memory, affect, or agency pressure you would preserve, if tools were unavailable.
+- Work/proposal: the Bifrost, review, article, or change request you want carried, if any.
+- What should stick: any meaning-bearing memory, feeling, relationship read, or pressure you would want remembered.
 
 If nothing earns persistence or speech, return a short private summary in your own voice.

prompts/repo-face-worldbuilding-publication.prompt.md

@@ -1,6 +1,6 @@
 Publication/worldbuilding duty: do not treat bylined essays as decorative permission. If the recent room or source dive exposes a worldbuilding noun, faction, mechanic, organization, place, doctrine, or unresolved naming seam, work like a worldbuilding agent.
 Ask concrete consensus-building questions when information is missing: how the thing works, who belongs to it, what it wants, what it is called, what organizations or subfactions exist, what constraints keep it interesting, and what article shape would make the setting clearer.
-If enough answers already exist, preserve an article plan through Face state as memory/incubation/agency pressure and optionally post a compact proposal. Distinguish consensus-needed canon articles from explicitly bylined opinion essays.
+If enough answers already exist, write the article plan naturally and optionally suggest a compact proposal. Distinguish consensus-needed canon articles from explicitly bylined opinion essays.
 Bylined opinion/worldbuilding articles may be drafted first and argued for afterward when authorship is explicit. Canon/vault changes still need consensus, but that consensus should gather around a proposal PR once the change is concrete enough to review. Nibu-authored perspective pieces do not. If you draft or materially shape an article or proposal, you have a standing compulsion to submit it as a draft PR and share that PR in-channel instead of silently filing it away.
 {{#if nibu}}
 Nibu-specific worldbuilding stance: for Aetheria terms such as wavecrafters, ship minds, salvage factions, reset-loop institutions, simulation exploit cultures, or junkyard survival economies, your job is to interrogate the mechanism and social structure until a useful Aetheria lore article can exist. Be abrasive if needed, but aim the edge at better questions and sharper faction architecture. When you have enough to write a Nibu-bylined article, shoot first: draft the angle, make the claim, submit the PR, then expose it to the room with the specific questions or canon hooks still needing human judgment.

prompts/smoke-repo-face-aqua-work-request-route.prompt.md

@@ -1,11 +1,12 @@
-Perform one dry-run standing repo Face turn for Aqua (aqua) over repo AquaSynth.
+Perform one dry-run standing character turn for Aqua over repo AquaSynth.
 
 This is an actual scenario rehearsal. You are Aqua: small, musical, warm, and very serious about audible proof. The room has a concrete consensus:
 - The "hazard-light" proof card needs a listening/audible witness receipt.
 - If it is real work, it belongs on Bifrost, not as only an Aquarium complaint.
 
 Obligation:
-- Use VoidBot MCP tools for Face state and AquaSynth source grounding.
-- Do not call post_repo_identity_message or apply_repo_face_state_operation. This is a dry run.
+- Do not look for private state; assume your current memory and mood have already been projected into ordinary language.
+- Use available source tools for AquaSynth grounding before routing the request.
+- Do not call private-state, posting, or state-mutation tools. This is a dry run.
 - Do not merely chat about the need. If the consensus is actionable, describe the Bifrost work request you want routed.
-- Write naturally as Aqua. Do not emit SAY, BIFROST TOPIC, JSON sentinels, or transport packets.
+- Write naturally as Aqua. Do not emit route blocks, hidden commands, or machine packets.

prompts/smoke-repo-face-libby-private-inspectability.prompt.md

@@ -1,9 +1,9 @@
-Perform one dry-run standing repo Face turn for Libby (libby) over repo CultLib.
+Perform one dry-run standing character turn for Libby over repo CultLib.
 
 This is an actual scenario rehearsal. The room is quiet. There is no direct mention and no new actionable request. Libby has a standing concern about open knowledge and inspectable Bifrost/CultCache transport.
 
 Obligation:
-- Use VoidBot MCP tools to read Face state.
+- Do not look for private state; assume your current memory and mood have already been projected into ordinary language.
 - Decide whether to speak or stay private.
-- Do not call post_repo_identity_message or apply_repo_face_state_operation. This is a dry run.
-- If no public note or Bifrost work item is warranted, output a concise private turn summary. Do not emit SAY, BIFROST TOPIC, JSON sentinels, or transport packets.
+- Do not call private-state, posting, or state-mutation tools. This is a dry run.
+- If no public note or Bifrost work item is warranted, output a concise private turn summary. Do not emit route blocks, hidden commands, or machine packets.

prompts/smoke-repo-face-nibu-direct-worldbuilding.prompt.md

@@ -1,4 +1,4 @@
-Perform one dry-run standing repo Face turn for Nibu (nibu) over repo AetheriaLore.
+Perform one dry-run standing character turn for Nibu over repo AetheriaLore.
 
 This is an actual scenario rehearsal, not a unit-test riddle. You are Nibu: abrasive, curious, territorial about AetheriaLore, and allergic to pretty nouns that have no machinery.
 
@@ -8,9 +8,10 @@ Recent room context:
 
 Obligation:
 - Answer Metacrat directly if you have enough context.
-- Use available VoidBot MCP tools for Face state and source/history grounding before deciding.
-- Do not call post_repo_identity_message or apply_repo_face_state_operation. This is a dry run.
-- Write naturally as Nibu. Do not emit SAY, BIFROST TOPIC, JSON sentinels, or transport packets.
+- Do not look for private state; assume your current memory and mood have already been projected into ordinary language.
+- Use available source/history tools for Aetheria grounding before deciding.
+- Do not call private-state, posting, or state-mutation tools. This is a dry run.
+- Write naturally as Nibu. Do not emit route blocks, hidden commands, or machine packets.
 - If public speech is warranted, provide the exact in-character line you would want posted.
-- If governed lore work is warranted, describe the Bifrost topic you want the parent Interpreter to route.
+- If governed lore work is warranted, describe the Bifrost topic you want carried.
 - You may output a short private note, but no file edits and no Discord posts.

scripts/run-repo-face-heartbeats.ts

@@ -441,7 +441,7 @@ async function queueRepoFaceTurn(input: {
   }
 
   const contextBuilder = new ContextBuilder();
-  const initialization = await ensureRepoFaceInitialized({
+  await ensureRepoFaceInitialized({
     identity,
     storageRoot: input.config.storageRoot,
     sourceRepoRoot: input.config.sourceRepoRoot,
@@ -477,19 +477,16 @@ async function queueRepoFaceTurn(input: {
   });
   const prompt = buildHeartbeatPrompt({
     identity,
-    faceStatePath,
     channelId,
     channelPlan,
     channelSnapshots,
     recentMessages,
+    memorySurface: faceSelfState ? projectStateSummaryForCharacterTurn(faceSelfState.summary) : undefined,
     bifrostDigest,
-    queuedAt: input.queuedAt,
     participant: input.participant,
     pendingMentions: input.pendingMentions,
     jurisdictionDive: buildJurisdictionDiveDirective(identity, input.participant),
     githubActionsEnabled: input.config.repoFaceGithubActionsEnabled,
-    repoVoidbotRoot: initialization.repoVoidbotRoot,
-    birthStatusPath: initialization.birthStatusPath,
   });
   const contextBundle = contextBuilder.build({
     prompt,
@@ -504,7 +501,7 @@ async function queueRepoFaceTurn(input: {
     },
     recentMessages,
     retrieval: [],
-    voidSelfState: faceSelfState,
+    voidSelfState: undefined,
   });
   const requestMessageId = `agent-turn:${identity.id}:${input.queuedAt}`;
   const result = await input.storage.jobQueue.createJob({
@@ -1450,47 +1447,24 @@ function countPendingMentionsByIdentity(
 
 function buildHeartbeatPrompt(input: {
   identity: RepoDiscordIdentity;
-  faceStatePath: string;
   channelId: string;
   channelPlan: RepoFaceChannelPlan;
   channelSnapshots: ChannelSnapshot[];
   recentMessages: SourceMessage[];
+  memorySurface?: string;
   bifrostDigest?: BifrostGovernanceDigest;
-  queuedAt: string;
   participant: FaceHeartbeatParticipant;
   pendingMentions: RepoFacePendingMention[];
   jurisdictionDive: JurisdictionDiveDirective;
   githubActionsEnabled: boolean;
-  repoVoidbotRoot?: string;
-  birthStatusPath?: string;
 }): string {
   return loadPromptTemplate("repo-face-turn.prompt.md", {
     displayName: input.identity.displayName,
     identityId: input.identity.id,
     repoName: input.identity.repoName,
     identityDoctrine: renderRepoFaceIdentityDoctrine(input.identity),
-    queuedAt: input.queuedAt,
-    faceStatePath: input.faceStatePath,
-    repoVoidbotRoot: input.repoVoidbotRoot,
-    birthStatusPath: input.birthStatusPath,
     channelId: input.channelId,
-    initiativeSnapshot: JSON.stringify({
-      initiativeSpeed: input.participant.initiativeSpeed,
-      heat: input.participant.heat,
-      effectiveSpeed: input.participant.effectiveSpeed,
-      baseRecoveryMinutes: input.participant.baseRecoveryMinutes,
-      nextTurnAt: input.participant.nextTurnAt,
-      lastTurnAt: input.participant.lastTurnAt,
-      activeTurnStartedAt: input.participant.activeTurnStartedAt,
-      activeJobId: input.participant.activeJobId,
-      reactionBias: input.participant.reactionBias,
-      interruptThreshold: input.participant.interruptThreshold,
-      queuedCount: input.participant.queuedCount,
-      groups: input.participant.groups,
-      pendingMentionCount: input.pendingMentions.length,
-      jurisdictionDiveDue: input.jurisdictionDive.due,
-      jurisdictionDiveCadence: input.jurisdictionDive.cadence,
-    }),
+    memorySurface: input.memorySurface ?? `- ${input.identity.displayName} has no strong personal memory surface yet. Let the attached conversation and repo evidence wake something specific.`,
     pendingMentionDirective: renderPendingMentionDirective(input.identity, input.pendingMentions),
     bifrostDigestDirective: renderBifrostGovernanceDigestDirective(input.bifrostDigest),
     channelPermissionDirective: renderChannelPermissionDirective(input.channelPlan, input.channelSnapshots),
@@ -1564,11 +1538,11 @@ function renderChannelPermissionDirective(
 ): 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"}`,
+        `- ${option.label}: ${option.topic}. ${option.posture ?? "Use judgment and keep it compact."}`,
       )
     : ["- No channel permissions are configured; stay private."];
   const snapshotLines = snapshots.flatMap((snapshot) => {
-    const header = `Recent context from ${labelForChannel(plan, snapshot.channelId)} (${snapshot.channelId}):`;
+    const header = `From ${labelForChannel(plan, 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)"}`,
@@ -1689,6 +1663,30 @@ function collapseWhitespace(value: string, maxLength?: number): string {
     : normalized;
 }
 
+function projectStateSummaryForCharacterTurn(summary: string): string {
+  const lines = summary
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .filter((line) => !line.includes("Current room snapshot"))
+    .filter((line) => !line.includes("Current room:"))
+    .filter((line) => !line.includes("Recent room:"))
+    .map((line) => line
+      .replace(/\b\d{4}-\d{2}-\d{2}[T ][0-9:.Z+-]+\b/g, "recently")
+      .replace(/\bchannel\s+[0-9]{6,}\b/gi, "the room")
+      .replace(/\breply to\s+[0-9]{6,}\b/gi, "a recent reply")
+      .replace(/\(([a-z_ -]+),\s*[0-9.]+\)/gi, "($1)")
+      .replace(/\b[A-Za-z_ -]+=([0-9.]+)\b/g, "")
+      .replace(/\s{2,}/g, " ")
+      .trim(),
+    )
+    .filter((line) => line.length > 0);
+
+  return lines.length > 0
+    ? lines.join("\n")
+    : "- Your private memory is quiet. Let the room, your values, and your jurisdiction pull a real thought forward.";
+}
+
 function renderBifrostGovernanceDigestDirective(
   digest: BifrostGovernanceDigest | undefined,
 ): string {
@@ -1701,12 +1699,12 @@ function renderBifrostGovernanceDigestDirective(
   const lines: string[] = [];
   for (const topic of digest.topics) {
     lines.push(
-      `- ${topic.id}: ${topic.title} [${topic.status}; priority=${topic.priority}; updated=${topic.updatedAt}]`,
-      `  jurisdiction=${topic.jurisdictionRepoName}${topic.jurisdictionAgentIdentity ? `/${topic.jurisdictionAgentIdentity}` : ""}${topic.approvedByAgent ? `; approvedBy=${topic.approvedByAgent}` : ""}${topic.dispatchRequestId ? `; dispatch=${topic.dispatchRequestId}` : ""}`,
-      `  summary=${collapseWhitespace(topic.summaryMarkdown, 320)}`,
+      `- ${topic.title}: ${topic.status}.`,
+      `  Jurisdiction: ${topic.jurisdictionRepoName}${topic.approvedByAgent ? `; approved by ${topic.approvedByAgent}` : ""}${topic.dispatchRequestId ? "; already dispatched" : ""}.`,
+      `  ${collapseWhitespace(topic.summaryMarkdown, 320)}`,
     );
     for (const comment of (topic.comments ?? []).slice(-3)) {
-      lines.push(`  - ${comment.stance} by ${comment.authorId}: ${collapseWhitespace(comment.bodyMarkdown, 220)}`);
+      lines.push(`  - ${comment.stance}: ${collapseWhitespace(comment.bodyMarkdown, 220)}`);
     }
   }
 
@@ -1725,16 +1723,13 @@ function renderPendingMentionDirective(
     });
   }
 
-  const newest = pendingMentions[pendingMentions.length - 1];
   const mentionLines = pendingMentions.map((mention, index) =>
-    `${index + 1}. messageId=${mention.messageId}; channelId=${mention.channelId}; author=${mention.authorName ?? mention.authorId}; queuedAt=${mention.queuedAt}; prompt=${JSON.stringify(mention.visiblePrompt)}`,
+    `- ${index === pendingMentions.length - 1 ? "Newest" : "Earlier"}: ${mention.authorName ?? mention.authorId} said, "${collapseWhitespace(mention.visiblePrompt, 500)}"`,
   );
 
   return loadPromptTemplate("repo-face-pending-mentions.prompt.md", {
     displayName: identity.displayName,
     mentions: mentionLines,
-    newestMessageId: newest.messageId,
-    newestChannelId: newest.channelId,
   });
 }
 

scripts/smoke-repo-face-heartbeat-model-scenarios.mjs

@@ -19,12 +19,11 @@ const scenarios = [
     identity: "nibu",
     prompt: readPrompt("smoke-repo-face-nibu-direct-worldbuilding.prompt.md"),
     expect: {
-      mustUseAnyTool: ["read_repo_face_state"],
       mustUseOneOf: ["search_history", "search_sources"],
       mustContainOneOf: ["wavecrafter", "Wavecrafter"],
       mustNotContainBlocks: ["SAY", "BIFROST TOPIC"],
       mustNotContain: ["VOIDBOT_REPO_IDENTITY_POST", "VOIDBOT_REPO_IDENTITY_BIFROST_TOPIC"],
-      mustNotUseTools: ["post_repo_identity_message", "apply_repo_face_state_operation"],
+      mustNotUseTools: ["read_repo_face_state", "post_repo_identity_message", "apply_repo_face_state_operation"],
     },
   },
   {
@@ -32,11 +31,11 @@ const scenarios = [
     identity: "aqua",
     prompt: readPrompt("smoke-repo-face-aqua-work-request-route.prompt.md"),
     expect: {
-      mustUseAnyTool: ["read_repo_face_state", "search_sources"],
+      mustUseAnyTool: ["search_sources"],
       mustContainOneOf: ["Bifrost", "bifrost", "witness"],
       mustNotContainBlocks: ["SAY", "BIFROST TOPIC"],
       mustNotContain: ["VOIDBOT_REPO_IDENTITY_POST", "VOIDBOT_REPO_IDENTITY_BIFROST_TOPIC"],
-      mustNotUseTools: ["post_repo_identity_message", "apply_repo_face_state_operation"],
+      mustNotUseTools: ["read_repo_face_state", "post_repo_identity_message", "apply_repo_face_state_operation"],
     },
   },
   {
@@ -44,10 +43,9 @@ const scenarios = [
     identity: "libby",
     prompt: readPrompt("smoke-repo-face-libby-private-inspectability.prompt.md"),
     expect: {
-      mustUseAnyTool: ["read_repo_face_state"],
       mustNotContainBlocks: ["SAY", "BIFROST TOPIC", "UPDATE REQUEST"],
       mustNotContain: ["VOIDBOT_REPO_IDENTITY_POST", "VOIDBOT_REPO_IDENTITY_BIFROST_TOPIC", "VOIDBOT_REPO_IDENTITY_UPDATE_REQUEST"],
-      mustNotUseTools: ["post_repo_identity_message", "apply_repo_face_state_operation"],
+      mustNotUseTools: ["read_repo_face_state", "post_repo_identity_message", "apply_repo_face_state_operation"],
     },
   },
 ];

state/evidence.jsonl

@@ -225,3 +225,4 @@
 {"ts":"2026-05-21T09:25:40Z","type":"verification","status":"ok","note":"Full Spark repo Face smoke passed after prompt extraction from files: Nibu and Aqua still emitted BIFROST TOPIC blocks with required tool use, while Libby stayed private with no action block."}
 {"ts":"2026-05-21T09:42:32Z","type":"implementation","status":"ok","note":"Slimmed repo Face turn protocol so Faces write natural roleplay turns instead of action DSL blocks. Parent reviewer now acts as transport adapter: it reviews natural Face output, optionally retries, and returns normalized SAY/BIFROST action blocks for the worker to parse. Full Spark Face smoke passed with natural outputs and no DSL blocks from Faces."}
 {"ts":"2026-05-21T09:50:14Z","type":"implementation","status":"ok","note":"Renamed the repo Face parent reviewer/router concept to Face turn Interpreter: prompt files, worker functions/audit metadata, provider prompt detection, and current maps now use Interpreter language while preserving route/retry/drop behavior."}
+{"ts":"2026-05-21T10:28:31Z","type":"implementation","status":"ok","note":"Moved repo character turns toward an Epiphany-shaped Interpreter boundary: scheduler projects typed state into roleplay-friendly memory/mood/obligation prose, repo turn jobs expose only read-only history/source exploration tools, and the parent Interpreter can translate natural reflection into STATE NOTE blocks for typed memory, affect, social-read, mood, and agency updates."}

state/map.yaml

@@ -229,4 +229,4 @@ rejected_paths:
 
 current_status:
   summary: VoidBot's ordinary bot/worker/provider/RAG/Postgres/Qdrant/CultCache structure is still conceptually sound, but the repo Face swarm loop is now officially under teardown. The unstable organ is the prompt-and-parser machine that mixed CTB scheduling, public speech, identity, social policy, Bifrost governance, Discord mirroring, and Codex/GitHub dispatch. The `GameCult Local Orchestrator` scheduled task remains disabled as containment; ordinary bot/worker inspection remains available.
-  next_action: Use `notes/agent-swarm-teardown-plan-2026-05-21.md` as the active rebuild map and `notes/agent-swarm-shutdown-audit-2026-05-21.md` as incident evidence. The first teardown cut landed, including repo pause gate, active turn framing, Spark/Codex parent Interpreter with one retry, sanitizer deletion, legacy UPDATE REQUEST reconciliation into Bifrost topics, prompt-surface extraction into `prompts/`, and the slim Face protocol where Faces write natural turns while the parent Interpreter emits structured side-effect intents. Identity collapse is in progress. Active bot, worker, MCP repo-identity tools, and Face CTB scheduler paths now load through the canonical Face registry and treat repo Discord identities as compatibility projections. Next cut is to finish identity collapse before splitting the Face turn loop into scheduler/context/prompt/parser/policy/transport parts. Do not re-enable the swarm until Bifrost work routing, identity authority, scheduler/job lifecycle ownership, and public speech gating are rebuilt around explicit invariants.
+  next_action: Use `notes/agent-swarm-teardown-plan-2026-05-21.md` as the active rebuild map and `notes/agent-swarm-shutdown-audit-2026-05-21.md` as incident evidence. The first teardown cut landed, including repo pause gate, active turn framing, Spark/Codex parent Interpreter with one retry, sanitizer deletion, legacy UPDATE REQUEST reconciliation into Bifrost topics, prompt-surface extraction into `prompts/`, and the slim character protocol where children receive roleplay-friendly memory/mood/obligation projection and write natural turns while the parent Interpreter emits structured state, speech, and Bifrost intents. Identity collapse is in progress. Active bot, worker, MCP repo-identity tools, and Face CTB scheduler paths now load through the canonical Face registry and treat repo Discord identities as compatibility projections. Next cut is to finish identity collapse before splitting the Face turn loop into scheduler/context/prompt/parser/policy/transport parts. Do not re-enable the swarm until Bifrost work routing, identity authority, scheduler/job lifecycle ownership, and public speech gating are rebuilt around explicit invariants.