agent-loft 0.2.125 → 0.2.126

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -96,6 +96,7 @@ Logo 是白底的三向汇合:橘红、暖橙和珊瑚红三个单元,表达
96
96
  只勾联网搜索、读网页的 Claude 专家就是以前聊天模式的效果。专家改了,用它的对话下一条消息起生效;专家删了,用它的对话还能看、不能再发消息,用它的定时任务暂停。以前的聊天模式取消了:升级后聊天模式的旧对话不再保留,聊天模式的定时任务暂停,选个专家再启用。
97
97
  - **MCP**:设置 → MCP,每人管自己的:HTTP 地址(+ 请求头),或者本机进程(命令 + 参数 + 环境变量,会在服务器上直接执行命令、不受专家权限约束,所以只有管理员能添加;成员以前建的不再启动)。值可以标成密钥(网页上不回显,只交给 MCP 进程或请求头,不进提示词)。可以设「调用前询问」,不设就直接用。**共享**:勾「共享给所有账号」后,别人能在专家和内置 Agent 里选它;共享的是命令、地址和普通的环境变量 / 请求头,标成密钥的项每人在「填写我的密钥」里填自己的值,作者的不会给出去;用别人共享的 MCP 时,调用工具前一律先弹授权卡;取消共享后别人填的值一起删掉。自定义专家加载各自勾选的服务;内置专家在「设置 → Agent → 对应 Agent 卡片 → 默认加载」里选择,支持个人 MCP、管理员可选的机器 MCP,也可全部取消;不指定时管理员沿用机器配置。
98
98
  - **记忆**:像 ChatGPT 的记忆,设置 → 记忆(默认关),按用很多年设计。「关于我」加上一条条记住的事;agent 在聊天里遇到长期有用的信息会自己用 `remember` 记一条(回复里会说),事情变了用 `update_memory`,记错了用 `forget`。**分三层**:长期(身份、家人、长期偏好,一直放进系统提示,不会被后来的挤掉,也可以自己置顶)、活跃(近期的事,按最近动过的时间放进系统提示,放不下的 agent 能用 `search_memory` 搜到)、归档(过时了、到期了、满了被挤出来的,不进系统提示,不删,能搜到能恢复)。**谁能动**:你加的、你在聊天里明确要求记的、你置顶的都受保护,自动整理不能改、不能删、满了也不会被挤,agent 要改得是你在当前对话里明确要求。明显的密钥(API key、`密码是……`)agent 和整理都记不进去。**不怕改错**:删除进回收站保留 30 天;每次改动都有记录(谁、什么时候、改之前是什么),在设置里能查能撤销,改之前的旧内容也搜得到;清空和彻底删除才是真删。**自动整理**:把上次整理之后新说的话连同日期交给模型(不留会话记录的一次性调用),补充、更新、归档过时的记忆。什么时候整理每个人自己定:每天一次(默认凌晨 2 点,把当天的对话合起来一次整理,最省)/每段对话聊完后(停多久可选,改了什么会在对话里说一声)/只在点「现在整理」时/不整理;整理哪些对话也能选:全部/只整理选中专家的对话;用哪个 agent 的哪个模型也能选,默认 Claude Haiku,没有 Claude 就用 Codex 的默认模型、思考程度 low。很长的对话切成几份整理,一句不漏;整理失败的对话不会丢,留着下次再试,连着全失败就退避(最长 6 小时),同一段一直失败的先搁置,点「现在整理」时再试。**摘要**:整理时顺带给每段对话写摘要(不多一次调用),月份过去后合成一份月度摘要(一个月一次调用),agent 回答「那段时间做了什么」「那件事的经过」时用 `memory_timeline` 看,还能按项目目录筛。只有整理范围内的对话才有摘要。**参考以前的聊天**:agent 遇到「上次说的那个……」会用 `search_past_chats` 搜你以前的对话(关键词搜索,能按日期筛,只有你自己的、没被删掉的对话),要看前后文用 `read_past_chat`。搜索走 SQLite FTS5 全文索引(中文按字索引,两个字的词也能搜),几十万句也在一秒内;设置页会显示近 30 天 agent 搜了多少次、多少次没搜到。聊天记录索引不开记忆也会记(侧栏的「搜索」也用它),升级后会把已有对话收录进来一次;没开记忆时记进来的不拿去整理。删对话时它的聊天记录索引和摘要一起删,提炼出来的记忆条目留着(记着来源)。**导出和备份**:记忆能导出成 JSON、导入到别的账号或服务器,聊天记录能导出成 JSONL;整个数据库每天自动备份到 `backups/db/`(校验后压缩,留最近 7 天、4 周、12 个月,`AGENT_LOFT_BACKUP_DIR` 可以换到别的盘)。每个用户一份,Claude 和 Codex、Web 和飞书共用;改了记忆(设置里改的、后台整理的、别的对话里记的),正在跑的会话空闲下来就换上新的。只用在有主人的对话里:你的 Web 对话,以及绑定了飞书账号后和机器人的私聊;飞书群聊不用。别人(包括管理员)看不到你的记忆,管理员只能清空它;删用户时记忆一起删,不转给管理员。
99
+ - **跨实例记忆同步**。多台 agent-loft 可以在离线时分别记忆、聊天和搜索。到「设置 → 记忆 → 跨实例同步」,在选作中转的一台生成配对码,在另一台自己的账号输入中转的 HTTPS 地址和配对码。首次连接会交换双方已有的个人档案、记忆、摘要和可读取的问答正文;以后每 15 秒尝试增量同步。两台同时改同一条正文时,可在此处选用或编辑合并结果。已配对的实例持有本地副本,撤销凭据会停止它继续收发数据。
99
100
  - **定时任务**:像 ChatGPT 的 Tasks,侧栏的「定时任务」。到点把一段提示词交给 agent,结果发回对话:一次 / 每天 / 工作日 / 每周 / 每月 / 每隔几小时 / 自定义 cron,按服务端时区,两次至少隔 15 分钟。**有需要才提醒**(默认):agent 自己判断这次有没有要告诉你的事(比如「有新版本才告诉我」),没有就在回复第一行写 `[[静默]]`,推送、飞书都不发,对话里折叠成一行;没写暗号一律照常提醒。结果发到**专用对话**(任务自己的一条对话,第一次运行时新建、之后续用,可选专家和目录;可以设成不携带上下文,每次运行都换新会话,之前的结果还留在对话里,只是 agent 看不到),在专用对话右上角的「更多」里可以直接编辑任务、立即运行,或者**原来的对话**。也能直接在对话里说「每天早上 9 点帮我……」:agent 用 `create_task` / `update_task` / `delete_task` / `list_tasks` 工具管理,新建、修改、删除都会先弹授权卡让你确认(只有暂停不用;没有「总是允许」),任务自己运行的那一轮里不能再建、改、删任务。按人隔离:每人只看得到、改得了自己的任务(最多 30 个),删用户时一起删;到点再核对一次对话还是不是他的,对话被删或换了主人就暂停任务。到点对话在忙(正在回复或挂着授权)就等它,最多 30 分钟;服务停着时错过 2 小时以内的启动后补跑一次。工具和记忆一样只给有主人的对话,飞书群聊里没有。结果可以发到专用对话,也可以发到正在聊的对话(新建和编辑时都能选,也能来回切换):发到正在聊的对话时,专家和目录跟随对话,权限就是对话自己的;选「不携带上下文」时任务在独立的临时会话里运行,跑完换回聊天的会话,结果照样显示在这条对话里,下一条消息会带给 agent。
100
101
  - **技能(skills)**:设置 → 技能。技能就是 Claude Code / Codex 用的那种 SKILL.md(可以带脚本和资料),由 agent-loft 按人管理,两个 agent 都能用。**来源**:在页面上写、上传技能包(`.zip` / `.skill` / 单个 SKILL.md / 整个文件夹),或者在对话里让 agent「把刚才的做法存成技能」(agent 用 `create_skill` / `update_skill`,先弹授权卡)。**共享**:新建、编辑时选择「仅自己可见」「指定用户」或「所有人可见」,也可在自己技能的「更多 → 共享」里调整;默认仅自己可见。其他用户在「共享技能」中查看正文和附带文件、安装;安装后出现在「我的技能」,可停用、卸载或重新安装。安装的是作者的同一份技能;作者改了内容(说明、正文、附带文件、变量声明),安装的人要在技能页看过并「确认使用新版」后才会继续加载,确认前会话里没有它。作者撤回共享后,范围外用户不再可用。只有作者能编辑;管理员能查看、下架所有分享出来的技能(包括没指名给他的),但看不到别人私有的。共享不包含作者填写的变量和密钥,每人使用自己的配置。**使用**:内置专家默认使用你启用的全部技能,也可以在「设置 → Agent」中分别指定 Claude Code / Codex 加载哪些技能;自定义专家只用它选中的;agent 遇到对得上的事自己用。**变量**:技能可以声明要用的环境变量(接口地址、密钥),每个人填自己的值,只注入自己的会话;密钥再写上「只允许发往」的地址就成了**受保护的密钥**——不进环境变量,agent 看不到值,只能用 `skill_request` 工具让 agent-loft 代发请求(在请求头或地址的查询参数里写 `{{变量名}}`;不能写进请求体和地址的主机、路径,免得借允许的服务本身发出去),只走 https(局域网、本机地址才允许 http)、不跟随跳转、响应里出现的值(含 URL 编码、base64 形式)会被抹掉。发往哪些地址**按技能分别确认**:在哪个技能的变量页里填值,就只同意这个技能(和你自己建的技能)声明的地址,别人技能声明的同名密钥地址要在各自页面另外确认;作者删掉的地址立即失效,新加的要你再确认。一个值按受保护密钥填过就一直受保护:声明它的技能停用、卸载了,别的技能声明同名的普通变量也拿不到明文,要当普通变量用得重新填。`skill_request` 只认当前会话挂着的技能声明过的变量。**机器上原有的技能**(`~/.claude/skills`、`~/.agents/skills`、插件市场和 claude.ai 同步的)只给管理员:成员的会话里看不到、调不了(Claude 用技能白名单,`/技能名` 也会被拦下;Codex 关掉它自己的技能清单),管理员在「设置 → 技能 → 本机技能」里能看到。
101
102
  - **工作区面板**:会话右上角「更多 → 文件」打开或折叠,菜单中用绿色新增行数、红色删除行数显示当前分支的改动,在对话旁边(手机上全屏)看和改这条会话工作目录里的文件。「文件」页签是一棵按需展开的文件树,图片、PDF、音视频、Markdown、网页、代码直接预览,CSV / TSV 显示成表格;文本文件(1 MB 以内、UTF-8)可以编辑,Ctrl / ⌘ + S 保存,Markdown 和 CSV 能预览没保存的内容。还能新建、重命名、上传(点按钮或拖到面板上)、删除。保存时如果文件在你编辑期间被 agent 或别人改过,不会覆盖,由你选覆盖还是重新加载;没保存的内容存在本机,换会话、刷新页面都不丢。「改动」页签是 Git 仓库的已暂存 / 未暂存 / 未跟踪文件,点开看 diff,宽度够时可以切并排;顶栏的分支标记显示当前分支和改动数,点面板里的分支行能查看和切换本地、远程分支,也能新建分支。文件行上可以暂存、取消暂存、丢弃改动,写好说明提交已暂存的内容(默认不运行 Git 钩子,要用的话勾上);「历史」页签看提交记录和每个提交的 diff。推送、拉取、合并、变基请交给 agent 或终端。一轮结束、切回窗口时自动刷新。
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "agent-loft",
3
- "version": "0.2.125",
3
+ "version": "0.2.126",
4
4
  "type": "module",
5
5
  "description": "多个 agent 的工作台:把本机 Claude Code / Codex 放到一处统一管理,用飞书和 Web 页面随时驱动——会话、审批、模型切换都共用",
6
6
  "keywords": [
@@ -96,6 +96,7 @@ import {
96
96
  import { canSeeConv, pushOwnedBy, sessionVisibleTo } from "./access.js";
97
97
  import { clampLimit, dirsOf, inDir, pageOf, parseCursor, recentPageOf, searchConvs } from "./conv-pages.js";
98
98
  import { clientIp, cookies, HttpError, isHttps, readBody, readJsonBody, SECURITY_HEADERS, sendJson, setServerTiming } from "./http.js";
99
+ import { syncApi } from "./memory-sync-api.js";
99
100
  import { handleTasksApi } from "./tasks-api.js";
100
101
  import { handleLibraryApi } from "./library-api.js";
101
102
  import { attachToConversation, canSeeFile, deleteConversationFiles, getLibraryFile } from "../../core/library.js";
@@ -624,6 +625,8 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
624
625
  const p = url.pathname;
625
626
  const ip = clientIp(req);
626
627
 
628
+ if (p.startsWith("/api/memory-sync/v1/")) return syncApi(req,res,p);
629
+
627
630
  // ----- 无需登录 -----
628
631
  if (p === "/api/me" && method === "GET") {
629
632
  const user = currentUser(req);
@@ -671,6 +674,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
671
674
  const user = currentUser(req);
672
675
  if (!user) throw new HttpError(401, "请先登录");
673
676
  if (adminOnly(p) && !isAdmin(user)) throw new HttpError(403, "只有管理员能做这个操作");
677
+ if (p === "/api/account/memory/sync" || p.startsWith("/api/account/memory/sync/")) return syncApi(req,res,p,user.id);
674
678
  const admin = isAdmin(user);
675
679
  const visible = (c: Parameters<typeof canSeeConv>[1]) => canSeeConv(user, c);
676
680
 
@@ -0,0 +1,44 @@
1
+ import type { IncomingMessage, ServerResponse } from "node:http";
2
+ import { authenticate, issueInvite, join, redeem, revoke, servePull, servePush, status, syncNow } from "../../core/memory-sync.js";
3
+ import { resolveConflict, type Change } from "../../core/memory-sync-store.js";
4
+ import { hub } from "../../core/hub.js";
5
+ import { readJsonBody, sendJson, HttpError } from "./http.js";
6
+
7
+ export async function syncApi(req: IncomingMessage, res: ServerResponse, path: string, user?: string) {
8
+ try {
9
+ if (user && path === "/api/account/memory/sync" && req.method === "GET") return sendJson(res, 200, status(user));
10
+ if (req.method !== "POST") throw new HttpError(405, "需要 POST");
11
+ const action = path.split("/").pop();
12
+ if (!user) {
13
+ if (action === "pair") {
14
+ const { code, device } = await readJsonBody(req, 2048);
15
+ return sendJson(res, 200, redeem(String(code), String(device)));
16
+ }
17
+ const token = req.headers.authorization?.match(/^Bearer ([a-f0-9]{64})$/)?.[1] ?? "";
18
+ if (!authenticate(token)) throw new HttpError(401, "实例配对已失效");
19
+ const body = await readJsonBody(req, 64 * 1024 * 1024);
20
+ // A revocation while a request was uploading must take effect before committing it.
21
+ const peer = authenticate(token);
22
+ if (!peer) throw new HttpError(401, "实例配对已失效");
23
+ if (action === "push" && Array.isArray(body.changes) && body.changes.length <= 48) {
24
+ servePush(peer, body.changes as Change[]);
25
+ if (body.changes.some((c) => c.kind === "item" || c.kind === "about")) hub.memoryChanged(peer.user_id);
26
+ } else if (action === "pull" && Number.isSafeInteger(body.cursor) && Number(body.cursor) >= 0) {
27
+ return sendJson(res, 200, servePull(peer, Number(body.cursor)));
28
+ } else throw new HttpError(400, "无效的同步请求");
29
+ } else {
30
+ const b = await readJsonBody(req);
31
+ if (action === "invite") return sendJson(res, 200, issueInvite(user));
32
+ if (action === "join") await join(user, String(b.url), String(b.code));
33
+ else if (action === "revoke") revoke(user, String(b.device));
34
+ else if (action === "resolve") resolveConflict(user, String(b.gid), b.choices as string[], String(b.text));
35
+ else if (action !== "now") throw new HttpError(404, "同步操作不存在");
36
+ if (action === "now") await syncNow(user);
37
+ else void syncNow(user).catch(() => {});
38
+ }
39
+ sendJson(res, 200, { ok: true });
40
+ } catch (err) {
41
+ if (err instanceof HttpError) throw err;
42
+ throw new HttpError(400, err instanceof Error ? err.message : "同步失败");
43
+ }
44
+ }
@@ -10,6 +10,7 @@
10
10
  // 索引不在写入时维护,而是按 index_state 里的进度补(见 syncHistoryIndex):写入路径不用多一步,
11
11
  // 导入的、老版本写的也都能补上。英文词中间的片段(lowercase 写的 openclash 搜 clash)FTS 查不到,
12
12
  // 最近的一段记录再用 instr 扫一遍兜底,扫描量有上限。
13
+ import { deleteConvSummary } from "./memory-summaries.js";
13
14
  import { sql, transaction } from "./db.js";
14
15
  import { bigrams, ftsIndexText, ftsMatch, isCjk, needles, terms } from "./fts.js";
15
16
 
@@ -43,6 +44,7 @@ export type CurationLog = {
43
44
  export type Meta = {
44
45
  /** 已有对话回填过了 */
45
46
  backfilled?: boolean;
47
+ fullTextChecked?: string;
46
48
  /** 每条对话整理记忆整理到了哪个时刻(这之后的话还没整理过) */
47
49
  extracted: Record<string, number>;
48
50
  /** 「每天一次」上次跑的是哪天(本地日期 YYYY-MM-DD) */
@@ -57,25 +59,49 @@ export type Meta = {
57
59
  lastRollup?: string;
58
60
  };
59
61
 
60
- /** 一句话最多存这么多字:长篇代码、整页网页没必要全存 */
62
+ /** 旧版录入上限。只用于识别、修复以前被截短的记录。 */
61
63
  export const TEXT_MAX = 8000;
62
64
  /** 太长时头尾都留:长回复的结论通常在最后 */
63
65
  const TEXT_TAIL = 2000;
64
66
 
65
- function capText(text: string): string {
67
+ export function legacyExcerpt(text: string): string {
66
68
  if (text.length <= TEXT_MAX) return text;
67
69
  const gap = "\n…(中间省略)…\n";
68
70
  return `${text.slice(0, TEXT_MAX - TEXT_TAIL - gap.length)}${gap}${text.slice(-TEXT_TAIL)}`;
69
71
  }
70
72
 
73
+ export function incompleteExcerpt(text: string): boolean {
74
+ return text.length === TEXT_MAX && text.slice(0, -TEXT_TAIL).endsWith("\n…(中间省略)…\n");
75
+ }
76
+
77
+ /** Update the exact surviving row. A deletion or rewind during asynchronous recovery wins. */
78
+ export function recoverExcerpt(user: string, key: string, agent: string, role: string, original: string, complete: string) {
79
+ transaction(() => {
80
+ const rows = sql("SELECT id FROM history WHERE user_id=? AND conv_key=? AND agent=? AND role=? AND text=?").all(
81
+ user,
82
+ key,
83
+ agent,
84
+ role,
85
+ original,
86
+ );
87
+ if (rows.length !== 1) return;
88
+ const id = Number(rows[0]!.id);
89
+ sql("UPDATE history SET text=? WHERE id=?").run(complete, id);
90
+ if (id <= indexedUpTo()) {
91
+ sql("DELETE FROM history_fts WHERE rowid=?").run(id);
92
+ sql("INSERT INTO history_fts(rowid,text) VALUES(?,?)").run(id, ftsIndexText(complete));
93
+ }
94
+ });
95
+ }
96
+
71
97
  function checkUser(userId: string): string {
72
98
  if (!/^[A-Za-z0-9_]{1,64}$/.test(userId)) throw new Error("用户 id 不合法");
73
99
  return userId;
74
100
  }
75
101
 
76
- type Row = { id: number; conv_key: string; agent: string; role: "u" | "a"; text: string; ts: number; msg_id: string | null };
102
+ type Row = { id: number; conv_key: string; agent: string; role: "u" | "a"; text: string; ts: number; msg_id: string | null; source_order: number | null };
77
103
 
78
- const COLUMNS = "id, conv_key, agent, role, text, ts, msg_id";
104
+ const COLUMNS = "id, conv_key, agent, role, text, ts, msg_id, source_order";
79
105
 
80
106
  function toRecord(row: Row): HistoryRecord {
81
107
  return { ...(row.msg_id ? { id: row.msg_id } : {}), k: row.conv_key, a: row.agent, r: row.role, t: row.text, ts: row.ts };
@@ -83,7 +109,7 @@ function toRecord(row: Row): HistoryRecord {
83
109
 
84
110
  function insertRecords(userId: string, records: HistoryRecord[]): void {
85
111
  const insert = sql("INSERT INTO history (user_id, conv_key, agent, role, text, ts, msg_id) VALUES (?, ?, ?, ?, ?, ?, ?)");
86
- for (const r of records) insert.run(userId, r.k, r.a, r.r, capText(r.t), r.ts, r.id ?? null);
112
+ for (const r of records) insert.run(userId, r.k, r.a, r.r, r.t, r.ts, r.id ?? null);
87
113
  }
88
114
 
89
115
  export function appendRecords(userId: string, records: HistoryRecord[]): void {
@@ -109,7 +135,7 @@ export function removeHistoryRecord(userId: string, key: string, id: string): vo
109
135
  checkUser(userId);
110
136
  transaction(() => {
111
137
  sql("DELETE FROM history_fts WHERE rowid IN (SELECT id FROM history WHERE user_id = ? AND conv_key = ? AND msg_id = ?)").run(userId, key, id);
112
- sql("DELETE FROM history WHERE user_id = ? AND conv_key = ? AND msg_id = ?").run(userId, key, id);
138
+ if (sql("DELETE FROM history WHERE user_id = ? AND conv_key = ? AND msg_id = ?").run(userId, key, id).changes) deleteConvSummary(userId,key);
113
139
  });
114
140
  }
115
141
 
@@ -135,6 +161,7 @@ export function replaceConversationRecords(userId: string, key: string, records:
135
161
  checkUser(userId);
136
162
  transaction(() => {
137
163
  deleteConversationRows(userId, key);
164
+ deleteConvSummary(userId, key);
138
165
  insertRecords(userId, records);
139
166
  });
140
167
  }
@@ -191,7 +218,7 @@ export function pendingConversations(
191
218
  const meta = readMeta(userId);
192
219
  // 先只看每段对话的最后一句(走覆盖索引,不读正文),再去读真正要整理的那几段。
193
220
  // 不能把 extracted 交给库去 JOIN:json_each 没有索引,句数 × 对话数,几年后要跑几分钟还卡住主进程
194
- const convs = sql("SELECT conv_key, max(ts) AS last FROM history WHERE user_id = ? GROUP BY conv_key").all(userId) as { conv_key: string; last: number }[];
221
+ const convs = sql("SELECT conv_key, max(ts) AS last FROM history WHERE user_id = ? AND conv_key NOT LIKE 'sync/%' GROUP BY conv_key").all(userId) as { conv_key: string; last: number }[];
195
222
  const out: { key: string; records: HistoryRecord[]; last: number }[] = [];
196
223
  const rows = sql(`SELECT ${COLUMNS} FROM history WHERE user_id = ? AND conv_key = ? AND ts > ? ORDER BY id`);
197
224
  for (const { conv_key: key, last } of convs.sort((a, b) => a.last - b.last)) {
@@ -348,7 +375,7 @@ export function searchHistory(userId: string, query: string, opts: SearchOptions
348
375
  const byId = new Map<number, Row>();
349
376
  if (match) {
350
377
  // CROSS JOIN 固定先查索引:普通 JOIN 时规划器会选「扫这个人的全部记录,每行跑一次 FTS」,慢上千倍
351
- const from = `SELECT h.id, h.conv_key, h.agent, h.role, h.text, h.ts, h.msg_id FROM history_fts CROSS JOIN history h ON h.id = history_fts.rowid
378
+ const from = `SELECT h.id, h.conv_key, h.agent, h.role, h.text, h.ts, h.msg_id, h.source_order FROM history_fts CROSS JOIN history h ON h.id = history_fts.rowid
352
379
  WHERE history_fts MATCH ? AND h.user_id = ?${timeSql.replace(/ ts /g, " h.ts ")}`;
353
380
  // 边读边过滤,名额只算 skip 留下的:不然常见词的候选可能全是要跳过的对话(按专家筛选时、当前对话很长时),结果就空了
354
381
  const take = (order: string, quota: number) => {
@@ -382,14 +409,14 @@ export function searchHistory(userId: string, query: string, opts: SearchOptions
382
409
  const used = new Set<number>();
383
410
  const perConv = new Map<string, number>();
384
411
  // 配对在同一段对话里找:同时开着几段对话时,用户记录里紧挨着的下一句可能是别的对话的
385
- const next = sql(`SELECT ${COLUMNS} FROM history WHERE user_id = ? AND conv_key = ? AND id > ? ORDER BY id LIMIT 1`);
386
- const prev = sql(`SELECT ${COLUMNS} FROM history WHERE user_id = ? AND conv_key = ? AND id < ? ORDER BY id DESC LIMIT 1`);
412
+ const next = sql(`SELECT ${COLUMNS} FROM history WHERE user_id = ? AND conv_key = ? AND coalesce(source_order,id) > ? ORDER BY coalesce(source_order,id) LIMIT 1`);
413
+ const prev = sql(`SELECT ${COLUMNS} FROM history WHERE user_id = ? AND conv_key = ? AND coalesce(source_order,id) < ? ORDER BY coalesce(source_order,id) DESC LIMIT 1`);
387
414
  for (const { row, score } of scored) {
388
415
  if (out.length >= limit) break;
389
416
  if (used.has(row.id)) continue;
390
417
  if (opts.perConv && (perConv.get(row.conv_key) ?? 0) >= opts.perConv) continue;
391
418
  // 配上同一条对话里紧挨着的另一半:问配答,答配问
392
- const pair = (row.role === "u" ? next : prev).get(userId, row.conv_key, row.id) as Row | undefined;
419
+ const pair = (row.role === "u" ? next : prev).get(userId, row.conv_key, row.source_order ?? row.id) as Row | undefined;
393
420
  const partner = pair && pair.role !== row.role ? pair : undefined;
394
421
  used.add(row.id);
395
422
  if (partner) used.add(partner.id);
@@ -419,10 +446,10 @@ export function readConversationRecords(
419
446
  const total = (sql("SELECT count(*) AS n FROM history WHERE user_id = ? AND conv_key = ?").get(userId, key) as { n: number }).n;
420
447
  let offset = Math.max(0, Math.round(Number(opts.offset ?? 0)) || 0);
421
448
  if (opts.around !== undefined && Number.isFinite(opts.around)) {
422
- const before = (sql("SELECT count(*) AS n FROM history WHERE user_id = ? AND conv_key = ? AND id < ?").get(userId, key, opts.around) as { n: number }).n;
449
+ const before = (sql("SELECT count(*) AS n FROM history WHERE user_id = ? AND conv_key = ? AND coalesce(source_order,id) < (SELECT coalesce(source_order,id) FROM history WHERE user_id=? AND conv_key=? AND id=?)").get(userId, key, userId,key,opts.around) as { n: number }).n;
423
450
  offset = Math.max(0, before - Math.floor(limit / 2));
424
451
  }
425
- const rows = sql(`SELECT ${COLUMNS} FROM history WHERE user_id = ? AND conv_key = ? ORDER BY id LIMIT ? OFFSET ?`).all(userId, key, limit, offset) as Row[];
452
+ const rows = sql(`SELECT ${COLUMNS} FROM history WHERE user_id = ? AND conv_key = ? ORDER BY coalesce(source_order,id) LIMIT ? OFFSET ?`).all(userId, key, limit, offset) as Row[];
426
453
  return { rows: rows.map((r) => ({ ...toRecord(r), rowId: r.id })), total, offset };
427
454
  }
428
455
 
package/src/core/db.ts CHANGED
@@ -15,6 +15,8 @@ import path from "node:path";
15
15
  import type { DatabaseSync, StatementSync } from "node:sqlite";
16
16
  import { dataDir, readJson } from "../home.js";
17
17
 
18
+ import { syncSchema } from "./memory-sync-schema.js";
19
+
18
20
  export const dbPath = path.join(dataDir, "agent-loft.db");
19
21
 
20
22
  /**
@@ -206,6 +208,16 @@ export function database(): DatabaseSync {
206
208
  opened.exec("PRAGMA journal_mode = WAL");
207
209
  opened.exec("PRAGMA synchronous = NORMAL");
208
210
  opened.exec(SCHEMA);
211
+ const historyColumns = opened.prepare("PRAGMA table_info(history)").all();
212
+ if (!historyColumns.some(c => c.name === "source_order")) {
213
+ try {
214
+ opened.exec("ALTER TABLE history ADD COLUMN source_order INTEGER");
215
+ } catch (err) {
216
+ if (!/duplicate column/i.test(String(err))) throw err;
217
+ }
218
+ }
219
+ opened.exec("CREATE INDEX IF NOT EXISTS history_source_order ON history(user_id,conv_key,coalesce(source_order,id))");
220
+ opened.exec(syncSchema);
209
221
  // 旧库的 footers 表还没有这一列(列表里每轮改动的摘要,JSON)。老版本读写时不看它,降级也没事
210
222
  const footerColumns = opened.prepare("PRAGMA table_info(footers)").all() as { name: string }[];
211
223
  if (!footerColumns.some((c) => c.name === "changes")) {
@@ -15,9 +15,12 @@
15
15
  // 合成一份月度摘要(一个月一次调用)。存取见 memory-summaries.ts。
16
16
  //
17
17
  // 定期扫描顺带做维护:补全文索引、到期的记忆归档、清回收站、让别的会话换上 agent 刚记下的记忆。
18
+ import { sql } from "./db.js";
18
19
  import { hub } from "./hub.js";
19
20
  import {
20
21
  appendRecords,
22
+ recoverExcerpt,
23
+ legacyExcerpt,
21
24
  markExtracted,
22
25
  patchMeta,
23
26
  pendingConversations,
@@ -157,6 +160,46 @@ export async function backfill(userId: string): Promise<number> {
157
160
 
158
161
  // ---------- 整理 ----------
159
162
 
163
+ /** Only read engine sessions whose local index still contains a legacy excerpt. */
164
+ async function recoverFullText(user: string, today: string) {
165
+ const checked = readMeta(user).fullTextChecked;
166
+ if (checked === "complete" || checked === today) return;
167
+ const rows = sql(
168
+ "SELECT DISTINCT conv_key,agent FROM history WHERE user_id=? AND conv_key NOT LIKE 'sync/%' AND instr(text,'…(中间省略)…')>0",
169
+ ).all(user) as { conv_key: string; agent: string }[];
170
+ for (const { conv_key: key, agent } of rows) {
171
+ const conv = hub.conversation(key);
172
+ const driver = hub.driver(agent);
173
+ const binding = conv?.perAgent[agent];
174
+ if (!conv || conv.hidden || memoryOwnerOf(conv) !== user || !driver || !binding) continue;
175
+ const sessions = new Set([binding.sessionId, binding.parked?.sessionId, ...(binding.pastSessions ?? [])]);
176
+ try {
177
+ const candidates = new Map<string, { role: string; short: string; full: string } | null>();
178
+ for (const session of sessions) {
179
+ if (!session) continue;
180
+ const messages = await withTimeout(driver.readHistory(session, conv.cwd), 30_000);
181
+ for (const m of messages) {
182
+ if (m.role !== "user" && m.role !== "assistant") continue;
183
+ const role = m.role === "user" ? "u" : "a";
184
+ const attachmentNames = m.attachments?.map(a => a.name).join("、");
185
+ const forms = attachmentNames ? [m.text, [m.text, `(附件:${attachmentNames})`].filter(Boolean).join("\n")] : [m.text];
186
+ for (const full of forms) {
187
+ const short = legacyExcerpt(full);
188
+ if (short === full) continue;
189
+ const id = role + short;
190
+ if (!candidates.has(id)) candidates.set(id, {role, short, full});
191
+ else if (candidates.get(id)?.full !== full) candidates.set(id, null);
192
+ }
193
+ }
194
+ }
195
+ for (const c of candidates.values()) if (c) recoverExcerpt(user, key, agent, c.role, c.short, c.full);
196
+ } catch {
197
+ /* Engine unavailable; the excerpt remains readable. Retry next day. */
198
+ }
199
+ }
200
+ patchMeta(user, { fullTextChecked: rows.length ? today : "complete" });
201
+ }
202
+
160
203
  export const CURATE_SYSTEM = [
161
204
  "你在帮一个 AI 助手整理它对用户的长期记忆。会给你:用户自己写的「关于我」、已有的记忆条目(带 id 和时间),以及用户最近的一段或几段对话(每段有编号,带日期)。这份记忆要用很多年。",
162
205
  "找出这些对话里值得长期记住的、关于用户本人的信息:身份和背景、长期的偏好和习惯、长期在做的项目、用的设备和环境、做过的重要决定、明确要求以后注意的事。",
@@ -540,6 +583,12 @@ export async function curateBatch(
540
583
  let succeeded = 0;
541
584
  let failed = 0;
542
585
  let changed = false;
586
+ // A response from before a rewind/deletion must not repopulate its old summary.
587
+ const historyVersion = (p: Pending) => {
588
+ const row = sql("SELECT count(*) AS n,max(id) AS last FROM history WHERE user_id=? AND conv_key=? AND ts<=?").get(userId, p.key, p.last)!;
589
+ return `${row.n}/${row.last}`;
590
+ };
591
+ const versions = new Map(batches.flat().map(p => [p, historyVersion(p)]));
543
592
  for (const whole of batches) {
544
593
  if (streak >= STOP_AFTER) break;
545
594
  const batch = whole.filter((p) => !failedKeys.has(p.key));
@@ -564,6 +613,7 @@ export async function curateBatch(
564
613
  console.warn(`[记忆] 整理 ${userId} 的 ${batch.length} 段对话失败:`, log.error);
565
614
  continue;
566
615
  }
616
+ if (batch.some(p => versions.get(p) !== historyVersion(p))) continue;
567
617
  succeeded++;
568
618
  streak = 0;
569
619
  const result = applyProposal(userId, raw, batch.map((p) => p.key));
@@ -721,6 +771,7 @@ export function sweepOnce(opts: { now?: number } = {}): Promise<void> {
721
771
  try {
722
772
  // 回填不看记忆开关:侧栏搜索也要搜以前的聊天
723
773
  if (!readMeta(user.id).backfilled) await backfill(user.id);
774
+ await recoverFullText(user.id, localDate(now));
724
775
  maintainMemory(user.id, now);
725
776
  refreshOtherSessions(user.id);
726
777
  const memory = readMemory(user.id);
@@ -164,7 +164,8 @@ function removeRow(userId: string, s: MemorySummary): void {
164
164
  sql("DELETE FROM memory_summaries WHERE id = ? AND user_id = ?").run(s.id, userId);
165
165
  if (s.kind !== "conv") return;
166
166
  // 这段对话跨过的每个月:月度摘要都可能含有它的内容,删掉,还有别的对话的月份下次重新合成
167
- const months = sql("SELECT id FROM memory_summaries WHERE user_id = ? AND kind = 'month' AND scope >= ? AND scope <= ?").all(userId, localMonth(s.fromTs), localMonth(s.toTs)) as { id: number }[];
167
+ const origin = /^sync\/[a-f0-9]{32}\//.exec(s.scope)?.[0] ?? "";
168
+ const months = sql("SELECT id FROM memory_summaries WHERE user_id = ? AND kind = 'month' AND scope >= ? AND scope <= ?").all(userId, origin + localMonth(s.fromTs), origin + localMonth(s.toTs)) as { id: number }[];
168
169
  for (const m of months) {
169
170
  sql("DELETE FROM memory_summaries_fts WHERE rowid = ?").run(m.id);
170
171
  sql("DELETE FROM memory_summaries WHERE id = ?").run(m.id);
@@ -202,7 +203,7 @@ export function purgeSummaries(userId: string): void {
202
203
  */
203
204
  export function monthsToRollup(userId: string, now = Date.now()): string[] {
204
205
  const current = localMonth(now);
205
- const rows = sql("SELECT to_ts, updated_at FROM memory_summaries WHERE user_id = ? AND kind = 'conv'").all(userId) as { to_ts: number; updated_at: number }[];
206
+ const rows = sql("SELECT to_ts, updated_at FROM memory_summaries WHERE user_id = ? AND kind = 'conv' AND scope NOT LIKE 'sync/%'").all(userId) as { to_ts: number; updated_at: number }[];
206
207
  const newest = new Map<string, number>();
207
208
  for (const r of rows) {
208
209
  const month = localMonth(r.to_ts);
@@ -220,6 +221,6 @@ export function monthsToRollup(userId: string, now = Date.now()): string[] {
220
221
 
221
222
  /** 某个月的全部对话摘要,从早到晚 */
222
223
  export function convSummariesOfMonth(userId: string, month: string): MemorySummary[] {
223
- const rows = sql(`SELECT ${COLUMNS} FROM memory_summaries WHERE user_id = ? AND kind = 'conv' ORDER BY to_ts`).all(userId) as Row[];
224
+ const rows = sql(`SELECT ${COLUMNS} FROM memory_summaries WHERE user_id = ? AND kind = 'conv' AND scope NOT LIKE 'sync/%' ORDER BY to_ts`).all(userId) as Row[];
224
225
  return rows.map(toSummary).filter((s) => localMonth(s.toTs) === month);
225
226
  }
@@ -0,0 +1,53 @@
1
+ // Changes are captured by SQLite in the writer's transaction, including writes by stdio MCP children.
2
+ // Bodies are read when sending; an offline deletion therefore doesn't leave a body in the queue.
3
+ export const syncKinds = ["about", "item", "message", "summary"] as const;
4
+ export type SyncKind = (typeof syncKinds)[number];
5
+ export const tables = { about: "memory", item: "memory_items", message: "history", summary: "memory_summaries" } as const;
6
+ const watched = {
7
+ about: ["data"],
8
+ item: ["text", "source", "tier", "locked", "valid_until", "observed_at", "deleted_at"],
9
+ message: ["text"],
10
+ summary: ["text", "title", "project", "from_ts", "to_ts", "updated_at"],
11
+ };
12
+
13
+ function trigger(kind: SyncKind, action: "INSERT" | "UPDATE" | "DELETE") {
14
+ const row = action === "DELETE" ? "OLD" : "NEW";
15
+ const user = row + ".user_id";
16
+ const key = kind === "about" ? "'about'" : row + ".id";
17
+ const device = `(SELECT device FROM sync_account WHERE user_id=${user} AND applying=0)`;
18
+ const match = `user_id=${user} AND kind='${kind}' AND local_key=CAST(${key} AS TEXT)`;
19
+ const global = kind === "about" ? "'about'" : `${device} || ':' || lower(hex(randomblob(16)))`;
20
+ // Ignore search touches. UPDATE also seeds pre-existing rows without changing their contents.
21
+ const changed = kind === "about" ? "OLD.data IS NOT NEW.data" : watched[kind].map((c) => `OLD.${c} IS NOT NEW.${c}`).join(" OR ");
22
+ return `CREATE TRIGGER IF NOT EXISTS sync_${kind}_${action} AFTER ${action} ON ${tables[kind]}
23
+ WHEN ${device} IS NOT NULL ${action === "UPDATE" ? `AND ((${changed}) OR NOT EXISTS(SELECT 1 FROM sync_map WHERE ${match}))` : ""}
24
+ BEGIN
25
+ INSERT INTO sync_map(user_id,kind,local_key,gid) VALUES(${user},'${kind}',CAST(${key} AS TEXT),${global})
26
+ ON CONFLICT(user_id,kind,local_key) DO NOTHING;
27
+ INSERT INTO sync_dirty(user_id,gid,op) SELECT user_id,gid,lower(hex(randomblob(16))) FROM sync_map WHERE ${match}
28
+ ON CONFLICT(user_id,gid) DO UPDATE SET op=excluded.op;
29
+ ${
30
+ action === "DELETE" && kind !== "about"
31
+ ? `
32
+ UPDATE sync_dirty SET resolution=NULL WHERE user_id=${user} AND gid=(SELECT gid FROM sync_map WHERE ${match});
33
+ DELETE FROM sync_flight WHERE user_id=${user} AND gid=(SELECT gid FROM sync_map WHERE ${match});
34
+ UPDATE sync_doc SET body=NULL, conflicts='[]' WHERE user_id=${user} AND gid=(SELECT gid FROM sync_map WHERE ${match});
35
+ UPDATE sync_map SET local_key=NULL WHERE ${match};`
36
+ : ""
37
+ }
38
+ END;`;
39
+ }
40
+
41
+ export const syncSchema =
42
+ `
43
+ CREATE TABLE IF NOT EXISTS sync_account(user_id TEXT PRIMARY KEY, device TEXT NOT NULL, relay TEXT, url TEXT, token TEXT, cursor INTEGER NOT NULL DEFAULT 0,
44
+ applying INTEGER NOT NULL DEFAULT 0,last_sync INTEGER,error TEXT);
45
+ CREATE TABLE IF NOT EXISTS sync_map(user_id TEXT NOT NULL,kind TEXT NOT NULL,local_key TEXT,gid TEXT NOT NULL,PRIMARY KEY(user_id,gid),UNIQUE(user_id,kind,local_key));
46
+ CREATE TABLE IF NOT EXISTS sync_dirty(seq INTEGER PRIMARY KEY AUTOINCREMENT,user_id TEXT NOT NULL,gid TEXT NOT NULL,op TEXT NOT NULL,resolution TEXT,UNIQUE(user_id,gid));
47
+ CREATE TABLE IF NOT EXISTS sync_flight(user_id TEXT NOT NULL,gid TEXT NOT NULL,change TEXT NOT NULL,PRIMARY KEY(user_id,gid));
48
+ CREATE TABLE IF NOT EXISTS sync_doc(seq INTEGER PRIMARY KEY AUTOINCREMENT,user_id TEXT NOT NULL,gid TEXT NOT NULL,kind TEXT NOT NULL,body TEXT,revision TEXT,conflicts TEXT NOT NULL,UNIQUE(user_id,gid));
49
+ CREATE INDEX IF NOT EXISTS sync_feed ON sync_doc(user_id,seq);
50
+ CREATE TABLE IF NOT EXISTS sync_peer(user_id TEXT NOT NULL,device TEXT NOT NULL,hash TEXT UNIQUE NOT NULL,last_sync INTEGER,PRIMARY KEY(user_id,device));
51
+ CREATE TABLE IF NOT EXISTS sync_invite(user_id TEXT PRIMARY KEY,hash TEXT NOT NULL UNIQUE,expires INTEGER NOT NULL);
52
+ CREATE TABLE IF NOT EXISTS sync_receipt(user_id TEXT NOT NULL,device TEXT NOT NULL,op TEXT NOT NULL,PRIMARY KEY(user_id,device,op));
53
+ ` + syncKinds.flatMap((kind) => (["INSERT", "UPDATE", "DELETE"] as const).map((action) => trigger(kind, action))).join("\n");