azeroth-shell 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+What changed in each release of `azeroth-shell` on npm. Update with `npm install -g azeroth-shell@latest`.
+
+## Unreleased
+
+## 0.4.0 — 2026-11-03
+
+- Bags: `X` destroys several stacks at once, and `Q` destroys every quest item left over from quests you handed in.
+- Dungeons: a 5-man you leave is held for two hours (it was 30 minutes). On the World tab, Enter on a run you
+  left half done takes you straight back in. The tab also lists the zone's dungeons while you are inside one,
+  and a cleared run says so. Picking another dungeon from inside one leaves the current run, which is held.
+- Companions get their own copy of a quest item that comes from an object. If their copy never finished, they
+  drop it when you hand the quest in, so it no longer fills their log. Their quest list offers to drop old ones.
+- Art for what a fight turns into or brings in: boss morphs, totems, wards and adds were invisible before.
+- The title line reads "Azeroth Shell".
+
+## 0.3.0 — 2026-11-03
+
+- HD gear art at 256 px with a palette per body. Shapeshift forms and costumes draw sharp under sixel.
+- The Travel tab has a world map, in half-block and sixel.
+- Tame and quest-item uses on World rows; dungeon entry locks and extra entrances; Hearthstone and ring/trinket
+  picks in Bags. The Character tab gets a stats page, and buffs are cast before a pull.
+- Hunter pets untrain at the trainer's prices and keep their innate abilities.
+- A foe still targeting you keeps the fight going.
+- `azsh --art` downloads the full-size art up front.
+
+## 0.2.0 — 2026-11-02
+
+- Art: creatures, icons and your geared character are drawn as half-block sprites, or as real pixels in a
+  terminal that supports sixel.
+- A fight stage, the Gear tab as a character sheet, talent trees, and a one-page character creation screen.
+- Party fights on the stage, each body at its real distance. Casters no longer stall on immune foes.
+- The autopilot on screen: pre-flight card, run strip, run panel, Run/Quests/Bags panes, end card, and the
+  rotation condition editor.
+- Auction house browsing by category; world search covers the zone you stand in.
+- Warsong Gulch: strip map, your own seat, side calls, and matches that actually end.
+- Faster start: the engine is cached under `~/.azsh/cache`, with a loading line while it imports.
+
+## 0.1.2 — 2026-11-01
+
+- A character open in another terminal cannot be opened a second time.
+- The Travel tab stays open after you depart.
+- A screen refresh setting: game loops repaint at most once per refresh.
+
+## 0.1.1 — 2026-11-01
+
+- Vendor window: `d` destroys a stack from your bags or a companion's.
+- Terminal: Ctrl-L repaints, a full repaint on screen change, and a notice when the window is too small.
+
+## 0.1.0 — 2026-11-01
+
+- First release on npm.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azeroth-shell",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "Azeroth shell. A WoW Classic 1.12 text RPG for the terminal, built on CMaNGOS data.",
   "keywords": [
@@ -32,7 +32,8 @@
     "!src/data/gear-art-hd/",
     "!src/data/*.only.bin.br",
     "!src/data/gear-art-hd.only/",
-    "docs/"
+    "docs/",
+    "CHANGELOG.md"
   ],
   "engines": {
     "node": ">=22.18"

package/src/cli/tui.mjs

@@ -9,7 +9,7 @@ import { createCommands } from './repl.mjs';
 import { makeTabs, deathView } from './tuiViews.mjs';
 import { cityAccess, bankDialog, auctionDialog, mailDialog } from './tuiCity.mjs';
 import { startFight, startAutopilot } from './tuiFight.mjs';
-import { openRun } from './tuiDungeon.mjs';
+import { openRun, runCleared, holdRunLonger } from './tuiDungeon.mjs';
 import { openLoot } from './tuiLoot.mjs';
 import { fightPaneRule, fightPaneLines, cycleFightPane, nextPaneId, fightPane } from './tuiFightPanes.mjs';
 import { MemoryPrefs, FilePrefs } from './prefs.mjs';
@@ -84,6 +84,7 @@ const HELP_LINES = [
   '  Bags tab: Enter uses, equips, opens, unwraps or learns; m lists every verb for the stack. s sells to the open',
   '  vendor, j sells junk, b opens the bank, d destroys, S sorts, / splits a stack, [ ] move it, A uses the whole stack.',
   '  D lists every green, blue or epic the group can disenchant; L lists every book someone can learn. G runs it.',
+  '  X marks several stacks to destroy at once; Q marks the quest items left over from quests you turned in. G destroys.',
   '  :dev item|quest|recipe|prof skips the rules (testing). New character offers a random world bot.',
   '  Settings tab (or :settings) sets auto-loot, the upgrade helper, auto-disenchant, the junk rules and which nodes get gathered.',
   '  Spells tab: b edits your action bars, m your macros. :macro <name> runs one; a macro on bar 1 fires by its key in a fight.',
@@ -190,10 +191,11 @@ export class App {
     this.tabs = makeTabs(this);
     this.stack = [];
     this.lastActivity = g.state.activity[0] ?? null;
+    this.inRunId = g.state.instance?.dungeonId ?? null; // holdRunLonger's last seen run, per character
     this.say(bold(`Welcome${isNew ? '' : ' back'}, ${g.state.char.name}.`) + dim('  Press ? for the keys.'));
     if (awayMs >= 60_000) this.offlineRest(Math.floor(awayMs / 1000));
     weeklyHonorPass(this); // a maintenance day passed while away scores that week
-    if (g.state.instance) openRun(this);
+    if (g.state.instance && !runCleared(this)) openRun(this);
     openLoot(this); // an opened bag item's remainder is still claimable after a reload
     if (!this.term.isTTY) return;
     // Out-of-combat regeneration ticks in real time, like standing still in the world.
@@ -499,6 +501,7 @@ export class App {
   /** After any state-changing key: pull activity, save, repaint. */
   afterAction() {
     journeyTick(this);
+    holdRunLonger(this);
     this.flushActivity();
     if (this.g) void this.persist();
     if (this.g && this.isDead() && this.top()?.id !== 'death' && !this.fight) this.push(deathView(this));
@@ -620,7 +623,7 @@ export class App {
   headerLines(L) {
     if (!this.g) {
       const crumbs = this.stack.map((v) => bold(v.title ?? '')).join(dim(' › '));
-      return [bold(' azsh') + dim('  Azeroth shell. WoW Classic 1.12 via CMaNGOS data.'), crumbs ? cut(` ${crumbs}`, L.W) : '', '', dim('─'.repeat(L.W))];
+      return [bold(' azsh') + dim('  Azeroth Shell'), crumbs ? cut(` ${crumbs}`, L.W) : '', '', dim('─'.repeat(L.W))];
     }
     // Watching a run, the name, bars and tabs go: the panel has your frame, and the XP line is what a run is for.
     if (this.compactHeader()) return [runHeaderLine(this, L.W), dim('─'.repeat(L.W))];
@@ -768,7 +771,7 @@ export class App {
 export async function runTui({ term = new RealTerm(), argv = [] } = {}) {
   term.open();
   // The tables take a second or two to load: say so, stage by stage, instead of leaving the screen blank.
-  const loading = (stage) => term.draw([bold(' azsh') + dim('  Azeroth shell. WoW Classic 1.12 via CMaNGOS data.'), '', dim(`  Loading ${stage}…`)]);
+  const loading = (stage) => term.draw([bold(' azsh') + dim('  Azeroth Shell'), '', dim(`  Loading ${stage}…`)]);
   loading('the game');
   await new Promise((r) => setImmediate(r)); // the first frame leaves before the synchronous load holds the loop
   const ds = bootDataStore(loading);

package/src/cli/tuiBulk.mjs

@@ -1,13 +1,14 @@
-// The two bulk bag verbs from phonecraft's bag bar (panels/bagBulkPanel.ts, app/appInteractBulkBags.ts): break
-// down a quality band, and read every recipe, formula and book in the bags onto whoever can take it. Both list
-// first; Enter switches a row off or on, G runs what is on. Rows a quest still needs or that are still an upgrade
+// The bulk bag verbs from phonecraft's bag bar (panels/bagBulkPanel.ts, app/appInteractBulkBags.ts): break
+// down a quality band, read every recipe, formula and book in the bags onto whoever can take it, and destroy
+// several stacks at once (the trash skull's multi-select, and the leftover-quest-items sweep). All list first;
+// Enter switches a row off or on, G runs what is on. Rows a quest still needs or that are still an upgrade
 // start off. p switches between your bags and the whole party's. The runs go through the same engine verbs a
 // single press uses, so a bulk pass never accepts what one-at-a-time would refuse.
 import { bold, dim, yellow, green, red, qualityPaint, plural, itemText } from './text.mjs';
 import { planBulkDisenchant, resolveRosterEnchanters, activeBulkDisenchantRows, bulkDisenchantRowKey } from '../domain/professions/partyDisenchant.ts';
 import { companionsForUpgradeGuard, partyUpgradeEntries, playerEquipOptsFrom } from '../domain/professions/autoDisenchant.ts';
 import { planLearnAllFromBags, activeLearnAllRows } from '../domain/professions/learnAllRecipes.ts';
-import { questNeededItems } from '../domain/quests/questlog.ts';
+import { questNeededItems, leftoverQuestItems } from '../domain/quests/questlog.ts';
 import { itemTeachIntent } from '../domain/items/itemTeaches.ts';
 import { learnOnCompanionPool } from '../domain/spells/learnOnTargets.ts';
 
@@ -160,3 +161,81 @@ function runLearnAll(app, state) {
   const spare = rows.reduce((n, r) => n + r.spare, 0);
   app.say(green(`Learned ${plural(learned, 'book')}.`) + (spare ? dim(`  ${spare} duplicate${spare === 1 ? '' : 's'} left to sell.`) : '') + (firstRefusal ? yellow(`  One refused: ${firstRefusal}.`) : ''));
 }
+
+const DESTROY_TABS = [['all', 'Everything'], ['quest', 'Leftover quest items']];
+
+/** Every stack in scope with its owner, plus the quests a leftover one belonged to (turned in, not repeatable,
+ * not wanted by an open quest: phonecraft's leftoverQuestItems). */
+function destroyCandidates(app, scope) {
+  const st = app.g.state, out = [];
+  for (const { inventory, owner } of bagsInScope(app.g, scope)) {
+    const left = new Map(leftoverQuestItems(st.questlog, inventory, (e) => app.ds.quest(e), (e) => app.ds.item(e), app.ds.quests()).map((r) => [r.slot, r.quests]));
+    inventory.stacks.forEach((stack, slot) => { if (stack) out.push({ stack, owner, quests: left.get(slot) ?? null }); });
+  }
+  return out;
+}
+
+/** Destroy several stacks at once: the trash skull's multi-select from phonecraft's bags (bagsPanel.ts
+ * destroySelectMode) and its leftover-quest-items sweep in one list. Marks are the stack objects themselves,
+ * so a slot shifting under a destroy never lands on the wrong item. */
+export function destroyManyDialog(app, tab = 'all', scope = 'player') {
+  const state = { tab, scope, marked: new Set() };
+  const shown = (a) => destroyCandidates(a, state.scope).filter((c) => state.tab === 'all' || c.quests);
+  const markLeftovers = (a) => { for (const c of destroyCandidates(a, state.scope)) if (c.quests) state.marked.add(c.stack); };
+  if (tab === 'quest') markLeftovers(app);
+  return {
+    id: 'destroy-many', title: 'Destroy', hint: 'Enter: mark / unmark',
+    keys: {
+      G: { hint: 'destroy', fn: (a) => confirmDestroyMany(a, state) },
+      tab: { hint: 'everything / quest leftovers', fn: (a) => { state.tab = state.tab === 'all' ? 'quest' : 'all'; a.top().cursor = 0; } },
+      a: { hint: 'mark all shown', fn: (a) => { for (const c of shown(a)) state.marked.add(c.stack); } },
+      c: { hint: 'clear', fn: () => state.marked.clear() },
+      p: { hint: 'yours / party', fn: (a) => { state.scope = state.scope === 'party' ? 'player' : 'party'; state.marked.clear(); if (state.tab === 'quest') markLeftovers(a); } },
+    },
+    rows(a) {
+      const all = destroyCandidates(a, state.scope);
+      const rows = state.tab === 'all' ? all : all.filter((c) => c.quests);
+      const on = all.filter((c) => state.marked.has(c.stack));
+      const tabs = DESTROY_TABS.map(([t, label]) => (t === state.tab ? bold(`[${label}]`) : dim(label))).join('  ');
+      const out = [H(`${tabs}   ${dim(state.scope === 'party' ? 'the party\'s bags' : 'your bags')}`), H(on.length ? red(`${plural(on.length, 'stack')} (${plural(on.reduce((n, c) => n + c.stack.count, 0), 'item')}) marked. G: destroy`) : dim('Nothing marked. Enter marks a stack, a marks every one shown.')), H('')];
+      if (!rows.length) out.push(H(dim(state.tab === 'quest' ? '  No quest items left over from quests you have turned in.' : '  The bags are empty.')));
+      for (const c of rows) {
+        const it = a.ds.item(c.stack.item);
+        const isOn = state.marked.has(c.stack);
+        const from = c.quests ? c.quests.map((q) => q.title).join(', ') : '';
+        out.push({
+          text: `${isOn ? red('✗') : dim('·')} ${qualityPaint(it?.quality)(it?.name ?? c.stack.item)}${c.stack.count > 1 ? ` x${c.stack.count}` : ''}${c.owner ? dim(`  ${c.owner.name}'s bags`) : ''}${from ? dim(`  ${from}`) : ''}`,
+          detail: () => [bold(itemText(it, '')), ...(from ? ['', dim(`Left over from ${from}.`)] : []), '', dim(isOn ? 'Enter: keep it' : 'Enter: mark it to destroy')],
+          act: () => { if (isOn) state.marked.delete(c.stack); else state.marked.add(c.stack); },
+        });
+      }
+      return out;
+    },
+  };
+}
+
+function confirmDestroyMany(app, state) {
+  // Slots resolved now, before anything splices: highest first per owner, as phonecraft's doDiscardSelected.
+  const targets = [];
+  for (const { inventory, owner } of bagsInScope(app.g, state.scope)) {
+    inventory.stacks.forEach((s, slot) => { if (state.marked.has(s)) targets.push({ owner: owner?.id, slot, item: s.item, count: s.count }); });
+  }
+  if (!targets.length) { app.flashMsg('Nothing marked.'); return; }
+  const pieces = targets.reduce((n, t) => n + t.count, 0);
+  const what = targets.length === 1 ? `${app.itemLabel(targets[0].item)}${pieces > 1 ? ` x${pieces}` : ''}` : `${plural(targets.length, 'stack')} (${plural(pieces, 'item')})`;
+  app.confirm(`Destroy ${what}? This cannot be undone.`, () => {
+    const g = app.g;
+    let stacks = 0, gone = 0, firstRefusal = '';
+    targets.sort((a, b) => (a.owner ?? '').localeCompare(b.owner ?? '') || b.slot - a.slot);
+    for (const t of targets) {
+      const bags = t.owner ? bagsInScope(g, 'party').find((b) => b.owner.id === t.owner)?.inventory : g.state.inventory;
+      if (bags?.stacks[t.slot]?.item !== t.item) continue;
+      const r = t.owner ? g.discardCompanionBagStack(t.owner, t.slot) : g.discardBagStack(t.slot);
+      if (!r.ok) { firstRefusal ||= r.reason ?? 'Cannot destroy'; continue; }
+      stacks++; gone += r.discarded;
+    }
+    state.marked.clear();
+    if (!stacks) { app.say(red(firstRefusal || 'Nothing was destroyed.')); return; }
+    app.say(green(stacks === 1 ? `Destroyed ${what}.` : `Destroyed ${plural(stacks, 'stack')} (${plural(gone, 'item')}).`) + (firstRefusal ? yellow(`  One refused: ${firstRefusal}.`) : ''));
+  });
+}

package/src/cli/tuiCheck.mjs

@@ -107,6 +107,11 @@ check('the stats page draws your body', !hasArt(nativeDisplayId(app.ch.race, app
   check('a costume aura draws its model', costumed);
   check('out of form you are in your gear again', drawn(view({ form: 0 })) === paperdollArt(app.ch, 20, 12)?.join('\n'));
 }
+{
+  // What a fight turns into or brings in is drawn too: Dathrohan's morph to Balnazzar, a shaman's totem, a
+  // witch doctor's ward. None is spawned anywhere, so the bake follows each kit. Cite: bake-model-art.mjs addFightCreatures.
+  check('a boss morph, a totem and a ward have art', [10813, 3903, 3560].every((e) => hasArt(app.ds.creature(e)?.displayId)));
+}
 if (iconsOn()) {
   // A big window: the Gear tab is the character sheet and the Talents tab the three trees, both icon grids
   // the arrows walk in two dimensions. At the usual 110x34 both list instead (the checks above).
@@ -871,7 +876,7 @@ check('b in Bags outside a bank town only flashes', app.stack.length === 0);
 // ---- dungeons: the Deadmines as a text run ------------------------------------------------------------------
 {
   const g = app.g;
-  const { hasFlag } = await import('../world/instances.ts');
+  const { hasFlag, isComplete } = await import('../world/instances.ts');
   g.state.char.level = 20; g.state.char.gold = 10_000_000;
   const bag = ds.items().find((i) => i.slot === 'bag' && i.itemClass !== 11 && (i.bagSlots ?? 0) >= 10 && (i.requiredLevel ?? 1) <= 20 && !i.allowClass?.length);
   for (let i = 0; i < 4; i++) { g.state.inventory = addItem(g.state.inventory, bag.entry, 1, 1); g.equip(bag.entry); }
@@ -942,12 +947,22 @@ check('b in Bags outside a bank town only flashes', app.stack.length === 0);
   check('finish instantly ends on the run report', app.top()?.id === 'run-summary' && /Run report|Cleared|Partial|Wiped/.test(strip(frame())) && (app.dungeonPulls?.length ?? 0) > 2);
   term.press('escape');
   const cleared = g.state.instance.defeated.length;
+  const allDown = isComplete(ds.instance('deadmines'), g.state.instance);
+  {
+    const { portalRows } = await import('./tuiDungeon.mjs');
+    const texts = portalRows(app).map((r) => strip(r.text));
+    check('inside a run, the World tab still lists the zone\'s dungeons, the one you are in marked', texts.some((t) => /The Deadmines .*you are in it/.test(t)) && !texts.some((t) => /Back into/.test(t)));
+  }
   term.press('L');
   check('L leaves and the run is held', !g.state.instance && !!g.state.instanceSaves?.deadmines);
-  check('the portal row shows the held run', /your run is held/.test(strip(frame())));
+  check('a 5-man holds the run for two hours', Math.abs(g.state.instanceSaves.deadmines.expiresAtMs - Date.now() - 2 * 3600_000) < 60_000);
+  check('the portal row shows the held run', allDown ? /cleared, resets in/.test(strip(frame())) : /your run is held/.test(strip(frame())));
   app.top().cursor = rowIndex((r) => r.data?.dungeon?.id === 'deadmines'); term.press('return');
-  check('the entry card offers to go back in', /Go back in/.test(strip(frame())));
-  app.top().cursor = rowIndex((r, t) => /^Go back in/.test(t)); term.press('return');
+  if (allDown) {
+    check('the entry card of a cleared run offers to go back in', /Go back in/.test(strip(frame())) && /You cleared it/.test(strip(frame())));
+    app.top().cursor = rowIndex((r, t) => /^Go back in/.test(t)); term.press('return');
+  }
+  check('a held run is walked straight back into', g.state.instance?.dungeonId === 'deadmines');
   check('going back in keeps the cleared stops', g.state.instance?.defeated.length === cleared);
   term.press('R'); term.press('return');
   check('R resets the run', g.state.instance?.defeated.length === 0);
@@ -1351,6 +1366,39 @@ check('b in Bags outside a bank town only flashes', app.stack.length === 0);
   home();
 }
 
+// Destroy several: X marks stacks and G destroys them after a yes; Q opens on the quest leftovers, already marked.
+{
+  const g = app.g;
+  const { isRepeatableQuest, leftoverQuestItems } = await import('../domain/quests/questlog.ts');
+  // Two grey items the bags do not already hold, so one stack each.
+  const [linen, wool] = ds.allItems().filter((it) => it.quality === 0 && !it.slot && (it.stackable ?? 1) > 1 && countItem(g.state.inventory, it.entry) === 0).slice(0, 2);
+  g.state.inventory = addItem(addItem(g.state.inventory, linen.entry, 3, 20), wool.entry, 2, 20);
+  home(); app.switchTab(2); term.press('X'); show('destroy several');
+  check('X opens Destroy with nothing marked', app.top().id === 'destroy-many' && /Nothing marked/.test(strip(frame())));
+  for (const name of [linen.name, wool.name]) { app.top().cursor = rowIndex((r, t) => t.includes(name)); term.press('return'); }
+  check('Enter marks two stacks', /2 stacks .* marked/.test(strip(frame())));
+  term.press('G');
+  check('G asks first', app.top().id === 'pick' && /Destroy 2 stacks/.test(strip(frame())));
+  term.press('return');
+  check('a yes destroys both marked stacks', countItem(g.state.inventory, linen.entry) === 0 && countItem(g.state.inventory, wool.entry) === 0 && app.top().id === 'destroy-many');
+  term.press('escape');
+  const open = new Set(g.state.questlog.quests.map((x) => x.entry));
+  const q = ds.quests().find((d) => !isRepeatableQuest(d) && !open.has(d.entry) && d.itemTargets?.some((t) => ds.item(t.item)?.questItem) && !ds.quests().some((o) => o !== d && o.itemTargets?.some((t) => t.item === d.itemTargets[0].item)));
+  const relic = q && q.itemTargets.find((t) => ds.item(t.item)?.questItem).item;
+  if (relic) {
+    g.state.questlog.quests.push({ entry: q.entry, status: 'turnedIn', kills: {}, objects: {} });
+    g.state.inventory = addItem(g.state.inventory, relic, 1, 20);
+    const left = leftoverQuestItems(g.state.questlog, g.state.inventory, (e) => ds.quest(e), (e) => ds.item(e), ds.quests());
+    check('the turned-in quest leaves its item behind', left.some((r) => r.item === relic));
+    term.press('Q'); show('quest leftovers');
+    check('Q lists the leftover, marked', app.top().id === 'destroy-many' && rowIndex((r, t) => t.startsWith('✗') && t.includes(ds.item(relic).name)) > 0);
+    term.press('G'); term.press('return');
+    check('G and a yes destroy it', countItem(g.state.inventory, relic) === 0);
+    term.press('escape');
+  } else check('the data has a finished quest with a quest item to leave behind', false);
+  home();
+}
+
 // Gear upkeep: durability on the slots, repair one piece, repair all, load ammo, auto consumables.
 {
   const g = app.g;

package/src/cli/tuiCompanionKit.mjs

@@ -9,6 +9,7 @@ import { className } from '../domain/core/ids.ts';
 import { companionLevel, companionCharacter } from '../domain/bots/squad.ts';
 import { listTameablePets, unlockedWarlockDemons, WARLOCK_DEMONS, WARLOCK_DEMON_UNLOCK } from '../domain/bots/botPet.ts';
 import { petKnownSpells, petAutocastOn } from '../domain/pet/pet.ts';
+import { MAX_QUEST_SLOTS } from '../domain/quests/questlog.ts';
 import { SHARE_CATEGORIES, SHARE_CATEGORY_LABEL, SHARE_GROUPS } from '../domain/bots/consumableShare.ts';
 
 const H = (text) => ({ text, header: true });
@@ -114,7 +115,23 @@ export function questRows(app, comp) {
   const offers = g.companionQuestOffers(id);
   const log = (comp.questLog?.quests ?? []).filter((q) => q.status !== 'turnedIn');
   if (!offers.length && !log.length) return [];
-  const rows = [H(''), H(`Their quests ${dim(`${log.length} in the log`)}`)];
+  // Ones you already handed in: their copy never completed (the items never reached their bags), so it
+  // only holds a slot now.
+  const yoursDone = new Set(g.state.questlog.quests.filter((q) => q.status === 'turnedIn').map((q) => q.entry));
+  const stale = log.filter((qs) => qs.status !== 'complete' && yoursDone.has(qs.entry));
+  const rows = [H(''), H(`Their quests ${dim(`${log.length}/${MAX_QUEST_SLOTS} in the log   x: abandon`)}`)];
+  if (stale.length) {
+    const titles = stale.map((qs) => ds.quest(qs.entry)?.title ?? qs.entry);
+    rows.push({
+      text: yellow(`Drop the ${plural(stale.length, 'quest')} you already handed in`),
+      detail: () => [bold('Handed in without them'), '', 'You turned these in, but their copy never completed, usually because the quest item never reached their bags. They hold log slots, and a full log refuses shared quests.', '', ...titles.map((t) => `  ${t}`)],
+      act: () => app.confirm(`${comp.name} abandons ${plural(stale.length, 'quest')}: ${titles.join(', ')}?`, () => {
+        let n = 0;
+        for (const qs of stale) if (g.abandonCompanionQuest(id, qs.entry).ok) n++;
+        app.say(dim(`${comp.name} abandons ${plural(n, 'quest')}.`));
+      }),
+    });
+  }
   for (const o of offers) {
     rows.push({
       text: o.kind === 'turn-in' ? `${green('?')} Hand in ${o.title}` : `${yellow('!')} Take ${o.title}${o.itemEntry ? dim(`  from ${app.itemLabel(o.itemEntry)}`) : ''}`,
@@ -130,7 +147,8 @@ export function questRows(app, comp) {
   }
   for (const qs of log) {
     const q = ds.quest(qs.entry);
-    rows.push({ text: `  ${q?.title ?? qs.entry} ${qs.status === 'complete' ? green('(Complete)') : ''}`, detail: () => [bold(q?.title ?? ''), '', dim('x: abandon')], keys: { x: (a) => a.confirm(`${comp.name} abandons ${q?.title}?`, () => a.result(g.abandonCompanionQuest(id, qs.entry), `${comp.name} abandons ${q?.title}.`)) } });
+    const done = qs.status === 'complete' ? green('(Complete)') : yoursDone.has(qs.entry) ? dim('(you handed it in)') : '';
+    rows.push({ text: `  ${q?.title ?? qs.entry} ${done}`, detail: () => [bold(q?.title ?? ''), '', dim('x: abandon')], keys: { x: (a) => a.confirm(`${comp.name} abandons ${q?.title}?`, () => a.result(g.abandonCompanionQuest(id, qs.entry), `${comp.name} abandons ${q?.title}.`)) } });
   }
   return rows;
 }

package/src/cli/tuiDungeon.mjs

@@ -27,7 +27,7 @@ import { isSkippableBeginFailure } from '../engine/game/types.ts';
 import {
   instancePortals, routeEncounterList, routeEncounterIdList, encounterOf, isCleared, isUnlocked, nextEncounter,
   isComplete, requiredFlags, hasFlag, routeBossProgress, applyEncounterCleared, autoAdvanceRouteGates,
-  itemDropsInsideInstance, lockRemainingMs, restoreSavedRun, canEnter,
+  itemDropsInsideInstance, lockRemainingMs, restoreSavedRun, canEnter, NORMAL_INSTANCE_RESET_TIME_MS,
 } from '../world/instances.ts';
 import { instanceObjectPins, lootObjectPins, objectGatesFor } from '../world/instanceObjects.ts';
 import { dungeonNpcsForMap } from '../data/dungeonSpawns.ts';
@@ -47,6 +47,12 @@ const hasOwned = (app) => (entry) => countItem(ownedInventory(app.g.state.invent
 const bagCapacityOf = (app) => bagCapacity(app.ch, app.ds);
 const isRaid = (def) => (def.maxPlayers ?? 5) > 5;
 
+/** Inside a run whose every required stop is down: nothing left but the way out. */
+export function runCleared(app) {
+  const def = runDef(app);
+  return !!def && isComplete(def, app.g.state.instance);
+}
+
 /** Bodies in a stop: the pack's counts, or the primary alone. */
 function packSize(enc) {
   const n = (enc.pack ?? []).reduce((s, m) => s + (m.count ?? 1), 0);
@@ -70,38 +76,74 @@ function lockText(app, def, now = Date.now()) {
   const lock = lockRemainingMs(g.state.lockouts ?? {}, def.id, now);
   if (held) {
     const left = (g.state.instanceSaves?.[def.id]?.expiresAtMs ?? now) - now;
+    if (isComplete(def, held)) return green(`cleared, resets in ${secondsText(left)}`);
     return yellow(`your run is held, ${held.defeated.length} cleared, ${secondsText(left)} left`);
   }
   if (lock > 0) return red(`saved, ${secondsText(lock)} left`);
   return '';
 }
 
-/** World tab rows: the instance portals in this zone. */
+/** World tab rows: the instance portals in this zone, the one you are in among them. */
 export function portalRows(app) {
   const g = app.g, ds = app.ds, ch = app.ch;
-  const rows = [];
-  if (g.state.instance) {
-    const def = runDef(app);
-    rows.push(H(''), H('Dungeon'), { text: `${green('▶')} Back into ${bold(def?.name ?? g.state.instance.dungeonId)}`, detail: () => [bold(def?.name ?? ''), 'You are inside this dungeon.', '', dim('Enter: the run window')], act: () => openRun(app) });
-    return rows;
-  }
+  const inside = runDef(app);
   const portals = instancePortals(ds, ch.zoneId).filter((d) => !d.id.startsWith('alterac'));
-  if (!portals.length) return rows;
-  rows.push(H(''), H(`Dungeons (${portals.length})`));
+  // The run you are in is listed even when its door is in another zone.
+  if (inside && !portals.some((d) => d.id === inside.id)) portals.unshift(inside);
+  if (!portals.length) return [];
+  const rows = [H(''), H(`Dungeons (${portals.length})`)];
   for (const def of portals) {
+    const range = dim(`L${def.levelRange[0]}-${def.levelRange[1]}${isRaid(def) ? `  ${def.maxPlayers}-man raid` : ''}`);
+    if (def.id === inside?.id) {
+      rows.push({ text: `${cyan(def.name)} ${range}  ${green('▶ you are in it')}`, data: { dungeon: def }, detail: () => portalLines(app, def), act: () => openRun(app) });
+      continue;
+    }
     const chk = entryCheck(app, def);
     const low = !chk.ok && !restoreSavedRun(g.state.instanceSaves, def.id, Date.now());
     const lock = lockText(app, def);
     rows.push({
-      text: `${low ? dim(def.name) : cyan(def.name)} ${dim(`L${def.levelRange[0]}-${def.levelRange[1]}${isRaid(def) ? `  ${def.maxPlayers}-man raid` : ''}`)}${low && !lock ? red(`  ${chk.reason ?? `requires ${def.minLevel}`}`) : ''}${lock ? `  ${lock}` : ''}`,
+      text: `${low ? dim(def.name) : cyan(def.name)} ${range}${low && !lock ? red(`  ${chk.reason ?? `requires ${def.minLevel}`}`) : ''}${lock ? `  ${lock}` : ''}`,
       data: { dungeon: def },
       detail: () => portalLines(app, def),
-      act: () => app.push(entryDialog(app, def)),
+      act: () => goToDungeon(app, def),
     });
   }
   return rows;
 }
 
+/** Enter on a portal: out of the run you are in (it is held), then straight back into a run you left
+ *  half done, or the entry card for a fresh one. */
+function goToDungeon(app, def) {
+  if (app.g.state.instance) {
+    const was = runDef(app);
+    if (!app.result(app.g.leaveInstance(Date.now()), `You leave ${was?.name ?? 'the dungeon'}.`)) return;
+    app.dungeonPulls = [];
+    app.floor = null;
+    app.stack = [];
+  }
+  const held = restoreSavedRun(app.g.state.instanceSaves, def.id, Date.now());
+  if (held && !isComplete(def, held)) enter(app, def, { routeDensity: held.routeDensity ?? DEFAULT_ROUTE_DENSITY, asRaid: isRaid(def), door: null });
+  else app.push(entryDialog(app, def));
+}
+
+// A 5-man you walk out of stays as you left it for two hours here, not the engine's 30 minutes
+// (NORMAL_INSTANCE_RESET_TIME): time to hearth, sell, repair and come back. Raids keep their lockout.
+const RUN_HOLD_MS = 2 * 60 * 60 * 1000;
+
+/** After every action: when the run you were in is gone (leave, hearth, taxi, another door), stretch its hold. */
+export function holdRunLonger(app) {
+  const g = app.g;
+  if (!g) { app.inRunId = null; return; }
+  const was = app.inRunId, now = g.state.instance?.dungeonId ?? null;
+  app.inRunId = now;
+  if (!was || was === now) return;
+  const def = app.ds.instance(was), save = g.state.instanceSaves?.[was];
+  if (!def || def.lockoutMs > 0 || !save) return;
+  g.state.instanceSaves = { ...g.state.instanceSaves, [was]: { ...save, expiresAtMs: save.expiresAtMs - NORMAL_INSTANCE_RESET_TIME_MS + RUN_HOLD_MS } };
+  const i = g.state.activity.findIndex((l, j) => j < 5 && l.endsWith('It resets in 30 minutes.'));
+  if (i >= 0) g.state.activity[i] = g.state.activity[i].replace('30 minutes', '2 hours');
+}
+
 function portalLines(app, def) {
   const bosses = def.encounters.filter((e) => e.kind === 'boss');
   const out = [bold(def.name), dim(`levels ${def.levelRange[0]}-${def.levelRange[1]}, requires ${def.minLevel}${isRaid(def) ? `, ${def.maxPlayers} players` : ''}`)];
@@ -125,8 +167,10 @@ export function entryDialog(app, def) {
       const squad = g.state.squad ?? [];
       const rows = [H(`${bold(def.name)}  ${dim(`L${def.levelRange[0]}-${def.levelRange[1]}`)}  ${lockText(a, def)}`), H('')];
       const held = restoreSavedRun(g.state.instanceSaves, def.id, Date.now());
-      if (held) rows.push(H(yellow(`Your earlier run is held: ${held.defeated.length} stops cleared. Entering continues it.`)), H(''));
-      rows.push({ text: green(held ? 'Go back in' : 'Enter the dungeon'), detail: () => [bold('Enter'), '', `${opts.routeDensity === 'full' ? 'Every pack on the way' : 'Bosses and what guards them'}; ${opts.asRaid ? 'as a raid, the bench comes too' : `you and ${plural(squad.length, 'companion')}`}.`], act: () => enter(a, def, opts) });
+      const heldDone = held && isComplete(def, held);
+      if (heldDone) rows.push(H(green('You cleared it. The halls stay empty until it resets.')), H(''));
+      else if (held) rows.push(H(yellow(`Your earlier run is held: ${held.defeated.length} stops cleared. Entering continues it.`)), H(''));
+      rows.push({ text: heldDone ? dim('Go back in (nothing left to fight)') : green(held ? 'Go back in' : 'Enter the dungeon'), detail: () => [bold('Enter'), '', `${opts.routeDensity === 'full' ? 'Every pack on the way' : 'Bosses and what guards them'}; ${opts.asRaid ? 'as a raid, the bench comes too' : `you and ${plural(squad.length, 'companion')}`}.`], act: () => enter(a, def, opts) });
       const pace = (d) => ({ text: `Route: ${cyan(d === 'full' ? 'Full' : 'Bosses')}`, detail: () => [bold('Route density'), '', 'Bosses: the bosses and the packs that stand in their way.', 'Full: every pack in the dungeon.', '', dim('Enter: switch')], act: () => { opts.routeDensity = opts.routeDensity === 'full' ? 'bosses' : 'full'; } });
       rows.push(pace(opts.routeDensity));
       if (doors.length) { const all = [null, ...doors]; rows.push({ text: `Door: ${cyan(opts.door?.name ?? 'Main entrance')}`, detail: () => [bold('Which door'), '', 'Some instances have more than one way in; each starts you at its own end of the route.', ...doors.map((d) => `  ${d.name}`), '', dim('Enter: next door')], act: () => { opts.door = all[(all.indexOf(opts.door) + 1) % all.length]; } }); }
@@ -407,7 +451,7 @@ export function runView(app) {
       }
       for (const o of objects.get('_') ?? []) rows.push({ ...objectRow(a, def, o), data: { object: o } });
       rows.push(H(''), { text: `Walk the floor  ${dim('go anywhere; patrols and packs you pass pull on their own (W)')}`, detail: () => [bold('The floor'), '', 'Instead of picking stops, walk the dungeon on its nav mesh. Patrols walk their routes, and whatever sees you on the way pulls.'], act: () => openFloor(a) });
-      rows.push({ text: dim('Leave the dungeon'), detail: () => [bold('Leave'), '', isRaid(def) ? 'A raid holds your progress until the lockout resets.' : 'A 5-man holds your progress for 30 minutes.'], act: () => leaveRun(a) });
+      rows.push({ text: dim('Leave the dungeon'), detail: () => [bold('Leave'), '', isRaid(def) ? 'A raid holds your progress until the lockout resets.' : 'A 5-man holds your progress for 2 hours.'], act: () => leaveRun(a) });
       return rows;
     },
   };

package/src/cli/tuiViews.mjs

@@ -36,7 +36,7 @@ import { petWorldRows, petDialog, hasPetClass } from './tuiPet.mjs';
 import { portalRows } from './tuiDungeon.mjs';
 import { conditionEditor, defaultConditionsForSpell, defaultItemRule } from './tuiRotationCond.mjs';
 import { allyIndexOfSide } from '../engine/core/events.ts';
-import { bulkDisenchantDialog, learnAllDialog } from './tuiBulk.mjs';
+import { bulkDisenchantDialog, learnAllDialog, destroyManyDialog } from './tuiBulk.mjs';
 import { gearExtraRows, durabilityText, repairOne, repairAll, slotRepairLines, enchantLines } from './tuiGear.mjs';
 import { outfitterDialog } from './tuiOutfitter.mjs';
 import { castWithPicker } from './tuiEnchantTarget.mjs';
@@ -574,6 +574,8 @@ function bagsView(app) {
       S: { hint: 'sort', fn: (a) => sortBags(a) },
       D: { hint: 'disenchant all', fn: (a) => a.push(bulkDisenchantDialog(a)) },
       L: { hint: 'learn all', fn: (a) => a.push(learnAllDialog(a)) },
+      X: { hint: 'destroy several', fn: (a) => a.push(destroyManyDialog(a)) },
+      Q: { hint: 'destroy quest leftovers', fn: (a) => a.push(destroyManyDialog(a, 'quest')) },
       A: { fn: onStack(useAll) },
       '/': { fn: onStack(splitStack) },
       '[': { fn: onStack((a, i) => moveStack(a, i, -1)) },

package/src/engine/game/professions.ts

@@ -167,6 +167,7 @@ import {
   creditSquadGoEnder,
   creditSquadKill,
   creditSquadLogs,
+  giveSquadQuestItem,
 } from './squadQuestShare.ts';
 import { applyGoSpellcasterCast } from './applyGoSpellcasterCast.ts';
 import { moneyMarked } from '../../domain/economy/money.ts';
@@ -1558,6 +1559,9 @@ export function createProfessionsModule(
       const yielded: LootDrop[] = goLootTable.length
         ? mergeLootDrops(Array.from({ length: miningTaps }, () => rollLoot(goLootTable, rng, goLootCtx)).flat())
         : [];
+      // Each companion on the quest takes their own copy, as kill loot and dungeon chests already do.
+      // Without it a quest item from an object never reached them and their copy could not finish.
+      for (const y of yielded) giveSquadQuestItem(state, ds, y.item, y.count);
       // HOLD: the object keeps its contents until the player clicks them (the loot window rolls
       // each item's identity as it fills, so taking never re-rolls a suffix).
       let heldLoot: PendingLoot | undefined;

package/src/engine/game/squadQuestShare.ts

@@ -206,6 +206,10 @@ function isPermanentQuestRefusal(reason: string | undefined): boolean {
   return !!reason && (reason.startsWith('Not a quest for ') || reason === 'Unknown quest');
 }
 
+function isUnfinishedTurnIn(reason: string | undefined): boolean {
+  return reason === 'Quest is not complete' || reason === 'Quest failed';
+}
+
 export function shareSquadAccept(
   state: GameState,
   ds: DataStore,
@@ -237,7 +241,15 @@ export function shareSquadTurnIn(
     if (!r.ok) {
       // Only for one who HAS the quest — a companion who never took it was named at accept.
       const held = getQuest(companionQuestLog(comp), entry);
-      if (held && held.status !== 'turnedIn') feed?.(`${comp.name} cannot hand it in: ${r.reason}.`);
+      if (!held || held.status === 'turnedIn') continue;
+      // The party moves on once the player hands in, so a copy that never finished (its item never
+      // reached their bags) would sit in their log for good and fill it. Bags full keeps the quest.
+      if (isUnfinishedTurnIn(r.reason)) {
+        comp.questLog = abandonQuest(companionQuestLog(comp), entry);
+        feed?.(`${comp.name} never finished it and drops it.`);
+      } else {
+        feed?.(`${comp.name} cannot hand it in: ${r.reason}.`);
+      }
       continue;
     }
     if ((r.money ?? 0) > 0) state.char = { ...state.char, gold: state.char.gold + (r.money ?? 0) };