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

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

@@ -15,46 +15,12 @@ export const SETTLE_AFTER_MS: Readonly<Record<Exclude<SettleAfter, "never">, num
   "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;
 }
 
 /**
@@ -76,47 +42,19 @@ export function lastActivityAt(
 }
 
 /**
- * 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.
+ * A settled thread: quiet as if no thread were focused, not needing attention,
+ * not pinned, and 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 (thread.pinnedAt !== null || thread.isPinned) return false;
+  if (!isQuietThread(info.state, info.unread, false) || info.attentionFlags.size > 0) return false;
   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/state.ts

@@ -109,17 +109,30 @@ export function isOffline(thread: Pick<PluginSidebarThread, "status" | "runtimeS
 /** Per-thread facts the host payload doesn't carry. */
 export interface ThreadContext {
   activeThreadId: string | null;
+  /**
+   * Threads shown in a visible pane of the window besides the active one:
+   * bb's split panes. Absent, only the active (focused) thread is open.
+   */
+  openThreadIds?: ReadonlySet<string>;
   /** Stamps, from the plugin server. */
   finishedAt: Readonly<Record<string, number>>;
   seenAt: Readonly<Record<string, number>>;
 }
 
+/** Whether the thread is shown in a visible pane: the active one or another split pane. */
+export function isOpenThread(thread: Pick<PluginSidebarThread, "id">, context: ThreadContext): boolean {
+  return thread.id === context.activeThreadId || (context.openThreadIds?.has(thread.id) ?? false);
+}
+
 /**
  * bb's rule for every thread: unread when it has finished (idle or
  * error) since it was last read. Children are also unread when they finished
- * after you last looked at them (done-unseen).
+ * after you last looked at them (done-unseen). An open thread is never
+ * unread: bb marks it read moments after it finishes or fails, and counting
+ * it until then only flashes the need-you filter.
  */
 export function isUnread(thread: PluginSidebarThread, context: ThreadContext): boolean {
+  if (isOpenThread(thread, context)) return false;
   const status = normalizeStatus(thread);
   const lastRead = thread.lastReadAt ?? 0;
   if ((status === "idle" || status === "error") && lastRead < thread.latestAttentionAt) {
@@ -132,7 +145,7 @@ export function isUnread(thread: PluginSidebarThread, context: ThreadContext): b
 export function isDoneUnseen(thread: PluginSidebarThread, context: ThreadContext): boolean {
   if (thread.parentThreadId === null) return false;
   if (normalizeStatus(thread) !== "idle") return false;
-  if (thread.id === context.activeThreadId) return false;
+  if (isOpenThread(thread, context)) return false;
   const finished = context.finishedAt[thread.id];
   if (finished === undefined) return false;
   return finished > Math.max(thread.lastReadAt ?? 0, context.seenAt[thread.id] ?? 0);

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

@@ -3,7 +3,7 @@
 import type { Preferences } from "@/shared/preferences";
 import { ancestorsOf, type ThreadTree, type Forest } from "./trees";
 import { isGroupCollapsed, toggleGroupCollapse } from "./groups";
-import { isDoneUnseen } from "./state";
+import { isDoneUnseen, type ThreadContext } from "./state";
 import type { GroupView, OlderRow, SettledRow, ThreadRow } from "./view";
 
 export interface ToggleOutcome {
@@ -76,7 +76,7 @@ export interface MarkAllRead {
 /** Every unread thread in the trees, descendants included: Mark all read, and a root's Mark read for its tree. */
 export function markAllReadPlan(
   trees: readonly ThreadTree[],
-  context: { activeThreadId: string | null; finishedAt: Readonly<Record<string, number>>; seenAt: Readonly<Record<string, number>> },
+  context: ThreadContext,
 ): MarkAllRead {
   const read: string[] = [];
   const seen: string[] = [];
@@ -97,7 +97,7 @@ export function markAllReadPlan(
 export function markReadPlanFor(
   threadId: string,
   forest: Pick<Forest, "infos" | "treeOf">,
-  context: { activeThreadId: string | null; finishedAt: Readonly<Record<string, number>>; seenAt: Readonly<Record<string, number>> },
+  context: ThreadContext,
 ): MarkAllRead {
   const tree = forest.treeOf.get(threadId);
   if (tree !== undefined && tree.root.thread.id === threadId) return markAllReadPlan([tree], context);

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

@@ -13,7 +13,7 @@ import {
   type StateKind,
   type ThreadState,
 } from "./state";
-import { attentionFlagsOf, isOrphanedFailure } from "./attention";
+import { attentionFlagsOf, orphanedAt } from "./attention";
 import { compareCreationAscending } from "./sort";
 import { needsKindOf, rowNote, type RowNote } from "./notes";
 import type { ThreadNotes } from "@/shared/contract";
@@ -40,9 +40,9 @@ export interface ThreadInfo {
   /** Quiet test for the thread alone. */
   quiet: boolean;
   /**
-   * A quiet thread, as if no thread were open: nothing to see behind a
+   * A quiet thread, as if no thread were focused: nothing to see behind a
    * tree's fold. A root, or any child when `childAttention` is
-   * `everything`, takes the quiet test without the open thread's exemption.
+   * `everything`, takes the quiet test without the focused thread's exemption.
    * 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.
@@ -67,7 +67,7 @@ export interface Subtree {
   visibleCount: number;
   /** Visible direct children: the chip's number. */
   childCount: number;
-  /** Every visible descendant is quiet, as if no thread were open, so the subtree adds nothing to see when folded. */
+  /** Every visible descendant is quiet, as if no thread were focused, so the subtree adds nothing to see when folded. */
   quietIgnoringOpen: boolean;
 }
 
@@ -88,7 +88,7 @@ export interface ThreadTree {
   /** Every thread quiet and the active thread not in it. */
   quiet: boolean;
   /**
-   * The quiet test without the open thread's exemption. A group's fold reads
+   * The quiet test without the focused thread's exemption. A group's fold reads
    * this, so opening a thread never changes which roots stay shown.
    */
   quietIgnoringOpen: boolean;
@@ -103,6 +103,8 @@ export interface Forest {
   treeOf: ReadonlyMap<string, ThreadTree>;
   /** The rollup under every thread with a row, by thread id. */
   subtrees: ReadonlyMap<string, Subtree>;
+  /** The earliest moment after `now` a child's failure becomes an orphaned failure, or null for none. */
+  nextOrphanAt: number | null;
 }
 
 export interface ForestInputs extends ThreadContext {
@@ -114,6 +116,12 @@ export interface ForestInputs extends ThreadContext {
   notes?: Readonly<Record<string, ThreadNotes>>;
   /** Which children can need attention; `blocked` when absent. */
   childAttention?: ChildAttention;
+  /** When this list last saw each thread go from busy to idle (see `trackIdle`). */
+  idleSince?: Readonly<Record<string, number>>;
+  /** The server's `idleAt` stamps: when any window last saw each thread go idle. */
+  idleAt?: Readonly<Record<string, number>>;
+  /** False until the stamps have loaded: no failure counts as orphaned before then. */
+  stampsLoaded?: boolean;
 }
 
 function isPinned(thread: PluginSidebarThread): boolean {
@@ -148,6 +156,18 @@ export function attachParent(
   return attach;
 }
 
+/**
+ * When a thread last went idle, as this list or any window saw it; null while
+ * the stamps that may hold it have not loaded.
+ */
+function idleSinceOf(id: string, inputs: ForestInputs): number | null | undefined {
+  if (inputs.stampsLoaded === false) return null;
+  const seen = inputs.idleSince?.[id];
+  const stamped = inputs.idleAt?.[id];
+  if (seen === undefined) return stamped;
+  return stamped === undefined ? seen : Math.max(seen, stamped);
+}
+
 export function buildForest(inputs: ForestInputs): Forest {
   const byId = new Map(inputs.threads.map((thread) => [thread.id, thread]));
   const infos = new Map<string, ThreadInfo>();
@@ -178,14 +198,22 @@ export function buildForest(inputs: ForestInputs): Forest {
   }
 
   const mode = inputs.childAttention ?? "blocked";
+  let nextOrphanAt: number | null = null;
   for (const info of infos.values()) {
     const parent = info.parentId === null ? undefined : infos.get(info.parentId);
+    const orphaned =
+      parent === undefined
+        ? null
+        : orphanedAt(info.thread, info.flags, {
+            ...parent,
+            finishedAt: inputs.finishedAt[parent.thread.id],
+            idleSince: idleSinceOf(parent.thread.id, inputs),
+          });
+    if (orphaned !== null && orphaned > inputs.now) nextOrphanAt = Math.min(nextOrphanAt ?? orphaned, orphaned);
     info.attentionFlags = attentionFlagsOf(info.flags, {
       isRoot: parent === undefined,
       mode,
-      orphaned:
-        parent !== undefined &&
-        isOrphanedFailure(info.thread, info.flags, { ...parent, finishedAt: inputs.finishedAt[parent.thread.id] }),
+      orphaned: orphaned !== null && orphaned <= inputs.now,
     });
     info.quietIgnoringOpen =
       parent === undefined || mode === "everything"
@@ -294,7 +322,16 @@ export function buildForest(inputs: ForestInputs): Forest {
     treeOf.set(root.thread.id, tree);
     for (const info of descendants) treeOf.set(info.thread.id, tree);
   }
-  return { infos, children, trees, treeOf, subtrees };
+  return { infos, children, trees, treeOf, subtrees, nextOrphanAt };
+}
+
+/**
+ * Whether any thread in the trees is unread, descendants, hidden and
+ * archived threads included: the threads Mark all read marks, so it is
+ * offered only when this holds.
+ */
+export function anyUnread(trees: readonly ThreadTree[]): boolean {
+  return trees.some((tree) => tree.root.unread || tree.descendants.some((info) => info.unread));
 }
 
 /** Ids from `id` up to (not including) `stopAt`, nearest first. */

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 ThreadTree, type Forest, type Subtree, type ThreadInfo } from "./trees";
+import { ancestorsOf, anyUnread, type ThreadTree, type Forest, type Subtree, type ThreadInfo } from "./trees";
 import {
   builtinGroup,
   entityGroups,
@@ -142,6 +142,8 @@ export interface GroupView {
   rows: Row[];
   /** Every tree root bucketed in the group, those behind folds included. */
   rootIds: string[];
+  /** A thread in the group's trees is unread: its menu offers Mark all read. */
+  hasUnread: boolean;
 }
 
 export interface ListView {
@@ -153,6 +155,8 @@ export interface ListView {
   order: string[];
   /** Thread trees that need attention, in every group, hidden ones included: the need-you filter's N. */
   needYouCount: number;
+  /** A thread in the list is unread, hidden groups included: the list header offers Mark all read. */
+  hasUnread: boolean;
 }
 
 export interface ViewInputs {
@@ -188,7 +192,7 @@ interface Context extends ViewInputs {
   /** Parent ids on the path to a reveal target. */
   revealPath: ReadonlySet<string>;
   revealIds: ReadonlySet<string>;
-  /** The open thread and its ancestors. */
+  /** The focused thread and its ancestors. */
   activePath: ReadonlySet<string>;
   projectNames: ReadonlyMap<string, string>;
   sectionNames: ReadonlyMap<string, string>;
@@ -325,7 +329,7 @@ function foldedChildren(
   }
 
   // The stable set reads `quietIgnoringOpen` for the child and everything under it, and
-  // ignores which thread is open and the reveal targets: they join afterwards
+  // ignores which thread is focused and the reveal targets: they join afterwards
   // and take no other row's place.
   const quietTree = (kid: ThreadInfo) => kid.quietIgnoringOpen && subtreeOf(context, kid.thread.id).quietIgnoringOpen;
   const stable = new Set<string>();
@@ -514,6 +518,7 @@ function buildGroup(context: Context, descriptor: GroupDescriptor, trees: Thread
     hidden,
     rows,
     rootIds: trees.map((tree) => tree.root.thread.id),
+    hasUnread: anyUnread(trees),
   };
 }
 
@@ -539,6 +544,7 @@ function needYouGroup(context: Context, descriptor: GroupDescriptor, trees: Thre
     hidden,
     rows: clusterEnvironments(context, sorted.filter(needsAttention).map((tree) => treeUnit(context, tree)), 0),
     rootIds: trees.map((tree) => tree.root.thread.id),
+    hasUnread: anyUnread(trees),
   };
 }
 
@@ -624,7 +630,7 @@ export function buildListView(inputs: ViewInputs): ListView {
     }
   }
 
-  return { groups, more, moreCounters, order, needYouCount: countNeedYou(forest) };
+  return { groups, more, moreCounters, order, needYouCount: countNeedYou(forest), hasUnread: anyUnread(forest.trees) };
 }
 
 /** Every thread row in visual order, for keyboard and windowing. */

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

@@ -8,7 +8,7 @@ import { defaultPreferences, type Preferences } from "@/shared/preferences";
 import { buildForest, type Forest } from "../model/trees";
 import { buildListView, type ListView, type Row } from "../model/view";
 import type { Targets } from "../model/expansion";
-import { pullRequestFact, type PullRequestState, type SettleInputs } from "../model/settled";
+import type { SettleInputs } from "../model/settled";
 
 export const T0 = 1_780_000_000_000;
 
@@ -109,6 +109,8 @@ export interface Scenario {
   sections?: PluginSidebarSection[];
   prefs?: Partial<Preferences>;
   activeThreadId?: string | null;
+  /** Threads other split panes show. */
+  openThreadIds?: string[];
   targets?: Targets;
   finishedAt?: Record<string, number>;
   seenAt?: Record<string, number>;
@@ -117,6 +119,10 @@ export interface Scenario {
   notes?: Record<string, import("@/shared/contract").ThreadNotes>;
   now?: number;
   startedAt?: Record<string, number>;
+  /** When this list saw each thread go idle, and the server's idleAt stamps. */
+  idleSince?: Record<string, number>;
+  idleAt?: Record<string, number>;
+  stampsLoaded?: boolean;
   /** Project id → default branch; "main" for every project when absent. */
   defaultBranches?: Record<string, string | null>;
   /** bb's primary machine; "host_1", the fixtures' own, when absent. */
@@ -125,14 +131,13 @@ export interface Scenario {
   needYouOnly?: boolean;
   /** bb's default harness; "claude-code", the fixtures' own, when absent. */
   defaultProviderId?: string | null;
-  /** Pull request lookups that answered, by thread id. */
-  pullRequests?: Record<string, PullRequestState | null>;
 }
 
 export function forestOf(scenario: Scenario): Forest {
   return buildForest({
     threads: scenario.threads,
     activeThreadId: scenario.activeThreadId ?? null,
+    openThreadIds: new Set(scenario.openThreadIds ?? []),
     finishedAt: scenario.finishedAt ?? {},
     seenAt: scenario.seenAt ?? {},
     scheduled: scenario.scheduled ?? {},
@@ -140,6 +145,9 @@ export function forestOf(scenario: Scenario): Forest {
     notes: scenario.notes ?? {},
     childAttention: scenario.prefs?.childAttention,
     now: scenario.now ?? T0 + 60_000,
+    idleSince: scenario.idleSince,
+    idleAt: scenario.idleAt,
+    stampsLoaded: scenario.stampsLoaded,
   });
 }
 
@@ -165,15 +173,11 @@ export function viewOf(scenario: Scenario): ListView {
 
 /** The settle inputs a scenario stands for. */
 export function settleOf(scenario: Scenario): SettleInputs {
-  const answers = new Map(Object.entries(scenario.pullRequests ?? {}));
-  const defaultBranchOf = (projectId: string) =>
-    scenario.defaultBranches === undefined ? "main" : scenario.defaultBranches[projectId];
   return {
     now: scenario.now ?? T0 + 60_000,
     settleAfter: scenario.prefs?.settleAfter ?? defaultPreferences().settleAfter,
     startedAt: scenario.startedAt ?? {},
     finishedAt: scenario.finishedAt ?? {},
-    pullRequestOf: (thread) => pullRequestFact(thread, defaultBranchOf(thread.projectId), answers),
   };
 }
 

package/package.json

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

package/server/stamps.ts

@@ -1,12 +1,12 @@
 // Per-thread timestamps: one kv row per thread, `stamp:<threadId>`,
-// holding whichever of the four kinds it has. Rows are read into memory once
+// holding whichever of the kinds it has. Rows are read into memory once
 // and written through, so listing does not read every row per call.
 import type { BbPluginApi } from "@get-bb/plugin-sdk";
 import { CHANNELS, type StampKind, type StampSignal, type Stamps } from "../shared/contract";
 import { createSerialQueue } from "./serial";
 
 export const STAMP_KEY_PREFIX = "stamp:";
-export const STAMP_KINDS: readonly StampKind[] = ["startedAt", "finishedAt", "pendingAt", "seenAt"];
+export const STAMP_KINDS: readonly StampKind[] = ["startedAt", "finishedAt", "pendingAt", "seenAt", "idleAt"];
 
 export type ThreadStamps = Partial<Record<StampKind, number>>;
 
@@ -30,6 +30,12 @@ export interface StampStore {
   list(): Promise<Stamps>;
   /** Sets `kind` to `at` for each thread and publishes one signal. */
   stamp(kind: StampKind, threadIds: readonly string[], at: number): Promise<void>;
+  /**
+   * Sets `kind` to `at` for each thread whose stored value is earlier or
+   * absent, and publishes one signal for those. A later value is kept, so
+   * several windows reporting one moment cannot move it back.
+   */
+  advance(kind: StampKind, threadIds: readonly string[], at: number): Promise<void>;
   /** Deletes `kind` for each thread and publishes one signal with `value: null`. */
   clear(kind: StampKind, threadIds: readonly string[]): Promise<void>;
   /** Deletes every stamp of each thread. Publishes nothing. */
@@ -89,7 +95,7 @@ export function createStampStore(
   return {
     list: () =>
       serial(async () => {
-        const result: Stamps = { startedAt: {}, finishedAt: {}, pendingAt: {}, seenAt: {} };
+        const result: Stamps = { startedAt: {}, finishedAt: {}, pendingAt: {}, seenAt: {}, idleAt: {} };
         for (const [threadId, stamps] of await load()) {
           for (const kind of STAMP_KINDS) {
             const value = stamps[kind];
@@ -107,6 +113,18 @@ export function createStampStore(
         }
         publish({ kind, threadIds: [...threadIds], value: at });
       }),
+    advance: (kind, threadIds, at) =>
+      serial(async () => {
+        const rows = await load();
+        const moved: string[] = [];
+        for (const threadId of new Set(threadIds)) {
+          const current = rows.get(threadId);
+          if ((current?.[kind] ?? -Infinity) >= at) continue;
+          await save(rows, threadId, { ...current, [kind]: at });
+          moved.push(threadId);
+        }
+        if (moved.length > 0) publish({ kind, threadIds: moved, value: at });
+      }),
     clear: (kind, threadIds) =>
       serial(async () => {
         if (threadIds.length === 0) return;

package/server.ts

@@ -51,6 +51,11 @@ export default function threadGlance(bb: BbPluginApi): void {
       await stamps.stamp("seenAt", threadIds, at);
       return { at };
     },
+    async markIdle({ threadIds }) {
+      const at = Date.now();
+      await stamps.advance("idleAt", threadIds, at);
+      return { at };
+    },
     async clearSeen({ threadIds }) {
       await stamps.clear("seenAt", threadIds);
       return { ok: true as const };

package/shared/contract.ts

@@ -56,6 +56,14 @@ export const rpcContract = defineRpcContract({
     input: z.object({ threadIds: threadIdsSchema }).strict(),
     output: z.object({ ok: z.literal(true) }).strict(),
   },
+  /**
+   * Records `idleAt` for threads a window saw go from busy to idle. A thread
+   * keeps the later of its stored moment and this one.
+   */
+  markIdle: {
+    input: z.object({ threadIds: threadIdsSchema }).strict(),
+    output: z.object({ at: z.number() }).strict(),
+  },
   /** Notes per thread id (see `noteSchema`). */
   listNotes: {
     input: z.null(),

package/shared/signals.ts

@@ -11,6 +11,8 @@ export const stampsSchema = z.object({
   finishedAt: stampMapSchema,
   pendingAt: stampMapSchema,
   seenAt: stampMapSchema,
+  /** When a window saw the thread go from busy to idle, the latest such moment. */
+  idleAt: stampMapSchema,
 });
 export type Stamps = z.infer<typeof stampsSchema>;
 export type StampKind = keyof Stamps;

package/skills/thread-glance/SKILL.md

@@ -52,11 +52,11 @@ and `bb environment list`; a thread id is a `thr_…` id.
 | `collapsedThreadSections` | Custom section keys, `section:<id>` | `[]` |
 | `collapsedMachines` | Machine ids | `[]` |
 | `collapsedEnvironments` | Environment ids of collapsed folder rows | `[]` |
-| `settleAfter` | Settle after: how long a quiet thread goes without activity before its tree can settle into the group's "Settled (N)" fold: `12h`, `1d`, `3d`, `1w` or `never` (then only a merged or closed pull request settles it) | `1d` |
+| `settleAfter` | Settle after: how long a quiet thread goes without activity before its tree can settle into the group's "Settled (N)" fold: `12h`, `1d`, `3d`, `1w` or `never` (then nothing settles) | `1d` |
 | `openSettledFolds` | Group ids whose settled fold is open | `[]` |
 | `expandedOlder` | Parent thread ids whose "N more child threads" row is open, once that tree's children chip is open | `[]` |
 | `expandedChildren` | Parent thread ids whose chip is open | `[]` |
-| `childAttention` | Needs attention counts every child. Which child threads need attention (collapsed groups, the need-you filter, counters, auto-reveal) and stay out of a tree'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 (collapsed groups, the need-you filter, counters, auto-reveal) and stay out of a tree'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 for 5 seconds since it failed); `everything` also counts every failed or unread child | `blocked` |
 | `harnessIcon` | How rows that draw a harness logo draw it: `muted` (monochrome) or `colour` (the provider's tint). A row draws one only where its harness differs from bb's default (a root) or its parent thread's (a child) | `muted` |
 
 Row density and the need-you filter are kept per browser window, and the CLI

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

@@ -1,27 +0,0 @@
-// Looks up the pull request of every thread settling has to know about and
-// reports each answer. Draws nothing: the host shares one lookup per
-// environment with the badges that ask for the same threads.
-import { memo, useEffect } from "react";
-import { experimental_useSidebarThreadPullRequest as usePullRequest } from "@get-bb/plugin-sdk/app";
-import type { PullRequestState } from "../model/settled";
-
-type Answer = (threadId: string, state: PullRequestState | null) => void;
-
-const Probe = memo(function Probe({ threadId, onAnswer }: { threadId: string; onAnswer: Answer }) {
-  const { isLoading, pullRequest } = usePullRequest(threadId);
-  const state = isLoading ? undefined : (pullRequest?.state ?? null);
-  useEffect(() => {
-    if (state !== undefined) onAnswer(threadId, state);
-  }, [threadId, state, onAnswer]);
-  return null;
-});
-
-export function PullRequestProbes({ threadIds, onAnswer }: { threadIds: readonly string[]; onAnswer: Answer }) {
-  return (
-    <>
-      {threadIds.map((threadId) => (
-        <Probe key={threadId} threadId={threadId} onAnswer={onAnswer} />
-      ))}
-    </>
-  );
-}

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

@@ -1,36 +0,0 @@
-// The pull request lookups that answered, by thread id. Answers arriving in
-// one burst (a list's worth of lookups on load) land in one state update.
-//
-// Debt: this copies server state the host's per-row pull request hook owns,
-// because settling reads every thread's pull request at once and the SDK
-// offers no query over many threads. It clears when the SDK does.
-import { useCallback, useRef, useState } from "react";
-import type { PullRequestState } from "../model/settled";
-
-export type PullRequestAnswers = ReadonlyMap<string, PullRequestState | null>;
-
-export function usePullRequestAnswers(): [PullRequestAnswers, (threadId: string, state: PullRequestState | null) => void] {
-  const [answers, setAnswers] = useState<PullRequestAnswers>(() => new Map());
-  const pending = useRef(new Map<string, PullRequestState | null>());
-  const scheduled = useRef(false);
-  const onAnswer = useCallback((threadId: string, state: PullRequestState | null) => {
-    pending.current.set(threadId, state);
-    if (scheduled.current) return;
-    scheduled.current = true;
-    setTimeout(() => {
-      scheduled.current = false;
-      const batch = pending.current;
-      pending.current = new Map();
-      setAnswers((current) => {
-        let next: Map<string, PullRequestState | null> | null = null;
-        for (const [id, value] of batch) {
-          if (current.has(id) && current.get(id) === value) continue;
-          next ??= new Map(current);
-          next.set(id, value);
-        }
-        return next ?? current;
-      });
-    }, 0);
-  }, []);
-  return [answers, onAnswer];
-}