@g3nomaly/g3n-mods 0.1.7 → 0.1.8

package/.claude-plugin/marketplace.json

@@ -4,6 +4,12 @@
     "name": "g3ntrovert"
   },
   "plugins": [
+    {
+      "name": "agent-adventure",
+      "source": "./mods/agent-adventure",
+      "description": "An idle roguelike in a pane: each running agent fights as a hero, and the party rests in the tavern when none run.",
+      "version": "0.1.0"
+    },
     {
       "name": "agents-panel",
       "source": "./mods/agents-panel",
@@ -61,7 +67,7 @@
     {
       "name": "you-should-know",
       "source": "./mods/you-should-know",
-      "description": "A card under long replies that flags their key point: a headline and one supporting line.",
+      "description": "A compact card under a reply: the questions it asks you word for word, and for long replies what changed and what it concluded, each line tagged.",
       "version": "0.1.0"
     }
   ]

package/README.md

@@ -20,6 +20,7 @@ Then open the project in VS Code and trust the workspace. New sessions load the
 
 | Mod | What it does | Command |
 |---|---|---|
+| `agent-adventure` | An idle roguelike to watch while agents work. Each running agent fights as a hero: the main thread and every subagent. With none running, the heroes rest in the tavern. A run is a dungeon of fights, two forks (a safe trail or a dangerous one with double XP and a relic), a camp and a boss. Heroes keep their level, skills and trophies between runs. A party wipe costs every hero 5 levels. Every 10 levels a hero picks one of two skills, up to three. Haiku names new heroes and makes the picks. Agents can name their own hero with the `hero` tool, which is cosmetic only. The game never changes what agents do | `/agent-adventure` |
 | `agents-panel` | The agents in `.claude/agents` with their model and a run button. A running agent shows a spinner, and a toast says when it starts and finishes | `/agents-panel` |
 | `context-bar` | One bar of context-window use split by source, with the total and where compaction starts | `/context-bar` |
 | `custom-crab-agents` | Adds each subagent to the agents panel as a crab drawn as Claude's mascot, walking while it works and blinking when done: its role (from its name or type) picks its hat and what it holds, such as a reviewer's deerstalker and magnifying glass, a tester's work helmet and wrench, a designer's top hat and brush. Shows model, effort, steps, context, tokens, cost and time. Click anywhere on a crab to open its whole conversation in a tab and message it there. Needs `agents-panel`, which installing it adds | `/agents-panel` |
@@ -29,15 +30,19 @@ Then open the project in VS Code and trust the workspace. New sessions load the
 | `hide-personal-data` | Masks names, emails, phone numbers, IBANs and card numbers in replies. Hover a mask to read it | `/hide-personal-data on \| off` |
 | `mini-game` | Minesweeper, or whack-a-mole when you want zero thinking: hit the mole before it hides, three misses and the round ends, and it speeds up as you score. Both keep a high score. Switch games with the tabs in its pane | `/mini-game [mines \| mole]` |
 | `tool-timeline` | The last ten tool calls, one line each, with their durations, in a pane that keeps one height. Click a call to see it in full in the box under them. A denied call is struck through, next to the call that replaced it | `/tool-timeline` |
-| `you-should-know` | A card under long replies with their key point, a headline and one supporting line. It costs one small Haiku call per reply of 1500 characters or more | none |
+| `you-should-know` | A compact card under a reply, one tagged line per point. **QUESTION** lines quote the questions the reply asks you, word for word. **CHANGE**, **CONCLUSION** and **FACT** lines come from one small Haiku call that reads your request beside the reply: what was added, removed or changed, the direct answer to what you asked, and costs or decisions only, never caveats. It runs only for replies of 800 characters or more | none |
 
-For `agents-panel`, `context-bar` and `tool-timeline`, the command opens the pane and running it again closes it.
+Every mod with a pane shows it in the mods viewer. Only `context-bar` also opens it in the Claude Code chat when a session starts. Each pane mod has a `showInClaudeCode` option, **Show in Claude Code** in `/config`, that turns this on or off. A mod's command opens its pane in the chat whatever the option says, and for `agents-panel`, `context-bar` and `tool-timeline` running it again closes it there. A `delete-guard` card waiting on an answer also opens in the chat, and leaves once answered.
 
-Three mods take settings, declared under `userConfig` in their `.claude-plugin/plugin.json`:
+Mods take settings, declared under `userConfig` in their `.claude-plugin/plugin.json`:
+
+- `agent-adventure`, `agents-panel`, `context-bar`, `delete-guard`, `focus-mode`, `mini-game` and `tool-timeline`: `showInClaudeCode`, whether the pane opens in the Claude Code chat at session start (on for `context-bar` only).
+
+- `agent-adventure`: `model`, the model that names heroes and picks skills and routes (`haiku`); `off` uses the game's own picks.
 
 - `focus-mode`: `minutes`, the block length before you pick one (25).
 - `hide-personal-data`: `names`, extra names to always mask, separated by commas.
-- `you-should-know`: `minChars`, the shortest reply that gets a card (1500), and `model`, the model that picks the key point (`haiku`).
+- `you-should-know`: `minChars`, the shortest reply Haiku reads for changes, conclusions and facts (800); questions get a card at any length, and `model`, the model that picks the key point (`haiku`).
 
 ## Requirements
 
@@ -57,6 +62,7 @@ mods/<name>/
 ├── hooks/register.tsx           # exports `register`
 ├── types/index.d.ts
 └── view/                        # optional: how the VS Code viewer draws it
+    ├── panes.json               # { "panes": [{ "id", "title" }] }: the panes the viewer shows
     ├── view.ts                  # exports `mount(root, api)`
     └── view.css
 ```
@@ -65,7 +71,7 @@ mods/<name>/
 
 On every surface but the VS Code viewer, a mod draws with the engine's elements (`Box`, `Text`, `Button`, `Svg`). In the viewer it can draw with its own HTML and CSS instead, as `tool-timeline`, `agents-panel` and `custom-crab-agents` do:
 
-1. **The hook hands over data.** On `e.surface === 'vscode'`, the render hook returns a view box: a `Box` keyed `g3n-view:<mod>` holding the data as JSON in one `Text`, and a hidden `Input` keyed `g3n-act:<mod>` that receives the view's actions.
+1. **The hook hands over data.** When the viewer draws the pane, the render hook returns a view box: a `Box` keyed `g3n-view:<mod>` holding the data as JSON in one `Text`, and a hidden `Input` keyed `g3n-act:<mod>` that receives the view's actions. The viewer's relay sets the prop `g3nViewer: true` on every pane the viewer draws. The Claude Code extension draws on the `vscode` surface too but never sets it, so check both: `e.surface === 'vscode'` and `e.props.g3nViewer === true`.
 2. **The view draws it.** `view/view.ts` exports `mount(root, api)`. `root` is a shadow root of the mod's own, so `view.css` applies only there and the editor's theme variables still reach it. `mount` returns `{ update(data) }`, which gets the data each time the pane is drawn. Keep elements across updates, and animations and anything typed in the view keep going.
 3. **Actions go back to the hook.** `api.act(name, arg)` arrives at the hidden Input's `onSubmit` as JSON of `{ name, arg }`.
 
@@ -80,6 +86,7 @@ Run `bun install` at the repository root first, then these from `packages/g3n-mo
 ```sh
 bun run build       # rewrites .claude-plugin/marketplace.json from each mod's plugin.json
 bun run typecheck
+bun run test        # the tests in tests/, such as agent-adventure's game rules
 bun run validate    # runs `claude plugin validate` on every mod
 bun run types       # copies the mod API types into types/claude-code.d.ts
 ```

package/mods/agent-adventure/.claude-plugin/plugin.json

@@ -0,0 +1,23 @@
+{
+  "name": "agent-adventure",
+  "version": "0.1.0",
+  "description": "An idle roguelike in a pane: each running agent fights as a hero, and the party rests in the tavern when none run.",
+  "author": {
+    "name": "g3ntrovert"
+  },
+  "types": "./types/index.d.ts",
+  "userConfig": {
+    "showInClaudeCode": {
+      "type": "boolean",
+      "title": "Show in Claude Code",
+      "default": false,
+      "description": "Open this mod's pane in the Claude Code chat when a session starts. The mods viewer shows it either way."
+    },
+    "model": {
+      "type": "string",
+      "title": "Model",
+      "default": "haiku",
+      "description": "Model that names new heroes, picks skills and routes. off for the game's own picks"
+    }
+  }
+}

package/mods/agent-adventure/hooks/content.ts

@@ -0,0 +1,263 @@
+// packages/g3n-mods/mods/agent-adventure/hooks/content.ts
+import type { ClassId, RegionId, SkillDef, StatId } from '../types'
+
+/**
+ * The game's tables: classes, skills, enemies, regions and relics. Plain data only, so the engine, the hooks module
+ * and the view can all import it.
+ */
+
+/** Stats at level 1 and their growth per level. Crit and evade are chances from 0 to 1 and do not grow. */
+type Stats = { hp: number; atk: number; def: number; spd: number; crit: number; evade: number }
+
+export type ClassDef = {
+  name: string
+  /** One line on how it fights */
+  role: string
+  base: Stats
+  growth: Omit<Stats, 'spd' | 'crit' | 'evade'>
+  basic: SkillDef
+  /** The skills it can be offered, two at a time, every 10 levels */
+  pool: SkillDef[]
+  /** An effect it starts every fight with */
+  opening?: { kind: 'taunt'; turns: number }
+}
+
+/** Builds a skill; `id` is the class or enemy prefix and the name. */
+function skill(prefix: string, name: string, kind: SkillDef['kind'], power: number, cd: number, blurb: string, extra: Partial<SkillDef> = {}): SkillDef {
+  return { id: `${prefix}.${name.toLowerCase().replace(/[^a-z]+/g, '-')}`, name, kind, power, cd, blurb, ...extra }
+}
+
+/** Builds a passive skill that raises `stat`. */
+function passive(prefix: string, name: string, stat: StatId, power: number, blurb: string): SkillDef {
+  return skill(prefix, name, 'passive', power, 0, blurb, { stat })
+}
+
+export const CLASSES: Readonly<Record<ClassId, ClassDef>> = {
+  fighter: {
+    name: 'Fighter',
+    role: 'Durable front line with heavy blows',
+    base: { hp: 44, atk: 8, def: 5, spd: 5, crit: 0.06, evade: 0.03 },
+    growth: { hp: 7, atk: 1.5, def: 0.9 },
+    basic: skill('fighter', 'Slash', 'strike', 1, 0, 'A solid sword swing'),
+    pool: [
+      skill('fighter', 'Cleave', 'cleave', 0.75, 3, 'Hits every enemy'),
+      skill('fighter', 'Power Strike', 'strike', 2.1, 3, 'One crushing blow'),
+      skill('fighter', 'Second Wind', 'healSelf', 0.3, 5, 'Recovers 30% HP'),
+      skill('fighter', 'Battle Cry', 'rally', 0.2, 5, 'Party deals 20% more damage', { turns: 3 }),
+      skill('fighter', 'Shield Bash', 'stun', 0.8, 4, 'Hits and stuns'),
+      passive('fighter', 'Iron Skin', 'def', 0.25, '+25% defense'),
+    ],
+  },
+  healer: {
+    name: 'Healer',
+    role: 'Mends wounds and raises the fallen',
+    base: { hp: 34, atk: 6, def: 3, spd: 5, crit: 0.04, evade: 0.05 },
+    growth: { hp: 5, atk: 1.2, def: 0.5 },
+    basic: skill('healer', 'Mend', 'mend', 0.24, 0, 'Heals the most hurt ally, or smites when no one is'),
+    pool: [
+      skill('healer', 'Prayer', 'healAll', 0.18, 4, 'Heals the whole party'),
+      skill('healer', 'Resurrect', 'revive', 0.4, 6, 'Raises a fallen ally'),
+      skill('healer', 'Sanctuary', 'shield', 0.3, 5, 'Party takes 30% less damage', { turns: 2 }),
+      skill('healer', 'Holy Light', 'strike', 1.8, 3, 'A searing beam'),
+      skill('healer', 'Blessing', 'rally', 0.15, 5, 'Party deals 15% more damage', { turns: 3 }),
+      passive('healer', 'Grace', 'hp', 0.2, '+20% max HP'),
+    ],
+  },
+  monk: {
+    name: 'Monk',
+    role: 'Quick combos and hard to hit',
+    base: { hp: 38, atk: 7, def: 3, spd: 6, crit: 0.08, evade: 0.12 },
+    growth: { hp: 6, atk: 1.4, def: 0.6 },
+    basic: skill('monk', 'Palm', 'multi', 0.55, 0, 'Two quick strikes', { hits: 2 }),
+    pool: [
+      skill('monk', 'Flurry', 'multi', 0.5, 3, 'Four strikes on random enemies', { hits: 4 }),
+      skill('monk', 'Stunning Fist', 'stun', 1, 4, 'Hits and stuns'),
+      skill('monk', 'Inner Peace', 'healSelf', 0.35, 5, 'Recovers 35% HP'),
+      skill('monk', 'Tiger Strike', 'strike', 1.9, 3, 'One fierce blow'),
+      skill('monk', 'Chi Wave', 'cleave', 0.6, 3, 'Hits every enemy'),
+      passive('monk', 'Wind Step', 'evade', 0.1, '+10% evasion'),
+    ],
+  },
+  ranger: {
+    name: 'Ranger',
+    role: 'Accurate shots from range',
+    base: { hp: 32, atk: 8, def: 2, spd: 6, crit: 0.15, evade: 0.06 },
+    growth: { hp: 5, atk: 1.5, def: 0.4 },
+    basic: skill('ranger', 'Shot', 'strike', 1, 0, 'An arrow at one enemy'),
+    pool: [
+      skill('ranger', 'Volley', 'cleave', 0.65, 3, 'Arrows on every enemy'),
+      skill('ranger', 'Aimed Shot', 'strike', 2.2, 4, 'One careful, heavy shot'),
+      skill('ranger', 'Poison Arrow', 'burn', 0.35, 3, 'Hits and poisons', { turns: 3 }),
+      skill('ranger', 'Snare', 'stun', 0.6, 4, 'Hits and roots'),
+      skill('ranger', 'Rapid Fire', 'multi', 0.6, 3, 'Three quick arrows', { hits: 3 }),
+      passive('ranger', 'Hawk Eye', 'crit', 0.15, '+15% critical chance'),
+    ],
+  },
+  mage: {
+    name: 'Mage',
+    role: 'Area damage, fragile',
+    base: { hp: 28, atk: 9, def: 1.5, spd: 5, crit: 0.08, evade: 0.04 },
+    growth: { hp: 4, atk: 1.8, def: 0.3 },
+    basic: skill('mage', 'Bolt', 'strike', 1.1, 0, 'A crackling bolt'),
+    pool: [
+      skill('mage', 'Fireball', 'cleave', 0.9, 3, 'Burns every enemy'),
+      skill('mage', 'Ignite', 'burn', 0.5, 3, 'Sets one enemy alight', { turns: 3 }),
+      skill('mage', 'Arcane Blast', 'strike', 2.4, 4, 'One huge blast'),
+      skill('mage', 'Chain Lightning', 'multi', 0.8, 3, 'Three arcs on random enemies', { hits: 3 }),
+      skill('mage', 'Mana Shield', 'shield', 0.25, 5, 'Party takes 25% less damage', { turns: 2 }),
+      passive('mage', 'Arcane Mind', 'atk', 0.2, '+20% attack'),
+    ],
+  },
+  guardian: {
+    name: 'Guardian',
+    role: 'Draws attacks and shields allies',
+    base: { hp: 52, atk: 6, def: 6, spd: 4, crit: 0.04, evade: 0.02 },
+    growth: { hp: 8, atk: 1.1, def: 1.1 },
+    basic: skill('guardian', 'Bash', 'strike', 0.85, 0, 'A shield to the face'),
+    opening: { kind: 'taunt', turns: 2 },
+    pool: [
+      skill('guardian', 'Provoke', 'taunt', 0.3, 4, 'Draws every attack and braces', { turns: 3 }),
+      skill('guardian', 'Bulwark', 'shield', 0.35, 5, 'Party takes 35% less damage', { turns: 2 }),
+      skill('guardian', 'Lay On Hands', 'heal', 0.3, 4, 'Heals the most hurt ally'),
+      skill('guardian', 'Earthshaker', 'cleave', 0.6, 4, 'Hits every enemy'),
+      skill('guardian', 'Rally Banner', 'rally', 0.15, 5, 'Party deals 15% more damage', { turns: 3 }),
+      passive('guardian', 'Shield Wall', 'def', 0.3, '+30% defense'),
+    ],
+  },
+  rogue: {
+    name: 'Rogue',
+    role: 'Fast, critical single-target damage',
+    base: { hp: 32, atk: 8, def: 2, spd: 7, crit: 0.2, evade: 0.1 },
+    growth: { hp: 5, atk: 1.6, def: 0.4 },
+    basic: skill('rogue', 'Stab', 'strike', 1, 0, 'A quick dagger'),
+    pool: [
+      skill('rogue', 'Backstab', 'strike', 2.5, 4, 'A vicious strike'),
+      skill('rogue', 'Fan of Knives', 'cleave', 0.6, 3, 'Knives at every enemy'),
+      skill('rogue', 'Toxin', 'burn', 0.4, 3, 'Hits and poisons', { turns: 3 }),
+      skill('rogue', 'Cheap Shot', 'stun', 0.7, 4, 'Hits and stuns'),
+      skill('rogue', 'Flurry of Blades', 'multi', 0.7, 3, 'Three cuts on random enemies', { hits: 3 }),
+      passive('rogue', 'Shadowstep', 'evade', 0.12, '+12% evasion'),
+    ],
+  },
+}
+
+export const CLASS_IDS = Object.keys(CLASSES) as ClassId[]
+
+/** Every learnable skill by id. */
+export const SKILLS: Readonly<Record<string, SkillDef>> = Object.fromEntries(
+  CLASS_IDS.flatMap(cls => CLASSES[cls].pool).map(one => [one.id, one]),
+)
+
+/** Most skills a hero holds, besides its basic action. */
+export const MAX_SKILLS = 3
+
+/** An enemy kind: its stats as multiples of the level baseline, and an optional special. */
+export type EnemyDef = {
+  name: string
+  hp: number
+  atk: number
+  def: number
+  spd: number
+  crit: number
+  evade: number
+  basic: SkillDef
+  special?: SkillDef
+}
+
+/** A boss: an enemy with a second phase below half HP. */
+export type BossDef = EnemyDef & { phase2: { line: string; atkPct: number; special: SkillDef } }
+
+const hit = (prefix: string, name: string) => skill(prefix, name, 'strike', 1, 0, '')
+
+export const ENEMIES: Readonly<Record<string, EnemyDef>> = {
+  slime: { name: 'Slime', hp: 1.1, atk: 0.8, def: 0.6, spd: 3, crit: 0.03, evade: 0, basic: hit('slime', 'Squelch') },
+  wolf: { name: 'Wolf', hp: 0.8, atk: 1.05, def: 0.8, spd: 7, crit: 0.12, evade: 0.08, basic: hit('wolf', 'Bite') },
+  goblin: { name: 'Goblin', hp: 0.9, atk: 1, def: 1, spd: 5, crit: 0.06, evade: 0.05, basic: hit('goblin', 'Stab') },
+  shaman: {
+    name: 'Goblin Shaman', hp: 0.9, atk: 0.9, def: 0.9, spd: 5, crit: 0.05, evade: 0.05, basic: hit('shaman', 'Zap'),
+    special: skill('shaman', 'Hex Mend', 'heal', 0.3, 3, ''),
+  },
+  bat: { name: 'Cave Bat', hp: 0.6, atk: 0.9, def: 0.5, spd: 8, crit: 0.08, evade: 0.15, basic: hit('bat', 'Screech') },
+  spider: {
+    name: 'Spider', hp: 0.85, atk: 0.9, def: 0.8, spd: 6, crit: 0.06, evade: 0.06, basic: hit('spider', 'Bite'),
+    special: skill('spider', 'Venom', 'burn', 0.35, 3, '', { turns: 3 }),
+  },
+  golem: { name: 'Rock Golem', hp: 1.5, atk: 1.1, def: 1.6, spd: 2, crit: 0.02, evade: 0, basic: hit('golem', 'Pound') },
+  skeleton: { name: 'Skeleton', hp: 0.9, atk: 1, def: 1.1, spd: 5, crit: 0.06, evade: 0.04, basic: hit('skeleton', 'Rattle Slash') },
+  ghost: { name: 'Ghost', hp: 0.7, atk: 0.95, def: 0.4, spd: 6, crit: 0.05, evade: 0.22, basic: hit('ghost', 'Chill Touch') },
+  cultist: {
+    name: 'Cultist', hp: 0.85, atk: 1, def: 0.8, spd: 5, crit: 0.05, evade: 0.05, basic: hit('cultist', 'Dark Bolt'),
+    special: skill('cultist', 'Hellfire', 'burn', 0.45, 3, '', { turns: 2 }),
+  },
+  knight: {
+    name: 'Bone Knight', hp: 1.3, atk: 1.15, def: 1.5, spd: 4, crit: 0.06, evade: 0.03, basic: hit('knight', 'Cleaver'),
+    special: skill('knight', 'Sweep', 'cleave', 0.7, 3, ''),
+  },
+}
+
+export const BOSSES: Readonly<Record<string, BossDef>> = {
+  goblinKing: {
+    name: 'Grub the Goblin King', hp: 1, atk: 1, def: 1.1, spd: 4, crit: 0.08, evade: 0.04, basic: hit('king', 'Club'),
+    special: skill('king', 'Ground Slam', 'cleave', 0.8, 3, ''),
+    phase2: { line: 'Grub throws his crown aside and roars!', atkPct: 0.3, special: skill('king', 'Frenzy', 'multi', 0.7, 2, '', { hits: 3 }) },
+  },
+  wyrm: {
+    name: 'The Crystal Wyrm', hp: 1.1, atk: 1, def: 1.3, spd: 4, crit: 0.06, evade: 0.03, basic: hit('wyrm', 'Claw'),
+    special: skill('wyrm', 'Shard Breath', 'cleave', 0.85, 3, ''),
+    phase2: { line: 'The Wyrm\'s crystals blaze with light!', atkPct: 0.25, special: skill('wyrm', 'Prism Beam', 'burn', 0.6, 2, '', { turns: 3 }) },
+  },
+  lich: {
+    name: 'The Lich', hp: 0.95, atk: 1.1, def: 0.9, spd: 5, crit: 0.06, evade: 0.08, basic: hit('lich', 'Soul Bolt'),
+    special: skill('lich', 'Life Drain', 'drain', 1.2, 3, ''),
+    phase2: { line: 'The Lich\'s phylactery cracks; death pours out!', atkPct: 0.3, special: skill('lich', 'Death Nova', 'cleave', 0.9, 2, '') },
+  },
+}
+
+export type RegionDef = { name: string; enemies: string[]; elites: string[]; boss: keyof typeof BOSSES }
+
+export const REGIONS: Readonly<Record<RegionId, RegionDef>> = {
+  woods: { name: 'Mossy Woods', enemies: ['slime', 'wolf', 'goblin'], elites: ['shaman', 'wolf'], boss: 'goblinKing' },
+  caves: { name: 'Echo Caves', enemies: ['bat', 'spider', 'golem'], elites: ['golem', 'spider'], boss: 'wyrm' },
+  crypt: { name: 'Sunken Crypt', enemies: ['skeleton', 'ghost', 'cultist'], elites: ['knight', 'cultist'], boss: 'lich' },
+}
+
+export const REGION_IDS = Object.keys(REGIONS) as RegionId[]
+
+/** A run-only relic: a party-wide bonus until the run ends. */
+export type RelicDef = {
+  name: string
+  icon: string
+  blurb: string
+  atkPct?: number
+  defPct?: number
+  spd?: number
+  crit?: number
+  /** Share of max HP healed at the start of each own turn */
+  regen?: number
+  /** Once per run, a wipe raises the party instead */
+  isFeather?: boolean
+}
+
+export const RELICS: Readonly<Record<string, RelicDef>> = {
+  ember: { name: 'Ember Charm', icon: '🔥', blurb: '+15% attack', atkPct: 0.15 },
+  oak: { name: 'Oak Ward', icon: '🌳', blurb: '+20% defense', defPct: 0.2 },
+  boots: { name: 'Swift Boots', icon: '👢', blurb: '+1 speed', spd: 1 },
+  moss: { name: 'Mending Moss', icon: '🌿', blurb: 'Heal 3% HP each turn', regen: 0.03 },
+  coin: { name: 'Lucky Coin', icon: '🪙', blurb: '+10% critical chance', crit: 0.1 },
+  feather: { name: 'Phoenix Feather', icon: '🪶', blurb: 'Once, a wipe raises the party instead', isFeather: true },
+}
+
+/** First halves and second halves of the names the game gives a hero when the model gives none. */
+export const NAME_PARTS: readonly [readonly string[], readonly string[]] = [
+  ['Bran', 'Elo', 'Thal', 'Mira', 'Kor', 'Wren', 'Ash', 'Iso', 'Dun', 'Sel', 'Fen', 'Rho', 'Tam', 'Vey', 'Orl', 'Pip'],
+  ['noc', 'wen', 'ric', 'dra', 'vin', 'ley', 'mir', 'bel', 'dor', 'ka', 'sin', 'tov', 'ra', 'lin', 'ger', 'by'],
+]
+
+/** What heroes say in the tavern; `{friend}` is a hero they like. */
+export const TAVERN_LINES: readonly string[] = [
+  'Another round!', 'My feet still smell of slime.', 'Anyone seen my other boot?', 'To the next dungeon!',
+  'This stew is mostly turnip.', 'I could take that boss. Probably.', '*polishes gear*', '*hums an old song*',
+  'Cards, anyone?', '*dozes by the fire*', 'Remember that time with the bats?', 'The bard here is awful.',
+]
+export const FRIEND_LINES: readonly string[] = ['A toast to {friend}!', '{friend}, you saved my hide back there.', 'I\'d follow {friend} into any crypt.']
+export const RIVAL_LINES: readonly string[] = ['{friend} snores like a golem.', 'I did more damage than {friend}.']