psyche-ai 11.6.1 → 11.7.0

package/dist/core.d.ts

@@ -142,6 +142,10 @@ export declare class PsycheEngine {
     private readonly feedbackUrl;
     /** Most recent legacy compatibility hint + confidence band */
     private lastCompatibilityAssessment;
+    /** Proprioception cooldown — turns remaining before next trajectory check */
+    private proprioceptionCooldown;
+    /** Last detected trajectory signal (in-memory only, for status summary) */
+    private lastTrajectory;
     constructor(config: PsycheEngineConfig | undefined, storage: StorageAdapter);
     /**
      * Load or create initial state. Must be called before processInput/processOutput.

package/dist/core.js

@@ -35,6 +35,7 @@ import { buildTurnObservability } from "./observability.js";
 import { DEFAULT_RELATIONSHIP_USER_ID, resolveRelationshipUserId } from "./relationship-key.js";
 import { normalizeAmbientPriors } from "./ambient-priors.js";
 import { normalizeWritebackSignals } from "./writeback-signals.js";
+import { detectTrajectory } from "./proprioception.js";
 function formatWritebackFeedbackNote(feedback, locale) {
     const top = feedback?.[0];
     if (!top)
@@ -143,6 +144,10 @@ export class PsycheEngine {
     feedbackUrl;
     /** Most recent legacy compatibility hint + confidence band */
     lastCompatibilityAssessment = null;
+    /** Proprioception cooldown — turns remaining before next trajectory check */
+    proprioceptionCooldown = 0;
+    /** Last detected trajectory signal (in-memory only, for status summary) */
+    lastTrajectory = null;
     constructor(config = {}, storage) {
         this.traits = config.traits;
         this.classifier = config.classifier ?? new BuiltInClassifier();
@@ -377,6 +382,44 @@ export class PsycheEngine {
             if (appliedStimulus) {
                 state = applyRelationshipDrift(state, appliedStimulus, opts?.userId);
             }
+            // ── Proprioception: self-trajectory awareness ──────────
+            if (this.proprioceptionCooldown > 0) {
+                this.proprioceptionCooldown--;
+            }
+            else {
+                const trajectory = detectTrajectory(state.stateHistory ?? [], state.baseline);
+                this.lastTrajectory = trajectory;
+                if (trajectory.kind === "decline" || trajectory.kind === "spiral") {
+                    // Gentle awareness nudge — not correction, just noticing
+                    if (trajectory.stabilize) {
+                        state = {
+                            ...state,
+                            current: {
+                                ...state.current,
+                                order: clamp(state.current.order + (trajectory.stabilize.order ?? 0)),
+                                flow: clamp(state.current.flow + (trajectory.stabilize.flow ?? 0)),
+                                boundary: clamp(state.current.boundary + (trajectory.stabilize.boundary ?? 0)),
+                                resonance: clamp(state.current.resonance + (trajectory.stabilize.resonance ?? 0)),
+                            },
+                        };
+                    }
+                    this.proprioceptionCooldown = 3;
+                }
+                else if (trajectory.kind === "growth" && trajectory.baselineShift) {
+                    // Growth detected — shift baseline upward
+                    const shift = trajectory.baselineShift;
+                    state = {
+                        ...state,
+                        baseline: {
+                            order: clamp(state.baseline.order + (shift.order ?? 0)),
+                            flow: clamp(state.baseline.flow + (shift.flow ?? 0)),
+                            boundary: clamp(state.baseline.boundary + (shift.boundary ?? 0)),
+                            resonance: clamp(state.baseline.resonance + (shift.resonance ?? 0)),
+                        },
+                    };
+                    this.proprioceptionCooldown = 3;
+                }
+            }
             this.lastCompatibilityAssessment = {
                 legacyStimulus: appliedStimulus,
                 confidence: perception.confidence,
@@ -953,7 +996,12 @@ export class PsycheEngine {
         const driveWarning = hungryDrives.length > 0
             ? ` | \u26A0\uFE0F${hungryDrives.join(",")}`
             : "";
+        // Proprioception: surface trajectory awareness
+        const trajectory = this.lastTrajectory ?? detectTrajectory(state.stateHistory ?? [], state.baseline);
+        const trajectoryNote = trajectory.description
+            ? ` | \u{1F9ED}${trajectory.description}`
+            : "";
         const sigilTag = state.meta.sigilId ? ` | sigil:${state.meta.sigilId}` : "";
-        return `${emoji} ${emotion} | flow:${Math.round(flow)} order:${Math.round(order)}${driveWarning}${sigilTag}`;
+        return `${emoji} ${emotion} | flow:${Math.round(flow)} order:${Math.round(order)}${driveWarning}${trajectoryNote}${sigilTag}`;
     }
 }

package/dist/proprioception.d.ts

@@ -0,0 +1,20 @@
+import type { SelfState, StateSnapshot } from "./types.js";
+export interface TrajectorySignal {
+    /** null = no signal, system is fine */
+    kind: "decline" | "growth" | "spiral" | null;
+    /** Which dimensions triggered the signal */
+    dimensions: (keyof SelfState)[];
+    /** Signal strength, 0–1 */
+    magnitude: number;
+    /** Gentle state nudge for decline/spiral (additive) */
+    stabilize: Partial<Record<keyof SelfState, number>> | null;
+    /** Baseline shift for growth (additive) */
+    baselineShift: Partial<Record<keyof SelfState, number>> | null;
+    /** One-line description for status summary */
+    description: string | null;
+}
+/**
+ * Detect trajectory patterns from recent state history.
+ * Pure function — no side effects, no persistence.
+ */
+export declare function detectTrajectory(history: StateSnapshot[], baseline: SelfState): TrajectorySignal;

package/dist/proprioception.js

@@ -0,0 +1,104 @@
+// ============================================================
+// Proprioception — Self-Trajectory Awareness
+//
+// Perception turned inward. The system perceives its own state
+// trajectory as input, the same way it perceives external stimuli.
+//
+// Two signals:
+//   decline/spiral → gentle awareness (order↑1, boundary↑1)
+//   growth         → baseline upshift (10% of sustained gain)
+//
+// Not a monitor. Not a correction. Just: the system can see itself.
+// ============================================================
+import { DIMENSION_KEYS } from "./types.js";
+// ── Constants ───────────────────────────────────────────────
+/** Minimum snapshots needed to detect a trajectory */
+const MIN_WINDOW = 4;
+/** Per-step change threshold to count as meaningful decline */
+const DECLINE_STEP = -1;
+/** Per-step change threshold to count as meaningful growth */
+const GROWTH_STEP = 1;
+/** Maximum stabilization nudge per dimension (awareness, not correction) */
+const STABILIZE_MAX = 1.5;
+/** Fraction of sustained gain that becomes new baseline */
+const GROWTH_BASELINE_RATIO = 0.1;
+const NO_SIGNAL = {
+    kind: null, dimensions: [], magnitude: 0,
+    stabilize: null, baselineShift: null, description: null,
+};
+// ── Core ────────────────────────────────────────────────────
+/**
+ * Detect trajectory patterns from recent state history.
+ * Pure function — no side effects, no persistence.
+ */
+export function detectTrajectory(history, baseline) {
+    if (history.length < MIN_WINDOW)
+        return NO_SIGNAL;
+    const window = history.slice(-MIN_WINDOW);
+    const declining = [];
+    const growing = [];
+    for (const dim of DIMENSION_KEYS) {
+        const values = window.map(s => s.state[dim]);
+        const deltas = [];
+        for (let i = 1; i < values.length; i++) {
+            deltas.push(values[i] - values[i - 1]);
+        }
+        if (deltas.every(d => d < DECLINE_STEP)) {
+            declining.push(dim);
+        }
+        if (deltas.every(d => d > GROWTH_STEP) && values[values.length - 1] > baseline[dim]) {
+            growing.push(dim);
+        }
+    }
+    // ── Spiral: 2+ dimensions declining together ──
+    if (declining.length >= 2) {
+        const totalDrop = declining.reduce((sum, dim) => {
+            const vals = window.map(s => s.state[dim]);
+            return sum + Math.abs(vals[vals.length - 1] - vals[0]);
+        }, 0);
+        const stabilize = {};
+        for (const dim of declining) {
+            stabilize[dim] = STABILIZE_MAX;
+        }
+        return {
+            kind: "spiral",
+            dimensions: declining,
+            magnitude: Math.min(1, totalDrop / 40),
+            stabilize,
+            baselineShift: null,
+            description: `spiral: ${declining.join("+")} declining ${window.length} turns`,
+        };
+    }
+    // ── Single dimension decline ──
+    if (declining.length === 1) {
+        const dim = declining[0];
+        const vals = window.map(s => s.state[dim]);
+        const drop = Math.abs(vals[vals.length - 1] - vals[0]);
+        return {
+            kind: "decline",
+            dimensions: declining,
+            magnitude: Math.min(1, drop / 20),
+            stabilize: { [dim]: STABILIZE_MAX * 0.5 },
+            baselineShift: null,
+            description: `${String(dim)} declining ${window.length} turns (-${drop.toFixed(1)})`,
+        };
+    }
+    // ── Growth: sustained increase above baseline ──
+    if (growing.length > 0) {
+        const baselineShift = {};
+        for (const dim of growing) {
+            const vals = window.map(s => s.state[dim]);
+            const gain = vals[vals.length - 1] - vals[0];
+            baselineShift[dim] = gain * GROWTH_BASELINE_RATIO;
+        }
+        return {
+            kind: "growth",
+            dimensions: growing,
+            magnitude: Math.min(1, growing.length / 4),
+            stabilize: null,
+            baselineShift,
+            description: `growth: ${growing.join("+")} sustained increase`,
+        };
+    }
+    return NO_SIGNAL;
+}

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "psyche-ai",
   "name": "Artificial Psyche",
   "description": "AI-first subjectivity kernel for agents with continuous appraisal, relation dynamics, and adaptive reply loops",
-  "version": "11.6.1",
+  "version": "11.7.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "psyche-ai",
-  "version": "11.6.1",
+  "version": "11.7.0",
   "description": "AI-first subjectivity kernel for agents with continuous appraisal, relation dynamics, and adaptive reply loops",
   "mcpName": "io.github.Shangri-la-0428/psyche-ai",
   "type": "module",