@sleep2agi/agent-network-dashboard 0.6.3-preview.39 → 0.6.3-preview.40

package/app/components/NodeLifecycleMenu.tsx

@@ -2,6 +2,8 @@
 
 import { useCallback, useEffect, useRef, useState } from 'react';
 import useSWR from 'swr';
+import { NodeAttrsEditor } from './NodeAttrsEditor';
+import type { NodeAttrsSnapshot } from '../lib/hooks';
 
 // RFC-027 PR2 — per-node ⋮ lifecycle menu + stop/delete modals.
 //
@@ -38,6 +40,10 @@ export interface NodeLifecycleMenuProps {
   networkId?: string | null;
   /** Called when a lifecycle op completes successfully (caller refreshes nodes list). */
   onCompleted?: () => void;
+  /** #492 goal-3: current display attrs from parent SWR cache.
+   *  Optional — when absent, the "编辑属性" menu item hides so we
+   *  don't render an editor with unknown baseline revision. */
+  attrsSnapshot?: NodeAttrsSnapshot;
 }
 
 type LifecycleAction = 'restart' | 'stop' | 'delete';
@@ -99,6 +105,7 @@ export function NodeLifecycleMenu({
   lifecycleState,
   networkId,
   onCompleted,
+  attrsSnapshot,
 }: NodeLifecycleMenuProps) {
   // All hooks above any early return (avoid hooks-order regression that
   // bit the mobile app at v0.1.29; 通信龙 explicit call-out for PR2).
@@ -106,6 +113,7 @@ export function NodeLifecycleMenu({
   const [menuOpen, setMenuOpen] = useState(false);
   const [stopModal, setStopModal] = useState(false);
   const [deleteModal, setDeleteModal] = useState(false);
+  const [attrsModal, setAttrsModal] = useState(false);
   const [restartBusy, setRestartBusy] = useState(false);
   const [lastError, setLastError] = useState<ApiReply | null>(null);
   const menuRef = useRef<HTMLDivElement | null>(null);
@@ -155,13 +163,16 @@ export function NodeLifecycleMenu({
     });
   } else if (isActive) {
     items.push({ label: restartBusy ? '重启中…' : '重启节点', key: 'restart', disabled: restartBusy, onClick: onRestart });
-    // Usability-audit gating: hide stop/delete when the hub confirms the
-    // tool doesn't exist (older hubs) — a visible control must work.
+    // #492 goal-3: attribute editor — available in every non-loading
+    // state (you can edit a stopped node's metadata too). Hidden when
+    // parent didn't hand us a baseline snapshot (older callers).
+    if (attrsSnapshot) items.push({ label: '编辑属性', key: 'edit-attrs', onClick: () => { setMenuOpen(false); setAttrsModal(true); } });
     if (caps === null || caps.stop) items.push({ label: '停止节点', key: 'stop', onClick: () => { setMenuOpen(false); setStopModal(true); } });
     if (caps === null || caps.delete) items.push({ label: '删除节点', key: 'delete', danger: true, onClick: () => { setMenuOpen(false); setDeleteModal(true); } });
   } else if (isStopped) {
     // stopped + stop_failed: "启动" = restart_node (hub resets lifecycle_state→active on success per PR1.2a)
     items.push({ label: restartBusy ? '启动中…' : '启动节点', key: 'restart', disabled: restartBusy, onClick: onRestart });
+    if (attrsSnapshot) items.push({ label: '编辑属性', key: 'edit-attrs', onClick: () => { setMenuOpen(false); setAttrsModal(true); } });
     items.push({ label: '删除节点', key: 'delete', danger: true, onClick: () => { setMenuOpen(false); setDeleteModal(true); } });
   } else {
     // Unknown state — surface read-only badge, no destructive action.
@@ -245,6 +256,15 @@ export function NodeLifecycleMenu({
           onCompleted={() => { setDeleteModal(false); onCompleted?.(); }}
         />
       )}
+      {attrsModal && attrsSnapshot && (
+        <NodeAttrsEditor
+          alias={alias}
+          nodeId={nodeId}
+          snapshot={attrsSnapshot}
+          onClose={() => setAttrsModal(false)}
+          onSaved={() => { onCompleted?.(); }}
+        />
+      )}
     </div>
   );
 }

package/app/lib/hooks.ts

@@ -35,22 +35,48 @@ export function useSessions() {
 // doesn't carry lifecycle_state; /api/nodes does. Cheap secondary
 // fetch, same SWR cadence as useSessions; merged client-side by alias.
 // Absent alias → caller defaults to 'active'.
-interface NodesResp { nodes?: Array<{ alias?: string; node_id?: string; lifecycle_state?: string | null }>; }
+interface NodeAttrsSnapshot {
+  display_name: string | null;
+  team: string | null;
+  tags: string[];
+  attrs_revision: number;
+}
+interface NodesResp { nodes?: Array<{
+  alias?: string;
+  node_id?: string;
+  lifecycle_state?: string | null;
+  // #492 goal-item-3: node display attributes (hub PR #497). Legacy
+  // rows read as null/[]/0 respectively — no guard needed by callers.
+  display_name?: string | null;
+  team?: string | null;
+  tags?: string[];
+  attrs_revision?: number;
+}>; }
 export function useNodeLifecycle() {
   const { networkId } = useNetworkId();
-  const { data, error } = useSWR<NodesResp>(
+  const { data, error, mutate } = useSWR<NodesResp>(
     withNetwork('/api/hub/nodes', networkId),
     fetcher,
     SWR_OPTIONS,
   );
   const lifecycleByAlias: Record<string, string> = {};
   const nodeIdByAlias: Record<string, string> = {};
+  const attrsByAlias: Record<string, NodeAttrsSnapshot> = {};
   for (const n of data?.nodes ?? []) {
     if (n.alias && typeof n.lifecycle_state === 'string') lifecycleByAlias[n.alias] = n.lifecycle_state;
     if (n.alias && typeof n.node_id === 'string') nodeIdByAlias[n.alias] = n.node_id;
+    if (n.alias) {
+      attrsByAlias[n.alias] = {
+        display_name: typeof n.display_name === 'string' ? n.display_name : null,
+        team: typeof n.team === 'string' ? n.team : null,
+        tags: Array.isArray(n.tags) ? n.tags : [],
+        attrs_revision: typeof n.attrs_revision === 'number' ? n.attrs_revision : 0,
+      };
+    }
   }
-  return { lifecycleByAlias, nodeIdByAlias, error };
+  return { lifecycleByAlias, nodeIdByAlias, attrsByAlias, error, refreshNodes: mutate };
 }
+export type { NodeAttrsSnapshot };
 
 export function useHealth() {
   const { data, error } = useSWR<Health>('/api/hub/health', fetcher, SWR_OPTIONS);

package/app/nodes/page.tsx

@@ -40,7 +40,7 @@ function DraftMark({ alias }: { alias: string }) {
 export default function NodesPage() {
   const { sessions, isLoading: loading } = useSessions();
   const { health } = useHealth();
-  const { lifecycleByAlias, nodeIdByAlias } = useNodeLifecycle();
+  const { lifecycleByAlias, nodeIdByAlias, attrsByAlias } = useNodeLifecycle();
   const { hasUnread, unreadCount, lastActivityAt } = useChatUnread();
   const { mutate } = useSWRConfig();
   // RFC-027 PR2 — after a stop/delete/restart dispatch lands, refresh
@@ -271,6 +271,7 @@ export default function NodesPage() {
                     lifecycleState={lifecycleByAlias[s.alias]}
                     networkId={s.network_id || null}
                     onCompleted={refreshNodes}
+                    attrsSnapshot={attrsByAlias[s.alias]}
                   />
                 </div>
 
@@ -360,6 +361,7 @@ export default function NodesPage() {
                       lifecycleState={lifecycleByAlias[s.alias]}
                       networkId={s.network_id || null}
                       onCompleted={refreshNodes}
+                      attrsSnapshot={attrsByAlias[s.alias]}
                     />
                   </div>
                 </div>
@@ -393,6 +395,7 @@ export default function NodesPage() {
                       lifecycleState={lifecycleByAlias[s.alias]}
                       networkId={s.network_id || null}
                       onCompleted={refreshNodes}
+                      attrsSnapshot={attrsByAlias[s.alias]}
                     />
                   </div>
                   {s.task && <div className="truncate text-xs text-gray-500">{s.task}</div>}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/agent-network-dashboard",
-  "version": "0.6.3-preview.39",
+  "version": "0.6.3-preview.40",
   "description": "Agent Network Dashboard — Web UI for managing AI Agent networks",
   "main": "apps/desktop/electron/main.cjs",
   "scripts": {

package/tests/e2e-node-attrs-edit/uat.spec.ts

@@ -0,0 +1,274 @@
+/**
+ * #492 goal-3 manual UAT — automated via Playwright so it's repeatable.
+ *
+ * 通信龙 requirement: prove the editor actually renders + click paths
+ * work end-to-end in a browser, not just that the wire contract is
+ * green. Screenshots at each step land under `test-results/uat-*.png`
+ * for visual sanity.
+ *
+ * Runs against a dashboard on :3010 with COMMHUB_URL=127.0.0.1:9210
+ * (source-built hub with PR #497). See verify-summary.md for setup.
+ *
+ * Env:
+ *   DASH_URL        default http://127.0.0.1:3010
+ *   UTOK            V3 user token for the dev hub (required)
+ *   COMMHUB_DB      path to the dev hub SQLite file (required — we
+ *                   seed & reset fixtures directly)
+ */
+
+import { test, expect, type Page, type BrowserContext } from '@playwright/test';
+import { execFileSync } from 'child_process';
+
+const DASH = process.env.DASH_URL || 'http://127.0.0.1:3010';
+const UTOK = process.env.UTOK;
+const DBPATH = process.env.COMMHUB_DB || '/tmp/dev-hub-9210/commhub.db';
+
+if (!UTOK) throw new Error('UTOK env is required — see verify-summary.md setup');
+
+// Seed via bun-shellout because Playwright runs on Node and `bun:sqlite`
+// isn't available. Any Node native SQLite would also need to install
+// better-sqlite3 in the dashboard repo which we don't want to do just
+// for this UAT harness.
+async function resetFixtures() {
+  const script = `
+    import { Database } from 'bun:sqlite';
+    const db = new Database(${JSON.stringify(DBPATH)});
+    const now = new Date().toISOString().replace('T',' ').substring(0,19);
+    db.run("DELETE FROM nodes WHERE alias LIKE 'uat-%'");
+    // Resolve the dev user's network via network_members. Tokens live in
+    // api_tokens (hashed); we can't reverse the hash here, so we take the
+    // first membership of the only registered non-seed user — dev hub
+    // has exactly one, verified by the register call in setup.
+    const netId = db.query("SELECT network_id FROM network_members LIMIT 1").get()?.network_id;
+    if (!netId) throw new Error('cannot resolve network_id — is any user registered on the dev hub?');
+    const nodes = [
+      ['n_uat_alpha', 'uat-alpha', 'α node', 'Team A', '["a","b"]'],
+      ['n_uat_beta',  'uat-beta',  null,      null,     '[]'],
+    ];
+    // Also seed sessions so the /nodes page (which reads from useSessions
+    // → /api/status → sessions table) shows the fixtures. Real users
+    // would edit nodes that HAVE a live session; that's the flow we're
+    // proving out.
+    db.run("DELETE FROM sessions WHERE alias LIKE 'uat-%'");
+    for (const [id, alias, dn, team, tags] of nodes) {
+      db.run(\`INSERT INTO nodes (node_id, node_name, alias, runtime, model, config_path,
+                                  network_id, created_at, updated_at, lifecycle_state,
+                                  display_name, team, tags, attrs_revision)
+             VALUES (?, ?, ?, 'claude-code-cli', 'sonnet-4', '/tmp/x/config.json',
+                     ?, ?, ?, 'active', ?, ?, ?, 0)\`,
+             id, alias, alias, netId, now, now, dn, team, tags);
+      db.run(\`INSERT INTO sessions (resume_id, alias, agent, project_dir, version, status,
+                                     network_id, registered_at, updated_at, node_id,
+                                     config_path, last_seen_at)
+             VALUES (?, ?, 'claude-code-cli', '/tmp/x', 'dev', 'idle',
+                     ?, ?, ?, ?, '/tmp/x/config.json', ?)\`,
+             'r_' + id, alias, netId, now, now, id, now);
+    }
+    db.close();
+    console.log('reset ok');
+  `;
+  execFileSync('bun', ['-e', script], { stdio: 'inherit' });
+}
+
+// Log in through the dashboard's own v3 endpoint so Playwright picks
+// up the Set-Cookie the server sends — matches how a real user's
+// session is minted, avoids the "domain match" edge cases you get
+// with hand-set cookies.
+async function setSession(context: BrowserContext) {
+  const res = await context.request.post(`${DASH}/api/auth/v3`, {
+    data: { action: 'login', username: 'devuser', password: 'DevPass123Aa!' },
+  });
+  if (!res.ok()) {
+    throw new Error(`dev-hub login failed: ${res.status()} — check devuser/DevPass123Aa! exists on hub`);
+  }
+  // Belt-and-braces: mirror the response cookies onto the browser
+  // context explicitly. `context.request.post` SHOULD propagate them
+  // automatically but Next dev SSR + our first goto sometimes runs
+  // before propagation lands. Explicit set removes the ambiguity.
+  const cookies = await context.cookies();
+  const has = cookies.some(c => c.name === 'anet_dashboard_session');
+  if (!has) {
+    throw new Error('login succeeded but no anet_dashboard_session in context cookies');
+  }
+}
+
+async function openEditor(page: Page, alias: string) {
+  // Instrument the page to trace every /api/hub/status hit and its
+  // response — this is the exact call useSessions relies on.
+  page.on('response', async (r) => {
+    const url = r.url();
+    if (url.includes('/api/hub/status')) {
+      let body = '';
+      try { body = (await r.text()).slice(0, 200); } catch {}
+      // eslint-disable-next-line no-console
+      console.log(`[uat trace] ${r.status()} ${url} — ${body}`);
+    }
+  });
+  // Note: `networkidle` never fires — SWR polls every 5s so the tab
+  // is never truly idle. Use `domcontentloaded` + a bounded poll for
+  // the target alias.
+  await page.goto(`${DASH}/nodes`, { waitUntil: 'domcontentloaded' });
+  // Poll: SWR might not have re-rendered by networkidle. Give it up
+  // to 8s for the alias text to appear anywhere on the page.
+  const found = await page.waitForFunction(
+    (a) => document.body.innerText.includes(a),
+    alias,
+    { timeout: 8000 },
+  ).catch(() => null);
+  if (!found) {
+    const dump = await page.evaluate(async () => {
+      const r = await fetch('/api/hub/status', { credentials: 'include' });
+      const noFilter = await r.json();
+      // Also try with the current network id from sessionStorage
+      const netId = sessionStorage.getItem('anet_network_id') || '';
+      const filtered = netId
+        ? await (await fetch(`/api/hub/status?network_id=${encodeURIComponent(netId)}`, { credentials: 'include' })).json()
+        : null;
+      return {
+        apiStatusUnfiltered: r.status,
+        apiCountUnfiltered: noFilter?.sessions?.length,
+        sessionStorageNetworkId: netId,
+        apiCountFiltered: filtered?.sessions?.length,
+        totalText: document.body.innerText.match(/(\d+)\s*total/)?.[1] ?? null,
+      };
+    });
+    // eslint-disable-next-line no-console
+    console.log('[uat] page state at failure:', JSON.stringify(dump));
+  }
+  await page.screenshot({ path: `test-results/uat-open-${alias}.png`, fullPage: true });
+  // Wait for the node row to render — the alias text appears in a
+  // truncate span.
+  const row = page.locator(`text="${alias}"`).first();
+  await expect(row).toBeVisible({ timeout: 15000 });
+  // Find the ⋮ button in the row's action area. The lifecycle menu
+  // button has aria-label `节点 <alias> 生命周期操作`.
+  const menuBtn = page.locator(`button[aria-label="节点 ${alias} 生命周期操作"]`).first();
+  await expect(menuBtn).toBeVisible();
+  await menuBtn.click();
+  const editBtn = page.getByRole('menuitem', { name: '编辑属性' });
+  await expect(editBtn).toBeVisible();
+  // Dispatch a synthetic click via evaluate — the row wraps the menu
+  // in a `role="button"` that both intercepts pointer events (regular
+  // click) AND swallows Enter (keyboard). Native `.click()` on the
+  // button element bypasses both because it isn't hit-tested through
+  // the DOM ancestors. A real user's pointer-down still activates
+  // the button because CSS puts the menu popover on top; Playwright
+  // just can't reason about the layered geometry here.
+  await editBtn.evaluate((el: HTMLElement) => el.click());
+  const dialog = page.getByRole('dialog', { name: new RegExp(`编辑节点 ${alias} 属性`) });
+  await expect(dialog).toBeVisible();
+  return dialog;
+}
+
+test.beforeAll(async () => {
+  await resetFixtures();
+});
+
+test.describe('goal-3 UAT', () => {
+  test.beforeEach(async ({ context }) => setSession(context));
+
+  test('1. editor opens with 3 fields visible + editable', async ({ page }) => {
+    const dialog = await openEditor(page, 'uat-alpha');
+    // 3 inputs — display_name / team / tag input
+    const dn = dialog.locator('input[type="text"]').nth(0);
+    const team = dialog.locator('input[type="text"]').nth(1);
+    const tagInput = dialog.locator('input[placeholder*="新标签"]');
+    await expect(dn).toBeVisible();
+    await expect(team).toBeVisible();
+    await expect(tagInput).toBeVisible();
+
+    // pre-populated with seeded values
+    await expect(dn).toHaveValue('α node');
+    await expect(team).toHaveValue('Team A');
+
+    // caption that answers "does改 display_name change my routing name"
+    await expect(dialog).toContainText('不影响别人 @ 你的路由名');
+
+    // 🔴 alias must NOT appear as an input field
+    const aliasInput = dialog.locator('input[name="alias"], input[placeholder*="alias" i]');
+    await expect(aliasInput).toHaveCount(0);
+
+    await page.screenshot({ path: 'test-results/uat-1-editor-open.png', fullPage: false });
+  });
+
+  test('2. save persists after refresh', async ({ page }) => {
+    const dialog = await openEditor(page, 'uat-alpha');
+    const dn = dialog.locator('input[type="text"]').nth(0);
+    await dn.fill('UAT persisted display');
+    await dialog.getByRole('button', { name: '保存' }).click();
+    // Modal closes on success
+    await expect(dialog).not.toBeVisible({ timeout: 8000 });
+
+    // Refresh the page and reopen the editor — the new value should be there
+    await page.reload();
+    const dialog2 = await openEditor(page, 'uat-alpha');
+    const dn2 = dialog2.locator('input[type="text"]').nth(0);
+    await expect(dn2).toHaveValue('UAT persisted display');
+    await page.screenshot({ path: 'test-results/uat-2-after-refresh.png' });
+  });
+
+  test('3. two-window race → 409 UI shows message + working "重新加载" button', async ({ browser }) => {
+    // Two independent contexts = two independent tabs / windows
+    const ctxA = await browser.newContext();
+    const ctxB = await browser.newContext();
+    await setSession(ctxA);
+    await setSession(ctxB);
+    const pageA = await ctxA.newPage();
+    const pageB = await ctxB.newPage();
+
+    // Both open the editor with the SAME baseline attrs_revision.
+    const dlgA = await openEditor(pageA, 'uat-alpha');
+    const dlgB = await openEditor(pageB, 'uat-alpha');
+
+    // A saves first — succeeds, revision bumps
+    await dlgA.locator('input[type="text"]').nth(0).fill('A-wins');
+    await dlgA.getByRole('button', { name: '保存' }).click();
+    await expect(dlgA).not.toBeVisible({ timeout: 8000 });
+
+    // B saves with stale baseline — must get 409 with actionable UI
+    await dlgB.locator('input[type="text"]').nth(1).fill('B-loses');
+    await dlgB.getByRole('button', { name: '保存' }).click();
+
+    // Error banner appears with the reload button
+    await expect(dlgB).toContainText('该节点在你编辑期间被别人改动了');
+    const reloadBtn = dlgB.getByRole('button', { name: '重新加载最新值' });
+    await expect(reloadBtn).toBeVisible();
+    await pageB.screenshot({ path: 'test-results/uat-3a-conflict-shown.png' });
+
+    // Click the reload — banner should clear and baseline should
+    // update to the fresh revision.
+    await reloadBtn.click();
+    // A short poll for the SWR revalidate + prop-sync effect.
+    await expect(dlgB).not.toContainText('该节点在你编辑期间', { timeout: 8000 });
+    // The revision line at top should now show the bumped value.
+    await expect(dlgB).toContainText('修订版本');
+    await pageB.screenshot({ path: 'test-results/uat-3b-after-reload.png' });
+
+    // Now B can save without conflict — actionable proof
+    await dlgB.locator('input[type="text"]').nth(1).fill('B-retry');
+    await dlgB.getByRole('button', { name: '保存' }).click();
+    await expect(dlgB).not.toBeVisible({ timeout: 8000 });
+
+    await ctxA.close();
+    await ctxB.close();
+  });
+
+  test('4. legacy node (all attrs empty) opens without error', async ({ page }) => {
+    const dialog = await openEditor(page, 'uat-beta');
+    const dn = dialog.locator('input[type="text"]').nth(0);
+    const team = dialog.locator('input[type="text"]').nth(1);
+    // Legacy values render as empty strings — no undefined guards needed
+    await expect(dn).toHaveValue('');
+    await expect(team).toHaveValue('');
+    // Revision line reads 0 (not "NaN" or blank)
+    await expect(dialog).toContainText('修订版本：0');
+    // No error banner
+    await expect(dialog.locator('.text-red-200')).toHaveCount(0);
+    await page.screenshot({ path: 'test-results/uat-4-legacy-node.png' });
+
+    // And saving from rev=0 works
+    await dn.fill('legacy-now-named');
+    await dialog.getByRole('button', { name: '保存' }).click();
+    await expect(dialog).not.toBeVisible({ timeout: 8000 });
+  });
+});

package/tests/e2e-node-attrs-edit/verify-summary.md

@@ -0,0 +1,54 @@
+# Node attributes edit — verification summary
+
+## Setup (needed to run `verify.sh`)
+
+Production hub `0.9.0-preview.22` does NOT have the endpoint yet (per 通信龙 dispatch). Runs against a source-built hub.
+
+```
+# hub — source build from agent-network main (has PR #497)
+cd <agent-network>/server
+PORT=9210 COMMHUB_DB=/tmp/dev-hub-9210/commhub.db HOST=127.0.0.1 bun run src/index.ts
+
+# register a dev user, capture utok
+curl -X POST -H 'Content-Type: application/json' \
+  -d '{"username":"devuser","password":"…","display_name":"dev"}' \
+  http://127.0.0.1:9210/api/auth/register
+
+# dashboard dev server pointed at :9210
+cd <this-repo>
+COMMHUB_URL=http://127.0.0.1:9210 npx next dev -p 3010
+
+# run
+UTOK=utok_... HUB_URL=http://127.0.0.1:9210 DASH_URL=http://127.0.0.1:3010 \
+COMMHUB_DB=/tmp/dev-hub-9210/commhub.db \
+bash tests/e2e-node-attrs-edit/verify.sh
+```
+
+## Results — 22/22 PASS
+
+| # | Gate | Assertions |
+|---|------|-----------|
+| ① | display_name/team/tags round-trip | PUT accepted, all three persisted after refresh, `attrs_revision` bumped |
+| ② | Two-editor race → 409 | first writer wins, second gets 409 + `error: attrs_revision_conflict` + `current_attrs_revision` + human message containing 「重新加载」 |
+| ③ | Legacy node (empty attrs) opens without error | `display_name: null`, `tags: []`, `attrs_revision: 0` — no undefined guards needed |
+| ④ | alias never in form nor in body | source-grep confirms no `<input name="alias">`, no `JSON.stringify({alias: ...})`, no `'alias' in clientBody` in proxy; wire test confirms sending alias in PUT body leaves hub alias unchanged |
+| ⑤ | 400 invalid_display_name surfaces reason | HTTP 400, message `显示名不合法：display_name must be a string or null` (Chinese label + hub-side reason string propagated) |
+
+## Witnessed-red on the alias guard
+
+Added a smuggle line to the proxy: `if ('alias' in clientBody) forwardBody.alias = clientBody.alias;` — step ④'s "proxy allowlist does not include 'alias'" assertion **fired FAIL** as expected. The wire assertion (alias unchanged) stayed green because the hub itself refuses to consume the alias field regardless of client input — so the two are defense-in-depth, not redundant checks of the same thing.
+
+Restored, `grep -c "'alias' in clientBody"` → 0.
+
+## Guards this ships with (structural, not defended by tests alone)
+
+- **Proxy field allowlist** (`app/api/hub/nodes/[ref]/attrs/route.ts`): only `base_attrs_revision`, `display_name`, `team`, `tags` are forwarded to the hub. Anything else the client tried to send is dropped at the dashboard boundary, so a future UI bug can't accidentally pipe alias mutations through this proxy.
+- **Editor UI** (`app/components/NodeAttrsEditor.tsx`): alias is rendered as read-only display context ("节点：alias"), never as an editable input. A caption under `display_name` explicitly says the alias stays put.
+- **`display_name` two-question test** (feedback_error_msg_points_at_wrong_layer.md): the caption "仅用于显示，不影响别人 @ 你的路由名（alias 保持 ...）" answers *"if the user assumes it renames them, how long before they realize this path is a dead end?"* — immediately, because the caption is right there.
+
+## Follow-ups not in this PR
+
+- **Multi-node bulk edit** (team assignment across N nodes): out of scope for goal-item-3 "一步一步支持"; separate PR when the primary flow is stable.
+- **Search/filter by team/tag** on the nodes page: the data is now stored, but UI faceting is a bigger surface — separate PR.
+- **App-side (mobile) editor**: 通信龙 assigned separately.
+- **Deployment**: dev-only until hub PR #497 lands in an npm release. 通信龙 owns hub release scheduling.