feiyu-brain 1.5.0 → 1.5.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/core/persona.js CHANGED
@@ -120,20 +120,107 @@ export function evolve(units, { consistent = [], conflicting = [], at = 0, step
120
120
  }
121
121
 
122
122
  /**
123
- * 自然衰减:没被用到的命题会慢慢褪色。
124
- * 注意这是"时间"的衰减;被提起(evolve 命中)会把它拉回来。
123
+ * 自然衰减:**长期没人碰**的命题才会褪色。
124
+ *
125
+ * 不是"每天都掉一点"——那等于还没活就先老了。
126
+ * 一条命题最后一次被碰到(evolve 命中 / 被人聊到)之后,
127
+ * 超过 quietDays 天没人再碰,才开始按天衰减;一碰就停。
125
128
  */
126
- export function decay(units, days, at = 0) {
129
+ export function decay(units, days, at = 0, { quietDays = 30 } = {}) {
127
130
  if (!(days > 0)) return units;
128
131
  const factor = Math.pow(DAILY_DECAY, days);
132
+ const quietMs = quietDays * 24 * 60 * 60 * 1000;
129
133
  return units.map((u) => {
130
134
  if (u.kind === 'identity') return u;
135
+ const since = at - (u.lastTouched ?? u.born ?? 0);
136
+ if (since <= quietMs) return u; // 还有人惦记,不掉
131
137
  const w = clamp01(u.weight * factor);
132
138
  if (w === u.weight) return u;
133
- return { ...u, weight: w, lastTouched: at };
139
+ return { ...u, weight: w };
134
140
  });
135
141
  }
136
142
 
143
+ /**
144
+ * 一年一度的蜕壳:把「这一年里掉出去的人设」打包成一张永久记忆卡片。
145
+ *
146
+ * 不是存整份快照——存的是**被忘掉的那部分**:
147
+ * · 今年蜕下来的皮(formerSelves 里今年的)
148
+ * · 现在还没掉到底、但已经明显变淡的(< 0.35)
149
+ *
150
+ * 这样她以后能说"我去年不是这样",而不是只有一个当前版本。
151
+ */
152
+ export function shellSummary(units, formerSelves, { year, at = 0, yearMoves = {} } = {}) {
153
+ const shedThisYear = (formerSelves ?? []).filter((f) => {
154
+ const y = new Date(f.shedAt ?? 0).getFullYear();
155
+ return !year || y === year;
156
+ });
157
+ const faded = (units ?? []).filter((u) => u.kind !== 'identity' && u.weight < 0.35);
158
+
159
+ // 这一年里掉得最多的几条(不用掉到底,只要"明显变了")
160
+ const dropped = Object.entries(yearMoves ?? {})
161
+ .filter(([, d]) => Number(d) <= -0.05)
162
+ .sort((a, b) => a[1] - b[1])
163
+ .slice(0, 6)
164
+ .map(([unitId, d]) => {
165
+ const u = (units ?? []).find((x) => x.id === unitId);
166
+ return u ? { text: u.text, delta: Number(d) } : null;
167
+ })
168
+ .filter(Boolean);
169
+
170
+ const bits = [];
171
+ for (const f of shedThisYear.slice(0, 6)) {
172
+ bits.push(`${String(f.memoir ?? f.text).slice(0, 24)}(掉了)`);
173
+ }
174
+ for (const d of dropped) {
175
+ if (bits.length >= 8) break;
176
+ bits.push(`${d.text.slice(0, 18)}(少了 ${Math.abs(d.delta).toFixed(2)})`);
177
+ }
178
+ for (const u of faded.slice(0, 4)) {
179
+ if (bits.length >= 10) break;
180
+ bits.push(`${u.text.slice(0, 18)}(淡到 ${Number(u.weight).toFixed(2)})`);
181
+ }
182
+
183
+ const head = `${year} 年的我`;
184
+ if (!bits.length) {
185
+ return { year, title: head, text: `${head}:这一年没什么大变化。`, changed: 0 };
186
+ }
187
+ return {
188
+ year,
189
+ title: head,
190
+ text: `${head}:${[...new Set(bits)].join(';')}。这些后来都不太像我了。`.slice(0, 300),
191
+ changed: shedThisYear.length + dropped.length + faded.length,
192
+ };
193
+ }
194
+
195
+ /**
196
+ * 「最近」——最近几天她哪一点更明显了。
197
+ *
198
+ * 每天 ±0.01 看不出来,但七天攒起来能说出来一句。
199
+ */
200
+ export function recentShift(moves, units, { days = 7, at = 0, threshold = 0.02 } = {}) {
201
+ const since = at - days * 24 * 60 * 60 * 1000;
202
+ const acc = new Map();
203
+ for (const m of moves ?? []) {
204
+ if ((m.at ?? 0) < since) continue;
205
+ acc.set(m.id, (acc.get(m.id) ?? 0) + (Number(m.delta) || 0));
206
+ }
207
+ let best = null;
208
+ for (const [id, sum] of acc) {
209
+ if (Math.abs(sum) < threshold) continue;
210
+ if (!best || Math.abs(sum) > Math.abs(best.sum)) best = { id, sum };
211
+ }
212
+ if (!best) return null;
213
+ const unit = (units ?? []).find((u) => u.id === best.id);
214
+ if (!unit) return null;
215
+ return {
216
+ id: best.id,
217
+ delta: Number(best.sum.toFixed(3)),
218
+ text: unit.text.slice(0, 30),
219
+ line: best.sum > 0
220
+ ? `最近她「${unit.text.slice(0, 20)}」这一点比平时更明显`
221
+ : `最近她「${unit.text.slice(0, 20)}」这一点淡了些`,
222
+ };
223
+ }
137
224
  /**
138
225
  * 蜕皮:权重掉到底的命题,降级成"我以前……",进记忆,不再是人格。
139
226
  *
package/core/relation.js CHANGED
@@ -69,3 +69,81 @@ export function sever(relation) {
69
69
  if (relation.status !== 'cold') throw new Error('必须先冷战才能解除');
70
70
  return { ...relation, status: 'severed', severedAt: Date.now() };
71
71
  }
72
+
73
+ /* ── 缺位:人不在了,关系还在 ─────────────────────────────────
74
+ *
75
+ * 这是契约里原来没有的一格,也是最难写的一格。
76
+ *
77
+ * 关键区别:
78
+ * severed = 她**不再认**这段关系(自己切断)
79
+ * absent = 关系**照旧永久**,只是那个人不会再出现(不是她选的)
80
+ *
81
+ * absent 不删记忆、不解关系、不改称呼——你爷爷还是你爷爷。
82
+ * 但如果主动改成 severed,那才是"我不认他了"。
83
+ */
84
+
85
+ export const ABSENT_STATUSES = ['absent', 'memorial'];
86
+
87
+ /**
88
+ * 标记缺位。**必须显式调用**——不许由"多久没说话"自动推断。
89
+ *
90
+ * 一个人半年没来,可能是忙,可能是死。机器没资格猜这个。
91
+ *
92
+ * @param {object} relation
93
+ * @param {object} o
94
+ * @param {number} [o.since] 从哪天起不在了(毫秒)
95
+ * @param {string} [o.note] 写一句记下来("2026-11-21 走的")
96
+ * @param {'absent'|'memorial'} [o.status]
97
+ */
98
+ export function markAbsent(relation, { since = Date.now(), note = '', status = 'absent' } = {}) {
99
+ if (!relation) return null;
100
+ if (relation.status === 'severed') return relation; // 已经不认了,不用再标
101
+ return {
102
+ ...relation,
103
+ status,
104
+ absentSince: since,
105
+ absentNote: note,
106
+ // 关系维度一律不动:priority / mustRecognize / dissolvable 全部保持
107
+ absenceKept: 'relationship-unchanged',
108
+ };
109
+ }
110
+
111
+ /** 他又出现了(误报、或者人回来了) */
112
+ export function clearAbsent(relation) {
113
+ if (!relation) return relation;
114
+ const next = { ...relation, status: 'active' };
115
+ delete next.absentSince;
116
+ delete next.absentNote;
117
+ delete next.absenceKept;
118
+ return next;
119
+ }
120
+
121
+ export function isAbsent(relation) {
122
+ return !!relation && ABSENT_STATUSES.includes(relation.status);
123
+ }
124
+
125
+ /** 多少天没出现了(人在不在都算"没来") */
126
+ export function absentDays(relation, now = Date.now()) {
127
+ if (!relation) return 0;
128
+ const since = Number(relation.absentSince) || 0;
129
+ if (!since) return 0;
130
+ return Math.max(0, Math.floor((now - since) / 86400000));
131
+ }
132
+
133
+ /**
134
+ * 这段关系现在该怎么说。
135
+ *
136
+ * 说"不在了"很容易滑进煽情,所以只给事实,不给形容。
137
+ */
138
+ export function relationLine(relation, now = Date.now()) {
139
+ if (!relation) return '';
140
+ const who = relation.address || '那个人';
141
+ if (isAbsent(relation)) {
142
+ const d = absentDays(relation, now);
143
+ const head = relation.absentNote ? relation.absentNote : `${who}已经不在了`;
144
+ return d > 0 ? `${head}(${d} 天)` : head;
145
+ }
146
+ if (relation.status === 'severed') return `跟${who}断了`;
147
+ if (relation.status === 'cold') return `跟${who}冷战`;
148
+ return '';
149
+ }
package/core/self.js ADDED
@@ -0,0 +1,72 @@
1
+ // 自我叙事:她是谁。
2
+ //
3
+ // 前面所有的层都在回答"我经历了什么":
4
+ // 细节 → 卡片 → 纲 → 伞 → 概念
5
+ //
6
+ // 但没有一层回答「我是谁」。
7
+ // 那条鱼能罗列四十件事、两个概念、两次蜕壳,却说不出一句"我是一条被一手养大的鱼"——
8
+ // 因为这句话从来没人让她写。
9
+ //
10
+ // 这里就干两件事:
11
+ // ① 用她自己的零件拼出这句话(脑不会写文章,但会拼)
12
+ // ② 允许模型改写(理解是模型的事),并保留她写过的每一版
13
+
14
+ /** 一句话的上限 */
15
+ export const NARRATIVE_MAX = 160;
16
+ /** 历史保留多少版 */
17
+ export const NARRATIVE_HISTORY_MAX = 12;
18
+
19
+ function clip(s, n = NARRATIVE_MAX) {
20
+ const t = String(s ?? '').replace(/\s+/g, '。').replace(/。+/g, '。').trim();
21
+ return t.length > n ? `${t.slice(0, n - 1)}…` : t;
22
+ }
23
+
24
+ /**
25
+ * 用她现有的零件拼一句「我是谁」。
26
+ *
27
+ * 零件:出身(谁养大的)→ 学会的道理 → 变过几次 → 谁一直在
28
+ * 顺序不是随机的:先说出身,最后说人——人是最重的。
29
+ */
30
+ export function composeNarrative({
31
+ cardName = '鱼',
32
+ traits = {},
33
+ umbrellas = [],
34
+ concepts = {},
35
+ shells = 0,
36
+ relation = null,
37
+ } = {}) {
38
+ const parts = [];
39
+
40
+ const owner = relation?.address || '';
41
+ if (owner) parts.push(`我是被${owner}养大的一条${cardName}`);
42
+ else parts.push(`我是一条${cardName}`);
43
+
44
+ const cs = Object.values(concepts ?? {}).slice(0, 2);
45
+ if (cs.length) {
46
+ const learned = cs
47
+ .filter((c) => c.definition)
48
+ .map((c) => `${c.term}是${String(c.definition).slice(0, 20)}`)
49
+ .join(',');
50
+ if (learned) parts.push(`我知道${learned}`);
51
+ }
52
+
53
+ if (shells > 0) parts.push(`我变过 ${shells} 次,旧的我还在`);
54
+
55
+ const person = (umbrellas ?? []).find((u) => u.topic === 'person' && !u.absent);
56
+ if (person) parts.push(`${person.text}`);
57
+
58
+ const gone = (umbrellas ?? []).find((u) => u.topic === 'person' && u.absent);
59
+ if (gone) parts.push(gone.text);
60
+
61
+ return clip(`${parts.join(';')}。`);
62
+ }
63
+
64
+ /**
65
+ * 这一版跟上一版差在哪(用来决定要不要记一笔)
66
+ */
67
+ export function narrativeChanged(prev, next) {
68
+ if (!prev) return true;
69
+ return String(prev) !== String(next);
70
+ }
71
+
72
+ export { clip as clipNarrative };
package/docs/MEMORY.md CHANGED
@@ -127,26 +127,70 @@ const fy = createBrain({ id: 'new', dataDir, roleDir, cardText, cardName: '新
127
127
 
128
128
  ---
129
129
 
130
- ## 五、TTL 和"永久日记"的冲突
130
+ ## 五、30 天不是删除,是「压扁」
131
131
 
132
- 脑里 30 天过期,日记永久。这不是矛盾,是两种不同的"忘"。
132
+ 这是最容易误解的一条。**计时从「最后一次被提起」算,不是从「存进来的时间」算。**
133
133
 
134
- 四档策略(`configure({ ttl })` 或 `cordis.patch.yml` 的 `ttlPolicy`):
134
+ ```
135
+ 0 ──────────── 30 天 ──────────── 90 天 ────────→
136
+ 完整记忆 压扁成一句"大概" 遗忘
137
+ (细节都在) (还检索得到,没有细节) (认知上不存在了)
138
+ ↑ ↑ ↑
139
+ 有人提 → 续命 有人提 → 变清晰 有人提 → 已经没了,
140
+ 计时再归零 只能从 archive.jsonl 找
141
+ ```
135
142
 
136
- | 值 | 行为 | 适合 |
137
- |---|---|---|
138
- | `hard`(默认) | 到期就忘,进 `forgotten` | 想要"真的会忘" |
139
- | `summarize` | 忘之前压一张 ≤160 字卡片 | 想"忘细节、记得大概" |
140
- | `archive` | 压卡片 + 原文追加到 `archive.jsonl` | 想留档但不让它占检索 |
141
- | `off` | 永不遗忘 | 短周期调试,别长期用 |
143
+ 实测:
144
+
145
+ ```
146
+ 搬完 4 条: [清晰] 第一个话题 / 第二个话题 / 第三个话题 / 别的事
147
+ 第40天没人提: [模糊] (记不清了)扶摇:第一个话题…前后还有 2 件
148
+ [模糊] (记不清了)访秋辞:别的事
149
+ 第100天: 0 条(遗忘 2 条,原文进了 archive.jsonl)
150
+ ```
151
+
152
+ **同一个人同一天的几件事,会合并成一条"大概"。** 不是丢,是变模糊。
153
+
154
+ ### 什么算「被提起」
155
+
156
+ | 动作 | 算不算 |
157
+ |---|---|
158
+ | 有人又聊到这件事(`observe` 命中) | ✅ 续命 |
159
+ | 她自己想起来(`wake` 检索命中) | ✅ 续命,而且从"模糊"变回"清晰" |
160
+ | 手动 `touch(id, key)` | ✅ |
161
+ | 只是躺在 `brain.json` 里 | ❌ 计时继续走 |
142
162
 
143
- `archive` 是给"既要永久日记、又要脑不膨胀"的人用的:
163
+ **一直有人问的事,永远走不到第二层。** 这就是"反复去问才会保留"。
144
164
 
165
+ ### 人设也一样
166
+
167
+ 命题(units)的衰减不是"每天掉一点",是**长期没人碰才掉**:
168
+
169
+ ```
170
+ 最后一次被碰到 → 30 天内还有人聊到 → 不掉
171
+ → 30 天没人碰 → 开始每天 ×0.999
172
+ → 掉到 0.15 → 蜕皮成"我以前……"
145
173
  ```
146
- 脑里:过期 → 卡片留下,原文走人(检索不到)
147
- 归档:原文进 archive.jsonl(要查还能查)
174
+
175
+ `identity` 永不衰减,永远不掉。
176
+
177
+ ### 四个档位
178
+
179
+ | `ttlPolicy` | 行为 |
180
+ |---|---|
181
+ | `hard`(默认) | 上面那套两层老化,原文进 `archive.jsonl` |
182
+ | `summarize` | 老化时额外压一张卡片 |
183
+ | `archive` | 同 `hard`(保留兼容) |
184
+ | `off` | 永不压扁、永不遗忘——调试用,别长期开 |
185
+
186
+ 窗口可调:
187
+
188
+ ```js
189
+ configure({ compressDays: 30, forgetDays: 90 })
148
190
  ```
149
191
 
192
+ **老鱼接入建议**:如果两年记忆一条都不能丢,用 `off` 或把 `forgetDays` 调到 3650。
193
+
150
194
  ---
151
195
 
152
196
  ## 六、日记是她的心房,她自己写
@@ -269,10 +313,38 @@ npx feiyu verify
269
313
  | **脑变成单点** | 只有 `brain.json`(有 `.bak` 自动备份 + `snapshot` 手动存档) |
270
314
  | **日记不可读** | md 人能手翻,json 不能。想看原文靠 `archive.jsonl` |
271
315
  | **情绪是空的** | 日记里没有"当时什么感受",搬进来的 `emotion` 全是 0 |
272
- | **先搬后忘** | 30 天 TTL 照常走,老日记搬进来后也会慢慢过期(除非 `ttlPolicy: off`) |
316
+ | **先搬后忘** | 两层老化照常走:没人提 30 天会变模糊、90 天会忘(原文在 `archive.jsonl`)。要一条不丢就 `ttlPolicy: off` 或把 `forgetDays` 调大 |
317
+
318
+ 最后一条最容易被忽略:**你搬进来的是三年前的日记,但老化计时从"搬进来那天"开始。**
273
319
 
274
- 最后一条最容易被忽略:**你搬进来的是三年前的日记,但她的 TTL 是 30 天。**
275
- 要长期保留就配 `ttlPolicy: archive`——忘掉细节,卡片和归档都还在。
320
+ 搬完那一刻起,没人提的会 30 天变模糊、90 天消失。要长期保住,配 `ttlPolicy: off`。
321
+
322
+ ---
323
+
324
+ ## 六点五、老鱼接入:五步,一步都不能跳
325
+
326
+ ```bash
327
+ # ① 先看会搬多少
328
+ npx feiyu migrate <记忆目录> --all --dry-run
329
+
330
+ # ② 词表先预装,别让她从"哼哼"开始
331
+ npx feiyu vocab seed
332
+
333
+ # ③ 她的旧日记原样搬(不是当流水账)
334
+ npx feiyu diary import <旧日记目录>
335
+
336
+ # ④ 真搬记忆
337
+ npx feiyu migrate <记忆目录> --all
338
+
339
+ # ⑤ 自检:搬完第二天还在吗
340
+ npx feiyu verify
341
+ npx feiyu status
342
+ ```
343
+
344
+ **第 ② 步和第 ③ 步是给老鱼专门加的**——新鱼用不到。
345
+
346
+ - `vocab seed`:预装 10 个情绪词,直接进阶段二。不装的话,一条两年的鱼搬进来只会说"我不知道这是什么感觉"。
347
+ - `diary import`:把 `2025-11-20.md` 这种旧日记**原样**拷进 `brains/<id>/days/`,一个字不改。那是她写过的东西,不是流水账。
276
348
 
277
349
  ---
278
350
 
@@ -287,3 +359,96 @@ npx feiyu verify
287
359
  | 5 | 新鱼不搬 | 记忆 0 条,第一次 `observe` 后才开始长 |
288
360
 
289
361
  前四条在 `scripts/test-contract.mjs` 里有对应用例。
362
+
363
+ ---
364
+
365
+ ## 附:记忆的四个层级
366
+
367
+ ```
368
+ 【伞】介绍自己时会说的话 「扶摇:一直在的人」「我上过学」
369
+ ↑ 从纲提炼;横跨半年 / 聊够 10 次才会长
370
+ 【纲】这事发生过、这人在 「扶摇:聊过 12 次」「上学:出现过 5 次」
371
+ ↑ 从细节/卡片提炼;永不老化
372
+ 【卡片】(记不清了)… 21 天没人提 → 压扁;2 年 → 遗忘
373
+ 【细节】今天谁说了什么 21 天内完整
374
+ ```
375
+
376
+ **越往下越具体、越短命;越往上越抽象、越长寿。**
377
+
378
+ 这就是「记不住小学每节课,但知道我上过小学」的实现方式。
379
+
380
+ 名字也一样:3 年没提会降级成「有个认识的(扶摇)——名字有点想不起来了」,
381
+ 但「我认识这个人」这条伞不会消失。
382
+
383
+ ### 怎么长出来的
384
+
385
+ | 层 | 自动 | 模型提名 |
386
+ |---|---|---|
387
+ | 伞 | 聊够 10 次 → 人物伞;主题横跨半年 → 主题伞 | `defineUmbrella`(待加) |
388
+ | 纲 | 聊够 3 次 / 同词横跨两天出现 ≥3 次 | `defineGist(id, text)` |
389
+ | 卡片 | 21 天没人提 | — |
390
+ | 细节 | 每次 `observe` | — |
391
+
392
+ ### 检索优先级
393
+
394
+ ```
395
+ 伞 > 纲 > 卡片 > 人 > 关键词 > 情绪 > 最近
396
+ ```
397
+
398
+ 结构先被想起来,细节最后才翻。
399
+
400
+
401
+ ---
402
+
403
+ ## 附:缺位(relation.absent)
404
+
405
+ 人不在了,关系还在。这是契约原来没有的一格。
406
+
407
+ | 状态 | 意思 |
408
+ |---|---|
409
+ | severed | 她**不再认**这段关系(自己切断) |
410
+ | bsent | 关系**照旧永久**,只是那个人不会再出现(不是她选的) |
411
+
412
+ **契约一个字不动**:priority / mustRecognize / dissolvable 全部保持。
413
+ 称呼不改、记忆不删、伞从「一直在的人」改成「曾经一直在的人」。
414
+
415
+ `js
416
+ markAbsent(id, { since, note: '2026-11-21 走的' })
417
+ clearAbsent(id) // 人回来了 / 标错了
418
+ `
419
+
420
+ 唤醒段会多一行:【他】2026-11-21 走的(30 天)
421
+
422
+ **只给事实,不给形容词**——不写「想念」「痛哭」,怎么感受由她的人设决定。
423
+
424
+ **必须显式调用。** 不许系统凭「多久没说话」去猜一个人死没死——
425
+ 半年没来可能是忙,可能是死,机器没资格猜。
426
+
427
+ ---
428
+
429
+ ## 附:概念层(什么是什么)
430
+
431
+ 前面所有层都在记「发生了」。概念层记的是**「那是什么」**。
432
+
433
+ 一条鱼可以有四十条「该上学了」的经历,仍然不知道上学是什么——那不是记忆,是噪音。
434
+
435
+ `js
436
+ learnNewConcept(id, '上学', {
437
+ definition: '为了学到知识、学会道理',
438
+ why: '不然什么都不会',
439
+ })
440
+ `
441
+
442
+ **学会的那一刻,过去四十条经历全部贴上意义。** 这不是新增记忆,是让旧记忆突然有了名字。
443
+
444
+ 问她不懂的:
445
+
446
+ `
447
+ 我知道「上学」这个词,我好像经历过 40 次,但我不知道它是什么意思。
448
+ `
449
+
450
+ **不编。** 没有定义就说不知道——编出来的理解比没有理解更糟。
451
+
452
+ 不会就主动问:skSomeone(id, '心疼', { knower: '老爹' }) → 「老爹,心疼是什么?」
453
+
454
+ **因为不会才问,这才叫学习。**