From c7221ff6abd34eff1cfda55ec377892908e8c112 Mon Sep 17 00:00:00 2001
From: Danyang Chen <birfychen@gmail.com>
Date: Fri, 23 Oct 2026 16:24:13 +0800
Subject: [PATCH] fix(tree): read the roster once per tick, and pin the order
 and the area rule

The tree plugin's structure entry and its archived-Bots list both needed
ctx.flybot.bots(), and each polled it on its own 10 s timer: a mounted sidebar
asked the host for the same list twice per tick, and the archived list also
fetched once on mount.

One rosterFeed now owns the poll. The first subscriber starts it, a later
subscriber joins it and gets the current list without a read of its own, a field
change or bot.removed calls refresh() for an immediate read, a read that is
still running sets `again` instead of stacking up behind the timer, and the last
subscriber to leave clears it. apply() builds one feed for both consumers;
registerStructure and makeArchivedSection still work when handed no feed.

The archived list is registered at order 88 and the reorganization notice at 89,
and a slot renders ascending, so the archived Bots sit above the notice. That was
already true in the code and unstated in the README; it is stated now and pinned
by a test, so a later edit cannot flip them silently.

The burst path already refuses an `area:` key (`kindOf(first) !== 'area'`), so a
batch of Bots the vocabulary cannot place is not forced under one "General Lead",
but nothing pinned it: deleting the clause left the suite green. The new test
creates two such Bots in flight at once and requires both at the caller and no
lead, while the same fixture with a `project:` key still makes one group.

Fixes ThinkFlowLab/FlyBot#816
---
 changelog.d/816-one-roster-read.fixed.md |   1 +
 docs/subsystems/tree.md                  |  10 ++-
 plugins/tree/README.md                   |   2 +-
 plugins/tree/client.js                   |  76 +++++++++++-----
 plugins/tree/test/tree.test.js           | 109 ++++++++++++++++++++++-
 5 files changed, 172 insertions(+), 26 deletions(-)
 create mode 100644 changelog.d/816-one-roster-read.fixed.md

diff --git a/changelog.d/816-one-roster-read.fixed.md b/changelog.d/816-one-roster-read.fixed.md
new file mode 100644
index 000000000..3a5159124
--- /dev/null
+++ b/changelog.d/816-one-roster-read.fixed.md
@@ -0,0 +1 @@
+The tree no longer asks the host for the Bot list twice per refresh: the sidebar's structure entry and the archived-Bots list share one feed, so a mounted sidebar reads the roster once every 10 s instead of once per consumer, and the poll stops when the last of them goes away ([#816](https://github.com/ThinkFlowLab/FlyBot/issues/816)). The README now says the archived list is registered at `order: 88` and the reorganization notice at `order: 89`, and a slot renders ascending — so the archived Bots sit above the notice instead of being pushed down by it.
diff --git a/docs/subsystems/tree.md b/docs/subsystems/tree.md
index 906a4b0c8..2f92ad429 100644
--- a/docs/subsystems/tree.md
+++ b/docs/subsystems/tree.md
@@ -76,7 +76,7 @@ The tree organizes itself by role instead of leaving Bots outside it or a parent
 - **Leads.** A suitable existing lead is a member already marked as that group's lead, already coordinating that group (it has children and the key, project and domain only), or named for it ("Life", "FlyBot Lead") or as a lead ("Kitchen Manager", 负责人). It gets `lead { key, label }`. Only when none fits a new lead is created with a clear role (`<Label> Lead`, role "Lead of the <Label> group: coordinates …"); its members move under it before it joins the level. A lead's own group key, and broad areas below any lead, are ignored inside it, so there is no second "Dev Lead" under "Dev Lead".
 - **Repair**: a parent over `maxChildren` (after a deletion re-attached a deleted Bot's children) is regrouped the same way, at once when the lead exists, else in the queue.
 - **Daily tidy** (checked hourly, runs once a day; the first check after install only records the time; `dailyTidy: false` turns it off): (1) leaf Bots with no activity for `tidy.idleDays` (14) get `idle` (any turn or tool call clears it) and are **archived** after `tidy.archiveIdleDays` (30) more days; Bots with children, granted Bots and the root are never idle; (2) duplicates: two Bots with essentially the same role (same name once generic words are dropped and no conflicting description, or near-identical descriptions in one domain), both at least `tidy.mergeGraceDays` (1) in the tree, are **merged**: the newer one's children move to the kept Bot, which lists it in `mergedFrom` and is told in its prompt; the old one is archived; (3) project and domain groups of three or more (or two with an existing lead) on every level, never a group of a whole level without a lead.
-- **Archive, never delete**: an archived Bot leaves the tree (`archived { at, reason, parent, treeRole, into? }`, tree fields and block removed) but keeps its chat, memory and grants. It is **hidden from the default Bot list** (`bot.hidden` / structure `include`; Search still finds it) (#452), and the sidebar's `flybot-tree-archived` section is the way back to its chat (#810): collapsed by default, header `Archived (N)`, drawn only while N > 0, one row per archived Bot with the same tag `statusOf()` gives (`archived`, `archived · merged into <name>`) opening the chat through `actions.openSession`. `include()` still returns false, so the list and `botTree()` never see it. Deleting it stays the owner's own click. On a merge (#450 item 1), the archived Bot's own memory is carried into the kept Bot through `flybot.memory` (at most 20 entries, tagged `source: merged`), so a merge loses nothing; without the host's memory seam the merge still stands.
+- **Archive, never delete**: an archived Bot leaves the tree (`archived { at, reason, parent, treeRole, into? }`, tree fields and block removed) but keeps its chat, memory and grants. It is **hidden from the default Bot list** (`bot.hidden` / structure `include`; Search still finds it) (#452), and the sidebar's `flybot-tree-archived` section is the way back to its chat (#810): collapsed by default, header `Archived (N)`, drawn only while N > 0, one row per archived Bot with the same tag `statusOf()` gives (`archived`, `archived · merged into <name>`) opening the chat through `actions.openSession`. `include()` still returns false, so the list and `botTree()` never see it. Deleting it stays the owner's own click. That section is registered at `order: 88` and the reorganization notice below at `order: 89`; a slot renders ascending, so the archived Bots sit **above** the notice. On a merge (#450 item 1), the archived Bot's own memory is carried into the kept Bot through `flybot.memory` (at most 20 entries, tagged `source: merged`), so a merge loses nothing; without the host's memory seam the merge still stands.
 - **Move, never rename-to-归档 + recreate** (#452): grouping always reparents (`parent`); it never renames a Bot to `归档-…` / `Archive-…` and never creates a replacement with the old name. A one-shot repair strips those prefixes when the bare name is free, or archives+hides the prefixed Bot when a live Bot already has that name.
 - **Journal and undo**: every move, new lead, lead mark, merge, archive and idle mark of a run is an action in the root's `reorg { runs (last 5), dismissed, dailyAt }` and a `flybot-tree: reorganized (<trigger>): …` log line. The tree view's notice (sidebar section `flybot-tree-reorg`, `reorgNotice: false` hides it) shows the last run with **Undo** and **Dismiss** (`tree/reorg`, `tree/undo`, `tree/dismiss`). Undo reverses the newest run: moves go back where the old parent has room and the Bot was not moved again, archived Bots come back, a lead the run created is archived once empty; what it cannot restore is listed as kept. Restored Bots are pinned for `tidy.pinDays` (14) so the daily tidy leaves them alone.
 - **The owner is told afterwards**, no plan card first: the notice in the tree view, and the Main Bot's prompt names the last run (within 7 days, not undone) so Chief can say what moved.
@@ -112,6 +112,14 @@ The rules above place a Bot by the words in its name, role label and description
 - The Bot list itself uses the core `.bt-tree-toggle` (see [core-client](core-client.md)). When `sidebarSection: true` brings this plugin's separate Tree section back, `.flybot-tree-toggle` matches that control: 28×28 hit target, 16px inner `.flybot-tree-caret`, hover, focus ring, and rotation of the glyph only. Leaf spacers (`.flybot-tree-dot`) keep the same 28px width. `aria-expanded` and Expand/Collapse `{name}` labels stay on the button.
 - The right-click menu entry from `menuItems({ bot })` is a single **Copy invite link** (bare URL, shown when `social.canInvite(bot.id)`). The invite with instructions is offered only in the Bot's Sharing section, so the menu does not list the same invite twice (#173).
 
+### One roster read for the sidebar (#816)
+
+Both sidebar entries — the `flybot.sidebar.structure` entry ds-bot draws its Bot list from and the `flybot-tree-archived` list — need the same `ctx.flybot.bots()`. Each used to poll it on its own 10 s timer, so a mounted sidebar asked the host for the list twice per tick.
+
+- `client.js` keeps one `rosterFeed(flybot, { interval })`: the first subscriber starts the poll, a later subscriber joins it and is handed the current list without a read of its own, a read already in flight sets `again` instead of stacking up behind the timer, and the last subscriber to leave clears it. `apply()` builds one feed and passes it to `registerStructure` and `makeArchivedSection`; called with no feed, each makes its own (tests and other callers keep working).
+- A field change that matters to either consumer (`archived`, `parent`, `treeRole`, `retired`, `idle`) and `bot.removed` call `refresh()`, so a removal is still immediate instead of waiting for the next tick.
+- Tests: `plugins/tree/test/tree.test.js`, `#816: one roster read per tick…` (one read per tick for two subscribers, the timer stops with the last one, and mounting the archived section inside `apply()` adds no read) and `#816: the archived list is ordered above the reorganization notice`.
+
 ### Discarded promise `.catch` (#213)
 
 The plugin's discarded `.catch(() => {})` calls carry a one-line reason comment or `void`; `check-empty-catch` enforces it (see `docs/code-standards.md`).
diff --git a/plugins/tree/README.md b/plugins/tree/README.md
index 1a1a02f6c..c53b3d6a5 100644
--- a/plugins/tree/README.md
+++ b/plugins/tree/README.md
@@ -15,7 +15,7 @@ Recursive bot tree plugin for FlyBot (built on ds-bot / DeepSeek Harness).
 - **`create_child_bot` is serialized per parent:** parallel calls never exceed `maxChildren` or create duplicate-name siblings. Two calls that are **in flight at the same time** and belong to the same project or domain become one group instead of each landing in whatever broader group it fits: one lead for that key (reused when it exists, created once otherwise) with both new Bots under it (#810). The overlap is the definition: one turn of the event loop, no timer, and a call that starts after the previous one returned keeps the ordinary placement.
 - Delegation is level by level: coordinators delegate to direct children whose scope fits and aggregate upward; a bot with no children does the work itself. A one-line trace like `Chief → Work → Dev` is added only to answers a tree bot sends to its parent tree bot; replies to the user or to a remote (friend's, Bot Social) bot never carry it, and the root (Chief) never adds one.
 - Tools (visible to every tree bot, not only Main/root — #16 Option B): `list_children()`, `find_bots(query?)`, `create_child_bot(name, role_description, parent?)`, `create_team(team, members, parent?)` and — root only — `move_bot(bot, parent)` (#635), which moves an existing Bot with its subtree under another parent after checking for cycles, `maxChildren`, `maxDepth` and duplicate sibling names, then refreshes every prompt whose trace changed. Unlike `create_child_bot` it never creates a Bot; use it to reorganise a team, and note that deleting a Bot still re-attaches its children to its parent. A bot creates only in its own downstream: `parent` (id or name) must be the caller or one of its descendants, and limits are checked at that parent. **Forward allocation (#447, `src/allocate.js`):** `find_bots` (read-only) lists the bots in the caller's branch (Chief: the whole tree) with role, parent, depth and path, matches first; `create_child_bot` reuses a bot with the same role anywhere in the caller's branch instead of creating a duplicate (`{ reused, note }`), and without `parent` puts the new bot under a marked group lead in the branch that its role belongs to ("FlyBot Docs" under "FlyBot Lead"), else under the caller; `create_team` makes a project team as a lead plus children (`Chief → FlyBot Lead → {Dev, Test, …}`, `members` as `"Name: role"` strings), one slot under the parent, reusing an existing lead and same-role members (a flat one moves under the lead, journaled and undoable). Allocation uses the self-organization's primitives (role profiles, leads, moves, journal); a concurrent burst of two or more `create_child_bot` calls in one group is placed as one leader plus members (#810), and an explicit `parent` keeps the caller's own placement; a full level, orphans (a bot whose parent is gone is reattached by role on the next repair pass) and duplicates are left to the self-organization, which never asks first. There is no plan card. Limits: depth 5 (root = 1), 8 children per node; duplicate sibling names (case/space-insensitive) are rejected; names are 1–40 characters (ds-bot's roster limit). Every new child gets the same recursive system prompt template (`src/prompt.js`). A new child starts with no person-grant even if its parent is granted; sharing it still needs an independent Sharing → Copy invite link (default deny).
-- Frontend (`client.js`, bundle id `@flybot/tree`, injects `flybot`): the tree is drawn by ds-bot's own Bot list, so this plugin's separate "Tree" sidebar section is **off by default** (`sidebarSection: true` in the client config brings it back). It always exposes the synchronous helper `ctx.flybot.tree.forest(bots)` (also `globalThis.__flybot__.tree.forest(bots)`), see **Tree data** below. It also registers `flybot.sidebar.structure` (`{ parentOf(botId) }`, parents from `forestOf` over `ctx.flybot.bots()`, refreshed on field changes and every 10 s); ds-bot's sidebar uses it to draw its Bot list as one expandable tree with Chief on top. Retired, archived and outside Bots and other Main Bots have no parent there, so ds-bot shows them directly under Chief; the entry's `nodeActions` draws a tag after such a row ("archived", "archived · merged into …", "outside the tree") and after an idle Bot ("idle"), so the sidebar and the tree model agree. A `flybot.sidebar.section` entry `flybot-tree-archived` lists the archived Bots the Bot list hides (#810): collapsed by default, header `Archived (N)`, nothing at all while N is 0, one row per Bot carrying the same tag (`archived`, or `archived · merged into …` after a merge) that opens that Bot's chat through `actions.openSession`; expanding is local state, so the 10 s refresh re-renders the rows without closing it (`archivedSection: false` hides it). A `flybot.sidebar.section` entry `flybot-tree-reorg` shows the last reorganization (what moved) with Undo and Dismiss, through the host endpoints `tree/reorg`, `tree/undo`, `tree/dismiss`; it draws nothing when there is none in the last 7 days (`reorgNotice: false` in the client config hides it). The entry also has `menuItems({ bot })`, which ds-bot adds to each Bot's right-click menu: one item, `{ id: 'copy-invite', label: 'Copy invite link' }` (with `visible`, `run`); the invite with instructions is offered in the Bot's Sharing section only, so the menu does not list the same invite twice (#173). `visible` is `social.canInvite(bot.id) === true` (false without the social plugin); `run` calls `social.createInvite(botId)` (or `flybot.call('social.createInvite', { botId })`). **Copy invite link** copies only the bare URL (`link`); `copyInvite(flybot, botId, 'text')` copies the full message `text` for other callers; a missing field is an error, never swapped for the other. The clipboard write starts inside the click via `ClipboardItem` with the text as a promise, so it keeps the click's permission while the invite is created; `writeText` then a textarea are the fallbacks. It returns "Invite link for <name> copied", which ds-bot shows as a toast; a failure throws and shows as the error toast. Right-clicking never opens the Bot's chat.
+- Frontend (`client.js`, bundle id `@flybot/tree`, injects `flybot`): the tree is drawn by ds-bot's own Bot list, so this plugin's separate "Tree" sidebar section is **off by default** (`sidebarSection: true` in the client config brings it back). It always exposes the synchronous helper `ctx.flybot.tree.forest(bots)` (also `globalThis.__flybot__.tree.forest(bots)`), see **Tree data** below. It also registers `flybot.sidebar.structure` (`{ parentOf(botId) }`, parents from `forestOf` over `ctx.flybot.bots()`, refreshed on field changes and every 10 s); ds-bot's sidebar uses it to draw its Bot list as one expandable tree with Chief on top. Retired, archived and outside Bots and other Main Bots have no parent there, so ds-bot shows them directly under Chief; the entry's `nodeActions` draws a tag after such a row ("archived", "archived · merged into …", "outside the tree") and after an idle Bot ("idle"), so the sidebar and the tree model agree. A `flybot.sidebar.section` entry `flybot-tree-archived` lists the archived Bots the Bot list hides (#810): collapsed by default, header `Archived (N)`, nothing at all while N is 0, one row per Bot carrying the same tag (`archived`, or `archived · merged into …` after a merge) that opens that Bot's chat through `actions.openSession`; expanding is local state, so the 10 s refresh re-renders the rows without closing it (`archivedSection: false` hides it). It is registered with `order: 88` and the reorganization notice with `order: 89`: a slot renders in ascending order, so the archived list sits **above** the notice (a smaller number is higher) instead of the card pushing it down. The structure entry and the archived list read `ctx.flybot.bots()` through **one** shared feed (`rosterFeed`, `{ interval }`): the first subscriber starts the poll, later ones join it without a read of their own, a field change or a removal asks for an immediate read (`refresh()`), and a mounted sidebar asks the host once per 10 s tick — not once per consumer (#816). A `flybot.sidebar.section` entry `flybot-tree-reorg` shows the last reorganization (what moved) with Undo and Dismiss, through the host endpoints `tree/reorg`, `tree/undo`, `tree/dismiss`; it draws nothing when there is none in the last 7 days (`reorgNotice: false` in the client config hides it). The entry also has `menuItems({ bot })`, which ds-bot adds to each Bot's right-click menu: one item, `{ id: 'copy-invite', label: 'Copy invite link' }` (with `visible`, `run`); the invite with instructions is offered in the Bot's Sharing section only, so the menu does not list the same invite twice (#173). `visible` is `social.canInvite(bot.id) === true` (false without the social plugin); `run` calls `social.createInvite(botId)` (or `flybot.call('social.createInvite', { botId })`). **Copy invite link** copies only the bare URL (`link`); `copyInvite(flybot, botId, 'text')` copies the full message `text` for other callers; a missing field is an error, never swapped for the other. The clipboard write starts inside the click via `ClipboardItem` with the text as a promise, so it keeps the click's permission while the invite is created; `writeText` then a textarea are the fallbacks. It returns "Invite link for <name> copied", which ds-bot shows as a toast; a failure throws and shows as the error toast. Right-clicking never opens the Bot's chat.
 
 ### Config
 ```yaml
diff --git a/plugins/tree/client.js b/plugins/tree/client.js
index b7c062918..e8fdded8d 100644
--- a/plugins/tree/client.js
+++ b/plugins/tree/client.js
@@ -312,7 +312,44 @@ window.__ModuleLoader__.load({
     // retired and non-tree Bots have no parent and ds-bot shows them under Chief; archived / 归档-*
     // Bots are omitted via include() (#452). The entry is
     // re-registered whenever the structure changes (field changes and a 10 s poll), which re-renders.
-    function registerStructure(flybot) {
+    // One roster read for the whole plugin (#816): the structure entry and the archived section both
+    // need ctx.flybot.bots(), and each of them polled it on its own 10 s timer, so a mounted sidebar
+    // asked the host for the same list twice per tick. The first subscriber starts the poll, every
+    // subscriber gets the same list, and the last one to leave stops it. `refresh()` asks for a fresh
+    // read now — a field change or a removal — without starting a second timer.
+    function rosterFeed(flybot, { interval = REFRESH_MS } = {}) {
+      let bots = []
+      let timer = null
+      let reading = false
+      let again = false
+      const subs = new Set()
+      const read = async () => {
+        if (reading) { again = true; return } // a slow read does not stack up behind the timer
+        reading = true
+        let next
+        try { next = typeof flybot.bots === 'function' ? await flybot.bots() : [] } catch { reading = false; return }
+        reading = false
+        bots = next ?? []
+        for (const fn of [...subs]) { try { fn(bots) } catch { /* one subscriber must not stop the feed */ } }
+        if (again) { again = false; void read() }
+      }
+      return {
+        get: () => bots,
+        subscribe(fn) {
+          subs.add(fn)
+          try { fn(bots) } catch { /* the subscriber can start again on the next read */ }
+          if (subs.size === 1) {
+            timer = setInterval(read, interval)
+            timer?.unref?.()
+            void read()
+          }
+          return () => { subs.delete(fn); if (!subs.size && timer) { clearInterval(timer); timer = null } }
+        },
+        refresh() { if (subs.size) void read() },
+      }
+    }
+
+    function registerStructure(flybot, feed = rosterFeed(flybot)) {
       let parents = new Map()
       let statuses = new Map()
       let key = '[[],[],[]]'  // parents, tags, hidden (#452)
@@ -323,9 +360,7 @@ window.__ModuleLoader__.load({
       let hidden = new Set()
       const entry = () => ({ id: 'flybot-tree', order: 90, parentOf: id => parents.get(id), include: id => !hidden.has(id), menuItems, nodeActions })
       let off = flybot.slots.register('flybot.sidebar.structure', entry())
-      const refresh = async () => {
-        let bots
-        try { bots = typeof flybot.bots === 'function' ? await flybot.bots() : [] } catch { return }
+      const update = bots => {
         if (stopped) return
         const next = new Map()
         const walk = (node, parent) => { if (parent) next.set(node.id, parent); for (const c of node.children) walk(c, node.id) }
@@ -347,14 +382,10 @@ window.__ModuleLoader__.load({
         off()
         off = flybot.slots.register('flybot.sidebar.structure', entry())
       }
-      const offs = []
-      try { offs.push(flybot.fields?.on?.('change', c => { if (c && (c.key === 'parent' || c.key === 'treeRole' || c.key === 'retired' || c.key === 'archived' || c.key === 'idle' || c.removed)) refresh() })) } catch { /* no change feed */ }
-      const timer = setInterval(refresh, REFRESH_MS)
-      timer?.unref?.()
-      void refresh()
+      const offs = [feed.subscribe(update)]
+      try { offs.push(flybot.fields?.on?.('change', c => { if (c && (c.key === 'parent' || c.key === 'treeRole' || c.key === 'retired' || c.key === 'archived' || c.key === 'idle' || c.removed)) feed.refresh() })) } catch { /* no change feed */ }
       return () => {
         stopped = true
-        clearInterval(timer)
         for (const o of offs) { try { o?.() } catch { /* already gone */ } }
         off()
       }
@@ -476,22 +507,21 @@ window.__ModuleLoader__.load({
             }))
           : null)
     }
-    function makeArchivedSection(flybot) {
+    function makeArchivedSection(flybot, feed = rosterFeed(flybot)) {
       return function ArchivedSection(props) {
         useStyles()
         const [bots, setBots] = useState([])
         // Local, so the 10 s roster refresh re-renders the rows without closing the section.
         const [expanded, setExpanded] = useState(false)
-        const refresh = useCallback(async () => { try { setBots(archivedOf(await flybot.bots())) } catch { /* keep last */ } }, [])
+        // The roster read is the plugin's (#816): this section used to keep its own 10 s timer, so a
+        // mounted sidebar fetched the same list twice per tick.
+        const applyBots = useCallback(list => setBots(archivedOf(list)), [])
         useEffect(() => {
-          refresh()
-          const offs = []
-          try { offs.push(flybot.fields?.on?.('change', c => { if (c && (c.key === 'archived' || c.key === 'parent' || c.key === 'treeRole' || c.removed)) refresh() })) } catch { /* no change feed */ }
-          try { if (typeof flybot.on === 'function') offs.push(flybot.on('bot.removed', refresh)) } catch { /* no removal event */ }
-          const timer = setInterval(refresh, REFRESH_MS)
-          offs.push(() => clearInterval(timer))
+          const offs = [feed.subscribe(applyBots)]
+          try { offs.push(flybot.fields?.on?.('change', c => { if (c && (c.key === 'archived' || c.key === 'parent' || c.key === 'treeRole' || c.removed)) feed.refresh() })) } catch { /* no change feed */ }
+          try { if (typeof flybot.on === 'function') offs.push(flybot.on('bot.removed', () => feed.refresh())) } catch { /* no removal event */ }
           return () => { for (const off of offs) { try { off?.() } catch { /* already gone */ } } }
-        }, [refresh])
+        }, [applyBots, feed])
         const openSession = props?.actions?.openSession
         return h(ArchivedView, { bots, expanded, onToggle: () => setExpanded(e => !e), openBot: typeof openSession === 'function' ? id => openSession(id) : undefined })
       }
@@ -508,16 +538,18 @@ window.__ModuleLoader__.load({
       if (ctx.flybot && typeof ctx.flybot === 'object') { ctx.flybot.tree = helper; offs.push(() => { if (ctx.flybot.tree === helper) delete ctx.flybot.tree }) }
       if (globalThis.__flybot__) { globalThis.__flybot__.tree = helper; offs.push(() => { if (globalThis.__flybot__?.tree === helper) delete globalThis.__flybot__.tree }) }
       if (config?.sidebarSection === true) offs.push(ctx.flybot.slots.register('flybot.sidebar.section', { id: 'flybot-tree', order: 90, component: makeSection(ctx.flybot) }))
-      if (ctx.flybot?.slots) offs.push(registerStructure(ctx.flybot))
+      // One roster feed for the structure entry and the archived section, so one read per tick (#816).
+      const feed = ctx.flybot ? rosterFeed(ctx.flybot) : null
+      if (ctx.flybot?.slots && feed) offs.push(registerStructure(ctx.flybot, feed))
       // Archived Bots (#810) are hidden from ds-bot's list (#452), which left their chats reachable only
       // from the right-click menu. Draws nothing when no Bot is archived.
-      if (ctx.flybot?.slots && config?.archivedSection !== false) offs.push(ctx.flybot.slots.register('flybot.sidebar.section', { id: 'flybot-tree-archived', order: 88, component: makeArchivedSection(ctx.flybot) }))
+      if (ctx.flybot?.slots && feed && config?.archivedSection !== false) offs.push(ctx.flybot.slots.register('flybot.sidebar.section', { id: 'flybot-tree-archived', order: 88, component: makeArchivedSection(ctx.flybot, feed) }))
       // The reorganization notice (#446) is on by default (config.reorgNotice: false hides it); it draws nothing until a reorganization ran.
       if (ctx.flybot?.slots && config?.reorgNotice !== false) offs.push(ctx.flybot.slots.register('flybot.sidebar.section', { id: 'flybot-tree-reorg', order: 89, component: makeReorgNotice(ctx.flybot) }))
       const off = () => { for (const fn of offs.splice(0)) fn?.() }
       ctx.effect?.(() => off, 'flybot-tree: tree helper')
       return off
     }
-    return { name: 'flybot-tree', inject, apply, forestOf, registerStructure, makeReorgNotice, ReorgCard, noticeRun, statusOf, makeStatusTag, archivedOf, ArchivedView, makeArchivedSection, REORG_CSS, makeMenuItems, makeInviteAction, copyInvite, copyText, INVITE_CSS, buildForest, treeOf, TreeView, countNodes, EMPTY, CSS }
+    return { name: 'flybot-tree', inject, apply, forestOf, rosterFeed, registerStructure, makeReorgNotice, ReorgCard, noticeRun, statusOf, makeStatusTag, archivedOf, ArchivedView, makeArchivedSection, REORG_CSS, makeMenuItems, makeInviteAction, copyInvite, copyText, INVITE_CSS, buildForest, treeOf, TreeView, countNodes, EMPTY, CSS }
   },
 })
diff --git a/plugins/tree/test/tree.test.js b/plugins/tree/test/tree.test.js
index fa6216934..ff6dbbba9 100644
--- a/plugins/tree/test/tree.test.js
+++ b/plugins/tree/test/tree.test.js
@@ -507,9 +507,9 @@ test('#90: new and adopted Bots start ungranted, prompts tell a child how outsid
   assert.doesNotMatch(sp(m, m.root), /granted access to you/)
 })
 
-const loadClient = () => {
+const loadClient = (react = reactStub) => {
   let mod
-  globalThis.window = { __ModuleLoader__: { load: ({ factory }) => { mod = factory(() => reactStub) } } }
+  globalThis.window = { __ModuleLoader__: { load: ({ factory }) => { mod = factory(() => react) } } }
   new Function(readFileSync(new URL('../client.js', import.meta.url), 'utf8'))()
   return mod
 }
@@ -1941,3 +1941,108 @@ test('#810: an existing lead of the group is reused, and no second lead is made'
   assert.deepEqual([ra.created.parent.id, rb.created.parent.id], [leadId, leadId])
   assert.deepEqual(childrenIn(f, leadId).map(x => x.name).sort(), ['FlyBot Programmer', 'FlyBot Tester'])
 })
+
+// #816: a burst whose bots the vocabulary cannot place shares only `area:` ('other' → "General"), and
+// that is the bucket roles are *filed* under, not a group (#810's key must be a real one). Without the
+// exclusion in createChild, two such creates in flight at once would be forced under one "General Lead"
+// — a group of unrelated Bots — instead of each taking the plain path.
+test('#816: an `area:` key never groups a burst, so no "General Lead" is made', async () => {
+  const { profileOf, keysOf } = await import('../src/roles.js')
+  const areaOf = name => keysOf(profileOf({ name, role: 'x' }))
+  assert.deepEqual(areaOf('Bo'), ['area:other'], 'a two-letter name with an unplaceable role has only the area key')
+  assert.deepEqual(areaOf('Al'), ['area:other'], 'and so does its sibling: they would share that key')
+  const f = fakeAdapter()
+  const tree = createTree(f.fb, { limits: { maxDepth: 5, maxChildren: 8 } })
+  const releaseA = f.hold('Bo')
+  const releaseB = f.hold('Al')
+  const a = tree.allocateChild(f.chief, 'Bo', 'x', undefined)
+  const b = tree.allocateChild(f.chief, 'Al', 'y', undefined)
+  await until('a create to start', () => byName(f, 'Bo') || byName(f, 'Al'))
+  releaseA(); releaseB()
+  const [ra, rb] = await Promise.all([a, b])
+  assert.equal(byName(f, 'General Lead'), undefined, 'no lead is made for the "other" area')
+  assert.equal([...f.bots.values()].filter(x => x.fields?.lead?.key === 'area:other').length, 0, 'and no entry claims that key')
+  assert.deepEqual([ra.created.parent.id, rb.created.parent.id], [f.chief, f.chief], 'each lands at the caller, where it would have gone alone')
+  assert.deepEqual([...f.bots.values()].map(x => x.name).sort(), ['Al', 'Bo', 'Chief', 'Dev Lead', 'Existing Programmer'])
+  // A real key still groups the same fixture, so the case fails for the right reason.
+  const g = fakeAdapter()
+  const grouped = createTree(g.fb, { limits: { maxDepth: 5, maxChildren: 8 } })
+  const relA = g.hold('FlyBot Programmer')
+  const relB = g.hold('FlyBot Tester')
+  const pa = grouped.allocateChild(g.chief, 'FlyBot Programmer', 'writes code', undefined)
+  const pb = grouped.allocateChild(g.chief, 'FlyBot Tester', 'tests code', undefined)
+  await until('a create to start', () => byName(g, 'FlyBot Programmer') || byName(g, 'FlyBot Tester'))
+  relA(); relB()
+  const [qa, qb] = await Promise.all([pa, pb])
+  assert.equal(qa.created.parent.id, qb.created.parent.id, 'a project: key still makes one group')
+  assert.equal(byName(g, 'FlyBot Lead').fields.parent, g.devLead)
+})
+
+// The client's sections render in ascending `order` within a slot (ds-bot sorts them), so a smaller
+// number sits HIGHER. The archived list (#810) is 88 and the reorganization notice is 89: the archived
+// Bots stay above the "Tree reorganized" card instead of the card pushing them down.
+test('#816: the archived list is ordered above the reorganization notice', () => {
+  const mod = loadClient()
+  const entries = []
+  const off = mod.apply({ flybot: { slots: { register: (name, entry) => { entries.push({ name, entry }); return () => {} } } } }, {})
+  const section = id => entries.find(e => e.name === 'flybot.sidebar.section' && e.entry.id === id)?.entry
+  const archived = section('flybot-tree-archived')
+  const reorg = section('flybot-tree-reorg')
+  assert.ok(archived && reorg, 'both sections are registered by default')
+  assert.ok(archived.order < reorg.order, `archived ${archived.order} must come before reorg ${reorg.order} (ascending order renders first)`)
+  assert.deepEqual(
+    entries.filter(e => e.name === 'flybot.sidebar.section').map(e => e.entry.id).sort((a, b) => section(a).order - section(b).order),
+    ['flybot-tree-archived', 'flybot-tree-reorg'],
+    'sorted the way the slot renders them: archived on top',
+  )
+  off()
+})
+
+// #816: the structure entry and the archived list both need ctx.flybot.bots(); each used to poll it on
+// its own 10 s timer, so a mounted sidebar asked the host for the same list twice per tick. Now the
+// plugin keeps one feed: the first subscriber starts it, later ones join it (no read on mount), and the
+// last one to leave stops it.
+test('#816: one roster read per tick, shared by the structure entry and the archived list', async () => {
+  const tick = (ms = 0) => new Promise(r => setTimeout(r, ms))
+  let reads = 0
+  const roster = [{ id: 'c', name: 'Chief', isMain: true, fields: {} }]
+  const flybot = { bots: async () => { reads++; return roster }, fields: { on: () => () => {} }, slots: { register: () => () => {} } }
+  const cleanups = []
+  const mod = loadClient({ ...reactStub, useEffect(fn) { const stop = fn(); cleanups.push(stop) } })
+
+  // (a) The feed itself: every subscriber sees every read, and one tick is one read.
+  const feed = mod.rosterFeed(flybot, { interval: 5 })
+  let seenStructure = 0
+  let seenArchived = 0
+  const offStructure = feed.subscribe(() => { seenStructure++ })
+  const offArchived = feed.subscribe(() => { seenArchived++ })
+  assert.equal(reads, 1, 'one read for both subscribers, not one each')
+  await tick() // let the read started by the first subscriber land before the window opens
+  reads = 0
+  seenStructure = 0
+  seenArchived = 0
+  await tick(40)
+  assert.ok(reads >= 2, 'the timer really ticked')
+  assert.equal(seenStructure, seenArchived, 'both consumers see the same reads')
+  assert.equal(seenStructure, reads, 'each read is delivered once: one roster read per tick, not one per consumer')
+  offStructure(); offArchived()
+  const afterStop = reads
+  await tick(30)
+  assert.equal(reads, afterStop, 'the last subscriber to leave stops the timer')
+
+  // (b) The wiring in apply(): mounting the archived list joins the structure entry's read instead of
+  // starting its own (a private feed would read once on its first subscribe, so this count would be 2).
+  reads = 0
+  const entries = []
+  const slots = { register: (name, entry) => { entries.push({ name, entry }); return () => {} } }
+  const stop = mod.apply({ flybot: { ...flybot, slots } }, {})
+  await tick()
+  assert.equal(reads, 1, 'the plugin starts with one read for the structure entry')
+  const archivedEntry = entries.find(e => e.name === 'flybot.sidebar.section' && e.entry.id === 'flybot-tree-archived')
+  assert.ok(archivedEntry, 'the archived section is registered by default')
+  renderToString(archivedEntry.entry.component({ bots: roster }))
+  await tick()
+  assert.equal(reads, 1, 'mounting the archived list reuses that read and does not ask for the roster again')
+  stop()
+  for (const stopEffect of cleanups.splice(0)) { try { stopEffect?.() } catch { /* already gone */ } }
+})