@nelsonlongxiang/dsh-open-a2a-net 0.6.31 → 0.6.33

package/lib/types/tools/info.d.ts

@@ -0,0 +1,102 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { Config } from '../index.ts';
+import type { CardCacheEntry, InFlightRoute, RouteActivityEntry } from '../runtime.ts';
+import type { A2aPeerCard } from '../types.ts';
+import type { ZoneCardFetch } from '../zone.ts';
+import type { A2aClient, CardFetchOutcome } from '../a2a-client.ts';
+import type { CanvasStore } from '../canvas-store.ts';
+import type { ExposureStore } from '../exposure-store.ts';
+import type { IdempotencyStore } from '../idempotency-store.ts';
+import type { JoinedSessions } from '../joined-store.ts';
+import type { PeerStore } from '../peer-store.ts';
+import type { TaskLedger } from '../task-ledger.ts';
+import type { TeamMembershipStore } from '../team-store.ts';
+/** One directory row shared with listDirectoryTeams (which stays in index.ts). */
+export type DirectoryTeamRow = {
+    team: string;
+    session: string;
+    name: string;
+    description: string;
+    local?: boolean;
+    origin?: string;
+    workspace?: string;
+    via?: string;
+    legacy?: boolean; /** gh#106: the peer's last card fetch missed — this row is its kept card, not a live answer. */
+    unreachable?: boolean;
+    teams?: string[]; /** Internal S5 scope hint, stripped before the tool's public output. */
+    canvasMembers?: readonly string[];
+};
+/** Everything the information-plane tools capture from apply(). */
+export interface InfoToolsDeps {
+    readonly ctx: Context;
+    readonly config: Config;
+    readonly logger: ReturnType<Context['logger']>;
+    readonly session: string;
+    readonly lanIp: string;
+    readonly ownCardUrl: string;
+    readonly peerStore: PeerStore;
+    readonly taskLedger: TaskLedger;
+    readonly joinedSessions: JoinedSessions;
+    readonly teamMemberships: TeamMembershipStore;
+    readonly canvasStore: CanvasStore;
+    readonly exposureStore: ExposureStore;
+    readonly idempotencyStore: IdempotencyStore;
+    readonly cardCache: Map<string, CardCacheEntry>;
+    readonly inFlightRoutes: Map<number, InFlightRoute>;
+    readonly recentActivity: RouteActivityEntry[];
+    readonly teamAuditRing: {
+        at: number;
+        action: 'join' | 'leave' | 'archive-prune' | 'agent-less';
+        team: string;
+        id: string;
+        ok: boolean;
+        reason?: string;
+    }[];
+    readonly reportRing: {
+        at: number;
+        level: 'info' | 'warning' | 'error';
+        message: string;
+        session: string;
+        task?: string;
+    }[];
+    readonly sessionNodes: Map<string, Agent>;
+    readonly ownerAllowlist: readonly string[];
+    readonly ownerTeamScopeInfo: boolean;
+    readonly id8: (id: string) => string;
+    readonly sessionTeamOf: (agent: Agent) => string;
+    readonly nodeMetadataOf: (agent: Agent) => {
+        name: string;
+        description: string;
+        workspace?: string;
+    };
+    readonly canvasTeamOf: (name: string) => string;
+    /** gh#152: the session's canvas teams read through the local lens — a handle-stored membership of this session counts. */
+    readonly canvasTeamsOfSession: (id: string) => string[];
+    /** Resolve a handle against the current local/seeded-peer collision snapshot. */
+    readonly localHandleResolver: () => (ref: string) => string | undefined;
+    readonly memoizedCardFetch: () => ZoneCardFetch;
+    readonly mapBounded: <T, R>(items: readonly T[], limit: number, task: (item: T) => Promise<R>) => Promise<R[]>;
+    readonly SWEEP_CONCURRENCY: number;
+    readonly a2aJoinGateRefusal: (exec: {
+        agent?: {
+            id: unknown;
+        };
+    } | undefined) => void;
+    readonly observeAuthorization: (cause: string) => void;
+    readonly settlePeerCard: (peer: string, outcome: CardFetchOutcome) => A2aPeerCard | undefined;
+    readonly client: A2aClient;
+    readonly listDirectoryTeams: (expand: boolean, includeCanvas?: boolean) => Promise<DirectoryTeamRow[]>;
+}
+/**
+ * Build the five registrars. Call createInfoTools after its deps exist, then
+ * invoke each registrar at the tool's original registration position — the
+ * registry order the model sees must not change.
+ */
+export declare function createInfoTools(deps: InfoToolsDeps): {
+    registerWhoami: () => void;
+    registerTeams: () => void;
+    registerStatus: () => void;
+    registerTasks: () => void;
+    registerProbe: () => void;
+};

package/lib/types/types.d.ts

@@ -129,6 +129,12 @@ export interface A2aRouteOk {
      * receipt-owed (`trackOwedTask` skips it).
      */
     readonly bridge?: 'native-teams';
+    /**
+     * gh#141: the peer refused the settlement the delivered message carried
+     * (its enforce verdict, `settlement: {status: 'refused'}` on the wire,
+     * #139) — the delivery landed, the debt it named stays owed there.
+     */
+    readonly settlementRefused?: true;
 }
 /** Canonical `a2a_route` failure value. */
 export interface A2aRouteError {

package/nexus-stage/src/canvas-ops.ts

@@ -19,16 +19,17 @@ import type { LayoutDoc } from './layout-doc'
 export type RosterOp = { op: 'remove' | 'add'; id: string }
 
 /** The five user-facing write actions (one per design.md §3.3 row), plus the two network join/leave actions the panel-slim migration moved into the planning view. */
-export type CanvasAction =
+export type CanvasAction = (
   | { type: 'create-team'; name: string; ids: readonly string[]; /** true when the model had no such team before this action; NOT server creation provenance and never authority to delete on failure. */ created?: boolean }
   | { type: 'add-member'; team: string; ids: readonly string[]; /** gh#41: set when the target frame is a REMOTE peer's team — the wire routes the op through the host fleet relay. */ fleetPeer?: string }
   | { type: 'remove-member'; team: string; ids: readonly string[]; /** gh#41: see add-member. */ fleetPeer?: string }
-  | { type: 'remove-team'; name: string }
+  | { type: 'remove-team'; name: string; /** set when the frame is a REMOTE peer's team: the owner dissolves it, through the relay. */ fleetPeer?: string }
   /** `ops` comes from reorderOps() at emit time; the wire stays model-free. */
   | { type: 'reorder'; team: string; ops: ReadonlyArray<RosterOp> }
   /** Network-level join/leave (the session joins the A2A mesh) — distinct from canvas-team membership. */
   | { type: 'join-network'; id: string }
   | { type: 'leave-network'; id: string }
+) & { roster?: boolean }
 
 /** Reverts exactly what one applyAction did (team-scoped). */
 export type Undo = () => void

package/nexus-stage/src/federation.ts

@@ -70,6 +70,7 @@ export function peerHostOf(url: string): string {
 /** One remote team row as the directory reports it (state.remote). */
 export interface RemoteTeamRow {
   team: string
+  unreachable?: boolean
   name?: string
   via?: string
   workspace?: string

package/nexus-stage/src/layout-doc.ts

@@ -66,11 +66,13 @@ function clampRect(raw: unknown): LayoutRect | undefined {
  * Normalize an untrusted layout document exactly as the host does:
  * version!==1 rejects the whole doc; non-finite coordinates drop the
  * point; coordinates round and clamp to ±COORD_LIMIT; scale clamps to
- * [SCALE_MIN, SCALE_MAX]; node keys cap at 128 chars; frame keys mirror
- * canvas team names (no '/', cap 40); rects need w>0 and h>0; caps are
+ * [SCALE_MIN, SCALE_MAX]; node keys cap at 128 chars; canvas frame names cap at 40,
+ * roster:<name> reserves seven extra characters; rects need w>0 and h>0; caps are
  * first-wins in insertion order - entries beyond are silently dropped,
  * never refused (an overflow renders, it just does not persist).
  */
+const validFrame = (name: string): boolean => name !== '' && !name.includes('/') && (name.startsWith('roster:') ? name.length > 7 && name.length <= 47 : name.length <= 40)
+
 export function clampDoc(raw: unknown): LayoutDoc | undefined {
   if (raw === null || typeof raw !== 'object') return undefined
   const rec = raw as Record<string, unknown>
@@ -96,7 +98,7 @@ export function clampDoc(raw: unknown): LayoutDoc | undefined {
   const frames: Record<string, LayoutRect> = {}
   if (rec.frames !== null && typeof rec.frames === 'object') {
     for (const [name, rect] of Object.entries(rec.frames as Record<string, unknown>)) {
-      if (typeof name !== 'string' || name === '' || name.includes('/') || name.length > 40) continue
+      if (!validFrame(name)) continue
       const r = clampRect(rect)
       if (r !== undefined) frames[name] = r
       if (Object.keys(frames).length >= LAYOUT_FRAME_CAP) break
@@ -127,7 +129,7 @@ export function buildLayoutDoc(
   }
   const docFrames: Record<string, LayoutRect> = {}
   for (const [name, r] of frames) {
-    if (typeof name !== 'string' || name === '' || name.includes('/') || name.length > 40) continue
+    if (!validFrame(name)) continue
     const w = clamp(r.w)
     const h = clamp(r.h)
     if (w <= 0 || h <= 0) continue

package/nexus-stage/src/main.ts

@@ -9,9 +9,10 @@
 import { createFaultReporter } from './fault'
 import { createWorkbench, type StateBody } from './workbench'
 import { createPlanningView } from './planning-view'
+import { rosterFrames, rosterNameOf } from './planning-roster'
 import { createSaveLoop, type LampState } from './layout-wire'
 import { createCanvasWire } from './canvas-wire'
-import type { CanvasAction } from './canvas-ops'
+import { actionTeam, type CanvasAction } from './canvas-ops'
 import './workbench.css'
 
 const app = document.getElementById('app')!
@@ -154,28 +155,58 @@ const canvasWire = createCanvasWire({
   onNotice: (kind, text) => planning.notice(kind, text),
 })
 
+/** One relayed op on a REMOTE peer's team. THIS host signs the envelope
+ *  and forwards; the peer's link gate authorizes the write. */
+async function fleetOp(peer: string, op: 'add-member' | 'remove-member' | 'remove', name: string, id?: string): Promise<boolean> {
+  const r = await controlFetch('/__dsh_a2a/fleet-canvas-op', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ peer, op, name, ...(id !== undefined ? { id } : {}) }),
+    cache: 'no-store',
+  }).catch(() => undefined)
+  const body = r !== undefined ? await r.json().catch(() => undefined) : undefined
+  if (body?.ok === true && op === 'remove' && body.removed === false) planning.notice('info', `属主那边已没有「${name}」，无需解散`)
+  if (body?.ok === true) return true
+  // Say WHY the peer refused (not linked, untrusted origin, unknown member…), not just that it did.
+  planning.notice('error', `跨主机团队操作失败：${String(body?.error ?? '对端无响应')}`)
+  return false
+}
+
+async function rosterAction(a: CanvasAction, name: string): Promise<boolean> {
+  const post = async (body: Record<string, unknown>): Promise<boolean> => {
+    const reply = await controlFetch('/__dsh_a2a/roster-op', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name, ...body }) }).catch(() => undefined)
+    const result = reply !== undefined ? await reply.json().catch(() => undefined) as { ok?: boolean; error?: string } | undefined : undefined
+    if (reply?.ok && result?.ok === true) return true
+    planning.notice('error', `roster 操作失败：${String(result?.error ?? (reply ? `HTTP ${reply.status}` : '无响应'))}`)
+    return false
+  }
+  if (a.type === 'create-team') return post({ op: 'create', ids: a.ids })
+  if (a.type === 'remove-team') return post({ op: 'dissolve' })
+  if (a.type === 'add-member' || a.type === 'remove-member') {
+    for (const id of a.ids) if (!(await post({ op: a.type, id }))) return false
+    return true
+  }
+  planning.notice('error', 'roster 不支持该操作')
+  return false
+}
+
 function runCanvasAction(a: CanvasAction): Promise<boolean> {
-  // gh#41: a remote-frame drop forks to the fleet relay — THIS host signs
-  // the envelope and forwards; the peer's link gate authorizes the write.
+  // gh#41: a remote-frame drop forks to the fleet relay; so does dissolving
+  // a mirror frame (single owner + mirror: the owner's store is the truth).
   if ((a.type === 'add-member' || a.type === 'remove-member') && a.fleetPeer !== undefined) {
+    const peer = a.fleetPeer
     return (async () => {
-      for (const id of a.ids) {
-        const r = await controlFetch('/__dsh_a2a/fleet-canvas-op', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ peer: a.fleetPeer, op: a.type === 'add-member' ? 'add-member' : 'remove-member', name: a.team, id }),
-          cache: 'no-store',
-        }).catch(() => undefined)
-        const body = r !== undefined ? await r.json().catch(() => undefined) : undefined
-        if (body?.ok !== true) {
-          // Say WHY the peer refused (not linked, untrusted origin, unknown member…), not just that it did.
-          planning.notice('error', `跨主机团队操作失败：${String(body?.error ?? '对端无响应')}`)
-          return false
-        }
-      }
+      for (const id of a.ids) if (!(await fleetOp(peer, a.type, a.team, id))) return false
       return true
     })()
   }
+  if (a.type === 'remove-team' && a.fleetPeer !== undefined) return fleetOp(a.fleetPeer, 'remove', a.name)
+  // Only a trusted registry roster frame or an explicit create choice may trigger a local roster write.
+  if (a.roster === true) {
+    const roster = rosterNameOf(actionTeam(a))
+    if (roster !== undefined) return rosterAction(a, roster)
+    planning.notice('error', '无效的 roster 框名'); return Promise.resolve(false)
+  }
   switch (a.type) {
     case 'create-team': return canvasWire.createTeam(a.name, a.ids, a.created)
     case 'add-member': return canvasWire.addMembers(a.team, a.ids)
@@ -200,6 +231,9 @@ async function postNetworkJoin(action: 'join' | 'leave', id: string): Promise<bo
 }
 
 let lampState: LampState = 'idle'
+// The nodes face reports effective scoped assemblies; a mounted registration alone does not prove visibility.
+let nodePromptMissing = new Set<string>()
+let nodePromptCheckedAt = 0
 let canvasFace = false
 let lastLayoutJson: string | undefined
 /** True once any layout answer (saved doc or an explicit null) has been
@@ -375,13 +409,25 @@ async function poll(): Promise<void> {
     const res = await controlFetch('/__dsh_a2a/state', { cache: 'no-store' })
     if (!res.ok) throw new Error(`/__dsh_a2a/state ${res.status}`)
     const body = (await res.json()) as StateBody
+    if (Date.now() - nodePromptCheckedAt >= 15_000) {
+      nodePromptCheckedAt = Date.now()
+      try {
+        const nodes = await controlFetch('/__dsh_a2a/nodes', { cache: 'no-store' })
+        if (!nodes.ok) throw new Error(`nodes ${nodes.status}`)
+        const view = await nodes.json() as { bindings?: Array<{ session: string; mounted: unknown; effective: { core: boolean; mutable: boolean } | null }> }
+        nodePromptMissing = new Set((view.bindings ?? [])
+          .filter(b => b.mounted !== null && b.effective !== null && (b.effective.core === false || b.effective.mutable === false))
+          .map(b => b.session))
+      } catch { nodePromptMissing.clear() } // unavailable is unknown, not confirmed missing
+    }
+    const shown = { ...body, sessions: (body.sessions ?? []).map(s => ({ ...s, ...(nodePromptMissing.has(s.id) ? { nodePromptMissing: true } : {}) })) }
     clearFault()
     // canvasFace first: bench.update reads board.available() to pick the
     // mode, so assigning it afterwards held the very first paint in data
     // mode (board display:none, 0px wide) until the next 3s poll — and the
     // board's first reconcile measured a zero-width view.
     canvasFace = body.canvas !== undefined
-    bench.update(body)
+    bench.update(shown)
 
     // ── The layout answer precedes the first reconcile on purpose ──
     // The board's first build reads `layoutDoc` for saved positions and
@@ -419,7 +465,7 @@ async function poll(): Promise<void> {
     // SessionLite needs `joined: boolean` (workbench rows carry `joined?`):
     // tri-state → boolean without losing the unjoined node-list population.
     const allSessions = (body.sessions ?? []).map(s => ({ ...s, joined: s.joined === true }))
-    const teams = body.canvas?.teams ?? []
+    const teams = [...(body.canvas?.teams ?? []), ...rosterFrames(body.registry?.teams ?? [], body.zone ?? '')]
     const peers = (body.peers ?? []).filter(p => p !== null && typeof p === 'object' && typeof (p as { url?: unknown }).url === 'string')
     const inFlight = (body.inFlight ?? []).filter(r => r !== null && typeof r === 'object' && typeof (r as { team?: unknown }).team === 'string' && typeof (r as { peer?: unknown }).peer === 'string' && Number.isFinite((r as { startedAt?: unknown }).startedAt))
     const remoteTeams = (body.remote ?? [])
@@ -429,15 +475,17 @@ async function poll(): Promise<void> {
         name: r.name,
         via: r.via,
         workspace: r.workspace,
+        ...(r.unreachable === true ? { unreachable: true } : {}),
         ...(typeof r.origin === 'string' && r.origin !== '' ? { origin: r.origin } : {}),
         ...(Array.isArray(r.teams) && r.teams.length > 0 ? { teams: r.teams.filter((t): t is string => typeof t === 'string' && t !== '') } : {}),
       }))
     // gh#41: the peers' published canvas org rides the board (remote frames).
     const peerOrg = (body.peerOrg as unknown[] ?? [])
-      .filter((r): r is { url?: unknown; org?: unknown } => r !== null && typeof r === 'object')
+      .filter((r): r is { url?: unknown; org?: unknown; unreachable?: unknown } => r !== null && typeof r === 'object')
       .filter(r => typeof r.url === 'string' && Array.isArray(r.org))
       .map(r => ({
         url: r.url as string,
+        ...(r.unreachable === true ? { unreachable: true } : {}),
         org: (r.org as unknown[])
           .filter((e): e is { name?: unknown; team?: unknown; members?: unknown } => e !== null && typeof e === 'object')
           .filter(e => typeof e.team === 'string' && e.team !== '')

package/nexus-stage/src/planning-frame-hue.ts

@@ -0,0 +1,13 @@
+/** Stable team hue shared by canvas and roster frames. */
+import { FRAME_HUES } from './tokens'
+
+export function frameHue(name: string): { line: string; bg: string } {
+  let h = 0
+  for (let i = 0; i < name.length; i++) h = ((h * 31 + name.charCodeAt(i)) & 0xfffffff) >>> 0
+  const rgb = FRAME_HUES[h % FRAME_HUES.length]!
+  const line = "#" + rgb.toString(16).padStart(6, "0")
+  const r = (rgb >> 16) & 0xff
+  const g = (rgb >> 8) & 0xff
+  const b = rgb & 0xff
+  return { line, bg: `rgba(${r},${g},${b},0.05)` }
+}

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

@@ -27,6 +27,7 @@ export function createLegend(): HTMLDetailsElement {
   }
   row(false, '成员边（星形，框→成员）')
   row(true, '跨队多属（虚线）')
+  row(true, 'roster 网络队框（双线边框）')
   row(false, '活动边（inFlight 路由，瞬时）', 'var(--accent)')
   row(true, '联邦线（→peer）', 'var(--federal)')
   legend.append(summary, rows)

package/nexus-stage/src/planning-member-handles.ts

@@ -0,0 +1,34 @@
+/** Pure joined-local-handle projection for remote organization members. */
+import type { RemoteTeamRow } from './federation'
+import type { SessionLite } from './world'
+
+type HandleSession = Pick<SessionLite, 'id' | 'team' | 'joined'>
+
+/** Map only unique joined id8 handles that no remote directory row already owns. */
+export function joinedLocalIdsByHandle(sessions: ReadonlyArray<HandleSession>, publishedHandles: ReadonlySet<string>): Map<string, string> {
+  const localIds = new Map<string, string>()
+  const ambiguous = new Set<string>()
+  for (const session of sessions) {
+    if (session.joined !== true) continue
+    const slash = session.team.lastIndexOf('/')
+    if (slash <= 0 || session.team.slice(slash + 1) !== session.id.replace(/^session-/, '').slice(0, 8)) continue
+    const handle = session.team
+    if (publishedHandles.has(handle) || ambiguous.has(handle)) continue
+    if (localIds.has(handle)) {
+      localIds.delete(handle)
+      ambiguous.add(handle)
+    } else {
+      localIds.set(handle, session.id)
+    }
+  }
+  return localIds
+}
+
+/** Project a remote canvas member to its local card or stable synthetic card id. */
+export function remoteMemberBoardId(member: string, localIdsByHandle: ReadonlyMap<string, string>, remoteTeams: ReadonlyArray<RemoteTeamRow> | undefined, peerUrl: string): string {
+  const localId = localIdsByHandle.get(member)
+  if (localId !== undefined) return localId
+  if (member.includes('/')) return `member-${member.replace(/[^a-z0-9-]/gi, '-')}`
+  const peerZone = remoteTeams?.find(row => row.via === peerUrl)?.team.split('/')[0] ?? 'dsh'
+  return `member-${peerZone}-${member.replace(/^session-/, '').slice(0, 8)}`
+}

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

@@ -8,6 +8,7 @@
  * @module nexus-stage/planning-menus
  */
 import { reorderOps, type CanvasAction } from './canvas-ops'
+import { rosterFrameName, rosterFrameTitle } from './planning-roster'
 import type { PlanningSession, PlanningTeam } from './planning-types'
 import type { WorldModel } from './world'
 
@@ -22,6 +23,8 @@ export interface MenusDeps {
   readonly model: WorldModel
   /** Canvas teams from the latest poll. */
   teams(): ReadonlyArray<PlanningTeam>
+  joined(id: string): boolean
+  isRoster(frame: string): boolean
   /** The card or frame-head element a menu re-focuses on close. */
   anchorFor(target: MenuTarget): HTMLElement | null
   emit(a: CanvasAction): void
@@ -45,6 +48,7 @@ export interface PlanningMenus {
 
 export function createPlanningMenus(d: MenusDeps): PlanningMenus {
   const { root, netBtn, signal, model } = d
+  const titleOf = (frame: string): string => d.isRoster(frame) ? rosterFrameTitle(frame) : frame
 
   // ── 建队：selection → 命名对话框 → create-team ──
   function selectedByY(): string[] {
@@ -87,6 +91,12 @@ export function createPlanningMenus(d: MenusDeps): PlanningMenus {
     title.id = 'p-dialog-title'
     title.className = 'p-dialog-title'
     title.textContent = `组建团队（${ids.length} 个节点，自上而下即优先级）`
+    const kind = document.createElement('select')
+    kind.className = 'p-dialog-kind'
+    kind.setAttribute('aria-label', '团队类型')
+    for (const [value, label] of [['canvas', 'canvas 队'], ['roster', 'roster 网络队']]) {
+      const option = document.createElement('option'); option.value = value; option.textContent = label; kind.appendChild(option)
+    }
     const input = document.createElement('input')
     input.className = 'p-dialog-input'
     input.maxLength = 40
@@ -103,7 +113,7 @@ export function createPlanningMenus(d: MenusDeps): PlanningMenus {
     cancelBtn.type = 'button'
     cancelBtn.textContent = '取消'
     row.append(okBtn, cancelBtn)
-    panel.append(title, input, err, row)
+    panel.append(title, kind, input, err, row)
     wrap.appendChild(panel)
     root.appendChild(wrap)
 
@@ -115,25 +125,27 @@ export function createPlanningMenus(d: MenusDeps): PlanningMenus {
     }
     const nameError = (): string | null => {
       const name = input.value.trim()
-      if (name === '' || name.length > 40 || name.includes('/') || /^\d+$/.test(name)) {
-        return '队名需 1..40 字，不含“/”，不为纯数字'
-      }
+      if (name === '' || name.length > 40 || name.includes('/') || name.startsWith('roster:') || (kind.value === 'roster' && name.includes('*')) || /^\d+$/.test(name)) return '队名需 1..40 字，不含“/”、通配符或保留前缀，不为纯数字'
+      if (kind.value === 'roster' && model.getFrame(name) !== undefined) return '同名 canvas 队已存在，不能创建 roster 队'
+      if (kind.value === 'roster' && model.getFrame(rosterFrameName(name)) !== undefined && !d.isRoster(rosterFrameName(name))) return 'roster 框名已被 canvas 或镜像队占用'
+      if (kind.value === 'canvas' && model.getFrame(rosterFrameName(name)) !== undefined) return '同名 roster 队已存在，不能创建 canvas 队'
+      if (kind.value === 'roster' && ids.some(id => model.getNode(id)?.remote === true || !d.joined(id))) return 'roster 仅接受本机已入网的会话'
       return null
     }
     const confirm = (): void => {
       const problem = nameError()
       if (problem !== null) { err.textContent = problem; input.focus(); return }
-      const name = input.value.trim()
+      const name = kind.value === 'roster' ? rosterFrameName(input.value.trim()) : input.value.trim()
       close()
       if (model.getFrame(name) !== undefined) {
         // Duplicate name: host create is idempotent-ok, but the optimistic
         // create-team would WIPE the existing roster and overwrite its saved
         // frame rect. Join instead — same wire result, nothing destroyed.
-        d.notice('info', `已加入现有团队「${name}」`)
+        d.notice('info', `已加入现有团队「${kind.value === 'roster' ? rosterFrameTitle(name) : name}」`)
         d.emit({ type: 'add-member', team: name, ids })
         return
       }
-      d.emit({ type: 'create-team', name, ids, created: true })
+      d.emit({ type: 'create-team', name, ids, created: true, ...(kind.value === 'roster' ? { roster: true } : {}) })
     }
     okBtn.addEventListener('click', confirm)
     cancelBtn.addEventListener('click', close)
@@ -149,7 +161,7 @@ export function createPlanningMenus(d: MenusDeps): PlanningMenus {
       if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); close(); return }
       if (e.key !== 'Tab') return
       e.preventDefault()
-      const focusables = Array.from(panel.querySelectorAll<HTMLElement>('input, button'))
+      const focusables = Array.from(panel.querySelectorAll<HTMLElement>('input, select, button'))
       const idx = focusables.indexOf(document.activeElement as HTMLElement)
       const next = e.shiftKey
         ? focusables[(idx - 1 + focusables.length) % focusables.length]
@@ -252,7 +264,7 @@ export function createPlanningMenus(d: MenusDeps): PlanningMenus {
     el.setAttribute('aria-label', '团队操作')
     let items: HTMLButtonElement[] = []
     if (target.kind === 'frame') {
-      items = [menuItem(`解散团队「${target.name}」`, true, () => d.emit({ type: 'remove-team', name: target.name }))]
+      items = [menuItem(`解散团队「${titleOf(target.name)}」`, true, () => d.emit({ type: 'remove-team', name: target.name }))]
     } else {
       const id = target.id
       if (level === 'root') {
@@ -278,13 +290,17 @@ export function createPlanningMenus(d: MenusDeps): PlanningMenus {
         for (const t of d.teams()) {
           if (level === 'join') {
             const already = (model.getNode(id)?.memberships.some(m => m.team === t.name)) ?? true
-            items.push(menuItem(already ? `${t.name}（已加入）` : t.name, !already, () => d.emit({ type: 'add-member', team: t.name, ids: [id] })))
+            const allowed = !d.isRoster(t.name) || (d.joined(id) && model.getNode(id)?.remote !== true)
+            const item = menuItem(already ? `${titleOf(t.name)}（已加入）` : titleOf(t.name), !already && allowed, () => d.emit({ type: 'add-member', team: t.name, ids: [id] }))
+            if (!allowed) item.title = 'roster 只接受本机已入网会话'
+            items.push(item)
           } else if (level === 'leave') {
             const member = (model.getNode(id)?.memberships.some(m => m.team === t.name)) ?? false
-            items.push(menuItem(t.name, member, () => d.emit({ type: 'remove-member', team: t.name, ids: [id] })))
+            items.push(menuItem(titleOf(t.name), member, () => d.emit({ type: 'remove-member', team: t.name, ids: [id] })))
           } else {
             const member = (model.getNode(id)?.memberships.some(m => m.team === t.name)) ?? false
-            items.push(menuItem(t.name, member, () => {
+            if (d.isRoster(t.name)) continue
+            items.push(menuItem(titleOf(t.name), member, () => {
               const current = model.teamMemberIds(t.name)
               const desired = [id, ...current.filter(x => x !== id)]
               d.emit({ type: 'reorder', team: t.name, ops: reorderOps(current, desired) })

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

@@ -4,9 +4,9 @@
  * 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.
+ * answers (the relay then re-reads the owner's card in the background, and
+ * the owner's own change ping backs it up). Local frames carry no marker —
+ * this host is their owner.
  * @module nexus-stage/planning-mirror
  */
 import { peerHostOf } from './federation'
@@ -29,3 +29,47 @@ export function mirrorRoute(ownerUrl: string | undefined, syncing: boolean): Mir
     syncing,
   }
 }
+
+type MirrorOrg = ReadonlyArray<{ readonly url: string; readonly org: ReadonlyArray<{ readonly name: string }> }>
+
+/** After the owner accepted a dissolve, hide its team at most this long: a
+ *  peer's late add-member re-creates the team on the owner, and then it is
+ *  real again even though the owner's org never stopped listing it. */
+export const DISSOLVE_HIDE_MS = 10_000
+
+/**
+ * 解散 on a mirror frame: the frame stays gone from the moment the dissolve
+ * is sent until the owner's published org stops listing the team (or
+ * DISSOLVE_HIDE_MS after the owner accepted). Without this, a poll that lands
+ * while the relay is in flight — or before the owner's card is re-read —
+ * draws the frame again (and keeps its saved rect for a later team of the
+ * same name). Keyed by owner AND name: two owners may both have a team X.
+ */
+export function createDissolveGuard(now: () => number = Date.now) {
+  const key = (ownerUrl: string, name: string): string => `${ownerUrl}\u0000${name}`
+  const dissolving = new Map<string, { url: string; name: string; acceptedAt?: number }>()
+  return {
+    /** Mark the dissolve and return the action carrying its owner (the relay fork). */
+    fork<A extends { type: 'remove-team'; name: string }>(act: A, ownerUrl: string): A & { fleetPeer: string } {
+      dissolving.set(key(ownerUrl, act.name), { url: ownerUrl, name: act.name })
+      return { ...act, fleetPeer: ownerUrl }
+    },
+    /** The owner answered: a refusal (or a failed channel) lets the frame back now, an acceptance starts the clock. */
+    settled(act: { type: string; name?: string; fleetPeer?: string }, ok: boolean): void {
+      if (act.type !== 'remove-team' || act.name === undefined || act.fleetPeer === undefined) return
+      const entry = dissolving.get(key(act.fleetPeer, act.name))
+      if (entry === undefined) return
+      if (ok) entry.acceptedAt = now()
+      else dissolving.delete(key(act.fleetPeer, act.name))
+    },
+    /** True while this owner's team is being (or has just been) dissolved here. */
+    hides(name: string, ownerUrl: string): boolean { return dissolving.has(key(ownerUrl, name)) },
+    /** Forget a dissolve once its owner's org no longer lists the team, or once its time is up. */
+    sweep(peerOrg: MirrorOrg): void {
+      for (const [k, e] of dissolving) {
+        const listed = peerOrg.find(row => row.url === e.url)?.org.some(t => t.name === e.name) === true
+        if (!listed || (e.acceptedAt !== undefined && now() - e.acceptedAt > DISSOLVE_HIDE_MS)) dissolving.delete(k)
+      }
+    },
+  }
+}

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

@@ -0,0 +1,28 @@
+/** Project the peer's last missed card read onto existing remote cards and frames. */
+import { peerHostOf, type RemoteTeamRow } from './federation'
+
+export const UNREACHABLE_HINT = '对端未应答（显示的是最后已知状态）'
+
+export function unreachableRefs(input: {
+  remoteTeams?: ReadonlyArray<RemoteTeamRow>
+  peerOrg?: ReadonlyArray<{ url: string; unreachable?: boolean }>
+}): { hosts: ReadonlySet<string>; members: ReadonlySet<string> } {
+  const hosts = new Set<string>()
+  for (const row of input.remoteTeams ?? []) if (row.unreachable === true && row.via) hosts.add(peerHostOf(row.via))
+  for (const row of input.peerOrg ?? []) if (row.unreachable === true) hosts.add(peerHostOf(row.url))
+  const members = new Set<string>()
+  for (const row of input.remoteTeams ?? []) if (row.via && hosts.has(peerHostOf(row.via))) members.add(`member-${row.team.replace(/[^a-z0-9-]/gi, '-')}`)
+  return { hosts, members }
+}
+
+/** A mirror keeps its last known contents visible but warns until its owner responds again. */
+export function showFrameReachability(frame: HTMLElement, lost: boolean): void {
+  frame.classList.toggle('is-unreachable', lost)
+  const existing = frame.querySelector('.p-frame-unreachable')
+  if (lost && existing === null) {
+    const hint = document.createElement('span')
+    hint.className = 'p-frame-unreachable'
+    hint.textContent = UNREACHABLE_HINT
+    frame.appendChild(hint)
+  } else if (!lost) existing?.remove()
+}

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

@@ -0,0 +1,15 @@
+/** Roster frames use an independent layout namespace beside canvas frames. */
+import type { PlanningTeam } from './planning-types'
+
+export const ROSTER_PREFIX = 'roster:'
+export const rosterNameOf = (frame: string): string | undefined => frame.startsWith(ROSTER_PREFIX) ? frame.slice(ROSTER_PREFIX.length) : undefined
+export const rosterFrameName = (name: string): string => ROSTER_PREFIX + name
+export const rosterFrameTitle = (frame: string): string => { const name = rosterNameOf(frame); return name === undefined ? frame : `网络队 · roster · ${name}` }
+export function rosterFrames(rows: readonly { team: string; members: readonly string[] }[], zone: string): PlanningTeam[] {
+  return rows.flatMap(row => {
+    if (zone === '' || !row.team.startsWith(zone + '/') || !Array.isArray(row.members)) return []
+    const name = row.team.slice(zone.length + 1)
+    if (name === '' || name.length > 40 || name.includes('/') || name.startsWith(ROSTER_PREFIX) || name.includes('*')) return []
+    return [{ name: rosterFrameName(name), team: row.team, kind: 'roster' as const, members: row.members.filter(id => typeof id === 'string' && id !== '').map(id => ({ id })) }]
+  })
+}

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

@@ -12,7 +12,7 @@ import type { SessionLite, TeamLite } from './world'
 
 /** Minimal session/team shapes consumed here (topology rows satisfy them). */
 export interface PlanningSession extends SessionLite {}
-export interface PlanningTeam extends TeamLite {}
+export interface PlanningTeam extends TeamLite { kind?: 'roster' }
 
 export interface PlanningInput {
   sessions: ReadonlyArray<PlanningSession>
@@ -26,7 +26,7 @@ export interface PlanningInput {
   remoteTeams?: ReadonlyArray<RemoteTeamRow>
   /** gh#41 fleet planning: each tracked peer's published canvas org —
    *  rendered as REMOTE team frames (read + cross-host regulation). */
-  peerOrg?: ReadonlyArray<{ url: string; org: ReadonlyArray<{ name: string; team: string; members: readonly string[] }> }>
+  peerOrg?: ReadonlyArray<{ url: string; unreachable?: boolean; org: ReadonlyArray<{ name: string; team: string; members: readonly string[] }> }>
 }
 
 /** Screen-width class a viewport is remembered under (window width, not board width — collapsing the rail must not switch buckets). */