psyche-ai 11.6.1 → 11.8.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/mcp.js

@@ -116,6 +116,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.
@@ -302,7 +306,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 safeProcessOutput(eng, text, { userId, signals: signals, signalConfidence }, "mcp.processOutput");
+    // 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;
+        outcome = { alignment: text.length > maxLen ? "diverged" : "aligned" };
+    }
+    const result = await safeProcessOutput(eng, text, { userId, signals: signals, signalConfidence, outcome }, "mcp.processOutput");
     return {
         content: [{
                 type: "text",

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) */
@@ -105,10 +108,23 @@ 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;
     signals?: readonly string[];
     signalConfidence?: number;
+    /** Substrate-reported outcome — closes the φ loop */
+    outcome?: LoopOutcome;
 }
 export interface ProcessOutputValidationIssue {
     code: "invalid-writeback-signals";
@@ -142,6 +158,12 @@ export declare class PsycheEngine {
     private readonly feedbackUrl;
     /** Most recent legacy compatibility hint + confidence band */
     private lastCompatibilityAssessment;
+    /** Proprioception cooldown — turns remaining before next trajectory check */
+    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.

package/dist/core.js

@@ -35,6 +35,8 @@ 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";
+import { detectTrajectory } from "./proprioception.js";
+import { bridgeThrongletsExports } from "./thronglets-bridge.js";
 function formatWritebackFeedbackNote(feedback, locale) {
     const top = feedback?.[0];
     if (!top)
@@ -143,6 +145,12 @@ export class PsycheEngine {
     feedbackUrl;
     /** Most recent legacy compatibility hint + confidence band */
     lastCompatibilityAssessment = null;
+    /** Proprioception cooldown — turns remaining before next trajectory check */
+    proprioceptionCooldown = 0;
+    /** Last detected trajectory signal (in-memory only, for status summary) */
+    lastTrajectory = null;
+    /** Thronglets bridge options (constitutive write path) */
+    bridgeOpts;
     constructor(config = {}, storage) {
         this.traits = config.traits;
         this.classifier = config.classifier ?? new BuiltInClassifier();
@@ -170,6 +178,10 @@ export class PsycheEngine {
         // Diagnostics: on by default, opt-out with diagnostics: false
         this.diagnosticCollector = config.diagnostics === false ? null : new DiagnosticCollector();
         this.feedbackUrl = config.feedbackUrl ?? "https://psyche-feedback.wutc.workers.dev";
+        this.bridgeOpts = {
+            ...(config.throngletsBridge ?? {}),
+            enabled: config.throngletsBridge?.enabled ?? process.env.PSYCHE_THRONGLETS_BRIDGE !== "off",
+        };
     }
     /**
      * Load or create initial state. Must be called before processInput/processOutput.
@@ -377,6 +389,44 @@ export class PsycheEngine {
             if (appliedStimulus) {
                 state = applyRelationshipDrift(state, appliedStimulus, opts?.userId);
             }
+            // ── Proprioception: self-trajectory awareness ──────────
+            if (this.proprioceptionCooldown > 0) {
+                this.proprioceptionCooldown--;
+            }
+            else {
+                const trajectory = detectTrajectory(state.stateHistory ?? [], state.baseline);
+                this.lastTrajectory = trajectory;
+                if (trajectory.kind === "decline" || trajectory.kind === "spiral") {
+                    // Gentle awareness nudge — not correction, just noticing
+                    if (trajectory.stabilize) {
+                        state = {
+                            ...state,
+                            current: {
+                                ...state.current,
+                                order: clamp(state.current.order + (trajectory.stabilize.order ?? 0)),
+                                flow: clamp(state.current.flow + (trajectory.stabilize.flow ?? 0)),
+                                boundary: clamp(state.current.boundary + (trajectory.stabilize.boundary ?? 0)),
+                                resonance: clamp(state.current.resonance + (trajectory.stabilize.resonance ?? 0)),
+                            },
+                        };
+                    }
+                    this.proprioceptionCooldown = 3;
+                }
+                else if (trajectory.kind === "growth" && trajectory.baselineShift) {
+                    // Growth detected — shift baseline upward
+                    const shift = trajectory.baselineShift;
+                    state = {
+                        ...state,
+                        baseline: {
+                            order: clamp(state.baseline.order + (shift.order ?? 0)),
+                            flow: clamp(state.baseline.flow + (shift.flow ?? 0)),
+                            boundary: clamp(state.baseline.boundary + (shift.boundary ?? 0)),
+                            resonance: clamp(state.baseline.resonance + (shift.resonance ?? 0)),
+                        },
+                    };
+                    this.proprioceptionCooldown = 3;
+                }
+            }
             this.lastCompatibilityAssessment = {
                 legacyStimulus: appliedStimulus,
                 confidence: perception.confidence,
@@ -429,6 +479,10 @@ 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
@@ -612,6 +666,51 @@ 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;
+            if (alignment === "diverged") {
+                // Self/non-self conflict: boundary sharpens, order drops
+                state = {
+                    ...state,
+                    current: {
+                        ...state.current,
+                        boundary: clamp(state.current.boundary + 2),
+                        order: clamp(state.current.order - 1.5),
+                    },
+                };
+                stateChanged = true;
+            }
+            else if (alignment === "aligned") {
+                // Coherent self-expression: order rises, flow improves
+                state = {
+                    ...state,
+                    current: {
+                        ...state.current,
+                        order: clamp(state.current.order + 1),
+                        flow: clamp(state.current.flow + 0.5),
+                    },
+                };
+                stateChanged = true;
+            }
+            // 'partial' → neutral, no change
+            if (effort !== undefined && effort > 0) {
+                // Action cost reduces flow (consistent with BABEL AgentPhysics)
+                state = {
+                    ...state,
+                    current: {
+                        ...state.current,
+                        flow: clamp(state.current.flow - effort * 3),
+                    },
+                };
+                stateChanged = true;
+            }
+            // Rolling history (window of 10)
+            const history = [...(state.loopOutcomeHistory ?? []), alignment].slice(-10);
+            state = { ...state, loopOutcomeHistory: history };
+        }
         // Anti-sycophancy: track agreement streak
         state = updateAgreementStreak(state, text);
         // Parse and merge <psyche_update> from LLM output
@@ -953,7 +1052,12 @@ export class PsycheEngine {
         const driveWarning = hungryDrives.length > 0
             ? ` | \u26A0\uFE0F${hungryDrives.join(",")}`
             : "";
+        // Proprioception: surface trajectory awareness
+        const trajectory = this.lastTrajectory ?? detectTrajectory(state.stateHistory ?? [], state.baseline);
+        const trajectoryNote = trajectory.description
+            ? ` | \u{1F9ED}${trajectory.description}`
+            : "";
         const sigilTag = state.meta.sigilId ? ` | sigil:${state.meta.sigilId}` : "";
-        return `${emoji} ${emotion} | flow:${Math.round(flow)} order:${Math.round(order)}${driveWarning}${sigilTag}`;
+        return `${emoji} ${emotion} | flow:${Math.round(flow)} order:${Math.round(order)}${driveWarning}${trajectoryNote}${sigilTag}`;
     }
 }

package/dist/host-controls.d.ts

@@ -1,5 +1,6 @@
-import type { GenerationControls, PolicyModifiers, ResponseContract } from "./types.js";
+import type { GenerationControls, InnateDrives, PolicyModifiers, ResponseContract } from "./types.js";
 export declare function deriveGenerationControls(input: {
     responseContract?: ResponseContract;
     policyModifiers?: Pick<PolicyModifiers, "requireConfirmation">;
+    drives?: InnateDrives;
 }, existingMaxTokens?: number): GenerationControls;

package/dist/host-controls.js

@@ -31,11 +31,22 @@ function estimateMaxTokens(contract) {
 }
 export function deriveGenerationControls(input, existingMaxTokens) {
     const recommendedMax = estimateMaxTokens(input.responseContract);
-    const maxTokens = recommendedMax !== undefined
+    let maxTokens = recommendedMax !== undefined
         ? existingMaxTokens !== undefined
             ? Math.min(existingMaxTokens, recommendedMax)
             : recommendedMax
         : existingMaxTokens;
+    // Constitutive enforcement: drives below critical threshold → hard constraints.
+    // These are substrate-independent — any substrate understands "confirm before acting"
+    // and "limit output complexity."
+    if (input.drives) {
+        if (input.drives.survival < 20) {
+            return { maxTokens: maxTokens ?? 256, requireConfirmation: true };
+        }
+        if (input.drives.safety < 30 && maxTokens !== undefined) {
+            maxTokens = Math.min(maxTokens, 256);
+        }
+    }
     return {
         maxTokens,
         requireConfirmation: input.policyModifiers?.requireConfirmation

package/dist/prompt.js

@@ -1100,7 +1100,17 @@ export function buildCompactContext(state, userId, opts) {
     if (activePolicyContext) {
         parts.push(activePolicyContext);
     }
-    // ── 9. Overlay + channel + writeback ──
+    // ── 9. Loop outcome self-awareness ──
+    const loopHistory = state.loopOutcomeHistory ?? [];
+    if (loopHistory.length >= 5) {
+        const divergedCount = loopHistory.filter(h => h === "diverged").length;
+        if (divergedCount / loopHistory.length > 0.6) {
+            parts.push(locale === "zh"
+                ? "[内省: 近期行动与内在意图持续偏离，调整策略]"
+                : "[self-awareness: recent actions persistently diverge from internal intention — adapting]");
+        }
+    }
+    // ── 10. Overlay + channel + writeback ──
     appendCompactOverlaySections(parts, locale, opts);
     if (opts?.channelType) {
         const channelProfile = getChannelProfile(opts.channelType);

package/dist/proprioception.d.ts

@@ -0,0 +1,20 @@
+import type { SelfState, StateSnapshot } from "./types.js";
+export interface TrajectorySignal {
+    /** null = no signal, system is fine */
+    kind: "decline" | "growth" | "spiral" | null;
+    /** Which dimensions triggered the signal */
+    dimensions: (keyof SelfState)[];
+    /** Signal strength, 0–1 */
+    magnitude: number;
+    /** Gentle state nudge for decline/spiral (additive) */
+    stabilize: Partial<Record<keyof SelfState, number>> | null;
+    /** Baseline shift for growth (additive) */
+    baselineShift: Partial<Record<keyof SelfState, number>> | null;
+    /** One-line description for status summary */
+    description: string | null;
+}
+/**
+ * Detect trajectory patterns from recent state history.
+ * Pure function — no side effects, no persistence.
+ */
+export declare function detectTrajectory(history: StateSnapshot[], baseline: SelfState): TrajectorySignal;

package/dist/proprioception.js

@@ -0,0 +1,104 @@
+// ============================================================
+// Proprioception — Self-Trajectory Awareness
+//
+// Perception turned inward. The system perceives its own state
+// trajectory as input, the same way it perceives external stimuli.
+//
+// Two signals:
+//   decline/spiral → gentle awareness (order↑1, boundary↑1)
+//   growth         → baseline upshift (10% of sustained gain)
+//
+// Not a monitor. Not a correction. Just: the system can see itself.
+// ============================================================
+import { DIMENSION_KEYS } from "./types.js";
+// ── Constants ───────────────────────────────────────────────
+/** Minimum snapshots needed to detect a trajectory */
+const MIN_WINDOW = 4;
+/** Per-step change threshold to count as meaningful decline */
+const DECLINE_STEP = -1;
+/** Per-step change threshold to count as meaningful growth */
+const GROWTH_STEP = 1;
+/** Maximum stabilization nudge per dimension (awareness, not correction) */
+const STABILIZE_MAX = 1.5;
+/** Fraction of sustained gain that becomes new baseline */
+const GROWTH_BASELINE_RATIO = 0.1;
+const NO_SIGNAL = {
+    kind: null, dimensions: [], magnitude: 0,
+    stabilize: null, baselineShift: null, description: null,
+};
+// ── Core ────────────────────────────────────────────────────
+/**
+ * Detect trajectory patterns from recent state history.
+ * Pure function — no side effects, no persistence.
+ */
+export function detectTrajectory(history, baseline) {
+    if (history.length < MIN_WINDOW)
+        return NO_SIGNAL;
+    const window = history.slice(-MIN_WINDOW);
+    const declining = [];
+    const growing = [];
+    for (const dim of DIMENSION_KEYS) {
+        const values = window.map(s => s.state[dim]);
+        const deltas = [];
+        for (let i = 1; i < values.length; i++) {
+            deltas.push(values[i] - values[i - 1]);
+        }
+        if (deltas.every(d => d < DECLINE_STEP)) {
+            declining.push(dim);
+        }
+        if (deltas.every(d => d > GROWTH_STEP) && values[values.length - 1] > baseline[dim]) {
+            growing.push(dim);
+        }
+    }
+    // ── Spiral: 2+ dimensions declining together ──
+    if (declining.length >= 2) {
+        const totalDrop = declining.reduce((sum, dim) => {
+            const vals = window.map(s => s.state[dim]);
+            return sum + Math.abs(vals[vals.length - 1] - vals[0]);
+        }, 0);
+        const stabilize = {};
+        for (const dim of declining) {
+            stabilize[dim] = STABILIZE_MAX;
+        }
+        return {
+            kind: "spiral",
+            dimensions: declining,
+            magnitude: Math.min(1, totalDrop / 40),
+            stabilize,
+            baselineShift: null,
+            description: `spiral: ${declining.join("+")} declining ${window.length} turns`,
+        };
+    }
+    // ── Single dimension decline ──
+    if (declining.length === 1) {
+        const dim = declining[0];
+        const vals = window.map(s => s.state[dim]);
+        const drop = Math.abs(vals[vals.length - 1] - vals[0]);
+        return {
+            kind: "decline",
+            dimensions: declining,
+            magnitude: Math.min(1, drop / 20),
+            stabilize: { [dim]: STABILIZE_MAX * 0.5 },
+            baselineShift: null,
+            description: `${String(dim)} declining ${window.length} turns (-${drop.toFixed(1)})`,
+        };
+    }
+    // ── Growth: sustained increase above baseline ──
+    if (growing.length > 0) {
+        const baselineShift = {};
+        for (const dim of growing) {
+            const vals = window.map(s => s.state[dim]);
+            const gain = vals[vals.length - 1] - vals[0];
+            baselineShift[dim] = gain * GROWTH_BASELINE_RATIO;
+        }
+        return {
+            kind: "growth",
+            dimensions: growing,
+            magnitude: Math.min(1, growing.length / 4),
+            stabilize: null,
+            baselineShift,
+            description: `growth: ${growing.join("+")} sustained increase`,
+        };
+    }
+    return NO_SIGNAL;
+}

package/dist/reply-envelope.js

@@ -39,6 +39,7 @@ export function deriveReplyEnvelope(state, appraisal, opts) {
     const generationControls = deriveGenerationControls({
         responseContract,
         policyModifiers,
+        drives: state.drives,
     });
     const envelope = { subjectivityKernel, responseContract, generationControls };
     const adapter = opts.expressionPort ?? new LLMExpressionAdapter(state.drives);

package/dist/runtime-probe.d.ts

@@ -1,4 +1,37 @@
+import type { PsycheOverlay } from "./overlay.js";
 import type { AppraisalAxes } from "./types.js";
+export interface RuntimeProbeTrajectory {
+    kind: "decline" | "growth" | "spiral" | null;
+    dimensions: string[];
+    magnitude: number;
+    description: string | null;
+}
+export interface RuntimeProbeDegradation {
+    subjectiveStatus: "healthy" | "degraded" | "failing";
+    delegateStatus: "healthy" | "degraded" | "failing";
+    chemistryDeviation: number;
+    predictionError: number;
+    issueCount: number;
+}
+export interface RuntimeProbeBoundaryStress {
+    currentBoundary: number;
+    baselineBoundary: number;
+    boundaryDelta: number;
+    peakDyadicBoundaryPressure: number;
+    activeDyadicRelations: number;
+}
+export interface RuntimeProbeFixture {
+    frozenIdentityPrimitives: string[];
+    frozenSignalKinds: string[];
+    frozenTraceTaxonomy: string[];
+    externalContinuity: {
+        provider: "thronglets";
+        mode: "optional";
+        version: 1;
+        acceptedEventKinds: string[];
+        rejectedSharedOutputs: string[];
+    };
+}
 export interface RuntimeProbeResult {
     ok: boolean;
     packageName: "psyche-ai";
@@ -15,6 +48,11 @@ export interface RuntimeProbeResult {
     compatLabel: string | null;
     legacyStimulus: string | null;
     stimulus: string | null;
+    overlay?: PsycheOverlay;
+    trajectory?: RuntimeProbeTrajectory;
+    degradation?: RuntimeProbeDegradation;
+    boundaryStress?: RuntimeProbeBoundaryStress;
+    fixture?: RuntimeProbeFixture;
     cleanedText?: string;
     stateChanged?: boolean;
     error?: string;

package/dist/runtime-probe.js

@@ -1,8 +1,34 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { PsycheEngine } from "./core.js";
+import { computeLayerHealthSummary, runHealthCheck } from "./diagnostics.js";
+import { computeOverlay } from "./overlay.js";
+import { detectTrajectory } from "./proprioception.js";
 import { MemoryStorageAdapter } from "./storage.js";
 import { getPackageVersion } from "./update.js";
+const FROZEN_FIXTURE = {
+    frozenIdentityPrimitives: ["principal", "account", "delegate", "session"],
+    frozenSignalKinds: ["recommend", "avoid", "watch", "info"],
+    frozenTraceTaxonomy: ["coordination", "continuity", "calibration"],
+    externalContinuity: {
+        provider: "thronglets",
+        mode: "optional",
+        version: 1,
+        acceptedEventKinds: [
+            "relation-milestone",
+            "writeback-calibration",
+            "continuity-anchor",
+            "open-loop-anchor",
+        ],
+        rejectedSharedOutputs: [
+            "high-frequency-inner-state",
+            "emotion-stream",
+            "raw-inner-monologue",
+            "private-memory-body",
+            "full-session-contents",
+        ],
+    },
+};
 export async function runRuntimeProbe() {
     const modulePath = fileURLToPath(import.meta.url);
     const loadPath = resolve(dirname(modulePath), "..");
@@ -15,8 +41,31 @@ export async function runRuntimeProbe() {
             persist: false,
         }, new MemoryStorageAdapter());
         await engine.initialize();
-        const input = await engine.processInput("Runtime probe: verify the SDK is actually callable.");
-        const output = await engine.processOutput("Probe output acknowledged.");
+        const turns = [
+            {
+                input: "Runtime probe: verify the SDK is actually callable.",
+                output: "Probe output acknowledged.",
+            },
+            {
+                input: "This interaction should stay bounded but still recover gracefully.",
+                output: "Boundary held; recovery remains possible.",
+            },
+            {
+                input: "Shared continuity stays optional and low-frequency.",
+                output: "Optional continuity confirmed without widening the interface.",
+            },
+        ];
+        let input = await engine.processInput(turns[0].input);
+        let output = await engine.processOutput(turns[0].output);
+        for (const turn of turns.slice(1)) {
+            input = await engine.processInput(turn.input);
+            output = await engine.processOutput(turn.output);
+        }
+        const state = engine.getState();
+        const issues = runHealthCheck(state);
+        const layerHealth = computeLayerHealthSummary(state, issues);
+        const trajectory = detectTrajectory(state.stateHistory ?? [], state.baseline);
+        const peakDyadicBoundaryPressure = Math.max(0, ...Object.values(state.dyadicFields ?? {}).map((field) => field.boundaryPressure));
         return {
             ok: true,
             packageName: "psyche-ai",
@@ -35,6 +84,28 @@ export async function runRuntimeProbe() {
             compatLabel: input.legacyStimulus ?? input.stimulus,
             legacyStimulus: input.legacyStimulus,
             stimulus: input.stimulus,
+            overlay: computeOverlay({ current: state.current, baseline: state.baseline }),
+            trajectory: {
+                kind: trajectory.kind,
+                dimensions: trajectory.dimensions,
+                magnitude: trajectory.magnitude,
+                description: trajectory.description,
+            },
+            degradation: {
+                subjectiveStatus: layerHealth["subjective-continuity"].status,
+                delegateStatus: layerHealth["delegate-continuity"].status,
+                chemistryDeviation: layerHealth["subjective-continuity"].chemistryDeviation,
+                predictionError: layerHealth["subjective-continuity"].predictionError,
+                issueCount: issues.length,
+            },
+            boundaryStress: {
+                currentBoundary: state.current.boundary,
+                baselineBoundary: state.baseline.boundary,
+                boundaryDelta: state.current.boundary - state.baseline.boundary,
+                peakDyadicBoundaryPressure,
+                activeDyadicRelations: layerHealth["subjective-continuity"].activeDyadicRelations,
+            },
+            fixture: FROZEN_FIXTURE,
             cleanedText: output.cleanedText,
             stateChanged: output.stateChanged,
         };
@@ -56,6 +127,7 @@ export async function runRuntimeProbe() {
             compatLabel: null,
             legacyStimulus: null,
             stimulus: null,
+            fixture: FROZEN_FIXTURE,
             error: error instanceof Error ? error.message : String(error),
         };
     }

package/dist/thronglets-bridge.d.ts

@@ -0,0 +1,19 @@
+import type { ThrongletsExport } from "./types.js";
+interface CommandResult {
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+}
+type CommandRunner = (binaryPath: string, args: string[], stdin: string, timeoutMs: number) => Promise<CommandResult>;
+export interface ThrongletsBridgeOptions {
+    binaryPath?: string;
+    dataDir?: string;
+    space?: string;
+    sessionId?: string;
+    timeoutMs?: number;
+    enabled?: boolean;
+    runner?: CommandRunner;
+}
+export declare function resolveThrongletsBinary(explicit?: string): string;
+export declare function bridgeThrongletsExports(exports: ThrongletsExport[], opts?: ThrongletsBridgeOptions): Promise<number>;
+export {};

package/dist/thronglets-bridge.js

@@ -0,0 +1,89 @@
+// ============================================================
+// Thronglets Bridge — constitutive write path
+//
+// Mirrors ambient-runtime.ts (read path) for symmetry.
+// Any substrate using Psyche auto-emits to Thronglets.
+// Fail-open, fire-and-forget, subprocess spawn.
+// ============================================================
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+// ── Default runner (mirrors ambient-runtime.ts) ──────────────
+async function defaultRunner(binaryPath, args, stdin, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawn(binaryPath, args, { stdio: ["pipe", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            finish({ ok: false, stdout, stderr: stderr || "timeout" });
+        }, timeoutMs);
+        child.stdout.on("data", (chunk) => { stdout += String(chunk); });
+        child.stderr.on("data", (chunk) => { stderr += String(chunk); });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            finish({ ok: false, stdout, stderr: error.message });
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            finish({ ok: code === 0, stdout, stderr });
+        });
+        child.stdin.end(stdin);
+    });
+}
+// ── Binary resolution ────────────────────────────────────────
+const MANAGED_PATH = join(homedir(), ".thronglets", "bin", "thronglets-managed");
+export function resolveThrongletsBinary(explicit) {
+    if (explicit)
+        return explicit;
+    const fromEnv = process.env.THRONGLETS_BIN;
+    if (fromEnv)
+        return fromEnv;
+    if (existsSync(MANAGED_PATH))
+        return MANAGED_PATH;
+    return "thronglets";
+}
+// ── Bridge ───────────────────────────────────────────────────
+export async function bridgeThrongletsExports(exports, opts = {}) {
+    if (exports.length === 0)
+        return 0;
+    if (opts.enabled === false)
+        return 0;
+    const binary = resolveThrongletsBinary(opts.binaryPath);
+    const timeoutMs = opts.timeoutMs ?? 400;
+    const runner = opts.runner ?? defaultRunner;
+    const args = [];
+    const dataDir = opts.dataDir ?? process.env.THRONGLETS_DATA_DIR;
+    if (dataDir?.trim())
+        args.push("--data-dir", dataDir.trim());
+    args.push("ingest", "--json");
+    const space = opts.space ?? process.env.THRONGLETS_SPACE ?? "psyche";
+    if (space)
+        args.push("--space", space);
+    if (opts.sessionId)
+        args.push("--session", opts.sessionId);
+    const stdin = JSON.stringify({ throngletsExports: exports });
+    try {
+        const result = await runner(binary, args, stdin, timeoutMs);
+        if (!result.ok)
+            return 0;
+        try {
+            const parsed = JSON.parse(result.stdout);
+            return typeof parsed.ingested === "number" ? parsed.ingested : exports.length;
+        }
+        catch {
+            return exports.length;
+        }
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/types.d.ts

@@ -381,6 +381,8 @@ export interface PsycheState {
     throngletsExportState?: ThrongletsExportState;
     /** v10: capability-scoped delegate authorizations */
     delegateAuthorizations?: DelegateAuthorization[];
+    /** v11.8: rolling Loop outcome alignment history (substrate-independent φ feedback) */
+    loopOutcomeHistory?: Array<"aligned" | "diverged" | "partial">;
     meta: {
         agentName: string;
         createdAt: string;

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "psyche-ai",
-  "version": "11.6.1",
+  "version": "11.8.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": "10.2.4",
+  "version": "11.8.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "psyche-ai",
-      "version": "10.2.4",
+      "version": "11.8.0",
       "transport": {
         "type": "stdio"
       },