psyche-ai 9.2.9 → 10.0.0

package/dist/index.js

@@ -1,71 +1,186 @@
 // ============================================================
 // psyche-ai — Universal AI Emotional Intelligence Plugin
 //
-// Main entry point: re-exports core, storage, types.
+// Public API surface (~20 essential exports).
+// Internal computation functions remain accessible via direct
+// module imports (e.g. "psyche-ai/src/learning.js") for tests
+// and advanced use, but are NOT part of the public contract.
+//
 // Framework adapters available via subpath imports:
 //   psyche-ai/openclaw   — OpenClaw plugin
 //   psyche-ai/vercel-ai  — Vercel AI SDK middleware
 //   psyche-ai/langchain  — LangChain helper
 //   psyche-ai/http       — HTTP server for Python/Go/etc.
 // ============================================================
-// Core
+// ── Core engine ─────────────────────────────────────────────
 export { PsycheEngine } from "./core.js";
-// Storage
+// ── Storage ─────────────────────────────────────────────────
 export { FileStorageAdapter, MemoryStorageAdapter } from "./storage.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";
-// Self-recognition
-export { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
-// Multi-agent interaction
-export { PsycheInteraction } from "./interaction.js";
-// Channels
-export { getChannelProfile, buildChannelModifier, createCustomChannel } from "./channels.js";
-// Custom profiles — beyond MBTI presets
-export { createCustomProfile, validateProfileConfig, PRESET_PROFILES } from "./custom-profile.js";
-// Emotional learning (P3)
-export { evaluateOutcome, getLearnedVector, updateLearnedVector, computeContextHash, predictChemistry, computePredictionError, recordPrediction, getAveragePredictionError, } from "./learning.js";
-// Context-aware classification (P3)
-export { classifyStimulusWithContext, extractContextFeatures, stimulusWarmth } from "./context-classifier.js";
-// Temporal consciousness (P4)
-export { predictNextStimulus, generateAnticipation, computeSurpriseEffect, computeRegret, } from "./temporal.js";
-// Attachment dynamics (P4)
-export { updateAttachment, computeSeparationEffect, computeReunionEffect, } from "./attachment.js";
-// Metacognition (P5)
-export { assessMetacognition, computeEmotionalConfidence, generateRegulationSuggestions, detectDefenseMechanisms, } from "./metacognition.js";
-// Decision bias (P5) + PolicyModifiers (v9)
-export { computeDecisionBias, computeAttentionWeights, computeExploreExploit, buildDecisionContext, computePolicyModifiers, buildPolicyContext, } from "./decision-bias.js";
-// Subjectivity kernel (v9.3)
-export { computeSubjectivityKernel, buildSubjectivityContext } from "./subjectivity.js";
-export { computeResponseContract, buildResponseContractContext } from "./response-contract.js";
-export { deriveGenerationControls } from "./host-controls.js";
-export { deriveReplyEnvelope } from "./reply-envelope.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";
-export { deriveThrongletsExports } from "./thronglets-export.js";
-export { taxonomyForThrongletsExport, serializeThrongletsExportAsTrace, serializeExternalContinuityForThronglets, } from "./thronglets-runtime.js";
-export { runRuntimeProbe } from "./runtime-probe.js";
-// Experiential field (P6 + P8 Barrett construction)
-export { computeExperientialField, computeCoherence, detectUnnamedEmotion, computeAffectCore } from "./experiential-field.js";
-// Generative self (P6)
-export { computeGenerativeSelf, predictSelfReaction, detectInternalConflicts, buildIdentityNarrative } from "./generative-self.js";
-// Shared intentionality (P6)
-export { updateSharedIntentionality, estimateOtherMood, buildSharedIntentionalityContext } from "./shared-intentionality.js";
-// Emotional ethics (P6)
-export { assessEthics, detectIntermittentReinforcement, detectDependencyRisk, buildEthicalContext, } from "./ethics.js";
-// Autonomic nervous system (P7)
-export { computeAutonomicResult, computeAutonomicState, computeProcessingDepth, gateEmotions, getTransitionTime, describeAutonomicState } from "./autonomic.js";
-// Circadian rhythms (P12)
-export { computeCircadianModulation, computeHomeostaticPressure, getCircadianPhase, computeEnergyDepletion, computeEnergyRecovery } from "./circadian.js";
-// Primary emotional systems — Panksepp (P9)
-export { computePrimarySystems, computeSystemInteractions, gatePrimarySystemsByAutonomic, getDominantSystems, describeBehavioralTendencies, PRIMARY_SYSTEM_NAMES, } from "./primary-systems.js";
-// Utilities — for custom adapter / advanced use
-// Trait drift (v9)
-export { updateTraitDrift } from "./drives.js";
-// Utilities — for custom adapter / advanced use
-export { classifyStimulus, getPrimaryStimulus, scoreSentiment, scoreEmoji, BuiltInClassifier, analyzeParticles, detectIntent, buildLLMClassifierPrompt, parseLLMClassification } from "./classify.js";
-export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline, getNearBaselineThreshold } from "./prompt.js";
-export { describeEmotionalState, getExpressionHint, getBehaviorGuide, detectEmotions } from "./chemistry.js";
-export { getBaseline, getTemperament, getSensitivity, getDefaultSelfModel, traitsToBaseline, mbtiToTraits } from "./profiles.js";
-export { migrateToLatest, compressSession, parsePsycheUpdate, computeSnapshotIntensity, computeSnapshotValence, consolidateHistory, retrieveRelatedMemories, } from "./psyche-file.js";
-// ── Diagnostics ──────────────────────────────────────────────
-export { runHealthCheck, DiagnosticCollector, generateReport, formatReport, toGitHubIssueBody, formatLogEntry, submitFeedback, } from "./diagnostics.js";
+// ── Prompt context builders ─────────────────────────────────
+export { buildProtocolContext, buildCompactContext } from "./prompt.js";
+/** @deprecated Use buildCompactContext instead. Kept for backward compat. */
+export { buildDynamicContext } from "./prompt.js";
+export { isNearBaseline, getNearBaselineThreshold, deriveBehavioralBias, computeUserInvestment } from "./prompt.js";
+// ── Profile helpers ─────────────────────────────────────────
+export { getBaseline, getSensitivity, getDefaultSelfModel, getTemperament, traitsToBaseline, mbtiToTraits } from "./profiles.js";
+export { createCustomProfile, PRESET_PROFILES } from "./custom-profile.js";
+// ── Diagnostics ─────────────────────────────────────────────
+export { computeLayerHealthSummary } from "./diagnostics.js";
+// ============================================================
+// INTENTIONALLY REMOVED FROM PUBLIC API (v9.3)
+//
+// The following were previously exported but are internal
+// implementation details. They remain importable via direct
+// module paths for tests and advanced integrations:
+//
+// types.js (constants & defaults):
+//   CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DRIVE_KEYS,
+//   DRIVE_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES,
+//   DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE,
+//   DEFAULT_PERSONHOOD_STATE, DEFAULT_ATTACHMENT,
+//   DEFAULT_TRAIT_DRIFT, DEFAULT_ENERGY_BUDGETS,
+//   DEFAULT_APPRAISAL_AXES, DEFAULT_SUBJECT_RESIDUE,
+//   DEFAULT_DYADIC_FIELD
+//
+// types.js (internal type aliases):
+//   ChemicalSnapshot, SelfModel, RelationshipState, EmpathyEntry,
+//   EmotionPattern, DriveType, InnateDrives, LearningState,
+//   LearnedVectorAdjustment, PredictionRecord, OutcomeScore,
+//   OutcomeSignals, AttachmentStyle, AttachmentData,
+//   MetacognitiveState, RegulationRecord, DefensePatternRecord,
+//   RegulationStrategyType, DefenseMechanismType, PersonhoodState,
+//   PersistedCausalInsight, GrowthDirection, PersonalityTraits,
+//   PolicyModifiers, SubjectivityKernel, ResponseContract,
+//   GenerationControls, TurnControlPlane, TurnControlDriver,
+//   ControlBoundaryObservation, StateLayerKind,
+//   StateLayerObservation, PromptRenderInputName, RuntimeHookName,
+//   OutputAttributionObservation, StateReconciliationObservation,
+//   DecisionEvidenceObservation, DecisionCandidateName,
+//   DecisionCandidateObservation, DecisionRationaleObservation,
+//   CausalChainObservation, ExternalTraceMappingObservation,
+//   TurnObservability, AppraisalAxes, SubjectResidue,
+//   TaskPlaneState, SubjectPlaneState, RelationPlaneState,
+//   AmbiguityPlaneState, RelationMoveType, RelationMove,
+//   OpenLoopType, OpenLoopState, PendingRelationSignalState,
+//   DyadicFieldState, SessionBridgeState,
+//   ThrongletsExport* types, ExternalContinuity* types,
+//   WritebackSignalWeightMap, PendingWritebackCalibration,
+//   WritebackCalibrationFeedback, WritebackCalibrationMetric,
+//   TraitDriftState, EnergyBudgets, ClassifierProvider,
+//   ClassifierContext, ClassificationResult
+//
+// self-recognition.js:
+//   computeSelfReflection, computeEmotionalTendency,
+//   buildSelfReflectionContext, SelfReflection
+//
+// interaction.js:
+//   PsycheInteraction, ExchangeResult, ContagionResult,
+//   RelationshipSummary, InteractionPhase
+//
+// channels.js:
+//   getChannelProfile, buildChannelModifier, createCustomChannel,
+//   ChannelType, ChannelProfile
+//
+// custom-profile.js:
+//   validateProfileConfig, CustomProfileConfig, ResolvedProfile
+//
+// learning.js:
+//   evaluateOutcome, getLearnedVector, updateLearnedVector,
+//   computeContextHash, predictChemistry, computePredictionError,
+//   recordPrediction, getAveragePredictionError
+//
+// context-classifier.js:
+//   classifyStimulusWithContext, extractContextFeatures,
+//   stimulusWarmth, ContextFeatures, ContextualClassification
+//
+// temporal.js:
+//   predictNextStimulus, generateAnticipation,
+//   computeSurpriseEffect, computeRegret, StimulusPrediction,
+//   AnticipationState, RegretEntry
+//
+// attachment.js:
+//   updateAttachment, computeSeparationEffect,
+//   computeReunionEffect, SeparationEffect
+//
+// metacognition.js:
+//   assessMetacognition, computeEmotionalConfidence,
+//   generateRegulationSuggestions, detectDefenseMechanisms,
+//   MetacognitiveAssessment, RegulationSuggestion, DetectedDefense
+//
+// decision-bias.js:
+//   computeDecisionBias, computeAttentionWeights,
+//   computeExploreExploit, buildDecisionContext,
+//   computePolicyModifiers, buildPolicyContext,
+//   DecisionBiasVector, AttentionWeights
+//
+// subjectivity.js, response-contract.js, host-controls.js,
+// reply-envelope.js, observability.js, appraisal.js,
+// relation-dynamics.js, external-continuity.js,
+// thronglets-export.js, thronglets-runtime.js,
+// runtime-probe.js:
+//   All functions & types (orchestrated by PsycheEngine)
+//
+// experiential-field.js:
+//   computeExperientialField, computeCoherence,
+//   detectUnnamedEmotion, computeAffectCore, ExperientialField,
+//   ExperientialQuality, ConstructionContext
+//
+// generative-self.js:
+//   computeGenerativeSelf, predictSelfReaction,
+//   detectInternalConflicts, buildIdentityNarrative,
+//   GenerativeSelfModel, CausalInsight, SelfPrediction,
+//   GrowthArc, InternalConflict
+//
+// shared-intentionality.js:
+//   updateSharedIntentionality, estimateOtherMood,
+//   buildSharedIntentionalityContext, SharedIntentionalityState,
+//   TheoryOfMindModel, JointAttentionTopic, GoalAlignment
+//
+// ethics.js:
+//   assessEthics, detectIntermittentReinforcement,
+//   detectDependencyRisk, buildEthicalContext,
+//   EthicalAssessment, EthicalConcern, SelfProtectionAction
+//
+// autonomic.js:
+//   computeAutonomicResult, computeAutonomicState,
+//   computeProcessingDepth, gateEmotions, getTransitionTime,
+//   describeAutonomicState, AutonomicState, AutonomicResult,
+//   AutonomicTransition
+//
+// circadian.js:
+//   computeCircadianModulation, computeHomeostaticPressure,
+//   getCircadianPhase, computeEnergyDepletion,
+//   computeEnergyRecovery, CircadianPhase
+//
+// primary-systems.js:
+//   computePrimarySystems, computeSystemInteractions,
+//   gatePrimarySystemsByAutonomic, getDominantSystems,
+//   describeBehavioralTendencies, PRIMARY_SYSTEM_NAMES,
+//   PrimarySystemName, PrimarySystemLevels,
+//   BehavioralTendency, DominantSystem
+//
+// classify.js:
+//   classifyStimulus, getPrimaryStimulus, scoreSentiment,
+//   scoreEmoji, BuiltInClassifier, analyzeParticles, detectIntent,
+//   buildLLMClassifierPrompt, parseLLMClassification,
+//   StimulusClassification, ParticleSignal, MessageIntent
+//
+// chemistry.js:
+//   describeEmotionalState, getExpressionHint,
+//   getBehaviorGuide, detectEmotions
+//
+// drives.js:
+//   updateTraitDrift
+//
+// psyche-file.js:
+//   migrateToLatest, compressSession, parsePsycheUpdate,
+//   computeSnapshotIntensity, computeSnapshotValence,
+//   consolidateHistory, retrieveRelatedMemories,
+//   PsycheUpdateResult
+//
+// diagnostics.js (remaining):
+//   runHealthCheck, DiagnosticCollector, generateReport,
+//   formatReport, toGitHubIssueBody, formatLogEntry,
+//   submitFeedback, DiagnosticIssue, DiagnosticReport,
+//   SessionMetrics, Severity
+// ============================================================

package/dist/observability.d.ts

@@ -0,0 +1,14 @@
+import type { PsycheState, ResolvedRelationContext, SessionBridgeState, StimulusType, ThrongletsExport, 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;
+    externalContinuityEvents: ThrongletsExport[];
+}): TurnObservability;

package/dist/observability.js

@@ -0,0 +1,392 @@
+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 pushEvidence(evidence, opts) {
+    if (!opts.condition)
+        return;
+    evidence.push({
+        ruleId: opts.ruleId,
+        sourceMetric: opts.sourceMetric,
+        rawValue: opts.rawValue,
+        threshold: opts.threshold,
+        contribution: clamp01(opts.contribution),
+    });
+}
+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 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 = [];
+    const workEvidence = [];
+    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");
+    pushEvidence(workEvidence, {
+        ruleId: "reply-profile.work.task-focus-threshold",
+        sourceMetric: "taskPlane.focus",
+        rawValue: taskFocus,
+        threshold: 0.62,
+        contribution: 0.55,
+        condition: taskFocused,
+    });
+    pushEvidence(workEvidence, {
+        ruleId: "reply-profile.work.discipline-threshold",
+        sourceMetric: "taskPlane.discipline",
+        rawValue: discipline,
+        threshold: 0.72,
+        contribution: 0.45,
+        condition: disciplined,
+    });
+    const workScore = clamp01(workEvidence.reduce((sum, item) => sum + item.contribution, 0));
+    const privateReasons = [];
+    const privateEvidence = [];
+    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");
+    pushEvidence(privateEvidence, {
+        ruleId: "reply-profile.private.default-fallback",
+        sourceMetric: "replyProfileBasis",
+        rawValue: !taskFocused && !disciplined ? 1 : 0,
+        threshold: 1,
+        contribution: 0.7,
+        condition: !taskFocused && !disciplined,
+    });
+    pushEvidence(privateEvidence, {
+        ruleId: "reply-profile.private.attachment-support",
+        sourceMetric: "subjectPlane.attachment",
+        rawValue: attachment,
+        threshold: 0.58,
+        contribution: 0.1,
+        condition: attachment > 0.58,
+    });
+    pushEvidence(privateEvidence, {
+        ruleId: "reply-profile.private.closeness-support",
+        sourceMetric: "relationPlane.closeness",
+        rawValue: closeness,
+        threshold: 0.58,
+        contribution: 0.08,
+        condition: closeness > 0.58,
+    });
+    pushEvidence(privateEvidence, {
+        ruleId: "reply-profile.private.guarded-support",
+        sourceMetric: "subjectPlane.guardedness",
+        rawValue: guardedness,
+        threshold: 0.62,
+        contribution: 0.07,
+        condition: guardedness > 0.62 || loopPressure > 0.58,
+    });
+    pushEvidence(privateEvidence, {
+        ruleId: "reply-profile.private.carry-support",
+        sourceMetric: "subjectPlane.residue",
+        rawValue: Math.max(repairFriction, residue),
+        threshold: 0.48,
+        contribution: 0.05,
+        condition: repairFriction > 0.48 || residue > 0.45,
+    });
+    const privateScore = clamp01(privateEvidence.reduce((sum, item) => sum + item.contribution, 0));
+    const selected = responseContract.replyProfile === "work"
+        ? "work-profile"
+        : "private-profile";
+    return {
+        selected,
+        triggerConditions,
+        candidates: [
+            {
+                candidate: "work-profile",
+                score: workScore,
+                accepted: selected === "work-profile",
+                reasons: workReasons,
+                evidence: workEvidence,
+            },
+            {
+                candidate: "private-profile",
+                score: privateScore,
+                accepted: selected === "private-profile",
+                reasons: privateReasons,
+                evidence: privateEvidence,
+            },
+        ],
+    };
+}
+function buildCausalChain(state, opts) {
+    const relationKey = opts.relationContext?.key ?? "_default";
+    const turnRef = `psyche:${relationKey}:turn:${state.meta.totalInteractions}`;
+    const parentTurnRef = state.meta.totalInteractions > 1
+        ? `psyche:${relationKey}:turn:${state.meta.totalInteractions - 1}`
+        : null;
+    const continuityRefs = opts.externalContinuityEvents
+        .filter((event) => event.kind === "continuity-anchor" || event.kind === "open-loop-anchor")
+        .map((event) => event.key);
+    const writebackRefs = opts.externalContinuityEvents
+        .filter((event) => event.kind === "writeback-calibration")
+        .map((event) => event.key);
+    const externalTraceRefs = opts.externalContinuityEvents.map((event) => event.key);
+    if (opts.writebackFeedback.length > 0 && writebackRefs.length === 0) {
+        writebackRefs.push(...opts.writebackFeedback.map((feedback) => `writeback:${relationKey}:${feedback.signal}:${feedback.effect}`));
+    }
+    if (opts.sessionBridge && continuityRefs.length === 0) {
+        continuityRefs.push(`bridge:${relationKey}:${opts.sessionBridge.continuityMode}`);
+    }
+    return {
+        turnRef,
+        parentTurnRef,
+        continuityRefs,
+        writebackRefs,
+        externalTraceRefs,
+    };
+}
+function buildTraceMapping(externalContinuityEvents) {
+    const localTraceRefs = externalContinuityEvents.map((event) => event.key);
+    const signalRefs = externalContinuityEvents
+        .filter((event) => event.primitive === "signal")
+        .map((event) => event.key);
+    const traceRefs = externalContinuityEvents
+        .filter((event) => event.primitive === "trace")
+        .map((event) => event.key);
+    const summaryCandidateRefs = externalContinuityEvents
+        .filter((event) => event.kind === "continuity-anchor"
+        || event.kind === "relation-milestone"
+        || (event.kind === "open-loop-anchor" && event.strength >= 0.72))
+        .map((event) => event.key);
+    return {
+        provider: externalContinuityEvents.length > 0 ? "thronglets" : null,
+        localTraceRefs,
+        signalRefs,
+        traceRefs,
+        summaryCandidateRefs,
+    };
+}
+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),
+        causalChain: buildCausalChain(state, {
+            relationContext: opts.relationContext,
+            sessionBridge: opts.sessionBridge,
+            writebackFeedback: opts.writebackFeedback,
+            externalContinuityEvents: opts.externalContinuityEvents,
+        }),
+        traceMapping: buildTraceMapping(opts.externalContinuityEvents),
+        outputAttribution: {
+            canonicalSurface: "reply-envelope",
+            promptRenderer: opts.compactMode ? "compact" : "dynamic",
+            renderInputs: listRenderInputs(opts.promptRenderInputs),
+            runtimeHooks: listRuntimeHooks(opts.externalContinuityEvents.length, opts.writebackFeedback.length),
+            externalContinuityExports: opts.externalContinuityEvents.length,
+            writebackFeedbackCount: opts.writebackFeedback.length,
+        },
+    };
+}