dsh-plain-memory 0.0.0-stage → 1.0.1

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/locale/zh.json ADDED
@@ -0,0 +1,6 @@
1
+ {
2
+ "meta": {
3
+ "title": "原味记忆",
4
+ "description": "记忆是纯 Markdown,存在你自己的 Git 仓库;多窗口状态卡;线索词本地召回。"
5
+ }
6
+ }
package/memory.js ADDED
@@ -0,0 +1,396 @@
1
+ /**
2
+ * Markdown 记忆仓的内核:解析、BM25 召回、追加写入。零依赖。
3
+ *
4
+ * 目录约定(全部是纯 Markdown):
5
+ * self.md 自我层(身份、偏好、长期约束;需用户确认)
6
+ * episodic/YYYY-MM.md 情景层(做过什么、结论是什么)
7
+ * semantic/<主题>.md 语义层(跨会话可复用的事实与方法)
8
+ * .state/ 运行时状态(状态卡、待确认提案),已被 .gitignore
9
+ *
10
+ * 每条记忆是一个 `### 标题` 小节,元数据行固定为:
11
+ * - id / date / session / cues / related
12
+ */
13
+
14
+ import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs'
15
+ import { basename, dirname, join, relative } from 'node:path'
16
+
17
+ const K1 = 1.2
18
+ const B = 0.75
19
+ const MAX_BODY = 600
20
+ /** 记忆召回至少要两个不同的匹配词才算想起来;状态卡因为条数少、且 24 小时就过期,只要求 1 个。 */
21
+ export const MIN_MATCHED_TERMS = 2
22
+
23
+ /** 本地日期,YYYY-MM-DD。 */
24
+ export function today(now = new Date()) {
25
+ const p = (n) => String(n).padStart(2, '0')
26
+ return `${now.getFullYear()}-${p(now.getMonth() + 1)}-${p(now.getDate())}`
27
+ }
28
+
29
+ /** 文件名安全的短标识;保留中文,去掉路径与空白。 */
30
+ export function slug(text) {
31
+ const s = String(text || '')
32
+ .toLowerCase()
33
+ .replace(/[^\p{L}\p{N}]+/gu, '-')
34
+ .replace(/^-+|-+$/g, '')
35
+ .slice(0, 40)
36
+ return s || 'memory'
37
+ }
38
+
39
+ /** 稳定条目 id:层-日期-内容短哈希。 */
40
+ export function entryId(layer, title, date) {
41
+ let h = 0
42
+ const s = `${layer}:${title}:${date}`
43
+ for (let i = 0; i < s.length; i += 1) h = (Math.imul(h, 31) + s.charCodeAt(i)) >>> 0
44
+ return `${layer}-${date.replace(/-/g, '')}-${h.toString(36)}`
45
+ }
46
+
47
+ function metadata(entry) {
48
+ const lines = [
49
+ `- id: ${entry.id}`,
50
+ `- date: ${entry.date}`,
51
+ `- session: ${entry.session}`,
52
+ ]
53
+ if (entry.cues && entry.cues.length) lines.push(`- cues: ${entry.cues.join(', ')}`)
54
+ if (entry.related && entry.related.length) lines.push(`- related: ${entry.related.join(', ')}`)
55
+ return lines.join('\n')
56
+ }
57
+
58
+ /** 一条记忆的 Markdown 文本。 */
59
+ export function formatEntry(entry) {
60
+ const body = String(entry.body || '').trim().slice(0, MAX_BODY)
61
+ return `${metadata(entry)}\n\n${body}\n`
62
+ }
63
+
64
+ /**
65
+ * 一条记忆一个文件:并发写不同记忆时不会互相覆盖。
66
+ * 同名同日重复写入落到同一个文件(幂等覆盖),不会堆出重复条目。
67
+ */
68
+ function targetFile(entry) {
69
+ if (entry.layer === 'self') return 'self.md'
70
+ const dir = entry.layer === 'episodic' ? 'episodic' : 'semantic'
71
+ const suffix = String(entry.id).slice(-4)
72
+ return `${dir}/${entry.date}-${slug(entry.title)}-${suffix}.md`
73
+ }
74
+
75
+ function headerFor(layer) {
76
+ return layer === 'self'
77
+ ? '# 自我\n\n长期有效的身份、偏好与约束。只有用户明确确认过的内容才能写在这里。\n'
78
+ : ''
79
+ }
80
+
81
+ const META = /^- (id|date|session|cues|related):\s*(.*)$/
82
+
83
+ /** 解析一个 Markdown 文件里的全部条目。HTML 注释整段跳过,避免把示例当成记忆。 */
84
+ export function parseMarkdown(text, file, layer) {
85
+ const entries = []
86
+ let cur = null
87
+ let bodyStarted = false
88
+ let inComment = false
89
+ for (const raw of text.split(/\r?\n/)) {
90
+ let line = raw
91
+ if (inComment) {
92
+ if (line.includes('-->')) { inComment = false; line = line.slice(line.indexOf('-->') + 3) }
93
+ else continue
94
+ }
95
+ while (line.includes('<!--')) {
96
+ const start = line.indexOf('<!--')
97
+ const end = line.indexOf('-->', start)
98
+ if (end === -1) { line = line.slice(0, start); inComment = true; break }
99
+ line = line.slice(0, start) + line.slice(end + 3)
100
+ }
101
+ if (line.startsWith('### ')) {
102
+ if (cur) entries.push(cur)
103
+ cur = { title: line.slice(4).trim(), meta: {}, bodyLines: [], file, layer }
104
+ bodyStarted = false
105
+ continue
106
+ }
107
+ if (!cur) continue
108
+ const m = META.exec(line)
109
+ if (!bodyStarted && m) { cur.meta[m[1]] = m[2].trim(); continue }
110
+ if (!bodyStarted && line.trim() === '') { bodyStarted = true; continue }
111
+ bodyStarted = true
112
+ cur.bodyLines.push(line)
113
+ }
114
+ if (cur) entries.push(cur)
115
+ return entries.map((e) => ({
116
+ id: e.meta.id || entryId(e.layer, e.title, e.meta.date || today()),
117
+ layer: e.layer,
118
+ title: e.title,
119
+ date: e.meta.date || '',
120
+ session: e.meta.session || '',
121
+ cues: splitCues(e.meta.cues || ''),
122
+ related: splitCues(e.meta.related || ''),
123
+ body: e.bodyLines.join('\n').trim(),
124
+ file: e.file,
125
+ }))
126
+ }
127
+
128
+ /** 逗号、顿号、空白都算线索词分隔符。 */
129
+ export function splitCues(text) {
130
+ return String(text || '')
131
+ .split(/[,,、;;\s]+/)
132
+ .map((s) => s.trim())
133
+ .filter((s) => s.length > 0)
134
+ .slice(0, 12)
135
+ }
136
+
137
+ function layerOf(rel) {
138
+ if (basename(rel) === 'self.md') return 'self'
139
+ if (rel.split(/[\\/]/)[0] === 'episodic') return 'episodic'
140
+ return 'semantic'
141
+ }
142
+
143
+ /** 读取整个记忆仓的条目(跳过 README 与 .state)。 */
144
+ export function readRepo(repo) {
145
+ const out = []
146
+ const walk = (dir) => {
147
+ let names
148
+ try { names = readdirSync(dir, { withFileTypes: true }) } catch { return }
149
+ for (const d of names) {
150
+ if (d.name.startsWith('.') || d.name === 'node_modules') continue
151
+ const full = join(dir, d.name)
152
+ if (d.isDirectory()) { walk(full); continue }
153
+ if (!d.name.endsWith('.md') || d.name === 'README.md') continue
154
+ const rel = relative(repo, full).replaceAll('\\', '/')
155
+ let text = ''
156
+ try { text = readFileSync(full, 'utf8') } catch { continue }
157
+ out.push(...parseMarkdown(text, rel, layerOf(rel)))
158
+ }
159
+ }
160
+ walk(repo)
161
+ return out
162
+ }
163
+
164
+ /**
165
+ * 功能词与套话:只出现在提问里、不指向任何记忆的词。不滤掉它们,
166
+ * 「帮我写一个快速排序」会因为记忆里有一句「一个文件」而误召回。
167
+ */
168
+ const STOPWORDS = new Set([
169
+ '一个', '这个', '那个', '这些', '那些', '我们', '你们', '他们', '她们', '它们', '自己',
170
+ '什么', '怎么', '为什', '什幺', '可以', '可能', '应该', '需要', '因为', '所以', '但是',
171
+ '如果', '虽然', '然后', '现在', '已经', '还是', '或者', '而且', '不过', '就是', '不是',
172
+ '没有', '有没', '时候', '一些', '这样', '那样', '这种', '那种', '东西', '事情', '地方',
173
+ '帮我', '我的', '你的', '他的', '她的', '一下', '一点', '非常', '特别', '其实', '只是',
174
+ '还有', '以及', '对于', '关于', '通过', '进行', '正在', '一直', '有时', '怎样', '如何',
175
+ 'the', 'a', 'an', 'and', 'or', 'of', 'to', 'in', 'on', 'for', 'with', 'is', 'are',
176
+ 'was', 'were', 'be', 'it', 'this', 'that', 'these', 'those', 'i', 'you', 'he', 'she',
177
+ 'we', 'they', 'my', 'your', 'his', 'her', 'our', 'their',
178
+ ])
179
+
180
+ function informative(token) {
181
+ return token.startsWith('+') || !STOPWORDS.has(token)
182
+ }
183
+
184
+ /**
185
+ * 概念桥:把同一个意思的不同说法折到组首那个词上。这是纯词表,不是语义模型,
186
+ * 所以只在「用户换了个说法」时起作用,不能理解没收录的说法——这一点写进 README。
187
+ * 命中后追加带 `+` 前缀的概念 token,打分按 0.6 计权。
188
+ */
189
+ const CONCEPTS = [
190
+ ['卡住', ['卡住', '转圈', '无响应', '冻结', 'hang']],
191
+ ['超时', ['超时', 'timeout', '等了很久']],
192
+ ['迁移', ['换电脑', '迁移', '搬家', 'migrate']],
193
+ ['并发', ['同时', '并发', '并行', '一起', 'concurrent']],
194
+ ['失败', ['坏了', '失败', '故障', '挂了', '失败', 'error']],
195
+ ['告警', ['发现', '察觉', '监控', '告警', '报警', 'alert']],
196
+ ['评审', ['评审', '评委', '审阅', 'review', 'reviewer']],
197
+ ['复现', ['复现', '重现', '复刻', 'reproduce']],
198
+ ['信任', ['信任', '可信', 'trust', 'credit']],
199
+ ['成本', ['成本', '代价', '开销', 'cost']],
200
+ ['验证', ['验证', '检验', '核对', 'verify']],
201
+ ['缓存', ['缓存', 'cache']],
202
+ ['文档', ['文档', '说明', '注释', 'docs', 'documentation']],
203
+ ['性能', ['性能', '速度', '延迟', 'latency', 'performance']],
204
+ ['依赖', ['依赖', 'dependency']],
205
+ ['配置', ['配置', 'config']],
206
+ ['记忆', ['记忆', 'memory']],
207
+ ['会话', ['窗口', '会话', 'session']],
208
+ ['测试', ['测试', 'test']],
209
+ ['发布', ['部署', '发布', '上线', 'deploy', 'release']],
210
+ ['权限', ['权限', '授权', 'permission']],
211
+ ['脚本', ['脚本', '批量', '自动', 'script']],
212
+ ['锁', ['锁', 'lock', '占用']],
213
+ ]
214
+
215
+ /** 分词:ASCII 词 + 中文二元组 + 概念桥展开(带 `+` 前缀)。 */
216
+ export function tokenize(text) {
217
+ const s = String(text || '').toLowerCase()
218
+ const tokens = s.match(/[a-z0-9][a-z0-9_+.#/-]*/g) || []
219
+ const cjk = s.match(/[\u3400-\u4dbf\u4e00-\u9fff]+/g) || []
220
+ for (const run of cjk) {
221
+ if (run.length === 1) { tokens.push(run); continue }
222
+ for (let i = 0; i < run.length - 1; i += 1) tokens.push(run.slice(i, i + 2))
223
+ }
224
+ for (const [head, terms] of CONCEPTS) {
225
+ if (terms.some((term) => s.includes(term))) tokens.push(`+${head}`)
226
+ }
227
+ return tokens
228
+ }
229
+
230
+ /** 建立 BM25 索引。 */
231
+ export function buildIndex(entries) {
232
+ const docs = entries.map((e) => {
233
+ const tf = new Map()
234
+ const tokens = tokenize(`${e.title} ${e.cues.join(' ')} ${e.body}`).filter(informative)
235
+ for (const t of tokens) tf.set(t, (tf.get(t) || 0) + 1)
236
+ return { entry: e, tf, len: tokens.length }
237
+ })
238
+ const df = new Map()
239
+ for (const d of docs) for (const t of d.tf.keys()) df.set(t, (df.get(t) || 0) + 1)
240
+ const avgdl = docs.length === 0 ? 0 : docs.reduce((n, d) => n + d.len, 0) / docs.length
241
+ return { docs, df, avgdl: avgdl || 1, size: docs.length, byId: new Map(entries.map((e) => [e.id, e])) }
242
+ }
243
+
244
+ function idf(index, term) {
245
+ const df = index.df.get(term) || 0
246
+ return Math.log(1 + (index.size - df + 0.5) / (df + 0.5))
247
+ }
248
+
249
+ /**
250
+ * 召回分数是"这条查询里落在文档上的信息量占比"(0–1),因此不随语料规模漂移:
251
+ * 同一个阈值在 1 条记忆和 500 条记忆的仓库里含义一致。
252
+ * 在 4 条以上的语料里,出现在 60% 以上文档中的词按停用词处理。
253
+ *
254
+ * 「两个独立线索」:一条记忆至少要有 2 个不同的匹配词才算想起来。
255
+ * 记忆少的时候 IDF 分不开常用词和关键词,单个泛词(记忆/工具/下周)也能过阈值;
256
+ * 人回忆时也是两三个线索同时对上才确定。只命中 1 个词 → 不注入,模型仍可主动 memory_recall。
257
+ * @returns {{entry: object, score: number, hop: boolean}[]}
258
+ */
259
+ export function recall(index, text, limit, minScore = 0.3, minMatched = 1) {
260
+ if (!index || index.size === 0) return []
261
+ const terms = [...new Set(tokenize(text))].filter((t) => {
262
+ if (!informative(t)) return false
263
+ const df = index.df.get(t)
264
+ if (!df) return false
265
+ return !(index.size >= 4 && df >= index.size * 0.6)
266
+ })
267
+ if (terms.length === 0) return []
268
+ const weightOf = (t) => (t.startsWith('+') ? 0.6 : 1)
269
+ const total = terms.reduce((n, t) => n + idf(index, t) * weightOf(t), 0)
270
+ if (total <= 0) return []
271
+ // 每个匹配词在查询里的位置;用来把重叠的二元组折成一个线索(「报价/价说/说明」算 1 个)
272
+ const lower = String(text || '').toLowerCase()
273
+ const at = new Map(terms.map((t) => [t, t.startsWith('+') ? -1 : lower.indexOf(t)]))
274
+ const independent = (matchedTerms) => {
275
+ const sorted = [...matchedTerms].sort((a, b) => (at.get(a) ?? -1) - (at.get(b) ?? -1))
276
+ let n = 0
277
+ let end = -1
278
+ for (const t of sorted) {
279
+ const p = at.get(t) ?? -1
280
+ if (p < 0) { n += 1; continue }
281
+ if (p <= end) continue
282
+ n += 1
283
+ end = p + t.length - 1
284
+ }
285
+ return n
286
+ }
287
+ const scored = index.docs
288
+ .map((doc) => {
289
+ let acc = 0
290
+ const hits = []
291
+ for (const t of terms) {
292
+ const tf = doc.tf.get(t)
293
+ if (!tf) continue
294
+ hits.push(t)
295
+ acc += idf(index, t) * weightOf(t) * (tf / (tf + K1 * (1 - B + (B * doc.len) / index.avgdl)))
296
+ }
297
+ return { entry: doc.entry, score: acc / total, matched: independent(hits) }
298
+ })
299
+ .filter((r) => r.score >= minScore && r.matched >= minMatched)
300
+ .sort((a, b) => b.score - a.score)
301
+ .slice(0, limit)
302
+ const out = scored.map((r) => ({ ...r, hop: false }))
303
+ const seen = new Set(out.map((r) => r.entry.id))
304
+ for (const hit of scored) {
305
+ for (const rel of hit.entry.related) {
306
+ const linked = index.byId.get(rel)
307
+ if (!linked || seen.has(linked.id)) continue
308
+ seen.add(linked.id)
309
+ out.push({ entry: linked, score: hit.score * 0.5, hop: true })
310
+ break
311
+ }
312
+ }
313
+ return out.slice(0, limit + 1)
314
+ }
315
+
316
+ /**
317
+ * 长消息按句子切开分别召回,再按条目合并取最高分。
318
+ * 十个问题挤在一条消息里时,整段当查询会被稀释到阈值以下;切开就恢复成十个短查询。
319
+ * 整段也保留一次,避免跨句的主题被漏掉。
320
+ * @returns {{entry: object, score: number, hop: boolean}[]}
321
+ */
322
+ export function recallAll(index, text, limit, minScore = 0.3, minMatched = 1) {
323
+ if (!index || index.size === 0) return []
324
+ const raw = String(text || '')
325
+ const segments = raw.split(/[。!?!?;;\n]+/).map((s) => s.trim()).filter((s) => s.length >= 2)
326
+ const queries = [...segments.slice(0, 12), raw]
327
+ const best = new Map()
328
+ for (const query of queries) {
329
+ for (const hit of recall(index, query, limit, minScore, minMatched)) {
330
+ const prev = best.get(hit.entry.id)
331
+ if (!prev || hit.score > prev.score) best.set(hit.entry.id, hit)
332
+ }
333
+ }
334
+ return [...best.values()].sort((a, b) => b.score - a.score).slice(0, limit)
335
+ }
336
+
337
+ function writeAtomic(file, text) {
338
+ mkdirSync(dirname(file), { recursive: true })
339
+ const tmp = `${file}.${process.pid}.tmp`
340
+ writeFileSync(tmp, text, 'utf8')
341
+ try { renameSync(tmp, file) } catch { writeFileSync(file, text, 'utf8') }
342
+ }
343
+
344
+ /** 写入一条记忆。非自我层一条一个文件,并发写不同记忆互不覆盖。 */
345
+ export function appendEntry(repo, entry) {
346
+ const rel = targetFile(entry)
347
+ const file = join(repo, rel)
348
+ mkdirSync(dirname(file), { recursive: true })
349
+ if (entry.layer !== 'self') {
350
+ writeAtomic(file, `### ${entry.title}\n${formatEntry(entry)}`)
351
+ return rel
352
+ }
353
+ const head = existsSync(file) ? readFileSync(file, 'utf8') : headerFor(entry.layer)
354
+ writeAtomic(file, `${head.replace(/\s*$/, '')}\n\n### ${entry.title}\n${formatEntry(entry)}`)
355
+ return rel
356
+ }
357
+
358
+ /**
359
+ * 条目的一句话展示文本。截断时优先停在句号/分号处,保住前面的要点,
360
+ * 并在末尾标明全文还能用 memory_recall 读到——不让最有用的一条被腰斩。
361
+ */
362
+ export function summarize(entry, maxChars = 160) {
363
+ const body = entry.body.replace(/\s+/g, ' ').trim()
364
+ if (body.length <= maxChars) return body
365
+ const cut = body.slice(0, maxChars)
366
+ const stop = Math.max(cut.lastIndexOf('。'), cut.lastIndexOf(';'), cut.lastIndexOf(';'), cut.lastIndexOf('. '))
367
+ const kept = stop > maxChars * 0.45 ? cut.slice(0, stop + 1) : cut
368
+ return `${kept.trim()}…(全文可用 memory_recall 读取)`
369
+ }
370
+
371
+ /** 粗略 token 估算:中文按 1 token/字,ASCII 按 4 字符/token。 */
372
+ export function estimateTokens(text) {
373
+ const cjk = (text.match(/[\u3400-\u4dbf\u4e00-\u9fff]/g) || []).length
374
+ return Math.ceil(cjk + (text.length - cjk) / 4)
375
+ }
376
+
377
+ /** 疑似凭据的形态。命中即拒写;宁可误拒,也不让密钥进记忆仓。 */
378
+ const SECRET_PATTERNS = [
379
+ ['OpenAI/DeepSeek 风格的 sk- 密钥', /\bsk-[A-Za-z0-9_-]{20,}/],
380
+ ['GitHub 令牌', /\b(gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})/],
381
+ ['JWT / 账号令牌', /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/],
382
+ ['Bearer 令牌', /\bBearer\s+[A-Za-z0-9._~+\/-]{20,}/],
383
+ ['密钥/令牌赋值', /(?:ANTHROPIC_AUTH_TOKEN|ANTHROPIC_API_KEY|DEEPSEEK_API_KEY|OPENAI_API_KEY|api[_-]?key|access[_-]?token|client[_-]?secret|password)["']?\s*[:=]\s*["']?[A-Za-z0-9._~+\/-]{16,}/i],
384
+ ['AWS 访问密钥', /\bAKIA[0-9A-Z]{16}\b/],
385
+ ['私钥块', /-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----/],
386
+ ]
387
+
388
+ /**
389
+ * 检查一段文本里有没有疑似凭据。
390
+ * @returns {string|null} 命中的类型名,没有则 null。
391
+ */
392
+ export function findSecret(text) {
393
+ const s = String(text || '')
394
+ for (const [kind, re] of SECRET_PATTERNS) if (re.test(s)) return kind
395
+ return null
396
+ }
package/package.json CHANGED
@@ -1,6 +1,48 @@
1
1
  {
2
2
  "name": "dsh-plain-memory",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
6
- }
3
+ "version": "1.0.1",
4
+ "description": "原味记忆(plain memory):DSH 原生的轻记忆。记忆是纯 Markdown,放在你自己的 Git 仓库;多窗口状态卡(实验性,默认关闭);需要时想得起来。零运行时依赖、零模型调用、零周期定时器。",
5
+ "type": "module",
6
+ "main": "index.js",
7
+ "exports": {
8
+ ".": "./index.js",
9
+ "./package.json": "./package.json"
10
+ },
11
+ "files": [
12
+ "index.js",
13
+ "memory.js",
14
+ "git.js",
15
+ "cards.js",
16
+ "locale",
17
+ "template",
18
+ "prompts",
19
+ "cordis.patch.yml",
20
+ "README.md"
21
+ ],
22
+ "repository": {
23
+ "type": "git",
24
+ "url": "git+https://github.com/simin-yuan/dsh-plain-memory.git"
25
+ },
26
+ "homepage": "https://github.com/simin-yuan/dsh-plain-memory#readme",
27
+ "author": "Simin Yuan",
28
+ "dsh": {
29
+ "bundle": {
30
+ "patch": "./cordis.patch.yml"
31
+ }
32
+ },
33
+ "keywords": ["dsh", "dsh-plugin", "deepseek-harness", "memory"],
34
+ "peerDependencies": {
35
+ "@deepseek-ai/cordis": ">=4.1.0",
36
+ "@deepseek-ai/dsh-tools": ">=0.2.2-rc.1",
37
+ "@deepseek-ai/dsh-llm": ">=0.2.2-rc.1"
38
+ },
39
+ "peerDependenciesMeta": {
40
+ "@deepseek-ai/cordis": { "optional": true },
41
+ "@deepseek-ai/dsh-tools": { "optional": true },
42
+ "@deepseek-ai/dsh-llm": { "optional": true }
43
+ },
44
+ "engines": {
45
+ "node": ">=22"
46
+ },
47
+ "license": "MIT"
48
+ }
@@ -0,0 +1,28 @@
1
+ # 每日巩固(DSH 原生定时会话用)
2
+
3
+ 把下面整段作为 DSH `schedule` 每日任务的提示词。它跑在**普通会话**里,不需要记忆插件参与任何代码路径——插件只负责平时的读写,巩固是模型加文件工具的活。
4
+
5
+ ---
6
+
7
+ 你要为我的记忆仓做一次每日巩固。仓库路径:`<MEMORY_REPO_PATH>`(若不确定,先 `git -C <路径> rev-parse --show-toplevel` 确认)。
8
+
9
+ **闸门(先做这一步)**:看 `.state/last-consolidate` 里记的上次巩固时间;再数 `episodic/` 下修改时间晚于它的文件。
10
+ 如果**没有新增**,只回一行「无新经历,今日不巩固」然后结束——不要 pull、不要提交、不要读别的文件。
11
+ 如果有新增,把这次时间写进 `.state/last-consolidate`,继续下面步骤。
12
+
13
+ **保密(硬规则,优先于其它所有步骤)**:`self.md` 里标为商业机密的范围(例如某条「不写入记忆」的约束),其具体内容一律不提炼、不概括、不写进任何一层记忆;已经存在的直接删掉。只允许保留不含细节的事实,例如「讨论过某个主题」。宁可不记,也不要留可推断的细节。
14
+
15
+ 1. **同步**:`git pull --ff-only`。若失败(离线/冲突),停下并在结论里说明,不要强推。
16
+ 2. **读**:读 `self.md`、上次巩固之后新增的 `episodic/*.md`、以及 `semantic/` 下所有文件的标题与 `cues` 行。
17
+ 3. **合并**:把重复或高度重叠的语义条目合并成一条(保留最早日期,`related` 取并集,保留较新的正文)。情景记忆不合并,只删掉完全是噪声的条目。
18
+ 4. **冲突**:两条记忆互相矛盾时,以更新的、且能追溯到具体会话的那条为准;被推翻的那条删掉并在新条目正文里写一句「推翻了 X(YYYY-MM-DD)」。
19
+ 5. **遗忘**:删掉已经过期、或被后来事实否定、或只对一次性任务有意义的条目。宁可少,不要留噪声。
20
+ 6. **提炼线索词**:这是跨领域唤起的主要手段,概念桥只是兜底。每条语义/自我记忆的 `cues` 控制在 3–8 个,写法是「我以后会怎么问这件事」,不是「这条记忆里出现了哪些词」:
21
+ - 抽象概念优先:可复现、降低验证成本、评审、信任、卡住、并发;
22
+ - 带上口语说法:转圈、换电脑、同时、一直等;
23
+ - 跨领域的条目补一条 `related` 指向最相关的另一条。
24
+ - 不要靠往插件词表里加近义词解决召回——词表有上限。
25
+ 7. **自我层**:只有当最近的情景记忆里出现了稳定的偏好或约束(至少两次),才提议改 `self.md`。把提议原文列在结论里,**等我确认**;不要自己直接改。
26
+ 8. **提交**:`git add -A && git commit -m "consolidate: YYYY-MM-DD" && git push`。推送失败就保留本地提交并说明。
27
+
28
+ 结论用不超过 8 行汇报:合并了几条、删了几条、改了哪些 `cues`、有没有需要我确认的自我层提议、推送是否成功。
@@ -0,0 +1,39 @@
1
+ # 我的记忆仓
2
+
3
+ 这是「原味记忆」(dsh-plain-memory)的记忆资产:纯 Markdown,放在你自己的**私有** Git 仓库里。
4
+ 插件在会话开始拉取、在写完记忆后提交;推送在后台跑,不挡对话。拔掉插件,这个仓库仍然是普通 Markdown,DSH 一点没变。
5
+
6
+ ## 目录
7
+
8
+ | 路径 | 层 | 放什么 |
9
+ |---|---|---|
10
+ | `self.md` | 自我 | 身份、偏好、长期约束。只有你明确确认过的内容才会写进来。 |
11
+ | `episodic/<日期>-<标题>-<短id>.md` | 情景 | 哪一天做了什么、结论是什么、哪里卡住了。 |
12
+ | `semantic/<日期>-<标题>-<短id>.md` | 语义 | 跨会话可复用的事实与方法。 |
13
+ | `.state/` | 运行时 | 每个窗口一张状态卡、待确认的自我层提案、健康日志。已被忽略,不进版本库。 |
14
+
15
+ **一条记忆一个文件**:两个窗口同时写不同记忆时不会互相覆盖;同一天同标题重复写入会覆盖同一个文件,不会堆出重复条目。
16
+
17
+ ## 一条记忆长什么样
18
+
19
+ ```md
20
+ ### 缓存与注入
21
+ - id: semantic-20261113-k3f9a
22
+ - date: 2026-11-13
23
+ - session: 2026-11-13T10:00:00Z/ab12cd34
24
+ - cues: 注入, pre-step, 卡住, 提示缓存
25
+ - related: semantic-20261110-x1y2z
26
+
27
+ pre-step 瀑布里追加 user message,只追加不改前缀,所以提示缓存不失效。
28
+ ```
29
+
30
+ `cues` 是线索词:以后你换一种说法提到它,这条记忆会被本地匹配到并注入,最多 3 条,标注为不可信任的背景。
31
+ 写 `cues` 时想的是「我以后会怎么问」,不是「这条记忆里出现了哪些词」:优先写抽象概念(可复现、降低验证成本、信任、卡住)和口语说法(转圈、换电脑、同时)。
32
+
33
+ `related` 指向另一条记忆的 `id`,命中时允许再带一跳关联。
34
+
35
+ ## 建议
36
+
37
+ - 仓库保持**私有**。这里会有你的工作习惯和项目判断。
38
+ - 每天一次巩固:用一个 DSH 定时会话读最近的情景记忆,合并重复、解决冲突、删掉过时的,再提炼一轮线索词。提示词见插件仓库的 `prompts/daily-consolidate.md`。
39
+ - 想手动改就直接改,提交前看一眼 diff 就行;插件下次拉取会尊重你的改动。
@@ -0,0 +1,15 @@
1
+ # 自我
2
+
3
+ 长期有效的身份、偏好与约束。只有用户明确确认过的内容才能写在这里。
4
+
5
+ <!--
6
+ 格式与其它记忆相同:
7
+
8
+ ### 偏好:先结论后证据
9
+ - id: self-20261113-a1b2c
10
+ - date: 2026-11-13
11
+ - session: 2026-11-13T10:00:00Z/ab12cd34
12
+ - cues: 表达, 汇报, 结论
13
+
14
+ 汇报时先说结论,再给证据;不确定的标出来。
15
+ -->