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

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

@@ -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.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

@@ -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