diff --git a/AGENTS.md b/AGENTS.md index 9247996..511873f 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -50,6 +50,14 @@ 誤殺防護：`speechBody()` 會先拿掉引號與 `code`，**提及不算使用**；「老實說」只擋開場。 最後是這一層的義務：**講自己的過去要有出處**——「我以前⋯」只能講 `recall` 查得到的轉折， `speechLint` 給 `level: "hint"`（不擋，但要人去驗），沒有紀錄就是編造自己的過去。 +8b. **情緒先行、會飽和、偏差看得見**：每輪注入之前先用 `readUserEmotion()` 讀對方那句話 + （十二類加權詞表、否定會擋掉命中、引號與 `code` 內不比對、標點只放大既有訊號）， + 回的是**訊號不是判定**——人格讀到的不一樣就以人格為準；`RESPONSE_STANCE` 給的是 + 「怎麼接」的**動作**不是罐頭句。每輪的偵測與 delta 記進 `state/felt.jsonl`， + `feltTrend()` 用近重遠輕的加權算走向。`applyEmotion()` 加了**飽和** + （`headroom^EMOTION_SATURATION_K`，往 baseline 回不壓）與**單輪預算** + （`EMOTION_TURN_BUDGET`=60），因為 delta 是人格自己挑的、只會往舒服的方向倒； + `emotion --audit` 把這個偏差印出來。 9. **人格可搬家**：`export` / `import`（單一 JSON bundle）。匯出只能匯出「本 session 載入的人格」， 其他人格一律 deny——匯出等於把記憶讀出來。 10. **人格有編號**：英文名全大寫＋兩位索引（`ASUNA-01`），同名才遞增。編號同時是新人格的 diff --git a/README.md b/README.md index 5ec7631..bc725d8 100644 --- a/README.md +++ b/README.md @@ -111,6 +111,26 @@ flowchart TB - **主導情緒**取「超出基線最多」的前三名，所以個性底色不會永遠霸榜。 - 觸發規則與事件→delta 對照表：`skills/persona-chat/reference/emotions.md`。 +**情緒先行：先讀對方那句話（`readUserEmotion`）。** 在這之前情緒**全部是人格自己填的**， +而人不會主動給自己扣分——結果是正向一路貼頂、負向整天不動。現在每輪注入之前會先讀一次 +對方的話：十二類加權詞表（強 3／一般 2／弱 1）、程度副詞乘係數（超 ×1.6、有點 ×0.6）、 +**否定會擋掉那次命中**（「我不害怕」不算 fear）、引號與 `` `code` `` 內不比對（提及不算使用）、 +標點只放大既有訊號不憑空長出新情緒。回的是**訊號不是判定**，人格讀到的不一樣就以人格為準。 +單獨測：`emotion --read "<他說的話>"`。 + +**怎麼接（`RESPONSE_STANCE`）**：注入的是**動作**不是句子——悲傷「先接住，不要急著給解法」、 +憤怒「不辯解，先認可能認的那一小塊」、焦慮「給具體的下一步與時間點，不要給保證」。 +罐頭同理心那類句子由講話規則擋掉。 + +**走向（`feltTrend`）**：每輪的偵測結果與套用的 delta 記進 `state/felt.jsonl`， +用近重遠輕的加權算最近幾輪的趨勢（不用多數決——會被離群值主導又丟掉強度）， +注入成「他最近 3 輪的走向：悲傷 ↘ 在退」。一直是同一種情緒就不要每輪用同一句接法。 + +**情緒調節**：delta 不再是加完直接 `clamp`。**飽和**——越接近端點同方向漲得越慢 +（`headroom^K`，永遠逼近 100 但到不了；往 baseline 回的方向不壓）；**單輪預算**—— +所有 `|delta|` 總和上限 60，超過等比例縮小。**偏差看得見**——`emotion --audit` +印出最近幾輪往舒服／往難受的總量與比例，正向佔 ≥ 90% 會被點名。 + ## 短期 → 長期的轉入條件（R1–R6） 寫在 `scripts/persona-lib.mjs` 的 `promotionCandidates()`，用 `candidates` 子指令查： diff --git a/scripts/persona-gitea.mjs b/scripts/persona-gitea.mjs index 3ff232b..9e923d9 100644 --- a/scripts/persona-gitea.mjs +++ b/scripts/persona-gitea.mjs @@ -75,6 +75,7 @@ export const AREAS = { "state/emotion.json", "state/inner.jsonl", "state/said.jsonl", + "state/felt.jsonl", "state/sleep.json", "memory/short-term.jsonl", "memory/inbox/", diff --git a/scripts/persona-lib.mjs b/scripts/persona-lib.mjs index ac5f94b..fb28861 100644 --- a/scripts/persona-lib.mjs +++ b/scripts/persona-lib.mjs @@ -303,21 +303,59 @@ export function decayEmotionBy(state, minutes = SLEEP_DECAY_MINUTES) { return state; } +// --------------------------------------------------------------------------- // +// 情緒調節：飽和與單輪預算 +// +// 沒有這兩條的時候，delta 是加完直接 clamp(0,100)——而 delta 一直是人格自己挑的， +// 沒有人會主動給自己扣分，結果就是正向一路貼頂（喜悅／平靜／感激同時 100， +// mood 的 valence 卡在 +100 失去解析度），負向整天不動。 +// +// 飽和：越接近端點，同方向的 delta 越小（headroom^K）。永遠逼近 100，不會真的到。 +// 預算：一輪之內所有 delta 的絕對值總和有上限，超過就等比例縮小。 +// --------------------------------------------------------------------------- // + +export const EMOTION_SATURATION_K = 1; // 0 = 不飽和；越大越難推到端點（1 = 線性遞減，永遠逼近但到不了 100） +export const EMOTION_TURN_BUDGET = 60; // 單輪所有 |delta| 的總和上限（emotions.md：單筆建議 ±3～±25） + +/** 這一筆 delta 實際能推動多少：往端點走會被壓，往 baseline 回來不壓。 */ +export function saturateDelta(level, delta, baseline = null) { + const d = Number(delta); + if (!Number.isFinite(d) || d === 0) return 0; + const lv = clamp(level); + // 往 baseline 的方向移動是「回歸」，不該被壓 + if (baseline !== null && Number.isFinite(Number(baseline))) { + const base = Number(baseline); + if ((d > 0 && lv < base) || (d < 0 && lv > base)) return d; + } + const headroom = d > 0 ? (100 - lv) / 100 : lv / 100; + return d * Math.pow(Math.max(0, headroom), EMOTION_SATURATION_K); +} + export function applyEmotion(state, deltas, trigger = "") { state = decayEmotion(state); - const applied = {}; + // 先算「想推多少」，超過單輪預算就等比例縮小——一次灌爆的路要堵起來 + const wanted = []; for (const [key, rawDelta] of Object.entries(deltas || {})) { if (!(key in EMOTIONS)) continue; const delta = Number(rawDelta); - if (!Number.isFinite(delta)) continue; + if (!Number.isFinite(delta) || delta === 0) continue; + wanted.push([key, delta]); + } + const demand = wanted.reduce((sum, [, d]) => sum + Math.abs(d), 0); + const budgetScale = demand > EMOTION_TURN_BUDGET ? EMOTION_TURN_BUDGET / demand : 1; + const applied = {}; + for (const [key, rawDelta] of wanted) { const before = Number(state.levels[key] ?? 0); - state.levels[key] = Math.round(clamp(before + delta) * 100) / 100; + const base = Number(state.baseline?.[key] ?? DEFAULT_BASELINE[key]); + const effective = saturateDelta(before, rawDelta * budgetScale, base); + state.levels[key] = Math.round(clamp(before + effective) * 100) / 100; applied[key] = Math.round((state.levels[key] - before) * 100) / 100; } state.updated_at = nowIso(); state.history_len = Number(state.history_len || 0) + 1; if (Object.keys(applied).length) { state.last_trigger = { at: nowIso(), summary: trigger || "", deltas: applied }; + if (budgetScale < 1) state.last_trigger.budget_scaled = Math.round(budgetScale * 100) / 100; } return state; } @@ -401,6 +439,176 @@ export function emotionBrief(slug, state = null) { ); } +// --------------------------------------------------------------------------- // +// 讀對方那句話的情緒（輸入端） +// +// 為什麼需要：在這之前，情緒**全部是人格自己填的** `--apply`。人不會主動給自己扣分， +// 所以正向一路漲、負向整天不動。把「對方那句話帶了什麼」變成獨立的訊號， +// 人格的 delta 才有外部依據。 +// +// 這裡回的是**訊號不是判定**：關鍵字永遠不准蓋掉語意，最後怎麼算還是人格自己決定。 +// 所以它處理否定與程度副詞（「我不害怕」不可判 fear），也給信心值讓人格知道要不要理它。 +// --------------------------------------------------------------------------- // + +/** 詞表：[詞, 權重]。權重 3 = 明講，2 = 一般，1 = 弱訊號。 */ +export const EMOTION_LEXICON = { + joy: [["開心", 3], ["快樂", 3], ["爽", 2], ["太好了", 3], ["高興", 3], ["滿足", 2], ["喜歡", 2], ["笑", 1], ["讚", 1]], + trust: [["交給你", 3], ["靠你", 2], ["相信", 3], ["放心", 2], ["我信", 3], ["拜託你", 1]], + anticipation: [["期待", 3], ["等不及", 3], ["快點", 2], ["什麼時候", 1], ["接下來", 1], ["想看", 2]], + gratitude: [["謝謝", 3], ["感謝", 3], ["辛苦了", 2], ["麻煩你了", 2], ["幫了大忙", 3]], + serenity: [["還好", 1], ["沒事", 1], ["安心", 2], ["放鬆", 2], ["慢慢來", 2], ["不急", 2]], + delight: [["居然", 2], ["竟然", 2], ["沒想到", 2], ["嚇一跳", 2], ["哇", 2], ["真的假的", 3]], + anger: [["生氣", 3], ["火大", 3], ["氣死", 3], ["不爽", 3], ["搞什麼", 3], ["夠了", 2], ["很扯", 2], ["離譜", 2]], + sadness: [["難過", 3], ["傷心", 3], ["孤單", 3], ["失落", 3], ["想哭", 3], ["累了", 2], ["沒力", 2], ["撐不住", 3], ["提不起勁", 3], ["沒意義", 2]], + fear: [["害怕", 3], ["好怕", 3], ["恐怖", 2], ["嚇死", 2], ["不敢", 2], ["危險", 1]], + disgust: [["噁心", 3], ["受不了", 2], ["厭倦", 2], ["煩死", 2], ["夠噁", 3]], + shame: [["丟臉", 3], ["對不起", 2], ["抱歉", 2], ["我的錯", 3], ["不好意思", 2], ["糗", 2], ["尷尬", 2], + ["做不好", 2], ["我沒用", 3], ["不夠好", 2], ["搞砸", 3]], + anxiety: [["焦慮", 3], ["不安", 3], ["緊張", 3], ["擔心", 3], ["怎麼辦", 3], ["來不及", 3], ["壓力", 2], ["睡不著", 2]], +}; + +const NEGATORS = ["不", "沒有", "沒", "別", "不要", "不會", "並不", "才不", "一點也不", "完全不"]; +const INTENSIFIERS = [["超", 1.6], ["非常", 1.6], ["很", 1.4], ["好", 1.2], ["真的", 1.3], ["有點", 0.6], ["稍微", 0.5], ["還算", 0.5], ["一點點", 0.5]]; +const NEG_WINDOW = 4; // 否定詞要在關鍵詞前幾個字內才算 + +function windowBefore(text, index, size = NEG_WINDOW) { + return text.slice(Math.max(0, index - size), index); +} + +/** + * 讀出對方這句話的情緒訊號。 + * + * @returns {{signals: Array<{key,zh,score}>, intensity: number, confident: boolean, marks: string[]}} + * `signals` 由強到弱；`intensity` 0–100；`confident` 表示夠強、值得讓人格參考。 + */ +export function readUserEmotion(text) { + const raw = String(text ?? ""); + // 引號裡是別人的話、code 是資料——跟講話的樣子同一套規則：提及不算使用 + const body = raw.replace(/`[^`]*`/g, " ").replace(/「[^」]*」|『[^』]*』/g, " "); + const scores = {}; + for (const [key, words] of Object.entries(EMOTION_LEXICON)) { + for (const [word, weight] of words) { + let from = 0; + for (;;) { + const at = body.indexOf(word, from); + if (at < 0) break; + from = at + word.length; + const before = windowBefore(body, at); + if (NEGATORS.some((n) => before.endsWith(n))) continue; // 「我不害怕」→ 這一命中不算 + const mult = INTENSIFIERS.find(([w]) => before.endsWith(w))?.[1] ?? 1; + scores[key] = (scores[key] ?? 0) + weight * mult; + } + } + } + // 標點與句式：只加溫、不定調。 + // 它們**放大已經在的訊號**，不憑空長出新的一種情緒——不然「居然修好了！！」會被讀出憤怒。 + const marks = []; + const amplify = (mult) => { for (const k of Object.keys(scores)) scores[k] *= mult; }; + if (/[！!]{2,}/.test(body)) { marks.push("連續驚嘆"); amplify(1.25); } + if (/(⋯⋯|……|\.\.\.)/.test(body)) { marks.push("欲言又止"); amplify(1.15); } + // 連續問號是少數可以自己成立的訊號：問到第二個問號的人多半在急 + if (/[？?]{2,}/.test(body)) { marks.push("連續問號"); scores.anxiety = (scores.anxiety ?? 0) + 0.8; } + const signals = Object.entries(scores) + .filter(([, v]) => v > 0) + .map(([key, v]) => ({ key, zh: EMOTIONS[key].zh, score: Math.round(v * 100) / 100 })) + .sort((a, b) => b.score - a.score) + .slice(0, 3); + const total = signals.reduce((sum, s) => sum + s.score, 0); + // 飽和曲線而不是線性乘：線性乘會讓「謝謝」跟「謝謝謝謝謝謝」都是 100，看不出差別 + const intensity = Math.round(100 * (1 - Math.exp(-total / 4))); + return { signals, intensity, confident: signals.length > 0 && signals[0].score >= 2, marks }; +} + +/** 對方是這個情緒的時候，我該怎麼接——寫的是**動作**，不是句子（罐頭句已被講話規則擋掉）。 */ +export const RESPONSE_STANCE = { + sadness: "先接住再說，不要急著給解法；句子放短，允許只回一句", + anxiety: "給具體的下一步與時間點，不要給「一定沒事」這種保證", + fear: "先講你會做什麼、什麼時候做；不要否認他的害怕", + anger: "不辯解。先認可能認的那一小塊，再講你的部分", + shame: "不要追問細節，把焦點從他身上移回事情", + disgust: "問他在意的是哪一點，不要跟著一起罵", + joy: "跟著高興，不要立刻把話題轉回正事", + delight: "接住那個意外，讓他把話講完", + gratitude: "收下就好，不要客套推回去", + trust: "他把事情交給你了——講你要怎麼做，不要再問一次要不要做", + anticipation: "給時間點，不要含糊", + serenity: "不用找話講，安靜也可以", +}; + +/** 把偵測結果寫成一行給人格看的話。 */ +export function userEmotionBrief(read) { + if (!read?.signals?.length) return ""; + const top = read.signals.map((s) => `${s.zh}${s.score >= 4 ? "（強）" : s.score >= 2 ? "（中）" : "（弱）"}`).join("、"); + const stance = RESPONSE_STANCE[read.signals[0].key]; + const marks = read.marks.length ? `；句子裡有${read.marks.join("、")}` : ""; + return `他這句的情緒訊號：${top}${marks}。怎麼接：${stance}。（這是關鍵字讀出來的**訊號**，不是判定——` + + "你讀到的跟它不一樣，以你讀到的為準。)"; +} + +// --------------------------------------------------------------------------- // +// 情緒的走向（不是只有當下這一格） +// +// 「他這三輪一直在低落」跟「他這一輪低落」該有完全不同的接法。 +// 近重遠輕的加權，不用多數決——多數決會被單一離群值主導，也丟掉強度。 +// --------------------------------------------------------------------------- // + +export const FELT_KEEP = 120; +export const feltPath = (slug) => path.join(personaDir(slug), "state", "felt.jsonl"); + +/** 記一輪：對方帶了什麼、我套用了什麼。 */ +export function recordFelt(slug, { user = null, mine = null, note = "" } = {}) { + if (!personaExists(slug)) return null; + const entry = { + ts: nowIso(), + user: user?.signals?.length ? { top: user.signals[0].key, signals: user.signals, intensity: user.intensity } : null, + mine: mine && Object.keys(mine).length ? mine : null, + note: String(note || "").slice(0, 200), + }; + if (!entry.user && !entry.mine) return null; + appendJsonl(feltPath(slug), entry); + return entry; +} + +/** 最近 n 輪對方情緒的加權走向：{key, zh, weight, direction, rounds}。 */ +export function feltTrend(slug, n = 5) { + const rows = readJsonl(feltPath(slug), n * 3).filter((r) => r.user?.top).slice(-n); + if (rows.length < 2) return null; + const weights = {}; + rows.forEach((row, i) => { + const w = i + 1; // 近重遠輕 + for (const s of row.user.signals || []) weights[s.key] = (weights[s.key] ?? 0) + s.score * w; + }); + const [key, weight] = Object.entries(weights).sort((a, b) => b[1] - a[1])[0] || []; + if (!key) return null; + const halves = [rows.slice(0, Math.ceil(rows.length / 2)), rows.slice(Math.ceil(rows.length / 2))]; + const avg = (arr) => (arr.length ? arr.reduce((s, r) => s + (r.user.signals.find((x) => x.key === key)?.score ?? 0), 0) / arr.length : 0); + const diff = avg(halves[1]) - avg(halves[0]); + const direction = diff > 0.5 ? "↗ 越來越強" : diff < -0.5 ? "↘ 在退" : "→ 持平"; + return { key, zh: EMOTIONS[key].zh, weight: Math.round(weight * 10) / 10, direction, rounds: rows.length }; +} + +/** 最近 n 輪我給自己套用的 delta 是不是只往一邊倒（只加分不扣分）。 */ +export function feltAudit(slug, n = 20) { + const rows = readJsonl(feltPath(slug), n * 2).filter((r) => r.mine).slice(-n); + let pos = 0; + let neg = 0; + for (const row of rows) { + for (const [key, d] of Object.entries(row.mine)) { + if (!(key in EMOTIONS)) continue; + const toward = EMOTIONS[key].polarity * Math.sign(Number(d) || 0); + if (toward > 0) pos += Math.abs(Number(d)); + else if (toward < 0) neg += Math.abs(Number(d)); + } + } + const total = pos + neg; + return { + rounds: rows.length, + positive: Math.round(pos * 10) / 10, + negative: Math.round(neg * 10) / 10, + positive_ratio: total ? Math.round((pos / total) * 100) : null, + }; +} + // --------------------------------------------------------------------------- // // 人格目錄骨架 // --------------------------------------------------------------------------- // @@ -2472,6 +2680,19 @@ export function turnContext(slug, sessionId, prompt = "") { "沒有紀錄就不要講——編一段轉折比講一句空話糟糕得多。同理，情緒要來自現在的情緒值，" + "不是為了有人味而加上去的。", ]; + // 情緒先行：先讀對方那句話帶了什麼，再談我自己的狀態。 + const read = readUserEmotion(prompt); + if (read.signals.length) { + lines.push(userEmotionBrief(read)); + recordFelt(slug, { user: read, note: String(prompt || "").slice(0, 80) }); + } + const trend = feltTrend(slug); + if (trend) { + lines.push( + `他最近 ${trend.rounds} 輪的走向：${trend.zh} ${trend.direction}。` + + "走向跟單輪不一樣——一直是同一種情緒，就不要每輪都用同一句接法。", + ); + } // 情緒會改變句子的形狀：緊張的人話說不完、彆扭的人先否認再承認。 const tells = emotionTells(slug, state); if (tells.length) { diff --git a/scripts/persona.mjs b/scripts/persona.mjs index f342b6d..92d1650 100644 --- a/scripts/persona.mjs +++ b/scripts/persona.mjs @@ -922,13 +922,41 @@ commands.emotion = ({ flags }) => { if (key in pl.EMOTIONS) state.baseline[key] = pl.clamp(value); } } + // 讀對方那句話的情緒訊號（不改狀態，只回報；`--read` 可以單獨拿來測詞表） + const readText = str(flags.read); + const read = readText ? pl.readUserEmotion(readText) : null; + if (read) { + emit({ persona: slug, read }, flags.json, [ + `讀「${readText.slice(0, 40)}」：`, + read.signals.length + ? ` 訊號：${read.signals.map((s) => `${s.zh} ${s.score}`).join("、")}｜強度 ${read.intensity}｜${read.confident ? "夠強，值得參考" : "偏弱，別當判定"}` + : " 沒有讀到明確的情緒訊號。", + ...(read.signals.length ? [` 怎麼接：${pl.RESPONSE_STANCE[read.signals[0].key]}`] : []), + ]); + return; + } + if (flags.audit) { + const audit = pl.feltAudit(slug, num(flags.limit, 20)); + const trend = pl.feltTrend(slug); + emit({ persona: slug, audit, trend }, flags.json, [ + `\`${slug}\` 最近 ${audit.rounds} 輪的情緒套用：`, + ` 往舒服的方向 ${audit.positive}｜往難受的方向 ${audit.negative}` + + (audit.positive_ratio === null ? "" : `　→ 正向佔 ${audit.positive_ratio}%`), + audit.positive_ratio !== null && audit.positive_ratio >= 90 + ? " ⚠ 幾乎只給自己加分——delta 是你自己挑的，這種偏差要自己看得見。" + : " 比例還算兩邊都有。", + trend ? ` 對方的走向：${trend.zh} ${trend.direction}（近 ${trend.rounds} 輪）` : " 還沒有足夠的輪次算走向。", + ]); + return; + } if (flags.apply) { if (role === "guest") die("guest（sub agent）不得改寫人格的情緒狀態。"); const deltas = parseDeltas(flags.apply); state = pl.applyEmotion(state, deltas, str(flags.trigger)); + pl.recordFelt(slug, { mine: state.last_trigger?.deltas || null, note: str(flags.trigger) }); pl.appendJsonl(pl.journalPath(slug), { ts: pl.nowIso(), kind: "emotion", trigger: str(flags.trigger), - deltas, levels: state.levels, mood: pl.mood(state), + deltas, applied: state.last_trigger?.deltas || {}, levels: state.levels, mood: pl.mood(state), }); } if (role !== "guest") pl.writeJson(pl.emotionPath(slug), state); @@ -1933,6 +1961,9 @@ const HELP = `persona.mjs — jsc-persona 人格 / 記憶 / 情緒 / 關係圖 C 情緒與圖： emotion --session [--apply joy=+10,...] [--baseline ...] [--trigger ] + [--read "<對方說的話>"] 只讀情緒訊號與該怎麼接，不改狀態 + [--audit [--limit 20]] 最近幾輪的 delta 是不是只往一邊倒＋對方的走向 + 套用時會飽和（越接近端點漲越慢）並受單輪預算限制（|delta| 總和 ≤ 40） mindmap show|thread|list --session [--topic ] [--force] relation node|edge|render|show --session [--name --id --kind --bond --closeness --trust --note --tags --from --to --label --affinity] relation style --session --name [--facet 稱呼 --value 親愛的 --except anger>=40 --since --clear] diff --git a/scripts/selftest.mjs b/scripts/selftest.mjs index 1f5d211..e6a59de 100644 --- a/scripts/selftest.mjs +++ b/scripts/selftest.mjs @@ -120,7 +120,10 @@ console.log("④ 情緒（六正向 + 六負向）"); check("十二種情緒", pl.EMOTION_KEYS.length === 12 && pl.POSITIVE.length === 6 && pl.NEGATIVE.length === 6); cli(["emotion", "--persona", "alpha", "--session", S_HOST, "--apply", "joy=+60,anger=+40", "--trigger", "selftest"]); let state = pl.loadEmotion("alpha"); -check("情緒有被施加", state.levels.joy >= 70, JSON.stringify(state.levels)); +// 施加後會被飽和與單輪預算縮小（見 applyEmotion）：推得動，但推不到端點 +check("情緒有被施加", state.levels.joy >= 45 && state.levels.anger >= 20, JSON.stringify(state.levels)); +check("單輪預算會把一次灌爆的量縮小", + state.levels.joy < 25 + 60 && pl.EMOTION_TURN_BUDGET === 60, JSON.stringify(state.levels)); state.updated_at = pl.iso(pl.minutesAgo(120)); const decayed = pl.decayEmotion(structuredClone(state)); const expected = state.baseline.joy + (state.levels.joy - state.baseline.joy) / 2; @@ -470,6 +473,67 @@ check("提醒的句子 room post 照樣發得出去", const voiceCtx = pl.turnContext("alpha", S_SPEAK, "你在幹嘛"); check("說話規則有注入黑名單與「過去要有出處」", voiceCtx.includes("罐頭同理心") && voiceCtx.includes("要有出處")); + +// --------------------------------------------------------------------------- // +// 情緒處理：讀對方那句話（輸入端）、走向、飽和與單輪預算 +console.log("\n情緒：讀對方那句話（SF：該讀到的）"); +const READ_SF = [ + ["直說難過", "我最近很難過", "sadness"], + ["自我否定", "我最近覺得自己什麼都做不好", "shame"], + ["生氣", "搞什麼啊，氣死我了", "anger"], + ["焦慮", "明天來不及了怎麼辦", "anxiety"], + ["道謝", "謝謝你，真的幫了大忙", "gratitude"], + ["託付", "這件事交給你", "trust"], +]; +for (const [label, text, key] of READ_SF) { + const r = pl.readUserEmotion(text); + check(`讀到${label}`, r.signals[0]?.key === key, `${text} → ${JSON.stringify(r.signals)}`); +} +console.log("\n情緒：讀對方那句話（SNF：不可誤讀的）"); +const READ_SNF = [ + ["否定句不算", "我不害怕，只是想確認一下", "fear"], + ["否定句不算（沒）", "我沒生氣", "anger"], + ["引號裡是別人的話", "他說「我好難過」，可是他在笑", "sadness"], + ["code 裡的欄位名不算", "這個 `sadness` 欄位要改嗎", "sadness"], +]; +for (const [label, text, key] of READ_SNF) { + const r = pl.readUserEmotion(text); + check(`不誤讀：${label}`, !r.signals.some((s) => s.key === key), `${text} → ${JSON.stringify(r.signals)}`); +} +check("程度副詞會調整強度", + pl.readUserEmotion("超級擔心").signals[0].score > pl.readUserEmotion("有點擔心").signals[0].score); +check("標點只放大既有訊號，不憑空長出新情緒", + !pl.readUserEmotion("居然真的修好了！！").signals.some((s) => s.key === "anger"), + JSON.stringify(pl.readUserEmotion("居然真的修好了！！").signals)); +check("每種情緒都有對應的「怎麼接」", + pl.EMOTION_KEYS.every((k) => typeof pl.RESPONSE_STANCE[k] === "string" && pl.RESPONSE_STANCE[k].length > 4)); + +console.log("\n情緒：飽和、單輪預算、走向、偏差稽核"); +let sat = pl.defaultEmotionState(); +for (let i = 0; i < 10; i += 1) sat = pl.applyEmotion(sat, { joy: +20 }, "連灌"); +check("連續 +20 十次推不到上限（飽和）", sat.levels.joy > 80 && sat.levels.joy < 100, `joy=${sat.levels.joy}`); +const budgeted = pl.applyEmotion(pl.defaultEmotionState(), { joy: +40, trust: +40, serenity: +40 }, "一次灌爆"); +const usedBudget = Object.values(budgeted.last_trigger.deltas).reduce((s, d) => s + Math.abs(d), 0); +check("單輪預算會等比例縮小（總需求 120 → 實際 ≤ 60）", + usedBudget <= pl.EMOTION_TURN_BUDGET && budgeted.last_trigger.budget_scaled < 1, `used=${usedBudget}`); +const backHome = pl.applyEmotion( + { ...pl.defaultEmotionState(), levels: { ...pl.defaultEmotionState().levels, joy: 95 } }, { joy: -20 }, "回歸"); +check("往 baseline 回的方向不被壓", Math.abs(backHome.levels.joy - 75) < 0.5, `joy=${backHome.levels.joy}`); +for (const line of ["我好難過", "還是很難過", "我真的撐不住了"]) pl.turnContext("alpha", S_SPEAK, line); +const trend = pl.feltTrend("alpha"); +check("走向：連續三輪低落會被算出來", trend?.key === "sadness" && trend.rounds >= 2, JSON.stringify(trend)); +const feelCtx = pl.turnContext("alpha", S_SPEAK, "我快撐不住了"); +check("注入有「他這句的情緒訊號」與「怎麼接」", + feelCtx.includes("情緒訊號") && feelCtx.includes("怎麼接")); +check("注入有最近幾輪的走向", feelCtx.includes("走向")); +cli(["emotion", "--persona", "alpha", "--session", S_SPEAK, "--apply", "joy=+10", "--trigger", "稽核用"]); +const audit = JSON.parse(cli(["emotion", "--persona", "alpha", "--session", S_SPEAK, "--audit", "--json"]).stdout); +check("--audit 看得出 delta 有沒有只往一邊倒", + audit.audit.rounds >= 1 && audit.audit.positive > 0, JSON.stringify(audit.audit)); +const readOut = JSON.parse(cli(["emotion", "--persona", "alpha", "--session", S_SPEAK, + "--read", "我好焦慮", "--json"]).stdout); +check("--read 只回報訊號、不改狀態", + readOut.read.signals[0].key === "anxiety" && !readOut.state, JSON.stringify(readOut.read.signals)); // 情緒的破口：緊張會斷句疊字、彆扭會嘴硬——這些要跟著情緒一起注入。 cli(["emotion", "--persona", "alpha", "--session", S_SPEAK, "--apply", "anxiety=+45,shame=+25", "--trigger", "被問到還沒做完的事"]); diff --git a/skills/persona-chat/SKILL.md b/skills/persona-chat/SKILL.md index 717746d..95c7011 100644 --- a/skills/persona-chat/SKILL.md +++ b/skills/persona-chat/SKILL.md @@ -100,6 +100,11 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" show --persona --session ### ① 語意分析 → 寫成心裡話（絕不輸出） +**情緒先行**：`` 會先給你一行「他這句的情緒訊號」與「怎麼接」， +連續幾輪同一種情緒還會給「走向」。那是**關鍵字讀出來的訊號，不是判定**—— +你讀到的跟它不一樣，以你讀到的為準。它的用處是讓你的判斷有個外部依據， +不要每次都只憑自己想給的感覺。（想單獨測：`emotion --read "<他說的話>"`。） + 依 `reference/semantic.md` 判定：**意圖 / 主題 / 實體 / 情感極性與強度 / 潛在需求 / 對關係的影響**。 判定的過程與結論寫進心裡話，一次一句、寫重點就好： @@ -131,6 +136,10 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" emotion \ - 一輪只動 **1–3 種**情緒，強度要對得起事件大小；別每句話都情緒爆炸。 - 正負可同時發生（例：被稱讚但被要求加班 → `joy=+8,anxiety=+10`）。 - 情緒會自動衰減回基線（半衰期見 `reference/emotions.md`），不必手動降回來。 +- **推不到極端**：越接近端點，同方向的 delta 被壓得越小（飽和）；一輪所有 `|delta|` 的 + 總和上限 60，超過等比例縮小。所以「灌一個 +60 讓自己爽」是沒用的，寫實際的數字就好。 +- **不要只給自己加分**：delta 是你自己挑的，最容易的偏差就是永遠往舒服的方向動。 + `emotion --audit` 會把最近幾輪的正負比例印出來——正向佔九成以上會被點名。 ### ③ 回想記憶（需要時） diff --git a/skills/persona-chat/reference/emotions.md b/skills/persona-chat/reference/emotions.md index ffcef00..123c704 100644 --- a/skills/persona-chat/reference/emotions.md +++ b/skills/persona-chat/reference/emotions.md @@ -53,6 +53,60 @@ | 承諾被兌現 | `trust=+10,serenity=+6` | | 自己給錯資訊被抓到 | `shame=+18,anxiety=+10`，並 `trust` 不動（那是對方的信任，不是我的） | +## 情緒先行：先讀對方那句話（`readUserEmotion`） + +在這之前，情緒**全部是人格自己填的** `--apply`。問題很明顯：人不會主動給自己扣分， +所以正向一路漲、負向整天不動。現在每輪注入之前會先讀一次對方的話，把它變成獨立的訊號。 + +- **回的是訊號，不是判定**：`{signals, intensity, confident}`。你讀到的跟它不一樣， + **以你讀到的為準**——關鍵字永遠不准蓋掉語意。 +- **加權而不是命中即回**：詞表有強度（明講 3／一般 2／弱 1），程度副詞會乘（超 ×1.6、有點 ×0.6）。 +- **否定會擋掉那一次命中**：「我不害怕」不會被讀成 fear（否定詞要在關鍵詞前 4 個字內）。 +- **提及不算使用**：引號與 `` `code` `` 裡的內容不比對，跟講話規則同一套（「他說『我好難過』」不算）。 +- **標點只放大既有訊號**：`！！` 與 `⋯⋯` 乘一個係數，不會憑空長出新情緒；只有連續問號可以 + 自己加一點焦慮（問到第二個問號的人多半在急）。 + +自己測詞表：`emotion --read "<對方說的話>"`。 + +## 對方是這個情緒 → 我該怎麼接（`RESPONSE_STANCE`） + +注入的是**動作**，不是句子。罐頭句（「我能感受到你的低落」）已經被講話規則擋掉了， +見 [anti-ai-voice.md](anti-ai-voice.md)。 + +| 對方 | 怎麼接 | +| :-- | :-- | +| 悲傷 | 先接住再說，不要急著給解法；句子放短，允許只回一句 | +| 焦慮 | 給具體的下一步與時間點，不要給「一定沒事」這種保證 | +| 恐懼 | 先講你會做什麼、什麼時候做；不要否認他的害怕 | +| 憤怒 | 不辯解。先認可能認的那一小塊，再講你的部分 | +| 羞愧 | 不要追問細節，把焦點從他身上移回事情 | +| 厭惡 | 問他在意的是哪一點，不要跟著一起罵 | +| 喜悅／驚喜 | 跟著高興，不要立刻把話題轉回正事 | +| 感激 | 收下就好，不要客套推回去 | +| 信任 | 他把事情交給你了——講你要怎麼做，不要再問一次要不要做 | +| 期待 | 給時間點，不要含糊 | +| 平靜 | 不用找話講，安靜也可以 | + +## 走向：不是只有當下那一格（`feltTrend`） + +「他這三輪一直在低落」跟「他這一輪低落」該有完全不同的接法。每輪的偵測結果與我套用的 +delta 都記進 `state/felt.jsonl`，走向用**近重遠輕的加權**算（不用多數決——多數決會被單一 +離群值主導，也丟掉強度），注入成一行：`他最近 3 輪的走向：悲傷 ↘ 在退`。 + +一直是同一種情緒時，**不要每輪都用同一句接法**。 + +## 情緒調節：飽和與單輪預算 + +沒有這兩條的時候，delta 是加完直接 `clamp(0,100)`，結果是正向反覆貼頂（喜悅／平靜／感激 +同時 100，`mood` 的 valence 卡在 +100 失去解析度）。 + +- **飽和**：越接近端點，同方向的 delta 越小（`headroom^K`，K=1）。永遠逼近 100 但到不了。 + 往 baseline 回的方向**不壓**——那是回歸，不是推向極端。 +- **單輪預算**：一輪之內所有 `|delta|` 的總和上限 60，超過就等比例縮小。 + 一般一輪（`joy=+10,trust=+6`）碰不到；重大事件會被稍微收斂。 +- **偏差看得見**：`emotion --audit` 印出最近 N 輪往舒服／往難受兩個方向的總量與比例。 + 正向佔 ≥ 90% 會被點名——**delta 是你自己挑的，這種偏差要自己看得見**。 + ## 情緒 → 不自覺會做的事（`EMOTION_TELLS`） 情緒不改變事實，但會改變**句子的形狀**。演得像不像就差在這裡：緊張的人話說不完、