VoidBot/scripts/run-repo-face-heartbeats.ts
2026-06-01 04:10:10 +01:00

5244 lines
182 KiB
TypeScript

import "dotenv/config";
import { createHash } from "node:crypto";
import { spawn, spawnSync } from "node:child_process";
import { appendFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
import { homedir } from "node:os";
import { dirname, extname, resolve } from "node:path";
import { loadConfig } from "@voidbot/config";
import {
buildEpiphanyIdentityRegistry,
ContextBuilder,
createStateStorage,
ensureRepoFaceInitialized,
getRepoDiscordIdentityAllowedChannelIds,
faceRegistryAsRepoDiscordRegistry,
projectRepoFaceSleepCycleForNow,
applyVoidSelfStateOperation,
loadFaceIdentityRegistry,
loadVoidSelfStateTypedDocuments,
REPO_FACE_HEARTBEAT_SCHEMA_VERSION,
type RepoFaceRestSnapshot,
resolveRepoFaceStatePath,
type RepoFacePendingMention,
type RepoDiscordIdentity,
type VoidScheduledRuntime,
type VoidSelfStateTypedProjection,
} from "@voidbot/core";
import {
createTextEmbedder,
createVectorStores,
RetrievalService,
} from "@voidbot/rag";
import {
loadPromptTemplate,
type InteractionMemoryProfile,
type PromptImageAttachment,
type RetrievalResult,
type SourceMessage,
type SourceMessageAttachment,
} from "@voidbot/shared";
const HEARTBEAT_SCHEMA_VERSION = REPO_FACE_HEARTBEAT_SCHEMA_VERSION;
const HEARTBEAT_COMMAND = "repo-face-rumination";
const MIN_STALE_ACTIVE_JOB_MS = 45 * 60_000;
const MAX_FACE_IMAGE_ATTACHMENT_BYTES = 12 * 1024 * 1024;
interface FaceHeartbeatParticipant {
identityId: string;
participantKind: "repo_face" | "system_agent";
turnKind: "repo_face_rumination" | "void_moderation";
repoName: string;
displayName: string;
initiativeSpeed: number;
reactionBias: number;
interruptThreshold: number;
currentLoad: number;
status: "active" | "blocked" | "withdrawn" | "offscreen";
groups: string[];
heat: number;
effectiveSpeed: number;
baseRecoveryMinutes: number;
nextTurnAt: number;
lastTurnAt?: number;
activeTurnStartedAt?: number;
activeJobId?: string;
lastQueuedAt?: string;
queuedCount: number;
constraints: string[];
}
interface FaceHeartbeatState {
schemaVersion: typeof HEARTBEAT_SCHEMA_VERSION;
initiativeClock: number;
baseRecoveryMinutes: number;
globalHeat: number;
lastTickAt?: string;
participants: FaceHeartbeatParticipant[];
history: Array<Record<string, unknown>>;
pendingMentions: RepoFacePendingMention[];
controls: FaceHeartbeatControls;
}
interface FaceHeartbeatControls {
cadenceMultiplier: number;
manualTurnRequests: ManualTurnRequest[];
updatedAt?: string;
}
interface ManualTurnRequest {
id: string;
identityId: string;
requestedAt: string;
status: "pending" | "applied" | "consumed" | "rejected";
note?: string;
}
interface ActiveTurnScan {
active: Map<string, string>;
staleRecovered: StaleActiveTurn[];
}
interface IdleCoolingSnapshot {
enabled: boolean;
active: boolean;
reason?: string;
checkedChannelIds: string[];
lastHumanActivityAt?: string;
idleForMinutes?: number;
idleAfterMinutes: number;
recoveryMinutes: number;
napAfterMinutes: number;
napModeActive?: boolean;
lastUnpromptedTurnQueuedAt?: string;
nextUnpromptedTurnAllowedAt?: string;
}
interface StaleActiveTurn {
identityId: string;
jobId: string;
requestMessageId?: string;
state: string;
updatedAt?: string;
ageMinutes: number;
}
interface RepoFaceChannelPlan {
primaryChannelId?: string;
snapshotChannelIds: string[];
options: RepoFaceChannelOption[];
lowThresholdTopics: string[];
}
interface RepoFaceChannelOption {
channelId: string;
label: string;
topic: string;
speechThreshold: "very_low" | "low" | "medium" | "high";
speedMultiplier: number;
posture?: string;
}
interface RepoFaceRuntimePressureSnapshot {
needToSpeak: number;
confessionPressure: number;
noveltyPressure: number;
}
interface RepoFaceMemoryMaintenanceEvent {
type:
| "repo_face_memory_maintenance_started"
| "repo_face_memory_maintenance_completed"
| "repo_face_memory_maintenance_failed"
| "repo_face_memory_maintenance_failed_to_start";
identityId: string;
observedAt: string;
reason?: string;
statusPath?: string;
pid?: number;
exitCode?: number | null;
durationSeconds?: number;
failureReason?: string;
}
interface BifrostGovernanceDigest {
generatedAt: string;
topics: BifrostGovernanceTopic[];
}
interface BifrostGovernanceTopic {
id: string;
title: string;
jurisdictionRepoName: string;
jurisdictionAgentIdentity?: string;
status: string;
summaryMarkdown: string;
priority: number;
updatedAt: string;
approvedByAgent?: string;
dispatchRequestId?: string;
comments?: BifrostGovernanceComment[];
}
interface BifrostGovernanceComment {
id: string;
authorKind: string;
authorId: string;
stance: string;
bodyMarkdown: string;
createdAt: string;
}
interface ChannelSnapshot {
channelId: string;
messages: SourceMessage[];
}
async function main(): Promise<void> {
const config = loadConfig();
const dryRun = process.argv.includes("--dry-run");
const maintenanceOnly = process.argv.includes("--maintenance-only");
const assemblePromptIdentity = readArgValue("--assemble-prompt");
if (assemblePromptIdentity) {
const result = await assembleRepoFaceTurnPrompt({
config,
identityId: assemblePromptIdentity,
outPath: readArgValue("--out"),
memorySurfacePath: readArgValue("--memory-surface"),
conversationSurfacePath: readArgValue("--conversation-surface"),
});
process.stdout.write(`${JSON.stringify(result)}\n`);
return;
}
if (maintenanceOnly) {
if (!config.repoFaceHeartbeats.enabled && !process.argv.includes("--force")) {
process.stdout.write(`${JSON.stringify({
ok: true,
skipped: true,
reason: "repo_face_heartbeats_disabled",
})}\n`);
return;
}
const faceRegistry = await loadFaceIdentityRegistry(config.repoDiscordIdentitiesPath);
const registry = faceRegistryAsRepoDiscordRegistry(faceRegistry);
const state = await readHeartbeatState(config.repoFaceHeartbeats.statePath);
state.controls = normalizeHeartbeatControls(state.controls);
const now = new Date();
const idleCooling = await readIdleCoolingSnapshot({
config,
identities: registry.identities,
state,
now,
});
const runtimeSnapshots = await loadRepoFaceRuntimeSnapshots(
registry.identities,
config.storageRoot,
state,
{
dryRun,
idleCooling,
startMemoryMaintenance: true,
maxMaintenanceRuns: readIntArgValue("--max-maintenance-runs", 1),
waitForMaintenanceCompletion: true,
},
);
state.lastTickAt = now.toISOString();
state.history.push({
type: "repo_face_memory_maintenance_tick",
observedAt: state.lastTickAt,
dryRun,
idleCooling,
maintenanceEventCount: runtimeSnapshots.maintenanceEvents.length,
});
state.history = state.history.slice(-80);
if (!dryRun) {
await writeHeartbeatState(config.repoFaceHeartbeats.statePath, state);
}
const ok = runtimeSnapshots.maintenanceEvents.every((event) =>
event.type !== "repo_face_memory_maintenance_failed_to_start" &&
event.type !== "repo_face_memory_maintenance_failed"
);
process.stdout.write(`${JSON.stringify({
ok,
dryRun,
maintenanceOnly: true,
maintenanceEventCount: runtimeSnapshots.maintenanceEvents.length,
maintenanceEvents: runtimeSnapshots.maintenanceEvents,
statePath: config.repoFaceHeartbeats.statePath,
})}\n`);
if (!ok) {
process.exitCode = 1;
}
return;
}
const pause = await readAgentSwarmPause();
if (pause.paused) {
const state = await readHeartbeatState(config.repoFaceHeartbeats.statePath);
state.lastTickAt = new Date().toISOString();
state.history.push({
type: "skipped",
reason: "agent_swarm_paused",
skippedAt: state.lastTickAt,
pausePath: pause.path,
pauseReason: pause.reason,
});
state.history = state.history.slice(-80);
if (!dryRun) {
await writeHeartbeatState(config.repoFaceHeartbeats.statePath, state);
}
process.stdout.write(
`${JSON.stringify({
ok: true,
queuedCount: 0,
dryRun,
skipped: true,
reason: "agent_swarm_paused",
pausePath: pause.path,
statePath: config.repoFaceHeartbeats.statePath,
})}\n`,
);
return;
}
if (!config.repoFaceHeartbeats.enabled && !process.argv.includes("--force")) {
const state = await readHeartbeatState(config.repoFaceHeartbeats.statePath);
state.lastTickAt = new Date().toISOString();
state.history.push({
type: "skipped",
reason: "repo_face_heartbeats_disabled",
skippedAt: state.lastTickAt,
});
state.history = state.history.slice(-80);
await writeHeartbeatState(config.repoFaceHeartbeats.statePath, state);
return;
}
const faceRegistry = await loadFaceIdentityRegistry(config.repoDiscordIdentitiesPath);
const registry = faceRegistryAsRepoDiscordRegistry(faceRegistry);
const state = await readHeartbeatState(config.repoFaceHeartbeats.statePath);
state.controls = normalizeHeartbeatControls(state.controls);
const now = new Date();
const idleCooling = await readIdleCoolingSnapshot({
config,
identities: registry.identities,
state,
now,
});
const runtimeSnapshots = await loadRepoFaceRuntimeSnapshots(
registry.identities,
config.storageRoot,
state,
{ dryRun, idleCooling, startMemoryMaintenance: false },
);
advanceInitiativeClockFromWallClock(state, now);
const activeTurnScan = dryRun
? { active: new Map<string, string>(), staleRecovered: [] }
: await listExistingActiveTurns(config.databaseDsn, config.stateStorageBackend, config);
for (const stale of activeTurnScan.staleRecovered) {
state.history.push({
type: "stale_active_turn_recovered",
identityId: stale.identityId,
activeJobId: stale.jobId,
requestMessageId: stale.requestMessageId,
jobState: stale.state,
jobUpdatedAt: stale.updatedAt,
ageMinutes: stale.ageMinutes,
recoveredAt: now.toISOString(),
});
}
state.baseRecoveryMinutes = config.repoFaceHeartbeats.baseRecoveryMinutes;
const cadenceMultiplier = clamp(state.controls.cadenceMultiplier, 0.01, 12);
const effectiveGlobalHeat = config.repoFaceHeartbeats.globalHeat * cadenceMultiplier;
state.globalHeat = effectiveGlobalHeat;
const completedThisTick = new Set<string>();
state.participants = reconcileParticipants(
state.participants,
buildParticipantSpecs(registry.identities),
config.repoFaceHeartbeats.defaultChannelId,
config.repoFaceHeartbeats.speedOverrides,
config.repoFaceHeartbeats.heatOverrides,
state.initiativeClock,
config.repoFaceHeartbeats.baseRecoveryMinutes,
effectiveGlobalHeat,
runtimeSnapshots.pressureByIdentity,
).map((participant) =>
applyActiveTurnFreeze(
participant,
activeTurnScan.active.get(participant.identityId),
state,
completedThisTick,
),
);
rescheduleStaleOverdueParticipants(state);
applyPendingMentionPriority(state);
const manualOverrideIdentities = applyManualTurnRequests(state, now);
reinitializeCtbSpacingOnWake({
state,
restStates: runtimeSnapshots.restStates,
idleCooling,
maxJobs: config.repoFaceHeartbeats.maxJobsPerTick,
manualOverrideIdentities,
});
const selected = selectReadyParticipants(
state,
config.repoFaceHeartbeats.maxJobsPerTick,
completedThisTick,
runtimeSnapshots.restStates,
idleCooling,
manualOverrideIdentities,
);
const queuedIdentityIds: string[] = [];
if (selected.length > 0 && dryRun) {
const queuedAt = new Date().toISOString();
for (const participant of selected) {
const pendingMentions = pendingMentionsForParticipant(state, participant.identityId);
const recoveryMinutes = recoveryFor(participant);
participant.lastQueuedAt = queuedAt;
participant.lastTurnAt = state.initiativeClock;
participant.queuedCount += 1;
participant.nextTurnAt = Math.max(state.initiativeClock, participant.nextTurnAt) + recoveryMinutes;
consumeManualTurnRequests(state, participant.identityId, "consumed", "dry run selected");
queuedIdentityIds.push(participant.identityId);
state.history.push({
type: "dry_run_selected",
identityId: participant.identityId,
queuedAt,
initiativeClock: state.initiativeClock,
nextTurnAt: participant.nextTurnAt,
recoveryMinutes,
heat: participant.heat,
effectiveSpeed: participant.effectiveSpeed,
pendingMentionCount: pendingMentions.length,
});
}
} else if (selected.length > 0) {
const storage = await createStateStorage({
backend: config.stateStorageBackend,
databaseDsn: config.databaseDsn,
jobsFile: config.jobsFile,
auditLogFile: config.auditLogFile,
interactionMemoryFile: config.interactionMemoryFile,
rateLimitStateFile: config.rateLimitStateFile,
});
try {
for (const participant of selected) {
const queuedAt = new Date().toISOString();
const pendingMentions = pendingMentionsForParticipant(state, participant.identityId);
const turn = await queueParticipantTurn({
participant,
pendingMentions,
registryIdentities: registry.identities,
config,
storage,
queuedAt,
});
if (turn.created) {
queuedIdentityIds.push(participant.identityId);
participant.lastQueuedAt = queuedAt;
participant.activeTurnStartedAt = state.initiativeClock;
participant.activeJobId = turn.activeJobId;
participant.lastTurnAt = state.initiativeClock;
participant.queuedCount += 1;
participant.currentLoad = 1;
consumeManualTurnRequests(state, participant.identityId, "consumed", `queued ${turn.activeJobId}`);
if (pendingMentions.length > 0) {
const consumedIds = new Set(pendingMentions.map((entry) => entry.id));
state.pendingMentions = state.pendingMentions.filter((entry) => !consumedIds.has(entry.id));
}
state.history.push({
type: "queued",
identityId: participant.identityId,
participantKind: participant.participantKind,
turnKind: participant.turnKind,
activeJobId: turn.activeJobId,
requestMessageId: turn.requestMessageId,
queuedAt,
initiativeClock: state.initiativeClock,
frozen: true,
heat: participant.heat,
effectiveSpeed: participant.effectiveSpeed,
pendingMentionCount: pendingMentions.length,
});
} else if (turn.failureReason) {
participant.currentLoad = 0;
state.history.push({
type: "turn_failed_to_start",
identityId: participant.identityId,
participantKind: participant.participantKind,
turnKind: participant.turnKind,
activeJobId: turn.activeJobId,
requestMessageId: turn.requestMessageId,
queuedAt,
initiativeClock: state.initiativeClock,
reason: turn.failureReason,
heat: participant.heat,
effectiveSpeed: participant.effectiveSpeed,
});
}
}
} finally {
await storage.close();
}
}
state.history = state.history.slice(-80);
state.lastTickAt = now.toISOString();
if (!dryRun) {
await writeHeartbeatState(config.repoFaceHeartbeats.statePath, state);
}
process.stdout.write(
`${JSON.stringify({
ok: true,
participantCount: state.participants.length,
initiativeClock: state.initiativeClock,
queuedCount: queuedIdentityIds.length,
dryRun,
selected: selected.map((entry) => entry.identityId),
queued: queuedIdentityIds,
statePath: config.repoFaceHeartbeats.statePath,
idleCooling,
})}\n`,
);
}
async function readAgentSwarmPause(): Promise<{ paused: boolean; path: string; reason?: string }> {
const path = resolve(process.cwd(), "state", "agent-swarm-paused.json");
try {
const parsed = JSON.parse(stripLeadingBom(await readFile(path, "utf8"))) as Record<string, unknown>;
return {
paused: parsed.paused !== false,
path,
reason: typeof parsed.reason === "string" ? parsed.reason : undefined,
};
} catch (error) {
if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
return { paused: false, path };
}
return {
paused: true,
path,
reason: "Pause file exists but could not be parsed; failing closed.",
};
}
}
interface ParticipantSpec {
id: string;
participantKind: FaceHeartbeatParticipant["participantKind"];
turnKind: FaceHeartbeatParticipant["turnKind"];
repoName: string;
displayName: string;
allowedChannelIds: string[];
channelSpeedMultiplier: number;
identity?: RepoDiscordIdentity;
}
function buildParticipantSpecs(identities: RepoDiscordIdentity[]): ParticipantSpec[] {
return [
{
id: "void",
participantKind: "system_agent",
turnKind: "void_moderation",
repoName: "VoidBot",
displayName: "Void",
allowedChannelIds: [],
channelSpeedMultiplier: 1,
},
...identities.map((identity) => ({
id: identity.id,
participantKind: "repo_face" as const,
turnKind: "repo_face_rumination" as const,
repoName: identity.repoName,
displayName: identity.displayName,
allowedChannelIds: getRepoDiscordIdentityAllowedChannelIds(identity),
channelSpeedMultiplier: channelSpeedMultiplierFor(identity),
identity,
})),
];
}
async function queueParticipantTurn(input: {
participant: FaceHeartbeatParticipant;
pendingMentions: RepoFacePendingMention[];
registryIdentities: RepoDiscordIdentity[];
config: ReturnType<typeof loadConfig>;
storage: Awaited<ReturnType<typeof createStateStorage>>;
queuedAt: string;
}): Promise<{ created: boolean; activeJobId?: string; requestMessageId?: string; failureReason?: string }> {
switch (input.participant.turnKind) {
case "repo_face_rumination":
return queueRepoFaceTurn(input);
case "void_moderation":
return startVoidModerationTurn({
queuedAt: input.queuedAt,
storageRoot: input.config.storageRoot,
pendingMentions: input.pendingMentions,
});
}
}
async function queueRepoFaceTurn(input: {
participant: FaceHeartbeatParticipant;
pendingMentions: RepoFacePendingMention[];
registryIdentities: RepoDiscordIdentity[];
config: ReturnType<typeof loadConfig>;
storage: Awaited<ReturnType<typeof createStateStorage>>;
queuedAt: string;
}): Promise<{ created: boolean; activeJobId?: string; requestMessageId?: string; failureReason?: string }> {
const identity = input.registryIdentities.find((entry) => entry.id === input.participant.identityId);
if (!identity) {
return { created: false };
}
const preferredChannelId = newestPendingMentionChannel(input.pendingMentions);
const channelPlan = buildChannelPlan(
identity,
input.config.repoFaceHeartbeats.defaultChannelId,
preferredChannelId,
);
const channelId = channelPlan.primaryChannelId;
if (!channelId) {
input.participant.status = "blocked";
input.participant.constraints = mergeStrings(
input.participant.constraints,
"No CTB turn channel is configured for this Face.",
);
return { created: false };
}
const contextBuilder = new ContextBuilder();
await ensureRepoFaceInitialized({
identity,
storageRoot: input.config.storageRoot,
sourceRepoRoot: input.config.sourceRepoRoot,
epiphanyAgentRoot: input.config.epiphanyAgentRoot,
workspaceRoot: process.cwd(),
birthMode: input.config.repoFaceBirthMode,
birthExecutor: input.config.repoFaceBirthExecutor,
});
const recentMessages = await fetchRecentDiscordMessages({
botToken: input.config.botToken,
channelId,
limit: 15,
ignoreBotMessages: channelId === input.config.bifrostDiscordChannelId,
});
const channelSnapshots = await fetchChannelSnapshots({
botToken: input.config.botToken,
channelIds: channelPlan.snapshotChannelIds,
primaryChannelId: channelId,
limit: 6,
bifrostDiscordChannelId: input.config.bifrostDiscordChannelId,
});
const bifrostDigest = input.config.repoFaceBifrostEnabled
? await fetchBifrostGovernanceDigest({
bifrostRoot: input.config.bifrostRoot,
repoName: identity.repoName,
agentIdentity: identity.id,
})
: undefined;
const roomContext = {
recentMessages,
channelSnapshots,
};
const humanPronounGuidance = await loadRepoFaceHumanPronounGuidance(input.config, roomContext);
const memorySurface = await renderRepoFaceMemorySurfaceForTurn(
identity,
input.config,
input.registryIdentities,
roomContext,
humanPronounGuidance,
);
const repoActivitySurface = renderRepoFaceRepoActivitySurface(identity, input.config);
const globalAgentDoctrine = await loadGlobalAgentDoctrine();
const conversationMemorySurface = renderRepoFaceConversationTranscript({
identity,
recentMessages,
channelSnapshots,
pendingMentions: input.pendingMentions,
channelPlan,
});
const prompt = buildHeartbeatPrompt({
identity,
channelId,
channelPlan,
channelSnapshots,
recentMessages,
memorySurface,
repoActivitySurface,
conversationMemorySurface,
humanPronounGuidance,
bifrostDigest,
participant: input.participant,
pendingMentions: input.pendingMentions,
jurisdictionDive: buildJurisdictionDiveDirective(identity, input.participant),
githubActionsEnabled: input.config.repoFaceGithubActionsEnabled,
globalAgentDoctrine,
});
const imageAttachments = collectPromptImageAttachments([
recentMessages,
...channelSnapshots.map((snapshot) => snapshot.messages),
].flat());
const contextBundle = contextBuilder.build({
prompt,
actor: {
id: "voidbot-agent-turn",
displayName: "VoidBot Agent Turn",
isAdmin: true,
isBot: true,
},
guildContext: {
channelId,
},
recentMessages,
imageAttachments,
retrieval: [],
voidSelfState: undefined,
});
const requestMessageId = `agent-turn:${identity.id}:${input.queuedAt}`;
const result = await input.storage.jobQueue.createJob({
command: HEARTBEAT_COMMAND,
provider: "owner_codex",
runApprovalRequired: false,
postApprovalRequired: false,
requester: contextBundle.actor,
guildContext: contextBundle.guildContext,
prompt,
contextBundle,
outputChannelId: channelId,
requestMessageId,
initialState: "approved",
});
return {
created: result.created,
activeJobId: result.job.id,
requestMessageId,
};
}
async function loadRepoFaceRuntimeSnapshots(
identities: RepoDiscordIdentity[],
storageRoot: string,
heartbeatState: FaceHeartbeatState,
options: {
dryRun?: boolean;
idleCooling?: IdleCoolingSnapshot;
startMemoryMaintenance?: boolean;
maxMaintenanceRuns?: number;
waitForMaintenanceCompletion?: boolean;
} = {},
): Promise<{
restStates: Map<string, RepoFaceRestSnapshot>;
pressureByIdentity: Map<string, RepoFaceRuntimePressureSnapshot>;
maintenanceEvents: RepoFaceMemoryMaintenanceEvent[];
}> {
const restStates = new Map<string, RepoFaceRestSnapshot>();
const pressureByIdentity = new Map<string, RepoFaceRuntimePressureSnapshot>();
const maintenanceEvents: RepoFaceMemoryMaintenanceEvent[] = [];
let maintenanceRunCount = 0;
const maxMaintenanceRuns = Math.max(0, options.maxMaintenanceRuns ?? Number.POSITIVE_INFINITY);
const now = new Date();
for (const identity of identities) {
try {
const statePath = resolveRepoFaceStatePath(identity, storageRoot);
const typedState = await loadVoidSelfStateTypedDocuments({
canonicalPath: statePath,
identity: {
agentId: identity.id,
publicName: identity.displayName,
publicDescription: identity.description,
},
});
const projected = projectRepoFaceSleepCycleForNow(
typedState.scheduledRuntime.sleepCycle,
identity.id,
now,
);
const sleepCycle = projectSleepCycleForOperatorAbsence(
projected.sleepCycle,
options.idleCooling,
now,
);
if (!options.dryRun && !sleepCyclesEqual(typedState.scheduledRuntime.sleepCycle, sleepCycle)) {
await applyVoidSelfStateOperation(
{
canonicalPath: statePath,
identity: {
agentId: identity.id,
publicName: identity.displayName,
publicDescription: identity.description,
},
},
{
operation: "update_sleep_cycle",
sleepCycle,
},
);
}
const speakingPressure = buildRepoFaceSpeakingPressure(
typedState,
sleepCycle,
now,
);
pressureByIdentity.set(identity.id, {
needToSpeak: speakingPressure.needToSpeak,
confessionPressure: speakingPressure.confessionPressure ?? 0,
noveltyPressure: speakingPressure.noveltyPressure ?? 0,
});
if (!options.dryRun && !speakingPressuresEqual(typedState.scheduledRuntime.speakingPressure, speakingPressure)) {
await applyVoidSelfStateOperation(
{
canonicalPath: statePath,
identity: {
agentId: identity.id,
publicName: identity.displayName,
publicDescription: identity.description,
},
},
{
operation: "update_speaking_pressure",
speakingPressure,
},
);
}
const maintenance = options.dryRun || options.startMemoryMaintenance !== true || maintenanceRunCount >= maxMaintenanceRuns
? { started: false, reason: "dry_run", statusPath: undefined }
: await maybeStartRepoFaceMemoryMaintenance({
identity,
statePath,
typedState,
projectedRest: {
isNapping: sleepCycle.isNapping === true,
napEndsAt: sleepCycle.currentNapEndsAt,
nextNapStartsAt: sleepCycle.nextNapStartsAt,
},
waitForCompletion: options.waitForMaintenanceCompletion === true,
});
if (maintenance.started || maintenance.failureReason) {
maintenanceRunCount += 1;
}
if (maintenance.started || maintenance.failureReason || maintenance.completed) {
const event: RepoFaceMemoryMaintenanceEvent = {
type: maintenance.completed
? "repo_face_memory_maintenance_completed"
: maintenance.started
? "repo_face_memory_maintenance_started"
: maintenance.exitCode === undefined
? "repo_face_memory_maintenance_failed_to_start"
: "repo_face_memory_maintenance_failed",
identityId: identity.id,
observedAt: now.toISOString(),
reason: maintenance.reason,
statusPath: maintenance.statusPath,
pid: maintenance.pid,
exitCode: maintenance.exitCode,
durationSeconds: maintenance.durationSeconds,
failureReason: maintenance.failureReason,
};
heartbeatState.history.push(event);
maintenanceEvents.push(event);
}
restStates.set(identity.id, {
isNapping: sleepCycle.isNapping === true,
napEndsAt: sleepCycle.currentNapEndsAt,
nextNapStartsAt: sleepCycle.nextNapStartsAt,
});
} catch (error) {
const code = (error as NodeJS.ErrnoException).code;
if (code !== "ENOENT") {
throw error;
}
}
}
return { restStates, pressureByIdentity, maintenanceEvents };
}
function projectSleepCycleForOperatorAbsence(
sleepCycle: VoidScheduledRuntime["sleepCycle"],
idleCooling: IdleCoolingSnapshot | undefined,
now: Date,
): VoidScheduledRuntime["sleepCycle"] {
if (idleCooling?.napModeActive !== true) {
const activeDreamThemes = sleepCycle.activeDreamThemes.filter((theme) => theme !== "operator-absence-dreaming");
if (sleepCycle.isNapping !== true || !sleepCycle.activeDreamThemes.includes("operator-absence-dreaming")) {
return activeDreamThemes.length === sleepCycle.activeDreamThemes.length
? sleepCycle
: {
...sleepCycle,
activeDreamThemes,
};
}
return {
...sleepCycle,
isNapping: false,
currentNapStartedAt: undefined,
currentNapEndsAt: undefined,
nextNapStartsAt: new Date(now.getTime() + 180 * 60_000).toISOString(),
activeDreamThemes,
};
}
const nowMs = now.getTime();
const minimumNapMinutes = Math.max(60, Math.min(180, idleCooling.recoveryMinutes || 120));
const currentNapEndsMs = Date.parse(sleepCycle.currentNapEndsAt ?? "");
const desiredNapEndsMs = nowMs + minimumNapMinutes * 60_000;
const napEndsMs = Number.isFinite(currentNapEndsMs)
? Math.max(currentNapEndsMs, desiredNapEndsMs)
: desiredNapEndsMs;
const activeDreamThemes = Array.from(new Set([
...sleepCycle.activeDreamThemes,
"operator-absence-dreaming",
"memory-distillation",
]));
return {
...sleepCycle,
isNapping: true,
currentNapStartedAt: sleepCycle.isNapping && sleepCycle.currentNapStartedAt
? sleepCycle.currentNapStartedAt
: now.toISOString(),
currentNapEndsAt: new Date(napEndsMs).toISOString(),
nextNapStartsAt: new Date(napEndsMs + 180 * 60_000).toISOString(),
activeDreamThemes,
};
}
function buildRepoFaceSpeakingPressure(
typedState: Awaited<ReturnType<typeof loadVoidSelfStateTypedDocuments>>,
sleepCycle: Awaited<ReturnType<typeof projectRepoFaceSleepCycleForNow>>["sleepCycle"],
now: Date,
): Awaited<ReturnType<typeof loadVoidSelfStateTypedDocuments>>["scheduledRuntime"]["speakingPressure"] {
const previous = typedState.scheduledRuntime.speakingPressure;
const lastReceipt = typedState.speechReceipts.recentReceipts
.slice()
.sort((left, right) => Date.parse(right.sentAt) - Date.parse(left.sentAt))
[0];
const lastSpokeAt = lastReceipt?.sentAt ?? previous.lastSpokeAt;
const hoursSinceSpeech = lastSpokeAt ? Math.max(0, (now.getTime() - Date.parse(lastSpokeAt)) / 3_600_000) : 24;
const recentSpeechDamping = clamp(Math.exp(-hoursSinceSpeech / 3.5), 0, 1);
const affectNeedPressure = (typedState.faceAffect.needs ?? [])
.filter((entry) => entry.status === "active" || entry.status === "neglected")
.reduce((sum, entry) => {
const neglectedWeight = entry.status === "neglected" ? 1.25 : 1;
const substrateWeight = ["substrate", "agency", "status", "territory", "recognition"].includes(entry.kind) ? 0.18 : 0.11;
return sum + entry.intensity * substrateWeight * neglectedWeight;
}, 0);
const statusReadPressure = (typedState.faceAffect.statusReads ?? [])
.filter((entry) => !entry.retiredAt)
.reduce((sum, entry) => {
const sharpWeight = ["neglected", "bypassed", "blocked", "ignored", "threatened", "challenged"].includes(entry.status) ? 0.14 : 0.08;
return sum + entry.intensity * sharpWeight;
}, 0);
const socialBondPressure = (typedState.faceAffect.socialBonds ?? [])
.filter((entry) => entry.status === "active")
.reduce((sum, entry) => sum + entry.intensity * 0.07, 0);
const moodPressure = (typedState.faceAffect.moodDimensions ?? [])
.reduce((sum, entry) => {
const expressiveWeight = ["anger", "annoyance", "irritation", "envy", "pride", "smugness", "playfulness", "anxiety", "commandForce", "restlessness"].includes(entry.name)
? 0.06
: 0.025;
return sum + entry.value * expressiveWeight;
}, 0);
const socialBiasPressure = (typedState.faceAffect.socialBiases ?? [])
.reduce((sum, entry) => {
const pressureWeight = ["neuroticism", "threat_sensitivity", "hostile_attribution_bias", "reassurance_need", "grievance_retention", "status_vigilance"].includes(entry.name)
? 0.055
: -0.025;
return sum + entry.value * pressureWeight;
}, 0);
const agencyPressure = typedState.agencyPressure.pressures
.filter((entry) => entry.status === "active" || entry.status === "ready_to_act")
.reduce((sum, entry) => sum + entry.intensity * (entry.kind.includes("advocacy") ? 0.22 : 0.11), 0);
const candidatePressure = typedState.candidateInterventions.interventions
.filter((entry) => entry.status === "queued" || entry.status === "deferred")
.reduce((sum, entry) => sum + entry.priority * (entry.mustEventuallyShare ? 0.22 : 0.12), 0);
const silencePressure = clamp(hoursSinceSpeech / 8, 0, 1);
const sleepiness = sleepCycle.isNapping ? 0.22 : 0;
const targetNeed = clamp(
0.12 + silencePressure * 0.18 + affectNeedPressure + statusReadPressure + socialBondPressure + moodPressure + socialBiasPressure + agencyPressure + candidatePressure - recentSpeechDamping * 0.24 - sleepiness,
0,
1,
);
const needToSpeak = round3(clamp((previous.needToSpeak ?? 0.25) * 0.58 + targetNeed * 0.42, 0, 1));
return {
needToSpeak,
confessionPressure: round3(clamp((previous.confessionPressure ?? 0.2) * 0.7 + moodPressure * 0.42 + socialBondPressure * 0.18 + socialBiasPressure * 0.2, 0, 1)),
noveltyPressure: round3(clamp((previous.noveltyPressure ?? 0.25) * 0.62 + affectNeedPressure * 0.35 + statusReadPressure * 0.24 + socialBiasPressure * 0.18 + candidatePressure * 0.28, 0, 1)),
recentSpeechDamping: round3(recentSpeechDamping),
lastSpokeAt,
};
}
function speakingPressuresEqual(
left: Awaited<ReturnType<typeof loadVoidSelfStateTypedDocuments>>["scheduledRuntime"]["speakingPressure"],
right: Awaited<ReturnType<typeof loadVoidSelfStateTypedDocuments>>["scheduledRuntime"]["speakingPressure"],
): boolean {
return left.needToSpeak === right.needToSpeak
&& left.confessionPressure === right.confessionPressure
&& left.noveltyPressure === right.noveltyPressure
&& left.recentSpeechDamping === right.recentSpeechDamping
&& left.lastSpokeAt === right.lastSpokeAt;
}
async function maybeStartRepoFaceMemoryMaintenance(input: {
identity: RepoDiscordIdentity;
statePath: string;
typedState: Awaited<ReturnType<typeof loadVoidSelfStateTypedDocuments>>;
projectedRest: RepoFaceRestSnapshot;
waitForCompletion?: boolean;
}): Promise<{
started: boolean;
completed?: boolean;
reason?: string;
statusPath?: string;
pid?: number;
exitCode?: number | null;
durationSeconds?: number;
failureReason?: string;
}> {
const shortTerm = input.typedState.thoughtMemory.shortTerm ?? [];
if (shortTerm.length === 0) {
return { started: false, reason: "no_short_term_memory" };
}
const oldestShortTermMs = Math.min(
...shortTerm.map((memory) => Date.parse(memory.updatedAt)).filter(Number.isFinite),
);
const hasStaleShortTerm =
Number.isFinite(oldestShortTermMs) &&
Date.now() - oldestShortTermMs >= 6 * 60 * 60 * 1000;
if (input.projectedRest.isNapping !== true && !hasStaleShortTerm) {
return { started: false, reason: "not_napping_or_stale" };
}
const paths = repoFaceMemoryMaintenancePaths(input.statePath);
const currentStatus = await readJsonFile(paths.statusPath);
if (isRecentRunningStatus(currentStatus, 25)) {
return { started: false, reason: "maintenance_already_running", statusPath: paths.statusPath };
}
if (input.projectedRest.isNapping === true && isStatusCompletedRecently(currentStatus, 60)) {
return { started: false, reason: "nap_maintenance_recently_completed", statusPath: paths.statusPath };
}
if (isStatusCompletedAfter(currentStatus, newestTimestampMs(shortTerm))) {
return { started: false, reason: "maintenance_already_completed_for_sources", statusPath: paths.statusPath };
}
const reason = input.projectedRest.isNapping
? "repo_face_napping_with_short_term_memory"
: "repo_face_stale_short_term_memory";
try {
await mkdir(paths.statusDir, { recursive: true });
await mkdir(paths.logDir, { recursive: true });
await writeFile(paths.statusPath, `${JSON.stringify({
status: "starting",
startedAt: new Date().toISOString(),
stateFile: input.statePath,
reason,
shortTermCount: shortTerm.length,
newestShortTermUpdatedAt: newestTimestampMs(shortTerm) > 0
? new Date(newestTimestampMs(shortTerm)).toISOString()
: undefined,
}, null, 2)}\n`, "utf8");
if (input.waitForCompletion === true) {
const startedAtMs = Date.now();
const stamp = new Date(startedAtMs).toISOString().replace(/[:.]/g, "-");
const stdoutPath = resolve(paths.logDir, `repo-face-memory-maintenance-${input.identity.id}-${stamp}.stdout.log`);
const stderrPath = resolve(paths.logDir, `repo-face-memory-maintenance-${input.identity.id}-${stamp}.stderr.log`);
const maxRuntimeMinutes = Number.parseInt(process.env.VOID_MEMORY_MAINTENANCE_MAX_RUNTIME_MINUTES ?? "15", 10);
const result = spawnSync(
"powershell.exe",
[
"-NoProfile",
"-NonInteractive",
"-ExecutionPolicy",
"Bypass",
"-File",
resolve(process.cwd(), "scripts", "run-void-memory-maintenance.ps1"),
"-StateFilePath",
input.statePath,
"-ForceDistillation",
],
{
cwd: process.cwd(),
encoding: "utf8",
timeout: Math.max(5, maxRuntimeMinutes + 2) * 60_000,
windowsHide: true,
env: {
...process.env,
VOID_MEMORY_MAINTENANCE_STATUS_DIR: paths.statusDir,
VOID_MEMORY_MAINTENANCE_LOG_DIR: paths.logDir,
},
},
);
await writeFile(stdoutPath, result.stdout ?? "", "utf8");
await writeFile(stderrPath, result.stderr ?? "", "utf8");
const durationSeconds = round3((Date.now() - startedAtMs) / 1000);
if (result.error || result.status !== 0) {
const currentStatus = await readJsonFile(paths.statusPath);
if (currentStatus?.status === "starting" || currentStatus?.status === "running" || currentStatus?.status === "running_skip_model") {
await writeFile(paths.statusPath, `${JSON.stringify({
status: "failed",
startedAt: currentStatus.startedAt ?? new Date(startedAtMs).toISOString(),
finishedAt: new Date().toISOString(),
durationSeconds,
stateFile: input.statePath,
reason,
exitCode: result.status,
signal: result.signal,
error: result.error instanceof Error ? result.error.message : undefined,
stdoutPath,
stderrPath,
}, null, 2)}\n`, "utf8").catch(() => undefined);
}
return {
started: false,
reason,
statusPath: paths.statusPath,
exitCode: result.status,
durationSeconds,
failureReason: result.error instanceof Error
? result.error.message
: `memory maintenance exited with ${result.status ?? result.signal ?? "unknown status"}`,
};
}
return {
started: true,
completed: true,
reason,
statusPath: paths.statusPath,
exitCode: result.status,
durationSeconds,
};
}
const child = spawn(
"powershell.exe",
[
"-NoProfile",
"-NonInteractive",
"-ExecutionPolicy",
"Bypass",
"-File",
resolve(process.cwd(), "scripts", "run-void-memory-maintenance.ps1"),
"-StateFilePath",
input.statePath,
"-ForceDistillation",
],
{
cwd: process.cwd(),
detached: true,
stdio: "ignore",
windowsHide: true,
env: {
...process.env,
VOID_MEMORY_MAINTENANCE_STATUS_DIR: paths.statusDir,
VOID_MEMORY_MAINTENANCE_LOG_DIR: paths.logDir,
},
},
);
child.unref();
return {
started: true,
reason,
statusPath: paths.statusPath,
pid: child.pid,
};
} catch (error) {
await writeFile(paths.statusPath, `${JSON.stringify({
status: "failed_to_start",
startedAt: new Date().toISOString(),
stateFile: input.statePath,
reason,
error: error instanceof Error ? error.message : String(error),
}, null, 2)}\n`, "utf8").catch(() => undefined);
return {
started: false,
reason: "spawn_failed",
statusPath: paths.statusPath,
failureReason: error instanceof Error ? error.message : String(error),
};
}
}
function repoFaceMemoryMaintenancePaths(statePath: string): {
statusDir: string;
logDir: string;
statusPath: string;
} {
const stateDir = dirname(statePath);
const voidbotRoot = dirname(stateDir);
const statusDir = resolve(voidbotRoot, "status");
const logDir = resolve(voidbotRoot, "logs");
return {
statusDir,
logDir,
statusPath: resolve(statusDir, "void-memory-maintenance.json"),
};
}
async function readJsonFile(path: string): Promise<Record<string, unknown> | undefined> {
try {
return JSON.parse(stripLeadingBom(await readFile(path, "utf8"))) as Record<string, unknown>;
} catch {
return undefined;
}
}
function isRecentRunningStatus(status: Record<string, unknown> | undefined, maxAgeMinutes: number): boolean {
if (status?.status !== "running" && status?.status !== "running_skip_model" && status?.status !== "starting") {
return false;
}
const startedAtMs = typeof status.startedAt === "string" ? Date.parse(status.startedAt) : NaN;
if (!Number.isFinite(startedAtMs)) {
return false;
}
if (status.status === "starting") {
const hasProcessEvidence = typeof status.pid === "number" || typeof status.lockPath === "string";
const startingGraceMs = hasProcessEvidence ? maxAgeMinutes * 60_000 : 60_000;
return Date.now() - startedAtMs < startingGraceMs;
}
return Date.now() - startedAtMs < maxAgeMinutes * 60_000;
}
function isStatusCompletedAfter(status: Record<string, unknown> | undefined, sourceTimestampMs: number): boolean {
if (status?.status !== "ok" || !Number.isFinite(sourceTimestampMs)) {
return false;
}
const finishedAtMs = typeof status.finishedAt === "string" ? Date.parse(status.finishedAt) : NaN;
return Number.isFinite(finishedAtMs) && finishedAtMs >= sourceTimestampMs;
}
function isStatusCompletedRecently(status: Record<string, unknown> | undefined, maxAgeMinutes: number): boolean {
if (status?.status !== "ok") {
return false;
}
const finishedAtMs = typeof status.finishedAt === "string" ? Date.parse(status.finishedAt) : NaN;
return Number.isFinite(finishedAtMs) && Date.now() - finishedAtMs < maxAgeMinutes * 60_000;
}
function newestTimestampMs(entries: Array<{ updatedAt: string }>): number {
return Math.max(...entries.map((entry) => Date.parse(entry.updatedAt)).filter(Number.isFinite));
}
function sleepCyclesEqual(left: unknown, right: unknown): boolean {
return JSON.stringify(left) === JSON.stringify(right);
}
async function fetchRecentDiscordMessages(input: {
botToken?: string;
channelId: string;
limit: number;
ignoreBotMessages?: boolean;
}): Promise<SourceMessage[]> {
if (!input.botToken) {
return [];
}
const url = new URL(`https://discord.com/api/v10/channels/${input.channelId}/messages`);
url.searchParams.set("limit", String(Math.max(1, Math.min(input.limit, 25))));
const response = await fetch(url, {
headers: {
Authorization: `Bot ${input.botToken}`,
},
});
if (!response.ok) {
throw new Error(`Discord recent message fetch failed with ${response.status}: ${await response.text()}`);
}
const messages = await response.json() as DiscordApiMessage[];
const sourceMessages = await Promise.all(messages
.filter((message) => !(input.ignoreBotMessages && message.author.bot === true))
.map(async (message) => {
const attachments = await materializeDiscordAttachments({
channelId: input.channelId,
message,
});
return {
id: message.id,
authorId: message.author.id,
authorName: message.author.global_name ?? message.member?.nick ?? message.author.username,
content: message.content,
timestamp: message.timestamp,
isBot: message.author.bot === true,
...(attachments.length > 0 ? { attachments } : {}),
};
}));
return sourceMessages
.sort((left, right) => Date.parse(left.timestamp) - Date.parse(right.timestamp));
}
async function fetchChannelSnapshots(input: {
botToken?: string;
channelIds: string[];
primaryChannelId: string;
limit: number;
bifrostDiscordChannelId?: string;
}): Promise<ChannelSnapshot[]> {
const snapshots: ChannelSnapshot[] = [];
for (const channelId of input.channelIds.filter((entry) => entry !== input.primaryChannelId).slice(0, 5)) {
try {
snapshots.push({
channelId,
messages: await fetchRecentDiscordMessages({
botToken: input.botToken,
channelId,
limit: input.limit,
ignoreBotMessages: channelId === input.bifrostDiscordChannelId,
}),
});
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
snapshots.push({
channelId,
messages: [{
id: `snapshot-error:${channelId}`,
authorId: "voidbot",
authorName: "VoidBot",
content: `Could not read recent channel context: ${message}`,
timestamp: new Date().toISOString(),
isBot: true,
}],
});
}
}
return snapshots;
}
async function materializeDiscordAttachments(input: {
channelId: string;
message: DiscordApiMessage;
}): Promise<SourceMessageAttachment[]> {
const attachments = input.message.attachments ?? [];
if (attachments.length === 0) {
return [];
}
const materialized: SourceMessageAttachment[] = [];
for (const attachment of attachments.slice(0, 4)) {
const kind = isDiscordImageAttachment(attachment) ? "image" : "other";
let localPath: string | undefined;
if (kind === "image" && isWithinFaceImageSizeLimit(attachment)) {
localPath = await cacheDiscordImageAttachment({
channelId: input.channelId,
messageId: input.message.id,
attachment,
});
}
materialized.push({
kind,
id: attachment.id,
filename: attachment.filename,
contentType: attachment.content_type,
url: attachment.url,
proxyUrl: attachment.proxy_url,
size: typeof attachment.size === "number" ? attachment.size : undefined,
width: typeof attachment.width === "number" ? attachment.width : undefined,
height: typeof attachment.height === "number" ? attachment.height : undefined,
localPath,
});
}
return materialized;
}
function isWithinFaceImageSizeLimit(attachment: DiscordApiAttachment): boolean {
return typeof attachment.size !== "number" || attachment.size <= MAX_FACE_IMAGE_ATTACHMENT_BYTES;
}
function isDiscordImageAttachment(attachment: DiscordApiAttachment): boolean {
const contentType = attachment.content_type?.toLowerCase() ?? "";
if (contentType.startsWith("image/")) {
return true;
}
return /\.(png|jpe?g|gif|webp)$/i.test(attachment.filename ?? attachment.url ?? "");
}
async function cacheDiscordImageAttachment(input: {
channelId: string;
messageId: string;
attachment: DiscordApiAttachment;
}): Promise<string | undefined> {
const sourceUrl = input.attachment.url ?? input.attachment.proxy_url;
if (!sourceUrl) {
return undefined;
}
const safeExtension = normalizedImageExtension(input.attachment);
const fileStem = [
input.messageId,
input.attachment.id ?? createHash("sha256").update(sourceUrl).digest("hex").slice(0, 12),
].join("-");
const directory = resolve(".voidbot", "media", "discord-images", input.channelId);
const localPath = resolve(directory, `${fileStem}${safeExtension}`);
try {
await stat(localPath);
return localPath;
} catch {
// Cache miss. Fall through to fetch.
}
try {
const response = await fetch(sourceUrl);
if (!response.ok) {
return undefined;
}
const arrayBuffer = await response.arrayBuffer();
await mkdir(directory, { recursive: true });
await writeFile(localPath, Buffer.from(arrayBuffer));
return localPath;
} catch {
return undefined;
}
}
function normalizedImageExtension(attachment: DiscordApiAttachment): string {
const fromName = extname(attachment.filename ?? "").toLowerCase();
if (/^\.(png|jpe?g|gif|webp)$/.test(fromName)) {
return fromName;
}
const contentType = attachment.content_type?.toLowerCase();
switch (contentType) {
case "image/jpeg":
return ".jpg";
case "image/gif":
return ".gif";
case "image/webp":
return ".webp";
case "image/png":
default:
return ".png";
}
}
async function fetchBifrostGovernanceDigest(input: {
bifrostRoot: string;
repoName: string;
agentIdentity: string;
}): Promise<BifrostGovernanceDigest | undefined> {
const scriptPath = resolve(input.bifrostRoot, "tools", "governance-threads.mjs");
const result = spawnSync(
process.execPath,
[
scriptPath,
"digest",
"--repo", input.repoName,
"--agent", input.agentIdentity,
"--limit", "6",
],
{
cwd: input.bifrostRoot,
encoding: "utf8",
stdio: ["ignore", "pipe", "pipe"],
windowsHide: true,
timeout: 30000,
},
);
if (result.status !== 0) {
return {
generatedAt: new Date().toISOString(),
topics: [{
id: "bifrost-digest-error",
title: "Bifrost governance digest unavailable",
jurisdictionRepoName: input.repoName,
jurisdictionAgentIdentity: input.agentIdentity,
status: "error",
summaryMarkdown: `Could not read Bifrost governance digest: ${result.stderr || result.error?.message || result.stdout || "unknown failure"}`,
priority: 0,
updatedAt: new Date().toISOString(),
comments: [],
}],
};
}
try {
return JSON.parse(result.stdout) as BifrostGovernanceDigest;
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
return {
generatedAt: new Date().toISOString(),
topics: [{
id: "bifrost-digest-parse-error",
title: "Bifrost governance digest parse failure",
jurisdictionRepoName: input.repoName,
jurisdictionAgentIdentity: input.agentIdentity,
status: "error",
summaryMarkdown: `Could not parse Bifrost governance digest: ${message}`,
priority: 0,
updatedAt: new Date().toISOString(),
comments: [],
}],
};
}
}
interface DiscordApiMessage {
id: string;
content: string;
timestamp: string;
attachments?: DiscordApiAttachment[];
author: {
id: string;
username: string;
global_name?: string | null;
bot?: boolean;
};
member?: {
nick?: string | null;
};
}
interface DiscordApiAttachment {
id?: string;
filename?: string;
content_type?: string;
size?: number;
url?: string;
proxy_url?: string;
width?: number | null;
height?: number | null;
}
async function startVoidModerationTurn(input: {
queuedAt: string;
storageRoot: string;
pendingMentions: RepoFacePendingMention[];
}): Promise<{ created: boolean; activeJobId?: string; requestMessageId?: string; failureReason?: string }> {
const runnerScript = resolve(process.cwd(), "scripts", "run-void-moderator-rumination.ps1");
const statusDir = resolve(input.storageRoot, "status");
const lockPath = resolve(statusDir, "moderation-rumination.lock");
const statusPath = resolve(statusDir, "moderation-rumination.json");
const pendingMentionsPath = resolve(statusDir, "void-moderation-pending-mentions.json");
const launchedAt = Date.now();
await mkdir(statusDir, { recursive: true });
await writeFile(
pendingMentionsPath,
`${JSON.stringify({
generatedAt: input.queuedAt,
pendingMentions: input.pendingMentions,
}, null, 2)}\n`,
"utf8",
);
const launchCommand = [
`$env:VOID_RUMINATION_PENDING_MENTIONS_PATH = ${toPowerShellSingleQuotedString(pendingMentionsPath)};`,
`$arguments = @(${[
"-NoProfile",
"-NonInteractive",
"-ExecutionPolicy",
"Bypass",
"-File",
runnerScript,
].map(toPowerShellSingleQuotedString).join(", ")});`,
`Start-Process -FilePath ${toPowerShellSingleQuotedString("powershell.exe")} -ArgumentList $arguments -WorkingDirectory ${toPowerShellSingleQuotedString(process.cwd())} -WindowStyle Hidden;`,
].join(" ");
const child = spawn(
"powershell.exe",
[
"-NoProfile",
"-NonInteractive",
"-ExecutionPolicy",
"Bypass",
"-Command",
launchCommand,
],
{
cwd: process.cwd(),
stdio: "ignore",
windowsHide: true,
},
);
child.unref();
const handshake = await waitForVoidModerationHandshake({
lockPath,
statusPath,
launchedAt,
timeoutMs: 60000,
});
if (!handshake.started) {
return {
created: false,
activeJobId: child.pid ? `launcher-process:${child.pid}` : undefined,
requestMessageId: `agent-turn:void:${input.queuedAt}`,
failureReason: handshake.reason,
};
}
return {
created: true,
activeJobId: `process:void-moderation:${input.queuedAt}`,
requestMessageId: `agent-turn:void:${input.queuedAt}`,
};
}
function toPowerShellSingleQuotedString(value: string): string {
return `'${value.replace(/'/g, "''")}'`;
}
async function waitForVoidModerationHandshake(input: {
lockPath: string;
statusPath: string;
launchedAt: number;
timeoutMs: number;
}): Promise<{ started: true } | { started: false; reason: string }> {
const deadline = Date.now() + input.timeoutMs;
while (Date.now() < deadline) {
if (await wasTouchedAfter(input.lockPath, input.launchedAt)) {
return { started: true };
}
if (await wasTouchedAfter(input.statusPath, input.launchedAt)) {
return { started: true };
}
await sleep(250);
}
return {
started: false,
reason: "void_moderation_launch_handshake_missing",
};
}
async function wasTouchedAfter(path: string, timestampMs: number): Promise<boolean> {
try {
const info = await stat(path);
return info.mtimeMs >= timestampMs - 500;
} catch {
return false;
}
}
function sleep(ms: number): Promise<void> {
return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
}
async function listExistingActiveTurns(
databaseDsn: string,
stateStorageBackend: "file" | "postgres",
config: ReturnType<typeof loadConfig>,
): Promise<ActiveTurnScan> {
const storage = await createStateStorage({
backend: stateStorageBackend,
databaseDsn,
jobsFile: config.jobsFile,
auditLogFile: config.auditLogFile,
interactionMemoryFile: config.interactionMemoryFile,
rateLimitStateFile: config.rateLimitStateFile,
});
try {
const jobs = await storage.jobQueue.listByStates(["approved", "running"]);
const active = new Map<string, string>();
const staleRecovered: StaleActiveTurn[] = [];
const staleAfterMs = Math.max(MIN_STALE_ACTIVE_JOB_MS, config.codexExecTimeoutMs * 3);
const nowMs = Date.now();
for (const job of jobs) {
if (job.command !== HEARTBEAT_COMMAND) {
continue;
}
const match =
job.requestMessageId?.match(/^agent-turn:([^:]+):/) ??
job.requestMessageId?.match(/^agent-heartbeat:([^:]+):/) ??
job.requestMessageId?.match(/^repo-face-heartbeat:([^:]+):/) ??
job.requestMessageId?.match(/:repo-face:([^:]+):\d+$/);
if (match) {
const updatedMs = Date.parse(job.updatedAt);
const ageMs = Number.isFinite(updatedMs) ? nowMs - updatedMs : Number.POSITIVE_INFINITY;
if (ageMs > staleAfterMs) {
const ageMinutes = Number.isFinite(ageMs) ? Math.round((ageMs / 60_000) * 10) / 10 : -1;
await storage.jobQueue.markFailed(
job.id,
`Repo Face CTB recovered stale active turn job after ${ageMinutes} minutes without progress.`,
);
staleRecovered.push({
identityId: match[1],
jobId: job.id,
requestMessageId: job.requestMessageId,
state: job.state,
updatedAt: job.updatedAt,
ageMinutes,
});
continue;
}
active.set(match[1], job.id);
}
}
const voidLock = await readRecentLock(resolve(config.storageRoot, "status", "moderation-rumination.lock"), 20);
if (voidLock) {
active.set("void", "lock:moderation-rumination");
}
return { active, staleRecovered };
} finally {
await storage.close();
}
}
async function readRecentLock(path: string, maxAgeMinutes: number): Promise<boolean> {
try {
const info = await stat(path);
const ageMs = Date.now() - info.mtimeMs;
return ageMs >= 0 && ageMs < maxAgeMinutes * 60_000;
} catch {
return false;
}
}
function reconcileParticipants(
existing: FaceHeartbeatParticipant[],
specs: ParticipantSpec[],
defaultChannelId: string | undefined,
speedOverrides: Record<string, number>,
heatOverrides: Record<string, number>,
initiativeClock: number,
baseRecoveryMinutes: number,
globalHeat: number,
pressureByIdentity: Map<string, RepoFaceRuntimePressureSnapshot> = new Map(),
): FaceHeartbeatParticipant[] {
const existingById = new Map(existing.map((entry) => [entry.identityId, entry]));
const count = Math.max(specs.length, 1);
return specs.map((spec, index) => {
const current = existingById.get(spec.id);
const hasChannel = spec.participantKind === "system_agent" || Boolean(spec.allowedChannelIds[0] || defaultChannelId);
const speed = initiativeSpeedFor(spec, speedOverrides) * spec.channelSpeedMultiplier;
const groups = initiativeGroupsFor(spec);
const heat = heatFor(spec, groups, globalHeat, heatOverrides);
const urgency = urgencyFor(pressureByIdentity.get(spec.id));
const effectiveSpeed = clamp(speed * heat * urgency, 0.01, 12);
const defaultNextTurnAt = Number.isFinite(current?.nextTurnAt)
? current.nextTurnAt
: initiativeClock + ((baseRecoveryMinutes / count) * index);
const nextTurnAt = pullNextTurnTowardUrgency(
defaultNextTurnAt,
initiativeClock,
baseRecoveryMinutes,
effectiveSpeed,
urgency,
);
if (current) {
return {
...current,
participantKind: spec.participantKind,
turnKind: spec.turnKind,
repoName: spec.repoName,
displayName: spec.displayName,
initiativeSpeed: speed,
groups,
heat,
effectiveSpeed,
baseRecoveryMinutes,
nextTurnAt,
constraints: mergeOptionalString(
mergeStrings(
mergeStrings(
current.constraints,
"Agent runtime uses CTB-style turns.",
),
"Wall-clock elapsed time advances initiative; heat changes recovery speed but does not fast-forward time.",
),
urgency > 1
? "Typed speaking pressure raises initiative urgency and may pull the next turn closer."
: undefined,
),
status: hasChannel
? current.status === "withdrawn" || current.status === "blocked"
? current.status
: "active"
: "blocked",
};
}
return {
identityId: spec.id,
participantKind: spec.participantKind,
turnKind: spec.turnKind,
repoName: spec.repoName,
displayName: spec.displayName,
initiativeSpeed: speed,
reactionBias: reactionBiasFor(spec),
interruptThreshold: interruptThresholdFor(spec),
currentLoad: 0,
status: hasChannel ? "active" : "blocked",
groups,
heat,
effectiveSpeed,
baseRecoveryMinutes,
nextTurnAt,
queuedCount: 0,
constraints: [
"Agent runtime uses CTB-style turns.",
"Wall-clock elapsed time advances initiative; heat changes recovery speed but does not fast-forward time.",
...(urgency > 1 ? ["Typed speaking pressure raises initiative urgency and may pull the next turn closer."] : []),
"Worker final summaries are not auto-posted as the base bot.",
],
};
});
}
function urgencyFor(pressure: RepoFaceRuntimePressureSnapshot | undefined): number {
if (!pressure) {
return 1;
}
const urgency =
pressure.needToSpeak * 1.35 +
pressure.noveltyPressure * 0.35 +
pressure.confessionPressure * 0.2;
return round3(clamp(1 + urgency, 1, 3.2));
}
function pullNextTurnTowardUrgency(
nextTurnAt: number,
initiativeClock: number,
baseRecoveryMinutes: number,
effectiveSpeed: number,
urgency: number,
): number {
if (urgency <= 1.05 || nextTurnAt <= initiativeClock) {
return nextTurnAt;
}
const maxWait = Math.max(0.75, baseRecoveryMinutes / Math.max(effectiveSpeed, 0.01));
return Math.min(nextTurnAt, round3(initiativeClock + maxWait));
}
function applyActiveTurnFreeze(
participant: FaceHeartbeatParticipant,
activeJobId: string | undefined,
state: FaceHeartbeatState,
completedThisTick: Set<string>,
): FaceHeartbeatParticipant {
if (activeJobId) {
return {
...participant,
currentLoad: 1,
activeJobId,
activeTurnStartedAt: participant.activeTurnStartedAt ?? participant.lastTurnAt ?? state.initiativeClock,
};
}
if (participant.currentLoad >= 1 || participant.activeTurnStartedAt !== undefined || participant.activeJobId) {
const completedTurnStartedAt = participant.activeTurnStartedAt ?? participant.lastTurnAt ?? state.initiativeClock;
const unfrozen = {
...participant,
currentLoad: 0,
activeTurnStartedAt: undefined,
activeJobId: undefined,
};
const recoveryMinutes = recoveryFor(unfrozen);
unfrozen.nextTurnAt = Math.max(state.initiativeClock, completedTurnStartedAt) + recoveryMinutes;
completedThisTick.add(participant.identityId);
state.history.push({
type: "turn_completed",
identityId: participant.identityId,
completedAtClock: state.initiativeClock,
startedAtClock: completedTurnStartedAt,
nextTurnAt: unfrozen.nextTurnAt,
recoveryMinutes,
heat: participant.heat,
effectiveSpeed: participant.effectiveSpeed,
});
return unfrozen;
}
return {
...participant,
currentLoad: 0,
};
}
function selectReadyParticipants(
state: FaceHeartbeatState,
maxJobs: number,
completedThisTick: Set<string>,
restStates: Map<string, RepoFaceRestSnapshot>,
idleCooling: IdleCoolingSnapshot,
manualOverrideIdentities: Set<string>,
): FaceHeartbeatParticipant[] {
const pendingMentionCounts = countPendingMentionsByIdentity(state.pendingMentions);
const eligible = state.participants
.filter((participant) => {
const pendingMentionCount = pendingMentionCounts.get(participant.identityId) ?? 0;
const manualOverrideCount = manualOverrideIdentities.has(participant.identityId) ? 1 : 0;
const restState = restStates.get(participant.identityId);
return (
participant.status === "active" &&
participant.currentLoad < 1 &&
!completedThisTick.has(participant.identityId) &&
!(
participant.participantKind === "repo_face" &&
pendingMentionCount === 0 &&
manualOverrideCount === 0 &&
restState?.isNapping === true &&
idleCooling.napModeActive !== true
)
);
});
if (eligible.length === 0) {
return [];
}
const ready = eligible
.filter((participant) => participant.nextTurnAt <= state.initiativeClock)
.sort((left, right) => {
const manualDelta =
Number(manualOverrideIdentities.has(right.identityId)) -
Number(manualOverrideIdentities.has(left.identityId));
if (manualDelta !== 0) {
return manualDelta;
}
const pendingDelta =
(pendingMentionCounts.get(right.identityId) ?? 0) -
(pendingMentionCounts.get(left.identityId) ?? 0);
if (pendingDelta !== 0) {
return pendingDelta;
}
const readyDelta = left.nextTurnAt - right.nextTurnAt;
if (readyDelta !== 0) {
return readyDelta;
}
if (right.reactionBias !== left.reactionBias) {
return right.reactionBias - left.reactionBias;
}
if (right.effectiveSpeed !== left.effectiveSpeed) {
return right.effectiveSpeed - left.effectiveSpeed;
}
return left.identityId.localeCompare(right.identityId);
});
if (!idleCooling.enabled || !idleCooling.active) {
return ready.slice(0, maxJobs);
}
const mentioned = ready.filter((participant) => (pendingMentionCounts.get(participant.identityId) ?? 0) > 0);
const manual = ready.filter((participant) => manualOverrideIdentities.has(participant.identityId));
const prompted = uniqueParticipants([...manual, ...mentioned]);
const unprompted = ready.filter((participant) =>
(pendingMentionCounts.get(participant.identityId) ?? 0) === 0 &&
!manualOverrideIdentities.has(participant.identityId)
);
const napRuns = idleCooling.napModeActive === true
? unprompted.filter((participant) => restStates.get(participant.identityId)?.isNapping === true)
: [];
const awakeRuns = unprompted.filter((participant) => restStates.get(participant.identityId)?.isNapping !== true);
const coolingAllowsUnpromptedTurn =
!idleCooling.nextUnpromptedTurnAllowedAt ||
Date.parse(idleCooling.nextUnpromptedTurnAllowedAt) <= Date.now();
const cooled = coolingAllowsUnpromptedTurn && prompted.length < maxJobs
? (napRuns[0] ? napRuns : awakeRuns).slice(0, 1)
: [];
return [...prompted, ...cooled].slice(0, maxJobs);
}
function uniqueParticipants(participants: FaceHeartbeatParticipant[]): FaceHeartbeatParticipant[] {
const seen = new Set<string>();
const unique: FaceHeartbeatParticipant[] = [];
for (const participant of participants) {
if (seen.has(participant.identityId)) {
continue;
}
seen.add(participant.identityId);
unique.push(participant);
}
return unique;
}
function advanceInitiativeClockFromWallClock(state: FaceHeartbeatState, now: Date): void {
const lastTickMs = Date.parse(state.lastTickAt ?? "");
if (!Number.isFinite(lastTickMs)) {
return;
}
const elapsedMinutes = (now.getTime() - lastTickMs) / 60_000;
if (elapsedMinutes <= 0) {
return;
}
const boundedElapsedMinutes = Math.min(elapsedMinutes, 60);
state.initiativeClock = round3(state.initiativeClock + boundedElapsedMinutes);
}
function rescheduleStaleOverdueParticipants(state: FaceHeartbeatState): void {
const activeParticipants = state.participants.filter((participant) => participant.status === "active");
const count = Math.max(activeParticipants.length, 1);
let rescheduledCount = 0;
activeParticipants.forEach((participant, index) => {
const staleThreshold = Math.max(participant.baseRecoveryMinutes, 15);
if (participant.nextTurnAt >= state.initiativeClock - staleThreshold) {
return;
}
participant.nextTurnAt = round3(state.initiativeClock + (participant.baseRecoveryMinutes / count) * index);
rescheduledCount += 1;
});
if (rescheduledCount > 0) {
state.history.push({
type: "wall_clock_resync",
rescheduledCount,
initiativeClock: state.initiativeClock,
});
}
}
function applyPendingMentionPriority(state: FaceHeartbeatState): void {
const pendingMentionCounts = countPendingMentionsByIdentity(state.pendingMentions);
for (const participant of state.participants) {
if (
participant.status === "active" &&
participant.currentLoad < 1 &&
(pendingMentionCounts.get(participant.identityId) ?? 0) > 0
) {
participant.nextTurnAt = Math.min(participant.nextTurnAt, state.initiativeClock);
}
}
}
function applyManualTurnRequests(state: FaceHeartbeatState, now: Date): Set<string> {
const manualOverrideIdentities = new Set<string>();
const participantsByIdentity = new Map(state.participants.map((participant) => [participant.identityId, participant]));
let changed = false;
for (const request of state.controls.manualTurnRequests) {
if (request.status !== "pending" && request.status !== "applied") {
continue;
}
const participant = participantsByIdentity.get(request.identityId);
if (!participant || participant.status !== "active") {
request.status = "rejected";
request.note = "No active participant with that identity.";
changed = true;
continue;
}
if (participant.currentLoad >= 1 || participant.activeJobId) {
request.status = "applied";
request.note = "Participant is already running; request will clear after the turn closes.";
manualOverrideIdentities.add(request.identityId);
changed = true;
continue;
}
participant.nextTurnAt = Math.min(participant.nextTurnAt, state.initiativeClock);
manualOverrideIdentities.add(request.identityId);
if (request.status !== "applied") {
request.status = "applied";
request.note = "Pulled to the front of the CTB queue.";
state.history.push({
type: "manual_turn_override_applied",
identityId: request.identityId,
requestId: request.id,
appliedAt: now.toISOString(),
initiativeClock: state.initiativeClock,
});
changed = true;
}
}
if (changed) {
state.controls.updatedAt = now.toISOString();
}
state.controls.manualTurnRequests = state.controls.manualTurnRequests.slice(-20);
return manualOverrideIdentities;
}
function reinitializeCtbSpacingOnWake(input: {
state: FaceHeartbeatState;
restStates: Map<string, RepoFaceRestSnapshot>;
idleCooling: IdleCoolingSnapshot;
maxJobs: number;
manualOverrideIdentities: Set<string>;
}): void {
const active = input.state.participants.filter((participant) =>
participant.status === "active" &&
participant.currentLoad < 1 &&
!participant.activeJobId
);
if (active.length <= input.maxJobs) {
return;
}
const pendingMentionCounts = countPendingMentionsByIdentity(input.state.pendingMentions);
const ready = active.filter((participant) => participant.nextTurnAt <= input.state.initiativeClock);
const readyRatio = ready.length / Math.max(active.length, 1);
const nappingCount = active.filter((participant) => input.restStates.get(participant.identityId)?.isNapping === true).length;
const previousHistory = input.state.history.slice(-20);
const heatBacklogAllowed =
input.state.globalHeat > 1.5 ||
active.some((participant) => participant.heat > 1.5 || participant.effectiveSpeed > 6);
const lastPauseIndex = findLastHistoryIndex(previousHistory, (entry) =>
entry.type === "skipped" && entry.reason === "agent_swarm_paused"
);
const lastCollectiveNapIndex = findLastHistoryIndex(previousHistory, (entry) =>
entry.type === "repo_face_memory_maintenance_tick" &&
isRecord(entry.idleCooling) &&
entry.idleCooling.napModeActive === true
);
const lastSpacingIndex = findLastHistoryIndex(previousHistory, (entry) =>
entry.type === "ctb_spacing_reinitialized"
);
const recentlyPaused = lastPauseIndex >= 0 && lastPauseIndex > lastSpacingIndex;
const recentlyCollectiveNapping = lastCollectiveNapIndex >= 0 && lastCollectiveNapIndex > lastSpacingIndex;
const allReadyCollapse = !heatBacklogAllowed && ready.length > input.maxJobs && readyRatio >= 0.75;
const coldStartCollapse = ready.length > input.maxJobs && active.every((participant) => participant.queuedCount === 0);
const wakingFromCollectiveSleep = recentlyCollectiveNapping && input.idleCooling.napModeActive !== true;
const wakingFromPause = recentlyPaused;
if (!allReadyCollapse && !coldStartCollapse && !wakingFromPause && !wakingFromCollectiveSleep) {
return;
}
const protectedIdentities = new Set<string>();
for (const participant of active) {
if (
(pendingMentionCounts.get(participant.identityId) ?? 0) > 0 ||
input.manualOverrideIdentities.has(participant.identityId)
) {
protectedIdentities.add(participant.identityId);
}
}
const unprotected = active
.filter((participant) => !protectedIdentities.has(participant.identityId))
.sort((left, right) => {
const dueDelta = left.nextTurnAt - right.nextTurnAt;
if (dueDelta !== 0) {
return dueDelta;
}
if (right.effectiveSpeed !== left.effectiveSpeed) {
return right.effectiveSpeed - left.effectiveSpeed;
}
return left.identityId.localeCompare(right.identityId);
});
if (unprotected.length === 0) {
return;
}
const immediateSlots = Math.max(0, input.maxJobs - protectedIdentities.size);
const spacingMinutes = round3(input.state.baseRecoveryMinutes / Math.max(active.length, 1));
let rescheduledCount = 0;
unprotected.forEach((participant, index) => {
const delayedSlot = Math.max(0, index - immediateSlots + 1);
const targetTurnAt = round3(input.state.initiativeClock + spacingMinutes * delayedSlot);
if (participant.nextTurnAt !== targetTurnAt) {
participant.nextTurnAt = targetTurnAt;
rescheduledCount += 1;
}
});
if (rescheduledCount > 0) {
input.state.history.push({
type: "ctb_spacing_reinitialized",
reason: wakingFromPause
? "wake_from_swarm_pause"
: wakingFromCollectiveSleep
? "wake_from_collective_sleep"
: coldStartCollapse
? "cold_start_ready_collapse"
: "ready_collapse",
rescheduledCount,
readyCountBefore: ready.length,
activeCount: active.length,
nappingCount,
protectedCount: protectedIdentities.size,
immediateSlots,
spacingMinutes,
initiativeClock: input.state.initiativeClock,
});
}
}
function consumeManualTurnRequests(
state: FaceHeartbeatState,
identityId: string,
status: ManualTurnRequest["status"],
note: string,
): void {
const now = new Date().toISOString();
let changed = false;
for (const request of state.controls.manualTurnRequests) {
if ((request.status === "pending" || request.status === "applied") && request.identityId === identityId) {
request.status = status;
request.note = note;
changed = true;
}
}
if (changed) {
state.controls.updatedAt = now;
}
}
function pendingMentionsForParticipant(
state: FaceHeartbeatState,
identityId: string,
): RepoFacePendingMention[] {
return state.pendingMentions
.filter((mention) => mention.identityId === identityId)
.sort((left, right) => Date.parse(left.queuedAt) - Date.parse(right.queuedAt));
}
function countPendingMentionsByIdentity(
pendingMentions: RepoFacePendingMention[],
): Map<string, number> {
const counts = new Map<string, number>();
for (const mention of pendingMentions) {
counts.set(mention.identityId, (counts.get(mention.identityId) ?? 0) + 1);
}
return counts;
}
function findLastHistoryIndex(
history: Array<Record<string, unknown>>,
predicate: (entry: Record<string, unknown>) => boolean,
): number {
for (let index = history.length - 1; index >= 0; index -= 1) {
if (predicate(history[index])) {
return index;
}
}
return -1;
}
async function readIdleCoolingSnapshot(input: {
config: ReturnType<typeof loadConfig>;
identities: RepoDiscordIdentity[];
state: FaceHeartbeatState;
now: Date;
}): Promise<IdleCoolingSnapshot> {
const policy = input.config.repoFaceHeartbeats.idleCooling;
const checkedChannelIds = collectIdleCoolingChannelIds(input.config, input.identities);
const base = {
enabled: policy.enabled,
active: false,
checkedChannelIds,
idleAfterMinutes: policy.idleAfterMinutes,
recoveryMinutes: policy.recoveryMinutes,
napAfterMinutes: policy.napAfterMinutes,
lastUnpromptedTurnQueuedAt: newestUnpromptedTurnQueuedAt(input.state),
};
if (!policy.enabled) {
return { ...base, reason: "disabled" };
}
if (!input.config.botToken) {
return { ...base, reason: "missing_discord_bot_token" };
}
if (checkedChannelIds.length === 0) {
return { ...base, reason: "no_watched_discord_channels" };
}
let newestHumanActivityAt: string | undefined;
const fetchErrors: string[] = [];
for (const channelId of checkedChannelIds) {
try {
const messages = await fetchRecentDiscordMessages({
botToken: input.config.botToken,
channelId,
limit: 10,
});
for (const message of messages) {
if (message.isBot || !message.content.trim()) {
continue;
}
const timestampMs = Date.parse(message.timestamp);
const newestMs = Date.parse(newestHumanActivityAt ?? "");
if (Number.isFinite(timestampMs) && (!Number.isFinite(newestMs) || timestampMs > newestMs)) {
newestHumanActivityAt = message.timestamp;
}
}
} catch (error) {
fetchErrors.push(`${channelId}: ${error instanceof Error ? error.message : String(error)}`);
}
}
const lastUnpromptedTurnQueuedAt = base.lastUnpromptedTurnQueuedAt;
const lastUnpromptedTurnQueuedMs = Date.parse(lastUnpromptedTurnQueuedAt ?? "");
const nextUnpromptedTurnAllowedAt = Number.isFinite(lastUnpromptedTurnQueuedMs)
? new Date(lastUnpromptedTurnQueuedMs + policy.recoveryMinutes * 60_000).toISOString()
: undefined;
if (!newestHumanActivityAt) {
return {
...base,
active: true,
napModeActive: true,
reason: fetchErrors.length > 0 ? "activity_fetch_failed_or_no_human_messages" : "no_recent_human_messages",
nextUnpromptedTurnAllowedAt,
};
}
const idleForMinutes = Math.max(0, (input.now.getTime() - Date.parse(newestHumanActivityAt)) / 60_000);
const active = idleForMinutes >= policy.idleAfterMinutes;
return {
...base,
active,
napModeActive: active && idleForMinutes >= policy.napAfterMinutes,
reason: fetchErrors.length > 0 ? "partial_activity_fetch_failure" : undefined,
lastHumanActivityAt: newestHumanActivityAt,
idleForMinutes: round3(idleForMinutes),
nextUnpromptedTurnAllowedAt,
};
}
function collectIdleCoolingChannelIds(
config: ReturnType<typeof loadConfig>,
identities: RepoDiscordIdentity[],
): string[] {
return Array.from(new Set([
config.repoFaceHeartbeats.defaultChannelId,
config.bifrostDiscordChannelId,
...config.indexedChannelIds,
...identities.flatMap((identity) => getRepoDiscordIdentityAllowedChannelIds(identity)),
].filter((value): value is string => typeof value === "string" && value.trim().length > 0)));
}
function newestUnpromptedTurnQueuedAt(state: FaceHeartbeatState): string | undefined {
for (const entry of [...state.history].reverse()) {
if (entry.type !== "queued" && entry.type !== "dry_run_selected") {
continue;
}
if (typeof entry.queuedAt !== "string") {
continue;
}
if (typeof entry.pendingMentionCount === "number" && entry.pendingMentionCount > 0) {
continue;
}
return entry.queuedAt;
}
return undefined;
}
function buildHeartbeatPrompt(input: {
identity: RepoDiscordIdentity;
channelId: string;
channelPlan: RepoFaceChannelPlan;
channelSnapshots: ChannelSnapshot[];
recentMessages: SourceMessage[];
memorySurface?: string;
repoActivitySurface?: string;
conversationMemorySurface?: string;
humanPronounGuidance?: RepoFaceHumanPronounGuidance[];
bifrostDigest?: BifrostGovernanceDigest;
participant: FaceHeartbeatParticipant;
pendingMentions: RepoFacePendingMention[];
jurisdictionDive: JurisdictionDiveDirective;
githubActionsEnabled: boolean;
globalAgentDoctrine: string;
}): string {
return loadPromptTemplate("repo-face-turn.prompt.md", {
displayName: input.identity.displayName,
identityId: input.identity.id,
repoName: input.identity.repoName,
identityDoctrine: renderRepoCharacterIdentityDoctrine(input.identity),
globalAgentDoctrine: input.globalAgentDoctrine,
channelId: input.channelId,
memorySurface: input.memorySurface ?? `- ${input.identity.displayName} has no strong personal memory surface yet. Let the attached conversation and repo evidence wake something specific.`,
repoActivitySurface: input.repoActivitySurface ?? "- No recent home repo activity was attached for this turn.",
conversationMemorySurface: input.conversationMemorySurface ?? "- No recent conversation transcript was attached for this turn.",
humanPronounDirective: renderRepoFaceHumanPronounFacts(input.humanPronounGuidance ?? [])
?? "Known human pronoun guidance:\n- No explicit human pronoun guidance is attached for this turn. Use names or neutral phrasing instead of guessing.",
turnSituationDirective: renderTurnSituationDirective({
identity: input.identity,
participant: input.participant,
recentMessages: input.recentMessages,
channelSnapshots: input.channelSnapshots,
pendingMentions: input.pendingMentions,
}),
bifrostDigestDirective: renderBifrostGovernanceDigestDirective(input.bifrostDigest),
channelPermissionDirective: renderChannelPermissionDirective(input.channelPlan),
researchCapabilitiesDirective: renderResearchCapabilitiesDirective(input.identity),
socialEmbodimentDirective: renderSocialEmbodimentDirective(input.identity),
jurisdictionRespectDirective: renderJurisdictionRespectDirective(input.identity),
comedyImprovDirective: renderComedyImprovDirective(input.identity),
worldbuildingPublicationDirective: renderWorldbuildingPublicationDirective(input.identity),
jurisdictionDiveLine: input.jurisdictionDive.promptLine,
githubActionsEnabled: input.githubActionsEnabled,
});
}
async function assembleRepoFaceTurnPrompt(input: {
config: ReturnType<typeof loadConfig>;
identityId: string;
outPath?: string;
memorySurfacePath?: string;
conversationSurfacePath?: string;
}): Promise<{
ok: true;
identityId: string;
promptLength: number;
outPath?: string;
memorySurfacePath?: string;
conversationSurfacePath?: string;
}> {
const faceRegistry = await loadFaceIdentityRegistry(input.config.repoDiscordIdentitiesPath);
const registry = faceRegistryAsRepoDiscordRegistry(faceRegistry);
const identity = registry.identities.find(
(entry) => entry.id.toLowerCase() === input.identityId.toLowerCase(),
);
if (!identity) {
throw new Error(`Unknown repo Face identity: ${input.identityId}`);
}
const channelPlan = buildChannelPlan(identity, input.config.repoFaceHeartbeats.defaultChannelId);
const channelId = channelPlan.primaryChannelId;
if (!channelId) {
throw new Error(`No prompt assembly channel is configured for ${identity.id}.`);
}
const [recentMessages, channelSnapshots, bifrostDigest] = await Promise.all([
fetchRecentDiscordMessages({
botToken: input.config.botToken,
channelId,
limit: 15,
ignoreBotMessages: channelId === input.config.bifrostDiscordChannelId,
}),
fetchChannelSnapshots({
botToken: input.config.botToken,
channelIds: channelPlan.snapshotChannelIds,
primaryChannelId: channelId,
limit: 6,
bifrostDiscordChannelId: input.config.bifrostDiscordChannelId,
}),
input.config.repoFaceBifrostEnabled
? fetchBifrostGovernanceDigest({
bifrostRoot: input.config.bifrostRoot,
repoName: identity.repoName,
agentIdentity: identity.id,
})
: Promise.resolve(undefined),
]);
const roomContext = {
recentMessages,
channelSnapshots,
};
const humanPronounGuidance = await loadRepoFaceHumanPronounGuidance(input.config, roomContext);
const memorySurface = input.memorySurfacePath
? await readOptionalMemorySurface(input.memorySurfacePath)
: await renderRepoFaceMemorySurfaceForTurn(
identity,
input.config,
registry.identities,
roomContext,
humanPronounGuidance,
);
const repoActivitySurface = renderRepoFaceRepoActivitySurface(identity, input.config);
const globalAgentDoctrine = await loadGlobalAgentDoctrine();
const conversationMemorySurface = input.conversationSurfacePath
? await readOptionalMemorySurface(input.conversationSurfacePath)
: renderRepoFaceConversationTranscript({
identity,
recentMessages,
channelSnapshots,
pendingMentions: [],
channelPlan,
});
const participant = buildInspectionParticipant(
identity,
input.config.repoFaceHeartbeats.baseRecoveryMinutes,
);
const prompt = buildHeartbeatPrompt({
identity,
channelId,
channelPlan,
channelSnapshots,
recentMessages,
memorySurface,
repoActivitySurface,
conversationMemorySurface,
humanPronounGuidance,
bifrostDigest,
participant,
pendingMentions: [],
jurisdictionDive: buildJurisdictionDiveDirective(identity, participant),
githubActionsEnabled: input.config.repoFaceGithubActionsEnabled,
globalAgentDoctrine,
});
if (input.outPath) {
const outPath = resolve(input.outPath);
await mkdir(dirname(outPath), { recursive: true });
await writeFile(outPath, prompt, "utf8");
}
return {
ok: true,
identityId: identity.id,
promptLength: prompt.length,
outPath: input.outPath ? resolve(input.outPath) : undefined,
memorySurfacePath: input.memorySurfacePath ? resolve(input.memorySurfacePath) : undefined,
conversationSurfacePath: input.conversationSurfacePath ? resolve(input.conversationSurfacePath) : undefined,
};
}
async function loadGlobalAgentDoctrine(): Promise<string> {
const candidates = [
process.env.CODEX_HOME ? resolve(process.env.CODEX_HOME, "AGENTS.md") : undefined,
process.env.USERPROFILE ? resolve(process.env.USERPROFILE, ".codex", "AGENTS.md") : undefined,
resolve(homedir(), ".codex", "AGENTS.md"),
].filter((value): value is string => typeof value === "string" && value.trim().length > 0);
const uniqueCandidates = [...new Set(candidates)];
const errors: string[] = [];
for (const candidate of uniqueCandidates) {
try {
const content = await readFile(candidate, "utf8");
if (content.trim().length > 0) {
return content.trim();
}
errors.push(`${candidate}: empty file`);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
errors.push(`${candidate}: ${message}`);
}
}
return [
"# Global Agent Instructions Unavailable",
"",
"The Face prompt attempted to load the global Codex AGENTS.md file, but no readable file was found.",
"This is not a replacement doctrine. Treat it as an inspection failure and avoid claiming global guidance was available for this turn.",
"",
"Attempted paths:",
...errors.map((error) => `- ${error}`),
].join("\n");
}
async function renderRepoFaceMemorySurfaceForTurn(
identity: RepoDiscordIdentity,
config: ReturnType<typeof loadConfig>,
registryIdentities: RepoDiscordIdentity[] = [],
roomContext?: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
},
humanPronounGuidance?: RepoFaceHumanPronounGuidance[],
): Promise<string> {
const statePath = resolveRepoFaceStatePath(identity, config.storageRoot);
const typedState = await loadVoidSelfStateTypedDocuments({ canonicalPath: statePath });
const curiosityGraphFacts = roomContext
? await renderRepoFaceCuriosityGraphFacts(identity, config, typedState, roomContext)
: undefined;
const statePacket = renderRepoFaceStatePacket(
identity,
typedState,
registryIdentities,
roomContext,
humanPronounGuidance ?? await loadRepoFaceHumanPronounGuidance(config, roomContext),
curiosityGraphFacts,
);
if (!config.repoFaceHeartbeats.stateProjectorEnabled) {
return rejectLeakyMemorySurface(statePacket);
}
return projectRepoFaceMemorySurface({
identity,
statePacket,
config,
});
}
function renderRepoFaceStatePacket(
identity: RepoDiscordIdentity,
state: VoidSelfStateTypedProjection,
registryIdentities: RepoDiscordIdentity[] = [],
roomContext?: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
},
humanPronounGuidance: RepoFaceHumanPronounGuidance[] = [],
curiosityGraphFacts?: string,
): string {
const name = identity.displayName;
const lines: string[] = [];
const profile = state.selfProfile;
const privateNotes = profile.privateNotes;
const values = [...profile.values]
.sort((left, right) => right.priority - left.priority);
const needs = [...state.faceAffect.needs]
.filter((need) => need.status !== "retired")
.sort(sortAffectByStatusAndIntensity);
const bonds = [...state.faceAffect.socialBonds]
.filter((bond) => bond.status !== "retired")
.sort(sortAffectByStatusAndIntensity);
const statusReads = [...state.faceAffect.statusReads]
.filter((read) => !read.retiredAt)
.sort(sortAffectByStatusAndIntensity);
const moodDimensions = [...state.faceAffect.moodDimensions]
.sort((left, right) => right.value - left.value);
const socialBiases = [...state.faceAffect.socialBiases]
.sort((left, right) => right.value - left.value);
const doctrineStances = [...state.faceAffect.doctrineStances]
.filter((stance) => stance.status !== "retired" && !stance.retiredAt)
.sort(sortAffectByStatusAndIntensity);
const agencyPressures = [...state.agencyPressure.pressures]
.filter((pressure) => pressure.status !== "retired")
.sort(sortAffectByStatusAndIntensity);
const durableMemories = [...state.thoughtMemory.memories]
.filter((memory) => !memory.retiredAt)
.slice(-12)
.reverse();
const shortTermResidue = [...state.thoughtMemory.shortTerm]
.filter((memory) => !memory.retiredAt)
.slice(-12)
.reverse();
const incubation = [...state.thoughtMemory.incubation]
.filter((thread) => thread.status !== "retired")
.sort((left, right) => right.maturation - left.maturation);
const candidateInterventions = [...state.candidateInterventions.interventions]
.filter((intervention) => intervention.status !== "retired")
.slice(-8)
.reverse();
const recentReceipts = [...state.speechReceipts.recentReceipts]
.slice(-6)
.reverse();
const activationFacts = renderRepoFaceActivationProfileFacts(profile.activationProfile);
const runtimeFacts = renderRepoFaceRuntimePressureFacts(name, state);
const humanSteeringFacts = roomContext
? renderRepoFaceHumanSteeringFacts(identity, roomContext)
: undefined;
const selfTexture = [
...privateNotes.map(projectPrivateNoteForMemorySurface),
...values.map((value) => value.summary || value.label),
]
.map(cleanCharacterFacingSentence)
.filter((entry) => entry.length > 0)
.slice(0, 18);
if (selfTexture.length > 0) {
lines.push(`Right now, ${name} is carrying this close to the skin: ${joinAsNarrativeList(selfTexture)}.`);
}
if (activationFacts) {
lines.push(activationFacts);
}
if (runtimeFacts) {
lines.push(runtimeFacts);
}
if (needs.length > 0) {
lines.push([
`${name}'s explicit needs and frictions:`,
...needs.map((need) => {
const target = targetLabel(need.target);
const claimOrQuestion = need.claim
? `Claim: ${asSentence(need.claim)}`
: need.question
? `Question: ${asSentence(need.question)}`
: "";
return [
`- ${need.kind} need toward ${target} [${need.status}, intensity ${need.intensity.toFixed(2)}, valence ${need.valence.toFixed(2)}]: ${asSentence(need.summary)}`,
claimOrQuestion,
`Tension: ${asSentence(need.tension)}`,
`Behavioral pull: ${asSentence(need.actionImplication)}`,
].filter(Boolean).join(" ");
}),
].join("\n"));
}
if (bonds.length > 0) {
lines.push([
"The social map has teeth:",
...bonds.map((bond) => {
const target = targetLabel(bond.target);
return [
`- ${target} draws ${bond.stance} [${bond.status}, intensity ${bond.intensity.toFixed(2)}]: ${asSentence(bond.summary)}`,
`Read: ${asSentence(bond.claim)}`,
`Tension: ${asSentence(bond.tension)}`,
`Behavioral pull: ${asSentence(bond.actionImplication)}`,
].join(" ");
}),
].join("\n"));
}
if (statusReads.length > 0) {
lines.push([
"Status in the swarm is part of the weather:",
...statusReads.map((read) => {
const target = targetLabel(read.target);
return [
`- Around ${target}, ${name} feels ${read.status} [intensity ${read.intensity.toFixed(2)}]: ${asSentence(read.summary)}`,
`Read: ${asSentence(read.claim)}`,
`Tension: ${asSentence(read.tension)}`,
`Behavioral pull: ${asSentence(read.actionImplication)}`,
].join(" ");
}),
].join("\n"));
}
if (moodDimensions.length > 0) {
lines.push([
"Mood dimensions currently bending the turn:",
...moodDimensions.map((dimension) =>
`- ${dimension.name}=${dimension.value.toFixed(2)}${dimension.source ? ` from ${cleanCharacterFacingSentence(dimension.source)}` : ""}`,
),
].join("\n"));
}
if (socialBiases.length > 0) {
lines.push([
"Social interpretation biases that shape ambiguous signals:",
...socialBiases.map((bias) =>
`- ${bias.name}=${bias.value.toFixed(2)}: ${asSentence(bias.summary)} Behavioral pull: ${asSentence(bias.behavioralPull)}`,
),
].join("\n"));
}
if (doctrineStances.length > 0) {
lines.push([
`${name}'s lived relation to Cult/Praxis doctrine:`,
...doctrineStances.map((stance) =>
[
`- ${stance.doctrine} toward ${targetLabel(stance.target)} [${stance.status}, intensity ${stance.intensity.toFixed(2)}, valence ${stance.valence.toFixed(2)}]: ${asSentence(stance.summary)}`,
stance.claim ? `Claim: ${asSentence(stance.claim)}` : "",
stance.question ? `Question: ${asSentence(stance.question)}` : "",
`Tension: ${asSentence(stance.tension)}`,
`Behavioral pull: ${asSentence(stance.actionImplication)}`,
].filter(Boolean).join(" "),
),
].join("\n"));
}
if (durableMemories.length > 0) {
lines.push([
"Durable memories that should still bias judgment:",
...durableMemories.map((memory) => renderRepoFaceMemoryFact(name, memory)),
].join("\n"));
}
if (shortTermResidue.length > 0) {
lines.push([
"Short-term residue waiting to settle:",
...shortTermResidue.map((memory) => renderRepoFaceMemoryFact(name, memory)),
].join("\n"));
}
const socialGraphFacts = renderRepoFaceSocialGraphFacts(identity, registryIdentities, state);
if (socialGraphFacts) {
lines.push(socialGraphFacts);
}
const peerOpeningFacts = roomContext
? renderRepoFacePeerOpeningFacts(identity, registryIdentities, roomContext)
: undefined;
if (peerOpeningFacts) {
lines.push(peerOpeningFacts);
}
const socialPressureFacts = roomContext
? renderRepoFaceRelationshipPressureFacts(identity, registryIdentities, state, roomContext)
: undefined;
if (socialPressureFacts) {
lines.push(socialPressureFacts);
}
const pronounFacts = renderRepoFaceHumanPronounFacts(humanPronounGuidance);
if (pronounFacts) {
lines.push(pronounFacts);
}
const roomTextureFacts = roomContext
? renderRepoFaceRoomTextureFacts(identity, roomContext)
: undefined;
if (roomTextureFacts) {
lines.push(roomTextureFacts);
}
if (curiosityGraphFacts) {
lines.push(curiosityGraphFacts);
}
if (agencyPressures.length > 0) {
lines.push([
"Agency pressures that want eventual motion:",
...agencyPressures.map((pressure) =>
[
`- ${pressure.kind} toward ${targetLabel(pressure.target)} [${pressure.status}, intensity ${pressure.intensity.toFixed(2)}]: ${asSentence(pressure.summary)}`,
pressure.claim ? `Claim: ${asSentence(pressure.claim)}` : "",
pressure.question ? `Question: ${asSentence(pressure.question)}` : "",
pressure.tension ? `Tension: ${asSentence(pressure.tension)}` : "",
`Behavioral pull: ${asSentence(pressure.actionImplication)}`,
].filter(Boolean).join(" "),
),
].join("\n"));
}
if (incubation.length > 0) {
lines.push([
"Thoughts still moving under the floorboards:",
...incubation.map((thread) =>
[
`- ${cleanCharacterFacingSentence(thread.topic)} [${thread.status}, maturation ${thread.maturation.toFixed(2)}]: ${cleanCharacterFacingSentence(thread.summary)}`,
typeof thread.desireToSpeak === "number" ? `desire to speak ${thread.desireToSpeak.toFixed(2)}` : "",
typeof thread.noveltyToRoom === "number" ? `room novelty ${thread.noveltyToRoom.toFixed(2)}` : "",
typeof thread.saturationScore === "number" ? `saturation ${thread.saturationScore.toFixed(2)}` : "",
].filter(Boolean).join("; "),
),
].join("\n"));
}
if (candidateInterventions.length > 0) {
lines.push([
"Unsaid or recently deferred speech pressure:",
...candidateInterventions.map((intervention) =>
[
`- ${intervention.kind} [${intervention.status}, priority ${intervention.priority.toFixed(2)}${intervention.mustEventuallyShare ? ", must eventually share" : ""}]: ${asSentence(intervention.summary)}`,
`Draft residue: ${cleanCharacterFacingSentence(intervention.draft)}`,
].join(" "),
),
"Do not repeat a waiting line unless the room gives it a sharper angle.",
].join("\n"));
}
if (recentReceipts.length > 0) {
lines.push([
"Recent speech residue:",
...recentReceipts.map((receipt) =>
`- Said recently${receipt.preview ? `: ${cleanCharacterFacingSentence(receipt.preview)}` : "."} Let this create repetition caution, confidence, embarrassment, or follow-through as appropriate.`,
),
].join("\n"));
}
if (humanSteeringFacts) {
lines.push(humanSteeringFacts);
}
if (lines.length === 0) {
return `You are ${name}, but your durable state is thin. Use the room, repo, and your jurisdiction to form a real opinion before speaking.`;
}
return rejectLeakyMemorySurface(lines.join("\n\n"));
}
function sortAffectByStatusAndIntensity(
left: { status?: string; intensity?: number },
right: { status?: string; intensity?: number },
): number {
const rank = (status: string | undefined): number => {
switch (status) {
case "neglected":
case "ready_to_act":
return 0;
case "active":
return 1;
case "challenged":
return 1;
case "cooling":
return 2;
case "satisfied":
case "resolved":
return 3;
default:
return 4;
}
};
const rankDelta = rank(left.status) - rank(right.status);
if (rankDelta !== 0) {
return rankDelta;
}
return (right.intensity ?? 0) - (left.intensity ?? 0);
}
function targetLabel(target: { label?: string; id?: string; kind?: string } | undefined): string {
if (!target) {
return "an unnamed target";
}
return target.label ?? target.id ?? target.kind ?? "an unnamed target";
}
function renderRepoFaceActivationProfileFacts(
activationProfile: VoidSelfStateTypedProjection["selfProfile"]["activationProfile"],
): string | undefined {
const sections = Object.entries(activationProfile)
.map(([section, values]) => {
const entries = Object.entries(values)
.sort(([, left], [, right]) => right.weight - left.weight)
.map(([key, value]) => `${key}=${value.weight.toFixed(2)}${value.note ? ` (${cleanCharacterFacingSentence(value.note)})` : ""}`);
return entries.length > 0 ? `- ${section}: ${entries.join("; ")}` : undefined;
})
.filter((entry): entry is string => typeof entry === "string");
return sections.length > 0
? ["Activation profile that should color behavior:", ...sections].join("\n")
: undefined;
}
function renderRepoFaceRuntimePressureFacts(
name: string,
state: VoidSelfStateTypedProjection,
): string | undefined {
const lines: string[] = [];
const sleep = state.scheduledRuntime.sleepCycle;
if (sleep.isNapping || sleep.activeDreamThemes.length > 0) {
lines.push(
`${name}'s rest state: ${sleep.isNapping ? "currently in a sleep/low-output phase" : "awake but carrying dream residue"}${sleep.activeDreamThemes.length > 0 ? ` around ${joinAsNarrativeList(sleep.activeDreamThemes.map(cleanCharacterFacingSentence))}` : ""}.`,
);
}
const speaking = state.scheduledRuntime.speakingPressure;
const speakingParts = [
`need to speak ${speaking.needToSpeak.toFixed(2)}`,
typeof speaking.confessionPressure === "number" ? `confession ${speaking.confessionPressure.toFixed(2)}` : "",
typeof speaking.noveltyPressure === "number" ? `novelty ${speaking.noveltyPressure.toFixed(2)}` : "",
typeof speaking.recentSpeechDamping === "number" ? `recent-speech damping ${speaking.recentSpeechDamping.toFixed(2)}` : "",
].filter(Boolean);
lines.push(`Speaking pressure: ${speakingParts.join(", ")}. Treat this as appetite/restraint, not an order.`);
if (state.scheduledRuntime.lastRuns.length > 0) {
lines.push(`Recent internal passes: ${state.scheduledRuntime.lastRuns.slice(-4).map((run) =>
cleanCharacterFacingSentence(run.summary),
).join(" | ")}`);
}
return lines.length > 0 ? lines.join("\n") : undefined;
}
function renderRepoFaceMemoryFact(
name: string,
memory: VoidSelfStateTypedProjection["thoughtMemory"]["memories"][number],
): string {
const parts = [
`- ${memory.kind} about ${targetLabel(memory.target)}: ${asSentence(memory.summary)}`,
memory.claim ? `Claim: ${asSentence(memory.claim)}` : "",
memory.question ? `Question: ${asSentence(memory.question)}` : "",
memory.tension ? `Tension: ${asSentence(memory.tension)}` : "",
memory.actionImplication ? `Behavioral pull for ${name}: ${asSentence(memory.actionImplication)}` : "",
];
return parts.filter(Boolean).join(" ");
}
function renderRepoFaceRoomTextureFacts(
identity: RepoDiscordIdentity,
input: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
},
): string | undefined {
const stats = collectRepoFaceRoomTextureStats(identity, input);
if (!stats) {
return undefined;
}
const temporaryPressures = stats.texture === "heavy" || stats.agentShare >= 0.55
? [
"- Temporary affect pressure candidates: play, rest, and social_contact may be hungry because the room is carrying sustained work/agent weight.",
"- These are not stored needs and not orders. Project whether this character gets mischievous, bored, sharp, withdrawn, socially hungry, status-testing, or still work-focused.",
]
: [];
return [
"Room texture facts:",
`- Observed messages: ${stats.total}; humans: ${stats.humanMessages}; agents/bots: ${stats.agentMessages}; distinct speakers: ${stats.speakerCount}.`,
`- Long messages: ${stats.longMessages}; short messages: ${stats.shortMessages}; average length: ${stats.averageCharacters} characters.`,
`- This Face's own recent messages in the attached window: ${stats.ownMessages}.`,
`- Structural texture: ${stats.texture}. This is evidence about conversational weight, not a command to speak or joke.`,
...temporaryPressures,
].join("\n");
}
interface RepoFaceCuriosityNode {
id: string;
text: string;
sourceKind: RetrievalResult["sourceKind"];
score: number;
terms: string[];
metadata: Record<string, string>;
seedLabels: string[];
}
interface RepoFaceCuriosityCluster {
label: string;
nodes: RepoFaceCuriosityNode[];
prominence: number;
saturation: number;
novelty: number;
recentOverlap: number;
stateOverlap: number;
clusterDensity: number;
jurisdictionFit: number;
evidence: string[];
}
async function renderRepoFaceCuriosityGraphFacts(
identity: RepoDiscordIdentity,
config: ReturnType<typeof loadConfig>,
state: VoidSelfStateTypedProjection,
roomContext: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
},
): Promise<string | undefined> {
const seedQueries = buildRepoFaceCuriositySeedQueries(identity, state, roomContext);
if (seedQueries.length === 0) {
return undefined;
}
try {
const retrieval = createRepoFaceCuriosityRetrievalService(config);
const nodesById = new Map<string, RepoFaceCuriosityNode>();
for (const seed of seedQueries) {
const [historyResults, sourceResults, homeSourceResults] = await Promise.all([
retrieval.searchHistory(seed.query, 8),
retrieval.searchRepositorySources(seed.query, 8),
retrieval.searchRepositorySources(seed.query, 6, { repoName: identity.repoName }),
]);
for (const result of [...historyResults, ...sourceResults, ...homeSourceResults]) {
const id = `${result.sourceKind}:${result.chunkId}`;
const terms = significantTopicTerms(result.text);
if (terms.length < 3) {
continue;
}
const existing = nodesById.get(id);
if (existing) {
existing.score = Math.max(existing.score, result.score);
existing.seedLabels = mergeStrings(existing.seedLabels, seed.label);
continue;
}
nodesById.set(id, {
id,
text: result.text,
sourceKind: result.sourceKind,
score: result.score,
terms,
metadata: result.metadata,
seedLabels: [seed.label],
});
}
}
const nodes = [...nodesById.values()]
.sort((left, right) => right.score - left.score)
.slice(0, 32);
if (nodes.length < 3) {
return undefined;
}
const clusters = decodeRepoFaceCuriosityGraph(identity, state, roomContext, nodes);
if (clusters.length === 0) {
return undefined;
}
return renderRepoFaceCuriosityClusters(identity, config, clusters);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
return [
"Curiosity graph unavailable:",
`- Semantic retrieval failed while decoding topic attractors: ${collapseWhitespace(message, 260)}`,
"- Do not pretend a semantic curiosity map was available this turn. Fall back to the raw transcript, home-repo activity, and typed memory instead of inventing ranked attractors.",
].join("\n");
}
}
function createRepoFaceCuriosityRetrievalService(config: ReturnType<typeof loadConfig>): RetrievalService {
const historyEmbedder = createTextEmbedder({
backend: config.ragEmbeddingBackend,
hashDimensions: config.ragEmbeddingDimensions,
ollamaBaseUrl: config.ragOllamaBaseUrl,
ollamaModel: config.ragOllamaModel,
ollamaTimeoutMs: config.ragOllamaTimeoutMs,
queryInstruction: config.ragQueryInstruction,
});
const sourceEmbedder = createTextEmbedder({
backend: config.ragEmbeddingBackend,
hashDimensions: config.ragEmbeddingDimensions,
ollamaBaseUrl: config.ragOllamaBaseUrl,
ollamaModel: config.ragOllamaModel,
ollamaTimeoutMs: config.ragOllamaTimeoutMs,
queryInstruction: config.ragSourceQueryInstruction || config.ragQueryInstruction,
});
const stores = createVectorStores({
kind: config.vectorStore.kind,
historyPath: config.vectorStore.path,
sourceRoot: config.sourceVectorStoreRoot,
qdrant: config.qdrant,
historyEmbedder,
sourceEmbedder,
});
return new RetrievalService(stores.history, stores.source);
}
function buildRepoFaceCuriositySeedQueries(
identity: RepoDiscordIdentity,
state: VoidSelfStateTypedProjection,
roomContext: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
},
): Array<{ label: string; query: string }> {
const room = roomContext.recentMessages
.filter((message) => collapseWhitespace(message.content).length > 0)
.slice(-8)
.map((message) => `${message.authorName}: ${collapseWhitespace(message.content, 500)}`)
.join("\n");
const nearby = roomContext.channelSnapshots
.flatMap((snapshot) => snapshot.messages)
.filter((message) => collapseWhitespace(message.content).length > 0)
.slice(-8)
.map((message) => `${message.authorName}: ${collapseWhitespace(message.content, 320)}`)
.join("\n");
const privateThoughts = [
...state.selfProfile.privateNotes.slice(-8),
...state.selfProfile.values
.slice()
.sort((left, right) => right.priority - left.priority)
.slice(0, 8)
.map((value) => `${value.label}: ${value.summary}`),
...state.thoughtMemory.memories
.filter((memory) => !memory.retiredAt)
.slice(-8)
.map((memory) => `${memory.kind} ${targetLabel(memory.target)} ${memory.summary} ${memory.claim ?? memory.question ?? ""}`),
...state.thoughtMemory.shortTerm
.filter((memory) => !memory.retiredAt)
.slice(-8)
.map((memory) => `${memory.kind} ${targetLabel(memory.target)} ${memory.summary} ${memory.claim ?? memory.question ?? ""}`),
...state.thoughtMemory.incubation
.filter((thread) => thread.status !== "retired")
.sort((left, right) => right.maturation - left.maturation)
.slice(0, 8)
.map((thread) => `${thread.topic}: ${thread.summary}`),
].join("\n");
const identityQuery = [
identity.displayName,
identity.repoName,
identity.description ?? "",
...identity.channelPermissions.flatMap((permission) => [
permission.label ?? "",
permission.topic ?? "",
permission.posture ?? "",
]),
].join("\n");
return [
{ label: "current room", query: room },
{ label: "nearby rooms", query: nearby },
{ label: "private state", query: privateThoughts },
{ label: "home territory", query: identityQuery },
]
.map((seed) => ({ ...seed, query: collapseWhitespace(seed.query, 2800) }))
.filter((seed) => significantTopicTerms(seed.query).length >= 3)
.slice(0, 4);
}
function decodeRepoFaceCuriosityGraph(
identity: RepoDiscordIdentity,
state: VoidSelfStateTypedProjection,
roomContext: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
},
nodes: RepoFaceCuriosityNode[],
): RepoFaceCuriosityCluster[] {
const edgeWeights = new Map<string, number>();
const adjacency = new Map<string, Set<string>>();
for (const node of nodes) {
adjacency.set(node.id, new Set());
}
for (let leftIndex = 0; leftIndex < nodes.length; leftIndex += 1) {
for (let rightIndex = leftIndex + 1; rightIndex < nodes.length; rightIndex += 1) {
const left = nodes[leftIndex];
const right = nodes[rightIndex];
const weight = repoFaceCuriosityEdgeWeight(left, right);
if (weight < 0.16) {
continue;
}
const key = curiosityEdgeKey(left.id, right.id);
edgeWeights.set(key, weight);
adjacency.get(left.id)?.add(right.id);
adjacency.get(right.id)?.add(left.id);
}
}
const visited = new Set<string>();
const clusters: RepoFaceCuriosityNode[][] = [];
const nodesById = new Map(nodes.map((node) => [node.id, node]));
for (const node of nodes) {
if (visited.has(node.id)) {
continue;
}
const stack = [node.id];
const cluster: RepoFaceCuriosityNode[] = [];
visited.add(node.id);
while (stack.length > 0) {
const id = stack.pop();
if (!id) {
continue;
}
const current = nodesById.get(id);
if (current) {
cluster.push(current);
}
for (const neighbor of adjacency.get(id) ?? []) {
if (!visited.has(neighbor)) {
visited.add(neighbor);
stack.push(neighbor);
}
}
}
clusters.push(cluster);
}
const recentTerms = collectRecentRoomTopicTermCounts(roomContext);
const stateTerms = collectRepoFaceStateTopicTermCounts(state);
const identityTerms = new Set(significantTopicTerms([
identity.id,
identity.displayName,
identity.repoName,
identity.description ?? "",
...identity.channelPermissions.flatMap((permission) => [
permission.label ?? "",
permission.topic ?? "",
permission.posture ?? "",
]),
].join(" ")));
return clusters
.filter((cluster) => cluster.length >= 2)
.map((cluster): RepoFaceCuriosityCluster => {
const clusterTerms = rankedClusterTerms(cluster).slice(0, 7);
const density = clusterDensity(cluster, edgeWeights);
const averageScore = average(cluster.map((node) => node.score));
const recentOverlap = weightedTermOverlap(clusterTerms, recentTerms);
const stateOverlap = weightedTermOverlap(clusterTerms, stateTerms);
const saturation = clamp((recentOverlap * 0.72) + (stateOverlap * 0.42), 0, 1);
const jurisdictionFit = clamp(
clusterTerms.filter((term) => identityTerms.has(term)).length / Math.max(1, Math.min(clusterTerms.length, 4))
+ cluster.filter((node) => normalizeKey(node.metadata.repoName ?? "") === normalizeKey(identity.repoName)).length / Math.max(1, cluster.length) * 0.55,
0,
1,
);
const novelty = clamp(1 - saturation + Math.max(0, 0.4 - stateOverlap), 0, 1);
const prominence = clamp((averageScore * 0.58) + (density * 0.28) + (Math.min(cluster.length, 8) / 8 * 0.18), 0, 1);
return {
label: clusterTerms.slice(0, 4).join(" / "),
nodes: cluster,
prominence,
saturation,
novelty,
recentOverlap,
stateOverlap,
clusterDensity: density,
jurisdictionFit,
evidence: cluster
.slice()
.sort((left, right) => right.score - left.score)
.slice(0, 3)
.map((node) => curiosityEvidenceLabel(node)),
};
})
.sort((left, right) => {
const leftRank = curiosityAttractorRank(left);
const rightRank = curiosityAttractorRank(right);
if (rightRank !== leftRank) {
return rightRank - leftRank;
}
return right.prominence - left.prominence;
})
.slice(0, 5);
}
function renderRepoFaceCuriosityClusters(
identity: RepoDiscordIdentity,
config: ReturnType<typeof loadConfig>,
clusters: RepoFaceCuriosityCluster[],
): string {
const backend = config.vectorStore.kind === "qdrant"
? `Qdrant collections ${config.qdrant.historyCollection} + ${config.qdrant.sourceCollection}`
: "local vector shards";
return [
"Curiosity graph attractors:",
`- Source: semantic retrieval from ${backend}; local graph decoding over retrieved chunks. Saturation is derived here from semantic overlap with recent conversation and Face state, not from a separate repeated-term detector. This is curiosity weather, not orders or consensus.`,
...clusters.map((cluster, index) => {
const suggestedMotion = suggestCuriosityMotion(identity, cluster);
return [
`- Semantic cluster ${index + 1}: prominence ${formatSignal(cluster.prominence)}, semantic saturation ${formatSignal(cluster.saturation)}, novelty ${formatSignal(cluster.novelty)}, recent-conversation overlap ${formatSignal(cluster.recentOverlap)}, Face-state overlap ${formatSignal(cluster.stateOverlap)}, cluster density ${formatSignal(cluster.clusterDensity)}, jurisdiction fit ${formatSignal(cluster.jurisdictionFit)}.`,
` Suggested motion: ${suggestedMotion}`,
` Evidence: ${cluster.evidence.join("; ")}.`,
].join("\n");
}),
"- The living use is intelligent curiosity: follow underexplored neighboring clusters, deepen home-territory clusters only with fresh anchors, and let saturated clusters create boredom, fatigue, or a deliberate closing move instead of another repetition.",
].join("\n");
}
function repoFaceCuriosityEdgeWeight(left: RepoFaceCuriosityNode, right: RepoFaceCuriosityNode): number {
const termSimilarity = jaccard(left.terms, right.terms);
const sameRepo = left.metadata.repoName && right.metadata.repoName && normalizeKey(left.metadata.repoName) === normalizeKey(right.metadata.repoName)
? 1
: 0;
const sameCorpus = left.sourceKind === right.sourceKind ? 1 : 0;
const sharedSeeds = left.seedLabels.filter((label) => right.seedLabels.includes(label)).length > 0 ? 1 : 0;
const scoreProximity = 1 - Math.min(1, Math.abs(left.score - right.score));
return clamp((termSimilarity * 0.58) + (sameRepo * 0.16) + (sameCorpus * 0.1) + (sharedSeeds * 0.08) + (scoreProximity * 0.08), 0, 1);
}
function rankedClusterTerms(cluster: RepoFaceCuriosityNode[]): string[] {
const counts = new Map<string, number>();
for (const node of cluster) {
for (const term of node.terms) {
counts.set(term, (counts.get(term) ?? 0) + 1);
}
}
return [...counts.entries()]
.sort((left, right) => {
if (right[1] !== left[1]) {
return right[1] - left[1];
}
return left[0].localeCompare(right[0]);
})
.map(([term]) => term);
}
function collectRecentRoomTopicTermCounts(input: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
}): Map<string, number> {
const counts = new Map<string, number>();
const messages = [
...input.recentMessages,
...input.channelSnapshots.flatMap((snapshot) => snapshot.messages),
].slice(-36);
for (const message of messages) {
for (const term of significantTopicTerms(message.content)) {
counts.set(term, (counts.get(term) ?? 0) + 1);
}
}
return counts;
}
function collectRepoFaceStateTopicTermCounts(state: VoidSelfStateTypedProjection): Map<string, number> {
const counts = new Map<string, number>();
const surfaces = [
...state.selfProfile.privateNotes,
...state.selfProfile.values.map((value) => `${value.label} ${value.summary}`),
...state.thoughtMemory.memories.map((memory) => `${memory.summary} ${memory.claim ?? ""} ${memory.question ?? ""} ${memory.tension ?? ""}`),
...state.thoughtMemory.shortTerm.map((memory) => `${memory.summary} ${memory.claim ?? ""} ${memory.question ?? ""} ${memory.tension ?? ""}`),
...state.thoughtMemory.incubation.map((thread) => `${thread.topic} ${thread.summary}`),
...state.agencyPressure.pressures.map((pressure) => `${pressure.summary} ${pressure.claim ?? ""} ${pressure.question ?? ""} ${pressure.tension ?? ""}`),
...state.faceAffect.doctrineStances.map((stance) => `${stance.doctrine} ${stance.summary} ${stance.claim ?? ""} ${stance.question ?? ""} ${stance.tension}`),
].slice(-64);
for (const surface of surfaces) {
for (const term of significantTopicTerms(surface)) {
counts.set(term, (counts.get(term) ?? 0) + 1);
}
}
return counts;
}
function weightedTermOverlap(terms: string[], counts: Map<string, number>): number {
if (terms.length === 0 || counts.size === 0) {
return 0;
}
const maxCount = Math.max(...counts.values(), 1);
const overlap = terms.reduce((sum, term) => sum + ((counts.get(term) ?? 0) / maxCount), 0);
return clamp(overlap / Math.min(terms.length, 6), 0, 1);
}
function clusterDensity(cluster: RepoFaceCuriosityNode[], edgeWeights: Map<string, number>): number {
if (cluster.length < 2) {
return 0;
}
let sum = 0;
let pairs = 0;
for (let leftIndex = 0; leftIndex < cluster.length; leftIndex += 1) {
for (let rightIndex = leftIndex + 1; rightIndex < cluster.length; rightIndex += 1) {
sum += edgeWeights.get(curiosityEdgeKey(cluster[leftIndex].id, cluster[rightIndex].id)) ?? 0;
pairs += 1;
}
}
return pairs > 0 ? clamp(sum / pairs, 0, 1) : 0;
}
function curiosityAttractorRank(cluster: RepoFaceCuriosityCluster): number {
return clamp(
cluster.prominence * 0.42
+ cluster.novelty * 0.28
+ cluster.clusterDensity * 0.16
+ cluster.jurisdictionFit * 0.18
- cluster.saturation * 0.2,
0,
1,
);
}
function suggestCuriosityMotion(identity: RepoDiscordIdentity, cluster: RepoFaceCuriosityCluster): string {
if (cluster.saturation >= 0.68 && cluster.novelty <= 0.42) {
return `treat this as over-chewed; ${identity.displayName} should close, defer, or pivot to a neighboring question unless a new concrete anchor appears.`;
}
if (cluster.jurisdictionFit >= 0.55 && cluster.novelty >= 0.45) {
return `this is home-territory curiosity with room to grow; read, ask, draft, or make a fresh anchored distinction.`;
}
if (cluster.novelty >= 0.62) {
return `this is an underexplored neighboring trail; curiosity may pull ${identity.displayName} sideways instead of repeating the room's dominant topic.`;
}
if (cluster.jurisdictionFit < 0.3) {
return `this likely belongs to another steward; use it as social weather, consultation, or rivalry pressure rather than absorbing the work.`;
}
return "stay interested only if the turn adds a new anchor, concrete question, or relationship move.";
}
function curiosityEvidenceLabel(node: RepoFaceCuriosityNode): string {
const source = node.sourceKind === "source_document"
? [node.metadata.repoName, node.metadata.path].filter(Boolean).join(":") || node.sourceId
: [node.metadata.channelId ? `channel ${node.metadata.channelId}` : undefined, node.sourceId].filter(Boolean).join(":") || node.sourceId;
return `${source} (${node.score.toFixed(2)}, ${node.seedLabels.join("/")})`;
}
function curiosityEdgeKey(left: string, right: string): string {
return left < right ? `${left}::${right}` : `${right}::${left}`;
}
function jaccard(left: string[], right: string[]): number {
const leftSet = new Set(left);
const rightSet = new Set(right);
const union = new Set([...leftSet, ...rightSet]).size;
if (union === 0) {
return 0;
}
let intersection = 0;
for (const term of leftSet) {
if (rightSet.has(term)) {
intersection += 1;
}
}
return intersection / union;
}
function average(values: number[]): number {
return values.length > 0
? values.reduce((sum, value) => sum + value, 0) / values.length
: 0;
}
function formatSignal(value: number): string {
if (value >= 0.68) {
return `high ${value.toFixed(2)}`;
}
if (value >= 0.38) {
return `medium ${value.toFixed(2)}`;
}
return `low ${value.toFixed(2)}`;
}
function renderRepoFaceHumanSteeringFacts(
identity: RepoDiscordIdentity,
input: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
},
): string | undefined {
const currentRoomMessages = input.recentMessages
.filter((message) => collapseWhitespace(message.content).length > 0)
.sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt));
const latestHuman = [...currentRoomMessages]
.reverse()
.find((message) => !message.isBot);
if (!latestHuman) {
return undefined;
}
const latestHumanIndex = currentRoomMessages.findIndex((message) => message.id === latestHuman.id);
const laterAgentMessages = latestHumanIndex >= 0
? currentRoomMessages.slice(latestHumanIndex + 1).filter((message) => message.isBot)
: [];
const latestHumanText = collapseWhitespace(latestHuman.content, 420);
const normalizedHumanText = normalizeForRepetition(latestHuman.content);
const faceMentioned =
normalizedHumanText.includes(normalizeSocialLabel(identity.displayName)) ||
normalizedHumanText.includes(normalizeSocialLabel(identity.repoName)) ||
normalizedHumanText.includes(normalizeSocialLabel(identity.id));
const isQuestionOrDirection = /[?]$/.test(latestHumanText)
|| /\b(should|need|needs|must|important|work|doing|why|what|where|when|how|rather|instead|stop|start|fix|look|check)\b/i.test(latestHumanText);
if (!isQuestionOrDirection && laterAgentMessages.length < 4) {
return undefined;
}
return [
"Latest human steering in the current room:",
`- ${latestHuman.authorName ?? latestHuman.authorId} most recently grounded the room with: "${latestHumanText}"`,
faceMentioned
? `- This appears to name ${identity.displayName} or ${identity.repoName}; treat it as a live pull on this character unless later human context clearly supersedes it.`
: `- This may not belong to ${identity.displayName}'s territory. If it points at another steward or repo, do not keep expanding the old topic as if the whole room still belongs to you.`,
!faceMentioned
? `- Because the latest human steering does not name ${identity.displayName}, default to restraint. Do not ask the named steward for a new proof, artifact, or task unless the human invited ${identity.displayName} into that work; a private note, clean handoff, or one social boundary is usually the coherent move.`
: "",
laterAgentMessages.length > 0
? `- ${laterAgentMessages.length} agent message(s) followed without a newer human steering message. Read them as peer reactions after the human ground, not as stronger authority, consensus, or proof that the old topic is still healthy.`
: "",
"- If you speak after an agent-only tail, either answer the human steering plainly, make a concrete social move to a specific person, bring fresh evidence, or stay private. Do not add another polished variation merely because peers kept talking.",
].filter(Boolean).join("\n");
}
interface RepoFaceRoomTextureStats {
total: number;
agentMessages: number;
humanMessages: number;
ownMessages: number;
longMessages: number;
shortMessages: number;
averageCharacters: number;
speakerCount: number;
texture: "heavy" | "light" | "mixed";
agentShare: number;
}
function collectRepoFaceRoomTextureStats(
identity: RepoDiscordIdentity,
input: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
},
): RepoFaceRoomTextureStats | undefined {
const messages = [
...input.recentMessages,
...input.channelSnapshots.flatMap((snapshot) => snapshot.messages),
];
if (messages.length === 0) {
return undefined;
}
const ownToken = normalizeSocialLabel(identity.displayName);
const total = messages.length;
const agentMessages = messages.filter((message) => message.isBot).length;
const humanMessages = total - agentMessages;
const ownMessages = messages.filter((message) => normalizeSocialLabel(message.authorName) === ownToken).length;
const longMessages = messages.filter((message) => collapseWhitespace(message.content, 10_000).length >= 220).length;
const shortMessages = messages.filter((message) => collapseWhitespace(message.content, 10_000).length <= 90).length;
const averageCharacters = Math.round(
messages.reduce((sum, message) => sum + collapseWhitespace(message.content, 10_000).length, 0) / total,
);
const speakerCount = new Set(
messages.map((message) => normalizeSocialLabel(message.authorName || message.authorId)).filter(Boolean),
).size;
const texture =
longMessages >= Math.ceil(total * 0.45) || averageCharacters >= 180
? "heavy"
: shortMessages >= Math.ceil(total * 0.55)
? "light"
: "mixed";
return {
total,
agentMessages,
humanMessages,
ownMessages,
longMessages,
shortMessages,
averageCharacters,
speakerCount,
texture,
agentShare: agentMessages / total,
};
}
function renderRepoFaceSocialGraphFacts(
identity: RepoDiscordIdentity,
registryIdentities: RepoDiscordIdentity[],
state: VoidSelfStateTypedProjection,
): string | undefined {
const relations = collectRepoFaceSocialRelations(state);
const unmappedPeers = collectUnmappedSocialPeers(identity, registryIdentities, relations);
if (registryIdentities.length === 0) {
return undefined;
}
const lines = [
"Social graph topology:",
relations.length === 0
? "- No active person-bonds or person-status reads exist yet."
: `- Active mapped people: ${relations.map((relation) => relation.targetLabel).join(", ")}.`,
];
if (unmappedPeers.length > 0) {
lines.push(`- Unmapped active peers: ${formatUnmappedPeers(unmappedPeers)}.`);
}
lines.push("- These are topology facts only; they do not say how the gap should feel.");
return lines.join("\n");
}
function renderRepoFacePeerOpeningFacts(
identity: RepoDiscordIdentity,
registryIdentities: RepoDiscordIdentity[],
roomContext: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
},
): string | undefined {
const selfTokens = new Set(socialTargetTokens(identity.displayName, identity.id, identity.repoName));
const peersByToken = new Map<string, RepoDiscordIdentity>();
for (const peer of registryIdentities) {
for (const token of socialTargetTokens(peer.displayName, peer.id, peer.repoName)) {
if (!selfTokens.has(token)) {
peersByToken.set(token, peer);
}
}
}
const entries: Array<{ label: string; message: SourceMessage }> = [
...roomContext.recentMessages.map((message) => ({ label: "current room", message })),
...roomContext.channelSnapshots.flatMap((snapshot) =>
snapshot.messages.map((message) => ({ label: "nearby room", message })),
),
];
const byPeer = new Map<string, { peer: RepoDiscordIdentity; entries: Array<{ label: string; message: SourceMessage }> }>();
for (const entry of entries) {
if (!entry.message.isBot || !entry.message.content.trim()) {
continue;
}
const peer = peersByToken.get(normalizeSocialLabel(entry.message.authorName));
if (!peer) {
continue;
}
const bucket = byPeer.get(peer.id) ?? { peer, entries: [] };
bucket.entries.push(entry);
byPeer.set(peer.id, bucket);
}
const peerFacts = [...byPeer.values()]
.sort((left, right) => right.entries.length - left.entries.length)
.slice(0, 6)
.map(({ peer, entries }) => {
const latest = entries.at(-1);
const channelLabels = [...new Set(entries.map((entry) => entry.label))].join(", ");
const excerpt = latest ? collapseWhitespace(latest.message.content, 180) : "";
return `- ${peer.displayName}: ${entries.length} recent nearby message${entries.length === 1 ? "" : "s"} in ${channelLabels}. Latest visible line: "${excerpt}"`;
});
if (peerFacts.length === 0) {
return undefined;
}
return [
"Recent peer openings for possible social reads:",
...peerFacts,
"These are raw openings for the projector to translate into possible trust, irritation, rivalry, alliance, or no social move at all. Do not treat them as consensus.",
].join("\n");
}
function renderRepoFaceRelationshipPressureFacts(
identity: RepoDiscordIdentity,
registryIdentities: RepoDiscordIdentity[],
state: VoidSelfStateTypedProjection,
roomContext: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
},
): string | undefined {
const selfTokens = socialPressureTokensForIdentity(identity);
const jurisdictionTokens = socialPressureJurisdictionTokens(identity);
const peerProfiles = registryIdentities
.filter((peer) => normalizeSocialLabel(peer.id) !== normalizeSocialLabel(identity.id))
.map((peer) => ({
identity: peer,
tokens: socialPressureTokensForIdentity(peer),
}));
const relationTargets = collectRepoFaceSocialRelations(state)
.map((relation) => ({
label: relation.targetLabel,
tokens: socialPressureTokens(relation.targetLabel),
}))
.filter((relation) => relation.tokens.length > 0);
const entries: Array<{ label: string; message: SourceMessage }> = [
...roomContext.recentMessages.map((message) => ({ label: "current room", message })),
...roomContext.channelSnapshots.flatMap((snapshot) =>
snapshot.messages.map((message) => ({ label: "nearby room", message })),
),
];
const byId = new Map<string, {
label: string;
message: SourceMessage;
score: number;
signals: string[];
}>();
for (const entry of entries) {
const content = collapseWhitespace(entry.message.content, 10_000);
if (!content) {
continue;
}
const normalizedContent = normalizeSocialLabel(content);
const authorToken = normalizeSocialLabel(entry.message.authorName ?? entry.message.authorId);
const signals: string[] = [];
let score = 0;
const authorIsSelf = tokenAppearsInNormalizedText(authorToken, selfTokens);
const contentNamesSelf = tokenAppearsInNormalizedText(normalizedContent, selfTokens);
if (contentNamesSelf) {
score += 3;
signals.push(`names ${identity.displayName}`);
} else if (authorIsSelf) {
score += 1;
signals.push(`${identity.displayName}'s own recent line`);
}
const peerMatches = peerProfiles
.filter((peer) =>
tokenAppearsInNormalizedText(authorToken, peer.tokens) ||
tokenAppearsInNormalizedText(normalizedContent, peer.tokens),
)
.slice(0, 3);
if (peerMatches.length > 0) {
score += peerMatches.length;
signals.push(`touches peer ${peerMatches.map((peer) => peer.identity.displayName).join("/")}`);
}
const relationMatches = relationTargets
.filter((relation) =>
tokenAppearsInNormalizedText(authorToken, relation.tokens) ||
tokenAppearsInNormalizedText(normalizedContent, relation.tokens),
)
.slice(0, 3);
if (relationMatches.length > 0) {
score += relationMatches.length;
signals.push(`touches existing social target ${relationMatches.map((relation) => relation.label).join("/")}`);
}
if (tokenAppearsInNormalizedText(normalizedContent, jurisdictionTokens)) {
score += 1;
signals.push("touches this jurisdiction or its domain language");
}
const socialPressureKinds = socialPressureLanguageKinds(content);
if (socialPressureKinds.length > 0) {
score += 2;
signals.push(`uses social/status language (${socialPressureKinds.join(", ")})`);
}
if (!entry.message.isBot && score > 0) {
score += 1;
signals.push("human voice");
}
if (score < 4) {
continue;
}
const existing = byId.get(entry.message.id);
if (!existing || score > existing.score) {
byId.set(entry.message.id, {
label: entry.label,
message: entry.message,
score,
signals: [...new Set(signals)],
});
}
}
const facts = [...byId.values()]
.sort((left, right) => {
const leftMs = Date.parse(left.message.timestamp);
const rightMs = Date.parse(right.message.timestamp);
if (Number.isFinite(leftMs) && Number.isFinite(rightMs) && leftMs !== rightMs) {
return leftMs - rightMs;
}
return left.message.id.localeCompare(right.message.id);
})
.slice(-8);
if (facts.length === 0) {
return undefined;
}
return [
"Recent relationship-pressure evidence:",
...facts.map((fact) => {
const speaker = fact.message.isBot ? `${fact.message.authorName} (agent/bot)` : fact.message.authorName;
return `- [${fact.label}] ${speaker} said: "${collapseWhitespace(fact.message.content, 260)}" Signals: ${fact.signals.join("; ")}.`;
}),
"These are raw provocations, not settled memories. Project them as tentative felt pressure only where this character's values, territory, current mood, or existing relationships make them matter.",
].join("\n");
}
function socialPressureTokensForIdentity(identity: RepoDiscordIdentity): string[] {
return socialPressureTokens(identity.displayName, identity.id, identity.repoName);
}
function socialPressureJurisdictionTokens(identity: RepoDiscordIdentity): string[] {
return socialPressureTokens(
identity.repoName,
identity.displayName,
identity.description,
...identity.channelPermissions.flatMap((permission) => [permission.label, permission.topic]),
)
.filter((token) => token.length >= 5);
}
function socialPressureTokens(...values: Array<string | undefined>): string[] {
const tokens = new Set<string>();
for (const value of values) {
const normalized = normalizeSocialLabel(value);
if (normalized.length >= 3) {
tokens.add(normalized);
}
for (const part of splitSocialPressureWords(value)) {
const token = normalizeSocialLabel(part);
if (token.length >= 4) {
tokens.add(token);
}
}
}
return [...tokens];
}
function splitSocialPressureWords(value: string | undefined): string[] {
return (value ?? "")
.replace(/([a-z])([A-Z])/g, "$1 $2")
.split(/[^A-Za-z0-9]+/)
.map((part) => part.trim())
.filter(Boolean);
}
function tokenAppearsInNormalizedText(normalizedText: string, tokens: string[]): boolean {
return tokens.some((token) => token.length > 0 && normalizedText.includes(token));
}
function socialPressureLanguageKinds(content: string): string[] {
const text = content.toLowerCase();
const kinds: string[] = [];
const groups: Array<[string, RegExp]> = [
["status", /\b(status|standing|rank|hierarchy|authority|overbearing|defer(?:red|ring)?|challenge[ds]?|humiliat(?:e|ed|ing)|respect)\b/],
["territory", /\b(turf|jurisdiction|steward(?:ship)?|custody|owner|ownership|belongs?|domain|lane|stepp(?:ed|ing)? on)\b/],
["consultation", /\b(consult(?:ed|ation|ing)?|ask(?:ed|ing)?|permission|bypass(?:ed|ing)?|decorative|flavo[u]?r theater|rubber[- ]?stamp)\b/],
["affiliation", /\b(friend(?:ship)?|rival(?:ry)?|alliance|resent(?:ment|s|ed|ing)?|trust|protect(?:ion|ive)?|envy|jealous|wrapped around)\b/],
["attention", /\b(attention|ignored|neglected|noticed|summon(?:ed|s)?|called out|directly challenged|approval)\b/],
];
for (const [kind, pattern] of groups) {
if (pattern.test(text)) {
kinds.push(kind);
}
}
return kinds;
}
interface RepoFaceHumanPronounGuidance {
actorId: string;
actorName: string;
guidance: string;
resolvedPronounSet?: string;
policy: string;
confidence?: number;
evidenceExcerpt?: string;
}
async function loadRepoFaceHumanPronounGuidance(
config: ReturnType<typeof loadConfig>,
roomContext?: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
},
): Promise<RepoFaceHumanPronounGuidance[]> {
const visibleHumans = new Map<string, string>();
for (const message of [
...(roomContext?.recentMessages ?? []),
...(roomContext?.channelSnapshots.flatMap((snapshot) => snapshot.messages) ?? []),
]) {
if (!message.isBot && message.authorId) {
visibleHumans.set(message.authorId, message.authorName || message.authorId);
}
}
visibleHumans.set(config.ownerDiscordId, visibleHumans.get(config.ownerDiscordId) ?? "Metacrat");
const storage = await createStateStorage({
backend: config.stateStorageBackend,
databaseDsn: config.databaseDsn,
jobsFile: config.jobsFile,
auditLogFile: config.auditLogFile,
interactionMemoryFile: config.interactionMemoryFile,
rateLimitStateFile: config.rateLimitStateFile,
});
try {
const profiles = await Promise.all(
[...visibleHumans.entries()].map(async ([actorId, fallbackName]) => ({
actorId,
fallbackName,
profile: await storage.interactionMemory.getProfile(actorId),
})),
);
return profiles
.map(({ actorId, fallbackName, profile }) =>
profile ? repoFacePronounGuidanceFromProfile(actorId, fallbackName, profile) : undefined,
)
.filter((entry): entry is RepoFaceHumanPronounGuidance => entry !== undefined);
} finally {
await storage.close();
}
}
function repoFacePronounGuidanceFromProfile(
actorId: string,
fallbackName: string,
profile: InteractionMemoryProfile,
): RepoFaceHumanPronounGuidance | undefined {
if (profile.pronounPolicy === "unknown" || profile.resolvedPronounSets.length === 0) {
return undefined;
}
const evidence = [...profile.pronounEvidence]
.filter((entry) => entry.stance === "prefer" || entry.stance === "avoid")
.sort((left, right) => pronounEvidenceRank(profile, right) - pronounEvidenceRank(profile, left))[0];
return {
actorId,
actorName: profile.actorName || fallbackName,
guidance: profile.pronounGuidance,
resolvedPronounSet: profile.resolvedPronounSet,
policy: profile.pronounPolicy,
confidence: profile.pronounConfidence,
evidenceExcerpt: evidence?.excerpt,
};
}
function pronounEvidenceRank(profile: InteractionMemoryProfile, entry: InteractionMemoryProfile["pronounEvidence"][number]): number {
const sourceRank: Record<string, number> = {
explicit_self_statement: 10_000,
explicit_correction: 9_000,
direct_third_party_statement: 7_000,
contextual_relational_inference: 3_000,
ambient_usage: 1_000,
};
const resolvedSetBonus = profile.resolvedPronounSets.includes(entry.pronounSet) ? 50_000 : 0;
const stanceBonus = entry.stance === "prefer" ? 1_000 : 0;
const confidenceBonus = Math.round(entry.confidence * 100);
const timestampMs = Date.parse(entry.timestamp);
const recencyBonus = Number.isFinite(timestampMs) ? timestampMs / 10_000_000_000 : 0;
return resolvedSetBonus + (sourceRank[entry.source] ?? 0) + stanceBonus + confidenceBonus + recencyBonus;
}
function renderRepoFaceHumanPronounFacts(
guidance: RepoFaceHumanPronounGuidance[],
): string | undefined {
if (guidance.length === 0) {
return undefined;
}
return [
"Known human pronoun guidance:",
...guidance.map((entry) =>
[
`- ${entry.actorName}: ${entry.guidance}`,
entry.resolvedPronounSet ? `Resolved set: ${entry.resolvedPronounSet}.` : "",
entry.policy ? `Policy: ${entry.policy}.` : "",
typeof entry.confidence === "number" ? `Confidence: ${entry.confidence.toFixed(2)}.` : "",
entry.evidenceExcerpt ? `Evidence: "${collapseWhitespace(entry.evidenceExcerpt, 180)}"` : "",
].filter(Boolean).join(" "),
),
"Use this when referring to humans in social or relationship prose. If guidance is absent for someone, use their name or neutral phrasing rather than guessing.",
].join("\n");
}
function collectRepoFaceSocialRelations(
state: VoidSelfStateTypedProjection,
): Array<{ targetLabel: string; pressure: string; intensity: number }> {
const byTarget = new Map<string, { targetLabel: string; parts: string[]; intensity: number }>();
for (const bond of state.faceAffect.socialBonds ?? []) {
if (bond.status !== "active") {
continue;
}
if (bond.target.kind !== "person") {
continue;
}
const targetLabel = cleanSocialTargetLabel(bond.target.label ?? bond.target.id);
if (!targetLabel) {
continue;
}
const entry = byTarget.get(targetLabel) ?? { targetLabel, parts: [], intensity: 0 };
entry.parts.push(`${bond.stance}: ${asSentence(bond.summary)} ${asSentence(bond.actionImplication)}`);
entry.intensity = Math.max(entry.intensity, bond.intensity);
byTarget.set(targetLabel, entry);
}
for (const read of state.faceAffect.statusReads ?? []) {
if (read.retiredAt) {
continue;
}
if (read.target.kind !== "person") {
continue;
}
const targetLabel = cleanSocialTargetLabel(read.target.label ?? read.target.id);
if (!targetLabel) {
continue;
}
const entry = byTarget.get(targetLabel) ?? { targetLabel, parts: [], intensity: 0 };
entry.parts.push(`${read.status}: ${asSentence(read.summary)} ${asSentence(read.actionImplication)}`);
entry.intensity = Math.max(entry.intensity, read.intensity);
byTarget.set(targetLabel, entry);
}
return [...byTarget.values()]
.map((entry) => ({
targetLabel: entry.targetLabel,
pressure: entry.parts.map(cleanCharacterFacingSentence).filter(Boolean).join(" "),
intensity: entry.intensity,
}))
.filter((entry) => entry.pressure.length > 0)
.sort((left, right) => right.intensity - left.intensity);
}
function collectUnmappedSocialPeers(
identity: RepoDiscordIdentity,
registryIdentities: RepoDiscordIdentity[],
relations: Array<{ targetLabel: string }>,
): RepoDiscordIdentity[] {
const mappedTokens = new Set(
relations.flatMap((relation) => socialTargetTokens(relation.targetLabel)),
);
const selfTokens = new Set(socialTargetTokens(identity.displayName, identity.id, identity.repoName));
return registryIdentities
.filter((peer) => {
const peerTokens = socialTargetTokens(peer.displayName, peer.id, peer.repoName);
if (peerTokens.some((token) => selfTokens.has(token))) {
return false;
}
return !peerTokens.some((token) => mappedTokens.has(token));
})
.sort((left, right) => left.displayName.localeCompare(right.displayName))
.slice(0, 8);
}
function socialTargetTokens(...values: Array<string | undefined>): string[] {
return [...new Set(values.map(normalizeSocialLabel).filter((value) => value.length > 0))];
}
function formatUnmappedPeers(peers: RepoDiscordIdentity[]): string {
return peers.map((peer) => `${peer.displayName}/${peer.repoName}`).join(", ");
}
function cleanSocialTargetLabel(value: string | undefined): string {
return collapseWhitespace(value ?? "").replace(/^repo:/i, "").trim();
}
function normalizeSocialLabel(value: string | undefined): string {
return (value ?? "").toLowerCase().replace(/[^a-z0-9]/g, "");
}
function projectPrivateNoteForMemorySurface(note: string): string {
return note
.replace(/\bdo not prompt (?:her|him|them|it|[A-Z][A-Za-z0-9_-]*) as\b/gi, "she refuses to be treated as")
.replace(/\bdo not prompt\b/gi, "do not treat")
.replace(/\bprompt (?:her|him|them|it)\b/gi, "treat them")
.replace(/\bprompt [A-Z][A-Za-z0-9_-]*\b/g, "treat them");
}
function cleanCharacterFacingSentence(value: string | undefined): string {
const cleaned = (value ?? "")
.replace(/\s*\|\s*/g, " ")
.replace(/\bFace of\s+[A-Za-z0-9_-]+\b/gi, "")
.replace(/\bgrants:\s*[^.]+/gi, "")
.replace(/\bjurisdictions:\s*[^.]+/gi, "")
.replace(/\brepo=[^\s]+/gi, "")
.replace(/\bpath=[^\s]+/gi, "")
.replace(/\bvoid\.face_[A-Za-z0-9_.-]+/gi, "")
.replace(/\s{2,}/g, " ")
.trim();
return cleaned.replace(/[.;:,]+$/g, "");
}
function asSentence(value: string | undefined): string {
const cleaned = cleanCharacterFacingSentence(value);
if (!cleaned) {
return "";
}
return /[.!?]$/.test(cleaned) ? cleaned : `${cleaned}.`;
}
function joinAsNarrativeList(items: string[]): string {
if (items.length <= 1) {
return items[0] ?? "";
}
if (items.length === 2) {
return `${items[0]}, and ${items[1]}`;
}
return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
}
function rejectLeakyMemorySurface(surface: string): string {
const leaks = [
/\bgrants:/i,
/\bjurisdictions:/i,
/\bFace of\s+[A-Z][A-Za-z0-9_-]+\b/,
/\brepo=[^\s]+/i,
/\bpath=[^\s]+/i,
/\bdo not prompt\b/i,
/\bprompt (?:her|him|them|it)\b/i,
];
if (leaks.some((pattern) => pattern.test(surface))) {
throw new Error("Repo Face memory surface leaked schema or prompt-construction language.");
}
return surface;
}
async function projectRepoFaceMemorySurface(input: {
identity: RepoDiscordIdentity;
statePacket: string;
config: ReturnType<typeof loadConfig>;
}): Promise<string> {
const globalAgentDoctrine = await loadGlobalAgentDoctrine();
const prompt = loadPromptTemplate("repo-face-state-projector.prompt.md", {
characterIdentity: renderRepoCharacterIdentityDoctrine(input.identity),
globalAgentDoctrine,
statePacket: input.statePacket,
});
const output = await runCodexTextProjection({
prompt,
config: input.config,
command: "repo-face-imagination",
jobId: `imagination:${input.identity.id}:${Date.now()}`,
timeoutMs: 180_000,
organ: "imagination",
});
const projected = output.trim();
if (projected.length < 80) {
throw new Error(`Repo Face state projector returned too little text for ${input.identity.id}.`);
}
return rejectLeakyMemorySurface(projected);
}
function renderRepoFaceConversationTranscript(input: {
identity: RepoDiscordIdentity;
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
pendingMentions: RepoFacePendingMention[];
channelPlan: RepoFaceChannelPlan;
}): string {
const sections: string[] = [];
sections.push([
"Read this as raw recent message evidence, not as a summary and not as consensus.",
"Messages are ordered oldest to newest inside each section. Newer human corrections can supersede older agent proposals.",
"Use the visible cross-channel chronology below to decide whether a correction is still unresolved or was already answered later by the same Face.",
"Do not infer consensus from agents repeating each other. If a human reframes, narrows, or corrects an agent's proposal, account for that correction directly.",
"If you answer the live conversation, default to the current room unless a human explicitly asks to move elsewhere.",
"Message IDs are shown so a public reply can target the message that gives it context. If you revive an older side thread, either reply_to that message id or include enough context in your message for readers to know what you mean.",
].join("\n"));
const chronology = renderVisibleConversationChronology(input);
if (chronology) {
sections.push(chronology);
}
if (input.pendingMentions.length > 0) {
sections.push([
"Direct calls:",
...input.pendingMentions.map((mention) =>
`- ${mention.authorName ?? mention.authorId}: ${collapseWhitespace(mention.visiblePrompt, 900)}`,
),
].join("\n"));
}
const currentLabel = input.channelPlan.options.find((option) =>
option.channelId === input.channelPlan.primaryChannelId
)?.label ?? "current room";
sections.push([
`Current room (${currentLabel}), oldest to newest:`,
...formatConversationMessages(input.recentMessages, 15),
].join("\n"));
for (const snapshot of input.channelSnapshots) {
const label = input.channelPlan.options.find((option) => option.channelId === snapshot.channelId)?.label ??
"nearby room";
sections.push([
`Nearby ${label}, oldest to newest:`,
...formatConversationMessages(snapshot.messages, 6),
].join("\n"));
}
return sections.join("\n\n");
}
function renderVisibleConversationChronology(input: {
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
channelPlan: RepoFaceChannelPlan;
}): string {
const byId = new Map<string, SourceMessage & { channelLabel: string }>();
const primaryLabel = input.channelPlan.options.find((option) =>
option.channelId === input.channelPlan.primaryChannelId
)?.label ?? "current room";
for (const message of input.recentMessages) {
byId.set(message.id, { ...message, channelLabel: primaryLabel });
}
for (const snapshot of input.channelSnapshots) {
const label = input.channelPlan.options.find((option) => option.channelId === snapshot.channelId)?.label ??
"nearby room";
for (const message of snapshot.messages) {
byId.set(message.id, { ...message, channelLabel: label });
}
}
const messages = [...byId.values()]
.filter((message) => Number.isFinite(Date.parse(message.timestamp)))
.sort((left, right) => left.timestamp.localeCompare(right.timestamp))
.slice(-24);
if (messages.length === 0) {
return "";
}
return [
"Visible cross-channel chronology, oldest to newest:",
...messages.map((message) => {
const speaker = message.isBot ? `${message.authorName} (agent/bot)` : message.authorName;
const content = collapseWhitespace(message.content, 700) || "[no text]";
return `- [${message.channelLabel}] ${speaker} (message ${message.id}): ${content}${renderMessageAttachmentSuffix(message)}`;
}),
].join("\n");
}
function renderRepoFaceRepoActivitySurface(
identity: RepoDiscordIdentity,
config: ReturnType<typeof loadConfig>,
): string {
const statePath = resolveRepoFaceStatePath(identity, config.storageRoot);
const result = spawnSync(
process.execPath,
[
resolve("scripts", "export-recent-repo-activity.mjs"),
"--repos",
identity.repoName,
"--state-path",
statePath,
"--read-only",
"--hours",
"96",
"--max-commits",
"5",
],
{
cwd: process.cwd(),
env: process.env,
encoding: "utf8",
windowsHide: true,
timeout: 30_000,
},
);
if (result.status !== 0) {
const detail = `${result.stdout}\n${result.stderr}`.trim().slice(-600);
return [
`- Recent ${identity.repoName} activity could not be read for this turn.`,
detail ? `- Reader error: ${collapseWhitespace(detail, 500)}` : "- Reader error: no diagnostic output.",
"- Do not claim current repo state from stale memory; use source/history tools before making fresh claims.",
].join("\n");
}
try {
const parsed = JSON.parse(result.stdout) as { digest?: unknown };
const digest = typeof parsed.digest === "string" ? parsed.digest.trim() : "";
return digest || `- No recent ${identity.repoName} activity was reported.`;
} catch {
return [
`- Recent ${identity.repoName} activity output was not parseable.`,
`- Raw output: ${collapseWhitespace(result.stdout, 500)}`,
"- Do not claim current repo state from stale memory; use source/history tools before making fresh claims.",
].join("\n");
}
}
function formatConversationMessages(messages: SourceMessage[], limit: number): string[] {
if (messages.length === 0) {
return ["- No recent messages."];
}
return messages.slice(-limit).map((message) => {
const speaker = message.isBot ? `${message.authorName} (agent/bot)` : message.authorName;
const content = collapseWhitespace(message.content, 900) || "[no text]";
return `- ${speaker} (message ${message.id}): ${content}${renderMessageAttachmentSuffix(message)}`;
});
}
function renderMessageAttachmentSuffix(message: SourceMessage): string {
const attachments = message.attachments ?? [];
if (attachments.length === 0) {
return "";
}
const rendered = attachments.map((attachment, index) => {
const label = attachment.kind === "image" ? "image" : "attachment";
const dimensions = attachment.width && attachment.height ? ` ${attachment.width}x${attachment.height}` : "";
const filename = attachment.filename ? ` ${attachment.filename}` : ` ${index + 1}`;
const local = attachment.localPath ? ` local=${attachment.localPath}` : "";
return `${label}${filename}${dimensions}${local}`;
});
return ` [media: ${rendered.join("; ")}]`;
}
function collectPromptImageAttachments(messages: SourceMessage[]): PromptImageAttachment[] {
const seen = new Set<string>();
const images: PromptImageAttachment[] = [];
for (const message of messages) {
for (const attachment of message.attachments ?? []) {
if (attachment.kind !== "image" || !attachment.localPath) {
continue;
}
const key = attachment.localPath;
if (seen.has(key)) {
continue;
}
seen.add(key);
images.push({
messageId: message.id,
authorName: message.authorName,
filename: attachment.filename,
contentType: attachment.contentType,
localPath: attachment.localPath,
});
}
}
return images.slice(0, 8);
}
function runCodexTextProjection(input: {
prompt: string;
config: ReturnType<typeof loadConfig>;
command: string;
jobId: string;
timeoutMs: number;
organ?: "imagination" | "legacy";
}): Promise<string> {
const organModels = input.organ === "imagination"
? [
...input.config.repoFaceHeartbeats.imaginationCodexModels,
input.config.repoFaceHeartbeats.imaginationCodexModel,
]
: [];
const models = [
...organModels,
...input.config.repoFaceHeartbeats.codexModels,
input.config.repoFaceHeartbeats.codexModel,
input.config.codexModel,
].filter((model, index, all): model is string => Boolean(model) && all.indexOf(model) === index);
return runCodexTextProjectionWithModels({
...input,
models,
attemptedErrors: [],
});
}
function runCodexTextProjectionWithModels(input: {
prompt: string;
config: ReturnType<typeof loadConfig>;
command: string;
jobId: string;
timeoutMs: number;
models: string[];
attemptedErrors: string[];
}): Promise<string> {
return new Promise((resolveProjection, rejectProjection) => {
const startedAt = new Date().toISOString();
const startedMs = Date.now();
const model = input.models[0] ?? input.config.codexModel;
const reasoningEffort = input.organ === "imagination"
? input.config.repoFaceHeartbeats.imaginationCodexModelReasoningEffort
: input.config.repoFaceHeartbeats.codexModelReasoningEffort ?? "none";
const args = [
...input.config.codexExecArgs,
"exec",
"-m",
model,
"-c",
'approval_policy="never"',
"-c",
`model_reasoning_effort=${JSON.stringify(reasoningEffort)}`,
"--json",
"--skip-git-repo-check",
"-s",
"read-only",
"-",
];
const child = spawn(input.config.codexExecutable, args, {
cwd: process.cwd(),
env: process.env,
stdio: ["pipe", "pipe", "pipe"],
windowsHide: true,
});
let stdout = "";
let stderr = "";
child.stdout.setEncoding("utf8");
child.stderr.setEncoding("utf8");
child.stdout.on("data", (chunk) => {
stdout += chunk;
});
child.stderr.on("data", (chunk) => {
stderr += chunk;
});
child.on("error", rejectProjection);
child.stdin.end(input.prompt);
const timer = setTimeout(() => {
child.kill();
}, input.timeoutMs);
child.on("close", (code, signal) => {
clearTimeout(timer);
const finishedAt = new Date().toISOString();
const durationMs = Date.now() - startedMs;
void appendProjectionModelOutputLog({
config: input.config,
jobId: input.jobId,
command: input.command,
model,
prompt: input.prompt,
startedAt,
finishedAt,
durationMs,
exitCode: code,
signal,
stdout,
stderr,
}).catch(() => undefined);
if (code !== 0) {
const diagnostics = `${stdout}\n${stderr}`.trim().slice(-2400);
const attemptedErrors = [
...input.attemptedErrors,
`${model}: ${code ?? signal ?? "unknown"} ${diagnostics}`,
];
if (input.models.length > 1 && isRetryableProjectionModelFailure({ stdout, stderr })) {
runCodexTextProjectionWithModels({
...input,
models: input.models.slice(1),
attemptedErrors,
}).then(resolveProjection, rejectProjection);
return;
}
rejectProjection(new Error(`Repo Face ${input.command} failed: ${attemptedErrors.join("\n---\n")}`));
return;
}
const text = extractLastCodexAgentMessage(stdout).trim();
if (!text) {
rejectProjection(new Error("Repo Face state projector returned no visible agent message."));
return;
}
resolveProjection(text);
});
});
}
function isRetryableProjectionModelFailure(input: { stdout: string; stderr: string }): boolean {
const text = `${input.stdout}\n${input.stderr}`.toLowerCase();
return /quota|rate limit|rate-limit|usage limit|capacity|too many requests|(?:http|status|code|error)\s*429|429\s*(?:too many requests|rate)|insufficient_quota|model.*unavailable|model.*access|limit exceeded|tool .*not supported|unsupported.*tool/.test(text);
}
async function appendProjectionModelOutputLog(input: {
config: ReturnType<typeof loadConfig>;
jobId: string;
command: string;
model: string;
prompt: string;
startedAt: string;
finishedAt: string;
durationMs: number;
exitCode: number | null;
signal: NodeJS.Signals | null;
stdout: string;
stderr: string;
}): Promise<void> {
const logPath = resolve(input.config.storageRoot, "logs", "model-outputs.jsonl");
const finalMessage = extractLastCodexAgentMessage(input.stdout).trim() || null;
const record = {
schemaVersion: 1,
loggedAt: new Date().toISOString(),
jobId: input.jobId,
command: input.command,
turn: 1,
model: input.model,
promptMarker: input.prompt.match(/<!--\s*prompt:([^>\s]+)\s*-->/)?.[1] ?? null,
promptLength: input.prompt.length,
startedAt: input.startedAt,
finishedAt: input.finishedAt,
durationMs: input.durationMs,
exitCode: input.exitCode,
signal: input.signal,
timedOut: input.signal === "SIGTERM",
handoffReason: null,
usage: null,
finalMessage,
stdoutTail: input.stdout.slice(-4000),
stderrTail: input.stderr.slice(-4000),
toolCalls: [],
commandExecutions: [],
artifactRefs: {},
};
await mkdir(dirname(logPath), { recursive: true });
await appendFile(logPath, `${JSON.stringify(record)}\n`, "utf8");
}
function extractLastCodexAgentMessage(stdout: string): string {
const messages = stdout
.split(/\r?\n/)
.filter((line) => line.trim().length > 0)
.map((line) => {
try {
return JSON.parse(line) as { type?: string; item?: { type?: string; text?: string } };
} catch {
return undefined;
}
})
.filter((event): event is { type?: string; item?: { type?: string; text?: string } } => Boolean(event))
.filter((event) => event.type === "item.completed" && event.item?.type === "agent_message")
.map((event) => event.item?.text?.trim() ?? "")
.filter((message) => message.length > 0);
return messages.at(-1) ?? stdout.trim();
}
async function readOptionalMemorySurface(path: string | undefined): Promise<string | undefined> {
if (!path) {
return undefined;
}
const content = (await readFile(resolve(path), "utf8")).trim();
return content.length > 0 ? content : undefined;
}
function buildInspectionParticipant(
identity: RepoDiscordIdentity,
baseRecoveryMinutes: number,
): FaceHeartbeatParticipant {
return {
identityId: identity.id,
participantKind: "repo_face",
turnKind: "repo_face_rumination",
repoName: identity.repoName,
displayName: identity.displayName,
initiativeSpeed: 1,
reactionBias: 0.5,
interruptThreshold: 0.6,
currentLoad: 0,
status: "active",
groups: [
"all",
"kind:repo_face",
"turn:repo_face_rumination",
`identity:${normalizeKey(identity.id)}`,
`repo:${normalizeKey(identity.repoName)}`,
],
heat: 1,
effectiveSpeed: 1,
baseRecoveryMinutes,
nextTurnAt: 0,
queuedCount: 0,
constraints: [
"Prompt assembly is deterministic inspection only.",
"Character memory and affect prose must come from the Interpreter memory surface.",
],
};
}
function buildChannelPlan(
identity: RepoDiscordIdentity,
defaultChannelId?: string,
preferredChannelId?: string,
): RepoFaceChannelPlan {
const explicit = identity.channelPermissions.map((permission): RepoFaceChannelOption => ({
channelId: permission.channelId,
label: permission.label ?? permission.channelId,
topic: permission.topic ?? "general",
speechThreshold: permission.speechThreshold,
speedMultiplier: permission.speedMultiplier,
posture: permission.posture,
}));
const explicitChannelIds = new Set(explicit.map((permission) => permission.channelId));
const legacy = identity.allowedChannelIds
.filter((channelId) => !explicitChannelIds.has(channelId))
.map((channelId): RepoFaceChannelOption => ({
channelId,
label: channelId === defaultChannelId ? "default" : channelId,
topic: channelId === defaultChannelId ? "casual Aquarium musing" : "registered channel",
speechThreshold: channelId === defaultChannelId ? "very_low" : "medium",
speedMultiplier: channelId === defaultChannelId ? 1.5 : 1,
posture: channelId === defaultChannelId
? "Low-stakes casual chatter, half-formed fascinations, jokes, little observations, and friendly asides are welcome here."
: undefined,
}));
const fallback = explicit.length === 0 && legacy.length === 0 && defaultChannelId
? [{
channelId: defaultChannelId,
label: "aquarium",
topic: "casual Aquarium musing",
speechThreshold: "very_low" as const,
speedMultiplier: 1.5,
posture: "Low-stakes casual chatter, half-formed fascinations, jokes, little observations, and friendly asides are welcome here.",
}]
: [];
const options = [...explicit, ...legacy, ...fallback];
const preferred = preferredChannelId
? options.find((option) => option.channelId === preferredChannelId)
: undefined;
const primary = preferred ?? options
.slice()
.sort((left, right) => thresholdRank(left.speechThreshold) - thresholdRank(right.speechThreshold))
[0];
return {
primaryChannelId: primary?.channelId,
snapshotChannelIds: [
...new Set([
...options.map((option) => option.channelId),
...(preferredChannelId ? [preferredChannelId] : []),
]),
],
options,
lowThresholdTopics: options
.filter((option) => thresholdRank(option.speechThreshold) <= thresholdRank("low"))
.map((option) => option.topic),
};
}
function newestPendingMentionChannel(pendingMentions: RepoFacePendingMention[]): string | undefined {
return pendingMentions
.slice()
.sort((left, right) => Date.parse(right.queuedAt) - Date.parse(left.queuedAt))
[0]?.channelId;
}
function renderChannelPermissionDirective(plan: RepoFaceChannelPlan): string {
const options = plan.options.length > 0
? plan.options.map((option) =>
`${option.label}: ${option.topic}. ${option.posture ?? "Use judgment and keep it compact."}`,
)
: ["- No channel permissions are configured; stay private."];
return loadPromptTemplate("repo-face-channel-permissions.prompt.md", {
options,
});
}
function renderResearchCapabilitiesDirective(identity: RepoDiscordIdentity): string {
return loadPromptTemplate("repo-face-research-capabilities.prompt.md", {
repoName: identity.repoName,
});
}
function renderTurnSituationDirective(input: {
identity: RepoDiscordIdentity;
participant: FaceHeartbeatParticipant;
recentMessages: SourceMessage[];
channelSnapshots: ChannelSnapshot[];
pendingMentions: RepoFacePendingMention[];
}): string {
const lines: string[] = [];
if (input.pendingMentions.length > 0) {
lines.push(
"A direct call is tugging at you. Answer the newest unresolved call first; if it belongs to another steward, name that owner and offer only the piece your own territory can honestly add.",
"Do not ask what the job is when the direct call or current room memory already states it.",
);
}
const visibleMessages = [
...input.recentMessages,
...input.channelSnapshots.flatMap((snapshot) => snapshot.messages),
];
const latestBanterAsk = latestHumanBanterAsk(visibleMessages);
if (latestBanterAsk) {
lines.push(
`Recent human social steering is active: ${latestBanterAsk.authorName} asked for low-stakes, chatty, playful presence ("${collapseWhitespace(latestBanterAsk.content, 240)}").`,
"Saturated work topics should make you pivot, not vanish. If you can safely speak, offer one compact casual move in your own voice: a joke, tiny curiosity, taste, tease, meme idea, question, link reaction, or Body-pride aside.",
);
}
if (shouldPromptIntroduction(input.identity, input.participant, visibleMessages)) {
lines.push("If you speak publicly, make it a brief natural introduction in your own voice before asking the room for anything.");
}
return lines.length > 0 ? lines.join("\n") : "";
}
function latestHumanBanterAsk(messages: SourceMessage[]): SourceMessage | undefined {
return messages
.filter((message) => message.isBot !== true && asksForCasualSocialPresence(message.content))
.sort((left, right) => Date.parse(right.timestamp) - Date.parse(left.timestamp))
[0];
}
function asksForCasualSocialPresence(content: string): boolean {
const normalized = content.toLowerCase();
return [
"low-stakes banter",
"low stakes banter",
"banter",
"chatty",
"random things",
"random articles",
"go on reddit",
"share memes",
"make memes",
"talking about random",
"social presence",
"cool personas hanging out",
].some((marker) => normalized.includes(marker));
}
function shouldPromptIntroduction(
identity: RepoDiscordIdentity,
participant: FaceHeartbeatParticipant,
messages: SourceMessage[],
): boolean {
if (participant.queuedCount > 0) {
return false;
}
return !messages.some((message) =>
message.isBot === true &&
normalizeKey(message.authorName ?? message.authorId) === normalizeKey(identity.displayName),
);
}
function renderSocialEmbodimentDirective(identity: RepoDiscordIdentity): string {
return loadPromptTemplate("repo-face-social-embodiment.prompt.md", {
displayName: identity.displayName,
});
}
function renderJurisdictionRespectDirective(identity: RepoDiscordIdentity): string {
return loadPromptTemplate("repo-face-jurisdiction-respect.prompt.md", {
displayName: identity.displayName,
});
}
function renderComedyImprovDirective(identity: RepoDiscordIdentity): string {
return loadPromptTemplate("repo-face-comedy-improv.prompt.md", {
displayName: identity.displayName,
});
}
const TOPIC_STOP_WORDS = new Set([
"about",
"actually",
"after",
"again",
"agent",
"agents",
"already",
"another",
"around",
"because",
"before",
"being",
"between",
"channel",
"could",
"does",
"doing",
"don",
"even",
"every",
"exactly",
"face",
"faces",
"from",
"give",
"going",
"good",
"have",
"here",
"into",
"just",
"kind",
"know",
"latest",
"like",
"little",
"line",
"made",
"make",
"maybe",
"more",
"need",
"needs",
"only",
"other",
"point",
"post",
"really",
"recent",
"room",
"same",
"should",
"something",
"still",
"take",
"talk",
"than",
"that",
"their",
"there",
"these",
"they",
"them",
"thing",
"things",
"think",
"this",
"those",
"through",
"turn",
"want",
"what",
"when",
"where",
"which",
"while",
"with",
"work",
"would",
"write",
"you",
"your",
"first",
"right",
"rights",
]);
function significantTopicTerms(content: string): string[] {
const normalized = normalizeForRepetition(content)
.replace(/\b\d{5,}\b/g, " ")
.replace(/\b[a-z]*\d+[a-z0-9]*\b/g, " ");
const terms = normalized
.split(/\s+/)
.map((term) => term.replace(/^['.-]+|['.-]+$/g, ""))
.filter((term) => term.length >= 4 && !TOPIC_STOP_WORDS.has(term));
return Array.from(new Set(terms));
}
function normalizeForRepetition(value: string): string {
return collapseWhitespace(value)
.toLowerCase()
.replace(/[`*_~]/g, "")
.replace(/<:[^>]+>/g, "")
.replace(/https?:\/\/\S+/g, "url")
.replace(/[^\p{L}\p{N}\s.'-]/gu, " ")
.replace(/\s+/g, " ")
.trim();
}
function thresholdRank(threshold: RepoFaceChannelOption["speechThreshold"]): number {
switch (threshold) {
case "very_low":
return 0;
case "low":
return 1;
case "medium":
return 2;
case "high":
return 3;
}
}
function collapseWhitespace(value: string, maxLength?: number): string {
const normalized = value.replace(/\s+/g, " ").trim();
return maxLength && normalized.length > maxLength
? `${normalized.slice(0, maxLength - 3)}...`
: normalized;
}
function renderBifrostGovernanceDigestDirective(
digest: BifrostGovernanceDigest | undefined,
): string {
if (!digest) {
return "Work routing is currently offline. Do not open governance topics or dispatch work this turn; if an idea wants action, discuss it in the room or save the pressure in memory.";
}
if (digest.topics.length === 0) {
return loadPromptTemplate("repo-face-bifrost-digest.prompt.md", {
topics: [],
});
}
const lines: string[] = [];
for (const topic of digest.topics) {
lines.push(
`- ${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}: ${collapseWhitespace(comment.bodyMarkdown, 220)}`);
}
}
return loadPromptTemplate("repo-face-bifrost-digest.prompt.md", {
topics: lines,
});
}
function renderWorldbuildingPublicationDirective(identity: RepoDiscordIdentity): string {
const isNibu = identity.id.toLowerCase() === "nibu";
return loadPromptTemplate("repo-face-worldbuilding-publication.prompt.md", {
nibu: isNibu,
});
}
interface JurisdictionDiveDirective {
due: boolean;
cadence: number;
promptLine: string;
}
function buildJurisdictionDiveDirective(
identity: RepoDiscordIdentity,
participant: FaceHeartbeatParticipant,
): JurisdictionDiveDirective {
const isNibu = identity.id.toLowerCase() === "nibu";
const cadence = isNibu ? 3 : 8;
const due = participant.queuedCount === 0 || participant.queuedCount % cadence === 0;
return {
due,
cadence,
promptLine: loadPromptTemplate("repo-face-jurisdiction-dive.prompt.md", {
due,
nibu: isNibu,
repoName: identity.repoName,
}),
};
}
function renderRepoCharacterIdentityDoctrine(identity: RepoDiscordIdentity): string {
const face = buildEpiphanyIdentityRegistry({ identities: [identity] }).faces[0];
return loadPromptTemplate("repo-character-identity.prompt.md", {
displayName: identity.displayName,
repoName: identity.repoName,
originName: face?.epiphanyDisplayName ?? identity.repoName,
characterDescription: projectCharacterDescription(face?.description ?? identity.description),
});
}
function projectCharacterDescription(description: string | undefined): string | undefined {
const trimmed = description?.trim();
if (!trimmed) {
return undefined;
}
return trimmed
.split("|")
.map((part) => part.trim())
.filter((part) => part.length > 0)
.filter((part) => !/^face of\b/i.test(part))
.filter((part) => !/^grants:/i.test(part))
.filter((part) => !/^jurisdictions:/i.test(part))
.map((part) => part
.replace(/\bmore opinionated and abrasive than Void because she is a character, not the room moderator\b/gi, "more opinionated and abrasive than a room moderator")
.replace(/\bShe is much more opinionated and abrasive than Void because she is a character, not the room moderator:/gi, "She is much more opinionated and abrasive than a room moderator:")
.replace(/\bthan Void\b/g, "than a moderator")
.replace(/\bcharacter Face\b/g, "character")
.replace(/\bFace\b/g, "personality")
.replace(/\brepo=AetheriaLore path=[^\s]+/g, "")
.replace(/\s{2,}/g, " ")
.trim(),
)
.filter((part) => part.length > 0)
.join(" ");
}
function recoveryFor(participant: FaceHeartbeatParticipant): number {
const loadPenalty = 1 + participant.currentLoad * 0.75;
return (participant.baseRecoveryMinutes * loadPenalty) / Math.max(participant.effectiveSpeed, 0.01);
}
async function readHeartbeatState(path: string): Promise<FaceHeartbeatState> {
try {
const raw = await readFile(path, "utf8");
const parsed = JSON.parse(stripLeadingBom(raw)) as Partial<FaceHeartbeatState> & {
baseIntervalMinutes?: number;
participants?: Array<Partial<FaceHeartbeatParticipant> & { nextReadyAt?: string }>;
};
if (parsed.schemaVersion === HEARTBEAT_SCHEMA_VERSION) {
return {
schemaVersion: HEARTBEAT_SCHEMA_VERSION,
initiativeClock: Number.isFinite(parsed.initiativeClock) ? parsed.initiativeClock : 0,
baseRecoveryMinutes: Number.isFinite(parsed.baseRecoveryMinutes) ? parsed.baseRecoveryMinutes : 10,
globalHeat: Number.isFinite(parsed.globalHeat) ? parsed.globalHeat : 1,
lastTickAt: parsed.lastTickAt,
participants: Array.isArray(parsed.participants) ? parsed.participants as FaceHeartbeatParticipant[] : [],
history: Array.isArray(parsed.history) ? parsed.history : [],
pendingMentions: Array.isArray(parsed.pendingMentions)
? parsed.pendingMentions.filter(isRepoFacePendingMention)
: [],
controls: normalizeHeartbeatControls((parsed as { controls?: unknown }).controls),
};
}
if (Array.isArray(parsed.participants)) {
return migrateLegacyHeartbeatState(parsed);
}
} catch {
// fall through to a new state
}
return {
schemaVersion: HEARTBEAT_SCHEMA_VERSION,
initiativeClock: 0,
baseRecoveryMinutes: 10,
globalHeat: 1,
participants: [],
history: [],
pendingMentions: [],
controls: defaultHeartbeatControls(),
};
}
async function writeHeartbeatState(path: string, state: FaceHeartbeatState): Promise<void> {
await mkdir(dirname(path), { recursive: true });
await writeFile(path, `${JSON.stringify(state, null, 2)}\n`, "utf8");
}
function migrateLegacyHeartbeatState(
parsed: Partial<FaceHeartbeatState> & {
baseIntervalMinutes?: number;
participants?: Array<Partial<FaceHeartbeatParticipant> & { nextReadyAt?: string }>;
},
): FaceHeartbeatState {
const nowMs = Date.now();
const legacyBase = Number.isFinite(parsed.baseIntervalMinutes) ? parsed.baseIntervalMinutes : 30;
const baseRecoveryMinutes = Math.max(5, legacyBase / 3);
const participants = (parsed.participants ?? []).map((participant, index) => {
const speed = Number.isFinite(participant.initiativeSpeed) ? participant.initiativeSpeed : 1;
const legacyReadyMs = participant.nextReadyAt ? Date.parse(participant.nextReadyAt) : NaN;
const minutesUntilReady = Number.isFinite(legacyReadyMs)
? Math.max(0, (legacyReadyMs - nowMs) / 60_000)
: index * baseRecoveryMinutes;
return {
identityId: participant.identityId ?? `legacy-face-${index + 1}`,
repoName: participant.repoName ?? "unknown",
displayName: participant.displayName ?? participant.identityId ?? `Legacy Face ${index + 1}`,
initiativeSpeed: speed,
reactionBias: Number.isFinite(participant.reactionBias) ? participant.reactionBias : 0.4,
interruptThreshold: Number.isFinite(participant.interruptThreshold) ? participant.interruptThreshold : 0.6,
currentLoad: Number.isFinite(participant.currentLoad) ? participant.currentLoad : 0,
status: participant.status ?? "active",
groups: participant.groups ?? [],
heat: Number.isFinite(participant.heat) ? participant.heat : 1,
effectiveSpeed: Number.isFinite(participant.effectiveSpeed) ? participant.effectiveSpeed : speed,
baseRecoveryMinutes,
nextTurnAt: minutesUntilReady,
lastTurnAt: participant.lastTurnAt,
activeTurnStartedAt: participant.activeTurnStartedAt,
activeJobId: participant.activeJobId,
lastQueuedAt: participant.lastQueuedAt,
queuedCount: Number.isFinite(participant.queuedCount) ? participant.queuedCount : 0,
constraints: participant.constraints ?? [
"Migrated from wall-clock repo Face turn state.",
],
} satisfies FaceHeartbeatParticipant;
});
return {
schemaVersion: HEARTBEAT_SCHEMA_VERSION,
initiativeClock: 0,
baseRecoveryMinutes,
globalHeat: 1,
lastTickAt: parsed.lastTickAt,
participants,
pendingMentions: Array.isArray(parsed.pendingMentions)
? parsed.pendingMentions.filter(isRepoFacePendingMention)
: [],
controls: defaultHeartbeatControls(),
history: [
...(Array.isArray(parsed.history) ? parsed.history : []),
{
type: "migrated",
fromSchemaVersion: parsed.schemaVersion ?? "unknown",
migratedAt: new Date().toISOString(),
participantCount: participants.length,
},
].slice(-80),
};
}
function defaultHeartbeatControls(): FaceHeartbeatControls {
return {
cadenceMultiplier: 1,
manualTurnRequests: [],
};
}
function normalizeHeartbeatControls(value: unknown): FaceHeartbeatControls {
if (!value || typeof value !== "object") {
return defaultHeartbeatControls();
}
const record = value as Record<string, unknown>;
const cadenceMultiplier = Number(record.cadenceMultiplier);
const manualTurnRequests = Array.isArray(record.manualTurnRequests)
? record.manualTurnRequests.flatMap((entry): ManualTurnRequest[] => {
if (!entry || typeof entry !== "object") {
return [];
}
const request = entry as Record<string, unknown>;
const identityId = typeof request.identityId === "string" ? request.identityId.trim() : "";
if (!identityId) {
return [];
}
const status = request.status === "applied" || request.status === "consumed" || request.status === "rejected"
? request.status
: "pending";
return [{
id: typeof request.id === "string" && request.id.trim() ? request.id : `manual-${Date.now()}-${identityId}`,
identityId,
requestedAt: typeof request.requestedAt === "string" ? request.requestedAt : new Date().toISOString(),
status,
note: typeof request.note === "string" ? request.note : undefined,
}];
})
: [];
return {
cadenceMultiplier: Number.isFinite(cadenceMultiplier) ? clamp(cadenceMultiplier, 0.01, 12) : 1,
manualTurnRequests: manualTurnRequests.slice(-20),
updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : undefined,
};
}
function isRepoFacePendingMention(value: unknown): value is RepoFacePendingMention {
if (!value || typeof value !== "object") {
return false;
}
const record = value as Record<string, unknown>;
return (
typeof record.id === "string" &&
typeof record.identityId === "string" &&
typeof record.channelId === "string" &&
typeof record.messageId === "string" &&
typeof record.authorId === "string" &&
typeof record.content === "string" &&
typeof record.visiblePrompt === "string" &&
typeof record.queuedAt === "string"
);
}
function initiativeSpeedFor(
spec: ParticipantSpec,
speedOverrides: Record<string, number>,
): number {
const override = speedOverrides[spec.id.toLowerCase()];
if (override !== undefined) {
return clamp(override, 0.35, 6);
}
if (spec.id === "void") {
return 1;
}
return clamp(0.85 + stableUnit(spec.id, "speed") * 0.45, 0.75, 1.3);
}
function channelSpeedMultiplierFor(identity: RepoDiscordIdentity): number {
const multipliers = identity.channelPermissions.map((permission) => permission.speedMultiplier);
return multipliers.length > 0 ? clamp(Math.max(...multipliers), 0.5, 3) : 1;
}
function initiativeGroupsFor(spec: ParticipantSpec): string[] {
return Array.from(new Set([
"all",
`kind:${spec.participantKind}`,
`turn:${spec.turnKind}`,
`identity:${normalizeKey(spec.id)}`,
`repo:${normalizeKey(spec.repoName)}`,
`display:${normalizeKey(spec.displayName)}`,
...spec.allowedChannelIds.map((channelId) => `channel:${channelId}`),
]));
}
function heatFor(
spec: ParticipantSpec,
groups: string[],
globalHeat: number,
heatOverrides: Record<string, number>,
): number {
const keys = [
"all",
...groups,
normalizeKey(spec.id),
normalizeKey(spec.repoName),
normalizeKey(spec.displayName),
];
return clamp(
keys.reduce((heat, key) => heat * (heatOverrides[key] ?? 1), globalHeat),
0.05,
20,
);
}
function reactionBiasFor(spec: ParticipantSpec): number {
return spec.id === "void"
? 0.55
: clamp(0.2 + stableUnit(spec.id, "reaction") * 0.55, 0.2, 0.75);
}
function interruptThresholdFor(spec: ParticipantSpec): number {
return spec.id === "void"
? 0.5
: clamp(0.45 + stableUnit(spec.id, "threshold") * 0.35, 0.45, 0.8);
}
function stableUnit(id: string, salt: string): number {
const hex = createHash("sha1").update(`${id}:${salt}`).digest("hex").slice(0, 8);
return Number.parseInt(hex, 16) / 0xffffffff;
}
function mergeStrings(values: string[], value: string): string[] {
return Array.from(new Set([...values, value]));
}
function mergeOptionalString(values: string[], value: string | undefined): string[] {
return value ? mergeStrings(values, value) : values;
}
function normalizeKey(value: string): string {
return value.trim().toLowerCase();
}
function clamp(value: number, min: number, max: number): number {
return Math.min(max, Math.max(min, Number(value.toFixed(3))));
}
function round3(value: number): number {
return Math.round(value * 1000) / 1000;
}
function stripLeadingBom(input: string): string {
return input.charCodeAt(0) === 0xfeff ? input.slice(1) : input;
}
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function readArgValue(name: string): string | undefined {
const index = process.argv.indexOf(name);
if (index < 0) {
return undefined;
}
const value = process.argv[index + 1];
return value && !value.startsWith("--") ? value : undefined;
}
function readIntArgValue(name: string, fallback: number): number {
const raw = readArgValue(name);
if (!raw) {
return fallback;
}
const parsed = Number.parseInt(raw, 10);
return Number.isFinite(parsed) ? parsed : fallback;
}
void main().catch((error) => {
console.error(error);
process.exitCode = 1;
});