soulbridge 0.0.3 → 0.0.4

package/README.md

@@ -3,7 +3,7 @@
 > **给任何 agent 装上一个人格层。**
 > A personality layer for any agent — continuity, forgetting, and growth across tools.
 
-**状态：v0.0.1 骨架 · 未发布 · 接口随时会变**
+**状态：v0.0.4 · 已发布 npm · 接口仍在演进**
 
 ---
 
@@ -25,6 +25,18 @@ soulbridge 是它们之间那层**不属于任何一家**的记忆与人格：
 | 云端服务 | 默认全本地，数据不出机器 |
 | “更像人”的叙事营销 | 只承诺可观测的事 |
 
+## 什么时候别用我们
+
+诚实地说：**如果你只用一种 agent 工具、只在一个仓库工作、并且愿意手动维护 `AGENTS.md`，那它比我们更好。**
+
+| 你的情况 | 建议 |
+|---|---|
+| 单工具 + 单仓库 + 愿意手动维护 | 用 `AGENTS.md` / `CLAUDE.md`，别装我们 |
+| 团队共享约定 | 用仓库里的 `AGENTS.md`，我们不抢 |
+| 多工具 / 多仓库 + 有个人偏好 | 我们是唯一能跨工具携带的那一层 |
+
+我们只做三件 steering 文件结构上做不到的事：**跨工具携带、自动维护（抽取/遗忘/取代）、注入选择**。详见 [ADR 0019](docs/adr/0019-steering-files.md)。
+
 ## 四个动词
 
 宿主只需要在四个时机调用，就完成了接入：
@@ -32,7 +44,7 @@ soulbridge 是它们之间那层**不属于任何一家**的记忆与人格：
 | 动词 | 时机 | 作用 |
 |---|---|---|
 | `context()` | 会话开始 | 注入：身份 + 画像 + 相关记忆 + 表达风格 |
-| `observe(turn)` | 每轮结束 | 观察：写入经历、更新情绪 |
+| `observe(turn)` | 每轮结束 | 观察：写入经历、分析用户情绪、更新自己的情绪 |
 | `recall(q)` | 需要时 | 召回：按相关性/新旧/重要度/唤醒次数排序 |
 | `reflect(session)` | 会话结束 | 反思：把经历固化成策略与认知 |
 
@@ -46,6 +58,7 @@ soulbridge 是它们之间那层**不属于任何一家**的记忆与人格：
 npx soulbridge init
 npx soulbridge remember --type strategy "提交前先跑 make check，能省一轮 CI"
 npx soulbridge context --query "要不要先跑测试"
+npx soulbridge affect "我不太开心，这个方案又被拒了"
 npx soulbridge demo          # 起一个 soul，跑完整 context→observe→reflect→context
 ```
 
@@ -81,10 +94,15 @@ SQLite（默认） / Postgres（可选）
 |---|---|
 | [thesis](docs/thesis.md) | 核心命题、三条可证伪预测、四臂实验、放弃条件 |
 | [RFC 0001](docs/rfcs/0001-foundations.md) | 定位、用户、非目标、成功指标、四个动词、接入阶梯 |
-| [ADR 索引](docs/rfcs/README.md) | 11 条已生效的架构决定（定位/语言/存储/依赖/协议/许可/接入/范围/评估/质量） |
+| [RFC 0002](docs/rfcs/0002-affect.md) | 输入侧情感层：两套情绪的边界、数据流、已知局限 |
+| [ADR 索引](docs/rfcs/README.md) | 21 条已生效的架构决定 |
 | [protocol.v0](docs/spec/protocol.v0.md) | 四个动词的完整契约：字段、错误码、降级、测试映射 |
+| [affect.v0](docs/spec/affect.v0.md) | 词库格式、8 条规则、置信度公式、黄金集与消融 |
+| [storage.v0](docs/spec/storage.v0.md) | 路径、身份、迁移、并发、导出格式 |
+| [sync.v0](docs/spec/sync.v0.md) | 跨设备合并语义（v0.5 实现） |
 | [quality](docs/quality.md) | 质量模型、九条门禁、五条评审清单 |
 | [references](docs/references.md) | 外部资料的去留与过期判断 |
+| [runbook](docs/runbook.md) | 发版流程、维护操作、已知待办 |
 
 **规则**：架构级改动必须先有 RFC 或 ADR；聊天里达成的不算决定。
 
@@ -98,6 +116,8 @@ SQLite（默认） / Postgres（可选）
 - 默认 SQLite，落在 `~/.soulbridge/soul.db`
 - 零遥测、零上报
 - 记忆可导出、可删除、可迁移
+- 情绪采样只存**词条与计数**，不存原句；30 天自动清理
+- 默认不联网；只有显式启用 LLM 分析器时，才会把**当前这一条** user 文本发给你配置的端点
 
 ## License
 

package/dist/packages/cli/src/cli.js

@@ -3,14 +3,17 @@
  * Minimal CLI. No framework, no dependencies.
  *
  *   soulbridge init
- *   soulbridge remember "以后提交前先跑 make check" --type strategy --importance 8
+ *   soulbridge remember "以后提交前先跑 make check" --type strategy
  *   soulbridge context --query "提交前要做什么"
- *   soulbridge recall "测试"
- *   soulbridge reflect --text "..."      (or --file transcript.txt)
+ *   soulbridge observe "我不太开心"
+ *   soulbridge affect "我不太开心"
+ *   soulbridge reflect --text "..."
+ *   soulbridge export --out soulbridge.jsonl
+ *   soulbridge import --in soulbridge.jsonl
  *   soulbridge stats
  *   soulbridge demo
  */
-import { mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 // node:sqlite prints an ExperimentalWarning the moment it loads. Replace the default
 // printer with a filter: the CLI's own output stays clean, other warnings still show.
@@ -21,7 +24,8 @@ process.on('warning', (warning) => {
         return;
     process.stderr.write(`${warning.name}: ${warning.message}\n`);
 });
-const { openSqlite, Soul } = await import('../../core/src/index.js');
+const { openSqlite, Soul, ensureConfig, resolveDbPath, analyzeAffect, validateLexicon } = await import('../../core/src/index.js');
+const { llmAnalyzerFromEnv } = await import('./llm-analyzer.js');
 function parse(argv) {
     const [cmd = 'help', ...rest] = argv;
     const positional = [];
@@ -44,22 +48,40 @@ function parse(argv) {
     }
     return { cmd, positional, flags };
 }
-function dbFile() {
-    const file = process.env.SOULBRIDGE_DB ?? resolve(process.cwd(), '.soulbridge', 'soul.db');
-    mkdirSync(dirname(file), { recursive: true });
-    return file;
+function lexiconAnalyzerFrom(path) {
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    const errors = validateLexicon(raw);
+    if (errors.length > 0)
+        throw new Error(`invalid lexicon (${path}): ${errors.slice(0, 3).join('; ')}`);
+    const lexicon = raw;
+    return { id: 'lexicon', analyze: (text) => analyzeAffect(text, { lexicon }) };
 }
-function open(file, createdAt) {
-    const target = file ?? dbFile();
-    const store = openSqlite(target);
+function pickAnalyzer(flags) {
+    let analyzer;
+    if (flags.lexicon)
+        analyzer = lexiconAnalyzerFrom(flags.lexicon);
+    if (flags.analyzer === 'llm') {
+        const llm = llmAnalyzerFromEnv();
+        if (llm)
+            analyzer = llm;
+        else
+            process.stderr.write('soulbridge: SOULBRIDGE_AFFECT_LLM_URL not set; using the lexicon analyzer\n');
+    }
+    return analyzer;
+}
+function open(flags) {
+    const config = ensureConfig();
+    const dbPath = resolveDbPath(flags.db);
+    mkdirSync(dirname(dbPath), { recursive: true });
     const soul = new Soul({
-        store,
-        soulId: process.env.SOULBRIDGE_SOUL ?? 'xiaoling',
-        userId: process.env.SOULBRIDGE_USER ?? 'local',
-        name: process.env.SOULBRIDGE_NAME ?? '小灵',
-        createdAt,
+        store: openSqlite(dbPath),
+        soulId: config.soulId,
+        userId: config.userId,
+        name: config.name,
+        deviceId: config.deviceId,
+        analyzer: pickAnalyzer(flags),
     });
-    return { soul, file: target };
+    return { soul, dbPath, deviceId: config.deviceId };
 }
 function out(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
@@ -70,7 +92,6 @@ async function demo() {
     const file = resolve(dir, 'demo.db');
     for (const suffix of ['', '-wal', '-shm'])
         rmSync(`${file}${suffix}`, { force: true });
-    // Backdate the birthday so the demo shows a relationship that has time in it.
     const seed = openSqlite(file);
     seed.ensureSoul({ soulId: 'xiaoling', name: '小灵', createdAt: Date.now() - 3 * 86_400_000 });
     seed.close();
@@ -85,27 +106,55 @@ async function demo() {
         { role: 'user', content: '不对，这个方案是错的' },
     ]);
     process.stdout.write(`写入 ${result.memories} 条记忆，情绪 ${JSON.stringify(result.emotion)}\n\n`);
-    process.stdout.write('=== 第 2 次会话：开场（无查询，按重要度注入全部）===\n');
-    process.stdout.write(`${soul.context().text}\n\n`);
-    process.stdout.write('=== 同一会话中，用户问「提交前要做什么」（有查询，只注入相关的）===\n');
+    process.stdout.write('=== 用户说了一句带情绪的话（observe）===\n');
+    const observed = await soul.observe({ role: 'user', content: '我特别难过，这个方案又被拒了' });
+    process.stdout.write(`affect: ${observed.affect.dominant ?? 'none'} / 强度 ${observed.affect.intensity} / 置信 ${observed.affect.confidence}\n\n`);
+    process.stdout.write('=== 第 2 次会话：开场（含情绪段）===\n');
     process.stdout.write(`${soul.context({ query: '提交前要做什么' }).text}\n\n`);
     process.stdout.write('=== stats ===\n');
     out(soul.stats());
     process.stdout.write(`\n数据库：${file}\n`);
 }
+function exportJsonl(soul, deviceId) {
+    const lines = [
+        JSON.stringify({
+            type: 'header',
+            version: 1,
+            soulId: soul.soulId,
+            userId: soul.userId,
+            deviceId,
+            exportedAt: Date.now(),
+        }),
+    ];
+    const memories = soul.store.query({
+        soulId: soul.soulId,
+        userId: soul.userId,
+        status: ['active', 'superseded', 'archived'],
+        limit: 100_000,
+    });
+    for (const memory of memories)
+        lines.push(JSON.stringify({ type: 'memory', memory }));
+    const samples = soul.store.recentAffect(soul.soulId, soul.userId, 0);
+    for (const sample of samples) {
+        const withAt = sample;
+        lines.push(JSON.stringify({ type: 'affect', at: withAt.at ?? 0, signal: sample }));
+    }
+    return `${lines.join('\n')}\n`;
+}
 async function main() {
     const { cmd, positional, flags } = parse(process.argv.slice(2));
     switch (cmd) {
         case 'init': {
-            const { soul, file } = open();
-            out({ ok: true, db: file, ...soul.stats() });
+            const config = ensureConfig();
+            const { dbPath } = open(flags);
+            out({ ok: true, db: dbPath, config });
             return;
         }
         case 'remember': {
             const content = positional.join(' ').trim();
             if (!content)
                 throw new Error('usage: soulbridge remember "内容" [--type T] [--importance N]');
-            const { soul } = open();
+            const { soul } = open(flags);
             const id = soul.remember(content, {
                 type: flags.type ?? 'fact',
                 importance: flags.importance ? Number(flags.importance) : undefined,
@@ -114,7 +163,7 @@ async function main() {
             return;
         }
         case 'context': {
-            const { soul } = open();
+            const { soul } = open(flags);
             const result = soul.context({
                 query: flags.query,
                 maxChars: flags.max ? Number(flags.max) : undefined,
@@ -126,17 +175,30 @@ async function main() {
             const query = positional.join(' ').trim();
             if (!query)
                 throw new Error('usage: soulbridge recall "查询" [--limit N]');
-            const { soul } = open();
+            const { soul } = open(flags);
             const hits = soul.recall(query, flags.limit ? Number(flags.limit) : 5);
-            out(hits.map((h) => ({ id: h.memory.id, type: h.memory.type, content: h.memory.content, score: Number(h.score.toFixed(3)) })));
+            out(hits.map((h) => ({
+                id: h.memory.id,
+                type: h.memory.type,
+                content: h.memory.content,
+                score: Number(h.score.toFixed(3)),
+            })));
             return;
         }
         case 'observe': {
             const content = positional.join(' ').trim();
             if (!content)
                 throw new Error('usage: soulbridge observe "一句话"');
-            const { soul } = open();
-            out(soul.observe({ role: 'user', content }));
+            const { soul } = open(flags);
+            out(await soul.observe({ role: 'user', content }));
+            return;
+        }
+        case 'affect': {
+            const text = positional.join(' ').trim();
+            if (!text)
+                throw new Error('usage: soulbridge affect "文本" [--analyzer lexicon|llm] [--lexicon path]');
+            const analyzer = pickAnalyzer(flags);
+            out(analyzer ? await analyzer.analyze(text) : analyzeAffect(text));
             return;
         }
         case 'reflect': {
@@ -154,13 +216,47 @@ async function main() {
                 const role = /^(assistant|助手)$/i.test(match[1]) ? 'assistant' : 'user';
                 return { role, content: match[2] };
             });
-            const { soul } = open();
+            const { soul } = open(flags);
             out(await soul.reflect(turns));
             return;
         }
+        case 'export': {
+            const file = flags.out;
+            if (!file)
+                throw new Error('usage: soulbridge export --out soulbridge.jsonl');
+            const { soul, deviceId } = open(flags);
+            const body = exportJsonl(soul, deviceId);
+            const target = resolve(file);
+            writeFileSync(target, body, 'utf8');
+            out({ ok: true, file: target, lines: body.trimEnd().split('\n').length });
+            return;
+        }
+        case 'import': {
+            const file = flags.in;
+            if (!file)
+                throw new Error('usage: soulbridge import --in soulbridge.jsonl');
+            const { soul, deviceId } = open(flags);
+            let memories = 0;
+            let affects = 0;
+            for (const line of readFileSync(resolve(file), 'utf8').split(/\r?\n/)) {
+                if (!line.trim())
+                    continue;
+                const record = JSON.parse(line);
+                if (record.type === 'memory' && record.memory) {
+                    soul.store.put(record.memory);
+                    memories += 1;
+                }
+                else if (record.type === 'affect' && record.signal) {
+                    soul.store.saveAffect(soul.soulId, soul.userId, record.signal, Number(record.at ?? 0), deviceId);
+                    affects += 1;
+                }
+            }
+            out({ ok: true, memories, affects });
+            return;
+        }
         case 'stats': {
-            const { soul, file } = open();
-            out({ db: file, ...soul.stats() });
+            const { soul, dbPath } = open(flags);
+            out({ db: dbPath, ...soul.stats() });
             return;
         }
         case 'demo':
@@ -171,16 +267,20 @@ async function main() {
                 'soulbridge — 给任何 agent 装上一个人格层',
                 '',
                 'commands:',
-                '  init                            初始化数据库',
+                '  init                            初始化配置与数据库',
                 '  remember <text> [--type T]      显式记住一条',
                 '  context [--query Q] [--max N]   生成注入文本',
+                '  observe <text>                  观察一轮（含情绪分析）',
+                '  affect <text> [--analyzer llm]  只做情绪分析',
                 '  recall <q> [--limit N]          召回',
-                '  observe <text>                  观察一轮',
                 '  reflect --text|--file           会话反思',
+                '  export --out <file>             导出 JSONL',
+                '  import --in <file>              导入 JSONL',
                 '  stats                           看状态',
                 '  demo                            端到端演示（无需模型）',
                 '',
-                'env: SOULBRIDGE_DB, SOULBRIDGE_SOUL, SOULBRIDGE_USER, SOULBRIDGE_NAME',
+                'env: SOULBRIDGE_DB, SOULBRIDGE_SOUL, SOULBRIDGE_USER, SOULBRIDGE_NAME,',
+                '     SOULBRIDGE_AFFECT_LLM_URL / _MODEL / _KEY / _TIMEOUT',
                 '',
             ].join('\n'));
     }

package/dist/packages/cli/src/llm-analyzer.js

@@ -0,0 +1,82 @@
+import { emptyAffect } from '../../core/src/index.js';
+const CATEGORIES = ['joy', 'anger', 'sadness', 'fear', 'disgust', 'surprise'];
+const SYSTEM_PROMPT = [
+    '你是情感分类器。只输出 JSON，不要解释。',
+    'JSON 结构：{"dominant":"joy|anger|sadness|fear|disgust|surprise|null","intensity":0-9,"valence":-1..1,"arousal":0..1,"confidence":0..1}',
+    '规则：只根据用户这句话判断；没有明显情绪时 dominant 为 null、confidence <= 0.3；不要猜测对方的人格。',
+].join('\n');
+const clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+function parseJsonBlock(content) {
+    const trimmed = content.trim().replace(/^```(?:json)?/i, '').replace(/```$/, '').trim();
+    const start = trimmed.indexOf('{');
+    const end = trimmed.lastIndexOf('}');
+    if (start < 0 || end < start)
+        throw new Error('model did not return JSON');
+    return JSON.parse(trimmed.slice(start, end + 1));
+}
+export function createLlmAnalyzer(options) {
+    const timeoutMs = options.timeoutMs ?? 3000;
+    const maxConfidence = options.maxConfidence ?? 0.85;
+    const endpoint = `${options.url.replace(/\/$/, '')}/chat/completions`;
+    return {
+        id: 'llm',
+        async analyze(text) {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetch(endpoint, {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        ...(options.apiKey ? { authorization: `Bearer ${options.apiKey}` } : {}),
+                    },
+                    body: JSON.stringify({
+                        model: options.model,
+                        temperature: 0,
+                        messages: [
+                            { role: 'system', content: SYSTEM_PROMPT },
+                            { role: 'user', content: text.slice(0, 2000) },
+                        ],
+                    }),
+                    signal: controller.signal,
+                });
+                if (!response.ok)
+                    throw new Error(`llm analyze failed: HTTP ${response.status}`);
+                const payload = (await response.json());
+                const content = payload.choices?.[0]?.message?.content;
+                if (!content)
+                    throw new Error('llm analyze returned empty content');
+                const parsed = parseJsonBlock(content);
+                const dominant = typeof parsed.dominant === 'string' && CATEGORIES.includes(parsed.dominant)
+                    ? parsed.dominant
+                    : null;
+                const intensity = clamp(Number(parsed.intensity ?? 0), 0, 9);
+                const confidence = clamp(Number(parsed.confidence ?? 0), 0, maxConfidence);
+                const signal = emptyAffect('llm');
+                return {
+                    ...signal,
+                    dominant,
+                    intensity,
+                    valence: clamp(Number(parsed.valence ?? 0), -1, 1),
+                    arousal: clamp(Number(parsed.arousal ?? 0), 0, 1),
+                    confidence: dominant ? confidence : Math.min(confidence, 0.3),
+                };
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+    };
+}
+/** Build the analyzer from env vars, or null when not configured. */
+export function llmAnalyzerFromEnv() {
+    const url = process.env.SOULBRIDGE_AFFECT_LLM_URL;
+    if (!url)
+        return null;
+    return createLlmAnalyzer({
+        url,
+        model: process.env.SOULBRIDGE_AFFECT_LLM_MODEL ?? 'qwen3:1.7b',
+        apiKey: process.env.SOULBRIDGE_AFFECT_LLM_KEY,
+        timeoutMs: Number(process.env.SOULBRIDGE_AFFECT_LLM_TIMEOUT ?? 3000),
+    });
+}

package/dist/packages/core/src/affect/analyze.js

@@ -0,0 +1,210 @@
+import { EMPTY_AFFECT } from '../types.js';
+import { ABSTAIN_TERMS, DEGREE_DELTA, NEGATORS } from './lexicon.js';
+import { SEED_LEXICON } from './seed-lexicon.js';
+export const MAX_INPUT_CHARS = 32_000;
+export const NEGATION_WINDOW = 3;
+export const DEGREE_WINDOW = 2;
+export class AffectBudgetError extends Error {
+    code = 'BUDGET_EXCEEDED';
+    constructor(length) {
+        super(`affect input too large: ${length} chars (max ${MAX_INPUT_CHARS})`);
+        this.name = 'AffectBudgetError';
+    }
+}
+const cache = new WeakMap();
+function prepare(lexicon) {
+    const cached = cache.get(lexicon);
+    if (cached)
+        return cached;
+    const entries = new Map(Object.entries(lexicon.entries));
+    const fillers = new Set(lexicon.fillers);
+    const hedges = new Set(lexicon.hedges);
+    const vague = new Set(Object.keys(lexicon.vague));
+    const degree = new Map();
+    for (const level of Object.keys(DEGREE_DELTA)) {
+        for (const word of lexicon.degree[level])
+            degree.set(word, DEGREE_DELTA[level]);
+    }
+    const dict = new Set([
+        ...entries.keys(),
+        ...fillers,
+        ...hedges,
+        ...vague,
+        ...degree.keys(),
+        ...NEGATORS,
+        ...ABSTAIN_TERMS,
+    ]);
+    let maxLen = 1;
+    for (const word of dict)
+        maxLen = Math.max(maxLen, word.length);
+    const prepared = { entries, fillers, hedges, vague, degree, dict, maxLen };
+    cache.set(lexicon, prepared);
+    return prepared;
+}
+/** Full-width punctuation → ASCII, strip code fences and shell lines, drop emoji. */
+export function normalizeForAffect(text) {
+    const withoutCode = text.replace(/```[\s\S]*?```/g, ' ');
+    const lines = withoutCode
+        .split(/\r?\n/)
+        .filter((line) => !/^\s*\$\s/.test(line))
+        .join('\n');
+    return lines
+        .replace(/[\uff01-\uff5e]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 0xfee0))
+        .replace(/[\u{1f000}-\u{1faff}\u{2600}-\u{27bf}\u{fe0f}\u{200d}]/gu, ' ')
+        .replace(/[\u0000-\u001f\u007f]/g, ' ')
+        .toLowerCase();
+}
+/** Max forward match over the lexicon dictionary; punctuation and spaces are separators. */
+export function tokenizeForAffect(text, dict, maxLen) {
+    const tokens = [];
+    let i = 0;
+    while (i < text.length) {
+        const ch = text[i];
+        if (/[\s\p{P}\p{S}]/u.test(ch)) {
+            i += 1;
+            continue;
+        }
+        let matched = '';
+        for (let len = Math.min(maxLen, text.length - i); len >= 1; len -= 1) {
+            const candidate = text.slice(i, i + len);
+            if (dict.has(candidate)) {
+                matched = candidate;
+                break;
+            }
+        }
+        if (matched) {
+            tokens.push(matched);
+            i += matched.length;
+        }
+        else {
+            tokens.push(ch);
+            i += 1;
+        }
+    }
+    return tokens;
+}
+const clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+/**
+ * Negating a positive emotion turns it negative ("不开心"), but negating a
+ * negative one does not turn it positive ("不生气" is relief, not joy) — it
+ * becomes neutral. This is a deliberate, testable simplification.
+ */
+function flip(polarity) {
+    if (polarity === 'positive')
+        return 'negative';
+    return 'neutral';
+}
+export function analyzeAffect(text, options = {}) {
+    if (typeof text !== 'string')
+        throw new TypeError('text must be a string');
+    if (text.length > MAX_INPUT_CHARS)
+        throw new AffectBudgetError(text.length);
+    const lexicon = options.lexicon ?? SEED_LEXICON;
+    const prepared = prepare(lexicon);
+    const normalized = normalizeForAffect(text);
+    const tokens = tokenizeForAffect(normalized, prepared.dict, prepared.maxLen);
+    const hits = [];
+    for (let i = 0; i < tokens.length; i += 1) {
+        const entry = prepared.entries.get(tokens[i]);
+        if (!entry)
+            continue;
+        let negated = false;
+        for (let back = 1; back <= NEGATION_WINDOW && i - back >= 0; back += 1) {
+            const prev = tokens[i - back];
+            if (NEGATORS.includes(prev)) {
+                negated = true;
+                break;
+            }
+            if (prepared.entries.has(prev))
+                break;
+        }
+        let degree = 0;
+        for (let back = 1; back <= DEGREE_WINDOW && i - back >= 0; back += 1) {
+            const delta = prepared.degree.get(tokens[i - back]);
+            if (delta !== undefined) {
+                degree = delta;
+                break;
+            }
+        }
+        let intensity = clamp(entry.intensity + degree, 1, 9);
+        let polarity = entry.polarity;
+        if (negated) {
+            polarity = flip(polarity);
+            intensity = Math.max(1, Math.round(intensity * 0.8));
+        }
+        hits.push({
+            term: tokens[i],
+            category: entry.category,
+            intensity,
+            polarity,
+            negated,
+            position: i,
+        });
+    }
+    const byCategory = new Map();
+    let weighted = 0;
+    let total = 0;
+    for (const hit of hits) {
+        byCategory.set(hit.category, (byCategory.get(hit.category) ?? 0) + hit.intensity);
+        const sign = hit.polarity === 'positive' ? 1 : hit.polarity === 'negative' ? -1 : 0;
+        weighted += sign * hit.intensity;
+        total += hit.intensity;
+    }
+    let dominant = null;
+    let best = 0;
+    for (const [category, sum] of byCategory) {
+        if (sum > best) {
+            best = sum;
+            dominant = category;
+        }
+    }
+    const emphasis = (normalized.match(/[!?]{2,}|…{2,}/g) ?? []).length + (normalized.match(/(.)\1{2,}/gu) ?? []).length;
+    let intensity = hits.length > 0 ? Math.max(...hits.map((h) => h.intensity)) : 0;
+    if (hits.length > 0 && emphasis > 0)
+        intensity = clamp(intensity + Math.min(2, emphasis), 1, 9);
+    const fillers = tokens.filter((t) => prepared.fillers.has(t)).length;
+    const hedges = tokens.filter((t) => prepared.hedges.has(t)).length;
+    const vague = tokens.filter((t) => prepared.vague.has(t)).length;
+    const abstain = hits.length === 0 && ABSTAIN_TERMS.some((term) => normalized.includes(term));
+    // No hits means no judgement at all — length alone must never produce confidence.
+    let confidence = 0;
+    if (hits.length > 0) {
+        confidence =
+            0.4 * Math.min(1, hits.length / 2) +
+                0.2 * Math.min(1, tokens.length / 20) +
+                0.25 * (dominant ? 1 : 0) +
+                0.15 * (intensity / 9);
+        if (tokens.length <= 3)
+            confidence *= 0.5;
+    }
+    if (abstain)
+        confidence = Math.min(confidence, 0.5);
+    return {
+        analyzer: 'lexicon',
+        hits,
+        dominant,
+        intensity: Math.round(intensity * 10) / 10,
+        valence: total > 0 ? Math.round((weighted / total) * 100) / 100 : 0,
+        arousal: clamp(intensity / 9 + 0.1 * emphasis, 0, 1),
+        features: {
+            fillers,
+            hedges,
+            vague,
+            tokens: tokens.length,
+            density: tokens.length > 0 ? (tokens.length - fillers - hedges) / tokens.length : 1,
+        },
+        confidence: clamp(Math.round(confidence * 100) / 100, 0, 1),
+        abstain,
+    };
+}
+/** Lexicon analyzer as a port implementation (ADR 0015). */
+export const lexiconAnalyzer = {
+    id: 'lexicon',
+    analyze(text) {
+        return analyzeAffect(text);
+    },
+};
+/** Empty signal helper so callers do not reach for the shared constant by accident. */
+export function emptyAffect(analyzer = 'none') {
+    return { ...EMPTY_AFFECT, analyzer, features: { ...EMPTY_AFFECT.features } };
+}

package/dist/packages/core/src/affect/directives.js

@@ -0,0 +1,29 @@
+export const DIRECTIVE_CATALOG = [
+    { id: 'negative_high', text: '对方情绪偏负面：先承接，再给方案；不要急着讲道理' },
+    { id: 'positive_high', text: '对方情绪偏正面：回答可以更简短' },
+    { id: 'hedging', text: '对方表达里犹豫词偏多：给结论，少加限定语' },
+    { id: 'fragmented', text: '对方表达较碎片：先复述你的理解，再回答' },
+    { id: 'vague_terms', text: '对方用词较笼统：必要时确认具体所指' },
+];
+const per100 = (count, tokens) => (tokens > 0 ? (count * 100) / tokens : 0);
+/** Which catalog entries the signal justifies, in priority order, capped at `max`. */
+export function selectDirectives(signal, max = 2) {
+    if (signal.hits.length === 0 || signal.confidence < 0.6)
+        return [];
+    const triggered = new Set();
+    if (signal.valence <= -0.4 && signal.intensity >= 6)
+        triggered.add('negative_high');
+    if (signal.valence >= 0.4 && signal.intensity >= 6)
+        triggered.add('positive_high');
+    // Absolute minimums stop a single "这个" in a ten-token sentence from
+    // reading as "fragmented" — rate alone is misleading on short inputs.
+    if (signal.features.hedges >= 2 && per100(signal.features.hedges, signal.features.tokens) >= 6) {
+        triggered.add('hedging');
+    }
+    if (signal.features.fillers >= 3 && per100(signal.features.fillers, signal.features.tokens) >= 8) {
+        triggered.add('fragmented');
+    }
+    if (signal.features.vague >= 3)
+        triggered.add('vague_terms');
+    return DIRECTIVE_CATALOG.filter((d) => triggered.has(d.id)).slice(0, max);
+}

package/dist/packages/core/src/affect/index.js

@@ -0,0 +1,4 @@
+export { analyzeAffect, lexiconAnalyzer, emptyAffect, AffectBudgetError, normalizeForAffect, tokenizeForAffect, MAX_INPUT_CHARS, } from './analyze.js';
+export { SEED_LEXICON } from './seed-lexicon.js';
+export { validateLexicon, DEGREE_DELTA, NEGATORS, ABSTAIN_TERMS } from './lexicon.js';
+export { DIRECTIVE_CATALOG, selectDirectives } from './directives.js';