@capagents/forgeqe 1.0.5 → 1.0.8

package/src/refine.ts

@@ -6,6 +6,9 @@ import { privateEnvNames } from "./childEnv.ts"
 import { MCP_NAME, TOOL_TIMEOUT_MS, localToolServer } from "./mcp/server.ts"
 import { TOOLS, environmentNotes, type ToolContext } from "./mcp/tools.ts"
 import { prompt } from "./prompts.ts"
+import { CAPABILITIES } from "./capabilities/registry.ts"
+import { allStatuses } from "./capabilities/status.ts"
+import { domainNotes } from "./domain.ts"
 import type { CodeEvent } from "./types.ts"
 
 /**
@@ -17,17 +20,28 @@ import type { CodeEvent } from "./types.ts"
 /** The only tools the refiner may call: each reads, none changes anything or starts a run. */
 export const REFINE_TOOLS = ["capabilities", "query_api", "find_test_cases", "list_sprints", "run_details"]
 
+/** The refined request as a task specification: what ForgeQE's agent is asked to do, in the parts its own prompt uses. */
+export type RefinedSpec = { goal: string; context: string[]; steps: string[]; rules: string[]; result: string }
+
 export type Refined = {
+  /** The request that is sent: the spec written out (Goal, Context, Steps, Rules, Result). */
   refined: string
+  spec?: RefinedSpec
   grounded: { fact: string; checked: boolean }[]
   assumed: string[]
   missing: string[]
 }
 
+const lines = { type: "array", items: { type: "string" } } as const
+
 export const REFINE_SCHEMA = {
   type: "object",
   properties: {
-    refined: { type: "string", description: "The request, precise and complete, as the user would say it" },
+    goal: { type: "string", description: "One instruction that starts with a verb: what the agent must do" },
+    context: { ...lines, description: "Facts the agent needs, one per line: system, project, work items, files, runs, with exact names and ids" },
+    steps: { ...lines, description: "The actions in sequence, one per step; empty for a request with one action" },
+    rules: { ...lines, description: "Limits the user gave or the setup sets, one per line" },
+    result: { type: "string", description: "What the agent must give back" },
     grounded: {
       type: "array",
       items: { type: "object", properties: { fact: { type: "string" }, checked: { type: "boolean" } }, required: ["fact", "checked"] },
@@ -35,7 +49,7 @@ export const REFINE_SCHEMA = {
     assumed: { type: "array", items: { type: "string" } },
     missing: { type: "array", items: { type: "string" } },
   },
-  required: ["refined", "grounded", "assumed", "missing"],
+  required: ["goal", "context", "steps", "rules", "result", "grounded", "assumed", "missing"],
 } as const
 
 const REFINE_AGENT = {
@@ -45,7 +59,36 @@ const REFINE_AGENT = {
     return prompt("refine")
   },
   permission: { edit: "deny", bash: "deny", webfetch: "deny" },
-  steps: 8,
+  steps: 12,
+}
+
+/** The spec as the request ForgeQE's agent gets: labelled parts, empty ones left out. */
+export function composeRefined(spec: RefinedSpec): string {
+  const parts = [`Goal: ${spec.goal}`]
+  if (spec.context.length) parts.push(["Context:", ...spec.context.map((c) => `- ${c}`)].join("\n"))
+  if (spec.steps.length) parts.push(["Steps:", ...spec.steps.map((st, i) => `${i + 1}. ${st}`)].join("\n"))
+  if (spec.rules.length) parts.push(["Rules:", ...spec.rules.map((r) => `- ${r}`)].join("\n"))
+  if (spec.result) parts.push(`Result: ${spec.result}`)
+  return parts.join("\n\n")
+}
+
+/**
+ * What the refiner knows before it calls a tool: each capability, whether it works in this setup and what it still
+ * needs, and the domain. Without this it spends its few steps finding out, and refines blind.
+ */
+export function refineContext(config: AppConfig): string {
+  const statuses = allStatuses(config)
+  const rows = CAPABILITIES.map((c) => {
+    const st = statuses.get(c.id)!
+    const state =
+      st.state === "ready"
+        ? "ready"
+        : st.state === "partial"
+          ? `works; optional: ${st.gaps.map((g) => g.missing).join(", ")}`
+          : `needs setup: ${st.gaps.filter((g) => !g.optional).map((g) => g.missing).join(", ")}`
+    return `- ${c.title} (${state}). Example: "${c.examples[0] || c.title}"`
+  })
+  return ["What ForgeQE can do here:", ...rows, "", domainNotes(config)].join("\n")
 }
 
 export function refineRequest(text: string, recent: { user: string; reply: string }[]): string {
@@ -54,10 +97,13 @@ export function refineRequest(text: string, recent: { user: string; reply: strin
 }
 
 /** Keeps only what the schema allows, so the shell never shows a malformed answer. */
-export function cleanRefined(r: Partial<Refined> | null | undefined, original: string): Refined {
+export function cleanRefined(r: (Partial<Refined> & Partial<RefinedSpec>) | null | undefined, original: string): Refined {
   const strings = (v: unknown) => (Array.isArray(v) ? v.map(String).map((s) => s.trim()).filter(Boolean) : [])
+  const goal = String(r?.goal || "").trim()
+  const spec: RefinedSpec | undefined = goal ? { goal, context: strings(r?.context), steps: strings(r?.steps), rules: strings(r?.rules), result: String(r?.result || "").trim() } : undefined
   return {
-    refined: String(r?.refined || "").trim() || original,
+    refined: spec ? composeRefined(spec) : String(r?.refined || "").trim() || original,
+    ...(spec ? { spec } : {}),
     grounded: Array.isArray(r?.grounded) ? r!.grounded.filter((g) => g && String(g.fact || "").trim()).map((g) => ({ fact: String(g.fact).trim(), checked: g.checked === true })) : [],
     assumed: strings(r?.assumed),
     missing: strings(r?.missing),
@@ -96,7 +142,7 @@ export async function refine(opts: {
       role: "refiner",
       signal: opts.signal,
       onEvent: opts.onEvent,
-      agent: { ...REFINE_AGENT, prompt: `${REFINE_AGENT.prompt}\n\nThis session:\n${environmentNotes(context())}` },
+      agent: { ...REFINE_AGENT, prompt: `${REFINE_AGENT.prompt}\n\nThis session:\n${environmentNotes(context())}\n\n${refineContext(opts.config)}` },
       schema: REFINE_SCHEMA as unknown as Record<string, unknown>,
       mcp: { [MCP_NAME]: tools.entry },
       hideTool: (tool) => tool.startsWith(`${MCP_NAME}_`),
@@ -104,7 +150,7 @@ export async function refine(opts: {
     })
     try {
       let out = await session.prompt(refineRequest(opts.text, opts.recent))
-      if (!out.report && !out.error && !opts.signal?.aborted) out = await session.prompt("Give the structured result: refined, grounded, assumed, and missing.")
+      if (!out.report && !out.error && !opts.signal?.aborted) out = await session.prompt("Give the structured result: goal, context, steps, rules, result, grounded, assumed, and missing.")
       if (!out.report) throw new Error(out.error ? `Refine failed: ${out.error}` : "Refine gave no result.")
       return cleanRefined(out.report, opts.text)
     } finally {

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

@@ -7,6 +7,7 @@ import { useEffect, useRef, useState } from "react"
 import { NO_MODEL_SET_UP } from "../llm.ts"
 import type { CodeEvent, ReplayMode } from "../types.ts"
 import { brainUnavailable, carryOver, openBrain, sessionSetup, type Brain, type BrainOptions } from "../brain/index.ts"
+import type { FollowUp } from "../brain/prompt.ts"
 import { INSTALL_HINT } from "../code/runtime.ts"
 import { briefText, detailFrom, shows, showsAgentTool, stepIntent, type Detail } from "../detail.ts"
 import { stepVerdictLines } from "../cases/types.ts"
@@ -23,7 +24,7 @@ import { counts } from "../suite/report.ts"
 import { buildSummary, shortPath } from "../summary.ts"
 import { meterSnapshot, requestLine } from "../usage.ts"
 import { cleanSelection, copyText } from "./clipboard.ts"
-import { ChoicePanel, Footer, Hints, Logo, Prompt, Spinner, type Hint } from "./components.tsx"
+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 { emptyProduced, Line, Produced, producedCard, TestsSetting, TranscriptLine } from "./transcript.tsx"
@@ -48,6 +49,7 @@ import {
   nextFocus,
   planLines,
   PlanPanel,
+  planProgress,
   planRows,
   SessionPanel,
   StatusBar,
@@ -167,6 +169,8 @@ export function App({ options }: { options: TuiOptions }) {
   const requests = useRef(0)
   /** Under 120 columns there is room for one pane: ctrl+o switches between the chat and the details. */
   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: [] })
   // 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" })
@@ -481,6 +485,7 @@ export function App({ options }: { options: TuiOptions }) {
       active: configRef.current?.activeProfile || "",
       narrow: widthRef.current < SPLIT_MIN,
       view: narrowView,
+      chatWide,
     })
   const paletteMatches = (query: string) => searchPalette(query, paletteAll())
 
@@ -556,6 +561,8 @@ export function App({ options }: { options: TuiOptions }) {
     else if (run.id === "stop") openDialog("stop")
     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 === "panels") setNav((n) => ({ ...n, focus: planLines(inspRef.current).length ? "plan" : "activity" }))
   }
 
   const cycleProfile = () => {
@@ -641,7 +648,7 @@ export function App({ options }: { options: TuiOptions }) {
       return
     }
     // The panels: shift+tab moves focus through those on screen; a focused panel takes the arrows, enter, and esc.
-    const panes = width >= SPLIT_MIN || narrowView === "details"
+    const panes = (width >= SPLIT_MIN && !chatWide) || (width < SPLIT_MIN && narrowView === "details")
     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) {
@@ -916,6 +923,9 @@ export function App({ options }: { options: TuiOptions }) {
       case "card":
         pushLine({ kind: "card", text: e.card.title, card: e.card })
         return
+      case "report":
+        producedRef.current.reports.push({ title: e.title, html: e.html })
+        return
     }
   }
 
@@ -971,8 +981,8 @@ export function App({ options }: { options: TuiOptions }) {
     return controller
   }
 
-  const finish = (finalStatus: string) => {
-    setNext(nextSteps(producedRef.current, { testsOn: testsRef.current.on }))
+  const finish = (finalStatus: string, followUps: FollowUp[] = []) => {
+    setNext(nextSteps(producedRef.current, { testsOn: testsRef.current.on, followUps }))
     progressDone(inspRef.current, finalStatus === "stopped")
     bump()
     setStatus(finalStatus)
@@ -1016,6 +1026,7 @@ export function App({ options }: { options: TuiOptions }) {
     const setup = sessionSetup(cfg, options.repo)
     testsRef.current = { on: setup.writeTests, why: "the session was started with --no-code" }
     let finalStatus = "fail"
+    let followUps: FollowUp[] = []
     let fresh = false
     try {
       if (!brainRef.current) {
@@ -1043,6 +1054,7 @@ export function App({ options }: { options: TuiOptions }) {
         finalStatus = "stopped"
       } else {
         if (answer.reply) pushLine({ kind: "reply", text: answer.reply, outcome: answer.outcome })
+        followUps = answer.next || []
         if (answer.error && !answer.reply) push("err", answer.error, "chat")
         finalStatus = answer.outcome === "done" ? "done" : answer.outcome === "needs_input" ? "idle" : "fail"
       }
@@ -1055,7 +1067,7 @@ export function App({ options }: { options: TuiOptions }) {
       // The split view's session and tokens panels show this; only the one-pane view needs it in the chat.
       const spent = widthRef.current < SPLIT_MIN ? requestLine(meterStart) : ""
       if (spent) push("sys", spent, "chat")
-      finish(finalStatus)
+      finish(finalStatus, followUps)
     }
   }
 
@@ -1285,35 +1297,38 @@ export function App({ options }: { options: TuiOptions }) {
 
   const closeHint: Hint = { key: "ctrl+c", label: "close", onPress: () => openDialog("quit") }
   const copiedHint: Hint[] = copied ? [{ key: `✓ ${copied}`, label: "" }] : []
-  // The split view's right pane shows tokens, time, and the last result, so the hints under the prompt leave them out.
+  // The split view's right pane shows tokens, time, and the last result, so the row under the prompt leaves them out.
   const wide = width >= SPLIT_MIN
-  const viewHint: Hint[] = wide ? [] : [{ key: "ctrl+o", label: "details", onPress: () => setNarrowView("details") }]
-  // Each hint's `drop` is when it gives way on a narrow row: the last run and profiles (also in the palette) go first.
-  const idleHints: Hint[] = [
-    ...copiedHint.map((h) => ({ ...h, drop: 0 })),
-    ...(lastStats && !wide ? [{ key: `last run ${lastStats}`, label: "", drop: 5 }] : []),
-    ...viewHint.map((h) => ({ ...h, drop: 3 })),
-    { key: "ctrl+r", label: "refine", onPress: () => refineRef.current(), drop: 1 },
-    ...(wide ? [{ key: "shift+tab", label: "panels", onPress: () => setNav((n) => ({ ...n, focus: planLines(inspRef.current).length ? "plan" : "activity" })), drop: 4 }] : [{ key: "tab", label: "profiles", drop: 4 }]),
-    { key: "ctrl+p", label: "commands" },
-    closeHint,
-  ]
-  const runningHints: Hint[] = [
-    // A note ("opened report.html") is the last to give way: it answers what was just pressed.
-    ...copiedHint.map((h) => ({ ...h, drop: 0 })),
-    // The split view's panels show tokens and time; the one-pane view shows them here while there is room.
-    ...(wide ? [] : [{ key: `${formatTokens(tokens)} tokens · ${elapsed}`, label: "", drop: 3 }, ...viewHint.map((h) => ({ ...h, drop: 2 }))]),
-    { key: "ctrl+p", label: "commands", drop: 1 },
-    closeHint,
+  const openPalette = () => {
+    paletteRef.current = { query: "", selected: 0 }
+    setPalette(paletteRef.current)
+  }
+  const focusPanels = () => setNav((n) => ({ ...n, focus: planLines(inspRef.current).length ? "plan" : "activity" }))
+  // What can be done from here, as buttons: Refine fills with its colour once there is a request to refine.
+  // `drop`: the order they give way on a narrow row; Refine, Search, and Stop always stay.
+  const refineButton: Button = { icon: "✦", label: "Refine", keys: "ctrl+r", color: theme.memory, onPress: () => refineRef.current(), active: Boolean(promptText.trim()) }
+  const searchButton: Button = { icon: "⌕", label: "Search", keys: "ctrl+p", color: theme.accent, onPress: openPalette }
+  // The view: in the split view, Panels and Wide chat sit in the right pane's status line, where there is room;
+  // Split view comes back here when the chat is wide, and Details on a narrow terminal.
+  const toggleWide = () => setChatWide((w) => !w)
+  const paneButtons: Button[] = [
+    { icon: "▦", label: "Panels", keys: "shift+tab", color: theme.thought, onPress: focusPanels, drop: 2 },
+    { icon: "⤢", label: "Wide chat", color: theme.muted, onPress: toggleWide, drop: 1 },
   ]
+  const viewButtons: Button[] = wide
+    ? chatWide
+      ? [{ icon: "◧", label: "Split view", color: theme.thought, onPress: toggleWide, drop: 2 }]
+      : []
+    : [{ 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]
+  // 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 = (
-    <>
+    <box style={{ flexDirection: "row", marginRight: 1 }}>
       <Spinner kind="bar" />
-      <text onMouseDown={() => openDialog("stop")}>
-        <span fg={theme.text}>{"  esc"}</span>
-        <span fg={theme.muted}>{" stop"}</span>
-      </text>
-    </>
+    </box>
   )
 
   const renderControls = (promptWidth: number, placeholder: string, rows: [number, number]) => {
@@ -1406,7 +1421,7 @@ export function App({ options }: { options: TuiOptions }) {
             setPromptText(t)
           }}
         />
-        <Hints width={promptWidth} items={running ? runningHints : idleHints} left={running ? runningLeft : undefined} reserve={running ? 20 : 0} />
+        <ButtonBar width={promptWidth} buttons={running ? runningButtons : idleButtons} hints={running ? runningHints : idleHints} left={running ? runningLeft : undefined} />
       </>
     )
   }
@@ -1509,7 +1524,7 @@ export function App({ options }: { options: TuiOptions }) {
     const sel = (f: "plan" | "files") => (nav.focus === f ? Math.min(nav[f], Math.max(0, (f === "plan" ? planLines(insp) : filesByUse(insp)).length - 1)) : undefined)
     return (
       <box style={{ flexDirection: "column", width: paneWidth, height: rowsAvailable, flexShrink: 0 }}>
-        <StatusBar running={running} who={insp.who} activity={activity} elapsed={elapsed} status={status} width={paneWidth} onStop={stop} progress={suiteProgress} />
+        <StatusBar running={running} who={insp.who} activity={activity} elapsed={elapsed} status={status} width={paneWidth} onStop={stop} progress={suiteProgress || planProgress(insp)} actions={paneButtons} />
         <box style={{ height: 1, flexShrink: 0 }} />
         {plan ? <PlanPanel s={insp} width={paneWidth} height={plan} selected={sel("plan")} onFocus={focusOn("plan")} /> : null}
         <ActivityPanel
@@ -1536,7 +1551,7 @@ export function App({ options }: { options: TuiOptions }) {
       {all.map((line) => (
         <TranscriptLine key={line.id} line={line} />
       ))}
-      {running && !split ? (
+      {running && (!split || chatWide) ? (
         <box style={{ flexDirection: "row", marginTop: 1, paddingLeft: 2, flexShrink: 0 }}>
           <Spinner kind="dots" />
           <text fg={theme.text}>{` ${activity || "Working…"}`}</text>
@@ -1548,18 +1563,22 @@ export function App({ options }: { options: TuiOptions }) {
 
   const split = width >= SPLIT_MIN
   if (split) {
-    const leftWidth = Math.floor(width * 0.4)
+    // Wide chat: the conversation across the screen for reading, the panels hidden until Split view.
+    const leftWidth = chatWide ? width : Math.floor(width * 0.4)
     return (
       <box style={{ flexDirection: "column", flexGrow: 1 }}>
         <box style={{ flexDirection: "row", height: height - 1, flexShrink: 0, paddingTop: 1 }}>
-          <box onMouseDown={() => navRef.current.focus !== "chat" && setNav((n) => ({ ...n, focus: "chat" }))} style={{ flexDirection: "column", width: leftWidth, height: height - 2, paddingLeft: 2, paddingRight: 1 }}>
-            <SessionPanel info={sessionInfo} width={leftWidth - 3} />
-            {transcript(chatLines, {})}
-            <box style={{ flexDirection: "column", flexShrink: 0 }}>{controls(leftWidth - 3)}</box>
-          </box>
-          <box style={{ flexDirection: "column", width: width - leftWidth, height: height - 2, paddingLeft: 1, paddingRight: 2 }}>
-            {details(width - leftWidth - 3, height - 2)}
+          <box onMouseDown={() => navRef.current.focus !== "chat" && setNav((n) => ({ ...n, focus: "chat" }))} style={{ flexDirection: "column", width: leftWidth, height: height - 2, paddingLeft: 2, paddingRight: chatWide ? 2 : 1 }}>
+            <SessionPanel info={sessionInfo} width={leftWidth - (chatWide ? 4 : 3)} />
+            {/* Wide chat shows what the agents do in the conversation, as the one-pane view does. */}
+            {transcript(chatWide ? lines : chatLines, {})}
+            <box style={{ flexDirection: "column", flexShrink: 0 }}>{controls(leftWidth - (chatWide ? 4 : 3))}</box>
           </box>
+          {chatWide ? null : (
+            <box style={{ flexDirection: "column", width: width - leftWidth, height: height - 2, paddingLeft: 1, paddingRight: 2 }}>
+              {details(width - leftWidth - 3, height - 2)}
+            </box>
+          )}
         </box>
         <Footer left={shortCwd()} right={footerRight} width={width} />
         {paletteOverlay}

package/src/tui/components.tsx

@@ -206,6 +206,55 @@ export function Hints({ width, items: all, left, reserve = 0 }: { width: number;
   )
 }
 
+/**
+ * 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 = {