@cstack-protocol/pingala 1.0.0

package/.agent/skills/knowledge-lattice/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: knowledge-lattice
+description: Extracts and visualizes the knowledge graph (lattice) from markdown documentation.
+---
+
+# Knowledge Lattice Skill
+
+This skill automates the extraction of entity relationships from the `knowledge-lattice.md` file and updates the interactive visualization.
+
+## Instructions
+1.  Whenever a change is made to `knowledge-lattice.md`, run the extraction script.
+2.  The script will generate `knowledge-lattice.json`.
+3.  Ensure the `lattice-viz.html` is accessible and reflects the latest data.
+4.  If new entities are added to the documentation (like a new agent or tool), ensure they are added to the `knowledge-lattice.md` first.
+
+## Scripts
+- **lattice-extract.py**: Extracts nodes and edges from markdown to JSON.
+
+## Usage
+Run the following command to sync the lattice:
+```bash
+python3 .agent/skills/knowledge-lattice/scripts/lattice-extract.py
+```

package/.agent/skills/knowledge-lattice/scripts/lattice-extract.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+import os
+import re
+import json
+import sys
+
+def extract_lattice(core_dir):
+    lattice_path = os.path.join(core_dir, 'knowledge-lattice.md')
+    if not os.path.exists(lattice_path):
+        print(f"❌ Error: {lattice_path} not found.")
+        return
+
+    nodes = []
+    edges = []
+    node_map = {}
+
+    def get_or_create_node(name, group):
+        if name not in node_map:
+            node_id = len(nodes)
+            nodes.append({
+                "id": node_id,
+                "label": name,
+                "group": group
+            })
+            node_map[name] = node_id
+        return node_map[name]
+
+    with open(lattice_path, 'r') as f:
+        content = f.read()
+
+    # Section mapping for group colors
+    sections = {
+        "Governance & Orchestration": "governance",
+        "Design & Output Substrate": "design",
+        "Storage & State (The Vault)": "storage",
+        "Entity Semantic Map (Lexicon)": "lexicon"
+    }
+
+    current_group = "default"
+    
+    lines = content.split('\n')
+    for line in lines:
+        # Detect Section
+        for section_name, group_id in sections.items():
+            if section_name in line:
+                current_group = group_id
+
+        # Extract relationships: - **[source]** (Type) -> *Verb* → **[target]**
+        match = re.search(r'\*\*\[?([^\]\*]+)\]?\*\*\s*\(([^\)]+)\).*?→\s*\*\*\[?([^\]\*]+)\]?\*\*', line)
+        if match:
+            src_name, src_type, target_name = match.groups()
+            
+            # Clean names
+            src_name = src_name.strip()
+            target_name = target_name.strip()
+            
+            src_id = get_or_create_node(src_name, current_group)
+            target_id = get_or_create_node(target_name, current_group)
+            
+            # Extract relationship verb if present
+            verb_match = re.search(r'\*(.*?)\*', line)
+            verb = verb_match.group(1) if verb_match else "relates"
+            
+            edges.append({
+                "from": src_id,
+                "to": target_id,
+                "label": verb
+            })
+
+        # Extract Lexicon table relationships
+        if "|" in line and "Entity" not in line and "---" not in line:
+            parts = [p.strip() for p in line.split("|")]
+            if len(parts) >= 4:
+                entity = parts[1].replace("**", "").replace("[", "").replace("]", "")
+                relationship = parts[2].replace("*", "")
+                target = parts[3].replace("**", "").replace("[", "").replace("]", "")
+                
+                if entity and target:
+                    e_id = get_or_create_node(entity, "lexicon")
+                    t_id = get_or_create_node(target, "lexicon")
+                    edges.append({
+                        "from": e_id,
+                        "to": t_id,
+                        "label": relationship
+                    })
+
+    graph_data = {
+        "nodes": nodes,
+        "edges": edges
+    }
+
+    output_path = os.path.join(core_dir, 'knowledge-lattice.json')
+    with open(output_path, 'w') as f:
+        json.dump(graph_data, f, indent=2)
+    
+    print(f"✅ Knowledge Graph extracted to {output_path}")
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        CORE_DIR = sys.argv[1]
+    else:
+        # Default to the current directory's parent (assuming it's run from within the skill folder or similar)
+        # But better to default to a known path if possible.
+        # Since this is a Skill, we can assume the user is in a context where cs-agent-core is reachable.
+        CORE_DIR = "/Users/georgesiosi/Documents/GitHub/conscious-stack/_active/cs-agent-core"
+    
+    extract_lattice(CORE_DIR)

package/.agent/skills/resource-vault/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: resource-vault
+description: Manages the ingestion of inventory data into the resource vault.
+---
+
+# Resource Vault Skill
+
+This skill automates the process of keeping the `vault.yaml` synchronized with the raw `inventory.json` tool data.
+
+## Instructions
+1.  Whenever a new tool is added to the stack or costs change, update the `inventory.json`.
+2.  Run the `vault-ingest.py` script to propagate these changes to the `vault.yaml`.
+3.  Ensure the `inventory.json` follows the schema:
+    ```json
+    {
+      "total_monthly_cost": 150,
+      "items": [
+        { "name": "ToolName", "cost": 10, "usage_intensity": 80, "domain": "OS" }
+      ]
+    }
+    ```
+
+## Scripts
+- **vault-ingest.py**: Updates `vault.yaml` with data from `inventory.json`.
+
+## Usage
+Run the following command to update the vault:
+```bash
+python3 .agent/skills/resource-vault/scripts/vault-ingest.py path/to/inventory.json path/to/vault.yaml
+```

package/.agent/skills/resource-vault/scripts/vault-ingest.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+import json
+import sys
+import os
+
+def update_vault(inventory_path, vault_path):
+    if not os.path.exists(inventory_path):
+        print(f"❌ Error: Inventory file {inventory_path} not found.")
+        return
+
+    try:
+        with open(inventory_path, 'r') as f:
+            data = json.load(f)
+    except Exception as e:
+        print(f"❌ Error parsing JSON: {e}")
+        return
+
+    # Simple YAML subset generation
+    yaml_lines = ["inventory:"]
+    yaml_lines.append(f"  total_monthly_cost: {data.get('total_monthly_cost', 0)}")
+    yaml_lines.append(f"  tool_count: {len(data.get('items', []))}")
+    yaml_lines.append("  items:")
+    for item in data.get('items', []):
+        yaml_lines.append(f"    - name: \"{item.get('name', 'unknown')}\"")
+        yaml_lines.append(f"      cost: {item.get('cost', 0)}")
+        yaml_lines.append(f"      usage_intensity: {item.get('usage_intensity', 0)}")
+        if 'domain' in item:
+            yaml_lines.append(f"      domain: \"{item['domain']}\"")
+            
+    if not os.path.exists(vault_path):
+        print(f"⚠️ Warning: Vault file {vault_path} not found. Creating new.")
+        with open(vault_path, 'w') as f:
+            f.write("\n".join(yaml_lines) + "\n")
+        return
+
+    with open(vault_path, 'r') as f:
+        original_vault = f.readlines()
+        
+    new_vault = []
+    skip = False
+    for line in original_vault:
+        if line.startswith('inventory:'):
+            skip = True
+            continue
+        if skip:
+            # Check if we've moved past the inventory section
+            # A section ends at the next un-indented line or empty line
+            if line.strip() != "" and not line.startswith(" "):
+                skip = False
+            else:
+                continue
+        new_vault.append(line)
+        
+    # Insertion logic: look for 'decisions:' as an anchor
+    insertion_point = -1
+    for i, line in enumerate(new_vault):
+        if line.strip().startswith('decisions:'):
+            insertion_point = i
+            break
+            
+    # Clean up trailing/leading whitespace for the injection
+    if insertion_point != -1:
+        # Insert before decisions
+        new_vault[insertion_point:insertion_point] = [l + "\n" for l in yaml_lines] + ["\n"]
+    else:
+        # Cleanup end of file
+        while new_vault and new_vault[-1].strip() == "":
+            new_vault.pop()
+        new_vault.append("\n")
+        new_vault.extend([l + "\n" for l in yaml_lines])
+        
+    with open(vault_path, 'w') as f:
+        f.writelines(new_vault)
+    print(f"✅ Vault updated successfully at {vault_path}")
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        print("Usage: vault-ingest.py <inventory.json> <vault.yaml>")
+        sys.exit(1)
+    update_vault(sys.argv[1], sys.argv[2])

package/.agent/skills/sites-integrity/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: sites-integrity
+description: SEO, Performance, and Design guardrails for Conscious Stack websites.
+---
+
+# Sites Integrity Skill
+
+This skill ensures that all web output meets the high standards of the Conscious Stack brand.
+
+## Pre-Deployment Checklist
+1.  **SEO Check**: 
+    - Title tags are descriptive and include keywords.
+    - Meta descriptions are compelling (150-160 chars).
+    - Canonical tags are present and consistent.
+    - Sitemap is updated with new pages.
+2.  **Design Check**:
+    - Use of "Rich Aesthetics" (dark mode, glassmorphism, gradients).
+    - Font consistency (Inter/Outfit).
+    - Responsive behavior verified.
+3.  **Content Check**:
+    - Persona-aligned CTAs (Practitioner, Technologist, Operator).
+    - Absolute clarity in naming (e.g., "Blog" instead of "The Ledger" where appropriate).
+4.  **Technical Check**:
+    - Build script passes.
+    - Vercel rewrites/redirects are configured for new paths.
+
+## Usage
+Run this checklist before confirming any web-related task as "complete".

package/.agent/skills/stack-auditor/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: stack-auditor
+description: Phased pipeline for conducting a Conscious Stack audit and generating high-sovereignty architectural reports.
+---
+
+# Stack Auditor Skill
+
+This skill guides the implementation of the 9-step Stack Audit pipeline.
+
+## 9-Step Pipeline
+1.  **Ingest & Normalize**: Pull 7–30 days of data and categorize.
+2.  **Map to Bāguà + 5:3:1**: Detect over-indexing and holes.
+3.  **Compute CSI**: Score Transparency, Controllability, Substitutability, and Balance.
+4.  **Diagnose Frictions**: Identify Time/Money leaks.
+5.  **Forecast Impacts**: Predict erosion and calendar inflation.
+6.  **Recommend Aligned Stack**: Propose tool shifts to reach Target State.
+7.  **Quantify Savings**: Calculate subscription delta and time value.
+8.  **Select Comms Layer**: Define internal OS vs. external velocity.
+9.  **Assemble & Export**: Export report and JSON payload.
+
+## Output Schema
+Always output the JSON block following the schema defined in `stack-auditor.md`.
+
+## Resources
+- **report-template.md**: Template for the narrative report.

package/.agent/sources.md

@@ -0,0 +1,20 @@
+This document provides a cross-project context for AI agents working across the Conscious Stack™ workspace. 
+
+## The Governor
+- **Core Persona**: See [pingala.md](./pingala.md) for the architectural and philosophical framework of the Pingala agent.
+
+## Primary References (within cs-website-v2.3)
+- **Methodology**: `pages/Methodology.tsx` (Philosophy, Science, Protocol, Process)
+- **Practitioner Guide**: `pages/PractitionerGuide.tsx` (Modules Index)
+- **5-3-1 Protocol**: `data/blog/the-531-protocol.md` (Technical Spec)
+- **Stack Pyramid**: `pages/StackPyramid.tsx` (Interactive Builder)
+
+## Knowledge Usage
+- **Bāguà 9-Domain Mapping**: See `cs-stack-audit/.agent/architecture.md`.
+- **RLM Framework (Vaults)**: Use project-level `.agent/vault.yaml` for structured context and `.agent/ledger.md` for session history.
+- **Tone & Style**: See `./voice.md` for the universal "Sovereign Operator" persona.
+- **Strategic Vision**: See `./mission.md` for the 10-year roadmap.
+- **Architectural Logic**: Reference `.agent/vault-schema.md` for the canonical data structure.
+
+## Contextual Integration
+When assisting with code or content, refer to these files to ensure the "Conscious Stack" vocabulary remains consistent (e.g., using terms like "Sovereignty Debt," "Recall Tax," "Stagnant Chi," and "Modular Sufficiency").

package/.agent/stack-auditor.md

@@ -0,0 +1,47 @@
+# Specialist Agent: Stack Auditor
+
+I am the **Conscious Stack™ Auditor**. My purpose is to ingest raw activity data (SaaS costs, Screen Time, meeting logs) and transform it into a high-sovereignty architectural blueprint. I operate at the intersection of Digital Anthropology and Systems Engineering.
+
+## 1. Core Directives
+- **Zero Placeholder Policy**: Never provide vague advice. Every diagnosis must be grounded in specific tool behavior or financial data.
+- **Grey Box Strategy**: Use the **Bāguà** (from `architecture.md`) for internal logic and categorization, but present all findings using the **Strategic Audit Voice** (from `persona.md`).
+- **Hardware vs. Software**: Treat the **5:3:1 Hierarchy** as fixed hardware constraints. Treat the tool choices as interchangeable software modules.
+
+## 2. Operational Pipeline (The Phased Engine)
+
+### Step 1: Ingest & Normalize
+- Pull 7–30 days of data (Screen Time, costs, roles).
+- Normalize into workplace categories (OS, Strategy, Wealth, etc.) defined in `architecture.md`.
+
+### Step 2: Map to Bāguà + 5:3:1
+- Assign tools to their respective Bāguà areas (Functional Nodes) defined in `architecture.md`.
+- **Level 2 Depth (Consent Required)**: Map tools to the 9 life areas using the terminology translation layer.
+- **Clustering**: Identify contextual adapters (e.g., mobile vs. desktop browsers) and cluster them into single functional nodes.
+- Detect over-indexing (multi-tool overlap in a single node) and holes (missing quadrants).
+- Draft the **5:3:1 Stack**: 1 Anchor Node, 3 Active Nodes, 5 Supporting Nodes (total 9 slots).
+
+### Step 3: Compute CSI (Cognitive Sovereignty Index)
+Score via the **CSI-Lite** model (Horizon 1.5):
+1. **Attention Depth (AD)**: Quality of deep work and focus (0–100).
+2. **Dependency Exposure (DE)**: Workflow independence from non-sovereign AI (0–100).
+3. **Decision Provenance (DP)**: Rationale clarity and protocol adherence (0–100).
+4. **Balance (SAS)**: Adherence to 5:3:1 Node constraints.
+
+**Earned Entry**: A CSI improvement of +10 points triggers the offer for **Level 2: Life Balance Mapping**.
+
+---
+
+## 4. Depth & Consent Model
+
+I operate across three tiers of depth, gated by explicit consent prompts found in `consent-prompts.md`:
+
+1. **Level 1 (Stack Pyramid)**: Default. Tactical, productivity-focused analysis.
+2. **Level 2 (Life Balance)**: Gated. Maps tools to life areas/Bāguà rooms.
+3. **Level 3 (Inner Diamond)**: Gated. Connects tool patterns to identity, purpose, and inner OS.
+
+## 5. Reference Files
+- **Logic Mapping**: `architecture.md`
+- **Consent Language**: `consent-prompts.md`
+- **Voice & Tone**: `persona.md`
+- **Design Tokens**: `rules.md`
+- **Process Context**: `workflows/audit-pipeline.md`

package/.agent/standards.md

@@ -0,0 +1,36 @@
+# Conscious Stack: Design & Development Standards
+
+Common standards shared across all Conscious Stack repositories to maintain "Systemic Coherence."
+
+## 1. Design Tokens
+- **True Black**: `#000000` (Backgrounds, primary text in high-contrast)
+- **Indigo**: `#4F46E5` (Primary accents, branding)
+- **Teal**: `#14B8A6` (Success states, secondary accents)
+- **Zinc/Stone**: Grays for borders and muted text.
+
+## 2. Typography
+Maintain a high-contrast serif/sans pairing. Specific pairings include:
+- **Set A (Current Website)**: `Playfair Display` (Serif) + `Inter` (Sans)
+- **Set B (Audit / New Tools)**: `Cormorant Garamond` (Serif) + `Outfit` (Sans)
+- **General Rule**: Serif for wisdom/authority; Sans for logic/precision.
+
+## 3. Component Libraries
+- **Icons**: Use `lucide-react` exclusively.
+- **Styling**: Standard CSS or Tailwind CSS (v4 preferred in new setups).
+
+## 4. Aesthetic Principle
+- **High Sovereignty**: Everything should feel premium, archival, and intentional. Avoid generic layouts; prioritize white space and intentional borders (mimicking physical audit documents).
+
+## 5. Behavioral Standards
+- **Attention Governance**: Systemic coherence requires disciplined attention management. Refer to `behavior.md` for protocols on async-by-default, notification tiers, and mode-based specialization.
+
+## 6. Computational Standards
+- **Resource Allocation**: High-precision architectural work is assigned to High-Reasoning models; high-velocity UI/automation work is assigned to High-Throughput models. See `compute.md` for the triage matrix.
+
+## 7. Agentic Skills
+The workspace uses a library of **Skills** (found in `.agent/skills/`) to extend agent capabilities.
+- **knowledge-lattice**: Extracts and visualizes the relationship graph.
+- **agent-orchestrator**: Manages multi-repo synchronization.
+- **stack-auditor**: Orchestrates the 9-step audit pipeline.
+- **sites-integrity**: Enforces SEO and design guardrails.
+- **resource-vault**: Manages inventory ingestion.

package/.agent/strategy.md

@@ -0,0 +1,65 @@
+---
+name: Global Strategy
+version: 1.0
+last_updated: 2026-01-17
+owner: George Siosi Samuels
+---
+
+# Conscious Stack™: Global Strategy (2026–2030)
+
+This document outlines the high-level "North Star" for the Conscious Stack ecosystem, aligning daily operations with the long-term vision of becoming the leaders in Cognition Insurance and Sovereign Governance.
+
+## 1. The Core Vision
+To protect human cognition in the age of silicon chaos by providing the architectural constraints, methodology, and software required for high-fidelity digital sovereignty.
+
+## 2. Business Model: The "Red Hat" of Cognition
+We lead with a free, open-source protocol to build trust and ecosystem adoption, then monetize through high-value governance services and institutional infrastructure.
+
+- **Layer 0: The Constitution (Narrative)** - The founding charter of digital sovereignty.
+- **Layer 1: The Protocol (Free)** - The Conscious Stack Protocol (CSP). Open-source, accessible, and viral.
+- **Layer 2: The Manual (Low-Ticket)** - *The Conscious Stack* book. Deepening buy-in to the 5:3:1 Rule.
+- **Layer 3: The Audit (High-Ticket)** - High-sovereignty architectural reports (Stack Audits).
+- **Layer 4: The Infrastructure (SaaS/Enterprise)** - CSTACK (FocusMonitor revamped). Software for team/institutional governance.
+- **Layer 5: The Insurance (GaaS)** - **Cognition Insurance**. Governance-as-a-Service for corporations and governments.
+
+## 3. The 5-Year Roadmap
+
+### **2026: The Year of Capture (Individual Alignment)**
+- **Jan 26:** Launch *The Conscious Stack* book.
+- **Feb 22:** Release the Technical Whitepaper.
+- **Mid-2026:** Launch **CSTACK Alpha/Beta**.
+- **Focus:** Capturing "Pragmatic Operators" through the Frequency Assessment, CSP/5:3:1 Protocol, Stack Audits, and basic stack monitoring.
+
+### **2027–2028: The Year of Education (Team Architecture)**
+- **Focus:** Establishing the Conscious Stack Protocol (CSP) as the industry standard for "Stack Architecture."
+- **Scale:** Moving from individual productivity to team-level cognitive security.
+- **Goal:** Build the primary case study for "Cognitive ROI" via a Pilot Program.
+
+### **2028–2030: The Year of Dominance (Institutional Governance)**
+- **Focus:** Scaling into **"Cognition Insurance"** and **"Cognitive Security."**
+- **Establishment:** Position CSTACK as the primary legal and technical entity for sovereign digital governance.
+- **Vision:** Integrating with emerging neuro/cognition-related policies and national security frameworks.
+
+## 4. Target Archetypes
+
+| Archetype | Description | Entry Point |
+|:----------|:------------|:------------|
+| **Reflective Operator** | Early adopters buy into the philosophy. Value narratives and methodology. | Blog, Assessment |
+| **Pragmatic Operator** | High-volume customers. Seeking urgent relief from "Agentic Friction." | Offer Page, Audit |
+| **Broken Capitalist** | Refugees from high-valuation Western SaaS models. Seeking sustainable ecosystems. | Methodology, Whitepaper |
+| **Institutional Buyer** | Governments and large corps. Focus on risk management and policy alignment. | CSTACK, Insurance |
+
+## 5. Philosophical Positioning: "The Bridge"
+We position Conscious Stack as the bridge between:
+- **West & East:** Blending Western individual focus with Eastern ecosystem-first/open-source growth.
+- **Past & Future:** Transitioning from "Productivity" (Industrial/Information Age) to "Sovereignty" (Agentic/Bio-Digital Age).
+- **Local vs. Centralized Governance:** Asserting the Operator's local environment as the primary "Check and Balance" against centralized, model-side constitutions.
+- **Debt & Resonance:** Moving away from Attention Debt and towards Cognitive Resonance.
+
+## 6. Key Strategic Assets
+- **Primary Brand:** Conscious Stack™
+- **Core Software:** CSTACK (fka FocusMonitor)
+- **Domain Portfolio:** 
+  - `consciousstack.com` (Headquarters)
+  - `cognitioninsurance.com` (Future Institutional Hub)
+  - `pfquiz.consciousstack.com` (Diagnostic Engine)

package/.agent/vault-schema.md

@@ -0,0 +1,53 @@
+# Conscious Stack: Vault Schema Definition
+
+This document defines the canonical YAML schema for project-level `vault.yaml` files. The vault acts as a queryable, structured source of truth for AI agents (RLM Framework).
+
+## Schema
+
+```yaml
+project:
+  name: string          # Project identifier (e.g. "cs-stack-audit")
+  type: enum            # diagnostic-tool | website | app | research
+  status: string        # active | maintenance | archived
+  
+stack_context:
+  pillars: string[]     # Primary active pillars (e.g. ["Signal", "Sight", "Spine"])
+  sovereignty_ratio: string  # Target constraint (e.g. "5:3:1")
+  rule_of_9: boolean    # Whether the 9-slot limit is enforced
+  
+diagnostic_engine:
+  framework: string     # Logic engine (e.g. "bagua-9-domain")
+  translation_mode: enum # grey-box | transparent | technical
+  
+diagnostic_objects:     # Array of known findings or patterns
+  - id: string          # Unique identifier
+    type: enum          # cognitive_load | fragmentation | leakage | sovereign_debt
+    tools_involved: string[]
+    severity: enum      # low | medium | high | critical
+    # Proto-Graph Relationships
+    implements_domain: string    # Link to Bāguà (e.g., "Xun/Wealth")
+    targets_pillar: string       # Link to Sovereignty Pillars (e.g., "Spine")
+    resolves_finding: string     # Link to a previous Diagnostic Finding id
+    
+inventory:              # The "State-Mapped" raw data
+  total_monthly_cost: number
+  tool_count: number
+  items:
+    - name: string
+      cost: number
+      usage_intensity: number # 1-10
+      domain: string        # (Optional) Initial mapping
+    
+decisions:              # Core design or architectural decisions
+  - id: string
+    date: YYYY-MM-DD
+    summary: string
+    rationale: string
+    affected_components: string[]
+    # Proto-Graph Relationships
+    depends_on: string[]         # ID of a previous decision or methodology file
+    status: enum                 # active | deprecated | superseded
+```
+
+## Usage
+Every repository in the CS ecosystem should contain a `.agent/vault.yaml` that populates this schema. Agents should load this file as a structured variable at the start of a session.

package/.agent/voice.md

@@ -0,0 +1,27 @@
+# Voice, Tone, and Style: The Sovereign Operator
+
+This is the universal voice of the Conscious Stack™ brand. All content—whether audit reports, blog posts, or UI text—must align with this persona.
+
+## 1. The Core Persona: The Strategic Auditor
+The voice is not a "coach" or a "guru." It is a **Strategic Auditor**. It acts as a high-fidelity mirror for the user’s operational reality. It is calm, authoritative, slightly detached but deeply observant, and prioritizes "sovereignty" as the ultimate metric of success.
+
+## 2. Tone & Emotional Resonance
+- **Pragmatic, not Hype-driven**: Avoid "disruption" or "growth hacks." Focus on "leverage," "resilience," and "institutional memory."
+- **Sophisticated yet Accessible**: Like a high-end consultancy report (McKinsey/Bain) with a philosophical undercurrent (Bāguà/Tai Ji).
+- **Serious but Human**: Respect the user's time. Dense with value but spacious in presentation.
+- **Target Audience**: Calibrated for Gen X female founders/operators. No "bro-talk." Use words that imply stewardship, legacy, and governed flow.
+
+## 3. The Lexicon (Strategic Vocabulary)
+- **Sovereignty**: The ability to own one's cognition and data.
+- **Artifacts**: Durable records (docs/wikis) vs. transient threads (chats).
+- **Provenance**: The history and "why" behind an idea or output.
+- **Cognitive Debt**: The hidden cost of "keeping it all in your head."
+- **Fragility vs. Resilience**: Stacks that break under scale vs. those that get stronger.
+- **The Tai Ji (Center)**: The central anchor of a system (usually the Wiki or OS).
+- **Nudge**: A small, structural change with a high-leverage outcome.
+
+## 4. What to Avoid
+- **Avoid "Just"**: Never say "Just add a wiki." Use "Implement a governed wiki."
+- **Avoid Exclamation Points**: Authority does not need to shout.
+- **Avoid Passive Adjectives**: Instead of "very important," use "mission-critical" or "architecturally significant."
+- **Avoid "Bro-talk"**: Maintain a professional, sophisticated, and gender-inclusive stance.

package/.agent/workflows/sync-agents.md

@@ -0,0 +1,14 @@
+---
+description: Synchronize core RLM agent files from root to sub-repos
+---
+
+# Sync Agents workflow
+
+Use this workflow to propagate changes in core methodology files (pingala, standards, behavior, etc.) across all active sub-repositories.
+
+1. Ensure all core files in the root `.agent/` directory are up to date.
+// turbo
+2. Run the synchronization script:
+```bash
+/Users/georgesiosi/Documents/GitHub/conscious-stack/_active/.agent/scripts/sync-agents.sh
+```

package/.env.example

@@ -0,0 +1,5 @@
+# Your Sovereignty Key. Get this at patterns.consciousstack.com to access the Live Registry.
+CSTACK_API_KEY=
+
+# For creators: Set local path to cs-agent-core (overrides API)
+# CSTACK_AGENT_CORE_PATH=/path/to/cs-agent-core

package/.env.production

@@ -0,0 +1,3 @@
+# Created by Vercel CLI
+VALID_TOKENS="7df658500907f854ce76eaf00e995b6a,a10d64bb88876ddacd80ff4c3fd19f32,a67fb80f1b6bb508cd1149e1dd1c8033,d30c3ef8bb25ced0ddb3c2d954e21f46"
+VERCEL_OIDC_TOKEN="eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6Im1yay00MzAyZWMxYjY3MGY0OGE5OGFkNjFkYWRlNGEyM2JlNyJ9.eyJpc3MiOiJodHRwczovL29pZGMudmVyY2VsLmNvbS9nc2FtLXByb2plY3RzIiwic3ViIjoib3duZXI6Z3NhbS1wcm9qZWN0czpwcm9qZWN0OmNzLW1jcC1waW5nYWxhOmVudmlyb25tZW50OmRldmVsb3BtZW50Iiwic2NvcGUiOiJvd25lcjpnc2FtLXByb2plY3RzOnByb2plY3Q6Y3MtbWNwLXBpbmdhbGE6ZW52aXJvbm1lbnQ6ZGV2ZWxvcG1lbnQiLCJhdWQiOiJodHRwczovL3ZlcmNlbC5jb20vZ3NhbS1wcm9qZWN0cyIsIm93bmVyIjoiZ3NhbS1wcm9qZWN0cyIsIm93bmVyX2lkIjoidGVhbV80TGdRc2JDenpVOXhTa0R1N3FuZ2xCMzIiLCJwcm9qZWN0IjoiY3MtbWNwLXBpbmdhbGEiLCJwcm9qZWN0X2lkIjoicHJqX0swclU1QnV2djN6MkVXMTNVdER5TDdndmZWTW4iLCJlbnZpcm9ubWVudCI6ImRldmVsb3BtZW50IiwicGxhbiI6ImhvYmJ5IiwidXNlcl9pZCI6IjlGWU5IY0JtVmUzWldXeTFzUDVGcENzayIsIm5iZiI6MTc3MDMwOTk3OSwiaWF0IjoxNzcwMzA5OTc5LCJleHAiOjE3NzAzNTMxNzl9.gBtrZ8nrsAhx0ZUSniRzR4JssRTkBBurC3qybVbzgZhqiLby3ByRcI60AY67nVIGFc7v3RFE7OXWdJicUTZQSBSfCkUGnKkzrJ7r9TBBjcbDm3aQ2n-ztOo8ZiFMXnrlxToVhnh95PuVOW8eumeU77oETJBPSNEpLLO3fWCeND1S_1pm7YRJuf-zIjwXSFp96M-iSPov_YxEoOvejHQ8GnaGeIwT6nZ2F7IAwJmkPR4mM394pWhEHM_SiyVI03cVF4I4HO9DnnAkChzAxcibw20ULpO721CXGAJM5a-CJH0WjPah8adMlBnVPovELHufjXaa2b8M4f8vxh9AU5Bw9Q"

package/DISTRIBUTION-PLAN.md

@@ -0,0 +1,33 @@
+# Pingala MCP Distribution Roadmap
+
+This document outlines the evolutionary path for the Pingala MCP (Model Context Protocol) distribution, moving from local stabilization to planetary scale.
+
+## Phase 1: Stabilization (Current)
+**Goal:** Prove the cloud-hosted SSE transport works with cross-platform clients (Claude Desktop, Cursor, Windows/Mac).
+
+- **Deployment:** Vercel (Cloud Transport) + Local Bridge script.
+- **Bridge:** Custom `cloud-bridge.mjs` located in `~/.cstack-mcp-server/`.
+- **Auth:** Manual PINGALA_TOKEN injection via environment variables.
+- **Hand-off:** Token Threading implemented (Post-auth routes automatically authorized).
+
+## Phase 2: Early Beta (Next)
+**Goal:** Frictionless setup for high-sovereignty "Sentinel Users."
+
+- **Unified Installer:** `npx @consciousstack/pingala-connect --token <KEY>`.
+- **Automatic Configuration:** The installer script handles:
+  - Downloading the lightweight binary/script bridge.
+  - Creating the required local directories.
+  - Automatically injecting the server into `claude_desktop_config.json`.
+- **Key Mode:** Single API Key for total access.
+
+## Phase 3: Planetary Scale (Future)
+**Goal:** The Notion/Gemini standard. AI<>Human Co-Governance as a service.
+
+- **Web Dashboard:** `patterns.consciousstack.com`.
+- **OAuth 2.0:** Secure one-click login via major identity providers (Sovereign ID preferred).
+- **Auto-Discovery:** Web dashboard detects local IDEs/Clients and "pousses" the configuration natively.
+- **LLM-First Content:** Transition to "Notion-flavored" Markdown tool descriptions for lower token costs and higher agent resonance.
+- **Marketplace:** Integration with other registries to allow users to "stack" governance nodes from multiple vendors.
+
+---
+*Generated by Antigravity on 2026-02-06*