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

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

@@ -0,0 +1,19 @@
+// Which family Needs attention holds, as it was when opened, 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 { holdAttention, NO_HOLD, type AttentionHold, type SectionFamily } from "../model/attention";
+
+export function useAttentionHold(forest: Forest | null, activeThreadId: string | null): SectionFamily | null {
+  const hold = useRef<AttentionHold>(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)) {
+    hold.current = holdAttention(hold.current, forest, activeThreadId);
+    lastForest.current = forest;
+    lastActive.current = activeThreadId;
+  }
+  return hold.current.held;
+}

package/features/thread-list/model/{needs-you.ts → attention.ts}

@@ -1,13 +1,13 @@
-// What needs you, thread by thread. The Needs you section, the header
+// What needs attention, thread by thread. The Needs attention section, the header
 // counters, the section's order and auto-reveal all read the set this
 // builds. Pure.
 import type { PluginSidebarThread } from "@get-bb/plugin-sdk/app";
 import type { ChildAttention } from "@/shared/preferences";
-import type { Family } from "./families";
+import type { Family, Forest } from "./families";
 import { type Flag, type StateKind, type ThreadState } from "./state";
 
 /** The flags that count for a root thread. Working is not one. */
-export const ROOT_NEEDS_YOU: ReadonlySet<Flag> = new Set<Flag>([
+export const ROOT_ATTENTION: ReadonlySet<Flag> = new Set<Flag>([
   "waits-on-you",
   "unread-failed",
   "queue-failed",
@@ -60,18 +60,18 @@ export function isOrphanedFailure(
 }
 
 /**
- * The flags of one thread that make it need you. A root keeps its own. A
+ * The flags of one thread that make it need attention. A root keeps its own. A
  * child counts when it waits on you or is offline, or for an orphaned
  * failure; a finished-unread child never does. With `everything`, a child
  * counts like a root.
  */
-export function needsYouFlagsOf(
+export function attentionFlagsOf(
   flags: ReadonlySet<Flag>,
   options: { isRoot: boolean; mode: ChildAttention; orphaned: boolean },
 ): Set<Flag> {
   const kept = new Set<Flag>();
   if (options.isRoot || options.mode === "everything") {
-    for (const flag of flags) if (ROOT_NEEDS_YOU.has(flag)) kept.add(flag);
+    for (const flag of flags) if (ROOT_ATTENTION.has(flag)) kept.add(flag);
     return kept;
   }
   if (flags.has("waits-on-you")) kept.add("waits-on-you");
@@ -83,51 +83,71 @@ export function needsYouFlagsOf(
   return kept;
 }
 
-/** Whether a set of Needs you flags is worth an auto-reveal: it waits on you or failed. */
-export function revealsOn(needsYou: ReadonlySet<Flag>, isRoot: boolean): boolean {
-  if (needsYou.has("waits-on-you") || needsYou.has("unread-failed")) return true;
-  return !isRoot && needsYou.has("queue-failed");
+/** Whether a set of Needs attention flags is worth an auto-reveal: it waits on you or failed. */
+export function revealsOn(attention: ReadonlySet<Flag>, isRoot: boolean): boolean {
+  if (attention.has("waits-on-you") || attention.has("unread-failed")) return true;
+  return !isRoot && attention.has("queue-failed");
 }
 
 /** What the section reads of a family. */
-type SectionFamily = Pick<Family, "root" | "needsYouFlags">;
+export type SectionFamily = Pick<Family, "root" | "attentionFlags" | "latestAttentionAt">;
 
-/** What Needs you remembers between renders: the family it holds, and the family that was open. */
-export interface NeedsYouHold {
-  /** The root of the family held in the section, if any. */
-  heldRootId: string | null;
+/** What Needs attention remembers between renders: the family it holds, and the family that was open. */
+export interface AttentionHold {
+  /**
+   * The family held in the section, if any, as it was when opened. The section
+   * orders it by this, so nothing that happens inside it moves it.
+   */
+  held: SectionFamily | null;
   /** The root of the family the open thread belonged to at the last render, if any. */
   openRootId: string | null;
 }
 
-export const NO_HOLD: NeedsYouHold = { heldRootId: null, openRootId: null };
+export const NO_HOLD: AttentionHold = { held: null, openRootId: null };
 
 /**
- * Whether a family is in the Needs you section: it is the held family, or one
- * of its threads needs you and none of them is open. Nothing moves while you
+ * Whether a family is in the Needs attention section: it is the held family, or one
+ * of its threads needs attention and none of them is open. Nothing moves while you
  * are inside a family, so the open family only enters by being judged when
- * opened (see `holdNeedsYou`).
+ * opened (see `holdAttention`).
  */
-export function inNeedsYou(family: SectionFamily, heldRootId: string | null, openRootId: string | null): boolean {
+export function inAttention(family: SectionFamily, heldRootId: string | null, openRootId: string | null): boolean {
   const rootId = family.root.thread.id;
   if (rootId === heldRootId) return true;
-  return family.needsYouFlags.size > 0 && rootId !== openRootId;
+  return family.attentionFlags.size > 0 && rootId !== openRootId;
+}
+
+/**
+ * Whether a family is attended: held in the section with nothing in it needing
+ * attention any more. It keeps its place and draws and counts as in its home group.
+ */
+export function isAttended(family: SectionFamily, heldRootId: string | null): boolean {
+  return family.root.thread.id === heldRootId && family.attentionFlags.size === 0;
 }
 
 /**
  * The hold after a render. A family is judged when a thread in it is opened
- * from outside it: it is held if something in it needs you then, and it stays
- * held while one of its threads is open, after nothing in it needs you any
- * more, until a thread outside it is opened. A family that does not need you
+ * from outside it: it is held if something in it needs attention then, and it stays
+ * held while one of its threads is open, after nothing in it needs attention any
+ * more, until none of its threads is open. An attended family whose open thread
+ * is archived counts as closed. A family that does not need attention
  * when opened is not pulled in later, whatever happens in it; nor is one
- * that never needed you. Opening another thread of the open family judges
+ * that never needed attention. Opening another thread of the open family judges
  * nothing again.
  */
-export function holdNeedsYou(previous: NeedsYouHold, openFamily: SectionFamily | undefined): NeedsYouHold {
+export function holdAttention(
+  previous: AttentionHold,
+  forest: Pick<Forest, "infos" | "familyOf">,
+  activeThreadId: string | null,
+): AttentionHold {
+  if (activeThreadId === null) return NO_HOLD;
+  const openFamily = forest.familyOf.get(activeThreadId);
   if (openFamily === undefined) return NO_HOLD;
   const openRootId = openFamily.root.thread.id;
   if (openRootId === previous.openRootId) {
-    return { heldRootId: previous.heldRootId === openRootId ? openRootId : null, openRootId };
+    const archived = forest.infos.get(activeThreadId)?.thread.isArchived ?? false;
+    const held = previous.held?.root.thread.id === openRootId && !(archived && openFamily.attentionFlags.size === 0);
+    return held ? previous : { held: null, openRootId };
   }
-  return { heldRootId: openFamily.needsYouFlags.size > 0 ? openRootId : null, openRootId };
+  return { held: openFamily.attentionFlags.size > 0 ? openFamily : null, openRootId };
 }

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

@@ -13,9 +13,9 @@ export interface Counters {
 export const EMPTY_COUNTERS: Counters = { waitsOnYou: 0, failed: 0, offline: 0, working: 0, unread: 0 };
 
 /**
- * Counts the threads in the families. A thread counts what its Needs you
+ * Counts the threads in the families. A thread counts what its Needs attention
  * flags say, so a child adds to waits-on-you, failed, offline and unread only
- * as "Needs you counts every child" lets it; working counts every thread that
+ * as "Needs attention counts every child" lets it; working counts every thread that
  * runs. Hidden threads carry only waits-on-you and unread-failed flags
  * already; archived threads never count.
  */
@@ -24,7 +24,7 @@ export function countFamilies(families: readonly Family[]): Counters {
   for (const family of families) {
     for (const info of [family.root, ...family.descendants]) {
       if (info.thread.isArchived) continue;
-      const flags = info.needsYou;
+      const flags = info.attentionFlags;
       if (flags.has("waits-on-you")) counters.waitsOnYou += 1;
       if (flags.has("unread-failed") || flags.has("queue-failed")) counters.failed += 1;
       if (flags.has("offline")) counters.offline += 1;

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

@@ -16,7 +16,7 @@ const SUMMARY_ORDER: readonly [StateKind, string][] = [
   ["idle", "idle"],
 ];
 
-/** "2 working, 1 need you, 3 idle": visible descendants by state. */
+/** "2 working, 1 needing you, 3 idle": visible descendants by state. */
 export function childSummary(descendants: readonly ThreadInfo[]): string | null {
   const counts = new Map<StateKind, number>();
   for (const info of descendants) {

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

@@ -1,6 +1,6 @@
 // Auto-expansion: transitions found by diffing snapshots, and the
 // transient targets they leave behind. Pure.
-import { revealsOn } from "./needs-you";
+import { revealsOn } from "./attention";
 import type { Forest } from "./families";
 
 /**
@@ -15,20 +15,20 @@ export type Targets = ReadonlyMap<string, TargetKind>;
 export interface Snapshot {
   activeThreadId: string | null;
   unread: ReadonlySet<string>;
-  /** Threads that wait on you or failed, as Needs you counts them. */
-  needsYou: ReadonlySet<string>;
+  /** Threads that wait on you or failed, as Needs attention counts them. */
+  attentionIds: ReadonlySet<string>;
 }
 
 export function snapshotOf(forest: Forest, activeThreadId: string | null): Snapshot {
   const unread = new Set<string>();
-  const needsYou = new Set<string>();
+  const attentionIds = new Set<string>();
   for (const info of forest.infos.values()) {
     if (info.thread.isArchived) continue;
-    // A finished child that does not need you never opens anything.
-    if (info.needsYou.has("unread") && !info.thread.isHidden) unread.add(info.thread.id);
-    if (revealsOn(info.needsYou, info.parentId === null)) needsYou.add(info.thread.id);
+    // A finished child that does not need attention never opens anything.
+    if (info.attentionFlags.has("unread") && !info.thread.isHidden) unread.add(info.thread.id);
+    if (revealsOn(info.attentionFlags, info.parentId === null)) attentionIds.add(info.thread.id);
   }
-  return { activeThreadId, unread, needsYou };
+  return { activeThreadId, unread, attentionIds };
 }
 
 /**
@@ -40,8 +40,8 @@ export function detectTransitions(previous: Snapshot | null, next: Snapshot): Ma
   if (next.activeThreadId !== null && next.activeThreadId !== previous?.activeThreadId) {
     found.set(next.activeThreadId, "reveal");
   }
-  for (const id of next.needsYou) {
-    if (!previous?.needsYou.has(id)) found.set(id, "reveal");
+  for (const id of next.attentionIds) {
+    if (!previous?.attentionIds.has(id)) found.set(id, "reveal");
   }
   for (const id of next.unread) {
     if (id === next.activeThreadId || found.has(id)) continue;

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

@@ -12,9 +12,9 @@ import {
   type StateKind,
   type ThreadState,
 } from "./state";
-import { needsYouFlagsOf, isOrphanedFailure } from "./needs-you";
+import { attentionFlagsOf, isOrphanedFailure } from "./attention";
 import { compareCreationAscending } from "./sort";
-import { needsKindOf, rowNote, type RowNote } from "./notes";
+import { attentionNote, needsKindOf, rowNote, type RowNote } from "./notes";
 import type { ThreadNotes } from "@/shared/contract";
 import type { ChildAttention } from "@/shared/preferences";
 
@@ -29,17 +29,17 @@ export interface ThreadInfo {
   /** Own flags; for hidden threads only waits-on-you and unread-failed. */
   flags: ReadonlySet<Flag>;
   /**
-   * The flags of this thread that make it need you, for Needs you, the
+   * The flags of this thread that make it need attention, for Needs attention, the
    * counters and auto-reveal: a child counts less than a root.
    */
-  needsYou: Set<Flag>;
+  attentionFlags: Set<Flag>;
   /** Quiet test for the thread alone. */
   quiet: boolean;
   /**
    * A quiet thread, as if no thread were open: nothing to see behind a
    * family's fold. A root, or any child when `childAttention` is
    * `everything`, takes the quiet test without the open thread's exemption.
-   * Otherwise a child is quiet unless it runs or needs you, so finishing
+   * Otherwise a child is quiet unless it runs or needs attention, so finishing
    * unread folds it; an archived child is always quiet. The fold reads this,
    * so opening a thread never changes which children stay shown.
    */
@@ -47,15 +47,17 @@ export interface ThreadInfo {
   isActive: boolean;
   /** The visible ancestor it attaches to, or null for a root. */
   parentId: string | null;
-  /** Why it needs you or failed, for the line under the row. */
+  /** Why it waits on you or failed, for the line under the row. */
   note: RowNote | null;
+  /** Why it needs attention, for the line under its row in Needs attention. */
+  attentionNote: RowNote | null;
 }
 
 /** What a thread's descendants add up to, for its chip and for folding. */
 export interface Subtree {
   /** Descendants, depth-first in creation order, hidden ones included. */
   descendants: ThreadInfo[];
-  /** Union of the descendants' Needs you flags and working, archived ones left out. */
+  /** Union of the descendants' Needs attention flags and working, archived ones left out. */
   flags: ReadonlySet<Flag>;
   /** Visible descendants: the chip's number. */
   visibleCount: number;
@@ -67,12 +69,12 @@ export interface Family {
   root: ThreadInfo;
   /** Descendants, depth-first in creation order, hidden ones included. */
   descendants: ThreadInfo[];
-  /** Union of the descendants' Needs you flags and working (the chip rollup). */
+  /** Union of the descendants' Needs attention flags and working (the chip rollup). */
   descendantFlags: ReadonlySet<Flag>;
   /** The same over root and descendants (rollup, folder rows). */
   flags: ReadonlySet<Flag>;
-  /** Needs you flags over root and descendants: what the section and its order read. */
-  needsYouFlags: ReadonlySet<Flag>;
+  /** Needs attention flags over root and descendants: what the section and its order read. */
+  attentionFlags: ReadonlySet<Flag>;
   /** Visible descendants: the chip's number. */
   visibleDescendantCount: number;
   /** Largest latestAttentionAt over the family. */
@@ -104,7 +106,7 @@ export interface ForestInputs extends ThreadContext {
   now: number;
   /** Server notes per thread id; absent until loaded. */
   notes?: Readonly<Record<string, ThreadNotes>>;
-  /** Which children can need you; `blocked` when absent. */
+  /** Which children can need attention; `blocked` when absent. */
   childAttention?: ChildAttention;
 }
 
@@ -159,29 +161,31 @@ export function buildForest(inputs: ForestInputs): Forest {
       state,
       unread,
       flags: thread.isHidden ? hiddenThreadFlags(flags) : flags,
-      needsYou: new Set<Flag>(),
+      attentionFlags: new Set<Flag>(),
       quiet: isQuietThread(state, unread, isActive),
       quietIgnoringOpen: false,
       isActive,
       parentId: attachParent(thread, byId),
       note: rowNote(thread, inputs.notes?.[thread.id]),
+      attentionNote: null,
     });
   }
 
   const mode = inputs.childAttention ?? "blocked";
   for (const info of infos.values()) {
     const parent = info.parentId === null ? undefined : infos.get(info.parentId);
-    info.needsYou = needsYouFlagsOf(info.flags, {
+    info.attentionFlags = attentionFlagsOf(info.flags, {
       isRoot: parent === undefined,
       mode,
       orphaned:
         parent !== undefined &&
         isOrphanedFailure(info.thread, info.flags, { ...parent, finishedAt: inputs.finishedAt[parent.thread.id] }),
     });
+    info.attentionNote = attentionNote(info.thread, inputs.notes?.[info.thread.id], info.attentionFlags);
     info.quietIgnoringOpen =
       parent === undefined || mode === "everything"
         ? isQuietThread(info.state, info.unread, false)
-        : info.thread.isArchived || (!RUNNING.has(info.state.kind) && info.needsYou.size === 0);
+        : info.thread.isArchived || (!RUNNING.has(info.state.kind) && info.attentionFlags.size === 0);
   }
 
   const children = new Map<string, string[]>();
@@ -216,11 +220,11 @@ export function buildForest(inputs: ForestInputs): Forest {
       const below = subtreeOf(childId, path);
       descendants.push(child, ...below.descendants);
       if (!child.thread.isArchived) {
-        for (const flag of child.needsYou) flags.add(flag);
+        for (const flag of child.attentionFlags) flags.add(flag);
         if (child.flags.has("working")) flags.add("working");
       }
       for (const flag of below.flags) flags.add(flag);
-      if (child.thread.isHidden ? child.needsYou.size > 0 : !child.quietIgnoringOpen) quietIgnoringOpen = false;
+      if (child.thread.isHidden ? child.attentionFlags.size > 0 : !child.quietIgnoringOpen) quietIgnoringOpen = false;
       if (!child.thread.isHidden) visibleCount += 1;
       visibleCount += below.visibleCount;
       if (!below.quietIgnoringOpen) quietIgnoringOpen = false;
@@ -240,13 +244,13 @@ export function buildForest(inputs: ForestInputs): Forest {
     let quiet = root.quiet;
     let quietIgnoringOpen = isQuietThread(root.state, root.unread, false);
     let containsActive = root.isActive;
-    const needsYouFlags = new Set<Flag>();
+    const attentionFlags = new Set<Flag>();
     for (const info of descendants) {
-      if (!info.thread.isArchived) for (const flag of info.needsYou) needsYouFlags.add(flag);
+      if (!info.thread.isArchived) for (const flag of info.attentionFlags) attentionFlags.add(flag);
       latestAttentionAt = Math.max(latestAttentionAt, info.thread.latestAttentionAt);
       if (info.isActive) containsActive = true;
       if (info.thread.isHidden) {
-        if (info.needsYou.size > 0) quiet = quietIgnoringOpen = false;
+        if (info.attentionFlags.size > 0) quiet = quietIgnoringOpen = false;
       } else {
         if (!info.quiet) quiet = false;
         // A child reads as its own fold does, so with `blocked` an unread child
@@ -256,9 +260,9 @@ export function buildForest(inputs: ForestInputs): Forest {
     }
     const flags = new Set<Flag>(descendantFlags);
     if (!root.thread.isArchived) {
-      for (const flag of root.needsYou) {
+      for (const flag of root.attentionFlags) {
         flags.add(flag);
-        needsYouFlags.add(flag);
+        attentionFlags.add(flag);
       }
       if (root.flags.has("working")) flags.add("working");
     }
@@ -267,7 +271,7 @@ export function buildForest(inputs: ForestInputs): Forest {
       descendants,
       descendantFlags,
       flags,
-      needsYouFlags,
+      attentionFlags,
       visibleDescendantCount,
       latestAttentionAt,
       quiet: quiet && !containsActive,

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

@@ -11,46 +11,3 @@ export const FOLDED_STEP = 12;
 export function rowIndent(depth: number): number {
   return ROOT_INDENT + depth * FOLDED_STEP;
 }
-
-/** How far the rail sits from a row's left edge: the centre of the status slot at that level. */
-export function railLeft(level: number): number {
-  return rowIndent(level) + 8;
-}
-
-/**
- * One level of guide rail on one row. `start` begins under the row's
- * status slot, `full` runs the row's height, `end` stops at its middle.
- */
-export type Rail = "start" | "full" | "end";
-
-/**
- * The rails every row draws, from the depths of the rows in order. Level `k`
- * runs from the row at depth `k` through the rows below it, and stops at the
- * last of them, so a family's rail ends on its last row, the fold row
- * included. Entry `k` of a row's result is its rail at level `k`, or null.
- */
-export function railsFor(depths: readonly number[]): (Rail | null)[][] {
-  return depths.map((depth, index) => {
-    const next = depths[index + 1];
-    const rails: (Rail | null)[] = [];
-    for (let level = 0; level <= depth; level += 1) {
-      const continues = next !== undefined && next > level;
-      if (level === depth) rails.push(continues ? "start" : null);
-      else rails.push(continues ? "full" : "end");
-    }
-    return rails;
-  });
-}
-
-/**
- * How a row's title reads. Children step back from roots: a size smaller and
- * muted, unless the thread is unread or open. Hover restores the colour in
- * the component.
- */
-export function titleTreatment(
-  depth: number,
-  state: { unread: boolean; active: boolean },
-): { small: boolean; muted: boolean } {
-  const child = depth > 0;
-  return { small: child, muted: child && !state.unread && !state.active };
-}

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

@@ -2,13 +2,15 @@
 // the server stores what it saw; this decides what a row says.
 import type { PluginSidebarThread } from "@get-bb/plugin-sdk/app";
 import type { Note, ThreadNotes } from "@/shared/contract";
-import { normalizeQueued, normalizeStatus, type NeedsKind } from "./state";
+import { normalizeQueued, normalizeStatus, type Flag, type NeedsKind } from "./state";
 
 export interface RowNote {
-  /** "Asks", "Approve", "Plan", "Failed"… */
+  /** "Asks", "Approve", "Plan", "Failed", "Offline", "Finished"… */
   prefix: string;
+  /** Empty when there is nothing to add: the prefix stands alone. */
   text: string;
-  tone: "attention" | "destructive";
+  /** The tone of the row's glyph for the same reason. */
+  tone: "attention" | "destructive" | "muted";
 }
 
 const PENDING_PREFIX: Record<NeedsKind, string> = {
@@ -25,7 +27,7 @@ export function needsKindOf(notes: ThreadNotes | undefined): NeedsKind | null {
 }
 
 /**
- * The line under a row: why it needs you, or why it failed. Other states
+ * The line under a row: why it needs attention, or why it failed. Other states
  * have none, so the list stays one line per thread where nothing is wrong.
  */
 export function rowNote(thread: PluginSidebarThread, notes: ThreadNotes | undefined): RowNote | null {
@@ -46,6 +48,37 @@ export function rowNote(thread: PluginSidebarThread, notes: ThreadNotes | undefi
   return null;
 }
 
+/**
+ * The line under a row in Needs attention that itself needs attention: its
+ * most urgent reason among `attention`, its Needs attention flags. Waits on
+ * you, then failed, then offline, then finished; each keeps its prefix when
+ * there is no text to follow it.
+ */
+export function attentionNote(
+  thread: PluginSidebarThread,
+  notes: ThreadNotes | undefined,
+  attention: ReadonlySet<Flag>,
+): RowNote | null {
+  if (attention.has("waits-on-you")) {
+    return { prefix: PENDING_PREFIX[needsKindOf(notes) ?? "input"], text: notes?.pending?.text.trim() ?? "", tone: "attention" };
+  }
+  if (attention.has("unread-failed")) {
+    const text = notes?.failed?.text.trim() ?? "";
+    return { prefix: "Failed", text: text.toLowerCase() === "failed" ? "" : text, tone: "destructive" };
+  }
+  if (attention.has("queue-failed")) {
+    return { prefix: "Failed", text: "queued message wasn't sent", tone: "destructive" };
+  }
+  if (attention.has("offline")) return { prefix: "Offline", text: thread.host?.name.trim() ?? "", tone: "attention" };
+  if (attention.has("unread")) return { prefix: "Finished", text: lastReply(notes)?.text.trim() ?? "", tone: "muted" };
+  return null;
+}
+
+/** A note as one line of text: "Failed: timeout", or "Failed" alone. */
+export function noteText(note: RowNote): string {
+  return note.text === "" ? note.prefix : `${note.prefix}: ${note.text}`;
+}
+
 /** The hover card's last-reply line. */
 export function lastReply(notes: ThreadNotes | undefined): Note | null {
   return notes?.done ?? null;

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

@@ -18,7 +18,7 @@ export function lifecyclesFor(shown: ThreadsShown): Lifecycle[] {
   return [shown];
 }
 
-/** "Needs you counts every child" is on when children count as `everything`. */
+/** "Needs attention counts every child" is on when children count as `everything`. */
 export function countsEveryChild(childAttention: ChildAttention): boolean {
   return childAttention === "everything";
 }

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

@@ -1,6 +1,6 @@
 // Structural sharing between two list views: whatever did not change keeps
 // the previous object, so memoized rows and groups skip their render. Pure.
-import type { GroupView, ListView, NeedsYouView, Row } from "./view";
+import type { GroupView, ListView, AttentionView, Row } from "./view";
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   if (value === null || typeof value !== "object") return false;
@@ -86,7 +86,7 @@ function shareGroups(previousGroups: GroupView[], all: ReadonlyMap<string, Group
   return sameItems(previousGroups, result) ? previousGroups : result;
 }
 
-function shareNeedsYou(previous: NeedsYouView | null, next: NeedsYouView | null): NeedsYouView | null {
+function shareAttention(previous: AttentionView | null, next: AttentionView | null): AttentionView | null {
   if (previous === null || next === null) return next;
   return shareFields(previous, next, { rows: shareRows(previous.rows, next.rows) });
 }
@@ -100,7 +100,7 @@ export function shareView(previous: ListView | null, next: ListView): ListView {
   if (previous === null) return next;
   const all = new Map([...previous.groups, ...previous.more].map((group) => [group.descriptor.id, group]));
   return shareFields(previous, next, {
-    needsYou: shareNeedsYou(previous.needsYou, next.needsYou),
+    attention: shareAttention(previous.attention, next.attention),
     groups: shareGroups(previous.groups, all, next.groups),
     more: shareGroups(previous.more, all, next.more),
   });

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

@@ -38,7 +38,7 @@ export const FLAG_ORDER: readonly Flag[] = [
  */
 export type Tone = "attention" | "destructive" | "working" | "background" | "muted" | "muted-strong" | "none";
 
-/** What a thread that needs you is waiting for, from its note. */
+/** What a thread that needs attention is waiting for, from its note. */
 export type NeedsKind = "question" | "approval" | "plan" | "input";
 
 const NEEDS: Record<NeedsKind, { icon: string; label: string }> = {

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

@@ -26,14 +26,16 @@ export function toggleChip(row: ThreadRow, prefs: Preferences, forest: Forest):
   // 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 };
+    : openChildren(id, prefs);
+}
+
+/** Opens a parent's children, as its chip does: "+N more" in Needs attention and an auto-reveal's fold. */
+export function openChildren(parentId: string, prefs: Preferences): ToggleOutcome {
+  return { patch: { expandedChildren: [...without(prefs.expandedChildren, parentId), parentId] }, drop: null };
 }
 
 export function toggleOlder(row: OlderRow, prefs: Preferences, group: GroupView | null, forest: Forest): ToggleOutcome {
-  if (row.scope === "reveal") {
-    // "+N more" expands the whole family, as the chip does.
-    return { patch: { expandedChildren: [...without(prefs.expandedChildren, row.scopeId), row.scopeId] }, drop: null };
-  }
+  if (row.scope === "reveal") return openChildren(row.scopeId, prefs);
   if (!row.expanded) {
     return { patch: { expandedOlder: [...without(prefs.expandedOlder, row.scopeId), row.scopeId] }, drop: null };
   }