@nelsonlongxiang/dsh-open-a2a-net 0.6.28 → 0.6.30

package/nexus-stage/src/planning-card-text.ts

@@ -0,0 +1,73 @@
+/**
+ * Board card text (review 2026-10-27): what a card's title, second line and
+ * tooltip say. Extracted from planning-view so the card rules read in one
+ * place (and the view stays under its M1 module-size cap).
+ *
+ * - Session cards used to read `dsh/11111111 · scout-01` on the second line:
+ *   the title repeated, the handle truncated on every card. The line now
+ *   carries what the session is FOR (its description) and falls back to the
+ *   handle; the handle always rides the tooltip.
+ * - Peer cards titled `192.168.3.157:13080`, clipped by the peer badge with no
+ *   break point. When the host publishes exactly one named team (its host
+ *   row), that name is the title and the address moves to the second line.
+ * @module nexus-stage/planning-card-text
+ */
+import { displayName } from './stage-name'
+import type { RemoteTeamRow } from './federation'
+import type { WorldNode } from './world'
+
+export interface CardText { readonly title: string; readonly sub: string; readonly tip: string }
+
+/**
+ * A description as one plain line. /state `description` is the session's
+ * recent-activity excerpt — the head of its last reply, newlines folded,
+ * capped at 160 chars — so on a real host it reads `# ✅ 已纠正——…`,
+ * `**全绿**`, `` `direct-…` `` and folded tables (`| 环节 | 结果 | |---|`).
+ * The card keeps the prose: it stops at the first table or code fence and
+ * drops heading, emphasis, code and link markup.
+ */
+export function plainLine(text: string): string {
+  let s = text
+  const stop = s.search(/\|| ```|^```/)
+  if (stop >= 0) s = s.slice(0, stop)
+  return s
+    .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1') // [text](url) → text
+    .replace(/(^|\s)#{1,6}\s+/g, '$1') // headings
+    .replace(/\*\*|__|`/g, '') // bold, code
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+/** The remote-team summary a peer card carries: score + count + first names. */
+function remoteSummary(rows: ReadonlyArray<RemoteTeamRow>, score: number | undefined): string {
+  const names = rows.map(r => r.name !== undefined && r.name !== '' ? r.name : r.team)
+  const head = names.slice(0, 2).join('、')
+  const more = names.length > 2 ? ` +${names.length - 2}` : ''
+  return (score !== undefined ? `score ${score} · ` : '') + `${rows.length} 远端团队` + (head !== '' ? `：${head}${more}` : '')
+}
+
+export function cardText(n: WorldNode, remoteRows: ReadonlyArray<RemoteTeamRow>, score: number | undefined): CardText {
+  // gh#38: member cards show their display NAME as the title (the whole
+  // point is picking a person).
+  if (n.id.startsWith('member-')) {
+    const title = n.name !== undefined && n.name !== '' ? n.name : n.team
+    return { title, sub: n.team, tip: n.team }
+  }
+  if (n.remote === true) {
+    const host = n.id.slice('peer-'.length)
+    const named = remoteRows.length === 1 && remoteRows[0]!.name !== undefined && remoteRows[0]!.name !== '' ? remoteRows[0]!.name : undefined
+    const summary = remoteSummary(remoteRows, score)
+    return named !== undefined
+      ? { title: named, sub: `${host} · ${summary}`, tip: `${named}\n${host}\n${summary}` }
+      : { title: host, sub: summary, tip: `${host}\n${summary}` }
+  }
+  const title = displayName(n)
+  const handle = n.team + (n.name !== undefined && n.name !== '' ? ' · ' + n.name : '')
+  const desc = plainLine(n.description ?? '')
+  // When the title fell back to the team label the handle would repeat it
+  // verbatim; then only the suffixes remain.
+  const base = desc !== '' ? desc : handle === title ? '' : n.team
+  const suffix = (n.memberships.length > 1 ? ` · 跨队×${n.memberships.length}` : '')
+    + (n.teams !== undefined && n.teams.length > 0 ? ` · 网络队×${n.teams.length}` : '')
+  return { title, sub: base + suffix, tip: desc !== '' ? `${handle}\n${desc}` : handle }
+}

package/nexus-stage/src/planning-edges.ts

@@ -0,0 +1,26 @@
+/**
+ * The membership spokes' SVG layer (edges.ts stays pure geometry). Moved
+ * out of planning-view (module-size cap) when pointercancel landed.
+ * @module nexus-stage/planning-edges
+ */
+import { starEdges } from './edges'
+import type { WorldModel } from './world'
+
+/**
+ * Stateless, rebuilt wholesale. Derived from the MODEL (not the host's
+ * teams): optimistic membership changes must repaint their edges
+ * immediately, before the host confirms.
+ */
+export function drawMemberEdges(svg: SVGSVGElement, model: WorldModel): void {
+  while (svg.firstChild !== null) svg.firstChild.remove()
+  const teams = model.allFrames().map(([name]) => ({ name, members: model.teamMemberIds(name).map(id => ({ id })) }))
+  for (const e of starEdges(teams, new Map(model.allFrames()), model.positions())) {
+    const line = document.createElementNS('http://www.w3.org/2000/svg', 'line')
+    line.setAttribute('class', 'e-member' + (e.dashed ? ' dashed' : ''))
+    line.setAttribute('x1', String(e.x1))
+    line.setAttribute('y1', String(e.y1))
+    line.setAttribute('x2', String(e.x2))
+    line.setAttribute('y2', String(e.y2))
+    svg.appendChild(line)
+  }
+}

package/nexus-stage/src/planning-fit.ts

@@ -0,0 +1,45 @@
+/**
+ * The board's 适配 (fit) framing (review 2026-10-27).
+ *
+ * 适配 used to fit the local content into the whole board at any scale: a
+ * small board zoomed to 167%, the top frame's title slid under the toolbar,
+ * and the peer cards on the right were cut off. 适配 now frames what the
+ * first-run fit frames:
+ * - local content plus the peer cards;
+ * - the frame titles that sit above their frames;
+ * - never magnified past 100%;
+ * - the area below the HUD (toolbar / status chip), not under it.
+ * @module nexus-stage/planning-fit
+ */
+import { FRAME_HEAD_TOP } from './edges'
+import { fitView, type LayoutViewport, type WorldBounds } from './viewport'
+import { nodeRect, type WorldNode } from './world'
+
+/** Local content bounds ∪ peer cards, lifted to include the frame titles
+ *  (a title straddles its frame's top border, FRAME_HEAD_TOP above it). */
+export function boardBounds(content: WorldBounds | null, nodes: Iterable<WorldNode>): WorldBounds | null {
+  let b = content === null ? null : { ...content, minY: content.minY + FRAME_HEAD_TOP }
+  for (const n of nodes) {
+    if (n.remote !== true) continue
+    const r = nodeRect(n)
+    b = b === null
+      ? { minX: r.x, minY: r.y, maxX: r.x + r.w, maxY: r.y + r.h }
+      : { minX: Math.min(b.minX, r.x), minY: Math.min(b.minY, r.y), maxX: Math.max(b.maxX, r.x + r.w), maxY: Math.max(b.maxY, r.y + r.h) }
+  }
+  return b
+}
+
+/** Fit `bounds` at ≤100% into the board area below the HUD's bottom edge
+ *  (`hudBottom` px from the board's top; 0 when the HUD is not laid out). */
+export function fitBelowHud(bounds: WorldBounds | null, viewW: number, viewH: number, hudBottom: number): LayoutViewport {
+  const inset = hudBottom > 0 && hudBottom < viewH / 2 ? hudBottom : 0
+  const vp = fitView(bounds, viewW, viewH - inset, 1)
+  return inset === 0 || bounds === null ? vp : { ...vp, y: vp.y - inset / vp.scale }
+}
+
+/** The HUD's bottom edge inside the board root: the lowest of the toolbar
+ *  and status chip, plus a small gap; 0 before layout (jsdom, hidden). */
+export function hudBottomOf(...els: ReadonlyArray<HTMLElement>): number {
+  const bottom = Math.max(0, ...els.map(e => e.offsetHeight > 0 ? e.offsetTop + e.offsetHeight : 0))
+  return bottom > 0 ? bottom + 8 : 0
+}

package/nexus-stage/src/planning-legend.ts

@@ -0,0 +1,38 @@
+/**
+ * The board legend (review 2026-10-27, real-host check): a fixed panel at
+ * the bottom-left sat over the lowest frames of a real 66-card board. It is
+ * now a native <details> fold — closed by default, a small 图例 chip that
+ * covers nothing; open, it shows the edge key. The open state is a
+ * per-viewer convenience in browser storage (absent or throwing → closed).
+ * @module nexus-stage/planning-legend
+ */
+const KEY = 'dsh-a2a.board.legend'
+
+/** Build the legend fold. */
+export function createLegend(): HTMLDetailsElement {
+  const legend = document.createElement('details')
+  legend.className = 'p-legend'
+  const summary = document.createElement('summary')
+  summary.textContent = '图例'
+  summary.title = '边的含义（点击展开 / 收起）'
+  const rows = document.createElement('div')
+  rows.className = 'p-legend-rows'
+  const row = (dashed: boolean, text: string, color?: string): void => {
+    const line = document.createElement('span')
+    const bar = document.createElement('i')
+    if (dashed) bar.className = 'dashed'
+    if (color !== undefined) bar.style.borderTopColor = color
+    line.append(bar, document.createTextNode(text))
+    rows.appendChild(line)
+  }
+  row(false, '成员边（星形，框→成员）')
+  row(true, '跨队多属（虚线）')
+  row(false, '活动边（inFlight 路由，瞬时）', 'var(--accent)')
+  row(true, '联邦线（→peer）', 'var(--federal)')
+  legend.append(summary, rows)
+  try { legend.open = window.localStorage.getItem(KEY) === 'open' } catch { /* closed */ }
+  legend.addEventListener('toggle', () => {
+    try { window.localStorage.setItem(KEY, legend.open ? 'open' : 'closed') } catch { /* convenience only */ }
+  })
+  return legend
+}

package/nexus-stage/src/planning-mirror.ts

@@ -0,0 +1,31 @@
+/**
+ * Owner vs mirror on the board (owner ruling 2026-10-29, PR#96: canvas sync
+ * is single owner + mirror). A team belongs to the host that made it; every
+ * other host renders it as a MIRROR of that host's published card and edits
+ * it through the fleet relay. The frame head says so: 「镜像 · <owner host>」,
+ * and 「同步中…」 from the moment a relayed edit is sent until the owner
+ * answers (the relay refreshes the owner's card before replying, so the next
+ * poll already shows the result). Local frames carry no marker — this host
+ * is their owner.
+ * @module nexus-stage/planning-mirror
+ */
+import { peerHostOf } from './federation'
+
+export interface MirrorRoute {
+  readonly text: string
+  readonly title: string
+  readonly syncing: boolean
+}
+
+/** The route line of a remote (mirrored) frame; undefined for a local frame. */
+export function mirrorRoute(ownerUrl: string | undefined, syncing: boolean): MirrorRoute | undefined {
+  if (ownerUrl === undefined) return undefined
+  const host = peerHostOf(ownerUrl)
+  return {
+    text: syncing ? `同步中… · ${host}` : `镜像 · ${host}`,
+    title: syncing
+      ? `已把改动交给属主 ${host}，等待它确认`
+      : `这个团队属于 ${host}，这里显示的是它的镜像；拖入或移出成员会经中继交给 ${host} 执行`,
+    syncing,
+  }
+}

package/nexus-stage/src/planning-overlap.ts

@@ -0,0 +1,159 @@
+/**
+ * Board overlap rules (owner, 2026-10-27: 团队方框需要避免遮盖和覆盖 — frames
+ * must not overlap each other, and a card must not sit on a frame it is not
+ * a member of).
+ *
+ * settleBoard() resolves both, deterministically:
+ * - Frame vs frame: one frame of an overlapping pair steps aside along the
+ *   shortest of the four directions, carrying its members like a drag. The
+ *   frame the user just touched stays where it was put; a remote org frame
+ *   never moves on its own (gh#44: its rect is the user's), so a local frame
+ *   yields to it; two remote frames are left alone.
+ * - Card vs frame: a card lying on a frame it does not belong to goes home
+ *   first — the first free grid seat inside its own frame (memberships in
+ *   state order) — and only a card with no frame (or no free seat) goes
+ *   outside: right of that frame, else below it, else down a column right of
+ *   every frame. No landing spot covers another card or a foreign frame, and
+ *   frames are never moved or resized by this step. Members are never moved
+ *   off their own frame; a member merely outside its frame (PR#85: a frame
+ *   moves only itself) is left where it is.
+ * Callers run it after a frame drag or resize, after 整理成员 / 一键重排,
+ * and once when the board first has content — never on every poll (a poll
+ * does not reposition what the user arranged).
+ *
+ * tidyMembers() is the gh#48 整理成员 grid, moved here from planning-view.
+ * @module nexus-stage/planning-overlap
+ */
+import { NODE_W, NODE_H, nodeRect, type FrameGeom, type WorldModel } from './world'
+
+/** Clearance kept between a moved frame or card and what it stepped off. */
+export const OVERLAP_GAP = 24
+/** Bound on resolution passes (a dense board settles in a few). */
+const MAX_PASSES = 200
+
+type Rect = { readonly x: number; readonly y: number; readonly w: number; readonly h: number }
+const hit = (a: Rect, b: Rect): boolean => a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h
+
+/** The shortest translation that takes `m` clear of `f` (plus the gap). */
+function stepAside(m: Rect, f: Rect): { dx: number; dy: number } {
+  const right = f.x + f.w + OVERLAP_GAP - m.x
+  const left = f.x - OVERLAP_GAP - (m.x + m.w)
+  const down = f.y + f.h + OVERLAP_GAP - m.y
+  const up = f.y - OVERLAP_GAP - (m.y + m.h)
+  const dx = Math.abs(right) <= Math.abs(left) ? right : left
+  const dy = Math.abs(down) <= Math.abs(up) ? down : up
+  return Math.abs(dx) <= Math.abs(dy) ? { dx, dy: 0 } : { dx: 0, dy }
+}
+
+function moveFrame(model: WorldModel, name: string, dx: number, dy: number): void {
+  const snap = model.beginFrameDrag(name)
+  if (snap !== undefined) model.applyFrameDrag(snap, dx, dy)
+}
+
+/** Separate overlapping frames; true when anything moved. */
+export function separateFrames(model: WorldModel, remote: ReadonlySet<string>, touched?: string): boolean {
+  let changed = false
+  for (let pass = 0; pass < MAX_PASSES; pass++) {
+    const frames = model.allFrames()
+    let pair: [string, FrameGeom, string, FrameGeom] | undefined
+    for (let i = 0; i < frames.length && pair === undefined; i++) {
+      for (let j = i + 1; j < frames.length; j++) {
+        const [a, ra] = frames[i]!
+        const [b, rb] = frames[j]!
+        if (remote.has(a) && remote.has(b)) continue
+        if (hit(ra, rb)) { pair = [a, ra, b, rb]; break }
+      }
+    }
+    if (pair === undefined) return changed
+    const [a, ra, b, rb] = pair
+    // Who yields: the lower stay score moves — remote 2 (never moves on its
+    // own), the frame just placed 1, any other 0; a tie moves the later one
+    // in board order. (A plain "a stays" check moved a remote b whenever a
+    // was the frame just placed — order-dependent: PR #83 review.)
+    const stay = (n: string): number => remote.has(n) ? 2 : n === touched ? 1 : 0
+    const [mover, mr, fixed] = stay(a) < stay(b) ? [a, ra, rb] : [b, rb, ra]
+    const { dx, dy } = stepAside(mr, fixed)
+    moveFrame(model, mover, dx, dy)
+    changed = true
+  }
+  return changed
+}
+
+/** Grid of the 整理成员 layout, shared by eviction seats. */
+const PAD = 28
+const GAP_X = 16
+const GAP_Y = 14
+
+/** Card-centred seats inside a frame, row by row (the 整理成员 grid). */
+function seatsIn(f: Rect): Array<{ x: number; y: number }> {
+  const out: Array<{ x: number; y: number }> = []
+  for (let y = f.y + PAD; y + NODE_H <= f.y + f.h - PAD; y += NODE_H + GAP_Y) {
+    for (let x = f.x + PAD; x + NODE_W <= f.x + f.w - PAD; x += NODE_W + GAP_X) out.push({ x: x + NODE_W / 2, y: y + NODE_H / 2 })
+  }
+  return out
+}
+
+/** Move cards off frames they do not belong to; true when anything moved. */
+export function evictStrangers(model: WorldModel): boolean {
+  let changed = false
+  const frames = model.allFrames()
+  const rectOf = new Map(frames)
+  for (const n of model.allNodes()) {
+    const own = new Set(n.memberships.map(m => m.team))
+    const host = frames.find(([name, f]) => !own.has(name) && hit(nodeRect(n), f))
+    if (host === undefined) continue
+    const f = host[1]
+    // Free = no foreign frame and no other card under it (cards read live: earlier evictions count).
+    const free = (p: { x: number; y: number }): boolean => {
+      const r = nodeRect(p)
+      return frames.every(([name, g]) => own.has(name) || !hit(r, g)) &&
+        model.allNodes().every(o => o.id === n.id || !hit(r, nodeRect(o)))
+    }
+    const home = n.memberships.map(m => rectOf.get(m.team)).filter((g): g is FrameGeom => g !== undefined)
+    const seat = home.flatMap(seatsIn).find(free)
+    const right = { x: f.x + f.w + OVERLAP_GAP + NODE_W / 2, y: n.y }
+    const below = { x: n.x, y: f.y + f.h + OVERLAP_GAP + NODE_H / 2 }
+    // Last resort: a column right of every frame, top-down from this frame. A card blocks
+    // at most two seats of this pitch, so 2·cards+1 seats always hold a free one.
+    const farX = Math.max(...frames.map(([, g]) => g.x + g.w)) + OVERLAP_GAP + NODE_W / 2
+    const column = Array.from({ length: 2 * model.allNodes().length + 1 }, (_, i) => ({ x: farX, y: f.y + NODE_H / 2 + i * (NODE_H + GAP_Y) }))
+    const to = seat ?? [right, below, ...column].find(free) ?? column[column.length - 1]!
+    model.dragNodes([n.id], to.x - n.x, to.y - n.y)
+    changed = true
+  }
+  return changed
+}
+
+/** Both rules, frames first (moving a frame can uncover or cover cards). */
+export function settleBoard(model: WorldModel, remote: ReadonlySet<string>, touched?: string): boolean {
+  const framesMoved = separateFrames(model, remote, touched)
+  const cardsMoved = evictStrangers(model)
+  return framesMoved || cardsMoved
+}
+
+/**
+ * gh#48 整理成员: inside every frame, the members that belong to exactly that
+ * one team re-seat into a padded grid; the frame grows downward (bounded) to
+ * fit them. Members of 2+ teams keep their positions.
+ */
+export function tidyMembers(model: WorldModel): void {
+  for (const [name, rect] of model.allFrames()) {
+    const sole = model.teamMemberIds(name)
+      .map(id => model.getNode(id))
+      .filter((n): n is NonNullable<typeof n> => n !== undefined)
+      .filter(n => n.memberships.length === 1)
+    if (sole.length === 0) continue // empty frame / only shared members: untouched
+    const perRow = Math.max(1, Math.floor((rect.w - 2 * PAD + GAP_X) / (NODE_W + GAP_X)))
+    const rows = Math.ceil(sole.length / perRow)
+    const needed = PAD * 2 + rows * NODE_H + (rows - 1) * GAP_Y
+    if (needed > rect.h) model.setFrame(name, { ...rect, h: Math.min(needed, rect.h + 400) })
+    const startX = rect.x + PAD + NODE_W / 2
+    let y = rect.y + PAD + NODE_H / 2
+    sole.forEach((n, i) => {
+      const col = i % perRow
+      if (i > 0 && col === 0) y += NODE_H + GAP_Y
+      const x = startX + col * (NODE_W + GAP_X)
+      model.dragNodes([n.id], x - n.x, y - n.y)
+    })
+  }
+}

package/nexus-stage/src/planning-relayout.ts

@@ -0,0 +1,121 @@
+/**
+ * 「一键重排」board relayout (supervisor order v2, upgrade of gh#48): a
+ * deterministic whole-board re-seat — every LOCAL canvas team frame is
+ * resized from its content (sole-member count drives cols/rows; width AND
+ * height both derive from the grid), then the frames tile in a row flow
+ * (constructively non-overlapping, no collision pass). Multi-team members
+ * never enter the size derivation and never move (their dashed edges
+ * express membership); remote org frames and frameless nodes are out of
+ * scope. Pure geometry: same input, same output — pressing twice is
+ * stable by construction.
+ * @module nexus-stage/planning-relayout
+ */
+import { NODE_W, NODE_H, type FrameGeom, type WorldModel } from './world'
+
+/** Inner padding between frame edge and the card grid (gh#48 family). */
+export const RELAYOUT_PAD = 28
+/** Card gaps inside a frame (same family as the tidy grid). */
+export const RELAYOUT_GAP_X = 16
+export const RELAYOUT_GAP_Y = 14
+/** Gap between neighbouring frames in the row-flow tiling. */
+export const FRAME_GAP = 48
+/** Column cap: perRow = min(4, ceil(sqrt(n))). */
+export const PER_ROW_CAP = 4
+/** Floor widths/heights: keeps the floating title band legible. */
+export const FRAME_MIN_W = 180
+export const FRAME_MIN_H = 90
+/** Default world-space wrap width of one tiling row. */
+export const RELAYOUT_WRAP = 1600
+
+/** One local frame to re-seat: its current rect and its SOLE member ids. */
+export interface RelayoutFrameInput {
+  readonly name: string
+  readonly rect: FrameGeom
+  readonly soleIds: readonly string[]
+}
+
+/** The deterministic outcome: new frame rects and absolute card centers. */
+export interface RelayoutOutput {
+  readonly frames: ReadonlyArray<{ name: string; rect: FrameGeom }>
+  readonly seats: ReadonlyArray<{ id: string; x: number; y: number }>
+}
+
+/**
+ * Derive the whole-board layout. Frame order in = tiling order out (the
+ * caller passes a stable order, e.g. the model's insertion order, which
+ * keeps the result deterministic across presses).
+ */
+export function planBoardRelayout(input: {
+  frames: ReadonlyArray<RelayoutFrameInput>
+  wrapWidth?: number
+}): RelayoutOutput {
+  const wrap = input.wrapWidth ?? RELAYOUT_WRAP
+  // Pass 1 — content-derived size per frame (multi-team members excluded
+  // upstream: soleIds carries exactly the re-seatable cards).
+  const sized = input.frames.map(f => {
+    const n = Math.max(f.soleIds.length, 1)
+    const perRow = Math.min(PER_ROW_CAP, Math.max(1, Math.ceil(Math.sqrt(n))))
+    const rows = Math.ceil(n / perRow)
+    const w = Math.max(FRAME_MIN_W, RELAYOUT_PAD * 2 + perRow * NODE_W + (perRow - 1) * RELAYOUT_GAP_X)
+    const h = Math.max(FRAME_MIN_H, RELAYOUT_PAD * 2 + rows * NODE_H + (rows - 1) * RELAYOUT_GAP_Y)
+    return { name: f.name, w, h, rows, perRow, soleIds: f.soleIds }
+  })
+  // Pass 2 — row-flow tiling: left→right until the wrap width is full,
+  // then advance one row by the tallest frame of the band. Constructive
+  // disjointness: boxes on one band share the y band and never overlap in
+  // x; bands stack with FRAME_GAP.
+  const frames: Array<{ name: string; rect: FrameGeom }> = []
+  const seats: Array<{ id: string; x: number; y: number }> = []
+  let x = 0
+  let y = 0
+  let bandH = 0
+  for (const f of sized) {
+    if (x > 0 && x + f.w > wrap) {
+      x = 0
+      y += bandH + FRAME_GAP
+      bandH = 0
+    }
+    const rect: FrameGeom = { x, y, w: f.w, h: f.h }
+    frames.push({ name: f.name, rect })
+    // Pass 3 — seat the sole cards on the new rect's grid (the gh#48 rule,
+    // driven by the NEW frame geometry).
+    const startX = rect.x + RELAYOUT_PAD + NODE_W / 2
+    let cy = rect.y + RELAYOUT_PAD + NODE_H / 2
+    f.soleIds.forEach((id, i) => {
+      const col = i % f.perRow
+      if (i > 0 && col === 0) cy += NODE_H + RELAYOUT_GAP_Y
+      seats.push({ id, x: startX + col * (NODE_W + RELAYOUT_GAP_X), y: cy })
+    })
+    x += f.w + FRAME_GAP
+    bandH = Math.max(bandH, f.h)
+  }
+  return { frames, seats }
+}
+
+/**
+ * The model adapter (supervisor order v2): collect the LOCAL frames and
+ * their sole members (remote org frames and multi-team members are out of
+ * scope by spec), run the pure planner, apply the rects and seat moves
+ * through the model's own mutation seam. Returns false when nothing is in
+ * scope (the caller decides whether to dirty the layout).
+ */
+export function applyBoardRelayout(model: WorldModel, remoteNames: ReadonlySet<string>): boolean {
+  const frames: Array<{ name: string; rect: FrameGeom; soleIds: string[] }> = []
+  for (const [name, rect] of model.allFrames()) {
+    if (remoteNames.has(name)) continue // remote org frames: untouched
+    const soleIds = model.teamMemberIds(name)
+      .map(id => model.getNode(id))
+      .filter((n): n is NonNullable<typeof n> => n !== undefined)
+      .filter(n => n.memberships.length === 1)
+      .map(n => n.id)
+    frames.push({ name, rect, soleIds })
+  }
+  if (frames.length === 0) return false
+  const out = planBoardRelayout({ frames })
+  for (const f of out.frames) model.setFrame(f.name, f.rect)
+  for (const seat of out.seats) {
+    const n = model.getNode(seat.id)
+    if (n !== undefined) model.dragNodes([seat.id], seat.x - n.x, seat.y - n.y)
+  }
+  return true
+}

package/nexus-stage/src/planning-search.ts

@@ -0,0 +1,168 @@
+/**
+ * 画板全局搜索（属主令 W1）: a toolbar search box (Ctrl+K focuses) over the
+ * board's node FACTS — display name, zone/id8 handle, and host spelling, in
+ * one substring match (case-insensitive). Picking a hit rides the existing
+ * fitView flight chain (the caller frames ~100% and pulses the card);
+ * Escape clears. Pure front end: no backend, no routing, no persistence.
+ * @module nexus-stage/planning-search
+ */
+import { fitView, type LayoutViewport } from './viewport'
+import { NODE_W, NODE_H } from './world'
+/** One searchable node fact row (already display-resolved by the caller). */
+export interface SearchHit {
+  readonly id: string
+  /** Display name (member cards' person name, peer hosts' spelling). */
+  readonly name: string
+  /** The zone/id8 handle (n.team) and any extra host tokens. */
+  readonly team: string
+  /** Optional host/owner token (peer cards carry the host spelling). */
+  readonly host?: string
+}
+
+/** Case-insensitive substring match across name / team / host. */
+export function matchHits(rows: ReadonlyArray<SearchHit>, query: string): SearchHit[] {
+  const q = query.trim().toLowerCase()
+  if (q === '') return []
+  return rows.filter(r =>
+    r.name.toLowerCase().includes(q) || r.team.toLowerCase().includes(q) || (r.host ?? '').toLowerCase().includes(q))
+    .slice(0, 8)
+}
+
+/**
+ * Build the searchable rows from the board model — the SAME display facts
+ * the cards render (member display name / peer host spelling / its handle),
+ * so every hit is a card the user can see.
+ */
+export function hitsFromModel(model: { allNodes(): ReadonlyArray<{ id: string; name?: string; team: string; remote?: boolean }> }, displayName: (n: never) => string): SearchHit[] {
+  return model.allNodes().map(n => {
+    const host = n.id.slice('peer-'.length)
+    const name = n.id.startsWith('member-')
+      ? (n.name !== undefined && n.name !== '' ? n.name : n.team)
+      : n.remote === true ? host : displayName(n as never)
+    return { id: n.id, name, team: n.team, ...(n.remote === true ? { host } : {}) }
+  })
+}
+
+/** W1 pulse: briefly ring the picked card (class removed on the timer). */
+export function pulseCard(el: HTMLElement | undefined, ms = 1200): void {
+  if (el === undefined) return
+  el.classList.add('pulse')
+  setTimeout(() => el.classList.remove('pulse'), ms)
+}
+
+/** The view seams the node flyer needs (the view keeps owning its model). */
+export interface NodeFlyerSpec {
+  readonly model: { getNode(id: string): { x: number; y: number } | undefined }
+  readonly viewSize: () => { w: number; h: number }
+  readonly setVp: (vp: LayoutViewport) => void
+  readonly applyViewport: () => void
+  readonly markDirty: () => void
+  readonly cardEl: (id: string) => HTMLElement | undefined
+}
+
+/**
+ * W1 pick flight: frame ONE node's rect at ~100% (the same fitView chain the
+ * statusbar fly rides) and pulse its card for 1.2s.
+ */
+export function createNodeFlyer(spec: NodeFlyerSpec): (id: string) => void {
+  return id => {
+    const n = spec.model.getNode(id)
+    if (n === undefined) return
+    const size = spec.viewSize()
+    // fitView takes WorldBounds ({minX,minY,maxX,maxY}), not the card rect —
+    // passing {x,y,w,h} silently yielded NaN → IDENTITY (flight never landed).
+    spec.setVp(fitView({ minX: n.x, minY: n.y, maxX: n.x + NODE_W, maxY: n.y + NODE_H }, size.w, size.h, 1))
+    spec.applyViewport()
+    spec.markDirty()
+    pulseCard(spec.cardEl(id))
+  }
+}
+
+export interface SearchMount extends PlanningSearch {
+  /** Rebuild the index from the model (call from the node reconcile). */
+  refresh(): void
+}
+
+/**
+ * Mount the whole search surface into the toolbar — the wiring lines the
+ * view used to carry live here (create + append + index builder), keeping
+ * the view under the M1 ratchet; the view keeps ONE call.
+ */
+export function mountBoardSearch(
+  toolbar: HTMLElement,
+  model: Parameters<typeof hitsFromModel>[0],
+  displayName: Parameters<typeof hitsFromModel>[1],
+  onPick: (id: string) => void,
+): SearchMount {
+  const search = createPlanningSearch({ onPick })
+  toolbar.appendChild(search.root)
+  return { ...search, refresh: () => search.setIndex(hitsFromModel(model, displayName)) }
+}
+
+export interface PlanningSearch {
+  readonly root: HTMLElement
+  /** Refresh the searchable index (called from the node reconcile). */
+  setIndex(rows: ReadonlyArray<SearchHit>): void
+  /** Focus the box (Ctrl+K) and select the current text. */
+  focus(): void
+  /** Clear the query and the dropdown (Escape elsewhere). */
+  clear(): void
+}
+
+/** Build the search box widget (input + hit list + keyboard handling). */
+export function createPlanningSearch(opts: { onPick: (id: string) => void }): PlanningSearch {
+  const root = document.createElement('div')
+  root.className = 'p-search'
+  const input = document.createElement('input')
+  input.type = 'search'
+  input.className = 'p-search-input'
+  // Short enough to read whole in the 170px box (review 2026-10-27); the
+  // full scope rides the tooltip and the accessible name.
+  input.placeholder = '🔍 搜索（Ctrl+K）'
+  input.title = '搜索名字 / 句柄 / 宿主（Ctrl+K 聚焦，Esc 清空）'
+  input.setAttribute('aria-label', '搜索画板节点：名字、句柄或宿主')
+  const list = document.createElement('div')
+  list.className = 'p-search-list'
+  let rows: ReadonlyArray<SearchHit> = []
+  let hits: SearchHit[] = []
+  let active = 0
+  const close = (): void => { list.style.display = 'none'; list.textContent = '' }
+  const paint = (): void => {
+    list.textContent = ''
+    if (hits.length === 0) { close(); return }
+    hits.forEach((h, i) => {
+      const row = document.createElement('div')
+      row.className = 'p-search-hit' + (i === active ? ' active' : '')
+      row.dataset.id = h.id
+      row.textContent = h.name === h.team ? h.name : `${h.name} · ${h.team}`
+      row.addEventListener('mousedown', ev => { ev.preventDefault(); opts.onPick(h.id); clearBox() })
+      list.appendChild(row)
+    })
+    list.style.display = 'block'
+  }
+  const clearBox = (): void => { input.value = ''; hits = []; close() }
+  const refresh = (): void => { hits = matchHits(rows, input.value); active = 0; paint() }
+  input.addEventListener('input', refresh)
+  input.addEventListener('keydown', ev => {
+    if (ev.key === 'Escape') { clearBox(); input.blur(); ev.stopPropagation(); return }
+    if (ev.key === 'ArrowDown' || ev.key === 'ArrowUp') {
+      if (hits.length === 0) return
+      ev.preventDefault()
+      active = (active + (ev.key === 'ArrowDown' ? 1 : hits.length - 1)) % hits.length
+      paint()
+      return
+    }
+    if (ev.key === 'Enter' && hits.length > 0) {
+      ev.preventDefault()
+      opts.onPick(hits[active]!.id)
+      clearBox()
+    }
+  })
+  root.append(input, list)
+  return {
+    root,
+    setIndex(next) { rows = next; if (input.value !== '') refresh() },
+    focus() { input.focus(); input.select() },
+    clear() { clearBox() },
+  }
+}

package/nexus-stage/src/planning-types.ts

@@ -105,6 +105,7 @@ export interface PlanningView {
     pointerDown(ev: SeamPointer): void
     pointerMove(ev: SeamPointer): void
     pointerUp(ev: SeamPointer): void
+    pointerCancel(ev: SeamPointer): void
     wheel(ev: SeamPointer): void
     key(ev: SeamKey): void
     keyUp(ev: SeamKey): void