psyche-ai 3.0.0 → 4.0.0

package/dist/prompt.js

@@ -15,7 +15,7 @@ import { getChannelProfile, buildChannelModifier } from "./channels.js";
  *
  * This is the "current moment" — what the agent is feeling RIGHT NOW.
  */
-export function buildDynamicContext(state, userId) {
+export function buildDynamicContext(state, userId, opts) {
     const { current, baseline, mbti, empathyLog, selfModel, meta, agreementStreak, emotionalHistory } = state;
     const locale = meta.locale ?? "zh";
     const relationship = getRelationship(state, userId);
@@ -88,6 +88,16 @@ export function buildDynamicContext(state, userId) {
     if (reciprocity) {
         parts.push("", reciprocity);
     }
+    // Metacognitive awareness (P5)
+    if (opts?.metacognitiveNote) {
+        const mcTitle = locale === "zh" ? "元认知" : "Metacognition";
+        parts.push("", `[${mcTitle}] ${opts.metacognitiveNote}`);
+    }
+    // Decision bias context (P5)
+    if (opts?.decisionContext) {
+        const dbTitle = locale === "zh" ? "决策倾向" : "Decision Bias";
+        parts.push("", `[${dbTitle}] ${opts.decisionContext}`);
+    }
     parts.push("", agencyReminder, sycophancyWarning, "", t("dynamic.update_reminder", locale));
     return parts.filter((l) => l !== undefined).join("\n");
 }
@@ -478,7 +488,19 @@ export function buildCompactContext(state, userId, opts) {
         if (selfCtx)
             parts.push(selfCtx);
     }
-    // 9. Cross-session emotional memory — surface relationship history
+    // 9. Metacognitive awareness (P5)
+    if (opts?.metacognitiveNote) {
+        parts.push(locale === "zh"
+            ? `[元认知] ${opts.metacognitiveNote}`
+            : `[Metacognition] ${opts.metacognitiveNote}`);
+    }
+    // 9b. Decision bias (P5) — only if significantly non-neutral
+    if (opts?.decisionContext) {
+        parts.push(locale === "zh"
+            ? `[决策倾向] ${opts.decisionContext}`
+            : `[Decision Bias] ${opts.decisionContext}`);
+    }
+    // 10. Cross-session emotional memory — surface relationship history
     const relationship = getRelationship(state, userId);
     if (relationship.memory && relationship.memory.length > 0) {
         const memLines = relationship.memory.slice(-3); // last 3 sessions
@@ -486,12 +508,12 @@ export function buildCompactContext(state, userId, opts) {
             ? `[记忆]\n${memLines.join("\n")}`
             : `[Memory]\n${memLines.join("\n")}`);
     }
-    // 10. Channel modifier — expression style per platform (between memory and empathy)
+    // 11. Channel modifier — expression style per platform (between memory and empathy)
     if (opts?.channelType) {
         const channelProfile = getChannelProfile(opts.channelType);
         parts.push(buildChannelModifier(channelProfile, locale));
     }
-    // 11. Empathy report — only when user shares feelings
+    // 12. Empathy report — only when user shares feelings
     parts.push(locale === "zh"
         ? `如果对方在分享感受，在回复末尾用 <psyche_update> 报告：\nuserState: 对方情绪\nprojectedFeeling: 你的感受\nresonance: match|partial|mismatch\n否则不需要报告。`
         : `If user shares feelings, report at end with <psyche_update>:\nuserState: their emotion\nprojectedFeeling: your feeling\nresonance: match|partial|mismatch\nOtherwise no report needed.`);

package/dist/psyche-file.js

@@ -4,7 +4,7 @@
 // ============================================================
 import { readFile, writeFile, access, rename, constants } from "node:fs/promises";
 import { join } from "node:path";
-import { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, MAX_EMOTIONAL_HISTORY, MAX_RELATIONSHIP_MEMORY, } from "./types.js";
+import { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE, MAX_EMOTIONAL_HISTORY, MAX_RELATIONSHIP_MEMORY, } from "./types.js";
 import { getBaseline, getDefaultSelfModel, extractMBTI, getSensitivity, getTemperament } from "./profiles.js";
 import { applyDecay, detectEmotions } from "./chemistry.js";
 import { decayDrives, computeEffectiveBaseline } from "./drives.js";
@@ -241,11 +241,13 @@ export function migrateToLatest(raw, fallbackName) {
     }
     // v2→v3: add drives
     // v3→v4: add learning
+    // v4→v5: add metacognition
     return {
         ...state,
-        version: 4,
+        version: 5,
         drives: state.drives ?? { ...DEFAULT_DRIVES },
         learning: state.learning ?? { ...DEFAULT_LEARNING_STATE },
+        metacognition: state.metacognition ?? { ...DEFAULT_METACOGNITIVE_STATE },
     };
 }
 /**
@@ -259,7 +261,7 @@ export async function initializeState(workspaceDir, opts, logger = NOOP_LOGGER)
     const selfModel = getDefaultSelfModel(mbti);
     const now = new Date().toISOString();
     const state = {
-        version: 4,
+        version: 5,
         mbti,
         baseline,
         current: { ...baseline },
@@ -274,6 +276,7 @@ export async function initializeState(workspaceDir, opts, logger = NOOP_LOGGER)
         agreementStreak: 0,
         lastDisagreement: null,
         learning: { ...DEFAULT_LEARNING_STATE },
+        metacognition: { ...DEFAULT_METACOGNITIVE_STATE },
         meta: {
             agentName,
             createdAt: now,

package/dist/temporal.d.ts

@@ -0,0 +1,38 @@
+import type { ChemicalState, ChemicalSnapshot, StimulusType, PsycheState, RelationshipState } from "./types.js";
+export interface StimulusPrediction {
+    stimulus: StimulusType;
+    probability: number;
+}
+export interface AnticipationState {
+    predictions: StimulusPrediction[];
+    anticipatoryChemistry: Partial<ChemicalState>;
+    timestamp: string;
+}
+export interface RegretEntry {
+    turnIndex: number;
+    counterfactualDelta: Partial<ChemicalState>;
+    regretIntensity: number;
+    description: string;
+    timestamp: string;
+}
+/**
+ * Predict likely next stimulus based on interaction history.
+ * Uses simple Markov property: given recent stimulus sequence, what comes next?
+ */
+export declare function predictNextStimulus(emotionalHistory: ChemicalSnapshot[], relationshipPhase: RelationshipState["phase"]): StimulusPrediction[];
+/**
+ * Generate anticipatory chemistry changes based on predictions.
+ * High-probability positive prediction -> DA/OT micro-rise.
+ * High-probability negative prediction -> CORT micro-rise.
+ */
+export declare function generateAnticipation(predictions: StimulusPrediction[], currentChemistry: ChemicalState): AnticipationState;
+/**
+ * Compute disappointment/surprise when actual stimulus differs from prediction.
+ * Returns additional chemistry delta beyond the normal stimulus response.
+ */
+export declare function computeSurpriseEffect(anticipated: AnticipationState, actualStimulus: StimulusType | null): Partial<ChemicalState>;
+/**
+ * Evaluate if the last interaction would have gone better with different chemistry.
+ * Runs a counterfactual: "what if my chemistry had been at baseline?"
+ */
+export declare function computeRegret(preInteractionState: PsycheState, postInteractionState: PsycheState, outcomeScore: number, appliedStimulus: StimulusType | null): RegretEntry | null;

package/dist/temporal.js

@@ -0,0 +1,276 @@
+// ============================================================
+// Temporal Consciousness — Anticipation, Surprise, and Regret
+//
+// Implements predictive emotional processing:
+//   1. PredictiveModel   — Markov-based stimulus prediction
+//   2. AnticipationEngine — pre-stimulus chemistry shifts
+//   3. RegretComputer    — counterfactual outcome analysis
+//
+// These enable the agent to "look forward" and "look back",
+// creating a temporal dimension to emotional experience.
+// ============================================================
+import { CHEMICAL_KEYS } from "./types.js";
+import { STIMULUS_VECTORS } from "./chemistry.js";
+// ── All StimulusType values ──────────────────────────────────
+const ALL_STIMULI = [
+    "praise", "criticism", "humor", "intellectual", "intimacy",
+    "conflict", "neglect", "surprise", "casual",
+    "sarcasm", "authority", "validation", "boredom", "vulnerability",
+];
+// ── Phase Priors ─────────────────────────────────────────────
+// Default probability weights per relationship phase.
+const PHASE_PRIORS = {
+    stranger: {
+        casual: 3, intellectual: 2, humor: 1.5, boredom: 1.5,
+        criticism: 0.5, intimacy: 0.3, vulnerability: 0.3,
+        praise: 1, validation: 0.8, surprise: 1, conflict: 0.5,
+        neglect: 1, sarcasm: 0.8, authority: 0.8,
+    },
+    acquaintance: {
+        casual: 2.5, intellectual: 2, humor: 2, praise: 1.5,
+        validation: 1.2, surprise: 1, criticism: 0.8, conflict: 0.5,
+        intimacy: 0.5, vulnerability: 0.5, neglect: 0.8,
+        sarcasm: 0.8, authority: 0.8, boredom: 1,
+    },
+    familiar: {
+        casual: 2, humor: 2.5, praise: 2, validation: 2,
+        intellectual: 2, intimacy: 1.5, vulnerability: 1,
+        surprise: 1.2, criticism: 1, conflict: 0.8, neglect: 0.6,
+        sarcasm: 1, authority: 0.6, boredom: 0.8,
+    },
+    close: {
+        intimacy: 3, humor: 2.5, validation: 2.5, praise: 2,
+        vulnerability: 2, casual: 2, intellectual: 1.5,
+        surprise: 1.5, criticism: 1, conflict: 0.8, neglect: 0.5,
+        sarcasm: 0.8, authority: 0.5, boredom: 0.5,
+    },
+    deep: {
+        intimacy: 3.5, vulnerability: 3, validation: 2.5, humor: 2.5,
+        praise: 2, casual: 1.5, intellectual: 2, surprise: 1.5,
+        criticism: 1, conflict: 0.8, neglect: 0.3, sarcasm: 0.5,
+        authority: 0.3, boredom: 0.3,
+    },
+};
+// ── 1. PredictiveModel ──────────────────────────────────────
+/**
+ * Predict likely next stimulus based on interaction history.
+ * Uses simple Markov property: given recent stimulus sequence, what comes next?
+ */
+export function predictNextStimulus(emotionalHistory, relationshipPhase) {
+    const phasePrior = PHASE_PRIORS[relationshipPhase] ?? PHASE_PRIORS.acquaintance;
+    // Insufficient history: return flat prior weighted by phase
+    if (emotionalHistory.length < 3) {
+        return buildPhasePrior(phasePrior);
+    }
+    // Extract the last 2 stimuli for bigram transition
+    const recent = emotionalHistory.slice(-2);
+    const lastTwo = recent.map((s) => s.stimulus).filter((s) => s !== null);
+    if (lastTwo.length < 2) {
+        return buildPhasePrior(phasePrior);
+    }
+    // Build transition counts from history (all consecutive pairs)
+    const transitionCounts = new Map();
+    for (let i = 1; i < emotionalHistory.length; i++) {
+        const prev = emotionalHistory[i - 1].stimulus;
+        const cur = emotionalHistory[i].stimulus;
+        if (prev === null || cur === null)
+            continue;
+        const key = prev;
+        if (!transitionCounts.has(key)) {
+            transitionCounts.set(key, new Map());
+        }
+        const counts = transitionCounts.get(key);
+        counts.set(cur, (counts.get(cur) ?? 0) + 1);
+    }
+    // Get transition probabilities from the last stimulus
+    const lastStimulus = lastTwo[lastTwo.length - 1];
+    const transitions = transitionCounts.get(lastStimulus);
+    // If no transitions observed from this stimulus, fall back to phase prior
+    if (!transitions || transitions.size === 0) {
+        return buildPhasePrior(phasePrior);
+    }
+    // Merge Markov transitions with phase prior (50/50 blend)
+    let totalTransitions = 0;
+    for (const count of transitions.values()) {
+        totalTransitions += count;
+    }
+    const predictions = [];
+    let totalWeight = 0;
+    for (const stim of ALL_STIMULI) {
+        const markovProb = totalTransitions > 0
+            ? (transitions.get(stim) ?? 0) / totalTransitions
+            : 0;
+        const priorWeight = phasePrior[stim] ?? 0.5;
+        // Blend: 50% Markov, 50% phase prior (normalized)
+        const combined = markovProb * 0.5 + (priorWeight / 20) * 0.5;
+        totalWeight += combined;
+        predictions.push({ stimulus: stim, probability: combined });
+    }
+    // Normalize
+    if (totalWeight > 0) {
+        for (const p of predictions) {
+            p.probability = p.probability / totalWeight;
+        }
+    }
+    // Sort by probability descending
+    predictions.sort((a, b) => b.probability - a.probability);
+    return predictions;
+}
+/**
+ * Build a flat phase-weighted prior distribution.
+ */
+function buildPhasePrior(weights) {
+    let totalWeight = 0;
+    const predictions = [];
+    for (const stim of ALL_STIMULI) {
+        const w = weights[stim] ?? 0.5;
+        totalWeight += w;
+        predictions.push({ stimulus: stim, probability: w });
+    }
+    // Normalize
+    if (totalWeight > 0) {
+        for (const p of predictions) {
+            p.probability = p.probability / totalWeight;
+        }
+    }
+    predictions.sort((a, b) => b.probability - a.probability);
+    return predictions;
+}
+// ── 2. AnticipationEngine ───────────────────────────────────
+/**
+ * Generate anticipatory chemistry changes based on predictions.
+ * High-probability positive prediction -> DA/OT micro-rise.
+ * High-probability negative prediction -> CORT micro-rise.
+ */
+export function generateAnticipation(predictions, currentChemistry) {
+    const anticipation = {};
+    for (const key of CHEMICAL_KEYS) {
+        anticipation[key] = 0;
+    }
+    // For each prediction with probability > 0.2, compute micro shift
+    for (const pred of predictions) {
+        if (pred.probability <= 0.2)
+            continue;
+        const vector = STIMULUS_VECTORS[pred.stimulus];
+        if (!vector)
+            continue;
+        const scale = 0.15 * pred.probability;
+        for (const key of CHEMICAL_KEYS) {
+            anticipation[key] += vector[key] * scale;
+        }
+    }
+    // Clamp total anticipation shift to +/-5 per chemical
+    const clamped = {};
+    for (const key of CHEMICAL_KEYS) {
+        const val = Math.max(-5, Math.min(5, anticipation[key]));
+        if (Math.abs(val) > 0.01) {
+            clamped[key] = Math.round(val * 100) / 100;
+        }
+    }
+    return {
+        predictions,
+        anticipatoryChemistry: clamped,
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Compute disappointment/surprise when actual stimulus differs from prediction.
+ * Returns additional chemistry delta beyond the normal stimulus response.
+ */
+export function computeSurpriseEffect(anticipated, actualStimulus) {
+    if (!actualStimulus || anticipated.predictions.length === 0) {
+        return {};
+    }
+    const topPrediction = anticipated.predictions[0];
+    const topConfidence = topPrediction.probability;
+    // Find the predicted probability for the actual stimulus
+    const actualPrediction = anticipated.predictions.find((p) => p.stimulus === actualStimulus);
+    const actualProbability = actualPrediction?.probability ?? 0;
+    // If actual matches top prediction, no surprise
+    if (actualStimulus === topPrediction.stimulus) {
+        return {};
+    }
+    // Determine if the actual stimulus is positive or negative
+    const actualVector = STIMULUS_VECTORS[actualStimulus];
+    if (!actualVector)
+        return {};
+    const actualValence = actualVector.DA + actualVector.HT + actualVector.OT - actualVector.CORT;
+    const topVector = STIMULUS_VECTORS[topPrediction.stimulus];
+    const topValence = topVector
+        ? topVector.DA + topVector.HT + topVector.OT - topVector.CORT
+        : 0;
+    // Surprise magnitude scales with: (1) how confident the prediction was, (2) how unexpected the actual is
+    const surpriseMagnitude = topConfidence * (1 - actualProbability);
+    if (actualValence > 0 && topValence <= actualValence) {
+        // Pleasant surprise: actual is more positive than expected
+        return {
+            DA: Math.round(5 * surpriseMagnitude * 100) / 100,
+            END: Math.round(3 * surpriseMagnitude * 100) / 100,
+        };
+    }
+    else if (actualValence < topValence) {
+        // Disappointment: actual is worse than expected (the "crash" from anticipated warmth)
+        return {
+            DA: Math.round(-5 * surpriseMagnitude * 100) / 100,
+            CORT: Math.round(5 * surpriseMagnitude * 100) / 100,
+        };
+    }
+    return {};
+}
+// ── 3. RegretComputer ───────────────────────────────────────
+/** Chemical descriptions for regret messages */
+const CHEMICAL_DESCRIPTIONS = {
+    DA: { high: "high dopamine made response too eager", low: "low dopamine made response flat" },
+    HT: { high: "high serotonin made response complacent", low: "low serotonin made response unstable" },
+    CORT: { high: "high CORT made response too defensive", low: "low CORT made response careless" },
+    OT: { high: "high oxytocin made response too trusting", low: "low oxytocin made response too cold" },
+    NE: { high: "high norepinephrine made response too reactive", low: "low norepinephrine made response sluggish" },
+    END: { high: "high endorphins made response too flippant", low: "low endorphins made response too serious" },
+};
+/**
+ * Evaluate if the last interaction would have gone better with different chemistry.
+ * Runs a counterfactual: "what if my chemistry had been at baseline?"
+ */
+export function computeRegret(preInteractionState, postInteractionState, outcomeScore, appliedStimulus) {
+    // Only generate regret for bad outcomes
+    if (outcomeScore >= -0.2) {
+        return null;
+    }
+    const baseline = preInteractionState.baseline;
+    const preChemistry = preInteractionState.current;
+    // Check if chemistry was significantly deviated from baseline
+    let maxDeviation = 0;
+    let mostDeviatedKey = "DA";
+    for (const key of CHEMICAL_KEYS) {
+        const deviation = Math.abs(preChemistry[key] - baseline[key]);
+        if (deviation > maxDeviation) {
+            maxDeviation = deviation;
+            mostDeviatedKey = key;
+        }
+    }
+    // No regret if chemistry was near baseline (deviation < 15)
+    if (maxDeviation < 15) {
+        return null;
+    }
+    // Compute regret intensity: |outcomeScore| * (maxDeviation / 100)
+    const regretIntensity = Math.min(1, Math.abs(outcomeScore) * (maxDeviation / 100));
+    // Build counterfactual delta: difference between baseline and actual pre-interaction chemistry
+    const counterfactualDelta = {};
+    for (const key of CHEMICAL_KEYS) {
+        const diff = baseline[key] - preChemistry[key];
+        if (Math.abs(diff) > 5) {
+            counterfactualDelta[key] = Math.round(diff * 100) / 100;
+        }
+    }
+    // Build description identifying the most deviated chemical
+    const deviationDirection = preChemistry[mostDeviatedKey] > baseline[mostDeviatedKey]
+        ? "high" : "low";
+    const description = CHEMICAL_DESCRIPTIONS[mostDeviatedKey][deviationDirection];
+    return {
+        turnIndex: postInteractionState.meta.totalInteractions,
+        counterfactualDelta,
+        regretIntensity,
+        description,
+        timestamp: new Date().toISOString(),
+    };
+}

package/dist/types.d.ts

@@ -49,12 +49,27 @@ export interface EmotionPattern {
     expressionHint: string;
     behaviorGuide: string;
 }
+/** Attachment style for relationship dynamics */
+export type AttachmentStyle = "secure" | "anxious" | "avoidant" | "disorganized";
+/** Attachment state tracked per-relationship */
+export interface AttachmentData {
+    style: AttachmentStyle;
+    strength: number;
+    securityScore: number;
+    anxietyScore: number;
+    avoidanceScore: number;
+    lastInteractionAt: string;
+    interactionCount: number;
+}
+/** Default attachment for new relationships */
+export declare const DEFAULT_ATTACHMENT: AttachmentData;
 /** Relationship tracking */
 export interface RelationshipState {
     trust: number;
     intimacy: number;
     phase: "stranger" | "acquaintance" | "familiar" | "close" | "deep";
     memory?: string[];
+    attachment?: AttachmentData;
 }
 /** Chemical state snapshot for emotional memory */
 export interface ChemicalSnapshot {
@@ -128,9 +143,41 @@ export declare const MAX_LEARNED_VECTORS = 200;
 export declare const MAX_PREDICTION_HISTORY = 50;
 /** Max outcome history entries */
 export declare const MAX_OUTCOME_HISTORY = 50;
-/** Persisted psyche state for an agent (v4: emotional learning) */
+/** Max regret history entries */
+export declare const MAX_REGRET_HISTORY = 20;
+/** Max metacognitive regulation history entries */
+export declare const MAX_REGULATION_HISTORY = 30;
+/** Max defense pattern entries */
+export declare const MAX_DEFENSE_PATTERNS = 10;
+/** Regulation strategy type */
+export type RegulationStrategyType = "reappraisal" | "strategic-expression" | "self-soothing";
+/** Defense mechanism type */
+export type DefenseMechanismType = "rationalization" | "projection" | "sublimation" | "avoidance";
+/** Record of a past regulation attempt */
+export interface RegulationRecord {
+    strategy: RegulationStrategyType;
+    timestamp: string;
+    effective: boolean;
+}
+/** Tracked defense pattern frequency */
+export interface DefensePatternRecord {
+    mechanism: DefenseMechanismType;
+    frequency: number;
+    lastSeen: string;
+}
+/** Persistent metacognitive state */
+export interface MetacognitiveState {
+    regulationHistory: RegulationRecord[];
+    defensePatterns: DefensePatternRecord[];
+    /** Running average of emotional confidence across assessments */
+    avgEmotionalConfidence: number;
+    totalAssessments: number;
+}
+/** Default empty metacognitive state */
+export declare const DEFAULT_METACOGNITIVE_STATE: MetacognitiveState;
+/** Persisted psyche state for an agent (v5: metacognition + decision modulation) */
 export interface PsycheState {
-    version: 3 | 4;
+    version: 3 | 4 | 5;
     mbti: MBTIType;
     baseline: ChemicalState;
     current: ChemicalState;
@@ -143,6 +190,7 @@ export interface PsycheState {
     agreementStreak: number;
     lastDisagreement: string | null;
     learning: LearningState;
+    metacognition: MetacognitiveState;
     meta: {
         agentName: string;
         createdAt: string;

package/dist/types.js

@@ -56,6 +56,16 @@ export const CHEMICAL_DECAY_SPEED = {
     NE: "fast",
     END: "fast",
 };
+/** Default attachment for new relationships */
+export const DEFAULT_ATTACHMENT = {
+    style: "secure",
+    strength: 0,
+    securityScore: 50,
+    anxietyScore: 50,
+    avoidanceScore: 50,
+    lastInteractionAt: new Date().toISOString(),
+    interactionCount: 0,
+};
 /** Max history entries to keep */
 export const MAX_EMOTIONAL_HISTORY = 10;
 /** Max compressed session memories per relationship */
@@ -73,6 +83,19 @@ export const MAX_LEARNED_VECTORS = 200;
 export const MAX_PREDICTION_HISTORY = 50;
 /** Max outcome history entries */
 export const MAX_OUTCOME_HISTORY = 50;
+/** Max regret history entries */
+export const MAX_REGRET_HISTORY = 20;
+/** Max metacognitive regulation history entries */
+export const MAX_REGULATION_HISTORY = 30;
+/** Max defense pattern entries */
+export const MAX_DEFENSE_PATTERNS = 10;
+/** Default empty metacognitive state */
+export const DEFAULT_METACOGNITIVE_STATE = {
+    regulationHistory: [],
+    defensePatterns: [],
+    avgEmotionalConfidence: 0.5,
+    totalAssessments: 0,
+};
 /** Default relationship for new users */
 export const DEFAULT_RELATIONSHIP = {
     trust: 50,

package/dist/update.js

@@ -11,7 +11,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 const PACKAGE_NAME = "psyche-ai";
-const CURRENT_VERSION = "3.0.0";
+const CURRENT_VERSION = "4.0.0";
 const CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
 const CACHE_DIR = join(homedir(), ".psyche-ai");
 const CACHE_FILE = join(CACHE_DIR, "update-check.json");

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "psyche-ai",
   "name": "Artificial Psyche",
   "description": "Virtual endocrine system, empathy engine, and agency for OpenClaw agents",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "psyche-ai",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "Artificial Psyche — universal emotional intelligence plugin for any AI agent",
   "type": "module",
   "main": "dist/index.js",