// memory.js —— 会话记忆：把 Codex 会话自动浓缩成「交接摘要」，边用边存。
// 分层记忆（Phase 0）：
//   监视 ~/.codex/sessions 的 rollout-*.jsonl → 会话静默 idleSeconds 秒后自动摘要 →
//     ① 存进 SQLite（userData/memory.db，历史可检索、只增不减 = 单一真源）
//     ② 从库里【确定性聚合】出「项目核心记忆块」直接写进项目 AGENTS.md 标记段
//        —— 关键：Codex 每次新会话必注入 AGENTS.md 全文，所以事实必须钉在这里，而不是放指针
//     ③ HANDOFF.md 降级为「给人看的近期快照」；每会话摘要另 append 到 ~/.codex/memory/<hash>.md 供 grep 检索
// 摘要优先走「路由中转」里可用分组的 LLM；没配分组或调用失败则退化为本地规则提取。
// 核心块的渲染是【确定性】的（每次从库重新投影，非在上一版上叠加）→ 天然无「传话游戏」漂移。
const { app } = require("electron");
const fs = require("fs");
const path = require("path");
const os = require("os");
const crypto = require("crypto");
const initSqlJs = require("sql.js");
const sessions = require("./sessions");
const router = require("./router");

const AGENTS_START = "<!-- codex-memory:start -->";
const AGENTS_END = "<!-- codex-memory:end -->";

// —— 运行时状态 ——
let db = null;
let SQLmod = null;
let log = () => {};
let notify = () => {};
let watcher = null;
let sweepTimer = null;
let persistTimer = null;
const dirty = new Map(); // rollout 文件 → 最后一次变化的时间戳
const seenRollouts = new Set(); // 已见过的 rollout 文件（判定「新会话开始」）
const queue = [];
let working = false;
let cfg = null;

// ---------------------------------------------------------------------------
// 配置（userData/memory.json）
// ---------------------------------------------------------------------------
function cfgFile() {
  return path.join(app.getPath("userData"), "memory.json");
}
function loadCfg() {
  if (cfg) return cfg;
  let raw = {};
  try {
    raw = JSON.parse(fs.readFileSync(cfgFile(), "utf-8"));
  } catch {}
  cfg = {
    enabled: true, // 总开关
    disabledProjects: [], // 关闭写入的项目 cwd 列表（记忆库照常记录，只是不写文件）
    idleSeconds: 20, // 会话静默多少秒后视为「一段落」并摘要（另有「开新会话即刻结算上一个」触发）
    backfillDays: 7, // 启动回填：只补最近 N 天的旧会话，防止首次启动海量调用
    handoffSessions: 4, // HANDOFF.md 里保留最近几次会话
    // —— 项目核心记忆块（写进 AGENTS.md，每轮注入）的预算与容量 ——
    coreMaxLines: 55, // 核心块最多行数
    coreMaxChars: 1400, // 核心块最多字符
    coreDecisions: 12, // 核心块保留最近多少条去重决策
    coreTopics: 12, // 历史话题索引保留最近多少条
    archiveEnabled: true, // 是否把每会话摘要 append 到 ~/.codex/memory/<hash>.md 供 grep 检索
    semanticCompact: true, // 是否用 LLM 做语义去重/取代（仅在配了中转分组时生效）
    compactMinItems: 6, // 活跃条目达到多少条才值得跑一次语义整合
    ...raw,
  };
  // 兼容旧配置：老版本存的是 idleMinutes
  if (typeof raw.idleMinutes === "number" && typeof raw.idleSeconds !== "number") {
    cfg.idleSeconds = Math.max(10, Math.round(raw.idleMinutes * 60));
  }
  return cfg;
}
function saveCfg() {
  fs.writeFileSync(cfgFile(), JSON.stringify(cfg, null, 2));
}

// ---------------------------------------------------------------------------
// SQLite（sql.js：内存库 + 落盘持久化）
// ---------------------------------------------------------------------------
function dbFile() {
  return path.join(app.getPath("userData"), "memory.db");
}
async function ensureDb() {
  if (db) return db;
  if (!SQLmod) {
    const wasm = require.resolve("sql.js/dist/sql-wasm.wasm");
    SQLmod = await initSqlJs({ wasmBinary: fs.readFileSync(wasm) });
  }
  try {
    db = new SQLmod.Database(fs.readFileSync(dbFile()));
  } catch {
    db = new SQLmod.Database();
  }
  db.run(`CREATE TABLE IF NOT EXISTS sessions (
    id TEXT PRIMARY KEY,
    ts TEXT, project TEXT, cwd TEXT, topic TEXT,
    summary TEXT, decisions TEXT, next_steps TEXT, files TEXT,
    rollout_path TEXT, rollout_size INTEGER, engine TEXT, updated_at TEXT
  )`);
  // —— Phase 1：结构化核心记忆 ——
  db.run(`CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY, v TEXT)`);
  // 每个 scope（项目 cwd）一行滚动状态
  db.run(`CREATE TABLE IF NOT EXISTS core (
    scope TEXT PRIMARY KEY,
    state TEXT, next_steps TEXT, files TEXT, updated_at TEXT
  )`);
  // 决策/长期事实：一条一行。pinned=1 的长期事实（身份/偏好）永不淘汰
  db.run(`CREATE TABLE IF NOT EXISTS core_decisions (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    scope TEXT, text TEXT, norm TEXT,
    pinned INTEGER DEFAULT 0, status TEXT DEFAULT 'active',
    session_id TEXT, ts TEXT
  )`);
  return db;
}
function persistDb() {
  clearTimeout(persistTimer);
  persistTimer = setTimeout(flushDb, 500);
}
function flushDb() {
  clearTimeout(persistTimer);
  if (!db) return;
  try {
    fs.writeFileSync(dbFile(), Buffer.from(db.export()));
  } catch (e) {
    log("会话记忆：记忆库写盘失败 " + (e.message || e));
  }
}
function all(sql, params = []) {
  const rows = [];
  const st = db.prepare(sql);
  st.bind(params);
  while (st.step()) rows.push(st.getAsObject());
  st.free();
  return rows;
}
function parseArr(s) {
  try {
    const a = JSON.parse(s);
    return Array.isArray(a) ? a.map(String).filter(Boolean) : [];
  } catch {
    return [];
  }
}

// ---------------------------------------------------------------------------
// 摘要生成
// ---------------------------------------------------------------------------
function clip(s, n) {
  s = String(s || "").replace(/\s+/g, " ").trim();
  return s.length > n ? s.slice(0, n) + "…" : s;
}
// 把整段对话压缩成给 LLM 看的精简文本（控制 token：单条截断 + 总长掐头留尾）
function compressConv(conv) {
  const parts = [];
  for (const m of conv.messages) {
    if (m.role === "user") parts.push("用户: " + clip(m.text, 600));
    else if (m.role === "assistant") parts.push("助手: " + clip(m.text, 400));
  }
  let text = parts.join("\n");
  if (text.length > 16000) {
    text = text.slice(0, 6000) + "\n……（中间已省略）……\n" + text.slice(-10000);
  }
  return text;
}

const SUMMARY_PROMPT = (convText) =>
  `你是"会话交接摘要器"。下面是用户与 AI 编程助手(Codex)在某个项目里的对话记录(已压缩,可能有省略)。
请只输出一个 JSON 对象(不要代码块、不要其它文字),字段:
{
 "topic": "一句话主题,不超过30字",
 "summary": "摘要,不超过200字。只写结论与当前状态,不写过程;要让没看过对话的人能接着干活",
 "decisions": ["已确定的关键决策,每条不超过40字,没有就空数组"],
 "next_steps": ["明确的下一步待办,每条不超过40字,没有就空数组"],
 "files": ["对话中涉及的重要文件路径,最多8个"]
}
对话记录:
<<<
${convText}
>>>`;

// 调 LLM（复用路由中转的可用分组；chat / responses 两种协议都支持）
async function llmSummarize(convText) {
  const g = router.llmGroup();
  if (!g) throw new Error("未配置可用的中转分组");
  const base = g.baseUrl.replace(/\/$/, "");
  const prompt = SUMMARY_PROMPT(convText);
  const ctrl = new AbortController();
  const timer = setTimeout(() => ctrl.abort(), 90000);
  try {
    let content = "";
    const headers = {
      "content-type": "application/json",
      authorization: "Bearer " + g.key,
      "User-Agent": "codex-market",
    };
    if (g.mode === "chat") {
      let ep;
      if (/\/chat\/completions$/.test(base)) ep = base;
      else if (/\/v\d+$/.test(base)) ep = base + "/chat/completions";
      else ep = base + "/v1/chat/completions";
      const res = await fetch(ep, {
        method: "POST",
        signal: ctrl.signal,
        headers,
        body: JSON.stringify({ model: g.model, messages: [{ role: "user", content: prompt }], stream: false }),
      });
      if (!res.ok) throw new Error("HTTP " + res.status);
      const j = await res.json();
      content = (j.choices && j.choices[0] && j.choices[0].message && j.choices[0].message.content) || "";
    } else {
      const ep = /\/v\d+$/.test(base) ? base + "/responses" : base + "/v1/responses";
      const res = await fetch(ep, {
        method: "POST",
        signal: ctrl.signal,
        headers,
        body: JSON.stringify({ model: g.model, input: prompt, stream: false }),
      });
      if (!res.ok) throw new Error("HTTP " + res.status);
      const j = await res.json();
      content = j.output_text || "";
      if (!content && Array.isArray(j.output)) {
        for (const it of j.output) {
          if (it.type !== "message") continue;
          for (const c of it.content || []) if (c.type === "output_text") content += c.text || "";
        }
      }
    }
    const m = String(content).match(/\{[\s\S]*\}/);
    if (!m) throw new Error("LLM 未返回 JSON");
    const d = JSON.parse(m[0]);
    return {
      topic: clip(d.topic, 60),
      summary: String(d.summary || "").trim().slice(0, 600),
      decisions: (Array.isArray(d.decisions) ? d.decisions : []).map((x) => clip(x, 80)).filter(Boolean).slice(0, 8),
      next_steps: (Array.isArray(d.next_steps) ? d.next_steps : []).map((x) => clip(x, 80)).filter(Boolean).slice(0, 8),
      files: (Array.isArray(d.files) ? d.files : []).map(String).filter(Boolean).slice(0, 8),
      engine: "llm:" + (g.name || g.model || ""),
    };
  } finally {
    clearTimeout(timer);
  }
}

// 本地兜底：不调外部服务的规则提取（质量粗糙但可用）
function localSummarize(item, conv) {
  const users = conv.messages.filter((m) => m.role === "user");
  const asst = conv.messages.filter((m) => m.role === "assistant");
  const blob = conv.messages.map((m) => m.text).join("\n");
  const files = Array.from(
    new Set(blob.match(/[\w./~-]+\.(?:js|ts|tsx|jsx|py|json|md|toml|yml|yaml|css|html|sh|go|rs|java|sql)\b/g) || [])
  ).slice(0, 8);
  const summary = [
    "首条需求：" + clip((users[0] && users[0].text) || item.title, 200),
    asst.length ? "最后进展：" + clip(asst[asst.length - 1].text, 260) : "",
  ]
    .filter(Boolean)
    .join("\n");
  return {
    topic: clip(item.title || (users[0] && users[0].text) || "（无标题）", 60),
    summary,
    decisions: [],
    next_steps: [],
    files,
    engine: "local",
  };
}

// ---------------------------------------------------------------------------
// 摘要一条会话 → 落库 → 写 HANDOFF / AGENTS
// ---------------------------------------------------------------------------
async function summarizeFile(file) {
  const items = sessions.listConversations({ includeSubagent: false });
  const item = items.find((i) => i.path === file);
  if (!item || !item.id) return; // 子 agent 线程或读不到元信息 → 跳过
  const conv = sessions.readConversation(file);
  if (!conv.messages.some((m) => m.role === "user")) return; // 空会话不摘要
  let r;
  try {
    r = await llmSummarize(compressConv(conv));
  } catch (e) {
    log(`会话记忆：LLM 摘要失败（${e.message || e}），改用本地提取`);
    r = localSummarize(item, conv);
  }
  await ensureDb();
  db.run(
    `INSERT INTO sessions (id, ts, project, cwd, topic, summary, decisions, next_steps, files,
                           rollout_path, rollout_size, engine, updated_at)
     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)
     ON CONFLICT(id) DO UPDATE SET
       ts=excluded.ts, project=excluded.project, cwd=excluded.cwd, topic=excluded.topic,
       summary=excluded.summary, decisions=excluded.decisions, next_steps=excluded.next_steps,
       files=excluded.files, rollout_path=excluded.rollout_path, rollout_size=excluded.rollout_size,
       engine=excluded.engine, updated_at=excluded.updated_at`,
    [
      item.id,
      item.ts || "",
      item.project || "",
      item.cwd || "",
      r.topic,
      r.summary,
      JSON.stringify(r.decisions),
      JSON.stringify(r.next_steps),
      JSON.stringify(r.files),
      file,
      item.size || 0,
      r.engine,
      new Date().toISOString(),
    ]
  );
  // Phase 1：把本次摘要并入结构化 core（决策去重/淘汰、长期事实 pin、滚动状态）
  // Phase 2：有新决策进来时，跑一次 LLM 语义整合（近义合并 / 推翻作废，只输出操作，抗漂移）
  if (item.cwd) {
    try {
      const added = consolidateCore(item.cwd, item.ts, item.id, r.decisions, r.summary, r.next_steps, r.files);
      if (added > 0) await semanticCompact(item.cwd);
    } catch (e) {
      log("会话记忆：整合 core 失败 " + (e.message || e));
    }
  }
  flushDb(); // 同步落盘：真源先持久，派生文件后写，避免 CLI/下次会话读到旧数据
  if (projectWritable(item.cwd)) {
    try {
      writeProjectCore(item.cwd); // 核心块直接进 AGENTS.md（Codex 必读）
      writeHandoff(item.cwd); // 详细快照（L2）
      appendArchive(item.cwd, item, r); // grep 归档（L3，只增不删）
    } catch (e) {
      log("会话记忆：写核心/HANDOFF/归档失败 " + (e.message || e));
    }
  }
  log(`会话记忆：已更新「${r.topic}」（${item.project || item.cwd || "未知项目"}）`);
  notify();
}

// 这个项目能不能写文件（总开关 + 项目开关 + 目录合法性）
function projectWritable(cwd) {
  loadCfg();
  if (!cfg.enabled) return false;
  if (!cwd || cwd === os.homedir() || cwd === "/") return false; // 家目录/根目录不写，避免制造垃圾
  if (cfg.disabledProjects.includes(cwd)) return false;
  try {
    return fs.statSync(cwd).isDirectory();
  } catch {
    return false;
  }
}

function handoffPath(cwd) {
  return path.join(cwd, "HANDOFF.md");
}

// 原子写：先写 .tmp 再 rename，避免 Codex 启动时读到写了一半的半截文件
function writeFileAtomic(file, text) {
  const tmp = file + ".tmp";
  fs.writeFileSync(tmp, text, "utf-8");
  fs.renameSync(tmp, file);
}

// 项目 → grep 归档文件（放 ~/.codex/memory，不污染用户项目 git 树）
function hashCwd(cwd) {
  return crypto.createHash("sha1").update(String(cwd)).digest("hex").slice(0, 12);
}
function archivePath(cwd) {
  const d = path.join(os.homedir(), ".codex", "memory");
  fs.mkdirSync(d, { recursive: true });
  return path.join(d, hashCwd(cwd) + ".md");
}
// 每次会话摘要 append 到归档（只增不删，供模型 rg 检索长尾细节）
function appendArchive(cwd, item, r) {
  if (!loadCfg().archiveEnabled) return;
  const when = (item.ts || "").slice(0, 16).replace("T", " ");
  const L = [`\n## ${when} · ${r.topic}  [${item.id || ""}]`];
  if (r.summary) L.push(r.summary);
  if ((r.decisions || []).length) L.push("决策：" + r.decisions.join("；"));
  if ((r.files || []).length) L.push("文件：" + r.files.join("、"));
  try {
    fs.appendFileSync(archivePath(cwd), L.join("\n") + "\n", "utf-8");
  } catch {}
}

// 写 HANDOFF.md（L2）：详细近期快照，给人看 / 被引导时读；核心已在 AGENTS.md，关键信息不依赖本文件
function writeHandoff(cwd) {
  const rows = all(`SELECT * FROM sessions WHERE cwd = ? ORDER BY ts DESC LIMIT ?`, [cwd, loadCfg().handoffSessions]);
  if (!rows.length) return;
  const L = [];
  L.push("<!-- 本文件由「Codex 插件市场 · 会话记忆」自动生成与覆盖，请勿手动编辑 -->");
  L.push("# HANDOFF —— 会话交接快照（补充细节）");
  L.push("");
  L.push("> 核心记忆已写进本项目 `AGENTS.md`（Codex 每次会话自动读）。本文件是更详细的近期快照，供需要时参考；关键信息不依赖本文件。");
  L.push("");
  rows.forEach((r, i) => {
    const dec = parseArr(r.decisions);
    const next = parseArr(r.next_steps);
    const files = parseArr(r.files);
    const when = (r.ts || "").slice(0, 16).replace("T", " ");
    L.push(`## ${i === 0 ? "最近会话" : "更早会话"} · ${when} · ${r.topic}`);
    L.push("");
    if (r.summary) L.push(r.summary, "");
    if (dec.length) { L.push("**已确定的决策**："); dec.forEach((d) => L.push(`- ${d}`)); L.push(""); }
    if (next.length) { L.push("**下一步**："); next.forEach((d) => L.push(`- ${d}`)); L.push(""); }
    if (files.length) L.push(`**涉及文件**：${files.join("、")}`, "");
  });
  writeFileAtomic(handoffPath(cwd), L.join("\n"));
}

// 预算裁剪：首尾标记 + 检索指令行始终保留；超预算时优先砍末尾（历史话题），再砍靠后的内容
function enforceBudget(lines, maxLines, maxChars) {
  const start = lines[0];
  const end = lines[lines.length - 1];
  const retrieval = lines.find((l) => l.startsWith("> 回答涉及")) || "";
  let body = lines.slice(1, lines.length - 1).filter((l) => l !== retrieval);
  const assemble = () => [start, ...body, retrieval, end].filter(Boolean).join("\n");
  while (body.length && [start, ...body, retrieval, end].filter(Boolean).length > maxLines) body.pop();
  while (body.length && assemble().length > maxChars) body.pop();
  return assemble();
}

// —— Phase 1：结构化核心记忆的增量整合（同步、确定性 → 无漂移、无 RMW 竞态窗口）——
function normText(s) {
  return String(s || "").toLowerCase().replace(/\s+/g, "").replace(/[。，、；：,.;:!?？！「」『』（）()]/g, "");
}
// 命中即视为「长期事实」（身份 / 称呼 / 偏好 / 背景）→ pinned，永不因预算淘汰
const PINNED_RE = /(称呼|叫我|叫你|用户(是|叫|名|有|为|的身份)|我(是|叫)|偏好|以后(都|请|叫|按)|习惯|喜欢|沟通(风格|方式)?|风格|背景|经验|职业|身份|资深|专职)/;
function classifyPinned(text) {
  return PINNED_RE.test(String(text || "")) ? 1 : 0;
}
// 把一次会话摘要并入结构化 core：决策去重新增 + 超预算淘汰(归档不删) + 更新滚动状态
function consolidateCore(scope, ts, sessionId, decisions, summary, nextSteps, files) {
  loadCfg();
  const existing = all("SELECT norm FROM core_decisions WHERE scope = ? AND status='active'", [scope]).map((r) => r.norm);
  const norms = new Set(existing);
  let added = 0;
  for (const d of decisions || []) {
    const t = String(d || "").trim();
    if (!t) continue;
    const n = normText(t);
    if (!n || norms.has(n)) continue;
    norms.add(n);
    added++;
    db.run("INSERT INTO core_decisions (scope,text,norm,pinned,status,session_id,ts) VALUES (?,?,?,?,'active',?,?)", [
      scope, t, n, classifyPinned(t), sessionId || "", ts || "",
    ]);
  }
  // 淘汰：非 pinned 的 active 决策超预算 → 归档（最旧先归档；pinned 永不淘汰、仍在库可检索）
  const acts = all("SELECT id FROM core_decisions WHERE scope = ? AND status='active' AND pinned=0 ORDER BY ts DESC, id DESC", [scope]);
  if (acts.length > cfg.coreDecisions) {
    for (const d of acts.slice(cfg.coreDecisions)) db.run("UPDATE core_decisions SET status='archived' WHERE id = ?", [d.id]);
  }
  // 滚动状态（当前状态 / 下一步 / 关键文件）来自最近一次摘要
  db.run(
    `INSERT INTO core (scope,state,next_steps,files,updated_at) VALUES (?,?,?,?,?)
     ON CONFLICT(scope) DO UPDATE SET state=excluded.state, next_steps=excluded.next_steps, files=excluded.files, updated_at=excluded.updated_at`,
    [scope, clip(summary, 300), JSON.stringify((nextSteps || []).slice(0, 6)), JSON.stringify((files || []).slice(0, 8)), new Date().toISOString()]
  );
  return added;
}

// —— Phase 2：LLM 语义整合（只让 LLM 输出「操作」：哪些 id 是重复/被取代，不重写记忆文本 → 抗漂移）——
// 复用中转分组做一次 LLM 调用，返回原始文本
async function llmRaw(prompt) {
  const g = router.llmGroup();
  if (!g) throw new Error("未配置可用的中转分组");
  const base = g.baseUrl.replace(/\/$/, "");
  const ctrl = new AbortController();
  const timer = setTimeout(() => ctrl.abort(), 90000);
  const headers = { "content-type": "application/json", authorization: "Bearer " + g.key, "User-Agent": "codex-market" };
  try {
    if (g.mode === "chat") {
      let ep;
      if (/\/chat\/completions$/.test(base)) ep = base;
      else if (/\/v\d+$/.test(base)) ep = base + "/chat/completions";
      else ep = base + "/v1/chat/completions";
      const res = await fetch(ep, { method: "POST", signal: ctrl.signal, headers, body: JSON.stringify({ model: g.model, messages: [{ role: "user", content: prompt }], stream: false }) });
      if (!res.ok) throw new Error("HTTP " + res.status);
      const j = await res.json();
      return (j.choices && j.choices[0] && j.choices[0].message && j.choices[0].message.content) || "";
    }
    const ep = /\/v\d+$/.test(base) ? base + "/responses" : base + "/v1/responses";
    const res = await fetch(ep, { method: "POST", signal: ctrl.signal, headers, body: JSON.stringify({ model: g.model, input: prompt, stream: false }) });
    if (!res.ok) throw new Error("HTTP " + res.status);
    const j = await res.json();
    let content = j.output_text || "";
    if (!content && Array.isArray(j.output)) {
      for (const it of j.output) {
        if (it.type !== "message") continue;
        for (const c of it.content || []) if (c.type === "output_text") content += c.text || "";
      }
    }
    return content;
  } finally {
    clearTimeout(timer);
  }
}

const COMPACT_PROMPT = (list) =>
  `你是"记忆去重/整合器"。下面是某项目已记录的若干事实/决策条目（每条带数字 id）。请只输出一个 JSON 对象（不要代码块、不要其它文字）：
{
 "duplicates": [ { "keep": <保留的id>, "remove": [<被合并的同义id>...], "text": "<该组最简洁准确的规范表述>" } ],
 "superseded": [ { "old": <被后来推翻/过时的id>, "by": <取代它的新id> } ]
}
规则：
- 只合并【真正同义】的（如"称呼用户为小楼"与"用户身份称呼为小楼"）；拿不准就不要合并。
- superseded 只在明确"后者推翻前者"时给（如先"用 Redis"后"改用内存缓存"）；不确定不给。
- keep 选表述最清晰的那条；text 用该组最准确简洁的说法。
- 没有可合并/取代的，返回 {"duplicates":[],"superseded":[]}。
条目：
<<<
${list}
>>>`;

// 对某项目的活跃条目做语义整合：LLM 只判断关系，代码按 id 执行合并/作废（归档不删）
async function semanticCompact(scope) {
  loadCfg();
  if (!cfg.semanticCompact || !router.llmGroup()) return;
  const rows = all("SELECT id, text FROM core_decisions WHERE scope = ? AND status='active' ORDER BY id ASC", [scope]);
  if (rows.length < cfg.compactMinItems) return;
  const idSet = new Set(rows.map((r) => r.id));
  const list = rows.map((r) => `[${r.id}] ${r.text}`).join("\n");
  let ops;
  try {
    const raw = await llmRaw(COMPACT_PROMPT(list));
    const m = String(raw).match(/\{[\s\S]*\}/);
    if (!m) return;
    ops = JSON.parse(m[0]);
  } catch (e) {
    log("会话记忆：语义整合跳过（" + (e.message || e) + "）");
    return; // 任何失败 → 保持现状，不动数据
  }
  applyCompactOps(scope, ops, idSet);
}

// 执行 LLM 给的操作，严格校验 id 属于本 scope 的活跃条目，非法一律忽略
function applyCompactOps(scope, ops, idSet) {
  let changed = 0;
  const valid = (id) => Number.isInteger(id) && idSet.has(id);
  for (const g of (ops && ops.duplicates) || []) {
    if (!valid(g.keep)) continue;
    const removes = (g.remove || []).filter((id) => valid(id) && id !== g.keep);
    if (!removes.length) continue;
    if (g.text && String(g.text).trim()) {
      const t = String(g.text).trim();
      db.run("UPDATE core_decisions SET text = ?, norm = ? WHERE id = ? AND scope = ?", [t, normText(t), g.keep, scope]);
    }
    for (const id of removes) {
      db.run("UPDATE core_decisions SET status='merged' WHERE id = ? AND scope = ?", [id, scope]);
      idSet.delete(id);
      changed++;
    }
  }
  for (const s of (ops && ops.superseded) || []) {
    if (!valid(s.old) || !valid(s.by) || s.old === s.by) continue;
    db.run("UPDATE core_decisions SET status='superseded', superseded_by = ? WHERE id = ? AND scope = ?", [s.by, s.old, scope]);
    idSet.delete(s.old);
    changed++;
  }
  if (changed) {
    flushDb();
    log(`会话记忆：语义整合合并/作废 ${changed} 条`);
  }
}

// 一次性迁移：把已有 sessions 按时间正序 replay 进结构化 core（幂等，靠 meta 标记只跑一次）
function migrateCoreFromSessions() {
  let done = false;
  try {
    done = all("SELECT v FROM meta WHERE k='core_migrated'").length > 0;
  } catch {}
  if (done) return;
  const rows = all("SELECT * FROM sessions WHERE cwd != '' ORDER BY ts ASC");
  for (const r of rows) {
    consolidateCore(r.cwd, r.ts, r.id, parseArr(r.decisions), r.summary, parseArr(r.next_steps), parseArr(r.files));
  }
  db.run("INSERT OR REPLACE INTO meta (k,v) VALUES ('core_migrated','1')");
  flushDb();
}

// 【核心】从结构化 core 表渲染「项目核心记忆块」。pinned 长期事实置顶且永不被预算裁掉。
function renderProjectCore(cwd) {
  loadCfg();
  const c = all("SELECT * FROM core WHERE scope = ?", [cwd])[0];
  const pinned = all("SELECT text FROM core_decisions WHERE scope = ? AND pinned=1 AND status='active' ORDER BY id ASC", [cwd]).map((r) => r.text);
  const decs = all("SELECT text FROM core_decisions WHERE scope = ? AND pinned=0 AND status='active' ORDER BY ts DESC, id DESC LIMIT ?", [cwd, cfg.coreDecisions]).map((r) => r.text);
  const topicRows = all("SELECT ts, topic FROM sessions WHERE cwd = ? ORDER BY ts DESC LIMIT ?", [cwd, cfg.coreTopics]);
  if (!c && !pinned.length && !decs.length && !topicRows.length) return null;
  const nextSteps = c ? parseArr(c.next_steps).slice(0, 6) : [];
  const files = c ? parseArr(c.files) : [];

  const L = [];
  L.push(AGENTS_START);
  L.push("## 项目记忆（Codex 插件市场自动维护 · 回答前据此 · 勿手动编辑本段）");
  if (pinned.length) { L.push("**关于用户 / 长期事实（务必遵守）**："); pinned.forEach((d) => L.push(`- ${d}`)); }
  if (c && c.state) L.push(`**当前状态**：${clip(c.state, 300)}`);
  if (decs.length) { L.push("**已定决策**："); decs.forEach((d) => L.push(`- ${d}`)); }
  if (nextSteps.length) { L.push("**下一步**："); nextSteps.forEach((d) => L.push(`- ${d}`)); }
  if (files.length) L.push(`**关键文件**：${files.join("、")}`);
  if (topicRows.length) { L.push("**历史话题（需其中细节时用下面命令检索）**："); topicRows.forEach((r) => L.push(`- ${(r.ts || "").slice(0, 10)} ${r.topic}`)); }
  L.push(`> 回答涉及本段未列出的历史细节前，先运行 \`rg -n "关键词" ${archivePath(cwd)}\` 查证再答。`);
  L.push(AGENTS_END);

  return enforceBudget(L, cfg.coreMaxLines, cfg.coreMaxChars);
}

// 把核心记忆块写进项目 AGENTS.md：写前重读，只替换标记段，块外内容原样保留；标记残缺则放弃不硬盖
function writeProjectCore(cwd) {
  const core = renderProjectCore(cwd);
  if (!core) return;
  const f = path.join(cwd, "AGENTS.md");
  let text = "";
  try { text = fs.readFileSync(f, "utf-8"); } catch {}
  const si = text.indexOf(AGENTS_START);
  const ei = text.indexOf(AGENTS_END);
  let nt;
  if (si >= 0 && ei > si) {
    nt = text.slice(0, si) + core + text.slice(ei + AGENTS_END.length);
  } else if (si >= 0 || ei >= 0) {
    log("会话记忆：AGENTS.md 记忆标记不完整，跳过本次更新以免破坏文件");
    return;
  } else {
    nt = (text ? text.trimEnd() + "\n\n" : "") + core + "\n";
  }
  if (nt !== text) writeFileAtomic(f, nt);
}

// 新版首启：先把已有 sessions 迁移进结构化 core，再把所有已知项目 AGENTS.md 升级为核心块格式
function refreshAllCores() {
  try {
    migrateCoreFromSessions();
  } catch (e) {
    log("会话记忆：core 迁移失败 " + (e.message || e));
  }
  let cwds = [];
  try {
    cwds = all("SELECT DISTINCT cwd FROM sessions WHERE cwd != ''").map((r) => r.cwd);
  } catch {
    return;
  }
  for (const cwd of cwds) {
    if (!projectWritable(cwd)) continue;
    try {
      writeProjectCore(cwd);
      writeHandoff(cwd);
    } catch {}
  }
}

// ---------------------------------------------------------------------------
// 监视 + 队列（串行处理，避免并发打爆中转 API）
// ---------------------------------------------------------------------------
function enqueue(file) {
  if (!queue.includes(file)) queue.push(file);
  pump();
}
async function pump() {
  if (working) return;
  working = true;
  try {
    while (queue.length) {
      if (!loadCfg().enabled) {
        queue.length = 0;
        break;
      }
      const file = queue.shift();
      try {
        await summarizeFile(file);
      } catch (e) {
        log("会话记忆：摘要失败 " + (e.message || e));
      }
    }
  } finally {
    working = false;
  }
}

// 定时清点：静默超过 idleSeconds 的脏文件 → 入队摘要
function sweep() {
  const idleMs = loadCfg().idleSeconds * 1000;
  const now = Date.now();
  for (const [file, t] of dirty) {
    if (now - t >= idleMs) {
      dirty.delete(file);
      enqueue(file);
    }
  }
}
// 立刻结算「除 exceptFile 外」所有待处理会话（用于「开新会话即刻把上一个存好」）
function flushPending(exceptFile) {
  for (const [file] of dirty) {
    if (file === exceptFile) continue;
    dirty.delete(file);
    enqueue(file);
  }
}

// 启动回填：把上次运行后新增/长大的会话补摘要（限最近 N 天、单次最多 20 个）
// 一次性：对所有已知项目跑语义整合，清理迁移进来的近义冗余（meta 标记，仅首次 Phase 2 启动跑）
async function compactAllOnce() {
  loadCfg();
  if (!cfg.semanticCompact || !router.llmGroup()) return;
  let done = false;
  try {
    done = all("SELECT v FROM meta WHERE k='compact_v1'").length > 0;
  } catch {}
  if (done) return;
  const cwds = all("SELECT DISTINCT cwd FROM sessions WHERE cwd != ''").map((r) => r.cwd);
  for (const cwd of cwds) {
    try {
      await semanticCompact(cwd);
      if (projectWritable(cwd)) writeProjectCore(cwd);
    } catch {}
  }
  db.run("INSERT OR REPLACE INTO meta (k,v) VALUES ('compact_v1','1')");
  flushDb();
}

async function backfill() {
  await ensureDb();
  loadCfg();
  if (!cfg.enabled) return;
  refreshAllCores(); // 首启即把已有项目 AGENTS.md 升级为核心块格式
  compactAllOnce().catch(() => {}); // 后台一次性语义整合已有近义项
  const cutoff = Date.now() - cfg.backfillDays * 86400000;
  const known = new Map(all("SELECT rollout_path, rollout_size FROM sessions").map((r) => [r.rollout_path, r.rollout_size]));
  const items = sessions.listConversations({ includeSubagent: false });
  let queued = 0;
  let skippedOld = 0;
  for (const it of items) {
    const t = Date.parse(it.ts || "");
    if (!t || t < cutoff) {
      if (!known.has(it.path)) skippedOld++;
      continue;
    }
    if (known.get(it.path) === it.size) continue; // 没变化
    enqueue(it.path);
    if (++queued >= 20) break;
  }
  if (queued) log(`会话记忆：发现 ${queued} 个新增/有变化的会话，开始后台摘要…`);
  if (skippedOld) log(`会话记忆：${skippedOld} 个 ${cfg.backfillDays} 天前的旧会话未自动回填（可在「会话记忆」页对单条手动摘要）`);
}

function start(opts = {}) {
  if (opts.log) log = opts.log;
  if (opts.notify) notify = opts.notify;
  loadCfg();
  // 先把已存在的会话标记为「已见」，这样只有启动后【新开】的会话才触发「即刻结算上一个」
  try {
    for (const it of sessions.listConversations({ includeSubagent: true })) seenRollouts.add(it.path);
  } catch {}
  // 监视器常开（总开关只控制是否处理），这样开关切换无需重启
  try {
    fs.mkdirSync(sessions.SESSIONS_DIR, { recursive: true });
    watcher = fs.watch(sessions.SESSIONS_DIR, { recursive: true }, (_ev, name) => {
      if (!name || !/rollout-.*\.jsonl$/.test(String(name))) return;
      const full = path.join(sessions.SESSIONS_DIR, String(name));
      // 「开新会话即刻结算上一个」：首次见到某 rollout 文件 = 新会话开始 → 立刻把其它待处理的（多半是刚关掉的那个）先存好
      if (!seenRollouts.has(full)) {
        seenRollouts.add(full);
        flushPending(full);
      }
      dirty.set(full, Date.now());
    });
  } catch (e) {
    log("会话记忆：无法监视 sessions 目录 " + (e.message || e));
  }
  sweepTimer = setInterval(sweep, 5000);
  backfill().catch((e) => log("会话记忆：启动扫描失败 " + (e.message || e)));
}

function stop() {
  try {
    if (watcher) watcher.close();
  } catch {}
  watcher = null;
  clearInterval(sweepTimer);
  flushDb(); // 退出前把内存库落盘
}

// ---------------------------------------------------------------------------
// 给 UI 的接口
// ---------------------------------------------------------------------------
async function statusInfo() {
  await ensureDb();
  loadCfg();
  const g = router.llmGroup();
  const projects = all(
    `SELECT cwd, project, COUNT(*) AS n, MAX(ts) AS last FROM sessions WHERE cwd != '' GROUP BY cwd ORDER BY last DESC`
  ).map((p) => ({
    cwd: p.cwd,
    project: p.project || path.basename(p.cwd || ""),
    count: p.n,
    last: p.last,
    enabled: !cfg.disabledProjects.includes(p.cwd),
    hasHandoff: fs.existsSync(handoffPath(p.cwd)),
  }));
  return {
    enabled: cfg.enabled,
    idleSeconds: cfg.idleSeconds,
    engine: g ? `LLM 摘要（分组「${g.name}」· ${g.model}）` : "本地提取（未配置可用中转分组，质量有限）",
    total: (all("SELECT COUNT(*) AS n FROM sessions")[0] || { n: 0 }).n,
    pending: queue.length + dirty.size,
    projects,
  };
}

async function list({ project = "", q = "", limit = 200 } = {}) {
  await ensureDb();
  let sql = "SELECT * FROM sessions";
  const cond = [];
  const params = [];
  if (project) {
    cond.push("cwd = ?");
    params.push(project);
  }
  if (q) {
    cond.push("(topic LIKE ? OR summary LIKE ? OR decisions LIKE ? OR project LIKE ?)");
    const s = `%${q}%`;
    params.push(s, s, s, s);
  }
  if (cond.length) sql += " WHERE " + cond.join(" AND ");
  sql += " ORDER BY ts DESC LIMIT ?";
  params.push(limit);
  return all(sql, params).map((r) => ({
    ...r,
    decisions: parseArr(r.decisions),
    next_steps: parseArr(r.next_steps),
    files: parseArr(r.files),
  }));
}

function setEnabled(on) {
  loadCfg();
  cfg.enabled = !!on;
  saveCfg();
  if (cfg.enabled) backfill().catch(() => {});
}

function toggleProject(cwd, on) {
  loadCfg();
  const set = new Set(cfg.disabledProjects);
  if (on) set.delete(cwd);
  else set.add(cwd);
  cfg.disabledProjects = Array.from(set);
  saveCfg();
  if (on && projectWritable(cwd)) {
    try {
      writeProjectCore(cwd);
      writeHandoff(cwd);
    } catch {}
  }
}

async function resummarize(file) {
  await summarizeFile(file);
}

async function deleteRow(id) {
  await ensureDb();
  db.run("DELETE FROM sessions WHERE id = ?", [id]);
  persistDb();
  notify();
}

module.exports = {
  start,
  stop,
  statusInfo,
  list,
  setEnabled,
  toggleProject,
  resummarize,
  deleteRow,
  handoffPath,
  renderProjectCore,
  writeProjectCore,
  semanticCompact,
  applyCompactOps,
};