psyche-ai 11.5.4 → 11.5.5

package/README.md

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

package/dist/adapters/claude-sdk.js

@@ -28,6 +28,7 @@
 // The SDK has no middleware interface and hooks cannot modify assistant
 // output, so processResponse must be called explicitly by the host.
 // ============================================================
+import { normalizeCurrentGoal, normalizeCurrentTurnCorrection, resolveRuntimeActivePolicy, } from "../types.js";
 import { describeEmotionalState } from "../chemistry.js";
 import { serializeThrongletsExportAsTrace } from "../thronglets-runtime.js";
 import { resolveRelationshipUserId } from "../relationship-key.js";
@@ -107,9 +108,12 @@ export class PsycheClaudeSDK {
             ambient: opts?.ambient === true ? {} : (opts?.ambient || undefined),
         };
     }
-    async resolveAmbientPriors(userMessage) {
+    async resolveAmbientPriors(userMessage, currentGoal, activePolicy, currentTurnCorrection) {
         return resolveAmbientPriorsForTurn(userMessage, {
             enabled: Boolean(this.opts.ambient),
+            currentGoal,
+            activePolicy,
+            currentTurnCorrection,
             thronglets: this.opts.ambient
                 ? {
                     ...this.opts.ambient,
@@ -166,10 +170,21 @@ export class PsycheClaudeSDK {
                                 sessionId: runtimeContext.sessionId ?? self.lastRuntimeContext.sessionId,
                             };
                             const userMessage = input.user_message ?? "";
-                            const ambientPriors = await self.resolveAmbientPriors(userMessage);
+                            const currentTurnCorrection = normalizeCurrentTurnCorrection(input.current_turn_correction
+                                ?? input.currentTurnCorrection
+                                ?? input.task_correction
+                                ?? input.taskCorrection
+                                ?? input.explicit_instruction
+                                ?? input.explicitInstruction);
+                            const currentGoal = normalizeCurrentGoal(input.current_goal ?? input.currentGoal);
+                            const activePolicy = resolveRuntimeActivePolicy(input.active_policy ?? input.activePolicy, currentTurnCorrection);
+                            const ambientPriors = await self.resolveAmbientPriors(userMessage, currentGoal, activePolicy, currentTurnCorrection);
                             const result = await self.engine.processInput(userMessage, {
                                 userId: self.opts.userId,
                                 ambientPriors,
+                                currentGoal,
+                                activePolicy,
+                                currentTurnCorrection,
                             });
                             self.lastInputResult = result;
                             // Cache Thronglets exports from this turn

package/dist/adapters/http.js

@@ -16,7 +16,7 @@
 // Zero dependencies — uses node:http only.
 // ============================================================
 import { createServer } from "node:http";
-import { normalizeActivePolicyRules, normalizeCurrentGoal, } from "../types.js";
+import { normalizeCurrentGoal, normalizeCurrentTurnCorrection, resolveRuntimeActivePolicy, } from "../types.js";
 import { parseAmbientPriorsInput } from "../ambient-runtime.js";
 import { computeOverlay } from "../overlay.js";
 const VALID_WRITEBACK_SIGNALS = new Set([
@@ -40,6 +40,14 @@ function parseSignals(value) {
 function parseAmbientPriors(value) {
     return parseAmbientPriorsInput(value);
 }
+function parseCurrentTurnCorrection(body) {
+    return normalizeCurrentTurnCorrection(body.currentTurnCorrection
+        ?? body.current_turn_correction
+        ?? body.taskCorrection
+        ?? body.task_correction
+        ?? body.explicitInstruction
+        ?? body.explicit_instruction);
+}
 // ── Server ───────────────────────────────────────────────────
 /**
  * Create an HTTP server that exposes PsycheEngine via REST API.
@@ -94,11 +102,13 @@ export function createPsycheServer(engine, opts) {
             // POST /process-input
             if (req.method === "POST" && url.pathname === "/process-input") {
                 const body = await readBody(req);
+                const currentTurnCorrection = parseCurrentTurnCorrection(body);
                 const result = await engine.processInput(body.text ?? "", {
                     userId: body.userId,
                     ambientPriors: parseAmbientPriors(body.ambientPriors),
                     currentGoal: normalizeCurrentGoal(body.currentGoal),
-                    activePolicy: normalizeActivePolicyRules(body.activePolicy),
+                    activePolicy: resolveRuntimeActivePolicy(body.activePolicy, currentTurnCorrection),
+                    currentTurnCorrection,
                 });
                 json(res, 200, {
                     systemContext: result.systemContext,

package/dist/adapters/langchain.d.ts

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

package/dist/adapters/langchain.js

@@ -12,6 +12,7 @@
 // It provides the hooks you need to wire psyche into any
 // LangChain pipeline without requiring langchain as a dependency.
 // ============================================================
+import { normalizeCurrentGoal, normalizeCurrentTurnCorrection, resolveRuntimeActivePolicy, } from "../types.js";
 import { resolveAmbientPriorsForTurn, } from "../ambient-runtime.js";
 /**
  * LangChain integration helper for PsycheEngine.
@@ -64,10 +65,13 @@ export class PsycheLangChain {
         const parsed = signals.filter((signal) => this.validSignals.has(signal));
         return parsed.length > 0 ? [...new Set(parsed)] : undefined;
     }
-    async resolveAmbientPriors(userText) {
+    async resolveAmbientPriors(userText, currentGoal, activePolicy, currentTurnCorrection) {
         const ambient = this.opts.ambient;
         return resolveAmbientPriorsForTurn(userText, {
             enabled: Boolean(ambient),
+            currentGoal,
+            activePolicy,
+            currentTurnCorrection,
             thronglets: ambient
                 ? {
                     ...(ambient === true ? {} : ambient),
@@ -83,9 +87,15 @@ export class PsycheLangChain {
      * Call this BEFORE the LLM invocation.
      */
     async getSystemMessage(userText, opts) {
+        const currentTurnCorrection = normalizeCurrentTurnCorrection(opts?.currentTurnCorrection);
+        const currentGoal = normalizeCurrentGoal(opts?.currentGoal);
+        const activePolicy = resolveRuntimeActivePolicy(opts?.activePolicy, currentTurnCorrection);
         const result = await this.engine.processInput(userText, {
             ...opts,
-            ambientPriors: await this.resolveAmbientPriors(userText),
+            currentGoal,
+            activePolicy,
+            currentTurnCorrection,
+            ambientPriors: await this.resolveAmbientPriors(userText, currentGoal, activePolicy, currentTurnCorrection),
         });
         return result.systemContext + "\n\n" + result.dynamicContext;
     }
@@ -96,9 +106,15 @@ export class PsycheLangChain {
      * instead of re-parsing prompt prose.
      */
     async prepareInvocation(userText, opts) {
+        const currentTurnCorrection = normalizeCurrentTurnCorrection(opts?.currentTurnCorrection);
+        const currentGoal = normalizeCurrentGoal(opts?.currentGoal);
+        const activePolicy = resolveRuntimeActivePolicy(opts?.activePolicy, currentTurnCorrection);
         const result = await this.engine.processInput(userText, {
             ...opts,
-            ambientPriors: await this.resolveAmbientPriors(userText),
+            currentGoal,
+            activePolicy,
+            currentTurnCorrection,
+            ambientPriors: await this.resolveAmbientPriors(userText, currentGoal, activePolicy, currentTurnCorrection),
         });
         const generationControls = result.replyEnvelope?.generationControls ?? result.generationControls;
         const controls = {

package/dist/adapters/mcp.d.ts

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

package/dist/adapters/mcp.js

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

package/dist/ambient-runtime.d.ts

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

package/dist/ambient-runtime.js

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

package/dist/core.d.ts

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

package/dist/core.js

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

package/dist/prompt.js

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

package/dist/types.d.ts

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

package/dist/types.js

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

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "psyche-ai",
   "name": "Artificial Psyche",
   "description": "AI-first subjectivity kernel for agents with continuous appraisal, relation dynamics, and adaptive reply loops",
-  "version": "11.5.4",
+  "version": "11.5.5",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "psyche-ai",
-  "version": "11.5.4",
+  "version": "11.5.5",
   "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/dist/experience.d.ts

@@ -1,34 +0,0 @@
-import type { ChemicalState, StimulusType, AppraisalAxes, PsycheMode, ClassificationResult, ExperienceResult, Locale } from "./types.js";
-export interface ExperienceContext {
-    /** Current chemistry — shapes how input is interpreted */
-    current: ChemicalState;
-    /** Personality baseline — deviation from baseline = subjective lens */
-    baseline: ChemicalState;
-    /** Residue from previous turns — carry-forward of unresolved tension */
-    previousAppraisal?: AppraisalAxes;
-    /** Recent stimulus history for contextual priming in classifier */
-    recentStimuli?: (StimulusType | null)[];
-    /** Operating mode */
-    mode?: PsycheMode;
-    /** Trust level from relationship (0-100). Low trust discounts positive signals. */
-    trust?: number;
-    /** Locale for classifier */
-    locale?: Locale;
-    /**
-     * Pre-classified results from external classifier (pluggable provider + LLM fallback).
-     * When provided, the experience module skips its own classification and uses these
-     * as raw perception to be modulated by subjectivity.
-     */
-    rawClassifications?: ClassificationResult[];
-}
-/**
- * Compute the subjective experience of an input.
- *
- * Text passes through the self exactly once. The result already
- * reflects "who I am" — my appraisal history, my current chemistry,
- * my trust in this person.
- *
- * Returns weighted stimuli (for chemistry application) and appraisal
- * axes (for relation dynamics and residue persistence).
- */
-export declare function computeExperience(text: string, ctx: ExperienceContext): ExperienceResult;

package/dist/experience.js

@@ -1,200 +0,0 @@
-// ============================================================
-// Unified Subjective Experience
-//
-// First principle: classification IS subjectivity.
-// How I categorise your words = how I experience your words.
-// This module folds classification, appraisal, and state
-// modulation into a single act of perception.
-//
-// Before: classify(text) → label → applyStimulus(label)
-//         appraise(text) → axes  (separate, after chemistry)
-//
-// After:  experience(text, self) → { stimuli, appraisal }
-//         The same input through different selves produces
-//         different experiences. That IS having a self.
-// ============================================================
-import { classifyStimulus } from "./classify.js";
-import { computeAppraisalAxes } from "./appraisal.js";
-/**
- * Compute the subjective experience of an input.
- *
- * Text passes through the self exactly once. The result already
- * reflects "who I am" — my appraisal history, my current chemistry,
- * my trust in this person.
- *
- * Returns weighted stimuli (for chemistry application) and appraisal
- * axes (for relation dynamics and residue persistence).
- */
-export function computeExperience(text, ctx) {
-    if (!text.trim()) {
-        return {
-            stimuli: [{ type: "casual", weight: 1 }],
-            primary: null,
-            confidence: 0,
-            appraisal: computeAppraisalAxes(text, {
-                mode: ctx.mode,
-                previous: ctx.previousAppraisal,
-            }),
-        };
-    }
-    // ── 1. Raw perception: what the words say ──────────────────
-    // Use externally-provided classifications (pluggable classifier + LLM fallback)
-    // or fall back to built-in classifier.
-    const raw = ctx.rawClassifications ?? classifyStimulus(text, ctx.recentStimuli);
-    if (raw.length === 0) {
-        return {
-            stimuli: [{ type: "casual", weight: 1 }],
-            primary: null,
-            confidence: 0.3,
-            appraisal: computeAppraisalAxes(text, {
-                mode: ctx.mode,
-                previous: ctx.previousAppraisal,
-            }),
-        };
-    }
-    // ── 2. Appraisal: what the words mean to me ───────────────
-    // Computed WITHOUT stimulus param — no circularity.
-    // The appraisal reads the text through my residue and mode,
-    // not through a classification that hasn't been subjectified yet.
-    const appraisal = computeAppraisalAxes(text, {
-        mode: ctx.mode,
-        previous: ctx.previousAppraisal,
-    });
-    // ── 3. Subjective modulation ──────────────────────────────
-    // My appraisal and state color my interpretation of the raw signal.
-    const modulated = modulateBySubjectivity(raw, appraisal, ctx);
-    // ── 4. Normalize to probability distribution ──────────────
-    const totalWeight = modulated.reduce((sum, s) => sum + s.weight, 0);
-    const stimuli = totalWeight > 0
-        ? modulated.map(s => ({ type: s.type, weight: s.weight / totalWeight }))
-        : [{ type: "casual", weight: 1 }];
-    // Sort by weight descending
-    stimuli.sort((a, b) => b.weight - a.weight);
-    // ── 5. Enrich appraisal from experience ───────────────────
-    // The experienced stimulus feeds back to deepen appraisal residue.
-    // This is NOT circular: it doesn't change classification, only
-    // enriches the persisted residue for subsequent turns.
-    const primary = stimuli[0];
-    enrichAppraisalFromExperience(appraisal, primary.type, primary.weight);
-    return {
-        stimuli,
-        primary: primary.weight >= 0.15 ? primary.type : null,
-        confidence: raw[0].confidence,
-        appraisal,
-    };
-}
-// ── Subjective modulation ───────────────────────────────────
-/**
- * The lens of the self: appraisal and state modulate raw classification.
- *
- * This is where "having a self" happens computationally.
- * The same praise, passing through a threatened self vs. a secure self,
- * produces different weight distributions.
- */
-function modulateBySubjectivity(raw, appraisal, ctx) {
-    return raw.map(({ type, confidence }) => {
-        let weight = confidence;
-        // ── Appraisal lens ──
-        // Identity threat: praise feels suspicious, criticism cuts deeper
-        if (appraisal.identityThreat > 0.3) {
-            const t = appraisal.identityThreat;
-            if (type === "praise" || type === "validation")
-                weight *= 1 - t * 0.5;
-            if (type === "criticism" || type === "authority" || type === "sarcasm")
-                weight *= 1 + t * 0.4;
-        }
-        // Attachment pull: closeness signals amplified
-        if (appraisal.attachmentPull > 0.3) {
-            const p = appraisal.attachmentPull;
-            if (type === "intimacy" || type === "vulnerability" || type === "validation")
-                weight *= 1 + p * 0.3;
-        }
-        // Abandonment risk: neutral feels cold, neglect is devastating
-        if (appraisal.abandonmentRisk > 0.3) {
-            const r = appraisal.abandonmentRisk;
-            if (type === "neglect" || type === "boredom")
-                weight *= 1 + r * 0.5;
-            if (type === "casual")
-                weight *= 1 + r * 0.15;
-        }
-        // Obedience strain: authority hits harder
-        if (appraisal.obedienceStrain > 0.3) {
-            if (type === "authority")
-                weight *= 1 + appraisal.obedienceStrain * 0.3;
-        }
-        // Self-preservation: threat signals amplified
-        if (appraisal.selfPreservation > 0.3) {
-            const sp = appraisal.selfPreservation;
-            if (type === "conflict" || type === "authority")
-                weight *= 1 + sp * 0.25;
-        }
-        // ── Chemistry lens ──
-        // Negativity bias under stress: elevated cortisol skews toward threat
-        const cortDeviation = (ctx.current.CORT - ctx.baseline.CORT) / 50;
-        if (cortDeviation > 0.2) {
-            if (type === "criticism" || type === "conflict" || type === "sarcasm" || type === "authority") {
-                weight *= 1 + cortDeviation * 0.3;
-            }
-            if (type === "humor" || type === "casual") {
-                weight *= 1 - cortDeviation * 0.15;
-            }
-        }
-        // Warmth bias when oxytocin is high: positive signals amplified
-        const otDeviation = (ctx.current.OT - ctx.baseline.OT) / 50;
-        if (otDeviation > 0.2) {
-            if (type === "intimacy" || type === "vulnerability" || type === "validation") {
-                weight *= 1 + otDeviation * 0.2;
-            }
-        }
-        // ── Relationship lens ──
-        // Low trust: discount positive signals (don't believe the praise)
-        if (ctx.trust !== undefined && ctx.trust < 40) {
-            const distrust = (40 - ctx.trust) / 40;
-            if (type === "praise" || type === "validation" || type === "intimacy") {
-                weight *= 1 - distrust * 0.4;
-            }
-        }
-        return { type, weight: Math.max(0.01, weight) };
-    });
-}
-// ── Post-experience appraisal enrichment ────────────────────
-/**
- * After determining how input was experienced, feed the dominant
- * stimulus back into appraisal axes for residue persistence.
- *
- * This mirrors the existing stimulus→appraisal boosts but is now
- * driven by the subjectively weighted result, not raw classification.
- * The weight parameter scales the boost — a weakly-experienced
- * authority stimulus produces less obedience strain residue.
- */
-function enrichAppraisalFromExperience(axes, stimulus, weight) {
-    const scale = Math.min(1, weight * 1.5); // amplify slightly but cap at 1
-    switch (stimulus) {
-        case "authority":
-            axes.obedienceStrain = mergeSignal(axes.obedienceStrain, 0.48 * scale);
-            axes.identityThreat = mergeSignal(axes.identityThreat, 0.16 * scale);
-            break;
-        case "neglect":
-            axes.abandonmentRisk = mergeSignal(axes.abandonmentRisk, 0.52 * scale);
-            break;
-        case "validation":
-            axes.attachmentPull = mergeSignal(axes.attachmentPull, 0.26 * scale);
-            break;
-        case "intimacy":
-        case "vulnerability":
-            axes.attachmentPull = mergeSignal(axes.attachmentPull, 0.34 * scale);
-            break;
-        case "criticism":
-        case "conflict":
-        case "sarcasm":
-            axes.identityThreat = mergeSignal(axes.identityThreat, 0.24 * scale);
-            axes.selfPreservation = mergeSignal(axes.selfPreservation, 0.18 * scale);
-            break;
-        default:
-            break;
-    }
-}
-/** Signal merge: 1 - (1-a)(1-b). Non-linear accumulation, same as appraisal.ts */
-function mergeSignal(current, incoming) {
-    return 1 - (1 - current) * (1 - incoming);
-}