@gperezmz/bb-plugin-thread-glance 0.2.4 → 0.4.0

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

@@ -6,7 +6,7 @@ import type {
   PluginSidebarThread,
 } from "@get-bb/plugin-sdk/app";
 import type { Preferences } from "@/shared/preferences";
-import { ancestorsOf, type Family, type Forest, type Subtree, type ThreadInfo } from "./families";
+import { ancestorsOf, type ThreadTree, type Forest, type Subtree, type ThreadInfo } from "./trees";
 import {
   builtinGroup,
   entityGroups,
@@ -18,25 +18,29 @@ import {
   THREADS_GROUP_ID,
   type GroupDescriptor,
 } from "./groups";
-import { addCounters, countFamilies, EMPTY_COUNTERS, type Counters } from "./counters";
+import { addCounters, countTrees, EMPTY_COUNTERS, type Counters } from "./counters";
 import { comparePinned, effectiveSortField, makeComparator, type SortKey } from "./sort";
-import { inAttention, isAttended, type SectionFamily } from "./attention";
+import { isSettledTree, type SettleInputs } from "./settled";
+import { isOffDefaultBranch } from "./branches";
 import { mostUrgent, type Flag } from "./state";
 import type { Targets } from "./expansion";
 import type { RowNote } from "./notes";
 
-/** 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. */
+/** How many quiet children stay in an expanded tree. */
 export const KEEP_QUIET_CHILDREN = 3;
 
+/** The children chip: the count of a parent's direct children and its chevron, after the state of its descendants. */
 export interface Chip {
+  /** Direct children opening it shows, hidden ones left out; 0 draws no number. */
   count: number;
-  flag: Flag | null;
   /** The user opened the chip, so every child shows. */
   expanded: boolean;
-  /** Harnesses among the visible children that differ from the parent's. */
-  providerIds: string[];
+  /**
+   * The most urgent state among the descendants at any depth, open or
+   * collapsed, or null for none: its glyph leads the chip and colours it, and
+   * keeps that colour through dimming and hover.
+   */
+  flag: Flag | null;
 }
 
 export interface ThreadRow {
@@ -50,32 +54,46 @@ export interface ThreadRow {
   /** Title of the thread this one attaches to, for tooltips and labels. */
   parentTitle: string | null;
   chip: Chip | null;
-  /** The title is bold: the thread is unread and its family is not attended. */
-  bold: boolean;
   /**
-   * The line under the title. In Needs attention, a row that itself needs
-   * attention says why, and an attended family's rows have none; any other
-   * row says why it waits on you or failed.
+   * The row draws its harness icon: a root whose harness is not bb's
+   * default, a child whose harness is not its parent thread's.
    */
+  harness: boolean;
+  /** The title is bold: the thread is unread. */
+  bold: boolean;
+  /** A root whose tree holds an unread thread: it offers Mark read for the whole tree. */
+  treeUnread: boolean;
+  /** The line under the title: why it waits on you or failed, in both densities. */
   note: RowNote | null;
+  /**
+   * In Comfortable density, a row with no note whose branch is known not to
+   * be its project's default draws that branch on its second line.
+   */
+  branchLine: string | null;
+  /**
+   * Where the pull request badge goes: after the branch on the second line,
+   * on the title line (a root off its default branch, as before), or nowhere.
+   */
+  pullRequest: "second-line" | "title" | null;
+  /** The machine's name, beside the age, for a thread off bb's primary machine. */
+  machine: string | null;
   /** The title, and the chip with it, step back: see `isDimmed`. */
   dimmed: boolean;
   /** A hidden thread shown because it needs attention or failed. */
   hiddenBadge: boolean;
-  /** "In project X" when the thread is outside its family's group. */
+  /** "In project X" when the thread is outside its tree's group. */
   crossGroupLabel: string | null;
-  /** A root in Needs attention: its home group's name, drawn where the age goes. */
-  homeGroupLabel: string | null;
   projectId: string;
 }
 
+/** The fold inside an open tree: "N more child threads". */
 export interface OlderRow {
   type: "older";
   key: string;
-  /** A group id, or a parent thread id for a family's fold. */
+  /** The parent thread's id. */
   scopeId: string;
-  /** `reveal`: an auto-reveal left `count` children hidden ("+N more"). */
-  scope: "group" | "family" | "reveal";
+  /** `reveal`: an auto-reveal left `count` children hidden. */
+  scope: "tree" | "reveal";
   count: number;
   expanded: boolean;
   depth: number;
@@ -95,54 +113,46 @@ export interface EnvironmentRow {
   depth: number;
 }
 
-/** Under a closed family in Needs attention: how many of its child threads it leaves out ("+N more"). Opens the family. */
-export interface LeftOutRow {
-  type: "left-out";
+/** A group's settled fold: the faint "Settled (N)" divider at its end. */
+export interface SettledRow {
+  type: "settled";
   key: string;
-  /** The family's root. */
-  scopeId: string;
+  groupId: string;
+  /** Settled trees in the group, the open one drawn above the divider included. */
   count: number;
-  depth: number;
+  expanded: boolean;
 }
 
-export type Row = ThreadRow | OlderRow | EnvironmentRow | LeftOutRow;
+/** The rows a tree and its folders draw. */
+export type TreeRow = ThreadRow | OlderRow | EnvironmentRow;
+
+export type Row = TreeRow | SettledRow;
 
 export interface GroupView {
   descriptor: GroupDescriptor;
   counters: Counters;
   /** What the user stored. */
   userCollapsed: boolean;
-  /** What is drawn: user collapse, unless a target opened it. */
+  /**
+   * What is drawn: user collapse, unless opening a thread in the group
+   * opened it. A collapsed group still draws its trees that need attention.
+   */
   collapsed: boolean;
   hidden: boolean;
   rows: Row[];
-  /** Every family root bucketed in the group, those in Needs attention and behind folds included. */
+  /** Every tree root bucketed in the group, those behind folds included. */
   rootIds: string[];
 }
 
-/** The id Needs attention's rows are drawn under; no group has it. */
-export const ATTENTION_GROUP_ID = "attention";
-
-/** The Needs attention section: every family with a thread that needs attention, or held there while one of its threads is open. */
-export interface AttentionView {
-  /** How many families the section holds, attended ones left out, 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. */
-  attention: AttentionView | null;
   groups: GroupView[];
   /** Hidden groups, shown in the More popover. */
   more: GroupView[];
   moreCounters: Counters;
   /** Resolved top-level order for the mode, for header drag. */
   order: string[];
-  /** Threads span more than one host (the row's second line). */
-  multiHost: boolean;
+  /** Thread trees that need attention, in every group, hidden ones included: the need-you filter's N. */
+  needYouCount: number;
 }
 
 export interface ViewInputs {
@@ -152,16 +162,28 @@ export interface ViewInputs {
   sections: readonly PluginSidebarSection[];
   prefs: Preferences;
   activeThreadId: string | null;
-  /** The family Needs attention keeps while one of its threads is open, as it was when opened: the section orders it by this. */
-  held: SectionFamily | null;
   targets: Targets;
+  settle: SettleInputs;
+  /** bb's default harness; null while unknown, when no root draws one. */
+  defaultProviderId: string | null;
+  /** bb's primary machine; null while unknown, when no row names its machine. */
+  primaryHostId: string | null;
+  /** Comfortable density: rows may take a branch line. */
+  comfortable: boolean;
+  /** A project's default branch: undefined while looked up, null when not found. */
+  defaultBranchOf(thread: PluginSidebarThread): string | null | undefined;
+  /**
+   * The need-you filter is on: every group, hidden ones included, draws only
+   * its trees that need attention, and a group with none is left out.
+   */
+  needYouOnly: boolean;
 }
 
 interface Context extends ViewInputs {
-  heldRootId: string | null;
   compare: (a: SortKey, b: SortKey) => number;
   expandedChildren: ReadonlySet<string>;
   expandedOlder: ReadonlySet<string>;
+  openSettledFolds: ReadonlySet<string>;
   collapsedEnvironments: ReadonlySet<string>;
   /** Parent ids on the path to a reveal target. */
   revealPath: ReadonlySet<string>;
@@ -170,10 +192,6 @@ interface Context extends ViewInputs {
   activePath: ReadonlySet<string>;
   projectNames: ReadonlyMap<string, string>;
   sectionNames: ReadonlyMap<string, string>;
-  /** The rows are drawn in Needs attention. */
-  drawnInAttention: boolean;
-  /** The rows are an attended family's: they draw as in its home group, with no bold title or why line. */
-  attended: boolean;
 }
 
 function titleOf(context: Context, id: string | null): string | null {
@@ -203,21 +221,45 @@ function crossGroupLabel(context: Context, info: ThreadInfo, root: ThreadInfo):
 /**
  * Whether a row's title steps back: a quiet thread does, at any depth, so
  * brightness shows state and depth is left to the indent and smaller text.
- * A root with children stays bright until its whole family is quiet.
+ * A root with children stays bright until its whole tree is quiet.
  */
 function isDimmed(context: Context, info: ThreadInfo, chip: Chip | null): boolean {
-  if (info.parentId === null && chip !== null) return context.forest.familyOf.get(info.thread.id)?.quiet ?? info.quiet;
+  if (info.parentId === null && chip !== null) return context.forest.treeOf.get(info.thread.id)?.quiet ?? info.quiet;
   return info.quiet;
 }
 
+
+/** A root draws its harness when it differs from bb's default; a child, when it differs from its parent thread's. */
+function drawsHarness(context: Context, info: ThreadInfo): boolean {
+  const providerId = info.thread.providerId;
+  if (info.parentId === null) return context.defaultProviderId !== null && providerId !== context.defaultProviderId;
+  return providerId !== context.forest.infos.get(info.parentId)?.thread.providerId;
+}
+
+/** The row's second line and pull request badge, as the density and the branch allow. */
+function lines(context: Context, info: ThreadInfo, depth: number): Pick<ThreadRow, "branchLine" | "pullRequest"> {
+  const branch = info.thread.environment?.branchName ?? null;
+  const offDefault = isOffDefaultBranch(branch, context.defaultBranchOf(info.thread));
+  if (context.comfortable && info.note === null && offDefault) return { branchLine: branch, pullRequest: "second-line" };
+  return { branchLine: null, pullRequest: depth === 0 && offDefault ? "title" : null };
+}
+
+/** The machine a row names: one other than bb's primary, unless the list is grouped by machine. */
+function machineOf(context: Context, info: ThreadInfo): string | null {
+  const host = info.thread.host;
+  if (context.prefs.organizationMode === "machine" || context.primaryHostId === null || host === null) return null;
+  return host.id === context.primaryHostId ? null : host.name || "Unknown machine";
+}
+
 function threadRow(
   context: Context,
   info: ThreadInfo,
   root: ThreadInfo,
   options: { depth: number; nested: boolean; chip: Chip | null },
 ): ThreadRow {
-  const needsAttention = !info.thread.isArchived && info.attentionFlags.size > 0;
   return {
+    ...lines(context, info, options.depth),
+    machine: machineOf(context, info),
     type: "thread",
     key: `thread:${info.thread.id}`,
     info,
@@ -225,12 +267,13 @@ function threadRow(
     nested: options.nested,
     parentTitle: titleOf(context, info.parentId),
     chip: options.chip,
-    bold: info.unread && !context.attended,
-    note: context.attended ? null : context.drawnInAttention && needsAttention ? info.attentionNote : info.note,
+    harness: drawsHarness(context, info),
+    bold: info.unread,
+    treeUnread: info === root && [root, ...(context.forest.treeOf.get(root.thread.id)?.descendants ?? [])].some((info) => info.unread),
+    note: info.note,
     dimmed: isDimmed(context, info, options.chip),
     hiddenBadge: info.thread.isHidden,
     crossGroupLabel: crossGroupLabel(context, info, root),
-    homeGroupLabel: null,
     projectId: info.thread.projectId,
   };
 }
@@ -261,7 +304,7 @@ function foldedChildren(
   const kids = eligibleChildren(context, parentId);
 
   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 =>
+  const olderRow = (scope: "tree" | "reveal", count: number, expanded: boolean): OlderRow | null =>
     count > 0
       ? {
           type: "older",
@@ -298,7 +341,7 @@ function foldedChildren(
   // Open, the fold still counts what it holds, so its row can close it again.
   const folded = kids.filter((kid) => !kept(kid)).length;
   const shown = olderExpanded ? kids : kids.filter(kept);
-  return { shown, older: olderRow("family", folded, olderExpanded) };
+  return { shown, older: olderRow("tree", folded, olderExpanded) };
 }
 
 function environmentLabel(thread: PluginSidebarThread): string {
@@ -310,13 +353,13 @@ function environmentLabel(thread: PluginSidebarThread): string {
   return "Environment";
 }
 
-type Unit = { info: ThreadInfo; rows: Row[]; flags: ReadonlySet<Flag> };
+type Unit = { info: ThreadInfo; rows: TreeRow[]; flags: ReadonlySet<Flag> };
 
 /**
  * Folds sibling units that share a worktree environment (2 or more) into a
  * folder row. Off unless the environment grouping preference is on.
  */
-function clusterEnvironments(context: Context, units: Unit[], depth: number): Row[] {
+function clusterEnvironments(context: Context, units: Unit[], depth: number): TreeRow[] {
   if (!context.prefs.environmentGrouping) return units.flatMap((unit) => unit.rows);
   const counts = new Map<string, number>();
   for (const unit of units) {
@@ -325,7 +368,7 @@ function clusterEnvironments(context: Context, units: Unit[], depth: number): Ro
       counts.set(environment.id, (counts.get(environment.id) ?? 0) + 1);
     }
   }
-  const rows: Row[] = [];
+  const rows: TreeRow[] = [];
   const emitted = new Set<string>();
   for (const unit of units) {
     const environment = unit.info.thread.environment;
@@ -362,30 +405,13 @@ function clusterEnvironments(context: Context, units: Unit[], depth: number): Ro
   return rows;
 }
 
-/** Distinct child harnesses other than the parent's, at most three. */
-function childProviders(parent: ThreadInfo, descendants: readonly ThreadInfo[]): string[] {
-  const ids: string[] = [];
-  for (const info of descendants) {
-    const id = info.thread.providerId;
-    if (info.thread.isHidden || id === parent.thread.providerId || ids.includes(id)) continue;
-    ids.push(id);
-    if (ids.length === 3) break;
-  }
-  return ids;
-}
-
-/** The chip of a parent: its children's count, most urgent flag and harnesses. */
+/** The children chip of a parent, or null when it would show nothing. */
 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.attentionFlags.size > 0);
-  if (!hasChildren) return null;
-  return {
-    count: subtree.visibleCount,
-    flag: mostUrgent(subtree.flags),
-    expanded,
-    providerIds: childProviders(info, subtree.descendants),
-  };
+  const { childCount: count, chipFlags } = subtreeOf(context, info.thread.id);
+  const flag = mostUrgent(chipFlags);
+  // A hidden child's failure that needs no attention has no row, yet the chip still shows it.
+  if (count === 0 && flag === null && eligibleChildren(context, info.thread.id).length === 0) return null;
+  return { count, expanded, flag };
 }
 
 /** What a thread and everything under it carry, for an environment folder's glyph. */
@@ -396,20 +422,20 @@ function rollupFlags(context: Context, info: ThreadInfo): Set<Flag> {
 }
 
 /** The rows under `parent`: each shown child, then its own level. */
-function foldedLevel(context: Context, family: Family, parent: ThreadInfo, depth: number): Row[] {
+function foldedLevel(context: Context, tree: ThreadTree, parent: ThreadInfo, depth: number): TreeRow[] {
   const { shown, older } = foldedChildren(context, parent, depth);
   const units: Unit[] = shown.map((info) => ({
     info,
     flags: rollupFlags(context, info),
     rows: [
-      threadRow(context, info, family.root, {
+      threadRow(context, info, tree.root, {
         depth,
         nested: depth > 1,
         // Expanded only when the user expanded it: an auto-reveal shows a
         // chevron that still expands, and a "N more child threads" row.
         chip: chipOf(context, info, context.expandedChildren.has(info.thread.id)),
       }),
-      ...foldedLevel(context, family, info, depth + 1),
+      ...foldedLevel(context, tree, info, depth + 1),
     ],
   }));
   const rows = clusterEnvironments(context, units, depth);
@@ -417,180 +443,69 @@ function foldedLevel(context: Context, family: Family, parent: ThreadInfo, depth
   return rows;
 }
 
-function foldedFamilyRows(context: Context, family: Family): Row[] {
-  const root = family.root;
+function foldedTreeRows(context: Context, tree: ThreadTree): TreeRow[] {
+  const root = tree.root;
   const chip = chipOf(context, root, context.expandedChildren.has(root.thread.id));
-  return [threadRow(context, root, root, { depth: 0, nested: false, chip }), ...foldedLevel(context, family, root, 1)];
+  return [threadRow(context, root, root, { depth: 0, nested: false, chip }), ...foldedLevel(context, tree, root, 1)];
 }
 
-function familyUnit(context: Context, family: Family): Unit {
-  return { info: family.root, rows: foldedFamilyRows(context, family), flags: family.flags };
+function treeUnit(context: Context, tree: ThreadTree): Unit {
+  return { info: tree.root, rows: foldedTreeRows(context, tree), flags: tree.flags };
 }
 
-/** Waiting on you, then failed, then offline, then unread, then the rest. */
-export function urgency(family: Pick<Family, "attentionFlags">): number {
-  const flags = family.attentionFlags;
-  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;
+/** Whether a thread in the tree needs attention: it stays drawn when its group is collapsed. */
+export function needsAttention(tree: Pick<ThreadTree, "attentionFlags">): boolean {
+  return tree.attentionFlags.size > 0;
 }
 
-/**
- * One family's rows in Needs attention. It arrives with the path from the root
- * down to each thread that needs attention or is open. Closed, the path is all
- * it draws, with one "+N more" line for the child threads left out; opened
- * with the root's chip, it draws as in its home group and keeps the path.
- */
-function attentionFamilyRows(groupContext: Context, family: Family, homeGroupLabel: string): Row[] {
-  const context: Context = {
-    ...groupContext,
-    drawnInAttention: true,
-    attended: isAttended(family, groupContext.heldRootId),
-  };
-  const root = family.root;
-  const onPath = new Set<string>([root.thread.id]);
-  for (const info of family.descendants) {
-    const attention = !info.thread.isArchived && info.attentionFlags.size > 0;
-    if (!attention && !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 expanded = context.expandedChildren.has(root.thread.id);
-  if (expanded) {
-    // The path is kept the way a reveal target's is.
-    const kept: Context = { ...context, revealIds: new Set([...context.revealIds, ...onPath]) };
-    const [rootRow, ...rest] = foldedFamilyRows(kept, family);
-    return [{ ...(rootRow as ThreadRow), homeGroupLabel }, ...rest];
-  }
-  const chip = chipOf(context, root, false);
-  const rows: Row[] = [{ ...threadRow(context, root, root, { depth: 0, nested: false, chip }), 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 });
-  return rows;
+/** The need-you filter's N: thread trees that need attention, in every group. */
+export function countNeedYou(forest: Pick<Forest, "trees">): number {
+  return forest.trees.filter(needsAttention).length;
 }
 
-function buildAttention(
-  context: Context,
-  families: readonly Family[],
-  homeGroupOf: (family: Family) => GroupDescriptor,
-): AttentionView | 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. The held family sorts as it was
-  // when opened, so nothing inside it moves it.
-  const compare = makeComparator({
-    field: context.prefs.chronologicalSort,
-    direction: "default",
-    workingFirst: context.prefs.workingFirst,
-  });
-  const slotOf = (family: Family): SectionFamily =>
-    context.held !== null && family.root.thread.id === context.heldRootId ? context.held : family;
-  const sorted = [...families].sort((familyA, familyB) => {
-    const a = slotOf(familyA);
-    const b = slotOf(familyB);
-    return (
-      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 = attentionFamilyRows(context, family, home.label);
-    for (const row of familyRows) if (row.type === "thread") homeGroupIds[row.info.thread.id] = home.id;
-    return familyRows;
-  });
-  return {
-    familyCount: sorted.filter((family) => !isAttended(family, context.heldRootId)).length,
-    rows,
-    homeGroupIds,
-  };
+/** The filter narrows the list only while something needs you: at 0 the full list is back. */
+export function needYouActive(on: boolean, count: number): boolean {
+  return on && count > 0;
 }
 
 /**
- * One group. `families` is every family bucketed in it, for its counters and
- * `rootIds`; `drawn` leaves out those in Needs attention.
+ * One group. `trees` is every tree bucketed in it. Collapsed, it draws only
+ * its trees that need attention; opening a thread in it opens it, as an
+ * auto-reveal did.
  */
-function buildGroup(
-  context: Context,
-  descriptor: GroupDescriptor,
-  families: Family[],
-  drawn: Family[],
-  hidden: boolean,
-): GroupView {
-  const counters = countFamilies(families);
+function buildGroup(context: Context, descriptor: GroupDescriptor, trees: ThreadTree[], hidden: boolean): GroupView {
+  if (context.needYouOnly) return needYouGroup(context, descriptor, trees, hidden);
+  const counters = countTrees(trees);
   const userCollapsed = isGroupCollapsed(descriptor, context.prefs);
-  const hasTarget = drawn.some(
-    (family) =>
-      context.targets.has(family.root.thread.id) ||
-      family.descendants.some((info) => context.targets.has(info.thread.id)),
-  );
-  const collapsed = userCollapsed && !hasTarget;
+  const activeId = context.activeThreadId;
+  const opened =
+    activeId !== null && context.targets.has(activeId) && trees.some((tree) => tree.containsActive);
+  const collapsed = userCollapsed && !opened;
   const isPinned = descriptor.id === PINNED_GROUP_ID;
 
-  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.latestAttentionAt },
-        { thread: b.root.thread, familyAttention: b.latestAttentionAt },
-      ),
-    );
-  }
+  const sorted = sortTrees(context, descriptor, trees);
 
-  let visible = sorted;
-  let older: OlderRow | null = null;
-  const foldable = !isPinned && context.prefs.foldOlder;
-  if (foldable) {
-    // 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.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 =
-        context.expandedOlder.has(descriptor.id) ||
-        foldedFamilies.some(
-          (family) =>
-            context.targets.has(family.root.thread.id) ||
-            family.descendants.some((info) => context.targets.has(info.thread.id)),
-        );
-      const folded = new Set(foldedFamilies);
-      if (!opened) visible = sorted.filter((family) => !folded.has(family));
-      older = {
-        type: "older",
-        key: `older:group:${descriptor.id}`,
-        scopeId: descriptor.id,
-        scope: "group",
-        count: foldedFamilies.length,
-        expanded: opened,
-        depth: 0,
-      };
+  let rows: Row[];
+  if (collapsed) {
+    rows = clusterEnvironments(context, sorted.filter(needsAttention).map((tree) => treeUnit(context, tree)), 0);
+  } else {
+    // Settled trees go behind the fold at the group's end. The open one, if
+    // settled, is drawn just above the divider, so opening it moves nothing else.
+    const settled = sorted.filter((tree) => isSettledTree(tree, context.settle));
+    const settledSet = new Set(settled);
+    const live = sorted.filter((tree) => !settledSet.has(tree));
+    const open = settled.find((tree) => tree.containsActive) ?? null;
+    rows = clusterEnvironments(context, live.map((tree) => treeUnit(context, tree)), 0);
+    if (settled.length > 0) {
+      if (open !== null) rows.push(...treeUnit(context, open).rows);
+      const expanded = context.openSettledFolds.has(descriptor.id);
+      rows.push({ type: "settled", key: `settled:${descriptor.id}`, groupId: descriptor.id, count: settled.length, expanded });
+      if (expanded) {
+        const folded = settled.filter((tree) => tree !== open).map((tree) => treeUnit(context, tree));
+        rows.push(...clusterEnvironments(context, folded, 0));
+      }
     }
   }
-
-  const units = visible.map((family) => familyUnit(context, family));
-  const rows = clusterEnvironments(context, units, 0);
-  if (older !== null) rows.push(older);
   return {
     descriptor,
     counters,
@@ -598,7 +513,32 @@ function buildGroup(
     collapsed,
     hidden,
     rows,
-    rootIds: families.map((family) => family.root.thread.id),
+    rootIds: trees.map((tree) => tree.root.thread.id),
+  };
+}
+
+/** A group's trees in its order: Pinned's own, else the chosen sort. */
+function sortTrees(context: Context, descriptor: GroupDescriptor, trees: readonly ThreadTree[]): ThreadTree[] {
+  if (descriptor.id === PINNED_GROUP_ID) return [...trees].sort((a, b) => comparePinned(a.root.thread, b.root.thread));
+  return [...trees].sort((a, b) =>
+    context.compare(
+      { thread: a.root.thread, treeAttention: a.latestAttentionAt },
+      { thread: b.root.thread, treeAttention: b.latestAttentionAt },
+    ),
+  );
+}
+
+/** A group under the need-you filter: its header, and its trees that need attention, whatever its collapse. */
+function needYouGroup(context: Context, descriptor: GroupDescriptor, trees: ThreadTree[], hidden: boolean): GroupView {
+  const sorted = sortTrees(context, descriptor, trees);
+  return {
+    descriptor,
+    counters: countTrees(trees),
+    userCollapsed: isGroupCollapsed(descriptor, context.prefs),
+    collapsed: false,
+    hidden,
+    rows: clusterEnvironments(context, sorted.filter(needsAttention).map((tree) => treeUnit(context, tree)), 0),
+    rootIds: trees.map((tree) => tree.root.thread.id),
   };
 }
 
@@ -618,40 +558,28 @@ export function buildListView(inputs: ViewInputs): ListView {
   }
   const context: Context = {
     ...inputs,
-    heldRootId: inputs.held?.root.thread.id ?? null,
-    compare: makeComparator({
-      field: prefs.chronologicalSort,
-      direction: prefs.sortDirection,
-      workingFirst: prefs.workingFirst,
-    }),
+    compare: makeComparator({ field: prefs.chronologicalSort, direction: prefs.sortDirection }),
     expandedChildren: new Set(prefs.expandedChildren),
     expandedOlder: new Set(prefs.expandedOlder),
+    openSettledFolds: new Set(prefs.openSettledFolds),
     collapsedEnvironments: new Set(prefs.collapsedEnvironments),
     revealIds,
     revealPath,
     activePath,
     projectNames: new Map(inputs.projects.map((project) => [project.id, project.name])),
     sectionNames: new Map(inputs.sections.map((section) => [section.id, section.name])),
-    drawnInAttention: false,
-    attended: false,
   };
 
-  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, {
+  const byGroup = new Map<string, ThreadTree[]>();
+  for (const tree of forest.trees) {
+    const id = groupIdForRoot(tree.root.thread, {
       mode: prefs.organizationMode,
       projects: inputs.projects,
     });
     const list = byGroup.get(id) ?? [];
-    list.push(family);
+    list.push(tree);
     byGroup.set(id, list);
-    homeOf.set(family, id);
-    if (inAttention(family, context.heldRootId, openRootId)) section.push(family);
   }
-  const inSection = new Set(section);
 
   const alphabetical = effectiveSortField(prefs.chronologicalSort) === "alpha";
   const entities = entityGroups(
@@ -674,16 +602,20 @@ export function buildListView(inputs: ViewInputs): ListView {
   for (const id of order) {
     const descriptor = descriptors.get(id);
     if (descriptor === undefined) continue;
-    const families = byGroup.get(id) ?? [];
-    const drawn = families.filter((family) => !inSection.has(family));
-    // Pinned and the loose bucket appear only when they hold threads outside
-    // Needs attention, except the loose bucket in custom-section mode, as in bb.
-    if (drawn.length === 0) {
+    const trees = 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 (trees.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, drawn, hidden);
+    if (context.needYouOnly) {
+      // Under the filter, a hidden group's trees come out of More, each under its own header.
+      if (trees.some(needsAttention)) groups.push(buildGroup(context, descriptor, trees, hidden));
+      continue;
+    }
+    const view = buildGroup(context, descriptor, trees, hidden);
     if (hidden) {
       more.push(view);
       moreCounters = addCounters(moreCounters, view.counters);
@@ -692,11 +624,7 @@ 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);
-  // Every root's group id has a descriptor: entity groups include unknown sections and every host.
-  const attention = buildAttention(context, section, (family) => descriptors.get(homeOf.get(family)!)!);
-  return { attention, groups, more, moreCounters, order, multiHost: hosts.size > 1 };
+  return { groups, more, moreCounters, order, needYouCount: countNeedYou(forest) };
 }
 
 /** Every thread row in visual order, for keyboard and windowing. */