azeroth-shell 0.0.0-stage → 0.1.1

package/src/cli/tuiArena.mjs

@@ -0,0 +1,109 @@
+// Arena from the Honor window: the 1v1 against a duelist at your rating, and the 2v2, 3v3 and 5v5 with your
+// companions (merc backfill for empty seats). Each is one fight in the live view; Esc forfeits. Settlement is
+// phonecraft app.ts:1861: the rating moves on a win, a loss or a draw, and a win pays per-opponent duel honor
+// plus the match bonus, banked into the week.
+import { bold, dim, yellow, green, red, cyan } from './text.mjs';
+import { startFight } from './tuiFight.mjs';
+import { BATTLEGROUNDS } from '../domain/run/battlegroundRun.ts';
+import { arenaRatingOf, ratingTier } from '../domain/bg/arenaRating.ts';
+import { BG_TIERS } from '../domain/bg/bgTier.ts';
+import { gauntletLength } from '../domain/bg/arenaComps.ts';
+import { avInstanceIdFor } from '../data/dungeons/alterac-valley.ts';
+import { factionOf } from '../domain/character/races.ts';
+import { openRun } from './tuiDungeon.mjs';
+import { objectiveBgRows } from './tuiBg.mjs';
+
+const H = (text) => ({ text, header: true });
+
+/** A finished arena session as a FightOutcome: no xp, gold or loot. */
+function arenaOutcome(r) {
+  const won = r.winner === 'player';
+  return { ok: true, outcome: r.winner === 'timeout' ? 'timeout' : won ? 'win' : 'defeat', result: r, xpGained: 0, goldGained: 0, loot: [], leveledTo: [], killCount: 0 };
+}
+
+function ratingSay(app, rated) {
+  app.say(cyan(`Arena rating ${rated.rating}`) + dim(` (${rated.delta >= 0 ? '+' : ''}${rated.delta})`));
+}
+
+export function startArenaDuel(app) {
+  const g = app.g;
+  const res = g.arenaDuel();
+  if (!app.result(res)) return;
+  app.say(yellow(`Arena: ${res.targetName}, rating ${res.oppRating}. You are ${res.rating}.`));
+  startFight(app, 0, {
+    label: 'arena',
+    begin: () => ({ ok: true, session: res.session, enemyName: res.targetName, enemyEntry: 0 }),
+    resolve: (s) => {
+      const r = s.result();
+      const won = r.winner === 'player';
+      g.settleArenaDuel(res.compId, won);
+      ratingSay(app, g.settleArenaRating(1, res.oppRating, r.winner === 'timeout' ? 'draw' : won ? 'win' : 'loss'));
+      if (won) {
+        const { cp } = g.awardDuelHonor({ name: res.targetName, level: res.targetLevel });
+        const bonus = g.awardArenaWinHonor().cp;
+        app.say(yellow(cp > 0 ? `${cp + bonus} honor.` : `${bonus} honor. You already beat ${res.targetName} today.`));
+      }
+      return arenaOutcome(r);
+    },
+  });
+}
+
+export function startArenaMatch(app, bracket) {
+  const g = app.g;
+  const res = g.arenaMatch({ bracket });
+  if (!app.result(res)) return;
+  app.say(yellow(`Arena ${bracket}v${bracket}: ${res.name}, rating ${res.oppRating}. You are ${res.rating}.`) + dim(`  With you: ${res.allies.map((x) => x.name).join(', ') || 'nobody'}.`));
+  startFight(app, 0, {
+    label: 'arena',
+    begin: () => ({ ok: true, session: res.session, enemyName: res.name, enemyEntry: 0 }),
+    resolve: (s) => {
+      const r = s.result();
+      const won = r.winner === 'player';
+      ratingSay(app, g.settleArenaRating(res.bracket, res.oppRating, r.winner === 'timeout' ? 'draw' : won ? 'win' : 'loss'));
+      if (won) {
+        let honor = 0;
+        for (const o of res.opponents) honor += g.awardDuelHonor({ name: o.name, level: o.level }).cp;
+        honor += g.awardArenaWinHonor().cp;
+        app.say(yellow(`${honor} honor for the match.`));
+      }
+      return arenaOutcome(r);
+    },
+  });
+}
+
+/** Alterac Valley is a raid run, not a battleground screen (phonecraft appInteractClickA.ts:1179): your side's
+ *  wing of the valley, entered as a raid with the bench promoted, played in the dungeon run window. */
+export function enterAlteracValley(app) {
+  const team = factionOf(app.ds, app.ch.race) === 'horde' ? 'horde' : 'alliance';
+  const r = app.g.enterInstance(avInstanceIdFor(team), Date.now(), { asRaid: true });
+  if (!app.result(r, `You join the fight for Alterac Valley.`)) return;
+  app.stack = [];
+  openRun(app);
+}
+
+/** The Battlegrounds section: Warsong Gulch and Arathi Basin as a watched match, Alterac Valley as a raid run. */
+export function battlegroundRows(app) {
+  const av = BATTLEGROUNDS.av;
+  const rows = [H(''), H(`${cyan('Battlegrounds')}  ${dim('earn honor and climb the weekly ranks')}`), ...objectiveBgRows(app)];
+  if (av) rows.push(app.ch.level >= av.minLevel
+    ? { text: `  ${av.name}  ${dim(`${av.minLevel}-${av.maxLevel}, a raid run: captains, towers and the general`)}`, act: (a) => enterAlteracValley(a) }
+    : H(dim(`  ${av.name}  level ${av.minLevel}`)));
+  return rows;
+}
+
+/** The Arena section of the Honor window. */
+export function arenaRows(app) {
+  const st = app.g.state;
+  const rows = [H(''), H(`${cyan('Arena')}  ${dim('last team standing; nobody respawns. Esc in the fight forfeits.')}`)];
+  for (const b of Object.values(BATTLEGROUNDS).filter((x) => x.mode === 'arena')) {
+    const bracket = b.teamSize;
+    const rating = arenaRatingOf(st.arenaRating, bracket);
+    const band = BG_TIERS[ratingTier(rating)]?.name ?? '';
+    const extra = bracket === 1 ? `, gauntlet ${st.gauntletRung ?? 0}/${gauntletLength()}` : `, you and ${bracket - 1} companion${bracket === 2 ? '' : 's'}`;
+    const open = app.ch.level >= b.minLevel;
+    rows.push(open
+      ? { text: `  ${b.name}  ${dim(`rating ${rating}, ${band}${extra}`)}`, act: (a) => (bracket === 1 ? startArenaDuel(a) : startArenaMatch(a, bracket)) }
+      : H(dim(`  ${b.name}  level ${b.minLevel}`)));
+  }
+  return rows;
+}

package/src/cli/tuiAutopilotSettings.mjs

@@ -0,0 +1,93 @@
+// Autopilot settings (phonecraft rotation/rotationEditorAuto.ts and autopilot/runDials.ts): every AutopilotConfig
+// field a player sets, as one form. Enter flips a switch, steps through a choice, or asks for a number. The raid
+// plan fields are left to the raid screens that own them.
+import { bold, dim, green, cyan } from './text.mjs';
+import { MAX_SOUL_SHARD_CAP } from '../autopilot/config.ts';
+
+const H = (text) => ({ text, header: true });
+const pct = (v) => `${Math.round(v * 100)}%`;
+
+// [key, label, kind, extra, shown?]: kind 'bool' | 'choice' (extra = [[value, label], ...]) | 'num' (extra = { min, max,
+// show? (value -> text), read? (typed text -> value), edit? (value -> what the prompt starts with) }).
+const SECTIONS = [
+  ['Rest between fights', [
+    ['autoEat', 'Eat when hurt', 'bool'],
+    ['autoDrink', 'Drink when low on mana', 'bool'],
+    ['healthEnterPct', 'Rest below health', 'num', { min: 0.05, max: 1, show: pct, read: (t) => Number(t.replace('%', '')) / 100, edit: (v) => String(Math.round(v * 100)), ask: '% health' }],
+    ['manaEnterPct', 'Rest below mana', 'num', { min: 0.05, max: 1, show: pct, read: (t) => Number(t.replace('%', '')) / 100, edit: (v) => String(Math.round(v * 100)), ask: '% mana' }],
+    ['recoverToPct', 'Rest until', 'num', { min: 0.1, max: 1, show: pct, read: (t) => Number(t.replace('%', '')) / 100, edit: (v) => String(Math.round(v * 100)), ask: '% full' }],
+    ['restMode', 'How to rest', 'choice', [['eat-then-wait', 'eat, then wait it out'], ['eat-only', 'eat and drink only']]],
+  ]],
+  ['The run', [
+    ['sessionMs', 'Stop after', 'num', { min: 60_000, max: 24 * 3_600_000, show: (v) => `${Math.round(v / 60_000)} min`, read: (t) => Number(t) * 60_000, edit: (v) => String(Math.round(v / 60_000)), ask: 'minutes' }],
+    ['maxConsecutiveDefeats', 'Stop after deaths in a row', 'num', { min: 1, max: 20 }],
+    ['stopAtLevel', 'Stop at level', 'num', { min: 0, max: 60, show: (v) => (v ? String(v) : 'never') }],
+    ['autoGather', 'Mine, pick and skin on the way', 'bool'],
+  ]],
+  ['Fighting', [
+    ['combatRole', 'Role in a group', 'choice', [['dps', 'damage'], ['tank', 'tank'], ['offtank', 'off-tank']]],
+    ['aoeMode', 'Area spells', 'choice', [['auto', 'when it pays'], ['aoe', 'against two or more'], ['single', 'never']]],
+    ['offHeal', 'Off-heal when the healer cannot', 'bool'],
+    ['threatWatch', 'Stop damage while a mob is on you', 'bool'],
+    ['ccPreferCasters', 'Crowd control casters first', 'bool'],
+    ['movement', 'Moving in a fight', 'choice', [['auto', 'as the fight needs'], ['hold', 'hold your ground'], ['melee', 'stay in melee']]],
+    ['pullOpenYards', 'Open the fight from', 'num', { min: -1, max: 40, show: (v) => (v === 0 ? 'auto' : v === -1 ? 'max spell range' : `${v} yd`), ask: 'yards (0 auto)' }],
+    ['totemTwisting', 'Twist the air totem (shaman)', 'bool', null, (app) => app.ch.cls === 7],
+    ['keepSoulShards', 'Soul shards to keep (warlock)', 'num', { min: 0, max: MAX_SOUL_SHARD_CAP }, (app) => app.ch.cls === 9],
+  ]],
+  ['How much to pull', [
+    ['pullNormalCount', 'Normal mobs per pull on a run', 'num', { min: 1, max: 10 }],
+    ['pullEliteCount', 'Elites per pull on a run', 'num', { min: 1, max: 5 }],
+    ['pullAttackNormalCount', 'Normal mobs when you press Enter', 'num', { min: 1, max: 10 }],
+    ['pullAttackEliteCount', 'Elites when you press Enter', 'num', { min: 1, max: 5 }],
+  ]],
+  ['Questing', [
+    ['questAutoAccept', 'Accept quests on its own', 'bool'],
+    ['questRewardChoice', 'Quest reward', 'choice', [['auto', 'pick the best one'], ['wait', 'ask me']]],
+    ['questZoneSwap', 'Move to another zone', 'choice', [['level-safe', 'when the level fits'], ['any', 'wherever the quests go'], ['off', 'never']]],
+    ['questEliteMode', 'Elite quests', 'choice', [['squad', 'with the companions'], ['solo', 'alone'], ['skip', 'skip them']]],
+    ['questSquadAlways', 'Companions in every fight', 'bool'],
+    ['questSquadShare', 'Share quests with companions', 'bool'],
+    ['questLevelBelow', 'Take quests down to levels below', 'num', { min: 0, max: 60, show: (v) => (v ? String(v) : 'no limit') }],
+    ['questLevelAbove', 'Take quests up to levels above', 'num', { min: 0, max: 10 }],
+    ['questSkipAbandon', 'Abandon quests it cannot finish', 'bool'],
+  ]],
+];
+
+function set(app, key, value) {
+  app.g.setAutopilotConfig({ ...app.g.autopilotConfig(), [key]: value });
+}
+
+export function autopilotSettingsDialog(app) {
+  return {
+    id: 'autopilot-settings', title: 'Autopilot settings', hint: 'Enter: change',
+    rows(a) {
+      const cfg = a.g.autopilotConfig();
+      const rows = [H(`${bold('Autopilot')}   ${dim('how the run rests, fights, pulls and quests')}`)];
+      for (const [title, fields] of SECTIONS) {
+        rows.push(H(''), H(cyan(title)));
+        for (const [key, label, kind, extra, shown] of fields) {
+          if (shown && !shown(a)) continue;
+          const v = cfg[key];
+          let text, act;
+          if (kind === 'bool') { text = v ? green('on') : dim('off'); act = (a2) => set(a2, key, !v); }
+          else if (kind === 'choice') {
+            const i = Math.max(0, extra.findIndex(([x]) => x === v));
+            text = extra[i][1];
+            act = (a2) => set(a2, key, extra[(i + 1) % extra.length][0]);
+          } else {
+            text = extra.show ? extra.show(v) : String(v);
+            act = (a2) => a2.prompt(`${label} (${extra.ask ?? `${extra.min}-${extra.max}`}): `, (t) => {
+              const n = extra.read ? extra.read(t.trim()) : Number(t.trim());
+              if (!Number.isFinite(n) || n < extra.min || n > extra.max) { a2.flashMsg(`Out of range: ${t}`); return; }
+              set(a2, key, key.endsWith('Pct') ? n : Math.round(n));
+              a2.afterAction();
+            }, extra.edit ? extra.edit(v) : String(v));
+          }
+          rows.push({ text: `${label.padEnd(36)} ${text}`, data: { key }, act });
+        }
+      }
+      return rows;
+    },
+  };
+}

package/src/cli/tuiBags.mjs

@@ -0,0 +1,180 @@
+// Bag housekeeping for the Bags tab: what Enter does to a stack (equip, open, unwrap, learn, use), the item menu
+// behind m with every other verb (use all, split, wrap, move, destroy), sorting, and the keyring. Phonecraft's
+// held-item menu (panels/heldItemMenu.ts) is the reference; every verb is a Game facade call.
+import { bold, dim, yellow, green, red, qualityPaint, itemText } from './text.mjs';
+import { autoLootOn, openLoot, takeAll } from './tuiLoot.mjs';
+import { SLOT_LABEL, bagCapacity } from '../domain/items/equipment.ts';
+import { freeSlots, isWrappingPaper, isFilledGift, canWrapTarget } from '../domain/items/inventory.ts';
+import { isOpenableContainer } from '../domain/items/itemContainer.ts';
+import { isAmmoItem } from '../domain/items/ammo.ts';
+import { itemTeachIntent } from '../domain/items/itemTeaches.ts';
+import { junkListOptions } from './tuiSettings.mjs';
+import { isMountItem, toggleMount } from './tuiWorld.mjs';
+import { questDialog } from './tuiViews.mjs';
+import { useItemWithPicker, isPermanentEnchantItem } from './tuiEnchantTarget.mjs';
+import { bagQuestStartState } from '../quests/quests.ts';
+
+const stacks = (app) => app.g.state.inventory.stacks;
+const hasLoot = (app) => (entry) => app.ds.lootTable(`item:${entry}`).length > 0;
+const isContainer = (app, it) => isOpenableContainer(it, hasLoot(app));
+const countText = (s) => (s.count > 1 ? ` x${s.count}` : '');
+
+/** Name of what Enter does to this stack, for the detail pane and the menu. */
+export function primaryVerb(app, s) {
+  const it = app.ds.item(s.item);
+  if (!it) return null;
+  if (isMountItem(it)) return app.ch.mountedItem === it.entry ? 'Dismount' : 'Mount';
+  if ((it.startQuest ?? 0) > 0 && bagQuestStartState(app.ds, app.ch, app.g.state.questlog, app.g.state.inventory, it.entry)) return 'Start the quest';
+  if (isFilledGift(s)) return 'Unwrap';
+  if (isWrappingPaper(it)) return 'Wrap an item';
+  if (isContainer(app, it)) return 'Open';
+  if (itemTeachIntent(it, app.ds)) return 'Learn';
+  if (it.slot) return it.slot === 'bag' ? 'Equip bag' : 'Equip';
+  if (isAmmoItem(it)) return app.ch.ammoItem === it.entry ? 'Unequip ammo' : 'Equip as ammo';
+  if (it.consumable) return /bandage/i.test(it.name) ? 'Use' : it.consumable.effect === 'food' ? 'Eat' : 'Drink';
+  if (it.useSpell && app.ds.enchantApplicator?.(it.useSpell)) return isPermanentEnchantItem(app, it) ? 'Apply to gear' : 'Apply to a weapon';
+  if (it.useBuff || it.useInCombat || it.useSpell) return 'Use';
+  return null;
+}
+
+/** Enter on a bag stack. */
+export function useStack(app, slot) {
+  const s = stacks(app)[slot];
+  if (!s) return;
+  const it = app.ds.item(s.item);
+  if (isMountItem(it)) { toggleMount(app, s.item); return; }
+  if ((it?.startQuest ?? 0) > 0) {
+    const st = bagQuestStartState(app.ds, app.ch, app.g.state.questlog, app.g.state.inventory, s.item);
+    if (st?.kind === 'offer') { app.push(questDialog(app, st.offer.quest, 'offer')); return; }
+    if (st?.kind === 'blocked') { app.flashMsg(st.reason); return; }
+  }
+  if (isFilledGift(s)) {
+    const r = app.g.unwrapItem(slot);
+    app.result(r, r.ok ? `You unwrap ${itemText(it, 'the gift')}: ${app.itemLabel(r.restoredEntry)}.` : '');
+    return;
+  }
+  if (isWrappingPaper(it)) { wrapWith(app, slot); return; }
+  if (isContainer(app, it)) { openContainer(app, slot); return; }
+  if (it?.slot) { const r = app.g.equip(s.item); app.result(r, r.ok ? (it.slot === 'bag' ? `You equip ${itemText(it)} as ${SLOT_LABEL[r.slot] ?? r.slot}.` : `You equip ${itemText(it)}.`) : ''); return; }
+  if (isAmmoItem(it)) {
+    if (app.ch.ammoItem === it.entry) app.result(app.g.clearAmmo(), 'You put your ammo away.');
+    else app.result(app.g.setAmmo(s.item), `You load ${itemText(it)}.`);
+    return;
+  }
+  // Cloth, ore, a quest item: nothing to use, so Enter opens the menu with what you can do instead.
+  if (!primaryVerb(app, s)) { itemMenu(app, slot); return; }
+  // An armor kit, a scope, a poison or a sharpening stone asks which slot it goes on.
+  useItemWithPicker(app, s.item, (r) => (r.learned ? green(`You learn ${r.learned.name}.`) : green(`You use ${itemText(it)}.  HP ${app.hpText()}  ${app.pwText()}`)));
+}
+
+/** Open a clam, crate or lockbox into the loot window; auto-loot takes what fits straight away. */
+export function openContainer(app, slot) {
+  const name = app.itemLabel(stacks(app)[slot]?.item);
+  const r = app.g.openContainerItem(slot, { hold: true });
+  if (!app.result(r)) return;
+  const by = r.openedBy ? ` ${r.openedBy} picks the lock.` : r.keyUsed ? ` The ${app.itemLabel(r.keyUsed)} turns.` : '';
+  app.say(green(`You open ${name}.${by}`) + (r.skillUp ? dim(`  Lockpicking ${r.skillUp}`) : ''));
+  if (!app.g.pendingLoot()) { app.say(dim('  It is empty.')); return; }
+  if (autoLootOn(app)) takeAll(app);
+  openLoot(app);
+}
+
+/** Wrapping paper: pick what goes in it. */
+function wrapWith(app, paperSlot) {
+  const targets = stacks(app).map((s, i) => ({ s, i })).filter(({ s, i }) => i !== paperSlot && canWrapTarget(app.ds.item(s.item), s).ok);
+  if (!targets.length) { app.flashMsg('Nothing in your bags can be wrapped.'); return; }
+  app.pick('Wrap which item?', targets.map(({ s, i }) => ({ label: `${app.itemLabel(s.item)}${countText(s)}`, value: i })), (i) => {
+    const target = app.itemLabel(stacks(app)[i]?.item);
+    const r = app.g.wrapItem(paperSlot, i);
+    app.result(r, r.ok ? `You wrap ${target}${r.bound ? ' (it is bound to you now)' : ''}.` : '');
+  });
+}
+
+/** Use (or open) the whole stack at once. Food, drink, buffs and books are left out, as phonecraft does. */
+export function useAll(app, slot) {
+  const s = stacks(app)[slot];
+  if (!s) return;
+  const it = app.ds.item(s.item);
+  if (s.count < 2 || !it || it.consumable || it.useBuff || itemTeachIntent(it, app.ds) || isFilledGift(s) || !['Use', 'Open'].includes(primaryVerb(app, s))) {
+    app.flashMsg(s.count < 2 ? 'Only one of those.' : 'That is used one at a time.');
+    return;
+  }
+  const r = app.g.consumeItemAll(s.item);
+  if (!app.result(r)) return;
+  app.say(green(`You use ${r.used}x ${itemText(it)}.`) + (r.restored ? dim(`  +${r.restored}`) : '') + (r.stopped === 'blocked' ? yellow(`  Stopped: ${r.lastReason ?? 'refused'}.`) : ''));
+}
+
+/** Split off part of a stack into a free slot. */
+export function splitStack(app, slot) {
+  const s = stacks(app)[slot];
+  if (!s || s.count < 2) { app.flashMsg('Nothing to split.'); return; }
+  if (freeSlots(app.g.state.inventory, bagCapacity(app.ch, app.ds)) < 1) { app.flashMsg('Your bags are full.'); return; }
+  app.prompt(`Split off how many ${app.itemLabel(s.item)} (1-${s.count - 1}): `, (raw) => {
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 1 || n >= s.count) { app.flashMsg(`A number from 1 to ${s.count - 1}.`); return; }
+    app.result(app.g.moveItem(slot, stacks(app).length, n), `You split ${n} ${app.itemLabel(s.item)} off.`);
+    app.afterAction();
+  });
+}
+
+/** Move a stack one slot up or down (a same-item neighbour merges into it). The cursor follows. */
+export function moveStack(app, slot, delta) {
+  const to = slot + delta;
+  if (!stacks(app)[slot] || to < 0 || to >= stacks(app).length) return;
+  const r = app.g.moveItem(slot, to);
+  if (!app.result(r)) return;
+  const view = app.top();
+  if (view?.id === 'bags') view.cursor = Math.max(0, view.cursor + delta);
+}
+
+export function destroyStack(app, slot, keyring = false) {
+  const s = (keyring ? app.g.state.keyring?.stacks : stacks(app))?.[slot];
+  if (!s) return;
+  app.confirm(`Destroy ${app.itemLabel(s.item)}${countText(s)}? This cannot be undone.`, () => {
+    const r = keyring ? app.g.discardKeyringStack(slot) : app.g.discardBagStack(slot);
+    app.result(r, r.ok ? `Destroyed ${app.itemLabel(s.item)}${r.discarded > 1 ? ` x${r.discarded}` : ''}.` : '');
+  });
+}
+
+export function sortBags(app) {
+  const r = app.g.sortContainer('bags');
+  if (!app.result(r)) return;
+  app.say(green(r.changed ? `Bags sorted${r.freed ? `, ${r.freed} slot${r.freed === 1 ? '' : 's'} freed` : ''}.` : 'Your bags are already in order.'));
+}
+
+/** m on a stack: every verb that applies to it. */
+export function itemMenu(app, slot) {
+  const s = stacks(app)[slot];
+  if (!s) return;
+  const it = app.ds.item(s.item);
+  const verb = primaryVerb(app, s);
+  const opts = [];
+  if (verb) opts.push({ label: `${verb}  ${dim('Enter')}`, value: () => useStack(app, slot) });
+  if (s.count > 1 && ['Use', 'Open'].includes(verb) && !it?.consumable && !it?.useBuff) opts.push({ label: `${verb === 'Open' ? 'Open' : 'Use'} all x${s.count}  ${dim('A')}`, value: () => useAll(app, slot) });
+  if (s.count > 1) opts.push({ label: `Split the stack  ${dim('/')}`, value: () => splitStack(app, slot) });
+  const paper = stacks(app).findIndex((x, i) => i !== slot && isWrappingPaper(app.ds.item(x.item)));
+  if (paper >= 0 && !isWrappingPaper(it) && canWrapTarget(it, s).ok) {
+    opts.push({ label: `Wrap it in ${app.itemLabel(stacks(app)[paper].item)}`, value: () => { const r = app.g.wrapItem(paper, slot); app.result(r, r.ok ? `You wrap ${itemText(it)}.` : ''); } });
+  }
+  if (slot > 0) opts.push({ label: `Move up  ${dim('[')}`, value: () => moveStack(app, slot, -1) });
+  if (slot < stacks(app).length - 1) opts.push({ label: `Move down  ${dim(']')}`, value: () => moveStack(app, slot, +1) });
+  opts.push({ label: `Move to the end`, value: () => app.result(app.g.moveItem(slot, stacks(app).length)) });
+  opts.push(...junkListOptions(app, s.item));
+  opts.push({ label: red(`Destroy  ${dim('d')}`), value: () => destroyStack(app, slot) });
+  app.pick(`${itemText(it, 'Item')}${countText(s)}`, opts, (fn) => fn());
+}
+
+/** The keyring under the bags: keys only destroy from here (the engine uses them when it opens a lock). */
+export function keyringRows(app) {
+  const keys = app.g.state.keyring?.stacks ?? [];
+  if (!keys.length) return [];
+  const rows = [{ text: '', header: true }, { text: `Keyring  ${dim(`${keys.length}`)}`, header: true }];
+  keys.forEach((k, i) => {
+    rows.push({
+      text: `${app.itemLabel(k.item)}${countText(k)}`, data: { keyring: i },
+      detail: () => [bold(app.itemLabel(k.item)), dim('A key. Locked doors and boxes use it on their own.'), '', dim('d: destroy')],
+      keys: { d: (a) => destroyStack(a, i, true) },
+    });
+  });
+  return rows;
+}

package/src/cli/tuiBars.mjs

@@ -0,0 +1,133 @@
+// Action bars: the player's own (spells, bag items, macros, keybinds), a companion's kit bars (spells from their
+// kit, items from their bags), and the global bar (items and outfits fired outside a fight). One editor over an
+// owner, like phonecraft hudActionBarPaint.ts and companionKitPanel.ts share actionBarModel.ts.
+import { bold, dim, cyan, green, yellow, red, fit } from './text.mjs';
+import { spellLines, itemLines } from './tuiViews.mjs';
+import { knownUsableSpells } from '../domain/character/characterSpells.ts';
+import { companionLevel, companionCharacter, companionSpellbook } from '../domain/bots/squad.ts';
+import { SLOTS_PER_BAR, MAX_BARS } from '../domain/character/actionbar.ts';
+import { actionBarsForForm } from '../domain/character/stanceBar.ts';
+
+const H = (text) => ({ text, header: true });
+
+/** What sits in a slot: a macro, an item or a spell, in the order the bar fires them. */
+export function slotContent(bar, i) {
+  if (bar.macros?.[i]) return { kind: 'macro', id: bar.macros[i] };
+  if (bar.items?.[i] != null) return { kind: 'item', entry: bar.items[i] };
+  if (bar.slots?.[i] != null) return { kind: 'spell', id: bar.slots[i] };
+  return null;
+}
+
+/** The player's bars as they show right now: bar 1 is paged by form (stance, shapeshift, stealth), like phonecraft. */
+export function visibleBars(g) {
+  return actionBarsForForm(g.state.actionBars ?? [], g.state.primaryBarPages, (g.state.char.form ?? 0) | 0);
+}
+
+export function playerBarsOwner(app) {
+  const g = app.g;
+  return {
+    title: 'Your action bars', player: true,
+    bars: () => visibleBars(g),
+    spells: () => knownUsableSpells(app.ch, g.state.spellbook, app.ds).filter((s) => !s.passive),
+    items: () => g.state.inventory.stacks,
+    macros: () => g.macros?.() ?? [],
+    setSpell: (b, i, id) => g.setActionSlot(b, i, id),
+    setItem: (b, i, e) => g.setItemActionSlot(b, i, e),
+    setMacro: (b, i, m) => g.setMacroActionSlot(b, i, m),
+    setKey: (b, i, k) => g.setActionKey(b, i, k),
+    add: () => g.addActionBar(), remove: () => g.removeActionBar(),
+  };
+}
+
+export function companionBarsOwner(app, comp) {
+  const g = app.g, lvl = companionLevel(comp, app.ch.level);
+  return {
+    title: `${comp.name}'s action bars`,
+    bars: () => g.companionActionBars(comp.id) ?? [],
+    spells: () => knownUsableSpells(companionCharacter(comp, lvl, app.ds), companionSpellbook(comp, lvl, app.ds), app.ds).filter((s) => !s.passive),
+    items: () => comp.bags?.stacks ?? [],
+    setSpell: (b, i, id) => g.setCompanionActionSlot(comp.id, b, i, id),
+    setItem: (b, i, e) => g.setCompanionItemActionSlot(comp.id, b, i, e),
+    add: () => g.addCompanionActionBar(comp.id), remove: () => g.removeCompanionActionBar(comp.id),
+    reset: () => g.resetCompanionActionBars(comp.id),
+  };
+}
+
+function slotLabel(app, owner, c) {
+  if (!c) return dim('empty');
+  if (c.kind === 'spell') { const sp = app.ds.spell(c.id); return `${sp?.name ?? c.id}${sp?.rank ? dim(` (Rank ${sp.rank})`) : ''}`; }
+  if (c.kind === 'item') return `${app.itemLabel(c.entry)}${owner.items ? dim(`  x${owner.items().filter((s) => s.item === c.entry).reduce((n, s) => n + s.count, 0)}`) : ''}`;
+  return cyan(`macro ${owner.macros?.().find((m) => m.id === c.id)?.name ?? c.id}`);
+}
+
+/** Pick what goes in one slot: a spell, an item, a macro, or nothing. */
+function fillSlot(app, owner, b, i) {
+  // The setters return nothing; the engine refuses by leaving the slot alone, so compare before and after.
+  const ok = (r) => {
+    if (r?.ok === false) { app.say(red(r.reason ?? 'That does not go there.')); return false; }
+    if (!slotContent(owner.bars()[b] ?? {}, i)) { app.say(red('That cannot go on a bar.')); return false; }
+    return true;
+  };
+  const opts = [
+    ...owner.spells().sort((x, y) => x.name.localeCompare(y.name)).map((sp) => ({ label: `${sp.name}${sp.rank ? dim(` (Rank ${sp.rank})`) : ''}`, detail: () => spellLines(app, sp), value: () => ok(owner.setSpell(b, i, sp.id)) })),
+    ...[...new Set(owner.items().map((s) => s.item))].map((e) => app.ds.item(e)).filter((it) => it && (it.useInCombat || it.consumable || it.useSpell)).map((it) => ({ label: yellow(it.name), detail: () => itemLines(app, it), value: () => ok(owner.setItem(b, i, it.entry)) })),
+    ...(owner.macros?.() ?? []).map((m) => ({ label: cyan(`Macro: ${m.name}`), value: () => ok(owner.setMacro(b, i, m.id)) })),
+    { label: dim('Clear the slot'), value: () => { owner.setSpell(b, i, null); owner.setItem(b, i, null); owner.setMacro?.(b, i, null); } },
+  ];
+  app.pick(`Bar ${b + 1}, slot ${i + 1}`, opts, (fn) => fn());
+}
+
+export function barsDialog(app, ownerFn) {
+  return {
+    id: 'bars', title: 'Action bars', hint: 'Enter: fill the slot',
+    keys: {
+      '+': { hint: 'add a bar', fn: (a) => a.result(ownerFn(a).add()) },
+      '-': { hint: 'remove the last bar', fn: (a) => a.result(ownerFn(a).remove()) },
+      k: { hint: 'keybind', fn: (a, row) => { const o = ownerFn(a); if (!o.setKey || row?.data == null) return; a.prompt('Key (1-9, 0, -, =, q, shift+2 …; empty clears): ', (t) => { o.setKey(row.data.b, row.data.i, t.trim().toLowerCase() || null); a.afterAction(); }); } },
+      x: { hint: 'clear', fn: (a, row) => { const o = ownerFn(a); if (row?.data == null) return; o.setSpell(row.data.b, row.data.i, null); o.setItem(row.data.b, row.data.i, null); o.setMacro?.(row.data.b, row.data.i, null); } },
+      R: { hint: 'reset', fn: (a) => { const o = ownerFn(a); if (o.reset) a.confirm('Reset the bars to their kit?', () => a.result(o.reset(), 'Bars reset.')); } },
+    },
+    rows(a) {
+      const o = ownerFn(a);
+      const bars = o.bars();
+      const rows = [H(`${bold(o.title)}   ${dim(`${bars.length} of ${MAX_BARS} bars`)}`)];
+      if (o.player) rows.push(H(dim(`Bar 1 is the number row in a fight. Keys you bind here fire there.${(a.ch.form ?? 0) ? '  This is the page for your current form.' : ''}`)));
+      bars.forEach((bar, b) => {
+        rows.push(H(''), H(`Bar ${b + 1}`));
+        for (let i = 0; i < SLOTS_PER_BAR; i++) {
+          const c = slotContent(bar, i);
+          rows.push({
+            text: `${fit(dim(bar.keys?.[i] ?? ''), 8)} ${slotLabel(a, o, c)}`, data: { b, i },
+            detail: () => [bold(`Bar ${b + 1}, slot ${i + 1}`), bar.keys?.[i] ? `Key: ${bar.keys[i]}` : dim('No key'), '', ...(c?.kind === 'spell' ? spellLines(a, a.ds.spell(c.id)) : c?.kind === 'item' ? itemLines(a, a.ds.item(c.entry)) : []), '', dim(`Enter: fill   x: clear${o.setKey ? '   k: keybind' : ''}`)],
+            act: () => fillSlot(a, o, b, i),
+          });
+        }
+      });
+      if (o.player) rows.push(...globalBarRows(a));
+      return rows;
+    },
+  };
+}
+
+/** The global bar: bag items and outfits, fired out of combat one slot or all at once. */
+function globalBarRows(app) {
+  const g = app.g, bar = g.state.globalActionBar;
+  const rows = [H(''), H(`Global bar ${dim('items and outfits, fired outside a fight')}`)];
+  rows.push({ text: green('Fire the whole global bar'), act: () => { const r = g.fireGlobalActionBar(); app.say(dim(`${r.tried} slot(s) fired.`)); } });
+  for (let i = 0; i < SLOTS_PER_BAR; i++) {
+    const item = bar?.items?.[i], outfit = bar?.outfits?.[i];
+    rows.push({
+      text: `  ${fit(dim(String(i + 1)), 4)} ${outfit ? cyan(`outfit ${outfit}`) : item != null ? app.itemLabel(item) : dim('empty')}`,
+      act: () => {
+        const opts = [
+          ...(item != null || outfit ? [{ label: green('Fire it now'), value: () => { const r = g.fireGlobalActionSlot(i); app.say(dim(`${r.tried} fired.`)); } }] : []),
+          ...[...new Set(g.state.inventory.stacks.map((s) => s.item))].map((e) => app.ds.item(e)).filter((it) => it?.consumable || it?.useSpell || it?.useInCombat).map((it) => ({ label: yellow(it.name), value: () => g.setGlobalItemSlot(i, it.entry) })),
+          ...(g.outfitterState?.()?.outfits ?? []).map((o) => ({ label: cyan(`Outfit: ${o.name}`), value: () => g.setGlobalOutfitSlot(i, o.name) })),
+          { label: dim('Clear'), value: () => g.clearGlobalActionSlot(i) },
+        ];
+        app.pick(`Global slot ${i + 1}`, opts, (fn) => fn());
+      },
+    });
+  }
+  return rows;
+}