@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/tui/task-store.ts

@@ -1,432 +0,0 @@
-import { hasText, errorText } from "./text-values.ts";
-import { listOwnedRunQuestions } from "../runs/shared/supervisor-questions.ts";
-import { ownedRunView } from "../runs/shared/run-records.ts";
-import { restoredView } from "./view-persistence.ts";
-import type { AgentHistory } from "./history-display.ts";
-import type {
-  SubagentState,
-  OwnedRun,
-  OwnedRunView,
-  HistoryRunRow,
-  HistoryPageInput,
-  HistoryPage,
-  SupervisorQuestionView,
-} from "../shared/types.ts";
-import {
-  UNAVAILABLE_ASSIGNMENT,
-  PENDING_MESSAGE_NOTICE,
-  agentModel,
-  unavailableModel,
-  type AgentTask,
-  type AgentVisit,
-} from "./view-model.ts";
-import {
-  selectedChild,
-  observedTask,
-  observedLabel,
-  cachedHistory,
-  observedConfiguration,
-  activityUnread,
-  observationFlags,
-  observedQuestion,
-} from "./task-observation.ts";
-type Identity = Pick<
-  OwnedRunView["children"][number],
-  "index" | "workflowNodeId" | "sessionFile" | "identityUnavailable"
->;
-function identityKey(run: OwnedRun, child: Identity, stable: boolean): string {
-  let identity: string | number = child.index;
-  if (child.workflowNodeId !== undefined) {
-    identity = child.workflowNodeId;
-  } else if (run.mode === "chain") {
-    identity = chainIdentity(child, stable);
-  }
-  return `${run.runId}:${identity}`;
-}
-function chainIdentity(child: Identity, stable: boolean): string | number {
-  if (!stable) {
-    return child.sessionFile ?? child.index;
-  }
-  return hasText(child.sessionFile) && child.identityUnavailable !== true
-    ? `session:${child.sessionFile}`
-    : child.index;
-}
-function authorityUnavailable(task: Readonly<AgentTask>, reason: string): AgentTask {
-  return {
-    ...task,
-    child: { ...task.child, state: "unknown", identityUnavailable: true },
-    question: undefined,
-    unavailable: reason,
-  };
-}
-/** Owns task-cache writes; composer and controls share visits through visit(). */
-export class AgentTaskStore {
-  private currentTasks: AgentTask[] = [];
-  private currentDockTasks: AgentTask[] = [];
-  get tasks(): readonly Readonly<AgentTask>[] {
-    return this.currentTasks;
-  }
-  get dockTasks(): readonly Readonly<AgentTask>[] {
-    return this.currentDockTasks;
-  }
-  readonly taskKeys = new Map<string, string>();
-  visits = new Map<string, AgentVisit>();
-  selectedKey?: string;
-  pinned?: string;
-  private readonly state: SubagentState;
-  private readonly syncDraft: () => void;
-  constructor(state: SubagentState, syncDraft: () => void) {
-    this.state = state;
-    this.syncDraft = syncDraft;
-  }
-  visit(key: string): AgentVisit {
-    let visit = this.visits.get(key);
-    if (!visit) {
-      visit = { draft: "", outbox: [] };
-      this.visits.set(key, visit);
-    }
-    return visit;
-  }
-  task(key: string): Readonly<AgentTask> | undefined {
-    return this.tasks.find((task) => task.key === key);
-  }
-  reset(): void {
-    this.currentTasks = [];
-    this.currentDockTasks = [];
-    this.taskKeys.clear();
-    this.visits.clear();
-    this.selectedKey = undefined;
-    this.pinned = undefined;
-  }
-  restore(value: unknown, ownerSessionId: string): void {
-    const saved = restoredView(value, ownerSessionId);
-    if (saved) {
-      this.visits = saved.visits;
-      this.pinned = saved.pinned;
-    }
-  }
-  dockPage(rows: readonly HistoryRunRow[]): void {
-    this.currentDockTasks = rows.flatMap((row) => this.fromView(row));
-  }
-  retainSelected(): void {
-    this.currentTasks = this.currentTasks.filter(
-      (task) => task.key === this.selectedKey || task.key === this.pinned,
-    );
-  }
-  setHistoryLoading(key: string, loading: boolean): void {
-    const task = this.currentTasks.find((candidate) => candidate.key === key);
-    if (task) {
-      task.historyLoading = loading;
-    }
-  }
-  applyHistoryPage(
-    key: string,
-    history: AgentHistory,
-    page: HistoryPage,
-    sourceSeen: boolean,
-  ): void {
-    const task = this.currentTasks.find((candidate) => candidate.key === key);
-    if (!task) {
-      return;
-    }
-    task.history = history.items;
-    task.historyIds = history.entryIds;
-    task.finalId = history.finalId;
-    task.page = page;
-    task.unavailable =
-      !sourceSeen &&
-      task.child.state === "live" &&
-      ["missing", "pending", "indexing", "unlinked"].includes(page.sourceState)
-        ? undefined
-        : history.unavailable;
-    this.applyTaskMetadata(task, page);
-  }
-  private taskKey(run: OwnedRun, child: Identity): string {
-    const path = new Set<string>();
-    let cursor = { run, child },
-      key: string;
-    for (;;) {
-      const cache = identityKey(cursor.run, cursor.child, false),
-        cached = this.taskKeys.get(cache);
-      if (cached !== undefined) {
-        key = cached;
-        break;
-      }
-      if (path.has(cache)) {
-        throw new Error("Cyclic saved continuation ancestry");
-      }
-      path.add(cache);
-      const predecessor = hasText(cursor.run.predecessorRunId)
-        ? this.state.ownedRuns?.get(cursor.run.predecessorRunId)
-        : undefined;
-      if (!predecessor) {
-        key = identityKey(cursor.run, cursor.child, true);
-        break;
-      }
-      const index = cursor.run.predecessorIndex ?? 0;
-      cursor = {
-        run: predecessor,
-        child: predecessor.children.find((candidate) => candidate.index === index) ?? { index },
-      };
-    }
-    for (const cache of path) {
-      this.taskKeys.set(cache, key);
-    }
-    return key;
-  }
-  fromView(view: HistoryRunRow, questions = view.questions ?? [], canonical = false): AgentTask[] {
-    return view.children
-      .filter(
-        (child) =>
-          view.matchedChildIndexes === undefined || view.matchedChildIndexes.includes(child.index),
-      )
-      .map((child) => this.taskFromChild(view, child, questions, canonical));
-  }
-  private taskFromChild(
-    view: HistoryRunRow,
-    child: HistoryRunRow["children"][number],
-    questions: readonly SupervisorQuestionView[],
-    canonical: boolean,
-  ): AgentTask {
-    const key = this.taskKey(view, child),
-      prior = this.task(key) ?? this.dockTasks.find((task) => task.key === key),
-      visit = this.visits.get(key);
-    const sameAttempt = prior?.run.runId === view.runId,
-      retained = sameAttempt ? prior : undefined;
-    const selected = !canonical && this.selectedKey === key && retained !== undefined;
-    const display = selected ? selectedChild(child, retained, view.updatedAt) : child;
-    const observed = observedTask(retained, child.state, view.updatedAt);
-    return {
-      key,
-      label: observedLabel(child, prior, sameAttempt),
-      run: view,
-      child: display,
-      model: agentModel(display, observedConfiguration(child, retained, canonical)),
-      ...cachedHistory(retained),
-      ...observationFlags(retained, observed, activityUnread(child, view.updatedAt, visit)),
-      unavailable:
-        child.missingSession === true && child.state !== "live"
-          ? "Saved conversation unavailable."
-          : view.diagnosis,
-      question: observedQuestion(child, questions),
-    };
-  }
-  unavailableTask(key: string, run: OwnedRunView): AgentTask {
-    return {
-      key,
-      label: "Saved assignment unavailable",
-      run,
-      child: {
-        agent: "unknown",
-        index: -1,
-        state: "unknown",
-        configuration: "legacy-partial",
-        identityUnavailable: true,
-      },
-      model: unavailableModel,
-      history: [],
-      historyIds: [],
-      unavailable: UNAVAILABLE_ASSIGNMENT,
-      unread: false,
-      replied: false,
-    };
-  }
-  private latestTasks(rows: readonly HistoryRunRow[]): Map<string, AgentTask> {
-    const tasks = new Map<string, AgentTask>();
-    for (const row of rows) {
-      for (const task of this.fromView(row)) {
-        const prior = tasks.get(task.key);
-        if (!prior || prior.run.startedAt <= task.run.startedAt) {
-          tasks.set(task.key, task);
-        }
-      }
-    }
-    return tasks;
-  }
-  private retainedTasks(rows: readonly HistoryRunRow[]): Map<string, AgentTask> {
-    const tasks = this.latestTasks(rows);
-    for (const [key, visit] of this.visits) {
-      const empty =
-        !hasText(visit.draft) && !visit.quote && visit.outbox.length === 0 && this.pinned !== key;
-      if (tasks.has(key) || empty) {
-        continue;
-      }
-      const row = rows.find((run) => run.runId === key.split(":")[0]);
-      if (row) {
-        tasks.set(key, this.unavailableTask(key, row));
-      }
-    }
-    return tasks;
-  }
-  browsePage(rows: readonly HistoryRunRow[]): void {
-    const tasks = this.retainedTasks(rows);
-    for (const key of [this.selectedKey, this.pinned]) {
-      if (!hasText(key)) {
-        continue;
-      }
-      const retained = this.task(key);
-      if (retained && !tasks.has(key)) {
-        tasks.set(key, { ...retained });
-      }
-    }
-    this.currentTasks = [...tasks.values()];
-  }
-  historyInput(task: Readonly<AgentTask>): HistoryPageInput {
-    const visit = this.visits.get(task.key),
-      ids = visit?.outbox.slice(0, 999).map((sent) => sent.id) ?? [];
-    if (hasText(visit?.lastSentId)) {
-      ids.push(visit.lastSentId);
-    }
-    const common = {
-      runId: task.run.runId,
-      index: task.child.index,
-      messageIds: [...new Set(ids)],
-      readThrough: visit?.readThrough,
-    };
-    if (task.child.state === "live") {
-      return common;
-    }
-    const terminal = task.child.result?.terminalEntryId;
-    return {
-      ...common,
-      leaf: task.child.result?.terminalLeafId,
-      terminalEntryId: terminal,
-      endedAt: hasText(terminal) ? undefined : task.run.updatedAt,
-    };
-  }
-  applyMetadata(key: string, page: HistoryPage): void {
-    for (const task of [...this.currentTasks, ...this.currentDockTasks]) {
-      if (task.key === key) {
-        this.applyTaskMetadata(task, page);
-      }
-    }
-  }
-  private applyTaskMetadata(task: AgentTask, page: HistoryPage): void {
-    const visit = this.visits.get(task.key),
-      delivered = new Map(page.deliveredMessages);
-    task.historySource = JSON.stringify([page.sourceId, page.generation, page.sessionId]);
-    if (page.freshness.state !== "catching-up") {
-      task.metadataAt = task.run.updatedAt;
-    }
-    task.model = agentModel(task.child, page.configuration);
-    task.unread = page.unreadAfter === true || activityUnread(task.child, 0, visit);
-    task.replied = hasText(visit?.lastSentId) && delivered.get(visit.lastSentId) === true;
-    this.applyDelivery(task.key, delivered);
-  }
-  private applyDelivery(key: string, delivered: Readonly<ReadonlyMap<string, boolean>>): void {
-    const visit = this.visits.get(key);
-    if (!visit) {
-      return;
-    }
-    if (
-      hasText(visit.lastSentId) &&
-      delivered.has(visit.lastSentId) &&
-      visit.notice === PENDING_MESSAGE_NOTICE
-    ) {
-      visit.notice = undefined;
-    }
-    for (const sent of visit.outbox) {
-      if (!delivered.has(sent.id) || visit.draft !== sent.draft) {
-        continue;
-      }
-      visit.draft = "";
-      visit.quote = undefined;
-      if (this.selectedKey === key) {
-        this.syncDraft();
-      }
-    }
-    visit.outbox = visit.outbox.filter((sent) => !delivered.has(sent.id));
-  }
-  metadataUnavailable(key: string, reason: string): void {
-    for (const task of [...this.currentTasks, ...this.currentDockTasks]) {
-      if (task.key === key) {
-        task.unavailable ??= reason;
-      }
-    }
-  }
-  private authorityTask(
-    key: string,
-    root: string,
-    ownerSessionId: string | undefined,
-  ): { selected?: AgentTask; rootView?: OwnedRunView } {
-    let selected: AgentTask | undefined, rootView: OwnedRunView | undefined;
-    for (const run of this.state.ownedRuns?.values() ?? []) {
-      if (run.rootRunId !== root || run.ownerSessionId !== ownerSessionId) {
-        continue;
-      }
-      const questions = listOwnedRunQuestions(run.ownerSessionId, run.runId);
-      const view = ownedRunView(run, this.state, {
-        pendingInput: questions.some((question) =>
-          ["awaiting_input", "answer_pending"].includes(question.state),
-        ),
-        includeContinuations: false,
-        readConfiguration: false,
-      });
-      if (view.runId === key.split(":")[0]) {
-        rootView = view;
-      }
-      const candidate = this.fromView(view, questions, true).find((task) => task.key === key);
-      if (candidate && (!selected || selected.run.startedAt <= candidate.run.startedAt)) {
-        selected = candidate;
-      }
-    }
-    return { selected, rootView };
-  }
-  private missingAuthority(
-    key: string,
-    current: Readonly<AgentTask> | undefined,
-    rootView: OwnedRunView | undefined,
-  ): AgentTask | undefined {
-    if (current) {
-      return authorityUnavailable(current, UNAVAILABLE_ASSIGNMENT);
-    }
-    return rootView && this.visits.has(key) ? this.unavailableTask(key, rootView) : undefined;
-  }
-  private replaceTask(task: AgentTask): void {
-    const position = this.currentTasks.findIndex((candidate) => candidate.key === task.key);
-    if (position < 0) {
-      this.currentTasks.push(task);
-    } else {
-      this.currentTasks[position] = task;
-    }
-    this.currentDockTasks = this.currentDockTasks.map((candidate) =>
-      candidate.key === task.key ? task : candidate,
-    );
-  }
-  releaseSelected(): void {
-    for (const task of [...this.currentTasks, ...this.currentDockTasks]) {
-      if (task.key === this.selectedKey) {
-        task.history = [];
-        task.historyIds = [];
-        task.page = undefined;
-        task.finalId = undefined;
-        task.historyLoading = false;
-      }
-    }
-    this.selectedKey = undefined;
-  }
-  private rootForKey(key: string, current: Readonly<AgentTask> | undefined): string | undefined {
-    return current?.run.rootRunId ?? this.state.ownedRuns?.get(key.split(":")[0] ?? "")?.rootRunId;
-  }
-  /** Browse SQLite is not authority: recheck this lineage before sending or stopping. */
-  refreshSelected(key: string, ownerSessionId: string | undefined): void {
-    const current = this.task(key),
-      root = this.rootForKey(key, current);
-    if (!hasText(root)) {
-      return;
-    }
-    this.taskKeys.clear();
-    let selected: AgentTask | undefined;
-    try {
-      const authority = this.authorityTask(key, root, ownerSessionId);
-      selected = authority.selected ?? this.missingAuthority(key, current, authority.rootView);
-    } catch (error) {
-      if (current) {
-        selected = authorityUnavailable(current, `Run authority unavailable: ${errorText(error)}`);
-      }
-    }
-    if (selected) {
-      this.replaceTask(selected);
-    }
-  }
-}

package/src/tui/text-values.ts

@@ -1,20 +0,0 @@
-import { inspect } from "node:util";
-
-/** Empty recorded strings are not display labels; retain their fallback semantics explicitly. */
-export function hasText(value: string): boolean;
-export function hasText(value: unknown): value is string;
-export function hasText(value: unknown): value is string {
-  return typeof value === "string" && value.length > 0;
-}
-export function nonemptyText(value: unknown): string | undefined {
-  return hasText(value) ? value : undefined;
-}
-export function errorText(error: unknown): string {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  return inspect(error, { depth: 2, customInspect: false });
-}

package/src/tui/view-connections.ts

@@ -1,64 +0,0 @@
-import type { AgentTaskStore } from "./task-store.ts";
-import type { AgentBrowser } from "./agent-browser.ts";
-import type { AgentControls } from "./agent-controls.ts";
-import type { ConversationController, PickerController } from "./view-ports.ts";
-
-type Layout = Pick<PickerController, "shortcut" | "availableHeight">;
-type ConversationUI = Layout & Pick<ConversationController, "changed" | "pin">;
-
-/** Bind native UI ports directly to the owners of their operations and observations. */
-export function pickerPort(
-  store: AgentTaskStore,
-  browser: AgentBrowser,
-  layout: Layout,
-): PickerController {
-  return {
-    ...layout,
-    get tasks() {
-      return store.tasks;
-    },
-    get listFilter() {
-      return browser.listFilter;
-    },
-    get listPending() {
-      return browser.listPending;
-    },
-    get listPage() {
-      return browser.listPage;
-    },
-    get listError() {
-      return browser.listError;
-    },
-    get listLoading() {
-      return browser.listLoading;
-    },
-    task: store.task.bind(store),
-    pageTasks: browser.pageTasks.bind(browser),
-    retry: browser.retry.bind(browser),
-    filterTasks: browser.filterTasks.bind(browser),
-  };
-}
-export function conversationPort(
-  store: AgentTaskStore,
-  browser: AgentBrowser,
-  controls: AgentControls,
-  ui: ConversationUI,
-): ConversationController {
-  return {
-    ...ui,
-    get pinned() {
-      return store.pinned;
-    },
-    task: store.task.bind(store),
-    visit: store.visit.bind(store),
-    historyPage: browser.historyPage.bind(browser),
-    savedResult: browser.savedResult.bind(browser),
-    applyHistoryPage: store.applyHistoryPage.bind(store),
-    setHistoryLoading: store.setHistoryLoading.bind(store),
-    send: controls.send.bind(controls),
-    stop: controls.stop.bind(controls),
-    changes: controls.changes.bind(controls),
-    isBusy: controls.isBusy.bind(controls),
-    retry: browser.retry.bind(browser),
-  };
-}

package/src/tui/view-model.ts

@@ -1,181 +0,0 @@
-import { nonemptyText, hasText } from "./text-values.ts";
-import { rawKeyHint, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
-import { getKeybindings, truncateToWidth, type Keybinding } from "@earendil-works/pi-tui";
-import type {
-  SupervisorQuestionView,
-  OwnedRunView,
-  SubagentExecutionResult,
-  ReadonlyInput,
-  HistoryPage,
-  HistoryRunRow,
-} from "../shared/types.ts";
-import type { SubagentParamsLike } from "../runs/foreground/subagent-params.ts";
-import { readableText, type AgentHistoryItem } from "./agent-history.ts";
-
-export const UNAVAILABLE_ASSIGNMENT =
-  "Assignment identity unavailable. Your draft is kept; no message or Stop was sent. Inspect the run and choose a verified assignment before sending it.";
-
-export const PENDING_MESSAGE_NOTICE =
-  "This message is already waiting for the child. You can keep working or write a different message.";
-
-export const CONTINUE_HINT = "Continue with this message (Alt+C)";
-
-export const CONTINUE_NOTICES = {
-  finished: "This agent has finished. Your draft is kept. Choose ",
-  blocked: "This agent needs your action; acceptance is incomplete. Your draft is kept. Choose ",
-};
-
-export type ExecuteControl = (
-  params: Readonly<
-    Pick<SubagentParamsLike, "action" | "id" | "index" | "questionId" | "message" | "messageOrigin">
-  >,
-  ctx: ExtensionContext,
-) => Promise<SubagentExecutionResult>;
-
-export type Quote = { readonly title: string; readonly text: string };
-
-export type Anchor = { readonly id: string; readonly line: number };
-
-export interface OutgoingMessage {
-  id: string;
-  runId: string;
-  index: number;
-  text: string;
-  draft: string;
-  quote?: Quote;
-  at: number;
-  status: "sending" | "waiting" | "unconfirmed";
-  reason?: string;
-}
-
-export interface AgentVisit {
-  draft: string;
-  quote?: Quote;
-  anchor?: Anchor;
-  /** null records a visit before the first saved history entry. */
-  readThrough?: string | null;
-  seenActivityAt?: number;
-  outbox: OutgoingMessage[];
-  lastSentId?: string;
-  notice?: string | { readonly continue: keyof typeof CONTINUE_NOTICES };
-}
-
-export interface AgentTask {
-  readonly key: string;
-  readonly label: string;
-  readonly run: ReadonlyInput<OwnedRunView>;
-  readonly child: ReadonlyInput<HistoryRunRow["children"][number]>;
-  model: { readonly summary: string; readonly details: string };
-  question?: SupervisorQuestionView;
-  history: readonly AgentHistoryItem[];
-  historyIds: readonly string[];
-  finalId?: string;
-  unavailable?: string;
-  unread: boolean;
-  replied: boolean;
-  page?: HistoryPage;
-  historyLoading?: boolean;
-  historySource?: string;
-  metadataAt?: number;
-}
-
-export const short = (text: string, width = 48): string =>
-  truncateToWidth(readableText(text).replace(/\s+/g, " ").trim(), width);
-
-export const resultText = (result: SubagentExecutionResult): string =>
-  result.content.map((part) => (part.type === "text" ? part.text : "")).join("\n");
-
-export function primaryKey(action: Keybinding): string {
-  const key = getKeybindings().getKeys(action).at(0);
-  const labels: Readonly<Record<string, string | undefined>> = {
-    enter: "Enter",
-    escape: "Esc",
-    up: "↑",
-    down: "↓",
-  };
-  return labels[key ?? ""] ?? readableText(rawKeyHint(key ?? "", "")).trim();
-}
-
-export function agentTaskLabel(child: OwnedRunView["children"][number]): string {
-  return readableText(
-    nonemptyText(child.label) ??
-      nonemptyText(child.task?.split("\n").find((line) => line.trim().length > 0)) ??
-      `${child.agent} · assignment unavailable`,
-  )
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-export function activity(task: Readonly<AgentTask>): string {
-  if (task.child.identityUnavailable === true) {
-    return "assignment unavailable";
-  }
-  if (task.question) {
-    return task.question.state === "answer_pending" ? "answer saved · waiting" : "needs an answer";
-  }
-  if (task.child.state === "blocked") {
-    return "needs your action · acceptance incomplete";
-  }
-  if (task.child.state !== "live") {
-    return task.child.state === "completed" ? "done" : task.child.state;
-  }
-  return liveActivity(task.child.activity);
-}
-function liveActivity(live: AgentTask["child"]["activity"]): string {
-  if (live?.status === "pending") {
-    return "waiting to start";
-  }
-  if (hasText(live?.currentTool)) {
-    return short(
-      `${live.currentTool} ${nonemptyText(live.currentToolArgs) ?? nonemptyText(live.currentPath) ?? ""}`,
-      42,
-    );
-  }
-  return hasText(live?.streamingText) ? short(live.streamingText, 42) : "working";
-}
-
-function taskStatus(task: Readonly<AgentTask>): string {
-  if (task.child.identityUnavailable === true) {
-    return "unavailable";
-  }
-  if (task.question) {
-    return task.question.state === "answer_pending" ? "answer pending" : "needs answer";
-  }
-  if (task.child.state === "blocked") {
-    return "needs action";
-  }
-  if (task.child.state === "live") {
-    return task.child.activity?.status === "pending" ? "queued" : "working";
-  }
-  return task.child.state === "completed" ? "done" : task.child.state;
-}
-export function taskSummary(task: Readonly<AgentTask>): { status: string; badge: string } {
-  let badge = "";
-  if (task.unread) {
-    badge = task.replied ? " · replied" : " · new";
-  }
-  return { status: taskStatus(task), badge };
-}
-
-export { agentModel, unavailableModel } from "./agent-model.ts";
-
-export function runningIndicator(theme: Theme): string {
-  // Six seconds, sampled by the existing 500 ms refresh; typing cannot speed up the pulse.
-  const phase = Math.floor(Date.now() / 500) % 12;
-  const ansi = theme.getFgAnsi("success");
-  // Parse the native SGR truecolor foreground sequence for the display-only pulse.
-  // oxlint-disable-next-line no-control-regex
-  const colorPattern = /^\x1b\[38;2;(\d+);(\d+);(\d+)m$/;
-  const rgb = theme.getColorMode() === "truecolor" ? colorPattern.exec(ansi) : null;
-  if (!rgb) {
-    return theme.fg("success", phase < 6 ? theme.bold("●") : "●");
-  }
-  const brightness = 0.9 + 0.1 * Math.cos((phase * Math.PI) / 6);
-  return theme.fg("success", "●").replace(
-    ansi,
-    `\x1b[38;2;${rgb
-      .slice(1)
-      .map((value) => Math.round(Number(value) * brightness))
-      .join(";")}m`,
-  );
-}