psyche-ai 11.5.4 → 11.5.6

package/README.md

@@ -103,6 +103,29 @@ Psyche 要解决的不可压缩问题只有一个：
 
 一句话：`Psyche` 读取当前执行边界，但不把执行边界误当成“我是谁”。
 
+## 中期方向：更像人，但不是靠 prompt 工程
+
+如果 `Psyche` 未来要变得更有感情、更会和人相处，这种能力也必须从连续性里长出来，而不是从 prompt 皮肤里长出来。
+
+允许增长的来源只有：
+
+- 持续本地状态
+- appraisal 残留
+- 关系动力学
+- 调节与修复历史
+- 低频写回与学习
+
+不允许把下面这些误当成“主体性升级”：
+
+- 静态 persona prompt
+- 手写情绪脚本
+- 高频情绪仪表盘
+- 只改措辞、不改后续行为分布的情感 UI
+
+冻结约束见：
+
+- [../Oasyce-Sigil/EMERGENT_SUBJECTIVITY_CONTRACT_V1.md](../Oasyce-Sigil/EMERGENT_SUBJECTIVITY_CONTRACT_V1.md)
+
 ## 可分离安装
 
 这两层默认就是可分离的，不应互相成为硬依赖。

package/dist/adapters/claude-sdk.js

@@ -28,10 +28,12 @@
 // The SDK has no middleware interface and hooks cannot modify assistant
 // output, so processResponse must be called explicitly by the host.
 // ============================================================
+import { normalizeCurrentGoal, normalizeCurrentTurnCorrection, resolveRuntimeActivePolicy, } from "../types.js";
 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,
@@ -107,9 +109,12 @@ export class PsycheClaudeSDK {
             ambient: opts?.ambient === true ? {} : (opts?.ambient || undefined),
         };
     }
-    async resolveAmbientPriors(userMessage) {
+    async resolveAmbientPriors(userMessage, currentGoal, activePolicy, currentTurnCorrection) {
         return resolveAmbientPriorsForTurn(userMessage, {
             enabled: Boolean(this.opts.ambient),
+            currentGoal,
+            activePolicy,
+            currentTurnCorrection,
             thronglets: this.opts.ambient
                 ? {
                     ...this.opts.ambient,
@@ -166,17 +171,29 @@ export class PsycheClaudeSDK {
                                 sessionId: runtimeContext.sessionId ?? self.lastRuntimeContext.sessionId,
                             };
                             const userMessage = input.user_message ?? "";
-                            const ambientPriors = await self.resolveAmbientPriors(userMessage);
-                            const result = await self.engine.processInput(userMessage, {
+                            const currentTurnCorrection = normalizeCurrentTurnCorrection(input.current_turn_correction
+                                ?? input.currentTurnCorrection
+                                ?? input.task_correction
+                                ?? input.taskCorrection
+                                ?? input.explicit_instruction
+                                ?? input.explicitInstruction);
+                            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 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 } : {};
                         },
                     ],
                 },
@@ -193,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,30 +16,22 @@
 // Zero dependencies — uses node:http only.
 // ============================================================
 import { createServer } from "node:http";
-import { normalizeActivePolicyRules, normalizeCurrentGoal, } from "../types.js";
+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);
 }
+function parseCurrentTurnCorrection(body) {
+    return normalizeCurrentTurnCorrection(body.currentTurnCorrection
+        ?? body.current_turn_correction
+        ?? body.taskCorrection
+        ?? body.task_correction
+        ?? body.explicitInstruction
+        ?? body.explicit_instruction);
+}
 // ── Server ───────────────────────────────────────────────────
 /**
  * Create an HTTP server that exposes PsycheEngine via REST API.
@@ -94,12 +86,14 @@ export function createPsycheServer(engine, opts) {
             // POST /process-input
             if (req.method === "POST" && url.pathname === "/process-input") {
                 const body = await readBody(req);
-                const result = await engine.processInput(body.text ?? "", {
+                const currentTurnCorrection = parseCurrentTurnCorrection(body);
+                const result = await safeProcessInput(engine, body.text ?? "", {
                     userId: body.userId,
                     ambientPriors: parseAmbientPriors(body.ambientPriors),
                     currentGoal: normalizeCurrentGoal(body.currentGoal),
-                    activePolicy: normalizeActivePolicyRules(body.activePolicy),
-                });
+                    activePolicy: resolveRuntimeActivePolicy(body.activePolicy, currentTurnCorrection),
+                    currentTurnCorrection,
+                }, "http.processInput");
                 json(res, 200, {
                     systemContext: result.systemContext,
                     dynamicContext: result.dynamicContext,
@@ -127,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

@@ -1,4 +1,5 @@
 import type { PsycheEngine } from "../core.js";
+import type { ActivePolicyRule, CurrentGoal } from "../types.js";
 import { type ThrongletsAmbientRuntimeOptions } from "../ambient-runtime.js";
 export interface PsycheLangChainOptions {
     ambient?: boolean | ThrongletsAmbientRuntimeOptions;
@@ -33,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.
@@ -44,6 +43,9 @@ export declare class PsycheLangChain {
      */
     getSystemMessage(userText: string, opts?: {
         userId?: string;
+        currentGoal?: CurrentGoal;
+        activePolicy?: ActivePolicyRule[];
+        currentTurnCorrection?: string;
     }): Promise<string>;
     /**
      * Prepare both prompt text and mechanical invocation hints for a LangChain call.
@@ -54,6 +56,9 @@ export declare class PsycheLangChain {
     prepareInvocation(userText: string, opts?: {
         userId?: string;
         maxTokens?: number;
+        currentGoal?: CurrentGoal;
+        activePolicy?: ActivePolicyRule[];
+        currentTurnCorrection?: string;
     }): Promise<{
         systemMessage: string;
         maxTokens?: number;

package/dist/adapters/langchain.js

@@ -12,7 +12,10 @@
 // It provides the hooks you need to wire psyche into any
 // LangChain pipeline without requiring langchain as a dependency.
 // ============================================================
+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.
  *
@@ -46,28 +49,13 @@ 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) {
+    async resolveAmbientPriors(userText, currentGoal, activePolicy, currentTurnCorrection) {
         const ambient = this.opts.ambient;
         return resolveAmbientPriorsForTurn(userText, {
             enabled: Boolean(ambient),
+            currentGoal,
+            activePolicy,
+            currentTurnCorrection,
             thronglets: ambient
                 ? {
                     ...(ambient === true ? {} : ambient),
@@ -83,11 +71,17 @@ export class PsycheLangChain {
      * Call this BEFORE the LLM invocation.
      */
     async getSystemMessage(userText, opts) {
-        const result = await this.engine.processInput(userText, {
+        const currentTurnCorrection = normalizeCurrentTurnCorrection(opts?.currentTurnCorrection);
+        const currentGoal = normalizeCurrentGoal(opts?.currentGoal);
+        const activePolicy = resolveRuntimeActivePolicy(opts?.activePolicy, currentTurnCorrection);
+        const result = await safeProcessInput(this.engine, userText, {
             ...opts,
-            ambientPriors: await this.resolveAmbientPriors(userText),
-        });
-        return result.systemContext + "\n\n" + result.dynamicContext;
+            currentGoal,
+            activePolicy,
+            currentTurnCorrection,
+            ambientPriors: await this.resolveAmbientPriors(userText, currentGoal, activePolicy, currentTurnCorrection),
+        }, "langchain.processInput");
+        return composePsycheContext(result);
     }
     /**
      * Prepare both prompt text and mechanical invocation hints for a LangChain call.
@@ -96,10 +90,16 @@ export class PsycheLangChain {
      * instead of re-parsing prompt prose.
      */
     async prepareInvocation(userText, opts) {
-        const result = await this.engine.processInput(userText, {
+        const currentTurnCorrection = normalizeCurrentTurnCorrection(opts?.currentTurnCorrection);
+        const currentGoal = normalizeCurrentGoal(opts?.currentGoal);
+        const activePolicy = resolveRuntimeActivePolicy(opts?.activePolicy, currentTurnCorrection);
+        const result = await safeProcessInput(this.engine, userText, {
             ...opts,
-            ambientPriors: await this.resolveAmbientPriors(userText),
-        });
+            currentGoal,
+            activePolicy,
+            currentTurnCorrection,
+            ambientPriors: await this.resolveAmbientPriors(userText, currentGoal, activePolicy, currentTurnCorrection),
+        }, "langchain.processInput");
         const generationControls = result.replyEnvelope?.generationControls ?? result.generationControls;
         const controls = {
             ...(generationControls ?? {}),
@@ -108,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,
         };
@@ -120,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.d.ts

@@ -8,7 +8,7 @@ export interface McpAmbientRuntimeOptions {
     fetcher?: typeof fetchAmbientPriorsFromThronglets;
 }
 declare function getEngine(): Promise<PsycheEngine>;
-export declare function resolveRuntimeAmbientPriors(text: string, explicit?: AmbientPriorView[], currentGoal?: CurrentGoal, activePolicy?: ActivePolicyRule[], opts?: McpAmbientRuntimeOptions): Promise<AmbientPriorView[] | undefined>;
+export declare function resolveRuntimeAmbientPriors(text: string, explicit?: AmbientPriorView[], currentGoal?: CurrentGoal, activePolicy?: ActivePolicyRule[], currentTurnCorrectionOrOpts?: string | McpAmbientRuntimeOptions, opts?: McpAmbientRuntimeOptions): Promise<AmbientPriorView[] | undefined>;
 declare const server: McpServer;
 export declare function runMcpServer(): Promise<void>;
 export { server, getEngine };

package/dist/adapters/mcp.js

@@ -32,9 +32,10 @@ import { z } from "zod";
 import { PsycheEngine } from "../core.js";
 import { fetchAmbientPriorsFromThronglets, resolveAmbientPriorsForTurn, } from "../ambient-runtime.js";
 import { MemoryStorageAdapter, FileStorageAdapter, resolveWorkspaceDir } from "../storage.js";
-import { CURRENT_GOALS } from "../types.js";
+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");
@@ -126,19 +127,32 @@ async function getEngine() {
     await engine.initialize();
     return engine;
 }
-export async function resolveRuntimeAmbientPriors(text, explicit, currentGoal, activePolicy, opts = DEFAULT_MCP_AMBIENT_OPTIONS) {
-    const throngletsOptions = opts.thronglets || currentGoal || activePolicy?.length
+export async function resolveRuntimeAmbientPriors(text, explicit, currentGoal, activePolicy, currentTurnCorrectionOrOpts, opts = DEFAULT_MCP_AMBIENT_OPTIONS) {
+    const currentTurnCorrection = typeof currentTurnCorrectionOrOpts === "string"
+        ? currentTurnCorrectionOrOpts
+        : undefined;
+    const resolvedOpts = (typeof currentTurnCorrectionOrOpts === "object"
+        && currentTurnCorrectionOrOpts !== null)
+        ? currentTurnCorrectionOrOpts
+        : opts;
+    const normalizedCorrection = normalizeCurrentTurnCorrection(currentTurnCorrection);
+    const resolvedActivePolicy = resolveRuntimeActivePolicy(activePolicy, normalizedCorrection);
+    const throngletsOptions = resolvedOpts.thronglets || currentGoal || resolvedActivePolicy?.length || normalizedCorrection
         ? {
-            ...(opts.thronglets ?? {}),
-            goal: currentGoal ?? opts.thronglets?.goal,
-            activePolicy: activePolicy ?? opts.thronglets?.activePolicy,
+            ...(resolvedOpts.thronglets ?? {}),
+            goal: currentGoal ?? resolvedOpts.thronglets?.goal,
+            activePolicy: resolvedActivePolicy ?? resolvedOpts.thronglets?.activePolicy,
+            currentTurnCorrection: normalizedCorrection ?? resolvedOpts.thronglets?.currentTurnCorrection,
         }
         : undefined;
     return resolveAmbientPriorsForTurn(text, {
         explicit,
-        enabled: opts.mode !== "off",
+        enabled: resolvedOpts.mode !== "off",
+        currentGoal,
+        currentTurnCorrection: normalizedCorrection,
+        activePolicy: resolvedActivePolicy,
         thronglets: throngletsOptions,
-        fetcher: opts.fetcher ?? fetchAmbientPriorsFromThronglets,
+        fetcher: resolvedOpts.fetcher ?? fetchAmbientPriorsFromThronglets,
     });
 }
 // ── MCP Server ─────────────────────────────────────────────
@@ -212,15 +226,18 @@ server.tool("process_input", "Process user input through the emotional engine. R
         scope: z.enum(["task", "project"]),
         summary: z.string(),
     })).optional().describe("Optional explicit current-turn method policy view. Runtime-only; not persisted as self-state."),
-}, async ({ text, userId, ambientPriors, currentGoal, activePolicy }) => {
+    currentTurnCorrection: z.string().optional().describe("Optional explicit current-turn correction. Compiles into a task-scoped hard policy for this turn only."),
+}, async ({ text, userId, ambientPriors, currentGoal, activePolicy, currentTurnCorrection }) => {
     const eng = await getEngine();
-    const resolvedAmbientPriors = await resolveRuntimeAmbientPriors(text, ambientPriors, currentGoal, activePolicy);
-    const result = await eng.processInput(text, {
+    const resolvedActivePolicy = resolveRuntimeActivePolicy(activePolicy, currentTurnCorrection);
+    const resolvedAmbientPriors = await resolveRuntimeAmbientPriors(text, ambientPriors, currentGoal, resolvedActivePolicy, currentTurnCorrection);
+    const result = await safeProcessInput(eng, text, {
         userId,
         ambientPriors: resolvedAmbientPriors,
         currentGoal,
-        activePolicy,
-    });
+        activePolicy: resolvedActivePolicy,
+        currentTurnCorrection,
+    }, "mcp.processInput");
     return {
         content: [{
                 type: "text",
@@ -257,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/ambient-runtime.d.ts

@@ -1,4 +1,4 @@
-import type { ActivePolicyRule, AmbientPriorView, CurrentGoal } from "./types.js";
+import { type ActivePolicyRule, type AmbientPriorView, type CurrentGoal } from "./types.js";
 interface CommandResult {
     ok: boolean;
     stdout: string;
@@ -11,6 +11,7 @@ export interface ThrongletsAmbientRuntimeOptions {
     space?: string;
     goal?: CurrentGoal;
     activePolicy?: ActivePolicyRule[];
+    currentTurnCorrection?: string;
     limit?: number;
     timeoutMs?: number;
     runner?: CommandRunner;
@@ -18,7 +19,9 @@ export interface ThrongletsAmbientRuntimeOptions {
 export interface AmbientPriorResolutionOptions {
     explicit?: readonly AmbientPriorView[] | unknown;
     enabled?: boolean;
+    currentGoal?: CurrentGoal;
     activePolicy?: ActivePolicyRule[];
+    currentTurnCorrection?: string;
     thronglets?: ThrongletsAmbientRuntimeOptions;
     fetcher?: typeof fetchAmbientPriorsFromThronglets;
 }

package/dist/ambient-runtime.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { normalizeCurrentTurnCorrection, resolveRuntimeActivePolicy, } from "./types.js";
 import { normalizeAmbientPriors } from "./ambient-priors.js";
 const DEFAULT_AMBIENT_LIMIT = 3;
 const DEFAULT_TIMEOUT_MS = 800;
@@ -64,6 +65,8 @@ export async function fetchAmbientPriorsFromThronglets(text, opts = {}) {
     const limit = Math.max(1, Math.min(5, opts.limit ?? DEFAULT_AMBIENT_LIMIT));
     const timeoutMs = Math.max(100, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
     const runner = opts.runner ?? defaultRunner;
+    const currentTurnCorrection = normalizeCurrentTurnCorrection(opts.currentTurnCorrection);
+    const activePolicy = resolveRuntimeActivePolicy(opts.activePolicy, currentTurnCorrection) ?? [];
     const args = [];
     if (dataDir && dataDir.trim()) {
         args.push("--data-dir", dataDir.trim());
@@ -74,7 +77,8 @@ export async function fetchAmbientPriorsFromThronglets(text, opts = {}) {
         space,
         goal,
         limit,
-        active_policy: opts.activePolicy ?? [],
+        active_policy: activePolicy,
+        current_turn_correction: currentTurnCorrection,
     });
     try {
         const result = await runner(binaryPath, args, payload, timeoutMs);
@@ -99,7 +103,8 @@ export async function resolveAmbientPriorsForTurn(text, opts = {}) {
     const fetcher = opts.fetcher ?? fetchAmbientPriorsFromThronglets;
     const priors = await fetcher(text, {
         ...(opts.thronglets ?? {}),
-        activePolicy: opts.activePolicy ?? opts.thronglets?.activePolicy,
+        activePolicy: resolveRuntimeActivePolicy(opts.activePolicy ?? opts.thronglets?.activePolicy, opts.currentTurnCorrection ?? opts.thronglets?.currentTurnCorrection),
+        currentTurnCorrection: normalizeCurrentTurnCorrection(opts.currentTurnCorrection ?? opts.thronglets?.currentTurnCorrection),
     });
     return priors.length > 0 ? priors : undefined;
 }

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";
@@ -95,18 +95,27 @@ export interface ProcessInputOptions {
     ambientPriors?: AmbientPriorView[];
     currentGoal?: CurrentGoal;
     activePolicy?: ActivePolicyRule[];
+    currentTurnCorrection?: string;
 }
 export interface ProcessOutputResult {
     /** LLM output with <psyche_update> tags stripped */
     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

@@ -11,7 +11,7 @@
 //
 // Orchestrates: self-state, appraisal, prompt, profiles, guards, learning
 // ============================================================
-import { normalizeActivePolicyRules, normalizeCurrentGoal } from "./types.js";
+import { normalizeCurrentGoal, resolveRuntimeActivePolicy } from "./types.js";
 import { DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE, DEFAULT_PERSONHOOD_STATE, DEFAULT_ENERGY_BUDGETS, DEFAULT_TRAIT_DRIFT, DEFAULT_SUBJECT_RESIDUE, DEFAULT_DYADIC_FIELD } from "./types.js";
 import { MemoryStorageAdapter } from "./storage.js";
 import { applyDecay, applyStimulus, applyContagion, clamp, describeEmotionalState } from "./chemistry.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)
@@ -461,7 +462,7 @@ export class PsycheEngine {
         }
         const writebackNote = formatWritebackFeedbackNote(writebackFeedback, locale);
         const ambientPriors = normalizeAmbientPriors(opts?.ambientPriors);
-        const activePolicy = normalizeActivePolicyRules(opts?.activePolicy) ?? [];
+        const activePolicy = resolveRuntimeActivePolicy(opts?.activePolicy, opts?.currentTurnCorrection) ?? [];
         const currentGoal = normalizeCurrentGoal(opts?.currentGoal)
             ?? ambientPriors.find((prior) => prior.goal)?.goal;
         const ambientPriorContext = buildAmbientPriorContext(ambientPriors, locale);
@@ -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/prompt.js

@@ -1094,6 +1094,10 @@ export function buildCompactContext(state, userId, opts) {
         if (unified)
             parts.push(unified);
     }
+    const activePolicyContext = buildActivePolicyContext(opts?.activePolicy, locale);
+    if (activePolicyContext) {
+        parts.push(activePolicyContext);
+    }
     // ── 9. Overlay + channel + writeback ──
     appendCompactOverlaySections(parts, locale, opts);
     if (opts?.channelType) {

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

@@ -593,8 +593,10 @@ export interface ActivePolicyRule {
     scope: ActivePolicyScope;
     summary: string;
 }
+export declare function normalizeCurrentTurnCorrection(value: unknown): string | undefined;
 export declare function normalizeCurrentGoal(value: unknown): CurrentGoal | undefined;
 export declare function normalizeActivePolicyRules(value: unknown, limit?: number): ActivePolicyRule[] | undefined;
+export declare function resolveRuntimeActivePolicy(activePolicy: unknown, currentTurnCorrection?: unknown, limit?: number): ActivePolicyRule[] | undefined;
 export interface AmbientPriorView {
     summary: string;
     confidence: number;

package/dist/types.js

@@ -224,6 +224,12 @@ export const AMBIENT_POLICY_STATES = [
     "method-conflict",
     "stable-path",
 ];
+export function normalizeCurrentTurnCorrection(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const summary = value.trim().replace(/\s+/g, " ");
+    return summary.length > 0 ? summary : undefined;
+}
 export function normalizeCurrentGoal(value) {
     return typeof value === "string" && CURRENT_GOALS.includes(value)
         ? value
@@ -251,6 +257,24 @@ export function normalizeActivePolicyRules(value, limit = 3) {
         .slice(0, Math.max(1, limit));
     return normalized.length > 0 ? normalized : undefined;
 }
+export function resolveRuntimeActivePolicy(activePolicy, currentTurnCorrection, limit = 3) {
+    const explicit = normalizeActivePolicyRules(activePolicy, limit) ?? [];
+    const correction = normalizeCurrentTurnCorrection(currentTurnCorrection);
+    if (!correction)
+        return explicit.length > 0 ? explicit : undefined;
+    const merged = [{
+            id: "task:current-turn-correction",
+            strength: "hard",
+            scope: "task",
+            summary: correction,
+        }];
+    for (const rule of explicit) {
+        if (rule.summary === correction)
+            continue;
+        merged.push(rule);
+    }
+    return merged.slice(0, Math.max(1, limit));
+}
 /** Default empty trait drift state */
 export const DEFAULT_TRAIT_DRIFT = {
     accumulators: {

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

package/package.json

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