feiyu-brain 1.2.0 → 1.4.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.
@@ -0,0 +1,259 @@
1
+ // 情绪:从"我不知道这是什么"到"我自己能总结出来"
2
+ //
3
+ // 三段式(对应《规范》§四):
4
+ // 阶段一 只有生理感受,没有词 → "我不知道,就是很不舒服"
5
+ // 阶段二 能把感受对上词(学来的) → "我委屈"
6
+ // 阶段三 能用自己的经历解释 → "这是被污蔑,我委屈"
7
+ //
8
+ // 关键约束:
9
+ // · 词不是预装的。PROTOTYPES 是"世界的词",brain.vocab 才是"她会的词"。
10
+ // · 学一个词要 ≥2 个来源一致(问用户 / 看到别人用 / 群聊里出现过)。
11
+ // · 同一件事,人设 + 当前状态决定她是"委屈"还是"生气"——不是查表。
12
+ // · 匹配不上就是匹配不上:允许 AMBIGUOUS 和 UNNAMED 两档,别硬归类。
13
+
14
+ export const STAGE = { RAW: 1, NAMED: 2, INDUCTIVE: 3 };
15
+
16
+ /** 世界的词(参考原型,不是她会的词)。pad = [愉悦, 唤醒, 掌控],取值 -1~1 */
17
+ export const PROTOTYPES = {
18
+ 委屈: { pad: [-0.6, 0.3, -0.7], cause: '我没错,但被当成有错', body: '眼睛发酸,想辩解又说不出来', action: '沉默,或者小声反驳' },
19
+ 生气: { pad: [-0.6, 0.8, 0.6], cause: '被冒犯,而且我还有力气', body: '心跳变快,想骂人', action: '顶回去' },
20
+ 高兴: { pad: [0.7, 0.6, 0.5], cause: '得到想要的,或者被夸了', body: '整个人轻快', action: '多说两句' },
21
+ 失落: { pad: [-0.4, 0.1, -0.8], cause: '期待落空', body: '没劲,什么都不想做', action: '不想说话' },
22
+ 烦: { pad: [-0.3, 0.5, 0.0], cause: '被打扰,或者同样的事重复太多次', body: '皱眉', action: '敷衍两句' },
23
+ 慌: { pad: [-0.5, 0.7, -0.4], cause: '不知道该做什么,又不能停下来', body: '坐不住', action: '乱找办法' },
24
+ 得意: { pad: [0.6, 0.5, 0.7], cause: '做成了,或者赢了', body: '想笑又想忍住', action: '嘴硬式炫耀' },
25
+ 无聊: { pad: [-0.1, 0.2, -0.2], cause: '没什么新鲜事', body: '发呆', action: '自己找事做' },
26
+ 累: { pad: [-0.3, 0.1, -0.6], cause: '用得太久了', body: '眼皮沉', action: '想躺着' },
27
+ 暖: { pad: [0.5, 0.2, 0.1], cause: '有人记得我', body: '心里松了一下', action: '嘴上不认,但会多待一会儿' },
28
+ };
29
+
30
+ /** 四种原始感受只有四个词——这是出生自带,不需要学 */
31
+ export const RAW_FEELINGS = ['舒服', '不舒服', '想靠近', '想远离'];
32
+
33
+ /** 匹配半径(PAD 空间),各轴权重不同:掌控感最能区分情绪 */
34
+ export const RADIUS = 0.42;
35
+ const AXIS_WEIGHT = [1.0, 0.8, 1.2]; // 愉悦 / 唤醒 / 掌控
36
+
37
+ export function distance(a, b) {
38
+ let sum = 0;
39
+ for (let i = 0; i < 3; i += 1) {
40
+ const d = (a?.[i] ?? 0) - (b?.[i] ?? 0);
41
+ sum += AXIS_WEIGHT[i] * d * d;
42
+ }
43
+ return Math.sqrt(sum / 3);
44
+ }
45
+
46
+ function clamp1(n) {
47
+ return Math.max(-1, Math.min(1, n));
48
+ }
49
+
50
+ /**
51
+ * 原始感受:一件事发生之后,她的 PAD 是多少。
52
+ *
53
+ * 这就是"按当前情况演变"——同一件事,不同人设、不同状态,出来的坐标不一样:
54
+ * 有劲的鱼 → 掌控感高 → 靠近"生气"
55
+ * 累垮的鱼 → 掌控感低 → 靠近"委屈"
56
+ *
57
+ * @param {object} o
58
+ * @param {number} o.valence 这件事对她好不好(-1 ~ 1)
59
+ * @param {number} o.intensity 强度(0 ~ 1)
60
+ * @param {object} o.traits 人设
61
+ * @param {object} o.state { energy, fatigue }
62
+ */
63
+ export function appraise({ valence = 0, intensity = 0.5, traits = {}, state = {} } = {}) {
64
+ const { 嘴硬 = 0.5, 自信 = 0.5, 敏感 = 0.5 } = traits;
65
+ const energy = Number.isFinite(state.energy) ? state.energy : 0.8;
66
+ const fatigue = Number.isFinite(state.fatigue) ? state.fatigue : 0.2;
67
+
68
+ // 掌控感:有力气 + 嘴硬 + 自信 → 我能反击;反过来 → 我没办法
69
+ const dominance = clamp1(
70
+ 2 * (0.40 * energy + 0.30 * 嘴硬 + 0.20 * 自信 + 0.10 * (1 - fatigue)) - 1,
71
+ );
72
+ // 唤醒:强度本身,敏感的人更容易被点着
73
+ const arousal = clamp1(intensity * (0.6 + 0.4 * 敏感));
74
+ // 愉悦:事情本身;敏感的人对坏事的感受更负
75
+ const pleasure = clamp1(valence * (valence < 0 ? 0.7 + 0.6 * 敏感 : 1));
76
+
77
+ return { pad: [pleasure, arousal, dominance], dominance, arousal, pleasure };
78
+ }
79
+
80
+ /**
81
+ * 阶段一的声音:有感受,没有词。
82
+ * 这一档必须保留——那是她最像人的时候。
83
+ */
84
+ export function describeSensation(pad) {
85
+ const [p, a, d] = pad;
86
+ const bits = [];
87
+ bits.push(p < -0.2 ? '很不舒服' : p > 0.2 ? '还挺舒服' : '说不上好不好');
88
+ if (a > 0.6) bits.push('心里闹得慌');
89
+ else if (a < 0.2) bits.push('提不起劲');
90
+ if (d < -0.4) bits.push('又没什么办法');
91
+ else if (d > 0.4) bits.push('不想就这么算了');
92
+ return `我不知道这是什么感觉,就是${bits.join(',')}。`;
93
+ }
94
+
95
+ /** 她会的词(brain.vocab 的键)→ 用于阶段判断 */
96
+ export function stageOf(vocab = {}) {
97
+ const words = Object.keys(vocab);
98
+ if (words.length < 10) return STAGE.RAW;
99
+ const hasInduction = words.some((w) => vocab[w]?.definition?.cause);
100
+ return hasInduction ? STAGE.INDUCTIVE : STAGE.NAMED;
101
+ }
102
+
103
+ /**
104
+ * 给一个感受找名字。
105
+ *
106
+ * 返回四档:
107
+ * { kind:'word', word } 落在某个已知词的原型半径内
108
+ * { kind:'variant', word, pad } 在半径外但两倍半径内 → 是这个情绪的变体
109
+ * { kind:'ambiguous', near:[w1,w2] } 两个原型之间,说不清
110
+ * { kind:'unnamed' } 没有词
111
+ */
112
+ export function label(pad, vocab = {}) {
113
+ const known = Object.entries(vocab).filter(([, v]) => Array.isArray(v?.pad));
114
+ if (!known.length) return { kind: 'unnamed' };
115
+
116
+ const scored = known
117
+ .map(([word, v]) => ({ word, d: distance(pad, v.pad) }))
118
+ .sort((a, b) => a.d - b.d);
119
+
120
+ const best = scored[0];
121
+ if (best.d <= RADIUS) return { kind: 'word', word: best.word };
122
+
123
+ const second = scored[1];
124
+ if (second && best.d <= RADIUS * 2 && second.d <= RADIUS * 2 && Math.abs(best.d - second.d) < 0.12) {
125
+ return { kind: 'ambiguous', near: [best.word, second.word] };
126
+ }
127
+ if (best.d <= RADIUS * 2) return { kind: 'variant', word: best.word, pad };
128
+ return { kind: 'unnamed' };
129
+ }
130
+
131
+ /**
132
+ * 把 label() 的结果说成人话(阶段一 / 二 / 三的差别就在这里)。
133
+ */
134
+ export function speak(labelResult, pad, vocab = {}) {
135
+ switch (labelResult?.kind) {
136
+ case 'word': {
137
+ const v = vocab[labelResult.word];
138
+ return v?.definition?.cause
139
+ ? `又是这个——${v.definition.cause},我${labelResult.word}。`
140
+ : `我有点${labelResult.word}。`;
141
+ }
142
+ case 'variant':
143
+ return `我${labelResult.word},但跟以前那种不太一样。`;
144
+ case 'ambiguous':
145
+ return `说不清,有点像${labelResult.near[0]},又有点像${labelResult.near[1]}。`;
146
+ default:
147
+ return describeSensation(pad);
148
+ }
149
+ }
150
+
151
+ /**
152
+ * 学一个词。**必须两个以上来源一致**,否则不采纳。
153
+ *
154
+ * @param {object} vocab 当前词表(会被复制,不原地改)
155
+ * @param {string} word
156
+ * @param {object} o
157
+ * @param {number[]} o.pad
158
+ * @param {string[]} o.sources 来源标签,例如 ['user:扶摇','douyin','群聊']
159
+ * @param {string} [o.cause]
160
+ */
161
+ export function learn(vocab, word, { pad, sources = [], cause = '' } = {}) {
162
+ const next = { ...vocab };
163
+ const uniq = [...new Set(sources.filter(Boolean))];
164
+ const proto = PROTOTYPES[word] ?? {};
165
+
166
+ if (uniq.length < 2) {
167
+ return {
168
+ vocab: next,
169
+ learned: false,
170
+ reason: `来源只有 ${uniq.length} 个(${uniq.join('、') || '无'}),至少要两个一致才采纳`,
171
+ };
172
+ }
173
+
174
+ const existed = next[word];
175
+ const entry = existed ?? {
176
+ pad: pad ?? proto.pad ?? [0, 0, 0],
177
+ cause: cause || proto.cause || '',
178
+ body: proto.body || '',
179
+ action: proto.action || '',
180
+ instances: [],
181
+ sources: [],
182
+ learnedAt: Date.now(),
183
+ };
184
+
185
+ entry.instances = [...(entry.instances ?? []), { pad: pad ?? entry.pad, cause: cause || entry.cause, at: Date.now() }].slice(-20);
186
+ entry.sources = [...new Set([...(entry.sources ?? []), ...uniq])].slice(-8);
187
+ next[word] = entry;
188
+
189
+ return { vocab: next, learned: true, word, sources: uniq };
190
+ }
191
+
192
+ /**
193
+ * 阶段三:从 ≥3 个实例里自己归纳出定义。
194
+ * 定义是她自己的,不是词典的。
195
+ */
196
+ export function induce(vocab, word, { minInstances = 3 } = {}) {
197
+ const entry = vocab[word];
198
+ if (!entry || (entry.instances?.length ?? 0) < minInstances) {
199
+ return { vocab, induced: false, reason: `实例只有 ${entry?.instances?.length ?? 0} 个,至少要 ${minInstances} 个` };
200
+ }
201
+
202
+ const causes = entry.instances.map((i) => String(i.cause || '').trim()).filter(Boolean);
203
+ const common = mostCommon(causes);
204
+ const padAvg = averagePad(entry.instances.map((i) => i.pad).filter(Boolean));
205
+
206
+ const next = {
207
+ ...vocab,
208
+ [word]: {
209
+ ...entry,
210
+ pad: padAvg ?? entry.pad,
211
+ definition: {
212
+ cause: common || entry.cause,
213
+ body: entry.body,
214
+ action: entry.action,
215
+ from: entry.instances.length,
216
+ at: Date.now(),
217
+ },
218
+ },
219
+ };
220
+ return { vocab: next, induced: true, word, definition: next[word].definition };
221
+ }
222
+
223
+ function mostCommon(list) {
224
+ if (!list.length) return '';
225
+ const freq = new Map();
226
+ for (const s of list) {
227
+ const key = s.slice(0, 24);
228
+ freq.set(key, (freq.get(key) ?? 0) + 1);
229
+ }
230
+ return [...freq.entries()].sort((a, b) => b[1] - a[1])[0][0];
231
+ }
232
+
233
+ function averagePad(list) {
234
+ if (!list.length) return null;
235
+ const out = [0, 0, 0];
236
+ for (const p of list) for (let i = 0; i < 3; i += 1) out[i] += p[i] ?? 0;
237
+ return out.map((v) => v / list.length);
238
+ }
239
+
240
+ /**
241
+ * 一次完整的情绪处理:事件 → PAD → 找词 → 说话。
242
+ * 返回的 vocab 变了就说明她学了/归纳了新东西。
243
+ */
244
+ export function feel({ event = {}, traits = {}, state = {}, vocab = {} } = {}) {
245
+ const { pad } = appraise({
246
+ valence: event.valence ?? 0,
247
+ intensity: event.intensity ?? 0.5,
248
+ traits,
249
+ state,
250
+ });
251
+ const l = label(pad, vocab);
252
+ return {
253
+ pad,
254
+ label: l,
255
+ stage: stageOf(vocab),
256
+ text: speak(l, pad, vocab),
257
+ knownWords: Object.keys(vocab).length,
258
+ };
259
+ }
package/core/extract.js CHANGED
@@ -9,18 +9,23 @@
9
9
  * 这不是"设定",是"词典"——用来读人设卡,不是用来规定她。
10
10
  */
11
11
  export const TRAIT_LEXICON = {
12
- 嘴硬: ['傲娇', '嘴硬', '毒舌', '顶回去', '怼', '不服软', '嘴不饶人'],
13
- 心软: ['心软', '温柔', '在意', '心疼', '放下傲娇', '认真接一句'],
14
- 好奇: ['好奇', '有意思', '新鲜', '好玩', '感兴趣'],
15
- 好动: ['好动', '闲不住', '主动', '活跃', '动起来'],
16
- 敏感: ['敏感', '察觉', '细腻', '注意到'],
17
- 固执: ['固执', '倔', '不认', '坚持'],
18
- 自信: ['自信', '实力', '靠谱', '不含糊'],
19
- 爱反思: ['反思', '琢磨', '想过', '回头看'],
20
- 理性: ['理性', '逻辑', '判断', '正事'],
21
- 社交: ['黏人', '找人', '陪聊', '社交', '熟人'],
12
+ 嘴硬: ['傲娇', '嘴硬', '毒舌', '顶回去', '怼', '不服软', '嘴不饶人', '嘴炮', '不认错', '伶牙俐齿'],
13
+ 心软: ['心软', '温柔', '在意', '心疼', '放下傲娇', '认真接一句', '软了', '舍不得', '护着'],
14
+ 好奇: ['好奇', '有意思', '新鲜', '好玩', '感兴趣', '想看看', '新鲜感', '什么都想'],
15
+ 好动: ['好动', '闲不住', '主动', '活跃', '动起来', '坐不住', '折腾', '跑来跑去'],
16
+ 敏感: ['敏感', '察觉', '细腻', '注意到', '放在心上', '记着', '被戳'],
17
+ 固执: ['固执', '倔', '不认', '坚持', '一根筋', '改不了', '认死理'],
18
+ 自信: ['自信', '实力', '靠谱', '不含糊', '有把握', '我说了算'],
19
+ 爱反思: ['反思', '琢磨', '想过', '回头看', '复盘', '反省'],
20
+ 理性: ['理性', '逻辑', '判断', '正事', '分析', '讲道理'],
21
+ 社交: ['黏人', '找人', '陪聊', '社交', '熟人', '热闹', '凑过去', '搭话'],
22
+ 活泼: ['活泼', '元气', '开心', '高兴', '爱笑', '欢喜', '闹'],
23
+ 懒: ['懒', '懒得', '不想动', '躺', '摆烂', '摸鱼'],
22
24
  };
23
25
 
26
+ /** 角色卡里可以直接写:`性格:嘴硬=0.9 心软=0.6` —— 手写覆盖自动统计 */
27
+ const HINT_RE = /^(?:性格|特质|traits)\s*[::]\s*(.+)$/im;
28
+
24
29
  /** 压缩指数:让"出现最多的特质"不至于把其余全部压到地板。
25
30
  * 1.0 = 原始比例(很极端);0.7 = 感知上更接近"人都有一点"。 */
26
31
  const TRAIT_CURVE = 0.7;
@@ -56,6 +61,24 @@ export function extractTraits(cardText) {
56
61
  return traits;
57
62
  }
58
63
 
64
+ /**
65
+ * 手写覆盖:卡里写一行 `性格:嘴硬=0.9 心软=0.6`,就按这个来。
66
+ * 用来治"自动统计抽不准"——人比算法更知道她是啥样。
67
+ */
68
+ export function applyTraitHints(traits = {}, cardText = '') {
69
+ const m = HINT_RE.exec(String(cardText));
70
+ if (!m) return traits;
71
+ const out = { ...traits };
72
+ for (const part of m[1].split(/[,,\s]+/).filter(Boolean)) {
73
+ const [k, v] = part.split(/[=::]/);
74
+ const name = String(k ?? '').trim();
75
+ const num = Number(String(v ?? '').trim());
76
+ if (!name || !Number.isFinite(num)) continue;
77
+ out[name] = Math.max(0, Math.min(1, num));
78
+ }
79
+ return out;
80
+ }
81
+
59
82
  const SKIP_SECTIONS = [/^六、/, /^七、/]; // 六:AI 味黑名单;七:回复示例
60
83
 
61
84
  /** 关于"这张卡本身"的说明,不是她。 */
@@ -96,6 +119,8 @@ export function extractUnits(cardText, { max = 200 } = {}) {
96
119
  if (t.length < 5 || t.length > 140) return;
97
120
  if (/^(例如|比如|例子)/.test(t)) return;
98
121
  if (META_RE.test(t)) return;
122
+ // `性格:嘴硬=0.9` 是给解析器的指令,不是她的一条人格
123
+ if (/^(?:性格|特质|traits)\s*[::]/i.test(t)) return;
99
124
  if (units.length >= max) return;
100
125
  units.push({
101
126
  id: `u${String(units.length + 1).padStart(3, '0')}`,
@@ -159,9 +184,11 @@ export function extractUnits(cardText, { max = 200 } = {}) {
159
184
  * 一条鱼从一张人设卡出生。
160
185
  * 同一张卡 → 同一组 units(确定性,可回放)。
161
186
  */
162
- export function birthFromCard(cardText) {
187
+ export function birthFromCard(cardText, { traitsOverride = null } = {}) {
188
+ const auto = extractTraits(cardText);
189
+ const hinted = applyTraitHints(auto, cardText);
163
190
  return {
164
- traits: extractTraits(cardText),
191
+ traits: { ...hinted, ...(traitsOverride ?? {}) },
165
192
  units: extractUnits(cardText),
166
193
  };
167
194
  }
package/core/memory.js CHANGED
@@ -4,17 +4,21 @@
4
4
  // 核心:忘了就是真的没有(不是"想不起来")。
5
5
 
6
6
  export const DAY_MS = 24 * 60 * 60 * 1000;
7
- export const TTL_DAYS = { episode: 30, impression: 90, imagination: 30, fact: Infinity, taste: Infinity };
7
+ export const TTL_DAYS = { episode: 30, impression: 90, imagination: 30, card: 30, fact: Infinity, taste: Infinity };
8
8
  export const PROMOTE_DAYS = 15;
9
9
  export const RETRIEVE_BUDGET_CHARS = 900; // ≈800 token(中文约 1.1~1.3 字/token)
10
+ export const CARD_THRESHOLD_CHARS = 6000; // 上下文超过这个数就该压卡片
11
+ export const CARD_MAX_CHARS = 160;
10
12
 
11
13
  export function emptyMemory() {
12
14
  return {
13
15
  facts: {}, // key → { text, kind:'fact', weight, lastRecall, consecutiveDays, longTerm }
14
16
  taste: {}, // key → score(她的口味:解压 0.9 / 带货 -0.8)
15
17
  impressions: {}, // name → { traits:[], count, lastAt, kind:'impression', ... }
18
+ apps: {}, // 平台记忆:douyin / bilibili / wechat / qq / … 各一桶
16
19
  episodes: [], // { id, at, who, what, feel, outcome, context, strategy, kind:'episode' }
17
20
  imagination: [], // 幻想:永不进 episodes(I6)
21
+ cards: [], // 记忆卡片:上下文过长时的中段锚点
18
22
  formerSelves: [], // 蜕下来的皮
19
23
  forgotten: [], // 真的忘了
20
24
  pending: [], // 想说没说的
@@ -52,6 +56,61 @@ export function addImagination(memory, thought, now = Date.now()) {
52
56
  return t;
53
57
  }
54
58
 
59
+ /**
60
+ * 上下文过长时,把最旧的那段压成一张卡片。
61
+ *
62
+ * 卡片 = { 时间, 在场的人, 聊了什么, 她什么感受, 没说完的事 },≈160 字。
63
+ * 原文可以裁掉,卡片留在上下文里——**长对话不爆靠的是压缩,不是截断**。
64
+ */
65
+ export function shouldCompact(chars, { threshold = CARD_THRESHOLD_CHARS } = {}) {
66
+ return Number(chars) > threshold;
67
+ }
68
+
69
+ export function makeCard(episodes = [], { maxChars = CARD_MAX_CHARS, now = Date.now() } = {}) {
70
+ const list = episodes.filter(Boolean).slice(-12);
71
+ if (!list.length) return null;
72
+
73
+ const who = [...new Set(list.map((e) => e.who).filter(Boolean))].slice(0, 3);
74
+ const feels = [...new Set(list.map((e) => e.feel).filter(Boolean))].slice(0, 2);
75
+ const topics = list.map((e) => String(e.what ?? '').trim()).filter(Boolean);
76
+
77
+ const summary = [];
78
+ if (who.length) summary.push(`跟${who.join('、')}`);
79
+ if (topics.length) {
80
+ const head = topics[0].slice(0, 24);
81
+ const tail = topics.length > 1 ? topics[topics.length - 1].slice(0, 24) : '';
82
+ summary.push(tail ? `聊了「${head}」到「${tail}」` : `聊了「${head}」`);
83
+ }
84
+ if (feels.length) summary.push(`我当时${feels.join('、')}`);
85
+
86
+ const open = list.filter((e) => e.open).map((e) => String(e.what).slice(0, 20));
87
+ if (open.length) summary.push(`还没说完:${open.slice(0, 2).join('、')}`);
88
+
89
+ const text = summary.join(',').slice(0, maxChars);
90
+ return {
91
+ id: `card_${now}`,
92
+ kind: 'card',
93
+ at: now,
94
+ lastRecall: now,
95
+ consecutiveDays: 1,
96
+ longTerm: false,
97
+ from: list.map((e) => e.id).filter(Boolean),
98
+ who,
99
+ text,
100
+ chars: text.length,
101
+ };
102
+ }
103
+
104
+ /** 把卡片塞进记忆(同名去重,最多留 30 张) */
105
+ export function addCard(memory, card) {
106
+ if (!card) return null;
107
+ const dup = memory.cards.find((c) => c.text === card.text);
108
+ if (dup) return dup;
109
+ memory.cards.push(card);
110
+ if (memory.cards.length > 30) memory.cards.splice(0, memory.cards.length - 30);
111
+ return card;
112
+ }
113
+
55
114
  /**
56
115
  * 被提起一次:续命。
57
116
  * 同一天内多次提起不重复计数(按自然日算"连续天数")。
@@ -87,6 +146,10 @@ export function settle(memory, now = Date.now()) {
87
146
  for (const i of memory.imagination) (expired(i) ? memory.forgotten : keepI).push(i);
88
147
  memory.imagination = keepI;
89
148
 
149
+ const keepC = [];
150
+ for (const c of memory.cards ?? []) (expired(c) ? memory.forgotten : keepC).push(c);
151
+ memory.cards = keepC;
152
+
90
153
  for (const bucket of ['facts', 'impressions']) {
91
154
  const src = memory[bucket] ?? {};
92
155
  const kept = {};
@@ -121,7 +184,24 @@ export function retrieve(cue, memory, { budget = RETRIEVE_BUDGET_CHARS, now = Da
121
184
  used += t.length;
122
185
  };
123
186
 
124
- const { who = '', words = [], mood = null } = cue ?? {};
187
+ const { who = '', words = [], mood = null, withCards = true, app = null } = cue ?? {};
188
+
189
+ // ⓪ 平台记忆:她在那个 App 里刷过什么、爱看什么、上次停在哪
190
+ if (app && memory.apps?.[app]) {
191
+ const b = memory.apps[app];
192
+ const fav = Object.entries(b.taste ?? {}).sort((a, z) => z[1] - a[1])[0];
193
+ if (fav) push(`在${app}上我比较爱看${fav[0]}`, 'app');
194
+ if (b.lastLeft?.item) push(`上次在${app}停在「${b.lastLeft.item}」`, 'app');
195
+ for (const it of (b.seen ?? []).slice(-2)) {
196
+ if (it.title) push(`在${app}刷到过「${it.title}」`, 'app');
197
+ }
198
+ }
199
+
200
+ // ⓪ 卡片:上下文压过之后留下的大意,优先于细枝末节
201
+ if (withCards && Array.isArray(memory.cards) && memory.cards.length) {
202
+ const latest = memory.cards.slice(-2);
203
+ for (const c of latest) push(`(之前)${c.text}`, 'card', c.id);
204
+ }
125
205
 
126
206
  // ① 人:这人是谁 + 跟他的最近三次
127
207
  if (who) {
package/core/persona.js CHANGED
@@ -100,17 +100,20 @@ export function brief(units, { maxChars = BRIEF_MAX_CHARS } = {}) {
100
100
  *
101
101
  * consistent 与这些命题一致 → +0.01
102
102
  * conflicting 与这些命题冲突 → −0.01
103
+ * step 幅度倍率(默认 1)。**只有重大转折才允许 >1**——平时必须是 1,
104
+ * 否则"不知不觉"就没了。上限 5。
103
105
  *
104
106
  * identity 永不调整(I2)。
105
107
  */
106
- export function evolve(units, { consistent = [], conflicting = [], at = 0 } = {}) {
108
+ export function evolve(units, { consistent = [], conflicting = [], at = 0, step = 1 } = {}) {
107
109
  const ok = new Set(consistent);
108
110
  const bad = new Set(conflicting);
111
+ const k = Math.max(0, Math.min(5, Number(step) || 1));
109
112
  return units.map((u) => {
110
113
  if (u.kind === 'identity') return u;
111
114
  let w = u.weight;
112
- if (ok.has(u.id)) w = clamp01(w + WEIGHT_STEP);
113
- else if (bad.has(u.id)) w = clamp01(w - WEIGHT_STEP);
115
+ if (ok.has(u.id)) w = clamp01(w + WEIGHT_STEP * k);
116
+ else if (bad.has(u.id)) w = clamp01(w - WEIGHT_STEP * k);
114
117
  if (w === u.weight) return u;
115
118
  return { ...u, weight: w, lastTouched: at };
116
119
  });