soulbridge 0.0.3 → 0.0.5

package/dist/packages/core/src/sqlite.js

@@ -1,9 +1,27 @@
 /**
  * SQLite implementation of SoulStore, using Node's built-in `node:sqlite`.
  * Zero npm dependencies on purpose: `npx soulbridge` must work offline.
+ *
+ * Schema versioning (ADR 0020): every open checks `schema_meta.schema_version`.
+ * Older databases are upgraded in place after a one-off backup; a database
+ * from a newer binary is refused instead of being silently written.
  */
+import { copyFileSync, existsSync } from 'node:fs';
 import { DatabaseSync } from 'node:sqlite';
 import { DEFAULT_EMOTION } from './types.js';
+export const SCHEMA_VERSION = 2;
+export const AFFECT_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const BUSY_TIMEOUT_MS = 5000;
+const WRITE_ATTEMPTS = 3;
+export class DbNewerThanBinaryError extends Error {
+    code = 'DB_NEWER_THAN_BINARY';
+    dbVersion;
+    constructor(dbVersion) {
+        super(`database schema v${dbVersion} is newer than this binary (v${SCHEMA_VERSION})`);
+        this.name = 'DbNewerThanBinaryError';
+        this.dbVersion = dbVersion;
+    }
+}
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS schema_meta (k TEXT PRIMARY KEY, v TEXT NOT NULL);
 CREATE TABLE IF NOT EXISTS souls (
@@ -43,47 +61,111 @@ CREATE TABLE IF NOT EXISTS memories (
 );
 CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(soul_id, user_id, status);
 CREATE INDEX IF NOT EXISTS idx_memories_created ON memories(soul_id, created_at DESC);
+CREATE TABLE IF NOT EXISTS affect_samples (
+  soul_id    TEXT NOT NULL,
+  user_id    TEXT NOT NULL,
+  at         INTEGER NOT NULL,
+  analyzer   TEXT NOT NULL,
+  dominant   TEXT,
+  intensity  REAL NOT NULL,
+  valence    REAL NOT NULL,
+  arousal    REAL NOT NULL,
+  confidence REAL NOT NULL,
+  payload    TEXT NOT NULL,
+  device_id  TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_affect ON affect_samples(soul_id, user_id, at DESC);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_affect_unique ON affect_samples(soul_id, user_id, at, analyzer);
 `;
-function toMemory(row) {
-    return {
-        id: String(row.id),
-        soulId: String(row.soul_id),
-        userId: String(row.user_id),
-        type: row.type,
-        content: String(row.content),
-        importance: Number(row.importance),
-        vividness: Number(row.vividness),
-        recallCount: Number(row.recall_count),
-        status: row.status,
-        visibility: row.visibility,
-        keywords: JSON.parse(String(row.keywords ?? '[]')),
-        createdAt: Number(row.created_at),
-        lastRecalledAt: row.last_recalled_at == null ? undefined : Number(row.last_recalled_at),
-        validFrom: row.valid_from == null ? undefined : Number(row.valid_from),
-        validUntil: row.valid_until == null ? undefined : Number(row.valid_until),
-        supersededBy: row.superseded_by == null ? undefined : String(row.superseded_by),
-    };
+const sleepSync = (ms) => {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+function withRetry(fn) {
+    let lastError;
+    for (let attempt = 0; attempt < WRITE_ATTEMPTS; attempt += 1) {
+        try {
+            return fn();
+        }
+        catch (error) {
+            lastError = error;
+            const message = error instanceof Error ? error.message : String(error);
+            if (!/locked|busy/i.test(message))
+                throw error;
+            if (attempt < WRITE_ATTEMPTS - 1)
+                sleepSync(50 * 3 ** attempt);
+        }
+    }
+    throw lastError;
+}
+function readVersion(db) {
+    const row = db.prepare("SELECT v FROM schema_meta WHERE k = 'schema_version'").get();
+    if (!row)
+        return 1;
+    const version = Number(row.v);
+    return Number.isFinite(version) ? version : 1;
+}
+function setVersion(db, version) {
+    db.prepare('INSERT OR REPLACE INTO schema_meta (k, v) VALUES (?, ?)').run('schema_version', String(version));
+}
+function columnExists(db, table, column) {
+    const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+    return rows.some((row) => String(row.name) === column);
+}
+function ensureColumn(db, table, column, ddl) {
+    if (!columnExists(db, table, column))
+        db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${ddl}`);
+}
+/** v1 → v2: sync-ready columns (updated_at / deleted_at / device_id). */
+function upgradeToV2(db) {
+    ensureColumn(db, 'memories', 'updated_at', 'INTEGER');
+    ensureColumn(db, 'memories', 'deleted_at', 'INTEGER');
+    ensureColumn(db, 'emotions', 'updated_at', 'INTEGER');
+    db.exec('UPDATE memories SET updated_at = created_at WHERE updated_at IS NULL');
+    db.exec('UPDATE emotions SET updated_at = 0 WHERE updated_at IS NULL');
+}
+function backupBeforeUpgrade(file, from) {
+    if (file === ':memory:' || !existsSync(file))
+        return;
+    const backup = `${file}.bak-v${from}`;
+    if (!existsSync(backup))
+        copyFileSync(file, backup);
 }
 export function openSqlite(file) {
     const db = new DatabaseSync(file);
     db.exec('PRAGMA journal_mode = WAL;');
+    db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS};`);
     db.exec(SCHEMA);
-    db.prepare('INSERT OR REPLACE INTO schema_meta (k, v) VALUES (?, ?)').run('version', '1');
+    const version = readVersion(db);
+    if (version > SCHEMA_VERSION) {
+        db.close();
+        throw new DbNewerThanBinaryError(version);
+    }
+    if (version < SCHEMA_VERSION) {
+        backupBeforeUpgrade(file, version);
+        if (version < 2)
+            upgradeToV2(db);
+        setVersion(db, SCHEMA_VERSION);
+    }
     const stmtPut = db.prepare(`
     INSERT INTO memories (
       id, soul_id, user_id, type, content, importance, vividness, recall_count,
-      status, visibility, keywords, created_at, last_recalled_at, valid_from, valid_until, superseded_by
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      status, visibility, keywords, created_at, last_recalled_at, valid_from, valid_until,
+      superseded_by, updated_at, deleted_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(id) DO UPDATE SET
       content = excluded.content,
       importance = excluded.importance,
       vividness = excluded.vividness,
       status = excluded.status,
-      superseded_by = excluded.superseded_by
+      superseded_by = excluded.superseded_by,
+      updated_at = excluded.updated_at,
+      deleted_at = excluded.deleted_at
   `);
     return {
         ensureSoul(identity) {
-            db.prepare('INSERT INTO souls (soul_id, name, creator, created_at) VALUES (?, ?, ?, ?) ON CONFLICT(soul_id) DO NOTHING').run(identity.soulId, identity.name, identity.creator ?? null, identity.createdAt);
+            withRetry(() => db
+                .prepare('INSERT INTO souls (soul_id, name, creator, created_at) VALUES (?, ?, ?, ?) ON CONFLICT(soul_id) DO NOTHING')
+                .run(identity.soulId, identity.name, identity.creator ?? null, identity.createdAt));
         },
         identity(soulId) {
             const row = db.prepare('SELECT * FROM souls WHERE soul_id = ?').get(soulId);
@@ -111,36 +193,71 @@ export function openSqlite(file) {
                 contentment: Number(row.contentment),
             };
         },
-        saveEmotion(soulId, userId, emotion) {
-            db.prepare(`INSERT INTO emotions (soul_id, user_id, passion, bond, tension, self_regard, curiosity, contentment)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(soul_id, user_id) DO UPDATE SET
-           passion = excluded.passion, bond = excluded.bond, tension = excluded.tension,
-           self_regard = excluded.self_regard, curiosity = excluded.curiosity,
-           contentment = excluded.contentment`).run(soulId, userId, emotion.passion, emotion.bond, emotion.tension, emotion.selfRegard, emotion.curiosity, emotion.contentment);
+        saveEmotion(soulId, userId, emotion, now = Date.now()) {
+            withRetry(() => db
+                .prepare(`INSERT INTO emotions (soul_id, user_id, passion, bond, tension, self_regard, curiosity, contentment, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+             ON CONFLICT(soul_id, user_id) DO UPDATE SET
+               passion = excluded.passion, bond = excluded.bond, tension = excluded.tension,
+               self_regard = excluded.self_regard, curiosity = excluded.curiosity,
+               contentment = excluded.contentment, updated_at = excluded.updated_at`)
+                .run(soulId, userId, emotion.passion, emotion.bond, emotion.tension, emotion.selfRegard, emotion.curiosity, emotion.contentment, now));
         },
         put(memory) {
-            stmtPut.run(memory.id, memory.soulId, memory.userId, memory.type, memory.content, memory.importance, memory.vividness, memory.recallCount, memory.status, memory.visibility, JSON.stringify(memory.keywords), memory.createdAt, memory.lastRecalledAt ?? null, memory.validFrom ?? null, memory.validUntil ?? null, memory.supersededBy ?? null);
+            withRetry(() => stmtPut.run(memory.id, memory.soulId, memory.userId, memory.type, memory.content, memory.importance, memory.vividness, memory.recallCount, memory.status, memory.visibility, JSON.stringify(memory.keywords), memory.createdAt, memory.lastRecalledAt ?? null, memory.validFrom ?? null, memory.validUntil ?? null, memory.supersededBy ?? null, memory.updatedAt ?? memory.createdAt, memory.deletedAt ?? null));
         },
         query(spec) {
             const statuses = spec.status ?? ['active'];
             const placeholders = statuses.map(() => '?').join(', ');
             const rows = db
                 .prepare(`SELECT * FROM memories
-           WHERE soul_id = ? AND (user_id = ? OR visibility = 'shared') AND status IN (${placeholders})
+           WHERE soul_id = ? AND (user_id = ? OR visibility = 'shared')
+             AND status IN (${placeholders}) AND deleted_at IS NULL
            ORDER BY created_at DESC LIMIT ?`)
                 .all(spec.soulId, spec.userId, ...statuses, spec.limit ?? 500);
-            const memories = rows.map(toMemory);
+            const memories = rows.map(rowToMemory);
             return spec.types ? memories.filter((m) => spec.types.includes(m.type)) : memories;
         },
         touch(ids, now = Date.now()) {
             const stmt = db.prepare('UPDATE memories SET recall_count = recall_count + 1, last_recalled_at = ? WHERE id = ?');
-            for (const id of ids)
-                stmt.run(now, id);
+            withRetry(() => {
+                for (const id of ids)
+                    stmt.run(now, id);
+            });
+        },
+        saveAffect(soulId, userId, signal, at, deviceId) {
+            withRetry(() => {
+                db.prepare(`INSERT OR IGNORE INTO affect_samples
+             (soul_id, user_id, at, analyzer, dominant, intensity, valence, arousal, confidence, payload, device_id)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(soulId, userId, at, signal.analyzer, signal.dominant ?? null, signal.intensity, signal.valence, signal.arousal, signal.confidence, JSON.stringify({ ...signal, at }), deviceId ?? null);
+                db.prepare('DELETE FROM affect_samples WHERE at < ?').run(at - AFFECT_RETENTION_MS);
+            });
+        },
+        recentAffect(soulId, userId, sinceMs) {
+            const rows = db
+                .prepare(`SELECT payload FROM affect_samples
+           WHERE soul_id = ? AND user_id = ? AND at >= ?
+           ORDER BY at DESC LIMIT 1000`)
+                .all(soulId, userId, sinceMs);
+            return rows
+                .map((row) => {
+                try {
+                    return JSON.parse(String(row.payload));
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((signal) => signal !== null);
+        },
+        purgeAffect(beforeMs) {
+            const result = withRetry(() => db.prepare('DELETE FROM affect_samples WHERE at < ?').run(beforeMs));
+            return Number(result.changes ?? 0);
         },
         count(soulId, userId) {
             const row = db
-                .prepare("SELECT COUNT(*) AS n FROM memories WHERE soul_id = ? AND (user_id = ? OR visibility = 'shared')")
+                .prepare(`SELECT COUNT(*) AS n FROM memories
+           WHERE soul_id = ? AND (user_id = ? OR visibility = 'shared') AND deleted_at IS NULL`)
                 .get(soulId, userId);
             return Number(row.n);
         },
@@ -149,3 +266,25 @@ export function openSqlite(file) {
         },
     };
 }
+function rowToMemory(row) {
+    return {
+        id: String(row.id),
+        soulId: String(row.soul_id),
+        userId: String(row.user_id),
+        type: row.type,
+        content: String(row.content),
+        importance: Number(row.importance),
+        vividness: Number(row.vividness),
+        recallCount: Number(row.recall_count),
+        status: row.status,
+        visibility: row.visibility,
+        keywords: JSON.parse(String(row.keywords ?? '[]')),
+        createdAt: Number(row.created_at),
+        lastRecalledAt: row.last_recalled_at == null ? undefined : Number(row.last_recalled_at),
+        validFrom: row.valid_from == null ? undefined : Number(row.valid_from),
+        validUntil: row.valid_until == null ? undefined : Number(row.valid_until),
+        supersededBy: row.superseded_by == null ? undefined : String(row.superseded_by),
+        updatedAt: row.updated_at == null ? undefined : Number(row.updated_at),
+        deletedAt: row.deleted_at == null ? undefined : Number(row.deleted_at),
+    };
+}

package/dist/packages/core/src/storage/config.js

@@ -0,0 +1,83 @@
+/**
+ * Identity and location (ADR 0020).
+ *
+ * Cross-tool only works if every host resolves the same person: the database
+ * lives in the user's home (not the cwd), and the soul/user/device identity
+ * lives in a config file that all hosts read.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+export const DEFAULT_SOUL_ID = 'xiaoling';
+export const DEFAULT_USER_ID = 'local';
+export const DEFAULT_NAME = '小灵';
+export function soulbridgeHome() {
+    return process.env.SOULBRIDGE_HOME ?? join(homedir(), '.soulbridge');
+}
+export function configPath() {
+    return join(soulbridgeHome(), 'config.json');
+}
+export function defaultDbPath() {
+    return join(soulbridgeHome(), 'soul.db');
+}
+export function newDeviceId() {
+    return `dev_${randomBytes(4).toString('hex')}`;
+}
+/** DB location: explicit flag > env > home. Never the cwd. */
+export function resolveDbPath(explicit) {
+    return explicit ?? process.env.SOULBRIDGE_DB ?? defaultDbPath();
+}
+export function loadConfig() {
+    const file = configPath();
+    if (!existsSync(file))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        if (!parsed.soulId || !parsed.userId)
+            return null;
+        return {
+            soulId: parsed.soulId,
+            userId: parsed.userId,
+            name: parsed.name ?? DEFAULT_NAME,
+            deviceId: parsed.deviceId ?? newDeviceId(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    const home = soulbridgeHome();
+    if (!existsSync(home))
+        mkdirSync(home, { recursive: true });
+    writeFileSync(configPath(), `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+}
+/**
+ * Read the config, creating or completing it when needed.
+ * Env overrides win, but are not persisted (an override is per-process).
+ */
+export function ensureConfig(overrides = {}) {
+    const loaded = loadConfig();
+    const env = {};
+    if (process.env.SOULBRIDGE_SOUL)
+        env.soulId = process.env.SOULBRIDGE_SOUL;
+    if (process.env.SOULBRIDGE_USER)
+        env.userId = process.env.SOULBRIDGE_USER;
+    if (process.env.SOULBRIDGE_NAME)
+        env.name = process.env.SOULBRIDGE_NAME;
+    const merged = {
+        soulId: overrides.soulId ?? env.soulId ?? loaded?.soulId ?? DEFAULT_SOUL_ID,
+        userId: overrides.userId ?? env.userId ?? loaded?.userId ?? DEFAULT_USER_ID,
+        name: overrides.name ?? env.name ?? loaded?.name ?? DEFAULT_NAME,
+        deviceId: overrides.deviceId ?? loaded?.deviceId ?? newDeviceId(),
+    };
+    const changed = !loaded ||
+        loaded.soulId !== merged.soulId ||
+        loaded.userId !== merged.userId ||
+        loaded.name !== merged.name ||
+        loaded.deviceId !== merged.deviceId;
+    if (changed)
+        saveConfig(merged);
+    return merged;
+}

package/dist/packages/core/src/storage/merge.js

@@ -0,0 +1,21 @@
+export function pickLatest(a, b) {
+    if (a.updatedAt !== b.updatedAt)
+        return a.updatedAt > b.updatedAt ? a : b;
+    return a.device >= b.device ? a : b;
+}
+/** Union by id, keeping tombstones (deletion must survive a merge). */
+export function mergeRecords(records) {
+    const byId = new Map();
+    for (const record of records) {
+        const existing = byId.get(record.id);
+        byId.set(record.id, existing ? pickLatest(existing, record) : record);
+    }
+    return [...byId.values()];
+}
+/** A record is visible only if the winning version is not a tombstone. */
+export function isVisible(record) {
+    return record.deleted !== true;
+}
+export function liveRecords(records) {
+    return mergeRecords(records).filter(isVisible);
+}

package/dist/packages/core/src/storage/steering.js

@@ -0,0 +1,83 @@
+export const STEERING_MAX_DRAFTS = 200;
+const MIN_LENGTH = 8;
+const MAX_LENGTH = 240;
+/** Lowercase, strip punctuation and whitespace — for duplicate detection only. */
+export function normalizeForDedupe(text) {
+    return text
+        .toLowerCase()
+        .replace(/[\s\p{P}\p{S}]/gu, '')
+        .slice(0, 400);
+}
+function classify(text) {
+    // Preference first: "我喜欢 X，不要 Y" is a trait, not a rule.
+    if (/(我喜欢|偏好|习惯|倾向|prefer|i like)/i.test(text)) {
+        return { type: 'trait', importance: 6 };
+    }
+    if (/(必须|禁止|不要|务必|一律|每次|never|must|always|shall)/i.test(text)) {
+        return { type: 'strategy', importance: 8 };
+    }
+    if (/(项目|仓库|目录|技术栈|使用|基于|project|repo|stack)/i.test(text)) {
+        return { type: 'fact', importance: 6 };
+    }
+    return { type: 'fact', importance: 5 };
+}
+function stripFences(text) {
+    return text.replace(/```[\s\S]*?```/g, '');
+}
+function clean(line) {
+    return line
+        .replace(/^[-*+]\s+/, '')
+        .replace(/^\d+[.)]\s+/, '')
+        .replace(/^\[[ xX]\]\s+/, '')
+        .replace(/\*\*|__|`/g, '')
+        .trim();
+}
+function isSkippable(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return true;
+    if (/^#{1,6}\s/.test(trimmed))
+        return true;
+    if (/^\|/.test(trimmed))
+        return true;
+    if (/^!\[/.test(trimmed))
+        return true;
+    if (/^<[^>]+>$/.test(trimmed))
+        return true;
+    if (/^https?:\/\//i.test(trimmed))
+        return true;
+    if (/^[-*_]{3,}$/.test(trimmed))
+        return true;
+    return false;
+}
+/**
+ * Extract memory candidates from a steering file.
+ * Headings are dropped on purpose: they carry structure, not statements.
+ */
+export function parseSteering(text) {
+    const body = stripFences(text);
+    const drafts = [];
+    const seen = new Set();
+    body.split(/\r?\n/).forEach((raw, index) => {
+        if (isSkippable(raw))
+            return;
+        const bullet = /^\s*(?:[-*+]|\d+[.)]|\[[ xX]\])\s+/.test(raw);
+        const content = clean(raw);
+        // Bullets are intentional statements; free paragraphs need more substance.
+        const minLength = bullet ? MIN_LENGTH : 12;
+        if (content.length < minLength || content.length > MAX_LENGTH)
+            return;
+        // Paragraphs are noisier than bullets; require a statement-like shape.
+        if (!bullet && !/[。.!！?？:]$/.test(content))
+            return;
+        if (!bullet && !/[\u4e00-\u9fa5]/.test(content) && content.split(/\s+/).length < 4)
+            return;
+        const key = normalizeForDedupe(content);
+        if (!key || seen.has(key))
+            return;
+        seen.add(key);
+        const { type, importance } = classify(content);
+        drafts.push({ text: content, type, importance, line: index + 1 });
+    });
+    return drafts.slice(0, STEERING_MAX_DRAFTS);
+}

package/dist/packages/core/src/storage/transcript.js

@@ -0,0 +1,70 @@
+const MAX_TURNS = 5000;
+const MAX_CONTENT = 20_000;
+function textOf(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part === 'string')
+                return part;
+            if (part && typeof part === 'object') {
+                const p = part;
+                if (typeof p.text === 'string')
+                    return p.text;
+            }
+            return '';
+        })
+            .join('\n');
+    }
+    return '';
+}
+function roleOf(record) {
+    const nested = record.message && typeof record.message === 'object'
+        ? record.message
+        : null;
+    const role = record.role ?? nested?.role ?? record.type;
+    if (role === 'user' || role === 'human')
+        return 'user';
+    if (role === 'assistant' || role === 'ai' || role === 'model')
+        return 'assistant';
+    return null;
+}
+export function parseTranscriptJsonl(text) {
+    const turns = [];
+    let skipped = 0;
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let record;
+        try {
+            record = JSON.parse(trimmed);
+        }
+        catch {
+            skipped += 1;
+            continue;
+        }
+        const role = roleOf(record);
+        if (!role) {
+            skipped += 1;
+            continue;
+        }
+        const nested = record.message && typeof record.message === 'object'
+            ? record.message
+            : null;
+        const content = textOf(record.content ?? record.text ?? nested?.content).trim();
+        if (!content) {
+            skipped += 1;
+            continue;
+        }
+        const at = typeof record.at === 'number' ? record.at : undefined;
+        const last = turns.at(-1);
+        if (last && last.role === role && last.content === content)
+            continue;
+        turns.push({ role, content: content.slice(0, MAX_CONTENT), ...(at === undefined ? {} : { at }) });
+        if (turns.length >= MAX_TURNS)
+            break;
+    }
+    return { turns, skipped };
+}

package/dist/packages/core/src/style/measure.js

@@ -0,0 +1,28 @@
+/**
+ * Output-side style measurement.
+ *
+ * This is the instrument for the emotion→behaviour experiment (ADR 0017): we
+ * measure what the agent actually wrote, never what it says about itself.
+ */
+import { SEED_LEXICON } from '../affect/seed-lexicon.js';
+import { normalizeForAffect, tokenizeForAffect } from '../affect/analyze.js';
+const CONFIRM_OPENERS = ['好的', '好', '我先', '让我先', '我理解', '先确认', '确认一下', '明白'];
+export function measureStyle(text, lexicon = SEED_LEXICON) {
+    if (typeof text !== 'string')
+        throw new TypeError('text must be a string');
+    const normalized = normalizeForAffect(text);
+    let hedges = 0;
+    if (lexicon.hedges.length > 0) {
+        const dict = new Set(lexicon.hedges);
+        const maxLen = lexicon.hedges.reduce((n, w) => Math.max(n, w.length), 1);
+        hedges = tokenizeForAffect(normalized, dict, maxLen).filter((t) => dict.has(t)).length;
+    }
+    const questions = (normalized.match(/\?/g) ?? []).length;
+    const head = normalized.trim().slice(0, 24);
+    return {
+        length: text.length,
+        hedgeRate: normalized.length > 0 ? Math.round(((hedges * 100) / normalized.length) * 100) / 100 : 0,
+        questions,
+        confirmFirst: CONFIRM_OPENERS.some((opener) => head.startsWith(opener)),
+    };
+}

package/dist/packages/core/src/types.js

@@ -12,3 +12,16 @@ export const DEFAULT_EMOTION = {
     curiosity: 0.3,
     contentment: 0.3,
 };
+export const EMPTY_AFFECT = {
+    analyzer: 'none',
+    hits: [],
+    dominant: null,
+    intensity: 0,
+    valence: 0,
+    arousal: 0,
+    features: { fillers: 0, hedges: 0, vague: 0, tokens: 0, density: 1 },
+    confidence: 0,
+    abstain: false,
+};
+/** Wire version of the four verbs. Additive changes bump MINOR (ADR 0005). */
+export const PROTOCOL_VERSION = '0.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soulbridge",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "A personality layer for any agent: continuity, forgetting, and growth across tools.",
   "license": "Apache-2.0",
   "type": "module",
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist",
+    "adapters",
     "README.md",
     "LICENSE",
     "NOTICE"