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

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

@@ -0,0 +1,52 @@
+// What Thread Glance reads of bb's own configuration: its default harness
+// and its primary machine. Asked once per list; null until answered.
+import { useEffect, useState } from "react";
+import { useSdk } from "@get-bb/plugin-sdk/app";
+
+export interface SystemFacts {
+  /** The harness a new thread starts with, when bb says. */
+  defaultProviderId: string | null;
+  /** The machine bb itself runs on, when one is connected. */
+  primaryHostId: string | null;
+}
+
+export const UNKNOWN_SYSTEM: SystemFacts = { defaultProviderId: null, primaryHostId: null };
+
+interface SystemConfig {
+  primaryHostId: string | null;
+  generalSettings: { defaultProviderId: string | null };
+  serverAccess: { defaultProviderId: string };
+}
+
+/**
+ * The facts in `system.config()`'s answer. The default harness is the one
+ * the user chose in bb's settings, else the one bb falls back to.
+ */
+export function readSystemFacts(config: SystemConfig): SystemFacts {
+  return {
+    defaultProviderId: config.generalSettings.defaultProviderId ?? config.serverAccess.defaultProviderId ?? null,
+    primaryHostId: config.primaryHostId,
+  };
+}
+
+export function useSystemFacts(): SystemFacts {
+  const sdk = useSdk();
+  const [facts, setFacts] = useState<SystemFacts>(UNKNOWN_SYSTEM);
+  useEffect(() => {
+    let cancelled = false;
+    // Called inside the chain, so a host that throws for an area it lacks
+    // lands in the rejection handler and leaves the facts unknown.
+    Promise.resolve()
+      .then(() => sdk.system.config())
+      .then(
+        (config) => {
+          if (!cancelled) setFacts(readSystemFacts(config));
+        },
+        () => undefined,
+      );
+    return () => {
+      cancelled = true;
+    };
+  }, [sdk]);
+  return facts;
+}

package/features/thread-list/icons.ts

@@ -25,6 +25,7 @@ export const ICONS = {
   newThread: "Plus",
   newSection: "SectionAdd",
   customize: "SlidersHorizontal",
+  settings: "SlidersHorizontal",
   check: "Check",
   pullRequest: "GitPullRequest",
   branch: "GitBranch",

package/features/thread-list/index.ts

@@ -1,3 +1,2 @@
 // The sidebar thread list feature: what the app entry may use.
 export { ThreadList } from "./components/ThreadList";
-export { SettingsDisclosure } from "./components/SettingsPanel";

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

@@ -1,9 +1,8 @@
-// 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
+// What needs attention, thread by thread. Collapsed groups, the header
+// counters, the need-you filter 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, Forest } from "./families";
 import { type Flag, type StateKind, type ThreadState } from "./state";
 
 /** The flags that count for a root thread. Working is not one. */
@@ -88,66 +87,3 @@ export function revealsOn(attention: ReadonlySet<Flag>, isRoot: boolean): boolea
   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. */
-export type SectionFamily = Pick<Family, "root" | "attentionFlags" | "latestAttentionAt">;
-
-/** 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: AttentionHold = { held: null, openRootId: null };
-
-/**
- * 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 `holdAttention`).
- */
-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.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 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 attention. Opening another thread of the open family judges
- * nothing again.
- */
-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) {
-    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 { held: openFamily.attentionFlags.size > 0 ? openFamily : null, openRootId };
-}

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

@@ -0,0 +1,27 @@
+// The project's default branch, and whether a thread's branch is another
+// one. Pure.
+
+/** A project source as `projects.get` returns it, narrowed to what the lookup reads. */
+export interface ProjectSourceRef {
+  hostId: string;
+  isDefault: boolean;
+}
+
+/**
+ * The machine to ask for a project's default branch: its default source's,
+ * else its first source's. Null when the project has no source, as a
+ * personal project may not. A thread's own machine may have no source for
+ * the project, and bb answers 404 there.
+ */
+export function defaultSourceHostId(sources: readonly ProjectSourceRef[]): string | null {
+  return (sources.find((source) => source.isDefault) ?? sources[0])?.hostId ?? null;
+}
+
+/**
+ * Whether a thread's branch is known to differ from its project's default:
+ * `defaultBranch` is undefined while the lookup runs and null when it found
+ * none, and in both cases the branch is not known to differ.
+ */
+export function isOffDefaultBranch(branch: string | null, defaultBranch: string | null | undefined): branch is string {
+  return branch !== null && typeof defaultBranch === "string" && branch !== defaultBranch;
+}

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

@@ -1,5 +1,5 @@
 // Group header counters. Pure.
-import type { Family } from "./families";
+import type { ThreadTree } from "./trees";
 
 export interface Counters {
   waitsOnYou: number;
@@ -13,16 +13,16 @@ 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 attention
+ * Counts the threads in the trees. A thread counts what its Needs attention
  * flags say, so a child adds to waits-on-you, failed, offline and unread only
  * 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.
  */
-export function countFamilies(families: readonly Family[]): Counters {
+export function countTrees(trees: readonly ThreadTree[]): Counters {
   const counters = { ...EMPTY_COUNTERS };
-  for (const family of families) {
-    for (const info of [family.root, ...family.descendants]) {
+  for (const tree of trees) {
+    for (const info of [tree.root, ...tree.descendants]) {
       if (info.thread.isArchived) continue;
       const flags = info.attentionFlags;
       if (flags.has("waits-on-you")) counters.waitsOnYou += 1;

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

@@ -1,5 +1,5 @@
 // Hover card and details drawer content. Pure.
-import type { Family, ThreadInfo } from "./families";
+import type { ThreadTree, ThreadInfo } from "./trees";
 import type { StateKind } from "./state";
 
 const SUMMARY_ORDER: readonly [StateKind, string][] = [
@@ -29,13 +29,13 @@ export function childSummary(descendants: readonly ThreadInfo[]): string | null
   return parts.length > 0 ? parts.join(", ") : null;
 }
 
-/** Descendants of `id` inside its family, for the card of any row. */
-export function descendantsOf(family: Family | undefined, id: string): ThreadInfo[] {
-  if (family === undefined) return [];
-  if (family.root.thread.id === id) return family.descendants;
+/** Descendants of `id` inside its tree, for the card of any row. */
+export function descendantsOf(tree: ThreadTree | undefined, id: string): ThreadInfo[] {
+  if (tree === undefined) return [];
+  if (tree.root.thread.id === id) return tree.descendants;
   const result: ThreadInfo[] = [];
   const within = new Set([id]);
-  for (const info of family.descendants) {
+  for (const info of tree.descendants) {
     if (info.parentId !== null && within.has(info.parentId)) {
       within.add(info.thread.id);
       result.push(info);

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

@@ -1,13 +1,13 @@
 // Auto-expansion: transitions found by diffing snapshots, and the
 // transient targets they leave behind. Pure.
 import { revealsOn } from "./attention";
-import type { Forest } from "./families";
+import type { Forest } from "./trees";
 
 /**
- * `reveal` targets open their group, their `N older` fold and the parent
- * chips on their path. `open` targets (a thread that newly became unread)
- * open the group and the fold only, so finished children don't expand
- * their parent's chip.
+ * `reveal` targets open the parent chips on their path. `open` targets (a
+ * thread that newly became unread) open no chip, so finished children don't
+ * expand their parent's. The open thread's target, of either kind, also
+ * opens its collapsed group. No target opens a settled fold.
  */
 export type TargetKind = "reveal" | "open";
 export type Targets = ReadonlyMap<string, TargetKind>;

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

@@ -1,4 +1,4 @@
-// Top-level groups: which group a family lands in, and the order
+// Top-level groups: which group a tree lands in, and the order
 // groups appear in. Pure.
 import type {
   PluginSidebarProject,
@@ -43,7 +43,7 @@ export function personalProject(
 }
 
 /**
- * The group a family root belongs to. Pinned roots go to Pinned. A root
+ * The group a tree root belongs to. Pinned roots go to Pinned. A root
  * whose project, section or machine isn't known goes to the loose Threads
  * bucket, except an unknown section, which gets a placeholder group as in
  * bb.

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

@@ -1,7 +1,8 @@
 // Accessible names: everything a tooltip says is in the aria-label.
-import type { OlderRow, ThreadRow } from "./view";
-import { FLAG_GLYPHS, type Flag } from "./state";
+import type { Chip, OlderRow, SettledRow, ThreadRow } from "./view";
+import type { Flag } from "./state";
 import { formatDateTime } from "./details";
+import type { OrganizationMode } from "@/shared/preferences";
 
 export function stateText(row: ThreadRow, pluginLabel: string | null): string {
   const state = row.info.state;
@@ -20,32 +21,56 @@ export function rowAriaLabel(
   const parts = [stateText(row, options.pluginLabel), options.providerName];
   if (row.parentTitle !== null && row.depth > 0) parts.push(`child of ${row.parentTitle}`);
   if (row.crossGroupLabel !== null) parts.push(row.crossGroupLabel.toLowerCase());
-  if (row.homeGroupLabel !== null) parts.push(`in ${row.homeGroupLabel}`);
   if (row.hiddenBadge) parts.push("hidden thread");
   if (row.info.unread && row.info.state.kind !== "unread") parts.push("unread");
   if (options.hasDraft && row.info.state.kind !== "draft") parts.push("unsubmitted draft");
   return `Open ${row.info.thread.displayTitle} — ${parts.join("; ")}`;
 }
 
-export function chipLabel(title: string, count: number, flag: Flag | null, expanded: boolean): string {
-  const noun = count === 1 ? "child thread" : "child threads";
-  const detail = flag === null ? "" : `, ${FLAG_GLYPHS[flag].label}`;
-  return `${expanded ? "Collapse" : "Show"} ${count} ${noun} of ${title}${detail}`;
-}
+/** What a children chip's state says, uncounted: the state can come from any depth, the count only from direct children. */
+const CHIP_STATE_TEXT: Readonly<Record<Flag, string>> = {
+  "waits-on-you": "waiting on you below",
+  "unread-failed": "failed below",
+  "queue-failed": "queued message failed below",
+  offline: "machine offline below",
+  working: "working below",
+  unread: "unread below",
+};
 
 /**
- * The fold row's text and accessible name. The family's row says "child
- * threads" so it never reads like the group's "older" row.
+ * "Show 2 child threads of Release, working below"; with no visible child,
+ * "Show hidden child threads of Release, waiting on you below".
  */
+export function chipLabel(title: string, chip: Chip): string {
+  const children = chip.count === 0 ? "hidden child threads" : `${chip.count} ${chip.count === 1 ? "child thread" : "child threads"}`;
+  const state = chip.flag === null ? "" : `, ${CHIP_STATE_TEXT[chip.flag]}`;
+  return `${chip.expanded ? "Collapse" : "Show"} ${children} of ${title}${state}`;
+}
+
+/** The text and accessible name of an open tree's fold row. */
 export function olderRowText(row: OlderRow): { label: string; ariaLabel: string } {
-  const noun = row.count === 1 ? "thread" : "threads";
-  if (row.scope === "group") {
-    return {
-      label: row.expanded ? "Show fewer" : `${row.count} older`,
-      ariaLabel: `${row.expanded ? "Hide" : "Show"} ${row.count} older ${noun}`,
-    };
-  }
   const children = row.count === 1 ? "child thread" : "child threads";
-  if (row.expanded) return { label: "Show fewer", ariaLabel: `Hide ${row.count} older ${children}` };
+  if (row.expanded) return { label: "Show fewer", ariaLabel: `Hide ${row.count} more ${children}` };
   return { label: `${row.count} more ${children}`, ariaLabel: `Show ${row.count} more ${children}` };
 }
+
+/** The settled fold's text: "Settled (N)" while closed, "Settled" while open. N counts trees. */
+export function settledRowText(row: SettledRow): { label: string; ariaLabel: string } {
+  const noun = row.count === 1 ? "settled thread tree" : "settled thread trees";
+  return {
+    label: row.expanded ? "Settled" : `Settled (${row.count})`,
+    ariaLabel: `${row.expanded ? "Hide" : "Show"} ${row.count} ${noun}`,
+  };
+}
+
+/** The list header's name for the current grouping. */
+export function groupingName(mode: OrganizationMode): string {
+  switch (mode) {
+    case "project":
+      return "Projects";
+    case "chronological":
+      return "Sections";
+    case "machine":
+      return "Machines";
+  }
+}

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

@@ -30,6 +30,7 @@ export interface RowMenuItem {
 
 export interface RowMenuInputs {
   thread: PluginSidebarThread;
+  /** The thread is unread; for a root, anything in its tree is, and Mark read marks the tree. */
   unread: boolean;
   splitAvailable: boolean;
   /** True for a thread with no parent (bb: Move to section on roots only). */

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

@@ -1,5 +1,5 @@
 // "Move…": the keyboard route to what drag and drop does. Pure.
-import type { Forest } from "./families";
+import type { Forest } from "./trees";
 import { isInSubtree } from "./drag";
 
 export interface MoveTarget {

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

@@ -2,10 +2,10 @@
 // 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 Flag, type NeedsKind } from "./state";
+import { normalizeQueued, normalizeStatus, type NeedsKind } from "./state";
 
 export interface RowNote {
-  /** "Asks", "Approve", "Plan", "Failed", "Offline", "Finished"… */
+  /** "Asks", "Approve", "Plan", "Needs" or "Failed". */
   prefix: string;
   /** Empty when there is nothing to add: the prefix stands alone. */
   text: string;
@@ -48,32 +48,6 @@ 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}`;

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

@@ -1,23 +1,7 @@
 // What the settings panel's controls show and write. Pure.
-import type { ChildAttention, Lifecycle, Preferences, SortField } from "@/shared/preferences";
+import type { ChildAttention, Preferences, SortField } from "@/shared/preferences";
 import { effectiveDirection, effectiveSortField, naturalDirection } from "./sort";
 
-export type ThreadsShown = "active" | "archived" | "both";
-
-/** The Threads choice a saved lifecycle list stands for. */
-export function threadsShown(lifecycles: readonly Lifecycle[]): ThreadsShown {
-  const active = lifecycles.includes("active");
-  const archived = lifecycles.includes("archived");
-  if (active && archived) return "both";
-  return archived ? "archived" : "active";
-}
-
-/** The lifecycles a Threads choice saves; never empty. */
-export function lifecyclesFor(shown: ThreadsShown): Lifecycle[] {
-  if (shown === "both") return ["active", "archived"];
-  return [shown];
-}
-
 /** "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/settled.ts

@@ -0,0 +1,122 @@
+// Settled threads: which trees go behind their group's settled fold.
+// Worked out afresh on every build, so any activity unsettles a thread. Pure.
+import type { PluginSidebarThread } from "@get-bb/plugin-sdk/app";
+import type { SettleAfter } from "@/shared/preferences";
+import { isQuietThread } from "./state";
+import type { ThreadInfo, ThreadTree } from "./trees";
+
+const HOUR = 60 * 60 * 1000;
+
+/** How long a thread goes without activity before it settles, per Settle after choice. */
+export const SETTLE_AFTER_MS: Readonly<Record<Exclude<SettleAfter, "never">, number>> = {
+  "12h": 12 * HOUR,
+  "1d": 24 * HOUR,
+  "3d": 3 * 24 * HOUR,
+  "1w": 7 * 24 * HOUR,
+};
+
+/** A pull request's state, as bb's lookup reports it. */
+export type PullRequestState = "open" | "draft" | "merged" | "closed";
+
+/**
+ * What settling knows of a thread's pull request: its state, null when the
+ * thread has none, or `unknown` while a lookup it needs has not answered.
+ */
+export type PullRequestFact = PullRequestState | null | "unknown";
+
+/**
+ * Whether a thread's branch can carry a pull request worth looking up: it is
+ * on a branch other than its project's default. A default branch the lookup
+ * could not find (null) is no reason to skip one; one still being looked up
+ * (undefined) is, until it answers.
+ */
+export function needsPullRequestLookup(branch: string | null, defaultBranch: string | null | undefined): boolean {
+  return branch !== null && defaultBranch !== undefined && branch !== defaultBranch;
+}
+
+/** A thread's pull request fact, from its project's default branch and the lookups that answered. */
+export function pullRequestFact(
+  thread: Pick<PluginSidebarThread, "id" | "environment">,
+  defaultBranch: string | null | undefined,
+  answers: ReadonlyMap<string, PullRequestState | null>,
+): PullRequestFact {
+  const branch = thread.environment?.branchName ?? null;
+  if (branch === null) return null;
+  if (defaultBranch === undefined) return "unknown";
+  if (!needsPullRequestLookup(branch, defaultBranch)) return null;
+  const answer = answers.get(thread.id);
+  return answer === undefined ? "unknown" : answer;
+}
+
+export interface SettleInputs {
+  now: number;
+  settleAfter: SettleAfter;
+  /** Server stamps: when each thread last started and finished a turn. */
+  startedAt: Readonly<Record<string, number>>;
+  finishedAt: Readonly<Record<string, number>>;
+  pullRequestOf(thread: PluginSidebarThread): PullRequestFact;
+}
+
+/**
+ * A thread's own last activity: its creation, its last finish or failure
+ * (`latestAttentionAt`) and the server's stamps of its last start and
+ * finish. `updatedAt` is left out because opening or renaming a thread
+ * moves it too.
+ */
+export function lastActivityAt(
+  thread: Pick<PluginSidebarThread, "id" | "createdAt" | "latestAttentionAt">,
+  stamps: Pick<SettleInputs, "startedAt" | "finishedAt">,
+): number {
+  return Math.max(
+    thread.createdAt,
+    thread.latestAttentionAt,
+    stamps.startedAt[thread.id] ?? 0,
+    stamps.finishedAt[thread.id] ?? 0,
+  );
+}
+
+/**
+ * A settled thread: quiet as if no thread were open, not needing attention,
+ * not pinned, with no open pull request, and either its pull request merged
+ * or closed or its own last activity is older than the Settle after period.
+ * Hidden and archived threads take the same test.
+ */
+export function isSettledThread(info: ThreadInfo, inputs: SettleInputs): boolean {
+  const thread = info.thread;
+  if (!mightSettle(info)) return false;
+  const pullRequest = inputs.pullRequestOf(thread);
+  if (pullRequest === "unknown" || pullRequest === "open" || pullRequest === "draft") return false;
+  if (pullRequest === "merged" || pullRequest === "closed") return true;
+  if (inputs.settleAfter === "never") return false;
+  return inputs.now - lastActivityAt(thread, inputs) >= SETTLE_AFTER_MS[inputs.settleAfter];
+}
+
+/** A row's thread that settles once its pull request and activity allow: quiet as if none were open, needing no attention, not pinned. */
+function mightSettle(info: ThreadInfo): boolean {
+  const thread = info.thread;
+  if (thread.pinnedAt !== null || thread.isPinned) return false;
+  return isQuietThread(info.state, info.unread, false) && info.attentionFlags.size === 0;
+}
+
+/** A tree settles as one unit: when every thread in it is settled. */
+export function isSettledTree(tree: Pick<ThreadTree, "root" | "descendants">, inputs: SettleInputs): boolean {
+  return isSettledThread(tree.root, inputs) && tree.descendants.every((info) => isSettledThread(info, inputs));
+}
+
+/**
+ * The threads whose pull request settling has to look up: every thread that
+ * would settle but for its pull request, on a branch other than its
+ * project's default.
+ */
+export function pullRequestLookupIds(
+  infos: Iterable<ThreadInfo>,
+  defaultBranchOf: (thread: PluginSidebarThread) => string | null | undefined,
+): string[] {
+  const ids: string[] = [];
+  for (const info of infos) {
+    const thread = info.thread;
+    if (!mightSettle(info)) continue;
+    if (needsPullRequestLookup(thread.environment?.branchName ?? null, defaultBranchOf(thread))) ids.push(thread.id);
+  }
+  return ids;
+}

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, AttentionView, Row } from "./view";
+import type { GroupView, ListView, Row } from "./view";
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   if (value === null || typeof value !== "object") return false;
@@ -86,11 +86,6 @@ function shareGroups(previousGroups: GroupView[], all: ReadonlyMap<string, Group
   return sameItems(previousGroups, result) ? previousGroups : result;
 }
 
-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) });
-}
-
 /**
  * `next`, sharing every group and row that did not change since `previous`.
  * Groups match by id and rows by key, never by position. A group keeps its
@@ -100,7 +95,6 @@ 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, {
-    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/sort.ts

@@ -5,14 +5,13 @@ import type { SortDirection, SortField } from "@/shared/preferences";
 export interface SortOptions {
   field: SortField;
   direction: SortDirection;
-  workingFirst: boolean;
 }
 
 /** What a comparator needs to know about a root beyond the thread itself. */
 export interface SortKey {
   thread: PluginSidebarThread;
-  /** Largest `latestAttentionAt` over the family. */
-  familyAttention: number;
+  /** Largest `latestAttentionAt` over the tree. */
+  treeAttention: number;
 }
 
 function byCreated(a: SortKey, b: SortKey): number {
@@ -28,7 +27,7 @@ function byAlpha(a: SortKey, b: SortKey): number {
 }
 
 function byUpdated(a: SortKey, b: SortKey): number {
-  const diff = b.familyAttention - a.familyAttention;
+  const diff = b.treeAttention - a.treeAttention;
   if (diff !== 0) return diff;
   return byCreated(a, b);
 }
@@ -48,22 +47,12 @@ export function effectiveDirection(field: SortField, direction: SortDirection):
   return direction === "default" ? naturalDirection(field) : direction;
 }
 
-/**
- * The comparator for roots in a group. Working first keeps active threads on
- * top whatever the direction.
- */
+/** The comparator for roots in a group. */
 export function makeComparator(options: SortOptions): (a: SortKey, b: SortKey) => number {
   const field = effectiveSortField(options.field);
   const sign = effectiveDirection(field, options.direction) === naturalDirection(field) ? 1 : -1;
   const base = field === "alpha" ? byAlpha : field === "created" ? byCreated : byUpdated;
-  return (a, b) => {
-    if (field === "updated" && options.workingFirst) {
-      const aActive = a.thread.status === "active";
-      const bActive = b.thread.status === "active";
-      if (aActive !== bActive) return aActive ? -1 : 1;
-    }
-    return sign * base(a, b);
-  };
+  return (a, b) => sign * base(a, b);
 }
 
 /** Pinned order: pinSortKey, then pinnedAt desc, createdAt desc, id. */