@gperezmz/bb-plugin-thread-glance 0.1.2

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

@@ -0,0 +1,101 @@
+// 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, Row } from "./view";
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+function sameSet(previous: ReadonlySet<unknown>, next: ReadonlySet<unknown>): boolean {
+  if (previous.size !== next.size) return false;
+  for (const value of next) if (!previous.has(value)) return false;
+  return true;
+}
+
+/**
+ * Returns `next` with every part that deep-equals the same part of
+ * `previous` replaced by the previous object; `previous` itself when the two
+ * are equal. Plain objects and arrays are compared by value, sets of
+ * primitives by membership, anything else by identity.
+ */
+export function share<T>(previous: T, next: T): T {
+  if (Object.is(previous, next)) return previous;
+  if (Array.isArray(previous) && Array.isArray(next)) {
+    let same = previous.length === next.length;
+    const result = next.map((value, index) => {
+      const shared = index < previous.length ? share(previous[index], value) : value;
+      if (shared !== previous[index]) same = false;
+      return shared;
+    });
+    return (same ? previous : result) as T;
+  }
+  if (previous instanceof Set && next instanceof Set) return (sameSet(previous, next) ? previous : next) as T;
+  if (isPlainObject(previous) && isPlainObject(next)) {
+    const keys = Object.keys(next);
+    let same = keys.length === Object.keys(previous).length;
+    const result: Record<string, unknown> = {};
+    for (const key of keys) {
+      if (!(key in previous)) same = false;
+      const shared = key in previous ? share(previous[key], next[key]) : next[key];
+      if (shared !== previous[key]) same = false;
+      result[key] = shared;
+    }
+    return (same ? previous : result) as T;
+  }
+  return next;
+}
+
+/** Rows matched by key, so an insertion doesn't renew every row after it. */
+function shareRows(previous: readonly Row[], next: Row[]): Row[] {
+  const byKey = new Map(previous.map((row) => [row.key, row]));
+  let same = previous.length === next.length;
+  const result = next.map((row, index) => {
+    const before = byKey.get(row.key);
+    const shared = before === undefined ? row : share(before, row);
+    if (shared !== previous[index]) same = false;
+    return shared;
+  });
+  return same ? (previous as Row[]) : result;
+}
+
+/** `next` with each field shared from `previous`; `previous` when every field is. */
+function shareFields<T extends object>(previous: T, next: T, shared: Partial<T>): T {
+  const result = { ...next } as Record<string, unknown>;
+  const before = previous as Record<string, unknown>;
+  let same = Object.keys(result).length === Object.keys(before).length;
+  for (const key of Object.keys(result)) {
+    if (!(key in before)) same = false;
+    result[key] = key in shared ? (shared as Record<string, unknown>)[key] : share(before[key], result[key]);
+    if (result[key] !== before[key]) same = false;
+  }
+  return same ? previous : (result as T);
+}
+
+function sameItems<T>(previous: readonly T[], next: readonly T[]): boolean {
+  return previous.length === next.length && next.every((item, index) => item === previous[index]);
+}
+
+function shareGroups(previousGroups: GroupView[], all: ReadonlyMap<string, GroupView>, next: GroupView[]): GroupView[] {
+  const result = next.map((group) => {
+    const before = all.get(group.descriptor.id);
+    if (before === undefined) return group;
+    return shareFields(before, group, { rows: shareRows(before.rows, group.rows) });
+  });
+  return sameItems(previousGroups, result) ? previousGroups : result;
+}
+
+/**
+ * `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
+ * object when its header and every row are unchanged.
+ */
+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, {
+    groups: shareGroups(previous.groups, all, next.groups),
+    more: shareGroups(previous.more, all, next.more),
+  });
+}

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

@@ -0,0 +1,78 @@
+// Sort order inside a group and in Pinned. Pure.
+import type { PluginSidebarThread } from "@get-bb/plugin-sdk/app";
+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;
+}
+
+function byCreated(a: SortKey, b: SortKey): number {
+  const diff = b.thread.createdAt - a.thread.createdAt;
+  if (diff !== 0) return diff;
+  return a.thread.id < b.thread.id ? -1 : a.thread.id > b.thread.id ? 1 : 0;
+}
+
+function byAlpha(a: SortKey, b: SortKey): number {
+  const diff = a.thread.displayTitle.localeCompare(b.thread.displayTitle);
+  if (diff !== 0) return diff;
+  return a.thread.id.localeCompare(b.thread.id);
+}
+
+function byUpdated(a: SortKey, b: SortKey): number {
+  const diff = b.familyAttention - a.familyAttention;
+  if (diff !== 0) return diff;
+  return byCreated(a, b);
+}
+
+/** `none` is bb's legacy value and reads as `updated`. */
+export function effectiveSortField(field: SortField): Exclude<SortField, "none"> {
+  return field === "none" ? "updated" : field;
+}
+
+/**
+ * The comparator for roots in a group. Direction follows bb: `default` keeps
+ * the field's natural direction (ascending for alpha, descending otherwise).
+ * Working first keeps active threads on top whatever the direction.
+ */
+export function makeComparator(options: SortOptions): (a: SortKey, b: SortKey) => number {
+  const field = effectiveSortField(options.field);
+  const natural = field === "alpha" ? "ascending" : "descending";
+  const sign = options.direction === "default" || options.direction === natural ? 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);
+  };
+}
+
+/** Pinned order: pinSortKey, then pinnedAt desc, createdAt desc, id. */
+export function comparePinned(a: PluginSidebarThread, b: PluginSidebarThread): number {
+  if (a.pinSortKey !== null && b.pinSortKey !== null && a.pinSortKey !== b.pinSortKey) {
+    return a.pinSortKey < b.pinSortKey ? -1 : 1;
+  }
+  const pinned = (b.pinnedAt ?? 0) - (a.pinnedAt ?? 0);
+  if (pinned !== 0) return pinned;
+  const created = b.createdAt - a.createdAt;
+  if (created !== 0) return created;
+  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+
+/** Children in Folded nesting: creation order. */
+export function compareCreationAscending(a: PluginSidebarThread, b: PluginSidebarThread): number {
+  const diff = a.createdAt - b.createdAt;
+  if (diff !== 0) return diff;
+  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}

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

@@ -0,0 +1,330 @@
+// Thread state model and unread rule. Pure functions over the
+// sidebar payload; no React.
+import type {
+  PluginSidebarThread,
+  PluginSidebarThreadRowStatus,
+} from "@get-bb/plugin-sdk/app";
+
+export type StateKind =
+  | "needs-you"
+  | "failed"
+  | "queue-failed"
+  | "offline"
+  | "working"
+  | "background"
+  | "scheduled"
+  | "queued"
+  | "unread"
+  | "draft"
+  | "idle";
+
+/** A rollup flag. Set independently of the first-match state. */
+export type Flag = "needs-you" | "unread-failed" | "queue-failed" | "offline" | "working" | "unread";
+
+/** Flags, most urgent first. */
+export const FLAG_ORDER: readonly Flag[] = [
+  "needs-you",
+  "unread-failed",
+  "queue-failed",
+  "offline",
+  "working",
+  "unread",
+];
+
+/**
+ * `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.
+ */
+export type Tone = "attention" | "destructive" | "working" | "background" | "muted" | "muted-strong" | "none";
+
+/** What a thread that needs you is waiting for, from its note. */
+export type NeedsKind = "question" | "approval" | "plan" | "input";
+
+const NEEDS: Record<NeedsKind, { icon: string; label: string }> = {
+  question: { icon: "CircleQuestion", label: "Asks a question" },
+  approval: { icon: "SecurityCheck", label: "Needs approval" },
+  plan: { icon: "ListTodo", label: "Plan to review" },
+  input: { icon: "MessageQuestion", label: "Needs your input" },
+};
+
+/** How a glyph is drawn. `dot` is the unread dot; everything else a host icon. */
+export interface Glyph {
+  icon: string | "dot" | null;
+  tone: Tone;
+  spin: boolean;
+  shine: boolean;
+}
+
+export interface ThreadState {
+  kind: StateKind;
+  label: string;
+  glyph: Glyph;
+  /** Earliest scheduled send time, for the `scheduled` tooltip. */
+  sendAt: number | null;
+}
+
+const KNOWN_STATUSES = new Set(["pending", "starting", "active", "stopping", "idle", "error"]);
+const WORKING_RUNTIME = new Set([
+  "provisioning",
+  "starting",
+  "active",
+  "stopping",
+  "host-reconnecting",
+]);
+const KNOWN_RUNTIME = new Set([...KNOWN_STATUSES, ...WORKING_RUNTIME, "waiting-for-host"]);
+
+/** `status`, with unknown values read as idle. */
+export function normalizeStatus(thread: Pick<PluginSidebarThread, "status">): string {
+  return KNOWN_STATUSES.has(thread.status) ? thread.status : "idle";
+}
+
+/** `runtimeStatus`, with unknown values read as the thread's status. */
+export function normalizeRuntime(
+  thread: Pick<PluginSidebarThread, "status" | "runtimeStatus">,
+): string {
+  return KNOWN_RUNTIME.has(thread.runtimeStatus) ? thread.runtimeStatus : normalizeStatus(thread);
+}
+
+/** `queuedWork`, with unknown values read as none. */
+export function normalizeQueued(
+  thread: Pick<PluginSidebarThread, "queuedWork">,
+): "none" | "waiting" | "failed" {
+  return thread.queuedWork === "waiting" || thread.queuedWork === "failed"
+    ? thread.queuedWork
+    : "none";
+}
+
+export function isWorking(thread: Pick<PluginSidebarThread, "status" | "runtimeStatus">): boolean {
+  return WORKING_RUNTIME.has(normalizeRuntime(thread));
+}
+
+export function isOffline(thread: Pick<PluginSidebarThread, "status" | "runtimeStatus">): boolean {
+  return normalizeRuntime(thread) === "waiting-for-host";
+}
+
+/** Per-thread facts the host payload doesn't carry. */
+export interface ThreadContext {
+  activeThreadId: string | null;
+  /** Stamps, from the plugin server. */
+  finishedAt: Readonly<Record<string, number>>;
+  seenAt: Readonly<Record<string, number>>;
+}
+
+/**
+ * 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).
+ */
+export function isUnread(thread: PluginSidebarThread, context: ThreadContext): boolean {
+  const status = normalizeStatus(thread);
+  const lastRead = thread.lastReadAt ?? 0;
+  if ((status === "idle" || status === "error") && lastRead < thread.latestAttentionAt) {
+    return true;
+  }
+  return isDoneUnseen(thread, context);
+}
+
+/** Done-unseen: a child that finished after you last read or viewed it. */
+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;
+  const finished = context.finishedAt[thread.id];
+  if (finished === undefined) return false;
+  return finished > Math.max(thread.lastReadAt ?? 0, context.seenAt[thread.id] ?? 0);
+}
+
+export interface StateInputs {
+  unread: boolean;
+  hasDraft: boolean;
+  /** Earliest future `sendAt` for this thread, or null. */
+  scheduledAt: number | null;
+  now: number;
+  /** What the pending interaction asks for, when the server saw it. */
+  needsKind?: NeedsKind | null;
+}
+
+const BACKGROUND: readonly [keyof PluginSidebarThread["activity"], string, string][] = [
+  ["planMode", "ListTodo", "Plan mode active"],
+  ["goals", "Target", "Goal active"],
+  ["workflows", "Workflow", "Workflow running"],
+  ["backgroundAgents", "UserRoundPlus", "Background agent running"],
+  ["backgroundCommands", "Terminal", "Background command running"],
+];
+
+function glyph(icon: Glyph["icon"], tone: Tone, spin = false, shine = false): Glyph {
+  return { icon, tone, spin, shine };
+}
+
+function workingLabel(runtime: string): string {
+  switch (runtime) {
+    case "provisioning":
+      return "Setting up";
+    case "host-reconnecting":
+      return "Reconnecting";
+    case "stopping":
+      return "Stopping";
+    default:
+      return "Working";
+  }
+}
+
+/** First match wins. */
+export function computeState(thread: PluginSidebarThread, inputs: StateInputs): ThreadState {
+  const status = normalizeStatus(thread);
+  const runtime = normalizeRuntime(thread);
+  const queued = normalizeQueued(thread);
+  const none = { sendAt: null };
+  if (thread.hasPendingInteraction) {
+    const needs = NEEDS[inputs.needsKind ?? "input"] ?? NEEDS.input;
+    const icon = inputs.needsKind ? needs.icon : "CircleQuestion";
+    return { kind: "needs-you", label: needs.label, glyph: glyph(icon, "attention"), ...none };
+  }
+  if (status === "error") {
+    return {
+      kind: "failed",
+      label: "Failed",
+      glyph: glyph("CircleX", "destructive"),
+      ...none,
+    };
+  }
+  if (queued === "failed") {
+    return {
+      kind: "queue-failed",
+      label: "Queued message failed to send",
+      glyph: glyph("AlertTriangle", "destructive"),
+      ...none,
+    };
+  }
+  if (runtime === "waiting-for-host") {
+    return { kind: "offline", label: "Machine offline", glyph: glyph("CloudOff", "attention"), ...none };
+  }
+  if (WORKING_RUNTIME.has(runtime)) {
+    const label = workingLabel(runtime);
+    if (inputs.hasDraft) {
+      return { kind: "working", label: `${label}, unsubmitted draft`, glyph: glyph("Edit", "working", false, true), ...none };
+    }
+    if (thread.activity.planMode > 0) {
+      return { kind: "working", label: `${label}, plan mode`, glyph: glyph("ListTodo", "working", false, true), ...none };
+    }
+    if (thread.activity.goals > 0) {
+      return { kind: "working", label: `${label}, goal active`, glyph: glyph("Target", "working", false, true), ...none };
+    }
+    return { kind: "working", label, glyph: glyph("Loading", "working", true), ...none };
+  }
+  for (const [field, icon, label] of BACKGROUND) {
+    if (thread.activity[field] > 0) {
+      return { kind: "background", label, glyph: glyph(icon, "background", false, true), ...none };
+    }
+  }
+  if (queued === "waiting") {
+    if (inputs.scheduledAt !== null && inputs.scheduledAt > inputs.now) {
+      return {
+        kind: "scheduled",
+        label: "Scheduled message",
+        glyph: glyph("Calendar", "muted-strong"),
+        sendAt: inputs.scheduledAt,
+      };
+    }
+    return { kind: "queued", label: "Message waiting to send", glyph: glyph("Clock", "muted-strong"), ...none };
+  }
+  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(null, "none"), ...none };
+}
+
+/**
+ * A plugin row status replaces the glyph for every state except
+ * needs-you, failed, and working with its plain spinner (the rule bb's list uses).
+ */
+export function pluginStatusWins(
+  state: ThreadState,
+  rowStatus: PluginSidebarThreadRowStatus | null,
+): boolean {
+  if (rowStatus === null) return false;
+  if (state.kind === "needs-you" || state.kind === "failed") return false;
+  if (state.kind === "working" && state.glyph.spin) return false;
+  return true;
+}
+
+/** The rollup flags a single thread carries. */
+export function threadFlags(thread: PluginSidebarThread, unread: boolean): Set<Flag> {
+  const flags = new Set<Flag>();
+  if (thread.hasPendingInteraction) flags.add("needs-you");
+  if (normalizeStatus(thread) === "error" && unread) flags.add("unread-failed");
+  if (normalizeQueued(thread) === "failed") flags.add("queue-failed");
+  if (isOffline(thread)) flags.add("offline");
+  if (isWorking(thread)) flags.add("working");
+  if (unread) flags.add("unread");
+  return flags;
+}
+
+/** Flags hidden threads contribute: needs-you and unread-failed only. */
+export function hiddenThreadFlags(flags: ReadonlySet<Flag>): Set<Flag> {
+  const kept = new Set<Flag>();
+  if (flags.has("needs-you")) kept.add("needs-you");
+  if (flags.has("unread-failed")) kept.add("unread-failed");
+  return kept;
+}
+
+/** The most urgent flag, or null. */
+export function mostUrgent(flags: ReadonlySet<Flag>): Flag | null {
+  return FLAG_ORDER.find((flag) => flags.has(flag)) ?? null;
+}
+
+/** The colour a child chip takes: only what asks for you, fails, or works. */
+export type ChipTone = "attention" | "destructive" | "working" | "neutral";
+
+/** The tone of a chip whose most urgent rolled-up flag is `flag`. */
+export function chipTone(flag: Flag | null): ChipTone {
+  switch (flag) {
+    case "needs-you":
+      return "attention";
+    case "unread-failed":
+    case "queue-failed":
+      return "destructive";
+    case "working":
+      return "working";
+    default:
+      return "neutral";
+  }
+}
+
+export const FLAG_GLYPHS: Readonly<Record<Flag, Glyph & { label: string }>> = {
+  "needs-you": { ...glyph("CircleQuestion", "attention"), label: "needs your input" },
+  "unread-failed": { ...glyph("CircleX", "destructive"), label: "failed" },
+  "queue-failed": { ...glyph("AlertTriangle", "destructive"), label: "queued message failed" },
+  offline: { ...glyph("CloudOff", "attention"), label: "machine offline" },
+  working: { ...glyph("Loading", "working", true), label: "working" },
+  unread: { ...glyph("dot", "none"), label: "unread" },
+};
+
+/** A thread is quiet when idle, a draft, or failed and read, and read. */
+export function isQuietThread(
+  state: ThreadState,
+  unread: boolean,
+  isActive: boolean,
+): boolean {
+  if (unread || isActive) return false;
+  return state.kind === "idle" || state.kind === "draft" || state.kind === "failed";
+}
+
+/** Every host icon name this module can draw. */
+export const STATE_ICON_NAMES: readonly string[] = [
+  "CircleQuestion",
+  "CircleX",
+  "AlertTriangle",
+  "CloudOff",
+  "Loading",
+  "Edit",
+  "ListTodo",
+  "Target",
+  "Workflow",
+  "UserRoundPlus",
+  "Terminal",
+  "Calendar",
+  "Clock",
+  "SecurityCheck",
+  "MessageQuestion",
+];

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

@@ -0,0 +1,107 @@
+// Row age and working timer. Pure.
+import type { PluginSidebarThread } from "@get-bb/plugin-sdk/app";
+
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const WEEK = 7 * DAY;
+
+/** `now`, `5m`, `3h`, `2d` or `4w`. */
+export function formatDuration(ms: number): string {
+  const elapsed = Math.max(0, ms);
+  if (elapsed < MINUTE) return "now";
+  if (elapsed < HOUR) return `${Math.floor(elapsed / MINUTE)}m`;
+  if (elapsed < DAY) return `${Math.floor(elapsed / HOUR)}h`;
+  if (elapsed < WEEK) return `${Math.floor(elapsed / DAY)}d`;
+  return `${Math.floor(elapsed / WEEK)}w`;
+}
+
+/** When the thread last finished: max(latestAttentionAt, finishedAt ?? createdAt). */
+export function lastFinishedAt(
+  thread: Pick<PluginSidebarThread, "id" | "latestAttentionAt" | "createdAt">,
+  finishedAt: Readonly<Record<string, number>>,
+): number {
+  return Math.max(thread.latestAttentionAt, finishedAt[thread.id] ?? thread.createdAt);
+}
+
+export interface TrailingTime {
+  text: string;
+  label: string;
+  /** A working timer is drawn in the working tone, a wait and an age muted. */
+  kind: "timer" | "waiting" | "age";
+}
+
+/**
+ * The trailing slot: time since start for a working row, else the age
+ *. A working row whose start wasn't stamped shows nothing.
+ */
+export function trailingTime(
+  thread: Pick<PluginSidebarThread, "id" | "latestAttentionAt" | "createdAt">,
+  working: boolean,
+  stamps: { startedAt: Readonly<Record<string, number>>; finishedAt: Readonly<Record<string, number>> },
+  now: number,
+  /**
+   * When the thread started waiting on you, if it is: bb reports such a
+   * thread as active, but it isn't working, so it gets no working timer.
+   */
+  waitingSince?: number | null,
+): TrailingTime | null {
+  if (waitingSince !== undefined) {
+    if (waitingSince === null) return null;
+    const elapsed = formatDuration(now - waitingSince);
+    const text = elapsed === "now" ? "<1m" : elapsed;
+    return { text, label: `Waiting on you for ${text === "<1m" ? "less than a minute" : text}`, kind: "waiting" };
+  }
+  if (working) {
+    const started = stamps.startedAt[thread.id];
+    if (started === undefined) return null;
+    const elapsed = formatDuration(now - started);
+    // "now" would read like "finished now"; a timer says "<1m".
+    const text = elapsed === "now" ? "<1m" : elapsed;
+    return { text, label: `Working for ${text === "<1m" ? "less than a minute" : text}`, kind: "timer" };
+  }
+  const text = formatDuration(now - lastFinishedAt(thread, stamps.finishedAt));
+  return { text, label: text === "now" ? "Finished just now" : `Finished ${text} ago`, kind: "age" };
+}
+
+/**
+ * When the thread last finished, or null while it never has: it is working,
+ * waiting for you, or has no finish on record.
+ */
+export function finishedAtFor(
+  thread: Pick<PluginSidebarThread, "id" | "status" | "latestAttentionAt" | "hasPendingInteraction" | "parentThreadId" | "createdAt">,
+  finishedAt: Readonly<Record<string, number>>,
+): number | null {
+  if (thread.status !== "idle" && thread.status !== "error") return null;
+  if (thread.hasPendingInteraction) return null;
+  const stamped = finishedAt[thread.id];
+  if (stamped !== undefined) return Math.max(stamped, thread.latestAttentionAt);
+  // bb bumps a root's attention when it finishes; a child's only on failure.
+  if (thread.latestAttentionAt > thread.createdAt && (thread.parentThreadId === null || thread.status === "error")) {
+    return thread.latestAttentionAt;
+  }
+  return null;
+}
+
+/** "since 5m" for the hover card, or null when the state has no stamp. */
+export function stateSince(
+  kind: string,
+  threadId: string,
+  stamps: {
+    startedAt: Readonly<Record<string, number>>;
+    finishedAt: Readonly<Record<string, number>>;
+    pendingAt: Readonly<Record<string, number>>;
+  },
+  now: number,
+): string | null {
+  const at =
+    kind === "working"
+      ? stamps.startedAt[threadId]
+      : kind === "needs-you"
+        ? stamps.pendingAt[threadId]
+        : kind === "idle" || kind === "unread" || kind === "failed"
+          ? stamps.finishedAt[threadId]
+          : undefined;
+  if (at === undefined) return null;
+  return formatDuration(now - at);
+}