Isolate portable Persona state compatibility

This commit is contained in:
Meta Vens 2026-07-16 03:00:58 +01:00
commit 3f87346dee
8 changed files with 80 additions and 191 deletions

View file

@ -0,0 +1,38 @@
import type { RepoDiscordIdentity } from "@voidbot/core";
import type { PortablePersonaStateObservation } from "./persona-portable-state-source.js";
export function projectPortablePersonaState(identity: RepoDiscordIdentity, observation: PortablePersonaStateObservation): string {
if (observation.status !== "ok") return [`${identity.displayName} is a native VoidBot Persona, not a repo Face.`, `Portable Persona state is ${observation.status}: ${observation.reason}`, "Treat this as a Body fault and keep the public turn modest."].join("\n");
const state = observation.state;
const profile = child(state, "profile") ?? child(state, "selfProfile") ?? state;
const memory = child(state, "memory") ?? child(state, "thoughtMemory");
const affect = child(state, "affect") ?? child(state, "faceAffect");
const doctrine = child(state, "doctrine") ?? child(state, "doctrineStances");
return [
`${identity.displayName} is a native VoidBot Persona, not a repo Face.`,
"Portable Persona state is an imported projection, not canonical typed runtime authority.",
identity.avatarUrl ? `Public avatar URL: ${identity.avatarUrl}` : undefined,
identity.avatarPath ? `Local avatar asset: ${identity.avatarPath}` : undefined,
text(profile, "publicDescription") ?? identity.description,
list("Private notes", array(profile, "privateNotes")),
values("Values", array(profile, "values")),
list("Activation traits", array(profile, "activationTraits")),
memories("Memories", [...array(memory, "memories"), ...array(memory, "durableMemories")]),
memories("Short-term residue", array(memory, "shortTerm")),
memories("Agency pressure", [...array(state, "pressures"), ...array(state, "agencyPressures"), ...array(child(state, "agencyPressure"), "pressures")]),
memories("Affect needs", array(affect, "needs")),
memories("Social bonds", array(affect, "socialBonds")),
memories("Doctrine stances", [...array(state, "doctrineStances"), ...array(doctrine, "stances"), ...array(doctrine, "doctrineStances")]),
].filter((line): line is string => Boolean(line?.trim())).join("\n\n");
}
export function projectNativePersonaBody(identity: RepoDiscordIdentity): string { return [`${identity.displayName} is a native VoidBot Persona.`, "Body for this turn: Persona state, avatar, allowed Discord channels, current conversation, and VoidBot's webhook mouth.", "No repo jurisdiction, Bifrost governance digest, source-repo activity, or repo proposal authority is implied by this native Persona category."].join("\n"); }
function child(value: unknown, key: string): Record<string, unknown> | undefined { return record(value) && record(value[key]) ? value[key] as Record<string, unknown> : undefined; }
function text(value: unknown, key: string): string | undefined { const field = record(value) ? value[key] : undefined; return typeof field === "string" && field.trim() ? field.trim() : undefined; }
function array(value: unknown, key: string): unknown[] { const field = record(value) ? value[key] : undefined; return Array.isArray(field) ? field : []; }
function list(title: string, entries: unknown[]): string | undefined { const rendered = entries.map((entry) => typeof entry === "string" ? entry : summarize(entry)).filter((entry): entry is string => Boolean(entry?.trim())).slice(0, 12); return rendered.length > 0 ? [`${title}:`, ...rendered.map((entry) => `- ${entry}`)].join("\n") : undefined; }
function values(title: string, entries: unknown[]): string | undefined { return list(title, entries.map((entry) => record(entry) ? [text(entry, "label") ?? text(entry, "id") ?? text(entry, "name"), text(entry, "summary") ?? text(entry, "description")].filter(Boolean).join(": ") : entry)); }
function memories(title: string, entries: unknown[]): string | undefined { return list(title, entries.map((entry) => record(entry) ? text(entry, "summary") ?? text(entry, "claim") ?? text(entry, "description") ?? text(entry, "text") ?? summarize(entry) : entry)); }
function summarize(value: unknown): string | undefined { if (!record(value)) return undefined; for (const key of ["summary", "claim", "description", "text", "label", "id", "name"]) { const field = text(value, key); if (field) return field; } return undefined; }
function record(value: unknown): value is Record<string, unknown> { return typeof value === "object" && value !== null && !Array.isArray(value); }

View file

@ -0,0 +1,23 @@
import { readFile } from "node:fs/promises";
import { resolve } from "node:path";
export type PortablePersonaStateObservation =
| { status: "ok"; statePath: string; state: Record<string, unknown>; schemaVersion: "gamecult.persona_state.v0" }
| { status: "missing" | "malformed" | "unsupported"; statePath: string; reason: string };
export async function readPortablePersonaState(path: string): Promise<PortablePersonaStateObservation> {
const statePath = resolve(path);
try {
const raw = await readFile(statePath, "utf8");
const parsed = JSON.parse(stripBom(raw)) as unknown;
if (!record(parsed)) return { status: "malformed", statePath, reason: "Portable Persona state root is not an object." };
if (parsed.schemaVersion !== "gamecult.persona_state.v0") return { status: "unsupported", statePath, reason: `Unsupported portable Persona schema ${String(parsed.schemaVersion ?? "missing")}.` };
return { status: "ok", statePath, state: parsed, schemaVersion: "gamecult.persona_state.v0" };
} catch (error) {
if ((error as NodeJS.ErrnoException).code === "ENOENT") return { status: "missing", statePath, reason: "Portable Persona state file does not exist." };
return { status: "malformed", statePath, reason: error instanceof Error ? error.message : String(error) };
}
}
function stripBom(value: string): string { return value.charCodeAt(0) === 0xfeff ? value.slice(1) : value; }
function record(value: unknown): value is Record<string, unknown> { return typeof value === "object" && value !== null && !Array.isArray(value); }

View file

@ -159,6 +159,7 @@ Git history and smoke artifacts carry routine proof. `state/evidence.jsonl` shou
- `persona-social-context-source.ts` owns visible-human selection, interaction-profile reads, pronoun-evidence precedence, and neutral guidance projection through an injected reader that it always closes. The heartbeat shell constructs the existing state-storage adapter but no longer knows pronoun ranking policy. `persona-social-context-projector.ts` remains presentation-only. Exact Nibu prompt assembly remains 153,917 characters.
- `persona-conversation-projector.ts` owns conversation threads/default focus, raw transcript/chronology rendering, attachment labels, pending-call framing, room-topic saturation, and memory-facing topic-attractor facts from supplied evidence. `turn-context-source.ts` remains the sole Discord acquirer. The queue actuator receives the same focus/thread result used to render the prompt, eliminating the prior duplicate derivation. Exact Nibu prompt assembly remains 153,917 characters.
- `persona-turn-prompt-projector.ts` owns final template composition, identity doctrine, jurisdiction-dive cadence, channel/research/situation/social/repetition/governance/mention/worldbuilding directives, and all prompt-default policy. The shell supplies already-acquired facts and invokes the resulting prompt; it no longer loads prompt templates. A same-environment differential run of committed-old versus extracted-new prompt owners produced equal 161,190-character prompts; the only differing lines were the sequential repo-activity timestamp and a live retrieval score rounded from 0.75 to 0.76.
- Typed native Personas now use the same state/memory projection path as repo Personas. The live portable JSON compatibility path for Muninn, Sleipnir, Hermodr, and Tengu is isolated in `persona-portable-state-source.ts` plus `persona-portable-state-projector.ts`; it validates `gamecult.persona_state.v0`, labels the surface as imported projection, and no longer leaks private filesystem paths. Muninn prompt assembly passed. Tengu's JSON claims canonical authority; the other three claim projection authority with self-referential install provenance, so migration requires a provenance audit rather than blindly elevating all four into `.cc` truth.
- `persona-social-context-projector.ts` owns one aggregate social-context projection from supplied identity, registry, typed state, messages, pronoun guidance, and observation time. That result includes relationship freshness, mapped/unmapped topology, peer openings, relationship-pressure scoring, pronouns, room texture, and human-clarity pressure. Clarity evidence sorts on the real `SourceMessage.timestamp`; the heartbeat shell no longer owns social tokenization or scoring helpers.
- Home-repo activity acquisition is isolated in `repo-activity-source.ts`. It owns source-repo/cursor resolution and the bounded read-only exporter invocation, returning typed observations that prompt composition renders without subprocess or JSON-parsing authority.
- Deployment authority detail: Idunn executes `/srv/odin/deploy-manifests/voidbot`; `/usr/local/sbin/deploy-voidbot` is only the identical inspection/recovery copy. Install both from `gamecult-ops/scripts/deploy-voidbot.sh`. `/srv/build/VoidBot/.git` and `/srv/build/cultcache-ts/.git` must remain wholly `idunn`-owned because lazy partial-clone reads can fetch objects; root owns releases and service promotion, never build-repo Git state.

View file

@ -189,6 +189,7 @@ VoidBot runs on Yggdrasil. Idunn owns deployment and consumes upstream repositor
- `persona-social-context-source.ts` is the read-only interaction-memory adapter for social guidance. It selects visible humans plus the owner, reads profiles through an injected closeable port, ranks explicit/corrective evidence over ambient usage, and emits neutral pronoun guidance. Storage remains authoritative; the source closes its reader and cannot render prompt prose or mutate profiles.
- `persona-conversation-projector.ts` is the pure owner of conversation projection. Given routing, raw current/nearby messages, pending mentions, and identity, it emits one transcript plus the exact thread/default-focus objects sent to the actuator, and derives shared room-saturation/topic-attractor facts. It cannot read Discord, state, vectors, or the queue; `turn-context-source.ts` remains the evidence owner.
- `persona-turn-prompt-projector.ts` is the final pure turn-policy owner. It composes the repo-Face prompt template and owns identity doctrine, situation/mention/channel/research/social/governance/repetition/worldbuilding directives, plus deterministic jurisdiction-dive cadence. The heartbeat shell passes acquired facts and sends the returned prompt to the actuator; it does not load prompt templates or decide prompt policy.
- Typed native Personas and repo Personas share the same `persona-state-source`/memory-projector path. Legacy `gamecult.persona_state.v0` JSON remains live for Muninn, Sleipnir, Hermodr, and Tengu behind `persona-portable-state-source.ts` and `persona-portable-state-projector.ts`; the source validates schema/read failures and the projector renders bounded imported state without exposing its path. This compatibility organ is not canonical state ownership and should disappear after a provenance-aware `.cc` migration.
- `apps/persona-scheduler/src/bifrost-governance-source.ts` owns the remaining Bifrost governance digest subprocess contract. It supplies the CLI path, arguments, timeout, JSON parsing, and typed command/parse failure topics; Persona prompt composition receives a `BifrostGovernanceDigest` and cannot invoke Bifrost directly.
- The scheduler state has one write authority. `initiative-engine.ts` commits participant reconciliation, operator controls, pause/disabled skips, stale-turn recovery witnesses, semantic pressure, pending-attention consumption, queue outcomes, and tick finalization. `run-repo-face-heartbeats.ts` contains no direct participant/state assignment or history append; its sources and actuators return facts to engine commits.
- `apps/persona-scheduler/src/turn-actuator.ts` is the worker-queue output port. Given a completed prompt, output channel, evidence fields, provider, identity, timestamp, and narrow `createJob` capability, it builds the canonical worker actor/guild `ContextBundle`, creates one approved `repo-face-rumination` job, and returns `{created, activeJobId, requestMessageId}`. It cannot choose a Persona, mutate scheduler state, or compose prompt content. The orchestration shell no longer knows `ContextBuilder`, job approval defaults, worker command names, or `createJob` mechanics.

View file

@ -12,7 +12,6 @@ import {
getRepoDiscordIdentityAllowedChannelIds,
faceRegistryAsRepoDiscordRegistry,
loadFaceIdentityRegistry,
loadVoidSelfStateTypedDocuments,
resolveRepoFaceStatePath,
type RepoFacePendingMention,
type RepoDiscordIdentity,
@ -62,6 +61,8 @@ import { readPersonaCuriosityEvidence } from "../apps/persona-scheduler/dist/per
import { projectPersonaCuriosityContext } from "../apps/persona-scheduler/dist/persona-curiosity-projector.js";
import { projectPersonaConversation, renderPersonaTopicAttractor } from "../apps/persona-scheduler/dist/persona-conversation-projector.js";
import { buildPersonaJurisdictionDiveDirective, buildPersonaTurnPrompt, renderPersonaIdentityDoctrine } from "../apps/persona-scheduler/dist/persona-turn-prompt-projector.js";
import { readPortablePersonaState } from "../apps/persona-scheduler/dist/persona-portable-state-source.js";
import { projectNativePersonaBody, projectPortablePersonaState } from "../apps/persona-scheduler/dist/persona-portable-state-projector.js";
import { projectPersonaSocialContext, type PersonaHumanPronounGuidance as RepoFaceHumanPronounGuidance } from "../apps/persona-scheduler/dist/persona-social-context-projector.js";
import { readPersonaHumanPronounGuidance } from "../apps/persona-scheduler/dist/persona-social-context-source.js";
import {
@ -428,7 +429,7 @@ async function queueRepoFaceTurn(input: {
input.personaStateObservation,
);
const repoActivitySurface = identity.identityKind === "native_persona"
? renderNativePersonaBodySurface(identity)
? projectNativePersonaBody(identity)
: renderRepoActivityObservation(readRepoActivity({ identity, storageRoot: input.config.storageRoot }));
const globalAgentDoctrine = await loadGlobalAgentDoctrine();
const conversationProjection = projectPersonaConversation({
@ -787,20 +788,14 @@ async function renderRepoFaceMemorySurfaceForTurn(
observation?: PersonaStateObservation,
): Promise<string> {
if (identity.identityKind === "native_persona") {
return renderNativePersonaMemorySurface(
identity,
config,
registryIdentities,
roomContext,
humanPronounGuidance ?? await loadRepoFaceHumanPronounGuidance(config, roomContext),
observation,
);
if (!identity.personaStatePath) return [`${identity.displayName} is a native VoidBot Persona, not a repo Face.`, "No Persona state path is registered. Treat that as a Body fault and keep the public turn modest."].join("\n");
if (extname(identity.personaStatePath).toLowerCase() !== ".cc") return projectPortablePersonaState(identity, await readPortablePersonaState(identity.personaStatePath));
}
const acquired = observation ?? await readPersonaStateObservation({ identity, storageRoot: config.storageRoot });
if (acquired.status !== "ok") throw new Error(`${identity.displayName} Persona state ${acquired.status}: ${acquired.reason}`);
const typedState = acquired.typedState;
const curiosityGraphFacts = roomContext
const curiosityGraphFacts = roomContext && identity.identityKind !== "native_persona"
? await renderRepoFaceCuriosityGraphFacts(identity, config, typedState, roomContext)
: undefined;
const statePacket = renderRepoFaceStatePacket(
@ -859,181 +854,6 @@ function renderPersonaMemoryRecallObservation(observation: PersonaMemoryRecallOb
].join("\n");
}
async function renderNativePersonaMemorySurface(
identity: RepoDiscordIdentity,
config: ReturnType<typeof loadConfig>,
registryIdentities: RepoDiscordIdentity[] = [],
roomContext?: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
},
humanPronounGuidance: RepoFaceHumanPronounGuidance[] = [],
observation?: PersonaStateObservation,
): Promise<string> {
const personaStatePath = identity.personaStatePath;
if (!personaStatePath) {
return [
`${identity.displayName} is a native VoidBot Persona, not a repo Face.`,
"No Persona state path is registered. Treat that as a Body fault and keep the public turn modest.",
].join("\n");
}
if (extname(personaStatePath).toLowerCase() === ".cc") {
const acquired = observation ?? await readPersonaStateObservation({ identity, storageRoot: config.storageRoot });
if (acquired.status !== "ok") throw new Error(`${identity.displayName} Persona state ${acquired.status}: ${acquired.reason}`);
const typedState = acquired.typedState;
const statePacket = renderRepoFaceStatePacket(
identity,
typedState,
registryIdentities,
roomContext,
humanPronounGuidance,
);
if (!config.repoFaceHeartbeats.stateProjectorEnabled) {
return projectPersonaMemorySurface({
identityId: identity.id,
characterIdentity: renderPersonaIdentityDoctrine(identity),
statePacket,
modelProjectionEnabled: false,
});
}
return projectPersonaMemorySurface({
identityId: identity.id,
characterIdentity: renderPersonaIdentityDoctrine(identity),
statePacket,
modelProjectionEnabled: true,
projectText: (prompt) => runCodexTextProjection({
prompt,
config,
command: "repo-face-state-projector",
jobId: `state-projector:${identity.id}:${Date.now()}`,
timeoutMs: 180_000,
}),
});
}
const raw = JSON.parse(stripLeadingBom(await readFile(resolve(personaStatePath), "utf8"))) as unknown;
const state = isRecord(raw) ? raw : {};
const profile = readRecord(state, "profile") ?? readRecord(state, "selfProfile") ?? state;
const presentation = readRecord(state, "presentation");
const memory = readRecord(state, "memory") ?? readRecord(state, "thoughtMemory");
const affect = readRecord(state, "affect") ?? readRecord(state, "faceAffect");
const doctrine = readRecord(state, "doctrine") ?? readRecord(state, "doctrineStances");
const lines = [
`${identity.displayName} is a native VoidBot Persona, not a repo Face.`,
`Persona state: ${resolve(personaStatePath)}`,
identity.avatarUrl ? `Public avatar URL: ${identity.avatarUrl}` : undefined,
identity.avatarPath ? `Local avatar asset: ${identity.avatarPath}` : undefined,
stringField(profile, "publicDescription") ?? identity.description,
listSection("Private notes", arrayField(profile, "privateNotes")),
valueSection("Values", arrayField(profile, "values")),
listSection("Activation traits", arrayField(profile, "activationTraits")),
memorySection("Memories", [
...arrayField(memory, "memories"),
...arrayField(memory, "durableMemories"),
]),
memorySection("Short-term residue", arrayField(memory, "shortTerm")),
memorySection("Agency pressure", [
...arrayField(state, "pressures"),
...arrayField(state, "agencyPressures"),
...arrayField(readRecord(state, "agencyPressure"), "pressures"),
]),
memorySection("Affect needs", arrayField(affect, "needs")),
memorySection("Social bonds", arrayField(affect, "socialBonds")),
memorySection("Doctrine stances", [
...arrayField(state, "doctrineStances"),
...arrayField(doctrine, "stances"),
...arrayField(doctrine, "doctrineStances"),
]),
].filter((line): line is string => typeof line === "string" && line.trim().length > 0);
return lines.join("\n\n");
}
function renderNativePersonaBodySurface(identity: RepoDiscordIdentity): string {
return [
`${identity.displayName} is a native VoidBot Persona.`,
"Body for this turn: Persona state, avatar, allowed Discord channels, current conversation, and VoidBot's webhook mouth.",
"No repo jurisdiction, Bifrost governance digest, source-repo activity, or repo proposal authority is implied by this native Persona category.",
].join("\n");
}
function readRecord(value: unknown, key: string): Record<string, unknown> | undefined {
if (!isRecord(value)) {
return undefined;
}
const child = value[key];
return isRecord(child) ? child : undefined;
}
function stringField(value: unknown, key: string): string | undefined {
if (!isRecord(value)) {
return undefined;
}
const child = value[key];
return typeof child === "string" && child.trim().length > 0 ? child.trim() : undefined;
}
function arrayField(value: unknown, key: string): unknown[] {
if (!isRecord(value)) {
return [];
}
const child = value[key];
return Array.isArray(child) ? child : [];
}
function listSection(title: string, entries: unknown[]): string | undefined {
const rendered = entries
.map((entry) => typeof entry === "string" ? entry : summarizeRecord(entry))
.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0)
.slice(0, 12);
return rendered.length > 0
? [`${title}:`, ...rendered.map((entry) => `- ${entry}`)].join("\n")
: undefined;
}
function valueSection(title: string, entries: unknown[]): string | undefined {
return listSection(title, entries.map((entry) => {
if (!isRecord(entry)) {
return entry;
}
const label = stringField(entry, "label") ?? stringField(entry, "id") ?? stringField(entry, "name");
const summary = stringField(entry, "summary") ?? stringField(entry, "description");
return [label, summary].filter(Boolean).join(": ");
}));
}
function memorySection(title: string, entries: unknown[]): string | undefined {
return listSection(title, entries.map((entry) => {
if (!isRecord(entry)) {
return entry;
}
return stringField(entry, "summary") ??
stringField(entry, "claim") ??
stringField(entry, "description") ??
stringField(entry, "text") ??
summarizeRecord(entry);
}));
}
function summarizeRecord(value: unknown): string | undefined {
if (!isRecord(value)) {
return undefined;
}
for (const key of ["summary", "claim", "description", "text", "label", "id", "name"]) {
const field = stringField(value, key);
if (field) {
return field;
}
}
return undefined;
}
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function renderRepoFaceStatePacket(
identity: RepoDiscordIdentity,
state: VoidSelfStateTypedProjection,
@ -1517,10 +1337,6 @@ function round3(value: number): number {
return Math.round(value * 1000) / 1000;
}
function stripLeadingBom(input: string): string {
return input.charCodeAt(0) === 0xfeff ? input.slice(1) : input;
}
function readArgValue(name: string): string | undefined {
const index = process.argv.indexOf(name);
if (index < 0) {

View file

@ -70,6 +70,8 @@ import { readPersonaCuriosityEvidence } from "../apps/persona-scheduler/dist/per
import { projectPersonaCuriosityContext } from "../apps/persona-scheduler/dist/persona-curiosity-projector.js";
import { projectPersonaConversation, renderPersonaRoomTopicSaturation } from "../apps/persona-scheduler/dist/persona-conversation-projector.js";
import { buildPersonaJurisdictionDiveDirective, buildPersonaTurnPrompt } from "../apps/persona-scheduler/dist/persona-turn-prompt-projector.js";
import { readPortablePersonaState } from "../apps/persona-scheduler/dist/persona-portable-state-source.js";
import { projectPortablePersonaState } from "../apps/persona-scheduler/dist/persona-portable-state-projector.js";
import { observePersonaRoomTexture, projectPersonaSocialContext, renderPersonaHumanClarityPressure, renderPersonaHumanPronounFacts, renderPersonaRoomWeather, renderPersonaSocialGraph } from "../apps/persona-scheduler/dist/persona-social-context-projector.js";
import { readPersonaHumanPronounGuidance } from "../apps/persona-scheduler/dist/persona-social-context-source.js";
@ -619,6 +621,13 @@ try {
});
assert.match(composedMemory ?? "", /Explicit social graph fact\.[\s\S]*Explicit room texture fact\./, "the projector owns final ordering of explicitly supplied external facts");
assert.deepEqual(await readFile(statePath), beforeObservation, "Persona state observation cannot rewrite sleep, speaking pressure, or any other Mind field");
const portablePath = join(stateSourceDirectory, "muninn.persona_state.v0.json");
await writeFile(portablePath, JSON.stringify({ schemaVersion: "gamecult.persona_state.v0", publicDescription: "Muninn remembers provenance.", privateNotes: ["Name missing evidence."], values: [{ label: "Source time", summary: "Keep observation time distinct." }], thoughtMemory: { shortTerm: [{ summary: "The last frame was stale." }] } }));
const portableObservation = await readPortablePersonaState(portablePath);
assert.equal(portableObservation.status, "ok", "the portable Persona source validates the live gamecult.persona_state.v0 contract");
const portableProjection = projectPortablePersonaState({ ...routedIdentity, id: "muninn", displayName: "Muninn", identityKind: "native_persona", personaStatePath: portablePath }, portableObservation);
assert.match(portableProjection, /Portable Persona state is an imported projection[\s\S]*Source time: Keep observation time distinct/, "the portable projector renders bounded state without becoming canonical authority");
assert.doesNotMatch(portableProjection, /persona_state\.v0\.json|state-source/, "portable Persona projection cannot leak its private filesystem path");
} finally {
await rm(stateSourceDirectory, { recursive: true, force: true });
}

View file

@ -424,3 +424,4 @@
{"ts":"2026-07-16T01:27:04Z","type":"implementation","status":"ok","note":"Human pronoun-guidance acquisition moved into persona-social-context-source. It owns visible-human selection, injected profile reads, evidence ranking, neutral guidance projection, and reader closure; the heartbeat shell only constructs the state-storage adapter. Build, source smoke including explicit-vs-ambient precedence, exact 153917-character Nibu prompt, dry-run, and operator tests passed."}
{"ts":"2026-07-16T01:35:46Z","type":"implementation","status":"ok","note":"Conversation projection moved into persona-conversation-projector. One supplied-evidence projection now owns transcript chronology, threads/default focus, attachments, direct-call framing, topic saturation, and memory-facing attractors; the same focus/thread result feeds the actuator. Build, focused smoke, exact 153917-character Nibu prompt, dry-run, and operator tests passed."}
{"ts":"2026-07-16T01:49:35Z","type":"implementation","status":"ok","note":"Final Persona turn policy moved into persona-turn-prompt-projector: template composition, identity doctrine, jurisdiction cadence, situation, mention, channel, research, social, repetition, governance, and worldbuilding directives. The heartbeat shell no longer loads templates. Targeted smoke, build, dry-run, operator tests, and an old-vs-new same-environment differential passed; both prompts were 161190 chars and differed only in sequential live repo timestamp/vector score evidence."}
{"ts":"2026-07-16T02:00:40Z","type":"implementation","status":"ok","note":"Native Persona memory ownership was collapsed: typed native Personas now use the same typed state/memory projector as repo Personas; live gamecult.persona_state.v0 JSON compatibility moved into schema-aware portable source/projector organs and no longer leaks private paths. Source/projector smoke, Muninn and Nibu prompt assembly, build, dry-run, and operator tests passed. Migration audit found Tengu canonical JSON while Muninn/Sleipnir/Hermodr claim projection authority."}

View file

@ -278,4 +278,4 @@ rejected_paths:
current_status:
summary: VoidBot's bot/worker/provider/RAG/Postgres/Qdrant/CultCache structure is live. Repo Face/persona heartbeat jobs run through the direct `openai_api` provider configured for MiMo `mimo-v2.5-pro`, with the expensive state-projector pass still disabled. The 2026-07-04 transport repair replaced the old Bifrost HTTP/token bridge shortcut with typed Bifrost CultMesh Discord command and receipt documents advertised in the Bifrost provider store at `cultmesh://asgard.starfire.bifrost/commands/discord-post`. VoidBot stores the Bifrost target as a CultMesh URI, writes command docs to `E:/Projects/Bifrost/.bifrost/provider-store.cc`, optionally pumps Bifrost's command processor, and waits for typed receipts before completing repo Face Discord delivery. Bifrost's provider advertisement exposes `discord.post` command metadata for Odin/Eve agents, and a bounded Weksa live-fire completed visibly. Eve live state now runs end to end through CultLib dev retained publications, Hermodr ordered SSE, Eve component bindings, and VoidBot typed control state. Receipts acknowledge intent only. Heat initial load, provider-driven change, and browser-command change were visibly verified without reload through the same subscription.
next_action: Map the native-Persona memory/body fallback in `scripts/run-repo-face-heartbeats.ts`. Collapse typed-state projection into the existing memory projector, identify whether legacy document parsing still protects a live contract, and delete or isolate it accordingly.
next_action: Audit and migrate native portable Persona ownership: Tengu's JSON declares canonical authority while Muninn, Sleipnir, and Hermodr declare projections with self-referential install provenance. Identify the real canonical source for each, migrate canonical Mind into typed `.cc` without elevating projections, then update registry paths and retire the portable compatibility organ when no live consumer remains.