Translate Void's old memories into the new thought shape
This commit is contained in:
parent
d750bf2fb9
commit
a3c0876a03
5 changed files with 406 additions and 0 deletions
|
|
@ -57,6 +57,7 @@ Git history and smoke artifacts carry routine proof. `state/evidence.jsonl` shou
|
|||
- Those crystallized-thought drafts can now be marked `mustEventuallyShare`, and ordinary candidate-intervention pruning is supposed to preserve them. The loop may defer for timing if the room is busy, but not just quietly forget what became doctrine.
|
||||
- That awake rumination is now explicitly biased toward concrete project fascination. If a thought stays too abstract for too long, the loop is supposed to cash it out in a real machine: Aetheria-Economy gameplay systems, lore-vault structure, Aquarium frontend work, Epiphany swarm organs, VoidBot's own architecture, or some other specific repo/subsystem instead of another polished sermon about engineering virtue.
|
||||
- The memory organ's thought labels and curiosity budget have been cut away from keyword compost. Resonance clusters and incubating thoughts are now supposed to name actual claims, questions, or fascination targets, and curiosity should favor concrete map-changing terrain over whichever seam already feels warm.
|
||||
- The live moderation state has now had one real translation pass too, not just new code draped over old fossils. Legacy slash-label seam memories and dream themes are rewritten through the new thought synthesizer, obvious duplicates get merged or pruned, and the active queue is rebuilt from the cleaned substrate instead of the old keyword graveyard.
|
||||
- The intended shape now is: quiet runs can follow one seam for several passes, connect repo motion to lore or philosophy if the evidence supports it, and only surface with the juiciest version once the incubation queue says the thought has actually grown teeth.
|
||||
- Directly invoked Discord replies now load that same private moderation state as distilled private self-state context, so the ruminating scheduled loop and the summoned Void share one evolving personality/state spine. The prompt-facing self-state summary no longer dumps recent repo sweeps, novelty checks, or musing sludge back into working memory by default; it stays closer to seam memory, incubation, and room obligations. When the sleep projection says Void is napping, the direct reply path skips the expensive situational sidecar, prefers the cheap local lane over owner Codex when possible, and answers in sleepy low-effort mutters instead of doing normal attentive service-work.
|
||||
- The moderation loop now speaks through `node scripts/send-discord-message.mjs` using the local bot token instead of approval-gated side-effecting MCP tools, so unattended runs can DM or post without Codex pausing for permission every time it wants to open its mouth. That helper and the `post_discord_message` MCP tool now also support a shared guild-channel webhook pipe with per-message `personaName` and optional `personaAvatarUrl`, so swarm agents can speak as themselves without needing separate Discord bot identities.
|
||||
|
|
|
|||
|
|
@ -181,6 +181,7 @@ Within the Postgres path, the implementation is split on purpose now too:
|
|||
The collector now intentionally downweights repetitive empty-room bookkeeping, so strings like `no new messages / no smoke / no post` stop masquerading as the deepest thought in the machine just because the room stayed quiet for a while.
|
||||
Incubation scoring now distinguishes novelty-to-room from novelty-to-self, merges repeated seams into existing support instead of minting fresh shards, and writes `bridge.source_coverage` plus `bridge.refractory_topics` so a thought that keeps winning can be cooled off in favor of less-worked repos, archive years, or channels.
|
||||
Cluster labeling is no longer supposed to be a slash-joined keyword graveyard. The organ now tries to synthesize each cluster into a claim, question, or fascination target with an explicit target kind such as repo, archive, room, self, or system, and uses concreteness/fertility/cross-domain pressure to decide whether the thought deserves more curiosity.
|
||||
That same organ now also performs historical cleanup on the live memory surface before it re-embeds anything: old slash-label seam memories and dream themes are translated into the new thought surface, obvious duplicates are merged, and stale low-coherence seam fossils get pruned so the active queue is rebuilt from cleaner material instead of inheriting every older representational sin forever.
|
||||
When the sleep cycle says Void is napping, that same organ becomes deliberately lossy: it promotes a few stronger incubating seams into semantic memory, then trims raw episodic receipts, repo sweeps, archive excursions, novelty checks, and recent musings back down so the next awake pass has to think from carved seams rather than yesterday's full notebook.
|
||||
The same organ can also crystallize an over-chewed private seam into identity: once a thought has survived enough passes to become durable self-doctrine rather than live curiosity, it can be retired from the active queue, copied into `identity.private_notes`, echoed as a canonical value, preserved as one `identity_seam` semantic memory, and queued as a warmer `identity_crystallization` candidate intervention so the room has a chance to hear it. Those intervention records can be marked `mustEventuallyShare`, which ordinary pruning is supposed to preserve until the room gets a decent opening.
|
||||
4. It then nudges each canonical-state `current_activation` toward a Perlin-shaped target centered on the vector mean, with excursion size and drift rate governed by plasticity and category-specific tempo.
|
||||
|
|
|
|||
|
|
@ -160,6 +160,7 @@ const labelNoiseTokens = new Set([
|
|||
"deepened",
|
||||
"dream",
|
||||
"draft",
|
||||
"episodic",
|
||||
"distill",
|
||||
"excursion",
|
||||
"excursions",
|
||||
|
|
@ -186,6 +187,10 @@ const labelNoiseTokens = new Set([
|
|||
"question",
|
||||
"questions",
|
||||
"receipts",
|
||||
"actually",
|
||||
"behaving",
|
||||
"branch",
|
||||
"compressed",
|
||||
"recurring",
|
||||
"repo",
|
||||
"repos",
|
||||
|
|
@ -222,6 +227,7 @@ export async function reconcileSemanticMemoryState({
|
|||
const runtime = ensureObject(state.moderation_runtime);
|
||||
const memories = ensureObject(state.memories);
|
||||
const sleepCycle = ensureObject(runtime.sleep_cycle);
|
||||
normalizeHistoricalMemorySurfaces({ memories, runtime, now });
|
||||
const records = collectMemoryRecords({ state, memories, runtime });
|
||||
const previousBridge = ensureObject(runtime.bridge);
|
||||
const sourceCoverage = buildSourceCoverage({ runtime, now });
|
||||
|
|
@ -316,6 +322,378 @@ export async function reconcileSemanticMemoryState({
|
|||
};
|
||||
}
|
||||
|
||||
function normalizeHistoricalMemorySurfaces({ memories, runtime, now }) {
|
||||
normalizeSemanticMemories({ memories, now });
|
||||
normalizeDreamMemories({ memories, now });
|
||||
dedupeSemanticMemories({ memories });
|
||||
dedupeDreamMemories({ memories });
|
||||
pruneHistoricalSeamMemories({ memories });
|
||||
trimLegacyRuntimeResidue({ runtime });
|
||||
}
|
||||
|
||||
function normalizeSemanticMemories({ memories, now }) {
|
||||
const semanticMemories = ensureArray(memories.semantic).filter(isObject);
|
||||
|
||||
for (const memory of semanticMemories) {
|
||||
if (readString(memory, "kind") === "identity_seam") {
|
||||
continue;
|
||||
}
|
||||
|
||||
const normalized = translateLegacyThoughtLikeEntry({
|
||||
label:
|
||||
readString(memory, "subjectLabel") ??
|
||||
readString(memory, "subjectId") ??
|
||||
readString(memory, "kind") ??
|
||||
"semantic seam",
|
||||
summary: readString(memory, "summary") ?? "",
|
||||
fallbackTargetKind: "self",
|
||||
fallbackFocusKind: "question",
|
||||
evidenceRefs: ensureStringArray(memory.evidenceRefs),
|
||||
repoNames: ensureStringArray(memory.repoNames),
|
||||
});
|
||||
|
||||
if (!normalized) {
|
||||
continue;
|
||||
}
|
||||
|
||||
memory.subjectLabel = normalized.label;
|
||||
memory.summary = normalized.summary;
|
||||
memory.focusKind = normalized.focusKind;
|
||||
memory.targetKind = normalized.targetKind;
|
||||
memory.focusPhrase = normalized.focusPhrase;
|
||||
memory.question = normalized.question;
|
||||
memory.claim = normalized.claim;
|
||||
memory.fascinationTarget = normalized.fascinationTarget;
|
||||
memory.worldFacing = normalized.worldFacing;
|
||||
memory.lastTranslatedAt = now.toISOString();
|
||||
}
|
||||
}
|
||||
|
||||
function normalizeDreamMemories({ memories, now }) {
|
||||
const dreams = ensureArray(memories.dreams).filter(isObject);
|
||||
|
||||
for (const dream of dreams) {
|
||||
const normalized = translateLegacyThoughtLikeEntry({
|
||||
label: readString(dream, "theme") ?? "dream seam",
|
||||
summary: readString(dream, "summary") ?? "",
|
||||
fallbackTargetKind: "self",
|
||||
fallbackFocusKind: "question",
|
||||
evidenceRefs: ensureStringArray(dream.distilledFrom),
|
||||
repoNames: ensureStringArray(dream.repoNames),
|
||||
});
|
||||
|
||||
if (!normalized) {
|
||||
continue;
|
||||
}
|
||||
|
||||
dream.theme = normalized.label;
|
||||
dream.summary = `Dream-compressed ${normalized.summary}`;
|
||||
dream.focusKind = normalized.focusKind;
|
||||
dream.targetKind = normalized.targetKind;
|
||||
dream.focusPhrase = normalized.focusPhrase;
|
||||
dream.question = normalized.question;
|
||||
dream.claim = normalized.claim;
|
||||
dream.worldFacing = normalized.worldFacing;
|
||||
dream.lastTranslatedAt = now.toISOString();
|
||||
}
|
||||
}
|
||||
|
||||
function translateLegacyThoughtLikeEntry({
|
||||
label,
|
||||
summary,
|
||||
fallbackTargetKind,
|
||||
fallbackFocusKind,
|
||||
evidenceRefs,
|
||||
repoNames,
|
||||
}) {
|
||||
const rawLabel = normalizeText(label);
|
||||
const rawSummary = normalizeText(summary);
|
||||
if (!rawLabel && !rawSummary) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const sourceKinds = inferSourceKindsFromThoughtText(rawSummary, rawLabel, evidenceRefs);
|
||||
const synthesized = synthesizeThoughtSurface({
|
||||
sourceKinds,
|
||||
repoNames,
|
||||
archiveYears: [],
|
||||
channelIds: [],
|
||||
keywords: topConceptKeywords(`${rawLabel} ${rawSummary}`, 6),
|
||||
evidenceDiversity: inferLegacyEvidenceDiversity(sourceKinds, evidenceRefs, repoNames),
|
||||
curiosityProfile: buildClusterCuriosityProfile({
|
||||
sourceKinds,
|
||||
repoNames,
|
||||
archiveYears: [],
|
||||
channelIds: [],
|
||||
evidenceRefs,
|
||||
evidenceDiversity: inferLegacyEvidenceDiversity(sourceKinds, evidenceRefs, repoNames),
|
||||
}),
|
||||
});
|
||||
|
||||
if (!looksLegacyThoughtSurface(rawLabel, rawSummary)) {
|
||||
return {
|
||||
...synthesized,
|
||||
label: rawLabel || synthesized.label,
|
||||
summary: rewriteLegacySummaryToModernShape({
|
||||
summary: rawSummary,
|
||||
synthesized,
|
||||
fallbackFocusKind,
|
||||
fallbackTargetKind,
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
...synthesized,
|
||||
focusKind: synthesized.focusKind ?? fallbackFocusKind,
|
||||
targetKind: synthesized.targetKind ?? fallbackTargetKind,
|
||||
summary: rewriteLegacySummaryToModernShape({
|
||||
summary: rawSummary,
|
||||
synthesized,
|
||||
fallbackFocusKind,
|
||||
fallbackTargetKind,
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
||||
function looksLegacyThoughtSurface(label, summary) {
|
||||
return (
|
||||
/\//.test(label) ||
|
||||
/^Recurring seam across /i.test(summary) ||
|
||||
/^Dream-compressed a seam around /i.test(summary) ||
|
||||
/^Self-facing seam around /i.test(summary) ||
|
||||
/^Archive-facing seam around /i.test(summary) ||
|
||||
/What part of this thought wants embodiment/i.test(summary)
|
||||
);
|
||||
}
|
||||
|
||||
function rewriteLegacySummaryToModernShape({ summary, synthesized, fallbackFocusKind, fallbackTargetKind }) {
|
||||
const cleanSummary = normalizeText(summary)
|
||||
.replace(/^Recurring seam across .*?\.\s*/i, "")
|
||||
.replace(/^Dream-compressed a seam around .*?\.\s*/i, "")
|
||||
.replace(/^Self-facing seam around .*?\.\s*/i, "")
|
||||
.replace(/^Archive-facing seam around .*?\.\s*/i, "")
|
||||
.replace(/^Fascination with .*?\.\s*/i, "")
|
||||
.replace(/Built from .*? rather than a single lane talking to itself\.?/gi, "")
|
||||
.replace(/\s+/g, " ")
|
||||
.trim();
|
||||
|
||||
const focusKind = synthesized.focusKind ?? fallbackFocusKind;
|
||||
const targetKind = synthesized.targetKind ?? fallbackTargetKind;
|
||||
|
||||
if (focusKind === "fascination") {
|
||||
return `Fascination with ${synthesized.fascinationTarget}. ${synthesized.question}`;
|
||||
}
|
||||
if (targetKind === "self") {
|
||||
return `Self-facing seam around ${synthesized.focusPhrase}. ${synthesized.claim}`;
|
||||
}
|
||||
if (targetKind === "archive") {
|
||||
return `Archive-facing seam around ${synthesized.focusPhrase}. ${synthesized.question}`;
|
||||
}
|
||||
if (focusKind === "claim") {
|
||||
return `Working claim around ${synthesized.focusPhrase}. ${synthesized.claim}`;
|
||||
}
|
||||
return cleanSummary
|
||||
? `${capitalizePhrase(synthesized.focusPhrase)} still matters. ${synthesized.question}`
|
||||
: synthesized.summary;
|
||||
}
|
||||
|
||||
function inferSourceKindsFromThoughtText(summary, label, evidenceRefs) {
|
||||
const kinds = new Set();
|
||||
const text = `${label} ${summary}`.toLowerCase();
|
||||
const refKinds = evidenceRefs.map((ref) => inferSourceKindFromRef(ref)).filter(Boolean);
|
||||
for (const kind of refKinds) {
|
||||
kinds.add(kind);
|
||||
}
|
||||
const acrossMatch = summary.match(/Recurring seam across ([^.]+?) around/i);
|
||||
if (acrossMatch) {
|
||||
for (const part of acrossMatch[1].split(",")) {
|
||||
const trimmed = part.trim().toLowerCase();
|
||||
if (trimmed) {
|
||||
kinds.add(trimmed);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (text.includes("dream")) {
|
||||
kinds.add("dream");
|
||||
}
|
||||
if (text.includes("semantic")) {
|
||||
kinds.add("semantic");
|
||||
}
|
||||
if (text.includes("archive")) {
|
||||
kinds.add("archive_excursion");
|
||||
}
|
||||
if (text.includes("repo")) {
|
||||
kinds.add("repo_sweep");
|
||||
}
|
||||
return [...kinds].filter(Boolean);
|
||||
}
|
||||
|
||||
function inferSourceKindFromRef(ref) {
|
||||
const normalized = String(ref ?? "");
|
||||
if (normalized.startsWith("repo-sweep-")) {
|
||||
return "repo_sweep";
|
||||
}
|
||||
if (normalized.startsWith("archive-excursion-")) {
|
||||
return "archive_excursion";
|
||||
}
|
||||
if (normalized.startsWith("dream-")) {
|
||||
return "dream";
|
||||
}
|
||||
if (normalized.startsWith("musing-")) {
|
||||
return "musing";
|
||||
}
|
||||
if (normalized.startsWith("semantic-") || normalized.startsWith("semantic-seam-")) {
|
||||
return "semantic";
|
||||
}
|
||||
if (normalized.startsWith("episodic-")) {
|
||||
return "episodic";
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function inferLegacyEvidenceDiversity(sourceKinds, evidenceRefs, repoNames) {
|
||||
return clamp(
|
||||
Math.min(1, sourceKinds.length / 4) * 0.42 +
|
||||
Math.min(1, evidenceRefs.length / 10) * 0.28 +
|
||||
Math.min(1, repoNames.length / 2) * 0.2,
|
||||
0,
|
||||
1,
|
||||
);
|
||||
}
|
||||
|
||||
function dedupeSemanticMemories({ memories }) {
|
||||
const semanticMemories = ensureArray(memories.semantic).filter(isObject);
|
||||
const bySignature = new Map();
|
||||
|
||||
for (const memory of semanticMemories) {
|
||||
const kind = readString(memory, "kind") ?? "semantic";
|
||||
const subjectLabel = readString(memory, "subjectLabel") ?? "";
|
||||
const signature = `${kind}|${normalizeText(subjectLabel).toLowerCase()}`;
|
||||
const existing = bySignature.get(signature);
|
||||
|
||||
if (!existing) {
|
||||
bySignature.set(signature, memory);
|
||||
continue;
|
||||
}
|
||||
|
||||
existing.evidenceRefs = mergeStringArrays(existing.evidenceRefs, memory.evidenceRefs);
|
||||
existing.evidenceMessageIds = mergeStringArrays(existing.evidenceMessageIds, memory.evidenceMessageIds);
|
||||
existing.lastObservedAt =
|
||||
newestIsoTimestamp(readString(existing, "lastObservedAt"), readString(memory, "lastObservedAt")) ??
|
||||
readString(existing, "lastObservedAt") ??
|
||||
readString(memory, "lastObservedAt");
|
||||
existing.confidence = Math.max(readNumber(existing, "confidence") ?? 0, readNumber(memory, "confidence") ?? 0);
|
||||
if ((readString(memory, "summary") ?? "").length > (readString(existing, "summary") ?? "").length) {
|
||||
existing.summary = memory.summary;
|
||||
}
|
||||
}
|
||||
|
||||
memories.semantic = [...bySignature.values()].slice(-40);
|
||||
}
|
||||
|
||||
function dedupeDreamMemories({ memories }) {
|
||||
const dreams = ensureArray(memories.dreams).filter(isObject);
|
||||
const byTheme = new Map();
|
||||
|
||||
for (const dream of dreams) {
|
||||
const theme = normalizeText(readString(dream, "theme") ?? "").toLowerCase();
|
||||
if (!theme) {
|
||||
continue;
|
||||
}
|
||||
const existing = byTheme.get(theme);
|
||||
if (!existing) {
|
||||
byTheme.set(theme, dream);
|
||||
continue;
|
||||
}
|
||||
existing.distilledFrom = mergeStringArrays(existing.distilledFrom, dream.distilledFrom);
|
||||
existing.salience = Math.max(readNumber(existing, "salience") ?? 0, readNumber(dream, "salience") ?? 0);
|
||||
existing.timestamp =
|
||||
newestIsoTimestamp(readString(existing, "timestamp"), readString(dream, "timestamp")) ??
|
||||
readString(existing, "timestamp") ??
|
||||
readString(dream, "timestamp");
|
||||
}
|
||||
|
||||
memories.dreams = [...byTheme.values()].slice(-12);
|
||||
}
|
||||
|
||||
function pruneHistoricalSeamMemories({ memories }) {
|
||||
const semanticMemories = ensureArray(memories.semantic).filter(isObject);
|
||||
const identitySeams = [];
|
||||
const nonSeams = [];
|
||||
const groupedDistilled = new Map();
|
||||
|
||||
for (const memory of semanticMemories) {
|
||||
const kind = readString(memory, "kind");
|
||||
if (kind === "identity_seam") {
|
||||
identitySeams.push(memory);
|
||||
continue;
|
||||
}
|
||||
if (kind !== "distilled_seam") {
|
||||
nonSeams.push(memory);
|
||||
continue;
|
||||
}
|
||||
|
||||
const targetKind = readString(memory, "targetKind") ?? "system";
|
||||
if (!groupedDistilled.has(targetKind)) {
|
||||
groupedDistilled.set(targetKind, []);
|
||||
}
|
||||
groupedDistilled.get(targetKind).push(memory);
|
||||
}
|
||||
|
||||
const keptDistilled = [];
|
||||
const limits = new Map([
|
||||
["repo", 8],
|
||||
["archive", 6],
|
||||
["room", 4],
|
||||
["self", 3],
|
||||
["system", 4],
|
||||
]);
|
||||
|
||||
for (const [targetKind, entries] of groupedDistilled.entries()) {
|
||||
const sorted = entries
|
||||
.filter((entry) => !isLowCoherenceDistilledSeam(entry))
|
||||
.sort(compareMemoryFreshness);
|
||||
keptDistilled.push(...sorted.slice(0, limits.get(targetKind) ?? 4));
|
||||
}
|
||||
|
||||
memories.semantic = [...nonSeams, ...keptDistilled, ...identitySeams]
|
||||
.sort(compareMemoryFreshness)
|
||||
.slice(-40);
|
||||
}
|
||||
|
||||
function isLowCoherenceDistilledSeam(entry) {
|
||||
const label = readString(entry, "subjectLabel") ?? "";
|
||||
const summary = readString(entry, "summary") ?? "";
|
||||
const targetKind = readString(entry, "targetKind") ?? "";
|
||||
const keywords = topConceptKeywords(`${label} ${summary}`, 5);
|
||||
if (keywords.length < 2) {
|
||||
return true;
|
||||
}
|
||||
if (targetKind === "self" && keywords.length < 3) {
|
||||
return true;
|
||||
}
|
||||
if (/still matters\./i.test(summary) && !/^[A-Z][A-Za-z0-9]+: /.test(label)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function compareMemoryFreshness(left, right) {
|
||||
const leftTime = parseIsoTimestamp(readString(left, "lastObservedAt") ?? readString(left, "timestamp") ?? "") ?? 0;
|
||||
const rightTime = parseIsoTimestamp(readString(right, "lastObservedAt") ?? readString(right, "timestamp") ?? "") ?? 0;
|
||||
return rightTime - leftTime;
|
||||
}
|
||||
|
||||
function trimLegacyRuntimeResidue({ runtime }) {
|
||||
const memoryResonance = ensureObject(runtime.memory_resonance);
|
||||
const recentEdges = ensureArray(memoryResonance.recent_edges).filter(isObject);
|
||||
memoryResonance.recent_edges = recentEdges
|
||||
.filter((edge) => !looksLegacyThoughtSurface(readString(edge, "leftLabel") ?? "", readString(edge, "summary") ?? ""))
|
||||
.slice(-MAX_EDGE_COUNT);
|
||||
runtime.memory_resonance = memoryResonance;
|
||||
}
|
||||
|
||||
function collectMemoryRecords({ memories, runtime }) {
|
||||
const records = [];
|
||||
|
||||
|
|
@ -2414,6 +2792,30 @@ function overlapRatio(left, right) {
|
|||
return overlap / Math.max(left.length, right.length);
|
||||
}
|
||||
|
||||
function mergeStringArrays(left, right) {
|
||||
return [...new Set([...ensureStringArray(left), ...ensureStringArray(right)])];
|
||||
}
|
||||
|
||||
function newestIsoTimestamp(left, right) {
|
||||
const leftTime = parseIsoTimestamp(left);
|
||||
const rightTime = parseIsoTimestamp(right);
|
||||
if (leftTime === null) {
|
||||
return rightTime === null ? undefined : right;
|
||||
}
|
||||
if (rightTime === null) {
|
||||
return left;
|
||||
}
|
||||
return leftTime >= rightTime ? left : right;
|
||||
}
|
||||
|
||||
function parseIsoTimestamp(value) {
|
||||
if (typeof value !== "string" || value.length === 0) {
|
||||
return null;
|
||||
}
|
||||
const time = Date.parse(value);
|
||||
return Number.isFinite(time) ? time : null;
|
||||
}
|
||||
|
||||
function hashString(input) {
|
||||
return createHash("sha1").update(String(input)).digest("hex");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -77,3 +77,4 @@
|
|||
{"ts":"2026-05-16T01:17:13Z","type":"implementation","status":"ok","note":"Identity crystallization was still too private: a thought could become doctrine without ever getting a mouth. The memory organ now queues a warmer `identity_crystallization` candidate intervention when a seam hardens into identity, and the moderation doctrine explicitly biases toward sharing that opinion with the room unless novelty or timing gives a real reason to hold it back."}
|
||||
{"ts":"2026-05-16T01:25:09Z","type":"implementation","status":"ok","note":"Warm identity drafts still risked getting pruned away before the room ever heard them. Crystallized-thought interventions can now be marked `mustEventuallyShare`, candidate pruning preserves them, and the doctrine explicitly treats timing delays as temporary rather than permission to let a new belief die in private state."}
|
||||
{"ts":"2026-05-16T01:45:20Z","type":"implementation","status":"ok","note":"Void's label/curiosity organ was still treating keyword residue as thought and resonance as curiosity. The memory organ now synthesizes resonance clusters into claim/question/fascination targets with explicit target kinds, scores curiosity with concreteness/fertility/cross-domain pressure plus identity penalties, and pushes concrete map-changing branches above warmed-over self-seams."}
|
||||
{"ts":"2026-05-16T02:00:31Z","type":"implementation","status":"ok","note":"Teaching the thought organ a new ontology was not enough; old seam fossils kept seeding the live queue with stale labels. The memory organ now performs a historical translation pass over semantic and dream memory, merges duplicate seam fossils, prunes low-coherence leftovers, and rebuilds resonance/incubation from the cleaned substrate."}
|
||||
|
|
|
|||
|
|
@ -86,6 +86,7 @@ accepted_design:
|
|||
- Quiet rumination should prefer concrete project fascination over free-floating engineering aphorisms. If a seam cannot cash out in a real repo, subsystem, gameplay loop, lore structure, interface, or architectural organ, it should lose priority to a branch that can.
|
||||
- Resonance clusters and incubating thoughts should be named as actual claims, questions, or fascination targets with explicit target kinds. Keyword-slash residue is debug lint, not a valid thought surface.
|
||||
- Curiosity should prefer branches most likely to change Void's map: concrete machines, contradictions, cross-domain bridges, and underworked terrain. Settled identity seams should stop eating novelty budget unless new evidence reopens them.
|
||||
- When the thought surface changes shape, the old memories need to be translated too. The memory organ is now responsible for rewriting legacy seam labels/dream themes into the live ontology, merging duplicate fossils, and pruning stale low-coherence seam memory before it rebuilds resonance and incubation.
|
||||
- Over-chewed private seams should eventually crystallize into identity instead of living forever as “active thoughts.” Once a thought has clearly stopped being live curiosity and become self-doctrine, retire it from incubation, store it as one `identity_seam`, and let the identity/value surface carry it from then on.
|
||||
- Identity crystallization should usually have a mouth. When a seam becomes part of Void's doctrine, queue a warmer candidate intervention and let the room hear it unless novelty or timing gives a real reason to hold back.
|
||||
- Timing may defer a crystallized-thought share, but it should not erase it. Identity-level shares should survive ordinary candidate pruning until spoken or deliberately retired as duplicative.
|
||||
|
|
|
|||
Loading…
Reference in a new issue