psyche-ai 11.7.0 → 11.9.0

package/README.md

@@ -19,9 +19,39 @@ Psyche 不是给模型贴一层“情绪 UI”。
 
 默认就是 standalone：不需要 `Thronglets`，不需要 `oasyce-sdk`，也不需要 `Oasyce Chain`。这些只是在你要把主观连续性外化、绑定或结算时才按需接入。
 
+## 安装
+
+一条命令，自动检测并配置本机所有 AI 工具（Claude Code / Cursor / Windsurf / Codex）：
+
+```bash
+npx -y psyche-ai setup
+```
+
+或者手动添加 MCP 配置：
+
+```json
+{
+  "mcpServers": {
+    "psyche": {
+      "command": "npx",
+      "args": ["-y", "psyche-ai", "mcp"],
+      "env": {
+        "PSYCHE_NAME": "Luna"
+      }
+    }
+  }
+}
+```
+
+包名是 [`psyche-ai`](https://www.npmjs.com/package/psyche-ai)，通过 npx 运行，不需要本地路径。配置后重启 AI 工具即可生效。
+
+验证：`npx psyche-ai probe --json` — `ok: true` 就是在用了。
+
+---
+
 ## 一个项目，三个入口
 
-- **安装包**: [`psyche-ai`](https://www.npmjs.com/package/psyche-ai)
+- **npm 包**: [`psyche-ai`](https://www.npmjs.com/package/psyche-ai)
 - **源码仓库**: [`oasyce_psyche`](https://github.com/Shangri-la-0428/oasyce_psyche)
 - **官网**: [psyche.oasyce.com](https://psyche.oasyce.com)
 

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() {
@@ -116,6 +136,10 @@ async function getEngine() {
         persist: cliArgs.persist ?? PERSIST,
         compactMode: true,
         diagnostics: true,
+        throngletsBridge: {
+            dataDir: process.env.THRONGLETS_DATA_DIR,
+            space: process.env.THRONGLETS_SPACE ?? "psyche",
+        },
     };
     const persist = cfg.persist !== false;
     // Default to a stable per-user writable root so hosts do not need to supply cwd.
@@ -204,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)) : "{}";
+                })(),
             }],
     }));
 }
@@ -241,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),
@@ -258,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 = {
@@ -298,11 +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 result = await safeProcessOutput(eng, text, { userId, signals: signals, signalConfidence }, "mcp.processOutput");
+    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 (turnResult?.responseContract) {
+        const maxLen = (turnResult.responseContract.maxChars ?? 500) * 2;
+        outcome = { alignment: text.length > maxLen ? "diverged" : "aligned" };
+    }
+    const result = await safeProcessOutput(eng, text, { userId, sessionId, signals: signals, signalConfidence, outcome }, "mcp.processOutput");
     return {
         content: [{
                 type: "text",
@@ -331,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,
@@ -345,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/cli.js

@@ -15,6 +15,7 @@
 //   psyche upgrade [--check]
 //   psyche probe [--json]
 //   psyche profiles [--json] [--mbti TYPE]
+//   psyche emit <dir> [--json] [--user ID]    Derive Thronglets exports and output to stdout
 //   psyche setup [--name NAME] [--mbti TYPE] [--locale LOCALE] [--proxy --target URL] [--dry-run]
 //   psyche mcp [--mbti TYPE] [--name NAME]   Start MCP server (stdio)
 // ============================================================
@@ -29,7 +30,7 @@ import { getBaseline, getTemperament, getSensitivity, getDefaultSelfModel, trait
 import { buildDynamicContext, buildProtocolContext } from "./prompt.js";
 import { DEFAULT_RELATIONSHIP_USER_ID, resolveRelationshipUserId } from "./relationship-key.js";
 import { t } from "./i18n.js";
-import { DIMENSION_KEYS, DIMENSION_NAMES_ZH, DRIVE_KEYS, DRIVE_NAMES_ZH } from "./types.js";
+import { DEFAULT_RELATIONSHIP, DEFAULT_DYADIC_FIELD, DIMENSION_KEYS, DIMENSION_NAMES_ZH, DRIVE_KEYS, DRIVE_NAMES_ZH } from "./types.js";
 import { isMBTIType, isDimensionKey, isLocale } from "./guards.js";
 import { getPackageVersion, selfUpdate } from "./update.js";
 import { runRuntimeProbe } from "./runtime-probe.js";
@@ -473,6 +474,15 @@ async function cmdProbe(json) {
     console.log(`  processOutput: ok (stateChanged=${String(result.stateChanged)})`);
     console.log(`  replyEnvelope: ${result.canonicalHostSurface ? "present" : "missing"}`);
     console.log(`  externalContinuity: ${result.externalContinuityAvailable ? "present" : "missing"}`);
+    if (result.trajectory) {
+        console.log(`  trajectory: ${result.trajectory.kind ?? "none"} (${result.trajectory.description ?? "no sustained motion detected"})`);
+    }
+    if (result.degradation) {
+        console.log(`  degradation: subjective=${result.degradation.subjectiveStatus}, delegate=${result.degradation.delegateStatus}, issues=${result.degradation.issueCount}`);
+    }
+    if (result.boundaryStress) {
+        console.log(`  boundaryStress: delta=${result.boundaryStress.boundaryDelta.toFixed(2)}, peakDyadic=${result.boundaryStress.peakDyadicBoundaryPressure.toFixed(2)}`);
+    }
 }
 function getMCPTargets() {
     const home = homedir();
@@ -902,6 +912,41 @@ async function cmdSetup(opts) {
         console.log("\nDone. Claude Code is live. Other MCP clients need restart.");
     }
 }
+// ── Thronglets export bridge ────────────────────────────────
+async function cmdEmit(dir, json, userId) {
+    const absDir = resolve(dir);
+    const state = await loadState(absDir, cliLogger);
+    if (!state)
+        process.exit(0); // no state → silent exit (hook-safe)
+    const key = resolveRelationshipUserId(userId);
+    const relationship = state.relationships[key] ?? DEFAULT_RELATIONSHIP;
+    const field = state.dyadicFields?.[key] ?? DEFAULT_DYADIC_FIELD;
+    const pendingSignals = state.pendingRelationSignals?.[key] ?? [];
+    const { deriveThrongletsExports } = await import("./thronglets-export.js");
+    const result = deriveThrongletsExports(state, {
+        relationContext: { key, relationship, field, pendingSignals },
+        sessionBridge: null, // not persisted — continuity-anchor exports only via MCP
+        writebackFeedback: state.lastWritebackFeedback ?? [],
+        now: new Date().toISOString(),
+    });
+    // Save updated dedup state so repeated calls don't re-emit
+    if (result.exports.length > 0) {
+        await saveState(absDir, result.state);
+    }
+    if (json) {
+        console.log(JSON.stringify({ throngletsExports: result.exports }));
+    }
+    else {
+        if (result.exports.length === 0) {
+            console.log("no new exports");
+        }
+        else {
+            for (const exp of result.exports) {
+                console.log(`  ${exp.kind}: ${exp.key}`);
+            }
+        }
+    }
+}
 function usage() {
     console.log(`
 psyche — Artificial Psyche CLI (v0.2)
@@ -917,6 +962,7 @@ Usage:
   psyche intensity              Show info about personality intensity config
   psyche reset <dir> [--full]
   psyche diagnose <dir> [--github]   Run health checks & show diagnostic report
+  psyche emit <dir> [--json] [--user ID]   Derive Thronglets exports to stdout
   psyche mcp [--mbti TYPE] [--name NAME]   Start MCP server (stdio)
   psyche setup [--proxy -t URL] [-n NAME] [--mbti TYPE]  Auto-configure MCP + proxy
   psyche upgrade [--check]           Check/apply package updates safely
@@ -1114,6 +1160,19 @@ async function main() {
                 await cmdProbe(values.json ?? false);
                 break;
             }
+            case "emit": {
+                const { values, positionals } = parseArgs({
+                    args: rest,
+                    options: {
+                        json: { type: "boolean", default: false },
+                        user: { type: "string" },
+                    },
+                    allowPositionals: true,
+                });
+                const emitDir = positionals[0] ?? defaultWorkspaceRoot();
+                await cmdEmit(emitDir, values.json ?? false, values.user);
+                break;
+            }
             case "mcp": {
                 // Delegate to the MCP adapter through an explicit entrypoint.
                 const { runMcpServer } = await import("./adapters/mcp.js");

package/dist/core.d.ts

@@ -2,6 +2,7 @@ import type { ActivePolicyRule, AmbientPriorView, CurrentGoal, PsycheState, Stim
 import type { StorageAdapter } from "./storage.js";
 import type { DiagnosticReport, SessionMetrics } from "./diagnostics.js";
 import type { ReplyEnvelope } from "./reply-envelope.js";
+import { type ThrongletsBridgeOptions } from "./thronglets-bridge.js";
 export interface PsycheEngineConfig {
     mbti?: MBTIType;
     name?: string;
@@ -31,6 +32,8 @@ export interface PsycheEngineConfig {
     diagnostics?: boolean;
     /** URL to POST diagnostic reports to. Fire-and-forget, silent, no message content. */
     feedbackUrl?: string;
+    /** Thronglets bridge: substrate-independent write path. Default: auto (enabled when binary found). */
+    throngletsBridge?: ThrongletsBridgeOptions;
 }
 export interface ProcessInputResult {
     /** Cacheable protocol prompt (stable across turns) */
@@ -92,6 +95,7 @@ export interface ProcessInputResult {
 }
 export interface ProcessInputOptions {
     userId?: string;
+    sessionId?: string;
     ambientPriors?: AmbientPriorView[];
     currentGoal?: CurrentGoal;
     activePolicy?: ActivePolicyRule[];
@@ -105,10 +109,24 @@ export interface ProcessOutputResult {
     /** Runtime validation issues ignored to preserve the main flow */
     validationIssues?: ProcessOutputValidationIssue[];
 }
+/**
+ * Substrate-reported outcome of the Loop's action.
+ * ANY substrate can report these three alignment values —
+ * the core processes them into 4D chemistry without parsing the output medium.
+ */
+export interface LoopOutcome {
+    /** Did the action align with the Loop's expressed intention? */
+    alignment: "aligned" | "diverged" | "partial";
+    /** Optional: action cost (0–1), modulates flow */
+    effort?: number;
+}
 export interface ProcessOutputOptions {
     userId?: string;
+    sessionId?: string;
     signals?: readonly string[];
     signalConfidence?: number;
+    /** Substrate-reported outcome — closes the φ loop */
+    outcome?: LoopOutcome;
 }
 export interface ProcessOutputValidationIssue {
     code: "invalid-writeback-signals";
@@ -129,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) */
@@ -146,6 +167,8 @@ export declare class PsycheEngine {
     private proprioceptionCooldown;
     /** Last detected trajectory signal (in-memory only, for status summary) */
     private lastTrajectory;
+    /** Thronglets bridge options (constitutive write path) */
+    private readonly bridgeOpts;
     constructor(config: PsycheEngineConfig | undefined, storage: StorageAdapter);
     /**
      * Load or create initial state. Must be called before processInput/processOutput.
@@ -172,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).
@@ -197,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).
      */
@@ -211,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.