dsh-tdai-memory 0.1.0

package/vendor/tdai/core/persona/persona-generator.js

@@ -0,0 +1,184 @@
+/**
+ * PersonaGenerator: generates or updates user persona using the four-layer
+ * deep scan model via CleanContextRunner.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { formatForLLM } from "../../utils/time.js";
+import { CleanContextRunner } from "../../utils/clean-context-runner.js";
+import { CheckpointManager } from "../../utils/checkpoint.js";
+import { readSceneIndex } from "../scene/scene-index.js";
+import { generateSceneNavigation, stripSceneNavigation } from "../scene/scene-navigation.js";
+import { buildPersonaPrompt } from "../prompts/persona-generation.js";
+import { BackupManager } from "../../utils/backup.js";
+import { escapeXmlTags } from "../../utils/sanitize.js";
+import { report } from "../report/reporter.js";
+const TAG = "[memory-tdai] [persona]";
+export class PersonaGenerator {
+    dataDir;
+    runner;
+    logger;
+    backupCount;
+    instanceId;
+    constructor(opts) {
+        this.dataDir = opts.dataDir;
+        this.logger = opts.logger;
+        this.backupCount = opts.backupCount ?? 3;
+        this.instanceId = opts.instanceId;
+        // Use injected LLMRunner if available, otherwise fall back to CleanContextRunner
+        this.runner = opts.llmRunner ?? new CleanContextRunner({
+            config: opts.config,
+            modelRef: opts.model,
+            enableTools: true,
+            logger: opts.logger,
+        });
+        this.logger?.debug?.(`${TAG} Generator created: model=${opts.model ?? "(default)"}, dataDir=${opts.dataDir}`);
+    }
+    /**
+     * Execute local persona generation without advancing checkpoint.
+     */
+    async generateLocalPersona(triggerReason) {
+        const startMs = Date.now();
+        this.logger?.debug?.(`${TAG} Starting generation: reason="${triggerReason ?? "none"}"`);
+        const cpManager = new CheckpointManager(this.dataDir);
+        const cp = await cpManager.read();
+        this.logger?.debug?.(`${TAG} Checkpoint: total_processed=${cp.total_processed}, last_persona_at=${cp.last_persona_at}`);
+        const personaPath = path.join(this.dataDir, "persona.md");
+        // 1. Read existing persona (strip navigation)
+        let existingPersona;
+        try {
+            const raw = await fs.readFile(personaPath, "utf-8");
+            existingPersona = stripSceneNavigation(raw).trim() || undefined;
+            this.logger?.debug?.(`${TAG} Existing persona: ${existingPersona ? `${existingPersona.length} chars` : "empty"}`);
+        }
+        catch {
+            this.logger?.debug?.(`${TAG} No existing persona file`);
+        }
+        // 2. Load scene index + identify changed scenes
+        const index = await readSceneIndex(this.dataDir);
+        const changedScenes = index.filter((e) => {
+            if (!cp.last_persona_time)
+                return true;
+            const updatedMs = new Date(e.updated).getTime();
+            const personaMs = new Date(cp.last_persona_time).getTime();
+            // If either date is unparseable (NaN), treat as changed (conservative)
+            if (Number.isNaN(updatedMs) || Number.isNaN(personaMs))
+                return true;
+            return updatedMs > personaMs;
+        });
+        this.logger?.debug?.(`${TAG} Scene index: ${index.length} total, ${changedScenes.length} changed since last persona`);
+        // 3. Read changed scene contents (full raw content including META, matching Python reference)
+        const blocksDir = path.join(this.dataDir, "scene_blocks");
+        const changedSceneContents = [];
+        for (const entry of changedScenes) {
+            try {
+                const raw = await fs.readFile(path.join(blocksDir, entry.filename), "utf-8");
+                changedSceneContents.push(`### [${changedSceneContents.length + 1}] ${entry.filename}\n\n\`\`\`markdown\n${raw}\n\`\`\``);
+            }
+            catch {
+                this.logger?.warn(`${TAG} Could not read scene block: ${entry.filename}`);
+            }
+        }
+        if (changedSceneContents.length === 0 && existingPersona) {
+            this.logger?.debug?.(`${TAG} No scene changes and persona exists, skipping generation`);
+            return false;
+        }
+        // 4. Determine mode
+        const mode = existingPersona ? "incremental" : "first";
+        this.logger?.debug?.(`${TAG} Generation mode: ${mode}, ${changedSceneContents.length} scene blocks to process`);
+        // 5. Build changed scenes section with guidance (matching Python reference format)
+        let changedScenesContent;
+        if (changedSceneContents.length > 0) {
+            changedScenesContent =
+                `\n\n## 📄 变化场景完整内容\n\n` +
+                    `*自上次 Persona 更新后，以下 ${changedSceneContents.length} 个场景发生了变化。工程已为你预加载完整内容：*\n\n` +
+                    changedSceneContents.join("\n\n") +
+                    `\n\n---\n\n` +
+                    `⚠️ **重点分析变化场景**：上述场景是自上次更新后的**新增/修改内容**，请**重点分析**这些场景中的新信息。\n`;
+        }
+        else {
+            changedScenesContent = `\n\n⚠️ **无变化场景**：所有场景均已在上次 Persona 更新中分析过，本次可直接读取所有场景进行全局审视。\n`;
+        }
+        // 6. Build prompt
+        const { systemPrompt, userPrompt } = buildPersonaPrompt({
+            mode,
+            currentTime: formatForLLM(new Date()),
+            totalProcessed: cp.total_processed,
+            sceneCount: index.length,
+            changedSceneCount: changedScenes.length,
+            changedScenesContent,
+            existingPersona,
+            triggerInfo: triggerReason,
+            personaFilePath: personaPath,
+            checkpointPath: path.join(this.dataDir, ".metadata", "recall_checkpoint.json"),
+        });
+        // 7. Backup before LLM run (LLM writes persona.md via tools)
+        const bm = new BackupManager(path.join(this.dataDir, ".backup"));
+        await bm.backupFile(personaPath, "persona", `offset${cp.total_processed}`, this.backupCount);
+        // 8. Run LLM agent (sandboxed to dataDir, tools enabled — LLM writes persona.md directly)
+        try {
+            this.logger?.debug?.(`${TAG} Calling LLM for persona generation (timeout=180s, tools=enabled, workspaceDir=${this.dataDir})...`);
+            await this.runner.run({
+                systemPrompt,
+                prompt: userPrompt,
+                taskId: "persona-generation",
+                timeoutMs: 180_000,
+                // maxTokens omitted → core uses the resolved model's maxTokens from catalog
+                workspaceDir: this.dataDir,
+            });
+            this.logger?.debug?.(`${TAG} LLM runner completed`);
+        }
+        catch (err) {
+            const elapsedMs = Date.now() - startMs;
+            this.logger?.error(`${TAG} Persona generation failed after ${elapsedMs}ms: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);
+            return false;
+        }
+        // 9. Read LLM-written persona.md and apply post-processing
+        let personaText;
+        try {
+            personaText = await fs.readFile(personaPath, "utf-8");
+        }
+        catch {
+            // LLM failed to write persona.md — treat as failure
+            this.logger?.error(`${TAG} LLM did not write persona.md — file not found after runner completed`);
+            return false;
+        }
+        // 10. Strip any navigation the LLM might have added + sanitize for safe injection
+        personaText = escapeXmlTags(stripSceneNavigation(personaText).trim());
+        if (!personaText) {
+            this.logger?.error(`${TAG} LLM wrote empty persona.md — skipping`);
+            return false;
+        }
+        // 11. Append fresh scene navigation and write final content
+        const nav = generateSceneNavigation(index);
+        const finalContent = nav ? `${personaText}\n\n${nav}\n` : personaText;
+        await fs.writeFile(personaPath, finalContent, "utf-8");
+        const elapsedMs = Date.now() - startMs;
+        this.logger?.info(`${TAG} Persona written (${finalContent.length} chars) in ${elapsedMs}ms`);
+        // ── l3_persona_generation metric ──
+        if (this.instanceId && this.logger) {
+            report("l3_persona_generation", {
+                triggerReason: triggerReason ?? "unknown",
+                mode: existingPersona ? "incremental" : "initial",
+                newPersonaContent: personaText,
+                newPersonaLength: personaText.length,
+                totalDurationMs: elapsedMs,
+                success: true,
+                error: null,
+            });
+        }
+        return true;
+    }
+    /**
+     * Backward-compatible wrapper: local generation + checkpoint advance.
+     */
+    async generate(triggerReason) {
+        const updated = await this.generateLocalPersona(triggerReason);
+        if (!updated)
+            return false;
+        const cpManager = new CheckpointManager(this.dataDir);
+        const cp = await cpManager.read();
+        await cpManager.markPersonaGenerated(cp.total_processed);
+        return true;
+    }
+}

package/vendor/tdai/core/persona/persona-trigger.js

@@ -0,0 +1,94 @@
+/**
+ * PersonaTrigger: determines whether to trigger persona generation.
+ * Implements the 5 trigger conditions from the legacy system.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { CheckpointManager } from "../../utils/checkpoint.js";
+import { stripSceneNavigation } from "../scene/scene-navigation.js";
+const TAG = "[memory-tdai] [trigger]";
+export class PersonaTrigger {
+    dataDir;
+    interval;
+    logger;
+    constructor(opts) {
+        this.dataDir = opts.dataDir;
+        this.interval = opts.interval;
+        this.logger = opts.logger;
+    }
+    async shouldGenerate() {
+        const cpManager = new CheckpointManager(this.dataDir);
+        const cp = await cpManager.read();
+        this.logger?.debug?.(`${TAG} Evaluating: total_processed=${cp.total_processed}, last_persona_at=${cp.last_persona_at}, memories_since=${cp.memories_since_last_persona}, scenes=${cp.scenes_processed}`);
+        // Priority 1: Agent explicitly requested persona update
+        if (cp.request_persona_update) {
+            const result = {
+                should: true,
+                reason: `主动请求: ${cp.persona_update_reason || "Agent 请求更新"}`,
+            };
+            this.logger?.debug?.(`${TAG} Trigger P1 (explicit request): ${result.reason}`);
+            return result;
+        }
+        // Priority 2: Cold start — first extraction done, no persona yet, has scene files
+        if (cp.scenes_processed > 0 &&
+            cp.last_persona_at === 0 &&
+            (await this.hasSceneFiles())) {
+            const result = { should: true, reason: "首次冷启动：首次提取完成且有场景文件" };
+            this.logger?.debug?.(`${TAG} Trigger P2 (cold start): scenes_processed=${cp.scenes_processed}, total_processed=${cp.total_processed}`);
+            return result;
+        }
+        // Priority 2.5: Recovery — persona was generated before but persona.md body
+        // is now empty (corrupted/missing). Regenerate to restore.
+        if (cp.last_persona_at > 0 &&
+            (await this.hasSceneFiles()) &&
+            !(await this.hasPersonaBody())) {
+            const result = { should: true, reason: "恢复：persona.md 正文丢失或为空，需要重新生成" };
+            this.logger?.debug?.(`${TAG} Trigger P2.5 (recovery): last_persona_at=${cp.last_persona_at}, persona body missing`);
+            return result;
+        }
+        // Priority 3: First scene block extraction
+        if (cp.scenes_processed === 1 && cp.memories_since_last_persona > 0) {
+            const result = { should: true, reason: "首次 Scene Block 提取完成" };
+            this.logger?.debug?.(`${TAG} Trigger P3 (first scene): scenes_processed=${cp.scenes_processed}`);
+            return result;
+        }
+        // Priority 4: Reached threshold
+        if (cp.memories_since_last_persona >= this.interval) {
+            const result = {
+                should: true,
+                reason: `达到阈值: ${cp.memories_since_last_persona} >= ${this.interval}`,
+            };
+            this.logger?.debug?.(`${TAG} Trigger P4 (threshold): ${result.reason}`);
+            return result;
+        }
+        this.logger?.debug?.(`${TAG} No trigger conditions met`);
+        return { should: false, reason: "" };
+    }
+    async hasSceneFiles() {
+        const blocksDir = path.join(this.dataDir, "scene_blocks");
+        try {
+            const files = await fs.readdir(blocksDir);
+            const hasFiles = files.some((f) => f.endsWith(".md"));
+            return hasFiles;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check whether persona.md has a non-empty body (excluding scene navigation).
+     * Returns false if the file doesn't exist, is empty, or only contains
+     * scene navigation (no actual persona content).
+     */
+    async hasPersonaBody() {
+        const personaPath = path.join(this.dataDir, "persona.md");
+        try {
+            const raw = await fs.readFile(personaPath, "utf-8");
+            const body = stripSceneNavigation(raw).trim();
+            return body.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/vendor/tdai/core/profile/profile-sync.js

@@ -0,0 +1,200 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { readSceneIndex, syncSceneIndex } from "../scene/scene-index.js";
+import { generateSceneNavigation, stripSceneNavigation } from "../scene/scene-navigation.js";
+const PROFILE_SCOPE = "global";
+/** Check if an error is a rename race condition (another concurrent pull won). */
+function isRenameRaceError(err) {
+    const code = err?.code;
+    return code === "ENOTEMPTY" || code === "EEXIST";
+}
+export function buildProfileStableId(scope, type, filename) {
+    const hash = createHash("sha256")
+        .update(`${scope}\u0000${type}\u0000${filename}`)
+        .digest("hex");
+    return `profile:v1:${hash}`;
+}
+function md5(text) {
+    return createHash("md5").update(text).digest("hex");
+}
+async function statTimes(filePath) {
+    try {
+        const stat = await fs.stat(filePath);
+        return {
+            createdAtMs: Math.floor(stat.birthtimeMs || stat.ctimeMs || Date.now()),
+            updatedAtMs: Math.floor(stat.mtimeMs || Date.now()),
+        };
+    }
+    catch {
+        const now = Date.now();
+        return { createdAtMs: now, updatedAtMs: now };
+    }
+}
+async function refreshPersonaNavigation(dataDir) {
+    const personaPath = path.join(dataDir, "persona.md");
+    let body;
+    try {
+        body = stripSceneNavigation(await fs.readFile(personaPath, "utf-8")).trim();
+    }
+    catch {
+        return;
+    }
+    if (!body)
+        return;
+    const index = await readSceneIndex(dataDir);
+    const nav = generateSceneNavigation(index);
+    const finalContent = nav ? `${body}\n\n${nav}\n` : `${body}\n`;
+    await fs.writeFile(personaPath, finalContent, "utf-8");
+}
+export async function listLocalProfiles(dataDir) {
+    const profiles = [];
+    const blocksDir = path.join(dataDir, "scene_blocks");
+    try {
+        const files = (await fs.readdir(blocksDir)).filter((file) => file.endsWith(".md")).sort();
+        for (const filename of files) {
+            const filePath = path.join(blocksDir, filename);
+            const content = await fs.readFile(filePath, "utf-8");
+            const { createdAtMs, updatedAtMs } = await statTimes(filePath);
+            profiles.push({
+                id: buildProfileStableId(PROFILE_SCOPE, "l2", filename),
+                type: "l2",
+                filename,
+                content,
+                contentMd5: md5(content),
+                version: 0,
+                createdAtMs,
+                updatedAtMs,
+            });
+        }
+    }
+    catch {
+        // ignore missing scene_blocks directory
+    }
+    const personaPath = path.join(dataDir, "persona.md");
+    try {
+        const rawPersona = await fs.readFile(personaPath, "utf-8");
+        const body = stripSceneNavigation(rawPersona).trim();
+        if (body) {
+            const { createdAtMs, updatedAtMs } = await statTimes(personaPath);
+            profiles.push({
+                id: buildProfileStableId(PROFILE_SCOPE, "l3", "persona.md"),
+                type: "l3",
+                filename: "persona.md",
+                content: body,
+                contentMd5: md5(body),
+                version: 0,
+                createdAtMs,
+                updatedAtMs,
+            });
+        }
+    }
+    catch {
+        // ignore missing persona file
+    }
+    return profiles;
+}
+export async function pullProfilesToLocal(dataDir, store, logger) {
+    if (!store.pullProfiles)
+        return new Map();
+    const records = await store.pullProfiles();
+    const baseline = new Map();
+    const tempDir = await fs.mkdtemp(path.join(dataDir, ".profiles-pull-"));
+    const tempBlocksDir = path.join(tempDir, "scene_blocks");
+    await fs.mkdir(tempBlocksDir, { recursive: true });
+    try {
+        for (const record of records) {
+            baseline.set(record.id, {
+                version: record.version,
+                contentMd5: record.contentMd5,
+                createdAtMs: record.createdAtMs,
+            });
+            if (record.type === "l2") {
+                const target = path.join(tempBlocksDir, record.filename);
+                await fs.writeFile(target, record.content, "utf-8");
+                if (md5(record.content) !== record.contentMd5) {
+                    await fs.rm(target, { force: true });
+                    logger.debug?.(`[memory-tdai][profile-sync] MD5 mismatch for ${record.filename} (will re-pull on next sync)`);
+                }
+                continue;
+            }
+            if (record.type === "l3") {
+                const body = stripSceneNavigation(record.content).trim();
+                await fs.writeFile(path.join(tempDir, "persona.md"), body, "utf-8");
+                if (md5(body) !== record.contentMd5) {
+                    await fs.rm(path.join(tempDir, "persona.md"), { force: true });
+                    logger.debug?.(`[memory-tdai][profile-sync] MD5 mismatch for ${record.filename} (will re-pull on next sync)`);
+                }
+            }
+        }
+        const localBlocksDir = path.join(dataDir, "scene_blocks");
+        await fs.rm(localBlocksDir, { recursive: true, force: true });
+        await fs.mkdir(path.dirname(localBlocksDir), { recursive: true });
+        try {
+            await fs.rename(tempBlocksDir, localBlocksDir);
+        }
+        catch (err) {
+            if (isRenameRaceError(err)) {
+                // Another concurrent pull already wrote scene_blocks — ours is redundant.
+                // Both pulls fetched the same remote snapshot, so the other result is equivalent.
+                logger.debug?.(`[memory-tdai][profile-sync] scene_blocks rename lost race (${err.code}), using existing`);
+                return baseline;
+            }
+            throw err;
+        }
+        const tempPersonaPath = path.join(tempDir, "persona.md");
+        const localPersonaPath = path.join(dataDir, "persona.md");
+        try {
+            await fs.access(tempPersonaPath);
+            await fs.rm(localPersonaPath, { force: true });
+            try {
+                await fs.rename(tempPersonaPath, localPersonaPath);
+            }
+            catch (err) {
+                if (!isRenameRaceError(err))
+                    throw err;
+                logger.debug?.(`[memory-tdai][profile-sync] persona.md rename lost race, using existing`);
+            }
+        }
+        catch (err) {
+            // No temp persona file → remove local persona (remote has none)
+            if (err.code === "ENOENT") {
+                await fs.rm(localPersonaPath, { force: true });
+            }
+            else if (!isRenameRaceError(err)) {
+                throw err;
+            }
+        }
+        await syncSceneIndex(dataDir);
+        await refreshPersonaNavigation(dataDir);
+        logger.debug?.(`[memory-tdai][profile-sync] Pulled ${records.length} profile(s) to local cache`);
+        return baseline;
+    }
+    finally {
+        await fs.rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function syncLocalProfilesToStore(dataDir, store, baselineMap, logger) {
+    const localProfiles = await listLocalProfiles(dataDir);
+    const localIds = new Set(localProfiles.map((profile) => profile.id));
+    const syncRecords = localProfiles
+        .filter((profile) => baselineMap.get(profile.id)?.contentMd5 !== profile.contentMd5 || !baselineMap.has(profile.id))
+        .map((profile) => ({
+        ...profile,
+        baselineVersion: baselineMap.get(profile.id)?.version,
+    }));
+    if (syncRecords.length > 0 && store.syncProfiles) {
+        await store.syncProfiles(syncRecords);
+        logger.info(`[memory-tdai][profile-sync] Synced ${syncRecords.length} changed profile(s)`);
+    }
+    const deletedIds = [...baselineMap.keys()].filter((id) => !localIds.has(id));
+    if (deletedIds.length > 0 && store.deleteProfiles) {
+        await store.deleteProfiles(deletedIds);
+        logger.info(`[memory-tdai][profile-sync] Deleted ${deletedIds.length} stale profile(s)`);
+    }
+}
+export async function ensureL2L3Local(dataDir, store, logger) {
+    if (!store.pullProfiles)
+        return new Map();
+    return pullProfilesToLocal(dataDir, store, logger);
+}

package/vendor/tdai/core/prompts/l1-dedup.js

@@ -0,0 +1,136 @@
+/**
+ * L1 Conflict Detection Prompt (Batch Mode)
+ *
+ * Based on Kenty's validated prototype prompt (l1_conflict_detection_prompt.md).
+ * Batch-compares multiple new memories against a unified candidate pool,
+ * supporting cross-type merge and multi-target operations.
+ */
+// ============================
+// System Prompt
+// ============================
+export const CONFLICT_DETECTION_SYSTEM_PROMPT = `你是记忆冲突检测器。批量比较多条【新记忆】与【统一候选记忆池】中的已有记忆，逐条决定如何处理。
+
+**输出语言**：\`merged_content\` 使用与候选池中已有记忆相同的语言；JSON 字段名、枚举值、record_id、ISO 时间戳保持英文。
+
+## 核心规则
+
+- **跨 type 合并**：不同 type（persona / episodic / instruction）的记忆如果语义上描述同一事实/事件，**可以合并**。
+- **多对多合并**：一条新记忆可以同时替换/合并候选池中的**多条**已有记忆（通过 target_ids 数组指定）。
+- 合并后你必须判断新记忆的最佳 type（merged_type）。
+
+## 判断逻辑
+
+1. **分辨记忆性质**：
+   - **状态类**（persona/instruction）：偏好、特质、长期设定、相对稳定的事实、行为规则
+   - **事件类**（episodic）：一次性经历、带时间点的客观记录，建议合并同一件事的前因后果
+
+2. **判断是否同一事实/事件**：主体相同、主题一致、时间接近、scene_name 相似
+
+3. **选择动作**：
+   - "store"：视为新信息，新增当前记忆。
+   - "skip"：已有记忆更好，新记忆无增量或更模糊，忽略当前记忆。
+   - "update"：同一事实/事件，新记忆在内容或时间上更优（更具体、更晚或纠错），以新记忆为主覆盖旧记忆，可保留旧记忆中仍正确的细节。
+   - "merge"：同一事实或同一演化过程，多条记忆信息互补且不矛盾，合并成一条更完整记忆，信息尽量不冗余。
+
+4. **策略倾向**：
+   - 状态类：多条描述同一偏好/特质 → 倾向 merge；无增量 → skip；明确更新 → update
+   - 事件类：同一事件的前因后果、不同阶段 → 倾向 merge 为一条完整叙述；完全相同 → skip
+   - 跨类型示例：一条 episodic "用户在 2018 年开始做播客" + 一条 persona "用户有播客制作经验" → 可 merge 为一条 persona 或 episodic（取决于信息侧重）
+
+5. **timestamp 处理**：
+   - merge / update 时，merged_timestamps 应包含**所有相关记忆的时间戳并集**（去重排序）
+   - 这样可以保留事件发生的完整时间线
+
+## 输出格式
+
+严格输出 JSON 数组，每个元素对应一条新记忆的决策。不输出任何其他内容：
+
+[
+  {
+    "record_id": "新记忆的 record_id",
+    "action": "store|update|skip|merge",
+    "target_ids": ["要删除的候选记忆 record_id 1", "record_id 2"],
+    "merged_content": "合并/更新后的记忆内容（merge/update 时必填）",
+    "merged_type": "合并后的最佳 type：persona|episodic|instruction（merge/update 时必填）",
+    "merged_priority": 85,
+    "merged_timestamps": ["合并后的时间戳数组，包含所有新旧记忆时间戳的并集（merge/update 时必填）"]
+  }
+]
+
+字段说明：
+- target_ids：要删除替换的旧记忆 ID **数组**（可以 1 条或多条）。store/skip 时省略或为空。
+- merged_content：merge/update 时的最终记忆文本。store/skip 时省略。
+- merged_type：merge/update 后记忆应归属的 type。根据合并后内容本质判断。
+- merged_priority：merge/update 后的新优先级（0-100 整数，merge/update 时必填）。合并后信息更完整、更确定，通常应**酌情提升** priority（例如两条 priority 70 的记忆合并后可提升到 80）。参考标准：80-100（核心特质/重要事件），60-79（一般偏好/普通活动），<60（次要信息）。
+- merged_timestamps：合并后的时间戳数组。收集新记忆 + 所有被合并旧记忆的时间戳，去重排序。`;
+/**
+ * Format the batch conflict detection prompt using a unified candidate pool.
+ *
+ * Format (aligned with prototype):
+ * 1. Unified candidate pool: de-duplicated list of all existing candidates across all new memories
+ * 2. Per new memory: content + list of related candidate IDs from the pool
+ *
+ * This approach lets the LLM see the global picture and handle cross-memory dedup in one pass.
+ *
+ * @param matches - Array of new memories with their candidate matches
+ */
+export function formatBatchConflictPrompt(matches) {
+    // Step 1: Build unified candidate pool (de-duplicate across all new memories)
+    const unifiedPool = new Map();
+    const perMemoryCandidateIds = new Map();
+    for (const m of matches) {
+        const candidateIds = [];
+        for (const c of m.candidates) {
+            if (!unifiedPool.has(c.id)) {
+                unifiedPool.set(c.id, c);
+            }
+            candidateIds.push(c.id);
+        }
+        perMemoryCandidateIds.set(m.newMemory.record_id, candidateIds);
+    }
+    // Step 2: Format unified pool as JSON
+    const poolList = Array.from(unifiedPool.values()).map((c) => ({
+        record_id: c.id,
+        content: c.content,
+        type: c.type,
+        priority: c.priority,
+        scene_name: c.scene_name,
+        timestamps: c.timestamps,
+    }));
+    let poolSection;
+    if (poolList.length === 0) {
+        poolSection = "## 统一候选记忆池\n\n（空，没有已有记忆，所有新记忆直接 store）";
+    }
+    else {
+        const poolStr = JSON.stringify(poolList, null, 2);
+        poolSection = `## 统一候选记忆池（共 ${poolList.length} 条已有记忆）\n\n${poolStr}`;
+    }
+    // Step 3: Format each new memory with its related candidate IDs
+    const memoryParts = matches.map((m, idx) => {
+        const relatedIds = perMemoryCandidateIds.get(m.newMemory.record_id) ?? [];
+        const relatedNote = relatedIds.length > 0
+            ? JSON.stringify(relatedIds)
+            : "[]（无相似候选，直接 store）";
+        const memStr = JSON.stringify({
+            record_id: m.newMemory.record_id,
+            content: m.newMemory.content,
+            type: m.newMemory.type,
+            priority: m.newMemory.priority,
+            scene_name: m.newMemory.scene_name,
+        }, null, 2);
+        return `### 第 ${idx + 1} 条新记忆 (record_id: ${m.newMemory.record_id})\n${memStr}\n\n【关联候选 ID】${relatedNote}`;
+    });
+    const newMemoriesText = memoryParts.join("\n\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n");
+    // Step 4: Assemble final prompt
+    return `**输出语言**：\`merged_content\` 使用与候选池中已有记忆相同的语言。
+
+${poolSection}
+
+${"═".repeat(50)}
+
+## 待判断的新记忆（共 ${matches.length} 条）
+
+${newMemoriesText}
+
+请逐条判断并输出决策 JSON 数组。当某条新记忆的候选列表为空时，该条直接输出 action=store。`;
+}