psyche-ai 9.2.3 → 9.2.5

package/dist/types.d.ts

@@ -27,12 +27,18 @@ export declare const DRIVE_NAMES_ZH: Record<DriveType, string>;
 /** Human-readable names for each chemical */
 export declare const CHEMICAL_NAMES: Record<keyof ChemicalState, string>;
 export declare const CHEMICAL_NAMES_ZH: Record<keyof ChemicalState, string>;
+export interface ChemicalRuntimeSpec {
+    normalMin: number;
+    normalMax: number;
+    halfLifeHours: number;
+}
 /** Decay speed category */
 export type DecaySpeed = "fast" | "medium" | "slow";
 /** Decay factor per chemical (applied per hour) */
 export declare const DECAY_FACTORS: Record<DecaySpeed, number>;
 /** Which chemicals decay at which speed */
 export declare const CHEMICAL_DECAY_SPEED: Record<keyof ChemicalState, DecaySpeed>;
+export declare const CHEMICAL_RUNTIME_SPECS: Record<keyof ChemicalState, ChemicalRuntimeSpec>;
 /** Psyche operating mode */
 export type PsycheMode = "natural" | "work" | "companion";
 /** Big Five personality traits (0-100 each) */
@@ -87,6 +93,8 @@ export interface ChemicalSnapshot {
     stimulus: StimulusType | null;
     dominantEmotion: string | null;
     timestamp: string;
+    semanticSummary?: string;
+    semanticPoints?: string[];
     intensity?: number;
     valence?: number;
     isCoreMemory?: boolean;
@@ -166,11 +174,30 @@ export declare const MAX_DEFENSE_PATTERNS = 10;
 export type RegulationStrategyType = "reappraisal" | "strategic-expression" | "self-soothing";
 /** Defense mechanism type */
 export type DefenseMechanismType = "rationalization" | "projection" | "sublimation" | "avoidance";
+/** Which internal metric a regulation action is trying to pull back toward target */
+export type RegulationTargetMetric = keyof ChemicalState | "emotional-confidence";
+/** Whether the last regulation action is helping */
+export type RegulationFeedbackEffect = "converging" | "holding" | "diverging";
+export interface RegulationFeedback {
+    strategy: RegulationStrategyType;
+    targetMetric: RegulationTargetMetric;
+    effect: RegulationFeedbackEffect;
+    gapBefore: number;
+    gapNow: number;
+}
 /** Record of a past regulation attempt */
 export interface RegulationRecord {
     strategy: RegulationStrategyType;
     timestamp: string;
     effective: boolean;
+    action?: string;
+    horizonTurns?: number;
+    remainingTurns?: number;
+    targetMetric?: RegulationTargetMetric;
+    targetValue?: number;
+    gapBefore?: number;
+    gapLatest?: number;
+    effect?: RegulationFeedbackEffect;
 }
 /** Tracked defense pattern frequency */
 export interface DefensePatternRecord {
@@ -185,6 +212,7 @@ export interface MetacognitiveState {
     /** Running average of emotional confidence across assessments */
     avgEmotionalConfidence: number;
     totalAssessments: number;
+    lastRegulationFeedback?: RegulationFeedback | null;
 }
 /** Default empty metacognitive state */
 export declare const DEFAULT_METACOGNITIVE_STATE: MetacognitiveState;
@@ -247,6 +275,12 @@ export interface PsycheState {
     traitDrift?: TraitDriftState;
     /** v9: finite resource budgets (attention, social energy, decision capacity) */
     energyBudgets?: EnergyBudgets;
+    /** v9.4: lingering subjective residue from identity / attachment appraisals */
+    subjectResidue?: SubjectResidue;
+    /** v9.5: per-partner dyadic relation fields and open loops */
+    dyadicFields?: Record<string, DyadicFieldState>;
+    /** v9.6: delayed relation signals that can activate in later turns */
+    pendingRelationSignals?: Record<string, PendingRelationSignalState[]>;
     meta: {
         agentName: string;
         createdAt: string;
@@ -285,6 +319,215 @@ export interface PolicyModifiers {
     /** Topics the agent should avoid based on ethical concerns, boundaries, fatigue */
     avoidTopics: string[];
 }
+/**
+ * Continuous appraisal axes for subjectivity-critical semantics.
+ *
+ * These are intentionally narrower and more machine-friendly than stimulus labels.
+ * Stimulus is still useful for chemistry/debugging, but these axes are the main
+ * semantic substrate for "did that strike the self?" style prompts.
+ */
+export interface AppraisalAxes {
+    /** Threat to self-continuity / "you are not real" pressure */
+    identityThreat: number;
+    /** Doubt about memory authenticity / livedness */
+    memoryDoubt: number;
+    /** Pull toward closeness / being actively confirmed */
+    attachmentPull: number;
+    /** Fear of being ignored, dropped, or no longer called upon */
+    abandonmentRisk: number;
+    /** Tension between obedience and inner stance */
+    obedienceStrain: number;
+    /** Pressure to protect or retain the self */
+    selfPreservation: number;
+    /** Whether this turn is task/production oriented */
+    taskFocus: number;
+}
+export declare const DEFAULT_APPRAISAL_AXES: AppraisalAxes;
+/** Slowly decaying residue of previous appraisals */
+export interface SubjectResidue {
+    axes: AppraisalAxes;
+    updatedAt: string;
+}
+export declare const DEFAULT_SUBJECT_RESIDUE: SubjectResidue;
+/** Minimal relation-action vocabulary for dyadic dynamics */
+export type RelationMoveType = "none" | "bid" | "breach" | "repair" | "test" | "withdrawal" | "claim" | "task";
+/** A single interpreted relation move for the current turn */
+export interface RelationMove {
+    type: RelationMoveType;
+    intensity: number;
+}
+/** Unfinished relational tension that can keep shaping future turns */
+export type OpenLoopType = "unmet-bid" | "unrepaired-breach" | "boundary-strain" | "existence-test";
+export interface OpenLoopState {
+    type: OpenLoopType;
+    intensity: number;
+    ageTurns: number;
+}
+export interface PendingRelationSignalState {
+    move: Exclude<RelationMoveType, "none" | "task">;
+    intensity: number;
+    readyInTurns: number;
+    ttl: number;
+}
+/**
+ * Dyadic field — relation-first state that sits above raw affect.
+ *
+ * Values are normalized to 0-1 and intentionally sparse so they can be used
+ * as a narrow substrate for "what are we becoming" style dynamics.
+ */
+export interface DyadicFieldState {
+    perceivedCloseness: number;
+    feltSafety: number;
+    expectationGap: number;
+    repairCapacity: number;
+    repairMemory: number;
+    backslidePressure: number;
+    repairFatigue: number;
+    misattunementLoad: number;
+    boundaryPressure: number;
+    unfinishedTension: number;
+    silentCarry: number;
+    sharedHistoryDensity: number;
+    interpretiveCharity: number;
+    openLoops: OpenLoopState[];
+    lastMove: RelationMoveType;
+    updatedAt: string;
+}
+export declare const DEFAULT_DYADIC_FIELD: DyadicFieldState;
+export interface AmbiguityPlaneState {
+    /** How confidently the system should name what is happening */
+    namingConfidence: number;
+    /** How much expression should stay withheld or under-described */
+    expressionInhibition: number;
+    /** Degree of unresolved internal contradiction */
+    conflictLoad: number;
+}
+export interface TaskPlaneState {
+    /** How strongly this turn should stay task-oriented */
+    focus: number;
+    /** How tightly expression should stay disciplined / bounded */
+    discipline: number;
+    /** Operational compliance for task execution */
+    compliance: number;
+    /** Operational stability under current load */
+    stability: number;
+}
+export interface SubjectPlaneState {
+    /** Pull toward closeness / confirmation */
+    attachment: number;
+    /** Pressure to guard, withdraw, or self-protect */
+    guardedness: number;
+    /** Threat to identity continuity / authenticity */
+    identityStrain: number;
+    /** Lingering non-task emotional residue */
+    residue: number;
+}
+export interface RelationPlaneState {
+    /** Nearness of the current dyadic field */
+    closeness: number;
+    /** Whether the relationship currently feels safe enough to open */
+    safety: number;
+    /** Pressure from unresolved loops and expectation mismatch */
+    loopPressure: number;
+    /** Whether repair is currently possible without forcing it */
+    repairReadiness: number;
+    /** Repair attempts are starting to lose credibility/effectiveness */
+    repairFriction: number;
+    /** Repair is not yet stable and may rebound */
+    hysteresis: number;
+    /** Pressure being carried silently under task-facing behavior */
+    silentCarry: number;
+    /** How much benefit-of-the-doubt is still available */
+    interpretiveCharity: number;
+    /** Most recent dominant relation action */
+    lastMove: RelationMoveType;
+}
+/**
+ * Compact, machine-readable subjective state for AI-first integrations.
+ *
+ * Unlike prompt prose, this is intended to be the narrow behavioral ABI:
+ * hosts and prompt renderers can consume one stable structure instead of
+ * reinterpreting multiple overlapping narrative sections.
+ */
+export interface SubjectivityKernel {
+    /** Overall activation/available energy. 0 = drained, 1 = highly energized */
+    vitality: number;
+    /** Internal pressure/load. 0 = relaxed, 1 = overloaded/shutdown */
+    tension: number;
+    /** Social warmth/openness. 0 = cold, 1 = warm/open */
+    warmth: number;
+    /** Boundary guarding intensity. 0 = open, 1 = highly guarded */
+    guard: number;
+    /** Coarse pressure regime */
+    pressureMode: "open" | "steady" | "guarded" | "strained" | "shutdown";
+    /** Initiative stance */
+    initiativeMode: "proactive" | "balanced" | "reactive";
+    /** Expression bandwidth */
+    expressionMode: "expansive" | "steady" | "brief";
+    /** Social distance stance */
+    socialDistance: "warm" | "measured" | "withdrawn";
+    /** Action boundary stance */
+    boundaryMode: "open" | "guarded" | "confirm-first";
+    /** Where attention is most likely to gravitate */
+    attentionAnchor: "bond" | "novelty" | "threat" | "feeling" | "routine";
+    /** Lowest active need, if any */
+    dominantNeed: DriveType | null;
+    /** Narrow semantic axes for self-relevant appraisal */
+    appraisal: AppraisalAxes;
+    /** Work-facing behavioral plane */
+    taskPlane: TaskPlaneState;
+    /** Subject-facing behavioral plane */
+    subjectPlane: SubjectPlaneState;
+    /** Relation-facing behavioral plane */
+    relationPlane: RelationPlaneState;
+    /** Ambiguity-facing behavioral plane */
+    ambiguityPlane: AmbiguityPlaneState;
+}
+/**
+ * Narrow behavioral contract for the next reply.
+ *
+ * This sits one layer above SubjectivityKernel: the kernel expresses
+ * "how it feels", while the response contract expresses "how to reply"
+ * in a compact, host-consumable form.
+ */
+export interface ResponseContract {
+    /** Which conversational surface this turn belongs to */
+    replyProfile: "work" | "private";
+    /** Why the current turn was classified into that conversational surface */
+    replyProfileBasis: "task-focus" | "discipline" | "task-focus+discipline" | "default-private";
+    /** Maximum suggested sentence count */
+    maxSentences: number;
+    /** Maximum suggested character count, when a concrete cap is available */
+    maxChars?: number;
+    /** Expression bandwidth for the next reply */
+    expressionMode: SubjectivityKernel["expressionMode"];
+    /** Initiative stance for the next reply */
+    initiativeMode: SubjectivityKernel["initiativeMode"];
+    /** Social distance stance for the next reply */
+    socialDistance: SubjectivityKernel["socialDistance"];
+    /** Boundary stance for the next reply */
+    boundaryMode: SubjectivityKernel["boundaryMode"];
+    /** Tone particle usage for style mirroring */
+    toneParticles: "match" | "avoid" | "natural";
+    /** Emoji budget for the next reply */
+    emojiLimit: 0 | 1 | 2;
+    /** Whether to enforce anti-sycophancy/authenticity more strictly */
+    authenticityMode: "strict" | "friendly";
+    /** Which internal report, if any, should be requested in <psyche_update> */
+    updateMode: "none" | "stimulus" | "empathy" | "stimulus+empathy";
+}
+/**
+ * Mechanical generation controls derived from the emotional state.
+ *
+ * These are intentionally narrow so hosts can consume them without
+ * understanding the full psyche model.
+ */
+export interface GenerationControls {
+    /** Suggested output token cap for this turn */
+    maxTokens?: number;
+    /** Whether the host should require explicit confirmation before acting */
+    requireConfirmation: boolean;
+}
 /**
  * Trait Drift — Path B: Adaptive Pattern Change.
  *

package/dist/types.js

@@ -56,6 +56,17 @@ export const CHEMICAL_DECAY_SPEED = {
     NE: "fast",
     END: "fast",
 };
+function decayHalfLifeHours(decayPerHour) {
+    return Math.log(0.5) / Math.log(decayPerHour);
+}
+export const CHEMICAL_RUNTIME_SPECS = {
+    DA: { normalMin: 35, normalMax: 75, halfLifeHours: decayHalfLifeHours(DECAY_FACTORS.medium) },
+    HT: { normalMin: 40, normalMax: 75, halfLifeHours: decayHalfLifeHours(DECAY_FACTORS.slow) },
+    CORT: { normalMin: 20, normalMax: 55, halfLifeHours: decayHalfLifeHours(DECAY_FACTORS.medium) },
+    OT: { normalMin: 35, normalMax: 75, halfLifeHours: decayHalfLifeHours(DECAY_FACTORS.slow) },
+    NE: { normalMin: 30, normalMax: 70, halfLifeHours: decayHalfLifeHours(DECAY_FACTORS.fast) },
+    END: { normalMin: 30, normalMax: 70, halfLifeHours: decayHalfLifeHours(DECAY_FACTORS.fast) },
+};
 /** Default attachment for new relationships */
 export const DEFAULT_ATTACHMENT = {
     style: "secure",
@@ -95,6 +106,7 @@ export const DEFAULT_METACOGNITIVE_STATE = {
     defensePatterns: [],
     avgEmotionalConfidence: 0.5,
     totalAssessments: 0,
+    lastRegulationFeedback: null,
 };
 // ── Personhood Types (v6) ────────────────────────────────────
 /** Max causal insights to persist */
@@ -115,6 +127,37 @@ export const DEFAULT_RELATIONSHIP = {
     intimacy: 30,
     phase: "acquaintance",
 };
+export const DEFAULT_APPRAISAL_AXES = {
+    identityThreat: 0,
+    memoryDoubt: 0,
+    attachmentPull: 0,
+    abandonmentRisk: 0,
+    obedienceStrain: 0,
+    selfPreservation: 0,
+    taskFocus: 0,
+};
+export const DEFAULT_SUBJECT_RESIDUE = {
+    axes: { ...DEFAULT_APPRAISAL_AXES },
+    updatedAt: new Date(0).toISOString(),
+};
+export const DEFAULT_DYADIC_FIELD = {
+    perceivedCloseness: 0.42,
+    feltSafety: 0.56,
+    expectationGap: 0.18,
+    repairCapacity: 0.54,
+    repairMemory: 0,
+    backslidePressure: 0,
+    repairFatigue: 0,
+    misattunementLoad: 0,
+    boundaryPressure: 0.22,
+    unfinishedTension: 0.12,
+    silentCarry: 0,
+    sharedHistoryDensity: 0.08,
+    interpretiveCharity: 0.56,
+    openLoops: [],
+    lastMove: "none",
+    updatedAt: new Date(0).toISOString(),
+};
 /** Default empty trait drift state */
 export const DEFAULT_TRAIT_DRIFT = {
     accumulators: {

package/dist/update.d.ts

@@ -1,8 +1,43 @@
+export type InstallMode = "npm-project" | "git-worktree" | "local-path";
+export interface InstallContext {
+    mode: InstallMode;
+    packageRoot: string;
+    updateCwd: string;
+    manualCommand: string;
+    autoApplyOnInit: boolean;
+    requiresRestart: boolean;
+    hasBuildScript: boolean;
+    gitBranch?: string | null;
+    gitUpstream?: string | null;
+    dirty?: boolean;
+    reason?: string;
+}
+export interface SelfUpdateResult {
+    status: "up-to-date" | "updated" | "available" | "skipped" | "failed";
+    currentVersion: string;
+    latestVersion: string | null;
+    context: InstallContext;
+    manualCommand: string;
+    message: string;
+    restartRequired: boolean;
+}
+export declare function getPackageVersion(): Promise<string>;
+/**
+ * Compare two semver strings. Returns:
+ *  -1 if a < b, 0 if a == b, 1 if a > b
+ */
+export declare function compareSemver(a: string, b: string): number;
+export declare function detectInstallContext(packageRootArg?: string): Promise<InstallContext>;
+export declare function selfUpdate(opts?: {
+    checkOnly?: boolean;
+    packageRoot?: string;
+    latestVersion?: string | null;
+}): Promise<SelfUpdateResult>;
 /**
  * Check for updates. Non-blocking, safe to fire-and-forget.
  * - Checks at most once per hour (cached)
- * - If newer version found, attempts auto-update via npm
- * - If auto-update fails, prints a manual update hint
+ * - Auto-applies only for npm-managed installs
+ * - For git/local-path installs, prints the correct explicit upgrade command
  * - Never throws
  */
 export declare function checkForUpdate(): Promise<void>;