psyche-ai 9.2.6 → 9.2.8

package/dist/relation-dynamics.js

@@ -4,7 +4,7 @@
 // Moves the system from "what am I feeling?" toward
 // "what just happened between us, and what is still unresolved?"
 // ============================================================
-import { DEFAULT_DYADIC_FIELD, DEFAULT_RELATIONSHIP } 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));
@@ -15,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",
@@ -258,15 +274,21 @@ export function computeRelationMove(text, opts) {
 }
 export function resolveRelationContext(state, userId) {
     const key = userId ?? "_default";
-    const relationship = state.relationships[key]
+    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,
@@ -275,6 +297,384 @@ export function resolveRelationContext(state, userId) {
         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);
@@ -296,6 +696,7 @@ export function applyRelationalTurn(state, text, opts) {
         now,
         delayedPressure: delayedRelation.delayedPressure,
     });
+    const relationship = evolveRelationshipLearning(relationContext.relationship, field, relationMove);
     return {
         state: {
             ...state,
@@ -307,6 +708,10 @@ export function applyRelationalTurn(state, text, opts) {
                 ...(state.dyadicFields ?? {}),
                 [relationContext.key]: field,
             },
+            relationships: {
+                ...state.relationships,
+                [relationContext.key]: relationship,
+            },
             pendingRelationSignals: {
                 ...(state.pendingRelationSignals ?? {}),
                 [relationContext.key]: delayedRelation.signals,
@@ -317,6 +722,7 @@ export function applyRelationalTurn(state, text, opts) {
         delayedPressure: delayedRelation.delayedPressure,
         relationContext: {
             ...relationContext,
+            relationship,
             field,
             pendingSignals: delayedRelation.signals,
         },
@@ -501,35 +907,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)) {
@@ -543,7 +960,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);
         }
@@ -558,7 +976,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);
         }

package/dist/reply-envelope.d.ts

@@ -1,9 +1,13 @@
 import type { AppraisalAxes, GenerationControls, Locale, PolicyModifiers, PsycheState, ResolvedRelationContext, ResponseContract, StimulusType, SubjectivityKernel } from "./types.js";
 export interface ReplyEnvelope {
-    policyModifiers: PolicyModifiers;
     subjectivityKernel: SubjectivityKernel;
     responseContract: ResponseContract;
     generationControls: GenerationControls;
+}
+export interface DerivedReplyEnvelope extends ReplyEnvelope {
+    /** Legacy/internal control vector kept for compatibility and prompt derivation. */
+    policyModifiers: PolicyModifiers;
+    /** Legacy/internal compact prose derived from policyModifiers. */
     policyContext: string;
     subjectivityContext: string;
     responseContractContext: string;
@@ -12,6 +16,7 @@ export declare function deriveReplyEnvelope(state: PsycheState, appraisal: Appra
     locale: Locale;
     userText?: string;
     algorithmStimulus?: StimulusType | null;
+    classificationConfidence?: number;
     personalityIntensity?: number;
     relationContext?: ResolvedRelationContext;
-}): ReplyEnvelope;
+}): DerivedReplyEnvelope;

package/dist/reply-envelope.js

@@ -15,6 +15,7 @@ export function deriveReplyEnvelope(state, appraisal, opts) {
         locale: opts.locale,
         userText: opts.userText,
         algorithmStimulus: opts.algorithmStimulus,
+        classificationConfidence: opts.classificationConfidence,
         personalityIntensity: opts.personalityIntensity,
     });
     const generationControls = deriveGenerationControls({
@@ -25,10 +26,10 @@ export function deriveReplyEnvelope(state, appraisal, opts) {
     const subjectivityContext = buildSubjectivityContext(subjectivityKernel, opts.locale);
     const responseContractContext = buildResponseContractContext(responseContract, opts.locale);
     return {
-        policyModifiers,
         subjectivityKernel,
         responseContract,
         generationControls,
+        policyModifiers,
         policyContext,
         subjectivityContext,
         responseContractContext,

package/dist/response-contract.d.ts

@@ -3,6 +3,7 @@ export declare function computeResponseContract(kernel: SubjectivityKernel, opts
     locale?: Locale;
     userText?: string;
     algorithmStimulus?: StimulusType | null;
+    classificationConfidence?: number;
     personalityIntensity?: number;
 }): ResponseContract;
 export declare function buildResponseContractContext(contract: ResponseContract, locale?: Locale): string;