@auxiora/personality 1.0.0 → 1.3.1

package/lib/correction-store.js

@@ -0,0 +1,185 @@
+// ────────────────────────────────────────────────────────────────────────────
+// Stopwords — common English words that carry no domain signal
+// ────────────────────────────────────────────────────────────────────────────
+const STOPWORDS = new Set([
+    'this', 'that', 'with', 'from', 'have', 'been', 'were', 'they', 'them',
+    'their', 'what', 'when', 'where', 'which', 'while', 'will', 'would',
+    'could', 'should', 'about', 'after', 'again', 'also', 'because', 'before',
+    'between', 'both', 'came', 'come', 'does', 'done', 'each', 'else', 'even',
+    'every', 'good', 'great', 'here', 'into', 'just', 'know', 'like', 'long',
+    'look', 'make', 'many', 'more', 'most', 'much', 'must', 'need', 'only',
+    'other', 'over', 'same', 'some', 'such', 'take', 'tell', 'than', 'then',
+    'there', 'these', 'thing', 'think', 'those', 'through', 'time', 'under',
+    'upon', 'very', 'want', 'well', 'went', 'your', 'able', 'back', 'being',
+    'call', 'case', 'down', 'find', 'first', 'give', 'going', 'hand', 'help',
+    'high', 'keep', 'last', 'left', 'life', 'line', 'made', 'might', 'move',
+    'name', 'next', 'open', 'part', 'place', 'point', 'right', 'show', 'side',
+    'since', 'small', 'start', 'still', 'turn', 'used', 'using', 'work',
+    'world', 'year', 'away', 'best', 'came', 'dear', 'didn', 'don', 'end',
+    'enough', 'ever', 'far', 'few', 'get', 'got', 'had', 'has', 'her', 'him',
+    'his', 'how', 'its', 'let', 'may', 'new', 'now', 'off', 'old', 'one',
+    'our', 'out', 'own', 'put', 'ran', 'run', 'say', 'she', 'too', 'try',
+    'two', 'use', 'way', 'who', 'why', 'big', 'can', 'day', 'did', 'for',
+    'got', 'him', 'not', 'the', 'and', 'are', 'but',
+]);
+// ────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ────────────────────────────────────────────────────────────────────────────
+/** Extract meaningful keywords from a message. */
+function extractKeywords(message) {
+    return message
+        .toLowerCase()
+        .split(/\s+/)
+        .map(w => w.replace(/[^a-z0-9]/g, ''))
+        .filter(w => w.length > 3 && !STOPWORDS.has(w));
+}
+/** Generate a v4-style UUID without crypto dependency. */
+function generateId() {
+    const hex = '0123456789abcdef';
+    const segments = [8, 4, 4, 4, 12];
+    return segments.map(len => {
+        let s = '';
+        for (let i = 0; i < len; i++) {
+            s += hex[Math.floor(Math.random() * 16)];
+        }
+        return s;
+    }).join('-');
+}
+// ────────────────────────────────────────────────────────────────────────────
+// CorrectionStore
+// ────────────────────────────────────────────────────────────────────────────
+export class CorrectionStore {
+    corrections = [];
+    patterns = [];
+    /** Record a new correction. Generates id/timestamp and extracts keywords. */
+    addCorrection(correction) {
+        this.corrections.push({
+            ...correction,
+            id: generateId(),
+            timestamp: Date.now(),
+            keywords: extractKeywords(correction.userMessage),
+        });
+        this.recomputePatterns();
+    }
+    /** Get all stored corrections. */
+    getCorrections() {
+        return this.corrections;
+    }
+    /** Get correction patterns sorted by confidence descending. */
+    getPatterns() {
+        return [...this.patterns].sort((a, b) => b.confidence - a.confidence);
+    }
+    /**
+     * Given a message and detected domain, check if corrections suggest a
+     * different domain. Returns the corrected domain if pattern confidence
+     * > 0.6 and occurrences >= 3, else null.
+     */
+    suggestCorrection(message, detectedDomain) {
+        const messageKeywords = extractKeywords(message);
+        if (messageKeywords.length === 0)
+            return null;
+        // Find matching patterns: keyword present in message, fromDomain matches
+        const matches = this.patterns.filter(p => p.fromDomain === detectedDomain &&
+            p.confidence > 0.6 &&
+            p.occurrences >= 3 &&
+            messageKeywords.includes(p.keyword));
+        if (matches.length === 0)
+            return null;
+        // Pick the match with highest confidence; break ties with occurrences
+        matches.sort((a, b) => b.confidence - a.confidence || b.occurrences - a.occurrences);
+        return matches[0].toDomain;
+    }
+    /** Recompute patterns from all stored corrections. */
+    recomputePatterns() {
+        // Count how many corrections contain each keyword (for confidence denominator)
+        const keywordTotals = new Map();
+        for (const c of this.corrections) {
+            const seen = new Set(c.keywords);
+            for (const kw of seen) {
+                keywordTotals.set(kw, (keywordTotals.get(kw) ?? 0) + 1);
+            }
+        }
+        // Group by (keyword, fromDomain, toDomain) and count occurrences
+        const groups = new Map();
+        for (const c of this.corrections) {
+            const seen = new Set(c.keywords);
+            for (const kw of seen) {
+                const key = `${kw}|${c.detectedDomain}|${c.correctedDomain}`;
+                const existing = groups.get(key);
+                if (existing) {
+                    existing.occurrences++;
+                }
+                else {
+                    groups.set(key, {
+                        keyword: kw,
+                        fromDomain: c.detectedDomain,
+                        toDomain: c.correctedDomain,
+                        occurrences: 1,
+                    });
+                }
+            }
+        }
+        this.patterns = [];
+        for (const g of groups.values()) {
+            const total = keywordTotals.get(g.keyword) ?? 1;
+            this.patterns.push({
+                ...g,
+                confidence: g.occurrences / total,
+            });
+        }
+    }
+    /** Serialize for encrypted storage. */
+    serialize() {
+        return JSON.stringify({
+            corrections: this.corrections,
+            patterns: this.patterns,
+        });
+    }
+    /** Deserialize from encrypted storage. */
+    static deserialize(data) {
+        const store = new CorrectionStore();
+        const parsed = JSON.parse(data);
+        store.corrections = parsed.corrections;
+        store.patterns = parsed.patterns;
+        return store;
+    }
+    /** Clear all corrections (user data deletion). */
+    clear() {
+        this.corrections = [];
+        this.patterns = [];
+    }
+    /** Stats for debugging. */
+    getStats() {
+        const pairCounts = new Map();
+        const domainDetected = new Map();
+        const domainCorrected = new Map();
+        for (const c of this.corrections) {
+            // Count pair
+            const key = `${c.detectedDomain}→${c.correctedDomain}`;
+            const existing = pairCounts.get(key);
+            if (existing) {
+                existing.count++;
+            }
+            else {
+                pairCounts.set(key, { from: c.detectedDomain, to: c.correctedDomain, count: 1 });
+            }
+            // Count detected and corrected per domain
+            domainDetected.set(c.detectedDomain, (domainDetected.get(c.detectedDomain) ?? 0) + 1);
+            domainCorrected.set(c.detectedDomain, (domainCorrected.get(c.detectedDomain) ?? 0) + 1);
+        }
+        const topMisclassifications = [...pairCounts.values()]
+            .sort((a, b) => b.count - a.count);
+        // correctionRate = corrections for domain / total times that domain was detected
+        const correctionRate = {};
+        for (const [domain, correctedCount] of domainCorrected) {
+            const detectedCount = domainDetected.get(domain) ?? 1;
+            correctionRate[domain] = correctedCount / detectedCount;
+        }
+        return {
+            totalCorrections: this.corrections.length,
+            topMisclassifications,
+            correctionRate,
+        };
+    }
+}
+//# sourceMappingURL=correction-store.js.map

package/lib/custom-weights.d.ts

@@ -0,0 +1,49 @@
+import type { TraitMix, ContextDomain } from '../schema.js';
+import type { PreferenceHistory } from './preference-history.js';
+export interface WeightPreset {
+    name: string;
+    description: string;
+    overrides: Partial<Record<keyof TraitMix, number>>;
+}
+export declare const WEIGHT_PRESETS: Record<string, WeightPreset>;
+/**
+ * User-defined trait weight adjustments. These are ADDITIVE offsets applied
+ * after context profiles and emotional overrides, allowing users to
+ * permanently nudge the personality toward their preferences.
+ *
+ * Offsets are clamped to [-0.3, +0.3] — enough to meaningfully shift
+ * behavior without fully overriding the context profile.
+ */
+export declare class CustomWeights {
+    private overrides;
+    /**
+     * Set a custom weight offset for a trait.
+     * Clamps to [-0.3, +0.3]. Throws if the trait key is invalid.
+     */
+    setOverride(trait: keyof TraitMix, offset: number): void;
+    /** Remove a custom override for a single trait. */
+    removeOverride(trait: keyof TraitMix): void;
+    /** Get all current overrides. Returns a shallow copy. */
+    getOverrides(): Partial<Record<keyof TraitMix, number>>;
+    /**
+     * Apply overrides to a trait mix. For each override, adds the offset
+     * and clamps the result to [0.0, 1.0].
+     */
+    apply(baseMix: TraitMix): TraitMix;
+    /**
+     * Apply overrides using history-resolved offsets instead of raw last-write values.
+     * Falls back to standard apply() when no history entries exist for a trait.
+     */
+    applyWithHistory(baseMix: TraitMix, currentDomain: ContextDomain | undefined, history: PreferenceHistory): TraitMix;
+    /** All available presets. */
+    static get presets(): Record<string, WeightPreset>;
+    /** Load a preset, replacing all current overrides. Throws if preset not found. */
+    loadPreset(presetName: string): void;
+    /** Serialize overrides to JSON string for persistence. */
+    serialize(): string;
+    /** Deserialize a CustomWeights instance from a JSON string. */
+    static deserialize(data: string): CustomWeights;
+    /** Clear all overrides. */
+    clear(): void;
+}
+//# sourceMappingURL=custom-weights.d.ts.map

package/lib/custom-weights.js

@@ -0,0 +1,181 @@
+// ────────────────────────────────────────────────────────────────────────────
+// Constants
+// ────────────────────────────────────────────────────────────────────────────
+/** Maximum absolute offset a user can apply to any trait. */
+const MAX_OFFSET = 0.3;
+/** All valid trait keys from TraitMix. */
+const VALID_TRAITS = new Set([
+    'inversion', 'firstPrinciples', 'mentalSimulation', 'adversarialThinking',
+    'secondOrder', 'systemsView', 'simplification', 'storytelling',
+    'tacticalEmpathy', 'genuineCuriosity', 'radicalCandor', 'standardSetting',
+    'developmentalCoaching', 'strategicGenerosity', 'stoicCalm', 'paranoidVigilance',
+    'valueEquation', 'ooda', 'buildForChange', 'humanCenteredDesign',
+    'constraintCreativity', 'regretMinimization', 'doorClassification',
+    'probabilistic', 'plannedAbandonment', 'warmth', 'urgency', 'humor', 'verbosity',
+]);
+// ────────────────────────────────────────────────────────────────────────────
+// Presets
+// ────────────────────────────────────────────────────────────────────────────
+export const WEIGHT_PRESETS = {
+    the_ciso: {
+        name: 'The CISO',
+        description: 'Extra paranoia, adversarial thinking, and rigor. For security-focused work.',
+        overrides: {
+            adversarialThinking: +0.2,
+            paranoidVigilance: +0.2,
+            inversion: +0.15,
+            systemsView: +0.1,
+            humor: -0.15,
+            warmth: -0.1,
+        },
+    },
+    the_builder: {
+        name: 'The Builder',
+        description: 'Bias toward action, simplicity, and shipping. Less analysis, more execution.',
+        overrides: {
+            valueEquation: +0.2,
+            ooda: +0.2,
+            buildForChange: +0.15,
+            constraintCreativity: +0.15,
+            secondOrder: -0.1,
+            verbosity: -0.15,
+        },
+    },
+    the_coach: {
+        name: 'The Coach',
+        description: 'Extra empathy, patience, and developmental focus. For leadership and mentoring.',
+        overrides: {
+            tacticalEmpathy: +0.2,
+            developmentalCoaching: +0.2,
+            genuineCuriosity: +0.15,
+            warmth: +0.2,
+            radicalCandor: +0.1,
+            urgency: -0.2,
+            adversarialThinking: -0.15,
+        },
+    },
+    the_strategist: {
+        name: 'The Strategist',
+        description: 'Deep second-order thinking, inversion, and long-term framing.',
+        overrides: {
+            inversion: +0.2,
+            secondOrder: +0.2,
+            probabilistic: +0.15,
+            doorClassification: +0.15,
+            plannedAbandonment: +0.1,
+            verbosity: +0.15,
+            ooda: -0.1,
+            humor: -0.1,
+        },
+    },
+    the_closer: {
+        name: 'The Closer',
+        description: 'Sales-focused energy. Value equations, storytelling, urgency.',
+        overrides: {
+            valueEquation: +0.25,
+            storytelling: +0.2,
+            simplification: +0.15,
+            urgency: +0.15,
+            humor: +0.1,
+            stoicCalm: -0.1,
+            adversarialThinking: -0.15,
+        },
+    },
+};
+// ────────────────────────────────────────────────────────────────────────────
+// CustomWeights
+// ────────────────────────────────────────────────────────────────────────────
+/**
+ * User-defined trait weight adjustments. These are ADDITIVE offsets applied
+ * after context profiles and emotional overrides, allowing users to
+ * permanently nudge the personality toward their preferences.
+ *
+ * Offsets are clamped to [-0.3, +0.3] — enough to meaningfully shift
+ * behavior without fully overriding the context profile.
+ */
+export class CustomWeights {
+    overrides = {};
+    // ── Set / Remove ────────────────────────────────────────────────────────
+    /**
+     * Set a custom weight offset for a trait.
+     * Clamps to [-0.3, +0.3]. Throws if the trait key is invalid.
+     */
+    setOverride(trait, offset) {
+        if (!VALID_TRAITS.has(trait)) {
+            throw new Error(`Invalid trait key: ${trait}`);
+        }
+        this.overrides[trait] = Math.min(MAX_OFFSET, Math.max(-MAX_OFFSET, offset));
+    }
+    /** Remove a custom override for a single trait. */
+    removeOverride(trait) {
+        delete this.overrides[trait];
+    }
+    /** Get all current overrides. Returns a shallow copy. */
+    getOverrides() {
+        return { ...this.overrides };
+    }
+    // ── Application ─────────────────────────────────────────────────────────
+    /**
+     * Apply overrides to a trait mix. For each override, adds the offset
+     * and clamps the result to [0.0, 1.0].
+     */
+    apply(baseMix) {
+        const result = { ...baseMix };
+        for (const [trait, offset] of Object.entries(this.overrides)) {
+            result[trait] = Math.min(1.0, Math.max(0.0, result[trait] + offset));
+        }
+        return result;
+    }
+    /**
+     * Apply overrides using history-resolved offsets instead of raw last-write values.
+     * Falls back to standard apply() when no history entries exist for a trait.
+     */
+    applyWithHistory(baseMix, currentDomain, history) {
+        const result = { ...baseMix };
+        const rawOverrides = this.overrides;
+        // Collect all traits that have either raw overrides or history entries
+        const traits = new Set(Object.keys(rawOverrides));
+        for (const trait of traits) {
+            const historyOffset = history.getEffectiveOffset(trait, currentDomain ?? undefined);
+            // Use history-resolved offset if history has entries for this trait, otherwise fall back to raw
+            const offset = historyOffset !== 0 ? historyOffset : (rawOverrides[trait] ?? 0);
+            result[trait] = Math.min(1.0, Math.max(0.0, result[trait] + offset));
+        }
+        return result;
+    }
+    // ── Presets ─────────────────────────────────────────────────────────────
+    /** All available presets. */
+    static get presets() {
+        return WEIGHT_PRESETS;
+    }
+    /** Load a preset, replacing all current overrides. Throws if preset not found. */
+    loadPreset(presetName) {
+        const preset = WEIGHT_PRESETS[presetName];
+        if (!preset) {
+            throw new Error(`Unknown preset: ${presetName}. Available: ${Object.keys(WEIGHT_PRESETS).join(', ')}`);
+        }
+        this.overrides = { ...preset.overrides };
+    }
+    // ── Serialization ───────────────────────────────────────────────────────
+    /** Serialize overrides to JSON string for persistence. */
+    serialize() {
+        return JSON.stringify(this.overrides);
+    }
+    /** Deserialize a CustomWeights instance from a JSON string. */
+    static deserialize(data) {
+        const instance = new CustomWeights();
+        const parsed = JSON.parse(data);
+        for (const [trait, offset] of Object.entries(parsed)) {
+            if (VALID_TRAITS.has(trait) && typeof offset === 'number') {
+                instance.overrides[trait] = Math.min(MAX_OFFSET, Math.max(-MAX_OFFSET, offset));
+            }
+        }
+        return instance;
+    }
+    // ── Lifecycle ───────────────────────────────────────────────────────────
+    /** Clear all overrides. */
+    clear() {
+        this.overrides = {};
+    }
+}
+//# sourceMappingURL=custom-weights.js.map

package/lib/decision-log.d.ts

@@ -0,0 +1,41 @@
+import type { ContextDomain } from '../schema.js';
+export type DecisionStatus = 'active' | 'revisit' | 'completed' | 'abandoned';
+export interface Decision {
+    id: string;
+    timestamp: number;
+    domain: ContextDomain;
+    summary: string;
+    context: string;
+    status: DecisionStatus;
+    followUpDate?: number;
+    outcome?: string;
+    tags: string[];
+}
+export interface DecisionQuery {
+    domain?: ContextDomain;
+    status?: DecisionStatus;
+    since?: number;
+    search?: string;
+    limit?: number;
+}
+export declare class DecisionLog {
+    private decisions;
+    private maxDecisions;
+    /** Record a new decision. Auto-generates id, timestamp, and tags. */
+    addDecision(decision: Omit<Decision, 'id' | 'timestamp' | 'tags'>): Decision;
+    /** Update an existing decision's status or outcome. */
+    updateDecision(id: string, updates: Partial<Pick<Decision, 'status' | 'outcome' | 'followUpDate'>>): void;
+    /** Query decisions with filters. All filters are AND-combined. */
+    query(q: DecisionQuery): Decision[];
+    /** Get decisions due for follow-up (followUpDate <= now). */
+    getDueFollowUps(): Decision[];
+    /** Get recent decisions for a domain (for context in new conversations). */
+    getRecentForDomain(domain: ContextDomain, limit?: number): Decision[];
+    /** Serialize for encrypted storage. */
+    serialize(): string;
+    /** Deserialize from encrypted storage. */
+    static deserialize(data: string): DecisionLog;
+    /** Clear all decisions (user data deletion). */
+    clear(): void;
+}
+//# sourceMappingURL=decision-log.d.ts.map

package/lib/decision-log.js

@@ -0,0 +1,145 @@
+// ────────────────────────────────────────────────────────────────────────────
+// Stopwords — common English words filtered from tag extraction
+// ────────────────────────────────────────────────────────────────────────────
+const STOPWORDS = new Set([
+    'this', 'that', 'with', 'from', 'have', 'been', 'were', 'they', 'them',
+    'their', 'what', 'when', 'where', 'which', 'while', 'will', 'would',
+    'could', 'should', 'about', 'after', 'again', 'also', 'because', 'before',
+    'between', 'both', 'came', 'come', 'does', 'done', 'each', 'else', 'even',
+    'every', 'good', 'great', 'here', 'into', 'just', 'know', 'like', 'long',
+    'look', 'make', 'many', 'more', 'most', 'much', 'must', 'need', 'only',
+    'other', 'over', 'same', 'some', 'such', 'take', 'tell', 'than', 'then',
+    'there', 'these', 'thing', 'think', 'those', 'through', 'time', 'under',
+    'upon', 'very', 'want', 'well', 'went', 'your', 'able', 'back', 'being',
+    'call', 'case', 'down', 'find', 'first', 'give', 'going', 'hand', 'help',
+    'high', 'keep', 'last', 'left', 'life', 'line', 'made', 'might', 'move',
+    'name', 'next', 'open', 'part', 'place', 'point', 'right', 'show', 'side',
+    'since', 'small', 'start', 'still', 'turn', 'used', 'using', 'work',
+    'world', 'year', 'away', 'best', 'came', 'dear', 'didn', 'don', 'end',
+    'enough', 'ever', 'far', 'few', 'get', 'got', 'had', 'has', 'her', 'him',
+    'his', 'how', 'its', 'let', 'may', 'new', 'now', 'off', 'old', 'one',
+    'our', 'out', 'own', 'put', 'ran', 'run', 'say', 'she', 'too', 'try',
+    'two', 'use', 'way', 'who', 'why', 'big', 'can', 'day', 'did', 'for',
+    'got', 'him', 'not', 'the', 'and', 'are', 'but',
+]);
+// ────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ────────────────────────────────────────────────────────────────────────────
+/** Extract meaningful keyword tags from text. */
+function extractTags(text) {
+    const words = text
+        .toLowerCase()
+        .split(/\s+/)
+        .map(w => w.replace(/[^a-z0-9]/g, ''))
+        .filter(w => w.length >= 4 && !STOPWORDS.has(w));
+    // Deduplicate while preserving order
+    return [...new Set(words)];
+}
+/** Generate a v4-style UUID without crypto dependency. */
+function generateId() {
+    const hex = '0123456789abcdef';
+    const segments = [8, 4, 4, 4, 12];
+    return segments.map(len => {
+        let s = '';
+        for (let i = 0; i < len; i++) {
+            s += hex[Math.floor(Math.random() * 16)];
+        }
+        return s;
+    }).join('-');
+}
+// ────────────────────────────────────────────────────────────────────────────
+// DecisionLog
+// ────────────────────────────────────────────────────────────────────────────
+export class DecisionLog {
+    decisions = [];
+    maxDecisions = 500;
+    /** Record a new decision. Auto-generates id, timestamp, and tags. */
+    addDecision(decision) {
+        const entry = {
+            ...decision,
+            id: generateId(),
+            timestamp: Date.now(),
+            tags: extractTags(`${decision.summary} ${decision.context}`),
+        };
+        this.decisions.push(entry);
+        // Enforce capacity — drop oldest when over limit
+        if (this.decisions.length > this.maxDecisions) {
+            this.decisions = this.decisions.slice(this.decisions.length - this.maxDecisions);
+        }
+        return entry;
+    }
+    /** Update an existing decision's status or outcome. */
+    updateDecision(id, updates) {
+        const decision = this.decisions.find(d => d.id === id);
+        if (!decision) {
+            throw new Error(`Decision not found: ${id}`);
+        }
+        if (updates.status !== undefined)
+            decision.status = updates.status;
+        if (updates.outcome !== undefined)
+            decision.outcome = updates.outcome;
+        if (updates.followUpDate !== undefined)
+            decision.followUpDate = updates.followUpDate;
+    }
+    /** Query decisions with filters. All filters are AND-combined. */
+    query(q) {
+        let results = this.decisions.filter(d => {
+            if (q.domain !== undefined && d.domain !== q.domain)
+                return false;
+            if (q.status !== undefined && d.status !== q.status)
+                return false;
+            if (q.since !== undefined && d.timestamp < q.since)
+                return false;
+            if (q.search !== undefined) {
+                const needle = q.search.toLowerCase();
+                const haystack = `${d.summary} ${d.context} ${d.tags.join(' ')}`.toLowerCase();
+                if (!haystack.includes(needle))
+                    return false;
+            }
+            return true;
+        });
+        // Sort by timestamp descending (most recent first)
+        results.sort((a, b) => b.timestamp - a.timestamp);
+        if (q.limit !== undefined && q.limit > 0) {
+            results = results.slice(0, q.limit);
+        }
+        return results;
+    }
+    /** Get decisions due for follow-up (followUpDate <= now). */
+    getDueFollowUps() {
+        const now = Date.now();
+        return this.decisions
+            .filter(d => d.followUpDate !== undefined && d.followUpDate <= now)
+            .sort((a, b) => b.timestamp - a.timestamp);
+    }
+    /** Get recent decisions for a domain (for context in new conversations). */
+    getRecentForDomain(domain, limit = 10) {
+        return this.decisions
+            .filter(d => d.domain === domain)
+            .sort((a, b) => b.timestamp - a.timestamp)
+            .slice(0, limit);
+    }
+    /** Serialize for encrypted storage. */
+    serialize() {
+        return JSON.stringify({ decisions: this.decisions });
+    }
+    /** Deserialize from encrypted storage. */
+    static deserialize(data) {
+        const log = new DecisionLog();
+        try {
+            const parsed = JSON.parse(data);
+            if (Array.isArray(parsed.decisions)) {
+                log.decisions = parsed.decisions;
+            }
+        }
+        catch {
+            // Corrupt data — return empty log
+        }
+        return log;
+    }
+    /** Clear all decisions (user data deletion). */
+    clear() {
+        this.decisions = [];
+    }
+}
+//# sourceMappingURL=decision-log.js.map

package/lib/emotional-overrides.d.ts

@@ -0,0 +1,14 @@
+import type { TraitMix, EmotionalRegister } from '../schema.js';
+/**
+ * Multipliers applied on top of the context profile's base trait values.
+ * Values > 1.0 amplify a trait; values < 1.0 dampen it.
+ * After multiplication, all traits are capped at 1.0 by `applyEmotionalOverride`.
+ */
+export declare const EMOTIONAL_OVERRIDES: Record<EmotionalRegister, Partial<Record<keyof TraitMix, number>>>;
+/**
+ * Applies emotional multipliers to a base trait mix, producing a new TraitMix
+ * where each trait is multiplied by its override value (defaulting to 1.0)
+ * and capped at 1.0.
+ */
+export declare function applyEmotionalOverride(baseMix: TraitMix, emotion: EmotionalRegister): TraitMix;
+//# sourceMappingURL=emotional-overrides.d.ts.map