linkchat-extension-spire 0.1.8 → 0.3.0

package/README.md

@@ -1,16 +1,16 @@
-# Spire for LinkChat — 0.1.8
+# Spire for LinkChat — 0.3.0
 
-按需安装的频道合作卡牌爬塔 TUI。需要支持扩展 API 1 的 LinkChatCLI **0.7.0-beta.2 及以上**（旧宿主只支持键盘）；路线图与目标的颜色要 **0.7.3 及以上**，更旧的宿主会把颜色剥离，以及管理员安装并启用 `linkchat-spire` 后端包；后端规则版本 `spire-tui-2`、内容版本 `0.1.0-alpha.2.dev17`，存档版本不一致时明确拒绝加载，不会静默升级进行中的局。
+按需安装的频道合作卡牌爬塔 TUI。需要支持扩展 API 1 的 LinkChatCLI **0.7.0-beta.2 及以上**（旧宿主只支持键盘）；推荐使用 **0.7.4 及以上**以包含备用屏幕行定位修复；路线图与目标的颜色要 **0.7.3 及以上**，更旧的宿主会把颜色剥离，以及管理员安装并启用 `linkchat-spire` 后端包；后端规则版本 `spire-tui-4`、内容版本 `0.1.0-alpha.2.dev17`，存档版本不一致时明确拒绝加载，不会静默升级进行中的局。
 
-离线包安装：`linkchat extension install spire --from /绝对路径/linkchat-extension-spire-0.1.8.tgz`；省略 `--from` 时从官方 registry 安装 `linkchat-extension-spire@latest`。安装后重新打开 LinkChat，输入 `/spire`。2–4 人同频道创建或加入房间，各自准备后开始。断线或退出会暂停整局；所有人重新准备后继续。
+离线包安装：`linkchat extension install spire --from /绝对路径/linkchat-extension-spire-0.3.0.tgz`；省略 `--from` 时从官方 registry 安装 `linkchat-extension-spire@latest`。安装后重新打开 LinkChat，输入 `/spire`。2–4 人同频道创建或加入房间，各自准备后开始。断线或退出会暂停整局；所有人重新准备后继续。
 
 ## 操作
 
-**战斗**：我方在左、敌人在右（宽度不足 100 列或高度不足 30 行时改为上下分区）；每个信息块自上而下是意图、名称、格挡与血条、生命、增益、减益，多个意图字段会换行而不是被截断。手牌竖排并编号 1–9、0：数字键只把光标移到该位置，Enter 才是执行；每页最多十项，PgUp/PgDn 翻页，方向键跨页时页码同步。能量右侧是固定的 `[E 结束回合]` 按钮，和 E 键共用同一套校验，按钮会显示 `[已结束回合]` 或 `[等待队友]`。
+**战斗**：我方在左、敌人在右（默认 80×25 终端使用紧凑双栏，队友在左、敌人在右；有效宽度不足 68 列或高度不足 24 行时改为上下分区）；每个信息块自上而下是意图、名称、格挡与血条、生命、增益、减益，多个意图字段会换行而不是被截断。手牌竖排并编号 1–9、0：数字键只把光标移到该位置，Enter 才是执行；每页最多十项，PgUp/PgDn 翻页，方向键跨页时页码同步。能量右侧是固定的 `[E 结束回合]` 按钮，和 E 键共用同一套校验，按钮会显示 `[已结束回合]` 或 `[等待队友]`。
 
 **选择单体目标**：不再弹出目标名单。使用需要目标的牌或药水后，合法目标会加上边框，直接用键鼠选中战场上的那个实体（名称、血条、状态都属于同一目标）：左右键循环、Enter 或单击提交、Esc 取消本地未提交的操作且不消耗任何东西。目标死亡、牌被消耗或阶段变化时会重新校验，点击不会因为列表重排落到别的身份上。战斗之外使用单体药水时仍给出目标列表。
 
-**地图**：普通视图按真实七列格位纵向分层，起点在下、向上前进；每个房间保留编号（如 `05-C`）和类型。`●` 当前位置、`✓` 已走过、数字为当前可选路线；黄色强调选中房间、普通出边和目标，投票人数仍在房间名后显示。↑ 查看更高层、↓ 查看更低层，←/→ 浏览同层房间，数字键定位可选路线，Enter 对选中的可达房间提交本人路线投票；悬停只查看，单击可达房间即投票。详情显示带编号的真实后继，飞靴额外可达单独列出，不画成普通地图边。`C` 回到当前位置，`F` 切换紧凑连接表，滚轮向上查看更高层、向下查看更低层；窄屏或高度不足时自动显示连接表，每行保留来源和目标编号、类型。地图阶段不再显示底部节点列表；直接在地图选点，底部保留详情和操作提示，Tab 查看其他面板。地图视图最低支持 40 列、12 行；暂停和缺少地图数据时仍保留操作列表。未知房间始终显示为未知。
+**地图**：开局先确认当前角色或选择其他角色，再显示路线。M 打开／关闭地图，战斗中查看地图不会提交路线投票。普通视图按真实七列格位纵向分层，起点在下、向上前进；每个房间保留编号（如 `05-C`）和类型。`●` 当前位置、`✓` 已走过、数字为当前可选路线；黄色强调选中房间、普通出边和目标，投票人数仍在房间名后显示。↑ 查看更高层、↓ 查看更低层，←/→ 浏览同层房间，数字键定位可选路线，Enter 对选中的可达房间提交本人路线投票；悬停只查看，单击可达房间即投票。详情显示带编号的真实后继，飞靴额外可达单独列出，不画成普通地图边。`C` 回到当前位置，`F` 切换紧凑连接表，滚轮向上查看更高层、向下查看更低层；窄屏或高度不足时自动显示连接表，每行保留来源和目标编号、类型。地图阶段不再显示底部节点列表；直接在地图选点，底部保留详情和操作提示，Tab 查看其他面板。地图视图最低支持 40 列、12 行；暂停和缺少地图数据时仍保留操作列表。未知房间始终显示为未知。
 
 **商店**：分类页签（卡牌 / 遗物 / 药水 / 删牌服务）+ 竖向商品列表 + 右侧详情（窄窗口改为列表下方的展开页）。详情显示当前实际价格、半价状态、购买后余额；买不起时显示还差多少并禁止提交，药水栏满时给出"管理药水栏"入口。选中商品后点击 `[购买]` 或按 Enter 即成交，不再二次确认。删牌服务会先给出价格，选完牌再确认费用与目标。`离开商店` 始终在列表里。`[`、`]` 切换分类。
 
@@ -18,7 +18,7 @@
 
 **宝箱**：单人时点选遗物即为一次明确的领取，客户端会在服务端确认后接着领取同一件遗物（按 reward ID 精确匹配，结果不明时不会猜）；多人保留投票、分配、领取三个阶段，投票按钮本身就是确认。
 
-**其他**：Tab 依次查看牌组、抽牌堆、弃牌堆、消耗堆、遗物、药水、状态、日志；Esc 返回或暂停退出；药水面板 D 丢弃药水；多选可用数字键定位、空格勾选、确认行提交，规则允许空选时会给出明确的取消项。请求结果不明时按 R 重试同一操作，不会重复出牌。
+**其他**：Tab 依次查看行动、牌组、遗物、药水、状态、日志，标签随窗口宽度换行；抽牌堆、消耗堆和弃牌堆仅在战斗中显示于能量栏下一行，依次位于左、中、右，点击或按 A / S / D 查看（药水面板的 D 仍为丢弃药水），Esc 返回；Esc 返回或暂停退出；药水面板 D 丢弃药水；多选可用数字键定位、空格勾选、确认行提交，规则允许空选时会给出明确的取消项。请求结果不明时按 R 重试同一操作，不会重复出牌。
 
 **鼠标**（需要客户端宿主 0.7.0 及以上）：鼠标移到某行即高亮该行（等同选中），**单击即生效**；点顶部面板名切换面板；滚轮滚动列表（地图页滚动地图），弹窗有长说明时滚轮翻页。游戏界面会接管鼠标，想在终端里选中或复制文本请按住 Shift 拖拽。旧宿主上鼠标点击不会生效。
 
@@ -31,3 +31,11 @@
 ## 其他
 
 扩展只提供游戏界面，存档在服务器，卸载扩展不会删除存档。正式客户端 0.6.3 不包含扩展功能。此版本为正式版。
+
+## 协议 5 配套更新
+
+本版必须与协议 5 的 Spire 后端一起更新。协议 1–4 会明确提示版本不匹配并阻止游戏操作。聊天 CLI 主程序无需重新发布。
+
+升级预览按当前牌堆读取卡牌，保留战斗中的临时费用；队友面板关闭后恢复原选择。水晶球支持方向键、Enter、空格和鼠标操作。
+
+进阶 A0–A10 全部开放，默认 A0。在创建房间前选择“新局难度”，创建后固定；继续已有单人存档保留原等级。扩展 0.3.0 使用游戏协议 5，需要配套后端。

package/index.js

@@ -1,8 +1,10 @@
 import { randomUUID } from 'node:crypto';
+const PROTOCOL = 5;
+const VERSION_ERROR = 'Spire 客户端与服务器版本不匹配，请配套升级。';
 const BASE = '/api/games/spire/rooms';
 const hpText = creature => creature.awaitingRevive ? '0（待复活）' : creature.hpDisplay === 'infinite' && creature.hp > 0 ? '∞' : `${creature.hp}/${creature.maxHp}`;
 export const phases = { lobby: '等待队友', map: '路线投票', combat: '战斗', reward: '战利品', rest: '休息', shop: '商店', event: '事件', treasure: '宝箱', actComplete: '本幕完成', ending: '结局事件', victory: '通关', defeat: '攀登结束', abandoned: '已放弃' };
-const tabs = ['action', 'deck', 'draw', 'discard', 'exhaust', 'relics', 'potions', 'status', 'log'];
+const tabs = ['action', 'deck', 'relics', 'potions', 'status', 'log'];
 const tabNames = {action:'行动',deck:'牌组',draw:'抽牌堆',discard:'弃牌堆',exhaust:'消耗堆',relics:'遗物',potions:'药水',status:'状态',log:'日志'};
 const powerNames = {strength:'力量',dexterity:'敏捷',weak:'虚弱',vulnerable:'易伤',frail:'脆弱',rage:'狂怒',thorns:'反伤',demonForm:'恶魔形态',darkEmbrace:'黑暗之拥',feelNoPain:'无惧疼痛',rupture:'撕裂',noDraw:'无法抽牌',noBlock:'无法从卡牌获得格挡',darkShackles:'黑暗枷锁',slow:'缓慢',slippery:'滑溜',paperCuts:'纸割'};
 Object.assign(powerNames, {juggling:'杂耍',aggression:'侵略',barricade:'壁垒',corruption:'腐化',colossus:'巨像',crimsonMantle:'猩红披风',cruelty:'残酷',inferno:'炼狱',juggernaut:'势不可挡',pyre:'柴堆',plating:'覆甲',unmovable:'坚如磐石',freeAttack:'免费攻击',vicious:'凶狠',tank:'坦克',guarded:'被守护',covered:'被掩护',intercept:'拦截',oneTwoPunch:'连环拳',stampede:'奔踏',calamity:'灾祸',tagTeam:'接力',knockdown:'击倒',beaconOfHope:'希望灯塔',fasten:'紧固',prepTime:'准备时间',retainHand:'保留手牌',nostalgia:'怀旧',automation:'自动化',panache:'华丽',bomb:'炸弹',rollingBoulder:'滚石',theGambit:'赌局',coordinate:'协同',blockNextTurn:'下回合格挡',setupStrike:'临时力量',vigor:'活力',artifact:'人工制品',poison:'中毒',strangle:'绞杀',freeSkill:'免费技能',drawNextTurn:'下回合抽牌',focus:'集中',temporaryFocus:'临时集中',freePower:'免费能力',energyNextTurn:'下回合能量',temporaryStrengthDown:'临时力量降低',doom:'灾厄',hang:'绞刑',debilitate:'衰弱',sicEm:'咬住',veilpiercer:'虚无免费'});
@@ -46,7 +48,7 @@ Object.assign(powerNames,{ravenous:'食尸增力',plating:'覆甲',tangled:'缠
 // moved on, and the screen has to say so rather than refuse to open. Only the
 // phase check is relaxed, and the caller has to ask for that explicitly.
 function wellFormed(s, knownPhase) {
-  return !!s && [1,2].includes(s.protocol) && typeof s.roomId === 'string' && Number.isSafeInteger(s.revision) && Number.isSafeInteger(s.phaseId) && (knownPhase ? Object.hasOwn(phases, s.phase) : typeof s.phase === 'string')
+  return !!s && s.protocol === PROTOCOL && typeof s.roomId === 'string' && Number.isSafeInteger(s.revision) && Number.isSafeInteger(s.phaseId) && (knownPhase ? Object.hasOwn(phases, s.phase) : typeof s.phase === 'string')
     && Array.isArray(s.players) && s.players.length <= 4 && s.players.every(p => Number.isSafeInteger(p.id) && typeof p.name === 'string')
     && Array.isArray(s.enemies) && s.enemies.length <= 12 && s.enemies.every(e => typeof e.id === 'string' && typeof e.name === 'string' && e.intent)
     && (!s.act || Number.isInteger(s.act.index) && s.act.index>=0 && s.act.index<3 && typeof s.act.name==='string')
@@ -58,6 +60,14 @@ function wellFormed(s, knownPhase) {
     && s.players.every(p=>p.companions===undefined || Array.isArray(p.companions) && p.companions.length<=3 && p.companions.every(pet=>pet && typeof pet.name==='string' && (pet.cooldown===undefined || Number.isSafeInteger(pet.cooldown) && pet.cooldown>=0)))
     && s.players.every(p=>p.monologueInstances===undefined || Array.isArray(p.monologueInstances) && p.monologueInstances.every(record=>record && Number.isSafeInteger(record.strength) && record.strength>0 && Number.isSafeInteger(record.applied) && record.applied>=0))
     && (!s.mapView || typeof s.mapView === 'object' && s.mapView.nodes && s.mapView.nodes.length <= 200 && Array.isArray(s.mapView.nodes) && s.mapView.nodes.every(n => n && typeof n.id === 'string' && Number.isSafeInteger(n.row) && Number.isSafeInteger(n.col) && typeof n.type === 'string' && (n.children === undefined || Array.isArray(n.children))))
+    && (!!s.endTurn && typeof s.endTurn === 'object' && typeof s.endTurn.canEndTurn === 'boolean' && typeof s.endTurn.canUndoEndTurn === 'boolean' && typeof s.endTurn.reason === 'string')
+    && (!s.eventProgress?.sphere || (Number.isSafeInteger(s.eventProgress.sphere.divinations) && s.eventProgress.sphere.divinations >= 0
+        && Number.isSafeInteger(s.eventProgress.sphere.width) && s.eventProgress.sphere.width > 0 && s.eventProgress.sphere.width <= 32
+        && Number.isSafeInteger(s.eventProgress.sphere.height) && s.eventProgress.sphere.height > 0 && s.eventProgress.sphere.height <= 32
+        && typeof s.eventProgress.sphere.tool === 'string' && typeof s.eventProgress.sphere.finished === 'boolean'
+        && Array.isArray(s.eventProgress.sphere.cells) && s.eventProgress.sphere.cells.length <= 1024
+        && s.eventProgress.sphere.cells.every(cell => cell && Number.isSafeInteger(cell.x) && Number.isSafeInteger(cell.y)
+            && (cell.item === null || cell.item === undefined || typeof cell.item === 'string'))))
     && Array.isArray(s.options) && Array.isArray(s.log) && s.log.every(entry => typeof entry === 'string' || entry && Number.isSafeInteger(entry.id) && typeof entry.text === 'string');
 }
 export function validState(s) { return wellFormed(s, true); }
@@ -136,10 +146,14 @@ function mapVotes(node, players) {
 }
 function drawMap(view, width, session = {}) {
   const data = mapData(view), layers = [...data.rows.keys()].sort((a,b) => a-b);
-  const focus = session.focus ?? view.current;
+  const focus = data.byId.has(session.focus) ? session.focus : view.current;
+  const codeLabel = n => `${n.id===focus?'›':' '} ${mapCode(n)}`;
   const labels = new Map(data.nodes.map(n => [n.id, mapLabel(view, data, n, session.options)]));
-  const slot = Math.max(12, ...data.nodes.map(n => displayWidth(labels.get(n.id)) + mapVotes(n, session.players).width + 2));
   const cols = Math.max(6, ...data.nodes.map(n => n.col)) + 1;
+  // An 80-column terminal gives the extension 75 columns after host margins.
+  // Reserve only measured text plus a separator before falling back to a table.
+  const needed = Math.max(8, ...data.nodes.map(n => displayWidth(labels.get(n.id)) + mapVotes(n, session.players).width + 1));
+  const slot = Math.max(needed, width >= cols * 12 ? 12 : 6);
   const unsafeGap = layers.some((layer,i)=>{
     const rooms=data.rows.get(layer), next=data.rows.get(layers[i+1])??[];
     const edges=rooms.flatMap(n=>(n.children??[]).map(id=>[n,data.byId.get(id)]).filter(([,kid])=>kid));
@@ -154,7 +168,7 @@ function drawMap(view, width, session = {}) {
     const rooms = data.rows.get(layers[i]), block = [];
     if (compact) {
       for (const n of rooms) {
-        const label = `${mapCode(n)} ${labels.get(n.id)}`;
+        const label = `${codeLabel(n)} ${labels.get(n.id)}`;
         const kids = (n.children ?? []).map(id => data.byId.get(id)).filter(Boolean);
         const targets=kids.length ? kids.map(k=>`${mapCode(k)}[${k.type}]`) : ['终点'];
         let suffix='';
@@ -169,7 +183,7 @@ function drawMap(view, width, session = {}) {
     } else {
       for (const codes of [true,false]) {
         const pieces = rooms.map(n => {
-          const text = codes ? mapCode(n) : labels.get(n.id);
+          const text = codes ? codeLabel(n) : labels.get(n.id);
           return {at:n.col*slot, text:mapPaint(view,data,n,text,focus)+(codes?'':mapVotes(n,session.players).text), node:n, plain:text};
         });
         const placed = place(pieces,width);
@@ -272,7 +286,10 @@ function cut(text, width) {
 }
 export function createScreen(ctx) {
   let state, roomId, leaseId, connection, online = false, synced = false, rooms = [], loading = true, busy = false, closed = false;
-  let tab = 0, selected = 'create', index = 0, modal, note = '', pending, columns = 80, height = 24, serverProtocol = 1, unsupported;
+  let ascension = 0;
+  const ascensionNames = ['基础', '精英增多', '疲惫旅人', '贫困', '紧束腰带', '进阶之灾', '通货膨胀', '稀缺', '坚韧敌人', '致命敌人', '双重首领'];
+  const ascensionDescriptions = ['无进阶修正', '地图精英配额增加', '古神恢复损失生命的 80%', '战斗与宝箱金币减少', '初始药水栏位减 1', '初始牌组加入进阶之灾', '删牌 100 起，每次增加 50', '稀有卡与升级卡概率降低', '怪物生命与防御等强化', '怪物攻击等强化', '第三幕连续两个不同首领'];
+  let tab = 0, selected = 'create', index = 0, modal, note = '', pending, columns = 80, height = 24, serverProtocol = undefined, unsupported;
   // Frame row -> what that row means, rebuilt by every render.
   let hits = [];
   let targeting;
@@ -294,15 +311,20 @@ export function createScreen(ctx) {
   const changed = () => { if (!closed && !ctx.signal.aborted) ctx.redraw(); };
   const errorText = e => e instanceof Error ? e.message : '游戏请求失败。';
   const me = () => state?.players.find(p => p.id === ctx.user.id);
-  const activeTab = () => tabs[tab];
+  let characterConfirmed=false, mapOpen, mapReturnTab=0;
+  const needsCharacterChoice=()=>!characterConfirmed && !state?.paused && ['lobby','map'].includes(state?.phase) && state?.options.some(row=>row.action?.type==='character');
+  let pileView;
+  const activeTab = () => pileView ?? tabs[tab];
+  function openPile(key) { if(state?.phase!=='combat' || modal)return; pileView=key; index=0;selected=undefined;listPage=0;changed(); }
   const logItems = () => state.log.map((entry, i) => typeof entry === 'string' ? {id:String(i),label:entry} : {id:String(entry.id),label:entry.text});
   // A phase this build cannot render stays read only, so nothing is submitted.
   const canAct = () => !!state && online && synced && !busy && !pending && !unsupported;
   const cardItem = c => ({ id: c.id, label: `${c.name}  [${c.cost}]  ${c.description}`, card: c });
   function items() {
     if (modal) return modal.items;
-    if (!roomId) return [{ id: 'create', label: '创建合作房间（2–4 人）' }, {id:'solo',label:'单人攀登 · 开始／继续'}, ...rooms.filter(r=>r.mode!=='solo').map(r => ({ id: r.id, room: r, label: `${r.players.some(p => p.id === ctx.user.id) ? '继续' : '加入'} · ${r.players.map(p => p.name).join(' / ')} · ${r.players.length}/4 · ${phases[r.phase] ?? r.phase}${r.paused ? ' · 已暂停' : ''}${r.compatible === false ? ' · 版本不兼容' : ''}` }))];
+    if (!roomId) return [{ id: 'create', label: '创建合作房间（2–4 人）' }, {id:'solo',label:rooms.some(r=>r.mode==='solo') ? `继续单人攀登 · A${rooms.find(r=>r.mode==='solo').ascension ?? 0}` : '单人攀登 · 开始'}, {id:'ascension',label:`新局难度 · A${ascension} ${ascensionNames[ascension]}（全部开放）`}, ...rooms.filter(r=>r.mode!=='solo').map(r => ({ id: r.id, room: r, label: `${r.players.some(p => p.id === ctx.user.id) ? '继续' : '加入'} · ${r.players.map(p => p.name).join(' / ')} · A${r.ascension ?? 0} · ${r.players.length}/4 · ${phases[r.phase] ?? r.phase}${r.paused ? ' · 已暂停' : ''}${r.compatible === false ? ' · 版本不兼容' : ''}` }))];
     if (!state) return [];
+    if(needsCharacterChoice())return [{id:'keepCharacter',label:`使用当前角色：${me()?.characterName??me()?.character??'铁甲战士'}`},...state.options.filter(row=>row.action?.type==='character')];
     if (['deck','draw','discard','exhaust'].includes(activeTab())) return (state.self[activeTab()] ?? []).map(cardItem);
     if (activeTab() === 'relics') return state.self.relics.map(r => ({ id: r.id ?? r.key, label: `${r.name}：${r.description}` }));
     if (activeTab() === 'potions') return state.self.potions.map(p => ({ id: p.id, label: `${p.name}：${p.description}`, potion: p }));
@@ -351,17 +373,19 @@ export function createScreen(ctx) {
         : { id: 'rewardDone', label: state.players.length > 1 ? '奖励已结算 · 等待队友' : '奖励已结算 · 等待继续' });
       return rows;
     }
+    if(state.phase==='map' && !state.paused && state.mapView?.nodes?.length)return [{id:'openMap',label:'打开地图 M'}];
     return state.options;
   }
   function anchor() {
     const rows = items(), at = rows.findIndex(row => row.id === selected);
-    index = at >= 0 ? at : Math.max(0, Math.min(index, rows.length - 1)); selected = rows[index]?.id;
+    index = at >= 0 ? at : Math.max(0, Math.min(Number.isFinite(index) ? index : 0, rows.length - 1)); selected = rows[index]?.id;
   }
   function accept(s) {
     // A phase this build does not know means the server moved ahead of the
     // extension: open it read only instead of refusing the whole state.
     const unknownPhase = typeof s?.phase === 'string' && !Object.hasOwn(phases, s.phase);
-    if (!wellFormed(s, !unknownPhase) || s.self.id !== ctx.user.id || s.channelId !== ctx.channel.id || s.roomId !== roomId) throw new Error('游戏状态与客户端不兼容。');
+    if (s?.protocol !== PROTOCOL) { synced=false; note=VERSION_ERROR; changed(); throw new Error(VERSION_ERROR); }
+    if (!wellFormed(s, !unknownPhase) || s.self.id !== ctx.user.id || s.channelId !== ctx.channel.id || s.roomId !== roomId) { synced=false; throw new Error('游戏状态与客户端不兼容。'); }
     // An older snapshot must not clear the read-only guard before it is discarded:
     // check the revision first, then update anything derived from the state.
     if (state && s.revision < state.revision) return;
@@ -379,7 +403,7 @@ export function createScreen(ctx) {
       mapFocus=undefined; mapAnchor=undefined; mapScroll=undefined;
     }
     if (state?.phaseId !== s.phaseId || state?.paused !== s.paused) {
-      modal = undefined; selected = undefined; index = 0; tab = 0;
+      modal = undefined; mapOpen=undefined; pileView=undefined; selected = undefined; index = 0; tab = 0;
       rewardLog = new Map(); rewardOpen = undefined; rewardPick = new Map(); skipQueue = []; skipKnown = new Set();
     }
     if (s.leaseId) { leaseId = s.leaseId; synced = true; }
@@ -409,11 +433,12 @@ export function createScreen(ctx) {
     try { result = await ctx.request(`${BASE}?channelId=${ctx.channel.id}`); }
     catch (e) { if (e?.status === 404) throw new Error('服务器尚未安装或启用 Spire 后端模块。'); throw e; }
     if (closed) return;
-    if (![1,2].includes(result?.protocol) || !Array.isArray(result.rooms)) throw new Error('服务器未启用兼容的游戏模块。');
+    if (result?.protocol !== PROTOCOL) { synced=false; serverProtocol=undefined; throw new Error(VERSION_ERROR); }
+    if (!Array.isArray(result.rooms)) throw new Error('游戏房间列表无效。');
     serverProtocol = result.protocol; rooms = result.rooms; anchor(); loading = false;
   }
   function connect(id) {
-    connection?.close(); roomId = id; state = undefined; leaseId = undefined; synced = false; loading = true; tab = 0; selected = undefined;
+    connection?.close(); characterConfirmed=false;mapOpen=undefined; roomId = id; state = undefined; leaseId = undefined; synced = false; loading = true; tab = 0; selected = undefined;
     connection = ctx.connect(`/ws/games/spire/rooms/${id}`, accept, connected => {
       online = connected; synced = false;
       if (!connected) note = '连接中断，正在重连；操作已暂停。';
@@ -422,12 +447,13 @@ export function createScreen(ctx) {
     });
   }
   async function submit(action, retry = false) {
-    if ((!retry && !canAct()) || !leaseId || !roomId) return;
+    if ((!retry && !canAct()) || !online || !synced || !leaseId || !roomId) return;
     await guard(async () => {
       if (!retry) pending = { actionId: randomUUID(), leaseId, action: { ...action, phaseId: action.phaseId ?? state.phaseId } };
       const envelope = { ...pending, leaseId };
       try {
         const response = await ctx.request(`${BASE}/${roomId}/actions`, 'POST', envelope);
+        if(envelope.action.type==='character'){characterConfirmed=true;mapOpen=undefined;}
         pending = undefined; note = ''; modal = undefined; accept(response);
       } catch (e) {
         // Unknown transport outcomes retain the operation id; R retries exactly
@@ -439,12 +465,34 @@ export function createScreen(ctx) {
     });
   }
   function choose(title, candidates, acceptChoice) {
-    modal = { title, items: candidates, accept: acceptChoice, previousSelected: selected, previousIndex: index }; index = 0; selected = candidates[0]?.id; changed();
+    modal = { title, items: candidates, accept: acceptChoice, previousSelected: selected, previousIndex: index, previousPage: listPage }; listPage = 0; index = 0; selected = candidates[0]?.id; changed();
   }
   function deckChoice(mode, callback) {
     const cards = state.self.deck.filter(c => mode === 'deckUpgrade' ? (!c.upgraded && !['status', 'curse', 'quest'].includes(c.kind)) : mode === 'deckEnchant' ? (c.canSown !== false && !c.sown && !c.inky && !c.enchantment && !['status', 'curse', 'quest'].includes(c.kind)) : c.removable !== false);
     if (!cards.length) { note = '没有符合条件的牌。'; changed(); return; }
-    choose('选择牌组中的牌', cards.map(cardItem), row => callback(row.id));
+    choose('选择牌组中的牌', cards.map(cardItem), row => {
+      if (mode === 'deckUpgrade') { void previewUpgrade(row.id, 'deck', callback); return; }
+      callback(row.id);
+    });
+  }
+  async function previewUpgrade(cardId, source, confirmUpgrade) {
+    if (!roomId || !canAct() || !cardId) return;
+    const originRoom=roomId, originPhase=state.phaseId, originRevision=state.revision;
+    await guard(async () => {
+      const body = await ctx.request(`${BASE}/${originRoom}/previews/upgrade`, 'POST', { cardId, source });
+      if(roomId!==originRoom || state?.phaseId!==originPhase || state?.revision!==originRevision)return;
+      const line = card => `${card.name}  [${card.cost}]  ${card.description}`;
+      const rows = [
+        { id:'before', label:`升级前：${line(body.before)}` },
+        { id:'after', label:`升级后：${line(body.after)}` },
+        { id:'back', label:'返回' },
+      ];
+      if (confirmUpgrade) rows.push({ id:'confirm', label:'确认升级' });
+      choose('升级预览', rows, answer => {
+        if (answer.id === 'confirm') confirmUpgrade(cardId);
+        else { modal=undefined; anchor(); changed(); }
+      });
+    });
   }
   function cardAction(c) {
     if (!canAct() || state.paused || me()?.done || me()?.hp <= 0) return;
@@ -456,13 +504,16 @@ export function createScreen(ctx) {
       else void submit(action);
     };
     const eligible = state.self.hand.filter(x => x.id !== c.id && (c.choice !== 'upgrade' || (!x.upgraded && !['status', 'curse', 'quest'].includes(x.kind))));
-    if (c.choice && eligible.length) choose(c.choice === 'upgrade' ? '选择升级的手牌' : '选择消耗的手牌', eligible.map(cardItem), row => { action.choice = row.id; send(); });
+    if (c.choice && eligible.length) choose(c.choice === 'upgrade' ? '选择升级的手牌' : '选择消耗的手牌', eligible.map(cardItem), row => {
+      const commit=()=>{ action.choice = row.id; send(); };
+      if (c.choice === 'upgrade') void previewUpgrade(row.id, 'hand', commit); else commit();
+    });
     else send();
   }
   // The keyboard branches and clicks move the same state through these, so the
   // two input paths cannot drift apart.
-  function switchTab(next) { tab = ((next % tabs.length) + tabs.length) % tabs.length; index = 0; selected = undefined; changed(); }
-  function moveTo(next) { const list = items(); index = Math.max(0, Math.min(next, list.length - 1)); selected = list[index]?.id; changed(); }
+  function switchTab(next) { pileView=undefined; tab = ((next % tabs.length) + tabs.length) % tabs.length; index = 0; selected = undefined; changed(); }
+  function moveTo(next) { const list = items(); index = Math.max(0, Math.min(Number.isFinite(next) ? next : 0, list.length - 1)); selected = list[index]?.id; changed(); }
   function pageDetail(delta) { modal.detailOffset = Math.max(0, (modal.detailOffset ?? 0) + delta); changed(); }
   function clickRow(id) {
     const list = items(), at = list.findIndex(row => row.id === id);
@@ -773,11 +824,92 @@ function mapHeader(width, view) {
     return hits.filter(hit => hit.row <= y && y < hit.row + hit.height && hit.col <= x && x < hit.col + hit.width)
       .sort((left, right) => left.width * left.height - right.width * right.height)[0];
   }
+  // The divination board. The server sends only the cells a player has looked
+  // at, so the client cannot draw what it has not earned and has no layout of
+  // its own to keep in step.
+  let sphereCursor = { x: 5, y: 5 };
+  function sphereView() { return state?.eventProgress?.sphere; }
+  function sphereGlyph(cell) {
+    if (!cell) return '·';
+    if (cell.item === 'Relic') return 'R';
+    if (cell.item === 'Potion') return 'P';
+    if (cell.item === 'CardReward') return 'C';
+    if (cell.item === 'Gold') return '$';
+    if (cell.item === 'Curse') return '!';
+    return 'o';
+  }
+  function sphereAt(view, x, y) {
+    return (view.cells ?? []).find(cell => cell.x === x && cell.y === y);
+  }
+  function sphereLines(view) {
+    const header = '    ' + Array.from({ length: view.width }, (_, x) => String(x % 10)).join(' ');
+    const lines = [header];
+    for (let y = 0; y < view.height; y += 1) {
+      const cells = [];
+      for (let x = 0; x < view.width; x += 1) {
+        const here = x === sphereCursor.x && y === sphereCursor.y;
+        const glyph = sphereGlyph(sphereAt(view, x, y));
+        cells.push(here ? `[${glyph}` : ` ${glyph}`);
+      }
+      lines.push(`${String(y).padStart(2, ' ')}  ${cells.join('').slice(1)}`);
+    }
+    return lines;
+  }
+  function sphereMove(dx, dy) {
+    const view = sphereView(); if (!view) return;
+    sphereCursor = { x: Math.max(0, Math.min(view.width - 1, sphereCursor.x + dx)),
+                     y: Math.max(0, Math.min(view.height - 1, sphereCursor.y + dy)) };
+    changed();
+  }
+  function sphereUse() {
+    const view = sphereView(); if (!view || view.finished) return;
+    void submit({ type: 'sphere', op: 'use', x: sphereCursor.x, y: sphereCursor.y });
+  }
+  function sphereTool() {
+    const view = sphereView(); if (!view || view.finished) return;
+    void submit({ type: 'sphere', op: 'tool', tool: view.tool === 'Big' ? 'Small' : 'Big' });
+  }
+  // Teammate detail. Read only, and paged on the server: the client asks for a
+  // page and shows what comes back, so it never holds a second copy of anyone's
+  // deck and never has to keep one in step.
+  async function inspectPlayer(id, page = 0) {
+    if (!roomId || !canAct()) return;
+    await guard(async () => {
+      const body = await ctx.request(`${BASE}/${roomId}/players/${id}/inspection?page=${page}`);
+      const rows = body.rows ?? [];
+      const first = body.total === 0 ? 0 : page * (body.pageSize ?? 40) + 1;
+      const last = page * (body.pageSize ?? 40) + rows.length;
+      const pages = Math.max(1, Math.ceil(body.total / (body.pageSize ?? 40)));
+      const previous = modal?.inspection ? {previousSelected:modal.previousSelected, previousIndex:modal.previousIndex, previousPage:modal.previousPage} : undefined;
+      choose(`${body.name} · ${first}-${last}/${body.total} · 第 ${page + 1}/${pages} 页`,
+        rows.map((row, i) => ({ id: `i${i}`, label: `${row.pile === 'status' ? powerNames[row.key] ?? row.key : row.name ?? row.key}${row.amount !== undefined ? ` ${row.amount}` : ''}${row.description ? `：${row.description}` : ''}${row.upgraded ? ' +' : ''}` })),
+        () => { anchor(); changed(); });
+      if(previous)Object.assign(modal,previous);
+      modal.inspection={id,page,pages,total:body.total};
+      changed();
+    });
+  }
+  function endTurnState() {
+    return state.endTurn;
+  }
+  // One key, three states. The server decides which applies and why, so the
+  // client never has to infer "the turn is resolving" from the phase.
   function endTurn() {
-    if (modal || !canAct() || state?.phase !== 'combat' || state.paused || state.pendingChoice || state.pendingDecision) return;
-    if (me()?.done || (me()?.hp ?? 0) <= 0) return;
+    if (modal || !canAct() || state?.phase !== 'combat' || state.paused) return;
+    const control = endTurnState();
+    if (control.canUndoEndTurn) { void submit({ type: 'undoEnd', turn: state.turn }); return; }
+    if (!control.canEndTurn) return;
     void submit({ type: 'end' });
   }
+  function endTurnLabel() {
+    const own = me();
+    if ((own?.hp ?? 0) <= 0) return '[已倒下]';
+    if (state?.phase !== 'combat') return '';
+    const control = endTurnState();
+    if (control.canUndoEndTurn) return '[E 撤销结束回合]';
+    if (control.canEndTurn) return state.paused ? '[等待继续]' : '[E 结束回合]';
+    return state.paused ? '[等待继续]' : `[${control.reason || '等待结算'}]`;
+  }
   function inspectEntity(id) {
     const enemy = (state.enemies ?? []).find(entry => entry.id === id);
     const player = (state.players ?? []).find(entry => String(entry.id) === id);
@@ -849,12 +981,15 @@ function mapHeader(width, view) {
   function confirm() {
     if (busy || pending) return;
     anchor(); const row = items()[index]; if (!row) return;
-    if (modal) { const current = modal; modal = undefined; selected = current.previousSelected; index = current.previousIndex; current.accept(row); return; }
+    if (modal) { const current = modal; modal = undefined; selected = current.previousSelected; index = current.previousIndex; listPage = current.previousPage ?? 0; current.accept(row); return; }
     if (!roomId) {
+      if (row.id === 'ascension') { choose('进阶难度 · 效果逐级叠加 · 创建后固定', ascensionNames.map((name, level)=>({id:String(level), label:`A${level} · ${name}：${ascensionDescriptions[level]}${level===ascension ? ' ✓' : ''}`})), choice=>{ascension=Number(choice.id);changed();});return; }
       void guard(async () => {
+        if(serverProtocol!==PROTOCOL)throw new Error(VERSION_ERROR);
         if (row.id === 'create' || row.id === 'solo') {
-          if (row.id === 'solo' && serverProtocol < 2) throw new Error('单人模式需要更新 Spire 后端模块。');
-          const result = await ctx.request(BASE, 'POST', { channelId: ctx.channel.id, requestId: randomUUID(),...(serverProtocol >= 2 ? {mode:row.id==='solo'?'solo':'coop'} : {}) }); connect(result.id);
+          const existing = row.id === 'solo' && rooms.find(r=>r.mode==='solo');
+          if (existing) { if(existing.compatible===false)throw new Error('该存档需要对应版本的后端游戏模块。'); await ctx.request(`${BASE}/${existing.id}/join`, 'POST');connect(existing.id);return; }
+          const result = await ctx.request(BASE, 'POST', { ascension, channelId: ctx.channel.id, requestId: randomUUID(),mode:row.id==='solo'?'solo':'coop' }); connect(result.id);
         } else {
           if (row.room.compatible === false) throw new Error('该存档需要对应版本的后端游戏模块。');
           await ctx.request(`${BASE}/${row.id}/join`, 'POST'); connect(row.id);
@@ -862,6 +997,8 @@ function mapHeader(width, view) {
       }); return;
     }
     if (!canAct()) return;
+    if(row.id==='keepCharacter'){characterConfirmed=true;mapOpen=undefined;selected=undefined;index=0;changed();return;}
+    if(row.id==='openMap'){mapOpen=true;mapReturnTab=tab;tab=0;changed();return;}
     if (tab === 0 && row.pick) {
       const limit = state.pendingChoice?.maximum ?? state.pendingDecision?.maximum ?? 1;
       if (picked.has(row.pick)) picked.delete(row.pick);
@@ -869,7 +1006,7 @@ function mapHeader(width, view) {
       else note=`最多选择 ${limit} 张牌。`;
       changed();return;
     }
-    if (tab === 0 && row.card) { cardAction(row.card); return; }
+    if (tab === 0 && !pileView && row.card) { cardAction(row.card); return; }
     if (activeTab() === 'potions' && row.potion) {
       if (state.self.potionsLocked) { note = '请先完成事件交易，当前不能使用或丢弃药水。'; changed(); return; }
       if (row.potion.usage === 'Automatic') { note = '这瓶药水会自动生效，不能主动使用。'; changed(); return; }
@@ -997,7 +1134,7 @@ function mapHeader(width, view) {
   // The drawing reads the view state and the party; this supplies both.
   const mapLines = (view, width) => drawMap(view, width,
     { full: mapFull, scroll: mapScroll, anchor: mapAnchor, focus:mapFocus, height:mapBudget, players: state?.players, options: state?.options });
-  const mapNavigation = () => !modal && tab===0 && state?.phase==='map' && !state.paused && !state.pendingChoice && !state.pendingDecision && Boolean(state.mapView?.nodes?.length);
+  const mapNavigation = () => !modal && !targeting && !needsCharacterChoice() && tab===0 && (mapOpen??state?.phase==='map') && !state?.paused && !state.pendingChoice && !state.pendingDecision && Boolean(state.mapView?.nodes?.length);
   const screen = {
     render(width, rows) {
       columns = width; height = rows; hits = [];
@@ -1005,7 +1142,7 @@ function mapHeader(width, view) {
       const mark = hit => hits.push({ row: frame.length, col: 0, width: Infinity, height: 1, ...hit });
       if (width < 40 || rows < (mapNavigation()?12:20)) { add(`请扩大终端至至少 40 列、${mapNavigation()?12:20} 行。`, 'title'); add('Esc 返回聊天', 'muted'); return frame; }
       const own = me();
-      const heading = state ? `${state.act ? `第 ${state.act.index + 1} 幕 ${state.act.name} · ` : ''}第 ${state.floor} 层 · ${phases[state.phase]}${state.paused ? ' · 暂停' : ''}` : `Spire · ${ctx.channel.name} · 合作房间`;
+      const heading = needsCharacterChoice() ? '选择初始角色' : state ? `A${state.ascension ?? 0} · ${state.act ? `第 ${state.act.index + 1} 幕 ${state.act.name} · ` : ''}第 ${state.floor} 层 · ${phases[state.phase]}${state.paused ? ' · 暂停' : ''}` : `Spire · ${ctx.channel.name} · 合作房间`;
       const status = state ? `金币 ${own?.gold ?? 0} · 药水 ${(own?.potions ?? []).length}/${own?.potionCapacity ?? 3} · ${state.online?.includes(ctx.user.id) ? '已连接' : '离线'}` : '';
       add(status ? pad(cut(heading, Math.max(8, width - displayWidth(status) - 2)), width - displayWidth(status)) + status : cut(heading, width), 'title');
       if(mapNavigation()) {
@@ -1022,9 +1159,9 @@ function mapHeader(width, view) {
         add(cut(`本幕${drawn.compact?'连接表':'路线'} · ${drawn.from+1}–${Math.min(drawn.total,drawn.from+drawn.span)}/${drawn.total} · ↑ 前进 · 滚轮查看`,width),'muted');
         add(cut(mapDetailText(view,mapData(view)),width),'muted');
         add(cut(busy?'操作处理中…':pending?note:note||(!synced?'等待服务器确认状态…':''),width),pending?'error':'muted');
-        add(cut('↑↓←→ 选节点 · Enter / 单击 投票 · C 定位 · F 总览',width),'muted');
+        add(cut(state.phase==='map'?'↑↓←→ 选节点 · Enter / 单击 投票 · C 定位 · F 总览':'↑↓←→ 查看节点 · 仅查看路线 · M 返回',width),'muted');
         mark({kind:'tab',advance:true});
-        add(cut('[面板 Tab] · 悬停查看 · Esc 返回 · R 重试',width),'muted');
+        add(cut('[面板 Tab] · M 关闭地图 · 悬停查看',width),'muted');
         hits=hits.filter(hit=>hit.row<rows);
         return frame.slice(0,rows);
       }
@@ -1039,7 +1176,41 @@ function mapHeader(width, view) {
           const partyBlocks = party.map(p => allyBlock(p));
           const legalEnemy = enemy => Boolean(targeting && enemy && targeting.arena === 'enemy' && targetIds().includes(enemy.id));
           const legalAlly = id => Boolean(targeting && targeting.arena === 'ally' && targetIds().includes(id));
-          if (wideBattlefield()) {
+          if(width>=68 && rows>=24 && !wideBattlefield()) {
+            // Medium terminals keep the two teams side by side. Party members
+            // stack in the left column; enemies page independently on the right.
+            const leftWidth=Math.floor((width-3)/2),rightWidth=width-leftWidth-3;
+            const budget=Math.max(4,rows-frame.length-10);
+            const room=Math.max(2,Math.min(5,Math.floor(budget/party.length)));
+            const perPage=Math.max(1,Math.floor(budget/room));
+            const pages=Math.max(1,Math.ceil(alive.length/perPage));
+            if(chosen>=0)enemyPage=Math.floor(chosen/perPage);
+            enemyPage=Math.max(0,Math.min(pages-1,enemyPage??0));
+            const shown=alive.slice(enemyPage*perPage,(enemyPage+1)*perPage);
+            const compactBlock=(creature,arena,span)=>{
+              const name=`${arena==='ally'&&creature.id===ctx.user.id?'› ':''}${creature.name}${creature.done?' · 已结束':''}`;
+              const health=`${hpText(creature)} HP · 格挡 ${creature.block}`;
+              const intent=arena==='enemy'?intentLines(creature.intent,creature,state).join(' · '):resourcesText(creature);
+              const powers=powerEntries(creature).map(p=>p.text).join(' · ');
+              const body=[name,health];
+              if(room>=4)body.push(healthBar(creature.hp,creature.maxHp));
+              if(room>=3)body.push(intent||powers||'无额外状态');
+              if(room>=5)body.push(intent?powers:'');
+              return body.map(line=>displayWidth(line)>span-2?cut(line,span-3)+'…':line);
+            };
+            const columns=[party.map(p=>({id:String(p.id),lines:compactBlock(p,'ally',leftWidth),legal:legalAlly(String(p.id))})),
+              shown.map(e=>({id:e.id,lines:compactBlock(e,'enemy',rightWidth),legal:legalEnemy(e)}))];
+            const startRow=frame.length,rendered=[[],[]];
+            columns.forEach((entries,side)=>entries.forEach(entry=>{
+              const top=rendered[side].length;
+              const body=entry.legal?tint(entry.lines,targetTint(entry,targeting.arena),aimed(entry)):entry.lines;
+              rendered[side].push(...body);
+              while(rendered[side].length<top+room)rendered[side].push('');
+              hits.push({kind:'entity',id:entry.id,row:startRow+top,col:side?leftWidth+3:0,width:side?rightWidth:leftWidth,height:room});
+            }));
+            for(let i=0;i<Math.max(...rendered.map(c=>c.length));i++)add(pad(rendered[0][i]??'',leftWidth)+' │ '+(rendered[1][i]??''));
+            if(pages>1){mark({kind:'enemyPage',pages});add(`敌人 ${enemyPage+1}/${pages} 页 · ←/→ 或点击翻页`,'muted');}
+          } else if (wideBattlefield()) {
             // The party column is as wide as what it prints (a fixed third used to
             // cut 增益/减益 short); the enemies share what is left.
             const natural = Math.max(MIN_BLOCK - 2, ...partyBlocks.flat().map(line => displayWidth(line)));
@@ -1098,13 +1269,20 @@ function mapHeader(width, view) {
           const usable = own?.energy ?? 0;
           const capacity = own?.energyCapacity ?? usable;
           const orbs = '●'.repeat(Math.max(0, usable)) + '○'.repeat(Math.max(0, capacity - usable));
-          const button = (own?.hp ?? 0) <= 0 ? '[已倒下]' : own?.done ? '[已结束回合]' : (!canAct() || state.paused) ? '[等待队友]' : '[E 结束回合]';
+          const button = endTurnLabel();
           // §2: the Regent's stars are a resource of the same row as the energy.
           const stars = own?.character === 'regent' || (own?.stars ?? 0) > 0 ? `星星 ${own?.stars ?? 0}` : '';
           const energy = `能量 ${orbs ? `${orbs} ` : ''}${usable}/${capacity}${stars ? `   ${stars}` : ''}`;
           const buttonAt = Math.max(8, width - displayWidth(button) - 1);
           if (!modal) mark({ kind: 'endTurn', id: 'endTurn', col: buttonAt, width: displayWidth(button) });
           add(pad(energy, buttonAt) + button, 'title');
+          const piles=[['draw','A','抽牌堆',state.self.draw?.length??state.self.drawCount??0],
+            ['exhaust','S','消耗堆',state.self.exhaust?.length??state.self.exhaustCount??0],
+            ['discard','D','弃牌堆',state.self.discard.length]];
+          const pileLabels=piles.map(([,key,name,count])=>width<60?`${key} ${name.slice(0,2)}(${count})`:`[${key} ${name}（${count}）]`);
+          const positions=[0,Math.floor((width-displayWidth(pileLabels[1]))/2),width-displayWidth(pileLabels[2])];
+          if(!modal)for(let i=0;i<piles.length;i++)mark({kind:'pile',id:piles[i][0],col:positions[i],width:displayWidth(pileLabels[i])});
+          add(place(pileLabels.map((text,i)=>({at:positions[i],text})),width).text,'muted');
         } else {
           add(`${state.event ?? ''}  金币 ${own?.gold ?? 0}`, 'muted');
           // §2: outside combat there is no battlefield, so the party, its health
@@ -1112,19 +1290,44 @@ function mapHeader(width, view) {
           for (const player of state.players ?? []) {
             const here = state.online?.includes(player.id);
             const flag = !here ? '离线' : state.paused || state.phase === 'lobby' ? (player.ready ? '已准备' : '') : player.done ? '已完成' : '';
-            add(cut(`${player.id === ctx.user.id ? '› ' : '  '}${player.name}${player.characterName ? ` · ${player.characterName}` : ''} ${hpText(player)} HP · 金币 ${player.gold ?? 0}${flag ? ` · ${flag}` : ''}${player.vote ? ` · 已投票 ${player.vote}` : ''}`, width), player.id === ctx.user.id ? 'selected' : 'text');
+            const rowText = cut(`${player.id === ctx.user.id ? '› ' : '  '}${player.name}${player.characterName ? ` · ${player.characterName}` : ''} ${hpText(player)} HP · 金币 ${player.gold ?? 0}${flag ? ` · ${flag}` : ''}${player.vote ? ` · 已投票 ${player.vote}` : ''}`, width);
+            // Clicking a teammate is the same act as pressing P on them. The
+            // mark is taken before the line is pushed, while the row still is
+            // the one it will land on.
+            if (player.id !== ctx.user.id && !modal) mark({ kind: 'inspect', id: String(player.id), width: displayWidth(rowText) });
+            add(rowText, player.id === ctx.user.id ? 'selected' : 'text');
           }
           if (['event', 'ending', 'victory'].includes(state.phase) && state.eventProgress?.description) add(state.eventProgress.description, 'muted');
+          const sphere = sphereView();
+          if (sphere && !modal) {
+            const left = sphere.divinations;
+            add(`占卜剩余 ${left} 次 · 工具：${sphere.tool === 'Big' ? '大（3×3）' : '小（1 格）'} · 方向键移动，空格揭开，T 换工具`,
+                left ? 'title' : 'muted');
+            for (const line of sphereLines(sphere)) add(line, 'text');
+            add('R 遗物 · P 药水 · C 卡牌奖励 · $ 金币 · ! 诅咒 · o 空 · · 未揭开', 'muted');
+          }
 
         }
         const labels = tabs.map((key, i) => {
           const count = ['deck', 'draw', 'discard', 'exhaust'].includes(key) ? state.self[key]?.length ?? (key === 'draw' ? state.self.drawCount : key === 'exhaust' ? state.self.exhaustCount : 0) : undefined;
           const label = tabNames[key] + (count === undefined ? '' : `（${count}）`);
-          return i === tab ? `[${label}]` : label;
+          return !pileView && i === tab ? `[${label}]` : label;
         });
         const decision = state.pendingChoice ?? state.pendingDecision;
-        if (!modal && !(tab === 0 && decision)) mark(width < 100 ? { kind: 'tab', advance: true } : { kind: 'tab', spans: tabSpans(labels) });
-        add(modal?.title ?? (tab === 0 && decision ? `${decision.owner === ctx.user.id ? '' : '等待队友 · '}${decision.title}` : width < 100 ? `${labels[tab]} · Tab 切换面板` : labels.join(' · ')), 'title');
+        if(modal || (tab===0 && decision)) {
+          add(modal?.title ?? `${decision.owner===ctx.user.id?'':'等待队友 · '}${decision.title}`,'title');
+        }else {
+          let text='',spans=[];
+          const flush=()=>{mark({kind:'tab',spans});add(text,'title');text='';spans=[];};
+          for(let i=0;i<labels.length;i++){
+            const label=labels[i];
+            if(text && displayWidth(text+' · '+label)>width)flush();
+            const from=displayWidth(text)+(text?3:0);
+            text+=(text?' · ':'')+label;spans.push({tab:i,from,to:from+displayWidth(label)});
+          }
+          if(text)flush();
+          if(pileView)add(`${tabNames[pileView]} · Esc 返回 · Tab 切换面板`,'title');
+        }
         if (modal?.detail) {
           const lines = ctx.wrap(modal.detail, Math.max(1, width - 2));
           const count = Math.max(1, Math.min(6, rows - frame.length - 9));
@@ -1135,14 +1338,15 @@ function mapHeader(width, view) {
         }
       } else add('频道成员可加入 · R 刷新房间列表', 'muted');
       if (loading) add('正在加载…', 'muted');
-      const logLines = state?.phase === 'combat' && !modal && activeTab() !== 'log' ? Math.min(2, Math.max(0, rows - frame.length - 8)) : 0;
-      if (state) add('');                                          // breathing room above the list
-      anchor(); const list = items(), available = Math.max(1, rows - frame.length - 3 - (logLines ? logLines + 1 : 0));
+      const footerRows=activeTab()==='potions' && !modal ? 2 : 1;
+      const logLines = state?.phase === 'combat' && !modal && activeTab() !== 'log' ? Math.min(2, Math.max(0, rows - frame.length - footerRows - 3)) : 0;
+      if (state && state.phase!=='combat') add('');                                          // breathing room above the list
+      anchor(); const list = items(), available = Math.max(1, rows - frame.length - footerRows - 1 - (logLines ? logLines + 1 : 0));
       pageSize = available;
       const maxPage = Math.max(0, Math.ceil(list.length / available) - 1);
       listPage = Math.max(0, Math.min(maxPage, listPage));
       const start = listPage * available;
-      if (!list.length && !loading) add(state?.phase === 'combat' && !state.paused ? '没有手牌。按 E 结束回合。' : '等待队友，或按 Esc 返回聊天。', 'muted');
+      if (!list.length && !loading) add(pileView ? `${tabNames[pileView]}为空。Esc 返回战斗。` : state?.phase === 'combat' && !state.paused ? '没有手牌。按 E 结束回合。' : '等待队友，或按 Esc 返回聊天。', 'muted');
       // §E: a wide frame puts the shop's detail beside the goods; a narrow one
       // expands it below the list instead.
       const pane = state && state.phase === 'shop' && !modal && list[index]?.shop
@@ -1179,15 +1383,14 @@ function mapHeader(width, view) {
         }
       }
       if (maxPage > 0) add(`第 ${listPage + 1}/${maxPage + 1} 页 · PgUp/PgDn 翻页 · 共 ${list.length} 项`, 'muted');
-      while (frame.length < rows - 3 - (logLines ? logLines + 1 : 0)) add('');
+      while (frame.length < rows - footerRows - (logLines ? logLines + 1 : 0)) add('');
       if (logLines) {
         add('战斗日志', 'muted');
         const recent = logItems().slice(-logLines);
         for (let i = 0; i < logLines; i++) add(recent[i]?.label ?? '', 'muted');
       }
       add(busy ? '操作处理中…' : pending ? note : note || (state && !synced ? '等待服务器确认状态…' : ''), pending ? 'error' : 'muted');
-      add(roomId ? '↑↓ / 1–0 选择 · Enter 确认 · Tab 面板 · E 结束回合 · PgUp/PgDn 翻页' : '↑↓ 选择 · Enter 创建/加入 · R 刷新', 'muted');
-      add('Esc 返回 / 暂停退出 · ? 说明 · R 重试 · B 房间 · D 丢弃药水', 'muted');
+      if(activeTab()==='potions' && !modal)add('D 丢弃药水', 'muted');
       const visible = Math.min(rows, frame.length); hits = hits.filter(hit => hit.row < visible);
       return frame.slice(0, rows);
     },
@@ -1210,6 +1413,11 @@ function mapHeader(width, view) {
         if (name === 'return' || name === 'enter') { submitTarget(targeting.id); return; }
         if (value === 'e') { cancelTargeting(); return; }
       }
+      if(value==='m' && state?.mapView?.nodes?.length && !modal && !targeting && !state.paused && !needsCharacterChoice() && !state.pendingChoice && !state.pendingDecision){
+        if(mapNavigation()){mapOpen=false;tab=mapReturnTab;}
+        else{mapReturnTab=tab;tab=0;mapOpen=true;}
+        changed();return;
+      }
       if (mapNavigation()) {
         if (value === 'c') { mapScroll = undefined; mapFocus = undefined; mapAnchor = undefined; mapFull = false; changed(); return; }
         if (value === 'f') { mapFull = !mapFull; mapScroll=undefined; changed(); return; }
@@ -1231,11 +1439,29 @@ function mapHeader(width, view) {
           return;
         }
         if(['return','enter'].includes(name)){
-          const row=items().find(row=>row.action?.type==='vote' && row.action.node===(mapFocus??state.mapView.current));
+          const row=state.phase==='map' && state.options.find(row=>row.action?.type==='vote' && row.action.node===(mapFocus??state.mapView.current));
           if(row)void submit({...row.action,phaseId:state.phaseId});
           return;
         }
       }
+      if(mapNavigation() && ['a','s','d','e',' '].includes(value))return;
+      if(!modal && !targeting && !pileView && tab===0 && state?.phase==='combat' && ['left','right'].includes(name)){enemyPage=Math.max(0,enemyPage+(name==='right'?1:-1));changed();return;}
+      if(!modal && !targeting && state?.phase==='combat' && ['a','s','d'].includes(value) && !(value==='d' && activeTab()==='potions')){openPile({a:'draw',s:'exhaust',d:'discard'}[value]);return;}
+      if(name==='escape' && pileView && !modal){pileView=undefined;index=0;selected=undefined;changed();return;}
+      // The board takes the arrows before the option list does, or moving on
+      // the grid would scroll the rows underneath it.
+      if (columns>=40 && height>=20 && sphereView() && !sphereView().finished && tab===0 && !pileView && !modal && !targeting) {
+        if (name === 'up') { sphereMove(0, -1); return; }
+        if (name === 'down') { sphereMove(0, 1); return; }
+        if (name === 'left') { sphereMove(-1, 0); return; }
+        if (name === 'right') { sphereMove(1, 0); return; }
+        if (value === 'h') { sphereMove(-1, 0); return; }
+        if (value === 'l') { sphereMove(1, 0); return; }
+        if (value === 'k') { sphereMove(0, -1); return; }
+        if (value === 'j') { sphereMove(0, 1); return; }
+        if (value === ' ' || name === 'space' || name === 'return' || name === 'enter') { sphereUse(); return; }
+        if (value === 't') { sphereTool(); return; }
+      }
       if (value === ' ' && !modal && !targeting) {
         const row = items()[index];
         if (row?.pick) {
@@ -1255,7 +1481,7 @@ function mapHeader(width, view) {
         return;
       }
       if (name === 'escape' || key.ctrl && ['c', 'd'].includes(name)) {
-        if (modal) { selected = modal.previousSelected; index = modal.previousIndex; modal = undefined; anchor(); changed(); }
+        if (modal) { selected = modal.previousSelected; index = modal.previousIndex; listPage = modal.previousPage ?? 0; modal = undefined; anchor(); changed(); }
         else ctx.closeScreen(); return;
       }
       if (columns < 40 || height < (mapNavigation()?12:20)) return;
@@ -1273,14 +1499,37 @@ function mapHeader(width, view) {
         void guard(async () => { connection?.close(); connection = undefined; roomId = undefined; state = undefined; modal = undefined; pending = undefined; online = synced = false; selected = 'create'; index = 0; await loadRooms(); }); return;
       }
       if (name === 'tab' && !modal && state) { switchTab(tab + (key.shift ? -1 : 1)); return; }
-      if (value === 's' && !modal && state) { switchTab(tabs.indexOf('status')); return; }
       // The key and the button share one entry point.
       if (value === 'e' && !modal && !targeting) { endTurn(); return; }
+      if (value === 'p' && !modal && !targeting && state) {
+        const others = (state.players ?? []).filter(player => player.id !== ctx.user.id);
+        if (!others.length) { note = '没有队友可查看。'; changed(); return; }
+        if (others.length === 1) { void inspectPlayer(others[0].id); return; }
+        choose('查看队友', others.map(player => ({ id: String(player.id), player: player.id, label: `${player.name} · ${player.characterName ?? ''}` })),
+               row => { void inspectPlayer(row.player ?? Number(row.id)); });
+        return;
+      }
+      if (value === 'u' && !modal && !targeting && state) {
+        const row=items()[index];
+        const cardId=row?.card?.id ?? row?.shop?.cardId ??
+          (['reward','customReward'].includes(row?.action?.type) && !['skip','reroll','sacrifice'].includes(row.action.card) ? row.action.card : undefined);
+        if (cardId) {
+          const source=row?.shop ? 'shop' : ['reward','customReward'].includes(row?.action?.type) ? 'reward' : ['deck','draw','discard','exhaust'].includes(activeTab()) ? activeTab() : 'hand';
+          void previewUpgrade(cardId,source);
+        }
+        else { note='当前项目没有可预览的升级。';changed(); }
+        return;
+      }
       if (name === 'space' && !modal && tab===0 && state?.pendingChoice?.maximum>1) { confirm();return; }
       if (value === 'd' && !modal && activeTab() === 'potions' && canAct()) {
         if (state.self.potionsLocked) { note = '请先完成事件交易，当前不能使用或丢弃药水。'; changed(); return; }
         const row = items()[index]; if (row?.potion) choose('丢弃这瓶药水？', [{ id: 'no', label: '保留' }, { id: 'yes', label: '丢弃' }], answer => { if (answer.id === 'yes') void submit({ type: 'dropPotion', potion: row.id }); else changed(); }); return;
       }
+      if (modal?.inspection && ['pageup','pagedown'].includes(name)) {
+        const wanted = modal.inspection.page + (name === 'pageup' ? -1 : 1);
+        if (wanted < 0 || wanted >= modal.inspection.pages) return;
+        void inspectPlayer(modal.inspection.id, wanted); return;
+      }
       if (modal?.detail && ['pageup','pagedown'].includes(name)) { pageDetail(name === 'pageup' ? -3 : 3); return; }
       if (name === 'pageup' || name === 'pagedown') {
         const pages = Math.max(1, Math.ceil(items().length / pageSize));
@@ -1320,11 +1569,14 @@ function mapHeader(width, view) {
           // §D: clicking a room you can travel to is the vote itself; any other
           // room is only looked at, and parks the view there.
           mapFocus = hit.id; mapAnchor = hit.id; mapScroll = undefined;
-          const row = items().find(row => row.action?.type === 'vote' && row.id === hit.id);
+          const row = state.phase==='map' && state.options.find(row => row.action?.type === 'vote' && row.action.node === hit.id);
           if (row) { void submit({ ...row.action, phaseId: state.phaseId }); return; }
           changed();
           return;
         }
+        if(hit?.kind==='enemyPage' && !targeting && !modal){enemyPage=(enemyPage+1)%hit.pages;changed();return;}
+        if (hit?.kind === 'inspect') {void inspectPlayer(Number(hit.id));return;}
+        if (hit?.kind === 'pile') {openPile(hit.id);return;}
         if (hit?.kind === 'shopBuy') {
           const row = items()[index];
           const price = row?.shop?.price ?? 0;
@@ -1376,4 +1628,4 @@ export async function run(context) {
 
 
 // Exported so a test can read a drawn act back the way a player does.
-export { drawMap };
+export { drawMap };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkchat-extension-spire",
-  "version": "0.1.8",
+  "version": "0.3.0",
   "type": "module",
   "description": "Optional cooperative card-climbing TUI for LinkChat",
   "license": "UNLICENSED",