@capagents/forgeqe 1.0.4 → 1.0.7

package/src/tui/components.tsx

@@ -50,6 +50,12 @@ export type PromptProps = {
   masked?: number
   /** Beside a session panel that names the model and profile, and a status bar: no bottom row. */
   compact?: boolean
+  /** Text the box starts with when `inputKey` changes (a refined request, an example from the palette). */
+  initialValue?: string
+  /** False while an overlay (the palette, a suggestion list) takes the keyboard. Default true. */
+  focused?: boolean
+  /** Called with the text as it changes, for actions on what is being typed (Refine). */
+  onText?: (text: string) => void
 }
 
 /** Enter sends; Shift+Enter, Alt+Enter or Ctrl+J start a new line. */
@@ -66,7 +72,12 @@ export function Prompt(props: PromptProps) {
   const ref = useRef<TextareaRenderable>(null)
   const [rows, setRows] = useState(props.minRows)
   useEffect(() => setRows(props.minRows), [props.inputKey, props.minRows])
+  // Inserted text (a completion, an example, a refined request) is continued from its end.
+  useEffect(() => {
+    if (props.initialValue) ref.current?.gotoBufferEnd()
+  }, [props.inputKey])
   const fit = () => {
+    props.onText?.(ref.current?.plainText ?? "")
     const lines = ref.current?.virtualLineCount ?? 1
     setRows(Math.min(props.maxRows, Math.max(props.minRows, lines)))
   }
@@ -95,7 +106,8 @@ export function Prompt(props: PromptProps) {
             key={props.inputKey}
             ref={ref}
             placeholder={props.placeholder}
-            focused
+            focused={props.focused !== false}
+            initialValue={props.initialValue || ""}
             wrapMode="word"
             keyBindings={PROMPT_KEYS}
             onSubmit={() => props.onSubmit(ref.current?.plainText ?? "")}
@@ -162,9 +174,23 @@ export function Spinner({ kind = "bar", color = theme.warn }: { kind?: "bar" | "
   )
 }
 
-export type Hint = { key: string; label: string; onPress?: () => void }
+/** `drop`: the order hints give way when the row is too narrow, highest first; without it a hint always stays. */
+export type Hint = { key: string; label: string; onPress?: () => void; drop?: number }
+
+/** The hints that fit in `room` columns: whole hints give way, by their `drop`, rather than every label being squeezed. */
+export function fitHints(items: Hint[], room: number): Hint[] {
+  const cells = (list: Hint[]) => list.reduce((n, h, i) => n + h.key.length + (h.label ? h.label.length + 1 : 0) + (i ? 2 : 0), 0)
+  let kept = [...items]
+  const order = items.filter((h) => h.drop !== undefined).sort((a, b) => b.drop! - a.drop!)
+  for (const h of order) {
+    if (cells(kept) <= room) break
+    kept = kept.filter((k) => k !== h)
+  }
+  return kept
+}
 
-export function Hints({ width, items, left }: { width: number; items: Hint[]; left?: ReactNode }) {
+export function Hints({ width, items: all, left, reserve = 0 }: { width: number; items: Hint[]; left?: ReactNode; reserve?: number }) {
+  const items = fitHints(all, width - reserve)
   return (
     <box style={{ width, height: 1, flexShrink: 0, flexDirection: "row", justifyContent: "space-between" }}>
       <box style={{ flexDirection: "row" }}>{left}</box>
@@ -180,6 +206,55 @@ export function Hints({ width, items, left }: { width: number; items: Hint[]; le
   )
 }
 
+/**
+ * A button under the prompt: an icon, a label, and its key, on a raised background; `active` fills it with its colour
+ * (Refine once there is text to refine). `drop`: when it gives way on a narrow row, highest first.
+ */
+export type Button = { icon: string; label: string; keys?: string; color: string; onPress: () => void; active?: boolean; drop?: number }
+
+const buttonCells = (b: Button) => b.icon.length + 1 + b.label.length + (b.keys ? b.keys.length + 1 : 0) + 3
+
+/** The buttons that fit in `room` columns; a narrow row first loses whole buttons by their `drop`, then the keys. */
+export function fitButtons(items: Button[], room: number): Button[] {
+  const cells = (list: Button[]) => list.reduce((n, b) => n + buttonCells(b), 0)
+  let kept = [...items]
+  for (const b of items.filter((x) => x.drop !== undefined).sort((x, y) => y.drop! - x.drop!)) {
+    if (cells(kept) <= room) return kept
+    kept = kept.filter((k) => k !== b)
+  }
+  return cells(kept) <= room ? kept : kept.map((b) => ({ ...b, keys: undefined }))
+}
+
+/** The row under the prompt: buttons on the left, the hints (close, a note) on the right. */
+export function ButtonBar({ width, buttons, hints, left }: { width: number; buttons: Button[]; hints: Hint[]; left?: ReactNode }) {
+  const hintCells = hints.reduce((n, h, i) => n + h.key.length + (h.label ? h.label.length + 1 : 0) + (i ? 2 : 0), 0)
+  const shown = fitButtons(buttons, Math.max(0, width - hintCells - (left ? 22 : 0) - 1))
+  return (
+    <box style={{ width, height: 1, flexShrink: 0, flexDirection: "row", justifyContent: "space-between" }}>
+      <box style={{ flexDirection: "row" }}>
+        {left}
+        {shown.map((b) => (
+          <box key={b.label} onMouseDown={b.onPress} style={{ flexDirection: "row", paddingLeft: 1, paddingRight: 1, marginRight: 1, backgroundColor: b.active ? b.color : theme.button }}>
+            <text>
+              <span fg={b.active ? theme.onButton : b.color}>{`${b.icon} `}</span>
+              <span fg={b.active ? theme.onButton : theme.text}>{b.label}</span>
+              {b.keys ? <span fg={b.active ? theme.onButton : theme.faint}>{` ${b.keys}`}</span> : null}
+            </text>
+          </box>
+        ))}
+      </box>
+      <box style={{ flexDirection: "row" }}>
+        {hints.map((item, i) => (
+          <text key={`${item.key}-${item.label}`} onMouseDown={item.onPress}>
+            <span fg={theme.text}>{`${i ? "  " : ""}${item.key}`}</span>
+            <span fg={item.onPress ? theme.muted : theme.faint}>{item.label ? ` ${item.label}` : ""}</span>
+          </text>
+        ))}
+      </box>
+    </box>
+  )
+}
+
 export type Choice = { id: string; label: string }
 
 export type ChoicePanelProps = {

package/src/tui/inspector.tsx

@@ -2,7 +2,7 @@ import type { ScrollBoxRenderable } from "@opentui/core"
 import type { ReactNode, RefObject } from "react"
 
 import type { Usage } from "../types.ts"
-import { Spinner } from "./components.tsx"
+import { fitButtons, Spinner, type Button } from "./components.tsx"
 import { filesByUse, type FileUse, type Inspector, type Progress } from "./session.ts"
 import { clip, tailCut } from "./text.ts"
 import { formatTokens, theme } from "./theme.ts"
@@ -25,15 +25,33 @@ export const SECTION = {
 /** Rows a panel's border takes: top and bottom. */
 export const PANEL_CHROME = 2
 
-/** A titled, rounded panel; `width` and `height` include the border. */
-export function Panel(props: { title: string; color: string; width?: number; height?: number; children: ReactNode }) {
+/** The panels keys can move between (shift+tab), after the chat; the order they sit in on screen. */
+export type Focus = "chat" | "plan" | "activity" | "files"
+export const FOCUS_ORDER: Focus[] = ["chat", "plan", "activity", "files"]
+
+/** The next panel shift+tab moves to, past any that are not on screen. */
+export function nextFocus(at: Focus, shown: (f: Focus) => boolean): Focus {
+  for (let i = 1; i <= FOCUS_ORDER.length; i++) {
+    const f = FOCUS_ORDER[(FOCUS_ORDER.indexOf(at) + i) % FOCUS_ORDER.length]!
+    if (shown(f)) return f
+  }
+  return "chat"
+}
+
+/**
+ * A titled, rounded panel; `width` and `height` include the border. Focused, its border takes the section's colour and
+ * its keys show in the bottom border.
+ */
+export function Panel(props: { title: string; color: string; width?: number; height?: number; focused?: boolean; keys?: string; onFocus?: () => void; children: ReactNode }) {
   return (
     <box
       border
       borderStyle="rounded"
-      borderColor={theme.border}
+      borderColor={props.focused ? props.color : theme.border}
       title={` ${props.title} `}
       titleColor={props.color}
+      {...(props.focused && props.keys ? { bottomTitle: ` ${props.keys} `, bottomTitleAlignment: "right" as const } : {})}
+      {...(props.onFocus ? { onMouseDown: props.onFocus } : {})}
       style={{
         flexDirection: "column",
         paddingLeft: 1,
@@ -84,7 +102,30 @@ export function SessionPanel({ info, width }: { info: SessionInfo; width: number
 }
 
 /** The right pane's first line: who is working on what and for how long, and Stop while something runs. */
-export function StatusBar(props: { running: boolean; who: string; activity: string; elapsed: string; status: string; width: number; onStop: () => void }) {
+/** How far the agent's own plan has got, while it has one of two steps or more. */
+export function planProgress(s: Inspector): { done: number; total: number } | null {
+  return s.plan.length > 1 ? { done: s.plan.filter((p) => p.status === "completed").length, total: s.plan.length } : null
+}
+
+/** "███████░░░░░ 5/8": how far a suite has got, in `cells` cells. */
+export function progressBar(done: number, total: number, cells: number): [string, string] {
+  const filled = total ? Math.round((Math.min(done, total) / total) * cells) : 0
+  return ["█".repeat(filled), "░".repeat(cells - filled)]
+}
+
+export function StatusBar(props: {
+  running: boolean
+  who: string
+  activity: string
+  elapsed: string
+  status: string
+  width: number
+  onStop: () => void
+  /** A suite's cases: done so far, of how many. */
+  progress?: { done: number; total: number } | null
+  /** Buttons for the view (Panels, Wide chat), before Stop; the first to give way when the line is short. */
+  actions?: Button[]
+}) {
   const done = props.status === "done"
   const failed = props.status === "fail"
   const color = props.running ? theme.warn : done ? theme.ok : failed ? theme.err : theme.muted
@@ -97,7 +138,13 @@ export function StatusBar(props: { running: boolean; who: string; activity: stri
         : props.status === "stopped"
           ? "Last request stopped"
           : "Ready for your next request"
-  const room = Math.max(10, props.width - props.who.length - (props.running ? 30 : 6))
+  const bar = props.running && props.progress && props.progress.total > 1 ? props.progress : null
+  const cells = 12
+  const barText = bar ? ` ${bar.done}/${bar.total}  ` : ""
+  const fixed = props.who.length + (props.running ? 30 : 6) + (bar ? cells + barText.length : 0)
+  const actions = fitButtons(props.actions || [], Math.max(0, props.width - fixed - 28))
+  const room = Math.max(10, props.width - fixed - actions.reduce((n, b) => n + b.icon.length + b.label.length + (b.keys ? b.keys.length + 1 : 0) + 4, 0))
+  const [full, empty] = bar ? progressBar(bar.done, bar.total, cells) : ["", ""]
   return (
     <box style={{ flexDirection: "row", justifyContent: "space-between", height: 1, flexShrink: 0, paddingLeft: 1, paddingRight: 1 }}>
       <box style={{ flexDirection: "row" }}>
@@ -107,14 +154,32 @@ export function StatusBar(props: { running: boolean; who: string; activity: stri
           <span fg={props.running ? theme.muted : color}>{`${props.running ? "  " : " "}${clip(what, room)}`}</span>
         </text>
       </box>
+      <box style={{ flexDirection: "row" }}>
+        {actions.map((b) => (
+          <box key={b.label} onMouseDown={b.onPress} style={{ flexDirection: "row", paddingLeft: 1, paddingRight: 1, marginLeft: 1, backgroundColor: theme.button }}>
+            <text>
+              <span fg={b.color}>{`${b.icon} `}</span>
+              <span fg={theme.text}>{b.label}</span>
+              {b.keys ? <span fg={theme.faint}>{` ${b.keys}`}</span> : null}
+            </text>
+          </box>
+        ))}
       {props.running ? (
-        <box style={{ flexDirection: "row" }}>
+        <box style={{ flexDirection: "row", marginLeft: 2 }}>
+          {bar ? (
+            <text>
+              <span fg={theme.ok}>{full}</span>
+              <span fg={theme.border}>{empty}</span>
+              <span fg={theme.muted}>{barText}</span>
+            </text>
+          ) : null}
           <text fg={theme.faint}>{`${props.elapsed}  `}</text>
           <box onMouseDown={props.onStop} style={{ paddingLeft: 1, paddingRight: 1, backgroundColor: theme.warn }}>
             <text fg={theme.onButton}>{"■ Stop · esc"}</text>
           </box>
         </box>
       ) : null}
+      </box>
     </box>
   )
 }
@@ -132,9 +197,9 @@ const PROGRESS_MARK: Record<Progress["status"], [string, string]> = {
   skipped: ["■", theme.faint],
 }
 
-type PlanLine = { mark: string; color: string; text: string; textColor: string }
+export type PlanLine = { mark: string; color: string; text: string; textColor: string }
 
-function planLines(s: Inspector): PlanLine[] {
+export function planLines(s: Inspector): PlanLine[] {
   const lines: PlanLine[] = []
   for (const p of s.plan) {
     const [mark, color] = PLAN_MARK[p.status] || PLAN_MARK.pending!
@@ -154,20 +219,33 @@ export function planRows(s: Inspector, cap: number): number {
   return n ? Math.min(cap, n) + PANEL_CHROME : 0
 }
 
-/** The agent's to-do list, then the browser steps or suite cases; the latest that fit. */
-export function PlanPanel({ s, width, height }: { s: Inspector; width: number; height: number }) {
+/** The rows of `total` a panel of `rows` shows: the latest, or, while a row is selected, a window that keeps it in view. */
+export function windowRows(total: number, rows: number, selected?: number): [number, number] {
+  if (selected === undefined) return [Math.max(0, total - rows), total]
+  const first = Math.max(0, Math.min(selected - Math.floor(rows / 2), total - rows))
+  return [first, Math.min(total, first + rows)]
+}
+
+/** The agent's to-do list, then the browser steps or suite cases; the latest that fit, or around the selected one. */
+export function PlanPanel(props: { s: Inspector; width: number; height: number; selected?: number; onFocus?: () => void }) {
+  const { s, width, height } = props
   const lines = planLines(s)
   const done = s.plan.filter((p) => p.status === "completed").length
   const count = s.plan.length ? ` · ${done} of ${s.plan.length}` : s.progress.items.length ? ` · ${clip(s.progress.title, 40)}` : ""
-  const shown = lines.slice(-Math.max(1, height - PANEL_CHROME))
+  const [first, last] = windowRows(lines.length, Math.max(1, height - PANEL_CHROME), props.selected)
   return (
-    <Panel title={`Plan${count}`} color={SECTION.plan} width={width} height={height}>
-      {shown.map((l, i) => (
-        <text key={i}>
-          <span fg={l.color}>{`${l.mark} `}</span>
-          <span fg={l.textColor}>{clip(l.text, Math.max(10, width - 8))}</span>
-        </text>
-      ))}
+    <Panel title={`Plan${count}`} color={SECTION.plan} width={width} height={height} focused={props.selected !== undefined} keys="↑↓ select · enter details · esc chat" onFocus={props.onFocus}>
+      {lines.slice(first, last).map((l, i) => {
+        const active = first + i === props.selected
+        return (
+          <box key={first + i} style={{ flexDirection: "row", height: 1, flexShrink: 0, backgroundColor: active ? theme.button : undefined }}>
+            <text>
+              <span fg={l.color}>{`${l.mark} `}</span>
+              <span fg={active ? theme.text : l.textColor}>{clip(l.text, Math.max(10, width - 8))}</span>
+            </text>
+          </box>
+        )
+      })}
     </Panel>
   )
 }
@@ -184,6 +262,12 @@ const ACTIVITY_STYLE: Record<string, [string, string, string]> = {
   err: ["✗", theme.err, theme.text],
 }
 
+/** A tool line's call and its arguments in brackets, or null when it has none. */
+export function toolArgs(text: string): [string, string] | null {
+  const at = text.indexOf(" (")
+  return at > 0 && text.endsWith(")") ? [text.slice(0, at), text.slice(at + 1)] : null
+}
+
 /** One activity line, its mark in a column of its own so wrapped text stays under the text. */
 export function ActivityRow({ line }: { line: Line }) {
   const [mark, markColor, textColor] = ACTIVITY_STYLE[line.kind] || ["·", theme.faint, theme.muted]
@@ -192,26 +276,78 @@ export function ActivityRow({ line }: { line: Line }) {
       <text fg={markColor} style={{ width: 2, flexShrink: 0 }}>
         {mark}
       </text>
-      <text fg={textColor} style={{ flexGrow: 1, flexShrink: 1 }}>
-        {line.text || " "}
-      </text>
+      {line.kind === "tool" && toolArgs(line.text) ? (
+        // "Azure DevOps · pipelines build (action list, project QI-Claims)": the call readable, its arguments quiet.
+        <text style={{ flexGrow: 1, flexShrink: 1 }}>
+          <span fg={theme.text}>{toolArgs(line.text)![0]}</span>
+          <span fg={theme.faint}>{` ${toolArgs(line.text)![1]}`}</span>
+        </text>
+      ) : (
+        <text fg={textColor} style={{ flexGrow: 1, flexShrink: 1 }}>
+          {line.text || " "}
+        </text>
+      )}
     </box>
   )
 }
 
-/** Everything the agents do, newest at the bottom. */
-export function ActivityPanel(props: { lines: Line[]; scrollRef: RefObject<ScrollBoxRenderable | null>; width: number; height: number }) {
+/** What the activity panel can narrow to, and the key for each while it has focus. */
+export const ACTIVITY_FILTERS = [
+  { id: "all", label: "All", key: "a", kinds: null },
+  { id: "errors", label: "Errors", key: "e", kinds: ["err"] },
+  { id: "steps", label: "Steps", key: "s", kinds: ["ok", "err", "thought", "memory", "timing"] },
+  { id: "tools", label: "Tools", key: "t", kinds: ["tool", "file", "code"] },
+] as const
+export type ActivityFilter = (typeof ACTIVITY_FILTERS)[number]["id"]
+
+export function filterActivity(lines: Line[], filter: ActivityFilter): Line[] {
+  const kinds = ACTIVITY_FILTERS.find((f) => f.id === filter)?.kinds
+  return kinds ? lines.filter((l) => (kinds as readonly string[]).includes(l.kind)) : lines
+}
+
+/** Everything the agents do, newest at the bottom; focused, it scrolls and narrows to errors, steps, or tools. */
+export function ActivityPanel(props: {
+  lines: Line[]
+  scrollRef: RefObject<ScrollBoxRenderable | null>
+  width: number
+  height: number
+  filter?: ActivityFilter
+  focused?: boolean
+  onFocus?: () => void
+  onFilter?: (f: ActivityFilter) => void
+}) {
+  const filter = props.filter || "all"
+  const shown = filterActivity(props.lines, filter)
+  const label = ACTIVITY_FILTERS.find((f) => f.id === filter)!.label
+  const count = filter === "all" ? (shown.length ? ` · ${shown.length}` : "") : ` · ${label} ${shown.length} of ${props.lines.length}`
   return (
-    <Panel title={`Activity${props.lines.length ? ` · ${props.lines.length}` : ""}`} color={SECTION.activity} width={props.width} height={props.height}>
-      {props.lines.length ? (
+    <Panel title={`Activity${count}`} color={SECTION.activity} width={props.width} height={props.height} focused={props.focused} keys="↑↓ pgup pgdn scroll · esc chat" onFocus={props.onFocus}>
+      {props.focused || filter !== "all" ? (
+        <box style={{ flexDirection: "row", height: 1, flexShrink: 0 }}>
+          {ACTIVITY_FILTERS.map((f) => {
+            const on = f.id === filter
+            return (
+              <box key={f.id} onMouseDown={() => props.onFilter?.(f.id)} style={{ paddingLeft: 1, paddingRight: 1, marginRight: 1, backgroundColor: on ? SECTION.activity : theme.button }}>
+                <text>
+                  <span fg={on ? theme.onButton : theme.text}>{f.key}</span>
+                  <span fg={on ? theme.onButton : theme.muted}>{` ${f.label}`}</span>
+                </text>
+              </box>
+            )
+          })}
+        </box>
+      ) : null}
+      {shown.length ? (
         <scrollbox ref={props.scrollRef} stickyScroll stickyStart="bottom" style={{ flexGrow: 1 }} focused={false}>
-          {props.lines.map((line) => (
+          {shown.map((line) => (
             <ActivityRow key={line.id} line={line} />
           ))}
         </scrollbox>
       ) : (
         <box style={{ flexGrow: 1, justifyContent: "center", alignItems: "center" }}>
-          <text fg={theme.faint}>{clip("Tool calls, browser steps, and the agents' reasoning show here", Math.max(10, props.width - 4))}</text>
+          <text fg={theme.faint}>
+            {clip(props.lines.length ? `Nothing under ${label} yet` : "Tool calls, browser steps, and the agents' reasoning show here", Math.max(10, props.width - 4))}
+          </text>
         </box>
       )}
     </Panel>
@@ -231,31 +367,37 @@ function fileLabel(path: string, room: number): [string, string] {
   return [name, dir && (dir.length <= space || space >= 12) ? tailCut(dir, space) : ""]
 }
 
-export function FilesPanel({ s, width, height }: { s: Inspector; width: number; height: number }) {
+export function FilesPanel(props: { s: Inspector; width: number; height: number; selected?: number; onFocus?: () => void; onOpen?: (file: string) => void }) {
+  const { s, width, height } = props
   const files = filesByUse(s)
   const rows = height - PANEL_CHROME
   const room = Math.max(8, width - 10)
-  const listed = files.length > rows ? files.slice(0, rows - 1) : files
+  const focused = props.selected !== undefined
+  // Unfocused: the most recent, and how many more; focused: a window that follows the selection through all of them.
+  const [first, last] = focused ? windowRows(files.length, rows, props.selected) : [0, files.length > rows ? rows - 1 : files.length]
   return (
-    <Panel title={`Files${files.length ? ` · ${files.length}` : ""}`} color={SECTION.files} width={width} height={height}>
+    <Panel title={`Files${files.length ? ` · ${files.length}` : ""}`} color={SECTION.files} width={width} height={height} focused={focused} keys="enter open" onFocus={props.onFocus}>
       {files.length ? (
-        listed.map((f) => {
+        files.slice(first, last).map((f, i) => {
           const [mark, color] = FILE_MARK[f.last]
           const [name, dir] = fileLabel(f.path, room)
           const times = f.reads + f.changes
+          const active = first + i === props.selected
           return (
-            <text key={f.path}>
-              <span fg={color}>{`${mark} `}</span>
-              <span fg={f.changes ? theme.text : theme.muted}>{name}</span>
-              {dir ? <span fg={theme.faint}>{`  ${dir}`}</span> : null}
-              {times > 1 ? <span fg={theme.faint}>{` ×${times}`}</span> : null}
-            </text>
+            <box key={f.path} onMouseDown={() => props.onOpen?.(f.path)} style={{ flexDirection: "row", height: 1, flexShrink: 0, backgroundColor: active ? theme.button : undefined }}>
+              <text>
+                <span fg={color}>{`${mark} `}</span>
+                <span fg={f.changes || active ? theme.text : theme.muted}>{name}</span>
+                {dir ? <span fg={theme.faint}>{`  ${dir}`}</span> : null}
+                {times > 1 ? <span fg={theme.faint}>{` ×${times}`}</span> : null}
+              </text>
+            </box>
           )
         })
       ) : (
         <text fg={theme.faint}>{"None yet"}</text>
       )}
-      {files.length > listed.length ? <text fg={theme.faint}>{`+${files.length - listed.length} more`}</text> : null}
+      {!focused && files.length > last ? <text fg={theme.faint}>{`+${files.length - last} more`}</text> : null}
     </Panel>
   )
 }

package/src/tui/next.ts

@@ -0,0 +1,43 @@
+import { existsSync } from "node:fs"
+import path from "node:path"
+
+import type { FollowUp } from "../brain/prompt.ts"
+import type { Produced } from "./transcript.tsx"
+
+/**
+ * What to do next, after a request: a few one-click follow-ups from what it actually produced (a run that passed and
+ * has no test yet, a failed run, a report to open). Requests are put in the prompt to adjust; nothing is sent by a chip.
+ */
+
+export type NextStep = { label: string; run: { kind: "insert"; text: string } | { kind: "open"; path: string } }
+
+/**
+ * `followUps`: what ForgeQE's agent suggests from its answer ("Write a release report"), after what the request
+ * produced; a follow-up that repeats a step already offered is left out.
+ */
+export function nextSteps(p: Produced, opts: { testsOn: boolean; followUps?: FollowUp[] }): NextStep[] {
+  const steps: NextStep[] = []
+  const report = p.reports.at(-1)
+  if (report && existsSync(report.html)) steps.push({ label: "Open the report", run: { kind: "open", path: report.html } })
+  const run = p.runs.at(-1)
+  const suite = p.suites.at(-1)
+  if (suite) {
+    if (existsSync(suite.html)) steps.push({ label: "Open the suite report", run: { kind: "open", path: suite.html } })
+    steps.push({ label: "Rerun the cases that failed", run: { kind: "insert", text: "Run the cases that failed in the last suite again" } })
+  } else if (run) {
+    const report = path.join(run.runDir, "report.html")
+    if (run.status === "complete" && !p.tests.some((t) => t.runDir === run.runDir)) steps.push({ label: "Write a test for this run", run: { kind: "insert", text: "Write a test for the last run" } })
+    if (run.status !== "complete") {
+      steps.push({ label: "Why did it fail?", run: { kind: "insert", text: "Why did the last run fail, and what should change?" } })
+      steps.push({ label: "Run it again, visible", run: { kind: "insert", text: "Run the last goal again in a visible browser" } })
+    }
+    if (existsSync(report)) steps.push({ label: "Open the report", run: { kind: "open", path: report } })
+  }
+  const test = p.tests.at(-1)
+  if (test?.result?.testFile && test.result.status === "passed") steps.unshift({ label: "Open the new test", run: { kind: "open", path: test.result.testFile } })
+  for (const f of opts.followUps || []) {
+    if (steps.some((s) => s.label.toLowerCase() === f.label.toLowerCase())) continue
+    steps.push({ label: f.label, run: { kind: "insert", text: f.request } })
+  }
+  return steps.slice(0, 3)
+}