@gperezmz/bb-plugin-thread-glance 0.4.1 → 0.5.0

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

@@ -3,7 +3,7 @@
 // builds. Pure.
 import type { PluginSidebarThread } from "@get-bb/plugin-sdk/app";
 import type { ChildAttention } from "@/shared/preferences";
-import { type Flag, type StateKind, type ThreadState } from "./state";
+import { computeState, type Flag, type StateKind, type ThreadState } from "./state";
 
 /** The flags that count for a root thread. Working is not one. */
 export const ROOT_ATTENTION: ReadonlySet<Flag> = new Set<Flag>([
@@ -17,11 +17,24 @@ export const ROOT_ATTENTION: ReadonlySet<Flag> = new Set<Flag>([
 /** States in which a parent thread is busy and may still deal with a failed child. */
 const BUSY: ReadonlySet<StateKind> = new Set<StateKind>(["working", "background", "queued", "scheduled"]);
 
+/**
+ * How long a parent thread stays idle before a child's failure counts as
+ * orphaned. bb reports a child's turn to its parent after a 2 s batch delay,
+ * and the parent then has to start: a failure it is about to pick up never
+ * reaches the need-you filter.
+ */
+export const ORPHAN_WAIT_MS = 5_000;
+
 export interface ParentThread {
   thread: Pick<PluginSidebarThread, "latestAttentionAt">;
   state: Pick<ThreadState, "kind">;
   /** When the plugin server last saw the parent thread finish a turn, if it did. */
   finishedAt?: number;
+  /**
+   * When a window last saw the parent thread go from busy to idle, if one did;
+   * null while that is not yet known, and no failure under it counts.
+   */
+  idleSince?: number | null;
 }
 
 /** A parent thread is idle when it is not working, setting up, running background work or holding a queued message. */
@@ -41,21 +54,72 @@ export function failureTime(
 }
 
 /**
- * An orphaned failure: the parent thread is idle and has not run or
- * finished since the child failed. A busy parent thread, or one that
+ * When a child's failure becomes an orphaned failure, or null while it cannot:
+ * the parent thread is idle and has not run or finished since the child
+ * failed, and has stayed idle for `ORPHAN_WAIT_MS` from the later of the
+ * failure and its last becoming idle. A busy parent thread, or one that
  * finished after the failure, is taken to know about it. The parent thread's
  * own clock is its last finish (`finishedAt`, or `latestAttentionAt` when it
  * failed): `updatedAt` also moves when someone merely opens or renames it.
  */
+export function orphanedAt(
+  thread: Pick<PluginSidebarThread, "latestAttentionAt" | "updatedAt">,
+  flags: ReadonlySet<Flag>,
+  parent: ParentThread,
+): number | null {
+  if (!flags.has("unread-failed") && !flags.has("queue-failed")) return null;
+  if (!isParentIdle(parent) || parent.idleSince === null) return null;
+  const parentActiveAt = Math.max(parent.thread.latestAttentionAt, parent.finishedAt ?? 0);
+  const failedAt = failureTime(thread, flags);
+  if (parentActiveAt > failedAt) return null;
+  return Math.max(failedAt, parent.idleSince ?? 0) + ORPHAN_WAIT_MS;
+}
+
+/** Whether a child's failure is an orphaned failure at `now` (see `orphanedAt`). */
 export function isOrphanedFailure(
   thread: Pick<PluginSidebarThread, "latestAttentionAt" | "updatedAt">,
   flags: ReadonlySet<Flag>,
   parent: ParentThread,
+  now: number,
 ): boolean {
-  if (!flags.has("unread-failed") && !flags.has("queue-failed")) return false;
-  if (!isParentIdle(parent)) return false;
-  const parentActiveAt = Math.max(parent.thread.latestAttentionAt, parent.finishedAt ?? 0);
-  return parentActiveAt <= failureTime(thread, flags);
+  const at = orphanedAt(thread, flags, parent);
+  return at !== null && at <= now;
+}
+
+/** Which threads the list last saw busy, and when each last went from busy to idle. */
+export interface IdleTracker {
+  busy: ReadonlySet<string>;
+  idleSince: Readonly<Record<string, number>>;
+  /** The threads this step saw go idle, for the server's `idleAt`. */
+  wentIdle: readonly string[];
+}
+
+function isBusyThread(thread: PluginSidebarThread): boolean {
+  const state = computeState(thread, { unread: false, hasDraft: false, scheduledAt: null, now: 0 });
+  return !isParentIdle({ thread, state });
+}
+
+/**
+ * The tracker after the list sees `threads` at `at`: a thread busy before and
+ * idle now went idle at `at`. A thread first seen idle has no time here; the
+ * server's `idleAt` holds what an earlier window saw.
+ */
+export function trackIdle(previous: IdleTracker | null, threads: readonly PluginSidebarThread[], at: number): IdleTracker {
+  const busy = new Set<string>();
+  const idleSince: Record<string, number> = {};
+  const wentIdle: string[] = [];
+  for (const thread of threads) {
+    const id = thread.id;
+    if (isBusyThread(thread)) {
+      busy.add(id);
+    } else if (previous?.busy.has(id)) {
+      idleSince[id] = at;
+      wentIdle.push(id);
+    } else if (previous?.idleSince[id] !== undefined) {
+      idleSince[id] = previous.idleSince[id];
+    }
+  }
+  return { busy, idleSince, wentIdle };
 }
 
 /**

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

@@ -6,7 +6,7 @@ import type { Forest } from "./trees";
 /**
  * `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
+ * expand their parent's. The focused thread's target, of either kind, also
  * opens its collapsed group. No target opens a settled fold.
  */
 export type TargetKind = "reveal" | "open";

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

@@ -42,7 +42,7 @@ export function lastActivityAt(
 }
 
 /**
- * A settled thread: quiet as if no thread were open, not needing attention,
+ * 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.
  */

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

@@ -33,8 +33,8 @@ export const FLAG_ORDER: readonly Flag[] = [
 
 /**
  * `working` is bb's timeline accent, so a running thread stands out in both
- * themes; `background` keeps bb's faint tone for background
- * activity, so the two stay apart.
+ * themes; `background` draws background activity in the grey `muted` has,
+ * and its glyph shines, which keeps it apart from a draft.
  */
 export type Tone = "attention" | "destructive" | "working" | "background" | "muted" | "muted-strong" | "none";
 
@@ -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);
@@ -234,7 +247,7 @@ export function computeState(thread: PluginSidebarThread, inputs: StateInputs):
   }
   if (inputs.unread) return { kind: "unread", label: "Unread", glyph: glyph("dot", "none"), ...none };
   if (inputs.hasDraft) return { kind: "draft", label: "Unsubmitted draft", glyph: glyph("Edit", "muted"), ...none };
-  return { kind: "idle", label: "Idle", glyph: glyph("ring", "muted"), ...none };
+  return { kind: "idle", label: "Idle", glyph: glyph("ring", "muted-strong"), ...none };
 }
 
 /**

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,
@@ -113,7 +113,7 @@ export interface EnvironmentRow {
   depth: number;
 }
 
-/** A group's settled fold: the faint "Settled (N)" divider at its end. */
+/** A group's settled fold: the muted "Settled (N)" divider at its end. */
 export interface SettledRow {
   type: "settled";
   key: string;
@@ -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/browser.css

@@ -11,3 +11,10 @@
 [data-icon] {
   display: inline-block;
 }
+
+/* bb's colour utilities read its palette variables; a test sets the ones it needs. */
+@theme inline {
+  --color-sidebar: var(--sidebar);
+  --color-foreground: var(--foreground);
+  --color-muted-foreground: var(--muted-foreground);
+}

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

@@ -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. */
@@ -131,6 +137,7 @@ 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 ?? {},
@@ -138,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,
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gperezmz/bb-plugin-thread-glance",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "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

@@ -56,7 +56,7 @@ and `bb environment list`; a thread id is a `thr_…` id.
 | `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