feiyu-brain 1.4.2 → 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.
@@ -0,0 +1,170 @@
1
+ // 记忆搬迁:老鱼把过去搬进来,新鱼从零开始。
2
+ //
3
+ // 宿主的记忆和大脑的记忆不是一回事:
4
+ // 宿主日记 = 流水账(发生过什么)
5
+ // brain = 带情绪的经历(她记得什么)
6
+ //
7
+ // 所以搬迁不是"复制一份",是**有损转换**:只搬那些真的会留下印象的,
8
+ // 并且每条都标 source:'import',将来能分清"亲历"和"听说的"。
9
+
10
+ export const MIGRATE_FORMATS = ['jsonl', 'days', 'generic'];
11
+
12
+ /** 一条宿主记录 → 她的经历。缺正文的直接丢。 */
13
+ export function toEpisode(item, { source = 'import' } = {}) {
14
+ if (!item) return null;
15
+ const text = String(item.text ?? item.what ?? item.content ?? item.message ?? '').trim();
16
+ if (!text) return null;
17
+ const at = Number(item.at ?? item.time ?? item.ts ?? item.createdAt);
18
+ return {
19
+ who: String(item.who ?? item.sender ?? item.name ?? item.from ?? '').trim(),
20
+ what: text.slice(0, 140),
21
+ feel: String(item.feel ?? item.mood ?? '').trim(),
22
+ mood: String(item.mood ?? '').trim(),
23
+ emotion: Number(item.emotion ?? 0) || 0,
24
+ outcome: item.outcome ?? null,
25
+ context: item.context ?? null,
26
+ at: Number.isFinite(at) ? at : 0,
27
+ source,
28
+ };
29
+ }
30
+
31
+ /**
32
+ * 解析 JSONL(一行一条 JSON)。
33
+ * 坏行不炸,记进 errors 里——搬迁最怕"因为一行坏了整批不进"。
34
+ */
35
+ export function parseJsonl(text) {
36
+ const out = [];
37
+ const errors = [];
38
+ const lines = String(text ?? '').split(/\r?\n/);
39
+ lines.forEach((line, i) => {
40
+ const s = line.replace(/^\uFEFF/, '').trim();
41
+ if (!s || s.startsWith('//') || s.startsWith('#')) return;
42
+ try {
43
+ const obj = JSON.parse(s);
44
+ const ep = toEpisode(obj);
45
+ if (ep) out.push(ep);
46
+ else errors.push({ line: i + 1, reason: '没有正文' });
47
+ } catch {
48
+ errors.push({ line: i + 1, reason: '不是合法 JSON' });
49
+ }
50
+ });
51
+ return { episodes: out, errors };
52
+ }
53
+
54
+ /**
55
+ * 解析日记式 markdown。
56
+ *
57
+ * 不指望通用的自然语言理解——只认几种明确写法的行:
58
+ * - 某人:"说了什么" (冒号 + 引号)
59
+ * - 2026-11-20 某人:说了什么 (日期头 + 冒号)
60
+ * - `- 说了什么` (无主语,算旁白)
61
+ *
62
+ * 认不出来的行直接跳过,不猜。**搬迁宁可少搬,不能瞎搬。**
63
+ */
64
+ export function parseDailyNotes(text) {
65
+ const out = [];
66
+ const errors = [];
67
+ let currentDate = 0;
68
+ let head = '';
69
+
70
+ const lines = String(text ?? '').split(/\r?\n/);
71
+ lines.forEach((line, i) => {
72
+ const s = line.replace(/^\uFEFF/, '').trim();
73
+ if (!s) return;
74
+
75
+ // 日期标题:## 2026-11-20
76
+ const d = /(\d{4})-(\d{2})-(\d{2})/.exec(s);
77
+ if (d && (s.startsWith('#') || s.length < 24)) {
78
+ currentDate = Date.UTC(Number(d[1]), Number(d[2]) - 1, Number(d[3]), 12, 0, 0);
79
+ return;
80
+ }
81
+
82
+ // 说话行:某人:「…」 / 某人:…
83
+ const say = /^[-*]?\s*([^\s::]{1,16})\s*[::]\s*[「“"]?(.+?)[」”"]?$/.exec(s);
84
+ if (say && !/^\d/.test(say[1])) {
85
+ const who = say[1].trim();
86
+ const body = say[2].trim();
87
+ if (body.length >= 2 && who.length <= 12) {
88
+ out.push({
89
+ who,
90
+ what: body.slice(0, 140),
91
+ feel: '',
92
+ mood: '',
93
+ emotion: 0,
94
+ outcome: null,
95
+ context: null,
96
+ // 没有 `## YYYY-MM-DD` 日期头就不编时间——宁可空着,也不假装知道几号
97
+ at: currentDate ? currentDate + out.length * 60_000 : 0,
98
+ source: 'import',
99
+ });
100
+ return;
101
+ }
102
+ }
103
+
104
+ // 无主语的项目符号:算旁白,who 留空
105
+ const bullet = /^[-*]\s+(.+)$/.exec(s);
106
+ if (bullet && bullet[1].trim().length >= 4) {
107
+ out.push({
108
+ who: head,
109
+ what: bullet[1].trim().slice(0, 140),
110
+ feel: '',
111
+ mood: '',
112
+ emotion: 0,
113
+ outcome: null,
114
+ context: null,
115
+ at: currentDate + out.length * 60_000,
116
+ source: 'import',
117
+ });
118
+ return;
119
+ }
120
+
121
+ errors.push({ line: i + 1, reason: '认不出格式(跳过,不猜)' });
122
+ });
123
+
124
+ return { episodes: out, errors };
125
+ }
126
+
127
+ /** 已经是数组就直接用 */
128
+ export function parseGeneric(list) {
129
+ const out = [];
130
+ const errors = [];
131
+ (Array.isArray(list) ? list : []).forEach((item, i) => {
132
+ const ep = toEpisode(item);
133
+ if (ep) out.push(ep);
134
+ else errors.push({ line: i + 1, reason: '没有正文' });
135
+ });
136
+ return { episodes: out, errors };
137
+ }
138
+
139
+ /** 按格式选解析器 */
140
+ export function parseAny(text, format = 'jsonl') {
141
+ if (format === 'days') return parseDailyNotes(text);
142
+ if (format === 'generic') {
143
+ try {
144
+ const j = JSON.parse(text);
145
+ return parseGeneric(Array.isArray(j) ? j : j.episodes);
146
+ } catch {
147
+ return { episodes: [], errors: [{ line: 0, reason: '不是合法 JSON 数组' }] };
148
+ }
149
+ }
150
+ return parseJsonl(text);
151
+ }
152
+
153
+ /**
154
+ * 去重:同一段对话可能导两次。
155
+ * 键 = 谁 + 前 40 字 + 时间(没有时间就只按前两项)。
156
+ */
157
+ export function dedupe(episodes, { existing = [] } = {}) {
158
+ const key = (e) => `${e.who ?? ''}|${String(e.what ?? '').slice(0, 40)}|${e.at || 0}`;
159
+ const seen = new Set();
160
+ for (const e of existing) seen.add(key(e));
161
+ const fresh = [];
162
+ let dup = 0;
163
+ for (const e of episodes) {
164
+ const k = key(e);
165
+ if (seen.has(k)) { dup += 1; continue; }
166
+ seen.add(k);
167
+ fresh.push(e);
168
+ }
169
+ return { episodes: fresh, duplicated: dup };
170
+ }
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 };
@@ -0,0 +1,101 @@
1
+ # 适配器契约 · qq-bridge(SnowLuma / OneBot)
2
+
3
+ > 这份文档存在的原因:有人照着示例接线,因为 `recentMessages` 没有 `seq`,
4
+ > 大脑**静默地**不再长大,而 `feiyu_status` 一切正常。这个坑不该踩第二次。
5
+
6
+ ---
7
+
8
+ ## 一、宿主需要提供什么
9
+
10
+ `buildBrainLine(key, st, brain)` 和 `drainUnread(key, st, brain)` 都读同一个 `st`:
11
+
12
+ ```js
13
+ st = {
14
+ unread: [], // 可选,强烈建议有
15
+ recentMessages: [], // 可选,通常有,但常常没有 seq
16
+ }
17
+ ```
18
+
19
+ ### 消息字段
20
+
21
+ | 字段 | 必填 | 说明 | 缺了会怎样 |
22
+ |---|---|---|---|
23
+ | `sender` / `nickname` | 建议 | 谁说的,用于"对这个人有没有印象" | 记为无名 |
24
+ | `text` / `plain` / `tail` | **是** | 说了什么 | 这条被跳过(`skipped`) |
25
+ | `seq` | 否 | 单调递增序号,最好的去重键 | 退到下一级 |
26
+ | `messageId` | 否 | 消息 id,第二优先 | 退到下一级 |
27
+ | `time` | **强烈建议** | 毫秒时间戳,第三优先 + 排序用 | 没有去重键 → 契约告警 |
28
+ | `isSelf` | 否 | 是不是她自己发的 | 默认 false,可能把自己的话记成经历 |
29
+
30
+ **去重键优先级**:`seq` → `messageId` → `time + 前16字`。
31
+
32
+ 三级都拿不到时,这条**不会**被静默丢弃——会记一条 `contractWarning`:
33
+
34
+ ```js
35
+ ad.warnings() // → [{ at, code: 'E_NO_NEW_KEYS', detail }]
36
+ ```
37
+
38
+ 宿主可以把这个数组挂到自己的 `/status` 接口上。**"没长大"不该是玄学。**
39
+
40
+ ---
41
+
42
+ ## 二、两个入口
43
+
44
+ ### `drainUnread(key, st, brain, { limit })`
45
+
46
+ 把 `st.unread + st.recentMessages` 里**没经历过的**按时间升序逐条 `observe`。
47
+
48
+ ```js
49
+ const r = ad.drainUnread('group:123', st, brain);
50
+ // → { observed: 7, skipped: 0, merged: 0, remaining: 0, ok: true }
51
+ ```
52
+
53
+ - `observed` 真正进记忆的条数
54
+ - `skipped` 有键但没正文,跳过的条数
55
+ - `merged` 超过 `limit` 时被合并成一条「补看」的条数
56
+ - `remaining` 合并后还剩多少没处理
57
+
58
+ 默认 `limit = 20`(构造适配器时 `createBridgeAdapter({ limit })` 可改)。
59
+
60
+ ### `buildBrainLine(key, st, brain)`
61
+
62
+ 唤醒时调一次:内部先 `drainUnread`,再产出要拼进 prompt 的那一段。永远不抛,失败返回空串。
63
+
64
+ ---
65
+
66
+ ## 三、验收标准(改完照这个测)
67
+
68
+ | # | 场景 | 期望 |
69
+ |---|---|---|
70
+ | 1 | `recentMessages` 只有 `time`,没有 `seq` | 必须产生一条 episode |
71
+ | 2 | 一次给 10 条 unread | 10 条(或 1 条合并 + 明确说明),不能只 1 条且无提示 |
72
+ | 3 | 同一条消息重复喂 | 不重复经历 |
73
+ | 4 | 拿不到去重键 | `warnings()` 里有记录,不静默 |
74
+ | 5 | 超过 limit | `merged > 0`,且合并的那条正文写明"补看 N 条" |
75
+
76
+ 这五条在 `scripts/test-contract.mjs` 里都有对应用例,`npm test` 会跑。
77
+
78
+ ---
79
+
80
+ ## 四、常见误接
81
+
82
+ | 症状 | 原因 | 修法 |
83
+ |---|---|---|
84
+ | `feiyu_status` 正常,但权重永远不动 | 宿主没有传 `st`,或 `st` 里没有消息 | 确认 `buildBrainLine` 拿到了当前会话的 `st` |
85
+ | 只在第一次有反应,后面都像没听见 | 用了旧版 `observeOnce`(只取最新一条 + 只认 seq) | 升级到 1.6+,改用 `drainUnread` |
86
+ | 权重乱跳 | 同一个 `st` 被 `buildBrainLine` 和手动 `observeOnce` 各调一次 | 只留一个入口 |
87
+ | 记忆里出现她自己的话 | `isSelf` 没标 | 宿主侧补上 |
88
+
89
+ ---
90
+
91
+ ## 五、影子模式(试跑不伤人设)
92
+
93
+ ```js
94
+ const brain = createBrain({ id: 'fy-test', dataDir, roleDir, cardText, shadow: true })
95
+ ```
96
+
97
+ - `observe` 只写 `audit.jsonl`,**不动权重、不进记忆、不落盘**
98
+ - 返回 `{ shadow: true, wouldChange: [{ id, from, to }] }` —— 直接能看到"如果真接会长成什么样"
99
+ - `feiyu_status` 里 `runtime.shadow` 会显示 `true`
100
+
101
+ 跑够一百轮,看 `wouldChange` 和自己的预期对不对,再关掉 shadow 正式接。
@@ -0,0 +1,136 @@
1
+ # 1.5.0 更新说明
2
+
3
+ > 上一个线上版本:**1.4.2**
4
+ > 这一版回答三件事:**怎么不打架、怎么接别人的系统、怎么把过去搬进来。**
5
+
6
+ ---
7
+
8
+ ## 一、不打架(四种装法)
9
+
10
+ 以前只有「全开」和「全关」,装上去就得整个接管人设和记忆。
11
+
12
+ 现在能只取一部分:
13
+
14
+ | 姿势 | 怎么配 | 适合谁 |
15
+ |---|---|---|
16
+ | **整脑** | 全套 | 从零开始 / 决定整套换 |
17
+ | **只当记忆库** | `observe(..., { evolve:false })` | 人设已有,只缺记忆 |
18
+ | **只当情绪机** | `wakeLine(..., { sections:['mood'] })` | 只想让语气有起伏 |
19
+ | **只当身体** | `tools:['app']` | 只想让它会开 App |
20
+
21
+ 实测:全量唤醒 100 字 → 只点 `mood` **22 字**,叠加时 token 不会翻倍。
22
+
23
+ ---
24
+
25
+ ## 二、接别人的系统
26
+
27
+ ### ① HTTP 边车(任何语言)
28
+
29
+ ```bash
30
+ npx feiyu serve --port 7788
31
+ ```
32
+
33
+ ```python
34
+ requests.post('http://127.0.0.1:7788/wake',
35
+ json={'id':'default','sender':who,'text':msg})
36
+ ```
37
+
38
+ 12 个接口,默认只绑 `127.0.0.1`,设了 `--token` 就要带 `x-feiyu-token` 头。
39
+ **Python / Java / Go 不用再 spawn node 进程。**
40
+
41
+ ### ② 适配器契约写清楚了
42
+
43
+ `recentMessages` 没有 `seq` 时,旧版会**静默地**不再长大,而 `status` 一切正常——
44
+ 这个坑不该踩第二次。
45
+
46
+ - 去重键三级兜底:`seq` → `messageId` → `time`
47
+ - `drainUnread()` 批量经历:10 条记 10 条,不再只记最新那条
48
+ - 拿不到键时记 `contractWarnings`,不静默
49
+
50
+ ### ③ 情绪双源仲裁
51
+
52
+ 宿主已有 `emotion.json` 的,两套都能改情绪会打架。现在定优先级:
53
+
54
+ ```yaml
55
+ moodPolicy: brain # brain(脑说了算)| host(宿主说了算,feel 只算不写)| blend(各一半)
56
+ ```
57
+
58
+ ---
59
+
60
+ ## 三、把过去搬进来
61
+
62
+ ```bash
63
+ # 老鱼:整个记忆目录一次并进来
64
+ npx feiyu migrate D:\cici\qq-bridge\memory --all --delete-source
65
+
66
+ # 自检
67
+ npx feiyu verify
68
+ ```
69
+
70
+ - 自动认格式:`.jsonl` / `.md`(日记式)/ `.json`
71
+ - 认不出的行**跳过并报行号**,不猜
72
+ - 搬两次自动去重
73
+ - `--delete-source` 把原文件改名 `.migrated`(**不是删除**,删不删你决定)
74
+ - 超过 5000 条自动压卡片 + 归档,脑子不会膨胀
75
+
76
+ ### 日记是她的心房
77
+
78
+ 宿主的日记记"发生过什么",她记"我怎么想"。
79
+
80
+ ```bash
81
+ npx feiyu diary # 今天的素材 + 第一人称骨架
82
+ npx feiyu diary write ./note.md # 存回去
83
+ npx feiyu diary list
84
+ ```
85
+
86
+ 存 `brains/<id>/days/2026-11-21.md`,**跟宿主日记分开**。
87
+ 写完自动记一条经历,以后能想起"我写过什么"。
88
+
89
+ **日记带心情**:正文没写就补一行;她自己写了就不动;那天没记过就写"那天没记",不编。
90
+
91
+ ---
92
+
93
+ ## 四、装不上能自救了
94
+
95
+ ```bash
96
+ npx feiyu doctor # 只查
97
+ npx feiyu doctor --fix # 能修的替你修
98
+ ```
99
+
100
+ 查四件事并给具体修法:pnpm、插件登记(bundles)、工具白名单、数据目录。
101
+ `--fix` 会改 profile 的 `package.json` 和 `tool-allow.json`,改完要**完全退出 DSH 再启动**。
102
+
103
+ ---
104
+
105
+ ## 五、安全与可控
106
+
107
+ | 能力 | 干什么 |
108
+ |---|---|
109
+ | `shadow` 影子模式 | 只写 audit,权重一个不动——先试跑一百轮看会长成什么样 |
110
+ | `snapshot` / `restore` | 存档回滚,权重逐条还原 |
111
+ | `ttlPolicy` | `hard` / `summarize` / `archive`(忘细节但原文进归档)/ `off` |
112
+ | `body.owner: host` | 宿主管设备时,脑不抢(`E_HOST_OWNS`) |
113
+ | `identityCheck()` | 查记忆 / 自我叙事 / 关系三项,判断"换过去还是不是她" |
114
+ | `exportPack()` / `importPack()` | 连同记忆一起搬走 |
115
+
116
+ ---
117
+
118
+ ## 六、数字
119
+
120
+ | | 1.4.2 | 1.5.0 |
121
+ |---|---|---|
122
+ | 公开导出 | 105 | 131 |
123
+ | DSH 工具 | 6 | 9 |
124
+ | 测试 | 118 | 167 |
125
+ | 文档 | 8 | 12 |
126
+ | 包大小 | 86.8 KB | ~122 KB |
127
+
128
+ 新增文档:`MEMORY.md`(记忆怎么处理)、`ADAPTER-CONTRACT.md`(接线必看)、`TROUBLESHOOT.md`(装不上)。
129
+
130
+ ---
131
+
132
+ ## 七、没做的
133
+
134
+ - **HTTP 边车的鉴权只有共享 token** —— 没有用户体系,够本地用,不够多租户
135
+ - **多设备并发** —— 一次只有一具身体在动
136
+ - **迁移不做语义理解** —— 日记里认不出的行直接跳过,不猜