@capagents/forgeqe 1.0.7 → 1.0.9

package/src/ste.ts

@@ -0,0 +1,184 @@
+/**
+ * How closely a prompt follows ASD-STE100 Simplified Technical English: the share of its sentences that keep the
+ * writing rules that can be checked in text. The full standard also needs its approved-word dictionary, which is
+ * licensed; WORDS holds the common words it does not approve, each with the approved word to use instead.
+ *
+ * Rules checked, per sentence (a list item is one or more sentences):
+ * - length: an instruction has 20 words or fewer; a description has 25 or fewer;
+ * - one instruction per sentence: an instruction does not join a second one with ";" or "and then";
+ * - active voice: an instruction is not passive ("is sent", "are written");
+ * - words: no word from WORDS (e.g., "ensure", "utilize", "prior to");
+ * and per paragraph: 6 sentences or fewer.
+ *
+ * Words are counted as written; text in `code`, a {{placeholder}}, and a "quoted example" each count as one word,
+ * because each is a name the reader takes in whole.
+ */
+
+/** Common words ASD-STE100 does not approve, with the approved word to use instead. */
+export const WORDS: Record<string, string> = {
+  "additional": "more",
+  "approximately": "about",
+  "assist": "help",
+  "attempt": "try",
+  "commence": "start",
+  "comprise": "contain",
+  "e.g.": "for example",
+  "ensure": "make sure",
+  "ensures": "makes sure",
+  "etc.": "a full list, or \"and other\"",
+  "i.e.": "that is",
+  "in order to": "to",
+  "obtain": "get",
+  "prior to": "before",
+  "require": "need",
+  "requires": "needs",
+  "sufficient": "enough",
+  "terminate": "stop",
+  "utilize": "use",
+  "utilise": "use",
+  "via": "through",
+  "whilst": "while",
+  "don't": "do not",
+  "doesn't": "does not",
+  "can't": "cannot",
+  "won't": "will not",
+  "isn't": "is not",
+  "aren't": "are not",
+  "shouldn't": "do not",
+  "wouldn't": "would not",
+  "it's": "it is",
+}
+
+/** Verbs a sentence starts with when it is an instruction (after a leading "If …," or "When …," clause). */
+const VERBS = new Set(
+  (
+    "accept act add answer append apply ask assert attach avoid build call change check choose cite click close compare confirm copy count cover create " +
+    "decide delete derive describe dismiss do edit end explain fill find finish fix flag focus follow generate get give group include insert install " +
+    "join keep leave let limit link list load look make map mark mention merge move name navigate note open pass pick plan point post prefer press put " +
+    "quote raise read record refer remove rename reply report rerun resolve respond retry return review run save say scroll select send set show skip " +
+    "sort split start state stay stop summarise summarize take tell test treat trust try type update use verify wait work write never always"
+  ).split(" "),
+)
+
+const LEAD = /^(if|when|whenever|before|after|unless|while|once|until|for|in|on|with|without|where|to)\b[^,]{0,140},\s+/i
+const PASSIVE = /\b(is|are|was|were|be|been|being)\s+(\w+ly\s+)?(\w+ed|written|sent|given|made|done|shown|taken|known|seen|found|run|built|kept|left|set|put|read|chosen|broken|held)\b/i
+
+export type SentenceIssue = "length" | "two instructions" | "passive" | "word"
+
+export type SteSentence = { text: string; words: number; instruction: boolean; issues: { rule: SentenceIssue; detail: string }[] }
+
+export type SteScore = {
+  /** Sentences that keep every rule, of all sentences, 0 to 1. */
+  score: number
+  sentences: number
+  compliant: number
+  /** Paragraphs with more than 6 sentences. */
+  longParagraphs: number
+  issues: SteSentence[]
+}
+
+/** Text a reader takes in as one word: `code`, {{placeholders}}, and "quoted examples". */
+function collapse(text: string): string {
+  return text
+    .replace(/`[^`]*`/g, "CODE")
+    .replace(/\{\{[^}]*\}\}/g, "NAME")
+    .replace(/"[^"\n]{1,200}"/g, "QUOTE")
+    .replace(/“[^”\n]{1,200}”/g, "QUOTE")
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+}
+
+export function countWords(text: string): number {
+  return (collapse(text).match(/[A-Za-z0-9][\w'’./-]*/g) || []).length
+}
+
+export function isInstruction(sentence: string): boolean {
+  const s = collapse(sentence).replace(/^[\s>*_-]+/, "").replace(LEAD, "")
+  const first = (s.match(/^[A-Za-z']+/)?.[0] || "").toLowerCase()
+  return VERBS.has(first)
+}
+
+/** Sentences of a prompt, by paragraph: list items, and sentences inside them, each one; code blocks and headings left out. */
+const ITEM_MARK = "\u0001"
+
+export function steParagraphs(markdown: string): string[][] {
+  const paragraphs: string[][] = []
+  let fence = false
+  let current: string[] = []
+  const end = () => {
+    if (current.length) paragraphs.push(current)
+    current = []
+  }
+  const blocks: string[] = []
+  for (const raw of markdown.replace(/\r/g, "").split("\n")) {
+    if (/^\s*(```|~~~)/.test(raw)) {
+      fence = !fence
+      continue
+    }
+    if (fence) continue
+    const line = raw.trimEnd()
+    if (!line.trim() || /^#{1,6}\s/.test(line) || /^\s*\|/.test(line) || /^\{\{>/.test(line.trim())) {
+      if (blocks.length) blocks.push("\n")
+      blocks.push("\n")
+      continue
+    }
+    if (/^\s*([-*+]|\d+[.)])\s+/.test(line)) blocks.push("\n", ITEM_MARK + line.replace(/^\s*([-*+]|\d+[.)])\s+/, ""))
+    else blocks.push(` ${line.trim()}`)
+  }
+  // A blank line ends a paragraph. A list is not a paragraph: each item is its own, so only prose counts toward 6.
+  for (const part of blocks.join("").split(/\n\n+/)) {
+    for (const item of part.split("\n")) {
+      if (item.startsWith(ITEM_MARK)) {
+        end()
+        current = splitSentences(item.slice(ITEM_MARK.length))
+        end()
+      } else for (const sentence of splitSentences(item)) current.push(sentence)
+    }
+    end()
+  }
+  end()
+  return paragraphs.filter((p) => p.length)
+}
+
+function splitSentences(text: string): string[] {
+  const t = text.trim()
+  if (!t) return []
+  // Protect what has a full stop inside: abbreviations, versions, file names, and quoted text.
+  const masked = t.replace(/"[^"]*"|`[^`]*`|\b(e\.g|i\.e|etc|vs|approx)\.|\w\.\w/g, (m) => m.replace(/[.!?]/g, "\u0000"))
+  return masked
+    .split(/(?<=[.!?])\s+(?=[A-Z"`(*])/)
+    .map((s) => s.replace(/\u0000/g, ".").trim())
+    .filter((s) => /[A-Za-z]/.test(s))
+}
+
+export function checkSentence(text: string): SteSentence {
+  const words = countWords(text)
+  const instruction = isInstruction(text)
+  const issues: SteSentence["issues"] = []
+  const limit = instruction ? 20 : 25
+  if (words > limit) issues.push({ rule: "length", detail: `${words} words; ${instruction ? "an instruction" : "a description"} has ${limit} or fewer` })
+  const plain = collapse(text)
+  if (instruction && (/;\s+\w/.test(plain) || /,?\s+and then\s+/i.test(plain))) issues.push({ rule: "two instructions", detail: "one instruction per sentence" })
+  if (instruction && PASSIVE.test(plain)) issues.push({ rule: "passive", detail: `"${plain.match(PASSIVE)![0]}": use the active voice` })
+  const lower = ` ${plain.toLowerCase()} `
+  for (const [word, use] of Object.entries(WORDS)) {
+    const at = lower.search(new RegExp(`[^a-z]${word.replace(/[.]/g, "\\.")}[^a-z]`))
+    if (at >= 0) issues.push({ rule: "word", detail: `"${word}": use ${use}` })
+  }
+  return { text, words, instruction, issues }
+}
+
+export function steScore(markdown: string): SteScore {
+  const paragraphs = steParagraphs(markdown)
+  const all = paragraphs.flat().map(checkSentence)
+  const compliant = all.filter((s) => !s.issues.length).length
+  return {
+    score: all.length ? compliant / all.length : 1,
+    sentences: all.length,
+    compliant,
+    longParagraphs: paragraphs.filter((p) => p.length > 6).length,
+    issues: all.filter((s) => s.issues.length),
+  }
+}
+
+/** The share of sentences every built-in prompt keeps to; a project's own prompts are scored against it too. */
+export const STE_TARGET = 0.8

package/src/tui/App.tsx

@@ -26,7 +26,9 @@ import { meterSnapshot, requestLine } from "../usage.ts"
 import { cleanSelection, copyText } from "./clipboard.ts"
 import { ButtonBar, ChoicePanel, Footer, Hints, Logo, Prompt, Spinner, type Button, type Hint } from "./components.tsx"
 import { setupChecklist, type SetupItem } from "./setup.ts"
-import { EXAMPLES, TIPS, formatDuration, formatTokens, packageVersion, pick, shortCwd, theme } from "./theme.ts"
+import { ShortcutsPanel } from "./shortcuts.tsx"
+import { ago, projectLine, setupSentence, recentWork, startActions, type RecentItem, type StartAction } from "./landing.ts"
+import { TIPS, formatDuration, formatTokens, packageVersion, shortCwd, theme } from "./theme.ts"
 import { emptyProduced, Line, Produced, producedCard, TestsSetting, TranscriptLine } from "./transcript.tsx"
 import { Dialog, dialogSpec } from "./dialogs.ts"
 import { activityFromLog, clip, hostOf, modelLabel } from "./text.ts"
@@ -154,6 +156,12 @@ export function App({ options }: { options: TuiOptions }) {
   const [next, setNext] = useState<NextStep[]>([])
   /** What the prompt holds, for suggestions; and the suggestion state: which is selected, which word was dismissed. */
   const [promptText, setPromptText] = useState("")
+  // The rows the request in the prompt needs; the start screen gives a long one room by folding its other sections.
+  const [promptLines, setPromptLines] = useState(1)
+  const [tipIndex, setTipIndex] = useState(() => Math.floor(Math.random() * TIPS.length))
+  const [shortcuts, setShortcuts] = useState(false)
+  const shortcutsRef = useRef(false)
+  shortcutsRef.current = shortcuts
   const [sugg, setSugg] = useState<{ selected: number; dismissed?: string }>({ selected: 0 })
   const [workItem, setWorkItem] = useState<WorkItem | null | undefined>(undefined)
   const suggRef = useRef<{ list: Suggestion[]; trigger: ReturnType<typeof triggerAt> }>({ list: [], trigger: null })
@@ -171,7 +179,7 @@ export function App({ options }: { options: TuiOptions }) {
   const [narrowView, setNarrowView] = useState<"chat" | "details">("chat")
   // The split view's chat at the full width, for reading a long answer; the panels come back with Split view.
   const [chatWide, setChatWide] = useState(false)
-  const setupRef = useRef<{ key: string; items: SetupItem[] }>({ key: "", items: [] })
+  const setupRef = useRef<{ key: string; items: SetupItem[]; start: StartAction[]; recent: RecentItem[] }>({ key: "", items: [], start: [], recent: [] })
   // Which panel the keys go to (shift+tab moves on), the row selected in the plan and files, and the activity filter.
   const [nav, setNavState] = useState<{ focus: Focus; plan: number; files: number; filter: ActivityFilter }>({ focus: "chat", plan: 0, files: 0, filter: "all" })
   const navRef = useRef(nav)
@@ -183,6 +191,8 @@ export function App({ options }: { options: TuiOptions }) {
   const contextInfo = useRef<{ key: string; knowledge: number; mcp: string[] }>({ key: "", knowledge: 0, mcp: [] })
 
   const [lines, setLines] = useState<Line[]>([])
+  const linesRef = useRef(0)
+  linesRef.current = lines.length
   const [headed, setHeaded] = useState(Boolean(options.headed))
   const [maxSteps, setMaxSteps] = useState(40)
   const [profile, setProfile] = useState(options.profile || "")
@@ -201,8 +211,6 @@ export function App({ options }: { options: TuiOptions }) {
   const [coding, setCoding] = useState(false)
   const [suiteProgress, setSuiteProgress] = useState<{ done: number; total: number } | null>(null)
   const [copied, setCopied] = useState("")
-  const [example] = useState(() => pick(EXAMPLES))
-  const [tip] = useState(() => pick(TIPS))
   const started = useRef<number | null>(null)
 
   const detailRef = useRef<Detail>(detailFrom(options.verbose))
@@ -289,6 +297,13 @@ export function App({ options }: { options: TuiOptions }) {
     return () => clearInterval(timer)
   }, [status])
 
+  // The start screen's tip changes every 8 seconds; only while it shows, so a session does not re-render for it.
+  useEffect(() => {
+    if (lines.length || status === "running") return
+    const timer = setInterval(() => setTipIndex((n) => n + 1), 8000)
+    return () => clearInterval(timer)
+  }, [lines.length, status])
+
   // The terminal hands mouse drags to the TUI, so text selected with the mouse is copied here when the drag ends.
   useEffect(() => {
     let timer: ReturnType<typeof setTimeout> | undefined
@@ -562,6 +577,7 @@ export function App({ options }: { options: TuiOptions }) {
     else if (run.id === "details" || run.id === "chat") setNarrowView(run.id)
     else if (run.id === "refine") refineRef.current()
     else if (run.id === "wide") setChatWide((w) => !w)
+    else if (run.id === "shortcuts") setShortcuts(true)
     else if (run.id === "panels") setNav((n) => ({ ...n, focus: planLines(inspRef.current).length ? "plan" : "activity" }))
   }
 
@@ -575,6 +591,8 @@ export function App({ options }: { options: TuiOptions }) {
   }
 
   useKeyboard((key) => {
+    // Esc is the shell's (stop, close a list or panel, cancel): the prompt never acts on it, or it would lose focus.
+    if (key.name === "escape") key.preventDefault()
     const pal = paletteRef.current
     if (pal) {
       // Keys can arrive faster than renders: every change builds on the latest state, never on this render's copy.
@@ -652,11 +670,15 @@ export function App({ options }: { options: TuiOptions }) {
     const insp = inspRef.current
     const shown = (f: Focus) => f === "activity" || f === "files" || (f === "plan" && planLines(insp).length > 0) || (f === "chat" && width >= SPLIT_MIN)
     if (panes && key.name === "tab" && key.shift && !entryRef.current) {
+      // Consumed here: the prompt can take focus within this key press and must not also act on it.
+      key.preventDefault()
       setNav((n) => ({ ...n, focus: nextFocus(n.focus, shown) }))
       return
     }
     const at = navRef.current.focus
     if (panes && at !== "chat" && shown(at)) {
+      // Keys a panel takes are its own: the prompt, focused again by esc, must not see the same esc (it would blur).
+      if (key.name === "escape" || key.name === "return" || key.name === "enter" || key.name === "kpenter") key.preventDefault()
       const list = at === "plan" ? planLines(insp).length : at === "files" ? filesByUse(insp).length : 0
       const move = (d: number) => setNav((n) => ({ ...n, [at]: Math.max(0, Math.min(list - 1, (n[at as "plan" | "files"] ?? 0) + d)) }))
       const page = Math.max(3, Math.floor(height / 3))
@@ -691,6 +713,23 @@ export function App({ options }: { options: TuiOptions }) {
       if (!key.ctrl && !key.meta && key.sequence && key.sequence.length === 1 && key.sequence > " " && width >= SPLIT_MIN) return setNav((n) => ({ ...n, focus: "chat" }))
       if (!key.ctrl && !key.meta) return
     }
+    // ? on an empty prompt: every key in one panel; esc or ? closes it.
+    if (shortcutsRef.current) {
+      if (key.name === "escape" || key.sequence === "?") setShortcuts(false)
+      return
+    }
+    if (key.sequence === "?" && !promptTextRef.current.trim() && !entryRef.current && !dialogRef.current) {
+      setShortcuts(true)
+      setDraft("")
+      setInputKey((k) => k + 1)
+      return
+    }
+    // The start screen's actions: alt+1 to alt+4 put one in the prompt.
+    if (key.meta && /^[1-4]$/.test(key.name || "") && linesRef.current === 0 && !abortRef.current) {
+      const a = setupRef.current.start[Number(key.name) - 1]
+      if (a) fillPrompt(a.request)
+      return
+    }
     if (suggRef.current.list.length && suggRef.current.trigger && !entryRef.current) {
       const n = suggRef.current.list.length
       if (key.name === "up") return setSugg((x) => ({ ...x, selected: (x.selected + n - 1) % n }))
@@ -1322,7 +1361,9 @@ export function App({ options }: { options: TuiOptions }) {
     : [{ icon: "◧", label: "Details", keys: "ctrl+o", color: theme.thought, onPress: () => setNarrowView("details"), drop: 1 }]
   const idleButtons: Button[] = [refineButton, searchButton, ...viewButtons, ...(wide ? [] : [{ icon: "⇄", label: "Profile", keys: "tab", color: theme.muted, onPress: cycleProfile, drop: 4 }])]
   const runningButtons: Button[] = [{ icon: "■", label: "Stop", keys: "esc", color: theme.warn, onPress: () => openDialog("stop") }, searchButton, ...viewButtons]
-  const idleHints: Hint[] = [...copiedHint, ...(lastStats && !wide && !copied ? [{ key: `last run ${lastStats}`, label: "" }] : []), closeHint]
+  const shortcutsHint: Hint = { key: "?", label: "shortcuts", onPress: () => setShortcuts(true) }
+  // ? is offered where there is room for it: the start screen of a terminal 110 columns or wider; it works everywhere.
+  const idleHints: Hint[] = [...copiedHint, ...(lastStats && !wide && !copied ? [{ key: `last run ${lastStats}`, label: "" }] : []), ...(home && width >= 110 ? [shortcutsHint] : []), closeHint]
   // The one-pane view has no tokens panel, so the tokens and time show here.
   const runningHints: Hint[] = [...copiedHint, ...(wide || copied ? [] : [{ key: `${formatTokens(tokens)} tokens · ${elapsed}`, label: "" }]), closeHint]
   const runningLeft = (
@@ -1420,52 +1461,147 @@ export function App({ options }: { options: TuiOptions }) {
             promptTextRef.current = t
             setPromptText(t)
           }}
+          onLines={setPromptLines}
         />
         <ButtonBar width={promptWidth} buttons={running ? runningButtons : idleButtons} hints={running ? runningHints : idleHints} left={running ? runningLeft : undefined} />
       </>
     )
   }
 
+  // Back on the start screen after /clear, its sections are read again: new reports and runs show up.
+  if (!home) setupRef.current.key = ""
+  const shortcutsOverlay = shortcuts ? <ShortcutsPanel width={width} wide={width >= SPLIT_MIN} onClose={() => setShortcuts(false)} /> : null
+
   if (home) {
-    const promptWidth = Math.max(40, Math.min(width - 8, 120))
+    // One column, as wide as the prompt, every section on its left edge.
+    const promptWidth = Math.max(40, Math.min(width - 8, 140))
     // What is set up, while something is not: each open item says how, or runs the command that does it.
     const cfgHome = configRef.current
     const setupKey = cfgHome ? `${cfgHome.configPath}|${cfgHome.activeProfile}` : ""
-    if (cfgHome && setupRef.current.key !== setupKey) setupRef.current = { key: setupKey, items: setupChecklist(cfgHome) }
-    const setup = setupRef.current.items
+    if (cfgHome && setupRef.current.key !== setupKey) {
+      setupRef.current = {
+        key: setupKey,
+        items: setupChecklist(cfgHome),
+        start: startActions(cfgHome),
+        recent: recentWork(path.resolve(cfgHome.export.outDir)),
+      }
+    }
+    const { items: setup, start, recent } = setupRef.current
     const open = setup.filter((i) => !i.done)
-    const pickSetup = (i: SetupItem) => (i.command ? submitRef.current(i.command) : i.fix && push("sys", i.fix, "chat"))
+    // Each missing item with how to set it up, in the chat; the first that a command sets up (/auth) is offered last.
+    const explainSetup = (items: SetupItem[]) => push("sys", items.map((i) => `○ ${i.fix}${i.command ? ` Type ${i.command} to start.` : ""}`).join("\n"), "chat")
+    const facts = projectLine(cfgHome, process.cwd(), cfgHome ? modelLabel(cfgHome) : "")
+
+    // Rows: the logo, the project line, and the prompt always; then Start with, Continue, and Setup while they fit.
+    // A long request takes rows from them, last section first, so the box never scrolls while there is room.
+    const loading = !cfgHome
+    // Each section is a blank row and then its own rows: a heading and its items, or the setup line.
+    const startRows = loading ? 1 + 1 + 4 : start.length ? 1 + 1 + start.length : 0
+    const recentRows = recent.length ? 1 + 1 + recent.length : 0
+    const setupRows = loading || open.length ? 2 : 0
+    const fixed = 5 + 2 + 1 + 5 + 1 + 1 + 1 // logo, project line, gap, prompt chrome, buttons, footer, one row to spare
+    const room = height - fixed
+    const want = Math.max(5, Math.min(promptLines, room - 1))
+    let left = room - want
+    const showStart = startRows > 0 && left >= startRows
+    if (showStart) left -= startRows
+    const showRecent = recentRows > 0 && left >= recentRows
+    if (showRecent) left -= recentRows
+    const showSetup = setupRows > 0 && left >= setupRows
+    const maxRows = Math.max(5, room - (showStart ? startRows : 0) - (showRecent ? recentRows : 0) - (showSetup ? setupRows : 0))
+    const heading = (t: string) => <text fg={theme.muted}>{t}</text>
+    const keyCell = (k: string) => <span fg={theme.faint}>{k.padEnd(4)}</span>
+    const done = setup.length - open.length
     return (
       <box style={{ flexDirection: "column", flexGrow: 1 }}>
-        <box style={{ flexDirection: "column", flexGrow: 1, alignItems: "center", justifyContent: "center" }}>
+        {/* Clipped, never pushed: the footer stays on screen whatever the sections above it need. */}
+        <box style={{ flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 0, overflow: "hidden", alignItems: "center", justifyContent: "center" }}>
           <Logo />
-          <box style={{ height: 2 }} />
-          {renderControls(promptWidth, `Describe a goal… "${example}"`, [4, Math.max(4, Math.min(12, height - 22))])}
-          <box style={{ height: open.length ? 2 : 3 }} />
-          {open.length ? (
-            <box style={{ flexDirection: "column", alignItems: "center", flexShrink: 0, marginBottom: 1 }}>
-              <box style={{ flexDirection: "row", flexShrink: 0 }}>
-                <text fg={theme.muted}>{"Setup  "}</text>
-                {(setup.reduce((n, i) => n + i.label.length + 5, 7) <= width - 4 ? setup : open).map((i) => (
-                  <box key={i.id} onMouseDown={i.done ? undefined : () => pickSetup(i)} style={{ flexDirection: "row", paddingLeft: 1, paddingRight: 1, marginRight: 1, backgroundColor: i.done ? undefined : theme.button }}>
-                    <text>
-                      <span fg={i.done ? theme.ok : theme.warn}>{i.done ? "✓ " : "○ "}</span>
-                      <span fg={i.done ? theme.muted : theme.text}>{i.label}</span>
+          <box style={{ paddingTop: 1, height: 2, flexShrink: 0 }}>
+          <text>
+            {facts.length ? (
+              facts.map((f, i) => (
+                <span key={i} fg={i === 0 ? theme.text : theme.muted}>
+                  {`${i ? "  ·  " : ""}${f}`}
+                </span>
+              ))
+            ) : (
+              <span fg={theme.faint}>{" "}</span>
+            )}
+          </text>
+          </box>
+          <box style={{ height: 1, flexShrink: 0 }} />
+          <box style={{ flexDirection: "column", width: promptWidth, flexShrink: 0 }}>
+            {renderControls(promptWidth, "Describe what you want to test…", [5, maxRows])}
+            {showStart ? (
+              <box style={{ flexDirection: "column", marginTop: 1, height: startRows - 1, flexShrink: 0 }}>
+                {heading("Start with")}
+                {loading
+                  ? [0, 1, 2, 3].map((i) => <text key={i} fg={theme.faint}>{i ? " " : "  Loading what works in this setup…"}</text>)
+                  : start.map((a, i) => (
+                      <box key={a.id} onMouseDown={() => fillPrompt(a.request)} style={{ flexDirection: "row", justifyContent: "space-between", flexShrink: 0 }}>
+                        <text>
+                          <span fg={theme.accent}>{"  ▸ "}</span>
+                          <span fg={theme.text}>{a.label.padEnd(32)}</span>
+                          <span fg={theme.faint}>{clip(a.detail, Math.max(10, promptWidth - 50))}</span>
+                        </text>
+                        <text>{keyCell(`alt+${i + 1}`)}</text>
+                      </box>
+                    ))}
+              </box>
+            ) : null}
+            {showRecent ? (
+              <box style={{ flexDirection: "column", marginTop: 1, height: recentRows - 1, flexShrink: 0 }}>
+                {heading("Continue")}
+                {recent.map((r) => (
+                  <box key={r.dir} style={{ flexDirection: "row", justifyContent: "space-between", flexShrink: 0 }}>
+                    <text onMouseDown={() => openFile(r.open)}>
+                      <span fg={r.kind === "report" ? theme.memory : r.status === "complete" || r.status === "passed" ? theme.ok : r.status ? theme.err : theme.muted}>
+                        {r.kind === "report" ? "  ▤ " : r.status === "complete" || r.status === "passed" ? "  ✓ " : r.status ? "  ✗ " : "  ▸ "}
+                      </span>
+                      <span fg={theme.muted}>{r.kind === "report" ? "Report  " : "Run     "}</span>
+                      <span fg={theme.text}>{clip(r.title, Math.max(10, promptWidth - 40))}</span>
                     </text>
+                    <box style={{ flexDirection: "row" }}>
+                      <text fg={theme.faint}>{`${ago(r.when)}  `}</text>
+                      <text fg={theme.accent} onMouseDown={() => openFile(r.open)}>
+                        {"open"}
+                      </text>
+                      {r.kind === "run" ? (
+                        <text fg={theme.accent} onMouseDown={() => fillPrompt(`Run this goal again: ${r.title}`)}>
+                          {"  rerun"}
+                        </text>
+                      ) : null}
+                    </box>
                   </box>
                 ))}
               </box>
-              <text fg={theme.faint}>{`${setup.length - open.length} of ${setup.length} set up · click one to see how · /features shows what each feature needs`}</text>
-            </box>
-          ) : null}
-          <text>
-            <span fg={theme.warn}>{"● "}</span>
-            <span fg={theme.text}>{"Tip "}</span>
-            <span fg={theme.muted}>{tip}</span>
-          </text>
+            ) : null}
+            {showSetup ? (
+              // Setup in one line: how far it is, what is missing in words, and one link that says how to set it up.
+              <box style={{ flexDirection: "row", height: 1, flexShrink: 0, marginTop: 1 }}>
+                <text>
+                  <span fg={theme.muted}>{"Setup  "}</span>
+                  <span fg={theme.ok}>{"▰".repeat(done)}</span>
+                  <span fg={theme.muted}>{"▱".repeat(open.length)}</span>
+                  <span fg={theme.muted}>{loading ? "  checking…" : `  ${done} of ${setup.length} · `}</span>
+                  {loading ? null : <span fg={theme.text}>{setupSentence(open.map((i) => i.label), promptWidth - 44)}</span>}
+                </text>
+                {loading ? null : (
+                  <box onMouseDown={() => explainSetup(open)} style={{ marginLeft: 2, paddingLeft: 1, paddingRight: 1, backgroundColor: theme.button }}>
+                    <text>
+                      <span fg={theme.warn}>{"▸ "}</span>
+                      <span fg={theme.text}>{"how to set up"}</span>
+                    </text>
+                  </box>
+                )}
+              </box>
+            ) : null}
+          </box>
         </box>
-        <Footer left={shortCwd()} right={footerRight} width={width} />
+        <Footer left={`● Tip  ${TIPS[tipIndex % TIPS.length]}`} right={footerRight} width={width} cut="end" />
         {paletteOverlay}
+        {shortcutsOverlay}
       </box>
     )
   }
@@ -1559,7 +1695,8 @@ export function App({ options }: { options: TuiOptions }) {
       ) : null}
     </scrollbox>
   )
-  const controls = (paneWidth: number) => renderControls(paneWidth, placeholder, [3, Math.max(3, Math.min(10, Math.floor(height / 3)))])
+  // A long request gets room: the box grows with the text up to nearly half the screen, then scrolls.
+  const controls = (paneWidth: number) => renderControls(paneWidth, placeholder, [3, Math.max(3, Math.floor(height * 0.45))])
 
   const split = width >= SPLIT_MIN
   if (split) {

package/src/tui/components.tsx

@@ -21,7 +21,7 @@ export function Logo() {
   const name = logoRows("forge")
   const suffix = logoRows("QE")
   return (
-    <box style={{ flexDirection: "column", alignItems: "flex-end" }}>
+    <box style={{ flexDirection: "column", alignItems: "flex-end", flexShrink: 0 }}>
       {name.map((row, i) => (
         <text key={i}>
           <span fg={theme.faint}>{row}</span>
@@ -56,6 +56,32 @@ export type PromptProps = {
   focused?: boolean
   /** Called with the text as it changes, for actions on what is being typed (Refine). */
   onText?: (text: string) => void
+  /** Called with the rows the text needs, so the screen around the box can make room for a long request. */
+  onLines?: (lines: number) => void
+}
+
+/** The rows `text` takes when word-wrapped at `width` columns, as the prompt wraps it. */
+export function wrappedLines(text: string, width: number): number {
+  if (width < 1) return 1
+  let rows = 0
+  for (const line of text.split("\n")) {
+    let used = 0
+    let count = 1
+    for (const word of line.split(/(\s+)/)) {
+      if (!word) continue
+      if (used + word.length <= width) used += word.length
+      else if (/^\s+$/.test(word)) used = width
+      else if (word.length > width) {
+        count += Math.ceil((used + word.length) / width) - 1
+        used = (used + word.length) % width
+      } else {
+        count++
+        used = word.length
+      }
+    }
+    rows += count
+  }
+  return Math.max(1, rows)
 }
 
 /** Enter sends; Shift+Enter, Alt+Enter or Ctrl+J start a new line. */
@@ -70,16 +96,31 @@ const PROMPT_KEYS: KeyBinding[] = [
 export function Prompt(props: PromptProps) {
   const edge = `╹${"▀".repeat(Math.max(0, props.width - 1))}`
   const ref = useRef<TextareaRenderable>(null)
-  const [rows, setRows] = useState(props.minRows)
-  useEffect(() => setRows(props.minRows), [props.inputKey, props.minRows])
+  // The rows the text needs; the box shows that many between minRows and maxRows, so it also grows when the screen
+  // around it makes more room (the start screen folds a section for a long request).
+  const [lines, setLines] = useState(1)
+  useEffect(() => setLines(1), [props.inputKey])
+  const rows = Math.min(props.maxRows, Math.max(props.minRows, lines))
+  // The text scrolled while the box was smaller: once it all fits, show it from the top.
+  useEffect(() => {
+    const t = ref.current
+    if (!t || lines > rows || t.scrollY === 0) return
+    // Going to the top scrolls the view there; going back to where the cursor was keeps it there, now that all fits.
+    const at = t.cursorOffset
+    t.gotoBufferHome()
+    t.cursorOffset = at
+  }, [rows, lines])
   // 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)))
+    // virtualLineCount counts only the lines in view, so a box could never ask to grow: count the wrapped lines.
+    const t = ref.current
+    const needed = t ? wrappedLines(t.plainText, t.width || props.width - 5) : 1
+    props.onLines?.(needed)
+    setLines(needed)
   }
   return (
     <box style={{ flexDirection: "column", width: props.width, flexShrink: 0 }}>
@@ -328,9 +369,10 @@ export function ChoicePanel(props: ChoicePanelProps) {
   )
 }
 
-export function Footer({ left, right, width }: { left: string; right: string; width: number }) {
+/** `cut`: which end of `left` gives way when it is too long: the start of a path, the end of a sentence (the tip). */
+export function Footer({ left, right, width, cut = "start" }: { left: string; right: string; width: number; cut?: "start" | "end" }) {
   const room = Math.max(8, width - right.length - 8)
-  const shown = left.length <= room ? left : `…${left.slice(left.length - room + 1)}`
+  const shown = left.length <= room ? left : cut === "end" ? `${left.slice(0, room - 1)}…` : `…${left.slice(left.length - room + 1)}`
   return (
     <box
       style={{ flexDirection: "row", justifyContent: "space-between", paddingLeft: 2, paddingRight: 2, height: 1, flexShrink: 0 }}