@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/src/tui/view-connections.ts

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,181 @@
+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`,
+  );
+}

package/src/tui/view-persistence.ts

@@ -0,0 +1,57 @@
+import { Type, Check } from "../shared/native-typebox.ts";
+import type { AgentVisit } from "./view-model.ts";
+const quote = Type.Object({ title: Type.String(), text: Type.String() });
+const anchor = Type.Object({ id: Type.String(), line: Type.Number() });
+const outgoing = Type.Object({
+  id: Type.String(),
+  runId: Type.String(),
+  index: Type.Number(),
+  text: Type.String(),
+  draft: Type.String(),
+  quote: Type.Optional(quote),
+  at: Type.Number(),
+  status: Type.Union([
+    Type.Literal("sending"),
+    Type.Literal("waiting"),
+    Type.Literal("unconfirmed"),
+  ]),
+  reason: Type.Optional(Type.String()),
+});
+const visit = Type.Object({
+  draft: Type.String(),
+  quote: Type.Optional(quote),
+  anchor: Type.Optional(anchor),
+  readThrough: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+  seenActivityAt: Type.Optional(Type.Number()),
+  outbox: Type.Array(outgoing),
+  lastSentId: Type.Optional(Type.String()),
+  notice: Type.Optional(
+    Type.Union([
+      Type.String(),
+      Type.Object({ continue: Type.Union([Type.Literal("finished"), Type.Literal("blocked")]) }),
+    ]),
+  ),
+});
+const saved = Type.Object({
+  ownerSessionId: Type.String(),
+  visits: Type.Array(Type.Tuple([Type.String(), visit])),
+  pinned: Type.Optional(Type.String()),
+});
+export function restoredView(
+  value: unknown,
+  ownerSessionId: string,
+): { visits: Map<string, AgentVisit>; pinned?: string } | undefined {
+  if (!Check(saved, value) || value.ownerSessionId !== ownerSessionId) {
+    return;
+  }
+  // The restored visit store owns its copies, never mutable session-entry data.
+  const visits = new Map<string, AgentVisit>(structuredClone(value.visits));
+  for (const current of visits.values()) {
+    for (const sent of current.outbox) {
+      if (sent.status === "sending") {
+        sent.status = "unconfirmed";
+      }
+    }
+  }
+  return { visits, pinned: value.pinned };
+}

package/src/tui/view-ports.ts

@@ -0,0 +1,55 @@
+import type { TUI, KeyId } from "@earendil-works/pi-tui";
+import type { HistoryPage, HistoryPageInput, HistoryRunPage } from "../shared/types.ts";
+import type { AgentHistory, AgentHistoryItem } from "./history-display.ts";
+import type { AgentTask, AgentVisit } from "./view-model.ts";
+
+export interface HistorySelection {
+  readonly history: AgentHistory;
+  readonly page: HistoryPage;
+  readonly latestPage: boolean;
+  readonly readThroughSequence?: number;
+  readonly isCurrent: () => boolean;
+}
+/** Browsing operations exposed to the native picker, not the controller's private state. */
+export interface PickerController {
+  readonly shortcut: KeyId;
+  readonly tasks: readonly Readonly<AgentTask>[];
+  readonly listFilter: string;
+  readonly listPending: boolean;
+  readonly listPage?: HistoryRunPage;
+  readonly listError?: string;
+  readonly listLoading: boolean;
+  readonly availableHeight: (tui: TUI) => number;
+  readonly task: (key: string) => Readonly<AgentTask> | undefined;
+  readonly pageTasks: (direction: "earlier" | "later") => void;
+  readonly retry: (key?: string) => Promise<void>;
+  readonly filterTasks: (text: string) => void;
+}
+/** The conversation controls the actual visit/cache owner through its public operations. */
+export interface ConversationController {
+  readonly shortcut: KeyId;
+  readonly pinned?: string;
+  readonly availableHeight: (tui: TUI) => number;
+  readonly task: (key: string) => Readonly<AgentTask> | undefined;
+  readonly visit: (key: string) => AgentVisit;
+  readonly changed: () => void;
+  readonly historyPage: (
+    key: string,
+    paging?: Pick<HistoryPageInput, "before" | "after" | "cursor">,
+    anchor?: string | null,
+  ) => Promise<HistorySelection | undefined>;
+  readonly savedResult: (key: string, id: string) => Promise<AgentHistoryItem>;
+  readonly applyHistoryPage: (
+    key: string,
+    history: AgentHistory,
+    page: HistoryPage,
+    sourceSeen: boolean,
+  ) => void;
+  readonly setHistoryLoading: (key: string, loading: boolean) => void;
+  readonly send: (key: string, text: string, continueExplicitly?: boolean) => Promise<void>;
+  readonly stop: (key: string) => Promise<void>;
+  readonly changes: (key: string) => Promise<AgentHistoryItem | undefined>;
+  readonly isBusy: (key: string) => boolean;
+  readonly retry: (key?: string) => Promise<void>;
+  readonly pin: (key: string | undefined) => void;
+}

package/src/tui/view-session.ts

@@ -0,0 +1,42 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { SubagentState } from "../shared/types.ts";
+
+/** One owner identity and cancellation generation shared by asynchronous UI observations/actions. */
+export class ViewSession {
+  ctx?: ExtensionContext;
+  ownerSessionId?: string;
+  generation = 0;
+  private pending = new AbortController();
+  private readonly state: SubagentState;
+  constructor(state: SubagentState) {
+    this.state = state;
+  }
+  context(): ExtensionContext {
+    if (!this.ctx) {
+      throw new Error("The owning session is no longer available.");
+    }
+    return this.ctx;
+  }
+  get signal(): AbortSignal {
+    return this.pending.signal;
+  }
+  start(ctx: ExtensionContext): void {
+    this.ctx = ctx;
+    this.ownerSessionId = ctx.sessionManager.getSessionId();
+    this.pending = new AbortController();
+  }
+  live(generation = this.generation): boolean {
+    return (
+      generation === this.generation &&
+      this.ctx !== undefined &&
+      this.ctx.sessionManager.getSessionId() === this.ownerSessionId &&
+      this.state.lastUiContext?.sessionManager.getSessionId() === this.ownerSessionId
+    );
+  }
+  dispose(): void {
+    this.generation++;
+    this.pending.abort();
+    this.ctx = undefined;
+    this.ownerSessionId = undefined;
+  }
+}

package/src/tui/widget-details.ts

@@ -0,0 +1,220 @@
+import type { AsyncJobState, ReadonlyInput } from "../shared/types.ts";
+import { shortenPath } from "../shared/formatters.ts";
+import { aggregateStepStatus, formatParallelOutcome } from "../shared/status-format.ts";
+import {
+  getTermWidth,
+  themeBold,
+  modelThinkingBadge,
+  buildLiveStatusLine,
+  truncLine,
+  type Theme,
+} from "./display.ts";
+import { buildAsyncChainStepSpans } from "./workflow-labels.ts";
+import {
+  widgetStepGlyph,
+  widgetStepsRunningSeed,
+  widgetStepActivity,
+  widgetStepRunningSeed,
+  widgetStepStatus,
+  widgetStepStats,
+  widgetStepActivityLine,
+  widgetOutputPath,
+  widgetActivity,
+  widgetStats,
+  widgetJobName,
+  widgetStatusGlyph,
+} from "./widget-status.ts";
+import { formatNestedWidgetLines } from "./nested-widget.ts";
+import { hasText } from "./text-values.ts";
+type Job = ReadonlyInput<AsyncJobState>;
+type Step = ReadonlyInput<NonNullable<AsyncJobState["steps"]>[number]>;
+interface StepLayout {
+  readonly title: "Agent" | "Step";
+  readonly index: number;
+  readonly total: number;
+  readonly width: number;
+}
+
+function widgetChainDetails(job: Job, theme: Theme, width: number): string[] {
+  const steps = job.steps ?? [],
+    total = job.chainStepCount ?? steps.length,
+    lines: string[] = [];
+  for (const span of buildAsyncChainStepSpans(total, steps.length, job.parallelGroups)) {
+    const group = steps.slice(span.start, span.start + span.count);
+    if (span.isParallel) {
+      const status = aggregateStepStatus(group);
+      lines.push(
+        `  ${widgetStepGlyph(status, theme, widgetStepsRunningSeed(group))} Step ${span.stepIndex + 1}/${total}: ${themeBold(theme, "parallel group")} ${theme.fg("dim", "·")} ${theme.fg("dim", formatParallelOutcome(group, span.count))}`,
+      );
+      continue;
+    }
+    const step = group.at(0);
+    if (!step) {
+      lines.push(`  ${theme.fg("dim", `◦ Step ${span.stepIndex + 1}/${total}: pending`)}`);
+      continue;
+    }
+    lines.push(
+      ...foregroundStyleWidgetStepLines(job, theme, step, {
+        title: "Step",
+        index: span.stepIndex + 1,
+        total,
+        width,
+      }),
+    );
+  }
+  return lines;
+}
+function parallelStepLines(job: Job, theme: Theme, step: Step, layout: StepLayout): string[] {
+  const marker = layout.index === (job.steps?.length ?? 0) ? "└" : "├";
+  const activity = widgetStepActivity(step, job.updatedAt),
+    model = modelThinkingBadge(theme, step.model, step.thinking);
+  const lines = [
+    `  ${theme.fg("dim", `${marker} ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, layout.index - 1))} ${layout.title} ${layout.index}/${layout.total}: ${step.agent} · ${widgetStepStatus(step.status, theme)}${model}${hasText(activity) ? ` · ${activity}` : ""}`)}`,
+  ];
+  for (const nested of formatNestedWidgetLines(step.children, theme, layout.width, {
+    snapshotNow: job.updatedAt,
+    lineBudget: 8,
+  })) {
+    lines.push(`    ${nested}`);
+  }
+  return lines;
+}
+export function widgetParallelAgentDetails(
+  job: Job,
+  theme: Theme,
+  width = getTermWidth(),
+): string[] {
+  const steps = job.steps ?? [];
+  if (steps.length === 0 || (job.mode !== "parallel" && job.mode !== "chain")) {
+    return [];
+  }
+  if (hasLogicalChainGroups(job)) {
+    return widgetChainDetails(job, theme, width);
+  }
+  const total = job.stepsTotal ?? steps.length,
+    title = job.mode === "parallel" || job.activeParallelGroup === true ? "Agent" : "Step";
+  return steps.flatMap((step, index) =>
+    parallelStepLines(job, theme, step, { title, index: index + 1, total, width }),
+  );
+}
+function hasLogicalChainGroups(
+  job: Pick<Job, "mode" | "activeParallelGroup" | "parallelGroups">,
+): boolean {
+  return (
+    job.mode === "chain" &&
+    job.activeParallelGroup !== true &&
+    (job.parallelGroups?.length ?? 0) > 0
+  );
+}
+
+function recentToolLines(step: Step, theme: Theme, width: number): string[] {
+  const max = Math.max(40, width - 30);
+  return (step.recentTools ?? []).slice(-3).map((tool) => {
+    const args = tool.args.length <= max ? tool.args : `${tool.args.slice(0, max)}...`;
+    return `      ${theme.fg("dim", `${tool.tool}${hasText(args) ? `: ${args}` : ""}`)}`;
+  });
+}
+function runningStepLines(
+  job: Job,
+  theme: Theme,
+  step: Step,
+  layout: { readonly width: number; readonly activity: string },
+): string[] {
+  const lines: string[] = [],
+    output = widgetOutputPath(job, step),
+    live = buildLiveStatusLine(step, job.updatedAt);
+  if (hasText(output)) {
+    lines.push(`    ${theme.fg("dim", `output: ${shortenPath(output)}`)}`);
+  }
+  if (hasText(live) && live !== layout.activity) {
+    lines.push(`    ${theme.fg("accent", live)}`);
+  }
+  lines.push(...recentToolLines(step, theme, layout.width));
+  for (const line of (step.recentOutput ?? []).slice(-5)) {
+    lines.push(`      ${theme.fg("dim", line)}`);
+  }
+  return lines;
+}
+function foregroundStyleWidgetStepLines(
+  job: Job,
+  theme: Theme,
+  step: Step,
+  layout: StepLayout,
+): string[] {
+  const status = widgetStepStatus(step.status, theme),
+    stats = widgetStepStats(theme, step),
+    model = modelThinkingBadge(theme, step.model, step.thinking);
+  const lines = [
+    `  ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, layout.index - 1))} ${layout.title} ${layout.index}/${layout.total}: ${themeBold(theme, step.agent)} ${theme.fg("dim", "·")} ${status}${model}${hasText(stats) ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+  ];
+  const activity = widgetStepActivityLine(step, layout.width, true, job.updatedAt);
+  if (hasText(activity)) {
+    lines.push(`    ${theme.fg("dim", `⎿  ${activity}`)}`);
+  }
+  for (const nested of formatNestedWidgetLines(step.children, theme, layout.width, {
+    snapshotNow: job.updatedAt,
+  })) {
+    lines.push(`    ${nested}`);
+  }
+  if (step.status === "running") {
+    lines.push(...runningStepLines(job, theme, step, { width: layout.width, activity }));
+  }
+  return lines;
+}
+function unattachedChildren(job: Job, theme: Theme, width: number): string[] {
+  const attached = new Set(
+    (job.steps ?? []).flatMap((step) => step.children?.map((child) => child.id) ?? []),
+  );
+  return formatNestedWidgetLines(
+    job.nestedChildren?.filter((child) => !attached.has(child.id)),
+    theme,
+    width,
+    { snapshotNow: job.updatedAt },
+  ).map((line) => `  ${line}`);
+}
+function foregroundStyleWidgetDetails(job: Job, theme: Theme, width: number): string[] {
+  const steps = job.steps ?? [];
+  if (steps.length === 0) {
+    return [
+      `  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
+      ...formatNestedWidgetLines(job.nestedChildren, theme, width, {
+        snapshotNow: job.updatedAt,
+      }).map((line) => `  ${line}`),
+    ];
+  }
+  if (hasLogicalChainGroups(job)) {
+    return widgetChainDetails(job, theme, width);
+  }
+  const total = job.stepsTotal ?? steps.length,
+    title = job.mode === "parallel" || job.activeParallelGroup === true ? "Agent" : "Step";
+  return [
+    ...steps.flatMap((step, index) =>
+      foregroundStyleWidgetStepLines(job, theme, step, { title, index: index + 1, total, width }),
+    ),
+    ...unattachedChildren(job, theme, width),
+  ];
+}
+export function buildSingleWidgetLines(job: Job, theme: Theme, width: number): string[] {
+  const stats = widgetStats(job, theme),
+    mode = widgetJobName(job);
+  const count =
+    job.mode === "chain"
+      ? job.chainStepCount
+      : (job.stepsTotal ?? job.agents?.length ?? job.steps?.length);
+  const title = `async subagent ${mode}${(count ?? 0) > 1 ? ` (${count ?? 0})` : ""}`;
+  return [
+    `${theme.fg("toolTitle", themeBold(theme, title))} ${theme.fg("dim", "· background")}`,
+    `${widgetStatusGlyph(job, theme)} ${themeBold(theme, mode)}${hasText(stats) ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+    ...foregroundStyleWidgetDetails(job, theme, width),
+  ].map((line) => truncLine(line, width));
+}
+export function collapsedJobRow(job: Job, theme: Theme, width: number): string {
+  const stats = widgetStats(job, theme),
+    running = job.steps?.filter((step) => step.status === "running") ?? [];
+  const solo = running.length === 1 ? running[0] : undefined;
+  let activity = widgetActivity(job, false);
+  if (job.status === "running" && solo) {
+    activity = widgetStepActivityLine(solo, width, false, job.updatedAt);
+  }
+  return `${widgetStatusGlyph(job, theme)} ${themeBold(theme, widgetJobName(job))}${hasText(stats) ? ` ${theme.fg("dim", "·")} ${stats}` : ""}${hasText(activity) ? ` ${theme.fg("dim", "·")} ${theme.fg("dim", activity)}` : ""}`;
+}