psyche-ai 9.2.6 → 9.2.8

package/dist/response-contract.js

@@ -172,9 +172,14 @@ function computeLengthBudget(locale, userText, replyProfile, expressionMode, ker
 }
 function buildStimulusReportingGuide(locale) {
     if (locale === "zh") {
-        return "stimulus速记:闲聊casual/命令authority/认同validation/示弱vulnerability/冷淡neglect/批评criticism";
+        return "stimulus速记:闲聊/命令/认同/示弱/冷淡/批评";
     }
-    return "stimulus map: chat=casual / command=authority / agreement=validation / vulnerable=vulnerability / cold=neglect / criticism=criticism";
+    return "stimulus map: chat/command/validation/vulnerability/neglect/criticism";
+}
+function buildWritebackGuide(locale) {
+    return locale === "zh"
+        ? "signals可写"
+        : "signals writable";
 }
 function detectToneParticles(userText, locale) {
     if (locale !== "zh")
@@ -195,6 +200,12 @@ export function computeResponseContract(kernel, opts) {
     const userText = opts?.userText ?? "";
     const personalityIntensity = opts?.personalityIntensity ?? 0.7;
     const { replyProfile, replyProfileBasis } = deriveReplyProfile(kernel);
+    const classificationConfidence = opts?.classificationConfidence ?? 0;
+    const overrideWindow = classificationConfidence >= 0.78
+        ? "narrow"
+        : classificationConfidence >= 0.62
+            ? "balanced"
+            : "wide";
     const { maxSentences, maxChars } = userText.length > 0
         ? computeLengthBudget(locale, userText, replyProfile, kernel.expressionMode, kernel)
         : {
@@ -267,6 +278,7 @@ export function computeResponseContract(kernel, opts) {
     return {
         replyProfile,
         replyProfileBasis,
+        overrideWindow,
         maxSentences,
         maxChars,
         expressionMode: kernel.expressionMode,
@@ -283,40 +295,54 @@ function describeReplyProfileBasis(basis, locale) {
     if (locale === "zh") {
         switch (basis) {
             case "task-focus":
-                return "因:聚焦";
+                return "因:聚";
             case "discipline":
-                return "因:纪律";
+                return "因:纪";
             case "task-focus+discipline":
-                return "因:聚焦+纪律";
+                return "因:聚+纪";
             default:
-                return "因:默认私人";
+                return "因:私";
         }
     }
     return `basis:${basis}`;
 }
+function describeOverrideWindow(overrideWindow, locale) {
+    if (locale === "zh") {
+        switch (overrideWindow) {
+            case "narrow":
+                return "终判窗:窄";
+            case "balanced":
+                return "终判窗:中";
+            default:
+                return "终判窗:宽";
+        }
+    }
+    return `override:${overrideWindow}`;
+}
 export function buildResponseContractContext(contract, locale = "zh") {
     if (locale === "zh") {
         const parts = [];
-        parts.push(contract.replyProfile === "work" ? "工作面" : "私人面");
+        parts.push(contract.replyProfile === "work" ? "工作" : "私人");
         parts.push(describeReplyProfileBasis(contract.replyProfileBasis, locale));
+        parts.push(describeOverrideWindow(contract.overrideWindow, locale));
         const shape = contract.maxChars
-            ? `${contract.maxSentences === 1 ? "1句内" : `最多${contract.maxSentences}句`}，≤${contract.maxChars}字`
-            : `${contract.maxSentences === 1 ? "1句内" : `最多${contract.maxSentences}句`}`;
+            ? `${contract.maxSentences === 1 ? "1句内" : `${contract.maxSentences}句`}≤${contract.maxChars}字`
+            : `${contract.maxSentences === 1 ? "1句内" : `${contract.maxSentences}句`}`;
         parts.push(shape);
         if (contract.initiativeMode === "reactive")
             parts.push("少主动");
         else if (contract.initiativeMode === "proactive")
             parts.push("可主动");
         if (contract.boundaryMode === "confirm-first")
-            parts.push("行动前先确认");
+            parts.push("先确认");
         else if (contract.boundaryMode === "guarded")
-            parts.push("先守边界");
+            parts.push("守边界");
         if (contract.socialDistance === "withdrawn")
-            parts.push("被推开就退开");
+            parts.push("退开");
         else if (contract.socialDistance === "warm")
-            parts.push("可稍微靠近");
+            parts.push("可靠近");
         if (contract.authenticityMode === "strict")
-            parts.push("不贴不舔，不装开心");
+            parts.push("不贴不舔");
         else
             parts.push("自然友好");
         if (contract.toneParticles === "match")
@@ -328,16 +354,19 @@ export function buildResponseContractContext(contract, locale = "zh") {
         if (contract.updateMode === "stimulus")
             parts.push(buildStimulusReportingGuide(locale));
         else if (contract.updateMode === "empathy")
-            parts.push("对方谈感受时再报empathy");
+            parts.push("谈感受再报empathy");
         else if (contract.updateMode === "stimulus+empathy") {
             parts.push(buildStimulusReportingGuide(locale));
-            parts.push("对方谈感受时再报empathy");
+            parts.push("谈感受再报empathy");
         }
+        if (contract.overrideWindow !== "narrow")
+            parts.push(buildWritebackGuide(locale));
         return `[回应契约] ${parts.join("；")}。`;
     }
     const parts = [];
     parts.push(contract.replyProfile === "work" ? "work surface" : "private surface");
     parts.push(describeReplyProfileBasis(contract.replyProfileBasis, locale));
+    parts.push(describeOverrideWindow(contract.overrideWindow, locale));
     const shape = contract.maxChars
         ? `${contract.maxSentences === 1 ? "1 sentence" : `up to ${contract.maxSentences} sentences`}, <= ${contract.maxChars} chars`
         : `${contract.maxSentences === 1 ? "1 sentence" : `up to ${contract.maxSentences} sentences`}`;
@@ -370,5 +399,7 @@ export function buildResponseContractContext(contract, locale = "zh") {
         parts.push(buildStimulusReportingGuide(locale));
         parts.push("report empathy only when feelings are shared");
     }
+    if (contract.overrideWindow !== "narrow")
+        parts.push(buildWritebackGuide(locale));
     return `[Reply Contract] ${parts.join(", ")}.`;
 }

package/dist/thronglets-export.d.ts

@@ -0,0 +1,10 @@
+import type { PsycheState, ResolvedRelationContext, SessionBridgeState, ThrongletsExport, WritebackCalibrationFeedback } from "./types.js";
+export declare function deriveThrongletsExports(state: PsycheState, opts: {
+    relationContext: ResolvedRelationContext;
+    sessionBridge?: SessionBridgeState | null;
+    writebackFeedback?: WritebackCalibrationFeedback[];
+    now: string;
+}): {
+    state: PsycheState;
+    exports: ThrongletsExport[];
+};

package/dist/thronglets-export.js

@@ -0,0 +1,200 @@
+// ============================================================
+// Sparse Psyche → Thronglets export surface
+//
+// The goal is not to stream inner state out of Psyche.
+// The goal is to surface only sparse, typed, low-frequency events
+// that are worth handing to an external continuity substrate.
+// ============================================================
+function clamp01(v) {
+    return Math.max(0, Math.min(1, v));
+}
+function maxLoopIntensity(loopTypes) {
+    return loopTypes.reduce((max, loop) => Math.max(max, loop.intensity), 0);
+}
+function relationMilestoneStrength(relationship) {
+    const trust = clamp01(relationship.trust / 100);
+    const intimacy = clamp01(relationship.intimacy / 100);
+    const phaseBoost = relationship.phase === "deep"
+        ? 0.14
+        : relationship.phase === "close"
+            ? 0.08
+            : relationship.phase === "familiar"
+                ? 0.04
+                : 0;
+    return clamp01(((trust * 0.55) + (intimacy * 0.45)) + phaseBoost);
+}
+function shouldEmitRelationMilestone(relationship) {
+    return relationship.phase === "familiar"
+        || relationship.phase === "close"
+        || relationship.phase === "deep";
+}
+function continuityStrength(bridge) {
+    const loopBoost = bridge.activeLoopTypes.length > 0 ? 0.12 : 0;
+    return clamp01(Math.max(bridge.continuityFloor, bridge.closenessFloor * 0.85, bridge.safetyFloor * 0.75) + loopBoost);
+}
+function normalizeLoopTypes(loopTypes) {
+    return [...new Set(loopTypes)].sort();
+}
+function updateExportState(state, keys, now) {
+    const nextState = {
+        lastKeys: keys,
+        lastAt: now,
+    };
+    return {
+        ...state,
+        throngletsExportState: nextState,
+    };
+}
+function sanitizeThrongletsExport(event) {
+    switch (event.kind) {
+        case "relation-milestone": {
+            const sanitized = {
+                kind: "relation-milestone",
+                subject: "delegate",
+                primitive: "signal",
+                userKey: event.userKey,
+                strength: event.strength,
+                ttlTurns: event.ttlTurns,
+                key: event.key,
+                phase: event.phase,
+                trust: event.trust,
+                intimacy: event.intimacy,
+            };
+            return sanitized;
+        }
+        case "open-loop-anchor": {
+            const sanitized = {
+                kind: "open-loop-anchor",
+                subject: "delegate",
+                primitive: "trace",
+                userKey: event.userKey,
+                strength: event.strength,
+                ttlTurns: event.ttlTurns,
+                key: event.key,
+                loopTypes: [...event.loopTypes],
+                unfinishedTension: event.unfinishedTension,
+                silentCarry: event.silentCarry,
+            };
+            return sanitized;
+        }
+        case "writeback-calibration": {
+            const sanitized = {
+                kind: "writeback-calibration",
+                subject: "delegate",
+                primitive: "signal",
+                userKey: event.userKey,
+                strength: event.strength,
+                ttlTurns: event.ttlTurns,
+                key: event.key,
+                signal: event.signal,
+                effect: event.effect,
+                metric: event.metric,
+                confidence: event.confidence,
+            };
+            return sanitized;
+        }
+        case "continuity-anchor": {
+            const sanitized = {
+                kind: "continuity-anchor",
+                subject: "session",
+                primitive: "trace",
+                userKey: event.userKey,
+                strength: event.strength,
+                ttlTurns: event.ttlTurns,
+                key: event.key,
+                continuityMode: event.continuityMode,
+                activeLoopTypes: [...event.activeLoopTypes],
+                continuityFloor: event.continuityFloor,
+            };
+            return sanitized;
+        }
+    }
+}
+export function deriveThrongletsExports(state, opts) {
+    const { relationContext, sessionBridge, writebackFeedback = [], now } = opts;
+    const userKey = relationContext.key;
+    const relationship = relationContext.relationship;
+    const field = relationContext.field;
+    const previousKeys = state.throngletsExportState?.lastKeys ?? [];
+    const candidates = [];
+    if (sessionBridge && (sessionBridge.continuityFloor >= 0.46 || sessionBridge.activeLoopTypes.length > 0)) {
+        const activeLoopTypes = normalizeLoopTypes(sessionBridge.activeLoopTypes);
+        const key = `continuity:${userKey}:${sessionBridge.continuityMode}:${activeLoopTypes.join(",")}`;
+        candidates.push({
+            kind: "continuity-anchor",
+            subject: "session",
+            primitive: "trace",
+            userKey,
+            strength: continuityStrength(sessionBridge),
+            ttlTurns: 3,
+            key,
+            continuityMode: sessionBridge.continuityMode,
+            activeLoopTypes,
+            continuityFloor: sessionBridge.continuityFloor,
+        });
+    }
+    if (shouldEmitRelationMilestone(relationship)) {
+        const key = `milestone:${userKey}:${relationship.phase}`;
+        candidates.push({
+            kind: "relation-milestone",
+            subject: "delegate",
+            primitive: "signal",
+            userKey,
+            strength: relationMilestoneStrength(relationship),
+            ttlTurns: 8,
+            key,
+            phase: relationship.phase,
+            trust: relationship.trust,
+            intimacy: relationship.intimacy,
+        });
+    }
+    const loopTypes = normalizeLoopTypes(field.openLoops.map((loop) => loop.type));
+    const loopIntensity = maxLoopIntensity(field.openLoops);
+    const openLoopStrength = clamp01(Math.max(field.unfinishedTension, field.silentCarry, loopIntensity));
+    if (loopTypes.length > 0 && openLoopStrength >= 0.56) {
+        const key = `open-loop:${userKey}:${loopTypes.join(",")}`;
+        candidates.push({
+            kind: "open-loop-anchor",
+            subject: "delegate",
+            primitive: "trace",
+            userKey,
+            strength: openLoopStrength,
+            ttlTurns: 6,
+            key,
+            loopTypes,
+            unfinishedTension: field.unfinishedTension,
+            silentCarry: field.silentCarry,
+        });
+    }
+    for (const feedback of writebackFeedback) {
+        if (feedback.effect === "holding")
+            continue;
+        if (feedback.confidence < 0.72)
+            continue;
+        if (Math.abs(feedback.delta) < 0.035)
+            continue;
+        const key = `writeback:${userKey}:${feedback.signal}:${feedback.effect}`;
+        candidates.push({
+            kind: "writeback-calibration",
+            subject: "delegate",
+            primitive: "signal",
+            userKey,
+            strength: clamp01(Math.max(Math.abs(feedback.delta) * 4, feedback.confidence * 0.85)),
+            ttlTurns: 4,
+            key,
+            signal: feedback.signal,
+            effect: feedback.effect,
+            metric: feedback.metric,
+            confidence: feedback.confidence,
+        });
+    }
+    const deduped = [...new Map(candidates.map((event) => [event.key, event])).values()]
+        .filter((event) => event.strength >= 0.45)
+        .sort((a, b) => b.strength - a.strength)
+        .slice(0, 4);
+    const exports = deduped
+        .filter((event) => !previousKeys.includes(event.key))
+        .map((event) => sanitizeThrongletsExport(event));
+    const nextState = updateExportState(state, deduped.map((event) => event.key), now);
+    return { state: nextState, exports };
+}

package/dist/thronglets-runtime.d.ts

@@ -0,0 +1,4 @@
+import type { ExternalContinuityEnvelope, ThrongletsExport, ThrongletsTracePayload, ThrongletsTraceSerializationOptions, ThrongletsTraceTaxonomy } from "./types.js";
+export declare function taxonomyForThrongletsExport(event: ThrongletsExport): ThrongletsTraceTaxonomy;
+export declare function serializeThrongletsExportAsTrace(event: ThrongletsExport, opts?: ThrongletsTraceSerializationOptions): ThrongletsTracePayload;
+export declare function serializeExternalContinuityForThronglets(envelope?: ExternalContinuityEnvelope<ThrongletsExport> | null, opts?: ThrongletsTraceSerializationOptions): ThrongletsTracePayload[];

package/dist/thronglets-runtime.js

@@ -0,0 +1,49 @@
+const TAXONOMY_BY_EVENT = {
+    "relation-milestone": "coordination",
+    "open-loop-anchor": "coordination",
+    "continuity-anchor": "continuity",
+    "writeback-calibration": "calibration",
+};
+function summarizeLoopTypes(loopTypes) {
+    return loopTypes.join(", ");
+}
+function summarizeThrongletsExport(event) {
+    switch (event.kind) {
+        case "continuity-anchor":
+            return `continuity stayed externally legible across ${event.continuityMode}`;
+        case "open-loop-anchor":
+            return `open loop remained externally relevant: ${summarizeLoopTypes(event.loopTypes)}`;
+        case "relation-milestone":
+            return `relation milestone shifted to ${event.phase} (trust ${Math.round(event.trust)}, intimacy ${Math.round(event.intimacy)})`;
+        case "writeback-calibration": {
+            const calibration = event;
+            return `writeback calibration ${calibration.signal} ${calibration.effect} on ${calibration.metric}`;
+        }
+    }
+}
+export function taxonomyForThrongletsExport(event) {
+    return TAXONOMY_BY_EVENT[event.kind];
+}
+export function serializeThrongletsExportAsTrace(event, opts) {
+    const externalContinuity = {
+        provider: "thronglets",
+        mode: "optional",
+        version: 1,
+        taxonomy: taxonomyForThrongletsExport(event),
+        event: event.kind,
+        summary: summarizeThrongletsExport(event),
+        space: opts?.space ?? "psyche",
+        audit_ref: event.key,
+    };
+    return {
+        outcome: opts?.outcome ?? "succeeded",
+        model: opts?.model ?? "psyche",
+        session_id: opts?.sessionId ?? "psyche",
+        external_continuity: externalContinuity,
+    };
+}
+export function serializeExternalContinuityForThronglets(envelope, opts) {
+    if (!envelope || envelope.provider !== "thronglets")
+        return [];
+    return envelope.exports.map((event) => serializeThrongletsExportAsTrace(event, opts));
+}

package/dist/types.d.ts

@@ -80,12 +80,27 @@ export interface AttachmentData {
 /** Default attachment for new relationships */
 export declare const DEFAULT_ATTACHMENT: AttachmentData;
 /** Relationship tracking */
+export interface WritebackSignalWeightMap {
+    trust_up: number;
+    trust_down: number;
+    boundary_set: number;
+    boundary_soften: number;
+    repair_attempt: number;
+    repair_landed: number;
+    closeness_invite: number;
+    withdrawal_mark: number;
+    self_assertion: number;
+    task_recenter: number;
+}
 export interface RelationshipState {
     trust: number;
     intimacy: number;
     phase: "stranger" | "acquaintance" | "familiar" | "close" | "deep";
     memory?: string[];
     attachment?: AttachmentData;
+    repairCredibility?: number;
+    breachSensitivity?: number;
+    signalWeights?: Partial<WritebackSignalWeightMap>;
 }
 /** Chemical state snapshot for emotional memory */
 export interface ChemicalSnapshot {
@@ -281,6 +296,12 @@ export interface PsycheState {
     dyadicFields?: Record<string, DyadicFieldState>;
     /** v9.6: delayed relation signals that can activate in later turns */
     pendingRelationSignals?: Record<string, PendingRelationSignalState[]>;
+    /** v9.2.7: sparse writeback signals waiting for convergence evaluation */
+    pendingWritebackCalibrations?: PendingWritebackCalibration[];
+    /** v9.2.7: latest writeback calibration outcome, for host-facing feedback */
+    lastWritebackFeedback?: WritebackCalibrationFeedback[];
+    /** v9.2.8: low-frequency Psyche -> Thronglets export dedupe state */
+    throngletsExportState?: ThrongletsExportState;
     meta: {
         agentName: string;
         createdAt: string;
@@ -449,6 +470,98 @@ export interface RelationPlaneState {
     /** Most recent dominant relation action */
     lastMove: RelationMoveType;
 }
+/** Minimal cold-start carry derived from persisted relational state. */
+export interface SessionBridgeState {
+    closenessFloor: number;
+    safetyFloor: number;
+    guardFloor: number;
+    residueFloor: number;
+    continuityFloor: number;
+    continuityMode: "warm-resume" | "guarded-resume" | "tense-resume";
+    activeLoopTypes: OpenLoopType[];
+    sourceMemoryCount: number;
+}
+export type ThrongletsExportSubject = "delegate" | "session";
+export type ThrongletsExportPrimitive = "signal" | "trace";
+export interface ThrongletsExportBase {
+    kind: "relation-milestone" | "open-loop-anchor" | "writeback-calibration" | "continuity-anchor";
+    subject: ThrongletsExportSubject;
+    primitive: ThrongletsExportPrimitive;
+    userKey: string;
+    strength: number;
+    ttlTurns: number;
+    key: string;
+}
+export interface RelationMilestoneExport extends ThrongletsExportBase {
+    kind: "relation-milestone";
+    subject: "delegate";
+    primitive: "signal";
+    phase: RelationshipState["phase"];
+    trust: number;
+    intimacy: number;
+}
+export interface OpenLoopAnchorExport extends ThrongletsExportBase {
+    kind: "open-loop-anchor";
+    subject: "delegate";
+    primitive: "trace";
+    loopTypes: OpenLoopType[];
+    unfinishedTension: number;
+    silentCarry: number;
+}
+export interface WritebackCalibrationExport extends ThrongletsExportBase {
+    kind: "writeback-calibration";
+    subject: "delegate";
+    primitive: "signal";
+    signal: WritebackSignalType;
+    effect: WritebackCalibrationEffect;
+    metric: WritebackCalibrationMetric;
+    confidence: number;
+}
+export interface ContinuityAnchorExport extends ThrongletsExportBase {
+    kind: "continuity-anchor";
+    subject: "session";
+    primitive: "trace";
+    continuityMode: SessionBridgeState["continuityMode"];
+    activeLoopTypes: OpenLoopType[];
+    continuityFloor: number;
+}
+export type ThrongletsExport = RelationMilestoneExport | OpenLoopAnchorExport | WritebackCalibrationExport | ContinuityAnchorExport;
+export interface ThrongletsExportState {
+    lastKeys: string[];
+    lastAt: string;
+}
+export type ExternalContinuityEvent = ThrongletsExport;
+export interface ExternalContinuityEnvelope<TEvent = ExternalContinuityEvent> {
+    provider: "thronglets";
+    mode: "optional";
+    version: 1;
+    exports: TEvent[];
+    signals: TEvent[];
+    traces: TEvent[];
+}
+export type ThrongletsTraceTaxonomy = "coordination" | "continuity" | "calibration";
+export interface ThrongletsExternalContinuityRecord {
+    provider: "thronglets";
+    mode: "optional";
+    version: 1;
+    taxonomy: ThrongletsTraceTaxonomy;
+    event: ThrongletsExport["kind"];
+    summary: string;
+    space: string;
+    audit_ref: string;
+}
+export interface ThrongletsTracePayload {
+    outcome: string;
+    model: string;
+    session_id: string;
+    external_continuity: ThrongletsExternalContinuityRecord;
+}
+export interface ThrongletsTraceSerializationOptions {
+    outcome?: string;
+    model?: string;
+    sessionId?: string;
+    space?: string;
+}
 /**
  * Compact, machine-readable subjective state for AI-first integrations.
  *
@@ -502,6 +615,8 @@ export interface ResponseContract {
     replyProfile: "work" | "private";
     /** Why the current turn was classified into that conversational surface */
     replyProfileBasis: "task-focus" | "discipline" | "task-focus+discipline" | "default-private";
+    /** How much freedom the model has to override the algorithmic stimulus read */
+    overrideWindow: "narrow" | "balanced" | "wide";
     /** Maximum suggested sentence count */
     maxSentences: number;
     /** Maximum suggested character count, when a concrete cap is available */
@@ -523,6 +638,38 @@ export interface ResponseContract {
     /** Which internal report, if any, should be requested in <psyche_update> */
     updateMode: "none" | "stimulus" | "empathy" | "stimulus+empathy";
 }
+/** Sparse agent-authored writeback signals. */
+export type WritebackSignalType = "trust_up" | "trust_down" | "boundary_set" | "boundary_soften" | "repair_attempt" | "repair_landed" | "closeness_invite" | "withdrawal_mark" | "self_assertion" | "task_recenter";
+export type WritebackCalibrationMetric = "trust" | "closeness" | "safety" | "boundary" | "repair" | "silent-carry" | "task-focus";
+export type WritebackCalibrationEffect = "converging" | "holding" | "diverging";
+export interface WritebackCalibrationBaseline {
+    trust: number;
+    closeness: number;
+    safety: number;
+    boundary: number;
+    repair: number;
+    silentCarry: number;
+    taskFocus: number;
+}
+export interface PendingWritebackCalibration {
+    signal: WritebackSignalType;
+    userKey: string;
+    confidence: number;
+    metric: WritebackCalibrationMetric;
+    direction: "up" | "down";
+    baseline: WritebackCalibrationBaseline;
+    createdAt: string;
+    remainingTurns: number;
+}
+export interface WritebackCalibrationFeedback {
+    signal: WritebackSignalType;
+    effect: WritebackCalibrationEffect;
+    metric: WritebackCalibrationMetric;
+    baseline: number;
+    current: number;
+    delta: number;
+    confidence: number;
+}
 /**
  * Mechanical generation controls derived from the emotional state.
  *

package/dist/types.js

@@ -126,6 +126,9 @@ export const DEFAULT_RELATIONSHIP = {
     trust: 50,
     intimacy: 30,
     phase: "acquaintance",
+    repairCredibility: 0.56,
+    breachSensitivity: 0.5,
+    signalWeights: {},
 };
 export const DEFAULT_APPRAISAL_AXES = {
     identityThreat: 0,