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

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

@@ -23,7 +23,7 @@ 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. */

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/main.ts

@@ -154,28 +154,34 @@ 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
+}
+
 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)
   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 +206,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 +384,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
@@ -429,15 +450,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-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-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-types.ts

@@ -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). */

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

@@ -30,6 +30,7 @@ import { buildLayoutDoc, clampDoc, type LayoutDoc, type LayoutRect } from './lay
 import { FRAME_HEAD_LIFT } from './edges'
 import { drawMemberEdges } from './planning-edges'
 import { createFederationOverlay } from './federation-overlay'
+import { joinedLocalIdsByHandle, remoteMemberBoardId } from './planning-member-handles'
 import { displayName } from './stage-name'
 import {
   activityEdges, federalEdges, flyBounds, groupRemoteTeams, peerNodeId, peerHostOf, placePeers,
@@ -44,12 +45,13 @@ import { FRAME_HUES } from './tokens'
 import { createPlanningMenus } from './planning-menus'
 import { createNodeFlyer, mountBoardSearch } from './planning-search'
 import { applyBoardRelayout } from './planning-relayout'
-import { mirrorRoute } from './planning-mirror'
+import { createDissolveGuard, mirrorRoute } from './planning-mirror'
 import { settleBoard, tidyMembers } from './planning-overlap'
 import { createLayoutUndo, type LayoutSnap } from './planning-undo'
 import { createNodeList } from './planning-nodelist'
 import { cardText } from './planning-card-text'
 import { createLegend } from './planning-legend'
+import { UNREACHABLE_HINT, showFrameReachability, unreachableRefs } from './planning-reachability'
 import { viewportBucket, type PlanningDeps, type PlanningInput, type PlanningSession, type PlanningTeam, type PlanningView, type SeamKey, type SeamPointer, type ViewportBucket } from './planning-types'
 import './planning.css'
 
@@ -382,12 +384,14 @@ export function createPlanningView(deps: PlanningDeps): PlanningView {
       const cntText = `${members} 成员` + (cross > 0 ? ` +${cross} 跨队` : '')
       if (cnt.textContent !== cntText) cnt.textContent = cntText
       const mirror = mirrorRoute(remoteFramesRef.get(name), pendingTeams.has(name)) // PR#96 single owner + mirror
+      const unavailable = mirror !== undefined && reachability.hosts.has(peerHostOf(remoteFramesRef.get(name)!))
       const routeText0 = mirror?.text ?? routeText(name)
       if (route.textContent !== routeText0) route.textContent = routeText0
-      route.title = mirror?.title ?? ''
+      route.title = `${mirror?.title ?? ''}${unavailable ? ` · ${UNREACHABLE_HINT}` : ''}`
+      showFrameReachability(el, unavailable)
       el.classList.toggle('is-mirror', mirror !== undefined)
       el.classList.toggle('is-syncing', mirror?.syncing === true)
-      const label = `团队框 ${name}${mirror !== undefined ? `（${mirror.text}）` : ''}（拖动整组，回车菜单）`
+      const label = `团队框 ${name}${mirror !== undefined ? `（${mirror.text}）` : ''}${unavailable ? `（${UNREACHABLE_HINT}）` : ''}（拖动整组，回车菜单）`
       const headEl = el.querySelector('.p-frame-head')!
       if (headEl.getAttribute('aria-label') !== label) headEl.setAttribute('aria-label', label) // a rewrite re-announces
     }
@@ -438,11 +442,15 @@ export function createPlanningView(deps: PlanningDeps): PlanningView {
       const host = n.id.slice('peer-'.length)
       // Title / second line / tooltip rules: planning-card-text.
       const txt = cardText(n, n.remote === true ? lastRemoteTeams.get(host) ?? [] : [], peerScoreByText.get(host))
+      const unavailable = n.remote === true && (n.id.startsWith('member-') ? reachability.members.has(n.id) : reachability.hosts.has(host))
+      el.classList.toggle('is-unreachable', unavailable)
       const nmEl = el.querySelector<HTMLElement>('.nm-text')!
       if (nmEl.textContent !== txt.title) nmEl.textContent = txt.title
       const subEl = el.querySelector<HTMLElement>('.sub')!
-      if (subEl.textContent !== txt.sub) subEl.textContent = txt.sub
-      if (el.title !== txt.tip) el.title = txt.tip
+      const subText = unavailable ? `未应答 · ${txt.sub}` : txt.sub
+      if (subEl.textContent !== subText) subEl.textContent = subText
+      const tip = unavailable ? `${txt.tip} · ${UNREACHABLE_HINT}` : txt.tip
+      if (el.title !== tip) el.title = tip
       const prioEl = el.querySelector<HTMLElement>('.prio')!
       if (n.remote === true) {
         // gh#20 W-A: the peer badge — link class colors the chip (linked
@@ -526,6 +534,8 @@ export function createPlanningView(deps: PlanningDeps): PlanningView {
   // gh#41: remote-frame registry (frame name → peer URL), refreshed by
   // reconcile and read by emitAction's serverAction to fork remote drops.
   let remoteFramesRef = new Map<string, string>()
+  let reachability = unreachableRefs({})
+  const dissolving = createDissolveGuard(deps.now)
 
   function emitAction(a: CanvasAction): void {
     // gh#20 W-B: the SERVER sees zone/id8 remote handles where the model
@@ -555,7 +565,8 @@ export function createPlanningView(deps: PlanningDeps): PlanningView {
           ? { ...act, ids, ...(fleetPeer !== undefined ? { fleetPeer } : {}) }
           : act
       }
-      return act
+      // Dissolving a mirror frame is the owner's write as well (relay op 'remove').
+      return act.type === 'remove-team' && remoteFramesRef.has(act.name) ? dissolving.fork(act, remoteFramesRef.get(act.name)!) : act
     }
 
     // Optimistic seats: a write may reference a session the teamed gate
@@ -583,10 +594,11 @@ export function createPlanningView(deps: PlanningDeps): PlanningView {
     const team = actionTeam(a)
     pendingAdd(team)
     render()
-    void deps.onCanvasAction(serverAction(a)).then(
+    const sent = serverAction(a)
+    void deps.onCanvasAction(sent).then(
       ok => {
         pendingRelease(team)
-        layoutDoc = settleAction(model, a, ok, undo, layoutDoc); markDirty()
+        layoutDoc = settleAction(model, a, ok, undo, layoutDoc); markDirty(); dissolving.settled(sent, ok)
         render()
       },
       () => {
@@ -594,7 +606,7 @@ export function createPlanningView(deps: PlanningDeps): PlanningView {
         // team's guard (and its optimistic state) forever — and per §3.4
         // 不吞错, the rollback surfaces to the user.
         pendingRelease(team)
-        layoutDoc = settleAction(model, a, false, undo, layoutDoc); markDirty()
+        layoutDoc = settleAction(model, a, false, undo, layoutDoc); markDirty(); dissolving.settled(sent, false)
         notice('error', '操作通道异常，已回滚')
         render()
       },
@@ -1207,6 +1219,7 @@ export function createPlanningView(deps: PlanningDeps): PlanningView {
     // excluded from bounds, so the column cannot feed back into itself).
     const peerSeen = new Set<string>()
     lastRemoteTeams = groupRemoteTeams(input.remoteTeams ?? [])
+    reachability = unreachableRefs(input)
     peerScoreByText.clear()
     for (const p of input.peers ?? []) {
       peerScoreByText.set(peerHostOf(p.url), p.score)
@@ -1247,6 +1260,7 @@ export function createPlanningView(deps: PlanningDeps): PlanningView {
     // peer card — pulling a specific remote member into a local team is a
     // plain drag (no picker, no hand-typed handle). Host cards stay for
     // federation context; the member cards carry the actual join gesture.
+
     const memberSeen = new Set<string>()
     for (const [host, rows] of lastRemoteTeams) {
       const hostNode = model.allNodes().find(n => n.remote === true && peerHostOf(n.peerUrl ?? '') === host && !n.id.startsWith('member-'))
@@ -1306,25 +1320,14 @@ export function createPlanningView(deps: PlanningDeps): PlanningView {
     if (input.peerOrg !== undefined) {
       let slot = 0
       const localNames = new Set(input.teams.map(t => t.name))
+      dissolving.sweep(input.peerOrg)
       for (const row of input.peerOrg) {
-        // The peer's zone comes from its directory rows ('dsh/xxxx' →
-        // 'dsh'); the org's members are stored verbatim — LOCAL members as
-        // session ids, remote members as zone/id8 handles. Both must
-        // resolve onto that host's session cards: id-form members become
-        // `member-<zone>-<id8>` (id8 = strip 'session-' prefix, first 8
-        // chars — the repo's id8 derivation), handle members sanitize
-        // directly. The old sanitize-only pass misresolved every local
-        // member (owner: 数据对不上).
-        const peerZone = input.remoteTeams?.find(r => r.via === row.url)?.team.split('/')[0] ?? 'dsh'
-        const id8of = (id: string): string => id.replace(/^session-/, '').slice(0, 8)
-        // The server now canonicalizes org members to handles (gh#41 wire
-        // form); the id-form branch stays as the defensive path for peers
-        // on an older build that still publish raw session ids.
-        const memberBoardId = (m: string): string =>
-          m.includes('/') ? `member-${m.replace(/[^a-z0-9-]/gi, '-')}` : `member-${peerZone}-${id8of(m)}`
+        // Resolve joined local handles and id-form legacy members through the pure projection helper.
+        const publishedHandles = new Set((input.remoteTeams ?? []).map(session => session.team))
+        const localIdsByHandle = joinedLocalIdsByHandle(input.sessions, publishedHandles)
         for (const team of row.org) {
-          if (team.name === '' || localNames.has(team.name)) continue
-          const memberIds = team.members.map(memberBoardId).filter(id => model.getNode(id) !== undefined)
+          if (team.name === '' || localNames.has(team.name) || dissolving.hides(team.name, row.url)) continue
+          const memberIds = team.members.map(member => remoteMemberBoardId(member, localIdsByHandle, input.remoteTeams, row.url)).filter(id => model.getNode(id) !== undefined)
           const saved = layoutDoc?.frames?.[team.name]
           // gh#44 (owner: frame position/size never sticks): the LOCAL-team
           // path keeps an existing frame's live rect ("live rect wins" — a

package/nexus-stage/src/planning.css

@@ -84,6 +84,10 @@
 #dsh-plan .p-frame-head .route{font-size:10.5px; color:var(--ink-muted)}
 #dsh-plan .p-frame.is-mirror{border-style:dashed}
 #dsh-plan .p-frame.is-syncing .p-frame-head .route{color:var(--accent)}
+#dsh-plan .p-frame.is-unreachable{opacity:.76;border-style:dashed}
+#dsh-plan .p-frame-unreachable{position:absolute;left:8px;top:20px;max-width:calc(100% - 16px);color:var(--uupm-error);font-size:11px;pointer-events:none}
+#dsh-plan .p-node.remote.is-unreachable{opacity:.72;border-left-color:var(--uupm-error)}
+#dsh-plan .p-node.remote.is-unreachable .sub{color:var(--uupm-error)}
 
 /* ── node card (fixed 56px border-box height = world.NODE_H) ── */
 #dsh-plan .p-node{position:absolute; width:172px; height:56px; padding:8px 26px 8px 14px;

package/nexus-stage/src/wb-directory.ts

@@ -130,8 +130,15 @@ export function renderDirectory(box: HTMLElement, ctx: DirectoryContext): string
     const g = group('本机会话', sessions.length, cold.length > 0 ? `${live.length} 在线 · ${cold.length} 冷` : undefined)
     for (const s of [...live, ...cold]) {
       const isLive = s.live === true
+      const missing = s.nodePromptMissing === true
       const item = row(g, isLive ? 'wb-dot-live' : 'wb-dot-cold', isLive ? '●' : '○', displayName(s), isLive ? s.team : `冷 · ${s.team}`,
         () => ctx.openChat({ kind: 'session', id: s.id, title: displayName(s), sub: s.team, team: s.team, live: s.live }), s.id)
+      if (missing) {
+        item.classList.add('is-node-prompt-missing')
+        const note = el('span', 'wb-node-warning')
+        note.textContent = '本会话的组装不含节点段'
+        item.querySelector('.wb-item-text')?.appendChild(note)
+      }
       badges(item, s.canvasTeams)
     }
   }
@@ -153,6 +160,12 @@ export function renderDirectory(box: HTMLElement, ctx: DirectoryContext): string
     for (const r of remote) {
       const item = row(g, 'wb-dot-remote', '◇', displayName(r), r.origin !== undefined && r.origin !== '' ? r.origin : r.team,
         () => ctx.openChat({ kind: 'remote', team: r.team, title: displayName(r), sub: r.team, row: r }), r.team)
+      if (r.unreachable === true) {
+        item.classList.add('is-unreachable')
+        const note = el('span', 'wb-unreachable-note')
+        note.textContent = '对端未应答（显示的是最后已知状态）'
+        item.querySelector('.wb-item-text')?.appendChild(note)
+      }
       badges(item, r.canvasTeams)
     }
   }

package/nexus-stage/src/workbench.css

@@ -321,6 +321,9 @@ body{background:var(--n-bg);color:var(--n-ink);font:13px/1.45 system-ui,"Segoe U
 .wb-item-sub{font:11px/1.35 ui-monospace,Consolas,monospace;color:var(--n-ink-muted);
   overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .wb-item.is-untitled .wb-item-label{color:var(--n-ink-muted);font-family:ui-monospace,Consolas,monospace;font-size:12px}
+.wb-directory .wb-item.is-unreachable{opacity:.78}
+.wb-unreachable-note{font-size:11px;line-height:1.35;color:var(--n-danger);white-space:normal;overflow-wrap:anywhere}
+.wb-node-warning{font-size:11px;line-height:1.35;color:var(--n-danger);white-space:normal;overflow-wrap:anywhere}
 .wb-dot-log{color:var(--n-ink-muted)}
 
 /* ── 台账 (wb-ledger) ── */

package/nexus-stage/src/workbench.ts

@@ -84,6 +84,7 @@ export interface ArchivedRow {
  *  canvasOrg) — the board renders REMOTE team frames from these rows. */
 export interface PeerOrgRow {
   readonly url: string
+  readonly unreachable?: boolean
   readonly org: ReadonlyArray<{ name: string; team: string; members: readonly string[] }>
 }
 
@@ -97,6 +98,8 @@ export interface SessionRow {
   readonly workspace?: string
   readonly joined?: boolean
   readonly live?: boolean
+  /** Final scoped assembly lacks at least one registered node section (#174). */
+  readonly nodePromptMissing?: boolean
   readonly teams?: readonly string[]
   /** Canvas teams this session is a member of (0.6.6 roster annotation). */
   readonly canvasTeams?: readonly string[]
@@ -107,6 +110,7 @@ export interface SessionRow {
 /** One remote team row from /state `remote`. */
 export interface RemoteRow {
   readonly team: string
+  readonly unreachable?: boolean
   readonly name?: string
   readonly origin?: string
   readonly via?: string
@@ -201,7 +205,7 @@ export interface WorkbenchDeps {
   ownerSettingsWrite?(changes: { teamJoinAllowlist?: string[]; teamScopeInfo?: boolean; announce?: boolean }): Promise<{ ok: boolean; restartNeeded?: boolean; error?: string }>
   /** gh#41 fleet planning: regulate a REMOTE peer's canvas team (this host
    *  signs the envelope and forwards; the peer's link gate authorizes). */
-  fleetCanvasOp?(peer: string, op: 'create' | 'add-member' | 'remove-member', name: string, id?: string): Promise<{ ok: boolean; members?: string[]; error?: string }>
+  fleetCanvasOp?(peer: string, op: 'create' | 'add-member' | 'remove-member' | 'remove', name: string, id?: string): Promise<{ ok: boolean; members?: string[]; error?: string }>
   /** Abandon one dead-lettered task via the control route. True on success. */
   abandon(taskId: string, reason: string): Promise<boolean>
   /** Canvas team member change via the control route (0.6.6): `id` is a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nelsonlongxiang/dsh-open-a2a-net",
-  "version": "0.6.31",
+  "version": "0.6.32",
   "description": "Open A2A network plugin for DeepSeek Harness: signed agent cards, decentralized peer/zone discovery, direct routing model tools, and joinable session nodes with a sidebar control",
   "type": "module",
   "main": "lib/index.js",