interface SustainabilityMetrics {
  velocityTrend: "accelerating" | "stable" | "decelerating";
  techDebtRatio: number; // % sprint spent on unplanned work
  deployConfidence: number; // 1-10, how confident the team is during deploys
  onboardingWeeks: number; // time from new engineer to productive
  bugEscapeRate: number; // % bugs slipping to production
}

function assessSustainability(m: SustainabilityMetrics): string {
  // Healthy: velocity accelerating, debt < 20%, confidence > 7
  if (
    m.velocityTrend === "accelerating" &&
    m.techDebtRatio < 0.2 &&
    m.deployConfidence > 7
  ) {
    return "🟢 SUSTAINABLE — Team is healthy, continue trajectory";
  }

  // Warning: velocity stable but debt climbing
  if (m.techDebtRatio > 0.3 || m.deployConfidence < 5) {
    return "🟡 WARNING — Needs sprint allocation for tech debt reduction";
  }

  // Critical: velocity decelerating
  if (m.velocityTrend === "decelerating" && m.techDebtRatio > 0.4) {
    return "🔴 CRITICAL — Stop new features, focus on stabilization";
  }

  return "🟡 MONITOR — Track trends for the next 2 sprints";
}

// Engineering Efficiency Ratio - reporting productivity in a financial tongue
type EngineeringEfficiency struct {
    Team            string
    Period          string // "Q1 2026"
    TotalEngHours   float64
    FeatureHours    float64
    BugFixHours     float64
    MeetingHours    float64
    BlockedHours    float64
    TechDebtHours   float64
    CodeReviewHours float64
}

func (e *EngineeringEfficiency) EfficiencyRatio() float64 {
    return e.FeatureHours / e.TotalEngHours
}

func (e *EngineeringEfficiency) CostPerFeaturePoint(hourlyRate float64, pointsDelivered int) float64 {
    totalCost := e.TotalEngHours * hourlyRate
    return totalCost / float64(pointsDelivered)
}

func (e *EngineeringEfficiency) WastedInvestment(hourlyRate float64) float64 {
    wastedHours := e.MeetingHours*0.5 + e.BlockedHours // 50% meetings = waste
    return wastedHours * hourlyRate
}

// Example output for a C-level report:
// "Engineering Efficiency Ratio: 42% (target: 50%)
//  Cost per Feature Point: $300 (target: < $250)
//  Wasted Investment this quarter: $12,000 (reducible meetings + blocked time)
//  Recommended action: Reduce meeting load by 30%, invest in CI/CD to slash blocked time"

interface SprintBalance {
  featureDevelopment: number; // 70% — the core reason the business pays engineers
  qualityInvestment: number; // 20% — testing, refactoring, documentation
  exploration: number; // 10% — R&D, learning, tooling improvements
}

const healthySprint: SprintBalance = {
  featureDevelopment: 70,
  qualityInvestment: 20,
  exploration: 10,
};

// Red flags:
// - featureDevelopment > 90% → actively burning the future
// - featureDevelopment < 50% → drowning in overhead
// - qualityInvestment === 0  → accumulating tech debt silently
// - exploration === 0        → innovation stagnation imminent

function validateSprintBalance(balance: SprintBalance): string[] {
  const warnings: string[] = [];

  if (balance.featureDevelopment > 90)
    warnings.push(
      "🔴 Burning future velocity — strictly allocate time for quality",
    );
  if (balance.qualityInvestment < 10)
    warnings.push(
      "🟡 Tech debt accumulating — enforce minimum 10% for quality",
    );
  if (balance.exploration === 0)
    warnings.push("🟡 No innovation budget — the team will stagnate");

  return warnings;
}

# Engineering Investment Report — {MONTH} {YEAR}

## Executive Summary

- Total engineering investment: ${X}
- Value delivered: {list of shipped features alongside business impact}
- Engineering Efficiency Ratio: {X}% (target: 50%)
- Key technical risk: {one-liner on the greatest looming threat}

## Investment Breakdown

| Category       | Hours | Cost ($) | % of Total   |
| -------------- | ----- | -------- | ------------ |
| New Features   | X     | X        | 70% target   |
| Bug Fixes      | X     | X        | < 15% target |
| Tech Debt      | X     | X        | ~15% target  |
| Infrastructure | X     | X        | ~5%          |

## ROI Highlights

1. **{Feature A}**: ${X} investment → ${Y} projected annual value (ROI: {Z}x)
2. **{Optimization B}**: ${X} investment → ${Y} annual savings (ROI: {Z}x)

## Tech Debt Balance Sheet

| Item     | Estimated Cost to Fix | Interest Rate | Deadline |
| -------- | --------------------- | ------------- | -------- |
| {Item 1} | ${X}                  | High          | Q2 2026  |

## Risks & Recommendations

1. {Risk 1}: {Mitigation plan}
2. {Risk 2}: {Mitigation plan}

## Next Month Focus

- {Priority 1}
- {Priority 2}

type IncidentCost struct {
    Duration        time.Duration
    AffectedUsers   int
    RevenuePerHour  float64 // average hourly revenue
    EngineersOnCall int
    EngHourlyRate   float64
    SLABreach       bool
    SLAPenalty      float64 // contractual penalty if applicable
}

func (i *IncidentCost) Calculate() map[string]float64 {
    hours := i.Duration.Hours()

    return map[string]float64{
        "lost_revenue":     hours * i.RevenuePerHour,
        "engineering_cost": hours * float64(i.EngineersOnCall) * i.EngHourlyRate,
        "sla_penalty":      conditionalPenalty(i.SLABreach, i.SLAPenalty),
        "reputation_cost":  float64(i.AffectedUsers) * 0.5, // est. $0.50 reputation hit per user
        "total":            0, // sum of above
    }
}

// Example: A 2-hour downtime during peak traffic
// Lost Revenue:     2 x $2,000 = $4,000
// Engineering:      2 x 4 engineers x $100 = $800
// SLA Penalty:      $5,000 (contractual)
// Reputation:       50,000 users x $0.50 = $25,000
// TOTAL COST:       $34,800 for 2 hours of downtime
//
// Contrast with: A $5,000 investment for redundancy and monitoring
// preventing this downtime yields a nearly 7x ROI from a single averted crisis.