@gperezmz/bb-plugin-thread-glance 0.1.3 → 0.2.1

package/features/thread-list/model/toggles.ts

@@ -23,12 +23,7 @@ function under(forest: Forest, parentId: string): (id: string) => boolean {
 export function toggleChip(row: ThreadRow, prefs: Preferences, forest: Forest): ToggleOutcome {
   const id = row.info.thread.id;
   const expanded = row.chip?.expanded ?? false;
-  if (prefs.nesting === "tree") {
-    return expanded
-      ? { patch: { collapsedChildren: [...without(prefs.collapsedChildren, id), id] }, drop: under(forest, id) }
-      : { patch: { collapsedChildren: without(prefs.collapsedChildren, id) }, drop: null };
-  }
-  // Folded: expanding shows every child; collapsing also drops auto-reveals.
+  // Expanding shows every child; collapsing also drops auto-reveals.
   return expanded
     ? { patch: { expandedChildren: without(prefs.expandedChildren, id) }, drop: under(forest, id) }
     : { patch: { expandedChildren: [...without(prefs.expandedChildren, id), id] }, drop: null };
@@ -46,7 +41,7 @@ export function toggleOlder(row: OlderRow, prefs: Preferences, group: GroupView
   if (row.scope === "family") return { patch, drop: under(forest, row.scopeId) };
   // Folding a group's older roots drops the targets that held it open.
   const quietRoots = new Set<string>();
-  for (const family of forest.families) if (family.settled) quietRoots.add(family.root.thread.id);
+  for (const family of forest.families) if (family.quietIgnoringOpen) quietRoots.add(family.root.thread.id);
   const inGroup = new Set(group?.rootIds ?? []);
   return {
     patch,

package/features/thread-list/model/view.ts

@@ -20,21 +20,20 @@ import {
 } from "./groups";
 import { addCounters, countFamilies, EMPTY_COUNTERS, type Counters } from "./counters";
 import { comparePinned, effectiveSortField, makeComparator, type SortKey } from "./sort";
+import { inNeedsYou } from "./needs-you";
 import { mostUrgent, type Flag } from "./state";
 import type { Targets } from "./expansion";
 import { railsFor, type Rail } from "./layout";
 
-/** How many quiet roots stay in a group. */
+/** How many of a group's newest quiet roots stay out of its older fold. */
 export const KEEP_QUIET = 5;
 /** How many quiet children stay in an expanded family. */
 export const KEEP_QUIET_CHILDREN = 3;
 
-export type ListFilter = "all" | "attention";
-
 export interface Chip {
   count: number;
   flag: Flag | null;
-  /** Every child shows: folded, the user expanded it; tree, it's open. */
+  /** The user opened the chip, so every child shows. */
   expanded: boolean;
   /** Harnesses among the visible children that differ from the parent's. */
   providerIds: string[];
@@ -44,9 +43,9 @@ export interface ThreadRow {
   type: "thread";
   key: string;
   info: ThreadInfo;
-  /** Visual depth: 0 for roots; 1 for every child in folded nesting. */
+  /** Visual depth: 0 for roots, one more per level below. */
   depth: number;
-  /** Grandchild or deeper in folded nesting: draws `↳`. */
+  /** Grandchild or deeper: draws `↳`. */
   nested: boolean;
   /** Title of the thread this one attaches to, for tooltips and labels. */
   parentTitle: string | null;
@@ -57,8 +56,8 @@ export interface ThreadRow {
   hiddenBadge: boolean;
   /** "In project X" when the thread is outside its family's group. */
   crossGroupLabel: string | null;
-  /** Tree nesting: this parent row sticks at this level (0-3), or null. */
-  stickyLevel: number | null;
+  /** A root in Needs you: its home group's name, drawn where the age goes. */
+  homeGroupLabel: string | null;
   projectId: string;
 }
 
@@ -90,19 +89,18 @@ export interface EnvironmentRow {
   rails: (Rail | null)[];
 }
 
-/** Under an opened chip that Needs attention leaves with nothing to show. */
-export interface EmptyRow {
-  type: "empty";
+/** Under a family in Needs you: how many of its child threads it leaves out ("+N more"). Not a control. */
+export interface LeftOutRow {
+  type: "left-out";
   key: string;
-  /** The parent whose chip is open. */
+  /** The family's root. */
   scopeId: string;
+  count: number;
   depth: number;
   rails: (Rail | null)[];
 }
 
-export const EMPTY_LEVEL_TEXT = "No child threads need attention";
-
-export type Row = ThreadRow | OlderRow | EnvironmentRow | EmptyRow;
+export type Row = ThreadRow | OlderRow | EnvironmentRow | LeftOutRow;
 
 export interface GroupView {
   descriptor: GroupDescriptor;
@@ -113,11 +111,25 @@ export interface GroupView {
   collapsed: boolean;
   hidden: boolean;
   rows: Row[];
-  /** Every family root bucketed in the group, before filtering and folding. */
+  /** Every family root bucketed in the group, those in Needs you and behind folds included. */
   rootIds: string[];
 }
 
+/** The id Needs you's rows are drawn under; no group has it. */
+export const NEEDS_YOU_GROUP_ID = "needs-you";
+
+/** The Needs you section: every family with a thread that needs you, or held there while one of its threads is open. */
+export interface NeedsYouView {
+  /** How many families the section holds, for its header. */
+  familyCount: number;
+  rows: Row[];
+  /** The home group of each thread drawn here, by thread id: a drop on its row acts there. */
+  homeGroupIds: Record<string, string>;
+}
+
 export interface ListView {
+  /** Null when no family is in the section. */
+  needsYou: NeedsYouView | null;
   groups: GroupView[];
   /** Hidden groups, shown in the More popover. */
   more: GroupView[];
@@ -126,8 +138,6 @@ export interface ListView {
   order: string[];
   /** Threads span more than one host (the row's second line). */
   multiHost: boolean;
-  /** Threads Needs attention would show for their own flags (the filter's badge). */
-  attentionCount: number;
 }
 
 export interface ViewInputs {
@@ -136,15 +146,15 @@ export interface ViewInputs {
   projects: readonly PluginSidebarProject[];
   sections: readonly PluginSidebarSection[];
   prefs: Preferences;
-  filter: ListFilter;
   activeThreadId: string | null;
+  /** The root of the family Needs you keeps while one of its threads is open. */
+  heldRootId: string | null;
   targets: Targets;
 }
 
 interface Context extends ViewInputs {
   compare: (a: SortKey, b: SortKey) => number;
   expandedChildren: ReadonlySet<string>;
-  collapsedChildren: ReadonlySet<string>;
   expandedOlder: ReadonlySet<string>;
   collapsedEnvironments: ReadonlySet<string>;
   /** Parent ids on the path to a reveal target. */
@@ -154,7 +164,6 @@ interface Context extends ViewInputs {
   activePath: ReadonlySet<string>;
   projectNames: ReadonlyMap<string, string>;
   sectionNames: ReadonlyMap<string, string>;
-  subtreeAttention: Map<string, number>;
 }
 
 function titleOf(context: Context, id: string | null): string | null {
@@ -185,7 +194,7 @@ function threadRow(
   context: Context,
   info: ThreadInfo,
   root: ThreadInfo,
-  options: { depth: number; nested: boolean; chip: Chip | null; stickyLevel?: number | null },
+  options: { depth: number; nested: boolean; chip: Chip | null },
 ): ThreadRow {
   return {
     type: "thread",
@@ -198,20 +207,16 @@ function threadRow(
     rails: [],
     hiddenBadge: info.thread.isHidden,
     crossGroupLabel: crossGroupLabel(context, info, root),
-    stickyLevel: options.stickyLevel ?? null,
+    homeGroupLabel: null,
     projectId: info.thread.projectId,
   };
 }
 
-function matchesAttention(info: ThreadInfo): boolean {
-  return info.attention.size > 0;
-}
-
 /** The children of `parent` that get a row: hidden ones only when they need you or failed. */
 function eligibleChildren(context: Context, parentId: string): ThreadInfo[] {
   return (context.forest.children.get(parentId) ?? [])
     .map((id) => context.forest.infos.get(id)!)
-    .filter((info) => !info.thread.isHidden || info.attention.size > 0);
+    .filter((info) => !info.thread.isHidden || info.needsYou.size > 0);
 }
 
 function subtreeOf(context: Context, id: string): Subtree {
@@ -219,7 +224,7 @@ function subtreeOf(context: Context, id: string): Subtree {
 }
 
 /**
- * The children of one parent that show in folded nesting. Each level
+ * The children of one parent that show under its chip. Each level
  * folds on its own: its direct children only, and a child's own children wait
  * for that child's chip. A child never shows without its parent, because the
  * parent's level is the only place it is drawn.
@@ -231,13 +236,6 @@ function foldedChildren(
 ): { shown: ThreadInfo[]; older: OlderRow | null } {
   const parentId = parent.thread.id;
   const kids = eligibleChildren(context, parentId);
-  const holds = (kid: ThreadInfo, test: (info: ThreadInfo) => boolean) =>
-    test(kid) || subtreeOf(context, kid.thread.id).descendants.some(test);
-
-  if (context.filter === "attention") {
-    const shown = kids.filter((kid) => holds(kid, (info) => matchesAttention(info) || info.isActive));
-    return { shown, older: null };
-  }
 
   const reveals = (kid: ThreadInfo) => context.revealIds.has(kid.thread.id) || context.revealPath.has(kid.thread.id);
   const olderRow = (scope: "family" | "reveal", count: number, expanded: boolean): OlderRow | null =>
@@ -261,10 +259,10 @@ function foldedChildren(
     return { shown, older: shown.length > 0 ? olderRow("reveal", left, false) : null };
   }
 
-  // The stable set reads `settled` for the child and everything under it, and
+  // The stable set reads `quietIgnoringOpen` for the child and everything under it, and
   // ignores which thread is open and the reveal targets: they join afterwards
   // and take no other row's place.
-  const quietTree = (kid: ThreadInfo) => kid.settled && subtreeOf(context, kid.thread.id).settled;
+  const quietTree = (kid: ThreadInfo) => kid.quietIgnoringOpen && subtreeOf(context, kid.thread.id).quietIgnoringOpen;
   const stable = new Set<string>();
   for (const kid of kids) if (kid.thread.isHidden || !quietTree(kid)) stable.add(kid.thread.id);
   const recentQuiet = kids
@@ -281,18 +279,6 @@ function foldedChildren(
   return { shown, older: olderRow("family", folded, olderExpanded) };
 }
 
-function subtreeAttention(context: Context, id: string): number {
-  const cached = context.subtreeAttention.get(id);
-  if (cached !== undefined) return cached;
-  context.subtreeAttention.set(id, context.forest.infos.get(id)?.thread.latestAttentionAt ?? 0);
-  let max = context.forest.infos.get(id)?.thread.latestAttentionAt ?? 0;
-  for (const child of context.forest.children.get(id) ?? []) {
-    max = Math.max(max, subtreeAttention(context, child));
-  }
-  context.subtreeAttention.set(id, max);
-  return max;
-}
-
 function environmentLabel(thread: PluginSidebarThread): string {
   const environment = thread.environment;
   if (environment === null) return "Environment";
@@ -371,7 +357,7 @@ function childProviders(parent: ThreadInfo, descendants: readonly ThreadInfo[]):
 function chipOf(context: Context, info: ThreadInfo, expanded: boolean): Chip | null {
   const subtree = subtreeOf(context, info.thread.id);
   const hasChildren =
-    subtree.visibleCount > 0 || subtree.descendants.some((descendant) => descendant.thread.isHidden && descendant.attention.size > 0);
+    subtree.visibleCount > 0 || subtree.descendants.some((descendant) => descendant.thread.isHidden && descendant.needsYou.size > 0);
   if (!hasChildren) return null;
   return {
     count: subtree.visibleCount,
@@ -383,12 +369,12 @@ function chipOf(context: Context, info: ThreadInfo, expanded: boolean): Chip | n
 
 /** What a thread and everything under it carry, for an environment folder's glyph. */
 function rollupFlags(context: Context, info: ThreadInfo): Set<Flag> {
-  const flags = new Set<Flag>([...info.attention, ...subtreeOf(context, info.thread.id).flags]);
+  const flags = new Set<Flag>([...info.needsYou, ...subtreeOf(context, info.thread.id).flags]);
   if (info.flags.has("working")) flags.add("working");
   return flags;
 }
 
-/** The rows under `parent` in folded nesting: each shown child, then its own level. */
+/** The rows under `parent`: each shown child, then its own level. */
 function foldedLevel(context: Context, family: Family, parent: ThreadInfo, depth: number): Row[] {
   const { shown, older } = foldedChildren(context, parent, depth);
   const units: Unit[] = shown.map((info) => ({
@@ -407,10 +393,6 @@ function foldedLevel(context: Context, family: Family, parent: ThreadInfo, depth
   }));
   const rows = clusterEnvironments(context, units, depth);
   if (older !== null) rows.push(older);
-  // An opened chip that the filter empties says so, instead of showing an open chevron over nothing.
-  if (context.filter === "attention" && shown.length === 0 && context.expandedChildren.has(parent.thread.id)) {
-    rows.push({ type: "empty", key: `empty:${parent.thread.id}`, scopeId: parent.thread.id, depth, rails: [] });
-  }
   return rows;
 }
 
@@ -420,72 +402,98 @@ function foldedFamilyRows(context: Context, family: Family): Row[] {
   return [threadRow(context, root, root, { depth: 0, nested: false, chip }), ...foldedLevel(context, family, root, 1)];
 }
 
-/** Tree nesting: bb's tree, with chips on collapsed parents. */
-function treeRows(context: Context, family: Family, info: ThreadInfo, depth: number): Unit {
-  const id = info.thread.id;
-  const root = family.root;
-  const childIds = (context.forest.children.get(id) ?? []).filter((childId) => {
-    const child = context.forest.infos.get(childId)!;
-    return !child.thread.isHidden || child.attention.size > 0;
-  });
-  const subtree = subtreeOf(context, id);
-  let children = childIds.map((childId) => context.forest.infos.get(childId)!);
-  if (context.filter === "attention") {
-    children = children.filter((child) => {
-      const test = (candidate: ThreadInfo) => matchesAttention(candidate) || candidate.isActive;
-      return test(child) || subtreeOf(context, child.thread.id).descendants.some(test);
-    });
-  }
-  const open =
-    context.filter === "attention" ||
-    !context.collapsedChildren.has(id) ||
-    context.revealPath.has(id);
-  const chip: Chip | null =
-    childIds.length > 0
-      ? // Drawn closed when the filter leaves nothing under it.
-        { count: subtree.visibleCount, flag: mostUrgent(subtree.flags), expanded: open && children.length > 0, providerIds: childProviders(info, subtree.descendants) }
-      : null;
-  const ownRow = threadRow(context, info, root, {
-    depth,
-    nested: false,
-    chip,
-    stickyLevel: open && children.length > 0 && depth < 4 ? depth : null,
-  });
-  const ownFlags = rollupFlags(context, info);
-  if (!open || children.length === 0) return { info, rows: [ownRow], flags: ownFlags };
-  const keyed = children.map((child) => ({
-    child,
-    key: { thread: child.thread, familyAttention: subtreeAttention(context, child.thread.id) },
-  }));
-  keyed.sort((a, b) => context.compare(a.key, b.key));
-  const units = keyed.map(({ child }) => treeRows(context, family, child, depth + 1));
-  return { info, rows: [ownRow, ...clusterEnvironments(context, units, depth + 1)], flags: ownFlags };
-}
-
 function familyUnit(context: Context, family: Family): Unit {
-  if (context.prefs.nesting === "tree") return treeRows(context, family, family.root, 0);
   return { info: family.root, rows: foldedFamilyRows(context, family), flags: family.flags };
 }
 
-/** needs-you, then failed, then offline, then unread, then the rest. */
+/** Waiting on you, then failed, then offline, then unread, then the rest. */
 export function urgency(family: Family): number {
-  const flags = family.attentionFlags;
-  if (flags.has("needs-you")) return 0;
+  const flags = family.needsYouFlags;
+  if (flags.has("waits-on-you")) return 0;
   if (flags.has("unread-failed") || flags.has("queue-failed")) return 1;
   if (flags.has("offline")) return 2;
   if (flags.has("unread")) return 3;
   return 4;
 }
 
+/**
+ * One family's rows in Needs you: the path from the root down to each thread
+ * that needs you or is open, then one "+N more" line for the child threads
+ * left out. No row draws a chip, since the section never opens one.
+ */
+function needsYouFamilyRows(context: Context, family: Family, homeGroupLabel: string): Row[] {
+  const root = family.root;
+  const onPath = new Set<string>([root.thread.id]);
+  for (const info of family.descendants) {
+    const needsYou = !info.thread.isArchived && info.needsYou.size > 0;
+    if (!needsYou && !info.isActive) continue;
+    onPath.add(info.thread.id);
+    for (const ancestor of ancestorsOf(info.thread.id, context.forest.infos, root.thread.id)) onPath.add(ancestor);
+  }
+  const rows: Row[] = [{ ...threadRow(context, root, root, { depth: 0, nested: false, chip: null }), homeGroupLabel }];
+  const walk = (parentId: string, depth: number) => {
+    for (const id of context.forest.children.get(parentId) ?? []) {
+      if (!onPath.has(id)) continue;
+      rows.push(threadRow(context, context.forest.infos.get(id)!, root, { depth, nested: depth > 1, chip: null }));
+      walk(id, depth + 1);
+    }
+  };
+  walk(root.thread.id, 1);
+  const left = family.descendants.filter((info) => !info.thread.isHidden && !onPath.has(info.thread.id)).length;
+  if (left > 0) rows.push({ type: "left-out", key: `left-out:${root.thread.id}`, scopeId: root.thread.id, count: left, depth: 1, rails: [] });
+  return rows;
+}
+
+function buildNeedsYou(
+  context: Context,
+  families: readonly Family[],
+  homeGroupOf: (family: Family) => GroupDescriptor,
+): NeedsYouView | null {
+  if (families.length === 0) return null;
+  // Most urgent first, then the chosen field in its natural direction: the
+  // sort direction orders the groups only.
+  const compare = makeComparator({
+    field: context.prefs.chronologicalSort,
+    direction: "default",
+    workingFirst: context.prefs.workingFirst,
+  });
+  const sorted = [...families].sort(
+    (a, b) =>
+      urgency(a) - urgency(b) ||
+      compare(
+        { thread: a.root.thread, familyAttention: a.latestAttentionAt },
+        { thread: b.root.thread, familyAttention: b.latestAttentionAt },
+      ),
+  );
+  const homeGroupIds: Record<string, string> = {};
+  const rows = sorted.flatMap((family) => {
+    const home = homeGroupOf(family);
+    const familyRows = needsYouFamilyRows(context, family, home.label);
+    for (const row of familyRows) if (row.type === "thread") homeGroupIds[row.info.thread.id] = home.id;
+    return familyRows;
+  });
+  const rails = railsFor(rows.map((row) => row.depth));
+  return {
+    familyCount: sorted.length,
+    rows: rows.map((row, index) => ({ ...row, rails: rails[index]! })),
+    homeGroupIds,
+  };
+}
+
+/**
+ * One group. `families` is every family bucketed in it, for its counters and
+ * `rootIds`; `drawn` leaves out those in Needs you.
+ */
 function buildGroup(
   context: Context,
   descriptor: GroupDescriptor,
   families: Family[],
+  drawn: Family[],
   hidden: boolean,
-): GroupView | null {
+): GroupView {
   const counters = countFamilies(families);
   const userCollapsed = isGroupCollapsed(descriptor, context.prefs);
-  const hasTarget = families.some(
+  const hasTarget = drawn.some(
     (family) =>
       context.targets.has(family.root.thread.id) ||
       family.descendants.some((info) => context.targets.has(info.thread.id)),
@@ -493,42 +501,30 @@ function buildGroup(
   const collapsed = userCollapsed && !hasTarget;
   const isPinned = descriptor.id === PINNED_GROUP_ID;
 
-  let kept = families;
-  if (context.filter === "attention") {
-    kept = families.filter((family) => family.attentionFlags.size > 0 || family.containsActive);
-    if (kept.length === 0) return null;
-  }
-
-  const sorted = [...kept];
-  if (context.filter === "attention") {
-    // Needs attention reads most urgent first.
-    sorted.sort(
-      (a, b) =>
-        urgency(a) - urgency(b) ||
-        context.compare(
-          { thread: a.root.thread, familyAttention: a.attention },
-          { thread: b.root.thread, familyAttention: b.attention },
-        ),
-    );
-  } else if (isPinned) {
+  const sorted = [...drawn];
+  if (isPinned) {
     sorted.sort((a, b) => comparePinned(a.root.thread, b.root.thread));
   } else {
     sorted.sort((a, b) =>
       context.compare(
-        { thread: a.root.thread, familyAttention: a.attention },
-        { thread: b.root.thread, familyAttention: b.attention },
+        { thread: a.root.thread, familyAttention: a.latestAttentionAt },
+        { thread: b.root.thread, familyAttention: b.latestAttentionAt },
       ),
     );
   }
 
   let visible = sorted;
   let older: OlderRow | null = null;
-  const foldable = !isPinned && context.filter === "all" && context.prefs.foldOlder;
+  const foldable = !isPinned && context.prefs.foldOlder;
   if (foldable) {
-    // The fold reads `settled`, as if no thread were open. The open family
+    // The fold reads `quietIgnoringOpen`, as if no thread were open. The open family
     // joins afterwards when it sits behind the fold, and takes no other row's place.
-    const quietActive = sorted.filter((family) => family.settled && !family.root.thread.isArchived);
-    const keepQuiet = new Set(quietActive.slice(0, KEEP_QUIET));
+    const quietActive = sorted.filter((family) => family.quietIgnoringOpen && !family.root.thread.isArchived);
+    // The newest quiet roots stay whatever the order: by creation under
+    // Created, by latest activity otherwise.
+    const byCreation = effectiveSortField(context.prefs.chronologicalSort) === "created";
+    const age = (family: Family) => (byCreation ? family.root.thread.createdAt : family.latestAttentionAt);
+    const keepQuiet = new Set([...quietActive].sort((a, b) => age(b) - age(a)).slice(0, KEEP_QUIET));
     const foldedFamilies = quietActive.filter((family) => !keepQuiet.has(family) && !family.containsActive);
     if (foldedFamilies.length > 0) {
       const opened =
@@ -591,7 +587,6 @@ export function buildListView(inputs: ViewInputs): ListView {
       workingFirst: prefs.workingFirst,
     }),
     expandedChildren: new Set(prefs.expandedChildren),
-    collapsedChildren: new Set(prefs.collapsedChildren),
     expandedOlder: new Set(prefs.expandedOlder),
     collapsedEnvironments: new Set(prefs.collapsedEnvironments),
     revealIds,
@@ -599,10 +594,12 @@ export function buildListView(inputs: ViewInputs): ListView {
     activePath,
     projectNames: new Map(inputs.projects.map((project) => [project.id, project.name])),
     sectionNames: new Map(inputs.sections.map((section) => [section.id, section.name])),
-    subtreeAttention: new Map(),
   };
 
   const byGroup = new Map<string, Family[]>();
+  const homeOf = new Map<Family, string>();
+  const section: Family[] = [];
+  const openRootId = inputs.activeThreadId === null ? null : (forest.familyOf.get(inputs.activeThreadId)?.root.thread.id ?? null);
   for (const family of forest.families) {
     const id = groupIdForRoot(family.root.thread, {
       mode: prefs.organizationMode,
@@ -611,7 +608,10 @@ export function buildListView(inputs: ViewInputs): ListView {
     const list = byGroup.get(id) ?? [];
     list.push(family);
     byGroup.set(id, list);
+    homeOf.set(family, id);
+    if (inNeedsYou(family, inputs.heldRootId, openRootId)) section.push(family);
   }
+  const inSection = new Set(section);
 
   const alphabetical = effectiveSortField(prefs.chronologicalSort) === "alpha";
   const entities = entityGroups(
@@ -635,15 +635,15 @@ export function buildListView(inputs: ViewInputs): ListView {
     const descriptor = descriptors.get(id);
     if (descriptor === undefined) continue;
     const families = byGroup.get(id) ?? [];
-    // Pinned and the loose bucket appear only when they hold threads,
-    // except the loose bucket in custom-section mode, as in bb.
-    if (families.length === 0) {
+    const drawn = families.filter((family) => !inSection.has(family));
+    // Pinned and the loose bucket appear only when they hold threads outside
+    // Needs you, except the loose bucket in custom-section mode, as in bb.
+    if (drawn.length === 0) {
       if (id === PINNED_GROUP_ID) continue;
       if (id === THREADS_GROUP_ID && prefs.organizationMode !== "chronological") continue;
     }
     const hidden = id !== PINNED_GROUP_ID && hiddenIds.has(id);
-    const view = buildGroup(context, descriptor, families, hidden);
-    if (view === null) continue;
+    const view = buildGroup(context, descriptor, families, drawn, hidden);
     if (hidden) {
       more.push(view);
       moreCounters = addCounters(moreCounters, view.counters);
@@ -654,13 +654,9 @@ export function buildListView(inputs: ViewInputs): ListView {
 
   const hosts = new Set<string>();
   for (const thread of inputs.threads) if (thread.host !== null) hosts.add(thread.host.id);
-  let attentionCount = 0;
-  for (const family of forest.families) {
-    for (const info of [family.root, ...family.descendants]) {
-      if (!info.thread.isArchived && matchesAttention(info)) attentionCount += 1;
-    }
-  }
-  return { groups, more, moreCounters, order, multiHost: hosts.size > 1, attentionCount };
+  // Every root's group id has a descriptor: entity groups include unknown sections and every host.
+  const needsYou = buildNeedsYou(context, section, (family) => descriptors.get(homeOf.get(family)!)!);
+  return { needsYou, groups, more, moreCounters, order, multiHost: hosts.size > 1 };
 }
 
 /** Every thread row in visual order, for keyboard and windowing. */

package/features/thread-list/testing/fixtures.ts

@@ -6,7 +6,7 @@ import type {
 } from "@get-bb/plugin-sdk/app";
 import { defaultPreferences, type Preferences } from "@/shared/preferences";
 import { buildForest, type Forest } from "../model/families";
-import { buildListView, type ListFilter, type ListView } from "../model/view";
+import { buildListView, type ListView, type Row } from "../model/view";
 import type { Targets } from "../model/expansion";
 
 export const T0 = 1_780_000_000_000;
@@ -107,8 +107,8 @@ export interface Scenario {
   projects?: PluginSidebarProject[];
   sections?: PluginSidebarSection[];
   prefs?: Partial<Preferences>;
-  filter?: ListFilter;
   activeThreadId?: string | null;
+  heldRootId?: string | null;
   targets?: Targets;
   finishedAt?: Record<string, number>;
   seenAt?: Record<string, number>;
@@ -140,23 +140,32 @@ export function viewOf(scenario: Scenario): ListView {
     projects: scenario.projects ?? PROJECTS,
     sections: scenario.sections ?? [],
     prefs: { ...defaultPreferences(), ...scenario.prefs },
-    filter: scenario.filter ?? "all",
     activeThreadId: scenario.activeThreadId ?? null,
+    heldRootId: scenario.heldRootId ?? null,
     targets: scenario.targets ?? new Map(),
   });
 }
 
-/** Thread ids in the group's rows, in order; older rows as `older:N`. */
-export function rowIds(view: ListView, groupId: string): string[] {
-  const group = [...view.groups, ...view.more].find((candidate) => candidate.descriptor.id === groupId);
-  if (group === undefined) throw new Error(`no group ${groupId}`);
-  return group.rows.map((row) =>
+function idsOf(rows: readonly Row[]): string[] {
+  return rows.map((row) =>
     row.type === "thread"
       ? row.info.thread.id
       : row.type === "older"
         ? `older:${row.count}`
-        : row.type === "empty"
-          ? `empty:${row.scopeId}`
+        : row.type === "left-out"
+          ? `+${row.count}`
           : `env:${row.environmentId}`,
   );
 }
+
+/** Thread ids in the group's rows, in order; older rows as `older:N`. */
+export function rowIds(view: ListView, groupId: string): string[] {
+  const group = [...view.groups, ...view.more].find((candidate) => candidate.descriptor.id === groupId);
+  if (group === undefined) throw new Error(`no group ${groupId}`);
+  return idsOf(group.rows);
+}
+
+/** Thread ids in Needs you, in order; "+N more" lines as `+N`. Empty when the section is absent. */
+export function needsYouIds(view: ListView): string[] {
+  return idsOf(view.needsYou?.rows ?? []);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gperezmz/bb-plugin-thread-glance",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "type": "module",
   "engines": {
     "bb": ">=0.43",

package/server/cli.ts

@@ -9,7 +9,7 @@ import {
 } from "../shared/preferences";
 import { PreferenceValidationError, type PreferenceStore } from "./preference-store";
 
-/** Parses a CLI value as JSON; a bare word such as `tree` is read as a string. */
+/** Parses a CLI value as JSON; a bare word such as `machine` is read as a string. */
 export function parseCliValue(raw: string): unknown {
   try {
     return JSON.parse(raw) as unknown;
@@ -38,7 +38,7 @@ export function createCli(store: PreferenceStore): PluginCliRegistration {
     name: "thread-glance",
     summary: "Inspect and change the Thread Glance sidebar's layout preferences",
     description:
-      "Organization, sort, group order, hidden and collapsed groups, child nesting and folding for the Thread Glance sidebar. Values are JSON; a bare word is read as a string.",
+      "Organization, sort, group order, hidden and collapsed groups, child-thread folding and which child threads Needs you counts, for the Thread Glance sidebar. Values are JSON; a bare word is read as a string.",
     commands: {
       "prefs list": cliCommand({
         summary: "List every preference and its current value",