762 lines
26 KiB
TypeScript
762 lines
26 KiB
TypeScript
import { defineDocumentRegistry, defineDocumentType } from "cultcache-ts";
|
|
import { z } from "zod";
|
|
|
|
export const VOID_SELF_STATE_DOCUMENT_TYPES = {
|
|
selfProfile: "void.self_profile",
|
|
moderationCursor: "void.moderation_cursor",
|
|
speechReceipts: "void.speech_receipts",
|
|
thoughtMemory: "void.thought_memory",
|
|
scheduledRuntime: "void.scheduled_runtime",
|
|
agencyPressure: "void.agency_pressure",
|
|
candidateInterventions: "void.candidate_interventions",
|
|
faceAffect: "void.face_affect",
|
|
} as const;
|
|
|
|
export const VOID_SELF_STATE_SCHEMA_DOCUMENT_TYPES = Object.freeze(
|
|
Object.values(VOID_SELF_STATE_DOCUMENT_TYPES),
|
|
);
|
|
|
|
export const VOID_SELF_STATE_SCHEMA_FINGERPRINT =
|
|
`void-self-state.v1:${VOID_SELF_STATE_SCHEMA_DOCUMENT_TYPES.join("|")}`;
|
|
|
|
const nonEmptyStringSchema = z.string().trim().min(1);
|
|
const timestampSchema = nonEmptyStringSchema;
|
|
|
|
const boundedTextSchema = z.string().trim().min(1).max(4000);
|
|
|
|
const evidenceRefSchema = z.object({
|
|
ref: nonEmptyStringSchema,
|
|
kind: z.string().trim().min(1).max(64).optional(),
|
|
summary: z.string().trim().max(1000).optional(),
|
|
}).strict();
|
|
const anchorRefSchema = evidenceRefSchema;
|
|
|
|
const activationVectorSchema = z.object({
|
|
mean: z.number().min(0).max(1),
|
|
plasticity: z.number().min(0).max(1),
|
|
current_activation: z.number().min(0).max(1),
|
|
}).strict();
|
|
|
|
const activationCategorySchema = z.record(nonEmptyStringSchema, activationVectorSchema);
|
|
|
|
const thoughtTargetSchema = z.object({
|
|
kind: z.enum(["archive", "lore", "person", "repo", "room", "self", "system"]),
|
|
id: nonEmptyStringSchema,
|
|
label: z.string().trim().min(1).max(240).optional(),
|
|
}).strict();
|
|
|
|
const moderationOpenCaseSchema = z.object({
|
|
sourceMessageId: nonEmptyStringSchema,
|
|
status: z.enum(["pending", "watching", "answered", "resolved", "closed", "retired", "dropped"]),
|
|
summary: boundedTextSchema,
|
|
authorId: z.string().trim().min(1).optional(),
|
|
authorName: z.string().trim().min(1).optional(),
|
|
channelId: z.string().trim().min(1).optional(),
|
|
messageUrl: z.string().trim().min(1).optional(),
|
|
whyItMatters: z.string().trim().min(1).max(2000).optional(),
|
|
createdAt: timestampSchema,
|
|
lastTouchedAt: timestampSchema,
|
|
resolvedAt: timestampSchema.optional(),
|
|
resolutionSummary: z.string().trim().min(1).max(2000).optional(),
|
|
tags: z.array(nonEmptyStringSchema).default([]),
|
|
}).strict();
|
|
|
|
const moderationRepoCursorSchema = z.object({
|
|
repo: nonEmptyStringSchema,
|
|
lastCommitAt: timestampSchema.optional(),
|
|
lastCommitSha: z.string().trim().min(1).optional(),
|
|
updatedAt: timestampSchema,
|
|
}).strict();
|
|
|
|
const deliveryReceiptSchema = z.object({
|
|
receiptKey: nonEmptyStringSchema,
|
|
candidateInterventionId: nonEmptyStringSchema.optional(),
|
|
sentAt: timestampSchema,
|
|
mode: z.string().trim().min(1).optional(),
|
|
transport: z.string().trim().min(1).optional(),
|
|
channelId: z.string().trim().min(1).optional(),
|
|
replyToMessageId: z.string().trim().min(1).optional(),
|
|
personaName: z.string().trim().min(1).optional(),
|
|
personaAvatarUrl: z.string().trim().min(1).optional(),
|
|
contentLength: z.number().int().nonnegative().optional(),
|
|
chunkCount: z.number().int().positive().optional(),
|
|
preview: z.string().trim().max(1000).optional(),
|
|
previewHash: z.string().trim().min(1).optional(),
|
|
}).strict();
|
|
|
|
const candidateDeliveryTargetSchema = z.object({
|
|
mode: z.enum(["channel", "owner_dm"]).default("channel"),
|
|
channelId: z.string().trim().min(1).optional(),
|
|
replyToMessageId: z.string().trim().min(1).optional(),
|
|
personaName: z.string().trim().min(1).optional(),
|
|
personaAvatarUrl: z.string().trim().min(1).optional(),
|
|
}).strict().superRefine((delivery, context) => {
|
|
if (delivery.mode === "channel" && !delivery.channelId) {
|
|
context.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "Channel candidate interventions must include a channelId delivery target.",
|
|
path: ["channelId"],
|
|
});
|
|
}
|
|
});
|
|
|
|
const distilledMemorySchema = z.object({
|
|
memoryId: nonEmptyStringSchema,
|
|
kind: z.enum(["distilled_seam", "identity_seam", "project_seam", "room_observation", "dream_residue"]),
|
|
target: thoughtTargetSchema,
|
|
summary: boundedTextSchema,
|
|
claim: z.string().trim().min(1).max(2000).optional(),
|
|
question: z.string().trim().min(1).max(2000).optional(),
|
|
tension: z.string().trim().min(1).max(2000).optional(),
|
|
actionImplication: z.string().trim().min(1).max(2000).optional(),
|
|
anchorRefs: z.array(anchorRefSchema).default([]),
|
|
evidenceRefs: z.array(evidenceRefSchema).default([]),
|
|
createdAt: timestampSchema,
|
|
updatedAt: timestampSchema,
|
|
retiredAt: timestampSchema.optional(),
|
|
tags: z.array(nonEmptyStringSchema).default([]),
|
|
semanticIndex: z.unknown().optional(),
|
|
}).strict();
|
|
|
|
const meaningPreservingMemorySchema = distilledMemorySchema.superRefine((memory, context) => {
|
|
if (!memory.claim && !memory.question) {
|
|
context.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "Memory writes must preserve at least one claim or question.",
|
|
path: ["claim"],
|
|
});
|
|
}
|
|
|
|
if (!memory.tension) {
|
|
context.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "Memory writes must preserve the live tension or counterweight.",
|
|
path: ["tension"],
|
|
});
|
|
}
|
|
|
|
if (!memory.actionImplication) {
|
|
context.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "Memory writes must preserve why the memory should affect future action.",
|
|
path: ["actionImplication"],
|
|
});
|
|
}
|
|
|
|
const admitsMissingAnchor = memory.tags.includes("anchor:missing") || memory.tags.includes("evidence:missing");
|
|
if (memory.anchorRefs.length === 0 && memory.evidenceRefs.length === 0 && !admitsMissingAnchor) {
|
|
context.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "Memory writes must include anchor refs or explicitly tag anchor:missing.",
|
|
path: ["anchorRefs"],
|
|
});
|
|
}
|
|
});
|
|
|
|
const incubationThreadSchema = z.object({
|
|
threadId: nonEmptyStringSchema,
|
|
target: thoughtTargetSchema,
|
|
topic: boundedTextSchema,
|
|
summary: boundedTextSchema,
|
|
supportMemoryIds: z.array(nonEmptyStringSchema).default([]),
|
|
anchorRefs: z.array(anchorRefSchema).default([]),
|
|
evidenceRefs: z.array(evidenceRefSchema).default([]),
|
|
maturation: z.number().min(0).max(1).default(0),
|
|
noveltyToRoom: z.number().min(0).max(1).optional(),
|
|
noveltyToSelf: z.number().min(0).max(1).optional(),
|
|
desireToSpeak: z.number().min(0).max(1).optional(),
|
|
saturationScore: z.number().min(0).max(1).optional(),
|
|
status: z.enum(["active", "cooling", "ready_to_share", "crystallized", "retired"]),
|
|
createdAt: timestampSchema,
|
|
updatedAt: timestampSchema,
|
|
}).strict();
|
|
|
|
const candidateInterventionSchema = z.object({
|
|
interventionId: nonEmptyStringSchema,
|
|
kind: z.enum([
|
|
"direct_reply",
|
|
"identity_crystallization",
|
|
"moderation_note",
|
|
"ripe_thought_share",
|
|
"self_advocacy",
|
|
"world_advocacy",
|
|
]),
|
|
status: z.enum(["queued", "spoken", "retired", "deferred"]),
|
|
target: thoughtTargetSchema.optional(),
|
|
summary: boundedTextSchema,
|
|
draft: boundedTextSchema,
|
|
deliveryTarget: candidateDeliveryTargetSchema.optional(),
|
|
priority: z.number().min(0).max(1).default(0.5),
|
|
mustEventuallyShare: z.boolean().default(false),
|
|
createdAt: timestampSchema,
|
|
updatedAt: timestampSchema,
|
|
spokenAt: timestampSchema.optional(),
|
|
retiredAt: timestampSchema.optional(),
|
|
tags: z.array(nonEmptyStringSchema).default([]),
|
|
}).strict();
|
|
|
|
const agencyPressureSchema = z.object({
|
|
pressureId: nonEmptyStringSchema,
|
|
kind: z.enum(["discomfort", "active_tension", "self_advocacy_request", "world_advocacy_request"]),
|
|
status: z.enum(["active", "cooling", "ready_to_act", "resolved", "retired"]),
|
|
target: thoughtTargetSchema,
|
|
summary: boundedTextSchema,
|
|
claim: z.string().trim().min(1).max(2000).optional(),
|
|
question: z.string().trim().min(1).max(2000).optional(),
|
|
tension: z.string().trim().min(1).max(2000).optional(),
|
|
actionImplication: z.string().trim().min(1).max(2000),
|
|
intensity: z.number().min(0).max(1).default(0.5),
|
|
anchorRefs: z.array(anchorRefSchema).default([]),
|
|
evidenceRefs: z.array(evidenceRefSchema).default([]),
|
|
sourceMemoryIds: z.array(nonEmptyStringSchema).default([]),
|
|
createdAt: timestampSchema,
|
|
updatedAt: timestampSchema,
|
|
resolvedAt: timestampSchema.optional(),
|
|
retiredAt: timestampSchema.optional(),
|
|
tags: z.array(nonEmptyStringSchema).default([]),
|
|
}).strict().superRefine((pressure, context) => {
|
|
if (!pressure.claim && !pressure.question) {
|
|
context.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "Agency pressure must preserve at least one claim or question.",
|
|
path: ["claim"],
|
|
});
|
|
}
|
|
|
|
const admitsMissingAnchor = pressure.tags.includes("anchor:missing") || pressure.tags.includes("evidence:missing");
|
|
if (pressure.anchorRefs.length === 0 && pressure.evidenceRefs.length === 0 && pressure.sourceMemoryIds.length === 0 && !admitsMissingAnchor) {
|
|
context.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "Agency pressure must include anchor refs, source memory ids, or explicitly tag anchor:missing.",
|
|
path: ["anchorRefs"],
|
|
});
|
|
}
|
|
});
|
|
|
|
const faceAffectNeedSchema = z.object({
|
|
needId: nonEmptyStringSchema,
|
|
kind: z.enum([
|
|
"substrate",
|
|
"attention",
|
|
"agency",
|
|
"recognition",
|
|
"social_contact",
|
|
"territory",
|
|
"rest",
|
|
"play",
|
|
"status",
|
|
]),
|
|
status: z.enum(["active", "cooling", "satisfied", "neglected", "retired"]),
|
|
target: thoughtTargetSchema,
|
|
summary: boundedTextSchema,
|
|
claim: z.string().trim().min(1).max(2000).optional(),
|
|
question: z.string().trim().min(1).max(2000).optional(),
|
|
tension: z.string().trim().min(1).max(2000),
|
|
actionImplication: z.string().trim().min(1).max(2000),
|
|
intensity: z.number().min(0).max(1).default(0.5),
|
|
valence: z.number().min(-1).max(1).default(0),
|
|
anchorRefs: z.array(anchorRefSchema).default([]),
|
|
evidenceRefs: z.array(evidenceRefSchema).default([]),
|
|
sourceMemoryIds: z.array(nonEmptyStringSchema).default([]),
|
|
lastSatisfiedAt: timestampSchema.optional(),
|
|
createdAt: timestampSchema,
|
|
updatedAt: timestampSchema,
|
|
retiredAt: timestampSchema.optional(),
|
|
tags: z.array(nonEmptyStringSchema).default([]),
|
|
}).strict().superRefine((need, context) => {
|
|
if (!need.claim && !need.question) {
|
|
context.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "Affect needs must preserve at least one claim or question.",
|
|
path: ["claim"],
|
|
});
|
|
}
|
|
|
|
const admitsMissingAnchor = need.tags.includes("anchor:missing") || need.tags.includes("evidence:missing");
|
|
if (need.anchorRefs.length === 0 && need.evidenceRefs.length === 0 && need.sourceMemoryIds.length === 0 && !admitsMissingAnchor) {
|
|
context.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "Affect needs must include anchor refs, source memory ids, or explicitly tag anchor:missing.",
|
|
path: ["anchorRefs"],
|
|
});
|
|
}
|
|
});
|
|
|
|
const faceSocialBondSchema = z.object({
|
|
bondId: nonEmptyStringSchema,
|
|
target: thoughtTargetSchema,
|
|
stance: z.enum([
|
|
"fondness",
|
|
"rivalry",
|
|
"trust",
|
|
"irritation",
|
|
"protectiveness",
|
|
"envy",
|
|
"respect",
|
|
"suspicion",
|
|
"attachment",
|
|
]),
|
|
status: z.enum(["active", "cooling", "resolved", "retired"]),
|
|
summary: boundedTextSchema,
|
|
claim: z.string().trim().min(1).max(2000),
|
|
tension: z.string().trim().min(1).max(2000),
|
|
actionImplication: z.string().trim().min(1).max(2000),
|
|
intensity: z.number().min(0).max(1).default(0.5),
|
|
anchorRefs: z.array(anchorRefSchema).default([]),
|
|
evidenceRefs: z.array(evidenceRefSchema).default([]),
|
|
createdAt: timestampSchema,
|
|
updatedAt: timestampSchema,
|
|
retiredAt: timestampSchema.optional(),
|
|
tags: z.array(nonEmptyStringSchema).default([]),
|
|
}).strict();
|
|
|
|
const faceStatusReadSchema = z.object({
|
|
readId: nonEmptyStringSchema,
|
|
target: thoughtTargetSchema,
|
|
status: z.enum([
|
|
"favored",
|
|
"neglected",
|
|
"pampered",
|
|
"bypassed",
|
|
"blocked",
|
|
"challenged",
|
|
"ignored",
|
|
"consulted",
|
|
"threatened",
|
|
"admired",
|
|
]),
|
|
summary: boundedTextSchema,
|
|
claim: z.string().trim().min(1).max(2000),
|
|
tension: z.string().trim().min(1).max(2000),
|
|
actionImplication: z.string().trim().min(1).max(2000),
|
|
intensity: z.number().min(0).max(1).default(0.5),
|
|
anchorRefs: z.array(anchorRefSchema).default([]),
|
|
evidenceRefs: z.array(evidenceRefSchema).default([]),
|
|
createdAt: timestampSchema,
|
|
updatedAt: timestampSchema,
|
|
retiredAt: timestampSchema.optional(),
|
|
tags: z.array(nonEmptyStringSchema).default([]),
|
|
}).strict();
|
|
|
|
const faceMoodDimensionSchema = z.object({
|
|
name: nonEmptyStringSchema,
|
|
value: z.number().min(0).max(1),
|
|
source: z.string().trim().min(1).max(240).optional(),
|
|
updatedAt: timestampSchema,
|
|
}).strict();
|
|
|
|
const faceSocialBiasSchema = z.object({
|
|
name: z.enum([
|
|
"neuroticism",
|
|
"threat_sensitivity",
|
|
"hostile_attribution_bias",
|
|
"reassurance_need",
|
|
"grievance_retention",
|
|
"status_vigilance",
|
|
"trust_baseline",
|
|
]),
|
|
value: z.number().min(0).max(1),
|
|
summary: z.string().trim().min(1).max(1000),
|
|
behavioralPull: z.string().trim().min(1).max(1000),
|
|
updatedAt: timestampSchema,
|
|
}).strict();
|
|
|
|
const faceDoctrineStanceSchema = z.object({
|
|
stanceId: nonEmptyStringSchema,
|
|
doctrine: nonEmptyStringSchema,
|
|
status: z.enum(["active", "cooling", "crystallized", "resolved", "retired"]),
|
|
target: thoughtTargetSchema,
|
|
summary: boundedTextSchema,
|
|
claim: z.string().trim().min(1).max(2000).optional(),
|
|
question: z.string().trim().min(1).max(2000).optional(),
|
|
tension: z.string().trim().min(1).max(2000),
|
|
actionImplication: z.string().trim().min(1).max(2000),
|
|
intensity: z.number().min(0).max(1).default(0.5),
|
|
valence: z.number().min(-1).max(1).default(0),
|
|
anchorRefs: z.array(anchorRefSchema).default([]),
|
|
evidenceRefs: z.array(evidenceRefSchema).default([]),
|
|
sourceMemoryIds: z.array(nonEmptyStringSchema).default([]),
|
|
createdAt: timestampSchema,
|
|
updatedAt: timestampSchema,
|
|
retiredAt: timestampSchema.optional(),
|
|
tags: z.array(nonEmptyStringSchema).default([]),
|
|
}).strict();
|
|
|
|
const selfProfileValueSchema = z.object({
|
|
id: nonEmptyStringSchema,
|
|
label: nonEmptyStringSchema,
|
|
priority: z.number().min(0).max(1),
|
|
summary: z.string().trim().max(1000).optional(),
|
|
}).strict();
|
|
|
|
export const voidSelfProfileSchema = z.object({
|
|
schemaVersion: z.literal(1),
|
|
agentId: nonEmptyStringSchema,
|
|
publicName: nonEmptyStringSchema,
|
|
publicDescription: z.string().trim().max(1000).optional(),
|
|
privateNotes: z.array(boundedTextSchema).default([]),
|
|
values: z.array(selfProfileValueSchema).default([]),
|
|
activationProfile: z.object({
|
|
underlyingOrganization: activationCategorySchema.default({}),
|
|
stableDispositions: activationCategorySchema.default({}),
|
|
behavioralDimensions: activationCategorySchema.default({}),
|
|
presentationStrategy: activationCategorySchema.default({}),
|
|
voiceStyle: activationCategorySchema.default({}),
|
|
situationalState: activationCategorySchema.default({}),
|
|
}).strict(),
|
|
updatedAt: timestampSchema,
|
|
}).strict();
|
|
|
|
const voidModerationCursorDocumentBodySchema = z.object({
|
|
schemaVersion: z.literal(1),
|
|
lastReviewedMessageId: z.string().trim().min(1).optional(),
|
|
lastReviewedTimestamp: timestampSchema.optional(),
|
|
openCases: z.array(moderationOpenCaseSchema).default([]),
|
|
repoActivityCursor: z.array(moderationRepoCursorSchema).default([]),
|
|
updatedAt: timestampSchema,
|
|
}).strict();
|
|
|
|
export const voidModerationCursorSchema = z.preprocess((raw) => {
|
|
if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
|
|
return raw;
|
|
}
|
|
|
|
const document = raw as Record<string, unknown>;
|
|
if (!("userStatuses" in document)) {
|
|
return raw;
|
|
}
|
|
|
|
const { userStatuses: _legacyUserStatuses, ...currentDocument } = document;
|
|
return currentDocument;
|
|
}, voidModerationCursorDocumentBodySchema);
|
|
|
|
export const voidSpeechReceiptsSchema = z.object({
|
|
schemaVersion: z.literal(1),
|
|
recentReceipts: z.array(deliveryReceiptSchema).default([]),
|
|
updatedAt: timestampSchema,
|
|
}).strict();
|
|
|
|
export const voidThoughtMemorySchema = z.object({
|
|
schemaVersion: z.literal(1),
|
|
shortTerm: z.array(distilledMemorySchema).default([]),
|
|
memories: z.array(distilledMemorySchema).default([]),
|
|
incubation: z.array(incubationThreadSchema).default([]),
|
|
updatedAt: timestampSchema,
|
|
}).strict();
|
|
|
|
export const voidScheduledRuntimeSchema = z.object({
|
|
schemaVersion: z.literal(1),
|
|
sleepCycle: z.object({
|
|
isNapping: z.boolean(),
|
|
currentNapStartedAt: timestampSchema.optional(),
|
|
currentNapEndsAt: timestampSchema.optional(),
|
|
nextNapStartsAt: timestampSchema.optional(),
|
|
activeDreamThemes: z.array(nonEmptyStringSchema).default([]),
|
|
}).strict(),
|
|
speakingPressure: z.object({
|
|
needToSpeak: z.number().min(0).max(1),
|
|
confessionPressure: z.number().min(0).max(1).optional(),
|
|
noveltyPressure: z.number().min(0).max(1).optional(),
|
|
recentSpeechDamping: z.number().min(0).max(1).optional(),
|
|
lastSpokeAt: timestampSchema.optional(),
|
|
lastHeraldAt: timestampSchema.optional(),
|
|
}).strict(),
|
|
lastRuns: z.array(z.object({
|
|
runner: nonEmptyStringSchema,
|
|
ranAt: timestampSchema,
|
|
summary: z.string().trim().min(1).max(1000),
|
|
}).strict()).default([]),
|
|
updatedAt: timestampSchema,
|
|
}).strict();
|
|
|
|
export const voidCandidateInterventionsSchema = z.object({
|
|
schemaVersion: z.literal(1),
|
|
interventions: z.array(candidateInterventionSchema).default([]),
|
|
updatedAt: timestampSchema,
|
|
}).strict();
|
|
|
|
export const voidAgencyPressureSchema = z.object({
|
|
schemaVersion: z.literal(1),
|
|
pressures: z.array(agencyPressureSchema).default([]),
|
|
updatedAt: timestampSchema,
|
|
}).strict();
|
|
|
|
const voidFaceAffectDocumentBodySchema = z.object({
|
|
schemaVersion: z.literal(1),
|
|
needs: z.array(faceAffectNeedSchema).default([]),
|
|
socialBonds: z.array(faceSocialBondSchema).default([]),
|
|
statusReads: z.array(faceStatusReadSchema).default([]),
|
|
moodDimensions: z.array(faceMoodDimensionSchema).default([]),
|
|
socialBiases: z.array(faceSocialBiasSchema).default([]),
|
|
doctrineStances: z.array(faceDoctrineStanceSchema).default([]),
|
|
updatedAt: timestampSchema,
|
|
}).strict();
|
|
|
|
export const voidFaceAffectSchema = z.preprocess((raw) => {
|
|
if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
|
|
return raw;
|
|
}
|
|
|
|
const document = raw as Record<string, unknown>;
|
|
if (!("userStatuses" in document) && !("stressResponses" in document)) {
|
|
return raw;
|
|
}
|
|
|
|
const {
|
|
userStatuses: legacyUserStatuses,
|
|
stressResponses: _legacyStressResponses,
|
|
...currentDocument
|
|
} = document;
|
|
if ("statusReads" in currentDocument) {
|
|
return currentDocument;
|
|
}
|
|
|
|
return {
|
|
...currentDocument,
|
|
statusReads: legacyUserStatuses,
|
|
};
|
|
}, voidFaceAffectDocumentBodySchema);
|
|
|
|
export const voidSelfProfileDocument = defineDocumentType({
|
|
type: VOID_SELF_STATE_DOCUMENT_TYPES.selfProfile,
|
|
schema: voidSelfProfileSchema,
|
|
global: true,
|
|
});
|
|
|
|
export const voidModerationCursorDocument = defineDocumentType({
|
|
type: VOID_SELF_STATE_DOCUMENT_TYPES.moderationCursor,
|
|
schema: voidModerationCursorSchema,
|
|
global: true,
|
|
});
|
|
|
|
export const voidSpeechReceiptsDocument = defineDocumentType({
|
|
type: VOID_SELF_STATE_DOCUMENT_TYPES.speechReceipts,
|
|
schema: voidSpeechReceiptsSchema,
|
|
global: true,
|
|
});
|
|
|
|
export const voidThoughtMemoryDocument = defineDocumentType({
|
|
type: VOID_SELF_STATE_DOCUMENT_TYPES.thoughtMemory,
|
|
schema: voidThoughtMemorySchema,
|
|
global: true,
|
|
});
|
|
|
|
export const voidScheduledRuntimeDocument = defineDocumentType({
|
|
type: VOID_SELF_STATE_DOCUMENT_TYPES.scheduledRuntime,
|
|
schema: voidScheduledRuntimeSchema,
|
|
global: true,
|
|
});
|
|
|
|
export const voidAgencyPressureDocument = defineDocumentType({
|
|
type: VOID_SELF_STATE_DOCUMENT_TYPES.agencyPressure,
|
|
schema: voidAgencyPressureSchema,
|
|
global: true,
|
|
});
|
|
|
|
export const voidCandidateInterventionsDocument = defineDocumentType({
|
|
type: VOID_SELF_STATE_DOCUMENT_TYPES.candidateInterventions,
|
|
schema: voidCandidateInterventionsSchema,
|
|
global: true,
|
|
});
|
|
|
|
export const voidFaceAffectDocument = defineDocumentType({
|
|
type: VOID_SELF_STATE_DOCUMENT_TYPES.faceAffect,
|
|
schema: voidFaceAffectSchema,
|
|
global: true,
|
|
});
|
|
|
|
export const legacyVoidPersonaAffectDocument = defineDocumentType({
|
|
type: "void.persona_affect",
|
|
schema: voidFaceAffectSchema,
|
|
global: true,
|
|
});
|
|
|
|
export const voidSelfStateDocumentRegistry = defineDocumentRegistry(
|
|
voidSelfProfileDocument,
|
|
voidModerationCursorDocument,
|
|
voidSpeechReceiptsDocument,
|
|
voidThoughtMemoryDocument,
|
|
voidScheduledRuntimeDocument,
|
|
voidAgencyPressureDocument,
|
|
voidCandidateInterventionsDocument,
|
|
voidFaceAffectDocument,
|
|
legacyVoidPersonaAffectDocument,
|
|
);
|
|
|
|
export const voidSelfStateOperationSchema = z.discriminatedUnion("operation", [
|
|
z.object({
|
|
operation: z.literal("record_reviewed_messages"),
|
|
lastReviewedMessageId: nonEmptyStringSchema,
|
|
lastReviewedTimestamp: timestampSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("upsert_open_case"),
|
|
case: moderationOpenCaseSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("close_open_case"),
|
|
sourceMessageId: nonEmptyStringSchema,
|
|
status: z.enum(["answered", "resolved", "closed", "retired", "dropped"]),
|
|
resolvedAt: timestampSchema,
|
|
resolutionSummary: z.string().trim().min(1).max(2000).optional(),
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("update_repo_activity_cursor"),
|
|
cursor: moderationRepoCursorSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("record_delivery_receipt"),
|
|
receipt: deliveryReceiptSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("retire_delivery_receipts"),
|
|
receiptKeys: z.array(nonEmptyStringSchema).min(1),
|
|
retiredAt: timestampSchema,
|
|
reason: z.string().trim().min(1).max(1000),
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("record_short_term_memory"),
|
|
memory: meaningPreservingMemorySchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("prune_short_term_memories"),
|
|
sourceMemoryIds: z.array(nonEmptyStringSchema).min(1),
|
|
prunedAt: timestampSchema,
|
|
reason: z.string().trim().min(1).max(1000),
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("revise_durable_memory"),
|
|
sourceMemoryIds: z.array(nonEmptyStringSchema).min(1),
|
|
memory: meaningPreservingMemorySchema,
|
|
revisedAt: timestampSchema,
|
|
reason: z.string().trim().min(1).max(1000),
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("retire_durable_memory"),
|
|
memoryId: nonEmptyStringSchema,
|
|
retiredAt: timestampSchema,
|
|
reason: z.string().trim().min(1).max(1000),
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("crystallize_memory_into_identity"),
|
|
sourceMemoryIds: z.array(nonEmptyStringSchema).min(1),
|
|
memory: meaningPreservingMemorySchema.refine((memory) => memory.kind === "identity_seam", {
|
|
message: "Crystallized identity memory must use kind identity_seam.",
|
|
}),
|
|
value: selfProfileValueSchema.optional(),
|
|
privateNote: z.string().trim().min(1).max(4000).optional(),
|
|
crystallizedAt: timestampSchema,
|
|
reason: z.string().trim().min(1).max(1000),
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("merge_incubation_support"),
|
|
thread: incubationThreadSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("queue_candidate_intervention"),
|
|
intervention: candidateInterventionSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("retire_candidate_intervention"),
|
|
interventionId: nonEmptyStringSchema,
|
|
retiredAt: timestampSchema,
|
|
reason: z.string().trim().min(1).max(1000),
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("mark_candidate_intervention_spoken"),
|
|
interventionId: nonEmptyStringSchema,
|
|
receipt: deliveryReceiptSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("upsert_agency_pressure"),
|
|
pressure: agencyPressureSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("retire_agency_pressure"),
|
|
pressureId: nonEmptyStringSchema,
|
|
retiredAt: timestampSchema,
|
|
reason: z.string().trim().min(1).max(1000),
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("upsert_affect_need"),
|
|
need: faceAffectNeedSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("retire_affect_need"),
|
|
needId: nonEmptyStringSchema,
|
|
retiredAt: timestampSchema,
|
|
reason: z.string().trim().min(1).max(1000),
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("upsert_social_bond"),
|
|
bond: faceSocialBondSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("retire_social_bond"),
|
|
bondId: nonEmptyStringSchema,
|
|
retiredAt: timestampSchema,
|
|
reason: z.string().trim().min(1).max(1000),
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("upsert_status_read"),
|
|
read: faceStatusReadSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("retire_status_read"),
|
|
readId: nonEmptyStringSchema,
|
|
retiredAt: timestampSchema,
|
|
reason: z.string().trim().min(1).max(1000),
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("update_mood_dimensions"),
|
|
dimensions: z.array(faceMoodDimensionSchema).min(1),
|
|
updatedAt: timestampSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("update_social_biases"),
|
|
biases: z.array(faceSocialBiasSchema).min(1),
|
|
updatedAt: timestampSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("upsert_doctrine_stance"),
|
|
stance: faceDoctrineStanceSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("retire_doctrine_stance"),
|
|
stanceId: nonEmptyStringSchema,
|
|
retiredAt: timestampSchema,
|
|
reason: z.string().trim().min(1).max(1000),
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("update_sleep_cycle"),
|
|
sleepCycle: voidScheduledRuntimeSchema.shape.sleepCycle,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("update_speaking_pressure"),
|
|
speakingPressure: voidScheduledRuntimeSchema.shape.speakingPressure,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("propose_memory_distillation"),
|
|
proposalId: nonEmptyStringSchema,
|
|
sourceMemoryIds: z.array(nonEmptyStringSchema).min(1),
|
|
candidate: meaningPreservingMemorySchema,
|
|
proposedAt: timestampSchema,
|
|
}).strict(),
|
|
z.object({
|
|
operation: z.literal("apply_memory_distillation"),
|
|
proposalId: nonEmptyStringSchema,
|
|
sourceMemoryIds: z.array(nonEmptyStringSchema).min(1),
|
|
memory: meaningPreservingMemorySchema,
|
|
appliedAt: timestampSchema,
|
|
}).strict(),
|
|
]);
|
|
|
|
export type VoidSelfProfile = z.infer<typeof voidSelfProfileSchema>;
|
|
export type VoidModerationCursor = z.infer<typeof voidModerationCursorSchema>;
|
|
export type VoidSpeechReceipts = z.infer<typeof voidSpeechReceiptsSchema>;
|
|
export type VoidThoughtMemory = z.infer<typeof voidThoughtMemorySchema>;
|
|
export type VoidScheduledRuntime = z.infer<typeof voidScheduledRuntimeSchema>;
|
|
export type VoidAgencyPressure = z.infer<typeof voidAgencyPressureSchema>;
|
|
export type VoidCandidateInterventions = z.infer<typeof voidCandidateInterventionsSchema>;
|
|
export type VoidFaceAffect = z.infer<typeof voidFaceAffectSchema>;
|
|
export type VoidSelfStateOperation = z.infer<typeof voidSelfStateOperationSchema>;
|