psyche-ai 11.6.0 → 11.7.0

package/dist/adapters/mcp.js

@@ -95,6 +95,10 @@ function parseCLIArgs() {
     }
     return overrides;
 }
+// ── Turn cache for on-demand resource access ──────────────
+// Single-client assumption: MCP stdio transport serves one host at a time.
+// If this ever becomes multi-client, turn cache must be keyed per session.
+let lastTurnResult = null;
 // ── Engine singleton ───────────────────────────────────────
 let engine = null;
 async function getEngine() {
@@ -200,13 +204,40 @@ server.resource("state", "psyche://state", {
             }],
     };
 });
+// Helper: register a turn-scoped resource backed by lastTurnResult.
+// Returns empty JSON when no turn has been processed yet (fail-open).
+function turnResource(name, uri, description, pick) {
+    server.resource(name, uri, { description, mimeType: "application/json" }, async (u) => ({
+        contents: [{
+                uri: u.href,
+                mimeType: "application/json",
+                text: lastTurnResult ? JSON.stringify(pick(lastTurnResult)) : "{}",
+            }],
+    }));
+}
+turnResource("turn-envelope", "psyche://turn/envelope", "Full ReplyEnvelope from the last process_input call — " +
+    "SubjectivityKernel, ResponseContract, GenerationControls, " +
+    "appraisal axes, policyModifiers, and writebackFeedback. " +
+    "Use this when you need the structured ABI data (non-LLM substrates, debugging, analytics).", (r) => ({
+    replyEnvelope: r.replyEnvelope,
+    appraisal: r.appraisal,
+    policyModifiers: r.policyModifiers,
+    writebackFeedback: r.writebackFeedback,
+    externalContinuity: r.externalContinuity,
+}));
+turnResource("turn-observability", "psyche://turn/observability", "Diagnostic metadata from the last process_input call — " +
+    "control boundary, state layers, decision rationale, causal chain. " +
+    "Use for debugging and auditing only.", (r) => ({
+    observability: r.observability,
+    stimulus: r.stimulus,
+    stimulusConfidence: r.stimulusConfidence,
+    policyContext: r.policyContext,
+}));
 // ── Tools ──────────────────────────────────────────────────
-server.tool("process_input", "Process user input through the emotional engine. Returns emotional " +
-    "context to inject into the LLM system prompt (systemContext + dynamicContext), " +
-    "an appraisal-first semantic reading, optional runtime ambient priors, an optional legacy stimulus hint, a canonical replyEnvelope, compatibility aliases " +
-    "(policyModifiers + subjectivityKernel + responseContract + generationControls), an optional " +
-    "externalContinuity envelope, and sparse low-frequency throngletsExports " +
-    "suitable for additive external continuity layers. " +
+server.tool("process_input", "Process user input through the emotional engine. Returns a directive " +
+    "(text to inject into system prompt), stimulus classification, generation controls, " +
+    "and optional sparse continuity signals. " +
+    "Full structured state (ReplyEnvelope, appraisal) available via psyche://turn/envelope resource. " +
     "Call this BEFORE generating a response to the user.", {
     text: z.string().describe("The user's message text"),
     userId: z.string().optional().describe("Optional user ID for multi-user relationship tracking"),
@@ -238,30 +269,27 @@ server.tool("process_input", "Process user input through the emotional engine. R
         activePolicy: resolvedActivePolicy,
         currentTurnCorrection,
     }, "mcp.processInput");
+    // Cache full result for turn-scoped resources
+    lastTurnResult = result;
+    // Build slim response: only what the LLM host actually needs.
+    // Full structured state available via psyche://turn/envelope resource.
+    const slim = {
+        directive: result.dynamicContext,
+        stimulus: result.stimulus,
+        maxTokens: result.generationControls?.maxTokens,
+        requireConfirmation: result.generationControls?.requireConfirmation ?? false,
+    };
+    // Sparse signals — only when non-empty to keep payload minimal
+    if (result.throngletsExports?.length) {
+        slim.throngletsExports = result.throngletsExports;
+    }
+    if (result.sessionBridge) {
+        slim.sessionBridge = result.sessionBridge;
+    }
     return {
         content: [{
                 type: "text",
-                text: JSON.stringify({
-                    systemContext: result.systemContext,
-                    dynamicContext: result.dynamicContext,
-                    ambientPriors: result.ambientPriors ?? [],
-                    activePolicy: result.activePolicy ?? [],
-                    currentGoal: result.currentGoal ?? null,
-                    ambientPriorContext: result.ambientPriorContext ?? null,
-                    appraisal: result.appraisal,
-                    legacyStimulus: result.legacyStimulus,
-                    stimulus: result.stimulus,
-                    replyEnvelope: result.replyEnvelope ?? null,
-                    policyModifiers: result.policyModifiers ?? null,
-                    subjectivityKernel: result.subjectivityKernel ?? null,
-                    responseContract: result.responseContract ?? null,
-                    generationControls: result.generationControls ?? null,
-                    sessionBridge: result.sessionBridge ?? null,
-                    writebackFeedback: result.writebackFeedback ?? null,
-                    externalContinuity: result.externalContinuity ?? null,
-                    throngletsExports: result.throngletsExports ?? null,
-                    policyContext: result.policyContext,
-                }, null, 2),
+                text: JSON.stringify(slim),
             }],
     };
 });
@@ -281,8 +309,8 @@ server.tool("process_output", "Process the LLM's response through the emotional
                 text: JSON.stringify({
                     cleanedText: result.cleanedText,
                     stateChanged: result.stateChanged,
-                    validationIssues: result.validationIssues ?? [],
-                }, null, 2),
+                    ...(result.validationIssues?.length ? { validationIssues: result.validationIssues } : {}),
+                }),
             }],
     };
 });

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.0",
+  "version": "11.7.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "psyche-ai",
-  "version": "11.6.0",
+  "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",