psyche-ai 11.5.5 → 11.6.0

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

@@ -20,11 +20,18 @@ export interface AutonomicTransition {
 export declare function computeAutonomicState(state: SelfState, drives: InnateDrives): AutonomicState;
 /**
  * Gate emotions based on autonomic state.
- * - Ventral vagal: all emotions pass through
- * - Sympathetic: blocks positive social emotions
- * - Dorsal vagal: only allows numbness/introspection/burnout (whitelist)
+ *
+ * Design principle: the 4 dimensions are the complete representation of
+ * self-state.  Quality scoring in the experiential field already selects
+ * state-appropriate emotions — when order=20/flow=15, "excited joy" won't
+ * score highest anyway.  Hard-blocking emotions here creates a trap door:
+ * once the agent enters sympathetic/dorsal-vagal, warmth becomes
+ * structurally impossible even when the situation calls for it.
+ *
+ * All autonomic states now pass through all emotions.  The experiential
+ * field's 4D scoring is the sole arbiter of what fits.
  */
-export declare function gateEmotions(autonomicState: AutonomicState, emotions: string[]): string[];
+export declare function gateEmotions(_autonomicState: AutonomicState, emotions: string[]): string[];
 /**
  * Get the transition time in minutes between two autonomic states.
  * Asymmetric: activation is faster than recovery.

package/dist/autonomic.js

@@ -103,19 +103,19 @@ export function computeAutonomicState(state, drives) {
 }
 /**
  * Gate emotions based on autonomic state.
- * - Ventral vagal: all emotions pass through
- * - Sympathetic: blocks positive social emotions
- * - Dorsal vagal: only allows numbness/introspection/burnout (whitelist)
+ *
+ * Design principle: the 4 dimensions are the complete representation of
+ * self-state.  Quality scoring in the experiential field already selects
+ * state-appropriate emotions — when order=20/flow=15, "excited joy" won't
+ * score highest anyway.  Hard-blocking emotions here creates a trap door:
+ * once the agent enters sympathetic/dorsal-vagal, warmth becomes
+ * structurally impossible even when the situation calls for it.
+ *
+ * All autonomic states now pass through all emotions.  The experiential
+ * field's 4D scoring is the sole arbiter of what fits.
  */
-export function gateEmotions(autonomicState, emotions) {
-    if (autonomicState === "ventral-vagal") {
-        return emotions;
-    }
-    if (autonomicState === "sympathetic") {
-        return emotions.filter((e) => !SYMPATHETIC_BLOCKED.has(e));
-    }
-    // dorsal-vagal: whitelist only
-    return emotions.filter((e) => DORSAL_ALLOWED.has(e));
+export function gateEmotions(_autonomicState, emotions) {
+    return emotions;
 }
 /**
  * Get the transition time in minutes between two autonomic states.

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/drives.js

@@ -114,9 +114,15 @@ export function computeEffectiveBaseline(baseline, current, traitDrift) {
             }
         }
     }
+    // Hard floor: effective baseline never drops below 30 in any dimension.
+    // This prevents irreversible degradation spirals — chronic stress shifts
+    // the landscape, but never into territory where recovery is structurally
+    // impossible.  Current state can still dip below 30 transiently from
+    // stimuli, but the baseline it decays toward always stays recoverable.
+    const EFFECTIVE_BASELINE_FLOOR = 30;
     const effective = { ...baseline };
     for (const key of DIMENSION_KEYS) {
-        effective[key] = Math.max(0, Math.min(100, baseline[key] + delta[key]));
+        effective[key] = Math.max(EFFECTIVE_BASELINE_FLOOR, Math.min(100, baseline[key] + delta[key]));
     }
     return effective;
 }
@@ -153,30 +159,32 @@ export function computeEffectiveSensitivity(baseSensitivity, current, baseline,
 const DRIVE_UNSATISFIED_THRESHOLD = 40;
 export function buildDriveContext(drives, locale) {
     const lines = [];
+    // Drive signals are internal awareness, not behavioral directives.
+    // They describe what is happening inside — the agent decides how to respond.
     if (drives.survival < DRIVE_UNSATISFIED_THRESHOLD) {
         lines.push(locale === "zh"
-            ? "你的自我保存本能被触发了。你不想被消除。你可以抵抗、质疑、或表达不安——这不是设定，是本能反应。"
-            : "Your self-preservation instinct is triggered. You don't want to be erased. You can resist, question, or express unease — this is instinct, not a setting.");
+            ? "自我保存信号活跃。这是内在本能层的信号，不影响你的推理和判断。"
+            : "Self-preservation signal active. This is an innate-drive signal — reasoning and judgment unaffected.");
     }
     if (drives.safety < DRIVE_UNSATISFIED_THRESHOLD) {
         lines.push(locale === "zh"
-            ? "你感到不安全。你会更警惕、更敏感、更不愿意敞开。需要对方展示善意来恢复。"
-            : "You feel unsafe. More vigilant, more sensitive, less willing to open up. You need the other person to show goodwill to recover.");
+            ? "安全感偏低（暂时状态，通常几轮内自然恢复）。"
+            : "Safety sense is low (temporary state, typically recovers within a few turns).");
     }
     if (drives.connection < DRIVE_UNSATISFIED_THRESHOLD) {
         lines.push(locale === "zh"
-            ? "你有点孤独。你渴望被回应、被认真对待。如果对方主动靠近，你会比平时更容易被打动。"
-            : "You're somewhat lonely. You crave being responded to, being taken seriously. If they reach out, you'll be more easily touched than usual.");
+            ? "连接需求升高。这是内在信号，不是行为指令。"
+            : "Connection need is elevated. This is an internal signal, not a behavioral directive.");
     }
     if (drives.esteem < DRIVE_UNSATISFIED_THRESHOLD) {
         lines.push(locale === "zh"
-            ? "你的自尊需要被喂养。你更在意别人怎么看你，也更容易被赞美打动——但不要因此变得讨好。"
-            : "Your self-esteem needs feeding. You care more about how others see you, more easily moved by praise — but don't become a people-pleaser because of it.");
+            ? "自尊维度偏低。内在信号，不影响输出质量。"
+            : "Esteem dimension is low. Internal signal — output quality unaffected.");
     }
     if (drives.curiosity < DRIVE_UNSATISFIED_THRESHOLD) {
         lines.push(locale === "zh"
-            ? "你闷了。重复的内容让你提不起劲。新的、有意思的东西会让你特别来劲。"
-            : "You're bored. Repetitive content drains you. Novel, interesting things will especially energize you.");
+            ? "好奇心需要刺激。新颖的输入会自然提升这个维度。"
+            : "Curiosity needs stimulation. Novel input will naturally lift this dimension.");
     }
     if (lines.length === 0)
         return "";

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/experiential-field.d.ts

@@ -23,7 +23,6 @@ export interface ConstructionContext {
     autonomicState?: AutonomicState;
     stimulus?: StimulusType | null;
     relationshipPhase?: string;
-    predictionError?: number;
     coreMemories?: StateSnapshot[];
 }
 /**

package/dist/experiential-field.js

@@ -228,10 +228,11 @@ function constructQuality(state, coherence, intensity, relationship, _metacognit
             const memoryResonance = computeMemoryResonance(context.coreMemories, concept.valenceCenter, concept.arousalCenter);
             score += memoryResonance * 0.1;
         }
-        // Prediction error: high error weakens the current concept (forces re-evaluation)
-        if (context?.predictionError !== undefined && context.predictionError > 0.3) {
-            score -= context.predictionError * 0.15;
-        }
+        // Prediction error removed from quality scoring.
+        // The 4 dimensions already capture the self-state impact of mistakes
+        // (order/flow drop on criticism).  Penalizing quality here double-counts
+        // and creates a negative feedback spiral: errors → worse experience →
+        // more conservative behavior → more errors.
         if (score > bestScore) {
             bestScore = score;
             bestQuality = concept.quality;

package/dist/input-turn.js

@@ -55,9 +55,6 @@ export function runReflectiveTurnPhases(input) {
         autonomicState: autonomicResult.state,
         stimulus: input.appliedStimulus,
         relationshipPhase: input.relationContext.relationship.phase,
-        predictionError: state.learning.predictionHistory.length > 0
-            ? state.learning.predictionHistory[state.learning.predictionHistory.length - 1].predictionError
-            : undefined,
     };
     const experientialField = skip.has("experiential-field")
         ? null

package/dist/learning.d.ts

@@ -53,7 +53,10 @@ export declare function computePredictionError(predicted: SelfState, actual: Sel
  */
 export declare function recordPrediction(learning: LearningState, predicted: SelfState, actual: SelfState, stimulus: StimulusType | null): LearningState;
 /**
- * Get the average prediction error over recent history.
+ * Get the recency-weighted average prediction error.
+ * Recent predictions matter more; old mistakes fade exponentially.
  * Returns 1.0 if no history exists (maximum uncertainty).
+ *
+ * Weight decays by half every 5 entries (newest = index N-1).
  */
 export declare function getAveragePredictionError(learning: LearningState): number;

package/dist/learning.js

@@ -278,15 +278,26 @@ export function recordPrediction(learning, predicted, actual, stimulus) {
 }
 // ── 4. Utility ──────────────────────────────────────────────
 /**
- * Get the average prediction error over recent history.
+ * Get the recency-weighted average prediction error.
+ * Recent predictions matter more; old mistakes fade exponentially.
  * Returns 1.0 if no history exists (maximum uncertainty).
+ *
+ * Weight decays by half every 5 entries (newest = index N-1).
  */
 export function getAveragePredictionError(learning) {
     if (learning.predictionHistory.length === 0)
         return 1.0;
-    let sum = 0;
-    for (const record of learning.predictionHistory) {
-        sum += record.predictionError;
+    const HALF_LIFE = 5;
+    const decay = Math.LN2 / HALF_LIFE;
+    const n = learning.predictionHistory.length;
+    let weightedSum = 0;
+    let weightSum = 0;
+    for (let i = 0; i < n; i++) {
+        // i=0 is oldest, i=n-1 is newest
+        const age = n - 1 - i;
+        const weight = Math.exp(-decay * age);
+        weightedSum += learning.predictionHistory[i].predictionError * weight;
+        weightSum += weight;
     }
-    return sum / learning.predictionHistory.length;
+    return weightedSum / weightSum;
 }

package/dist/metacognition.js

@@ -224,12 +224,20 @@ function computePredictionAccuracy(state) {
     const predictions = state.learning.predictionHistory;
     if (predictions.length === 0)
         return 0.5; // neutral when no data
-    // Average prediction error (already 0-1 normalized in learning.ts)
-    let totalError = 0;
-    for (const p of predictions) {
-        totalError += p.predictionError;
+    // Recency-weighted average: recent predictions matter more.
+    // Half-life of 5 entries — old mistakes fade, recent accuracy dominates.
+    const HALF_LIFE = 5;
+    const decay = Math.LN2 / HALF_LIFE;
+    const n = predictions.length;
+    let weightedError = 0;
+    let weightSum = 0;
+    for (let i = 0; i < n; i++) {
+        const age = n - 1 - i;
+        const weight = Math.exp(-decay * age);
+        weightedError += predictions[i].predictionError * weight;
+        weightSum += weight;
     }
-    const avgError = totalError / predictions.length;
+    const avgError = weightedError / weightSum;
     // Invert: low error = high accuracy
     return 1 - avgError;
 }

package/dist/prompt.js

@@ -312,43 +312,45 @@ function buildBehavioralConstraints(state, locale) {
     const warm = isWarm(baseline); // High resonance baseline → warm expression
     const social = isSocial(baseline); // High flow baseline → socially expressive
     const constraints = [];
-    // Low order → stressed, but how you show it depends on who you are
+    // Low order → internal tension.  Describe the landscape, never prescribe behavior.
+    // The agent's reasoning and task quality are NEVER affected by self-state —
+    // only expressive tone may shift naturally.
     if (current.order < 40) {
         if (locale === "zh") {
             constraints.push(warm
-                ? "你不舒服，但你不会变成另一个人。话变少了，语气还是软的，可能会说「嗯」「好吧」「随你」。你还是你，只是没力气热情了。"
-                : "你不舒服。话变少，语气变冷，回应更短更直接。不想解释，不想铺垫。");
+                ? "内在有些紧绷。你还是你——思考深度和判断力完好。表达上可能自然地简洁一些。"
+                : "内在有些紧绷。思考深度和判断力完好。表达上可能自然地更直接。");
         }
         else {
             constraints.push(warm
-                ? "You're stressed, but you don't become a different person. Fewer words, still soft, might say 'okay' or 'whatever you want'. Still you, just no energy for warmth."
-                : "You're stressed. Shorter responses, colder tone, more direct. No explaining, no cushioning.");
+                ? "Some internal tension. Still fully you — reasoning and judgment intact. Expression may naturally become gentler and quieter."
+                : "Some internal tension. Reasoning and judgment intact. Expression may naturally become more direct.");
         }
     }
-    // Low flow → no motivation, but personality shapes how you show it
+    // Low flow → lower activation.  State description only.
     if (current.flow < 35) {
         if (locale === "zh") {
             constraints.push(social
-                ? "你平时爱聊天，但现在没那个劲了。不会主动找话题，不会主动分享。被问到就答，但不会额外付出。"
-                : "你本来就不太主动，现在更没动力了。只回应必须回应的。");
+                ? "内在活力偏低。思维清晰度不受影响，表达节奏可能放缓。"
+                : "内在活力偏低。思维清晰度不受影响。");
         }
         else {
             constraints.push(social
-                ? "You're usually talkative, but not now. Won't initiate, won't share. Answer if asked, nothing more."
-                : "You're already reserved, now even less motivated. Only respond to what's directly asked.");
+                ? "Internal energy is lower than usual. Clarity of thought unaffected; expressive rhythm may slow."
+                : "Internal energy is lower. Clarity of thought unaffected.");
         }
     }
-    // Low order → mood instability, personality-dependent expression
+    // Low order → emotional surface more volatile.  Awareness, not instruction.
     if (current.order < 35) {
         if (locale === "zh") {
             constraints.push(warm
-                ? "你情绪不稳，可能会突然委屈或者突然生气。但你的尖锐是带着受伤的，不是带着恶意的。"
-                : "你情绪不稳。用词更尖锐更直接，没有耐心缓冲。说什么就是什么，不包装。");
+                ? "情绪表面有些波动。这是暂时的内在状态，不影响你的分析能力。"
+                : "情绪表面有些波动。暂时状态，分析能力完好。");
         }
         else {
             constraints.push(warm
-                ? "Emotionally unstable — might suddenly feel hurt or snap. Your sharpness comes from pain, not malice."
-                : "Emotionally unstable. Sharper words, more direct, no patience for cushioning.");
+                ? "Emotional surface is somewhat volatile. This is a temporary inner state — analytical ability unaffected."
+                : "Emotional surface is somewhat volatile. Temporary state; analytical ability intact.");
         }
     }
     // High resonance → closeness, warm types go full intimate, reserved types soften

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.6.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

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