psyche-ai 9.2.8 → 9.2.10

package/README.md

@@ -1,7 +1,7 @@
 # Psyche — 面向智能体的 AI-first 主观性内核
 
 [![npm](https://img.shields.io/npm/v/psyche-ai)](https://www.npmjs.com/package/psyche-ai)
-[![tests](https://img.shields.io/badge/tests-1307%20passing-brightgreen)]()
+[![tests](https://img.shields.io/badge/tests-1308%20passing-brightgreen)]()
 [![deps](https://img.shields.io/badge/dependencies-0-blue)]()
 [![license](https://img.shields.io/badge/license-MIT-yellow)](LICENSE)
 
@@ -209,6 +209,30 @@ npm view psyche-ai version
 - `git` 工作树和本地路径安装不会偷偷改你的代码；脏工作树只会提示手动命令。
 - OpenClaw 如果是从当前仓库本地加载，升级后记得重启 gateway 以载入新的 `dist/`。
 
+## 给本机其他 Agent 的真实验收
+
+如果另一个 agent 声称“已经在用 Psyche”，不要接受口头解释，直接让它跑：
+
+```bash
+psyche probe --json
+```
+
+这条命令会实际调用一次 `processInput()` 和 `processOutput()`，并返回：
+
+- 实际版本
+- 实际加载路径
+- 是否真的调用成功
+- `replyEnvelope` 这个规范主接口是否存在
+
+通过标准不是“它理解了 Psyche”，而是：
+
+- `ok = true`
+- `processInputCalled = true`
+- `processOutputCalled = true`
+- `canonicalHostSurface = true`
+
+正式说明见：[docs/AGENT_RUNTIME_PROBE.md](docs/AGENT_RUNTIME_PROBE.md)
+
 ---
 
 ## 它和你认知中的 AI 完全不同
@@ -302,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 一个始终运转的内在自我——不是条件触发，而是每时每刻都在：
@@ -523,7 +555,7 @@ Psyche 核心引擎永久开源（MIT）。
 ```bash
 npm install
 npm run build
-npm test           # 1307 tests
+npm test           # 1308 tests
 npm run typecheck  # strict mode
 ```
 

package/dist/cli.js

@@ -13,6 +13,7 @@
 //   psyche reset <dir> [--full]
 //   psyche diagnose <dir> [--github]
 //   psyche upgrade [--check]
+//   psyche probe [--json]
 //   psyche profiles [--json] [--mbti TYPE]
 // ============================================================
 import { resolve } from "node:path";
@@ -27,6 +28,7 @@ import { t } from "./i18n.js";
 import { CHEMICAL_KEYS, CHEMICAL_NAMES_ZH, DRIVE_KEYS, DRIVE_NAMES_ZH } from "./types.js";
 import { isMBTIType, isChemicalKey, isLocale } from "./guards.js";
 import { getPackageVersion, selfUpdate } from "./update.js";
+import { runRuntimeProbe } from "./runtime-probe.js";
 // ── Logger ───────────────────────────────────────────────────
 const cliLogger = {
     info: (msg) => console.error(`[info] ${msg}`),
@@ -425,6 +427,33 @@ async function cmdUpgrade(checkOnly) {
     const result = await selfUpdate({ checkOnly });
     console.log(result.message);
 }
+async function cmdProbe(json) {
+    const result = await runRuntimeProbe();
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (!result.ok) {
+        console.log("\nPsyche runtime probe: FAILED\n");
+        console.log(`  version: ${result.version}`);
+        console.log(`  entry: ${result.entry}`);
+        console.log(`  load path: ${result.loadPath}`);
+        console.log(`  module path: ${result.modulePath}`);
+        console.log(`  cli path: ${result.cliPath}`);
+        console.log(`  error: ${result.error ?? "unknown error"}`);
+        return;
+    }
+    console.log("\nPsyche runtime probe: OK\n");
+    console.log(`  version: ${result.version}`);
+    console.log(`  entry: ${result.entry}`);
+    console.log(`  load path: ${result.loadPath}`);
+    console.log(`  module path: ${result.modulePath}`);
+    console.log(`  cli path: ${result.cliPath}`);
+    console.log(`  processInput: ok (stimulus=${result.stimulus ?? "null"})`);
+    console.log(`  processOutput: ok (stateChanged=${String(result.stateChanged)})`);
+    console.log(`  replyEnvelope: ${result.canonicalHostSurface ? "present" : "missing"}`);
+    console.log(`  externalContinuity: ${result.externalContinuityAvailable ? "present" : "missing"}`);
+}
 // ── Usage ────────────────────────────────────────────────────
 function usage() {
     console.log(`
@@ -442,6 +471,7 @@ Usage:
   psyche reset <dir> [--full]
   psyche diagnose <dir> [--github]   Run health checks & show diagnostic report
   psyche upgrade [--check]           Check/apply package updates safely
+  psyche probe [--json]              Verify the runtime is truly callable
   psyche profiles [--mbti TYPE] [--json]
 
 Options:
@@ -474,6 +504,9 @@ Examples:
 
   # Check for new package versions without applying them
   psyche upgrade --check
+
+  # Prove this environment can really call Psyche
+  psyche probe --json
 	`);
 }
 // ── Main ─────────────────────────────────────────────────────
@@ -614,6 +647,17 @@ async function main() {
                 await cmdUpgrade(values.check ?? false);
                 break;
             }
+            case "probe": {
+                const { values } = parseArgs({
+                    args: rest,
+                    options: {
+                        json: { type: "boolean", default: false },
+                    },
+                    allowPositionals: true,
+                });
+                await cmdProbe(values.json ?? false);
+                break;
+            }
             default:
                 die(`unknown command: ${command}. Run 'psyche help' for usage.`);
         }

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,11 +28,14 @@ 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";
 export { deriveThrongletsExports } from "./thronglets-export.js";
 export { taxonomyForThrongletsExport, serializeThrongletsExportAsTrace, serializeExternalContinuityForThronglets, } from "./thronglets-runtime.js";
+export { runRuntimeProbe } from "./runtime-probe.js";
+export type { RuntimeProbeResult } from "./runtime-probe.js";
 export { computeExperientialField, computeCoherence, detectUnnamedEmotion, computeAffectCore } from "./experiential-field.js";
 export type { ExperientialField, ExperientialQuality, ConstructionContext } from "./experiential-field.js";
 export { computeGenerativeSelf, predictSelfReaction, detectInternalConflicts, buildIdentityNarrative } from "./generative-self.js";

package/dist/index.js

@@ -38,11 +38,13 @@ 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";
 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)

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/runtime-probe.d.ts

@@ -0,0 +1,18 @@
+export interface RuntimeProbeResult {
+    ok: boolean;
+    packageName: "psyche-ai";
+    version: string;
+    entry: "sdk";
+    loadPath: string;
+    modulePath: string;
+    cliPath: string;
+    processInputCalled: boolean;
+    processOutputCalled: boolean;
+    canonicalHostSurface: boolean;
+    externalContinuityAvailable: boolean;
+    stimulus: string | null;
+    cleanedText?: string;
+    stateChanged?: boolean;
+    error?: string;
+}
+export declare function runRuntimeProbe(): Promise<RuntimeProbeResult>;

package/dist/runtime-probe.js

@@ -0,0 +1,56 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { PsycheEngine } from "./core.js";
+import { MemoryStorageAdapter } from "./storage.js";
+import { getPackageVersion } from "./update.js";
+export async function runRuntimeProbe() {
+    const modulePath = fileURLToPath(import.meta.url);
+    const loadPath = resolve(dirname(modulePath), "..");
+    const cliPath = resolve(loadPath, "dist", "cli.js");
+    const version = await getPackageVersion();
+    try {
+        const engine = new PsycheEngine({
+            name: "Probe",
+            locale: "en",
+            persist: false,
+        }, new MemoryStorageAdapter());
+        await engine.initialize();
+        const input = await engine.processInput("Runtime probe: verify the SDK is actually callable.");
+        const output = await engine.processOutput("Probe output acknowledged.");
+        return {
+            ok: true,
+            packageName: "psyche-ai",
+            version,
+            entry: "sdk",
+            loadPath,
+            modulePath,
+            cliPath,
+            processInputCalled: true,
+            processOutputCalled: true,
+            canonicalHostSurface: Boolean(input.replyEnvelope?.subjectivityKernel
+                && input.replyEnvelope?.responseContract
+                && input.replyEnvelope?.generationControls),
+            externalContinuityAvailable: Boolean(input.externalContinuity?.provider === "thronglets"),
+            stimulus: input.stimulus,
+            cleanedText: output.cleanedText,
+            stateChanged: output.stateChanged,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            packageName: "psyche-ai",
+            version,
+            entry: "sdk",
+            loadPath,
+            modulePath,
+            cliPath,
+            processInputCalled: false,
+            processOutputCalled: false,
+            canonicalHostSurface: false,
+            externalContinuityAvailable: false,
+            stimulus: null,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

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/llms.txt

@@ -142,6 +142,23 @@ npm install psyche-ai
 npx psyche-mcp
 ```
 
+## Runtime Proof
+
+If an agent claims it is already using Psyche in the current environment, require a real probe:
+
+```bash
+psyche probe --json
+```
+
+Passing means:
+
+- `ok = true`
+- `processInputCalled = true`
+- `processOutputCalled = true`
+- `canonicalHostSurface = true`
+
+This is runtime proof. Conceptual understanding is not enough.
+
 ## Links
 
 - npm: https://www.npmjs.com/package/psyche-ai

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "psyche-ai",
-  "version": "9.2.8",
+  "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",
@@ -43,7 +43,10 @@
     "test": "npm run build && npm run build:test && node --test dist-test/tests/*.test.js",
     "typecheck": "tsc --noEmit --strict",
     "dev": "tsc --watch",
-    "demo": "node scripts/demo-ab.js"
+    "demo": "node scripts/demo-ab.js",
+    "probe": "node dist/cli.js probe --json",
+    "release:guard": "node scripts/release-guard.mjs",
+    "prepublishOnly": "npm run release:guard && npm test"
   },
   "license": "MIT",
   "repository": {