ZenNode - Focus & Wellbeing

Stop burnout before it starts. Code with clarity, not exhaustion.
Real-time cognitive load monitoring for VS Code — protecting developer mental health with behavioral science and AI.

🌐 Live Demo → ryadavtmc.github.io/zen-node

"We spend billions building tools that monitor the health of servers, databases, and APIs. ZenNode asks a simple question: what if we monitored the health of the developer too? Not with surveys. Not with annual check-ins. But in real-time, inside the tool they use 8 hours a day, using the behavioral signals their brain is already broadcasting. Because the most expensive bug in production isn't a null pointer — it's a burned-out developer who stopped caring enough to catch it."

🔒 Privacy Is the Foundation

ZenNode was designed privacy-first from day one — not as a checkbox, but as a core principle.

Mental health tooling only works if developers trust it. The moment an employee suspects their IDE is reporting their struggle to a manager, they'll hide the struggle. ZenNode is architected so that trust is not a matter of policy — it's guaranteed by the code itself.

🔥 The Problem

Software developers are in the middle of a mental health epidemic — and their tools are blind to it.

• 58% of developers report burnout symptoms (Haystack Analytics 2025)
• 73% feel mentally exhausted by end of day — up from 42% pre-AI era
• 42% who left tech in 2025 cited mental health as the primary reason
• The WHO now classifies occupational burnout as a medical syndrome (ICD-11)

In 2026, AI-assisted coding made developers 10x faster at producing code — but the human brain still reviews at the same speed. The bottleneck shifted from writing to sustaining the mental energy to review, verify, and reason about a flood of AI-generated code.

Your IDE knows if your code has a bug. It has no idea if you are about to break.

💡 What It Does

Real-time cognitive load monitoring for VS Code. Tracks your behavioral signals (keystrokes, tab switches, undo rate, idle time) and tells you when your brain is overloaded — before burnout sets in.

Scoring runs 100% locally in TypeScript. The cloud backend is optional and only adds LLM interventions + team sync.

What It Does

Setup

Requirements: VS Code ≥ 1.85 · Node.js ≥ 18 · Python ≥ 3.10 (cloud only)

1. Extension (required)

git clone https://github.com/ryadavtmc/zen-node.git
cd zen-node
npm install
npm run compile

Then either:

• Dev mode: Press F5 in VS Code → Extension Development Host launches
• Install VSIX: vsce package → code --install-extension zennode-0.1.0.vsix

The Zen Bar appears in the status bar: 🧠 ZenNode: Flow (0) 🟢

2. Cloud Backend (optional)

The cloud adds LLM-powered interventions and a manager team dashboard.

cd cloud
python3 -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install -r requirements.txt

Create a cloud/.env file:

SECRET_KEY=your-secret-key
LLM_API_KEY=your-groq-or-openai-key
LLM_BASE_URL=https://api.groq.com/openai/v1
LLM_MODEL=llama-3.3-70b-versatile
LLM_ENABLED=true
JWT_EXPIRE_MINUTES=10080

Start the server:

uvicorn main:app --host 127.0.0.1 --port 8421 --reload

Verify: curl http://127.0.0.1:8421/health API docs: http://127.0.0.1:8421/docs

3. Connect Extension to Cloud

1. In VS Code: Cmd+Shift+P → ZenNode: Connect to Team
2. Sign up or log in with your account
3. Create or join a team using the invite code
4. Enable LLM in VS Code settings: set zennode.enableLLM to true

Demo developer account (for testing):

4. Manager Dashboard

Open http://127.0.0.1:8421/ in your browser and log in with your manager account.

Demo credentials (for testing):

To create your own manager account:

1. Sign up at POST /auth/signup
2. Create a team at POST /teams/create — you become the manager automatically
3. Share the invite code with your developers

Commands

Open the Command Palette (Cmd+Shift+P / Ctrl+Shift+P):

Settings

All settings are under zennode.* in VS Code settings (Cmd+,):

Cloud API Endpoints

Interactive API docs (Swagger UI): http://127.0.0.1:8421/docs

Troubleshooting

Architecture

flowchart TD
    subgraph EXT["VS Code Extension (TypeScript)"]
        TC[TraceCollector\nkeystrokes · tab switches · undos · idle · paste]
        SC[scorer.ts\nWeighted EMA · 0–100 score]
        ZB[ZenBar\n🟢🟡🟠🔴 status bar]
        TS[ThemeShifter\nwarm amber overlay]
        DB[Dashboard\nlive metrics webview]
        BR[BreathingExercise\n4-7-8 guided webview]
        SS[SessionStore\nJSON persistence]
        CS[CloudSync\noptional · JWT auth]
    end

    subgraph CLOUD["Cloud API — FastAPI :8421 (Optional)"]
        AUTH[auth.py\nsignup · login · JWT]
        LLM[llm_interpreter.py\nCBT interventions · Groq/OpenAI]
        SYNC[sync route\nanonymized session summaries]
        DASH[dashboard route\nteam overview · trend]
        DB2[(SQLite\nzennode_cloud.db)]
    end

    USER([Developer in VS Code]) --> TC
    TC --> SC
    SC --> ZB
    SC --> TS
    SC --> DB
    SC --> SS
    SC -->|score ≥ 80 + LLM enabled| CS

    CS -->|POST /api/v1/intervention| LLM
    CS -->|POST /sync/session| SYNC
    LLM --> DB2
    SYNC --> DB2

    MANAGER([Manager Browser]) -->|http://127.0.0.1:8421/| DASH
    AUTH --> DB2
    DASH --> DB2

    ZB -->|click| DB
    DB -->|Breathe button| BR

Project Structure

zen-node/
├── src/                    VS Code Extension (TypeScript)
│   ├── extension.ts        Main activation + 5s loop
│   ├── traceCollector.ts   Behavioral signal tracking
│   ├── scorer.ts           Local cognitive scoring (Layer A)
│   ├── sessionStore.ts     Session persistence (JSON)
│   ├── zenBar.ts           Status bar indicator
│   ├── themeShifter.ts     Warm amber theme overlay
│   ├── dashboard.ts        Live metrics webview
│   ├── breathingExercise.ts  Guided breathing webview
│   ├── cloudSync.ts        Cloud sync (optional)
│   └── connectWizard.ts    Team connect wizard
│
├── cloud/                  Cloud API (FastAPI, optional)
│   ├── main.py             App entry point
│   ├── auth.py             JWT auth
│   ├── database.py         SQLite via SQLAlchemy
│   ├── models.py           DB models
│   ├── schemas.py          Pydantic schemas
│   ├── routes/             API route handlers
│   └── requirements.txt    Python dependencies
│
└── package.json            Extension manifest

Technologies Used

Team

Privacy

• Scoring runs 100% locally — no data leaves your machine
• Tracks counts only (keystrokes, tab switches, undos) — never what you typed
• LLM sees behavioral numbers only — never your source code
• Team sync is opt-in and anonymized — random anonymous_id, no names or emails
• No telemetry, no analytics, fully open source

MIT License · Built for the Nepal US Hackathon 2026