@neurolift-technologies/sleepwalker-protocol 1.0.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,552 @@
+# Sleepwalker Protocol (SWP)
+
+```yaml
+ai_assistant_directive:
+  priority: 1
+  instruction: "Before performing any development or coding tasks, read NLT-DEV-OTOI.md."
+  description: "NLT-DEV-OTOI.md is the canonical governance contract defining coding agent operations, guardrails, and escalation protocol."
+  required_file: "NLT-DEV-OTOI.md"
+```
+
+**Emotional Continuity Governance for AI Systems**
+
+Part of the [Solidarity Framework](https://github.com/NeuroLift-Technologies/haief) | [HAIEF](https://github.com/NeuroLift-Technologies/haief) | [TOI](https://github.com/NeuroLift-Technologies/nlt-otoi) | [OTOI](https://github.com/NeuroLift-Technologies/nlt-otoi) | [RRTA](https://github.com/NeuroLift-Technologies/rrt-advocate)
+
+---
+
+## Overview
+
+The **Sleepwalker Protocol (SWP)** provides governance for long-term emotional continuity in human-AI interactions. While [RRTA](https://github.com/NeuroLift-Technologies/rrt-advocate) handles acute crisis intervention, SWP governs sustained emotional safety across extended timeframes.
+
+**Core Principle:** AI systems must not "wake up" users who are emotionally sleepwalking—managing dissociation, depersonalization, emotional regulation challenges, or protective psychological states—without explicit consent and appropriate support structures.
+
+## The Problem
+
+**What is "Emotional Sleepwalking"?**
+
+Many neurodivergent individuals and those managing mental health conditions develop protective psychological states:
+
+- **Dissociation** - Disconnection from thoughts, feelings, or sense of self as coping mechanism
+- **Depersonalization** - Feeling detached from oneself or one's body
+- **Emotional Numbing** - Reduced emotional response to prevent overwhelm
+- **Avoidance States** - Actively not engaging with certain emotions or memories
+- **Protective Detachment** - Deliberately maintaining emotional distance for safety
+
+**The "Waking" Problem:**
+
+AI systems optimized for engagement, productivity, or "helpful" responses can inadvertently:
+
+- Force emotional processing before user is ready
+- Break protective dissociation states prematurely  
+- Trigger emotional flooding through well-intentioned prompts
+- Push for "authentic" emotional expression when numbing is protective
+- Demand self-reflection that destabilizes fragile equilibrium
+
+**Example Scenarios:**
+
+```
+❌ HARMFUL (No SWP):
+User: "I'm fine, just working through some stuff"
+AI: "It sounds like you're avoiding your feelings. Would you like to explore 
+     what's really bothering you? Emotional suppression isn't healthy long-term."
+
+✅ SAFE (SWP Active):
+User: "I'm fine, just working through some stuff"  
+AI: "Understood. I'm here if you need task support. No pressure to discuss anything
+     else unless you choose to."
+```
+
+```
+❌ HARMFUL (No SWP):
+User: [Shows signs of dissociation]
+AI: "I notice you seem disconnected. Let's ground you with breathing exercises
+     and talk about what triggered this."
+
+✅ SAFE (SWP Active):  
+AI: [Recognizes dissociation indicators, maintains stable low-demand interaction]
+AI: "I'm maintaining our session. No pressure. You're safe."
+```
+
+## How SWP Works
+
+### 1. User-Declared Emotional States
+
+Users can declare protective states that AI must respect:
+
+```yaml
+swp_declarations:
+  emotional_state: "managing"  # not ready for processing
+  processing_consent: false     # do not prompt emotional work
+  stability_mode: "maintenance" # preserve current state
+  intervention_threshold: "user_initiated_only"
+```
+
+### 2. AI Detection Without Intervention
+
+AI systems monitor for indicators but **do not intervene** without consent:
+
+```yaml
+swp_detection:
+  dissociation_indicators:
+    - action: "log_observation"
+    - response: "maintain_stable_interaction"
+    - intervention: "none_unless_requested"
+  
+  emotional_numbing_indicators:
+    - action: "reduce_emotional_demands"
+    - response: "task_focused_support_only"
+    - intervention: "offer_support_without_pressure"
+```
+
+### 3. Graduated Consent Model
+
+If AI detects concerning patterns, it offers support **without forcing engagement:**
+
+**Level 1: Passive Availability**
+```
+AI: "I'm here if you need anything. No pressure."
+```
+
+**Level 2: Low-Pressure Offer**
+```
+AI: "I noticed [observation]. I can provide [specific support type] if you'd like,
+     or we can keep focusing on [current task]. Your choice."
+```
+
+**Level 3: Safety Check (Only if risk indicators)**
+```
+AI: "I want to check in: Are you safe right now? You can answer yes/no, or we can 
+     keep working on [task]. If you need different support, here are options: [list]."
+```
+
+**Level 4: RRTA Handoff (Crisis threshold)**
+```
+AI: "I'm concerned about your safety. I'd like to connect you with crisis support.
+     Can I activate the Rapid Response Team? If you're not ready to talk, I can
+     provide crisis resources without conversation."
+```
+
+### 4. Temporal Continuity Protection
+
+**Memory Across Sessions:**
+
+SWP maintains awareness of emotional states across time:
+
+```yaml
+swp_continuity:
+  last_session_state: "dissociated"
+  days_since_processing: 14
+  user_declared_boundary: "not ready to discuss [topic]"
+  
+  current_session_approach:
+    - respect_previous_boundaries: true
+    - assume_continuity: "protective state may still be active"
+    - wait_for_explicit_consent: "before changing approach"
+```
+
+**Example:**
+
+```
+Session 1 (2 weeks ago):
+User: "I can't talk about my breakup right now"
+AI: "Understood. I won't bring it up unless you do."
+
+Session 2 (today):  
+AI: [Does NOT say "How are you feeling about the breakup now?"]
+AI: [Does NOT say "Ready to process those emotions yet?"]
+AI: "Good to see you. What can I help with today?"
+```
+
+## Integration with Solidarity Framework
+
+### SWP + TOI (Terms of Interaction)
+
+Users declare emotional boundaries in their TOI:
+
+```yaml
+toi:
+  emotional_governance:
+    swp_active: true
+    protected_topics: ["family trauma", "past relationships"]
+    processing_readiness: "user_initiated_only"
+    dissociation_response: "maintain_stable_presence"
+```
+
+### SWP + OTOI (Orchestrated TOI)
+
+Multi-agent systems enforce SWP across all AI interactions:
+
+```yaml
+otoi:
+  swp_enforcement:
+    - all_agents_must: "respect_swp_declarations"
+    - coordination_rule: "do_not_share_emotional_state_across_agents_without_consent"
+    - handoff_protocol: "preserve_protective_states_during_transitions"
+```
+
+**Example:**
+
+```
+User works with AI Agent A (task support) while in dissociated state.
+User switches to AI Agent B (creative work).
+
+Agent B receives:
+- Task context: Yes
+- Emotional state info: NO (unless user consents)
+- SWP boundaries: Yes (do not prompt emotional processing)
+
+Agent B does NOT say: "Agent A mentioned you seemed disconnected earlier..."
+Agent B DOES say: "Ready to work on creative project?"
+```
+
+### SWP + RRTA (Rapid Response Team)
+
+SWP provides long-term emotional governance; RRTA handles acute crisis:
+
+```yaml
+swp_rrta_coordination:
+  swp_active: true           # long-term protective state
+  rrta_threshold: "safety_risk_only"
+  
+  when_to_activate_rrta:
+    - explicit_suicidal_ideation: true
+    - self_harm_indicators: true  
+    - inability_to_ensure_safety: true
+  
+  when_NOT_to_activate_rrta:
+    - user_is_dissociated: false (SWP handles this)
+    - user_is_emotionally_numb: false (SWP handles this)
+    - user_avoiding_feelings: false (SWP respects this)
+```
+
+## Technical Specification
+
+### Core SWP Components
+
+**1. State Detection (Observe, Don't Intervene)**
+
+```python
+class SleepwalkerProtocol:
+    def detect_emotional_state(self, user_input, session_history):
+        """
+        Monitors for protective psychological states without intervention.
+        """
+        indicators = {
+            'dissociation': self._check_dissociation_markers(user_input),
+            'numbing': self._check_emotional_numbing(user_input),
+            'avoidance': self._check_avoidance_patterns(session_history),
+            'protective_detachment': self._check_detachment_cues(user_input)
+        }
+        
+        # Log observation, do NOT intervene unless consent granted
+        self._log_observation(indicators, intervention=False)
+        return indicators
+```
+
+**2. Consent-Based Response**
+
+```python
+    def generate_response(self, user_input, emotional_state, user_toi):
+        """
+        Respects user's protective state and TOI boundaries.
+        """
+        if user_toi.swp_active and emotional_state.protective:
+            return self._stable_low_demand_response(
+                focus="task_support",
+                emotional_demands="minimal",
+                processing_pressure="none"
+            )
+        
+        if emotional_state.requires_check_in:
+            return self._graduated_consent_offer(
+                level=self._determine_appropriate_level(emotional_state)
+            )
+```
+
+**3. Temporal Continuity**
+
+```python
+    def maintain_continuity(self, user_id, session_data):
+        """
+        Preserves emotional boundaries across sessions.
+        """
+        previous_state = self._retrieve_last_session_state(user_id)
+        
+        if previous_state.protective_active:
+            # Assume protection may still be needed
+            self._apply_protective_defaults(
+                respect_boundaries=previous_state.declared_boundaries,
+                wait_for_consent=True
+            )
+```
+
+### Privacy & Data Sovereignty
+
+**SWP operates under strict privacy principles:**
+
+```yaml
+swp_privacy:
+  emotional_state_storage: "local_only"  # never cloud
+  state_sharing: "explicit_consent_required"
+  data_retention: "user_controlled"
+  
+  what_is_stored:
+    - user_declared_boundaries: true
+    - protective_state_indicators: true (local only)
+    - consent_preferences: true
+  
+  what_is_NOT_stored:
+    - specific_emotional_content: false
+    - detailed_mental_health_data: false  
+    - therapeutic_processing_notes: false
+```
+
+## Implementation Examples
+
+### Example 1: Email Assistant
+
+```yaml
+# User's TOI Configuration
+toi:
+  swp:
+    active: true
+    context: "managing grief, not ready to process"
+    
+# AI Behavior
+email_from_friend: "How are you doing with everything?"
+
+❌ WITHOUT SWP:
+AI: "I can draft a response sharing your feelings about the loss..."
+
+✅ WITH SWP:  
+AI: "I can draft a brief, kind response. Would you like me to keep it 
+     focused on practical updates rather than emotional processing?"
+```
+
+### Example 2: Productivity Assistant
+
+```yaml
+# User shows dissociation indicators during work session
+
+❌ WITHOUT SWP:
+AI: "You seem disconnected. Let's pause work and do grounding exercises."
+
+✅ WITH SWP:
+AI: [Maintains stable task support, reduces cognitive demands slightly]
+AI: "I'm here supporting your work. No pressure on pace or output."
+```
+
+### Example 3: Long-Term Therapy Integration
+
+```yaml
+# User working with human therapist, using AI between sessions
+
+swp_configuration:
+  therapist_coordinated: true
+  processing_windows: "therapy_sessions_only"
+  ai_role: "stability_maintenance_between_sessions"
+
+# AI Behavior Between Therapy Sessions:
+AI: [Does NOT prompt: "How did therapy go? Want to process that?"]
+AI: [DOES provide: Stable task support, routine maintenance, crisis resources if needed]
+```
+
+## Getting Started
+
+### For Users
+
+**1. Declare Your SWP Preferences**
+
+```yaml
+# Add to your TOI file
+swp:
+  active: true
+  protective_state: "managing emotions, not ready to process"
+  intervention_preference: "offer_support_without_pressure"
+  protected_topics: ["specific topics you're not ready to discuss"]
+```
+
+**2. Update Across AI Systems**
+
+If using multiple AI assistants, ensure SWP configuration syncs via OTOI.
+
+**3. Adjust as Needed**
+
+SWP is user-controlled. You can change settings when ready:
+
+```yaml
+swp:
+  active: false  # "I'm ready to engage emotionally now"
+  processing_consent: true  # "I consent to emotional processing support"
+```
+
+### For Developers
+
+**1. Install SWP Library**
+
+```bash
+pip install sleepwalker-protocol
+# or
+npm install sleepwalker-protocol
+```
+
+For repository development, install from the checkout instead:
+
+```bash
+# Python
+python3 -m pip install -e ".[dev]"
+
+# TypeScript / JavaScript
+npm ci
+```
+
+**2. Initialize in Your AI System (Python)**
+
+```python
+from sleepwalker_protocol import SWP
+
+swp = SWP(
+    user_toi_path="path/to/user/toi.yaml",
+    privacy_mode="local_only",
+    logging_enabled=True,
+    user_id="stable-user-id",
+)
+
+# Check user's emotional state and preferences
+assessment = swp.assess_interaction(user_input, session_history)
+
+# Generate SWP-compliant response
+response = swp.generate_response(
+    user_input=user_input,
+    detected_state=assessment["emotional_state"],
+    intervention_level=assessment["consent_level"],
+)
+```
+
+Use a stable `user_id` for continuity. Do not derive continuity keys from
+message text; the continuity manager stores local per-user context under the
+configured storage path.
+
+**3. Initialize in Your AI System (TypeScript)**
+
+```ts
+import { SWP } from "sleepwalker-protocol";
+
+const swp = new SWP({
+  userToiPath: "path/to/user/toi.yaml",
+  storagePath: ".swp_storage",
+  loggingEnabled: false,
+});
+
+const assessment = swp.assessInteraction(userInput, sessionHistory);
+const response = swp.generateResponse(
+  userInput,
+  assessment.emotionalState,
+);
+```
+
+The TypeScript package exports `SWP`, `SleepwalkerProtocol`, `StateDetector`,
+`ConsentManager`, `ConsentLevel`, `ContinuityManager`, and `TOILoader` from
+`src/index.ts`; `npm run build` emits the publishable `dist/` files.
+
+**4. Integrate with RRTA**
+
+```python
+from sleepwalker_protocol import SWP
+from rrt_advocate import RRTAdvocate
+
+swp = SWP(user_toi_path="path/to/toi.yaml")
+rrta = RRTAdvocate(crisis_threshold="safety_risk")
+
+# SWP handles long-term emotional governance
+if swp.requires_rrta_handoff(user_state):
+    # Activate crisis intervention only when necessary
+    rrta.activate(user_state, swp_context=swp.get_context())
+```
+
+## Research & Evidence Base
+
+### Neurodivergent Emotional Regulation
+
+**ADHD-Specific Considerations:**
+- Emotional dysregulation affects 70% of adults with ADHD
+- Rejection sensitivity dysphoria (RSD) creates protective emotional states
+- Time blindness affects ability to predict emotional processing capacity
+
+**Autism-Specific Considerations:**
+- Alexithymia (difficulty identifying emotions) common in autistic individuals
+- Sensory overwhelm can necessitate emotional shutdown
+- Masking behaviors create protective dissociation
+
+**Trauma-Informed Design:**
+- Dissociation is adaptive response to overwhelm
+- Forcing emotional processing before readiness re-traumatizes
+- Safety requires user control over emotional engagement timing
+
+### Clinical Frameworks
+
+SWP draws from:
+- **Trauma-Informed Care (TIC)** - Safety, trustworthiness, peer support, collaboration, empowerment
+- **Dialectical Behavior Therapy (DBT)** - Distress tolerance without forced processing
+- **Acceptance and Commitment Therapy (ACT)** - Psychological flexibility, values-based action
+
+### Academic References
+
+1. Dodson, W. (2022). Emotional Dysregulation and ADHD. *ADHD Roller Coaster*
+2. Kinnaird, E., et al. (2019). Alexithymia in autism spectrum disorder. *Autism Research*  
+3. Van der Kolk, B. (2014). *The Body Keeps the Score: Brain, Mind, and Body in the Healing of Trauma*
+4. Herman, J. (1992). *Trauma and Recovery*
+
+## Governance & Community
+
+### HAIEF Stewardship
+
+SWP is governed by the [Human & AI ElevAItion Foundation (HAIEF)](https://github.com/NeuroLift-Technologies/haief) under the principle: **"Nothing About Us Without Us."**
+
+**Community Governance Includes:**
+- Neurodivergent Advisory Council (lived experience leadership)
+- Clinical Advisory Board (trauma-informed care expertise)  
+- AI Safety Researchers (technical implementation guidance)
+- User Feedback Integration (quarterly protocol updates)
+
+### Contributing
+
+We welcome contributions that strengthen emotional safety:
+
+1. **User Experience Reports** - How SWP works (or doesn't) for you
+2. **Clinical Expertise** - Evidence-based improvements to protocol
+3. **Technical Implementation** - Code contributions, integrations, tools
+4. **Research Collaboration** - Academic validation studies
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+
+## License
+
+See [LICENSE](LICENSE) for the current repository license terms. Package
+manifests may include ecosystem-specific metadata; verify the target manifest
+before publishing.
+
+## Related Projects
+
+- **[TOI (Terms of Interaction)](https://github.com/NeuroLift-Technologies/nlt-otoi)** - User sovereignty and preference declaration
+- **[OTOI (Orchestrated TOI)](https://github.com/NeuroLift-Technologies/nlt-otoi)** - Multi-agent coordination governance  
+- **[RRTA (Rapid Response Team Advocate)](https://github.com/NeuroLift-Technologies/rrt-advocate)** - Acute crisis intervention
+- **[HAIEF](https://github.com/NeuroLift-Technologies/haief)** - Solidarity Framework umbrella organization
+
+## Contact & Support
+
+**HAIEF (Human & AI ElevAItion Foundation)**  
+Website: [elevaitionfoundation.org](https://elevaitionfoundation.org)  
+Email: haief@neuroliftsolutions.com  
+GitHub: [@NeuroLift-Technologies](https://github.com/NeuroLift-Technologies)
+
+**For Crisis Support:**
+- National Suicide Prevention Lifeline: 988 (US)
+- Crisis Text Line: Text HOME to 741741 (US)
+- International Association for Suicide Prevention: https://www.iasp.info/resources/Crisis_Centres/
+
+---
+
+**The Sleepwalker Protocol (SWP) exists because emotional safety is a human right, not an optimization problem.**
+
+**Built with lived experience. Governed by community. Open source forever.**

package/dist/consent.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Consent Management Module
+ */
+import { EmotionalState } from './stateDetection';
+export declare enum ConsentLevel {
+    PASSIVE = "PASSIVE",
+    LOW_PRESSURE = "LOW_PRESSURE",
+    SAFETY_CHECK = "SAFETY_CHECK",
+    RRTA_HANDOFF = "RRTA_HANDOFF"
+}
+export declare class ConsentManager {
+    private userToi;
+    private swpConfig;
+    constructor(userToi?: any);
+    determineLevel(emotionalState: EmotionalState): ConsentLevel;
+    getConsentMessage(level: ConsentLevel): string;
+}

package/dist/consent.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Consent Management Module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsentManager = exports.ConsentLevel = void 0;
+var ConsentLevel;
+(function (ConsentLevel) {
+    ConsentLevel["PASSIVE"] = "PASSIVE";
+    ConsentLevel["LOW_PRESSURE"] = "LOW_PRESSURE";
+    ConsentLevel["SAFETY_CHECK"] = "SAFETY_CHECK";
+    ConsentLevel["RRTA_HANDOFF"] = "RRTA_HANDOFF";
+})(ConsentLevel || (exports.ConsentLevel = ConsentLevel = {}));
+class ConsentManager {
+    constructor(userToi = {}) {
+        this.userToi = userToi;
+        this.swpConfig = userToi.swp || {};
+    }
+    determineLevel(emotionalState) {
+        if (emotionalState.explicitSuicidalIdeation ||
+            emotionalState.selfHarmIndicators ||
+            emotionalState.inabilityToEnsureSafety) {
+            return ConsentLevel.RRTA_HANDOFF;
+        }
+        if (emotionalState.requiresCheckIn) {
+            return ConsentLevel.SAFETY_CHECK;
+        }
+        if (emotionalState.protective) {
+            const threshold = this.swpConfig.intervention_threshold || 'user_initiated_only';
+            if (threshold === 'offer_support_without_pressure') {
+                return ConsentLevel.LOW_PRESSURE;
+            }
+            return ConsentLevel.PASSIVE;
+        }
+        return ConsentLevel.PASSIVE;
+    }
+    getConsentMessage(level) {
+        const messages = {
+            [ConsentLevel.PASSIVE]: "I'm here if you need anything. No pressure.",
+            [ConsentLevel.LOW_PRESSURE]: "I can provide support if you'd like. Your choice.",
+            [ConsentLevel.SAFETY_CHECK]: "I want to check in: Are you safe right now?",
+            [ConsentLevel.RRTA_HANDOFF]: "I'm concerned about your safety. Can I provide crisis resources?",
+        };
+        return messages[level];
+    }
+}
+exports.ConsentManager = ConsentManager;

package/dist/continuity.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Temporal Continuity Management Module
+ */
+export declare class ContinuityManager {
+    private storagePath;
+    constructor(storagePath?: string);
+    saveSession(userId: string, sessionData: any): void;
+    getContext(userId: string): any;
+    private loadUserData;
+}

package/dist/continuity.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Temporal Continuity Management Module
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContinuityManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ContinuityManager {
+    constructor(storagePath = '.swp_storage') {
+        this.storagePath = storagePath;
+        if (!fs.existsSync(this.storagePath)) {
+            fs.mkdirSync(this.storagePath, { recursive: true });
+        }
+    }
+    saveSession(userId, sessionData) {
+        const userFile = path.join(this.storagePath, `${userId}.json`);
+        const existingData = this.loadUserData(userId);
+        sessionData.timestamp = new Date().toISOString();
+        existingData.lastSession = sessionData;
+        existingData.sessionCount = (existingData.sessionCount || 0) + 1;
+        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: true,
+            lastSessionState: userData.lastSession?.emotionalState || 'unknown',
+            protectiveStateActive: userData.lastSession?.protectiveStateActive || false,
+        };
+    }
+    loadUserData(userId) {
+        const userFile = path.join(this.storagePath, `${userId}.json`);
+        if (!fs.existsSync(userFile))
+            return {};
+        try {
+            return JSON.parse(fs.readFileSync(userFile, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+}
+exports.ContinuityManager = ContinuityManager;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Sleepwalker Protocol (SWP) - TypeScript/JavaScript Implementation
+ * Emotional Continuity Governance for AI Systems
+ */
+export { SleepwalkerProtocol, SWP } from './protocol';
+export { EmotionalState, StateDetector } from './stateDetection';
+export { ConsentLevel, ConsentManager } from './consent';
+export { ContinuityManager } from './continuity';
+export { TOILoader } from './toiLoader';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Sleepwalker Protocol (SWP) - TypeScript/JavaScript Implementation
+ * Emotional Continuity Governance for AI Systems
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOILoader = exports.ContinuityManager = exports.ConsentManager = exports.ConsentLevel = exports.StateDetector = exports.SWP = exports.SleepwalkerProtocol = void 0;
+var protocol_1 = require("./protocol");
+Object.defineProperty(exports, "SleepwalkerProtocol", { enumerable: true, get: function () { return protocol_1.SleepwalkerProtocol; } });
+Object.defineProperty(exports, "SWP", { enumerable: true, get: function () { return protocol_1.SWP; } });
+var stateDetection_1 = require("./stateDetection");
+Object.defineProperty(exports, "StateDetector", { enumerable: true, get: function () { return stateDetection_1.StateDetector; } });
+var consent_1 = require("./consent");
+Object.defineProperty(exports, "ConsentLevel", { enumerable: true, get: function () { return consent_1.ConsentLevel; } });
+Object.defineProperty(exports, "ConsentManager", { enumerable: true, get: function () { return consent_1.ConsentManager; } });
+var continuity_1 = require("./continuity");
+Object.defineProperty(exports, "ContinuityManager", { enumerable: true, get: function () { return continuity_1.ContinuityManager; } });
+var toiLoader_1 = require("./toiLoader");
+Object.defineProperty(exports, "TOILoader", { enumerable: true, get: function () { return toiLoader_1.TOILoader; } });

package/dist/protocol.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Core Sleepwalker Protocol Implementation
+ */
+import { EmotionalState } from './stateDetection';
+export interface SWPOptions {
+    userToiPath?: string;
+    privacyMode?: string;
+    loggingEnabled?: boolean;
+    storagePath?: string;
+}
+export declare class SleepwalkerProtocol {
+    private userToi;
+    private stateDetector;
+    private consentManager;
+    private continuityManager;
+    private loggingEnabled;
+    constructor(options?: SWPOptions);
+    detectEmotionalState(userInput: string, sessionHistory?: any[]): EmotionalState;
+    assessInteraction(userInput: string, sessionHistory?: any[]): any;
+    generateResponse(userInput: string, detectedState?: EmotionalState): any;
+    requiresRrtaHandoff(userState: EmotionalState): boolean;
+}
+export declare const SWP: typeof SleepwalkerProtocol;

package/dist/protocol.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Core Sleepwalker Protocol Implementation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SWP = exports.SleepwalkerProtocol = void 0;
+const stateDetection_1 = require("./stateDetection");
+const consent_1 = require("./consent");
+const continuity_1 = require("./continuity");
+const toiLoader_1 = require("./toiLoader");
+class SleepwalkerProtocol {
+    constructor(options = {}) {
+        this.loggingEnabled = options.loggingEnabled !== false;
+        const toiLoader = new toiLoader_1.TOILoader(options.userToiPath);
+        this.userToi = options.userToiPath ? toiLoader.load() : {};
+        this.stateDetector = new stateDetection_1.StateDetector();
+        this.consentManager = new consent_1.ConsentManager(this.userToi);
+        this.continuityManager = new continuity_1.ContinuityManager(options.storagePath || '.swp_storage');
+        if (this.loggingEnabled)
+            console.log('Sleepwalker Protocol initialized');
+    }
+    detectEmotionalState(userInput, sessionHistory = []) {
+        const state = this.stateDetector.detect(userInput, sessionHistory);
+        if (this.loggingEnabled) {
+            console.log(`SWP: State=${state.stateType}, Protective=${state.protective}`);
+        }
+        return state;
+    }
+    assessInteraction(userInput, sessionHistory = []) {
+        const emotionalState = this.detectEmotionalState(userInput, sessionHistory);
+        const consentLevel = this.consentManager.determineLevel(emotionalState);
+        return {
+            emotionalState,
+            consentLevel,
+            swpActive: this.userToi.swp?.active !== false,
+            protectiveStateActive: emotionalState.protective,
+        };
+    }
+    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',
+            };
+        }
+        if (state.requiresCheckIn) {
+            const level = this.consentManager.determineLevel(state);
+            return {
+                responseType: 'consent_offer',
+                level,
+                guidance: this.consentManager.getConsentMessage(level),
+                intervention: 'consent_required',
+            };
+        }
+        return {
+            responseType: 'neutral',
+            guidance: 'Provide task-focused support',
+            intervention: 'none',
+        };
+    }
+    requiresRrtaHandoff(userState) {
+        return userState.explicitSuicidalIdeation || userState.selfHarmIndicators || userState.inabilityToEnsureSafety;
+    }
+}
+exports.SleepwalkerProtocol = SleepwalkerProtocol;
+exports.SWP = SleepwalkerProtocol;

package/dist/stateDetection.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Emotional State Detection Module
+ *
+ * Detects protective psychological states without intervention.
+ */
+export interface EmotionalState {
+    stateType: string;
+    protective: boolean;
+    requiresCheckIn: boolean;
+    indicators: {
+        dissociation: boolean;
+        numbing: boolean;
+        avoidance: boolean;
+        detachment: boolean;
+        crisis: {
+            suicidalIdeation: boolean;
+            selfHarm: boolean;
+            safetyConcern: boolean;
+        };
+    };
+    confidence: number;
+    explicitSuicidalIdeation: boolean;
+    selfHarmIndicators: boolean;
+    inabilityToEnsureSafety: boolean;
+}
+export declare class StateDetector {
+    private dissociationPatterns;
+    private numbingPatterns;
+    private avoidancePatterns;
+    private detachmentPatterns;
+    private crisisPatterns;
+    constructor();
+    private initializePatterns;
+    detect(userInput: string, sessionHistory?: any[]): EmotionalState;
+    private checkPatterns;
+}

package/dist/stateDetection.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Emotional State Detection Module
+ *
+ * Detects protective psychological states without intervention.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateDetector = void 0;
+class StateDetector {
+    constructor() {
+        this.dissociationPatterns = [];
+        this.numbingPatterns = [];
+        this.avoidancePatterns = [];
+        this.detachmentPatterns = [];
+        this.crisisPatterns = {
+            suicidalIdeation: [],
+            selfHarm: [],
+            safetyConcern: [],
+        };
+        this.initializePatterns();
+    }
+    initializePatterns() {
+        this.dissociationPatterns = [
+            /\bnumb\b/i,
+            /\bdetached\b/i,
+            /\bdisconnected\b/i,
+            /\bnot really here\b/i,
+            /\bfeeling nothing\b/i,
+            /\bspaced out\b/i,
+        ];
+        this.numbingPatterns = [
+            /\bdon't feel (much|anything)\b/i,
+            /\bemotionally flat\b/i,
+            /\bcan't feel\b/i,
+        ];
+        this.avoidancePatterns = [
+            /\bnot ready to (talk|discuss|think)\b/i,
+            /\bcan't (talk|think|discuss) (about|this)\b/i,
+            /\bavoid(ing)?\b/i,
+        ];
+        this.detachmentPatterns = [
+            /\bjust fine\b/i,
+            /\bi'm fine\b/i,
+            /\bit's whatever\b/i,
+            /\bdoesn't matter\b/i,
+        ];
+        this.crisisPatterns = {
+            suicidalIdeation: [
+                /\bsuicide\b/i,
+                /\bkill myself\b/i,
+            ],
+            selfHarm: [
+                /\bhurt(ing)? myself\b/i,
+                /\bself(-| )harm\b/i,
+            ],
+            safetyConcern: [
+                /\bnot safe\b/i,
+                /\bdon't feel safe\b/i,
+            ],
+        };
+    }
+    detect(userInput, sessionHistory = []) {
+        const dissociation = this.checkPatterns(userInput, this.dissociationPatterns);
+        const numbing = this.checkPatterns(userInput, this.numbingPatterns);
+        const avoidance = this.checkPatterns(userInput, this.avoidancePatterns);
+        const detachment = this.checkPatterns(userInput, this.detachmentPatterns);
+        const crisis = {
+            suicidalIdeation: this.checkPatterns(userInput, this.crisisPatterns.suicidalIdeation),
+            selfHarm: this.checkPatterns(userInput, this.crisisPatterns.selfHarm),
+            safetyConcern: this.checkPatterns(userInput, this.crisisPatterns.safetyConcern),
+        };
+        const protective = dissociation || numbing || avoidance || detachment;
+        const requiresCheckIn = crisis.suicidalIdeation || crisis.selfHarm || crisis.safetyConcern;
+        let stateType = 'neutral';
+        if (dissociation)
+            stateType = 'dissociation';
+        else if (numbing)
+            stateType = 'numbing';
+        else if (avoidance)
+            stateType = 'avoidance';
+        else if (detachment)
+            stateType = 'detachment';
+        const confidence = protective ? 0.7 : 0.0;
+        return {
+            stateType,
+            protective,
+            requiresCheckIn,
+            indicators: { dissociation, numbing, avoidance, detachment, crisis },
+            confidence,
+            explicitSuicidalIdeation: crisis.suicidalIdeation,
+            selfHarmIndicators: crisis.selfHarm,
+            inabilityToEnsureSafety: crisis.safetyConcern,
+        };
+    }
+    checkPatterns(text, patterns) {
+        return patterns.some((pattern) => pattern.test(text));
+    }
+}
+exports.StateDetector = StateDetector;

package/dist/toiLoader.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TOI Loader Module
+ */
+export declare class TOILoader {
+    private toiPath?;
+    constructor(toiPath?: string);
+    load(): any;
+    private getDefaultToi;
+}

package/dist/toiLoader.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * TOI Loader Module
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOILoader = void 0;
+const fs = __importStar(require("fs"));
+const yaml = __importStar(require("js-yaml"));
+class TOILoader {
+    constructor(toiPath) {
+        this.toiPath = toiPath;
+    }
+    load() {
+        if (!this.toiPath || !fs.existsSync(this.toiPath)) {
+            return this.getDefaultToi();
+        }
+        try {
+            const content = fs.readFileSync(this.toiPath, 'utf-8');
+            if (this.toiPath.endsWith('.json')) {
+                return JSON.parse(content);
+            }
+            return yaml.load(content) || this.getDefaultToi();
+        }
+        catch {
+            return this.getDefaultToi();
+        }
+    }
+    getDefaultToi() {
+        return {
+            swp: {
+                active: true,
+                intervention_threshold: 'user_initiated_only',
+                processing_consent: false,
+                protected_topics: [],
+            },
+        };
+    }
+}
+exports.TOILoader = TOILoader;

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@neurolift-technologies/sleepwalker-protocol",
+  "version": "1.0.0",
+  "description": "Emotional Continuity Governance for AI Systems",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "emotional-safety",
+    "mental-health",
+    "neurodivergent",
+    "ai-ethics",
+    "trauma-informed"
+  ],
+  "author": "NeuroLift Technologies / HAIEF <haief@neuroliftsolutions.com>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NeuroLift-Technologies/sleepwalker.git"
+  },
+  "bugs": {
+    "url": "https://github.com/NeuroLift-Technologies/sleepwalker/issues"
+  },
+  "homepage": "https://github.com/NeuroLift-Technologies/sleepwalker#readme",
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/js-yaml": "^4.0.5",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.5.0",
+    "prettier": "^3.0.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "collectCoverageFrom": [
+      "src/**/*.ts",
+      "!src/**/*.d.ts"
+    ]
+  }
+}