dsh-memu-memory 1.1.2 → 1.2.0

package/lib/memu-config.js

@@ -2,7 +2,7 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { dataDir, ensureDir, stamp, withFileLock } from './paths.js'
-import { getSettings } from './state.js'
+import { getSettings, updateSettings } from './state.js'
 import { commit, retrieve } from './memu.js'
 
 export const MEMU_CONFIG_KEYS = [
@@ -108,9 +108,9 @@ export function getMemuConfig() {
     baseUrl,
     hasKey,
     providers: Object.keys(PROVIDER_ENV),
-    // Derived, not a separate stored flag: a loopback base URL is what "local"
-    // actually means to MemU, so the toggle can never drift from the config.
-    source: baseUrl && /^https?:\/\/(127\.0\.0\.1|localhost)(:|\/)/.test(baseUrl) ? 'local' : 'remote',
+    // Source is a persisted route choice, not an inference from connection fields.
+    // Toggling vector mode must never rewrite a saved remote endpoint or key.
+    source: getSettings().vectorSource === 'api' ? 'api' : 'local',
     localBaseUrl: LOCAL_EMBED_BASE_URL,
     localModel: LOCAL_EMBED_MODEL,
   }
@@ -132,24 +132,12 @@ export function getSummaryConfig({ withKey = false } = {}) {
   return withKey ? { ...view, apiKey } : view
 }
 
-// Switching source rewrites the connection fields but never the API key: leaving a
-// third-party key in place after moving to a loopback endpoint would send it to a
-// local server, and clearing it on the way out would silently break a working setup.
-export function setEmbeddingSource(source, { keepModel = false } = {}) {
-  const env = readMemuEnv()
-  if (source === 'local') {
-    env.MEMU_EMBED_PROVIDER = 'openai'
-    env.MEMU_BASE_URL = String(env.MEMU_BASE_URL || '').includes('127.0.0.1') || String(env.MEMU_BASE_URL || '').includes('localhost')
-      ? env.MEMU_BASE_URL
-      : LOCAL_EMBED_BASE_URL
-    if (!keepModel && !String(env.MEMU_EMBED_MODEL || '')) env.MEMU_EMBED_MODEL = LOCAL_EMBED_MODEL
-  } else if (source === 'remote') {
-    if (String(env.MEMU_BASE_URL || '') === LOCAL_EMBED_BASE_URL) delete env.MEMU_BASE_URL
-    if (String(env.MEMU_EMBED_MODEL || '') === LOCAL_EMBED_MODEL) delete env.MEMU_EMBED_MODEL
-  } else {
-    throw new Error('source must be local or remote')
-  }
-  writeMemuEnv(env)
+// Switch only the vector route. Connection fields belong to the selected profile and
+// must survive a route toggle; callers may explicitly edit them through saveMemuConfig.
+export function setEmbeddingSource(source) {
+  const normalized = source === 'remote' ? 'api' : source
+  if (normalized !== 'local' && normalized !== 'api') throw new Error('source must be local or api')
+  updateSettings({ vectorSource: normalized })
   return getMemuConfig()
 }
 

package/lib/memu.js

@@ -1,9 +1,11 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { spawn } from 'node:child_process'
-import { dataDir, ensureDir, redactSecrets } from './paths.js'
+import { dataDir, ensureDir, redactSecrets, windowsSystemEnv } from './paths.js'
 import { readCurrent, verifyEngine } from './engine.js'
 import { getSettings } from './state.js'
+import { activeProfile, captureVectorGeneration, assertVectorGeneration, assertProfileVerified, assertMigrationProfile } from './vector-profile.js'
+import { embeddingWorkerManager } from './local-embedding-manager.js'
 
 // MemU's own storage mode. 'local' keeps every row in this plugin's sqlite files;
 // 'cloud' hands storage to MemU's backend and needs the vendor credentials in
@@ -36,6 +38,7 @@ function runRaw(pythonArgs, { env, timeoutMs = 90_000, cwd } = {}) {
     const child = spawn(current.python, pythonArgs, {
       cwd,
       env: {
+        ...windowsSystemEnv(),
         ...process.env,
         PYTHONUTF8: '1',
         PYTHONIOENCODING: 'utf-8',
@@ -75,11 +78,31 @@ function runRaw(pythonArgs, { env, timeoutMs = 90_000, cwd } = {}) {
   })
 }
 
-function run(args, opts) {
-  return runRaw(['-m', 'memu', ...args], opts)
+async function runConfigured(args, options = {}) {
+  const route = options.route || (options.vectorProfile ? 'managed-local' : 'remote-api')
+  const useManagedLocal = route === 'managed-local'
+  const migration = options.vectorProfile ? assertMigrationProfile({ profile: options.vectorProfile, db: options.db }) : null
+  const generation = useManagedLocal && !options.vectorProfile && activeProfile() ? captureVectorGeneration() : null
+  if (generation && options.db && ![generation.global, ...Object.values(generation.libraries)].includes(options.db)) {
+    throw new MemuError('database does not belong to the captured vector generation', 'VECTOR_DB_MISMATCH')
+  }
+  const env = await envFor({ ...options, route })
+  if (generation) assertVectorGeneration(generation)
+  if (migration) assertMigrationProfile(migration)
+  const result = await runRaw(['-m', 'memu', ...args], { env, timeoutMs: options.timeoutMs })
+  if (generation) assertVectorGeneration(generation)
+  if (migration) assertMigrationProfile(migration)
+  return result
 }
 
-function envFor({ db, provider, embedModel, baseUrl, apiKey }) {
+async function envFor({ db, provider, embedModel, baseUrl, apiKey, vectorProfile, route }) {
+  const profile = route === 'managed-local' ? (vectorProfile || activeProfile()) : null
+  if (profile) {
+    assertProfileVerified(profile)
+    const endpoint = await embeddingWorkerManager().acquire(profile)
+    return localEmbeddingEnv({ ...endpoint, db })
+  }
+  if (route === 'managed-local') throw new MemuError('managed local vector profile is not active', 'VECTOR_NOT_READY')
   const env = {}
   if (db) env.MEMU_DB = db
   if (provider) env.MEMU_EMBED_PROVIDER = provider
@@ -89,6 +112,26 @@ function envFor({ db, provider, embedModel, baseUrl, apiKey }) {
   return env
 }
 
+// §14.3 strict-local embedding wiring. The plugin injects this into each MemU
+// child instead of asking the user to export anything: the loopback endpoint, the
+// per-process random token (env only, never argv/log/config) and the pinned
+// embedding model id. Telemetry is switched off explicitly, because "local mode"
+// alone is not proof that nothing leaves the machine.
+export function localEmbeddingEnv({ baseUrl, token, model, db } = {}) {
+  const env = {
+    MEMU_MEMORY_MODE: 'local',
+    MEMU_EMBED_PROVIDER: 'openai',
+    MEMU_TELEMETRY: '0',
+    DO_NOT_TRACK: '1',
+    MEMU_EVENTS_BASE_URL: '',
+  }
+  if (typeof baseUrl === 'string' && baseUrl.trim()) env.MEMU_BASE_URL = baseUrl.trim()
+  if (typeof token === 'string' && token.trim()) env.MEMU_API_KEY = token.trim()
+  if (typeof model === 'string' && model.trim()) env.MEMU_EMBED_MODEL = model.trim()
+  if (typeof db === 'string' && db.trim()) env.MEMU_DB = db.trim()
+  return env
+}
+
 export function parseJson(text) {
   const raw = String(text || '').trim()
   if (!raw) return null
@@ -101,14 +144,11 @@ export function parseJson(text) {
   return null
 }
 
-export async function retrieve({ query, db, provider, embedModel, baseUrl, apiKey, timeoutMs = 60_000 }) {
+export async function retrieve({ query, db, provider, embedModel, baseUrl, apiKey, vectorProfile, route, timeoutMs = 60_000 }) {
   if (!query || !String(query).trim()) {
     throw new MemuError('retrieve requires a non-empty query', 'MEMU_BAD_ARGUMENT')
   }
-  const res = await run(['retrieve', String(query), '--json'], {
-    env: envFor({ db, provider, embedModel, baseUrl, apiKey }),
-    timeoutMs,
-  })
+  const res = await runConfigured(['retrieve', String(query), '--json'], { db, provider, embedModel, baseUrl, apiKey, vectorProfile, route, timeoutMs })
   const data = parseJson(res.stdout)
   if (data === null) {
     return { raw: res.stdout.trim(), parseWarning: 'memu retrieve returned non-JSON' }
@@ -116,11 +156,8 @@ export async function retrieve({ query, db, provider, embedModel, baseUrl, apiKe
   return data
 }
 
-export async function listFiles({ db, provider, embedModel, baseUrl, apiKey, timeoutMs = 60_000 } = {}) {
-  const res = await run(['list-files', '--json'], {
-    env: envFor({ db, provider, embedModel, baseUrl, apiKey }),
-    timeoutMs,
-  })
+export async function listFiles({ db, provider, embedModel, baseUrl, apiKey, vectorProfile, route, timeoutMs = 60_000 } = {}) {
+  const res = await runConfigured(['list-files', '--json'], { db, provider, embedModel, baseUrl, apiKey, vectorProfile, route, timeoutMs })
   const data = parseJson(res.stdout)
   if (data === null) {
     return { recall_files: [], raw: res.stdout.trim(), parseWarning: 'memu list-files returned non-JSON' }
@@ -128,15 +165,12 @@ export async function listFiles({ db, provider, embedModel, baseUrl, apiKey, tim
   return data
 }
 
-export async function commit({ payload, db, provider, embedModel, baseUrl, apiKey, timeoutMs = 180_000 }) {
+export async function commit({ payload, db, provider, embedModel, baseUrl, apiKey, vectorProfile, route, timeoutMs = 180_000 }) {
   const tmpDir = ensureDir(path.join(dataDir(), 'tmp'))
   const file = path.join(tmpDir, `commit-${process.pid}-${Date.now()}.json`)
   try {
     fs.writeFileSync(file, JSON.stringify(payload, null, 2), 'utf8')
-    const res = await run(['commit', file, '--json'], {
-      env: envFor({ db, provider, embedModel, baseUrl, apiKey }),
-      timeoutMs,
-    })
+    const res = await runConfigured(['commit', file, '--json'], { db, provider, embedModel, baseUrl, apiKey, vectorProfile, route, timeoutMs })
     const data = parseJson(res.stdout)
     if (data === null) {
       return { raw: res.stdout.trim(), parseWarning: 'memu commit returned non-JSON' }

package/lib/mood.js

@@ -1,66 +1,277 @@
-// Cheap, local, deterministic mood inference. No model call: the plugin needs a
-// mood signal every turn for mood-congruent retrieval, and a round trip per turn
+// Cheap, local, deterministic affect inference. No model call: the plugin needs an
+// affect signal every turn for affect-congruent retrieval, and a round trip per turn
 // would make injection slower than the memory it fetches.
 //
-// Scores are deliberately coarse (valence -1..1, arousal 0..1). A wrong read only
-// nudges recall ordering; it is never stored as a fact about the user.
-
-const VALENCE_WORDS = [
-  [/开心|高兴|太好了|棒|喜欢|爱|满意|惊喜|顺利|爽|感谢|谢谢|amazing|great|happy|love|nice|awesome|thanks/i, 0.8],
-  [/不错|还行|可以|有趣|好奇|舒服|ok|fine|good|interesting|curious/i, 0.4],
-  [/有点|稍微|somewhat|kind of|a bit/i, 0.1],
-  [/难受|难过|失望|烦|讨厌|累|困|郁闷|崩溃|糟糕|气|火|sad|upset|tired|annoying|awful|hate|frustrated|angry/i, -0.7],
-  [/疼|痛|病|哭|害怕|慌|焦虑|压力|失眠|hurt|sick|cry|scared|anxious|stress|insomnia/i, -0.9],
-]
-
-const AROUSAL_WORDS = [
-  [/(!{2,}|[!?]{2,}|太|超|巨|特别|疯狂|爆炸|never|always|everything|nothing)/i, 0.8],
-  [/必须|一定|马上|立刻|不能|别|停止|紧急|must|need|stop|urgent|now/i, 0.7],
-  [/可能|也许|大概|想想|不确定|maybe|perhaps|might|wonder/i, 0.25],
-]
+// Model: four shares on the simplex (joy / anger / sorrow / fear) + two auxiliary
+// axes — arousal (how loud) and dominance (who is in control). Shares answer "which
+// feeling, in what proportion"; arousal answers "how loud"; dominance answers "who is
+// steering". Normalising the shares throws intensity away, which is exactly why
+// arousal has to stay a separate field rather than being folded into the four.
+//
+// Scores are deliberately coarse. A wrong read only nudges recall ordering; it is
+// never stored as a fact about the user.
+
+export const EMOTION_AXES = Object.freeze(['joy', 'anger', 'sorrow', 'fear'])
 
 // Mood fades back to neutral on its own, so an old read does not tint the whole
 // day's retrieval.
-const MOOD_HALF_LIFE_MINUTES = 90
+export const MOOD_HALF_LIFE_MINUTES = 90
 // A resting level, not zero: a calm stretch reads as calm-and-alert, which is what
 // keeps the arousal term meaningful when nothing is happening.
 export const BASE_AROUSAL = 0.35
+// Below this share no single axis is dominant enough to call the reading a mood.
+export const EMOTION_MIN_SHARE = 0.35
+// The composition stops being worth anything once the whole reading has faded this
+// far; arousal and dominance keep decaying and are still reported.
+export const EMOTION_FADE_FLOOR = 0.35
+// How much anger-vs-fear moves dominance on its own. Anger carries agency, fear does
+// not, and neither phrase usually contains a control word.
+export const DOMINANCE_PRIOR_WEIGHT = 0.4
+// Every axis projects onto the legacy valence with the same magnitude; only joy is
+// positive. Anger is *not* a mild positive — it pulls the projection down as hard as
+// sorrow does.
+export const VALENCE_SCALE = 0.8
+
+const NEGATION_AS_SAD = /不开心|不高兴|不喜欢|不满意|不顺利|not\s+happy|not\s+good|don't\s+like/gi
+const NEGATION_TO_NEUTRAL = /不难过|不害怕|不焦虑|不生气|not\s+sad|not\s+afraid|not\s+anxious/gi
+
+const AXIS_PATTERNS = Object.freeze({
+  joy: [
+    [/开心|高兴|太好了|喜欢|爱你|满意|惊喜|谢谢|感谢|期待|幸福|欣慰|兴奋|激动|雀跃/, 0.9],
+    [/不错|还行|顺利|爽|安心|踏实|棒|有趣|舒服/, 0.6],
+  ],
+  anger: [
+    [/气死|烦死|受不了|离谱|凭什么|恨|火大|欺人太甚/, 0.9],
+    [/生气|气|烦|讨厌|恶心|无语|恼火|不满|angry|annoying|hate|furious/, 0.6],
+  ],
+  sorrow: [
+    [/崩溃|难受|心疼|失望透顶|想哭|哭|心碎/, 0.9],
+    // `sad` is not decoration: the negation rules below rewrite 不开心/不高兴 into the
+    // word `sad`, so dropping English here silently turns a negated positive into a
+    // neutral reading instead of a negative one.
+    [/难过|失望|委屈|郁闷|累|困|没意思|算了|沮丧|孤独|sad|unhappy|upset|tired|miserable/, 0.6],
+  ],
+  fear: [
+    [/吓死|害怕|恐慌|焦虑|绝望|惊恐|发抖/, 0.9],
+    [/担心|紧张|慌|不敢|万一|怕|不安|忐忑|afraid|scared|anxious|worried|nervous/, 0.6],
+  ],
+})
+
+// Compound expressions are mixtures, not new axes. Each entry is a named point on the
+// simplex plus the dominance that usually comes with it.
+export const COMPOUND_PRESETS = Object.freeze({
+  委屈: Object.freeze({ emotion: Object.freeze({ joy: 0, anger: 0.3, sorrow: 0.7, fear: 0 }), dominance: -0.4 }),
+  尴尬: Object.freeze({ emotion: Object.freeze({ joy: 0, anger: 0, sorrow: 0.5, fear: 0.5 }), dominance: -0.5 }),
+  嫉妒: Object.freeze({ emotion: Object.freeze({ joy: 0, anger: 0.5, sorrow: 0.3, fear: 0.2 }), dominance: -0.1 }),
+  心疼: Object.freeze({ emotion: Object.freeze({ joy: 0.2, anger: 0, sorrow: 0.8, fear: 0 }), dominance: -0.2 }),
+  不甘: Object.freeze({ emotion: Object.freeze({ joy: 0, anger: 0.6, sorrow: 0.4, fear: 0 }), dominance: 0.4 }),
+})
+
+const COMPOUND_PATTERN = new RegExp(Object.keys(COMPOUND_PRESETS).join('|'))
+const HEDGE_PATTERN = /有点|稍微|一点点|a bit|somewhat/i
+// "一点都不好" is an intensifier, not a hedge: it must never damp what follows.
+const HEDGE_SKEW_GUARD = /一点都|一点也不|一点也没|一点没有/
+const INTENSITY_PATTERN = /死|疯了|极了|受不了|爆|炸|太|超|巨|特别|疯狂/
+const REPEATED_PUNCT = /[!！?？]{2,}/
+
+const HIGH_DOMINANCE = /凭什么|我决定|不许|听我的|我不在乎|随便你|必须|轮不到|说了算|懒得|我才不/g
+const LOW_DOMINANCE = /不敢|没办法|只能|求|拜托|对不起|是我错|控制不住|万一|怎么办|逃|来不及|都怪我/g
+
+const CLAUSE_SPLIT = /([，。！？；,.!?;]+)/
+
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value))
+}
+
+/**
+ * Normalise a four-axis composition.
+ *
+ * Returns null for "no mood". An explicit all-zero object normalises to null too: it
+ * is the tool-friendly way of saying neutral, not a reading where all four are faintly
+ * present. Anything malformed is rejected instead of being repaired — silently
+ * clamping a negative share into a legal one would hide a caller bug forever.
+ */
+export function normalizeEmotion(raw) {
+  if (raw === null || raw === undefined) return null
+  if (typeof raw !== 'object' || Array.isArray(raw)) throw new Error('emotion must be an object with joy, anger, sorrow, fear')
+  const values = {}
+  for (const axis of EMOTION_AXES) {
+    if (!Object.prototype.hasOwnProperty.call(raw, axis)) throw new Error('emotion is missing the ' + axis + ' share')
+    const value = raw[axis]
+    if (typeof value !== 'number' || !Number.isFinite(value)) throw new Error('emotion.' + axis + ' must be a finite number')
+    if (value < 0) throw new Error('emotion.' + axis + ' must not be negative')
+    values[axis] = value
+  }
+  const sum = EMOTION_AXES.reduce((total, axis) => total + values[axis], 0)
+  if (!(sum > 0)) return null
+  const normalized = {}
+  for (const axis of EMOTION_AXES) normalized[axis] = values[axis] / sum
+  return normalized
+}
+
+/** The legacy single-number projection. Joy is the only axis that points up. */
+export function derivedValence(emotion) {
+  if (!emotion) return 0
+  const raw = VALENCE_SCALE * (emotion.joy - emotion.anger - emotion.sorrow - emotion.fear)
+  return clamp(Number.isFinite(raw) ? raw : 0, -1, 1)
+}
+
+/** The largest single share; 0 for a neutral reading. */
+export function maxShare(emotion) {
+  if (!emotion) return 0
+  return EMOTION_AXES.reduce((best, axis) => Math.max(best, Number(emotion[axis]) || 0), 0)
+}
+
+/** How much of the present composition a memory still shares. 0..1, symmetric. */
+export function overlap(left, right) {
+  if (!left || !right) return 0
+  let total = 0
+  for (const axis of EMOTION_AXES) {
+    const a = Number(left[axis]) || 0
+    const b = Number(right[axis]) || 0
+    if (a > 0 && b > 0) total += Math.min(a, b)
+  }
+  return clamp(total, 0, 1)
+}
+
+/**
+ * Dominance similarity, mapped to a bounded multiplier. A missing or illegal value on
+ * either side is "no signal", never NaN: callers multiply by this result directly.
+ */
+export function dominanceBias(entryDominance, contextDominance) {
+  // Number(null) is 0, so a missing value must be rejected before coercion — otherwise
+  // "we do not know" quietly becomes "slightly in control" and still moves the ranking.
+  if (entryDominance === null || entryDominance === undefined) return 1
+  if (contextDominance === null || contextDominance === undefined) return 1
+  const a = Number(entryDominance)
+  const b = Number(contextDominance)
+  if (!Number.isFinite(a) || !Number.isFinite(b)) return 1
+  return 1 + 0.2 * (0.5 - Math.abs(clamp(a, -1, 1) - clamp(b, -1, 1)) / 2)
+}
+
+/**
+ * Whether the affect terms are worth applying at all. Three independent legs: a clear
+ * composition, an arousal away from rest, or a clear sense of control. A null
+ * composition only closes the first leg.
+ */
+export function emotionActive({ emotion = null, arousal = BASE_AROUSAL, dominance = 0 } = {}) {
+  if (emotion !== null && emotion !== undefined && maxShare(emotion) >= EMOTION_MIN_SHARE) return true
+  const arousalValue = Number(arousal)
+  if (Number.isFinite(arousalValue) && Math.abs(arousalValue - BASE_AROUSAL) >= 0.1) return true
+  const dominanceValue = Number(dominance)
+  if (Number.isFinite(dominanceValue) && Math.abs(dominanceValue) >= 0.25) return true
+  return false
+}
 
+function clausesOf(source) {
+  return String(source || '')
+    .split(CLAUSE_SPLIT)
+    .map((part) => part.trim())
+    .filter((part) => part && !/^[，。！？；,.!?;]+$/.test(part))
+}
+
+function compoundIn(clause) {
+  const hit = COMPOUND_PATTERN.exec(clause)
+  return hit ? COMPOUND_PRESETS[hit[0]] : null
+}
+
+function axisHits(clause) {
+  const hits = {}
+  for (const axis of EMOTION_AXES) {
+    let best = 0
+    for (const [pattern, weight] of AXIS_PATTERNS[axis]) {
+      if (pattern.test(clause)) best = Math.max(best, weight)
+    }
+    if (best > 0) hits[axis] = best
+  }
+  return hits
+}
+
+/**
+ * Read the present affect state out of one user turn.
+ *
+ * Kept text-only and deterministic. `.valence` stays on the return value because the
+ * legacy retrieval path and its tests read it directly; `emotion`/`dominance` are
+ * additive, so a caller that only knows about valence keeps working.
+ */
 export function readMood(text) {
   const source = String(text || '')
     .replace(/["“「][^"”」]*["”」]/g, '')
-    .replace(/不开心|不高兴|不喜欢|不满意|not\s+happy|not\s+good|don't\s+like/gi, ' sad ')
-    .replace(/不难过|不害怕|不焦虑|not\s+sad|not\s+afraid/gi, '')
-  let valence = 0
-  for (const [pattern, weight] of VALENCE_WORDS) {
-    if (pattern.test(source)) valence = valence === 0 ? weight : (valence + weight) / 2
-  }
-  let arousal = 0.35
-  for (const [pattern, weight] of AROUSAL_WORDS) {
-    if (pattern.test(source)) arousal = Math.max(arousal, weight)
+    .replace(NEGATION_AS_SAD, ' sad ')
+    .replace(NEGATION_TO_NEUTRAL, '')
+  const clauses = clausesOf(source)
+
+  const raw = { joy: 0, anger: 0, sorrow: 0, fear: 0 }
+  let compoundDominance = null
+  let peakIntensity = 0
+  let hedged = false
+
+  for (const clause of clauses) {
+    const hedge = HEDGE_PATTERN.test(clause) && !HEDGE_SKEW_GUARD.test(clause)
+    if (hedge) hedged = true
+    const scale = hedge ? 0.6 : 1
+    const compound = compoundIn(clause)
+    if (compound) {
+      for (const axis of EMOTION_AXES) raw[axis] += compound.emotion[axis] * scale
+      if (compoundDominance === null) compoundDominance = compound.dominance
+    } else {
+      const hits = axisHits(clause)
+      for (const axis of EMOTION_AXES) if (hits[axis]) raw[axis] += hits[axis] * scale
+    }
+    if (INTENSITY_PATTERN.test(clause) || REPEATED_PUNCT.test(clause)) peakIntensity = Math.max(peakIntensity, 0.75)
+    if (REPEATED_PUNCT.test(clause)) peakIntensity = Math.max(peakIntensity, 0.8)
   }
+
+  for (const axis of EMOTION_AXES) raw[axis] = Math.min(1, raw[axis])
+  const emotion = normalizeEmotion(raw)
+
+  let arousal = BASE_AROUSAL
+  if (emotion !== null) arousal = Math.max(arousal, peakIntensity)
   if (source.length > 600) arousal = Math.max(0.2, arousal - 0.15)
+
+  const high = (source.match(HIGH_DOMINANCE) || []).length
+  const low = (source.match(LOW_DOMINANCE) || []).length
+  const lexical = clamp(0.5 * (high - low), -1, 1)
+  const prior = emotion === null ? 0 : DOMINANCE_PRIOR_WEIGHT * (emotion.anger - emotion.fear)
+  const dominance = clamp(lexical + prior + (compoundDominance === null ? 0 : compoundDominance * 0.5), -1, 1)
+
   return {
-    valence: Math.max(-1, Math.min(1, valence)),
-    arousal: Math.max(0, Math.min(1, arousal)),
+    valence: derivedValence(emotion),
+    emotion,
+    arousal: clamp(arousal, 0, 1),
+    dominance: hedged ? clamp(dominance * 0.8, -1, 1) : dominance,
   }
 }
 
+/**
+ * Fade a reading toward neutral.
+ *
+ * The composition does not decay proportionally — proportions sum to 1, so scaling
+ * them changes nothing. What fades is how much of it is left: arousal returns to rest,
+ * dominance returns to zero, and once the whole reading has faded past the floor the
+ * composition is dropped. Arousal and dominance keep decaying past that point.
+ */
 export function moodDecay(mood, now = Date.now()) {
-  if (!mood || typeof mood.at !== 'number') return { valence: 0, arousal: BASE_AROUSAL }
-  const minutes = Math.max(0, (now - mood.at) / 60_000)
-  const fade = Math.pow(0.5, minutes / MOOD_HALF_LIFE_MINUTES)
-  const arousal = Number(mood.arousal)
+  const hasStamp = Boolean(mood) && typeof mood.at === 'number'
+  const minutes = hasStamp ? Math.max(0, (now - mood.at) / 60_000) : 0
+  const fade = hasStamp ? Math.pow(0.5, minutes / MOOD_HALF_LIFE_MINUTES) : 0
+
+  const emotion = hasStamp && mood.emotion ? mood.emotion : null
+  const keptEmotion = fade < EMOTION_FADE_FLOOR ? null : emotion
+  const arousalValue = Number(mood && mood.arousal)
+  const dominanceValue = Number(mood && mood.dominance)
+  const legacyValence = Number(mood && mood.valence)
+
   return {
-    valence: Number(mood.valence || 0) * fade,
-    // Arousal relaxes back to the baseline instead of collapsing to zero, so a
-    // calm stretch still reads as calm-but-alert rather than flat.
-    arousal: BASE_AROUSAL + ((Number.isFinite(arousal) ? arousal : BASE_AROUSAL) - BASE_AROUSAL) * fade,
+    valence: (keptEmotion ? derivedValence(keptEmotion) : (Number.isFinite(legacyValence) ? legacyValence : 0)) * (hasStamp ? fade : 0),
+    emotion: keptEmotion,
+    arousal: BASE_AROUSAL + ((Number.isFinite(arousalValue) ? arousalValue : BASE_AROUSAL) - BASE_AROUSAL) * fade,
+    dominance: (Number.isFinite(dominanceValue) ? dominanceValue : 0) * fade,
   }
 }
 
 // Congruence is |a·b| over signed valence: sad recalls sad, happy recalls happy,
-// and a neutral present state recalls nothing extra.
+// and a neutral present state recalls nothing extra. Kept for the legacy path.
 export function moodCongruence(entryValence, currentValence) {
   const a = Number(entryValence || 0)
   const b = Number(currentValence || 0)
@@ -69,3 +280,21 @@ export function moodCongruence(entryValence, currentValence) {
   const agreement = Math.min(Math.abs(a), Math.abs(b))
   return same ? agreement : -agreement * 0.5
 }
+
+export default {
+  EMOTION_AXES,
+  MOOD_HALF_LIFE_MINUTES,
+  BASE_AROUSAL,
+  EMOTION_MIN_SHARE,
+  EMOTION_FADE_FLOOR,
+  COMPOUND_PRESETS,
+  normalizeEmotion,
+  derivedValence,
+  maxShare,
+  overlap,
+  dominanceBias,
+  emotionActive,
+  readMood,
+  moodDecay,
+  moodCongruence,
+}

package/lib/paths.js

@@ -243,6 +243,30 @@ export function stamp() {
   return new Date().toISOString()
 }
 
+/**
+ * Windows 子进程的系统变量补齐。
+ *
+ * 宿主在工具化执行里把 `process.env` 清空后（docs/env-and-commands.md §9.1），注入进程的
+ * 组件（输入法云缓存、DirectWrite 字体缓存）用 `%SystemDrive%\ProgramData\...` 拼路径时会
+ * 展开失败，于是整串被当成相对路径写进**当前工作目录** —— 仓库里出现过字面量
+ * `%SystemDrive%/ProgramData/...` 就是这么来的。
+ *
+ * 只补缺失的键：宿主给了正确的值就绝不覆盖。返回的是 overlay，调用方按
+ * `{ ...overlay, ...process.env, ...explicit }` 的顺序合并。
+ */
+export function windowsSystemEnv(platform = process.platform, env = process.env) {
+  if (platform !== 'win32') return {}
+  const source = env || {}
+  const drive = String(source.SystemDrive || source.HOMEDRIVE || 'C:')
+  const root = String(source.SystemRoot || source.windir || source.WINDIR || (drive.replace(/\\$/, '') + '\\Windows')).replace(/\\/g, '/')
+  const overlay = {}
+  if (!source.SystemDrive) overlay.SystemDrive = drive
+  if (!source.SystemRoot) overlay.SystemRoot = root
+  if (!source.windir && !source.WINDIR) overlay.windir = root
+  if (!source.PATH && !source.Path) overlay.PATH = root + '/system32'
+  return overlay
+}
+
 export function safeSegment(value, fallback = 'unknown') {
   const text = String(value ?? '').trim()
   if (!text) return fallback

package/lib/preset-scope.js

@@ -76,7 +76,7 @@ export function attachPresetAgents(ctx, { log = () => {}, attached = attachments
     seen.add(actx)
     if (!attached.has(actx) && !sameScopeTree(actx, ctx)) {
       try {
-        const dispose = registerInjection(actx, { guide: false, guideMessage: true })
+        const dispose = registerInjection(actx)
         attached.set(actx, dispose)
         added += 1
         log(`attached memory injection to preset conversation ${sessionId}`)