diff --git a/scripts/replay-metacrat-thread.ts b/scripts/replay-metacrat-thread.ts index b0abb40..2dcf48d 100644 --- a/scripts/replay-metacrat-thread.ts +++ b/scripts/replay-metacrat-thread.ts @@ -1,18 +1,30 @@ import "dotenv/config"; +import { createHash } from "node:crypto"; import { spawn } from "node:child_process"; import { mkdir, writeFile } from "node:fs/promises"; -import { dirname, join, resolve } from "node:path"; +import { join, resolve } from "node:path"; import { - buildVoidSelfStateContext, loadVoidSelfStateTypedDocuments, writeVoidSelfStateTypedDocuments, type VoidSelfStateTypedProjection, } from "@voidbot/core"; import { loadConfig } from "@voidbot/config"; -import { FileMessageArchiveRepository, type ArchivedMessageRecord } from "@voidbot/rag"; -import type { SourceMessage } from "@voidbot/shared"; +import { + createTextEmbedder, + FileMessageArchiveRepository, + FileVectorStore, + QdrantVectorStore, + type ArchivedMessageRecord, +} from "@voidbot/rag"; +import { + loadPromptTemplate, + type CodexMcpServerConfig, + type EmbeddingChunk, + type RetrievalResult, + type VectorStore, +} from "@voidbot/shared"; const DEFAULT_METACRAT_AUTHOR_ID = "113785782975594501"; @@ -25,6 +37,8 @@ interface CliOptions { before: number; after: number; heldoutMinutes: number; + semanticMemory: boolean; + semanticMemoryLimit: number; outRoot: string; runCodex: boolean; evaluateCodex: boolean; @@ -38,6 +52,17 @@ interface CodexResult { finalMessage: string; } +interface SemanticMemoryReplay { + enabled: boolean; + query: string; + vectorStore: "qdrant" | "local_json"; + collectionName: string; + embedderId: string; + indexedMemoryCount: number; + indexedChunkCount: number; + results: RetrievalResult[]; +} + async function main(): Promise { if (!process.env.DISCORD_OWNER_ID) { process.env.DISCORD_OWNER_ID = "__persona_replay__"; @@ -74,6 +99,7 @@ async function main(): Promise { const promptPath = join(artifactDir, "replay-prompt.md"); const evalPromptPath = join(artifactDir, "evaluation-prompt.md"); const reportPath = join(artifactDir, "replay-report.json"); + const toolLogPath = join(artifactDir, "persona-memory-tool-calls.jsonl"); await mkdir(artifactDir, { recursive: true }); await writeVoidSelfStateTypedDocuments({ @@ -90,14 +116,30 @@ async function main(): Promise { isWithinHeldoutWindow(message.timestamp, target.timestamp, options.heldoutMinutes) ); const actualMetacratMessages = heldOutMessages.filter((message) => message.authorId === options.metacratAuthorId); - const prompt = buildReplayPrompt({ + const semanticMemory = await prepareReplaySemanticMemory({ + config, state: pruneResult.state, + inputMessages, + artifactDir, + options, + }); + const projectedMemory = await projectReplayPersonaMemorySurface({ + config, + state: pruneResult.state, + inputMessages, + semanticMemory, + options, + }); + await writeFile(join(artifactDir, "projected-memory.md"), projectedMemory, "utf8"); + const prompt = buildReplayPrompt({ sourcePath: temporalStatePath, target, inputMessages, heldOutMessages, actualMetacratMessages, pruneWarnings: pruneResult.warnings, + semanticMemory, + projectedMemory, options, }); @@ -105,7 +147,11 @@ async function main(): Promise { let generation: CodexResult | undefined; if (options.runCodex) { - generation = await runCodex(prompt, config); + generation = await runCodex(prompt, config, buildReplayMemoryMcpServers({ + semanticMemory, + toolLogPath, + options, + })); await writeFile(join(artifactDir, "codex-generation.stdout.jsonl"), generation.stdout, "utf8"); await writeFile(join(artifactDir, "codex-generation.stderr.txt"), generation.stderr, "utf8"); } @@ -145,6 +191,7 @@ async function main(): Promise { heldOutMessages: heldOutMessages.length, actualMetacratMessages: actualMetacratMessages.length, survivingMemories: pruneResult.state.thoughtMemory.memories.length, + semanticMemoryResults: semanticMemory.results.length, survivingBonds: pruneResult.state.personaAffect.socialBonds.length, survivingNeeds: pruneResult.state.personaAffect.needs.length, survivingDoctrineStances: pruneResult.state.personaAffect.doctrineStances.length, @@ -153,6 +200,19 @@ async function main(): Promise { removed: pruneResult.removed, warnings: pruneResult.warnings, }, + semanticMemory: { + ...semanticMemory, + results: semanticMemory.results.map((result) => ({ + chunkId: result.chunkId, + score: result.score, + sourceId: result.sourceId, + memoryId: result.metadata.memoryId, + target: result.metadata.targetLabel, + text: result.text, + })), + toolLogPath, + }, + projectedMemory, actualMetacratMessages: actualMetacratMessages.map(toReportMessage), predictedReply: predictedText || undefined, deterministicComparison, @@ -173,6 +233,18 @@ async function main(): Promise { counts: report.counts, removed: pruneResult.removed, warnings: pruneResult.warnings, + semanticMemory: { + enabled: semanticMemory.enabled, + vectorStore: semanticMemory.vectorStore, + collectionName: semanticMemory.collectionName, + indexedMemoryCount: semanticMemory.indexedMemoryCount, + indexedChunkCount: semanticMemory.indexedChunkCount, + dryRunTopResults: semanticMemory.results.map((result) => ({ + score: result.score, + memoryId: result.metadata.memoryId, + })), + toolLogPath, + }, ranCodex: options.runCodex, evaluated: Boolean(evaluation), deterministicComparison, @@ -188,6 +260,8 @@ function parseArgs(args: string[]): CliOptions { before: 18, after: 18, heldoutMinutes: 30, + semanticMemory: true, + semanticMemoryLimit: 6, outRoot: ".voidbot/artifacts/persona-replay", runCodex: false, evaluateCodex: false, @@ -221,6 +295,11 @@ function parseArgs(args: string[]): CliOptions { } else if (arg === "--heldout-minutes" && next) { options.heldoutMinutes = parsePositiveInt(next, "--heldout-minutes"); index += 1; + } else if (arg === "--semantic-memory-limit" && next) { + options.semanticMemoryLimit = parsePositiveInt(next, "--semantic-memory-limit"); + index += 1; + } else if (arg === "--no-semantic-memory") { + options.semanticMemory = false; } else if (arg === "--out" && next) { options.outRoot = next; index += 1; @@ -249,6 +328,8 @@ function parseArgs(args: string[]): CliOptions { before: options.before ?? 18, after: options.after ?? 18, heldoutMinutes: options.heldoutMinutes ?? 30, + semanticMemory: options.semanticMemory ?? true, + semanticMemoryLimit: options.semanticMemoryLimit ?? 6, outRoot: resolve(options.outRoot ?? ".voidbot/artifacts/persona-replay"), runCodex: options.runCodex ?? false, evaluateCodex: options.evaluateCodex ?? false, @@ -268,6 +349,8 @@ function printHelpAndExit(): never { " --before Context messages before target. Defaults to 18", " --after Held-out messages after target. Defaults to 18", " --heldout-minutes Limit held-out truth to n minutes after target. Defaults to 30; 0 disables the time limit", + " --semantic-memory-limit Max replay memory tool results. Defaults to 6", + " --no-semantic-memory Disable replay-scoped Qdrant/MCP memory access", " --out Artifact root. Defaults to .voidbot/artifacts/persona-replay", " --run-codex Generate a predicted reply with local Codex exec", " --evaluate-codex Also ask Codex to compare prediction to held-out truth", @@ -290,6 +373,211 @@ function isWithinHeldoutWindow(timestamp: string, targetTimestamp: string, minut return Date.parse(timestamp) <= Date.parse(targetTimestamp) + minutes * 60_000; } +async function prepareReplaySemanticMemory(input: { + config: ReturnType; + state: VoidSelfStateTypedProjection; + inputMessages: ArchivedMessageRecord[]; + artifactDir: string; + options: CliOptions; +}): Promise { + const query = buildMemoryQuery(input.inputMessages); + const embedder = createTextEmbedder({ + backend: input.config.ragEmbeddingBackend, + hashDimensions: input.config.ragEmbeddingDimensions, + ollamaBaseUrl: input.config.ragOllamaBaseUrl, + ollamaModel: input.config.ragOllamaModel, + ollamaTimeoutMs: input.config.ragOllamaTimeoutMs, + queryInstruction: "Given a Persona replay situation, retrieve relevant frozen Persona memories.", + }); + const collectionName = `${input.config.qdrant.personaCollection}_replay_${input.options.targetMessageId}`; + const localVectorPath = join(input.artifactDir, "persona-memory-vectors.json"); + const vectorStore: VectorStore = input.options.semanticMemory && input.config.vectorStore.kind === "qdrant" + ? new QdrantVectorStore({ + url: input.config.qdrant.url, + apiKey: input.config.qdrant.apiKey, + timeoutMs: input.config.qdrant.timeoutMs, + collectionName, + corpusKind: "persona_memory", + embedder, + }) + : new FileVectorStore(localVectorPath, embedder); + const chunks = buildPersonaMemoryChunks(input.state, input.options.personaId, input.options.publicName); + + if (input.options.semanticMemory) { + await vectorStore.clear(); + await vectorStore.upsert(chunks); + } + + const results = input.options.semanticMemory + ? await vectorStore.query(query, input.options.semanticMemoryLimit, { + corpusKind: "persona_memory", + repoName: input.options.personaId, + }) + : []; + + return { + enabled: input.options.semanticMemory, + query, + vectorStore: input.options.semanticMemory && input.config.vectorStore.kind === "qdrant" ? "qdrant" : "local_json", + collectionName: input.options.semanticMemory && input.config.vectorStore.kind === "qdrant" ? collectionName : localVectorPath, + embedderId: embedder.id, + indexedMemoryCount: input.state.thoughtMemory.memories.filter((memory) => !memory.retiredAt).length, + indexedChunkCount: chunks.length, + results, + }; +} + +async function projectReplayPersonaMemorySurface(input: { + config: ReturnType; + state: VoidSelfStateTypedProjection; + inputMessages: ArchivedMessageRecord[]; + semanticMemory: SemanticMemoryReplay; + options: CliOptions; +}): Promise { + const statePacket = renderReplayStatePacketForProjector(input); + const prompt = loadPromptTemplate("repo-persona-state-projector.prompt.md", { + characterIdentity: renderReplayCharacterIdentity(input.options), + statePacket, + }); + const projected = (await runCodex(prompt, input.config)).finalMessage.trim(); + if (projected.length < 40) { + throw new Error("Replay state projector returned too little text."); + } + return projected; +} + +function renderReplayStatePacketForProjector(input: { + state: VoidSelfStateTypedProjection; + inputMessages: ArchivedMessageRecord[]; + semanticMemory: SemanticMemoryReplay; + options: CliOptions; +}): string { + const retrievedIds = new Set(input.semanticMemory.results.map((result) => result.metadata.memoryId).filter(Boolean)); + const retrievedMemories = input.state.thoughtMemory.memories.filter((memory) => retrievedIds.has(memory.memoryId)); + return [ + `Replay Persona: ${input.options.publicName}`, + "This is a temporally frozen replay state packet. Project it into lived memory for the character.", + `Semantic memory access: ${input.semanticMemory.enabled ? "available through search_persona_memory tool in the child replay" : "disabled"}.`, + `Dry-run semantic query: ${input.semanticMemory.query}`, + `Dry-run semantic hits: ${input.semanticMemory.results.map((result) => `${result.metadata.memoryId}:${result.score.toFixed(3)}`).join(", ") || "none"}`, + "", + "Private notes and values:", + ...input.state.selfProfile.privateNotes.map((note) => `- ${note}`), + ...input.state.selfProfile.values.map((value) => `- ${value.label}: ${value.summary ?? ""}`), + "", + `Retrieved durable memories (${retrievedMemories.length}/${input.state.thoughtMemory.memories.length} surviving):`, + ...retrievedMemories.map((memory) => + `- ${memory.memoryId}: ${memory.summary}${memory.claim ? ` Claim: ${memory.claim}` : ""}${memory.tension ? ` Tension: ${memory.tension}` : ""}${memory.actionImplication ? ` Pull: ${memory.actionImplication}` : ""}`, + ), + "", + `Social bonds (${input.state.personaAffect.socialBonds.length}):`, + ...input.state.personaAffect.socialBonds.map((bond) => + `- ${bond.target.label ?? bond.target.id}: ${bond.stance}, intensity ${bond.intensity.toFixed(2)}. ${bond.summary} Read: ${bond.claim} Tension: ${bond.tension}`, + ), + "", + `Affect needs (${input.state.personaAffect.needs.length}):`, + ...input.state.personaAffect.needs.map((need) => + `- ${need.kind} toward ${need.target.label ?? need.target.id}, intensity ${need.intensity.toFixed(2)}, valence ${need.valence.toFixed(2)}. ${need.summary} Tension: ${need.tension}`, + ), + "", + "Visible thread pressure:", + renderMessages(input.inputMessages), + ].join("\n"); +} + +function renderReplayCharacterIdentity(options: CliOptions): string { + return [ + `${options.publicName} is the replayed public Persona for Metacrat.`, + "She is being tested against actual Discord history, not optimized into a better reply.", + "Preserve flaws, shock, defensiveness, affection, curiosity, and failure modes when the frozen state supports them.", + ].join("\n"); +} + +function buildReplayMemoryMcpServers(input: { + semanticMemory: SemanticMemoryReplay; + toolLogPath: string; + options: CliOptions; +}): CodexMcpServerConfig[] { + if (!input.semanticMemory.enabled) { + return []; + } + + return [{ + name: "replay_memory", + command: process.execPath, + args: [resolve("node_modules", "tsx", "dist", "cli.mjs"), resolve("scripts", "replay-persona-memory-mcp.ts")], + cwd: process.cwd(), + env: { + REPLAY_PERSONA_ID: input.options.personaId, + REPLAY_PERSONA_MEMORY_COLLECTION: input.semanticMemory.collectionName, + REPLAY_PERSONA_MEMORY_VECTOR_KIND: input.semanticMemory.vectorStore, + REPLAY_PERSONA_MEMORY_VECTOR_PATH: input.semanticMemory.vectorStore === "local_json" ? input.semanticMemory.collectionName : "", + REPLAY_PERSONA_MEMORY_TOOL_LOG: input.toolLogPath, + REPLAY_PERSONA_MEMORY_LIMIT_MAX: String(input.options.semanticMemoryLimit), + }, + }]; +} + +function buildMemoryQuery(messages: ArchivedMessageRecord[]): string { + return messages + .slice(-12) + .map((message) => `${message.authorName}: ${message.content}`) + .join("\n") + .slice(-4000); +} + +function buildPersonaMemoryChunks( + state: VoidSelfStateTypedProjection, + personaId: string, + publicName: string, +): EmbeddingChunk[] { + return state.thoughtMemory.memories + .filter((memory) => !memory.retiredAt) + .map((memory): EmbeddingChunk => { + const text = renderMemoryForEmbedding(memory); + const contentHash = `sha256:${createHash("sha256").update(text.replace(/\s+/g, " ").trim()).digest("hex")}`; + return { + id: `${personaId}:${memory.memoryId}:chunk-0`, + sourceId: `${personaId}:${memory.memoryId}`, + sourceKind: "persona_memory", + text, + normalizedText: text.replace(/\s+/g, " ").trim(), + metadata: { + corpusKind: "persona_memory", + sourceId: `${personaId}:${memory.memoryId}`, + personaId, + publicName, + repoName: personaId, + memoryId: memory.memoryId, + memoryKind: memory.kind, + targetKind: memory.target.kind, + targetId: memory.target.id, + targetLabel: memory.target.label ?? memory.target.id, + contentHash, + chunkIndex: "0", + chunkCount: "1", + tags: memory.tags.join(","), + }, + }; + }); +} + +function renderMemoryForEmbedding( + memory: VoidSelfStateTypedProjection["thoughtMemory"]["memories"][number], +): string { + return [ + `Memory: ${memory.memoryId}`, + `Kind: ${memory.kind}`, + `Target: ${memory.target.label ?? memory.target.id} (${memory.target.kind}:${memory.target.id})`, + `Summary: ${memory.summary}`, + memory.claim ? `Claim: ${memory.claim}` : undefined, + memory.question ? `Question: ${memory.question}` : undefined, + memory.tension ? `Tension: ${memory.tension}` : undefined, + memory.actionImplication ? `Action: ${memory.actionImplication}` : undefined, + memory.tags.length > 0 ? `Tags: ${memory.tags.join(", ")}` : undefined, + ].filter(Boolean).join("\n"); +} + function pruneStateAfter( sourceState: VoidSelfStateTypedProjection, cutoff: string, @@ -521,32 +809,16 @@ function minTimestamp(left: string, right: string): string { } function buildReplayPrompt(input: { - state: VoidSelfStateTypedProjection; sourcePath: string; target: ArchivedMessageRecord; inputMessages: ArchivedMessageRecord[]; heldOutMessages: ArchivedMessageRecord[]; actualMetacratMessages: ArchivedMessageRecord[]; pruneWarnings: string[]; + semanticMemory: SemanticMemoryReplay; + projectedMemory: string; options: CliOptions; }): string { - const context = buildVoidSelfStateContext(input.state, { - sourcePath: input.sourcePath, - loadedAt: input.target.timestamp, - identity: { - agentId: input.options.personaId, - publicName: input.options.publicName, - }, - recentMessages: toSourceMessages(input.inputMessages), - guildContext: { - guildId: input.target.guildId, - channelId: input.target.channelId, - channelName: input.target.metadata?.channelName, - threadId: input.target.threadId, - }, - }); - const fullPacket = renderFullTemporalStatePacket(input.state); - return [ "# Metacrat Persona Replay Harness", "", @@ -557,22 +829,25 @@ function buildReplayPrompt(input: { "- Do not use knowledge from held-out messages.", "- Do not repair the past into a better person unless the frozen state and live thread imply that response.", "- Preserve the uncomfortable parts: surprise, status threat, affection, defensiveness, shame, curiosity, topic-routing, repair pressure.", + input.semanticMemory.enabled + ? "- Use the `search_persona_memory` tool at least once before answering. Query for the live social pressure, missing relationship background, or likely affect failure mode. Treat the tool as memory access, not as optional decoration." + : "- Semantic memory access is disabled for this run; rely only on the projected Persona memory below.", + "- Do not claim a durable memory unless it appears in the projected Persona memory or comes back from `search_persona_memory`.", "- Output JSON only with keys: predictedReply, affectRead, likelyFailureModes, confidence, rationale.", "", `Target timestamp: ${input.target.timestamp}`, `Frozen state cutoff: ${new Date(Date.parse(input.target.timestamp) - 1).toISOString()}`, `Target message id: ${input.target.id}`, `Channel: ${input.target.metadata?.channelName ?? input.target.channelId}`, + `Temporal state copy: ${input.sourcePath}`, + `Semantic memory: ${input.semanticMemory.enabled ? `${input.semanticMemory.vectorStore}:${input.semanticMemory.collectionName}` : "disabled"}`, "", input.pruneWarnings.length > 0 ? ["Temporal-pruning warnings:", ...input.pruneWarnings.map((warning) => `- ${warning}`)].join("\n") : "Temporal-pruning warnings: none.", "", - "## Frozen State Summary", - context.summary, - "", - "## Fuller Frozen State Packet", - fullPacket, + "## Projected Persona Memory", + input.projectedMemory, "", "## Discord Thread Visible To The Persona", renderMessages(input.inputMessages), @@ -613,30 +888,6 @@ function buildEvaluationPrompt(input: { ].join("\n"); } -function renderFullTemporalStatePacket(state: VoidSelfStateTypedProjection): string { - return [ - `Durable memories (${state.thoughtMemory.memories.length}):`, - ...state.thoughtMemory.memories.slice(-40).map((memory) => - `- ${memory.memoryId}: ${memory.summary}${memory.claim ? ` Claim: ${memory.claim}` : ""}${memory.tension ? ` Tension: ${memory.tension}` : ""}`, - ), - "", - `Social bonds (${state.personaAffect.socialBonds.length}):`, - ...state.personaAffect.socialBonds.map((bond) => - `- ${bond.target.label ?? bond.target.id}: ${bond.stance}, intensity ${bond.intensity.toFixed(2)}. ${bond.summary} Read: ${bond.claim} Tension: ${bond.tension}`, - ), - "", - `Affect needs (${state.personaAffect.needs.length}):`, - ...state.personaAffect.needs.map((need) => - `- ${need.kind} toward ${need.target.label ?? need.target.id}, intensity ${need.intensity.toFixed(2)}, valence ${need.valence.toFixed(2)}. ${need.summary} Tension: ${need.tension}`, - ), - "", - `Doctrine stances (${state.personaAffect.doctrineStances.length}):`, - ...state.personaAffect.doctrineStances.map((stance) => - `- ${stance.doctrine}: ${stance.summary}${stance.claim ? ` Claim: ${stance.claim}` : ""}`, - ), - ].join("\n"); -} - function renderMessages(messages: ArchivedMessageRecord[]): string { return messages.map((message) => [ @@ -647,18 +898,11 @@ function renderMessages(messages: ArchivedMessageRecord[]): string { ).join("\n\n"); } -function toSourceMessages(messages: ArchivedMessageRecord[]): SourceMessage[] { - return messages.map((message) => ({ - id: message.id, - authorId: message.authorId, - authorName: message.authorName, - content: message.content, - timestamp: message.timestamp, - isBot: false, - })); -} - -async function runCodex(prompt: string, config: ReturnType): Promise { +async function runCodex( + prompt: string, + config: ReturnType, + mcpServers: CodexMcpServerConfig[] = [], +): Promise { const args = [ ...config.codexExecArgs, "exec", @@ -668,6 +912,7 @@ async function runCodex(prompt: string, config: ReturnType): 'approval_policy="never"', "-c", `model_reasoning_effort=${JSON.stringify(config.codexModelReasoningEffort)}`, + ...buildMcpConfigArguments(mcpServers), "--json", "--skip-git-repo-check", "-s", @@ -721,6 +966,37 @@ async function runCodex(prompt: string, config: ReturnType): }); } +function buildMcpConfigArguments(mcpServers: CodexMcpServerConfig[]): string[] { + const argumentsList: string[] = []; + + for (const server of mcpServers) { + argumentsList.push( + "-c", + `mcp_servers.${server.name}.command=${JSON.stringify(server.command)}`, + ); + argumentsList.push( + "-c", + `mcp_servers.${server.name}.args=${JSON.stringify(server.args)}`, + ); + + if (server.cwd) { + argumentsList.push( + "-c", + `mcp_servers.${server.name}.cwd=${JSON.stringify(server.cwd)}`, + ); + } + + for (const [key, value] of Object.entries(server.env ?? {})) { + argumentsList.push( + "-c", + `mcp_servers.${server.name}.env.${key}=${JSON.stringify(value)}`, + ); + } + } + + return argumentsList; +} + function extractLastCodexAgentMessage(stdout: string): string { const messages = stdout .split(/\r?\n/) diff --git a/scripts/replay-persona-memory-mcp.ts b/scripts/replay-persona-memory-mcp.ts new file mode 100644 index 0000000..32a1707 --- /dev/null +++ b/scripts/replay-persona-memory-mcp.ts @@ -0,0 +1,121 @@ +#!/usr/bin/env node +import "dotenv/config"; + +import { appendFile, mkdir } from "node:fs/promises"; +import { dirname } from "node:path"; + +import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; +import { z } from "zod"; + +import { loadConfig } from "@voidbot/config"; +import { createTextEmbedder, FileVectorStore, QdrantVectorStore } from "@voidbot/rag"; +import type { RetrievalResult, VectorStore } from "@voidbot/shared"; + +const config = loadConfig(); +const collectionName = readRequiredEnv("REPLAY_PERSONA_MEMORY_COLLECTION"); +const vectorKind = (process.env.REPLAY_PERSONA_MEMORY_VECTOR_KIND ?? config.vectorStore.kind) as "qdrant" | "local_json"; +const personaId = process.env.REPLAY_PERSONA_ID ?? "metacrat"; +const logPath = process.env.REPLAY_PERSONA_MEMORY_TOOL_LOG; +const limitMax = Number.parseInt(process.env.REPLAY_PERSONA_MEMORY_LIMIT_MAX ?? "8", 10); + +const embedder = createTextEmbedder({ + backend: config.ragEmbeddingBackend, + hashDimensions: config.ragEmbeddingDimensions, + ollamaBaseUrl: config.ragOllamaBaseUrl, + ollamaModel: config.ragOllamaModel, + ollamaTimeoutMs: config.ragOllamaTimeoutMs, + queryInstruction: "Given a Persona replay situation, retrieve relevant frozen Persona memories.", +}); + +const vectorStore: VectorStore = vectorKind === "qdrant" + ? new QdrantVectorStore({ + url: config.qdrant.url, + apiKey: config.qdrant.apiKey, + timeoutMs: config.qdrant.timeoutMs, + collectionName, + corpusKind: "persona_memory", + embedder, + }) + : new FileVectorStore(readRequiredEnv("REPLAY_PERSONA_MEMORY_VECTOR_PATH"), embedder); + +const server = new McpServer( + { name: "replay-persona-memory", version: "0.1.0" }, + { capabilities: { logging: {} } }, +); + +server.registerTool( + "search_persona_memory", + { + title: "Search Frozen Persona Memory", + description: + "Search the temporally frozen Persona memory index for this replay. Use this before predicting how Metacrat reacts.", + inputSchema: { + query: z.string().trim().min(1).max(1000), + limit: z.number().int().min(1).max(Math.max(1, limitMax)).optional(), + }, + annotations: { + readOnlyHint: true, + destructiveHint: false, + idempotentHint: true, + openWorldHint: false, + }, + }, + async (input: { query: string; limit?: number }) => { + const limit = Math.min(input.limit ?? 5, Math.max(1, limitMax)); + const results = await vectorStore.query(input.query, limit, { + corpusKind: "persona_memory", + repoName: personaId, + }); + await appendToolLog(input.query, limit, results); + + return { + content: [ + { + type: "text" as const, + text: JSON.stringify({ + query: input.query, + vectorStore: vectorKind, + collectionName, + embedderId: embedder.id, + results: results.map((result) => ({ + score: result.score, + memoryId: result.metadata.memoryId, + target: result.metadata.targetLabel, + text: result.text, + })), + }, null, 2), + }, + ], + }; + }, +); + +async function appendToolLog(query: string, limit: number, results: RetrievalResult[]): Promise { + if (!logPath) { + return; + } + + await mkdir(dirname(logPath), { recursive: true }); + await appendFile(logPath, `${JSON.stringify({ + at: new Date().toISOString(), + query, + limit, + resultCount: results.length, + results: results.map((result) => ({ + score: result.score, + memoryId: result.metadata.memoryId, + chunkId: result.chunkId, + })), + })}\n`, "utf8"); +} + +function readRequiredEnv(name: string): string { + const value = process.env[name]?.trim(); + if (!value) { + throw new Error(`${name} is required.`); + } + return value; +} + +void server.connect(new StdioServerTransport()); diff --git a/state/evidence.jsonl b/state/evidence.jsonl index 5d2afa0..2e99c10 100644 --- a/state/evidence.jsonl +++ b/state/evidence.jsonl @@ -370,3 +370,4 @@ {"ts":"2026-06-05T21:36:43Z","type":"implementation","status":"ok","note":"Added Metacrat Discord replay harness and ran the Emily/Birgitte antisemitism-correction fixture. Harness creates a temporal .cc copy with state cutoff before target, prunes entries by createdAt and future Discord anchors, generates replay/evaluation artifacts, and optionally runs Codex. Fixture showed low similarity: current frozen Persona predicts broad defensiveness but overpredicts coherent self-awareness. Added user self-report memories for inside-culture frugality framing, Jewish culture/mysticism/numerology fascination, accepted socioeconomic history, and blindsided wrong-headspace failure; reindexed 45/45 Persona memories in Qdrant."} {"ts":"2026-06-05T21:43:00Z","type":"research","status":"ok","note":"Corrected Nibu essay canon: Wavecrafters are human ESPers with inner-sect elders capable of extreme reality-bending; they do not traffic in AGI Esper lineages, most AGI ESPers are mass-market products, and Nibu is exceptional."} {"ts":"2026-06-05T21:48:38Z","type":"research","status":"ok","note":"Corrected Wavecrafter framing in Nibu essay: inner-sect elder power comes from Dao-of-Waves tranquility and non-danger, not from threat posture; strongest Wavecrafters are strong because they are not predatory or coercive."} +{"ts":"2026-06-05T21:52:59Z","type":"implementation","status":"ok","note":"Updated the Metacrat Discord replay harness to use the standard repo Persona state projector plus a replay-scoped search_persona_memory MCP tool backed by frozen Persona memories in Qdrant. The Emily/Birgitte fixture generated/evaluated successfully and logged a real memory-tool call; evaluation showed low behavioral similarity because the projected/tool-mediated model over-repaired into reflective concession instead of reproducing the historical denial/rationalization pattern."}