crewbus 10.0.3 → 10.0.5

package/CHANGELOG.md

@@ -4,6 +4,32 @@
 
 - Package is now published as unscoped `crewbus` (v10.0.2): `npm i -g crewbus`.
 
+## 10.0.5 (2026-10-12)
+
+PATCH RELEASE: Self-update command. No board-schema change (`board.json` stays v2); additive CLI surface only.
+
+- **`crewbus update [--check] [--yes] [--version x.y.z]`**:
+  - Version check via `npm view <own-name>@latest version`, install via `npm install -g` — registry, auth, and proxy come from the user's npm config, never hardcoded.
+  - Package name always read from our own `package.json` (never argv); `--version` accepts strict `x.y.z` only.
+  - `--check` reports only; bare `update` refuses off-TTY without `--yes` (install scripts execute from the network); source checkouts are refused with `git pull` guidance.
+  - Already-latest and newer-than-registry are no-ops; explicit pins allow downgrades; post-install note covers the old-code process restart + `init --force` for wiring.
+
+## 10.0.4 (2026-10-12)
+
+PATCH RELEASE: Briefs view + gather endpoint, task-scoped spawn rosters, and mobile brief/thread/watcher screens. No board-schema change (`board.json` stays v2); all additions backward-compatible.
+
+- **Dashboard Briefs view + `GET /api/gather?batch=`**:
+  - New Briefs section: one row per fan-out (subject, workers, checkpoint/final counts, acked fraction, relative last activity); click a row for its gathered thread (briefs, checkpoint timeline, finals with ack ticks, telemetry footer).
+  - Crews table gains a brief/groups column (batch short-id + group names, or "solo"); Recent activity gains a text filter + checkpoints/finals toggle.
+- **Task-scoped spawn rosters**:
+  - `buildCrewContext` takes the task's groups only; groups from unrelated concurrent briefs collapse to a count (`N other groups exist on this board`) instead of leaking names cross-task. Documented in `docs/GROUPS.md`.
+- **Mobile (M5)**:
+  - Boards card counts live workers (`alive === true`) instead of all pid-bearing workers.
+  - Triage groups inbox by brief thread with checkpoint/final/note chips.
+  - New Briefs screen (one row per batch, tap for thread via `/api/gather`).
+  - Foreground watcher (`src/lib/watch.js`): polls inbox approvals + board dead-man state, alerts once per new id with in-app banner + haptic. Foreground-only by scaffold rule (no notification plugins); killed-app push remains future work (needs the plugin rule lifted + EAS credentials + a relay sender).
+  - `/api/inbox` items now carry `checkpoint` (additive).
+
 ## 10.0.3 (2026-10-10)
 
 PATCH RELEASE: Worker-record integrity, truthful presence, and multi-group collaboration in spawn briefs. No board-schema change (`board.json` stays v2); all prompt additions are backward-compatible (absent unless the spawn carries group/compute context).

package/README.md

@@ -1,4 +1,4 @@
-# crewbus v10.0.3 — DM bus
+# crewbus v10.0.5 — DM bus
 
 [![CI](https://github.com/eamonpluto/crewbus/actions/workflows/ci.yml/badge.svg)](https://github.com/eamonpluto/crewbus/actions/workflows/ci.yml)
 
@@ -55,7 +55,7 @@ env overrides below.)
 Layout: `board.json`, `agents/<name>.json`, `dm/<recipient>/<id>.json`,
 `delivered/<recipient>/<id>.json` (push markers, written by the plugin).
 
-Versions: `package.json` (currently 10.0.3) is the source of truth for the
+Versions: `package.json` (currently 10.0.5) is the source of truth for the
 release version. `board.json`'s `version: 2` is the **board schema version**
 (a different number on purpose — do not "align" them). New to the project?
 Start with `docs/QUICKSTART.md` (5 minutes).

package/bin/crewbus.js

@@ -2869,16 +2869,21 @@ function cmdSpawn(args) {
   if (alsoChannel && (!toGroupRaw || !String(toGroupRaw).trim())) fail("--also-channel needs --to-group <g,...> (it mirrors the brief into each group's channel)");
   const groupNames = String(toGroupRaw || "").split(",").map((s) => String(s).trim().toLowerCase().replace(/[^a-z0-9_.-]/g, "-").slice(0, 40)).filter(Boolean);
   // Crew roster for the prompt block (see buildCrewContext in lib/spawn.js):
-  // every group on the board with its members, so each worker learns the
-  // map — its own group, the other groups, and the peer-DM norms — at
-  // boot instead of discovering (or never discovering) the board alone.
+  // TASK-scoped, not board-scoped. Only the groups named in THIS spawn
+  // appear in the brief — their lanes are what a worker may need to
+  // contact. Groups from unrelated concurrent briefs collapse to a count
+  // (discoverable via `crewbus group list`, never advertised cross-task:
+  // ambient cross-task rosters are prompt noise and a misleading
+  // invitation to DM crews working on unrelated tasks).
   const rosterGroups = [];
   for (const e of listJson(d.groups)) {
     const g = e && e.data;
     if (g && g.name && Array.isArray(g.members)) rosterGroups.push({ name: g.name, members: g.members.slice() });
   }
   rosterGroups.sort((a, b) => String(a.name).localeCompare(String(b.name)));
-  const crewFor = (to) => buildCrewContext({ name: to, from, subject, groups: rosterGroups, myGroups: rosterGroups.filter((g) => g.members.includes(to)).map((g) => g.name) });
+  const taskGroups = rosterGroups.filter((g) => groupNames.includes(g.name));
+  const offTask = rosterGroups.length - taskGroups.length;
+  const crewFor = (to) => buildCrewContext({ name: to, from, subject, groups: taskGroups, myGroups: taskGroups.filter((g) => g.members.includes(to)).map((g) => g.name), offTask });
   const model = getFlag(args, "--model");
   const auto = args.includes("--auto");
   requireAutoConfirm(args);
@@ -6321,6 +6326,10 @@ Setup:
     project-local surface (claude/opencode/cursor); codex/grok/antigravity
     are skipped (TOML or global-only surfaces — see docs/COMPATIBILITY.md).
     Nothing else is widened.
+  crewbus update [--check] [--yes] [--version x.y.z]
+    self-update the global npm install to the registry latest
+    (--check reports only; needs --yes off-TTY; runs the published
+    install scripts — same trust as npm i -g crewbus)
 
 Identity (first claim wins, token after that):
   crewbus register --from <you> [--session <opencode-session-id>] [--token <t>] [--expires-in <dur>] [--service]
@@ -7332,6 +7341,107 @@ function cmdInstallCli() {
   }
 }
 
+// Self-update support: which package did this process install as? Read
+// from our own package.json next to bin/crewbus.js — the name is never
+// taken from argv, so there is no `update <other-pkg>` confusion/abuse.
+function ownPackage() {
+  try {
+    const here = path.dirname(path.resolve(process.argv[1] || ""));
+    const pkg = JSON.parse(fs.readFileSync(path.join(here, "..", "package.json"), "utf8"));
+    if (pkg && typeof pkg.name === "string" && typeof pkg.version === "string") {
+      return { name: pkg.name, version: pkg.version, dir: path.resolve(path.join(here, "..")) };
+    }
+  } catch {}
+  return null;
+}
+
+// Zero-dep semver compare (release parts only; prerelease suffixes compare
+// equal — `npm view` reports the latest stable tag, so suffixes never meet
+// in the check path; --version pins accept them verbatim).
+function cmpSemver(a, b) {
+  const parts = (s) => String(s || "").trim().replace(/^[=v]/, "").split(".").map((x) => {
+    const n = Number(String(x).split("-")[0]);
+    return Number.isInteger(n) && n >= 0 ? n : 0;
+  });
+  const pa = parts(a);
+  const pb = parts(b);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d !== 0) return d > 0 ? 1 : -1;
+  }
+  return 0;
+}
+
+function cmdUpdate(args) {
+  const checkOnly = args.includes("--check");
+  const yes = args.includes("--yes");
+  const wantRaw = getFlag(args, "--version");
+  if (wantRaw !== undefined && !/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/.test(String(wantRaw).trim())) {
+    fail(`--version must be a plain x.y.z version (got "${wantRaw}") — no tags, URLs, or ranges`);
+  }
+  const own = ownPackage();
+  if (!own) fail("cannot determine the installed package (no package.json next to the CLI) — reinstall with: npm i -g crewbus");
+  try {
+    if (fs.existsSync(path.join(own.dir, ".git"))) {
+      fail(`running from a source checkout at ${own.dir} — update it with: git pull (npm would install the registry copy elsewhere; the global CLI is a separate install)`);
+    }
+  } catch (e) {
+    if (e && e.message && e.message.startsWith("running from a source checkout")) throw e;
+  }
+  // The user's own npm: registry, auth, proxy and cache all come from
+  // their npm config — never hardcoded here. shell:true on Windows so the
+  // npm.cmd shim resolves (same convention as probeBinary in lib/launch.js).
+  const npmShell = process.platform === "win32";
+  try {
+    execFileSync("npm", ["--version"], { stdio: ["ignore", "pipe", "pipe"], timeout: 15000, shell: npmShell });
+  } catch {
+    fail("npm was not found on PATH — install Node.js/npm first, or update manually: npm i -g crewbus@latest");
+  }
+  let latest = "";
+  try {
+    latest = String(execFileSync("npm", ["view", `${own.name}@latest`, "version"], { stdio: ["ignore", "pipe", "pipe"], timeout: 30000, shell: npmShell }) || "").trim();
+  } catch {
+    latest = "";
+  }
+  if (!latest) fail(`could not reach the npm registry (offline?) — latest ${own.name} version unknown; retry with network, or install explicitly: npm i -g ${own.name}@<x.y.z>`);
+  const want = wantRaw !== undefined ? String(wantRaw).trim() : latest;
+  const cmp = cmpSemver(own.version, want);
+  if (cmp === 0) {
+    console.log(`crewbus ${own.version} installed${wantRaw !== undefined ? ` (requested ${want})` : `, ${latest} latest`} — already up to date [board n/a]`);
+    return;
+  }
+  if (cmp > 0 && wantRaw === undefined) {
+    console.log(`crewbus ${own.version} installed is newer than registry latest ${latest} (dev install?) — nothing to do [board n/a]`);
+    return;
+  }
+  if (checkOnly) {
+    console.log(`crewbus ${own.version} installed, ${want} available — re-run without --check to update [board n/a]`);
+    return;
+  }
+  const direction = cmp < 0 ? "upgrade" : "downgrade";
+  if (!yes) {
+    if (process.stdin && process.stdin.isTTY) {
+      process.stderr.write(`This ${direction}s ${own.name} ${own.version} → ${want} via "npm install -g" (runs the published package's install scripts). Type "yes" to continue: `);
+      let answer = "";
+      try {
+        answer = String(fs.readFileSync(0, "utf8") || "").trim().toLowerCase();
+      } catch {}
+      if (answer !== "yes" && answer !== "y") fail("update refused (confirmation not given) — re-run with --yes to confirm");
+    } else {
+      fail(`refusing to self-update non-interactively without --yes (npm install -g executes the published package's install scripts) — re-run with --yes to confirm`);
+    }
+  }
+  console.log(`${direction === "upgrade" ? "Updating" : "Downgrading"} ${own.name} ${own.version} → ${want} (npm install -g ${own.name}@${want})…`);
+  try {
+    execFileSync("npm", ["install", "-g", `${own.name}@${want}`], { stdio: "inherit", timeout: 300000, shell: npmShell });
+  } catch (e) {
+    const detail = String((e && e.message) || e);
+    const busy = /EBUSY|EPERM/i.test(detail);
+    fail(`npm install failed: ${detail.slice(0, 300)}${busy ? " — close running crewbus processes (web/serve/listen/watchers holding the install open) and retry" : ""}`);
+  }
+  console.log(`updated to ${want} — this process is still the old code: restart your terminal (and any crewbus web/serve/listen processes), then re-run init --force in your projects to refresh harness wiring [board n/a]`);
+}
+
 async function main() {
   const [, , cmd, ...rest] = process.argv;
   if (REMOVED.has(cmd)) {
@@ -7340,6 +7450,7 @@ async function main() {
   switch (cmd) {
     case "init": return cmdInit(rest);
     case "install-cli": return cmdInstallCli();
+    case "update": return cmdUpdate(rest);
     case "register": return cmdRegister(rest);
     case "acl": return cmdAcl(rest);
     case "agents": return cmdAgents(rest);

package/bin/lib/groups.js

@@ -7,7 +7,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { readJson, writeJson, listJson, fail, parseGroupList, cleanGroupName } from "./store.js";
-import { readDMs, findMessageById, isVerified, scanAllMessages } from "./mail.js";
+import { readDMs, findMessageById, isVerified, scanAllMessages, ackedIdSet } from "./mail.js";
 import { readChannelPosts } from "./channels.js";
 
 // parseGroupList + cleanGroupName live in store.js (canonical home).
@@ -197,6 +197,99 @@ export function gatherTelemetry(items) {
   return { messages: items.length, tokensEst: Math.floor(chars / 4) };
 }
 
+// Batch (brief) enumeration for the dashboard Briefs view: one row per
+// fan-out/thread on the board — briefs, checkpoints, finals, ack state,
+// last activity. Keys come from message batch stamps plus spawned
+// workers' briefIds (single-recipient briefs carry no batch until
+// replied to); a batch-less root with no replies and no worker pointing
+// at it is a stray DM, not a brief, and is skipped. Stats mirror
+// collectBatch + gatherTelemetry; pure read, no board IO.
+export function listBatches(d) {
+  const all = [];
+  let subs = [];
+  try {
+    subs = fs.readdirSync(d.dm);
+  } catch {
+    subs = [];
+  }
+  for (const sub of subs) {
+    try {
+      if (!fs.statSync(path.join(d.dm, sub)).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    for (const m of readDMs(d, sub)) all.push(m);
+  }
+  for (const e of listJson(d.broadcast || path.join(d.root, "broadcast"))) {
+    const b = e.data;
+    if (b && b.id && b.from) {
+      if (!b.batch) b.batch = b.id;
+      all.push(b);
+    }
+  }
+  const childCount = new Map();
+  for (const m of all) {
+    if (!m.replyTo) continue;
+    childCount.set(m.replyTo, (childCount.get(m.replyTo) || 0) + 1);
+  }
+  const keys = [];
+  const seen = new Set();
+  const addKey = (k) => {
+    if (k && !seen.has(k)) {
+      seen.add(k);
+      keys.push(k);
+    }
+  };
+  for (const m of all) {
+    if (m.batch) addKey(m.batch);
+    else if (!m.replyTo && (childCount.get(m.id) || 0) > 0) addKey(m.id);
+  }
+  try {
+    for (const e of listJson(path.join(d.root, "agents"))) {
+      const a = e && e.data;
+      if (a && a.briefId) addKey(a.briefId);
+    }
+  } catch {}
+  const acked = ackedIdSet(d);
+  const rows = [];
+  for (const key of keys) {
+    const res = collectBatch(d, key);
+    if (!res) continue;
+    const briefs = res.items.filter((m) => !m.replyTo);
+    if (briefs.length === 0) continue;
+    briefs.sort((a, b) => String(a.at).localeCompare(String(b.at)) || String(a.id).localeCompare(String(b.id)));
+    const replies = res.items.filter((m) => !!m.replyTo);
+    const checkpoints = replies.filter((m) => m.checkpoint === true);
+    const finals = replies.filter((m) => m.checkpoint !== true);
+    const workers = [];
+    for (const b of briefs) {
+      const tos = Array.isArray(b.to) ? b.to : (b.to ? [b.to] : []);
+      for (const t of tos) {
+        if (t && !workers.includes(t)) workers.push(t);
+      }
+    }
+    let lastAt = briefs[0].at || "";
+    for (const m of res.items) {
+      if (String(m.at || "") > String(lastAt || "")) lastAt = m.at;
+    }
+    rows.push({
+      batch: key,
+      subject: briefs[0].subject || "",
+      from: briefs[0].from || "",
+      at: briefs[0].at || "",
+      workers,
+      briefCount: briefs.length,
+      replyCount: replies.length,
+      checkpointCount: checkpoints.length,
+      finalCount: finals.length,
+      ackedFinals: finals.filter((m) => acked.has(m.id)).length,
+      lastAt: lastAt || "",
+    });
+  }
+  rows.sort((a, b) => String(b.lastAt).localeCompare(String(a.lastAt)) || String(a.batch).localeCompare(String(b.batch)));
+  return rows;
+}
+
 export function batchReplyIds(d, batch) {
   const res = collectBatch(d, batch);
   if (!res) return null;

package/bin/lib/mail.js

@@ -388,6 +388,27 @@ export function ackedIds(d, agent) {
   return out;
 }
 
+// Ack markers across every agent: message ids with at least one ack, by
+// anyone. Powers batch-thread ack state (dashboard Briefs/gather) —
+// orthogonal to per-agent ackedIds(), which scopes triage to one inbox.
+export function ackedIdSet(d) {
+  const out = new Set();
+  let subs = [];
+  try {
+    subs = fs.readdirSync(path.join(d.root, "acked"));
+  } catch {
+    return out;
+  }
+  for (const sub of subs) {
+    try {
+      for (const f of fs.readdirSync(path.join(d.root, "acked", sub)).filter((f) => f.endsWith(".json"))) {
+        out.add(f.replace(/\.json$/, ""));
+      }
+    } catch {}
+  }
+  return out;
+}
+
 export function splitCommand(cmd) {
   const out = [];
   let cur = "";

package/bin/lib/spawn.js

@@ -185,14 +185,19 @@ export function buildSpawnPrompt({ name, from, subject, body, replyId, rev, cwd,
 
 // Crew context block for the spawn prompt: the roster a worker needs to
 // talk peer-direct instead of star-topologizing every question through
-// the lead. `groups` is the board's full group list [{ name, members }],
-// `myGroups` the group names this recipient belongs to, `subject` the lane
-// line for my groups (the spawn call's --subject). Workers may send to
-// each other (and to-group) and tail any channel, but channel-post is
-// lead|admin-only (see identity.js LEAD_PLUS) — so the block points reads
-// at channels and writes at DMs. Returns bullet lines (no header); the
-// caller renders them under a Crew: header. Pure: unit-tested, no board IO.
-export function buildCrewContext({ name, from, subject, groups, myGroups }) {
+// the lead. `groups` is the TASK roster — the groups named in this spawn
+// only — [{ name, members }]; `myGroups` the group names this recipient
+// belongs to; `subject` the lane line for my groups (the spawn call's
+// --subject); `offTask` how many board groups from unrelated concurrent
+// briefs exist (collapsed to a count, never enumerated: cross-task
+// rosters are prompt noise and a misleading invitation — "ask the group
+// that owns a thing" only makes sense for sibling lanes of the same
+// task). Workers may send to each other (and to-group) and tail any
+// channel, but channel-post is lead|admin-only (see identity.js
+// LEAD_PLUS) — so the block points reads at channels and writes at DMs.
+// Returns bullet lines (no header); the caller renders them under a
+// Crew: header. Pure: unit-tested, no board IO.
+export function buildCrewContext({ name, from, subject, groups, myGroups, offTask }) {
   const all = (groups || []).filter((g) => g && g.name);
   const mineSet = new Set(myGroups || []);
   const mine = all.filter((g) => mineSet.has(g.name));
@@ -200,6 +205,8 @@ export function buildCrewContext({ name, from, subject, groups, myGroups }) {
   const lane = subject && String(subject).trim() ? String(subject).trim() : "the brief above";
   const me = String(name || "you");
   const lead = String(from || "lead");
+  const off = Math.max(0, Number(offTask) || 0);
+  const offNoun = (n) => `${n} other group${n === 1 ? "" : "s"}`;
   const showMembers = (members) => {
     const ms = (members || []).filter(Boolean).map(String);
     return ms.slice(0, 8).join(",") + (ms.length > 8 ? "…" : "");
@@ -212,11 +219,11 @@ export function buildCrewContext({ name, from, subject, groups, myGroups }) {
   }
   if (others.length > 0) {
     // Same one-liner as channels.js groupChannelName (grp-<group>, max 60).
-    out.push(`other groups on this board: ${others.map((g) => `${g.name} (${showMembers(g.members)})`).join("; ")} — their channels: ${others.map((g) => `grp-${g.name}`.slice(0, 60)).join(", ")}.`);
+    out.push(`other groups on this task: ${others.map((g) => `${g.name} (${showMembers(g.members)})`).join("; ")} — their channels: ${others.map((g) => `grp-${g.name}`.slice(0, 60)).join(", ")}.` + (off > 0 ? ` ${offNoun(off)} exist on this board: crewbus group list to discover.` : ""));
   } else if (mine.length > 0) {
-    out.push(`no other groups on this board right now — discover live agents with: crewbus agents.`);
+    out.push(off > 0 ? `no other groups on this task. ${offNoun(off)} exist on this board: crewbus group list to discover.` : `no other groups on this board right now — discover live agents with: crewbus agents.`);
   } else {
-    out.push(`discover who else is on this board with: crewbus agents (plus crewbus group list once groups exist).`);
+    out.push(off > 0 ? `${offNoun(off)} exist on this board (crewbus group list to discover).` : `discover who else is on this board with: crewbus agents (plus crewbus group list once groups exist).`);
   }
   out.push(`ask the group that owns a thing before asking ${lead}: crewbus send --from ${me} --to-group <group> --subject "..." --body "..." (reaches every member; ${lead} is for approvals and scope disputes only).`);
   out.push(`read context freely: crewbus channel tail grp-<group> (a group's briefs + progress, reads need no token). Posting to channels needs lead rights — write everything via DMs.`);

package/bin/lib/web.js

@@ -17,9 +17,9 @@ import path from "node:path";
 import http from "node:http";
 import { boardDir, requireBoard, getFlag, fail, writeJson, listJson, cleanWebName, readJson, gitRevForBoard, newId, MAX_SPAWN, MAX_BODY_CHARS } from "./store.js";
 import { readAgent, agentTokenMatches, authorizeCheck, mintToken, newSalt, hashToken, touchAgent } from "./identity.js";
-import { readDMs, readVisible, ackedIds, findMessageById, deliverDMs, parseRecipients } from "./mail.js";
+import { readDMs, readVisible, ackedIds, ackedIdSet, findMessageById, deliverDMs, parseRecipients } from "./mail.js";
 import { workerStatus, pidAlive, killWorkers, bootWorker, buildSpawnPrompt, buildSpawnTarget, formatSpawnCmd, installCliToUserPath, ensureBoardCliShim } from "./spawn.js";
-import { groupTelemetryData } from "./groups.js";
+import { groupTelemetryData, collectBatch, gatherTelemetry, listBatches } from "./groups.js";
 import { httpJson } from "./sync.js";
 import { readChainRecords, verifyChainRecords, appendChainRecord, readHold, readBoardQuotas } from "./export.js";
 import { launchDrivers, detectHarnessBinaries, validateLaunchPlan, advertiseEnv, HARNESS_MODELS, getDiscoveredModels, refreshDiscoveredModels } from "./launch.js";
@@ -112,7 +112,18 @@ export function boardSnapshot(d, activeWindowSec) {
     .filter((x) => x && x.peer && typeof x.lastOk === "number")
     .sort((a, b) => String(a.peer).localeCompare(String(b.peer)))
     .map((p) => ({ peer: p.peer, lastOk: new Date(p.lastOk).toISOString() }));
-  return { board: d.root, at: new Date().toISOString(), agents, workers, broadcasts, recent: recent.slice(0, 30), ackedBy, groups, peers };
+  // Brief batch per worker (for the Crews brief/group column): the batch
+  // stamp on the worker's brief DM, else the brief id itself. Built from
+  // the full pre-slice message scan so capped feeds never lose the join.
+  const batchByBriefId = new Map();
+  for (const m of recent) {
+    if (m && m.id && !batchByBriefId.has(m.id)) batchByBriefId.set(m.id, m.batch || m.id);
+  }
+  const workersWithBatch = workers.map((w) => ({
+    ...w,
+    batch: w.briefId ? (batchByBriefId.get(w.briefId) || w.briefId) : undefined,
+  }));
+  return { board: d.root, at: new Date().toISOString(), agents, workers: workersWithBatch, broadcasts, recent: recent.slice(0, 30), ackedBy, groups, peers, briefs: listBatches(d) };
 }
 
 // Fleet console snapshots (served by `web`, all open reads like /api/board;
@@ -622,9 +633,10 @@ details.tech-details summary{cursor:pointer;font-weight:500;user-select:none}
 
     <div class="sidebar-heading">VIEWS</div>
     <nav id="approot-nav" aria-label="sections">
-      <button data-nav="sec-launch" class="active">Launch</button>
-      <button data-nav="sec-boards">Boards</button>
-      <button data-nav="sec-crews">Crews</button>
+        <button data-nav="sec-launch" class="active">Launch</button>
+        <button data-nav="sec-boards">Boards</button>
+        <button data-nav="sec-briefs">Briefs</button>
+        <button data-nav="sec-crews">Crews</button>
       <button data-nav="sec-fleet">Fleet</button>
       <button data-nav="sec-channels">Channels</button>
       <button data-nav="sec-triage">Triage</button>
@@ -770,15 +782,23 @@ details.tech-details summary{cursor:pointer;font-weight:500;user-select:none}
           <div class="card"><b id="c-peers">–</b><br>peers</div>
         </div>
         <h2>Recent activity</h2>
+        <div style="display:flex;gap:8px;margin-bottom:8px"><input id="feed-q" placeholder="filter route / message…" style="flex:1"><select id="feed-type"><option value="">all</option><option value="checkpoint">checkpoints</option><option value="final">final reports</option></select></div>
         <table><tr><th>id</th><th>route</th><th>message</th></tr><tbody id="recent"></tbody></table>
         <h2>Broadcasts</h2>
         <table><tr><th>id</th><th>from</th><th>to</th><th>subject</th><th>body</th></tr><tbody id="bcast"></tbody></table>
       </section>
 
+      <!-- SECTION: BRIEFS (ONE ROW PER FAN-OUT) -->
+      <section id="sec-briefs" data-section="Briefs" class="approot-hidden">
+        <h2>Briefs <span class="dim">one row per fan-out — click a row for its gathered thread</span></h2>
+        <table><tr><th>brief</th><th>workers</th><th>checkpoints</th><th>finals</th><th>acked</th><th>last activity</th></tr><tbody id="briefs"></tbody></table>
+        <div id="brief-thread"></div>
+      </section>
+
       <!-- SECTION: CREWS (WORKERS & TEAMS) -->
       <section id="sec-crews" data-section="Crews" class="approot-hidden">
         <h2>Workers <button id="killall" class="danger">kill all</button></h2>
-        <table><tr><th>worker</th><th>state</th><th>pid</th><th>reply</th><th>log tail</th><th></th></tr><tbody id="workers"></tbody></table>
+        <table><tr><th>worker</th><th>state</th><th>pid</th><th>brief / groups</th><th>reply</th><th>log tail</th><th></th></tr><tbody id="workers"></tbody></table>
         <h2>Agents</h2>
         <table><tr><th>name</th><th>presence</th><th>last seen</th><th>session</th><th>DMs</th><th>unacked</th></tr><tbody id="agents"></tbody></table>
         <h2>Groups</h2>
@@ -919,6 +939,10 @@ var _lt=document.getElementById('launch-token');
 if(_lt){_lt.oninput=function(){try{localStorage.setItem('ab-tok',this.value.trim());}catch(_){}var t=document.getElementById('tok');if(t)t.value=this.value.trim();markIdent();};}
 autoLoadOperatorCreds();
 function stateOf(w){if(!w.known)return 'unknown';if(w.reply)return w.acked?'done · acked':'done · reply waiting';if(w.alive===true)return 'running';if(w.alive===false)return 'exited · no reply';return 'no pid';}
+var _fq=document.getElementById('feed-q');
+if(_fq){_fq.oninput=function(){renderRecent();};}
+var _ft=document.getElementById('feed-type');
+if(_ft){_ft.onchange=function(){renderRecent()};}
 async function kill(names){
   var c=creds();
   if(!c.from||!c.token){say('set identity + token first');return;}
@@ -938,8 +962,7 @@ document.getElementById('killall').onclick=async function(){
     if(!names.length){say('no live workers (kill needs a running pid)');return;}
   kill(names);
 };
-document.getElementById('ackall').onclick=async function(){
-  var c=creds();
+document.getElementById('ackall').onclick=async function(){  var c=creds();
   if(!c.from||!c.token){say('set identity + token first');return;}
   if(!confirm('ack everything unacked for '+c.from+'?'))return;
   say('acking all for '+c.from+' …');
@@ -950,6 +973,37 @@ document.getElementById('ackall').onclick=async function(){
   }catch(e){say('ack failed: '+e.message);}
   refresh();
 };
+function renderRecent(){
+  var q=((document.getElementById('feed-q')||{}).value||'').toLowerCase();
+  var t=((document.getElementById('feed-type')||{}).value||'');
+  var known=window.__ackedBy||{};
+  var rows=(window.__recent||[]).filter(function(m){
+    if(t==='checkpoint'&&m.checkpoint!==true)return false;
+    if(t==='final'&&!(m.replyTo&&m.checkpoint!==true))return false;
+    if(!q)return true;
+    var to=Array.isArray(m.to)?m.to.join(','):String(m.to||'');
+    return (m.id+' '+(m.from||'')+' '+to+' '+(m.subject||'')+' '+(m.body||'')).toLowerCase().indexOf(q)!==-1;
+  });
+  document.getElementById('recent').innerHTML=rows.map(function(m){
+    var to=Array.isArray(m.to)?m.to.join(','):String(m.to||'');
+    var acks=(known[m.id]||[]).map(function(x){return '✓'+x;}).join(' ');
+    return '<tr><td>'+esc(m.id)+'</td><td>'+esc(m.from)+' → '+esc(short(to,40))+'</td><td>'+(m.subject?'<b>'+esc(m.subject)+'</b><br>':'')+esc(short(m.body,200))+'<div class="dim">'+(m.replyTo?('re: '+esc(m.replyTo)+' '):'')+(m.batch?('batch '+esc(m.batch)+' '):'')+esc(acks)+'</div></td></tr>';
+  }).join('')||'<tr><td colspan="3" class="dim">no messages yet</td></tr>';
+}
+async function showBrief(batch){
+  var box=document.getElementById('brief-thread');
+  box.innerHTML='<div class="dim">loading thread '+esc(batch)+'…</div>';
+  try{
+    var r=await fetch('/api/gather?batch='+encodeURIComponent(batch),{cache:'no-store'});
+    var g=await r.json();
+    if(!r.ok){box.innerHTML='<div class="dim">gather failed: '+esc(g.error||r.status)+'</div>';return;}
+    box.innerHTML='<h3>'+esc(short(batch,32))+' <span class="dim">'+g.briefs+' briefs · '+g.replies+' replies · ~'+g.telemetry.tokensEst+' tok</span></h3>'+g.items.map(function(m){
+      var kind=!m.replyTo?'<b>brief</b>':(m.checkpoint?'<span class="dim">checkpoint</span>':'<b>final'+(m.acked?' ✓':'')+'</b>');
+      var to=Array.isArray(m.to)?m.to.join(','):String(m.to||'');
+      return '<div class="card" style="margin:.5em 0"><div>'+kind+' <b>'+esc(m.from)+'</b> → '+esc(short(to,60))+' <span class="dim">'+esc(ago(m.at))+'</span></div>'+(m.subject?'<div><b>'+esc(m.subject)+'</b></div>':'')+'<div class="log" style="white-space:pre-wrap">'+esc(m.body)+'</div></div>';
+    }).join('');
+  }catch(e){box.innerHTML='<div class="dim">gather failed: '+esc(e.message)+'</div>';}
+}
 async function refresh(){
   try{
     var r=await fetch('/api/board',{cache:'no-store'});
@@ -977,8 +1031,11 @@ async function refresh(){
       var tail=(w.tail||[]).slice(-3).map(function(l){return '<div class="log">'+esc(l)+'</div>';}).join('')||'<span class="dim">no log</span>';
       var rep=w.reply?esc(w.reply.id)+'<div class="dim">'+esc(w.reply.head)+'</div>':'—';
       var btn=(w.known&&w.alive===true)?'<button class="danger" data-kill="'+esc(w.name)+'">kill</button>':'';
-      return '<tr data-worker="'+esc(w.name)+'" class="worker-row"><td><b>'+esc(w.name)+'</b><div class="dim">by '+esc(w.spawnedBy||'?')+'</div></td><td>'+esc(stateOf(w))+'</td><td>'+(w.pid===null||w.pid===undefined?'—':esc(String(w.pid)))+'</td><td>'+rep+'</td><td>'+tail+'</td><td>'+btn+'</td></tr>';
-    }).join('')||'<tr><td colspan="6" class="dim">no spawned workers</td></tr>';
+      var wgroups=(s.groups||[]).filter(function(g){return (g.members||[]).indexOf(w.name)!==-1;}).map(function(g){return g.name;}).join(',');
+      var batch=w.batch||w.briefId||'—';
+      var bcell='<div class="dim">'+esc(short(batch,20))+'</div>'+(wgroups?esc(wgroups):'<span class="dim">solo</span>');
+      return '<tr data-worker="'+esc(w.name)+'" class="worker-row"><td><b>'+esc(w.name)+'</b><div class="dim">by '+esc(w.spawnedBy||'?')+'</div></td><td>'+esc(stateOf(w))+'</td><td>'+(w.pid===null||w.pid===undefined?'—':esc(String(w.pid)))+'</td><td>'+bcell+'</td><td>'+rep+'</td><td>'+tail+'</td><td>'+btn+'</td></tr>';
+    }).join('')||'<tr><td colspan="7" class="dim">no spawned workers</td></tr>';
     Array.prototype.forEach.call(document.querySelectorAll('[data-kill]'),function(b){b.onclick=function(){kill([b.getAttribute('data-kill')]);};});
     document.getElementById('agents').innerHTML=s.agents.map(function(a){
       return '<tr><td><b>'+esc(a.name)+'</b></td><td>'+(a.active?'● active':'○ stale')+'</td><td title="'+esc(a.lastSeen||'?')+'">'+esc(ago(a.lastSeen))+'</td><td>'+esc(a.sessionId||'—')+'</td><td>'+a.dmCount+'</td><td>'+a.unacked+'</td></tr>';
@@ -987,11 +1044,14 @@ async function refresh(){
       var to=Array.isArray(b.to)?b.to.join(','):String(b.to||'');
       return '<tr><td>'+esc(b.id)+'</td><td>'+esc(b.from)+'</td><td>'+esc(short(to,80))+'</td><td>'+esc(b.subject||'')+'</td><td>'+esc(short(b.body,140))+'</td></tr>';
     }).join('')||'<tr><td colspan="5" class="dim">no broadcasts</td></tr>';
-    document.getElementById('recent').innerHTML=s.recent.map(function(m){
-      var to=Array.isArray(m.to)?m.to.join(','):String(m.to||'');
-      var acks=(s.ackedBy[m.id]||[]).map(function(x){return '✓'+x;}).join(' ');
-      return '<tr><td>'+esc(m.id)+'</td><td>'+esc(m.from)+' → '+esc(short(to,40))+'</td><td>'+(m.subject?'<b>'+esc(m.subject)+'</b><br>':'')+esc(short(m.body,200))+'<div class="dim">'+(m.replyTo?('re: '+esc(m.replyTo)+' '):'')+(m.batch?('batch '+esc(m.batch)+' '):'')+esc(acks)+'</div></td></tr>';
-    }).join('')||'<tr><td colspan="3" class="dim">no messages yet</td></tr>';
+    window.__recent=s.recent||[];
+    window.__ackedBy=s.ackedBy||{};
+    renderRecent();
+    document.getElementById('briefs').innerHTML=(s.briefs||[]).map(function(b){
+      var ws=(b.workers||[]).join(',');
+      return '<tr data-batch="'+esc(b.batch)+'" class="brief-row"><td>'+(b.subject?'<b>'+esc(b.subject)+'</b><br>':'')+'<span class="dim">'+esc(short(b.batch,24))+' · from '+esc(b.from)+'</span></td><td>'+esc(ws.length>60?ws.slice(0,60)+'…':ws)+'<div class="dim">'+b.briefCount+' brief'+(b.briefCount===1?'':'s')+'</div></td><td>'+b.checkpointCount+'</td><td>'+b.finalCount+'</td><td>'+b.ackedFinals+'/'+b.finalCount+'</td><td>'+esc(ago(b.lastAt))+'</td></tr>';
+    }).join('')||'<tr><td colspan="6" class="dim">no briefs yet</td></tr>';
+    Array.prototype.forEach.call(document.querySelectorAll('[data-batch]'),function(r){r.onclick=function(){showBrief(r.getAttribute('data-batch'));};});
     try{
       var fr=await fetch('/api/fleet',{cache:'no-store'});
       var fl=await fr.json();
@@ -1870,12 +1930,40 @@ export async function handleWebDashboardRoute(req, res, url, d) {
         id: m.id, from: m.from, at: m.at, subject: m.subject || "",
         head: String(m.body || "").slice(0, 160),
         replyTo: m.replyTo || "", batch: m.batch || "",
+        checkpoint: m.checkpoint === true,
         artifact: m.artifact || "", acked: known.has(m.id),
       }));
     res.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
     res.end(JSON.stringify({ board: d.root, agent, items }));
     return true;
   }
+  if (req.method === "GET" && url.pathname === "/api/gather") {
+    // Open read like /api/board (the transcript is already visible piece
+    // by piece there); the dashboard twin of `gather --batch`: one brief
+    // thread — briefs, checkpoint timeline, final reports — oldest first.
+    const batch = String(url.searchParams.get("batch") || "").trim().slice(0, 200);
+    if (!batch) {
+      res.writeHead(400, { "content-type": "application/json; charset=utf-8" });
+      res.end(JSON.stringify({ error: "pass ?batch=<batch-id>" }));
+      return true;
+    }
+    const got = collectBatch(d, batch);
+    if (!got) {
+      res.writeHead(404, { "content-type": "application/json; charset=utf-8" });
+      res.end(JSON.stringify({ error: `unknown batch "${batch}"` }));
+      return true;
+    }
+    const known = ackedIdSet(d);
+    const tele = gatherTelemetry(got.items);
+    const items = got.items.map((m) => ({
+      id: m.id, from: m.from, to: m.to, at: m.at, subject: m.subject || "",
+      body: String(m.body || ""), replyTo: m.replyTo || "", batch: m.batch || "",
+      checkpoint: m.checkpoint === true, acked: known.has(m.id),
+    }));
+    res.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+    res.end(JSON.stringify({ board: d.root, batch, briefs: got.briefs, replies: got.replies, telemetry: tele, items }));
+    return true;
+  }
   if (req.method === "POST" && url.pathname === "/api/ack") {
     // JSON-only like /api/kill (plain browser forms can't reach it),
     // token-checked like the CLI, no --verify over HTTP.

package/docs/GROUPS.md

@@ -81,8 +81,13 @@ Groups share one board, so any member can already read anything. The
 thing that decides whether groups actually collaborate is whether the
 brief tells them the map. Since v10.0.x every `spawn` brief carries a
 **Crew:** block (see `buildCrewContext` in `bin/lib/spawn.js`): your
-group(s) + members + lane, the other groups + members, their group
-channels, and the peer-DM norm. Conventions that block assumes:
+group(s) + members + lane, the sibling groups of the same spawn +
+members, their group channels, and the peer-DM norm. Groups from
+unrelated concurrent briefs are deliberately NOT enumerated — they
+collapse to a count (`N other groups exist on this board`), so
+cross-task rosters stay discoverable (`crewbus group list`) without
+becoming prompt noise or a misleading invitation. Conventions that
+block assumes:
 
 - **Peer-direct for questions.** `crewbus send --from you --to-group
   <group> --subject "..." --body "..."` reaches every member of

package/docs/VERSION_SKEW.md

@@ -1,6 +1,6 @@
 # Version skew (mixed-relay operation)
 
-How crewbus versions interoperate. Evidence: `package.json:2` (`10.0.3`),
+How crewbus versions interoperate. Evidence: `package.json:2` (`10.0.5`),
 `CHANGELOG.md` (10.0.0 2026-10-08; 7.0.0 2026-10-05; 6.4.0–6.0.0; 4.1.0/4.0.0 baseline).
 Capabilities: `RELAY_CAPS` + `launch` per `packages/contracts/board-caps.json:6-8`.
 Cell behavior is the NEW side's verified behavior (`bin/lib/sync.js` refs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crewbus",
-  "version": "10.0.3",
+  "version": "10.0.5",
   "description": "Zero-dependency message bus for AI coding-agent crews: message another agent, inserted into context, just a tool call.",
   "type": "module",
   "bin": {