@restregular/dsh-memory 0.7.3 → 0.9.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/README.md CHANGED
@@ -28,7 +28,7 @@ English: Local, durable memory for DeepSeek Harness — one npm package, one loa
28
28
  | **印象形态** | 每轮只给每条记忆的短摘要;模型判断相关但需要细节时再 `memory_search` 取全文(可在面板关掉,退回长文召回) |
29
29
  | **会话摘要** | 会话第一步注入一次「已有记忆」概览:项目 + global 按**重要度 × 新鲜度**挑几条,省得模型从头摸索 |
30
30
  | **记忆使用策略** | 系统提示常驻段:什么时候该查记忆、查到怎么复用、查不到时低风险推断 / 高风险先问用户 |
31
- | **硬性规则** | `kind: rule` 的记忆进系统提示常驻段(限量、可关)。能机械校验的规则应该做成钩子,提示词只做解释 |
31
+ | **硬性规则** | `kind: rule` 的记忆进系统提示常驻段(限量、可关);**新增/改过的规则会在旧会话的下一轮补一条提醒**(同一条只提醒一次)。能机械校验的规则应该做成钩子,提示词只做解释 |
32
32
  | **五个工具** | `memory_save` / `memory_search` / `memory_list` / `memory_get` / `memory_forget`(摘要带 8 位 id,`memory_get` 直接取全文) |
33
33
  | **管理面板** | 设置页「记忆」:记录(浏览 / 搜索 / 新建 / 编辑 / 删除)+ 设置(召回、摘要、印象、策略、规则、轮末提醒逐项开关、导入导出)、向量服务启停、模型与硬件、维护(卸载 / 清空) |
34
34
  | **向量后端一键装** | 面板里选模型 → 下 llama.cpp 运行时 + 模型 → 托管 `llama-server` 进程;内置 8 个模型 + 硬件推荐 + 自定义 GGUF |
@@ -106,7 +106,7 @@ memory_save({
106
106
 
107
107
  - **服务**:「向量服务」:状态、地址、启停开关、**模型与硬件**(见下)、维护(卸载向量服务 / 清空记忆数据,两步确认)
108
108
  - **记录**(默认打开):顶部统计(记忆数 / 作用域数 / 待嵌入向量数)、搜索、按作用域筛选、**新建**(任意作用域 + 类型,类型里含 `rule`)、展开编辑 / 删除;列表放在独立的滚动容器里(记忆再多也不把面板撑长),滚动条是自定义的细圆头样式,从侧栏入口打开时容器还会跟着窗口长高;作用域下拉**动态枚举实际存在的作用域**(`global` 显示「全局」、project 显示 cwd、会话 scope 显示会话标题、自定义 scope 显示原名)
109
- - **设置**:注入链路逐项开关 —— 每轮召回(topK / 预算)、印象形态(每条字数)、会话摘要(条数 / 预算)、记忆使用策略段、硬性规则段(条数 / 预算,并显示当前规则条数)、轮末提醒、侧栏入口;底部「数据」:导出全部 / 导入文件。改完**即保存**,不需要点按钮
109
+ - **设置**:注入链路逐项开关 —— 每轮召回(topK / 预算)、印象形态(每条字数)、会话摘要(条数 / 预算)、记忆使用策略段、硬性规则段(条数 / 预算 / 变更提醒,并显示当前规则条数)、轮末提醒、侧栏入口;底部「数据」:导出全部 / 导入文件。改完**即保存**,不需要点按钮
110
110
 
111
111
  > **导入 / 导出**:导出的是纯文本 —— 作用域、类型、内容、标签、重要度、时间戳,**没有向量**。导入时逐条走保存路径,按**当前模型重新嵌入**,并按「作用域 + 内容」去重(重复的计入「跳过」)。一次最多 5000 条。
112
112
 
@@ -177,7 +177,7 @@ provider 的配置在顶层,工具 / 注入 / 面板各占一个小节(合并前
177
177
  impression: { enabled: true, chars: 120 } # 每条只给摘要,细节再 memory_search
178
178
  digest: { enabled: true, topK: 8, tokenBudget: 400 } # 会话第一步的概览
179
179
  policy: { enabled: true } # 系统提示:记忆使用策略
180
- rules: { enabled: true, maxItems: 10, tokenBudget: 300 } # 系统提示:kind=rule
180
+ rules: { enabled: true, maxItems: 10, tokenBudget: 300, delta: true } # 系统提示:kind=rule(δ=旧会话补新规则)
181
181
  turnEnd: { enabled: false } # 轮末提醒(下一轮开头提示落盘)
182
182
  panel: { route: '/memory/api' }
183
183
  ```
@@ -189,6 +189,7 @@ provider 的配置在顶层,工具 / 注入 / 面板各占一个小节(合并前
189
189
 
190
190
  - **注入分四层**:`recall`(每轮按问题检索)、`digest`(会话第一步给概览)、`policy`(系统提示常驻的使用策略)、`rules`(系统提示常驻的 `kind=rule` 规则),外加 `turnEnd`(轮末提醒,默认关)。每层独立开关,`inject.enabled: false` 全关。面板改过的值写在 `<storeDir>/settings.json`,**优先级高于这里的配置**。
191
191
  - **写规则**:`memory_save({ kind: 'rule', content: '改 lib 必须同时改 source' })`。规则会进系统提示常驻段;能机械校验的规则更适合做成钩子,提示词只负责解释。
192
+ - **规则变更怎么进旧会话**:系统提示段本身每步都会按 store 快照重渲染,但那只改提示词文本、不产生任何对话消息,旧会话里的模型不会主动重读;而且常驻段有 token 预算,新规则可能被更重要的旧规则挤掉。所以 `rules.delta`(默认开)在一轮的第一步比一次「这个会话已经见过的规则行」与当前规则,把新增/改过的补成一条 `source.kind='memory'` 消息(旧会话重开、宿主重启都不会重复提醒);关掉它只影响这条提醒,常驻段照旧。
192
193
 
193
194
  向量检索是**按配置启用**的:写了 `endpoint`、配了 `spawn`、或面板里装了本地后端才会碰网络,否则一个请求都不发,检索自动降级为纯词法(IDF + CJK bigram)。不需要自动召回就 `inject.enabled: false`。
194
195
 
@@ -320,6 +321,14 @@ tools/build-single-package.mjs 构建(产物契约检查 + 可选加载验证)
320
321
 
321
322
  ## 版本
322
323
 
324
+ - **0.9.0** —— **规则变更会跟进旧会话**:
325
+ - 以前在别的会话里新加一条 `kind=rule`,旧会话继续聊时只有系统提示段的文本会刷新 —— 不产生对话消息,模型未必会重读;而且规则段有 300 token 预算,新规则可能被更重要的旧规则挤出常驻段。
326
+ - 现在每轮第一步比一次「该系统提示里的规则行 ∪ 历史里注入过的增量行」与当前规则,把新增/改过的补成一条 `source.kind='memory'` 消息(与召回/摘要同一条卡片来源),只提醒没出现过的;新会话第一步不补(系统提示本来就全有)。
327
+ - 面板「设置 → 硬性规则」新增**变更提醒**开关(`rules.delta`,默认开);关掉只停这条提醒,常驻段与检索不受影响。
328
+ - **0.8.0** —— 「服务 → 维护」新增**重建全部向量**:
329
+ - 一键把所有记录的向量(内存 + 磁盘)作废、重新排队并按当前模型重嵌,用于换过模型或怀疑向量与内容对不上时修复;只显示在两个条件都满足时(配置了后端且启用),两步确认,后台执行、不阻塞请求。
330
+ - 进度看「待嵌入向量」:面板在有待嵌入时每 **1.5s** 自动刷新列表徽标与计数(上限 300 次);从其它标签切回「记录」也会立即刷新一次。
331
+ - 重建期间向量检索暂时只用词法,完成一条恢复一条。
323
332
  - **0.7.3** —— 修复「编辑一条记忆后一直显示待嵌入」:
324
333
  - 面板 `/update` 改内容时只删了内存里的向量、**没有把 `.vec` 标脏**,重启后旧向量仍在磁盘上,会被当成“已嵌入”继续用(而且内容已经变了)。现在旧向量在内存与磁盘上一并作废。
325
334
  - 编辑后**立即重建这一条**的向量(不再等 60s 的定时回填);重建失败才留在队列里由重试兜底。
package/lib/client.js CHANGED
@@ -678,12 +678,13 @@ window.__ModuleLoader__.load({
678
678
  },
679
679
  {
680
680
  key: 'rules', title: '硬性规则',
681
- desc: '把 kind=rule 的记忆放进系统提示常驻段。',
681
+ desc: '把 kind=rule 的记忆放进系统提示常驻段;旧会话下一轮补一条新增/变更的规则。',
682
682
  hint: '关闭只影响系统提示常驻段,记忆本身仍可被检索',
683
683
  fields: [
684
684
  { k: 'enabled', label: '启用', type: 'bool' },
685
685
  { k: 'maxItems', label: '最多条数', type: 'num', min: 1, max: 40, step: 1 },
686
686
  { k: 'tokenBudget', label: 'token 预算', type: 'num', min: 50, max: 4000, step: 50 },
687
+ { k: 'delta', label: '变更提醒', type: 'bool', hint: '旧会话在下一轮第一步补一条「新增/变更的规则」,同一条只提醒一次' },
687
688
  ],
688
689
  },
689
690
  {
@@ -789,7 +790,7 @@ window.__ModuleLoader__.load({
789
790
  ? h(Switch, {
790
791
  key: field.k,
791
792
  checked: Boolean(value[field.k]),
792
- title: group.hint || field.label,
793
+ title: field.hint || group.hint || field.label,
793
794
  onChange: (next) => patch(group.key, field.k, next),
794
795
  })
795
796
  : h('label', { className: 'set-field', key: field.k }, field.label, ' ',
@@ -898,8 +899,8 @@ window.__ModuleLoader__.load({
898
899
  )
899
900
  }
900
901
 
901
- /** 待嵌入自动刷新:最多 30 次 × 2s(后端挂着时不无限轮询)。 */
902
- const PENDING_POLL_LIMIT = 30
902
+ /** 待嵌入自动刷新:最多 300 次 × 1.5s(后端挂着时不无限轮询)。 */
903
+ const PENDING_POLL_LIMIT = 300
903
904
 
904
905
  function MemoryPanel() {
905
906
  const [records, setRecords] = React.useState([])
@@ -974,8 +975,8 @@ window.__ModuleLoader__.load({
974
975
  }
975
976
 
976
977
  /**
977
- * 维护动作:卸载向量服务 / 清空记忆数据。两者都不可撤销,所以都走两步确认
978
- * (dangerAsk 记住当前等确认的那一项,第二次点击才真的发请求)。
978
+ * 维护动作:卸载向量服务 / 清空记忆数据 / 重建全部向量。前两者不可撤销,重建代价高,
979
+ * 都走两步确认(dangerAsk 记住当前等确认的那一项,第二次点击才真的发请求)。
979
980
  */
980
981
  const maintenanceAction = async (which) => {
981
982
  if (dangerAsk !== which) { setDangerAsk(which); setEmbedNotice(''); return }
@@ -984,8 +985,10 @@ window.__ModuleLoader__.load({
984
985
  try {
985
986
  const value = which === 'uninstall'
986
987
  ? await api('embed/uninstall', {})
987
- // 服务端要求显式 confirm:"delete",避免任何一次误触就清库
988
- : await api('data/wipe', { confirm: 'delete' })
988
+ : which === 'reindex'
989
+ ? await api('embed/reindex', {})
990
+ // 服务端要求显式 confirm:"delete",避免任何一次误触就清库
991
+ : await api('data/wipe', { confirm: 'delete' })
989
992
  setEmbedServer(value.embedServer ? { ...value.embedServer } : value)
990
993
  if (which === 'uninstall') {
991
994
  setEmbedNotice(value.removed
@@ -993,6 +996,9 @@ window.__ModuleLoader__.load({
993
996
  : value.reason === 'EXTERNAL_BACKEND'
994
997
  ? '当前后端不在本插件管理的目录里(是你自己装的),没有删除任何东西。'
995
998
  : '没有找到本插件安装的向量服务文件。')
999
+ } else if (which === 'reindex') {
1000
+ setPendingTick(0)
1001
+ setEmbedNotice(`已开始重建 ${value.records ?? 0} 条的向量;「待嵌入向量」会逐步下降,期间检索暂时只用词法。`)
996
1002
  } else {
997
1003
  setEmbedNotice(`已清空 ${value.removed ?? 0} 条记忆(${(value.scopes ?? []).length} 个作用域)。`)
998
1004
  }
@@ -1033,7 +1039,7 @@ window.__ModuleLoader__.load({
1033
1039
  const timer = setTimeout(() => {
1034
1040
  setPendingTick((n) => n + 1)
1035
1041
  load()
1036
- }, 2000)
1042
+ }, 1500)
1037
1043
  return () => clearTimeout(timer)
1038
1044
  }, [pendingTick, pending])
1039
1045
  // 服务端 /status 给的 scope → label 映射(会话标题、project 的 cwd 只有服务端知道)
@@ -1151,6 +1157,8 @@ window.__ModuleLoader__.load({
1151
1157
  onInstall: (override) => embedAction('install', override),
1152
1158
  }),
1153
1159
  )
1160
+ // 重建向量只在"配置了后端且启用"时有意义(maintenanceCard 在 configured 声明之前构建)。
1161
+ const canReindex = Boolean(embedServer && embedServer.enabled && (embedServer.configured === undefined ? Boolean(embedServer.baseUrl) : embedServer.configured))
1154
1162
  // 维护区:DSH 卸载插件时不会给插件任何提问机会(就是 pnpm remove + 去掉
1155
1163
  // bundles),所以"要不要留向量服务 / 要不要留记忆数据"只能在这里、卸载之前问。
1156
1164
  const maintenanceCard = maintenance
@@ -1168,6 +1176,17 @@ window.__ModuleLoader__.load({
1168
1176
  : h('button', { key: 'ask', disabled: embedBusy, onClick: () => maintenanceAction('uninstall') }, '卸载向量服务'))
1169
1177
  : h('span', { className: 'muted' }, '未安装'),
1170
1178
  ),
1179
+ h('div', { className: 'maint-row' },
1180
+ h('span', { className: 'grow' }, `向量索引:${maintenance.records} 条`),
1181
+ canReindex
1182
+ ? (maintenance.records > 0
1183
+ ? (dangerAsk === 'reindex'
1184
+ ? [h('button', { key: 'ok', className: 'danger', disabled: embedBusy, onClick: () => maintenanceAction('reindex') }, `确认重建 ${maintenance.records} 条的向量`),
1185
+ h('button', { key: 'no', disabled: embedBusy, onClick: () => setDangerAsk('') }, '取消')]
1186
+ : h('button', { key: 'ask', disabled: embedBusy, onClick: () => maintenanceAction('reindex') }, '重建全部向量'))
1187
+ : h('span', { className: 'muted' }, '无'))
1188
+ : h('span', { className: 'muted' }, '向量未启用'),
1189
+ ),
1171
1190
  h('div', { className: 'maint-row' },
1172
1191
  h('span', { className: 'grow' }, `记忆数据:${maintenance.records} 条`),
1173
1192
  maintenance.storeDir ? h('span', { className: 'muted path', title: maintenance.storeDir }, maintenance.storeDir) : null,
@@ -1233,7 +1252,7 @@ window.__ModuleLoader__.load({
1233
1252
  return h('div', { className: 'memp' },
1234
1253
  h('div', { className: 'tabs' },
1235
1254
  h('button', { className: 'tab' + (tab === 'records' ? ' on' : ''), onClick: () => setTab('records') }, '服务'),
1236
- h('button', { className: 'tab' + (tab === 'data' ? ' on' : ''), onClick: () => setTab('data') }, '记录'),
1255
+ h('button', { className: 'tab' + (tab === 'data' ? ' on' : ''), onClick: () => { if (tab !== 'data') load(); setTab('data') } }, '记录'),
1237
1256
  h('button', { className: 'tab' + (tab === 'settings' ? ' on' : ''), onClick: () => setTab('settings') }, '设置'),
1238
1257
  ),
1239
1258
  tab === 'settings' ? h(SettingsTab, {}) : tab === 'data' ? dataBody : overviewBody,
@@ -6,6 +6,7 @@
6
6
  * 2. digest —— 会话第一步给一次"已有记忆"的摘要
7
7
  * 3. policy —— 系统提示里的「记忆使用策略」常驻段
8
8
  * 4. rules —— 系统提示里的「硬性规则」段(kind='rule' 的记忆)
9
+ * 另有 rulesDelta —— 旧会话在下一轮补一条新增/变更的规则(0.9.0;随 rules 开关)
9
10
  * 另有 turnEnd —— 轮末提醒(下一轮开头提示"上一轮若有结论就记一条"),默认关。
10
11
  *
11
12
  * Message construction MUST go through createUserMessage: the loop reads
@@ -33,6 +34,7 @@ import {
33
34
  } from './inject.js'
34
35
  import { renderDigestBlock } from './digest.js'
35
36
  import { renderRulesBlock } from './rules.js'
37
+ import { ruleDeltaText } from './rules-delta.js'
36
38
  import { POLICY_TEXT } from './policy.js'
37
39
  import { normalizeInjectSettings, } from '../provider/inject-settings.js'
38
40
 
@@ -174,13 +176,20 @@ export function apply(ctx , config = {}) {
174
176
 
175
177
  // 摘要(每个会话一次)、召回(每轮有新内容时)、轮末提醒(下一轮首步)合成
176
178
  // 同一条消息:内容没变就什么都不加,避免一步两张卡片。
179
+ const settings = enabled ? settingsOf() : undefined
177
180
  const parts = []
181
+ // 规则增量:别的会话新加/改过的规则,在本轮第一步给旧会话补一次。
182
+ // `delta !== false` 而不是 `=== true`:老 provider 的 settings 快照没有这个
183
+ // 字段时要按"开"处理,否则升级当天等于静默关掉。
184
+ if (settings && step === 1 && settings.rules.enabled && settings.rules.delta !== false) {
185
+ const delta = ruleDeltaText(agent, memory, settings.rules)
186
+ if (delta) parts.push(delta)
187
+ }
178
188
  if (pendingNudge && step === 1) {
179
189
  pendingNudge = false
180
190
  parts.push(NUDGE_TEXT)
181
191
  }
182
- if (enabled) {
183
- const settings = settingsOf()
192
+ if (settings) {
184
193
  if (settings.digest.enabled) {
185
194
  const digest = await digester.maybeDigest(sessionIdOf(agent), scopes, (records) =>
186
195
  renderDigestBlock(records, settings.digest)?.text ?? null)
@@ -0,0 +1,70 @@
1
+ /**
2
+ * 规则增量(0.9.0):旧会话继续聊之前,把「这个会话还没见过的硬性规则」补一条消息。
3
+ *
4
+ * 为什么光刷新系统提示不够:规则段每步都会按 store 快照重渲染,但那条更新只改
5
+ * 系统提示文本、不产生任何对话消息 —— 模型在旧会话里接着聊时不会主动重读;
6
+ * 而且规则段有 token 预算,新规则还可能被更重要的旧规则挤出常驻段。
7
+ *
8
+ * 这里只做"读会话派生历史 + 算差集 + 渲染",宿主差异(拿不到 session / 拿不到
9
+ * listSync)一律降级为不提醒 —— 注入路径抛错会打断整个 agent 循环。
10
+ */
11
+
12
+ import {
13
+ latestSystemText,
14
+ renderRulesDeltaBlock,
15
+ seenRuleLines,
16
+ unseenRules,
17
+
18
+ } from './rules.js'
19
+
20
+
21
+ /** 宿主 Session 上我们用到的那一小部分(派生历史是 surface 节点的缓存投影)。 */
22
+
23
+
24
+
25
+
26
+ /** provider 在增量侧需要的能力(缺一个就走"不提醒")。 */
27
+
28
+
29
+
30
+
31
+
32
+ /** 会话的模型可见历史;老宿主 / 半个加载失败时返回 undefined。 */
33
+ export function derivedHistoryOf(agent ) {
34
+ try {
35
+ const session = (agent )?.session
36
+ const derive = session?.deriveMessages
37
+ if (typeof derive !== 'function') return undefined
38
+ const history = derive.call(session)
39
+ return Array.isArray(history) ? (history ) : undefined
40
+ } catch {
41
+ return undefined
42
+ }
43
+ }
44
+
45
+ /**
46
+ * 增量块的正文;没有新增/变更(或这是会话的第一步)时返回 undefined。
47
+ *
48
+ * 规则范围与系统提示「硬性规则」段一致(`resolveReadScopes`,拿不到就 global),
49
+ * 免得提醒了本来就不该进常驻段的规则。只在一轮的第一步调用:增量消息会持久化,
50
+ * 每一步都算会重复;新会话(还没有系统提示)直接跳过 —— 系统提示这次就带全。
51
+ */
52
+ export function ruleDeltaText(agent , memory , cfg ) {
53
+ const history = derivedHistoryOf(agent)
54
+ if (history === undefined || latestSystemText(history) === undefined) return undefined
55
+ let scopes = ['global']
56
+ try {
57
+ const resolved = memory.resolveReadScopes?.(agent)
58
+ if (Array.isArray(resolved) && resolved.length > 0) scopes = resolved
59
+ } catch { scopes = ['global'] }
60
+ let records
61
+ try {
62
+ records = memory.listSync?.({ scopes, kind: 'rule', limit: 100 }) ?? []
63
+ } catch {
64
+ return undefined
65
+ }
66
+ return renderRulesDeltaBlock(unseenRules(records, seenRuleLines(history)), cfg) ?? undefined
67
+ }
68
+
69
+
70
+ //# sourceURL=source/memory-inject/src/rules-delta.ts
@@ -4,28 +4,136 @@
4
4
  * 为什么放系统提示而不是每轮消息:规则要"一直在场",但每轮复制会膨胀并稀释
5
5
  * 注意力;系统提示是每步都会看见的位置,且文本稳定时可以跟着前缀缓存。
6
6
  * 只放"不可机械校验"的规则 —— 能写成检查的规则应该进钩子(代码强制)。
7
+ *
8
+ * 增量提醒(0.9.0):系统提示段每步都会按内存快照重渲染,但"规则是别的会话里
9
+ * 新加的"这件事只改文本、不产生任何对话消息;模型在旧会话里继续聊时未必会
10
+ * 重新读一遍系统提示,而且规则段有 token 预算,新规则可能被旧规则挤出常驻段。
11
+ * 所以 apply.ts 在每轮第一步把「这个会话还没见过的规则行」补成一条消息。
12
+ * 这里只放纯函数:渲染、从系统提示/历史消息里抽取规则行、算差集。
7
13
  */
8
14
 
9
15
  import { estimateTokens } from '../provider/rerank.js'
10
16
 
11
17
 
12
- const HEADER = '以下是必须遵守的硬性规则(来自 kind=rule 的长期记忆;除非用户明确要求破例,否则按它做):'
18
+ export const RULES_HEADER =
19
+ '以下是必须遵守的硬性规则(来自 kind=rule 的长期记忆;除非用户明确要求破例,否则按它做):'
13
20
 
14
- /** 渲染规则段。重要性优先,其次新的在前;每条截 240 字,超出预算截断。 */
15
- export function renderRulesBlock(records , cfg ) {
16
- if (records.length === 0) return null
17
- const ordered = [...records].sort((a, b) => b.importance - a.importance || b.updatedAt - a.updatedAt || a.content.localeCompare(b.content))
18
- let tokens = estimateTokens(HEADER) + 4
21
+ export const RULES_DELTA_HEADER =
22
+ '以下是新增或变更的硬性规则(来自 kind=rule 的长期记忆;从现在起按它做):'
23
+
24
+ /**
25
+ * 一条规则的渲染行。常驻段与增量块共用同一个格式 —— 增量靠"逐行比对"判断
26
+ * 会话是否已经见过某条规则,两边只要有一个字符不同就会重复提醒。
27
+ */
28
+ export function ruleLine(record ) {
29
+ return `- ${record.content.replace(/\s+/g, ' ').slice(0, 240)}`
30
+ }
31
+
32
+ /** 规则排序:重要度优先,其次新的在前,最后按内容稳定排序(两个实例结果一致)。 */
33
+ export function orderRules(records ) {
34
+ return [...records].sort(
35
+ (a, b) =>
36
+ b.importance - a.importance ||
37
+ b.updatedAt - a.updatedAt ||
38
+ a.content.localeCompare(b.content),
39
+ )
40
+ }
41
+
42
+ function renderLines(records , header , cfg , budget ) {
43
+ let tokens = estimateTokens(header) + 4
19
44
  const lines = []
20
- for (const record of ordered.slice(0, cfg.maxItems)) {
21
- const line = `- ${record.content.replace(/\s+/g, ' ').slice(0, 240)}`
45
+ for (const record of orderRules(records).slice(0, cfg.maxItems)) {
46
+ const line = ruleLine(record)
22
47
  const cost = estimateTokens(line) + 1
23
- if (tokens + cost > cfg.tokenBudget) break
48
+ if (tokens + cost > budget) break
24
49
  lines.push(line)
25
50
  tokens += cost
26
51
  }
27
52
  if (lines.length === 0) return null
28
- return `${HEADER}\n${lines.join('\n')}`
53
+ return `${header}\n${lines.join('\n')}`
54
+ }
55
+
56
+ /** 渲染规则段(系统提示常驻)。重要性优先,新的在前;每条截 240 字,超出预算截断。 */
57
+ export function renderRulesBlock(records , cfg ) {
58
+ return renderLines(records, RULES_HEADER, cfg, cfg.tokenBudget)
59
+ }
60
+
61
+ /**
62
+ * 渲染"新增/变更的规则"块。预算比常驻段留宽一点:增量块本来就是常驻段装不下
63
+ * 时才需要的补充,用同一个 300 token 的上限容易把最该提醒的一条又截掉。
64
+ */
65
+ export function renderRulesDeltaBlock(records , cfg ) {
66
+ return renderLines(records, RULES_DELTA_HEADER, cfg, Math.max(cfg.tokenBudget, 600))
67
+ }
68
+
69
+ /** 模型可见历史里的一小部分形状(只读;不依赖宿主的 Message 类型)。 */
70
+
71
+
72
+
73
+
74
+
75
+
76
+ /** 一条消息的纯文本(多个 text 块用换行连接)。 */
77
+ export function messageText(message ) {
78
+ return (message.content ?? [])
79
+ .filter((block) => block.type === 'text' && typeof block.text === 'string')
80
+ .map((block) => block.text )
81
+ .join('\n')
29
82
  }
30
83
 
84
+ /**
85
+ * 从一段提示文本里抽出以 `header` 开头的段。段与段之间用一个空行分隔,
86
+ * 段内的行都是单行(渲染时已把空白折叠成空格)。
87
+ */
88
+ export function extractSection(text , header ) {
89
+ const at = text.indexOf(header)
90
+ if (at < 0) return undefined
91
+ const rest = text.slice(at + header.length)
92
+ const end = rest.indexOf('\n\n')
93
+ return end < 0 ? rest : rest.slice(0, end)
94
+ }
95
+
96
+ /** 段里的条目行(以 `- ` 开头、已 trim 的行)。 */
97
+ export function sectionLines(section ) {
98
+ if (!section) return []
99
+ return section
100
+ .split('\n')
101
+ .map((line) => line.trim())
102
+ .filter((line) => line.startsWith('- '))
103
+ }
104
+
105
+ /** 模型可见历史里最新的那条非空系统提示(宿主可能在历史里追加多个系统节点)。 */
106
+ export function latestSystemText(history ) {
107
+ for (let i = history.length - 1; i >= 0; i--) {
108
+ const message = history[i]
109
+ if (message?.role !== 'system') continue
110
+ const text = messageText(message)
111
+ if (text.length > 0) return text
112
+ }
113
+ return undefined
114
+ }
115
+
116
+ /**
117
+ * 这个会话"已经看见过"的规则行 = 最新系统提示里的规则段
118
+ * ∪ 历史上注入过的增量块(同一条规则只会提醒一次,重启宿主也不会重复)。
119
+ */
120
+ export function seenRuleLines(history ) {
121
+ const seen = new Set ()
122
+ const systemText = latestSystemText(history)
123
+ if (systemText !== undefined) {
124
+ for (const line of sectionLines(extractSection(systemText, RULES_HEADER))) seen.add(line)
125
+ }
126
+ for (const message of history) {
127
+ if (message.role !== 'user' || message.source?.kind !== 'memory') continue
128
+ for (const line of sectionLines(extractSection(messageText(message), RULES_DELTA_HEADER))) seen.add(line)
129
+ }
130
+ return seen
131
+ }
132
+
133
+ /** 还没在这个会话里出现过的规则(按常驻段同一套行格式比对)。 */
134
+ export function unseenRules(records , seen ) {
135
+ return records.filter((record) => !seen.has(ruleLine(record)))
136
+ }
137
+
138
+
31
139
  //# sourceURL=source/memory-inject/src/rules.ts
package/lib/panel.js CHANGED
@@ -363,6 +363,15 @@ async function handle(ctx, routePath, req, res) {
363
363
  writeJson(res, { ok: true, value: { ...out, ...(await memory.embedServerStatus()) } })
364
364
  return
365
365
  }
366
+ if (method === 'POST' && path === '/embed/reindex') {
367
+ if (typeof memory.reindexAll !== 'function') throw new ApiError(501, 'NOT_SUPPORTED', 'provider 未提供向量重建接口(请升级 @restregular/dsh-memory)')
368
+ // 同步部分只作废旧向量 + 排队,真正的重嵌在后台跑,不阻塞请求;进度看 /status 的待嵌入计数。
369
+ const result = memory.reindexAll() ?? {}
370
+ const total = typeof result.total === 'number' ? result.total : 0
371
+ console.log(`[dsh-memory-panel] 开始重建全部向量:${total} 条`)
372
+ writeJson(res, { ok: true, value: { scheduled: true, records: total } })
373
+ return
374
+ }
366
375
  if (method === 'POST' && path === '/data/wipe') {
367
376
  if (typeof memory.wipeAllRecords !== 'function') throw new ApiError(501, 'NOT_SUPPORTED', 'provider 未提供数据清理接口(请升级 @restregular/dsh-memory)')
368
377
  const body = await readJsonBody(req)
@@ -155,6 +155,16 @@ export class CordisMemoryService extends Service {
155
155
  return this.impl.reindexRecord(scope, id)
156
156
  }
157
157
 
158
+ /** 维护:重建全部向量(作废旧向量并重新嵌入)。 */
159
+ reindexAll() {
160
+ return this.impl.reindexAll()
161
+ }
162
+
163
+ /** 维护:作废全部向量并按当前模型后台重嵌。 */
164
+ reindexAll() {
165
+ return this.impl.reindexAll()
166
+ }
167
+
158
168
  /** 作用域别名(没有则 undefined)。 */
159
169
  scopeName(scope ) {
160
170
  return this.impl.scopeName(scope)
@@ -1296,6 +1296,29 @@ export class LocalMemoryService {
1296
1296
  return true
1297
1297
  }
1298
1298
 
1299
+ /**
1300
+ * 作废全部向量并按当前模型重新嵌入。给"换模型残留了旧向量 / 怀疑向量有问题"用:
1301
+ * 同步部分只清空 + 排队,真正的重嵌在后台跑(别让 HTTP 等几分钟)。
1302
+ * 返回排队条数;进度由面板的「待嵌入」计数与自动刷新体现。
1303
+ */
1304
+ reindexAll() {
1305
+ if (!this.cfg.vector.enabled || !this.cfg.vector.configured) return { total: 0, queued: this.pendingEmbedCount }
1306
+ this.discoverScopes()
1307
+ let total = 0
1308
+ for (const s of this.store.allScopes()) {
1309
+ for (const id of s.records.keys()) {
1310
+ s.vectors.delete(id)
1311
+ s.embedPending.add(id)
1312
+ total += 1
1313
+ }
1314
+ s.vectorsDirty = true
1315
+ s.dirty = true
1316
+ }
1317
+ this.store.scheduleFlush()
1318
+ void this.backfillAll({ throttleMs: 50 }).catch(() => { /* 失败留给 60s 重试 */ })
1319
+ return { total, queued: this.pendingEmbedCount }
1320
+ }
1321
+
1299
1322
  /**
1300
1323
  * First-fill: embed the ENTIRE backlog (unlike backfillEmbeddings' single
1301
1324
  * batch per scope), in throttled batches so a big import does not hammer
@@ -34,6 +34,12 @@
34
34
 
35
35
 
36
36
 
37
+
38
+                                  
39
+                                 
40
+                                 
41
+
42
+
37
43
 
38
44
 
39
45
 
@@ -61,7 +67,7 @@ export const defaultInjectSettings = {
61
67
  digest: { enabled: true, topK: 8, tokenBudget: 400 },
62
68
  impression: { enabled: true, chars: 120 },
63
69
  policy: { enabled: true },
64
- rules: { enabled: true, maxItems: 10, tokenBudget: 300 },
70
+ rules: { enabled: true, maxItems: 10, tokenBudget: 300, delta: true },
65
71
  turnEnd: { enabled: false },
66
72
  sidebar: { enabled: false },
67
73
  }
@@ -122,6 +128,7 @@ export function normalizeInjectSettings(raw , base = def
122
128
  enabled: bool(rules.enabled, base.rules.enabled),
123
129
  maxItems: clampInt(rules.maxItems, 1, 40, base.rules.maxItems),
124
130
  tokenBudget: clampInt(rules.tokenBudget, 50, 4000, base.rules.tokenBudget),
131
+ delta: bool(rules.delta, base.rules.delta),
125
132
  },
126
133
  turnEnd: { enabled: bool(turnEnd.enabled, base.turnEnd.enabled) },
127
134
  sidebar: { enabled: bool(sidebar.enabled, base.sidebar.enabled) },
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@restregular/dsh-memory",
3
- "version": "0.7.3",
3
+ "version": "0.9.0",
4
4
  "description": "DeepSeek Harness 本地长期记忆(单包单入口):JSONL 存储 + 本地向量检索(BGE-M3)+ 四个模型工具 + 自动召回注入 + 管理面板。",
5
5
  "icon": "./icon.svg",
6
6
  "type": "module",