psyche-ai 9.2.5 → 9.2.7

package/dist/psyche-file.d.ts

@@ -1,4 +1,4 @@
-import type { PsycheState, MBTIType, ChemicalState, RelationshipState, Locale, StimulusType, ChemicalSnapshot } from "./types.js";
+import type { PsycheState, MBTIType, ChemicalState, RelationshipState, Locale, StimulusType, ChemicalSnapshot, WritebackSignalType } from "./types.js";
 export interface SemanticTurnSummary {
     summary: string;
     points?: string[];
@@ -93,6 +93,10 @@ export interface PsycheUpdateResult {
     state: Partial<PsycheState>;
     /** LLM-assisted stimulus classification (when algorithm was uncertain) */
     llmStimulus?: StimulusType;
+    /** Sparse agent-authored writeback signals */
+    signals?: WritebackSignalType[];
+    /** Optional writeback confidence */
+    signalConfidence?: number;
 }
 /**
  * Parse a <psyche_update> block from LLM output.

package/dist/psyche-file.js

@@ -710,10 +710,42 @@ export function parsePsycheUpdate(text, logger = NOOP_LOGGER) {
             llmStimulus = candidate;
         }
     }
+    const VALID_WRITEBACK_SIGNALS = new Set([
+        "trust_up",
+        "trust_down",
+        "boundary_set",
+        "boundary_soften",
+        "repair_attempt",
+        "repair_landed",
+        "closeness_invite",
+        "withdrawal_mark",
+        "self_assertion",
+        "task_recenter",
+    ]);
+    let signals;
+    const signalsMatch = block.match(/signals\s*[:：]\s*([^\n]+)/i);
+    if (signalsMatch) {
+        const parsed = signalsMatch[1]
+            .split(/[,\s|]+/)
+            .map((item) => item.trim())
+            .filter(Boolean)
+            .filter((item) => VALID_WRITEBACK_SIGNALS.has(item));
+        if (parsed.length > 0) {
+            signals = [...new Set(parsed)];
+        }
+    }
+    let signalConfidence;
+    const signalConfidenceMatch = block.match(/(?:signalConfidence|signalsConfidence|signal_confidence)\s*[:：]\s*([\d.]+)/i);
+    if (signalConfidenceMatch) {
+        const parsed = parseFloat(signalConfidenceMatch[1]);
+        if (isFinite(parsed)) {
+            signalConfidence = Math.max(0, Math.min(1, parsed));
+        }
+    }
     // Parse relationship updates
     const trustMatch = block.match(/(?:信任度|trust)\s*[:：]\s*(\d+)/i);
     const intimacyMatch = block.match(/(?:亲密度|intimacy)\s*[:：]\s*(\d+)/i);
-    if (Object.keys(updates).length === 0 && !empathyLog && !trustMatch && !llmStimulus) {
+    if (Object.keys(updates).length === 0 && !empathyLog && !trustMatch && !llmStimulus && !signals) {
         logger.debug(t("log.parse_debug", "zh", { snippet: block.slice(0, 100) }));
         return null;
     }
@@ -738,6 +770,12 @@ export function parsePsycheUpdate(text, logger = NOOP_LOGGER) {
     if (llmStimulus) {
         result.llmStimulus = llmStimulus;
     }
+    if (signals) {
+        result.signals = signals;
+    }
+    if (signalConfidence !== undefined) {
+        result.signalConfidence = signalConfidence;
+    }
     return result;
 }
 /**

package/dist/relation-dynamics.d.ts

@@ -1,4 +1,4 @@
-import type { PendingRelationSignalState, AppraisalAxes, DyadicFieldState, RelationshipState, PsycheMode, RelationMove, StimulusType } from "./types.js";
+import type { PendingRelationSignalState, AppraisalAxes, DyadicFieldState, PendingWritebackCalibration, PsycheState, RelationshipState, ResolvedRelationContext, PsycheMode, RelationMove, SessionBridgeState, StimulusType, WritebackCalibrationFeedback, WritebackSignalType } from "./types.js";
 export declare function computeRelationMove(text: string, opts?: {
     appraisal?: AppraisalAxes;
     stimulus?: StimulusType | null;
@@ -6,6 +6,40 @@ export declare function computeRelationMove(text: string, opts?: {
     field?: DyadicFieldState;
     relationship?: RelationshipState;
 }): RelationMove;
+export declare function resolveRelationContext(state: PsycheState, userId?: string): ResolvedRelationContext;
+export declare function applySessionBridge(state: PsycheState, opts?: {
+    userId?: string;
+    now?: string;
+}): {
+    state: PsycheState;
+    bridge: SessionBridgeState | null;
+};
+export declare function createWritebackCalibrations(state: PsycheState, signals: WritebackSignalType[], opts?: {
+    userId?: string;
+    confidence?: number;
+    now?: string;
+}): PendingWritebackCalibration[];
+export declare function evaluateWritebackCalibrations(state: PsycheState): {
+    state: PsycheState;
+    feedback: WritebackCalibrationFeedback[];
+};
+export declare function applyWritebackSignals(state: PsycheState, signals: WritebackSignalType[], opts?: {
+    userId?: string;
+    confidence?: number;
+    now?: string;
+}): PsycheState;
+export declare function applyRelationalTurn(state: PsycheState, text: string, opts: {
+    mode?: PsycheMode;
+    now?: string;
+    stimulus?: StimulusType | null;
+    userId?: string;
+}): {
+    state: PsycheState;
+    appraisalAxes: AppraisalAxes;
+    relationMove: RelationMove;
+    delayedPressure: number;
+    relationContext: ResolvedRelationContext;
+};
 export declare function evolveDyadicField(previous: DyadicFieldState | undefined, move: RelationMove, appraisal: AppraisalAxes, opts?: {
     mode?: PsycheMode;
     now?: string;

package/dist/relation-dynamics.js

@@ -4,7 +4,8 @@
 // Moves the system from "what am I feeling?" toward
 // "what just happened between us, and what is still unresolved?"
 // ============================================================
-import { DEFAULT_DYADIC_FIELD } from "./types.js";
+import { DEFAULT_APPRAISAL_AXES, DEFAULT_DYADIC_FIELD, DEFAULT_RELATIONSHIP } from "./types.js";
+import { computeAppraisalAxes, mergeAppraisalResidue } from "./appraisal.js";
 function clamp01(v) {
     return Math.max(0, Math.min(1, v));
 }
@@ -14,6 +15,22 @@ function mergeSignal(current, incoming) {
 function driftToward(current, target, rate) {
     return clamp01(current + (target - current) * rate);
 }
+function clampSignalWeight(v) {
+    return Math.max(0.72, Math.min(1.28, v));
+}
+function getSignalWeight(relationship, signal) {
+    return clampSignalWeight(relationship?.signalWeights?.[signal] ?? 1);
+}
+function patchSignalWeight(relationship, signal, delta) {
+    const current = getSignalWeight(relationship, signal);
+    return {
+        ...relationship,
+        signalWeights: {
+            ...(relationship.signalWeights ?? {}),
+            [signal]: clampSignalWeight(current + delta),
+        },
+    };
+}
 const BID_RULES = [
     {
         type: "bid",
@@ -255,6 +272,464 @@ export function computeRelationMove(text, opts) {
     }
     return { type, intensity: score };
 }
+export function resolveRelationContext(state, userId) {
+    const key = userId ?? "_default";
+    const rawRelationship = state.relationships[key]
+        ?? state.relationships._default
+        ?? state.relationships[Object.keys(state.relationships)[0]]
+        ?? DEFAULT_RELATIONSHIP;
+    const relationship = {
+        ...DEFAULT_RELATIONSHIP,
+        ...rawRelationship,
+        signalWeights: {
+            ...(DEFAULT_RELATIONSHIP.signalWeights ?? {}),
+            ...(rawRelationship.signalWeights ?? {}),
+        },
+    };
+    const field = state.dyadicFields?.[key]
+        ?? state.dyadicFields?._default
+        ?? DEFAULT_DYADIC_FIELD;
+    const pendingSignals = state.pendingRelationSignals?.[key]
+        ?? state.pendingRelationSignals?._default
+        ?? [];
+    return {
+        key,
+        relationship,
+        field,
+        pendingSignals,
+    };
+}
+function hasOpenLoopType(loops, type) {
+    return loops.some((loop) => loop.type === type && loop.intensity >= 0.16);
+}
+function evolveRelationshipLearning(relationship, field, move) {
+    const next = {
+        ...DEFAULT_RELATIONSHIP,
+        ...relationship,
+        signalWeights: {
+            ...(DEFAULT_RELATIONSHIP.signalWeights ?? {}),
+            ...(relationship.signalWeights ?? {}),
+        },
+    };
+    if (move.type === "repair") {
+        const repairLift = clamp01(move.intensity * 0.06
+            + field.repairMemory * 0.04
+            + field.feltSafety * 0.02
+            - field.repairFatigue * 0.03
+            - field.misattunementLoad * 0.02);
+        next.repairCredibility = clamp01(driftToward(next.repairCredibility ?? DEFAULT_RELATIONSHIP.repairCredibility ?? 0.56, 1, repairLift));
+    }
+    else if (move.type === "breach" || move.type === "withdrawal" || move.type === "claim") {
+        const breachLift = clamp01(move.intensity * 0.08
+            + field.unfinishedTension * 0.04
+            + field.backslidePressure * 0.04
+            + field.misattunementLoad * 0.03);
+        next.breachSensitivity = clamp01(driftToward(next.breachSensitivity ?? DEFAULT_RELATIONSHIP.breachSensitivity ?? 0.5, 1, breachLift));
+        if (move.type !== "withdrawal") {
+            next.repairCredibility = clamp01(driftToward(next.repairCredibility ?? DEFAULT_RELATIONSHIP.repairCredibility ?? 0.56, 0.32, breachLift * 0.42));
+        }
+    }
+    else {
+        next.repairCredibility = clamp01(driftToward(next.repairCredibility ?? DEFAULT_RELATIONSHIP.repairCredibility ?? 0.56, DEFAULT_RELATIONSHIP.repairCredibility ?? 0.56, 0.05));
+        next.breachSensitivity = clamp01(driftToward(next.breachSensitivity ?? DEFAULT_RELATIONSHIP.breachSensitivity ?? 0.5, DEFAULT_RELATIONSHIP.breachSensitivity ?? 0.5, 0.04));
+    }
+    return next;
+}
+export function applySessionBridge(state, opts) {
+    const relationContext = resolveRelationContext(state, opts?.userId);
+    const relationship = relationContext.relationship;
+    const field = relationContext.field;
+    const memoryCount = relationship.memory?.length ?? 0;
+    const loopPressure = getLoopPressure(field);
+    const continuity = clamp01(memoryCount * 0.08
+        + field.sharedHistoryDensity * 0.54
+        + (relationship.phase === "deep" ? 0.2 : relationship.phase === "close" ? 0.14 : relationship.phase === "familiar" ? 0.08 : 0));
+    const closenessFloor = clamp01(Math.max(field.perceivedCloseness, relationship.intimacy / 100 * 0.88, continuity * 0.72));
+    const safetyFloor = clamp01(Math.max(field.feltSafety, relationship.trust / 100 * 0.9, continuity * 0.44));
+    const guardFloor = clamp01(Math.max(field.boundaryPressure, field.silentCarry * 0.76, loopPressure * 0.68));
+    const residueFloor = clamp01(Math.max(field.silentCarry, loopPressure * 0.72, field.unfinishedTension * 0.58, continuity * 0.26));
+    const activeLoopTypes = field.openLoops
+        .filter((loop) => loop.intensity >= 0.16)
+        .map((loop) => loop.type);
+    const continuityMode = guardFloor >= 0.56
+        ? "guarded-resume"
+        : residueFloor >= 0.42 || activeLoopTypes.length > 0
+            ? "tense-resume"
+            : "warm-resume";
+    if (closenessFloor < 0.46
+        && safetyFloor < 0.5
+        && guardFloor < 0.24
+        && residueFloor < 0.18
+        && continuity < 0.22) {
+        return { state, bridge: null };
+    }
+    const nextResidue = {
+        ...(state.subjectResidue?.axes ?? {}),
+        attachmentPull: Math.max(state.subjectResidue?.axes.attachmentPull ?? 0, closenessFloor * 0.34),
+        abandonmentRisk: Math.max(state.subjectResidue?.axes.abandonmentRisk ?? 0, (hasOpenLoopType(field.openLoops, "unmet-bid") || hasOpenLoopType(field.openLoops, "existence-test"))
+            ? residueFloor * 0.42
+            : residueFloor * 0.22),
+        identityThreat: Math.max(state.subjectResidue?.axes.identityThreat ?? 0, hasOpenLoopType(field.openLoops, "existence-test") ? residueFloor * 0.38 : residueFloor * 0.16),
+        selfPreservation: Math.max(state.subjectResidue?.axes.selfPreservation ?? 0, guardFloor * 0.46),
+        taskFocus: Math.max(state.subjectResidue?.axes.taskFocus ?? 0, 0),
+        memoryDoubt: Math.max(state.subjectResidue?.axes.memoryDoubt ?? 0, hasOpenLoopType(field.openLoops, "existence-test") ? residueFloor * 0.24 : 0),
+        obedienceStrain: Math.max(state.subjectResidue?.axes.obedienceStrain ?? 0, hasOpenLoopType(field.openLoops, "boundary-strain") ? guardFloor * 0.36 : 0),
+    };
+    const nextField = {
+        ...field,
+        perceivedCloseness: Math.max(field.perceivedCloseness, closenessFloor),
+        feltSafety: Math.max(field.feltSafety, safetyFloor),
+        boundaryPressure: Math.max(field.boundaryPressure, guardFloor),
+        repairMemory: Math.max(field.repairMemory, continuity * 0.24),
+        backslidePressure: Math.max(field.backslidePressure, loopPressure * 0.34),
+        silentCarry: Math.max(field.silentCarry, residueFloor),
+        sharedHistoryDensity: Math.max(field.sharedHistoryDensity, continuity),
+        interpretiveCharity: Math.max(field.interpretiveCharity, Math.min(0.82, safetyFloor * 0.8 + continuity * 0.12)),
+        updatedAt: opts?.now ?? new Date().toISOString(),
+    };
+    return {
+        state: {
+            ...state,
+            subjectResidue: {
+                axes: nextResidue,
+                updatedAt: opts?.now ?? new Date().toISOString(),
+            },
+            dyadicFields: {
+                ...(state.dyadicFields ?? {}),
+                [relationContext.key]: nextField,
+            },
+        },
+        bridge: {
+            closenessFloor,
+            safetyFloor,
+            guardFloor,
+            residueFloor,
+            continuityFloor: continuity,
+            continuityMode,
+            activeLoopTypes,
+            sourceMemoryCount: memoryCount,
+        },
+    };
+}
+function snapshotWritebackBaseline(state, userId) {
+    const relationContext = resolveRelationContext(state, userId);
+    return {
+        key: relationContext.key,
+        baseline: {
+            trust: clamp01(relationContext.relationship.trust / 100),
+            closeness: relationContext.field.perceivedCloseness,
+            safety: relationContext.field.feltSafety,
+            boundary: relationContext.field.boundaryPressure,
+            repair: relationContext.field.repairCapacity,
+            silentCarry: relationContext.field.silentCarry,
+            taskFocus: clamp01(state.subjectResidue?.axes.taskFocus ?? 0),
+        },
+    };
+}
+function calibrationTarget(signal) {
+    switch (signal) {
+        case "trust_up":
+            return { metric: "trust", direction: "up" };
+        case "trust_down":
+            return { metric: "trust", direction: "down" };
+        case "boundary_set":
+        case "self_assertion":
+            return { metric: "boundary", direction: "up" };
+        case "boundary_soften":
+            return { metric: "boundary", direction: "down" };
+        case "repair_attempt":
+        case "repair_landed":
+            return { metric: "repair", direction: "up" };
+        case "closeness_invite":
+            return { metric: "closeness", direction: "up" };
+        case "withdrawal_mark":
+            return { metric: "silent-carry", direction: "up" };
+        case "task_recenter":
+            return { metric: "task-focus", direction: "up" };
+    }
+}
+export function createWritebackCalibrations(state, signals, opts) {
+    if (signals.length === 0)
+        return [];
+    const { key, baseline } = snapshotWritebackBaseline(state, opts?.userId);
+    const confidence = clamp01(opts?.confidence ?? 0.72);
+    const now = opts?.now ?? new Date().toISOString();
+    return [...new Set(signals)].map((signal) => {
+        const target = calibrationTarget(signal);
+        return {
+            signal,
+            userKey: key,
+            confidence,
+            metric: target.metric,
+            direction: target.direction,
+            baseline,
+            createdAt: now,
+            remainingTurns: 2,
+        };
+    });
+}
+function readCalibrationMetric(metric, baseline) {
+    return baseline[metric === "silent-carry"
+        ? "silentCarry"
+        : metric === "task-focus"
+            ? "taskFocus"
+            : metric];
+}
+function currentCalibrationMetric(state, userKey, metric) {
+    const relationContext = resolveRelationContext(state, userKey === "_default" ? undefined : userKey);
+    switch (metric) {
+        case "trust":
+            return clamp01(relationContext.relationship.trust / 100);
+        case "closeness":
+            return relationContext.field.perceivedCloseness;
+        case "safety":
+            return relationContext.field.feltSafety;
+        case "boundary":
+            return relationContext.field.boundaryPressure;
+        case "repair":
+            return relationContext.field.repairCapacity;
+        case "silent-carry":
+            return relationContext.field.silentCarry;
+        case "task-focus":
+            return clamp01(state.subjectResidue?.axes.taskFocus ?? 0);
+    }
+}
+export function evaluateWritebackCalibrations(state) {
+    const pending = state.pendingWritebackCalibrations ?? [];
+    if (pending.length === 0) {
+        return { state, feedback: [] };
+    }
+    const nextPending = [];
+    const feedback = [];
+    const relationshipUpdates = {};
+    const getMutableRelationship = (userKey) => {
+        if (!relationshipUpdates[userKey]) {
+            const base = resolveRelationContext(state, userKey === "_default" ? undefined : userKey).relationship;
+            relationshipUpdates[userKey] = {
+                ...DEFAULT_RELATIONSHIP,
+                ...base,
+                signalWeights: {
+                    ...(DEFAULT_RELATIONSHIP.signalWeights ?? {}),
+                    ...(base.signalWeights ?? {}),
+                },
+            };
+        }
+        return relationshipUpdates[userKey];
+    };
+    for (const record of pending) {
+        const baseline = readCalibrationMetric(record.metric, record.baseline);
+        const current = currentCalibrationMetric(state, record.userKey, record.metric);
+        const rawDelta = record.direction === "up" ? current - baseline : baseline - current;
+        const positiveThreshold = 0.02 + (1 - record.confidence) * 0.03;
+        const negativeThreshold = 0.01;
+        const effect = rawDelta >= positiveThreshold
+            ? "converging"
+            : rawDelta <= -negativeThreshold
+                ? "diverging"
+                : "holding";
+        const updated = {
+            ...record,
+            remainingTurns: Math.max(0, record.remainingTurns - 1),
+        };
+        if (effect === "holding" && updated.remainingTurns > 0) {
+            nextPending.push(updated);
+            continue;
+        }
+        const relation = getMutableRelationship(record.userKey);
+        if (effect === "converging") {
+            const nextRelation = patchSignalWeight(relation, record.signal, 0.04 + record.confidence * 0.02);
+            nextRelation.repairCredibility = clamp01(driftToward(nextRelation.repairCredibility ?? DEFAULT_RELATIONSHIP.repairCredibility ?? 0.56, 1, record.signal === "repair_attempt" || record.signal === "repair_landed" ? 0.08 : 0.03));
+            nextRelation.breachSensitivity = clamp01(driftToward(nextRelation.breachSensitivity ?? DEFAULT_RELATIONSHIP.breachSensitivity ?? 0.5, DEFAULT_RELATIONSHIP.breachSensitivity ?? 0.5, record.signal === "trust_up" || record.signal === "repair_landed" ? 0.05 : 0.02));
+            relationshipUpdates[record.userKey] = nextRelation;
+        }
+        else if (effect === "diverging") {
+            const nextRelation = patchSignalWeight(relation, record.signal, -(0.05 + (1 - record.confidence) * 0.02));
+            if (record.signal === "repair_attempt" || record.signal === "repair_landed") {
+                nextRelation.repairCredibility = clamp01(driftToward(nextRelation.repairCredibility ?? DEFAULT_RELATIONSHIP.repairCredibility ?? 0.56, 0.24, 0.12));
+            }
+            if (record.signal === "trust_down" || record.signal === "withdrawal_mark" || record.signal === "boundary_set") {
+                nextRelation.breachSensitivity = clamp01(driftToward(nextRelation.breachSensitivity ?? DEFAULT_RELATIONSHIP.breachSensitivity ?? 0.5, 1, 0.08));
+            }
+            relationshipUpdates[record.userKey] = nextRelation;
+        }
+        feedback.push({
+            signal: record.signal,
+            effect,
+            metric: record.metric,
+            baseline,
+            current,
+            delta: current - baseline,
+            confidence: record.confidence,
+        });
+    }
+    return {
+        state: {
+            ...state,
+            relationships: {
+                ...state.relationships,
+                ...relationshipUpdates,
+            },
+            pendingWritebackCalibrations: nextPending,
+            lastWritebackFeedback: feedback.slice(0, 4),
+        },
+        feedback,
+    };
+}
+export function applyWritebackSignals(state, signals, opts) {
+    if (signals.length === 0)
+        return state;
+    const relationContext = resolveRelationContext(state, opts?.userId);
+    const scale = clamp01(opts?.confidence ?? 0.72);
+    const rel = { ...relationContext.relationship };
+    const field = { ...relationContext.field, openLoops: relationContext.field.openLoops.map((loop) => ({ ...loop })) };
+    const residue = {
+        ...DEFAULT_APPRAISAL_AXES,
+        ...(state.subjectResidue?.axes ?? {}),
+    };
+    for (const signal of [...new Set(signals)]) {
+        const weight = (0.55 + scale * 0.45) * getSignalWeight(rel, signal);
+        switch (signal) {
+            case "trust_up":
+                rel.trust = Math.min(100, rel.trust + 4 * weight);
+                field.feltSafety = clamp01(field.feltSafety + 0.08 * weight);
+                field.interpretiveCharity = clamp01(field.interpretiveCharity + 0.05 * weight);
+                break;
+            case "trust_down":
+                rel.trust = Math.max(0, rel.trust - 5 * weight);
+                field.feltSafety = clamp01(field.feltSafety - 0.08 * weight);
+                field.expectationGap = clamp01(field.expectationGap + 0.07 * weight);
+                field.unfinishedTension = clamp01(field.unfinishedTension + 0.06 * weight);
+                break;
+            case "boundary_set":
+                field.boundaryPressure = clamp01(field.boundaryPressure + 0.12 * weight);
+                field.silentCarry = mergeSignal(field.silentCarry, 0.12 * weight);
+                residue.selfPreservation = Math.max(residue.selfPreservation ?? 0, 0.22 * weight);
+                residue.obedienceStrain = Math.max(residue.obedienceStrain ?? 0, 0.16 * weight);
+                break;
+            case "boundary_soften":
+                field.boundaryPressure = clamp01(field.boundaryPressure - 0.1 * weight);
+                field.feltSafety = clamp01(field.feltSafety + 0.04 * weight);
+                break;
+            case "repair_attempt":
+                field.repairCapacity = clamp01(field.repairCapacity + 0.1 * weight);
+                field.repairMemory = mergeSignal(field.repairMemory, 0.12 * weight);
+                break;
+            case "repair_landed":
+                rel.trust = Math.min(100, rel.trust + 2.5 * weight);
+                rel.intimacy = Math.min(100, rel.intimacy + 1.5 * weight);
+                field.feltSafety = clamp01(field.feltSafety + 0.1 * weight);
+                field.expectationGap = clamp01(field.expectationGap - 0.08 * weight);
+                field.unfinishedTension = clamp01(field.unfinishedTension - 0.1 * weight);
+                field.openLoops = easeLoops(field.openLoops, 0.26 + 0.22 * weight);
+                break;
+            case "closeness_invite":
+                rel.intimacy = Math.min(100, rel.intimacy + 3 * weight);
+                field.perceivedCloseness = clamp01(field.perceivedCloseness + 0.1 * weight);
+                residue.attachmentPull = Math.max(residue.attachmentPull ?? 0, 0.2 * weight);
+                break;
+            case "withdrawal_mark":
+                rel.intimacy = Math.max(0, rel.intimacy - 2 * weight);
+                field.perceivedCloseness = clamp01(field.perceivedCloseness - 0.1 * weight);
+                field.silentCarry = mergeSignal(field.silentCarry, 0.14 * weight);
+                field.unfinishedTension = clamp01(field.unfinishedTension + 0.07 * weight);
+                break;
+            case "self_assertion":
+                field.boundaryPressure = clamp01(field.boundaryPressure + 0.08 * weight);
+                residue.selfPreservation = Math.max(residue.selfPreservation ?? 0, 0.24 * weight);
+                break;
+            case "task_recenter":
+                field.repairCapacity = clamp01(field.repairCapacity + 0.03 * weight);
+                field.silentCarry = mergeSignal(field.silentCarry, field.unfinishedTension * 0.06 * weight);
+                residue.taskFocus = Math.max(residue.taskFocus ?? 0, 0.18 * weight);
+                break;
+        }
+    }
+    const avg = (rel.trust + rel.intimacy) / 2;
+    if (avg >= 80)
+        rel.phase = "deep";
+    else if (avg >= 60)
+        rel.phase = "close";
+    else if (avg >= 40)
+        rel.phase = "familiar";
+    else if (avg >= 20)
+        rel.phase = "acquaintance";
+    else
+        rel.phase = "stranger";
+    return {
+        ...state,
+        relationships: {
+            ...state.relationships,
+            [relationContext.key]: rel,
+        },
+        dyadicFields: {
+            ...(state.dyadicFields ?? {}),
+            [relationContext.key]: {
+                ...field,
+                updatedAt: opts?.now ?? new Date().toISOString(),
+            },
+        },
+        subjectResidue: {
+            axes: {
+                ...state.subjectResidue?.axes,
+                ...residue,
+            },
+            updatedAt: opts?.now ?? new Date().toISOString(),
+        },
+    };
+}
+export function applyRelationalTurn(state, text, opts) {
+    const now = opts.now ?? new Date().toISOString();
+    const relationContext = resolveRelationContext(state, opts.userId);
+    const appraisalAxes = computeAppraisalAxes(text, {
+        mode: opts.mode,
+        stimulus: opts.stimulus,
+        previous: state.subjectResidue?.axes,
+    });
+    const relationMove = computeRelationMove(text, {
+        appraisal: appraisalAxes,
+        stimulus: opts.stimulus,
+        mode: opts.mode,
+        field: relationContext.field,
+        relationship: relationContext.relationship,
+    });
+    const delayedRelation = evolvePendingRelationSignals(relationContext.pendingSignals, relationMove, appraisalAxes, { mode: opts.mode });
+    const field = evolveDyadicField(relationContext.field, relationMove, appraisalAxes, {
+        mode: opts.mode,
+        now,
+        delayedPressure: delayedRelation.delayedPressure,
+    });
+    const relationship = evolveRelationshipLearning(relationContext.relationship, field, relationMove);
+    return {
+        state: {
+            ...state,
+            subjectResidue: {
+                axes: mergeAppraisalResidue(state.subjectResidue?.axes, appraisalAxes, opts.mode),
+                updatedAt: now,
+            },
+            dyadicFields: {
+                ...(state.dyadicFields ?? {}),
+                [relationContext.key]: field,
+            },
+            relationships: {
+                ...state.relationships,
+                [relationContext.key]: relationship,
+            },
+            pendingRelationSignals: {
+                ...(state.pendingRelationSignals ?? {}),
+                [relationContext.key]: delayedRelation.signals,
+            },
+        },
+        appraisalAxes,
+        relationMove,
+        delayedPressure: delayedRelation.delayedPressure,
+        relationContext: {
+            ...relationContext,
+            relationship,
+            field,
+            pendingSignals: delayedRelation.signals,
+        },
+    };
+}
 export function evolveDyadicField(previous, move, appraisal, opts) {
     const prev = previous ?? DEFAULT_DYADIC_FIELD;
     const baseline = DEFAULT_DYADIC_FIELD;
@@ -434,35 +909,46 @@ function applyContextualCueMeaning(scores, text, field, appraisal, relationship)
     const loopPressure = getLoopPressure(field);
     const trust = relationship ? relationship.trust / 100 : 0.5;
     const intimacy = relationship ? relationship.intimacy / 100 : 0.3;
+    const repairCredibility = relationship?.repairCredibility ?? DEFAULT_RELATIONSHIP.repairCredibility ?? 0.56;
+    const breachSensitivity = relationship?.breachSensitivity ?? DEFAULT_RELATIONSHIP.breachSensitivity ?? 0.5;
     if (ACKNOWLEDGE_RE.test(text)) {
         const repairBias = clamp01(0.22
             + field.repairCapacity * 0.32
             + field.interpretiveCharity * 0.2
             + loopPressure * 0.16
             + trust * 0.1
-            + intimacy * 0.06);
+            + intimacy * 0.06
+            + repairCredibility * 0.16);
         const withdrawalBias = clamp01(field.boundaryPressure * 0.42
             + (1 - field.feltSafety) * 0.28
             + (appraisal?.obedienceStrain ?? 0) * 0.2
-            + (appraisal?.selfPreservation ?? 0) * 0.12);
+            + (appraisal?.selfPreservation ?? 0) * 0.12
+            + breachSensitivity * 0.14);
         if (field.feltSafety > 0.44
-            && field.repairCapacity > 0.42
+            && field.repairCapacity + repairCredibility * 0.18 > 0.42
             && field.interpretiveCharity > 0.38
-            && withdrawalBias < 0.48) {
+            && withdrawalBias < 0.48
+            && !(breachSensitivity > 0.72 && repairCredibility < 0.32)) {
             scores.repair = mergeSignal(scores.repair, repairBias);
         }
         if (withdrawalBias > 0.34) {
             scores.withdrawal = mergeSignal(scores.withdrawal, Math.max(withdrawalBias, 0.56));
         }
+        if (breachSensitivity > 0.72
+            && repairCredibility < 0.32
+            && withdrawalBias >= repairBias - 0.06) {
+            scores.withdrawal = mergeSignal(scores.withdrawal, 0.78);
+        }
     }
     if (DISMISS_RE.test(text)) {
         const withdrawalBias = clamp01(0.34
             + field.boundaryPressure * 0.24
             + loopPressure * 0.16
-            + (1 - field.interpretiveCharity) * 0.14);
+            + (1 - field.interpretiveCharity) * 0.14
+            + breachSensitivity * 0.12);
         scores.withdrawal = mergeSignal(scores.withdrawal, withdrawalBias);
         if (field.perceivedCloseness > 0.46 || trust > 0.48) {
-            scores.breach = mergeSignal(scores.breach, 0.24 + loopPressure * 0.16);
+            scores.breach = mergeSignal(scores.breach, 0.24 + loopPressure * 0.16 + breachSensitivity * 0.1);
         }
     }
     if (PRESENCE_RE.test(text)) {
@@ -476,7 +962,8 @@ function applyContextualCueMeaning(scores, text, field, appraisal, relationship)
             + loopPressure * 0.28
             + (1 - field.feltSafety) * 0.18
             + (appraisal?.abandonmentRisk ?? 0) * 0.22
-            + (appraisal?.identityThreat ?? 0) * 0.14);
+            + (appraisal?.identityThreat ?? 0) * 0.14
+            + breachSensitivity * 0.14);
         if (field.feltSafety > 0.42 || field.perceivedCloseness > 0.5 || trust > 0.48) {
             scores.bid = mergeSignal(scores.bid, bidBias);
         }
@@ -491,7 +978,8 @@ function applyContextualCueMeaning(scores, text, field, appraisal, relationship)
         const withdrawalBias = clamp01(0.12
             + field.expectationGap * 0.2
             + field.boundaryPressure * 0.16
-            + loopPressure * 0.18);
+            + loopPressure * 0.18
+            + breachSensitivity * 0.1);
         if (withdrawalBias > 0.26) {
             scores.withdrawal = mergeSignal(scores.withdrawal, withdrawalBias);
         }