@auxiora/personality 1.3.0 → 1.3.1

package/lib/custom-weights.d.ts

@@ -1,4 +1,5 @@
-import type { TraitMix } from '../schema.js';
+import type { TraitMix, ContextDomain } from '../schema.js';
+import type { PreferenceHistory } from './preference-history.js';
 export interface WeightPreset {
     name: string;
     description: string;
@@ -29,6 +30,11 @@ export declare class CustomWeights {
      * 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. */

package/lib/custom-weights.js

@@ -126,6 +126,23 @@ export class CustomWeights {
         }
         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() {

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/feedback-store.d.ts

@@ -0,0 +1,45 @@
+import type { ContextDomain, TraitMix } from '../schema.js';
+export type FeedbackRating = 'helpful' | 'off_target' | 'too_verbose' | 'too_brief' | 'wrong_tone';
+export interface FeedbackEntry {
+    id: string;
+    timestamp: number;
+    domain: ContextDomain;
+    rating: FeedbackRating;
+    traitSnapshot: Partial<Record<keyof TraitMix, number>>;
+    note?: string;
+}
+export interface FeedbackInsight {
+    /** Trait adjustments suggested by accumulated feedback. */
+    suggestedAdjustments: Partial<Record<keyof TraitMix, number>>;
+    /** Domains where responses consistently miss. */
+    weakDomains: ContextDomain[];
+    /** Overall satisfaction trend: improving, declining, or stable. */
+    trend: 'improving' | 'declining' | 'stable';
+    /** Total feedback count. */
+    totalFeedback: number;
+}
+export declare class FeedbackStore {
+    private entries;
+    private maxEntries;
+    /** Record feedback on a response. Auto-generates id and timestamp. */
+    addFeedback(entry: Omit<FeedbackEntry, 'id' | 'timestamp'>): void;
+    /**
+     * Analyze all feedback to produce actionable insights.
+     * - too_verbose feedback -> suggest lowering verbosity (negative adjustment)
+     * - too_brief feedback -> suggest raising verbosity (positive adjustment)
+     * - off_target in a domain -> flag as weak domain
+     * - wrong_tone -> suggest adjusting warmth up
+     */
+    getInsights(): FeedbackInsight;
+    /** Get feedback for a specific domain. */
+    getForDomain(domain: ContextDomain): FeedbackEntry[];
+    /** Get the satisfaction trend over the last N entries. */
+    getRecentTrend(windowSize?: number): 'improving' | 'declining' | 'stable';
+    /** Serialize for encrypted storage. */
+    serialize(): string;
+    /** Deserialize from encrypted storage. */
+    static deserialize(data: string): FeedbackStore;
+    /** Clear all feedback (user data deletion). */
+    clear(): void;
+}
+//# sourceMappingURL=feedback-store.d.ts.map

package/lib/feedback-store.js

@@ -0,0 +1,152 @@
+// ────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ────────────────────────────────────────────────────────────────────────────
+/** 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('-');
+}
+/**
+ * Compute the helpful ratio for a slice of entries.
+ * Returns 0 if the slice is empty.
+ */
+function helpfulRatio(entries) {
+    if (entries.length === 0)
+        return 0;
+    const helpful = entries.filter(e => e.rating === 'helpful').length;
+    return helpful / entries.length;
+}
+/**
+ * Compare helpful ratios of first half vs second half.
+ * A difference > 0.10 in either direction triggers a trend change.
+ */
+function computeTrend(entries) {
+    if (entries.length < 2)
+        return 'stable';
+    const mid = Math.floor(entries.length / 2);
+    const firstHalf = entries.slice(0, mid);
+    const secondHalf = entries.slice(mid);
+    const firstRatio = helpfulRatio(firstHalf);
+    const secondRatio = helpfulRatio(secondHalf);
+    const diff = secondRatio - firstRatio;
+    if (diff > 0.10)
+        return 'improving';
+    if (diff < -0.10)
+        return 'declining';
+    return 'stable';
+}
+// ────────────────────────────────────────────────────────────────────────────
+// FeedbackStore
+// ────────────────────────────────────────────────────────────────────────────
+export class FeedbackStore {
+    entries = [];
+    maxEntries = 500;
+    /** Record feedback on a response. Auto-generates id and timestamp. */
+    addFeedback(entry) {
+        this.entries.push({
+            ...entry,
+            id: generateId(),
+            timestamp: Date.now(),
+        });
+        // Drop oldest entries when exceeding capacity
+        if (this.entries.length > this.maxEntries) {
+            this.entries = this.entries.slice(this.entries.length - this.maxEntries);
+        }
+    }
+    /**
+     * Analyze all feedback to produce actionable insights.
+     * - too_verbose feedback -> suggest lowering verbosity (negative adjustment)
+     * - too_brief feedback -> suggest raising verbosity (positive adjustment)
+     * - off_target in a domain -> flag as weak domain
+     * - wrong_tone -> suggest adjusting warmth up
+     */
+    getInsights() {
+        const suggestedAdjustments = {};
+        const weakDomains = [];
+        // Count each rating type across all entries
+        let tooVerboseCount = 0;
+        let tooBriefCount = 0;
+        let wrongToneCount = 0;
+        // Count off_target per domain
+        const offTargetByDomain = new Map();
+        for (const entry of this.entries) {
+            switch (entry.rating) {
+                case 'too_verbose':
+                    tooVerboseCount++;
+                    break;
+                case 'too_brief':
+                    tooBriefCount++;
+                    break;
+                case 'wrong_tone':
+                    wrongToneCount++;
+                    break;
+                case 'off_target': {
+                    const count = offTargetByDomain.get(entry.domain) ?? 0;
+                    offTargetByDomain.set(entry.domain, count + 1);
+                    break;
+                }
+            }
+        }
+        // too_verbose (>= 5) -> lower verbosity, capped at -0.3
+        if (tooVerboseCount >= 5) {
+            const adj = -0.1 * tooVerboseCount;
+            suggestedAdjustments.verbosity = Math.max(adj, -0.3);
+        }
+        // too_brief (>= 5) -> raise verbosity, capped at +0.3
+        if (tooBriefCount >= 5) {
+            const adj = 0.1 * tooBriefCount;
+            suggestedAdjustments.verbosity = Math.min(adj, 0.3);
+        }
+        // wrong_tone (>= 5) -> adjust warmth up
+        if (wrongToneCount >= 5) {
+            suggestedAdjustments.warmth = 0.1;
+        }
+        // off_target in a domain (>= 3) -> weak domain
+        for (const [domain, count] of offTargetByDomain) {
+            if (count >= 3) {
+                weakDomains.push(domain);
+            }
+        }
+        const trend = computeTrend(this.entries);
+        return {
+            suggestedAdjustments,
+            weakDomains,
+            trend,
+            totalFeedback: this.entries.length,
+        };
+    }
+    /** Get feedback for a specific domain. */
+    getForDomain(domain) {
+        return this.entries.filter(e => e.domain === domain);
+    }
+    /** Get the satisfaction trend over the last N entries. */
+    getRecentTrend(windowSize = 20) {
+        const window = this.entries.slice(-windowSize);
+        return computeTrend(window);
+    }
+    /** Serialize for encrypted storage. */
+    serialize() {
+        return JSON.stringify({ entries: this.entries });
+    }
+    /** Deserialize from encrypted storage. */
+    static deserialize(data) {
+        const store = new FeedbackStore();
+        const parsed = JSON.parse(data);
+        if (Array.isArray(parsed.entries)) {
+            store.entries = parsed.entries;
+        }
+        return store;
+    }
+    /** Clear all feedback (user data deletion). */
+    clear() {
+        this.entries = [];
+    }
+}
+//# sourceMappingURL=feedback-store.js.map

package/lib/index.d.ts

@@ -4,6 +4,9 @@ import type { ArchitectPreferences } from './persistence.js';
 import type { EncryptedStorage } from './persistence-adapter.js';
 import type { WeightPreset } from './custom-weights.js';
 import type { ChatMessage, ExportedConversation } from './conversation-export.js';
+import type { Decision, DecisionQuery } from './decision-log.js';
+import type { FeedbackRating, FeedbackInsight } from './feedback-store.js';
+import type { UserModel } from './user-model-synthesizer.js';
 export type { TraitMix, TraitValue, TaskContext, TraitSource, ContextDomain, EmotionalRegister, ContextSignal, PromptOutput, } from '../schema.js';
 export { ARCHITECT_BASE_PROMPT } from './system-prompt.js';
 export { CONTEXT_PROFILES } from './context-profiles.js';
@@ -29,6 +32,14 @@ export type { ArchitectPreferences } from './persistence.js';
 export type { EncryptedStorage } from './persistence-adapter.js';
 export { InMemoryEncryptedStorage, VaultStorageAdapter } from './persistence-adapter.js';
 export type { VaultLike } from './persistence-adapter.js';
+export { PreferenceHistory } from './preference-history.js';
+export type { PreferenceEntry, PreferenceConflict } from './preference-history.js';
+export { DecisionLog } from './decision-log.js';
+export type { Decision, DecisionQuery, DecisionStatus } from './decision-log.js';
+export { FeedbackStore } from './feedback-store.js';
+export type { FeedbackRating, FeedbackEntry, FeedbackInsight } from './feedback-store.js';
+export { UserModelSynthesizer } from './user-model-synthesizer.js';
+export type { UserModel, DomainProfile, CommunicationStyle, SatisfactionProfile, CorrectionSummary } from './user-model-synthesizer.js';
 type Message = {
     role: string;
     content: string;
@@ -51,6 +62,9 @@ export declare class TheArchitect {
     private conversationContext;
     private emotionalTracker;
     private customWeights;
+    private preferenceHistory;
+    private decisionLog;
+    private feedbackStore;
     private persistence?;
     private preferences?;
     private initialized;
@@ -109,18 +123,47 @@ export declare class TheArchitect {
     getConversationSummary(): import("./conversation-context.js").ConversationSummary;
     /** Get the current emotional trajectory. */
     getEmotionalState(): import("./emotional-tracker.js").EffectiveEmotion;
-    /** Set a custom trait weight offset. Persists if storage is available. */
-    setTraitOverride(trait: keyof TraitMix, offset: number): Promise<void>;
+    /** Set a custom trait weight offset. Records in preference history and persists. */
+    setTraitOverride(trait: keyof TraitMix, offset: number, source?: 'user' | 'preset' | 'feedback', reason?: string): Promise<void>;
     /** Remove a custom trait weight override. */
     removeTraitOverride(trait: keyof TraitMix): Promise<void>;
-    /** Load a preset weight configuration. */
+    /** Load a preset weight configuration. Records each override in preference history. */
     loadPreset(presetName: string): Promise<void>;
     /** Returns available weight presets. */
     listPresets(): Record<string, WeightPreset>;
     /** Returns current custom weight overrides. */
     getActiveOverrides(): Partial<Record<keyof TraitMix, number>>;
-    /** Persist custom weights to encrypted storage. */
+    /** Persist custom weights and preference history to encrypted storage. */
     private persistCustomWeights;
+    /** Get conflicts in preference history. */
+    getPreferenceConflicts(): import("./preference-history.js").PreferenceConflict[];
+    /** Get preference change history for a trait. */
+    getPreferenceHistory(trait: keyof TraitMix): import("./preference-history.js").PreferenceEntry[];
+    /** Record a decision for cross-session tracking. */
+    recordDecision(decision: Omit<Decision, 'id' | 'timestamp' | 'tags'>): Promise<Decision>;
+    /** Update a decision's status or outcome. */
+    updateDecision(id: string, updates: Partial<Pick<Decision, 'status' | 'outcome' | 'followUpDate'>>): Promise<void>;
+    /** Query decisions with filters. */
+    queryDecisions(q: DecisionQuery): Decision[];
+    /** Get decisions due for follow-up. */
+    getDueFollowUps(): Decision[];
+    /** Persist decision log to encrypted storage. */
+    private persistDecisionLog;
+    /** Record feedback on a response. */
+    recordFeedback(feedback: {
+        domain: ContextDomain;
+        rating: FeedbackRating;
+        traitSnapshot?: Partial<Record<keyof TraitMix, number>>;
+        note?: string;
+    }): Promise<void>;
+    /** Get actionable feedback insights. */
+    getFeedbackInsights(): FeedbackInsight;
+    /** Get satisfaction trend over recent feedback. */
+    getFeedbackTrend(windowSize?: number): 'improving' | 'declining' | 'stable';
+    /** Persist feedback store to encrypted storage. */
+    private persistFeedbackStore;
+    /** Synthesize a complete user model from all data stores. */
+    getUserModel(): UserModel;
     /**
      * Apply trajectory-based multipliers on top of standard emotional overrides.
      * Caps all values at 1.0.
@@ -141,7 +184,7 @@ export declare class TheArchitect {
     getPreferences(): Promise<ArchitectPreferences>;
     /** Update a single preference and persist. */
     updatePreference<K extends keyof ArchitectPreferences>(key: K, value: ArchitectPreferences[K]): Promise<void>;
-    /** Clear all persisted data: corrections, preferences, usage history. */
+    /** Clear all persisted data: corrections, preferences, usage history, and self-awareness stores. */
     clearAllData(): Promise<void>;
     /**
      * Export a conversation with full personality engine metadata.