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

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

@@ -20,10 +20,10 @@ 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 { inAttention, isAttended, type SectionFamily } from "./attention";
 import { mostUrgent, type Flag } from "./state";
 import type { Targets } from "./expansion";
-import { railsFor, type Rail } from "./layout";
+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;
@@ -50,13 +50,21 @@ export interface ThreadRow {
   /** Title of the thread this one attaches to, for tooltips and labels. */
   parentTitle: string | null;
   chip: Chip | null;
-  /** Guide rails by nesting level. */
-  rails: (Rail | null)[];
-  /** A hidden thread shown because it needs you or failed. */
+  /** 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.
+   */
+  note: RowNote | 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. */
   crossGroupLabel: string | null;
-  /** A root in Needs you: its home group's name, drawn where the age goes. */
+  /** A root in Needs attention: its home group's name, drawn where the age goes. */
   homeGroupLabel: string | null;
   projectId: string;
 }
@@ -71,7 +79,6 @@ export interface OlderRow {
   count: number;
   expanded: boolean;
   depth: number;
-  rails: (Rail | null)[];
 }
 
 export interface EnvironmentRow {
@@ -86,10 +93,9 @@ export interface EnvironmentRow {
   collapsed: boolean;
   flag: Flag | null;
   depth: number;
-  rails: (Rail | null)[];
 }
 
-/** Under a family in Needs you: how many of its child threads it leaves out ("+N more"). Not a control. */
+/** 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";
   key: string;
@@ -97,7 +103,6 @@ export interface LeftOutRow {
   scopeId: string;
   count: number;
   depth: number;
-  rails: (Rail | null)[];
 }
 
 export type Row = ThreadRow | OlderRow | EnvironmentRow | LeftOutRow;
@@ -111,16 +116,16 @@ export interface GroupView {
   collapsed: boolean;
   hidden: boolean;
   rows: Row[];
-  /** Every family root bucketed in the group, those in Needs you and behind folds included. */
+  /** Every family root bucketed in the group, those in Needs attention 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 id Needs attention's rows are drawn under; no group has it. */
+export const ATTENTION_GROUP_ID = "attention";
 
-/** 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. */
+/** 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. */
@@ -129,7 +134,7 @@ export interface NeedsYouView {
 
 export interface ListView {
   /** Null when no family is in the section. */
-  needsYou: NeedsYouView | null;
+  attention: AttentionView | null;
   groups: GroupView[];
   /** Hidden groups, shown in the More popover. */
   more: GroupView[];
@@ -147,12 +152,13 @@ export interface ViewInputs {
   sections: readonly PluginSidebarSection[];
   prefs: Preferences;
   activeThreadId: string | null;
-  /** The root of the family Needs you keeps while one of its threads is open. */
-  heldRootId: 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;
 }
 
 interface Context extends ViewInputs {
+  heldRootId: string | null;
   compare: (a: SortKey, b: SortKey) => number;
   expandedChildren: ReadonlySet<string>;
   expandedOlder: ReadonlySet<string>;
@@ -164,6 +170,10 @@ 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 {
@@ -190,12 +200,23 @@ 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.
+ */
+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;
+  return info.quiet;
+}
+
 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 {
     type: "thread",
     key: `thread:${info.thread.id}`,
@@ -204,7 +225,9 @@ function threadRow(
     nested: options.nested,
     parentTitle: titleOf(context, info.parentId),
     chip: options.chip,
-    rails: [],
+    bold: info.unread && !context.attended,
+    note: context.attended ? null : context.drawnInAttention && needsAttention ? info.attentionNote : info.note,
+    dimmed: isDimmed(context, info, options.chip),
     hiddenBadge: info.thread.isHidden,
     crossGroupLabel: crossGroupLabel(context, info, root),
     homeGroupLabel: null,
@@ -212,11 +235,11 @@ function threadRow(
   };
 }
 
-/** The children of `parent` that get a row: hidden ones only when they need you or failed. */
+/** The children of `parent` that get a row: hidden ones only when they need attention 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.needsYou.size > 0);
+    .filter((info) => !info.thread.isHidden || info.attentionFlags.size > 0);
 }
 
 function subtreeOf(context: Context, id: string): Subtree {
@@ -248,7 +271,6 @@ function foldedChildren(
           count,
           expanded,
           depth,
-          rails: [],
         }
       : null;
 
@@ -330,7 +352,6 @@ function clusterEnvironments(context: Context, units: Unit[], depth: number): Ro
       collapsed,
       flag: collapsed ? mostUrgent(flags) : null,
       depth,
-      rails: [],
     });
     if (!collapsed) {
       for (const member of members) {
@@ -357,7 +378,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.needsYou.size > 0);
+    subtree.visibleCount > 0 || subtree.descendants.some((descendant) => descendant.thread.isHidden && descendant.attentionFlags.size > 0);
   if (!hasChildren) return null;
   return {
     count: subtree.visibleCount,
@@ -369,7 +390,7 @@ 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.needsYou, ...subtreeOf(context, info.thread.id).flags]);
+  const flags = new Set<Flag>([...info.attentionFlags, ...subtreeOf(context, info.thread.id).flags]);
   if (info.flags.has("working")) flags.add("working");
   return flags;
 }
@@ -407,8 +428,8 @@ function familyUnit(context: Context, family: Family): Unit {
 }
 
 /** Waiting on you, then failed, then offline, then unread, then the rest. */
-export function urgency(family: Family): number {
-  const flags = family.needsYouFlags;
+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;
@@ -417,20 +438,34 @@ export function urgency(family: Family): number {
 }
 
 /**
- * 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.
+ * 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 needsYouFamilyRows(context: Context, family: Family, homeGroupLabel: string): Row[] {
+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 needsYou = !info.thread.isArchived && info.needsYou.size > 0;
-    if (!needsYou && !info.isActive) continue;
+    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 rows: Row[] = [{ ...threadRow(context, root, root, { depth: 0, nested: false, chip: null }), homeGroupLabel }];
+  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;
@@ -440,49 +475,54 @@ function needsYouFamilyRows(context: Context, family: Family, homeGroupLabel: st
   };
   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: [] });
+  if (left > 0) rows.push({ type: "left-out", key: `left-out:${root.thread.id}`, scopeId: root.thread.id, count: left, depth: 1 });
   return rows;
 }
 
-function buildNeedsYou(
+function buildAttention(
   context: Context,
   families: readonly Family[],
   homeGroupOf: (family: Family) => GroupDescriptor,
-): NeedsYouView | null {
+): 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.
+  // 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 sorted = [...families].sort(
-    (a, b) =>
+  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 = needsYouFamilyRows(context, family, home.label);
+    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;
   });
-  const rails = railsFor(rows.map((row) => row.depth));
   return {
-    familyCount: sorted.length,
-    rows: rows.map((row, index) => ({ ...row, rails: rails[index]! })),
+    familyCount: sorted.filter((family) => !isAttended(family, context.heldRootId)).length,
+    rows,
     homeGroupIds,
   };
 }
 
 /**
  * One group. `families` is every family bucketed in it, for its counters and
- * `rootIds`; `drawn` leaves out those in Needs you.
+ * `rootIds`; `drawn` leaves out those in Needs attention.
  */
 function buildGroup(
   context: Context,
@@ -544,15 +584,12 @@ function buildGroup(
         count: foldedFamilies.length,
         expanded: opened,
         depth: 0,
-        rails: [],
       };
     }
   }
 
   const units = visible.map((family) => familyUnit(context, family));
-  const clustered = clusterEnvironments(context, units, 0);
-  const rails = railsFor(clustered.map((row) => row.depth));
-  const rows = clustered.map((row, index) => ({ ...row, rails: rails[index]! }));
+  const rows = clusterEnvironments(context, units, 0);
   if (older !== null) rows.push(older);
   return {
     descriptor,
@@ -581,6 +618,7 @@ 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,
@@ -594,6 +632,8 @@ 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])),
+    drawnInAttention: false,
+    attended: false,
   };
 
   const byGroup = new Map<string, Family[]>();
@@ -609,7 +649,7 @@ export function buildListView(inputs: ViewInputs): ListView {
     list.push(family);
     byGroup.set(id, list);
     homeOf.set(family, id);
-    if (inNeedsYou(family, inputs.heldRootId, openRootId)) section.push(family);
+    if (inAttention(family, context.heldRootId, openRootId)) section.push(family);
   }
   const inSection = new Set(section);
 
@@ -637,7 +677,7 @@ export function buildListView(inputs: ViewInputs): ListView {
     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 you, except the loose bucket in custom-section mode, as in bb.
+    // Needs attention, 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;
@@ -655,8 +695,8 @@ 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 needsYou = buildNeedsYou(context, section, (family) => descriptors.get(homeOf.get(family)!)!);
-  return { needsYou, groups, more, moreCounters, order, multiHost: hosts.size > 1 };
+  const attention = buildAttention(context, section, (family) => descriptors.get(homeOf.get(family)!)!);
+  return { attention, 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

@@ -8,6 +8,7 @@ import { defaultPreferences, type Preferences } from "@/shared/preferences";
 import { buildForest, type Forest } from "../model/families";
 import { buildListView, type ListView, type Row } from "../model/view";
 import type { Targets } from "../model/expansion";
+import type { SectionFamily } from "../model/attention";
 
 export const T0 = 1_780_000_000_000;
 
@@ -108,7 +109,10 @@ export interface Scenario {
   sections?: PluginSidebarSection[];
   prefs?: Partial<Preferences>;
   activeThreadId?: string | null;
+  /** The root of the held family, held as it stands now. */
   heldRootId?: string | null;
+  /** The held family as it was when opened; wins over `heldRootId`. */
+  held?: SectionFamily | null;
   targets?: Targets;
   finishedAt?: Record<string, number>;
   seenAt?: Record<string, number>;
@@ -141,7 +145,7 @@ export function viewOf(scenario: Scenario): ListView {
     sections: scenario.sections ?? [],
     prefs: { ...defaultPreferences(), ...scenario.prefs },
     activeThreadId: scenario.activeThreadId ?? null,
-    heldRootId: scenario.heldRootId ?? null,
+    held: scenario.held ?? (scenario.heldRootId == null ? null : (forest.familyOf.get(scenario.heldRootId) ?? null)),
     targets: scenario.targets ?? new Map(),
   });
 }
@@ -165,7 +169,7 @@ export function rowIds(view: ListView, groupId: string): string[] {
   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 ?? []);
+/** Thread ids in Needs attention, in order; "+N more" lines as `+N`. Empty when the section is absent. */
+export function attentionIds(view: ListView): string[] {
+  return idsOf(view.attention?.rows ?? []);
 }

package/package.json

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

package/server/cli.ts

@@ -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-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.",
+      "Organization, sort, group order, hidden and collapsed groups, child-thread folding and which child threads Needs attention 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",

package/shared/preferences.ts

@@ -131,7 +131,7 @@ export const PREFERENCES = {
   childAttention: define(
     childAttentionSchema,
     "blocked" as ChildAttention,
-    "Needs you counts every child: blocked counts a child thread that waits on you, is offline or has an orphaned failure; everything also counts every failed or finished-unread child. The same children stay out of a family's older fold, as running ones do.",
+    "Needs attention counts every child: blocked counts a child thread that waits on you, is offline or has an orphaned failure; everything also counts every failed or finished-unread child. The same children stay out of a family's older fold, as running ones do.",
   ),
   harnessIcon: define(
     harnessIconSchema,
@@ -212,7 +212,7 @@ export function mapBbPreferences(raw: unknown): Partial<Preferences> {
   return mapped as Partial<Preferences>;
 }
 
-/** Per-client preferences, kept in localStorage only. A saved `filter` from before Needs you is dropped. */
+/** Per-client preferences, kept in localStorage only. A saved `filter`, from the old All / Needs attention control, is dropped. */
 export const clientPreferencesSchema = z.object({
   density: z.enum(["compact", "comfortable"]).catch("compact"),
 });

package/skills/thread-glance/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: thread-glance
-description: "Reads and changes the Thread Glance sidebar's layout preferences with `bb thread-glance prefs`: grouping, sort, group order, hidden and collapsed groups, child-thread folding, which child threads Needs you counts, harness icons. Use when asked to change how the Thread Glance sidebar lists, groups, sorts, hides, collapses or folds threads or draws their harness icon."
+description: "Reads and changes the Thread Glance sidebar's layout preferences with `bb thread-glance prefs`: grouping, sort, group order, hidden and collapsed groups, child-thread folding, which child threads Needs attention counts, harness icons. Use when asked to change how the Thread Glance sidebar lists, groups, sorts, hides, collapses or folds threads or draws their harness icon."
 ---
 
 # Thread Glance preferences
@@ -57,12 +57,12 @@ and `bb environment list`; a thread id is a `thr_…` id.
 | `expandedOlder` | Group ids and parent thread ids whose "N older" or "N more child threads" row is open | `[]` |
 | `expandedChildren` | Parent thread ids whose chip is open | `[]` |
 | `showPullRequests` | `true` shows a pull request badge on rows | `true` |
-| `childAttention` | Needs you counts every child. Which child threads need you (the Needs you section, counters, auto-reveal) and stay out of a family's "N more child threads" fold alongside running ones: `blocked` counts a child that waits on you, is offline, or has an orphaned failure (its parent thread idle since); `everything` also counts every failed or unread child | `blocked` |
+| `childAttention` | Needs attention counts every child. Which child threads need attention (the Needs attention section, counters, auto-reveal) and stay out of a family's "N more child threads" fold alongside running ones: `blocked` counts a child that waits on you, is offline, or has an orphaned failure (its parent thread idle since); `everything` also counts every failed or unread child | `blocked` |
 | `harnessIcon` | How rows draw the harness logo: `muted` (monochrome), `colour` (the provider's tint) or `hidden` | `muted` |
 
 Row density is kept per browser, and the CLI cannot read or change it. No
-preference filters the list: families that need you always move into the
-Needs you section.
+preference filters the list: families that need attention always move into the
+Needs attention section.
 
 Sections themselves and the section a thread is in are bb core state: use
 `bb thread section` and `bb thread update`.

package/features/thread-list/components/Rails.tsx

@@ -1,27 +0,0 @@
-// The guide rails of a nested row: one hairline per nesting level,
-// drawn inside the row so they join up from row to row.
-import { railLeft, type Rail } from "../model/layout";
-
-// `start` begins just under the 16px status slot, which is centred in the row.
-const SPAN: Record<Rail, { top: string; bottom: string }> = {
-  start: { top: "calc(50% + 10px)", bottom: "0px" },
-  full: { top: "0px", bottom: "0px" },
-  end: { top: "0px", bottom: "50%" },
-};
-
-export function RowRails({ rails }: { rails: readonly (Rail | null)[] }) {
-  if (rails.every((rail) => rail === null)) return null;
-  return (
-    <span aria-hidden data-rails="" className="pointer-events-none absolute inset-0">
-      {rails.map((rail, level) =>
-        rail === null ? null : (
-          <span
-            key={level}
-            className="absolute w-px bg-border"
-            style={{ left: railLeft(level), ...SPAN[rail] }}
-          />
-        ),
-      )}
-    </span>
-  );
-}

package/features/thread-list/data/useNeedsYouHold.ts

@@ -1,19 +0,0 @@
-// Which family Needs you holds, and which family is open, while one of its threads is open. Diffed
-// render to render, as auto-expansion is; nothing here is persisted.
-import { useRef } from "react";
-import type { Forest } from "../model/families";
-import { holdNeedsYou, NO_HOLD, type NeedsYouHold } from "../model/needs-you";
-
-export function useNeedsYouHold(forest: Forest | null, activeThreadId: string | null): string | null {
-  const held = useRef<NeedsYouHold>(NO_HOLD);
-  const lastForest = useRef<Forest | null>(null);
-  const lastActive = useRef<string | null | undefined>(undefined);
-  // Derived during render, so the family never leaves for a frame. Idempotent:
-  // a repeated render with the same inputs keeps what it stored.
-  if (forest !== null && (forest !== lastForest.current || activeThreadId !== lastActive.current)) {
-    held.current = holdNeedsYou(held.current, activeThreadId === null ? undefined : forest.familyOf.get(activeThreadId));
-    lastForest.current = forest;
-    lastActive.current = activeThreadId;
-  }
-  return held.current.heldRootId;
-}