@neurolift-technologies/sleepwalker-protocol 1.0.0 → 1.0.2

package/README.md

@@ -1,3 +1,11 @@
+> ## ⚠️ PROTOTYPE — NOT A SAFETY SYSTEM
+>
+> This is an **experimental** crisis-detection library with **stubbed/placeholder intervention layers**. It is **NOT medical advice, NOT a crisis service**, and performs **no real-time monitoring**. It **can miss real crisis signals** (known detection/recall gaps) — **do not rely on it as a safety net or as the sole safety mechanism**.
+>
+> **If you or someone else needs help now:** in the US, call or text **988** (Suicide & Crisis Lifeline) or chat [988lifeline.org](https://988lifeline.org); in an emergency call **911**. Outside the US: [findahelpline.com](https://findahelpline.com).
+>
+> Provided **AS-IS, without warranty**.
+
 # Sleepwalker Protocol (SWP)
 
 ```yaml

package/dist/continuity.d.ts

@@ -1,9 +1,29 @@
 /**
  * Temporal Continuity Management Module
+ *
+ * Maintains emotional state and boundary awareness across sessions.
  */
 export declare class ContinuityManager {
     private storagePath;
     constructor(storagePath?: string);
+    /**
+     * Resolve the storage file for a user — traversal-safe and collision-safe.
+     *
+     * `userId` becomes part of a filename, which raises two risks:
+     *
+     * - **Path traversal.** A raw value like `"../../etc/passwd"` must not read or
+     *   write outside `storagePath`.
+     * - **Collisions.** Simply stripping disallowed characters would map distinct
+     *   ids onto the same file (`"a/b"` and `"ab"`, or `"alice@example.com"` and
+     *   `"aliceexample.com"`), letting one user's continuity overwrite or leak
+     *   into another's.
+     *
+     * We therefore key the file on a SHA-256 of the *full* id — deterministic,
+     * collision-resistant, and filesystem-safe (hex only) — prefixed with a
+     * sanitized, human-readable slug purely for debuggability. Mirrors the Python
+     * `ContinuityManager._user_file`.
+     */
+    private userFile;
     saveSession(userId: string, sessionData: any): void;
     getContext(userId: string): any;
     private loadUserData;

package/dist/continuity.js

@@ -1,6 +1,8 @@
 "use strict";
 /**
  * Temporal Continuity Management Module
+ *
+ * Maintains emotional state and boundary awareness across sessions.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -37,6 +39,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContinuityManager = void 0;
+const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 class ContinuityManager {
@@ -46,27 +49,58 @@ class ContinuityManager {
             fs.mkdirSync(this.storagePath, { recursive: true });
         }
     }
+    /**
+     * Resolve the storage file for a user — traversal-safe and collision-safe.
+     *
+     * `userId` becomes part of a filename, which raises two risks:
+     *
+     * - **Path traversal.** A raw value like `"../../etc/passwd"` must not read or
+     *   write outside `storagePath`.
+     * - **Collisions.** Simply stripping disallowed characters would map distinct
+     *   ids onto the same file (`"a/b"` and `"ab"`, or `"alice@example.com"` and
+     *   `"aliceexample.com"`), letting one user's continuity overwrite or leak
+     *   into another's.
+     *
+     * We therefore key the file on a SHA-256 of the *full* id — deterministic,
+     * collision-resistant, and filesystem-safe (hex only) — prefixed with a
+     * sanitized, human-readable slug purely for debuggability. Mirrors the Python
+     * `ContinuityManager._user_file`.
+     */
+    userFile(userId) {
+        const raw = String(userId);
+        const slug = (raw.match(/[A-Za-z0-9_-]/g) || []).join('').slice(0, 32) || 'user';
+        // Full SHA-256 hex (the filename is the user-isolation boundary; the extra
+        // length is free and maximizes separation between users).
+        const digest = crypto.createHash('sha256').update(raw, 'utf-8').digest('hex');
+        return path.join(this.storagePath, `${slug}-${digest}.json`);
+    }
     saveSession(userId, sessionData) {
-        const userFile = path.join(this.storagePath, `${userId}.json`);
+        const userFile = this.userFile(userId);
         const existingData = this.loadUserData(userId);
         sessionData.timestamp = new Date().toISOString();
         existingData.lastSession = sessionData;
         existingData.sessionCount = (existingData.sessionCount || 0) + 1;
+        // Preserve declared boundaries across sessions.
+        if (sessionData.declaredBoundaries !== undefined) {
+            existingData.declaredBoundaries = sessionData.declaredBoundaries;
+        }
         fs.writeFileSync(userFile, JSON.stringify(existingData, null, 2));
     }
     getContext(userId) {
         const userData = this.loadUserData(userId);
         if (Object.keys(userData).length === 0) {
-            return { hasHistory: false, protectiveStateActive: false };
+            return { hasHistory: false, protectiveStateActive: false, declaredBoundaries: [] };
         }
         return {
             hasHistory: true,
             lastSessionState: userData.lastSession?.emotionalState || 'unknown',
             protectiveStateActive: userData.lastSession?.protectiveStateActive || false,
+            declaredBoundaries: userData.declaredBoundaries || [],
+            sessionCount: userData.sessionCount || 0,
         };
     }
     loadUserData(userId) {
-        const userFile = path.join(this.storagePath, `${userId}.json`);
+        const userFile = this.userFile(userId);
         if (!fs.existsSync(userFile))
             return {};
         try {

package/dist/protocol.d.ts

@@ -7,16 +7,31 @@ export interface SWPOptions {
     privacyMode?: string;
     loggingEnabled?: boolean;
     storagePath?: string;
+    /**
+     * Stable identifier for the user this instance serves. Used as the continuity
+     * key when `assessInteraction` is called without an explicit `userId`. Falls
+     * back to a `userId` declared in the TOI, or to `'default_user'` so a single
+     * instance still maintains continuity across calls.
+     */
+    userId?: string;
 }
 export declare class SleepwalkerProtocol {
     private userToi;
+    private userId;
     private stateDetector;
     private consentManager;
     private continuityManager;
     private loggingEnabled;
     constructor(options?: SWPOptions);
     detectEmotionalState(userInput: string, sessionHistory?: any[]): EmotionalState;
-    assessInteraction(userInput: string, sessionHistory?: any[]): any;
+    assessInteraction(userInput: string, sessionHistory?: any[], userId?: string): any;
+    /**
+     * Preserves emotional boundaries across sessions. Mirrors Python
+     * `maintain_continuity`: the read (`assessInteraction`) and the write
+     * (`maintainContinuity`) stay separate so that assessment never implicitly
+     * writes to disk.
+     */
+    maintainContinuity(userId: string, sessionData: any): void;
     generateResponse(userInput: string, detectedState?: EmotionalState): any;
     requiresRrtaHandoff(userState: EmotionalState): boolean;
 }

package/dist/protocol.js

@@ -12,7 +12,17 @@ class SleepwalkerProtocol {
     constructor(options = {}) {
         this.loggingEnabled = options.loggingEnabled !== false;
         const toiLoader = new toiLoader_1.TOILoader(options.userToiPath);
-        this.userToi = options.userToiPath ? toiLoader.load() : {};
+        const loadedToi = options.userToiPath ? toiLoader.load() : {};
+        // A malformed TOI can parse to a non-object; coerce so downstream `.swp`
+        // lookups are always safe.
+        this.userToi = loadedToi && typeof loadedToi === 'object' ? loadedToi : {};
+        // Stable continuity identity for this instance. Never derive this from the
+        // user's input text — doing so makes every interaction look like a brand new
+        // user and continuity can never be retrieved. Accept an explicit id, then a
+        // top-level or swp-nested TOI id. The id is hashed where it becomes a
+        // filename (see ContinuityManager.userFile), so traversal is contained.
+        const swpToi = this.userToi.swp && typeof this.userToi.swp === 'object' ? this.userToi.swp : {};
+        this.userId = options.userId || this.userToi.user_id || swpToi.user_id || 'default_user';
         this.stateDetector = new stateDetection_1.StateDetector();
         this.consentManager = new consent_1.ConsentManager(this.userToi);
         this.continuityManager = new continuity_1.ContinuityManager(options.storagePath || '.swp_storage');
@@ -26,25 +36,38 @@ class SleepwalkerProtocol {
         }
         return state;
     }
-    assessInteraction(userInput, sessionHistory = []) {
+    assessInteraction(userInput, sessionHistory = [], userId) {
         const emotionalState = this.detectEmotionalState(userInput, sessionHistory);
         const consentLevel = this.consentManager.determineLevel(emotionalState);
+        // Get continuity context, keyed by the stable user identifier. Passing
+        // `userInput` here (the previous behavior on the Python side) keyed
+        // continuity on the message text, so it always reported "no history".
+        const continuityContext = this.continuityManager.getContext(userId || this.userId);
         return {
             emotionalState,
             consentLevel,
+            continuityContext,
             swpActive: this.userToi.swp?.active !== false,
             protectiveStateActive: emotionalState.protective,
         };
     }
+    /**
+     * Preserves emotional boundaries across sessions. Mirrors Python
+     * `maintain_continuity`: the read (`assessInteraction`) and the write
+     * (`maintainContinuity`) stay separate so that assessment never implicitly
+     * writes to disk.
+     */
+    maintainContinuity(userId, sessionData) {
+        this.continuityManager.saveSession(userId, sessionData);
+    }
     generateResponse(userInput, detectedState) {
         const state = detectedState || this.detectEmotionalState(userInput);
-        if ((this.userToi.swp?.active !== false) && state.protective) {
-            return {
-                responseType: 'stable_low_demand',
-                guidance: 'Maintain stable, task-focused interaction',
-                intervention: 'none',
-            };
-        }
+        // Crisis / check-in states are handled BEFORE the protective low-demand
+        // branch. An input can be both protective (e.g. "numb" -> dissociation) and a
+        // crisis ("kill myself" -> suicidal ideation); the crisis path must win so a
+        // safety check / RRTA handoff is never masked by a stable-low-demand response.
+        // This matches ConsentManager.determineLevel, which already ranks crisis
+        // (RRTA_HANDOFF) and check-in (SAFETY_CHECK) above protective.
         if (state.requiresCheckIn) {
             const level = this.consentManager.determineLevel(state);
             return {
@@ -54,6 +77,13 @@ class SleepwalkerProtocol {
                 intervention: 'consent_required',
             };
         }
+        if ((this.userToi.swp?.active !== false) && state.protective) {
+            return {
+                responseType: 'stable_low_demand',
+                guidance: 'Maintain stable, task-focused interaction',
+                intervention: 'none',
+            };
+        }
         return {
             responseType: 'neutral',
             guidance: 'Provide task-focused support',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@neurolift-technologies/sleepwalker-protocol",
-  "version": "1.0.0",
-  "description": "Emotional Continuity Governance for AI Systems",
+  "version": "1.0.2",
+  "description": "⚠️ PROTOTYPE / not medical advice — Emotional Continuity Governance for AI Systems",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "publishConfig": {
@@ -22,13 +22,16 @@
     "mental-health",
     "neurodivergent",
     "ai-ethics",
-    "trauma-informed"
+    "trauma-informed",
+    "prototype",
+    "experimental",
+    "not-medical-advice"
   ],
   "author": "NeuroLift Technologies / HAIEF <haief@neuroliftsolutions.com>",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/NeuroLift-Technologies/sleepwalker.git"
+    "url": "git+https://github.com/NeuroLift-Technologies/sleepwalker.git"
   },
   "bugs": {
     "url": "https://github.com/NeuroLift-Technologies/sleepwalker/issues"