World Fates

{
  "_meta": {
    "description": "Tier 2 fate choice templates for dramatic decision points",
    "version": "1.0",
    "usage": "Reference for fate-choice.ts when generating dramatic choices",
    "design_principles": [
      "Every path should cost something",
      "NPC path is survival but loss of player control",
      "Roll path keeps control but risks death/fall",
      "Third path offers a different trade-off",
      "Choices should reflect entity vulnerabilities"
    ]
  },
  "choice_patterns": {
    "dark_bargain": {
      "description": "A powerful entity offers safety at the cost of service",
      "triggers": ["high_pressure", "powerful_enemy", "desperate_situation"],
      "paths": {
        "accept": {
          "outcome": "npc_transition",
          "description": "Accept the bargain. Survive, but serve.",
          "consequences": [
            "Character becomes NPC in antagonist's service",
            "May appear as ally, enemy, or neutral figure later",
            "Player loses control but character persists"
          ]
        },
        "refuse": {
          "outcome": "fate_roll",
          "description": "Refuse. Face what comes.",
          "consequences": [
            "Roll death/fall check at current odds",
            "If survived: fortune buffer decreases",
            "If failed: death or major fall"
          ]
        },
        "counter": {
          "outcome": "complication",
          "description": "Make a counter-offer. Change the terms.",
          "consequences": [
            "Temporary reprieve",
            "New obligation or debt",
            "Fate pressure temporarily reduced but will return"
          ]
        }
      },
      "examples": [
        "The Queen of Shadows offers sanctuary—serve her, lose yourself",
        "The demon whispers: your soul for your survival",
        "The emperor grants pardon in exchange for eternal loyalty"
      ]
    },
    "betrayal_escape": {
      "description": "Survival requires betraying allies or principles",
      "triggers": ["trapped", "outnumbered", "principles_tested"],
      "paths": {
        "betray": {
          "outcome": "survival_with_cost",
          "description": "Betray them. Save yourself.",
          "consequences": [
            "Character survives, stays player-controlled",
            "Reputation destroyed, new enemies created",
            "May face later consequences from betrayed allies"
          ]
        },
        "stand": {
          "outcome": "fate_roll",
          "description": "Stand with them. Face the odds together.",
          "consequences": [
            "Roll death/fall check",
            "If survived: bonds strengthened",
            "If failed: death with honor or capture"
          ]
        },
        "sacrifice": {
          "outcome": "npc_transition",
          "description": "Sacrifice yourself so they can escape.",
          "consequences": [
            "Character becomes captured/imprisoned NPC",
            "Allies escape and may rescue later",
            "Heroic reputation, but no longer playable"
          ]
        }
      },
      "examples": [
        "Give up their location or die with them",
        "Testify against your mentor or share their fate",
        "Abandon the refugees or be overrun defending them"
      ]
    },
    "corruption_temptation": {
      "description": "Power or victory available at moral cost",
      "triggers": ["losing_fight", "goal_blocked", "power_offered"],
      "paths": {
        "embrace": {
          "outcome": "npc_transition",
          "description": "Accept the power. Become something else.",
          "consequences": [
            "Character transformed into antagonist NPC",
            "Gains power but loses self",
            "May become future threat to other PCs"
          ]
        },
        "resist": {
          "outcome": "fate_roll",
          "description": "Resist the temptation. Face defeat.",
          "consequences": [
            "Roll fall check (not death unless in danger)",
            "Moral victory regardless of roll",
            "If failed: significant setback"
          ]
        },
        "bargain": {
          "outcome": "partial_corruption",
          "description": "Take only what you need. Stay in control.",
          "consequences": [
            "Gain limited benefit",
            "New vulnerability added",
            "Fate pressure increases"
          ]
        }
      },
      "examples": [
        "Drink the blood of the demon to gain its strength",
        "Accept the dark artifact that whispers promises",
        "Use the forbidden ritual to save your people"
      ]
    },
    "succession_crisis": {
      "description": "Position can be kept only by unacceptable means",
      "triggers": ["leadership_challenged", "heir_dispute", "legitimacy_questioned"],
      "paths": {
        "abdicate": {
          "outcome": "npc_transition",
          "description": "Step down. Let someone else bear the burden.",
          "consequences": [
            "Character becomes advisor/mentor NPC",
            "Peaceful transition, legacy preserved",
            "May guide successor but no longer in control"
          ]
        },
        "fight": {
          "outcome": "fate_roll",
          "description": "Fight for your position. Winner takes all.",
          "consequences": [
            "Roll fall check",
            "If survived: position secured, enemies made",
            "If failed: deposed, possibly exiled"
          ]
        },
        "compromise": {
          "outcome": "reduced_power",
          "description": "Share power. Keep some influence.",
          "consequences": [
            "Position weakened but retained",
            "New constraints on action",
            "Fate pressure reduced but vulnerabilities remain"
          ]
        }
      },
      "examples": [
        "Your council demands you name an heir or be removed",
        "The pretender has equal claim—share the throne or duel",
        "Your people have lost faith—retire or be overthrown"
      ]
    },
    "final_stand": {
      "description": "No escape, only how the end comes",
      "triggers": ["cornered", "no_allies", "overwhelming_force"],
      "paths": {
        "surrender": {
          "outcome": "npc_transition",
          "description": "Surrender. Become a prisoner.",
          "consequences": [
            "Character captured, becomes NPC",
            "May be rescued or ransomed later",
            "Survival but at enemy's mercy"
          ]
        },
        "fight": {
          "outcome": "death_roll",
          "description": "Fight to the last. Die on your feet.",
          "consequences": [
            "Roll death check at high odds",
            "If survived: legendary reputation, narrow escape",
            "If failed: heroic death"
          ]
        },
        "escape": {
          "outcome": "survival_with_major_cost",
          "description": "Find a way out. Leave everything behind.",
          "consequences": [
            "Survive but lose all resources/status",
            "Start over from nothing",
            "Reputation as coward possible"
          ]
        }
      },
      "examples": [
        "The castle is breached, enemies at the door",
        "Your ship is sinking, enemy fleet surrounds you",
        "Assassins have you cornered in the alley"
      ]
    },
    "prophetic_doom": {
      "description": "Fate itself seems to demand the character's end",
      "triggers": ["prophecy_nearing", "curse_climax", "destiny_calling"],
      "paths": {
        "accept": {
          "outcome": "npc_transition",
          "description": "Accept your fate. Fulfill the prophecy.",
          "consequences": [
            "Character fulfills destiny, leaves player control",
            "May become legend, god, or something else",
            "Story purpose complete"
          ]
        },
        "defy": {
          "outcome": "fate_roll",
          "description": "Defy destiny. The prophecy was wrong.",
          "consequences": [
            "Roll at increased difficulty",
            "If survived: broke the chains of fate",
            "If failed: prophecy fulfilled despite defiance"
          ]
        },
        "redirect": {
          "outcome": "transformed_fate",
          "description": "Fulfill the letter but not the spirit.",
          "consequences": [
            "Find loophole in prophecy",
            "Unexpected consequences",
            "Neither victory nor defeat, but change"
          ]
        }
      },
      "examples": [
        "The oracle said you would die this day",
        "The curse reaches its final hour",
        "The god you serve demands your sacrifice"
      ]
    }
  },
  "outcome_types": {
    "npc_transition": {
      "description": "Character leaves player control but persists in world",
      "player_control": false,
      "character_survives": true,
      "world_presence": true
    },
    "fate_roll": {
      "description": "Roll against fate pressure for death/fall",
      "player_control": "conditional",
      "character_survives": "probabilistic",
      "world_presence": "conditional"
    },
    "death_roll": {
      "description": "Roll specifically for death (high stakes)",
      "player_control": "conditional",
      "character_survives": "probabilistic",
      "world_presence": "if_survived"
    },
    "survival_with_cost": {
      "description": "Survive but pay significant price",
      "player_control": true,
      "character_survives": true,
      "world_presence": true,
      "cost": "reputation, allies, resources"
    },
    "survival_with_major_cost": {
      "description": "Survive but lose almost everything",
      "player_control": true,
      "character_survives": true,
      "world_presence": true,
      "cost": "status, possessions, position"
    },
    "partial_corruption": {
      "description": "Gain benefit but add vulnerability",
      "player_control": true,
      "character_survives": true,
      "world_presence": true,
      "cost": "new vulnerability, increased pressure"
    },
    "reduced_power": {
      "description": "Keep position but weakened",
      "player_control": true,
      "character_survives": true,
      "world_presence": true,
      "cost": "power level reduced"
    },
    "complication": {
      "description": "Delay fate but create new problems",
      "player_control": true,
      "character_survives": true,
      "world_presence": true,
      "cost": "new obligation, pressure returns"
    },
    "transformed_fate": {
      "description": "Change the terms but not escape",
      "player_control": "varies",
      "character_survives": true,
      "world_presence": true,
      "cost": "unexpected transformation"
    }
  },
  "personalization_hooks": {
    "use_vulnerabilities": "Match choice pattern to entity's specific weaknesses",
    "use_relationships": "Involve NPCs the character has bonds with",
    "use_antagonists": "If known antagonist exists, cast them as tempter/threat",
    "use_values": "Challenge what the character believes in",
    "use_history": "Reference past events and exposure log entries"
  }
}

{
  "_meta": {
    "description": "Schema for entity fate tracking metadata",
    "version": "1.0",
    "usage": "Add to entity entries in world bible under 'Fate Tracking' section"
  },
  "schema": {
    "powerLevel": {
      "type": "integer",
      "range": [1, 10],
      "description": "Influence/resources/capability scale",
      "levels": {
        "1-2": "Local significance (village elder, small merchant, local hero)",
        "3-4": "Regional influence (town mayor, guild master, regional champion)",
        "5-6": "National importance (noble house, major faction, famous adventurer)",
        "7-8": "Civilization-scale impact (kingdom ruler, legendary hero, archmage)",
        "9-10": "World-shaping power (emperor, demigod, world-threatening force)"
      }
    },
    "tenure": {
      "type": "string",
      "description": "Duration in power/position",
      "format": "X years|months|decades",
      "modifiers": {
        "under_1_year": 0.5,
        "1_to_5_years": 1.0,
        "5_to_20_years": 1.5,
        "20_to_50_years": 2.0,
        "over_50_years": 2.5
      }
    },
    "vulnerabilities": {
      "type": "array",
      "items": "string",
      "description": "Known weaknesses that increase fate pressure",
      "weightings": {
        "known_enemy": 1.0,
        "active_conflict": 1.5,
        "exploitable_flaw": 2.0,
        "critical_dependency": 1.0,
        "destroying_secret": 3.0,
        "default": 1.0
      },
      "maxScore": 10
    },
    "protections": {
      "type": "array",
      "items": "string",
      "description": "Shields that reduce fate pressure",
      "weightings": {
        "loyal_ally": 1.0,
        "fortified_position": 2.0,
        "divine_protection": 3.0,
        "magical_protection": 3.0,
        "information_network": 1.0,
        "popular_support": 2.0,
        "default": 0.5
      },
      "minFactor": 1
    },
    "fortuneBuffer": {
      "type": "number",
      "range": [0, 5],
      "description": "Remaining luck/grace/narrative protection",
      "defaults": {
        "standard_character": 3,
        "protagonist": 4,
        "major_protagonist": 5
      },
      "notes": "Decreases with narrow escapes; can be restored through sacrifice/growth"
    },
    "exposureLog": {
      "type": "array",
      "items": {
        "date": "string (YYYY-MM-DD)",
        "event": "string",
        "pressure": "number (0.01-0.30)",
        "category": "string (optional)"
      },
      "description": "Record of risk exposure events",
      "categories": {
        "combat": 0.10,
        "intrigue": 0.05,
        "betrayal": 0.15,
        "overreach": 0.10,
        "revelation": 0.20,
        "loss": 0.08,
        "challenge": 0.12,
        "narrow_escape": 0.05
      }
    },
    "lastAssessment": {
      "type": "string",
      "format": "date (YYYY-MM-DD)",
      "description": "When fate pressure was last calculated"
    }
  },
  "templates": {
    "character": {
      "powerLevel": 5,
      "tenure": "5 years",
      "vulnerabilities": [],
      "protections": [],
      "fortuneBuffer": 3,
      "exposureLog": [],
      "lastAssessment": null
    },
    "faction": {
      "powerLevel": 6,
      "tenure": "50 years",
      "vulnerabilities": [],
      "protections": [],
      "fortuneBuffer": 4,
      "exposureLog": [],
      "lastAssessment": null
    },
    "location": {
      "powerLevel": 4,
      "tenure": "200 years",
      "vulnerabilities": [],
      "protections": [],
      "fortuneBuffer": 5,
      "exposureLog": [],
      "lastAssessment": null
    }
  },
  "formula": {
    "description": "Fate Pressure = (Power × TenureMod × VulnScore/10) / (ProtectionFactor × max(FortuneBuffer, 0.5)) + ExposureSum",
    "components": {
      "base": "(powerLevel * tenureModifier * vulnerabilityScore / 10)",
      "divisor": "(protectionFactor * Math.max(fortuneBuffer, 0.5))",
      "exposure": "sum of all exposure log pressure values"
    },
    "clamp": {
      "min": 0,
      "max": 1
    }
  },
  "states": {
    "F1": { "name": "Stable Ascent", "range": [0.0, 0.3] },
    "F2": { "name": "Peak Power", "range": [0.3, 0.5] },
    "F3": { "name": "Overextension", "range": [0.5, 0.7] },
    "F4": { "name": "Precarious Position", "range": [0.7, 0.9] },
    "F5": { "name": "Fall in Progress", "range": [0.9, 1.0] }
  }
}

{
  "_meta": {
    "description": "Fate-shift types with severity levels and narrative hooks",
    "version": "1.0",
    "usage": "Reference for propose-shift.ts and fate-choice.ts"
  },
  "character": {
    "death": {
      "description": "Physical end of the character",
      "severities": {
        "catastrophic": "Complete destruction, no return possible, legacy may be tainted",
        "major": "Death with lasting influence (legacy, ghost, prophecy fulfilled)"
      },
      "eligibility": {
        "requiresDanger": true,
        "minPressure": 0.5,
        "maxFortuneBuffer": 1
      },
      "narrativeHooks": [
        "Found slain in their chambers, door locked from within",
        "Fell in battle, surrounded but fighting to the last",
        "Poisoned at a feast, the cup still in their hand",
        "Disappeared during a journey, only their horse returned",
        "Died protecting someone they loved",
        "Struck down by illness that none could cure",
        "Executed publicly for crimes real or fabricated",
        "Lost at sea during a storm",
        "Killed by the very power they sought to control",
        "Died of a broken heart after final betrayal",
        "Vanished into the wilderness, presumed dead",
        "Sacrificed themselves to save many"
      ]
    },
    "fall": {
      "description": "Loss of power, status, or position",
      "severities": {
        "catastrophic": "Total loss—exile, imprisonment, or complete disgrace",
        "major": "Significant loss of position, recovery difficult but possible",
        "moderate": "Noticeable decline in influence, must rebuild from weakened position",
        "minor": "Reputation damaged, warning sign of worse to come"
      },
      "eligibility": {
        "requiresDanger": false,
        "minPressure": 0.3
      },
      "narrativeHooks": [
        "Secrets revealed in the public square",
        "Allies turned against them one by one",
        "Caught in corruption that could not be hidden",
        "Lost a challenge that cost everything",
        "Betrayed by the one they trusted most",
        "Made an enemy of the wrong power",
        "Failed at the crucial moment when it mattered most",
        "Their protector could no longer shield them",
        "The people they served turned their backs",
        "Outmaneuvered by a younger, cleverer rival",
        "Their lies caught up with them all at once",
        "A single mistake cascaded into disaster"
      ]
    },
    "corruption": {
      "description": "Moral or spiritual decline",
      "severities": {
        "catastrophic": "Fully turned to darkness or opposition, irredeemable",
        "major": "Core values fundamentally compromised",
        "moderate": "Making increasingly morally questionable choices",
        "minor": "Temptation acknowledged, first steps toward darkness"
      },
      "eligibility": {
        "requiresDanger": false,
        "minPressure": 0.4
      },
      "narrativeHooks": [
        "Made a deal they cannot escape",
        "The ends began justifying the means",
        "Power revealed their true nature",
        "They became what they once fought against",
        "The corruption spread slowly, unnoticed until too late",
        "A single compromise opened the door to many more",
        "They convinced themselves it was necessary",
        "The darkness offered what the light could not"
      ]
    },
    "exile": {
      "description": "Removal from sphere of influence",
      "severities": {
        "catastrophic": "Permanent banishment, can never return, all connections severed",
        "major": "Long exile, return uncertain, must start over elsewhere",
        "moderate": "Temporary exile with conditions for return",
        "minor": "Withdrawal from public life, self-imposed distance"
      },
      "eligibility": {
        "requiresDanger": false,
        "minPressure": 0.35
      },
      "narrativeHooks": [
        "Driven out by those they once led",
        "Fled before enemies could catch them",
        "Banished by decree of higher authority",
        "Chose exile over compromise",
        "The land itself seemed to reject them",
        "Stripped of titles and sent away in disgrace"
      ]
    },
    "transformation": {
      "description": "Fundamental change in nature or identity",
      "severities": {
        "catastrophic": "Unrecognizable from former self, old identity gone",
        "major": "Major aspect fundamentally changed, core identity shifted",
        "moderate": "Significant shift in priorities, methods, or beliefs",
        "minor": "Noticeable change in approach or outlook"
      },
      "eligibility": {
        "requiresDanger": false,
        "minPressure": 0.4
      },
      "narrativeHooks": [
        "Emerged from the ordeal a different person",
        "The experience broke something inside them",
        "They shed their old self like a snake's skin",
        "What they saw changed them forever",
        "The choice they made redefined who they were",
        "They realized they had been wrong about everything"
      ]
    },
    "diminishment": {
      "description": "Gradual decline over time",
      "severities": {
        "major": "Significant reduction in capability, shadow of former self",
        "moderate": "Noticeable weakening, slowing, or fading",
        "minor": "Early signs of decline, the peak is past"
      },
      "eligibility": {
        "requiresDanger": false,
        "minPressure": 0.25
      },
      "narrativeHooks": [
        "Age finally caught up with them",
        "Old wounds began to take their toll",
        "Their fire slowly dimmed",
        "They could no longer do what once came easy",
        "The burden of years weighed heavier each day",
        "Their legend faded as new heroes rose"
      ]
    }
  },
  "faction": {
    "collapse": {
      "description": "Organization ceases to exist",
      "severities": {
        "catastrophic": "Complete dissolution, members scattered to the winds, legacy destroyed",
        "major": "Organization effectively destroyed, only remnants remain"
      },
      "narrativeHooks": [
        "Internal strife tore them apart",
        "Their enemies finally united against them",
        "The cause that bound them lost its meaning",
        "Corruption rotted them from within",
        "A single betrayal brought down the whole structure"
      ]
    },
    "schism": {
      "description": "Faction splits into competing groups",
      "severities": {
        "major": "Bitter split, factions in open conflict",
        "moderate": "Amicable division, factions maintain some cooperation",
        "minor": "Internal factions forming, unity strained"
      },
      "narrativeHooks": [
        "Two leaders claimed the right to lead",
        "Ideological differences became irreconcilable",
        "A succession crisis divided loyalties",
        "Regional chapters went their own way",
        "The old guard clashed with reformers"
      ]
    },
    "absorption": {
      "description": "Faction absorbed by another power",
      "severities": {
        "catastrophic": "Hostile takeover, identity erased, members absorbed or purged",
        "major": "Merger with junior status, name may survive but independence gone"
      },
      "narrativeHooks": [
        "A stronger power made an offer they couldn't refuse",
        "Survival meant surrendering independence",
        "They were bought out by their largest rival",
        "The merger was sold as partnership but became subjugation"
      ]
    },
    "decline": {
      "description": "Gradual loss of influence and resources",
      "severities": {
        "catastrophic": "Reduced to irrelevance, barely exists",
        "major": "Major loss of territory, membership, or resources",
        "moderate": "Noticeable decline in power and prestige",
        "minor": "Beginning to slip, rivals gaining ground"
      },
      "narrativeHooks": [
        "Their best members left for other opportunities",
        "Funding dried up as patrons lost interest",
        "Younger organizations outcompeted them",
        "They failed to adapt to changing times",
        "A series of failed ventures depleted their resources"
      ]
    },
    "reformation": {
      "description": "Fundamental change in faction nature or purpose",
      "severities": {
        "major": "Complete transformation of goals, methods, or identity",
        "moderate": "Significant shift in direction or values"
      },
      "narrativeHooks": [
        "New leadership brought new vision",
        "Crisis forced them to reinvent themselves",
        "They abandoned their original purpose for survival",
        "A revelation changed everything they believed"
      ]
    },
    "defeat": {
      "description": "Loss in specific conflict or competition",
      "severities": {
        "catastrophic": "Total defeat, terms dictated by victors",
        "major": "Decisive defeat, significant concessions required",
        "moderate": "Clear loss, must regroup and recover",
        "minor": "Setback, reputation damaged but organization intact"
      },
      "narrativeHooks": [
        "Their enemies proved stronger than expected",
        "A crucial battle turned against them",
        "Their strategy failed at the worst moment",
        "Allies abandoned them when needed most"
      ]
    }
  },
  "location": {
    "destruction": {
      "description": "Physical end of the location",
      "severities": {
        "catastrophic": "Completely destroyed, uninhabitable, may never recover",
        "major": "Largely destroyed, some remains but barely recognizable"
      },
      "narrativeHooks": [
        "Fire consumed everything",
        "The earth swallowed it whole",
        "War left nothing but ruins",
        "A curse rendered it uninhabitable",
        "Flood waters washed it away"
      ]
    },
    "conquest": {
      "description": "Location changes hands to new power",
      "severities": {
        "catastrophic": "Brutal conquest, population displaced or subjugated",
        "major": "Conquered, new rulers impose their will",
        "moderate": "Control contested, authority unclear"
      },
      "narrativeHooks": [
        "Invaders broke through the defenses",
        "Betrayal from within opened the gates",
        "Siege finally succeeded after months",
        "The rulers surrendered to spare their people",
        "A bloodless coup changed everything overnight"
      ]
    },
    "disaster": {
      "description": "Catastrophic damage to location",
      "severities": {
        "catastrophic": "Rendered uninhabitable for foreseeable future",
        "major": "Severe damage, long recovery needed",
        "moderate": "Significant damage, major repairs required",
        "minor": "Localized damage, disruption but recovery underway"
      },
      "narrativeHooks": [
        "The plague swept through without mercy",
        "Earthquake shattered the foundations",
        "Famine emptied the streets",
        "A magical catastrophe twisted the land",
        "The river broke its banks and drowned the valley"
      ]
    },
    "decline": {
      "description": "Economic or population decline",
      "severities": {
        "catastrophic": "Ghost town, nearly abandoned",
        "major": "Major population and economic exodus",
        "moderate": "Noticeable decline in prosperity",
        "minor": "Beginning to fade, young people leaving"
      },
      "narrativeHooks": [
        "The mines ran dry",
        "Trade routes shifted elsewhere",
        "A better opportunity drew people away",
        "Taxes drove out the merchants",
        "The old industries died and nothing replaced them"
      ]
    },
    "transformation": {
      "description": "Fundamental change in location's nature",
      "severities": {
        "major": "Completely different character and purpose",
        "moderate": "Significant shift in identity or role"
      },
      "narrativeHooks": [
        "What was sacred became profane",
        "The forest reclaimed what was once farmland",
        "Industry replaced the gardens",
        "The fortress became a marketplace",
        "Magic changed the very nature of the land"
      ]
    },
    "isolation": {
      "description": "Location cut off from the world",
      "severities": {
        "major": "Completely unreachable, forgotten by the outside",
        "moderate": "Difficult to reach, connections severed",
        "minor": "Increasing difficulty in travel or communication"
      },
      "narrativeHooks": [
        "The roads became too dangerous",
        "A curse keeps travelers away",
        "Political borders closed around them",
        "The bridge collapsed and was never rebuilt",
        "They chose to wall themselves off"
      ]
    }
  }
}

#!/usr/bin/env -S deno run --allow-read

/**
 * Exposure Log - Track Risk Events
 *
 * Logs risk exposure events that increase fate pressure.
 * Categorizes events and suggests pressure increments.
 *
 * Usage:
 *   deno run --allow-read exposure-log.ts --event "Survived assassination attempt"
 *   deno run --allow-read exposure-log.ts --event "Secret revealed publicly" --pressure 0.20
 *   deno run --allow-read exposure-log.ts --list
 */

interface ExposureCategory {
  base: number;
  description: string;
  keywords: string[];
}

const EXPOSURE_CATEGORIES: { [key: string]: ExposureCategory } = {
  combat: {
    base: 0.10,
    description: "Active combat, violence, or physical danger",
    keywords: ["combat", "battle", "fight", "wound", "attack", "assassination", "duel"],
  },
  intrigue: {
    base: 0.05,
    description: "Political maneuvering, subtle threats",
    keywords: ["intrigue", "politics", "scheme", "plot", "manipulat", "negotiat"],
  },
  betrayal: {
    base: 0.15,
    description: "Trust violated, ally turns against",
    keywords: ["betray", "turned", "abandon", "traitor", "double-cross"],
  },
  revelation: {
    base: 0.20,
    description: "Secret exposed, truth revealed",
    keywords: ["secret", "reveal", "exposed", "discover", "truth", "uncover"],
  },
  overreach: {
    base: 0.10,
    description: "Hubris, overconfident action",
    keywords: ["hubris", "overconfident", "reckless", "arrogant", "foolish"],
  },
  loss: {
    base: 0.08,
    description: "Resource, ally, or territory lost",
    keywords: ["lost", "death of", "defeat", "lose", "fallen"],
  },
  challenge: {
    base: 0.12,
    description: "Direct challenge to power or status",
    keywords: ["challenge", "rival", "contest", "dispute", "claim"],
  },
  narrow_escape: {
    base: 0.05,
    description: "Survived dangerous situation",
    keywords: ["narrow", "escape", "surviv", "barely", "close call"],
  },
};

function categorizeEvent(eventDescription: string): {
  category: string;
  suggestedPressure: number;
  categoryData: ExposureCategory;
} {
  const lower = eventDescription.toLowerCase();

  for (const [category, data] of Object.entries(EXPOSURE_CATEGORIES)) {
    for (const keyword of data.keywords) {
      if (lower.includes(keyword)) {
        return { category, suggestedPressure: data.base, categoryData: data };
      }
    }
  }

  // Default to intrigue if no match
  return {
    category: "intrigue",
    suggestedPressure: 0.05,
    categoryData: EXPOSURE_CATEGORIES.intrigue,
  };
}

function getDate(): string {
  return new Date().toISOString().split("T")[0];
}

function formatExposureEntry(
  event: string,
  category: string,
  pressure: number,
  name?: string
): string {
  const date = getDate();
  const lines: string[] = [];

  lines.push("EXPOSURE EVENT LOGGED");
  lines.push("=".repeat(50));
  lines.push("");
  if (name) {
    lines.push(`Entity: ${name}`);
  }
  lines.push(`Date: ${date}`);
  lines.push(`Event: ${event}`);
  lines.push(`Category: ${category}`);
  lines.push(`Pressure Increment: +${(pressure * 100).toFixed(1)}%`);
  lines.push("");
  lines.push("WORLD BIBLE ENTRY FORMAT");
  lines.push("-".repeat(50));
  lines.push("Add to entity's Risk Exposure Log section:");
  lines.push("");
  lines.push(`- ${date}: ${event} (+${(pressure * 100).toFixed(0)}% pressure)`);
  lines.push("");
  lines.push("CUMULATIVE EFFECT");
  lines.push("-".repeat(50));
  lines.push("This event adds to the entity's total fate pressure.");
  lines.push("Run fate-pressure.ts to see current total.");

  return lines.join("\n");
}

function showUsage() {
  console.log(`
Exposure Log - Track Risk Events
=================================

Logs risk exposure events that increase fate pressure.

Usage:
  deno run --allow-read exposure-log.ts [options]

Required:
  --event <text>    Description of the exposure event

Optional:
  --pressure <n>    Override suggested pressure increment (0.01-0.30)
  --name <name>     Entity name for context
  --json            Output as JSON for programmatic use

Information:
  --list            List all exposure categories and base pressures

Categories and Base Pressures:
  combat:        +10%  Active combat, violence, physical danger
  intrigue:      +5%   Political maneuvering, subtle threats
  betrayal:      +15%  Trust violated, ally turns against
  revelation:    +20%  Secret exposed, truth revealed
  overreach:     +10%  Hubris, overconfident action
  loss:          +8%   Resource, ally, or territory lost
  challenge:     +12%  Direct challenge to power or status
  narrow_escape: +5%   Survived dangerous situation

Examples:
  deno run --allow-read exposure-log.ts --event "Survived assassination attempt"
  deno run --allow-read exposure-log.ts --event "Secret revealed publicly" --name "Lord Varen"
  deno run --allow-read exposure-log.ts --event "Lost the Battle of the Crossing" --pressure 0.15
`);
}

function main() {
  const args = Deno.args;

  if (args.includes("--help") || args.includes("-h")) {
    showUsage();
    Deno.exit(0);
  }

  if (args.includes("--list")) {
    console.log("Exposure Categories");
    console.log("=".repeat(50));
    console.log("");
    for (const [category, data] of Object.entries(EXPOSURE_CATEGORIES)) {
      console.log(`${category.toUpperCase()}`);
      console.log(`  Base pressure: +${(data.base * 100).toFixed(0)}%`);
      console.log(`  Description: ${data.description}`);
      console.log(`  Keywords: ${data.keywords.join(", ")}`);
      console.log("");
    }
    Deno.exit(0);
  }

  // Parse arguments
  let event = "";
  let customPressure: number | undefined;
  let name = "";
  let jsonOutput = false;

  for (let i = 0; i < args.length; i++) {
    switch (args[i]) {
      case "--event":
        event = args[++i] || "";
        break;
      case "--pressure":
        customPressure = parseFloat(args[++i]);
        break;
      case "--name":
        name = args[++i] || "";
        break;
      case "--json":
        jsonOutput = true;
        break;
    }
  }

  if (!event) {
    console.error("Error: --event required");
    console.error('Example: --event "Survived assassination attempt"');
    Deno.exit(1);
  }

  const { category, suggestedPressure, categoryData } = categorizeEvent(event);
  const pressure = customPressure !== undefined ? customPressure : suggestedPressure;

  // Clamp pressure
  const clampedPressure = Math.min(Math.max(pressure, 0.01), 0.30);

  if (jsonOutput) {
    console.log(
      JSON.stringify(
        {
          date: getDate(),
          entity: name || undefined,
          event,
          category,
          pressure: clampedPressure,
          categoryDescription: categoryData.description,
        },
        null,
        2
      )
    );
  } else {
    console.log(formatExposureEntry(event, category, clampedPressure, name || undefined));
  }
}

main();

#!/usr/bin/env -S deno run --allow-read

/**
 * Fate Choice Generator - Tier 2 Dramatic Choices
 *
 * Generates dramatic choices when fate pressure is high.
 * One path leads to NPC-hood, one path faces the roll,
 * optional third path offers different trade-off.
 *
 * Usage:
 *   deno run --allow-read fate-choice.ts --name "Kaira the Bold" --pressure 0.72
 *   deno run --allow-read fate-choice.ts --name "Kaira" --pressure 0.72 --antagonist "The Dark Queen"
 *   deno run --allow-read fate-choice.ts --name "Kaira" --pressure 0.72 --pattern dark_bargain
 */

import { dirname, fromFileUrl, join } from "https://deno.land/std@0.208.0/path/mod.ts";

interface ChoicePattern {
  description: string;
  triggers: string[];
  paths: {
    [key: string]: {
      outcome: string;
      description: string;
      consequences: string[];
    };
  };
  examples: string[];
}

interface FateChoiceData {
  choice_patterns: { [key: string]: ChoicePattern };
  outcome_types: { [key: string]: unknown };
}

// Seeded random for reproducibility
class SeededRandom {
  private seed: number;

  constructor(seed: number) {
    this.seed = seed;
  }

  next(): number {
    this.seed = (this.seed * 1103515245 + 12345) & 0x7fffffff;
    return this.seed / 0x7fffffff;
  }

  pick<T>(array: T[]): T {
    return array[Math.floor(this.next() * array.length)];
  }
}

async function loadChoiceData(): Promise<FateChoiceData | null> {
  try {
    const scriptDir = dirname(fromFileUrl(import.meta.url));
    const dataPath = join(scriptDir, "..", "data", "fate-choices.json");
    const text = await Deno.readTextFile(dataPath);
    return JSON.parse(text);
  } catch {
    return null;
  }
}

function calculateDeathOdds(pressure: number, fortune: number): number {
  if (pressure <= 0.5 || fortune >= 1) return 0;
  return (pressure - 0.5) * 2 * (1 - fortune / 5) * 100;
}

function generateChoice(
  name: string,
  pressure: number,
  fortune: number,
  pattern: ChoicePattern,
  antagonist: string | undefined,
  rng: SeededRandom
): string {
  const lines: string[] = [];
  const deathOdds = calculateDeathOdds(pressure, fortune);

  lines.push(`FATE CHOICE: ${name}`);
  lines.push("=".repeat(50));
  lines.push("");
  lines.push(`The wheel turns. Fate pressure is ${(pressure * 100).toFixed(0)}%.`);
  lines.push("A choice presents itself:");
  lines.push("");

  // Get example and personalize with antagonist if provided
  let situation = rng.pick(pattern.examples);
  if (antagonist) {
    situation = situation.replace(/The Queen of Shadows|the demon|The emperor|the enemy/gi, antagonist);
  }
  lines.push(`"${situation}"`);
  lines.push("");

  // Generate paths
  const pathKeys = Object.keys(pattern.paths);
  const pathLabels = ["A", "B", "C"];

  for (let i = 0; i < pathKeys.length; i++) {
    const key = pathKeys[i];
    const path = pattern.paths[key];
    const label = pathLabels[i];

    lines.push(`${label}) ${key.toUpperCase().replace(/_/g, " ")}`);
    lines.push(`   ${path.description}`);

    for (const consequence of path.consequences) {
      let displayConsequence = consequence;

      // Replace placeholders with actual values
      if (consequence.includes("current odds")) {
        displayConsequence = consequence.replace("current odds", `${deathOdds.toFixed(0)}% death chance`);
      }

      lines.push(`   → ${displayConsequence}`);
    }
    lines.push("");
  }

  lines.push("-".repeat(50));
  lines.push("MECHANICS");
  lines.push("-".repeat(50));
  lines.push(`  Fate Pressure: ${(pressure * 100).toFixed(0)}%`);
  lines.push(`  Fortune Buffer: ${fortune}/5`);
  if (deathOdds > 0) {
    lines.push(`  Death Odds (if roll path): ${deathOdds.toFixed(0)}%`);
  } else {
    lines.push("  Death: Not eligible (fortune > 0 or pressure <= 50%)");
  }
  lines.push("");
  lines.push("NOTES FOR FACILITATOR");
  lines.push("-".repeat(50));
  lines.push("  - Present this choice at a dramatic moment");
  lines.push("  - The NPC path should feel like a real cost, not escape");
  lines.push("  - If they choose to roll, use fate-roll.ts with --danger flag");
  lines.push("  - Honor their choice—this IS the climax");

  return lines.join("\n");
}

function showUsage() {
  console.log(`
Fate Choice Generator
=====================

Generates Tier 2 dramatic choices for high-pressure situations.

Usage:
  deno run --allow-read fate-choice.ts [options]

Required:
  --name <name>        Entity name
  --pressure <0-1>     Fate pressure (should be > 0.6)

Optional:
  --fortune <0-5>      Fortune buffer (default: 0)
  --antagonist <name>  Name to use for tempter/threat
  --pattern <type>     Specific pattern to use
  --seed <n>           Random seed for reproducibility
  --list               List available patterns

Patterns:
  dark_bargain         A powerful entity offers safety at cost of service
  betrayal_escape      Survival requires betraying allies or principles
  corruption_temptation Power or victory available at moral cost
  succession_crisis    Position can only be kept by unacceptable means
  final_stand          No escape, only how the end comes
  prophetic_doom       Fate itself demands the character's end

Examples:
  deno run --allow-read fate-choice.ts --name "Kaira" --pressure 0.72
  deno run --allow-read fate-choice.ts --name "Lord Varen" --pressure 0.85 --antagonist "House Blackwood"
  deno run --allow-read fate-choice.ts --name "Captain Sera" --pressure 0.68 --pattern final_stand

Design Principles:
  - Every path should cost something
  - NPC path = survival but loss of player control
  - Roll path = keep control but risk death/fall
  - Third path = different trade-off
`);
}

async function main() {
  const args = Deno.args;

  if (args.includes("--help") || args.includes("-h")) {
    showUsage();
    Deno.exit(0);
  }

  // Load choice data
  const choiceData = await loadChoiceData();
  if (!choiceData) {
    console.error("Warning: Could not load fate-choices.json, using defaults");
  }

  // Parse arguments
  let name = "";
  let pressure = -1;
  let fortune = 0;
  let antagonist: string | undefined;
  let patternName: string | undefined;
  let seed = Date.now();

  for (let i = 0; i < args.length; i++) {
    switch (args[i]) {
      case "--name":
        name = args[++i] || "";
        break;
      case "--pressure":
        pressure = parseFloat(args[++i]) || -1;
        break;
      case "--fortune":
        fortune = parseFloat(args[++i]) ?? 0;
        break;
      case "--antagonist":
        antagonist = args[++i];
        break;
      case "--pattern":
        patternName = args[++i];
        break;
      case "--seed":
        seed = parseInt(args[++i]) || Date.now();
        break;
      case "--list":
        if (choiceData) {
          console.log("Available patterns:");
          for (const [key, pattern] of Object.entries(choiceData.choice_patterns)) {
            console.log(`  ${key}: ${pattern.description}`);
          }
        }
        Deno.exit(0);
    }
  }

  if (!name) {
    console.error("Error: --name required");
    Deno.exit(1);
  }

  if (pressure < 0 || pressure > 1) {
    console.error("Error: --pressure required (value between 0 and 1)");
    Deno.exit(1);
  }

  if (pressure < 0.5) {
    console.warn("Warning: Fate pressure < 50%. Tier 2 choices typically trigger at > 60%.");
  }

  // Clamp fortune
  fortune = Math.min(Math.max(fortune, 0), 5);

  const rng = new SeededRandom(seed);

  // Get or create pattern
  let pattern: ChoicePattern;

  if (choiceData && patternName && choiceData.choice_patterns[patternName]) {
    pattern = choiceData.choice_patterns[patternName];
  } else if (choiceData) {
    // Pick random pattern
    const patterns = Object.values(choiceData.choice_patterns);
    pattern = rng.pick(patterns);
  } else {
    // Fallback default pattern
    pattern = {
      description: "A powerful entity offers safety at the cost of service",
      triggers: ["high_pressure"],
      paths: {
        accept: {
          outcome: "npc_transition",
          description: "Accept the bargain. Survive, but serve.",
          consequences: [
            "Character becomes NPC in antagonist's service",
            "May appear as ally, enemy, or neutral figure later",
            "Player loses control but character persists",
          ],
        },
        refuse: {
          outcome: "fate_roll",
          description: "Refuse. Face what comes.",
          consequences: [
            "Roll death/fall check at current odds",
            "If survived: fortune buffer decreases",
            "If failed: death or major fall",
          ],
        },
        counter: {
          outcome: "complication",
          description: "Make a counter-offer. Change the terms.",
          consequences: [
            "Temporary reprieve",
            "New obligation or debt",
            "Fate pressure temporarily reduced but will return",
          ],
        },
      },
      examples: [
        "The Dark One offers sanctuary—serve them, lose yourself",
        "Your enemy offers pardon in exchange for eternal loyalty",
        "The power offers itself—take it and be changed forever",
      ],
    };
  }

  console.log(generateChoice(name, pressure, fortune, pattern, antagonist, rng));
}

main();

#!/usr/bin/env -S deno run --allow-read

/**
 * Fate Pressure Calculator
 *
 * Calculates current fate pressure for entities based on:
 * - Power level (1-10)
 * - Tenure modifier (0.5x - 2.5x)
 * - Vulnerability score (0-10)
 * - Protection factor (1-10)
 * - Fortune buffer (0-5)
 * - Risk exposure accumulation
 *
 * Usage:
 *   deno run --allow-read fate-pressure.ts --power 7 --tenure 40 --vulns 3 --prots 2 --fortune 2
 *   deno run --allow-read fate-pressure.ts --interactive
 *   deno run --allow-read fate-pressure.ts --json
 */

interface FatePressureInput {
  powerLevel: number;
  tenureYears: number;
  vulnerabilities: string[];
  protections: string[];
  fortuneBuffer: number;
  exposureLog: { date: string; event: string; pressure: number }[];
}

interface FatePressureResult {
  components: {
    powerLevel: number;
    tenureModifier: number;
    vulnerabilityScore: number;
    protectionFactor: number;
    fortuneBuffer: number;
    riskExposure: number;
  };
  fatePressure: number;
  state: string;
  stateDescription: string;
  interpretation: string;
}

// Tenure modifiers based on duration
function getTenureModifier(years: number): number {
  if (years < 1) return 0.5;
  if (years <= 5) return 1.0;
  if (years <= 20) return 1.5;
  if (years <= 50) return 2.0;
  return 2.5;
}

// Calculate vulnerability score based on type keywords
function calculateVulnerabilityScore(vulnerabilities: string[]): number {
  let score = 0;
  for (const v of vulnerabilities) {
    const lower = v.toLowerCase();
    if (lower.includes("secret") || lower.includes("hidden")) {
      score += 3;
    } else if (lower.includes("flaw") || lower.includes("weakness") || lower.includes("addiction")) {
      score += 2;
    } else if (lower.includes("conflict") || lower.includes("war") || lower.includes("feud")) {
      score += 1.5;
    } else if (lower.includes("enemy") || lower.includes("rival") || lower.includes("opponent")) {
      score += 1;
    } else if (lower.includes("depends") || lower.includes("relies") || lower.includes("needs")) {
      score += 1;
    } else {
      score += 1; // Default weight
    }
  }
  return Math.min(score, 10);
}

// Calculate protection factor based on type keywords
function calculateProtectionFactor(protections: string[]): number {
  let factor = 1; // Base protection (everyone has at least 1)
  for (const p of protections) {
    const lower = p.toLowerCase();
    if (lower.includes("divine") || lower.includes("god") || lower.includes("blessed")) {
      factor += 3;
    } else if (lower.includes("magical") || lower.includes("enchant") || lower.includes("ward")) {
      factor += 3;
    } else if (lower.includes("fortif") || lower.includes("stronghold") || lower.includes("castle")) {
      factor += 2;
    } else if (lower.includes("popular") || lower.includes("beloved") || lower.includes("supported")) {
      factor += 2;
    } else if (lower.includes("ally") || lower.includes("loyal") || lower.includes("friend")) {
      factor += 1;
    } else if (lower.includes("network") || lower.includes("spies") || lower.includes("intelligence")) {
      factor += 1;
    } else {
      factor += 0.5; // Default weight
    }
  }
  return Math.min(factor, 10);
}

// Calculate total risk exposure from log
function calculateRiskExposure(
  exposureLog: { date: string; event: string; pressure: number }[]
): number {
  return exposureLog.reduce((sum, entry) => sum + entry.pressure, 0);
}

// Main calculation
function calculateFatePressure(input: FatePressureInput): FatePressureResult {
  const tenureModifier = getTenureModifier(input.tenureYears);
  const vulnerabilityScore = calculateVulnerabilityScore(input.vulnerabilities);
  const protectionFactor = calculateProtectionFactor(input.protections);
  const riskExposure = calculateRiskExposure(input.exposureLog);

  // Core formula:
  // (Power × TenureMod × VulnScore/10) / (ProtFactor × max(Fortune, 0.5)) + Exposure
  const numerator = input.powerLevel * tenureModifier * (vulnerabilityScore / 10);
  const denominator = protectionFactor * Math.max(input.fortuneBuffer, 0.5);
  let fatePressure = (numerator / denominator) + riskExposure;

  // Clamp to 0-1 range
  fatePressure = Math.min(Math.max(fatePressure, 0), 1);

  // Determine state
  let state: string;
  let stateDescription: string;
  let interpretation: string;

  if (fatePressure < 0.2) {
    state = "F1";
    stateDescription = "Stable Ascent";
    interpretation = "This entity is relatively stable. Monitor for changes but no immediate action needed.";
  } else if (fatePressure < 0.35) {
    state = "F2";
    stateDescription = "Peak Power";
    interpretation = "At peak influence. Consider surfacing hidden vulnerabilities or introducing rivals.";
  } else if (fatePressure < 0.6) {
    state = "F3";
    stateDescription = "Overextension";
    interpretation = "High pressure. Fate-shift likely if pressure continues. Consider Tier 2 choices.";
  } else if (fatePressure < 0.85) {
    state = "F4";
    stateDescription = "Precarious Position";
    interpretation = "Critical pressure. Fate-offered choices should be generated. Death rolls possible.";
  } else {
    state = "F5";
    stateDescription = "Fall in Progress";
    interpretation = "Terminal pressure. Focus on managing the transition and documenting the fall.";
  }

  return {
    components: {
      powerLevel: input.powerLevel,
      tenureModifier,
      vulnerabilityScore,
      protectionFactor,
      fortuneBuffer: input.fortuneBuffer,
      riskExposure,
    },
    fatePressure,
    state,
    stateDescription,
    interpretation,
  };
}

function formatResult(result: FatePressureResult, entityName?: string): string {
  const lines: string[] = [];

  lines.push(`FATE PRESSURE${entityName ? `: ${entityName}` : ""}`);
  lines.push("=".repeat(50));
  lines.push("");
  lines.push(`Current State: ${result.state} - ${result.stateDescription}`);
  lines.push(`Fate Pressure: ${(result.fatePressure * 100).toFixed(1)}%`);
  lines.push("");
  lines.push("COMPONENT BREAKDOWN");
  lines.push("-".repeat(50));
  lines.push(`  Power Level:        ${result.components.powerLevel}/10`);
  lines.push(`  Tenure Modifier:    ${result.components.tenureModifier}x`);
  lines.push(`  Vulnerability Score: ${result.components.vulnerabilityScore.toFixed(1)}/10`);
  lines.push(`  Protection Factor:   ${result.components.protectionFactor.toFixed(1)}/10`);
  lines.push(`  Fortune Buffer:      ${result.components.fortuneBuffer}/5`);
  lines.push(`  Risk Exposure:       +${(result.components.riskExposure * 100).toFixed(1)}%`);
  lines.push("");
  lines.push("INTERPRETATION");
  lines.push("-".repeat(50));
  lines.push(`  ${result.interpretation}`);
  lines.push("");

  // Add specific recommendations based on state
  lines.push("RECOMMENDATIONS");
  lines.push("-".repeat(50));

  if (result.fatePressure < 0.3) {
    lines.push("  - Log exposure events as they occur");
    lines.push("  - Re-assess after significant events");
  } else if (result.fatePressure < 0.6) {
    lines.push("  - Consider fate-choice.ts for dramatic moments");
    lines.push("  - Track vulnerabilities carefully");
    lines.push("  - Fate-shifts at Moderate or Minor severity possible");
  } else if (result.fatePressure < 0.85) {
    lines.push("  - Run fate-choice.ts to generate Tier 2 choice");
    lines.push("  - Death/fall rolls active if in danger");
    lines.push("  - Consider voluntary NPC transition option");
  } else {
    lines.push("  - Fall is in progress or imminent");
    lines.push("  - Run propose-shift.ts to document the end");
    lines.push("  - Focus on managing consequences for world");
  }

  return lines.join("\n");
}

function showUsage() {
  console.log(`
Fate Pressure Calculator
========================

Calculates fate pressure for entities based on power, tenure,
vulnerabilities, protections, fortune, and exposure.

Usage:
  deno run --allow-read fate-pressure.ts [options]

Options:
  --power <n>       Power level (1-10, default: 5)
  --tenure <years>  Years in power (default: 5)
  --vulns <n>       Number of vulnerabilities (default: 0)
  --prots <n>       Number of protections (default: 0)
  --fortune <n>     Fortune buffer (0-5, default: 3)
  --exposure <n>    Accumulated exposure (0-1, default: 0)
  --name <name>     Entity name for output
  --json            Output as JSON

Examples:
  deno run --allow-read fate-pressure.ts --power 7 --tenure 40 --vulns 5 --prots 3 --fortune 2
  deno run --allow-read fate-pressure.ts --power 9 --tenure 100 --vulns 8 --fortune 0 --name "The Eternal Emperor"

Formula:
  Pressure = (Power × TenureMod × VulnScore/10) / (ProtFactor × Fortune) + Exposure

Tenure Modifiers:
  < 1 year:   0.5x
  1-5 years:  1.0x
  5-20 years: 1.5x
  20-50 years: 2.0x
  50+ years:  2.5x

States:
  F1 (0-20%):  Stable Ascent
  F2 (20-35%): Peak Power
  F3 (35-60%): Overextension
  F4 (60-85%): Precarious Position
  F5 (85%+):  Fall in Progress
`);
}

function main() {
  const args = Deno.args;

  if (args.includes("--help") || args.includes("-h")) {
    showUsage();
    Deno.exit(0);
  }

  // Parse arguments
  let power = 5;
  let tenure = 5;
  let vulnCount = 0;
  let protCount = 0;
  let fortune = 3;
  let exposure = 0;
  let name = "";
  let jsonOutput = false;

  for (let i = 0; i < args.length; i++) {
    switch (args[i]) {
      case "--power":
        power = parseInt(args[++i]) || 5;
        break;
      case "--tenure":
        tenure = parseInt(args[++i]) || 5;
        break;
      case "--vulns":
        vulnCount = parseInt(args[++i]) || 0;
        break;
      case "--prots":
        protCount = parseInt(args[++i]) || 0;
        break;
      case "--fortune":
        fortune = parseFloat(args[++i]) ?? 3;
        break;
      case "--exposure":
        exposure = parseFloat(args[++i]) || 0;
        break;
      case "--name":
        name = args[++i] || "";
        break;
      case "--json":
        jsonOutput = true;
        break;
    }
  }

  // Clamp values
  power = Math.min(Math.max(power, 1), 10);
  fortune = Math.min(Math.max(fortune, 0), 5);
  exposure = Math.min(Math.max(exposure, 0), 1);

  // Create synthetic vulnerabilities and protections
  const vulnerabilities: string[] = [];
  for (let i = 0; i < vulnCount; i++) {
    vulnerabilities.push(`vulnerability_${i + 1}`);
  }

  const protections: string[] = [];
  for (let i = 0; i < protCount; i++) {
    protections.push(`protection_${i + 1}`);
  }

  // Create exposure log entry if exposure provided
  const exposureLog: { date: string; event: string; pressure: number }[] = [];
  if (exposure > 0) {
    exposureLog.push({
      date: new Date().toISOString().split("T")[0],
      event: "Accumulated exposure",
      pressure: exposure,
    });
  }

  const input: FatePressureInput = {
    powerLevel: power,
    tenureYears: tenure,
    vulnerabilities,
    protections,
    fortuneBuffer: fortune,
    exposureLog,
  };

  const result = calculateFatePressure(input);

  if (jsonOutput) {
    console.log(JSON.stringify({ name: name || undefined, ...result }, null, 2));
  } else {
    console.log(formatResult(result, name || undefined));
  }
}

main();

#!/usr/bin/env -S deno run --allow-read

/**
 * Fate Roll - The Wheel of Fortune
 *
 * Rolls against fate pressure to determine if a fate-shift occurs.
 * Uses weighted probability based on accumulated pressure.
 *
 * Usage:
 *   deno run --allow-read fate-roll.ts --pressure 0.65
 *   deno run --allow-read fate-roll.ts --pressure 0.75 --danger --fortune 0
 *   deno run --allow-read fate-roll.ts --pressure 0.80 --danger --fortune 0 --name "Kaira the Bold"
 *   deno run --allow-read fate-roll.ts --seed 12345 --pressure 0.65
 */

interface FateRollResult {
  roll: number;
  threshold: number;
  shiftTriggered: boolean;
  severity: "none" | "minor" | "moderate" | "major" | "catastrophic";
  deathEligible: boolean;
  deathRoll?: number;
  deathThreshold?: number;
  deathOccurs?: boolean;
  fortuneDecrement?: boolean;
}

// Seeded random for reproducibility
class SeededRandom {
  private seed: number;

  constructor(seed: number) {
    this.seed = seed;
  }

  next(): number {
    this.seed = (this.seed * 1103515245 + 12345) & 0x7fffffff;
    return this.seed / 0x7fffffff;
  }

  d100(): number {
    return Math.floor(this.next() * 100) + 1;
  }
}

function rollFate(
  fatePressure: number,
  inDanger: boolean,
  fortuneBuffer: number,
  rng: SeededRandom
): FateRollResult {
  const roll = rng.d100();
  const threshold = fatePressure * 100;
  const shiftTriggered = roll < threshold;

  let severity: FateRollResult["severity"] = "none";
  if (shiftTriggered) {
    if (roll < threshold * 0.25) {
      severity = "catastrophic";
    } else if (roll < threshold * 0.50) {
      severity = "major";
    } else if (roll < threshold * 0.75) {
      severity = "moderate";
    } else {
      severity = "minor";
    }
  }

  // Death eligibility: in danger + pressure > 0.5 + fortune < 1
  const deathEligible = inDanger && fatePressure > 0.5 && fortuneBuffer < 1;

  let deathRoll: number | undefined;
  let deathThreshold: number | undefined;
  let deathOccurs: boolean | undefined;
  let fortuneDecrement: boolean | undefined;

  if (deathEligible && shiftTriggered) {
    deathRoll = rng.next();
    // Death threshold: (pressure - 0.5) × 2 × (1 - fortune/5)
    deathThreshold = (fatePressure - 0.5) * 2 * (1 - fortuneBuffer / 5);
    deathOccurs = deathRoll < deathThreshold;

    // If death avoided, fortune decreases
    if (!deathOccurs) {
      fortuneDecrement = true;
    }
  }

  return {
    roll,
    threshold,
    shiftTriggered,
    severity,
    deathEligible,
    deathRoll,
    deathThreshold,
    deathOccurs,
    fortuneDecrement,
  };
}

function formatRollResult(result: FateRollResult, entityName?: string): string {
  const lines: string[] = [];

  lines.push(`FATE ROLL${entityName ? `: ${entityName}` : ""}`);
  lines.push("=".repeat(50));
  lines.push("");
  lines.push(`Roll: ${result.roll} vs Threshold ${result.threshold.toFixed(0)}`);
  lines.push("");

  if (result.shiftTriggered) {
    lines.push("THE WHEEL TURNS");
    lines.push("-".repeat(50));
    lines.push(`Fate-shift triggered. Severity: ${result.severity.toUpperCase()}`);
    lines.push("");

    switch (result.severity) {
      case "catastrophic":
        lines.push("The wheel turns heavily. A catastrophic fate-shift is warranted.");
        lines.push("Consider: death, complete fall, total collapse, destruction.");
        break;
      case "major":
        lines.push("A major turn of the wheel. Significant consequences follow.");
        lines.push("Consider: serious wound, major loss, significant decline, defeat.");
        break;
      case "moderate":
        lines.push("The wheel moves. A moderate setback occurs.");
        lines.push("Consider: vulnerability exposed, resource lost, ally turns.");
        break;
      case "minor":
        lines.push("A warning from fate. Minor consequences manifest.");
        lines.push("Consider: reputation damage, small loss, omen of worse to come.");
        break;
    }

    if (result.deathEligible) {
      lines.push("");
      lines.push("DEATH ROLL");
      lines.push("-".repeat(50));
      lines.push("Death eligibility: YES (in danger, pressure > 50%, fortune depleted)");
      lines.push(
        `Death roll: ${(result.deathRoll! * 100).toFixed(1)}% vs threshold ${(result.deathThreshold! * 100).toFixed(1)}%`
      );

      if (result.deathOccurs) {
        lines.push("");
        lines.push("*** DEATH OCCURS ***");
        lines.push("The wheel of fate turns completely. The entity meets their end.");
        lines.push("");
        lines.push("Next steps:");
        lines.push("  1. Run propose-shift.ts to generate death proposal");
        lines.push("  2. Determine narrative hook for the death");
        lines.push("  3. Submit for human approval");
      } else {
        lines.push("");
        lines.push("Death avoided. Fate grants a reprieve this time.");
        if (result.fortuneDecrement) {
          lines.push("Fortune buffer should decrease by 1 (narrow escape).");
        }
      }
    }
  } else {
    lines.push("THE WHEEL HOLDS");
    lines.push("-".repeat(50));
    lines.push("No fate-shift triggered. The entity continues.");
    lines.push("");
    lines.push("Pressure continues to accumulate unless addressed.");
    lines.push("Re-roll at next trigger point (session end, arc completion, etc.).");
  }

  lines.push("");
  lines.push("NEXT STEPS");
  lines.push("-".repeat(50));
  if (result.shiftTriggered) {
    lines.push("1. Determine appropriate shift type based on severity");
    lines.push("2. Consider running fate-choice.ts for Tier 2 choice");
    lines.push("3. Run propose-shift.ts to generate formal proposal");
    lines.push("4. Submit for human approval before applying");
  } else {
    lines.push("1. Continue tracking exposure events");
    lines.push("2. Update vulnerability/protection if changed");
    lines.push("3. Re-roll at next trigger point");
  }

  return lines.join("\n");
}

function showUsage() {
  console.log(`
Fate Roll - The Wheel of Fortune
=================================

Rolls against fate pressure to determine if a fate-shift occurs.

Usage:
  deno run --allow-read fate-roll.ts [options]

Options:
  --pressure <0-1>  Fate pressure (required)
  --danger          Entity is in active danger (enables death roll)
  --fortune <0-5>   Fortune buffer (default: 3)
  --name <name>     Entity name for output
  --seed <n>        Random seed for reproducibility
  --json            Output as JSON

Examples:
  deno run --allow-read fate-roll.ts --pressure 0.65
  deno run --allow-read fate-roll.ts --pressure 0.75 --danger --fortune 0
  deno run --allow-read fate-roll.ts --pressure 0.80 --danger --fortune 0 --name "Kaira"

Mechanics:
  - Roll d100 vs (pressure × 100)
  - If roll < threshold: fate-shift triggered

Severity (based on roll vs threshold):
  < 25%: Catastrophic
  < 50%: Major
  < 75%: Moderate
  < 100%: Minor

Death Eligibility (all required):
  - Entity in danger (--danger flag)
  - Fate pressure > 0.5
  - Fortune buffer < 1

Death Threshold:
  (pressure - 0.5) × 2 × (1 - fortune/5)
`);
}

function main() {
  const args = Deno.args;

  if (args.includes("--help") || args.includes("-h")) {
    showUsage();
    Deno.exit(0);
  }

  // Parse arguments
  let pressure = -1;
  let danger = false;
  let fortune = 3;
  let name = "";
  let seed = Date.now();
  let jsonOutput = false;

  for (let i = 0; i < args.length; i++) {
    switch (args[i]) {
      case "--pressure":
        pressure = parseFloat(args[++i]) || -1;
        break;
      case "--danger":
        danger = true;
        break;
      case "--fortune":
        fortune = parseFloat(args[++i]) ?? 3;
        break;
      case "--name":
        name = args[++i] || "";
        break;
      case "--seed":
        seed = parseInt(args[++i]) || Date.now();
        break;
      case "--json":
        jsonOutput = true;
        break;
    }
  }

  if (pressure < 0 || pressure > 1) {
    console.error("Error: --pressure required (value between 0 and 1)");
    console.error("Example: --pressure 0.65");
    Deno.exit(1);
  }

  // Clamp fortune
  fortune = Math.min(Math.max(fortune, 0), 5);

  const rng = new SeededRandom(seed);
  const result = rollFate(pressure, danger, fortune, rng);

  if (jsonOutput) {
    console.log(
      JSON.stringify(
        {
          name: name || undefined,
          fatePressure: pressure,
          inDanger: danger,
          fortuneBuffer: fortune,
          seed,
          ...result,
        },
        null,
        2
      )
    );
  } else {
    console.log(formatRollResult(result, name || undefined));
  }
}

main();