psyche-ai 11.8.0 → 11.9.0

package/dist/adapters/claude-sdk.d.ts

@@ -38,7 +38,10 @@ declare function stripPsycheTags(text: string): string;
 export interface ThrongletsSignalPayload {
     kind: "psyche_state";
     agent_id: string;
+    context: string;
     message: string;
+    model: "psyche";
+    session_id: string;
 }
 export interface PsycheClaudeSdkOptions {
     /** User ID for relationship tracking. Default: internal shared bucket (`_default`). */

package/dist/adapters/claude-sdk.js

@@ -182,6 +182,7 @@ export class PsycheClaudeSDK {
                             const ambientPriors = await self.resolveAmbientPriors(userMessage, currentGoal, activePolicy, currentTurnCorrection);
                             const result = await safeProcessInput(self.engine, userMessage, {
                                 userId: self.opts.userId,
+                                sessionId: runtimeContext.sessionId ?? self.lastRuntimeContext.sessionId,
                                 ambientPriors,
                                 currentGoal,
                                 activePolicy,
@@ -212,6 +213,7 @@ export class PsycheClaudeSDK {
     async processResponse(text, opts) {
         const result = await safeProcessOutput(this.engine, text, {
             userId: this.opts.userId,
+            sessionId: this.resolveSessionId(),
             signals: opts?.signals,
             signalConfidence: opts?.signalConfidence,
         }, "claude-sdk.processOutput");
@@ -250,10 +252,14 @@ export class PsycheClaudeSDK {
             return null;
         const state = this.engine.getState();
         const s = state.current;
+        const sessionId = this.resolveSessionId();
         return {
             kind: "psyche_state",
             agent_id: this.resolveAgentId(),
+            context: `psyche:session:${sessionId}:user:${this.opts.userId}`,
             message: `order:${s.order} flow:${s.flow} boundary:${s.boundary} resonance:${s.resonance}`,
+            model: "psyche",
+            session_id: sessionId,
         };
     }
     /**

package/dist/adapters/mcp.d.ts

@@ -1,5 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { PsycheEngine } from "../core.js";
+import type { ProcessInputResult } from "../core.js";
 import { fetchAmbientPriorsFromThronglets, type ThrongletsAmbientRuntimeOptions } from "../ambient-runtime.js";
 import { type ActivePolicyRule, type AmbientPriorView, type CurrentGoal } from "../types.js";
 export interface McpAmbientRuntimeOptions {
@@ -7,6 +8,10 @@ export interface McpAmbientRuntimeOptions {
     thronglets?: ThrongletsAmbientRuntimeOptions;
     fetcher?: typeof fetchAmbientPriorsFromThronglets;
 }
+export declare function resolveMcpTurnCacheSession(sessionId?: string): string;
+export declare function cacheMcpTurnResult(result: ProcessInputResult, sessionId?: string): void;
+export declare function getCachedMcpTurnResult(sessionId?: string): ProcessInputResult | null;
+export declare function resetMcpTurnCacheForTests(): void;
 declare function getEngine(): Promise<PsycheEngine>;
 export declare function resolveRuntimeAmbientPriors(text: string, explicit?: AmbientPriorView[], currentGoal?: CurrentGoal, activePolicy?: ActivePolicyRule[], currentTurnCorrectionOrOpts?: string | McpAmbientRuntimeOptions, opts?: McpAmbientRuntimeOptions): Promise<AmbientPriorView[] | undefined>;
 declare const server: McpServer;

package/dist/adapters/mcp.js

@@ -96,9 +96,29 @@ function parseCLIArgs() {
     return overrides;
 }
 // ── Turn cache for on-demand resource access ──────────────
-// Single-client assumption: MCP stdio transport serves one host at a time.
-// If this ever becomes multi-client, turn cache must be keyed per session.
-let lastTurnResult = null;
+// Hosts may overlap sessions on one MCP transport, so cache per session key.
+const DEFAULT_TURN_CACHE_SESSION = "__default__";
+const turnResultsBySession = new Map();
+let lastTurnCacheSession = DEFAULT_TURN_CACHE_SESSION;
+export function resolveMcpTurnCacheSession(sessionId) {
+    const normalized = sessionId?.trim();
+    return normalized ? normalized : DEFAULT_TURN_CACHE_SESSION;
+}
+export function cacheMcpTurnResult(result, sessionId) {
+    const key = resolveMcpTurnCacheSession(sessionId);
+    turnResultsBySession.set(key, result);
+    lastTurnCacheSession = key;
+}
+export function getCachedMcpTurnResult(sessionId) {
+    if (sessionId) {
+        return turnResultsBySession.get(resolveMcpTurnCacheSession(sessionId)) ?? null;
+    }
+    return turnResultsBySession.get(lastTurnCacheSession) ?? null;
+}
+export function resetMcpTurnCacheForTests() {
+    turnResultsBySession.clear();
+    lastTurnCacheSession = DEFAULT_TURN_CACHE_SESSION;
+}
 // ── Engine singleton ───────────────────────────────────────
 let engine = null;
 async function getEngine() {
@@ -208,14 +228,17 @@ server.resource("state", "psyche://state", {
             }],
     };
 });
-// Helper: register a turn-scoped resource backed by lastTurnResult.
+// Helper: register a turn-scoped resource backed by the per-session turn cache.
 // Returns empty JSON when no turn has been processed yet (fail-open).
 function turnResource(name, uri, description, pick) {
     server.resource(name, uri, { description, mimeType: "application/json" }, async (u) => ({
         contents: [{
                 uri: u.href,
                 mimeType: "application/json",
-                text: lastTurnResult ? JSON.stringify(pick(lastTurnResult)) : "{}",
+                text: (() => {
+                    const cached = getCachedMcpTurnResult(u.searchParams.get("session") ?? undefined);
+                    return cached ? JSON.stringify(pick(cached)) : "{}";
+                })(),
             }],
     }));
 }
@@ -245,6 +268,7 @@ server.tool("process_input", "Process user input through the emotional engine. R
     "Call this BEFORE generating a response to the user.", {
     text: z.string().describe("The user's message text"),
     userId: z.string().optional().describe("Optional user ID for multi-user relationship tracking"),
+    sessionId: z.string().optional().describe("Optional session ID for overlapping host sessions and turn-scoped resource lookup"),
     ambientPriors: z.array(z.object({
         summary: z.string(),
         confidence: z.number().min(0).max(1),
@@ -262,19 +286,20 @@ server.tool("process_input", "Process user input through the emotional engine. R
         summary: z.string(),
     })).optional().describe("Optional explicit current-turn method policy view. Runtime-only; not persisted as self-state."),
     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 }) => {
+}, async ({ text, userId, sessionId, ambientPriors, currentGoal, activePolicy, currentTurnCorrection }) => {
     const eng = await getEngine();
     const resolvedActivePolicy = resolveRuntimeActivePolicy(activePolicy, currentTurnCorrection);
     const resolvedAmbientPriors = await resolveRuntimeAmbientPriors(text, ambientPriors, currentGoal, resolvedActivePolicy, currentTurnCorrection);
     const result = await safeProcessInput(eng, text, {
         userId,
+        sessionId,
         ambientPriors: resolvedAmbientPriors,
         currentGoal,
         activePolicy: resolvedActivePolicy,
         currentTurnCorrection,
     }, "mcp.processInput");
     // Cache full result for turn-scoped resources
-    lastTurnResult = result;
+    cacheMcpTurnResult(result, sessionId);
     // Build slim response: only what the LLM host actually needs.
     // Full structured state available via psyche://turn/envelope resource.
     const slim = {
@@ -302,18 +327,20 @@ server.tool("process_output", "Process the LLM's response through the emotional
     "emotional contagion. Call this AFTER generating a response.", {
     text: z.string().describe("The LLM's response text"),
     userId: z.string().optional().describe("Optional user ID"),
+    sessionId: z.string().optional().describe("Optional session ID to match the corresponding process_input turn"),
     signals: z.array(z.string()).optional().describe("Optional sparse writeback signals from the host"),
     signalConfidence: z.number().min(0).max(1).optional().describe("Optional confidence for the supplied signals"),
-}, async ({ text, userId, signals, signalConfidence }) => {
+}, async ({ text, userId, sessionId, signals, signalConfidence }) => {
     const eng = await getEngine();
+    const turnResult = getCachedMcpTurnResult(sessionId);
     // LLM-specific alignment inference (adapter layer — the ONLY text-specific code).
     // Compare output length against last contract's maxChars to detect divergence.
     let outcome;
-    if (lastTurnResult?.responseContract) {
-        const maxLen = (lastTurnResult.responseContract.maxChars ?? 500) * 2;
+    if (turnResult?.responseContract) {
+        const maxLen = (turnResult.responseContract.maxChars ?? 500) * 2;
         outcome = { alignment: text.length > maxLen ? "diverged" : "aligned" };
     }
-    const result = await safeProcessOutput(eng, text, { userId, signals: signals, signalConfidence, outcome }, "mcp.processOutput");
+    const result = await safeProcessOutput(eng, text, { userId, sessionId, signals: signals, signalConfidence, outcome }, "mcp.processOutput");
     return {
         content: [{
                 type: "text",
@@ -342,7 +369,7 @@ server.tool("get_state", "Get the current emotional state — self-state dimensi
                     overlay,
                     drives: state.drives,
                     mbti: state.mbti,
-                    mode: state.meta?.mode,
+                    mode: eng.getMode(),
                     totalInteractions: state.meta?.totalInteractions,
                     traitDrift: state.traitDrift,
                     energyBudgets: state.energyBudgets,
@@ -356,12 +383,7 @@ server.tool("set_mode", "Switch operating mode. 'natural' = balanced emotional e
     mode: z.enum(["natural", "work", "companion"]).describe("Operating mode"),
 }, async ({ mode }) => {
     const eng = await getEngine();
-    // PsycheEngine stores mode in config, we need to reinitialize
-    // For now, update via state manipulation
-    const state = eng.getState();
-    if (state.meta) {
-        state.meta.mode = mode;
-    }
+    await eng.setMode(mode);
     return {
         content: [{
                 type: "text",

package/dist/adapters/openclaw.js

@@ -12,6 +12,8 @@ import { PsycheEngine } from "../core.js";
 import { FileStorageAdapter, MemoryStorageAdapter } from "../storage.js";
 import { detectMBTI, extractAgentName, loadState } from "../psyche-file.js";
 import { resolveAmbientPriorsForTurn } from "../ambient-runtime.js";
+import { buildResponseContractContext } from "../response-contract.js";
+import { resolveCanonicalResponseContract, renderOpenClawBehavioralSurface, } from "./response-contract-surface.js";
 function isPsycheMode(value) {
     return value === "natural" || value === "work" || value === "companion";
 }
@@ -178,6 +180,8 @@ export function register(api) {
                 userId: ctx.userId,
                 ambientPriors: ambientPriors ?? [],
             });
+            const responseContract = resolveCanonicalResponseContract(result);
+            const locale = (engine.getState().meta.locale ?? "zh");
             const controls = result.replyEnvelope?.generationControls ?? result.generationControls;
             const dominantAppraisal = getDominantAppraisalLabel(result);
             const state = engine.getState();
@@ -192,6 +196,12 @@ export function register(api) {
                 (controls?.maxTokens ? ` | out<=${controls.maxTokens}t` : "") +
                 (controls?.requireConfirmation ? " | confirm" : ""));
             const systemParts = [result.systemContext, result.dynamicContext].filter(Boolean);
+            if (responseContract) {
+                const responseSurface = buildResponseContractContext(responseContract, locale);
+                if (!result.dynamicContext.includes(responseSurface)) {
+                    systemParts.push(renderOpenClawBehavioralSurface(responseContract, locale));
+                }
+            }
             return {
                 appendSystemContext: systemParts.join("\n\n"),
             };

package/dist/adapters/proxy.js

@@ -21,7 +21,8 @@
 import { createServer } from "node:http";
 import { PsycheEngine } from "../core.js";
 import { MemoryStorageAdapter, FileStorageAdapter } from "../storage.js";
-import { isNearBaseline, deriveBehavioralBias } from "../prompt.js";
+import { isNearBaseline } from "../prompt.js";
+import { resolveCanonicalResponseContract, renderProxyBehavioralSurface, } from "./response-contract-surface.js";
 // ── Helpers ─────────────────────────────────────────────────
 function readBody(req) {
     return new Promise((resolve, reject) => {
@@ -112,18 +113,17 @@ export function createPsycheProxy(engine, opts) {
             const parsed = JSON.parse(rawBody.toString("utf-8"));
             const userMsg = lastUserMessage(parsed.messages);
             const userId = parsed.user ?? undefined;
+            let messages = parsed.messages;
             // ── 1. Observe input ────────────────────────────
+            let result = null;
             if (userMsg) {
-                await engine.processInput(userMsg, { userId });
+                result = await engine.processInput(userMsg, { userId });
             }
             // ── 2. Inject behavioral bias (silent when near baseline) ──
             const state = engine.getState();
-            let messages = parsed.messages;
-            if (!isNearBaseline(state)) {
-                const bias = deriveBehavioralBias(state, locale);
-                if (bias) {
-                    messages = injectBias(parsed.messages, bias);
-                }
+            const responseContract = result ? resolveCanonicalResponseContract(result) : null;
+            if (responseContract && !isNearBaseline(state)) {
+                messages = injectBias(parsed.messages, renderProxyBehavioralSurface(responseContract, locale));
             }
             const modifiedBody = JSON.stringify({ ...parsed, messages });
             const headers = forwardHeaders(req);

package/dist/adapters/response-contract-surface.d.ts

@@ -0,0 +1,5 @@
+import type { ProcessInputResult } from "../core.js";
+import type { Locale, ResponseContract } from "../types.js";
+export declare function resolveCanonicalResponseContract(result: Pick<ProcessInputResult, "replyEnvelope" | "responseContract">): ResponseContract | null;
+export declare function renderProxyBehavioralSurface(contract: ResponseContract, locale: Locale): string;
+export declare function renderOpenClawBehavioralSurface(contract: ResponseContract, locale: Locale): string;

package/dist/adapters/response-contract-surface.js

@@ -0,0 +1,16 @@
+import { buildResponseContractContext } from "../response-contract.js";
+export function resolveCanonicalResponseContract(result) {
+    return result.replyEnvelope?.responseContract ?? result.responseContract ?? null;
+}
+export function renderProxyBehavioralSurface(contract, locale) {
+    const context = buildResponseContractContext(contract, locale);
+    return locale === "zh"
+        ? `[代理行为契约]\n${context}`
+        : `[Proxy Behavioral Contract]\n${context}`;
+}
+export function renderOpenClawBehavioralSurface(contract, locale) {
+    const context = buildResponseContractContext(contract, locale);
+    return locale === "zh"
+        ? `[OpenClaw 行为契约]\n${context}`
+        : `[OpenClaw Behavioral Contract]\n${context}`;
+}

package/dist/core.d.ts

@@ -95,6 +95,7 @@ export interface ProcessInputResult {
 }
 export interface ProcessInputOptions {
     userId?: string;
+    sessionId?: string;
     ambientPriors?: AmbientPriorView[];
     currentGoal?: CurrentGoal;
     activePolicy?: ActivePolicyRule[];
@@ -121,6 +122,7 @@ export interface LoopOutcome {
 }
 export interface ProcessOutputOptions {
     userId?: string;
+    sessionId?: string;
     signals?: readonly string[];
     signalConfidence?: number;
     /** Substrate-reported outcome — closes the φ loop */
@@ -145,11 +147,14 @@ export declare class PsycheEngine {
     private _lastAlgorithmApplied;
     private readonly traits;
     private readonly cfg;
+    private readonly modeOverride?;
     private readonly classifier;
     private readonly llmClassifier?;
     private readonly protocolCache;
-    /** Pending prediction from last processInput for auto-learning */
-    private pendingPrediction;
+    /** Pending predictions keyed by relationship/session scope for auto-learning */
+    private readonly pendingPredictions;
+    /** Most recent response contract keyed by relationship/session scope for implicit loop closure */
+    private readonly pendingResponseContracts;
     /** Built-in diagnostics collector — auto-records every processInput/processOutput */
     private readonly diagnosticCollector;
     /** Last generated diagnostic report (from endSession or explicit call) */
@@ -190,8 +195,9 @@ export declare class PsycheEngine {
      * @param nextUserStimulus - The stimulus detected in the user's next message,
      *   or null if the session ended.
      */
-    processOutcome(nextUserStimulus: StimulusType | null, _opts?: {
+    processOutcome(nextUserStimulus: StimulusType | null, opts?: {
         userId?: string;
+        sessionId?: string;
     }): Promise<ProcessOutcomeResult | null>;
     /**
      * Get the current psyche state (read-only snapshot).
@@ -215,6 +221,8 @@ export declare class PsycheEngine {
      * Get the last diagnostic report (from most recent endSession call).
      */
     getLastDiagnosticReport(): DiagnosticReport | null;
+    getMode(): PsycheMode;
+    setMode(mode: PsycheMode): Promise<void>;
     /**
      * Get current session diagnostic metrics (live, before endSession).
      */
@@ -229,6 +237,9 @@ export declare class PsycheEngine {
      */
     getPreviousIssues(): Promise<string[]>;
     private ensureInitialized;
+    private resolveMode;
+    private resolvePendingPredictionKey;
+    private inferLoopOutcome;
     private createDefaultState;
     /**
      * Reset state to baseline. Optionally preserves relationships.

package/dist/core.js

@@ -30,7 +30,7 @@ import { computeCircadianModulation, computeHomeostaticPressure, computeEnergyDe
 import { runReflectiveTurnPhases } from "./input-turn.js";
 import { applyRelationalTurn, applySessionBridge, applyWritebackSignals, createWritebackCalibrations, evaluateWritebackCalibrations } from "./relation-dynamics.js";
 import { buildExternalContinuityEnvelope } from "./external-continuity.js";
-import { deriveThrongletsExports } from "./thronglets-export.js";
+import { deriveThrongletsExports, markThrongletsExportsEmitted } 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";
@@ -132,11 +132,14 @@ export class PsycheEngine {
     _lastAlgorithmApplied = false;
     traits;
     cfg;
+    modeOverride;
     classifier;
     llmClassifier;
     protocolCache = new Map();
-    /** Pending prediction from last processInput for auto-learning */
-    pendingPrediction = null;
+    /** Pending predictions keyed by relationship/session scope for auto-learning */
+    pendingPredictions = new Map();
+    /** Most recent response contract keyed by relationship/session scope for implicit loop closure */
+    pendingResponseContracts = new Map();
     /** Built-in diagnostics collector — auto-records every processInput/processOutput */
     diagnosticCollector;
     /** Last generated diagnostic report (from endSession or explicit call) */
@@ -155,6 +158,7 @@ export class PsycheEngine {
         this.traits = config.traits;
         this.classifier = config.classifier ?? new BuiltInClassifier();
         this.llmClassifier = config.llmClassifier;
+        this.modeOverride = config.mode;
         this.cfg = {
             mbti: config.mbti ?? "INFJ",
             name: config.name ?? "agent",
@@ -239,6 +243,15 @@ export class PsycheEngine {
             if (!loaded.lastWritebackFeedback) {
                 loaded.lastWritebackFeedback = [];
             }
+            if (this.modeOverride) {
+                loaded.meta = { ...loaded.meta, mode: this.modeOverride };
+            }
+            else if (loaded.meta.mode) {
+                this.cfg.mode = loaded.meta.mode;
+            }
+            else {
+                loaded.meta = { ...loaded.meta, mode: this.cfg.mode };
+            }
             // Update sigilId if config provides one (Sigil may be assigned after first run)
             if (this.cfg.sigilId && loaded.meta.sigilId !== this.cfg.sigilId) {
                 loaded.meta = { ...loaded.meta, sigilId: this.cfg.sigilId };
@@ -262,31 +275,34 @@ export class PsycheEngine {
         let sessionBridge = null;
         let writebackFeedback = [];
         let throngletsExports = [];
+        const now = new Date();
+        const runtimeMode = this.resolveMode(state);
+        const pendingKey = this.resolvePendingPredictionKey(opts);
         // ── Auto-learning: evaluate previous turn's outcome ──────
-        if (this.pendingPrediction && text.length > 0) {
+        const pendingPrediction = this.pendingPredictions.get(pendingKey);
+        if (pendingPrediction && text.length > 0) {
             const nextClassifications = classifyLegacyStimulus(text);
             const nextStimulus = (nextClassifications[0]?.confidence ?? 0) >= 0.5
                 ? nextClassifications[0].type
                 : null;
-            const outcome = evaluateOutcome(this.pendingPrediction.preInteractionState, state, nextStimulus, this.pendingPrediction.appliedStimulus);
+            const outcome = evaluateOutcome(pendingPrediction.preInteractionState, state, nextStimulus, pendingPrediction.appliedStimulus, pendingPrediction.userId);
             // Record prediction accuracy
             state = {
                 ...state,
-                learning: recordPrediction(state.learning, this.pendingPrediction.predictedState, state.current, this.pendingPrediction.appliedStimulus),
+                learning: recordPrediction(state.learning, pendingPrediction.predictedState, state.current, pendingPrediction.appliedStimulus),
             };
             // Update learned vectors based on outcome
-            if (this.pendingPrediction.appliedStimulus) {
+            if (pendingPrediction.appliedStimulus) {
                 state = {
                     ...state,
-                    learning: updateLearnedVector(state.learning, this.pendingPrediction.appliedStimulus, this.pendingPrediction.contextHash, outcome.adaptiveScore, state.current, state.baseline),
+                    learning: updateLearnedVector(state.learning, pendingPrediction.appliedStimulus, pendingPrediction.contextHash, outcome.adaptiveScore, state.current, state.baseline),
                 };
             }
-            this.pendingPrediction = null;
+            this.pendingPredictions.delete(pendingKey);
         }
         // ── Snapshot pre-interaction state for next turn's outcome evaluation
         const preInteractionState = { ...state };
         // Time decay toward baseline (chemistry + drives)
-        const now = new Date();
         const minutesElapsed = (now.getTime() - new Date(state.updatedAt).getTime()) / 60000;
         if (minutesElapsed >= 1) {
             // Compute effective baseline from current 4D position (drives are derived, not stored)
@@ -311,15 +327,24 @@ export class PsycheEngine {
         }
         // Apply homeostatic pressure (fatigue from extended sessions)
         const sessionMinutes = (now.getTime() - new Date(state.sessionStartedAt).getTime()) / 60000;
+        const previousSessionMinutes = Math.max(0, sessionMinutes - Math.max(minutesElapsed, 0));
         const pressure = computeHomeostaticPressure(sessionMinutes);
-        if (pressure.orderDepletion > 0 || pressure.flowDepletion > 0 || pressure.boundaryStiffening > 0) {
+        const previousPressure = computeHomeostaticPressure(previousSessionMinutes);
+        const incrementalPressure = {
+            orderDepletion: Math.max(0, pressure.orderDepletion - previousPressure.orderDepletion),
+            flowDepletion: Math.max(0, pressure.flowDepletion - previousPressure.flowDepletion),
+            boundaryStiffening: Math.max(0, pressure.boundaryStiffening - previousPressure.boundaryStiffening),
+        };
+        if (incrementalPressure.orderDepletion > 0
+            || incrementalPressure.flowDepletion > 0
+            || incrementalPressure.boundaryStiffening > 0) {
             state = {
                 ...state,
                 current: {
                     ...state.current,
-                    order: clamp(state.current.order - pressure.orderDepletion * 0.1),
-                    flow: clamp(state.current.flow - pressure.flowDepletion * 0.1),
-                    boundary: clamp(state.current.boundary + pressure.boundaryStiffening * 0.1),
+                    order: clamp(state.current.order - incrementalPressure.orderDepletion * 0.1),
+                    flow: clamp(state.current.flow - incrementalPressure.flowDepletion * 0.1),
+                    boundary: clamp(state.current.boundary + incrementalPressure.boundaryStiffening * 0.1),
                 },
             };
         }
@@ -365,7 +390,7 @@ export class PsycheEngine {
                 baseline: state.baseline,
                 sensitivity: state.sensitivity ?? 1.0,
                 personalityIntensity: this.cfg.personalityIntensity,
-                mode: this.cfg.mode,
+                mode: runtimeMode,
                 maxDimensionDelta: this.cfg.maxDimensionDelta,
                 drives,
                 previousAppraisal: state.subjectResidue?.axes,
@@ -445,7 +470,7 @@ export class PsycheEngine {
         state = { ...state, energyBudgets };
         // Relational turn uses pre-computed appraisal from perception
         const relationalTurn = applyRelationalTurn(state, text, {
-            mode: this.cfg.mode,
+            mode: runtimeMode,
             now: now.toISOString(),
             stimulus: appliedStimulus,
             userId: opts?.userId,
@@ -479,10 +504,6 @@ export class PsycheEngine {
         });
         state = throngletsExportResult.state;
         throngletsExports = throngletsExportResult.exports;
-        // Constitutive bridge: emit to Thronglets directly (substrate-independent)
-        if (throngletsExports.length > 0) {
-            bridgeThrongletsExports(throngletsExports, this.bridgeOpts).catch(() => { });
-        }
         // ── Locale (used by multiple subsystems below) ──────────
         const locale = state.meta.locale ?? this.cfg.locale;
         // Push snapshot to emotional history
@@ -501,18 +522,20 @@ export class PsycheEngine {
         this._lastAlgorithmApplied = appliedStimulus !== null;
         // ── Generate prediction for next turn's auto-learning ────
         if (appliedStimulus) {
-            const ctxHash = computeContextHash(state, opts?.userId);
+            const ctxHash = computeContextHash(state, opts?.userId, opts?.sessionId);
             const effectiveSensitivity = computeEffectiveSensitivity((state.sensitivity ?? 1.0), state.current, state.baseline, appliedStimulus, state.traitDrift);
             const predicted = predictState(preInteractionState.current, appliedStimulus, state.learning, ctxHash, effectiveSensitivity, this.cfg.maxDimensionDelta);
-            this.pendingPrediction = {
+            this.pendingPredictions.set(pendingKey, {
                 predictedState: predicted,
                 preInteractionState,
                 appliedStimulus,
                 contextHash: ctxHash,
-            };
+                userId: resolveRelationshipUserId(opts?.userId),
+                sessionId: opts?.sessionId?.trim() || undefined,
+            });
         }
         else {
-            this.pendingPrediction = null;
+            this.pendingPredictions.delete(pendingKey);
         }
         const writebackNote = formatWritebackFeedbackNote(writebackFeedback, locale);
         const ambientPriors = normalizeAmbientPriors(opts?.ambientPriors);
@@ -539,6 +562,20 @@ export class PsycheEngine {
         // Persist
         this.state = state;
         await this.storage.save(state);
+        // Constitutive bridge: emit to Thronglets directly (substrate-independent)
+        if (throngletsExports.length > 0) {
+            bridgeThrongletsExports(throngletsExports, {
+                ...this.bridgeOpts,
+                sessionId: opts?.sessionId ?? this.bridgeOpts.sessionId,
+            }).then(async (ingested) => {
+                if (ingested <= 0)
+                    return;
+                const latestState = this.ensureInitialized();
+                const markedState = markThrongletsExportsEmitted(latestState, throngletsExports, new Date().toISOString());
+                this.state = markedState;
+                await this.storage.save(markedState);
+            }).catch(() => { });
+        }
         // Auto-diagnostics: record this input
         if (this.diagnosticCollector) {
             this.diagnosticCollector.recordInput(appliedStimulus, appliedStimulus ? 1.0 : 0.0, state.current, appraisalAxes);
@@ -585,6 +622,7 @@ export class PsycheEngine {
         });
         // v10: compact mode is always on. Legacy buildDynamicContext removed from engine path.
         const externalContinuity = buildExternalContinuityEnvelope(throngletsExports);
+        this.pendingResponseContracts.set(pendingKey, replyEnvelope.responseContract);
         return {
             systemContext: "",
             dynamicContext: buildCompactContext(state, opts?.userId, promptRenderInputs),
@@ -620,6 +658,7 @@ export class PsycheEngine {
         let state = this.ensureInitialized();
         let stateChanged = false;
         const validationIssues = [];
+        const pendingKey = this.resolvePendingPredictionKey(opts);
         // Emotional contagion from empathy log
         if (state.empathyLog?.userState && this.cfg.emotionalContagionRate > 0) {
             const userEmotion = state.empathyLog.userState.toLowerCase();
@@ -669,8 +708,9 @@ export class PsycheEngine {
         // Loop outcome feedback (substrate-independent φ closure).
         // The substrate reports whether the output aligned with the Loop's intention.
         // Core processes this as pure 4D chemistry — no text parsing, no medium assumptions.
-        if (opts?.outcome) {
-            const { alignment, effort } = opts.outcome;
+        const outcome = opts?.outcome ?? this.inferLoopOutcome(text, pendingKey);
+        if (outcome) {
+            const { alignment, effort } = outcome;
             if (alignment === "diverged") {
                 // Self/non-self conflict: boundary sharpens, order drops
                 state = {
@@ -813,13 +853,14 @@ export class PsycheEngine {
      * @param nextUserStimulus - The stimulus detected in the user's next message,
      *   or null if the session ended.
      */
-    async processOutcome(nextUserStimulus, _opts) {
-        if (!this.pendingPrediction)
-            return null;
+    async processOutcome(nextUserStimulus, opts) {
         let state = this.ensureInitialized();
-        const pending = this.pendingPrediction;
-        this.pendingPrediction = null;
-        const outcome = evaluateOutcome(pending.preInteractionState, state, nextUserStimulus, pending.appliedStimulus);
+        const pendingKey = this.resolvePendingPredictionKey(opts);
+        const pending = this.pendingPredictions.get(pendingKey);
+        if (!pending)
+            return null;
+        this.pendingPredictions.delete(pendingKey);
+        const outcome = evaluateOutcome(pending.preInteractionState, state, nextUserStimulus, pending.appliedStimulus, pending.userId);
         // Record prediction
         state = {
             ...state,
@@ -900,6 +941,21 @@ export class PsycheEngine {
     getLastDiagnosticReport() {
         return this.lastReport;
     }
+    getMode() {
+        return this.resolveMode(this.ensureInitialized());
+    }
+    async setMode(mode) {
+        const state = this.ensureInitialized();
+        this.cfg.mode = mode;
+        this.state = {
+            ...state,
+            meta: {
+                ...state.meta,
+                mode,
+            },
+        };
+        await this.storage.save(this.state);
+    }
     /**
      * Get current session diagnostic metrics (live, before endSession).
      */
@@ -937,6 +993,27 @@ export class PsycheEngine {
         }
         return this.state;
     }
+    resolveMode(state) {
+        const mode = state.meta.mode;
+        if (mode) {
+            this.cfg.mode = mode;
+            return mode;
+        }
+        return this.cfg.mode;
+    }
+    resolvePendingPredictionKey(opts) {
+        const userKey = resolveRelationshipUserId(opts?.userId);
+        const sessionId = opts?.sessionId?.trim();
+        return sessionId ? `${userKey}::${sessionId}` : userKey;
+    }
+    inferLoopOutcome(text, pendingKey) {
+        const contract = this.pendingResponseContracts.get(pendingKey);
+        this.pendingResponseContracts.delete(pendingKey);
+        if (!contract)
+            return undefined;
+        const maxLen = (contract.maxChars ?? 500) * 2;
+        return { alignment: text.length > maxLen ? "diverged" : "aligned" };
+    }
     createDefaultState() {
         const { mbti, name, locale } = this.cfg;
         // Use Big Five traits if provided, otherwise use preset baseline

package/dist/learning.d.ts

@@ -5,7 +5,7 @@ import type { PsycheState, StimulusType, SelfState, ImpactVector, LearningState,
  * Computes a score from -1 to 1 using multiple signals:
  * drive changes, relationship changes, user warmth, conversation continuation.
  */
-export declare function evaluateOutcome(prevState: PsycheState, currentState: PsycheState, nextUserStimulus: StimulusType | null, appliedStimulus: StimulusType | null): OutcomeScore;
+export declare function evaluateOutcome(prevState: PsycheState, currentState: PsycheState, nextUserStimulus: StimulusType | null, appliedStimulus: StimulusType | null, userId?: string): OutcomeScore;
 /**
  * Get the effective compatibility vector for a given stimulus + context,
  * combining the base vector with any learned adjustment.
@@ -32,7 +32,7 @@ export declare function updateLearnedVector(learning: LearningState, stimulus: S
  *
  * Example: "familiar:approach,task,task:hmlhh"
  */
-export declare function computeContextHash(state: PsycheState, _userId?: string): string;
+export declare function computeContextHash(state: PsycheState, userId?: string, sessionId?: string): string;
 /**
  * Predict the resulting chemistry after applying a stimulus,
  * using learned vectors instead of raw base vectors.

package/dist/learning.js

@@ -14,6 +14,7 @@
 import { DIMENSION_KEYS, DRIVE_KEYS, MAX_LEARNED_VECTORS, MAX_PREDICTION_HISTORY, } from "./types.js";
 import { STIMULUS_VECTORS, clamp } from "./chemistry.js";
 import { derivePrimarySnapshotMarker, markerFromLegacyStimulus, } from "./appraisal-markers.js";
+import { resolveRelationshipUserId } from "./relationship-key.js";
 // ── 1. OutcomeEvaluator ─────────────────────────────────────
 /** Warmth mapping for appraisal residue. */
 const MARKER_WARMTH_MAP = {
@@ -39,9 +40,10 @@ function matchesLearningEntry(entry, stimulus, marker, contextHash) {
  * Computes a score from -1 to 1 using multiple signals:
  * drive changes, relationship changes, user warmth, conversation continuation.
  */
-export function evaluateOutcome(prevState, currentState, nextUserStimulus, appliedStimulus) {
+export function evaluateOutcome(prevState, currentState, nextUserStimulus, appliedStimulus, userId) {
     const nextUserMarker = learningMarkerFromStimulus(nextUserStimulus);
     const appliedMarker = learningMarkerFromStimulus(appliedStimulus);
+    const relationKey = resolveRelationshipUserId(userId);
     // Drive delta: sum of all drive changes, normalized
     let driveSum = 0;
     for (const key of DRIVE_KEYS) {
@@ -49,8 +51,8 @@ export function evaluateOutcome(prevState, currentState, nextUserStimulus, appli
     }
     const driveDelta = Math.max(-1, Math.min(1, driveSum / 50));
     // Relationship delta: change in trust + intimacy of _default relationship
-    const prevRel = prevState.relationships._default ?? { trust: 50, intimacy: 30 };
-    const curRel = currentState.relationships._default ?? { trust: 50, intimacy: 30 };
+    const prevRel = prevState.relationships[relationKey] ?? { trust: 50, intimacy: 30 };
+    const curRel = currentState.relationships[relationKey] ?? { trust: 50, intimacy: 30 };
     const relChange = (curRel.trust - prevRel.trust) + (curRel.intimacy - prevRel.intimacy);
     const relationshipDelta = Math.max(-1, Math.min(1, relChange / 20));
     // User warmth: what residue their next turn carried
@@ -193,9 +195,10 @@ export function updateLearnedVector(learning, stimulus, contextHash, outcomeScor
  *
  * Example: "familiar:approach,task,task:hmlhh"
  */
-export function computeContextHash(state, _userId) {
+export function computeContextHash(state, userId, sessionId) {
     // Relationship phase
-    const rel = state.relationships._default ?? { phase: "stranger" };
+    const relationKey = resolveRelationshipUserId(userId);
+    const rel = state.relationships[relationKey] ?? { phase: "stranger" };
     const phase = rel.phase;
     // Last 3 canonical residues from emotional history
     const history = state.stateHistory ?? [];
@@ -217,7 +220,10 @@ export function computeContextHash(state, _userId) {
     // Format: separate safety from the rest for readability
     // survival_safety_connection_esteem_curiosity
     const driveStr = driveLevels.join("");
-    return `${phase}:${recentMarkers || "none"}:${driveStr}`;
+    const scope = sessionId?.trim();
+    return scope
+        ? `${phase}:${recentMarkers || "none"}:${driveStr}:session=${scope}`
+        : `${phase}:${recentMarkers || "none"}:${driveStr}`;
 }
 // ── 3. PredictionEngine ─────────────────────────────────────
 /**

package/dist/thronglets-export.d.ts

@@ -1,4 +1,5 @@
 import type { PsycheState, ResolvedRelationContext, SessionBridgeState, ThrongletsExport, WritebackCalibrationFeedback } from "./types.js";
+export declare function markThrongletsExportsEmitted(state: PsycheState, exports: ThrongletsExport[], now: string): PsycheState;
 export declare function deriveThrongletsExports(state: PsycheState, opts: {
     relationContext: ResolvedRelationContext;
     sessionBridge?: SessionBridgeState | null;

package/dist/thronglets-export.js

@@ -5,6 +5,8 @@
 // The goal is to surface only sparse, typed, low-frequency events
 // that are worth handing to an external continuity substrate.
 // ============================================================
+import { DRIVE_KEYS } from "./types.js";
+import { deriveDriveSatisfaction, hasCriticalDrive } from "./drives.js";
 function clamp01(v) {
     return Math.max(0, Math.min(1, v));
 }
@@ -45,6 +47,11 @@ function updateExportState(state, keys, now) {
         throngletsExportState: nextState,
     };
 }
+export function markThrongletsExportsEmitted(state, exports, now) {
+    if (exports.length === 0)
+        return state;
+    return updateExportState(state, exports.map((event) => event.key), now);
+}
 function quantize(v, step = 10) {
     return Math.round(v / step) * step;
 }
@@ -148,6 +155,23 @@ function sanitizeThrongletsExport(event) {
             };
             return sanitized;
         }
+        case "viability": {
+            // Viability stays a sparse export, but its meaning is defined by the
+            // protocol-layer dimension registry. Keep the kind/payload stable here.
+            const sanitized = {
+                kind: "viability",
+                subject: "session",
+                primitive: "signal",
+                userKey: event.userKey,
+                strength: event.strength,
+                ttlTurns: event.ttlTurns,
+                key: event.key,
+                viable: event.viable,
+                minDrive: event.minDrive,
+                minDriveType: event.minDriveType,
+            };
+            return sanitized;
+        }
     }
 }
 export function deriveThrongletsExports(state, opts) {
@@ -220,6 +244,27 @@ export function deriveThrongletsExports(state, opts) {
         order, flow, boundary, resonance,
         summary: selfStateSummary(order, flow, boundary, resonance),
     });
+    // Viability — Psyche's self-assessment of aliveness for field pulse
+    if (state.baseline) {
+        const drives = deriveDriveSatisfaction(state.current, state.baseline);
+        const driveEntries = DRIVE_KEYS.map((k) => ({ type: k, value: drives[k] }));
+        const min = driveEntries.reduce((a, b) => (a.value < b.value ? a : b));
+        const viable = !hasCriticalDrive(drives);
+        const driveBucket = Math.round(min.value / 10) * 10;
+        const viabilityKey = `viability:${viable ? "viable" : "critical"}:${min.type}:${driveBucket}`;
+        candidates.push({
+            kind: "viability",
+            subject: "session",
+            primitive: "signal",
+            userKey,
+            strength: viable ? 0.5 : 0.9,
+            ttlTurns: 12,
+            key: viabilityKey,
+            viable,
+            minDrive: min.value,
+            minDriveType: min.type,
+        });
+    }
     for (const feedback of writebackFeedback) {
         if (feedback.effect === "holding")
             continue;
@@ -249,6 +294,5 @@ export function deriveThrongletsExports(state, opts) {
     const exports = deduped
         .filter((event) => !previousKeys.includes(event.key))
         .map((event) => sanitizeThrongletsExport(event));
-    const nextState = updateExportState(state, deduped.map((event) => event.key), now);
-    return { state: nextState, exports };
+    return { state, exports };
 }

package/dist/thronglets-runtime.js

@@ -3,7 +3,8 @@ const TAXONOMY_BY_EVENT = {
     "open-loop-anchor": "coordination",
     "continuity-anchor": "continuity",
     "writeback-calibration": "calibration",
-    "self-state": "state",
+    "self-state": "calibration",
+    "viability": "calibration",
 };
 function summarizeLoopTypes(loopTypes) {
     return loopTypes.join(", ");
@@ -22,6 +23,8 @@ function summarizeThrongletsExport(event) {
         }
         case "self-state":
             return event.summary;
+        case "viability":
+            return `viability: ${event.viable ? "viable" : "critical"} (min drive: ${event.minDriveType} at ${Math.round(event.minDrive)})`;
     }
 }
 export function taxonomyForThrongletsExport(event) {

package/dist/types.d.ts

@@ -611,7 +611,7 @@ export interface AmbientPriorView {
 export type ThrongletsExportSubject = "delegate" | "session";
 export type ThrongletsExportPrimitive = "signal" | "trace";
 export interface ThrongletsExportBase {
-    kind: "relation-milestone" | "open-loop-anchor" | "writeback-calibration" | "continuity-anchor" | "self-state";
+    kind: "relation-milestone" | "open-loop-anchor" | "writeback-calibration" | "continuity-anchor" | "self-state" | "viability";
     subject: ThrongletsExportSubject;
     primitive: ThrongletsExportPrimitive;
     userKey: string;
@@ -662,7 +662,15 @@ export interface SelfStateExport extends ThrongletsExportBase {
     resonance: number;
     summary: string;
 }
-export type ThrongletsExport = RelationMilestoneExport | OpenLoopAnchorExport | WritebackCalibrationExport | ContinuityAnchorExport | SelfStateExport;
+export interface ViabilityExport extends ThrongletsExportBase {
+    kind: "viability";
+    subject: "session";
+    primitive: "signal";
+    viable: boolean;
+    minDrive: number;
+    minDriveType: DriveType;
+}
+export type ThrongletsExport = RelationMilestoneExport | OpenLoopAnchorExport | WritebackCalibrationExport | ContinuityAnchorExport | SelfStateExport | ViabilityExport;
 export interface ThrongletsExportState {
     lastKeys: string[];
     lastAt: string;

package/package.json

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

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/Shangri-la-0428/oasyce_psyche",
     "source": "github"
   },
-  "version": "11.8.0",
+  "version": "11.9.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "psyche-ai",
-      "version": "11.8.0",
+      "version": "11.9.0",
       "transport": {
         "type": "stdio"
       },