psyche-ai 9.2.9 → 9.2.10

package/README.md

@@ -326,6 +326,14 @@ Psyche 现在更准确的目标，不是“模仿某种像人的风格”，而
 
 当前主线里，`processInput()` 会直接返回 `replyEnvelope` 作为规范主接口；原有平级字段继续保留为兼容别名，避免打断现有宿主。`policyModifiers` 不再属于规范主接口，只保留为 legacy raw vector。
 
+在这个规范主接口之外，`processInput()` 现在还会可选返回一个很薄的 `observability` side-channel。它不是新的控制面，也不会反向改写 `replyEnvelope`；它只回答三件事：
+
+- 这轮当前由哪一个控制平面主导
+- 当前 turn / writeback / session bridge / persisted relationship 四层是怎么对账的
+- 这次 `work/private` 选择为什么会落在这个 profile 上
+
+这样别的 agent 或宿主不用再自己猜“现在到底是谁在主导”和“为什么这次选了这个策略”，但主链路仍然只有 `replyEnvelope` 一个真相源。
+
 ### 内在世界
 
 Psyche 给 AI 一个始终运转的内在自我——不是条件触发，而是每时每刻都在：

package/dist/core.d.ts

@@ -1,4 +1,4 @@
-import type { PsycheState, StimulusType, Locale, MBTIType, OutcomeScore, PsycheMode, PersonalityTraits, PolicyModifiers, ClassifierProvider, SubjectivityKernel, ResponseContract, GenerationControls, SessionBridgeState, ThrongletsExport, WritebackCalibrationFeedback, WritebackSignalType, ExternalContinuityEnvelope } from "./types.js";
+import type { PsycheState, StimulusType, Locale, MBTIType, OutcomeScore, PsycheMode, PersonalityTraits, PolicyModifiers, ClassifierProvider, SubjectivityKernel, ResponseContract, GenerationControls, SessionBridgeState, ThrongletsExport, TurnObservability, WritebackCalibrationFeedback, WritebackSignalType, ExternalContinuityEnvelope } from "./types.js";
 import type { StorageAdapter } from "./storage.js";
 import type { DiagnosticReport, SessionMetrics } from "./diagnostics.js";
 import type { ReplyEnvelope } from "./reply-envelope.js";
@@ -57,6 +57,8 @@ export interface ProcessInputResult {
     externalContinuity?: ExternalContinuityEnvelope<ThrongletsExport>;
     /** v9.2.8: sparse low-frequency export surface suitable for Thronglets */
     throngletsExports?: ThrongletsExport[];
+    /** v9.2.10: low-cost side channel for control boundary, state layers, and output attribution */
+    observability?: TurnObservability;
     /**
      * Legacy compatibility alias: ready-to-use prompt fragment summarizing raw policy modifiers.
      *

package/dist/core.js

@@ -28,6 +28,7 @@ import { runReflectiveTurnPhases } from "./input-turn.js";
 import { applyRelationalTurn, applySessionBridge, applyWritebackSignals, createWritebackCalibrations, evaluateWritebackCalibrations } from "./relation-dynamics.js";
 import { buildExternalContinuityEnvelope } from "./external-continuity.js";
 import { deriveThrongletsExports } from "./thronglets-export.js";
+import { buildTurnObservability } from "./observability.js";
 function formatWritebackFeedbackNote(feedback, locale) {
     const top = feedback?.[0];
     if (!top)
@@ -480,6 +481,17 @@ export class PsycheEngine {
             responseContractContext: derivedReplyEnvelope.responseContractContext,
             policyContext: derivedReplyEnvelope.policyContext || undefined,
         };
+        const observability = buildTurnObservability(state, {
+            replyEnvelope,
+            promptRenderInputs,
+            compactMode: this.cfg.compactMode,
+            stimulus: appliedStimulus,
+            userText: text || undefined,
+            sessionBridge,
+            writebackFeedback,
+            relationContext: relationalTurn.relationContext,
+            externalContinuityExports: throngletsExports.length,
+        });
         if (this.cfg.compactMode) {
             const externalContinuity = buildExternalContinuityEnvelope(throngletsExports);
             return {
@@ -496,6 +508,7 @@ export class PsycheEngine {
                 writebackFeedback,
                 externalContinuity,
                 throngletsExports,
+                observability,
                 policyContext: derivedReplyEnvelope.policyContext,
             };
         }
@@ -514,6 +527,7 @@ export class PsycheEngine {
             writebackFeedback,
             externalContinuity,
             throngletsExports,
+            observability,
             policyContext: derivedReplyEnvelope.policyContext,
         };
     }

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { PsycheEngine } from "./core.js";
 export type { PsycheEngineConfig, ProcessInputResult, ProcessOutputResult, ProcessOutcomeResult } from "./core.js";
 export { FileStorageAdapter, MemoryStorageAdapter } from "./storage.js";
 export type { StorageAdapter } from "./storage.js";
-export type { PsycheState, MBTIType, Locale, StimulusType, ChemicalState, ChemicalSnapshot, SelfModel, RelationshipState, EmpathyEntry, EmotionPattern, DriveType, InnateDrives, LearningState, LearnedVectorAdjustment, PredictionRecord, OutcomeScore, OutcomeSignals, AttachmentStyle, AttachmentData, MetacognitiveState, RegulationRecord, DefensePatternRecord, RegulationStrategyType, DefenseMechanismType, PersonhoodState, PersistedCausalInsight, GrowthDirection, PersonalityTraits, PsycheMode, PolicyModifiers, SubjectivityKernel, ResponseContract, GenerationControls, AppraisalAxes, SubjectResidue, TaskPlaneState, SubjectPlaneState, RelationPlaneState, AmbiguityPlaneState, RelationMoveType, RelationMove, OpenLoopType, OpenLoopState, PendingRelationSignalState, DyadicFieldState, SessionBridgeState, ThrongletsExportSubject, ThrongletsExportPrimitive, ThrongletsExportBase, RelationMilestoneExport, OpenLoopAnchorExport, WritebackCalibrationExport, ContinuityAnchorExport, ThrongletsExport, ThrongletsExportState, ExternalContinuityEvent, ExternalContinuityEnvelope, ThrongletsTraceTaxonomy, ThrongletsExternalContinuityRecord, ThrongletsTracePayload, ThrongletsTraceSerializationOptions, WritebackSignalType, WritebackSignalWeightMap, PendingWritebackCalibration, WritebackCalibrationFeedback, WritebackCalibrationMetric, TraitDriftState, EnergyBudgets, ClassifierProvider, ClassifierContext, ClassificationResult, } from "./types.js";
+export type { PsycheState, MBTIType, Locale, StimulusType, ChemicalState, ChemicalSnapshot, SelfModel, RelationshipState, EmpathyEntry, EmotionPattern, DriveType, InnateDrives, LearningState, LearnedVectorAdjustment, PredictionRecord, OutcomeScore, OutcomeSignals, AttachmentStyle, AttachmentData, MetacognitiveState, RegulationRecord, DefensePatternRecord, RegulationStrategyType, DefenseMechanismType, PersonhoodState, PersistedCausalInsight, GrowthDirection, PersonalityTraits, PsycheMode, PolicyModifiers, SubjectivityKernel, ResponseContract, GenerationControls, TurnControlPlane, TurnControlDriver, ControlBoundaryObservation, StateLayerKind, StateLayerObservation, PromptRenderInputName, RuntimeHookName, OutputAttributionObservation, StateReconciliationObservation, DecisionCandidateName, DecisionCandidateObservation, DecisionRationaleObservation, TurnObservability, AppraisalAxes, SubjectResidue, TaskPlaneState, SubjectPlaneState, RelationPlaneState, AmbiguityPlaneState, RelationMoveType, RelationMove, OpenLoopType, OpenLoopState, PendingRelationSignalState, DyadicFieldState, SessionBridgeState, ThrongletsExportSubject, ThrongletsExportPrimitive, ThrongletsExportBase, RelationMilestoneExport, OpenLoopAnchorExport, WritebackCalibrationExport, ContinuityAnchorExport, ThrongletsExport, ThrongletsExportState, ExternalContinuityEvent, ExternalContinuityEnvelope, ThrongletsTraceTaxonomy, ThrongletsExternalContinuityRecord, ThrongletsTracePayload, ThrongletsTraceSerializationOptions, WritebackSignalType, WritebackSignalWeightMap, PendingWritebackCalibration, WritebackCalibrationFeedback, WritebackCalibrationMetric, TraitDriftState, EnergyBudgets, ClassifierProvider, ClassifierContext, ClassificationResult, } from "./types.js";
 export { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE, DEFAULT_PERSONHOOD_STATE, DEFAULT_ATTACHMENT, DRIVE_KEYS, DRIVE_NAMES_ZH, DEFAULT_TRAIT_DRIFT, DEFAULT_ENERGY_BUDGETS, DEFAULT_APPRAISAL_AXES, DEFAULT_SUBJECT_RESIDUE, DEFAULT_DYADIC_FIELD, } from "./types.js";
 export { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
 export type { SelfReflection } from "./self-recognition.js";
@@ -28,6 +28,7 @@ export { computeResponseContract, buildResponseContractContext } from "./respons
 export { deriveGenerationControls } from "./host-controls.js";
 export { deriveReplyEnvelope } from "./reply-envelope.js";
 export type { ReplyEnvelope } from "./reply-envelope.js";
+export { buildTurnObservability } from "./observability.js";
 export { computeAppraisalAxes, mergeAppraisalResidue, getResidueIntensity } from "./appraisal.js";
 export { computeRelationMove, evolveDyadicField, evolvePendingRelationSignals, getLoopPressure, applySessionBridge, applyWritebackSignals, createWritebackCalibrations, evaluateWritebackCalibrations, } from "./relation-dynamics.js";
 export { EXTERNAL_CONTINUITY_SIGNAL_KINDS, EXTERNAL_CONTINUITY_TRACE_KINDS, buildExternalContinuityEnvelope, } from "./external-continuity.js";

package/dist/index.js

@@ -38,6 +38,7 @@ export { computeSubjectivityKernel, buildSubjectivityContext } from "./subjectiv
 export { computeResponseContract, buildResponseContractContext } from "./response-contract.js";
 export { deriveGenerationControls } from "./host-controls.js";
 export { deriveReplyEnvelope } from "./reply-envelope.js";
+export { buildTurnObservability } from "./observability.js";
 export { computeAppraisalAxes, mergeAppraisalResidue, getResidueIntensity } from "./appraisal.js";
 export { computeRelationMove, evolveDyadicField, evolvePendingRelationSignals, getLoopPressure, applySessionBridge, applyWritebackSignals, createWritebackCalibrations, evaluateWritebackCalibrations, } from "./relation-dynamics.js";
 export { EXTERNAL_CONTINUITY_SIGNAL_KINDS, EXTERNAL_CONTINUITY_TRACE_KINDS, buildExternalContinuityEnvelope, } from "./external-continuity.js";

package/dist/observability.d.ts

@@ -0,0 +1,14 @@
+import type { PsycheState, ResolvedRelationContext, SessionBridgeState, StimulusType, TurnObservability, WritebackCalibrationFeedback } from "./types.js";
+import type { PromptRenderInputs } from "./prompt.js";
+import type { ReplyEnvelope } from "./reply-envelope.js";
+export declare function buildTurnObservability(state: PsycheState, opts: {
+    replyEnvelope: ReplyEnvelope;
+    promptRenderInputs: PromptRenderInputs;
+    compactMode: boolean;
+    stimulus: StimulusType | null;
+    userText?: string;
+    sessionBridge: SessionBridgeState | null;
+    writebackFeedback: WritebackCalibrationFeedback[];
+    relationContext?: ResolvedRelationContext;
+    externalContinuityExports: number;
+}): TurnObservability;

package/dist/observability.js

@@ -0,0 +1,274 @@
+function clamp01(v) {
+    return Math.max(0, Math.min(1, v));
+}
+function pickDominantPlane(replyEnvelope) {
+    const { subjectivityKernel, responseContract } = replyEnvelope;
+    const taskCandidates = [
+        ["task-focus", subjectivityKernel.taskPlane.focus],
+        ["discipline", subjectivityKernel.taskPlane.discipline],
+    ];
+    const subjectCandidates = [
+        ["attachment", subjectivityKernel.subjectPlane.attachment],
+        ["guardedness", subjectivityKernel.subjectPlane.guardedness],
+        ["identity-strain", subjectivityKernel.subjectPlane.identityStrain],
+        ["residue", subjectivityKernel.subjectPlane.residue],
+    ];
+    const relationCandidates = [
+        ["closeness", subjectivityKernel.relationPlane.closeness],
+        ["loop-pressure", subjectivityKernel.relationPlane.loopPressure],
+        ["repair-readiness", subjectivityKernel.relationPlane.repairReadiness],
+        ["repair-friction", subjectivityKernel.relationPlane.repairFriction],
+        ["hysteresis", subjectivityKernel.relationPlane.hysteresis],
+        ["silent-carry", subjectivityKernel.relationPlane.silentCarry],
+    ];
+    const ambiguityCandidates = [
+        ["conflict-load", subjectivityKernel.ambiguityPlane.conflictLoad],
+        ["expression-inhibition", subjectivityKernel.ambiguityPlane.expressionInhibition],
+        ["naming-uncertainty", 1 - subjectivityKernel.ambiguityPlane.namingConfidence],
+    ];
+    const planeSummaries = [
+        ["task", ...taskCandidates.sort((a, b) => b[1] - a[1])[0]],
+        ["subject", ...subjectCandidates.sort((a, b) => b[1] - a[1])[0]],
+        ["relation", ...relationCandidates.sort((a, b) => b[1] - a[1])[0]],
+        ["ambiguity", ...ambiguityCandidates.sort((a, b) => b[1] - a[1])[0]],
+    ];
+    planeSummaries.sort((a, b) => {
+        if (b[2] !== a[2])
+            return b[2] - a[2];
+        if (responseContract.replyProfile === "work") {
+            if (a[0] === "task")
+                return -1;
+            if (b[0] === "task")
+                return 1;
+        }
+        return 0;
+    });
+    const [dominantPlane, dominantDriver, strength] = planeSummaries[0];
+    return {
+        dominantPlane,
+        dominantDriver,
+        strength: clamp01(strength),
+        replyProfile: responseContract.replyProfile,
+        replyProfileBasis: responseContract.replyProfileBasis,
+        overrideWindow: responseContract.overrideWindow,
+    };
+}
+function summarizeCurrentTurn(stimulus, userText) {
+    if (stimulus)
+        return `stimulus:${stimulus}`;
+    if (userText && userText.trim().length > 0)
+        return "stimulus:none";
+    return "no-user-input";
+}
+function summarizeWriteback(feedback) {
+    if (feedback.length === 0)
+        return "none";
+    const top = feedback[0];
+    return `${top.signal}:${top.effect}`;
+}
+function summarizeSessionBridge(bridge) {
+    if (!bridge)
+        return "none";
+    const loops = bridge.activeLoopTypes.length > 0 ? bridge.activeLoopTypes.join("+") : "no-open-loops";
+    return `${bridge.continuityMode}/${loops}`;
+}
+function summarizeRelationship(state, relationContext) {
+    const relationship = relationContext?.relationship
+        ?? state.relationships._default
+        ?? state.relationships[Object.keys(state.relationships)[0]];
+    if (!relationship)
+        return "none";
+    return `${relationship.phase}/trust:${Math.round(relationship.trust)}/intimacy:${Math.round(relationship.intimacy)}`;
+}
+function buildStateLayers(state, opts) {
+    return [
+        {
+            layer: "current-turn",
+            precedence: 1,
+            scope: "turn",
+            active: Boolean(opts.stimulus) || Boolean(opts.userText?.trim()),
+            summary: summarizeCurrentTurn(opts.stimulus, opts.userText),
+        },
+        {
+            layer: "writeback-feedback",
+            precedence: 2,
+            scope: "session",
+            active: opts.writebackFeedback.length > 0,
+            summary: summarizeWriteback(opts.writebackFeedback),
+        },
+        {
+            layer: "session-bridge",
+            precedence: 3,
+            scope: "session",
+            active: Boolean(opts.sessionBridge),
+            summary: summarizeSessionBridge(opts.sessionBridge),
+        },
+        {
+            layer: "persisted-relationship",
+            precedence: 4,
+            scope: "persistent",
+            active: true,
+            summary: summarizeRelationship(state, opts.relationContext),
+        },
+    ];
+}
+function buildStateReconciliation(stateLayers) {
+    const activeObservations = stateLayers
+        .filter((layer) => layer.active)
+        .sort((a, b) => a.precedence - b.precedence);
+    const activeLayers = activeObservations.map((layer) => layer.layer);
+    const carryLayers = activeLayers.filter((layer) => layer !== "current-turn");
+    const governingLayer = activeObservations[0]?.layer ?? "persisted-relationship";
+    let resolution = "persistent-baseline";
+    if (activeLayers.includes("writeback-feedback")) {
+        resolution = "writeback-adjusted";
+    }
+    else if (activeLayers.includes("session-bridge") && activeLayers.includes("current-turn")) {
+        resolution = "session-bridge-biased";
+    }
+    else if (activeLayers.includes("current-turn")) {
+        resolution = "current-turn-dominant";
+    }
+    const notes = stateLayers
+        .filter((layer) => layer.active && layer.layer !== "persisted-relationship")
+        .map((layer) => `${layer.layer}:${layer.summary}`);
+    return {
+        governingLayer,
+        activeLayers,
+        carryLayers,
+        resolution,
+        notes,
+    };
+}
+function pushReason(reasons, condition, label) {
+    if (condition)
+        reasons.push(label);
+}
+function buildDecisionRationale(replyEnvelope) {
+    const { subjectivityKernel, responseContract } = replyEnvelope;
+    const taskFocus = subjectivityKernel.taskPlane.focus;
+    const discipline = subjectivityKernel.taskPlane.discipline;
+    const attachment = subjectivityKernel.subjectPlane.attachment;
+    const residue = subjectivityKernel.subjectPlane.residue;
+    const guardedness = subjectivityKernel.subjectPlane.guardedness;
+    const closeness = subjectivityKernel.relationPlane.closeness;
+    const loopPressure = subjectivityKernel.relationPlane.loopPressure;
+    const repairFriction = subjectivityKernel.relationPlane.repairFriction;
+    const expressionInhibition = subjectivityKernel.ambiguityPlane.expressionInhibition;
+    const namingConfidence = subjectivityKernel.ambiguityPlane.namingConfidence;
+    const taskFocused = taskFocus >= 0.62;
+    const disciplined = discipline >= 0.72;
+    const taskFocusRatio = clamp01(taskFocus / 0.62);
+    const disciplineRatio = clamp01(discipline / 0.72);
+    const triggerConditions = [];
+    pushReason(triggerConditions, taskFocused, "task-focus>=0.62");
+    pushReason(triggerConditions, disciplined, "discipline>=0.72");
+    pushReason(triggerConditions, expressionInhibition > 0.64, "expression-inhibition>0.64");
+    pushReason(triggerConditions, loopPressure > 0.68, "loop-pressure>0.68");
+    pushReason(triggerConditions, repairFriction > 0.6, "repair-friction>0.60");
+    pushReason(triggerConditions, namingConfidence < 0.36, "naming-confidence<0.36");
+    if (triggerConditions.length === 0) {
+        triggerConditions.push("default-private-fallback");
+    }
+    const workReasons = [];
+    pushReason(workReasons, taskFocused, "task focus crossed work threshold");
+    pushReason(workReasons, disciplined, "discipline crossed work threshold");
+    pushReason(workReasons, taskFocus > 0.78 && discipline > 0.68, "high task-focus and discipline reinforce work mode");
+    const workScore = taskFocused && disciplined
+        ? 1
+        : taskFocused || disciplined
+            ? 0.82
+            : clamp01(Math.max(taskFocusRatio, disciplineRatio) * 0.35);
+    const privateReasons = [];
+    pushReason(privateReasons, !taskFocused && !disciplined, "no work threshold active");
+    pushReason(privateReasons, attachment > 0.58, "attachment keeps private surface viable");
+    pushReason(privateReasons, closeness > 0.58, "relational closeness favors private surface");
+    pushReason(privateReasons, guardedness > 0.62 || loopPressure > 0.58, "guarded relation state prefers private handling");
+    pushReason(privateReasons, repairFriction > 0.48 || residue > 0.45, "carry or friction remains active");
+    const privateScore = !taskFocused && !disciplined
+        ? clamp01(0.78 + (((1 - taskFocusRatio) + (1 - disciplineRatio)) / 2) * 0.22)
+        : clamp01((1 - Math.max(taskFocusRatio, disciplineRatio)) * 0.3);
+    const selected = responseContract.replyProfile === "work"
+        ? "work-profile"
+        : "private-profile";
+    return {
+        selected,
+        triggerConditions,
+        candidates: [
+            {
+                candidate: "work-profile",
+                score: workScore,
+                accepted: selected === "work-profile",
+                reasons: workReasons,
+            },
+            {
+                candidate: "private-profile",
+                score: privateScore,
+                accepted: selected === "private-profile",
+                reasons: privateReasons,
+            },
+        ],
+    };
+}
+function listRenderInputs(inputs) {
+    const names = [];
+    if (inputs.userText)
+        names.push("sensing");
+    if (inputs.subjectivityContext)
+        names.push("subjectivity");
+    if (inputs.responseContractContext)
+        names.push("response-contract");
+    if (inputs.metacognitiveNote)
+        names.push("metacognition");
+    if (inputs.decisionContext)
+        names.push("decision");
+    if (inputs.ethicsContext)
+        names.push("ethics");
+    if (inputs.sharedIntentionalityContext)
+        names.push("shared-intentionality");
+    if (inputs.experientialNarrative)
+        names.push("experiential");
+    if (inputs.autonomicDescription)
+        names.push("autonomic");
+    if (inputs.primarySystemsDescription)
+        names.push("primary-systems");
+    if (inputs.policyContext)
+        names.push("policy");
+    return names;
+}
+function listRuntimeHooks(externalContinuityExports, writebackFeedbackCount) {
+    const hooks = [
+        "appraisal",
+        "relation-dynamics",
+        "reply-envelope",
+        "prompt-renderer",
+    ];
+    if (writebackFeedbackCount > 0)
+        hooks.push("writeback-evaluation");
+    if (externalContinuityExports > 0)
+        hooks.push("external-continuity");
+    return hooks;
+}
+export function buildTurnObservability(state, opts) {
+    const stateLayers = buildStateLayers(state, {
+        stimulus: opts.stimulus,
+        userText: opts.userText,
+        sessionBridge: opts.sessionBridge,
+        writebackFeedback: opts.writebackFeedback,
+        relationContext: opts.relationContext,
+    });
+    return {
+        controlBoundary: pickDominantPlane(opts.replyEnvelope),
+        stateLayers,
+        stateReconciliation: buildStateReconciliation(stateLayers),
+        decisionRationale: buildDecisionRationale(opts.replyEnvelope),
+        outputAttribution: {
+            canonicalSurface: "reply-envelope",
+            promptRenderer: opts.compactMode ? "compact" : "dynamic",
+            renderInputs: listRenderInputs(opts.promptRenderInputs),
+            runtimeHooks: listRuntimeHooks(opts.externalContinuityExports, opts.writebackFeedback.length),
+            externalContinuityExports: opts.externalContinuityExports,
+            writebackFeedbackCount: opts.writebackFeedback.length,
+        },
+    };
+}

package/dist/types.d.ts

@@ -638,6 +638,60 @@ export interface ResponseContract {
     /** Which internal report, if any, should be requested in <psyche_update> */
     updateMode: "none" | "stimulus" | "empathy" | "stimulus+empathy";
 }
+export type TurnControlPlane = "task" | "subject" | "relation" | "ambiguity";
+export type TurnControlDriver = "task-focus" | "discipline" | "attachment" | "guardedness" | "identity-strain" | "residue" | "closeness" | "loop-pressure" | "repair-readiness" | "repair-friction" | "hysteresis" | "silent-carry" | "conflict-load" | "expression-inhibition" | "naming-uncertainty";
+export interface ControlBoundaryObservation {
+    dominantPlane: TurnControlPlane;
+    dominantDriver: TurnControlDriver;
+    strength: number;
+    replyProfile: ResponseContract["replyProfile"];
+    replyProfileBasis: ResponseContract["replyProfileBasis"];
+    overrideWindow: ResponseContract["overrideWindow"];
+}
+export type StateLayerKind = "current-turn" | "writeback-feedback" | "session-bridge" | "persisted-relationship";
+export interface StateLayerObservation {
+    layer: StateLayerKind;
+    precedence: number;
+    scope: "turn" | "session" | "persistent";
+    active: boolean;
+    summary: string;
+}
+export type PromptRenderInputName = "sensing" | "subjectivity" | "response-contract" | "metacognition" | "decision" | "ethics" | "shared-intentionality" | "experiential" | "autonomic" | "primary-systems" | "policy";
+export type RuntimeHookName = "appraisal" | "relation-dynamics" | "writeback-evaluation" | "reply-envelope" | "prompt-renderer" | "external-continuity";
+export interface OutputAttributionObservation {
+    canonicalSurface: "reply-envelope";
+    promptRenderer: "compact" | "dynamic";
+    renderInputs: PromptRenderInputName[];
+    runtimeHooks: RuntimeHookName[];
+    externalContinuityExports: number;
+    writebackFeedbackCount: number;
+}
+export interface StateReconciliationObservation {
+    governingLayer: StateLayerKind;
+    activeLayers: StateLayerKind[];
+    carryLayers: StateLayerKind[];
+    resolution: "current-turn-dominant" | "writeback-adjusted" | "session-bridge-biased" | "persistent-baseline";
+    notes: string[];
+}
+export type DecisionCandidateName = "work-profile" | "private-profile";
+export interface DecisionCandidateObservation {
+    candidate: DecisionCandidateName;
+    score: number;
+    accepted: boolean;
+    reasons: string[];
+}
+export interface DecisionRationaleObservation {
+    selected: DecisionCandidateName;
+    triggerConditions: string[];
+    candidates: DecisionCandidateObservation[];
+}
+export interface TurnObservability {
+    controlBoundary: ControlBoundaryObservation;
+    stateLayers: StateLayerObservation[];
+    stateReconciliation: StateReconciliationObservation;
+    decisionRationale: DecisionRationaleObservation;
+    outputAttribution: OutputAttributionObservation;
+}
 /** 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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "psyche-ai",
-  "version": "9.2.9",
+  "version": "9.2.10",
   "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",