@gperezmz/bb-plugin-thread-glance 0.1.2

package/server/startup.ts

@@ -0,0 +1,121 @@
+// Work done once per server start, in a background service because `bb.sdk`
+// is bind-gated in the factory.
+import type { BbPluginApi } from "@get-bb/plugin-sdk";
+import type { ScheduledTracker } from "./scheduled";
+
+const THREAD_PAGE_SIZE = 500;
+const SEED_RETRY_MS = 60_000;
+
+type Sdk = BbPluginApi["sdk"];
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Returns the id of every thread bb has, archived and hidden ones included.
+ *
+ * It lists active and archived threads separately and pages each with
+ * limit and offset, since the list is capped per call.
+ */
+export async function listAllThreadIds(sdk: Sdk, signal?: AbortSignal): Promise<Set<string>> {
+  const ids = new Set<string>();
+  for (const archived of [false, true]) {
+    for (let offset = 0; ; offset += THREAD_PAGE_SIZE) {
+      const page = await sdk.threads.list({
+        archived,
+        includeHidden: true,
+        limit: THREAD_PAGE_SIZE,
+        offset,
+        signal,
+      });
+      for (const thread of page) ids.add(thread.id);
+      if (page.length < THREAD_PAGE_SIZE) break;
+    }
+  }
+  return ids;
+}
+
+/** A per-thread store, such as stamps or notes, that startup prunes. */
+export interface PrunableStore {
+  /** What the store holds, for the log line. */
+  name: string;
+  prune(liveIds: ReadonlySet<string>, before: number): Promise<string[]>;
+}
+
+/** Drops per-thread rows of threads bb no longer has. Logs and returns on failure. */
+export async function pruneDeletedThreads(
+  bb: Pick<BbPluginApi, "sdk" | "log">,
+  stores: readonly PrunableStore[],
+  signal?: AbortSignal,
+): Promise<void> {
+  const before = Date.now();
+  let live: Set<string>;
+  try {
+    live = await listAllThreadIds(bb.sdk, signal);
+  } catch (error) {
+    bb.log.warn(`could not list threads to prune deleted ones: ${errorMessage(error)}`);
+    return;
+  }
+  for (const store of stores) {
+    const pruned = await store.prune(live, before);
+    if (pruned.length > 0) {
+      bb.log.info(`pruned ${store.name} of ${pruned.length} deleted threads`);
+    }
+  }
+}
+
+/** Seeds the scheduled-send tracker from every queued row in bb. */
+export function seedScheduled(
+  bb: Pick<BbPluginApi, "sdk" | "log">,
+  tracker: ScheduledTracker,
+  signal?: AbortSignal,
+): Promise<boolean> {
+  return tracker.seed(async () => {
+    try {
+      return await bb.sdk.threads.queue.list({ signal });
+    } catch (error) {
+      bb.log.warn(`could not list queued messages: ${errorMessage(error)}`);
+      throw error;
+    }
+  });
+}
+
+function sleep(ms: number, signal: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, ms);
+    function done(): void {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve();
+    }
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+
+function waitForAbort(signal: AbortSignal): Promise<void> {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
+}
+
+/**
+ * The `startup` service: seeds scheduled sends, retrying every minute until
+ * one seed succeeds, prunes `stores` once, then waits for `signal` to abort.
+ */
+export async function runStartup(
+  bb: Pick<BbPluginApi, "sdk" | "log">,
+  stores: readonly PrunableStore[],
+  tracker: ScheduledTracker,
+  signal: AbortSignal,
+  retryMs = SEED_RETRY_MS,
+): Promise<void> {
+  const seeded = seedScheduled(bb, tracker, signal);
+  await pruneDeletedThreads(bb, stores, signal);
+  let ok = await seeded;
+  while (!ok && !signal.aborted) {
+    await sleep(retryMs, signal);
+    if (signal.aborted) break;
+    ok = await seedScheduled(bb, tracker, signal);
+  }
+  await waitForAbort(signal);
+}

package/server.ts

@@ -0,0 +1,126 @@
+// Thread Glance server: preferences, first-run import, thread stamps, thread
+// notes and scheduled sends. The app imports the contract's types from shared/contract.ts.
+import type { BbPluginApi } from "@get-bb/plugin-sdk";
+import { CHANNELS, rpcContract } from "./shared/contract";
+import { createCli } from "./server/cli";
+import { resolveFailureText } from "./server/failures";
+import { createBbCliReader, importPreferences } from "./server/import";
+import {
+  createNoteStore,
+  describeDone,
+  describeFailure,
+  describeInteraction,
+  type NoteDraft,
+} from "./server/notes";
+import { createPreferenceStore } from "./server/preference-store";
+import { createScheduledTracker } from "./server/scheduled";
+import { createSerialQueue } from "./server/serial";
+import { createStampStore } from "./server/stamps";
+import { runStartup } from "./server/startup";
+
+export default function threadGlance(bb: BbPluginApi): void {
+  const preferences = createPreferenceStore(bb);
+  const stamps = createStampStore(bb);
+  const notes = createNoteStore(bb);
+  const scheduled = createScheduledTracker({
+    publish: (signal) => bb.realtime.publish(CHANNELS.scheduled, signal),
+  });
+  const readBbCli = createBbCliReader(bb.log);
+  const importOnce = createSerialQueue();
+
+  bb.rpc.register(rpcContract, {
+    async listPreferences() {
+      return { preferences: await preferences.readAll() };
+    },
+    async setPreference({ key, value }) {
+      return { key, value: await preferences.write(key, value) };
+    },
+    async resetPreference({ key }) {
+      return { key, value: await preferences.reset(key) };
+    },
+    importPreferences({ bbMirror }) {
+      return importOnce(() =>
+        importPreferences({ kv: bb.storage.kv, log: bb.log, store: preferences, readBbCli }, bbMirror),
+      );
+    },
+    async listStamps() {
+      return { stamps: await stamps.list() };
+    },
+    async markSeen({ threadIds }) {
+      const at = Date.now();
+      await stamps.stamp("seenAt", threadIds, at);
+      return { at };
+    },
+    async clearSeen({ threadIds }) {
+      await stamps.clear("seenAt", threadIds);
+      return { ok: true as const };
+    },
+    async listNotes() {
+      return { notes: await notes.list() };
+    },
+    listScheduled() {
+      return scheduled.snapshot();
+    },
+  });
+
+  bb.cli.register(createCli(preferences));
+
+  const note = (draft: NoteDraft, at = Date.now()) => ({ ...draft, at });
+
+  bb.events.on("thread.active", async ({ thread }) => {
+    await stamps.stamp("startedAt", [thread.id], Date.now());
+    await notes.update(thread.id, { pending: null, failed: null });
+  });
+  bb.events.on("thread.idle", async ({ thread, lastAssistantText }) => {
+    await stamps.stamp("finishedAt", [thread.id], Date.now());
+    const done = describeDone(lastAssistantText);
+    await notes.update(thread.id, { pending: null, ...(done ? { done: note(done) } : {}) });
+  });
+  bb.events.on("thread.failed", async ({ thread, error }) => {
+    await stamps.stamp("finishedAt", [thread.id], Date.now());
+    const text = await resolveFailureText(bb, {
+      threadId: thread.id,
+      error,
+      errorInfo: null,
+      turnId: null,
+    });
+    // thread.active clears the failed note, so one that is already here
+    // belongs to this failure: turn.failed wrote it first.
+    if (text === null && (await notes.get(thread.id))?.failed) return;
+    await notes.update(thread.id, { failed: note(describeFailure(text)) });
+  });
+  // turn.failed carries errorInfo and the turn id. It writes only text that
+  // says more than "Failed", in whichever order the two events arrive.
+  bb.events.on("turn.failed", async ({ threadId, errorInfo, turnId }) => {
+    const text = await resolveFailureText(bb, { threadId, error: null, errorInfo, turnId });
+    if (text !== null) await notes.update(threadId, { failed: note(describeFailure(text)) });
+  });
+  bb.events.on("interaction.pending", async ({ thread, interaction }) => {
+    await stamps.stamp("pendingAt", [thread.id], Date.now());
+    await notes.update(thread.id, {
+      pending: note(describeInteraction(interaction), interaction.createdAt),
+    });
+  });
+  bb.events.on("thread.deleted", async ({ thread }) => {
+    scheduled.threadGone(thread.id);
+    await stamps.forget([thread.id]);
+    await notes.forget([thread.id]);
+  });
+  bb.events.on("thread.archived", ({ thread }) => scheduled.threadGone(thread.id));
+  bb.events.on("message.queued", ({ entry }) => scheduled.queued(entry));
+  bb.events.on("message.dispatched", ({ entry }) => scheduled.removed(entry.id));
+  bb.events.on("message.cancelled", ({ entry }) => scheduled.removed(entry.id));
+
+  bb.background.service("startup", {
+    start: (signal) =>
+      runStartup(
+        bb,
+        [
+          { name: "stamps", prune: stamps.prune },
+          { name: "notes", prune: notes.prune },
+        ],
+        scheduled,
+        signal,
+      ),
+  });
+}

package/shared/contract.ts

@@ -0,0 +1,73 @@
+// RPC contract between the app and the server. The app imports this module
+// for its types only; channel names and payload schemas live in signals.ts.
+import { defineRpcContract } from "@get-bb/plugin-sdk";
+import { z } from "zod";
+import { PREFERENCE_KEYS, PREFERENCES, type PreferenceKey } from "./preferences";
+import { stampsSchema, threadNotesSchema } from "./signals";
+
+export * from "./signals";
+
+const preferenceKeySchema = z.enum(PREFERENCE_KEYS as [PreferenceKey, ...PreferenceKey[]]);
+const preferencesSchema = z.object(
+  Object.fromEntries(PREFERENCE_KEYS.map((key) => [key, PREFERENCES[key].schema])),
+);
+const stampMapSchema = z.record(z.string(), z.number());
+const threadIdsSchema = z.array(z.string().min(1).max(1024)).max(10_000);
+
+export const rpcContract = defineRpcContract({
+  listPreferences: {
+    input: z.null(),
+    output: z.object({ preferences: preferencesSchema }).strict(),
+  },
+  setPreference: {
+    input: z.object({ key: preferenceKeySchema, value: z.unknown() }).strict(),
+    output: z.object({ key: preferenceKeySchema, value: z.unknown() }).strict(),
+  },
+  resetPreference: {
+    input: z.object({ key: preferenceKeySchema }).strict(),
+    output: z.object({ key: preferenceKeySchema, value: z.unknown() }).strict(),
+  },
+  /**
+   * First-run import. `bbMirror` is the parsed value of bb's own
+   * localStorage mirror, or null when the app found none; the server then
+   * tries `bb thread-list prefs list --json`. Runs at most once.
+   */
+  importPreferences: {
+    input: z.object({ bbMirror: z.unknown().nullable() }).strict(),
+    output: z
+      .object({
+        status: z.enum(["already-imported", "imported", "defaults"]),
+        source: z.enum(["local-storage", "cli", "none"]).nullable(),
+        keys: z.array(preferenceKeySchema),
+      })
+      .strict(),
+  },
+  listStamps: {
+    input: z.null(),
+    output: z.object({ stamps: stampsSchema }).strict(),
+  },
+  /** Records `seenAt` for child threads the user viewed. */
+  markSeen: {
+    input: z.object({ threadIds: threadIdsSchema }).strict(),
+    output: z.object({ at: z.number() }).strict(),
+  },
+  /** Deletes `seenAt`, so Mark unread shows a finished child as unread. */
+  clearSeen: {
+    input: z.object({ threadIds: threadIdsSchema }).strict(),
+    output: z.object({ ok: z.literal(true) }).strict(),
+  },
+  /** Notes per thread id (see `noteSchema`). */
+  listNotes: {
+    input: z.null(),
+    output: z.object({ notes: z.record(z.string(), threadNotesSchema) }).strict(),
+  },
+  /** Earliest future `sendAt` per thread (scheduled sends). */
+  listScheduled: {
+    input: z.null(),
+    output: z
+      .object({ status: z.enum(["ready", "error"]), scheduled: stampMapSchema })
+      .strict(),
+  },
+});
+
+export type RpcContract = typeof rpcContract;

package/shared/preferences.ts

@@ -0,0 +1,241 @@
+// Preference schema shared by the server (kv storage, RPC, CLI) and the app
+// (localStorage mirror, first paint). Keys and defaults: docs/reference/thread-glance-preferences.md.
+import { z } from "zod";
+
+const MAX_ITEMS = 10_000;
+const idSchema = z.string().min(1).max(1024);
+const idListSchema = z.array(idSchema).max(MAX_ITEMS);
+
+export const organizationModeSchema = z.enum(["project", "chronological", "machine"]);
+export const sortFieldSchema = z.enum(["updated", "created", "alpha", "none"]);
+export const sortDirectionSchema = z.enum(["default", "ascending", "descending"]);
+export const nestingSchema = z.enum(["folded", "tree"]);
+export const lifecycleSchema = z.enum(["active", "archived"]);
+export const harnessIconSchema = z.enum(["muted", "colour", "hidden"]);
+export const childAttentionSchema = z.enum(["blocked", "everything"]);
+
+const hiddenGroupsSchema = z
+  .array(z.union([z.literal("threads"), idSchema.regex(/^(project|section|machine):\S+$/)]))
+  .max(MAX_ITEMS)
+  .transform((groups) => [...new Set(groups)]);
+
+export type OrganizationMode = z.infer<typeof organizationModeSchema>;
+export type SortField = z.infer<typeof sortFieldSchema>;
+export type SortDirection = z.infer<typeof sortDirectionSchema>;
+export type Nesting = z.infer<typeof nestingSchema>;
+export type Lifecycle = z.infer<typeof lifecycleSchema>;
+export type HarnessIcon = z.infer<typeof harnessIconSchema>;
+export type ChildAttention = z.infer<typeof childAttentionSchema>;
+
+interface PreferenceDefinition<T> {
+  schema: z.ZodType<T, unknown>;
+  defaultValue: T;
+  description: string;
+}
+
+function define<T>(
+  schema: z.ZodType<T, unknown>,
+  defaultValue: T,
+  description: string,
+): PreferenceDefinition<T> {
+  return { schema, defaultValue, description };
+}
+
+/** Server-side preferences, shared across windows and devices. */
+export const PREFERENCES = {
+  threadLifecycles: define(
+    z
+      .array(lifecycleSchema)
+      .min(1)
+      .max(2)
+      .refine((values) => new Set(values).size === values.length, "Lifecycles must be unique"),
+    ["active"] as Lifecycle[],
+    "Thread lifecycles shown: active, archived, or both. At least one is required.",
+  ),
+  organizationMode: define(
+    organizationModeSchema,
+    "project" as OrganizationMode,
+    "How top-level groups are formed: project, chronological (custom sections) or machine.",
+  ),
+  environmentGrouping: define(
+    z.boolean(),
+    false,
+    "Whether sibling threads sharing a worktree environment fold into a folder row.",
+  ),
+  chronologicalSort: define(
+    sortFieldSchema,
+    "updated" as SortField,
+    "Sort field inside a group: updated, created or alpha. none is read as updated.",
+  ),
+  sortDirection: define(
+    sortDirectionSchema,
+    "default" as SortDirection,
+    "Sort direction; default keeps the field's natural direction.",
+  ),
+  sectionOrder: define(
+    idListSchema,
+    ["pinned", "projects", "threads"],
+    "Top-level group order when organized by project.",
+  ),
+  manualSectionOrder: define(
+    idListSchema,
+    ["pinned", "sections", "threads"],
+    "Top-level group order when organized chronologically.",
+  ),
+  machineSectionOrder: define(
+    idListSchema,
+    ["pinned", "machines", "threads"],
+    "Top-level group order when organized by machine.",
+  ),
+  hiddenGroups: define(
+    hiddenGroupsSchema,
+    [] as string[],
+    "Groups moved into More: threads, project:<id>, section:<id> or machine:<id>.",
+  ),
+  collapsedSections: define(
+    z.array(z.enum(["pinned", "threads"])).max(MAX_ITEMS),
+    [] as ("pinned" | "threads")[],
+    "Built-in groups (pinned, threads) that are collapsed.",
+  ),
+  collapsedProjects: define(idListSchema, [] as string[], "Project ids whose group is collapsed."),
+  collapsedThreadSections: define(
+    idListSchema,
+    [] as string[],
+    "Custom section keys (section:<id>) whose group is collapsed.",
+  ),
+  collapsedMachines: define(idListSchema, [] as string[], "Machine ids whose group is collapsed."),
+  collapsedEnvironments: define(
+    idListSchema,
+    [] as string[],
+    "Environment ids whose folder row is collapsed.",
+  ),
+  nesting: define(
+    nestingSchema,
+    "folded" as Nesting,
+    "Child thread nesting: folded (one flat level behind a chip) or tree (bb's tree).",
+  ),
+  foldOlder: define(
+    z.boolean(),
+    true,
+    "Whether quiet roots past the 5 most recent fold behind an N older row.",
+  ),
+  workingFirst: define(
+    z.boolean(),
+    false,
+    "Whether working threads sort first under Updated, as bb's list does.",
+  ),
+  expandedOlder: define(
+    idListSchema,
+    [] as string[],
+    "Group ids and parent thread ids whose N older fold the user opened.",
+  ),
+  expandedChildren: define(
+    idListSchema,
+    [] as string[],
+    "Parent thread ids the user expanded (folded nesting).",
+  ),
+  collapsedChildren: define(
+    idListSchema,
+    [] as string[],
+    "Parent thread ids the user collapsed (tree nesting).",
+  ),
+  showPullRequests: define(z.boolean(), true, "Whether rows show a pull request badge."),
+  childAttention: define(
+    childAttentionSchema,
+    "blocked" as ChildAttention,
+    "Which child threads count under Needs attention, in badges and counters, and stay out of a family's fold along with running children: blocked (waiting on you, offline, or an orphaned failure) or everything (also every failed and unread child).",
+  ),
+  harnessIcon: define(
+    harnessIconSchema,
+    "muted" as HarnessIcon,
+    "How rows draw the harness logo: muted (monochrome), colour (the provider's tint) or hidden.",
+  ),
+} as const;
+
+export type PreferenceKey = keyof typeof PREFERENCES;
+export type Preferences = {
+  -readonly [K in PreferenceKey]: (typeof PREFERENCES)[K]["defaultValue"];
+};
+
+export const PREFERENCE_KEYS = Object.keys(PREFERENCES) as PreferenceKey[];
+
+export function isPreferenceKey(key: string): key is PreferenceKey {
+  return Object.hasOwn(PREFERENCES, key);
+}
+
+export function preferenceDefault<K extends PreferenceKey>(key: K): Preferences[K] {
+  return structuredClone(PREFERENCES[key].defaultValue) as Preferences[K];
+}
+
+export function defaultPreferences(): Preferences {
+  return Object.fromEntries(
+    PREFERENCE_KEYS.map((key) => [key, preferenceDefault(key)]),
+  ) as Preferences;
+}
+
+export function describePreference(key: PreferenceKey): string {
+  return PREFERENCES[key].description;
+}
+
+export type ParseResult<T> = { success: true; value: T } | { success: false; message: string };
+
+export function parsePreference<K extends PreferenceKey>(
+  key: K,
+  value: unknown,
+): ParseResult<Preferences[K]> {
+  const result = PREFERENCES[key].schema.safeParse(value);
+  if (result.success) return { success: true, value: result.data as Preferences[K] };
+  return { success: false, message: result.error.issues.map((issue) => issue.message).join("; ") };
+}
+
+/**
+ * Reads a whole preference object, falling back to the default for each key
+ * that is missing or invalid. Used for the localStorage mirror.
+ */
+export function coercePreferences(raw: unknown): Preferences {
+  const result = defaultPreferences();
+  if (raw === null || typeof raw !== "object") return result;
+  const record = raw as Record<string, unknown>;
+  for (const key of PREFERENCE_KEYS) {
+    if (!(key in record)) continue;
+    const parsed = parsePreference(key, record[key]);
+    if (parsed.success) (result as Record<string, unknown>)[key] = parsed.value;
+  }
+  return result;
+}
+
+/**
+ * Maps bb's own thread-list preferences onto ours for the first-run import
+ *. `environmentGrouping: "auto"` becomes off, `collapsedThreads` is
+ * skipped because it means the inverse of folded nesting, and invalid values
+ * are skipped. Returns only the keys that parsed.
+ */
+export function mapBbPreferences(raw: unknown): Partial<Preferences> {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const source = raw as Record<string, unknown>;
+  const mapped: Partial<Record<PreferenceKey, unknown>> = {};
+  for (const [bbKey, value] of Object.entries(source)) {
+    if (bbKey === "collapsedThreads") continue;
+    if (!isPreferenceKey(bbKey)) continue;
+    const candidate = bbKey === "environmentGrouping" && value === "auto" ? false : value;
+    const parsed = parsePreference(bbKey, candidate);
+    if (parsed.success) mapped[bbKey] = parsed.value;
+  }
+  return mapped as Partial<Preferences>;
+}
+
+/** Per-client preferences, kept in localStorage only. */
+export const clientPreferencesSchema = z.object({
+  filter: z.enum(["all", "attention"]).catch("all"),
+  density: z.enum(["compact", "comfortable"]).catch("compact"),
+});
+export type ClientPreferences = z.infer<typeof clientPreferencesSchema>;
+
+export const CLIENT_PREFERENCES_STORAGE_KEY = "bb.thread-glance.client.v1";
+export const PREFERENCES_MIRROR_STORAGE_KEY = "bb.thread-glance.preferences.v1";
+export const BB_PREFERENCES_MIRROR_STORAGE_KEY = "bb.thread-list.preferences.v1";
+
+export function parseClientPreferences(raw: unknown): ClientPreferences {
+  const result = clientPreferencesSchema.safeParse(raw ?? {});
+  return result.success ? result.data : { filter: "all", density: "compact" };
+}

package/shared/signals.ts

@@ -0,0 +1,71 @@
+// Realtime channels, their payloads and the schemas the app validates them
+// with. Nothing here imports the SDK, so the app bundle can use its values.
+import { z } from "zod";
+import type { PreferenceKey } from "./preferences";
+
+const stampMapSchema = z.record(z.string(), z.number());
+
+/** Per-thread timestamps (epoch ms) kept by the server. */
+export const stampsSchema = z.object({
+  startedAt: stampMapSchema,
+  finishedAt: stampMapSchema,
+  pendingAt: stampMapSchema,
+  seenAt: stampMapSchema,
+});
+export type Stamps = z.infer<typeof stampsSchema>;
+export type StampKind = keyof Stamps;
+
+/**
+ * Why a thread is blocked, failed or done, in one line: what the server saw
+ * on `interaction.pending`, `thread.failed` and `thread.idle`. Text is whitespace-collapsed and at most NOTE_MAX_LENGTH.
+ */
+export const NOTE_MAX_LENGTH = 140;
+export const noteSchema = z.object({
+  /** question: asks the user; approval: a command, file or permission; plan: plan review; input: other requests. */
+  kind: z.enum(["question", "approval", "plan", "input", "failed", "done"]),
+  text: z.string().max(NOTE_MAX_LENGTH),
+  at: z.number(),
+});
+export type Note = z.infer<typeof noteSchema>;
+export const threadNotesSchema = z.object({
+  /** The latest pending interaction. */
+  pending: noteSchema.optional(),
+  /** The latest failure. */
+  failed: noteSchema.optional(),
+  /** The last assistant text when the thread went idle. */
+  done: noteSchema.optional(),
+});
+export type ThreadNotes = z.infer<typeof threadNotesSchema>;
+
+/** Realtime channels the server publishes on. */
+export const CHANNELS = {
+  preferences: "preferences",
+  stamps: "stamps",
+  scheduled: "scheduled",
+  notes: "notes",
+} as const;
+
+/** `notes` payload: one thread's notes replaced; null deletes them. */
+export interface NotesSignal {
+  threadId: string;
+  notes: ThreadNotes | null;
+}
+
+/** `preferences` payload: one key changed. */
+export interface PreferenceSignal {
+  key: PreferenceKey;
+  value: unknown;
+}
+
+/** `stamps` payload: one thread's stamp changed; null deletes it. */
+export interface StampSignal {
+  kind: StampKind;
+  threadIds: string[];
+  value: number | null;
+}
+
+/** `scheduled` payload: the whole map, replaced. */
+export interface ScheduledSignal {
+  status: "ready" | "error";
+  scheduled: Record<string, number>;
+}