@restregular/dsh-memory 0.32.0 → 0.34.0
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/CHANGELOG.md +21 -0
- package/README.md +1 -1
- package/lib/client.js +211 -81
- package/lib/inject/apply.js +1 -1
- package/lib/inject/digest.js +2 -2
- package/lib/inject/inject.js +1 -1
- package/lib/inject/policy.js +3 -1
- package/lib/panel.js +133 -10
- package/lib/provider/apply.js +68 -0
- package/lib/tools/index.js +1 -1
- package/package.json +1 -1
package/CHANGELOG.md
CHANGED
|
@@ -2,6 +2,27 @@
|
|
|
2
2
|
|
|
3
3
|
本项目的版本记录。安装 id 与 npm 版本一一对应。
|
|
4
4
|
|
|
5
|
+
## 0.34.0 — 让 Agent 真的会主动屏蔽:把 memory_block 写进常驻策略段与注入头部
|
|
6
|
+
|
|
7
|
+
- **问题**:0.32.0 就做出了 `memory_block`,工具、存储、审批矩阵、`blockFilter` 全链路都在,但**模型从来不用它**。实测现象是「明明有一堆与当前项目无关的记忆(别的项目、别的插件的发布流程与踩坑)反复被注入,Agent 一直忍着」。原因不在功能而在**可发现性**:模型每轮唯一必读的记忆文本是 `POLICY_TEXT`(常驻 `## 记忆系统` 段)加摘要 / 召回的头部,这三处**一处都没提过 `memory_block`** —— 策略段列了 `memory_search / memory_list / memory_get / memory_save / memory_forget / memory_scopes` 六个工具,唯独漏掉屏蔽;摘要头部和召回头部还都写着「删除用 memory_forget」,等于把唯一的降噪动作指到了**删除**上。工具自己的 `description` 写得再全也没用:不先调用它就看不到。
|
|
8
|
+
- **策略段补上工具与判断口径**:工具清单加入 `memory_block`;新增一段「记忆里出现与本次任务无关的条目时,主动降噪而不是忍着」,给出可执行的四条口径 —— ①一条记录连续两轮以上出现在注入里却对当前任务没用 → 按 `id` 屏蔽(会话级、不审批、不删数据、`action="unblock"` 可复原);②只有整个作用域确实与本工作区无关时才按 `scope` 屏蔽(会弹审批、影响面大);③不确定是否无关就先别屏蔽,**屏蔽是降噪不是清理**;④不要用 `memory_forget` 删别人的记忆。
|
|
9
|
+
- **摘要头部改口径**:`renderDigest` 的 HEADER 从「删除用 memory_forget」改为「无关条目用 memory_block 屏蔽,过时/写错的才用 memory_forget 删除」;标签索引的 HINT_FOOTER 同样补一句「与本轮无关的用 memory_block 屏蔽」。
|
|
10
|
+
- **召回头部改口径**:`renderRecallBlock` 的头部不再教「用 memory_forget 删除」,改为「与本轮无关的用 memory_block 屏蔽,可逆、不删数据」。
|
|
11
|
+
- **`memory_block` 计入记忆工具集**:`MEMORY_TOOL_NAMES` 补上 `memory_block`。它此前被当成普通工具,两个后果:①屏蔽调用不留轨迹锚点,审计里查不到「这次为什么突然安静了」;②`reason` / `description` 里一旦出现被监控的标签词(例如「与 release 流程无关」),会**反过来触发一次高风险召回** —— 降噪动作把噪声又拉回来。
|
|
12
|
+
- **工具描述同步**:`memory_block` 的 description 明确写出「**主动使用**:召回 / 摘要反复注入明显属于别的项目或技术栈的记录时,按记录 id 屏蔽而不是忍着或删掉」。
|
|
13
|
+
- 测试:新增 `source/memory-inject/test/policy.test.ts`(3 例:策略段必须含 `memory_block` / 无关 / 不删除 / unblock / 弹审批代价,摘要头部与召回头部各自的口径),`apply-audit.test.ts` 新增「memory_block 也被当成记忆工具:留轨迹锚点、不因参数里的标签触发高风险召回」。全套 583 tests / 582 pass / 1 skipped。
|
|
14
|
+
|
|
15
|
+
## 0.33.0 — 屏蔽不再在总面板折叠;会话面板拆成「记录 / 审计」两页
|
|
16
|
+
|
|
17
|
+
- **问题(0.32.0 的一处设计错位)**:屏蔽按**会话 / 工作区**生效,但总面板(侧栏 / 设置)没有 agent —— 服务端一直调 `scopeCatalog(undefined)`,只能拿到兜底项目键那一层。于是「显示已屏蔽」开关几乎永远无效:**会话级屏蔽在总面板里根本不存在**(它连自己的会话 id 都没有),工作区级屏蔽也只在兜底项目键恰好等于真实工作区时才冒出来。更糟的是它会把用户**本来想看的记录藏起来**,而开关上看不出这是"判不准"还是"真的没有"。
|
|
18
|
+
- **总面板改为老实列全部**:移除 `showBlocked` 状态、工具栏的「显示已屏蔽 N」、作用域行上的「已屏蔽 · 工作区级 / 会话级」徽标、每行的「解除屏蔽」按钮,以及 `unblockScope()`。`/status` 与 `/records` 也不再传 `blocked` / `blockedLevel` —— 与其给一份"半真"的状态,不如不给。**归档照旧**(它不依赖会话,总面板判得准):默认折叠、「显示已归档 N」、徽标、「解除归档」全部保留。
|
|
19
|
+
- **会话面板的「记忆」页拆成两个标签页**(`conversation.view`,id 仍是 `memory`):**记录**(在左,默认打开)与本会话的**审计**。日常真正要看的是"我这个会话记了什么",所以记录在前;审计保持原样(真实空状态,不补造数据)。
|
|
20
|
+
- **「记录」页只列这个会话权限范围内的记忆**:新增 `GET /memory/api/session-records?session=<id>`,带着真实会话 id 走 `resolveReadScopes(agentLike)` 解析可见域(会话 + 项目 + global + 工作区绑定,显式「记忆范围」优先),归档作用域不列,记录按更新时间倒序。返回 `{ session, workspace, scopes, records, blockedCount }`。
|
|
21
|
+
- **屏蔽感知搬到这里**:`listBlocks(agentLike)` 一次算出该会话**生效**的屏蔽(会话链含父会话 + 工作区级),同一目标以工作区级为准,记录级按 `recordId` / 前缀匹配。默认折叠被屏蔽的记录并给出「显示已屏蔽 N」,勾上才列出来,卡片带「已屏蔽 · 工作区级 / 会话级」徽标与「解除屏蔽」。每条记录还带上**屏蔽自己的 id**(`blockedId`),解除时按 id 精确删那一条,不会顺手带走别的屏蔽。
|
|
22
|
+
- **修掉一处会让功能整体失效的漏转发**:面板通过 `ctx.get('memory')` 拿到的是 `CordisMemoryService` 包装实例,而 0.32.0 的归档 / 屏蔽方法只加在 `LocalMemoryService` 上、**包装层没转发**。真实 profile 里 `memory.listBlocks` / `unblock` / `archiveScope` 全是 `undefined`,面板的「解除归档 / 解除屏蔽」点了没反应,`/status` 的 `blocked` 字段永远是空 —— 而单测直接 `new LocalMemoryService`,所以完全看不见。现在 `archiveScope` / `restoreScope` / `archivedProjectScopes` / `blocksFor` / `listBlocks` / `sessionBlocks` / `workspaceBlocks` / `isScopeBlocked` / `isRecordBlocked` / `unblock` / `clearBlocks` / `requestBlock` 全部显式转发,并在 `service-delegation.test.ts` 里锁死。
|
|
23
|
+
- **记录卡新增可选 `onUnblock`**:只有会话面板的「记录」页传,主面板不传 —— 「解除屏蔽」从此只会出现在算得准层级的地方。
|
|
24
|
+
- 测试:`archive-blocks-api.test.ts` 改为锁新口径(`/status` 不再带 `blocked`、`/session-records` 默认折叠 + 计数 + `blocked=1` 列出 + `blockedId` + 解除后回到列表),新增「会话记忆视图:记录 / 审计 两个标签页,记录在左且默认打开」与「记录页:显示已屏蔽 才列出屏蔽项,解除走 `/blocks` restore」两例,`service-delegation.test.ts` 加一例锁转发,`记忆视图用 composer overlay 占满高度` 加一条 `.mem-recs-scroll` 滚动契约。全套 579 tests / 578 pass / 1 skipped。
|
|
25
|
+
|
|
5
26
|
## 0.32.0 — 作用域归档(会话 / 项目)+ Agent 主动屏蔽(会话级 / 工作区级)
|
|
6
27
|
|
|
7
28
|
- **两件不同的事,两个不同的机制**:**归档**是生命周期事实(会话被归档、工作区被从侧边栏移除),没有审批通道,恢复时自动复原;**屏蔽**是 Agent 主动降噪(「这条与本轮任务无关,别再出现」),可以随时解除。两者都不删除数据,都不改读写权限,但在检索、注入、目录里效果一样:**看不见**。代码里也刻意分成两套 deny reason(`SCOPE_ARCHIVED` / `SCOPE_BLOCKED`),因为它们该给用户的解释完全不同。
|
package/README.md
CHANGED
|
@@ -50,7 +50,7 @@ JSONL 落盘 · 本机向量检索 · 七个模型工具 · 自动召回 · 硬
|
|
|
50
50
|
| **记忆权限** | 输入框旁的「记忆权限」按钮设置本会话可读的作用域 + 限制等级(绝对 / 普通 / 无限制);每个作用域一行就是一条设置:**勾选**表示本会话可访问,行内**【绑定】/【可读】/【可写】**控制工作区默认可见与读写权限——**【绑定】点一下立即保存**(0.25.13 起),绑定到当前工作区后新会话默认可见,可读 / 可写独立影响工具读写;Agent 通过 `memory_scopes request` 申请到的范围外授权**也用勾选呈现**(名称右边挂一个「AI」气泡,样式与你自己勾选的行区分开),取消勾选只是草稿,**点「保存」才真正撤销**(0.25.4 起),且按钮数字 / 「已选」都把 AI 授权算进去(0.25.5 起)并**实时轮询**——浮窗关着,Agent 刚拿到的授权也会让按钮数字自己变(0.25.6 起);**整张作用域卡片都能点选**,点名称 / 计数 / 留白等同点勾选框(0.25.7 起),本会话那一行直接叫「**session:当前会话**」(0.25.8 起,0.25.10 起带类型前缀);**所有作用域名都以 `global:` / `project:` / `session:` / `custom:` 开头**(0.25.10 起);浮窗挂在页面根层,不会被输入框上方的浮动按钮盖住(0.25.8 起);Agent 及其子 Agent 都按它检索、注入与 `memory_get` |
|
|
51
51
|
| **修正版编辑** | 面板里编辑一条记忆 = 新建一条修正版并通过 `supersedes` 指向旧记录,旧记录不原地修改;记录页「是否被修正」筛选默认隐藏旧版本,可切到全部 / 只看已修正 |
|
|
52
52
|
| **归档(0.32.0)** | **会话作用域**随会话归档冻结(0.30.0);**项目作用域**绑定工作区路径,归档记录持久化在 `archive/project.json`。工作区从侧边栏移除 → 归档条目转 `dormant`(记忆保留、不参与检索);重新加入 → **自动解除归档**(实时读宿主 `workspaceRegistry`,5 秒节流对账)。`global` / 自定义作用域**拒绝归档**(`SCOPE_NOT_ARCHIVABLE`)。归档不是权限:没有审批通道、`requestable=false`,面板可手动「解除归档」 |
|
|
53
|
-
| **屏蔽(0.32.0)** | Agent 用 `memory_block` 主动降噪:被屏蔽的作用域 / 记录不再出现在检索、注入、规则段、过程段与目录里,**数据一字不改**,`unblock` 立刻复原。存储 `blocks/session/<id>.json` / `blocks/workspace/<sha1>.json`。**审批矩阵**:按作用域屏蔽 → 弹审批;工作区级 → 弹审批;目标是硬性规则(`kind='rule'`)→ **一律弹审批,即使按 id**;只有「会话级 + 按记录 id/前缀 + 不是规则」静默生效。被屏蔽的作用域**拒绝 Agent 写入**(`SCOPE_BLOCKED
|
|
53
|
+
| **屏蔽(0.32.0)** | Agent 用 `memory_block` 主动降噪:被屏蔽的作用域 / 记录不再出现在检索、注入、规则段、过程段与目录里,**数据一字不改**,`unblock` 立刻复原。存储 `blocks/session/<id>.json` / `blocks/workspace/<sha1>.json`。**审批矩阵**:按作用域屏蔽 → 弹审批;工作区级 → 弹审批;目标是硬性规则(`kind='rule'`)→ **一律弹审批,即使按 id**;只有「会话级 + 按记录 id/前缀 + 不是规则」静默生效。被屏蔽的作用域**拒绝 Agent 写入**(`SCOPE_BLOCKED`),避免写进去自己看不见。**0.34.0 起它真的会被用起来**:常驻策略段、摘要头部、召回头部都点名 `memory_block` 并给出「无关条目就屏蔽,屏蔽是降噪不是清理」的口径(此前三处只提 `memory_forget`,等于把降噪指到了删除上) |
|
|
54
54
|
| **范围外审批** | 普通限制下,`memory_search` 撞到可见域外的记忆**默认只返回作用域清单**(名字 / 条数 / 用途,不含任何条目内容与摘要,0.28.0 起),不自动弹审批;Agent 确认某个作用域的用途确实相关后,带 `requestApproval=true` 重发查询才会发起审批。另一条路是 `memory_scopes request`(申请整个作用域的本会话权限)。发起后,审批卡在**对应会话的输入框上方**出现(样式与系统权限审批一致):展示工具、Agent 说明、查询关键词与范围外记忆摘要,支持逐条勾选 / 全选 / 取消全选(「允许选中的 N 条」或整单「允许一次」)或「拒绝」;点记忆 ID 直接跳到面板「记录」页并展开该条。**0.25.14 起**审批等待期间还会像系统审批 / ask 工具一样,在该会话的侧边栏行显示黄色圆点与「待审批」(含后台会话;回答或超时后撤销),其它插件也能从宿主 `uiSession.sessionStatus` 读到这条阻塞 |
|
|
55
55
|
| **上下文去重** | `memory_search` / `memory_list` 返回过的条目记进会话上下文状态;同一版本再次命中只回记忆 ID(`memory_search` 的裸 ID 与带摘要条目之间空一行),并提示用 `memory_get` 取全文(内容更新后重新给摘要) |
|
|
56
56
|
| **状态记忆** | `kind: state` 默认 7 天 TTL;注入带「状态,使用前验证」;过期后默认不进检索 / 摘要 / 召回,但 `memory_get` 与面板仍可取 |
|
package/lib/client.js
CHANGED
|
@@ -547,6 +547,15 @@ window.__ModuleLoader__.load({
|
|
|
547
547
|
'.mem-view .audit{height:100%;max-height:none;min-height:0;flex:1;overflow:hidden}',
|
|
548
548
|
'.mem-view .audit-split{min-height:0}',
|
|
549
549
|
'.mem-view .audit-detail{max-height:100%}',
|
|
550
|
+
// 会话视图的「记录」页(0.33.0):作用域一览 + 记录列表,滚动只发生在列表里。
|
|
551
|
+
'.mem-recs{display:flex;flex-direction:column;gap:8px;min-height:0;height:100%;overflow:hidden}',
|
|
552
|
+
'.mem-recs-toolbar{display:flex;align-items:center;gap:8px;flex-wrap:wrap;flex:none}',
|
|
553
|
+
'.mem-recs-toolbar .muted{font-size:11.5px;color:var(--dsw-alias-label-secondary)}',
|
|
554
|
+
'.mem-recs-toolbar .spacer{flex:1}',
|
|
555
|
+
'.mem-recs-scopes{display:flex;gap:5px;flex-wrap:wrap;flex:none;max-height:60px;overflow-y:auto}',
|
|
556
|
+
'.mem-recs-scopes .badge.blocked{opacity:.72;text-decoration:line-through}',
|
|
557
|
+
'.mem-recs-scroll{flex:1;min-height:0;overflow-y:auto;overscroll-behavior:contain;padding:2px 8px 2px 2px;margin-right:-2px}',
|
|
558
|
+
'.mem-recs-scroll.is-empty{overflow:visible}',
|
|
550
559
|
// 轨迹详情面板的「记忆审计」页签。Trajectory 没有行级/页签级 slot,所以
|
|
551
560
|
// 按钮和面板都放在 shell.overlay 里用 fixed 定位贴着详情面板;不在 React
|
|
552
561
|
// 管理的 tabs 行里插 DOM,避免被轨迹的重渲染清掉。
|
|
@@ -1335,7 +1344,14 @@ window.__ModuleLoader__.load({
|
|
|
1335
1344
|
})
|
|
1336
1345
|
}
|
|
1337
1346
|
|
|
1338
|
-
|
|
1347
|
+
/**
|
|
1348
|
+
* 一条记忆卡。
|
|
1349
|
+
*
|
|
1350
|
+
* `onUnblock` 只在会话面板的「记录」页传:屏蔽按会话 / 工作区生效,只有那里
|
|
1351
|
+
* 拿得到真实会话 id,也只有那里该给「解除屏蔽」的入口(主面板一律列全部,
|
|
1352
|
+
* 不判断、不展示屏蔽状态)。
|
|
1353
|
+
*/
|
|
1354
|
+
function RecordCard({ rec, vectorOn, labels, onSaved, onDeleted, focus = false, score = null, onUnblock = null }) {
|
|
1339
1355
|
// collapsed by default: the list stays scannable, full text on demand
|
|
1340
1356
|
const [expanded, setExpanded] = React.useState(false)
|
|
1341
1357
|
const [editing, setEditing] = React.useState(false)
|
|
@@ -1451,6 +1467,16 @@ window.__ModuleLoader__.load({
|
|
|
1451
1467
|
: null,
|
|
1452
1468
|
// 只在"待嵌入"时提示:已嵌入是常态,向量没启用时这条也没有行动价值。
|
|
1453
1469
|
!rec.embedded && vectorOn ? h('span', { className: 'pending', title: '待嵌入:向量服务就绪后会自动补上' }, '待嵌入') : null,
|
|
1470
|
+
// 被 Agent 屏蔽的记录:只有会话面板的「记录」页会标出来(它带着会话 id,
|
|
1471
|
+
// 算得准会话级 / 工作区级)。屏蔽不是删除,解除后立刻回到检索与注入里。
|
|
1472
|
+
rec.blocked
|
|
1473
|
+
? h('span', {
|
|
1474
|
+
className: 'badge',
|
|
1475
|
+
title: rec.blockedLevel === 'workspace'
|
|
1476
|
+
? '工作区级屏蔽:这个工作区的所有会话都不会检索 / 注入它;解除后立刻复原'
|
|
1477
|
+
: '会话级屏蔽:只有本会话不会检索 / 注入它;解除后立刻复原',
|
|
1478
|
+
}, rec.blockedLevel === 'workspace' ? '已屏蔽 · 工作区级' : '已屏蔽 · 会话级')
|
|
1479
|
+
: null,
|
|
1454
1480
|
h('span', { className: 'time', title: `更新于 ${fmtTime(rec.updatedAt)}` }, fmtTime(rec.updatedAt)),
|
|
1455
1481
|
),
|
|
1456
1482
|
!open ? h('div', { className: 'preview' }, rec.content) : null,
|
|
@@ -1513,6 +1539,18 @@ window.__ModuleLoader__.load({
|
|
|
1513
1539
|
open && !editing
|
|
1514
1540
|
? h('div', { className: 'acts' },
|
|
1515
1541
|
h('button', { onClick: () => setEditing(true) }, '编辑'),
|
|
1542
|
+
// 解除屏蔽只在会话面板的「记录」页出现(见组件注释)。
|
|
1543
|
+
typeof onUnblock === 'function' && rec.blocked
|
|
1544
|
+
? h('button', {
|
|
1545
|
+
className: 'linkbtn',
|
|
1546
|
+
disabled: busy,
|
|
1547
|
+
title: '解除屏蔽:这条记忆立刻重新参与检索与注入(正文一字不改)',
|
|
1548
|
+
onClick: async () => {
|
|
1549
|
+
setBusy(true); setError('')
|
|
1550
|
+
try { await onUnblock(rec) } catch (e) { setError(String(e.message || e)) } finally { setBusy(false) }
|
|
1551
|
+
},
|
|
1552
|
+
}, '解除屏蔽')
|
|
1553
|
+
: null,
|
|
1516
1554
|
h('button', { disabled: busy, onClick: del }, busy ? '…' : '删除'),
|
|
1517
1555
|
)
|
|
1518
1556
|
: null,
|
|
@@ -2616,7 +2654,7 @@ window.__ModuleLoader__.load({
|
|
|
2616
2654
|
},
|
|
2617
2655
|
{
|
|
2618
2656
|
key: 'policy', title: '记忆使用策略',
|
|
2619
|
-
desc: '
|
|
2657
|
+
desc: '系统提示常驻段:什么时候该查记忆、查到后怎么用、查不到怎么办、无关记忆什么时候该屏蔽。',
|
|
2620
2658
|
fields: [
|
|
2621
2659
|
{ k: 'enabled', label: '启用', type: 'bool', hint: '关闭只移除这段提示,不影响记忆检索。' },
|
|
2622
2660
|
],
|
|
@@ -4105,10 +4143,14 @@ window.__ModuleLoader__.load({
|
|
|
4105
4143
|
// 两个视图共用 /status 的那次拉取,切换不重新请求。
|
|
4106
4144
|
const [dataView, setDataView] = React.useState('memories')
|
|
4107
4145
|
const [scopeQuery, setScopeQuery] = React.useState('')
|
|
4108
|
-
// 0.32.0
|
|
4109
|
-
// 但用户要能一眼看到"有几个被藏起来了"
|
|
4146
|
+
// 0.32.0:归档的作用域默认**折叠**(它们不该混在日常作用域清单里),
|
|
4147
|
+
// 但用户要能一眼看到"有几个被藏起来了",所以工具栏给一个计数开关。
|
|
4148
|
+
//
|
|
4149
|
+
// 0.33.0:屏蔽**不折叠、也不显示**。屏蔽按会话 / 工作区生效,而这个总面板
|
|
4150
|
+
// 没有 agent(服务端 `scopeCatalog(undefined)` 只反映兜底项目键那一层),
|
|
4151
|
+
// 在这里判断"是否被屏蔽"既漏会话级屏蔽、又会把用户本想看的记录藏起来。
|
|
4152
|
+
// 总面板就老实列全部;屏蔽的展示与解除都在会话面板的「记录」页。
|
|
4110
4153
|
const [showArchived, setShowArchived] = React.useState(false)
|
|
4111
|
-
const [showBlocked, setShowBlocked] = React.useState(false)
|
|
4112
4154
|
// 作用域编辑(0.29.0):同一时间只编辑一行 —— 描述 / 别名都是全局共享的元数据,
|
|
4113
4155
|
// 同时开多个编辑框只会让人不确定保存的是哪一条。
|
|
4114
4156
|
const [editingScope, setEditingScope] = React.useState('')
|
|
@@ -4142,17 +4184,16 @@ window.__ModuleLoader__.load({
|
|
|
4142
4184
|
const qq = query !== undefined ? query : q
|
|
4143
4185
|
const ss = scopeF !== undefined ? scopeF : scopeFilter
|
|
4144
4186
|
const sem = semanticF !== undefined ? semanticF : semantic
|
|
4145
|
-
// 0.32.0
|
|
4187
|
+
// 0.32.0:归档开关可以在同一次点击里翻转,此时 state 还没更新,
|
|
4146
4188
|
// 所以允许调用方把新值显式传进来(extraF)。
|
|
4147
4189
|
const withArchived = extraF?.archived !== undefined ? extraF.archived : showArchived
|
|
4148
|
-
const withBlocked = extraF?.blocked !== undefined ? extraF.blocked : showBlocked
|
|
4149
4190
|
// 空查询在语义模式下没有意义(embedding 空串),直接列全部记录。
|
|
4150
4191
|
const semanticSearch = sem && qq.trim() !== ''
|
|
4151
4192
|
if (ss) params.set('scope', ss)
|
|
4152
4193
|
if (qq.trim()) params.set('q', qq.trim())
|
|
4153
|
-
// 0.32.0
|
|
4194
|
+
// 0.32.0:归档默认不出现在列表里,开关显式请求时才带上。
|
|
4195
|
+
// 屏蔽没有开关:总面板一律列全部(屏蔽感知在会话面板的「记录」页)。
|
|
4154
4196
|
if (withArchived) params.set('archived', '1')
|
|
4155
|
-
if (withBlocked) params.set('blocked', '1')
|
|
4156
4197
|
const suffix = params.toString() ? `?${params}` : ''
|
|
4157
4198
|
const [listVal, status] = await Promise.all([
|
|
4158
4199
|
api(`${semanticSearch ? 'search' : 'records'}${suffix}`),
|
|
@@ -4241,11 +4282,14 @@ window.__ModuleLoader__.load({
|
|
|
4241
4282
|
}
|
|
4242
4283
|
}
|
|
4243
4284
|
/**
|
|
4244
|
-
*
|
|
4285
|
+
* 解除归档(0.32.0)。
|
|
4286
|
+
*
|
|
4287
|
+
* 不是删除:解除后这个作用域的记忆**立刻**回到检索与注入里,正文一字不改。
|
|
4288
|
+
* 归档是生命周期事实(工作区被移除 / 会话被归档)—— 面板只负责把「谁藏了它」
|
|
4289
|
+
* 如实展示,并给一个一键复原的入口。
|
|
4245
4290
|
*
|
|
4246
|
-
*
|
|
4247
|
-
*
|
|
4248
|
-
* 面板只负责把「谁藏了它」如实展示,并给一个一键复原的入口。
|
|
4291
|
+
* 屏蔽(0.33.0)不在这个面板里:屏蔽按会话 / 工作区生效,总面板没有 agent,
|
|
4292
|
+
* 展示与解除都挪到了会话面板的「记录」页(那里带着真实会话 id)。
|
|
4249
4293
|
*/
|
|
4250
4294
|
const restoreArchivedScope = async (scope) => {
|
|
4251
4295
|
setScopeBusy(true); setScopeError(''); setScopeSaved('')
|
|
@@ -4259,28 +4303,6 @@ window.__ModuleLoader__.load({
|
|
|
4259
4303
|
setScopeBusy(false)
|
|
4260
4304
|
}
|
|
4261
4305
|
}
|
|
4262
|
-
const unblockScope = async (row) => {
|
|
4263
|
-
setScopeBusy(true); setScopeError(''); setScopeSaved('')
|
|
4264
|
-
try {
|
|
4265
|
-
// 层级取自 provider 算出来的真实层级;key 明确告诉 provider 是哪一层的那一份
|
|
4266
|
-
//(会话级 = 会话 id,工作区级 = project:<路径>),面板不靠 agent 反推。
|
|
4267
|
-
const sessionId = currentSessionId() ?? ''
|
|
4268
|
-
const workspace = row.scope.startsWith('project:') ? row.scope : ''
|
|
4269
|
-
await api('blocks', {
|
|
4270
|
-
level: row.blockedLevel === 'workspace' ? 'workspace' : 'session',
|
|
4271
|
-
session: sessionId,
|
|
4272
|
-
workspace,
|
|
4273
|
-
scope: row.scope,
|
|
4274
|
-
restore: true,
|
|
4275
|
-
})
|
|
4276
|
-
setScopeSaved(row.scope)
|
|
4277
|
-
await load()
|
|
4278
|
-
} catch (e) {
|
|
4279
|
-
setScopeError(String(e.message || e))
|
|
4280
|
-
} finally {
|
|
4281
|
-
setScopeBusy(false)
|
|
4282
|
-
}
|
|
4283
|
-
}
|
|
4284
4306
|
// 审批浮层 / 其它入口点击记忆 ID:挂载时消费一次 pending,之后靠同一事件。
|
|
4285
4307
|
React.useEffect(() => {
|
|
4286
4308
|
const applyFocus = () => {
|
|
@@ -4610,18 +4632,16 @@ window.__ModuleLoader__.load({
|
|
|
4610
4632
|
onChange: setSupersededFilter,
|
|
4611
4633
|
}),
|
|
4612
4634
|
h('button', { onClick: () => setCreating((v) => !v), disabled: loading }, creating ? '收起' : '新建'),
|
|
4613
|
-
// 0.32.0
|
|
4614
|
-
//
|
|
4635
|
+
// 0.32.0:归档默认不列。这个开关是"看得见"而不是"能读写"—— 归档本来就不
|
|
4636
|
+
// 参与检索与注入,这里只是让用户能在面板里找回并恢复。
|
|
4637
|
+
//
|
|
4638
|
+
// 0.33.0:屏蔽没有开关。屏蔽按会话 / 工作区生效,总面板没有 agent 判不准;
|
|
4639
|
+
// 这里一律列全部,屏蔽的展示与解除在会话面板的「记录」页。
|
|
4615
4640
|
h('button', {
|
|
4616
4641
|
className: 'linkbtn' + (showArchived ? ' on' : ''),
|
|
4617
4642
|
title: '已归档作用域(会话归档 / 工作区已移除)里的记录默认不列出来;勾上才显示',
|
|
4618
4643
|
onClick: () => { const next = !showArchived; setShowArchived(next); load(q, scopeFilter, semantic, { archived: next }) },
|
|
4619
4644
|
}, showArchived ? '隐藏已归档' : '显示已归档'),
|
|
4620
|
-
h('button', {
|
|
4621
|
-
className: 'linkbtn' + (showBlocked ? ' on' : ''),
|
|
4622
|
-
title: '被 Agent 屏蔽的记录 / 作用域默认不列出来;勾上才显示',
|
|
4623
|
-
onClick: () => { const next = !showBlocked; setShowBlocked(next); load(q, scopeFilter, semantic, { blocked: next }) },
|
|
4624
|
-
}, showBlocked ? '隐藏已屏蔽' : '显示已屏蔽'),
|
|
4625
4645
|
h('button', { onClick: () => load(q, scopeFilter), disabled: loading }, loading ? '刷新中…' : '刷新'),
|
|
4626
4646
|
filtering ? h('button', { className: 'linkbtn', onClick: () => { setQ(''); setScopeFilter(''); setSupersededFilter('hide'); setSearchInfo(null); load('', '', semantic) } }, '清空筛选') : null,
|
|
4627
4647
|
)
|
|
@@ -4711,12 +4731,10 @@ window.__ModuleLoader__.load({
|
|
|
4711
4731
|
// 0.32.0:项目作用域同理(绑定工作区,工作区删掉时自动归档、重加时自动恢复)。
|
|
4712
4732
|
archived: s.archived === true,
|
|
4713
4733
|
archivedKind: s.archivedKind === 'project' ? 'project' : (s.archivedKind === 'session' ? 'session' : undefined),
|
|
4714
|
-
// 0.32.0:Agent 主动屏蔽(会话级 / 工作区级),解除即刻复原。
|
|
4715
|
-
blocked: s.blocked === true,
|
|
4716
|
-
blockedLevel: s.blockedLevel === 'workspace' ? 'workspace' : (s.blockedLevel === 'session' ? 'session' : undefined),
|
|
4717
4734
|
}))
|
|
4718
|
-
//
|
|
4719
|
-
|
|
4735
|
+
// 归档默认折叠:它不该混在日常清单里,但计数开关让人知道有东西被藏着。
|
|
4736
|
+
// 屏蔽不参与折叠(0.33.0):总面板一律列全部,屏蔽感知在会话面板的「记录」页。
|
|
4737
|
+
.filter((row) => showArchived || !row.archived)
|
|
4720
4738
|
.filter((row) => needle === ''
|
|
4721
4739
|
|| row.label.toLowerCase().includes(needle)
|
|
4722
4740
|
|| row.scope.toLowerCase().includes(needle)
|
|
@@ -4725,7 +4743,6 @@ window.__ModuleLoader__.load({
|
|
|
4725
4743
|
.sort((a, b) => b.records - a.records || b.updatedAt - a.updatedAt || a.label.localeCompare(b.label))
|
|
4726
4744
|
})()
|
|
4727
4745
|
const archivedCount = scopes.filter((s) => s.archived === true).length
|
|
4728
|
-
const blockedCount = scopes.filter((s) => s.blocked === true).length
|
|
4729
4746
|
const viewSwitch = h('div', { className: 'row' },
|
|
4730
4747
|
h('div', { className: 'subtabs' },
|
|
4731
4748
|
h('button', {
|
|
@@ -4753,13 +4770,6 @@ window.__ModuleLoader__.load({
|
|
|
4753
4770
|
onClick: () => setShowArchived((v) => !v),
|
|
4754
4771
|
}, `${showArchived ? '隐藏' : '显示'}已归档 ${archivedCount}`)
|
|
4755
4772
|
: null,
|
|
4756
|
-
blockedCount > 0
|
|
4757
|
-
? h('button', {
|
|
4758
|
-
className: 'linkbtn' + (showBlocked ? ' on' : ''),
|
|
4759
|
-
title: '被 Agent 屏蔽的作用域不参与检索与注入;勾上才能在清单里看到并解除屏蔽',
|
|
4760
|
-
onClick: () => setShowBlocked((v) => !v),
|
|
4761
|
-
}, `${showBlocked ? '隐藏' : '显示'}已屏蔽 ${blockedCount}`)
|
|
4762
|
-
: null,
|
|
4763
4773
|
scopeQuery.trim() !== '' ? h('button', { className: 'linkbtn', onClick: () => setScopeQuery('') }, '清空筛选') : null,
|
|
4764
4774
|
)
|
|
4765
4775
|
const scopeListBody = !loading && !error && scopeRows.length === 0
|
|
@@ -4779,14 +4789,6 @@ window.__ModuleLoader__.load({
|
|
|
4779
4789
|
: '所属会话已归档:作用域与记忆被冻结,取消归档后自动恢复读写',
|
|
4780
4790
|
}, '已归档')
|
|
4781
4791
|
: null,
|
|
4782
|
-
row.blocked
|
|
4783
|
-
? h('span', {
|
|
4784
|
-
className: 'badge',
|
|
4785
|
-
title: row.blockedLevel === 'workspace'
|
|
4786
|
-
? 'Agent 申请、用户批准的工作区级屏蔽:该工作区所有会话都看不到这个域;解除后立刻复原'
|
|
4787
|
-
: 'Agent 申请的会话级屏蔽:只有当前会话看不到这个域;解除后立刻复原',
|
|
4788
|
-
}, row.blockedLevel === 'workspace' ? '已屏蔽 · 工作区级' : '已屏蔽 · 会话级')
|
|
4789
|
-
: null,
|
|
4790
4792
|
row.pendingEmbeds > 0
|
|
4791
4793
|
? h('span', { className: 'pending', title: '待嵌入向量:向量服务就绪后会自动补上' }, `待嵌入 ${row.pendingEmbeds}`)
|
|
4792
4794
|
: null,
|
|
@@ -4850,13 +4852,6 @@ window.__ModuleLoader__.load({
|
|
|
4850
4852
|
onClick: () => restoreArchivedScope(row.scope),
|
|
4851
4853
|
}, '解除归档')
|
|
4852
4854
|
: null,
|
|
4853
|
-
row.blocked
|
|
4854
|
-
? h('button', {
|
|
4855
|
-
className: 'linkbtn',
|
|
4856
|
-
title: '解除屏蔽:这个作用域的记忆立刻重新参与检索与注入',
|
|
4857
|
-
onClick: () => unblockScope(row),
|
|
4858
|
-
}, '解除屏蔽')
|
|
4859
|
-
: null,
|
|
4860
4855
|
),
|
|
4861
4856
|
)
|
|
4862
4857
|
}),
|
|
@@ -4923,13 +4918,133 @@ window.__ModuleLoader__.load({
|
|
|
4923
4918
|
}
|
|
4924
4919
|
|
|
4925
4920
|
/**
|
|
4926
|
-
*
|
|
4921
|
+
* 会话面板的「记录」页(0.33.0)。
|
|
4922
|
+
*
|
|
4923
|
+
* 只列**这个会话权限范围内**的记忆:服务端 /session-records 带着真实会话 id
|
|
4924
|
+
* 解析可见域(会话 + 项目 + global + 工作区绑定),并算出该会话生效的屏蔽。
|
|
4925
|
+
* 这也是唯一该出现「显示已屏蔽 / 解除屏蔽」的地方 —— 主面板没有 agent,
|
|
4926
|
+
* 按层级判断屏蔽只会给出一份"半真"的状态(会话级屏蔽它根本看不见)。
|
|
4927
|
+
*/
|
|
4928
|
+
function SessionRecordsTab({ sessionId }) {
|
|
4929
|
+
const [records, setRecords] = React.useState([])
|
|
4930
|
+
const [scopes, setScopes] = React.useState([])
|
|
4931
|
+
const [blockedCount, setBlockedCount] = React.useState(0)
|
|
4932
|
+
const [showBlocked, setShowBlocked] = React.useState(false)
|
|
4933
|
+
const [loading, setLoading] = React.useState(true)
|
|
4934
|
+
const [error, setError] = React.useState('')
|
|
4935
|
+
const [notice, setNotice] = React.useState('')
|
|
4936
|
+
|
|
4937
|
+
// 作用域键 → 展示名(服务端已按会话标题 / 别名算好)。
|
|
4938
|
+
const labels = {}
|
|
4939
|
+
for (const entry of scopes) {
|
|
4940
|
+
if (entry && typeof entry.scope === 'string' && typeof entry.label === 'string') labels[entry.scope] = entry.label
|
|
4941
|
+
}
|
|
4942
|
+
|
|
4943
|
+
const load = async (withBlocked) => {
|
|
4944
|
+
const wantBlocked = withBlocked !== undefined ? withBlocked : showBlocked
|
|
4945
|
+
setLoading(true); setError('')
|
|
4946
|
+
try {
|
|
4947
|
+
const params = new URLSearchParams({ session: sessionId })
|
|
4948
|
+
if (wantBlocked) params.set('blocked', '1')
|
|
4949
|
+
const value = await api(`session-records?${params}`)
|
|
4950
|
+
setRecords(Array.isArray(value.records) ? value.records : [])
|
|
4951
|
+
setScopes(Array.isArray(value.scopes) ? value.scopes : [])
|
|
4952
|
+
setBlockedCount(Number(value.blockedCount) || 0)
|
|
4953
|
+
} catch (e) {
|
|
4954
|
+
setError(String(e.message || e))
|
|
4955
|
+
}
|
|
4956
|
+
setLoading(false)
|
|
4957
|
+
}
|
|
4958
|
+
React.useEffect(() => { load(false) }, [sessionId])
|
|
4959
|
+
|
|
4960
|
+
/**
|
|
4961
|
+
* 解除一条屏蔽。
|
|
4962
|
+
*
|
|
4963
|
+
* 走 /blocks 的 restore 分支:层级与 key 都显式给(会话级 = 会话 id,
|
|
4964
|
+
* 工作区级 = 该记录所属的 project: 键),并带上屏蔽自己的 id 做精确匹配。
|
|
4965
|
+
* 面板不靠 agent 反推层级 —— 那条屏蔽可能来自父会话,反推会删错文件。
|
|
4966
|
+
*/
|
|
4967
|
+
const unblock = async (rec) => {
|
|
4968
|
+
const level = rec.blockedLevel === 'workspace' ? 'workspace' : 'session'
|
|
4969
|
+
const workspace = typeof rec.scope === 'string' && rec.scope.startsWith('project:') ? rec.scope : ''
|
|
4970
|
+
const value = await api('blocks', {
|
|
4971
|
+
level,
|
|
4972
|
+
session: sessionId,
|
|
4973
|
+
workspace,
|
|
4974
|
+
scope: rec.scope,
|
|
4975
|
+
...(typeof rec.blockedId === 'string' && rec.blockedId !== '' ? { id: rec.blockedId } : {}),
|
|
4976
|
+
restore: true,
|
|
4977
|
+
})
|
|
4978
|
+
const removed = Array.isArray(value?.removed) ? value.removed.reduce((sum, item) => sum + (Number(item?.removed) || 0), 0) : 0
|
|
4979
|
+
setNotice(removed > 0 ? '已解除屏蔽' : '这条屏蔽已经不在了')
|
|
4980
|
+
setTimeout(() => setNotice(''), 2200)
|
|
4981
|
+
await load()
|
|
4982
|
+
}
|
|
4983
|
+
|
|
4984
|
+
const scopeRows = scopes
|
|
4985
|
+
.filter((s) => s && typeof s.scope === 'string')
|
|
4986
|
+
.sort((a, b) => (Number(b.records) || 0) - (Number(a.records) || 0) || a.scope.localeCompare(b.scope))
|
|
4987
|
+
|
|
4988
|
+
return h('div', { className: 'mem-recs' },
|
|
4989
|
+
h('div', { className: 'mem-recs-toolbar' },
|
|
4990
|
+
h('span', { className: 'muted' },
|
|
4991
|
+
`本会话可见 ${scopeRows.length} 个作用域 · ${records.length} 条记忆`),
|
|
4992
|
+
h('span', { className: 'spacer' }),
|
|
4993
|
+
blockedCount > 0
|
|
4994
|
+
? h('button', {
|
|
4995
|
+
className: 'linkbtn' + (showBlocked ? ' on' : ''),
|
|
4996
|
+
title: '被 Agent 屏蔽的记录不参与检索与注入;勾上才显示,并可在卡片里解除',
|
|
4997
|
+
onClick: () => { const next = !showBlocked; setShowBlocked(next); load(next) },
|
|
4998
|
+
}, `${showBlocked ? '隐藏' : '显示'}已屏蔽 ${blockedCount}`)
|
|
4999
|
+
: null,
|
|
5000
|
+
h('button', { onClick: () => load(), disabled: loading }, loading ? '刷新中…' : '刷新'),
|
|
5001
|
+
notice !== '' ? h('span', { className: 'meta-done' }, notice) : null,
|
|
5002
|
+
),
|
|
5003
|
+
// 作用域一览:这里回答的是"本会话能读到哪些域",与主面板的目录同源但按
|
|
5004
|
+
// 会话可见域裁剪过。
|
|
5005
|
+
scopeRows.length > 0
|
|
5006
|
+
? h('div', { className: 'mem-recs-scopes' },
|
|
5007
|
+
scopeRows.map((row) => h('span', {
|
|
5008
|
+
key: row.scope,
|
|
5009
|
+
className: 'badge scope' + (row.blocked ? ' blocked' : ''),
|
|
5010
|
+
title: scopeTitle(row.scope, scopeLabel(row.scope, labels))
|
|
5011
|
+
+ (row.blocked ? `\n已屏蔽(${row.blockedLevel === 'workspace' ? '工作区级' : '会话级'}):本会话不会检索 / 注入它` : ''),
|
|
5012
|
+
}, `${scopeLabel(row.scope, labels)} · ${Number(row.records) || 0}`)),
|
|
5013
|
+
)
|
|
5014
|
+
: null,
|
|
5015
|
+
error ? h('div', { className: 'err' }, error) : null,
|
|
5016
|
+
h('div', { className: 'mem-recs-scroll' + (records.length > 0 || loading ? '' : ' is-empty') },
|
|
5017
|
+
records.length === 0 && !loading
|
|
5018
|
+
? h('div', { className: 'empty' }, error === '' ? '这个会话的可见域里还没有记忆' : '加载失败')
|
|
5019
|
+
: h('div', { className: 'list' },
|
|
5020
|
+
records.map((rec) => h(RecordCard, {
|
|
5021
|
+
key: rec.id,
|
|
5022
|
+
rec,
|
|
5023
|
+
labels,
|
|
5024
|
+
vectorOn: false,
|
|
5025
|
+
onSaved: () => load(),
|
|
5026
|
+
onDeleted: () => load(),
|
|
5027
|
+
onUnblock: unblock,
|
|
5028
|
+
}))),
|
|
5029
|
+
),
|
|
5030
|
+
)
|
|
5031
|
+
}
|
|
5032
|
+
|
|
5033
|
+
/**
|
|
5034
|
+
* 会话内的「记忆」视图:和 Chat/Trajectory 同一个 view ring。
|
|
5035
|
+
*
|
|
5036
|
+
* 两个标签页(0.33.0):
|
|
5037
|
+
* 记录 —— 本会话权限范围内的记忆(可展开「显示已屏蔽」,并在卡片里解除);
|
|
5038
|
+
* 审计 —— 本会话的注入评估、投递与记忆工具调用。
|
|
5039
|
+
* 记录在左、默认打开:日常真正要看的是"我这个会话记了什么"。
|
|
4927
5040
|
*
|
|
4928
5041
|
* 它拿到 owner 传下来的 `openView(view, focus)`,所以从这里跳轨迹是宿主
|
|
4929
5042
|
* 官方支持的深链路径,不依赖任何内部字段。主面板(侧栏/设置)不在 view
|
|
4930
5043
|
* ring 里,走 `conversationStoreFor` 的 bridge。
|
|
4931
5044
|
*/
|
|
4932
5045
|
function MemoryAuditView({ sessionId, openView, sessionInfo }) {
|
|
5046
|
+
// 默认「记录」:进来先看这个会话记得什么,而不是一堆投递事件。
|
|
5047
|
+
const [view, setView] = React.useState('records')
|
|
4933
5048
|
const openTrajectory = (focus) => {
|
|
4934
5049
|
try {
|
|
4935
5050
|
if (typeof openView === 'function') {
|
|
@@ -4946,8 +5061,20 @@ window.__ModuleLoader__.load({
|
|
|
4946
5061
|
'data-conversation-composer-overlay': '',
|
|
4947
5062
|
},
|
|
4948
5063
|
h('div', { className: 'mem-view-head' },
|
|
4949
|
-
h('
|
|
4950
|
-
|
|
5064
|
+
h('div', { className: 'subtabs' },
|
|
5065
|
+
h('button', {
|
|
5066
|
+
className: 'subtab' + (view === 'records' ? ' on' : ''),
|
|
5067
|
+
onClick: () => setView('records'),
|
|
5068
|
+
}, '记录'),
|
|
5069
|
+
h('button', {
|
|
5070
|
+
className: 'subtab' + (view === 'audit' ? ' on' : ''),
|
|
5071
|
+
onClick: () => setView('audit'),
|
|
5072
|
+
}, '审计'),
|
|
5073
|
+
),
|
|
5074
|
+
h('span', { className: 'muted' },
|
|
5075
|
+
view === 'records'
|
|
5076
|
+
? '本会话权限范围内的记忆;被屏蔽的可以点开「显示已屏蔽」再解除。'
|
|
5077
|
+
: '本会话的注入评估、投递与记忆工具调用;选中一条可在轨迹里精确定位。'),
|
|
4951
5078
|
h('span', { className: 'spacer' }),
|
|
4952
5079
|
h('button', {
|
|
4953
5080
|
className: 'linkbtn',
|
|
@@ -4955,14 +5082,16 @@ window.__ModuleLoader__.load({
|
|
|
4955
5082
|
}, '打开完整面板'),
|
|
4956
5083
|
),
|
|
4957
5084
|
h('div', { className: 'mem-view-body' },
|
|
4958
|
-
|
|
4959
|
-
|
|
4960
|
-
|
|
4961
|
-
|
|
4962
|
-
|
|
4963
|
-
|
|
4964
|
-
|
|
4965
|
-
|
|
5085
|
+
view === 'records'
|
|
5086
|
+
? h(SessionRecordsTab, { sessionId })
|
|
5087
|
+
: h(AuditTab, {
|
|
5088
|
+
scopes: [],
|
|
5089
|
+
records: [],
|
|
5090
|
+
sessionInfo,
|
|
5091
|
+
lockSession: sessionId,
|
|
5092
|
+
audience: 'view',
|
|
5093
|
+
openTrajectory,
|
|
5094
|
+
}),
|
|
4966
5095
|
),
|
|
4967
5096
|
)
|
|
4968
5097
|
}
|
|
@@ -6900,6 +7029,7 @@ window.__ModuleLoader__.load({
|
|
|
6900
7029
|
paintNavIcon: paintNavIcon,
|
|
6901
7030
|
// 审计 ↔ 轨迹桥(测试只覆盖纯解析/焦点总线,不碰宿主 slot 实例)
|
|
6902
7031
|
MemoryAuditView: MemoryAuditView,
|
|
7032
|
+
SessionRecordsTab: SessionRecordsTab,
|
|
6903
7033
|
TrajectoryMemoryBadge: TrajectoryMemoryBadge,
|
|
6904
7034
|
TrajectoryMemoryMarks: TrajectoryMemoryMarks,
|
|
6905
7035
|
TrajectoryDetailAudit: TrajectoryDetailAudit,
|
package/lib/inject/apply.js
CHANGED
|
@@ -620,7 +620,7 @@ export function apply(ctx , config = {}) {
|
|
|
620
620
|
}
|
|
621
621
|
|
|
622
622
|
/** 记忆工具自身的调用:不属于注入评估,但它是审计里最有用的轨迹锚点。 */
|
|
623
|
-
const MEMORY_TOOL_NAMES = new Set(['memory_save', 'memory_search', 'memory_forget', 'memory_list', 'memory_get', 'memory_scopes'])
|
|
623
|
+
const MEMORY_TOOL_NAMES = new Set(['memory_save', 'memory_search', 'memory_forget', 'memory_list', 'memory_get', 'memory_scopes', 'memory_block'])
|
|
624
624
|
const rememberMemoryToolCall = (
|
|
625
625
|
sessionId ,
|
|
626
626
|
data ,
|
package/lib/inject/digest.js
CHANGED
|
@@ -17,10 +17,10 @@ import { estimateTokens } from '../provider/rerank.js'
|
|
|
17
17
|
|
|
18
18
|
const HEADER =
|
|
19
19
|
'以下是本项目 / 全局已有的记忆摘要(按重要度挑出的前几条;' +
|
|
20
|
-
'需要原文用 memory_get
|
|
20
|
+
'需要原文用 memory_get,定位用 memory_search;无关条目用 memory_block 屏蔽,过时/写错的才用 memory_forget 删除):'
|
|
21
21
|
|
|
22
22
|
const HINT_HEADER = '相关记忆索引(正文未注入):'
|
|
23
|
-
const HINT_FOOTER = '这些条目的正文尚未加载;遇到相关任务时,按 ID 用 memory_get 取正文,按标签用 memory_search
|
|
23
|
+
const HINT_FOOTER = '这些条目的正文尚未加载;遇到相关任务时,按 ID 用 memory_get 取正文,按标签用 memory_search 定位;与本轮无关的用 memory_block 屏蔽。'
|
|
24
24
|
|
|
25
25
|
/** 一条正文被省略的原因。统计口径互斥:每条记录只归入一个原因。 */
|
|
26
26
|
|
package/lib/inject/inject.js
CHANGED
|
@@ -236,7 +236,7 @@ export function renderRecallBlock(
|
|
|
236
236
|
const chars = impression ? (options.chars ?? 120) : 300
|
|
237
237
|
const header = impression
|
|
238
238
|
? '以下是与你这次请求可能相关的记忆摘要:'
|
|
239
|
-
: '以下是与此请求可能相关的记忆,供参考(需要正文用 memory_get
|
|
239
|
+
: '以下是与此请求可能相关的记忆,供参考(需要正文用 memory_get;与本轮无关的用 memory_block 屏蔽,可逆、不删数据):'
|
|
240
240
|
let tokens = estimateTokens(header) + 4
|
|
241
241
|
const lines = []
|
|
242
242
|
const ids = []
|
package/lib/inject/policy.js
CHANGED
|
@@ -4,7 +4,7 @@
|
|
|
4
4
|
*/
|
|
5
5
|
export const POLICY_TEXT = `## 记忆系统
|
|
6
6
|
|
|
7
|
-
本会话挂着一个本地记忆库,工具:memory_search / memory_list / memory_get / memory_save / memory_forget / memory_scopes(可按会话、项目、全局等作用域读写)。
|
|
7
|
+
本会话挂着一个本地记忆库,工具:memory_search / memory_list / memory_get / memory_save / memory_forget / memory_scopes / memory_block(可按会话、项目、全局等作用域读写)。
|
|
8
8
|
|
|
9
9
|
memory_search 只返回印象(ID、作用域、类型、标签和少量摘要);判断相关后再用 memory_get(ids, fields) 取正文。fields 省略 = content + scope + kind + tags;只要摘要用 ["summary"],只要正文用 ["content"],需要重要度 / 时间 / 触发词等再显式加上对应字段。
|
|
10
10
|
|
|
@@ -22,6 +22,8 @@ memory_search 只返回印象(ID、作用域、类型、标签和少量摘要
|
|
|
22
22
|
|
|
23
23
|
同一会话里已经出现过的记忆,memory_search / memory_list 只回 ID 并注明“摘要因上下文去重被省略”;那不是没找到,需要正文时直接用 memory_get 取。
|
|
24
24
|
|
|
25
|
+
记忆里出现**与本次任务无关**的条目时,主动降噪而不是忍着:摘要 / 召回里那些明显属于别的项目、别的技术栈、别的插件的流程与踩坑(例如你在写 A 项目,却反复被 B 项目的发布流程打断),用 memory_block({ id }) 把它屏蔽掉 —— 会话级默认、按记录 id 不需要审批、数据不删除、随时 action="unblock" 复原。判断口径:①一条记录连续两轮以上出现在注入里却对当前任务没用 → 屏蔽它;②只有整个作用域(某个 custom 域 / 别的项目域)确实与本工作区无关时才按 scope 屏蔽,这会弹审批、影响面大,别为了省事整个域一藏;③不确定是否无关就先别屏蔽,屏蔽是降噪不是清理;④不要用 memory_forget 删别人的记忆。
|
|
26
|
+
|
|
25
27
|
本会话「记忆范围」为普通限制时(默认),调用任一 memory_* 工具都必须带 description 字段:用一句话说明这次调用要做什么(例如「查发布流程的坑」)。它只用于范围外访问的审批弹窗,不写进记忆;漏了会被工具直接拒绝。绝对限制 / 无限制下可省略。
|
|
26
28
|
|
|
27
29
|
遇到以下情况先查记忆,不要凭猜测开始:
|
package/lib/panel.js
CHANGED
|
@@ -926,11 +926,13 @@ async function handle(ctx, routePath, req, res) {
|
|
|
926
926
|
? { description: entry.description.trim(), descriptionSource: 'default' }
|
|
927
927
|
: {}),
|
|
928
928
|
...(entry !== undefined && typeof entry.origin === 'string' ? { origin: entry.origin } : {}),
|
|
929
|
-
// 0.
|
|
929
|
+
// 0.33.0:归档照实传(面板默认折叠,但仍可展开并解除)。
|
|
930
|
+
//
|
|
931
|
+
// 屏蔽**不传**:主面板没有 agent,`scopeCatalog(undefined)` 只反映兜底项目键
|
|
932
|
+
// 那一层,会话级屏蔽在这里根本看不见,传上去只会是一份"半真"的状态。
|
|
933
|
+
// 屏蔽的展示与解除都在会话面板的「记录」页(/session-records 带真实会话 id)。
|
|
930
934
|
...(entry !== undefined && entry.archived === true ? { archived: true } : {}),
|
|
931
935
|
...(entry !== undefined && typeof entry.archivedKind === 'string' ? { archivedKind: entry.archivedKind } : {}),
|
|
932
|
-
...(entry !== undefined && entry.blocked === true ? { blocked: true } : {}),
|
|
933
|
-
...(entry !== undefined && typeof entry.blockedLevel === 'string' ? { blockedLevel: entry.blockedLevel } : {}),
|
|
934
936
|
}
|
|
935
937
|
})
|
|
936
938
|
// 删光记录不等于作用域消失:目录里有用途、却没有记录的作用域也列出来。
|
|
@@ -956,8 +958,6 @@ async function handle(ctx, routePath, req, res) {
|
|
|
956
958
|
...(typeof entry.origin === 'string' ? { origin: entry.origin } : {}),
|
|
957
959
|
...(entry.archived === true ? { archived: true } : {}),
|
|
958
960
|
...(typeof entry.archivedKind === 'string' ? { archivedKind: entry.archivedKind } : {}),
|
|
959
|
-
...(entry.blocked === true ? { blocked: true } : {}),
|
|
960
|
-
...(typeof entry.blockedLevel === 'string' ? { blockedLevel: entry.blockedLevel } : {}),
|
|
961
961
|
})
|
|
962
962
|
}
|
|
963
963
|
let embedServer = null
|
|
@@ -1081,6 +1081,126 @@ async function handle(ctx, routePath, req, res) {
|
|
|
1081
1081
|
writeJson(res, { ok: true, value: result })
|
|
1082
1082
|
return
|
|
1083
1083
|
}
|
|
1084
|
+
// 会话面板的「记录」页(0.33.0):只列**这个会话权限范围内**的记忆。
|
|
1085
|
+
//
|
|
1086
|
+
// 与主面板的 /records 的关键区别是这里带着真实会话 id:能按 agent 口径解析
|
|
1087
|
+
// 默认读取范围(会话 + 项目 + global + 工作区绑定),也拿得到该会话**生效**的
|
|
1088
|
+
// 屏蔽(会话链含父会话 + 工作区级)。主面板没有 agent,按层级折叠屏蔽是做不
|
|
1089
|
+
// 准的(会话级屏蔽根本不会出现在它的视角里),所以屏蔽感知只放在这里。
|
|
1090
|
+
if (method === 'GET' && path === '/session-records') {
|
|
1091
|
+
const sessionId = (url.searchParams.get('session') ?? '').trim()
|
|
1092
|
+
if (sessionId === '') throw new ApiError(400, 'SESSION_REQUIRED', 'session 参数不能为空')
|
|
1093
|
+
const includeBlocked = url.searchParams.get('blocked') === '1'
|
|
1094
|
+
const query = url.searchParams.get('q') ?? ''
|
|
1095
|
+
// 宿主里能查到会话对象就用它(cwd / parentSession 都在上面),查不到退化成
|
|
1096
|
+
// 只有 id 的最小形状 —— resolveReadScopes 会按 id 解析出 session: 作用域。
|
|
1097
|
+
let session
|
|
1098
|
+
try { session = ctx.get('sessions')?.get?.(sessionId) } catch { session = undefined }
|
|
1099
|
+
const agentLike = { session: session !== undefined ? session : { id: sessionId } }
|
|
1100
|
+
// 这个会话实际能读的作用域集合 = 它的权限范围。显式「记忆范围」优先,否则是
|
|
1101
|
+
// 默认三路 + 工作区绑定。
|
|
1102
|
+
let scopes = []
|
|
1103
|
+
try {
|
|
1104
|
+
const resolved = typeof memory.resolveReadScopes === 'function' ? memory.resolveReadScopes(agentLike) : []
|
|
1105
|
+
if (Array.isArray(resolved)) scopes = resolved.filter((scope) => typeof scope === 'string' && scope !== '')
|
|
1106
|
+
} catch { scopes = [] }
|
|
1107
|
+
const catalog = new Map()
|
|
1108
|
+
try {
|
|
1109
|
+
if (typeof memory.scopeCatalog === 'function') {
|
|
1110
|
+
for (const entry of memory.scopeCatalog(agentLike) ?? []) {
|
|
1111
|
+
if (entry && typeof entry.scope === 'string') catalog.set(entry.scope, entry)
|
|
1112
|
+
}
|
|
1113
|
+
}
|
|
1114
|
+
} catch { /* 目录是增强:拿不到就只有名称与条数 */ }
|
|
1115
|
+
// 归档的作用域不再参与检索与注入,这里也不列:会话作用域随会话归档、项目
|
|
1116
|
+
// 作用域随工作区移除,都属于「生命周期已经结束」。
|
|
1117
|
+
const archived = new Set()
|
|
1118
|
+
for (const [key, entry] of catalog) if (entry.archived === true) archived.add(key)
|
|
1119
|
+
const liveScopes = scopes.filter((scope) => !archived.has(scope))
|
|
1120
|
+
// 该会话生效的屏蔽:工作区级更「重」,同一目标以工作区级为准;记录级按 id / 前缀。
|
|
1121
|
+
// 每条都留着屏蔽自己的 id —— 解除时按 id 精确删那一条,不会顺手带走别的。
|
|
1122
|
+
const blockedScopes = new Map()
|
|
1123
|
+
const blockedRecords = new Map()
|
|
1124
|
+
const blockedPrefixes = []
|
|
1125
|
+
try {
|
|
1126
|
+
const blocks = typeof memory.listBlocks === 'function' ? memory.listBlocks(agentLike) : []
|
|
1127
|
+
for (const block of Array.isArray(blocks) ? blocks : []) {
|
|
1128
|
+
if (!block) continue
|
|
1129
|
+
const level = block.level === 'workspace' ? 'workspace' : 'session'
|
|
1130
|
+
const hit = { id: typeof block.id === 'string' ? block.id : undefined, level }
|
|
1131
|
+
if (typeof block.scope === 'string' && block.scope !== '') {
|
|
1132
|
+
if (level === 'workspace' || !blockedScopes.has(block.scope)) blockedScopes.set(block.scope, hit)
|
|
1133
|
+
} else if (typeof block.recordId === 'string' && block.recordId !== '') {
|
|
1134
|
+
blockedRecords.set(block.recordId, hit)
|
|
1135
|
+
} else if (typeof block.prefix === 'string' && block.prefix !== '') {
|
|
1136
|
+
blockedPrefixes.push({ prefix: block.prefix, ...hit })
|
|
1137
|
+
}
|
|
1138
|
+
}
|
|
1139
|
+
} catch { /* 屏蔽是增强:拿不到就当作没有屏蔽 */ }
|
|
1140
|
+
const blockOf = (record) => {
|
|
1141
|
+
const scopeHit = blockedScopes.get(record.scope)
|
|
1142
|
+
if (scopeHit !== undefined) return scopeHit
|
|
1143
|
+
const recordHit = blockedRecords.get(record.id)
|
|
1144
|
+
if (recordHit !== undefined) return recordHit
|
|
1145
|
+
for (const { prefix, ...hit } of blockedPrefixes) {
|
|
1146
|
+
if (record.id.startsWith(prefix)) return hit
|
|
1147
|
+
}
|
|
1148
|
+
return undefined
|
|
1149
|
+
}
|
|
1150
|
+
const rows = []
|
|
1151
|
+
let records = []
|
|
1152
|
+
let blockedCount = 0
|
|
1153
|
+
for (const scope of liveScopes) {
|
|
1154
|
+
const scopeStore = store.peek(scope) // 只读:不创建作用域文件
|
|
1155
|
+
const scopeHit = blockedScopes.get(scope)
|
|
1156
|
+
rows.push({
|
|
1157
|
+
scope,
|
|
1158
|
+
label: scopeLabel(ctx, scope),
|
|
1159
|
+
records: scopeStore !== undefined ? scopeStore.records.size : 0,
|
|
1160
|
+
...(scopeHit !== undefined ? { blocked: true, blockedLevel: scopeHit.level } : {}),
|
|
1161
|
+
})
|
|
1162
|
+
if (scopeStore === undefined) continue
|
|
1163
|
+
for (const rec of collectScope(scopeStore)) {
|
|
1164
|
+
const hit = blockOf(rec)
|
|
1165
|
+
if (hit !== undefined) {
|
|
1166
|
+
blockedCount += 1
|
|
1167
|
+
if (!includeBlocked) continue
|
|
1168
|
+
records.push({
|
|
1169
|
+
...rec,
|
|
1170
|
+
blocked: true,
|
|
1171
|
+
blockedLevel: hit.level,
|
|
1172
|
+
...(hit.id !== undefined ? { blockedId: hit.id } : {}),
|
|
1173
|
+
})
|
|
1174
|
+
continue
|
|
1175
|
+
}
|
|
1176
|
+
records.push(rec)
|
|
1177
|
+
}
|
|
1178
|
+
}
|
|
1179
|
+
if (query !== '') {
|
|
1180
|
+
const needle = query.trim().toLowerCase()
|
|
1181
|
+
records = records.filter((r) =>
|
|
1182
|
+
r.content.toLowerCase().includes(needle)
|
|
1183
|
+
|| r.kind.toLowerCase().includes(needle)
|
|
1184
|
+
|| r.tags.some((tag) => tag.toLowerCase().includes(needle)))
|
|
1185
|
+
}
|
|
1186
|
+
records.sort((a, b) => b.updatedAt - a.updatedAt)
|
|
1187
|
+
let workspace = null
|
|
1188
|
+
try {
|
|
1189
|
+
if (typeof memory.projectKeyFor === 'function') workspace = memory.projectKeyFor(agentLike)
|
|
1190
|
+
} catch { workspace = null }
|
|
1191
|
+
writeJson(res, {
|
|
1192
|
+
ok: true,
|
|
1193
|
+
value: {
|
|
1194
|
+
session: sessionId,
|
|
1195
|
+
workspace,
|
|
1196
|
+
scopes: rows,
|
|
1197
|
+
records,
|
|
1198
|
+
// 折叠开关要显示「有几个被藏起来了」,所以计数必须包含被折叠的那些。
|
|
1199
|
+
blockedCount,
|
|
1200
|
+
},
|
|
1201
|
+
})
|
|
1202
|
+
return
|
|
1203
|
+
}
|
|
1084
1204
|
if (method === 'POST' && path === '/scope-meta') {
|
|
1085
1205
|
// 用户编辑作用域的描述 / 别名(0.29.0)。面板是用户本人的操作,不带会话可见域;
|
|
1086
1206
|
// 但只允许改**目录里看得见**的作用域,免得手滑把用途写到一条永远读不到的元数据上。
|
|
@@ -1254,14 +1374,18 @@ async function handle(ctx, routePath, req, res) {
|
|
|
1254
1374
|
const rawScope = url.searchParams.get('scope')
|
|
1255
1375
|
const query = (url.searchParams.get('q') ?? '').trim().toLowerCase()
|
|
1256
1376
|
const idQuery = (url.searchParams.get('id') ?? '').trim()
|
|
1257
|
-
//
|
|
1258
|
-
// 只是日常浏览不该被"已经归档的旧会话"
|
|
1377
|
+
// 归档默认**不出现在列表里**(0.32.0)。这不是权限:用户点开开关就能看到,
|
|
1378
|
+
// 只是日常浏览不该被"已经归档的旧会话"填满。
|
|
1379
|
+
//
|
|
1380
|
+
// 屏蔽**不再折叠**(0.33.0):屏蔽按会话 / 工作区生效,而主面板没有 agent
|
|
1381
|
+
// (`scopeCatalog(undefined)` 只能拿到兜底项目键那一层),在这里按屏蔽折叠
|
|
1382
|
+
// 既漏会话级屏蔽、又会把用户本想看的记录藏起来。屏蔽感知挪到了会话面板的
|
|
1383
|
+
// 「记录」页(/session-records,带着真实会话 id)。
|
|
1259
1384
|
const includeArchived = url.searchParams.get('archived') === '1'
|
|
1260
|
-
const includeBlocked = url.searchParams.get('blocked') === '1'
|
|
1261
1385
|
// scope 先过同一套规范化:非法 → 400(而不是当成一个陌生 scope 去建文件);
|
|
1262
1386
|
// 合法但不存在的 scope → 空列表。`peek`/`peekScope`,**绝不通过 store.scope() 创建**。
|
|
1263
1387
|
const stores = selectedStores(store, resolveScopeSelection(memory, rawScope))
|
|
1264
|
-
//
|
|
1388
|
+
// 目录一次拿全:归档状态与展示名同源,避免两次查询之间状态漂移。
|
|
1265
1389
|
const catalog = new Map()
|
|
1266
1390
|
try {
|
|
1267
1391
|
if (typeof memory.scopeCatalog === 'function') {
|
|
@@ -1276,7 +1400,6 @@ async function handle(ctx, routePath, req, res) {
|
|
|
1276
1400
|
if (catalog.size > 0 && !explicitScope) {
|
|
1277
1401
|
for (const [key, entry] of catalog) {
|
|
1278
1402
|
if (!includeArchived && entry.archived === true) hiddenScopes.add(key)
|
|
1279
|
-
if (!includeBlocked && entry.blocked === true) hiddenScopes.add(key)
|
|
1280
1403
|
}
|
|
1281
1404
|
}
|
|
1282
1405
|
let records = []
|
package/lib/provider/apply.js
CHANGED
|
@@ -307,6 +307,74 @@ export class CordisMemoryService extends Service {
|
|
|
307
307
|
return this.impl.scopeCatalog(agent)
|
|
308
308
|
}
|
|
309
309
|
|
|
310
|
+
/**
|
|
311
|
+
* 归档 / 屏蔽(0.32.0)。
|
|
312
|
+
*
|
|
313
|
+
* 面板通过 `ctx.get('memory')` 拿到的是**这个包装实例**,不是 LocalMemoryService。
|
|
314
|
+
* 0.32.0 的实现只加在 LocalMemoryService 上,包装层没转发,于是真实 profile 里
|
|
315
|
+
* `memory.listBlocks` / `memory.unblock` / `memory.archiveScope` 全是 undefined ——
|
|
316
|
+
* 面板的「解除归档 / 解除屏蔽」和 `/status` 的 blocked 字段于是静默失效,
|
|
317
|
+
* 而单测直接 new LocalMemoryService 所以完全看不见。这一组必须显式转发。
|
|
318
|
+
*/
|
|
319
|
+
archiveScope(scope , by , note ) {
|
|
320
|
+
return this.impl.archiveScope(scope, by, note)
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
/** 解除项目作用域归档;返回是否真的解除了一条。 */
|
|
324
|
+
restoreScope(scope ) {
|
|
325
|
+
return this.impl.restoreScope(scope)
|
|
326
|
+
}
|
|
327
|
+
|
|
328
|
+
/** 已归档的项目作用域清单(面板 / 目录用)。 */
|
|
329
|
+
archivedProjectScopes() {
|
|
330
|
+
return this.impl.archivedProjectScopes()
|
|
331
|
+
}
|
|
332
|
+
|
|
333
|
+
/** 当前 agent 生效的**全部**屏蔽(会话链 + 工作区级)。 */
|
|
334
|
+
blocksFor(agent ) {
|
|
335
|
+
return this.impl.blocksFor(agent)
|
|
336
|
+
}
|
|
337
|
+
|
|
338
|
+
/** 面板 / 诊断:当前 agent 生效的屏蔽清单。 */
|
|
339
|
+
listBlocks(agent ) {
|
|
340
|
+
return this.impl.listBlocks(agent)
|
|
341
|
+
}
|
|
342
|
+
|
|
343
|
+
/** 面板:某会话自己的会话级屏蔽(不含父链、不含工作区级)。 */
|
|
344
|
+
sessionBlocks(sessionId ) {
|
|
345
|
+
return this.impl.sessionBlocks(sessionId)
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
/** 面板:某工作区的工作区级屏蔽。 */
|
|
349
|
+
workspaceBlocks(workspace ) {
|
|
350
|
+
return this.impl.workspaceBlocks(workspace)
|
|
351
|
+
}
|
|
352
|
+
|
|
353
|
+
/** 这个作用域当前是否被屏蔽(会话级或工作区级)。 */
|
|
354
|
+
isScopeBlocked(agent , scope ) {
|
|
355
|
+
return this.impl.isScopeBlocked(agent, scope)
|
|
356
|
+
}
|
|
357
|
+
|
|
358
|
+
/** 这条记录当前是否被屏蔽(作用域级屏蔽也算)。 */
|
|
359
|
+
isRecordBlocked(agent , record ) {
|
|
360
|
+
return this.impl.isRecordBlocked(agent, record)
|
|
361
|
+
}
|
|
362
|
+
|
|
363
|
+
/** 解除一条屏蔽(面板 / 工具共用)。 */
|
|
364
|
+
unblock(agent , match ) {
|
|
365
|
+
return this.impl.unblock(agent, match)
|
|
366
|
+
}
|
|
367
|
+
|
|
368
|
+
/** 清空某一层级的全部屏蔽。 */
|
|
369
|
+
clearBlocks(agent , level ) {
|
|
370
|
+
return this.impl.clearBlocks(agent, level)
|
|
371
|
+
}
|
|
372
|
+
|
|
373
|
+
/** Agent 请求屏蔽(0.32.0;审批矩阵在 provider 里)。 */
|
|
374
|
+
requestBlock(agent , input ) {
|
|
375
|
+
return this.impl.requestBlock(agent, input)
|
|
376
|
+
}
|
|
377
|
+
|
|
310
378
|
/** 注入设置(面板「设置」标签页读它)。 */
|
|
311
379
|
injectSettings() {
|
|
312
380
|
return this.impl.injectSettings()
|
package/lib/tools/index.js
CHANGED
|
@@ -2026,7 +2026,7 @@ const BLOCK_NOTE_RULE =
|
|
|
2026
2026
|
export function memoryBlockTool(opts ) {
|
|
2027
2027
|
return {
|
|
2028
2028
|
name: 'memory_block',
|
|
2029
|
-
description: 'Hide memories that are irrelevant to the current task so they stop appearing in search, injection and the scope catalog — without deleting anything. Blocking by record id/prefix needs no approval; blocking a whole scope, a rule (kind="rule"), or anything at workspace level raises an approval dialog for the user. action="unblock" removes a block; action="list" shows the active blocks. Blocks are recoverable: the data is never touched.',
|
|
2029
|
+
description: 'Hide memories that are irrelevant to the current task so they stop appearing in search, injection and the scope catalog — without deleting anything. Use it proactively: when recall/digest keeps injecting records that clearly belong to another project or stack, block them by record id (no approval, reversible) instead of tolerating the noise or deleting them. Blocking by record id/prefix needs no approval; blocking a whole scope, a rule (kind="rule"), or anything at workspace level raises an approval dialog for the user. action="unblock" removes a block; action="list" shows the active blocks. Blocks are recoverable: the data is never touched.',
|
|
2030
2030
|
parameters: {
|
|
2031
2031
|
action: {
|
|
2032
2032
|
type: 'string',
|