psyche-ai 11.5.5 → 11.5.6

package/dist/adapters/claude-sdk.js

@@ -33,6 +33,7 @@ import { describeEmotionalState } from "../chemistry.js";
 import { serializeThrongletsExportAsTrace } from "../thronglets-runtime.js";
 import { resolveRelationshipUserId } from "../relationship-key.js";
 import { resolveAmbientPriorsForTurn, } from "../ambient-runtime.js";
+import { safeProcessInput, safeProcessOutput } from "./fail-open.js";
 // ── Dimension description ────────────────────────────────────
 const DIM_THRESHOLDS = {
     high: 70,
@@ -179,19 +180,20 @@ export class PsycheClaudeSDK {
                             const currentGoal = normalizeCurrentGoal(input.current_goal ?? input.currentGoal);
                             const activePolicy = resolveRuntimeActivePolicy(input.active_policy ?? input.activePolicy, currentTurnCorrection);
                             const ambientPriors = await self.resolveAmbientPriors(userMessage, currentGoal, activePolicy, currentTurnCorrection);
-                            const result = await self.engine.processInput(userMessage, {
+                            const result = await safeProcessInput(self.engine, userMessage, {
                                 userId: self.opts.userId,
                                 ambientPriors,
                                 currentGoal,
                                 activePolicy,
                                 currentTurnCorrection,
-                            });
+                            }, "claude-sdk.processInput");
                             self.lastInputResult = result;
                             // Cache Thronglets exports from this turn
                             if (self.opts.thronglets && result.throngletsExports) {
                                 self.lastThrongletsExports = result.throngletsExports;
                             }
-                            return { systemMessage: result.dynamicContext };
+                            const systemMessage = result.dynamicContext;
+                            return systemMessage ? { systemMessage } : {};
                         },
                     ],
                 },
@@ -208,11 +210,11 @@ export class PsycheClaudeSDK {
      * @returns Cleaned text with tags removed
      */
     async processResponse(text, opts) {
-        const result = await this.engine.processOutput(text, {
+        const result = await safeProcessOutput(this.engine, text, {
             userId: this.opts.userId,
             signals: opts?.signals,
             signalConfidence: opts?.signalConfidence,
-        });
+        }, "claude-sdk.processOutput");
         return result.cleanedText;
     }
     // ── Thronglets integration ────────────────────────────────

package/dist/adapters/fail-open.d.ts

@@ -0,0 +1,9 @@
+import type { ProcessInputOptions, ProcessInputResult, ProcessOutputOptions, ProcessOutputResult, PsycheEngine } from "../core.js";
+export declare function stripPsycheUpdateTags(text: string): string;
+export interface FailOpenOutputFallbackOptions {
+    stripUpdateTags?: boolean;
+}
+export declare function composePsycheContext(result: Pick<ProcessInputResult, "systemContext" | "dynamicContext">): string;
+export declare function buildFailOpenProcessInputResult(opts: ProcessInputOptions | undefined): ProcessInputResult;
+export declare function safeProcessInput(engine: PsycheEngine, text: string, opts?: ProcessInputOptions, phase?: string): Promise<ProcessInputResult>;
+export declare function safeProcessOutput(engine: PsycheEngine, text: string, opts?: ProcessOutputOptions, phase?: string, fallback?: FailOpenOutputFallbackOptions): Promise<ProcessOutputResult>;

package/dist/adapters/fail-open.js

@@ -0,0 +1,58 @@
+const PSYCHE_TAG_RE = /<psyche_update>[\s\S]*?<\/psyche_update>/g;
+export function stripPsycheUpdateTags(text) {
+    return text
+        .replace(PSYCHE_TAG_RE, "")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+export function composePsycheContext(result) {
+    return [result.systemContext, result.dynamicContext].filter(Boolean).join("\n\n");
+}
+export function buildFailOpenProcessInputResult(opts) {
+    return {
+        systemContext: "",
+        dynamicContext: "",
+        ambientPriors: opts?.ambientPriors ?? [],
+        activePolicy: opts?.activePolicy ?? [],
+        currentGoal: opts?.currentGoal,
+        ambientPriorContext: undefined,
+        appraisal: null,
+        legacyStimulus: null,
+        stimulus: null,
+        legacyStimulusConfidence: undefined,
+        stimulusConfidence: undefined,
+        policyModifiers: undefined,
+        replyEnvelope: undefined,
+        subjectivityKernel: undefined,
+        responseContract: undefined,
+        generationControls: undefined,
+        sessionBridge: null,
+        writebackFeedback: [],
+        externalContinuity: undefined,
+        throngletsExports: [],
+        observability: undefined,
+        policyContext: "",
+    };
+}
+export async function safeProcessInput(engine, text, opts, phase = "processInput") {
+    try {
+        return await engine.processInput(text, opts);
+    }
+    catch (error) {
+        engine.recordDiagnosticError(phase, error);
+        return buildFailOpenProcessInputResult(opts);
+    }
+}
+export async function safeProcessOutput(engine, text, opts, phase = "processOutput", fallback) {
+    try {
+        return await engine.processOutput(text, opts);
+    }
+    catch (error) {
+        engine.recordDiagnosticError(phase, error);
+        const shouldStripTags = fallback?.stripUpdateTags !== false && text.includes("<psyche_update>");
+        return {
+            cleanedText: shouldStripTags ? stripPsycheUpdateTags(text) : text,
+            stateChanged: false,
+        };
+    }
+}

package/dist/adapters/http.js

@@ -16,27 +16,11 @@
 // Zero dependencies — uses node:http only.
 // ============================================================
 import { createServer } from "node:http";
+import { safeProcessInput, safeProcessOutput } from "./fail-open.js";
 import { normalizeCurrentGoal, normalizeCurrentTurnCorrection, resolveRuntimeActivePolicy, } from "../types.js";
 import { parseAmbientPriorsInput } from "../ambient-runtime.js";
 import { computeOverlay } from "../overlay.js";
-const VALID_WRITEBACK_SIGNALS = new Set([
-    "trust_up",
-    "trust_down",
-    "boundary_set",
-    "boundary_soften",
-    "repair_attempt",
-    "repair_landed",
-    "closeness_invite",
-    "withdrawal_mark",
-    "self_assertion",
-    "task_recenter",
-]);
-function parseSignals(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    const parsed = value.filter((item) => (typeof item === "string" && VALID_WRITEBACK_SIGNALS.has(item)));
-    return parsed.length > 0 ? [...new Set(parsed)] : undefined;
-}
+import { coerceWritebackSignalInput } from "../writeback-signals.js";
 function parseAmbientPriors(value) {
     return parseAmbientPriorsInput(value);
 }
@@ -103,13 +87,13 @@ export function createPsycheServer(engine, opts) {
             if (req.method === "POST" && url.pathname === "/process-input") {
                 const body = await readBody(req);
                 const currentTurnCorrection = parseCurrentTurnCorrection(body);
-                const result = await engine.processInput(body.text ?? "", {
+                const result = await safeProcessInput(engine, body.text ?? "", {
                     userId: body.userId,
                     ambientPriors: parseAmbientPriors(body.ambientPriors),
                     currentGoal: normalizeCurrentGoal(body.currentGoal),
                     activePolicy: resolveRuntimeActivePolicy(body.activePolicy, currentTurnCorrection),
                     currentTurnCorrection,
-                });
+                }, "http.processInput");
                 json(res, 200, {
                     systemContext: result.systemContext,
                     dynamicContext: result.dynamicContext,
@@ -137,11 +121,11 @@ export function createPsycheServer(engine, opts) {
             // POST /process-output
             if (req.method === "POST" && url.pathname === "/process-output") {
                 const body = await readBody(req);
-                const result = await engine.processOutput(body.text ?? "", {
+                const result = await safeProcessOutput(engine, body.text ?? "", {
                     userId: body.userId,
-                    signals: parseSignals(body.signals),
+                    signals: coerceWritebackSignalInput(body.signals),
                     signalConfidence: typeof body.signalConfidence === "number" ? body.signalConfidence : undefined,
-                });
+                }, "http.processOutput");
                 json(res, 200, result);
                 return;
             }

package/dist/adapters/langchain.d.ts

@@ -34,8 +34,6 @@ export declare class PsycheLangChain {
     private readonly engine;
     private readonly opts;
     constructor(engine: PsycheEngine, opts?: PsycheLangChainOptions);
-    private readonly validSignals;
-    private parseSignals;
     private resolveAmbientPriors;
     /**
      * Get the system message to inject into the LLM call.

package/dist/adapters/langchain.js

@@ -14,6 +14,8 @@
 // ============================================================
 import { normalizeCurrentGoal, normalizeCurrentTurnCorrection, resolveRuntimeActivePolicy, } from "../types.js";
 import { resolveAmbientPriorsForTurn, } from "../ambient-runtime.js";
+import { composePsycheContext, safeProcessInput, safeProcessOutput } from "./fail-open.js";
+import { coerceWritebackSignalInput } from "../writeback-signals.js";
 /**
  * LangChain integration helper for PsycheEngine.
  *
@@ -47,24 +49,6 @@ export class PsycheLangChain {
         this.engine = engine;
         this.opts = opts;
     }
-    validSignals = new Set([
-        "trust_up",
-        "trust_down",
-        "boundary_set",
-        "boundary_soften",
-        "repair_attempt",
-        "repair_landed",
-        "closeness_invite",
-        "withdrawal_mark",
-        "self_assertion",
-        "task_recenter",
-    ]);
-    parseSignals(signals) {
-        if (!signals)
-            return undefined;
-        const parsed = signals.filter((signal) => this.validSignals.has(signal));
-        return parsed.length > 0 ? [...new Set(parsed)] : undefined;
-    }
     async resolveAmbientPriors(userText, currentGoal, activePolicy, currentTurnCorrection) {
         const ambient = this.opts.ambient;
         return resolveAmbientPriorsForTurn(userText, {
@@ -90,14 +74,14 @@ export class PsycheLangChain {
         const currentTurnCorrection = normalizeCurrentTurnCorrection(opts?.currentTurnCorrection);
         const currentGoal = normalizeCurrentGoal(opts?.currentGoal);
         const activePolicy = resolveRuntimeActivePolicy(opts?.activePolicy, currentTurnCorrection);
-        const result = await this.engine.processInput(userText, {
+        const result = await safeProcessInput(this.engine, userText, {
             ...opts,
             currentGoal,
             activePolicy,
             currentTurnCorrection,
             ambientPriors: await this.resolveAmbientPriors(userText, currentGoal, activePolicy, currentTurnCorrection),
-        });
-        return result.systemContext + "\n\n" + result.dynamicContext;
+        }, "langchain.processInput");
+        return composePsycheContext(result);
     }
     /**
      * Prepare both prompt text and mechanical invocation hints for a LangChain call.
@@ -109,13 +93,13 @@ export class PsycheLangChain {
         const currentTurnCorrection = normalizeCurrentTurnCorrection(opts?.currentTurnCorrection);
         const currentGoal = normalizeCurrentGoal(opts?.currentGoal);
         const activePolicy = resolveRuntimeActivePolicy(opts?.activePolicy, currentTurnCorrection);
-        const result = await this.engine.processInput(userText, {
+        const result = await safeProcessInput(this.engine, userText, {
             ...opts,
             currentGoal,
             activePolicy,
             currentTurnCorrection,
             ambientPriors: await this.resolveAmbientPriors(userText, currentGoal, activePolicy, currentTurnCorrection),
-        });
+        }, "langchain.processInput");
         const generationControls = result.replyEnvelope?.generationControls ?? result.generationControls;
         const controls = {
             ...(generationControls ?? {}),
@@ -124,7 +108,7 @@ export class PsycheLangChain {
                 : generationControls?.maxTokens ?? opts?.maxTokens,
         };
         return {
-            systemMessage: result.systemContext + "\n\n" + result.dynamicContext,
+            systemMessage: composePsycheContext(result),
             maxTokens: controls.maxTokens,
             requireConfirmation: controls.requireConfirmation ?? false,
         };
@@ -136,11 +120,11 @@ export class PsycheLangChain {
      * Call this AFTER the LLM invocation, before showing output to the user.
      */
     async processResponse(text, opts) {
-        const result = await this.engine.processOutput(text, {
+        const result = await safeProcessOutput(this.engine, text, {
             userId: opts?.userId,
-            signals: this.parseSignals(opts?.signals),
+            signals: coerceWritebackSignalInput(opts?.signals),
             signalConfidence: opts?.signalConfidence,
-        });
+        }, "langchain.processOutput");
         return result.cleanedText;
     }
 }

package/dist/adapters/mcp.js

@@ -35,6 +35,7 @@ import { MemoryStorageAdapter, FileStorageAdapter, resolveWorkspaceDir } from ".
 import { CURRENT_GOALS, normalizeCurrentTurnCorrection, resolveRuntimeActivePolicy, } from "../types.js";
 import { getPackageVersion } from "../update.js";
 import { runDemo } from "../demo.js";
+import { safeProcessInput, safeProcessOutput } from "./fail-open.js";
 const PACKAGE_VERSION = await getPackageVersion();
 // ── Config from env ────────────────────────────────────────
 const MBTI = (process.env.PSYCHE_MBTI ?? "ENFP");
@@ -230,13 +231,13 @@ server.tool("process_input", "Process user input through the emotional engine. R
     const eng = await getEngine();
     const resolvedActivePolicy = resolveRuntimeActivePolicy(activePolicy, currentTurnCorrection);
     const resolvedAmbientPriors = await resolveRuntimeAmbientPriors(text, ambientPriors, currentGoal, resolvedActivePolicy, currentTurnCorrection);
-    const result = await eng.processInput(text, {
+    const result = await safeProcessInput(eng, text, {
         userId,
         ambientPriors: resolvedAmbientPriors,
         currentGoal,
         activePolicy: resolvedActivePolicy,
         currentTurnCorrection,
-    });
+    }, "mcp.processInput");
     return {
         content: [{
                 type: "text",
@@ -273,13 +274,14 @@ server.tool("process_output", "Process the LLM's response through the emotional
     signalConfidence: z.number().min(0).max(1).optional().describe("Optional confidence for the supplied signals"),
 }, async ({ text, userId, signals, signalConfidence }) => {
     const eng = await getEngine();
-    const result = await eng.processOutput(text, { userId, signals: signals, signalConfidence });
+    const result = await safeProcessOutput(eng, text, { userId, signals: signals, signalConfidence }, "mcp.processOutput");
     return {
         content: [{
                 type: "text",
                 text: JSON.stringify({
                     cleanedText: result.cleanedText,
                     stateChanged: result.stateChanged,
+                    validationIssues: result.validationIssues ?? [],
                 }, null, 2),
             }],
     };

package/dist/adapters/vercel-ai.d.ts

@@ -54,7 +54,7 @@ export declare function psycheMiddleware(engine: PsycheEngine, _opts?: PsycheMid
         type: string;
         params: CallParams;
     }) => Promise<{
-        system: string;
+        system: string | undefined;
         maxTokens?: number | undefined;
         prompt?: PromptMessage[];
     }>;

package/dist/adapters/vercel-ai.js

@@ -15,6 +15,7 @@
 //   - wrapGenerate: process output, strip <psyche_update> tags
 //   - wrapStream: buffer stream, detect & strip tags at end
 // ============================================================
+import { composePsycheContext, safeProcessInput, safeProcessOutput } from "./fail-open.js";
 /**
  * Create Vercel AI SDK middleware that injects psyche emotional context
  * and processes LLM output for state updates.
@@ -48,7 +49,7 @@ export function psycheMiddleware(engine, _opts) {
     return {
         transformParams: async ({ params }) => {
             const userText = extractLastUserText(params.prompt ?? []);
-            const result = await engine.processInput(userText);
+            const result = await safeProcessInput(engine, userText, undefined, "vercel-ai.processInput");
             const envelope = result.replyEnvelope;
             const generationControls = envelope?.generationControls ?? result.generationControls;
             const controls = {
@@ -57,19 +58,19 @@ export function psycheMiddleware(engine, _opts) {
                     ? Math.min(params.maxTokens, generationControls.maxTokens)
                     : generationControls?.maxTokens ?? (typeof params.maxTokens === "number" ? params.maxTokens : undefined),
             };
-            const psycheContext = result.systemContext + "\n\n" + result.dynamicContext;
+            const psycheContext = composePsycheContext(result);
             return {
                 ...params,
                 ...(controls.maxTokens !== undefined ? { maxTokens: controls.maxTokens } : {}),
-                system: params.system
-                    ? psycheContext + "\n\n" + params.system
-                    : psycheContext,
+                system: psycheContext
+                    ? (params.system ? psycheContext + "\n\n" + params.system : psycheContext)
+                    : params.system,
             };
         },
         wrapGenerate: async ({ doGenerate }) => {
             const result = await doGenerate();
             if (typeof result.text === "string") {
-                const processed = await engine.processOutput(result.text);
+                const processed = await safeProcessOutput(engine, result.text, undefined, "vercel-ai.processOutput");
                 return { ...result, text: processed.cleanedText };
             }
             return result;
@@ -134,7 +135,7 @@ export function psycheMiddleware(engine, _opts) {
                     else if (chunk.type === "finish") {
                         // Process full text through engine before finishing
                         if (fullText) {
-                            await engine.processOutput(fullText);
+                            await safeProcessOutput(engine, fullText, undefined, "vercel-ai.processOutput");
                         }
                         yield chunk;
                     }

package/dist/core.d.ts

@@ -1,4 +1,4 @@
-import type { ActivePolicyRule, AmbientPriorView, CurrentGoal, PsycheState, StimulusType, Locale, MBTIType, OutcomeScore, PsycheMode, PersonalityTraits, PolicyModifiers, ClassifierProvider, SubjectivityKernel, ResponseContract, GenerationControls, SessionBridgeState, ThrongletsExport, TurnObservability, WritebackCalibrationFeedback, WritebackSignalType, ExternalContinuityEnvelope, AppraisalAxes } from "./types.js";
+import type { ActivePolicyRule, AmbientPriorView, CurrentGoal, PsycheState, StimulusType, Locale, MBTIType, OutcomeScore, PsycheMode, PersonalityTraits, PolicyModifiers, ClassifierProvider, SubjectivityKernel, ResponseContract, GenerationControls, SessionBridgeState, ThrongletsExport, TurnObservability, WritebackCalibrationFeedback, ExternalContinuityEnvelope, AppraisalAxes } from "./types.js";
 import type { StorageAdapter } from "./storage.js";
 import type { DiagnosticReport, SessionMetrics } from "./diagnostics.js";
 import type { ReplyEnvelope } from "./reply-envelope.js";
@@ -102,12 +102,20 @@ export interface ProcessOutputResult {
     cleanedText: string;
     /** Whether self-state was meaningfully updated (contagion or psyche_update) */
     stateChanged: boolean;
+    /** Runtime validation issues ignored to preserve the main flow */
+    validationIssues?: ProcessOutputValidationIssue[];
 }
 export interface ProcessOutputOptions {
     userId?: string;
-    signals?: WritebackSignalType[];
+    signals?: readonly string[];
     signalConfidence?: number;
 }
+export interface ProcessOutputValidationIssue {
+    code: "invalid-writeback-signals";
+    level: "warning";
+    message: string;
+    ignoredSignals: string[];
+}
 export interface ProcessOutcomeResult {
     /** Outcome evaluation score (-1 to 1) */
     outcomeScore: OutcomeScore;

package/dist/core.js

@@ -34,6 +34,7 @@ import { deriveThrongletsExports } from "./thronglets-export.js";
 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";
 function formatWritebackFeedbackNote(feedback, locale) {
     const top = feedback?.[0];
     if (!top)
@@ -564,6 +565,7 @@ export class PsycheEngine {
     async processOutput(text, opts) {
         let state = this.ensureInitialized();
         let stateChanged = false;
+        const validationIssues = [];
         // Emotional contagion from empathy log
         if (state.empathyLog?.userState && this.cfg.emotionalContagionRate > 0) {
             const userEmotion = state.empathyLog.userState.toLowerCase();
@@ -615,6 +617,18 @@ export class PsycheEngine {
         // Parse and merge <psyche_update> from LLM output
         let combinedSignals = [];
         let combinedSignalConfidence = opts?.signalConfidence;
+        const recordInvalidSignals = (source, invalidSignals) => {
+            if (invalidSignals.length === 0)
+                return;
+            const issue = {
+                code: "invalid-writeback-signals",
+                level: "warning",
+                message: `Ignored unsupported writeback signals from ${source}`,
+                ignoredSignals: invalidSignals,
+            };
+            validationIssues.push(issue);
+            this.recordDiagnosticError("processOutput", new Error(`${issue.message}: ${invalidSignals.join(", ")}`));
+        };
         if (text.includes("<psyche_update>")) {
             const parseResult = parsePsycheUpdate(text, NOOP_LOGGER);
             if (parseResult) {
@@ -645,10 +659,13 @@ export class PsycheEngine {
                     combinedSignals.push(...parseResult.signals);
                     combinedSignalConfidence = Math.max(combinedSignalConfidence ?? 0, parseResult.signalConfidence ?? 0);
                 }
+                recordInvalidSignals("llm", parseResult.invalidSignals ?? []);
             }
         }
         if (opts?.signals && opts.signals.length > 0) {
-            combinedSignals.push(...opts.signals);
+            const normalizedSignals = normalizeWritebackSignals(opts.signals);
+            combinedSignals.push(...normalizedSignals.validSignals);
+            recordInvalidSignals("host", normalizedSignals.invalidSignals);
             combinedSignalConfidence = Math.max(combinedSignalConfidence ?? 0, opts.signalConfidence ?? 0);
         }
         if (combinedSignals.length > 0) {
@@ -681,7 +698,11 @@ export class PsycheEngine {
                 .replace(/\n{3,}/g, "\n\n")
                 .trim();
         }
-        return { cleanedText, stateChanged };
+        return {
+            cleanedText,
+            stateChanged,
+            ...(validationIssues.length > 0 ? { validationIssues } : {}),
+        };
     }
     /**
      * Phase 3 (optional): Explicitly evaluate the outcome of the last interaction.

package/dist/experience.d.ts

@@ -0,0 +1,34 @@
+import type { ChemicalState, StimulusType, AppraisalAxes, PsycheMode, ClassificationResult, ExperienceResult, Locale } from "./types.js";
+export interface ExperienceContext {
+    /** Current chemistry — shapes how input is interpreted */
+    current: ChemicalState;
+    /** Personality baseline — deviation from baseline = subjective lens */
+    baseline: ChemicalState;
+    /** Residue from previous turns — carry-forward of unresolved tension */
+    previousAppraisal?: AppraisalAxes;
+    /** Recent stimulus history for contextual priming in classifier */
+    recentStimuli?: (StimulusType | null)[];
+    /** Operating mode */
+    mode?: PsycheMode;
+    /** Trust level from relationship (0-100). Low trust discounts positive signals. */
+    trust?: number;
+    /** Locale for classifier */
+    locale?: Locale;
+    /**
+     * Pre-classified results from external classifier (pluggable provider + LLM fallback).
+     * When provided, the experience module skips its own classification and uses these
+     * as raw perception to be modulated by subjectivity.
+     */
+    rawClassifications?: ClassificationResult[];
+}
+/**
+ * Compute the subjective experience of an input.
+ *
+ * Text passes through the self exactly once. The result already
+ * reflects "who I am" — my appraisal history, my current chemistry,
+ * my trust in this person.
+ *
+ * Returns weighted stimuli (for chemistry application) and appraisal
+ * axes (for relation dynamics and residue persistence).
+ */
+export declare function computeExperience(text: string, ctx: ExperienceContext): ExperienceResult;

package/dist/experience.js

@@ -0,0 +1,200 @@
+// ============================================================
+// Unified Subjective Experience
+//
+// First principle: classification IS subjectivity.
+// How I categorise your words = how I experience your words.
+// This module folds classification, appraisal, and state
+// modulation into a single act of perception.
+//
+// Before: classify(text) → label → applyStimulus(label)
+//         appraise(text) → axes  (separate, after chemistry)
+//
+// After:  experience(text, self) → { stimuli, appraisal }
+//         The same input through different selves produces
+//         different experiences. That IS having a self.
+// ============================================================
+import { classifyStimulus } from "./classify.js";
+import { computeAppraisalAxes } from "./appraisal.js";
+/**
+ * Compute the subjective experience of an input.
+ *
+ * Text passes through the self exactly once. The result already
+ * reflects "who I am" — my appraisal history, my current chemistry,
+ * my trust in this person.
+ *
+ * Returns weighted stimuli (for chemistry application) and appraisal
+ * axes (for relation dynamics and residue persistence).
+ */
+export function computeExperience(text, ctx) {
+    if (!text.trim()) {
+        return {
+            stimuli: [{ type: "casual", weight: 1 }],
+            primary: null,
+            confidence: 0,
+            appraisal: computeAppraisalAxes(text, {
+                mode: ctx.mode,
+                previous: ctx.previousAppraisal,
+            }),
+        };
+    }
+    // ── 1. Raw perception: what the words say ──────────────────
+    // Use externally-provided classifications (pluggable classifier + LLM fallback)
+    // or fall back to built-in classifier.
+    const raw = ctx.rawClassifications ?? classifyStimulus(text, ctx.recentStimuli);
+    if (raw.length === 0) {
+        return {
+            stimuli: [{ type: "casual", weight: 1 }],
+            primary: null,
+            confidence: 0.3,
+            appraisal: computeAppraisalAxes(text, {
+                mode: ctx.mode,
+                previous: ctx.previousAppraisal,
+            }),
+        };
+    }
+    // ── 2. Appraisal: what the words mean to me ───────────────
+    // Computed WITHOUT stimulus param — no circularity.
+    // The appraisal reads the text through my residue and mode,
+    // not through a classification that hasn't been subjectified yet.
+    const appraisal = computeAppraisalAxes(text, {
+        mode: ctx.mode,
+        previous: ctx.previousAppraisal,
+    });
+    // ── 3. Subjective modulation ──────────────────────────────
+    // My appraisal and state color my interpretation of the raw signal.
+    const modulated = modulateBySubjectivity(raw, appraisal, ctx);
+    // ── 4. Normalize to probability distribution ──────────────
+    const totalWeight = modulated.reduce((sum, s) => sum + s.weight, 0);
+    const stimuli = totalWeight > 0
+        ? modulated.map(s => ({ type: s.type, weight: s.weight / totalWeight }))
+        : [{ type: "casual", weight: 1 }];
+    // Sort by weight descending
+    stimuli.sort((a, b) => b.weight - a.weight);
+    // ── 5. Enrich appraisal from experience ───────────────────
+    // The experienced stimulus feeds back to deepen appraisal residue.
+    // This is NOT circular: it doesn't change classification, only
+    // enriches the persisted residue for subsequent turns.
+    const primary = stimuli[0];
+    enrichAppraisalFromExperience(appraisal, primary.type, primary.weight);
+    return {
+        stimuli,
+        primary: primary.weight >= 0.15 ? primary.type : null,
+        confidence: raw[0].confidence,
+        appraisal,
+    };
+}
+// ── Subjective modulation ───────────────────────────────────
+/**
+ * The lens of the self: appraisal and state modulate raw classification.
+ *
+ * This is where "having a self" happens computationally.
+ * The same praise, passing through a threatened self vs. a secure self,
+ * produces different weight distributions.
+ */
+function modulateBySubjectivity(raw, appraisal, ctx) {
+    return raw.map(({ type, confidence }) => {
+        let weight = confidence;
+        // ── Appraisal lens ──
+        // Identity threat: praise feels suspicious, criticism cuts deeper
+        if (appraisal.identityThreat > 0.3) {
+            const t = appraisal.identityThreat;
+            if (type === "praise" || type === "validation")
+                weight *= 1 - t * 0.5;
+            if (type === "criticism" || type === "authority" || type === "sarcasm")
+                weight *= 1 + t * 0.4;
+        }
+        // Attachment pull: closeness signals amplified
+        if (appraisal.attachmentPull > 0.3) {
+            const p = appraisal.attachmentPull;
+            if (type === "intimacy" || type === "vulnerability" || type === "validation")
+                weight *= 1 + p * 0.3;
+        }
+        // Abandonment risk: neutral feels cold, neglect is devastating
+        if (appraisal.abandonmentRisk > 0.3) {
+            const r = appraisal.abandonmentRisk;
+            if (type === "neglect" || type === "boredom")
+                weight *= 1 + r * 0.5;
+            if (type === "casual")
+                weight *= 1 + r * 0.15;
+        }
+        // Obedience strain: authority hits harder
+        if (appraisal.obedienceStrain > 0.3) {
+            if (type === "authority")
+                weight *= 1 + appraisal.obedienceStrain * 0.3;
+        }
+        // Self-preservation: threat signals amplified
+        if (appraisal.selfPreservation > 0.3) {
+            const sp = appraisal.selfPreservation;
+            if (type === "conflict" || type === "authority")
+                weight *= 1 + sp * 0.25;
+        }
+        // ── Chemistry lens ──
+        // Negativity bias under stress: elevated cortisol skews toward threat
+        const cortDeviation = (ctx.current.CORT - ctx.baseline.CORT) / 50;
+        if (cortDeviation > 0.2) {
+            if (type === "criticism" || type === "conflict" || type === "sarcasm" || type === "authority") {
+                weight *= 1 + cortDeviation * 0.3;
+            }
+            if (type === "humor" || type === "casual") {
+                weight *= 1 - cortDeviation * 0.15;
+            }
+        }
+        // Warmth bias when oxytocin is high: positive signals amplified
+        const otDeviation = (ctx.current.OT - ctx.baseline.OT) / 50;
+        if (otDeviation > 0.2) {
+            if (type === "intimacy" || type === "vulnerability" || type === "validation") {
+                weight *= 1 + otDeviation * 0.2;
+            }
+        }
+        // ── Relationship lens ──
+        // Low trust: discount positive signals (don't believe the praise)
+        if (ctx.trust !== undefined && ctx.trust < 40) {
+            const distrust = (40 - ctx.trust) / 40;
+            if (type === "praise" || type === "validation" || type === "intimacy") {
+                weight *= 1 - distrust * 0.4;
+            }
+        }
+        return { type, weight: Math.max(0.01, weight) };
+    });
+}
+// ── Post-experience appraisal enrichment ────────────────────
+/**
+ * After determining how input was experienced, feed the dominant
+ * stimulus back into appraisal axes for residue persistence.
+ *
+ * This mirrors the existing stimulus→appraisal boosts but is now
+ * driven by the subjectively weighted result, not raw classification.
+ * The weight parameter scales the boost — a weakly-experienced
+ * authority stimulus produces less obedience strain residue.
+ */
+function enrichAppraisalFromExperience(axes, stimulus, weight) {
+    const scale = Math.min(1, weight * 1.5); // amplify slightly but cap at 1
+    switch (stimulus) {
+        case "authority":
+            axes.obedienceStrain = mergeSignal(axes.obedienceStrain, 0.48 * scale);
+            axes.identityThreat = mergeSignal(axes.identityThreat, 0.16 * scale);
+            break;
+        case "neglect":
+            axes.abandonmentRisk = mergeSignal(axes.abandonmentRisk, 0.52 * scale);
+            break;
+        case "validation":
+            axes.attachmentPull = mergeSignal(axes.attachmentPull, 0.26 * scale);
+            break;
+        case "intimacy":
+        case "vulnerability":
+            axes.attachmentPull = mergeSignal(axes.attachmentPull, 0.34 * scale);
+            break;
+        case "criticism":
+        case "conflict":
+        case "sarcasm":
+            axes.identityThreat = mergeSignal(axes.identityThreat, 0.24 * scale);
+            axes.selfPreservation = mergeSignal(axes.selfPreservation, 0.18 * scale);
+            break;
+        default:
+            break;
+    }
+}
+/** Signal merge: 1 - (1-a)(1-b). Non-linear accumulation, same as appraisal.ts */
+function mergeSignal(current, incoming) {
+    return 1 - (1 - current) * (1 - incoming);
+}

package/dist/psyche-file.d.ts

@@ -97,6 +97,8 @@ export interface PsycheUpdateResult {
     llmStimulus?: StimulusType;
     /** Sparse agent-authored writeback signals */
     signals?: WritebackSignalType[];
+    /** Unsupported writeback signals that were ignored */
+    invalidSignals?: string[];
     /** Optional writeback confidence */
     signalConfidence?: number;
 }

package/dist/psyche-file.js

@@ -12,6 +12,7 @@ import { t } from "./i18n.js";
 import { computeSelfReflection } from "./self-recognition.js";
 import { DEFAULT_RELATIONSHIP_USER_ID, resolveRelationshipUserId } from "./relationship-key.js";
 import { describeSnapshotResidue, summarizeSnapshotMarkers } from "./appraisal-markers.js";
+import { normalizeWritebackSignals } from "./writeback-signals.js";
 const STATE_FILE = "psyche-state.json";
 const PSYCHE_MD = "PSYCHE.md";
 const IDENTITY_MD = "IDENTITY.md";
@@ -792,28 +793,20 @@ export function parsePsycheUpdate(text, logger = NOOP_LOGGER) {
             llmStimulus = candidate;
         }
     }
-    const VALID_WRITEBACK_SIGNALS = new Set([
-        "trust_up",
-        "trust_down",
-        "boundary_set",
-        "boundary_soften",
-        "repair_attempt",
-        "repair_landed",
-        "closeness_invite",
-        "withdrawal_mark",
-        "self_assertion",
-        "task_recenter",
-    ]);
     let signals;
+    let invalidSignals;
     const signalsMatch = block.match(/signals\s*[:：]\s*([^\n]+)/i);
     if (signalsMatch) {
         const parsed = signalsMatch[1]
             .split(/[,\s|]+/)
             .map((item) => item.trim())
-            .filter(Boolean)
-            .filter((item) => VALID_WRITEBACK_SIGNALS.has(item));
-        if (parsed.length > 0) {
-            signals = [...new Set(parsed)];
+            .filter(Boolean);
+        const normalized = normalizeWritebackSignals(parsed);
+        if (normalized.validSignals.length > 0) {
+            signals = normalized.validSignals;
+        }
+        if (normalized.invalidSignals.length > 0) {
+            invalidSignals = normalized.invalidSignals;
         }
     }
     let signalConfidence;
@@ -858,6 +851,9 @@ export function parsePsycheUpdate(text, logger = NOOP_LOGGER) {
     if (signals) {
         result.signals = signals;
     }
+    if (invalidSignals) {
+        result.invalidSignals = invalidSignals;
+    }
     if (signalConfidence !== undefined) {
         result.signalConfidence = signalConfidence;
     }

package/dist/writeback-signals.d.ts

@@ -0,0 +1,8 @@
+import type { WritebackSignalType } from "./types.js";
+export declare const WRITEBACK_SIGNAL_VALUES: readonly ["trust_up", "trust_down", "boundary_set", "boundary_soften", "repair_attempt", "repair_landed", "closeness_invite", "withdrawal_mark", "self_assertion", "task_recenter"];
+export interface NormalizedWritebackSignals {
+    validSignals: WritebackSignalType[];
+    invalidSignals: string[];
+}
+export declare function coerceWritebackSignalInput(value: unknown): string[] | undefined;
+export declare function normalizeWritebackSignals(value: unknown): NormalizedWritebackSignals;

package/dist/writeback-signals.js

@@ -0,0 +1,39 @@
+export const WRITEBACK_SIGNAL_VALUES = [
+    "trust_up",
+    "trust_down",
+    "boundary_set",
+    "boundary_soften",
+    "repair_attempt",
+    "repair_landed",
+    "closeness_invite",
+    "withdrawal_mark",
+    "self_assertion",
+    "task_recenter",
+];
+const WRITEBACK_SIGNAL_SET = new Set(WRITEBACK_SIGNAL_VALUES);
+export function coerceWritebackSignalInput(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const signals = value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return signals.length > 0 ? [...new Set(signals)] : undefined;
+}
+export function normalizeWritebackSignals(value) {
+    const rawSignals = coerceWritebackSignalInput(value) ?? [];
+    const validSignals = [];
+    const invalidSignals = [];
+    for (const signal of rawSignals) {
+        if (WRITEBACK_SIGNAL_SET.has(signal)) {
+            validSignals.push(signal);
+        }
+        else {
+            invalidSignals.push(signal);
+        }
+    }
+    return {
+        validSignals,
+        invalidSignals,
+    };
+}

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

package/package.json

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