Startup founder mental health

import { EventEmitter } from 'events';

interface TelemetryEvent {
  timestamp: Date;
  type: 'calendar_load' | 'communication_volume' | 'sleep_consistency' | 'decision_latency';
  value: number;
  source: string;
}

interface InterventionConfig {
  cooldown_minutes: number;
  max_deferrals_per_cycle: number;
  escalation_threshold: number;
}

interface SystemState {
  cli_score: number;
  baseline_window: number;
  intervention_log: Array<{ triggered_at: Date; action: string }>;
  adaptive_threshold: number;
}

export class FounderCognitiveLoadManager extends EventEmitter {
  private state: SystemStat

e; private config: InterventionConfig; private telemetryBuffer: TelemetryEvent[] = [];

constructor(config: InterventionConfig, baselineWindow: number = 30) { super(); this.config = config; this.state = { cli_score: 0, baseline_window: baselineWindow, intervention_log: [], adaptive_threshold: 75 // Initial threshold, will calibrate }; }

/**

• Ingests behavioral telemetry and updates CLI score */ async ingest(event: TelemetryEvent): Promise<void> { this.telemetryBuffer.push(event); this.state.cli_score = this.calculateCLI();

if (this.state.cli_score > this.state.adaptive_threshold) {

  await this.triggerIntervention();
}

this.emit('load_updated', { score: this.state.cli_score, threshold: this.state.adaptive_threshold });

}

/**

• Weighted cognitive load calculation */ private calculateCLI(): number { const weights = { calendar_load: 0.3, communication_volume: 0.25, sleep_consistency: -0.25, // Inverse: better sleep reduces load decision_latency: 0.2 };

let score = 0;

const recentEvents = this.telemetryBuffer.slice(-this.state.baseline_window * 24); // Approximate hourly events

recentEvents.forEach(event => {
  const weight = weights[event.type] || 0;
  score += event.value * weight;
});

return Math.min(100, Math.max(0, Math.round(score)));

}

/**

• Executes tiered intervention when threshold is breached */ private async triggerIntervention(): Promise<void> { const recentInterventions = this.state.intervention_log.filter( log => Date.now() - log.triggered_at.getTime() < this.config.cooldown_minutes * 60000 );

if (recentInterventions.length >= this.config.max_deferrals_per_cycle) {

  this.emit('escalation_required', { reason: 'Intervention cooldown active' });
  return;
}

const action = this.state.cli_score > this.config.escalation_threshold 
  ? 'mandatory_recovery_block' 
  : 'meeting_deferral';

this.state.intervention_log.push({ triggered_at: new Date(), action });
this.emit('intervention_triggered', { action, cli_score: this.state.cli_score });

// Adaptive recalibration
this.state.adaptive_threshold = this.calibrateThreshold();

}

/**

• Recalibrates threshold based on recent intervention success rate */ private calibrateThreshold(): number { const recent = this.state.intervention_log.slice(-10); if (recent.length < 3) return this.state.adaptive_threshold;

const successRate = recent.filter(i => i.action === 'meeting_deferral').length / recent.length;

const delta = successRate > 0.7 ? -2 : successRate < 0.3 ? 3 : 0;

return Math.min(95, Math.max(40, this.state.adaptive_threshold + delta));

}

/**

• Exports state for clinical or operational review */ exportState(): SystemState { return { ...this.state, telemetryBuffer: this.telemetryBuffer.slice(-100) }; } }

The implementation uses an event emitter pattern to decouple telemetry ingestion from intervention logic. The `calculateCLI` method applies domain-specific weights to behavioral signals, while `calibrateThreshold` implements a lightweight feedback loop to prevent alert fatigue. The system is designed to run as a background service, integrating with calendar APIs (Google Calendar, Outlook), communication platforms (Slack, Teams), and health telemetry (Oura, Apple HealthKit) via standardized webhooks.

## Pitfall Guide

1. **Treating mental health like a bug to be patched**: Cognitive load is not a defect. It is a continuous state variable. Systems that attempt to "fix" founders with one-off interventions fail because they ignore the underlying operational design.
2. **Ignoring baseline variance**: Comparing day 1 telemetry to day 100 without recalibration generates false positives. Founders experience natural load fluctuations during fundraising, launches, and hiring cycles. Static thresholds break under real-world conditions.
3. **Over-indexing on self-reported data**: Subjective surveys lack temporal resolution. Behavioral telemetry (calendar density, response latency, sleep consistency) provides higher signal-to-noise ratios for operational decision-making.
4. **Hardcoding thresholds instead of adaptive learning**: Fixed alert levels cause notification fatigue. Founders disable systems that trigger during high-intensity but necessary periods. Adaptive recalibration based on intervention success rates maintains trust and compliance.
5. **Skipping peer or clinical integration**: Automation cannot replace human context. Systems that operate in isolation miss nuanced stressors (co-founder conflict, investor pressure, product-market fit uncertainty). Always route escalation events to designated human reviewers.
6. **Notification fatigue from poorly tuned alerting**: Excessive alerts degrade system credibility. Implement cooldown windows, batch non-critical events, and use tiered severity levels to preserve attention for genuine thresholds.
7. **Neglecting data privacy and consent frameworks**: Behavioral telemetry contains sensitive patterns. Systems that transmit data to third-party analytics without explicit consent violate privacy standards and erode founder trust. Always default to local-first storage and scoped OAuth permissions.

## Production Bundle

### Action Checklist
- [ ] Define baseline metrics: Establish founder-specific thresholds for calendar load, communication volume, sleep consistency, and decision latency before deployment.
- [ ] Configure telemetry sources: Connect calendar, communication, and health APIs using OAuth 2.0 with explicit consent and scoped permissions.
- [ ] Implement adaptive thresholds: Enable rolling 30-day recalibration to prevent false positives during high-intensity operational periods.
- [ ] Set intervention workflows: Define tiered responses (meeting deferral, communication blackout, mandatory recovery block) with cooldown windows and escalation paths.
- [ ] Deploy monitoring dashboard: Build a read-only interface for load trends, intervention history, and compliance metrics. Restrict access to founder and designated operators.
- [ ] Schedule quarterly calibration: Review intervention success rates, adjust weights, and validate thresholds against operational outcomes.

### Decision Matrix

| Scenario | Recommended Approach | Why | Cost Impact |
|----------|---------------------|-----|-------------|
| Solo founder, pre-seed | Lightweight telemetry + manual intervention | Low overhead, preserves runway, avoids over-engineering | Minimal (API costs only) |
| Co-founder team, seed stage | Systematic monitoring + peer escalation | Balances automation with human context, prevents single-point cognitive failure | Moderate (dashboard + integration dev) |
| Post-Series A scaling | Full FCLM deployment + clinical routing | High operational complexity requires structured load management and compliance | High (engineering + external review) |

### Configuration Template

```yaml
fclm_config:
  telemetry:
    calendar:
      enabled: true
      max_meetings_per_day: 6
      buffer_minutes: 30
    communication:
      enabled: true
      max_responses_per_hour: 15
      blacklist_keywords: ["urgent", "asap", "fire"]
    health:
      enabled: true
      sleep_consistency_threshold: 0.75
      recovery_block_minutes: 120
  alerting:
    cli_threshold: 75
    adaptive_window_days: 30
    cooldown_minutes: 1440
    max_deferrals_per_cycle: 3
  intervention:
    tier_1: meeting_deferral
    tier_2: communication_blackout
    tier_3: mandatory_recovery_block
    escalation_contact: "ops_lead@company.com"
  privacy:
    storage: local_first
    encryption: aes_256_gcm
    consent_revocation: true
    data_retention_days: 90

Quick Start Guide

1. Initialize the repository: Clone the FCLM base code, install dependencies (npm install), and configure environment variables for API keys and OAuth credentials.
2. Define baselines: Run the calibration script (npm run calibrate -- --days 14) to generate founder-specific thresholds based on historical operational data.
3. Deploy telemetry collectors: Enable webhook listeners for calendar, communication, and health APIs. Verify event ingestion using the local test harness (npm run test:telemetry).
4. Activate intervention workflows: Start the background service (npm start). Monitor the dashboard for CLI trends and verify tiered responses trigger correctly during threshold breaches.
5. Schedule review cycle: Set a quarterly calendar event to export state logs, review intervention success rates, and adjust configuration weights based on operational outcomes.