@capagents/forgeqe 1.0.8 → 1.1.0

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,75 +96,82 @@ 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)
   }
+  // A rounded box with ">" before the text, as in Claude Code; the border lights up while it has the keys.
   return (
-    <box style={{ flexDirection: "column", width: props.width, flexShrink: 0 }}>
-      <box
-        border={["left"]}
-        borderColor={props.modeColor}
-        customBorderChars={BAR}
-        style={{
-          flexDirection: "column",
-          backgroundColor: theme.panel,
-          paddingLeft: 2,
-          paddingRight: 2,
-          paddingTop: 1,
-          paddingBottom: 1,
-          width: props.width,
-        }}
-      >
-        {props.masked !== undefined ? (
-          <text style={{ height: 1 }}>
-            {props.masked ? <span fg={theme.text}>{"•".repeat(Math.min(props.masked, Math.max(1, props.width - 8)))}</span> : <span fg={theme.faint}>{props.placeholder}</span>}
-          </text>
-        ) : (
-          <textarea
-            key={props.inputKey}
-            ref={ref}
-            placeholder={props.placeholder}
-            focused={props.focused !== false}
-            initialValue={props.initialValue || ""}
-            wrapMode="word"
-            keyBindings={PROMPT_KEYS}
-            onSubmit={() => props.onSubmit(ref.current?.plainText ?? "")}
-            onContentChange={fit}
-            style={{ height: rows }}
-            backgroundColor={theme.panel}
-            focusedBackgroundColor={theme.panel}
-            textColor={theme.text}
-            focusedTextColor={theme.text}
-            placeholderColor={theme.faint}
-          />
-        )}
-        {props.compact ? null : (
-          <box style={{ flexDirection: "row", justifyContent: "space-between", marginTop: 1 }}>
-            <text>
-              <span fg={theme.muted}>{"Model  "}</span>
-              <span fg={theme.text}>{props.model || "…"}</span>
-            </text>
-            <text>
-              {props.right ? <span fg={props.rightColor || theme.muted}>{props.right}</span> : null}
-              {props.right ? <span fg={theme.faint}>{"  ·  "}</span> : null}
-              <span fg={theme.muted}>{"profile "}</span>
-              <span fg={theme.text}>{props.profile || "none"}</span>
+    <box
+      border
+      borderStyle="rounded"
+      borderColor={props.focused === false ? theme.border : theme.muted}
+      style={{ flexDirection: "column", width: props.width, flexShrink: 0, paddingLeft: 1, paddingRight: 1 }}
+    >
+      <box style={{ flexDirection: "row" }}>
+        <text fg={props.modeColor} style={{ width: 2, flexShrink: 0 }}>
+          {">"}
+        </text>
+        <box style={{ flexDirection: "column", flexGrow: 1, flexShrink: 1 }}>
+          {props.masked !== undefined ? (
+            <text style={{ height: 1 }}>
+              {props.masked ? <span fg={theme.text}>{"•".repeat(Math.min(props.masked, Math.max(1, props.width - 8)))}</span> : <span fg={theme.faint}>{props.placeholder}</span>}
             </text>
-          </box>
-        )}
+          ) : (
+            <textarea
+              key={props.inputKey}
+              ref={ref}
+              placeholder={props.placeholder}
+              focused={props.focused !== false}
+              initialValue={props.initialValue || ""}
+              wrapMode="word"
+              keyBindings={PROMPT_KEYS}
+              onSubmit={() => props.onSubmit(ref.current?.plainText ?? "")}
+              onContentChange={fit}
+              style={{ height: rows }}
+              textColor={theme.text}
+              focusedTextColor={theme.text}
+              placeholderColor={theme.faint}
+            />
+          )}
+        </box>
       </box>
-      <text>
-        <span fg={props.modeColor}>{edge.slice(0, 1)}</span>
-        <span fg={theme.panel}>{edge.slice(1)}</span>
-      </text>
+      {props.compact ? null : (
+        <box style={{ flexDirection: "row", justifyContent: "space-between", marginTop: 1 }}>
+          <text>
+            <span fg={theme.muted}>{"Model  "}</span>
+            <span fg={theme.text}>{props.model || "…"}</span>
+          </text>
+          <text>
+            {props.right ? <span fg={props.rightColor || theme.muted}>{props.right}</span> : null}
+            {props.right ? <span fg={theme.faint}>{"  ·  "}</span> : null}
+            <span fg={theme.muted}>{"profile "}</span>
+            <span fg={theme.text}>{props.profile || "none"}</span>
+          </text>
+        </box>
+      )}
     </box>
   )
 }
@@ -328,9 +361,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 }}

package/src/tui/landing.ts

@@ -0,0 +1,201 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs"
+import path from "node:path"
+
+import type { AppConfig } from "../config.ts"
+import { CAPABILITIES } from "../capabilities/registry.ts"
+import { allStatuses, configuredSystems, SYSTEM_LABEL, type Probes, MACHINE } from "../capabilities/status.ts"
+
+/**
+ * What the start screen shows before the first request: the project it works on, the actions that work in this setup,
+ * and the reports and runs to pick up again. Everything comes from the config, the capability registry, and the files
+ * in the folder, so it changes as the setup changes.
+ */
+
+/** Files a stack is read from, at the top and one or two folders down (tests/Shop.Tests/Shop.Tests.csproj). */
+function projectFiles(cwd: string, match: RegExp, depth = 2): string[] {
+  const out: string[] = []
+  const walk = (dir: string, level: number) => {
+    let names: string[] = []
+    try {
+      names = readdirSync(dir)
+    } catch {
+      return
+    }
+    for (const n of names) {
+      if (n.startsWith(".") || n === "node_modules" || n === "bin" || n === "obj") continue
+      const full = path.join(dir, n)
+      if (match.test(n)) out.push(full)
+      else if (level < depth) {
+        try {
+          if (statSync(full).isDirectory()) walk(full, level + 1)
+        } catch {}
+      }
+      if (out.length > 20) return
+    }
+  }
+  walk(cwd, 0)
+  return out
+}
+
+const read = (file: string) => {
+  try {
+    return readFileSync(file, "utf8")
+  } catch {
+    return ""
+  }
+}
+
+/**
+ * "C# · NUnit · Playwright": the language, test framework, and browser library the project's own files declare
+ * (project files, package.json, Python requirements). Read from the files, never guessed from folder names.
+ */
+export function projectStack(cwd: string): string[] {
+  const csproj = projectFiles(cwd, /\.csproj$/).map(read).join("\n")
+  if (csproj) {
+    const framework = /PackageReference Include="NUnit"/i.test(csproj) ? "NUnit" : /PackageReference Include="xunit/i.test(csproj) ? "xUnit" : /PackageReference Include="MSTest/i.test(csproj) ? "MSTest" : ""
+    const browser = /Microsoft\.Playwright/i.test(csproj) ? "Playwright" : /Selenium\.WebDriver/i.test(csproj) ? "Selenium" : /Reqnroll|SpecFlow/i.test(csproj) ? "BDD" : ""
+    return ["C#", framework, browser].filter(Boolean)
+  }
+  const pkg = read(path.join(cwd, "package.json"))
+  if (pkg) {
+    const lang = existsSync(path.join(cwd, "tsconfig.json")) ? "TypeScript" : "JavaScript"
+    const runner = /"@playwright\/test"/.test(pkg) ? "Playwright Test" : /"cypress"/.test(pkg) ? "Cypress" : /"webdriverio"|"@wdio\//.test(pkg) ? "WebdriverIO" : /"vitest"/.test(pkg) ? "Vitest" : /"jest"/.test(pkg) ? "Jest" : ""
+    return [lang, runner].filter(Boolean)
+  }
+  const py = ["requirements.txt", "pyproject.toml", "setup.cfg"].map((f) => read(path.join(cwd, f))).join("\n")
+  if (py.trim() || existsSync(path.join(cwd, "pytest.ini")) || existsSync(path.join(cwd, "conftest.py"))) {
+    return ["Python", /pytest/i.test(py) || existsSync(path.join(cwd, "pytest.ini")) ? "pytest" : "", /playwright/i.test(py) ? "Playwright" : /selenium/i.test(py) ? "Selenium" : ""].filter(Boolean)
+  }
+  const java = [read(path.join(cwd, "pom.xml")), read(path.join(cwd, "build.gradle")), read(path.join(cwd, "build.gradle.kts"))].join("\n")
+  if (java.trim()) return ["Java", /junit-jupiter|junit/i.test(java) ? "JUnit" : /testng/i.test(java) ? "TestNG" : "", /playwright/i.test(java) ? "Playwright" : /selenium/i.test(java) ? "Selenium" : ""].filter(Boolean)
+  return []
+}
+
+export type Fact = { text: string; tone: "name" | "plain" | "warn" }
+
+/**
+ * The project line: the folder, its stack, each system ForgeQE works with here and how it is signed in ("Azure DevOps
+ * (PAT)"), and the model; or, where nothing is set up, that this folder has no forgeqe.yaml.
+ */
+export function projectLine(cfg: AppConfig | null, cwd: string, opts: { model: string; signIns?: Record<string, string> }): Fact[] {
+  const facts: Fact[] = [{ text: path.basename(cwd), tone: "name" }, ...projectStack(cwd).map((t) => ({ text: t, tone: "plain" as const }))]
+  if (!cfg) return facts
+  if (!cfg.configPath) return [...facts, { text: "no forgeqe.yaml here", tone: "warn" }]
+  const systems = [...configuredSystems(cfg)].filter((s) => s !== "xray" || !configuredSystems(cfg).has("jira"))
+  for (const s of systems) {
+    const how = opts.signIns?.[SYSTEM_LABEL[s]]
+    facts.push({ text: how ? `${SYSTEM_LABEL[s]} (${how})` : SYSTEM_LABEL[s], tone: "plain" })
+  }
+  const live = cfg.llm.provider !== "none" && cfg.llm.provider !== "mock"
+  facts.push(live && opts.model ? { text: opts.model, tone: "plain" } : { text: "no model", tone: "warn" })
+  return facts
+}
+
+const ALL_SYSTEMS = Object.values(SYSTEM_LABEL)
+
+export type StartAction = { id: string; label: string; detail: string; request: string }
+
+/**
+ * The first things worth asking, in this order, among the capabilities that work in this setup: work from the systems
+ * first, then what a team asks for most. Each puts its example request in the prompt to adjust.
+ */
+const START_ORDER = ["run-test-cases", "release-readiness", "reports", "exploratory-testing", "write-test-cases", "pr-review", "api-testing", "find-run-tests", "browser-goals"]
+
+const START_LABEL: Record<string, string> = {
+  "run-test-cases": "Run test cases",
+  "release-readiness": "Check release readiness",
+  reports: "Write a report to share",
+  "exploratory-testing": "Explore a story for bugs",
+  "write-test-cases": "Write test cases from a story",
+  "pr-review": "Review a pull request",
+  "api-testing": "Test an API",
+  "find-run-tests": "Run the repository's tests",
+  "browser-goals": "Try a flow in the browser",
+}
+
+export function startActions(cfg: AppConfig | null, limit = 4, probes: Probes = MACHINE, hasRuns = true): StartAction[] {
+  // Without a live model nothing on the list can run: the start screen offers Get started instead.
+  if (!cfg || cfg.llm.provider === "none" || cfg.llm.provider === "mock") return []
+  const statuses = allStatuses(cfg, probes)
+  const systems = [...configuredSystems(cfg)].map((x) => SYSTEM_LABEL[x])
+  const out: StartAction[] = []
+  for (const id of START_ORDER) {
+    const c = CAPABILITIES.find((x) => x.id === id)
+    if (!c || statuses.get(id)?.state === "needs_setup") continue
+    // An example in the words of this setup: one that names a system that is set up, else one that names none.
+    // Not an example that builds on a run when there is none to build on.
+    const usable = c.examples.filter((e) => hasRuns || !/\blast run\b|\bthe run\b|that run/i.test(e))
+    if (!usable.length) continue
+    const named = usable.find((e) => systems.some((n) => e.includes(n)))
+    const neutral = usable.find((e) => !ALL_SYSTEMS.some((n) => e.includes(n)))
+    const example = named || neutral || usable[0]!
+    out.push({ id, label: START_LABEL[id] || c.title, detail: example, request: example })
+    if (out.length === limit) break
+  }
+  return out
+}
+
+export type RecentItem = { kind: "report" | "run"; title: string; dir: string; open: string; when: Date; status?: string }
+
+/** The newest reports and runs in the reports folder: what a returning user picks up again. */
+export function recentWork(outDir: string, limit = 3): RecentItem[] {
+  if (!existsSync(outDir)) return []
+  const items: RecentItem[] = []
+  for (const name of readdirSync(outDir)) {
+    const dir = path.join(outDir, name)
+    try {
+      if (!statSync(dir).isDirectory()) continue
+      const when = statSync(dir).mtime
+      if (existsSync(path.join(dir, "run.json"))) {
+        // The engine writes success; ForgeQE's own records write status. Either says how the run ended.
+        const run = JSON.parse(readFileSync(path.join(dir, "run.json"), "utf8")) as { goal?: string; status?: string; success?: boolean }
+        const report = path.join(dir, "report.html")
+        const status = run.status || (run.success === true ? "passed" : run.success === false ? "fail" : undefined)
+        items.push({ kind: "run", title: String(run.goal || name), dir, open: existsSync(report) ? report : dir, when, ...(status ? { status } : {}) })
+      } else if (existsSync(path.join(dir, "report.md"))) {
+        const first = readFileSync(path.join(dir, "report.md"), "utf8").split("\n")[0] || ""
+        const html = path.join(dir, "report.html")
+        items.push({ kind: "report", title: first.replace(/^#\s*/, "").trim() || name, dir, open: existsSync(html) ? html : path.join(dir, "report.md"), when })
+      }
+    } catch {}
+  }
+  return items.sort((a, b) => b.when.getTime() - a.when.getTime()).slice(0, limit)
+}
+
+/** "just now", "12 min ago", "3 h ago", "yesterday", "4 days ago", then the date. */
+export function ago(when: Date, now = new Date()): string {
+  const s = Math.max(0, (now.getTime() - when.getTime()) / 1000)
+  if (s < 60) return "just now"
+  if (s < 3600) return `${Math.floor(s / 60)} min ago`
+  if (s < 86400) return `${Math.floor(s / 3600)} h ago`
+  if (s < 2 * 86400) return "yesterday"
+  if (s < 7 * 86400) return `${Math.floor(s / 86400)} days ago`
+  return when.toISOString().slice(0, 10)
+}
+
+/** "Domain", "Domain and Notifications", "Model, Domain, and Notifications". */
+export function listWords(words: string[]): string {
+  if (words.length < 3) return words.join(" and ")
+  return `${words.slice(0, -1).join(", ")}, and ${words.at(-1)}`
+}
+
+/** "Domain and Notifications are not set up", or, when the names do not fit in `room`, "5 items are not set up". */
+export function setupSentence(missing: string[], room: number): string {
+  const named = `${listWords(missing)} ${missing.length === 1 ? "is" : "are"} not set up`
+  return named.length <= room ? named : `${missing.length} ${missing.length === 1 ? "item is" : "items are"} not set up`
+}
+
+/** What to do first where little is set up: each step runs a command or says how, in the order they are needed. */
+export type GetStarted = { id: string; label: string; detail: string; command?: string; fix?: string }
+
+export function getStarted(cfg: AppConfig | null, setup: { id: string; done: boolean; fix?: string; command?: string }[]): GetStarted[] {
+  if (!cfg) return []
+  const out: GetStarted[] = []
+  if (!cfg.configPath) out.push({ id: "init", label: "Set up ForgeQE in this folder", detail: "writes forgeqe.yaml, llms.json, prompts, skills", command: "/init" })
+  const missing = (id: string) => setup.find((i) => i.id === id && !i.done)
+  const model = missing("model")
+  if (model) out.push({ id: "model", label: "Add a model", detail: "an API key or Microsoft Entra ID, in llms.json", fix: model.fix })
+  const system = missing("system")
+  if (system) out.push({ id: "system", label: "Sign in to Azure DevOps or Jira", detail: "test cases, stories, pipelines", command: "/auth" })
+  return out.slice(0, 4)
+}

package/src/tui/next.ts

@@ -26,7 +26,7 @@ export function nextSteps(p: Produced, opts: { testsOn: boolean; followUps?: Fol
     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 (opts.testsOn && 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" } })

package/src/tui/palette.tsx

@@ -15,7 +15,7 @@ export type PaletteRun =
   /** Put in the prompt to edit and send: an example request. */
   | { kind: "insert"; text: string }
   /** Something the shell does itself. */
-  | { kind: "action"; id: "refine" | "stop" | "details" | "chat" | "wide" | "panels" }
+  | { kind: "action"; id: "refine" | "stop" | "details" | "chat" | "wide" | "panels" | "shortcuts" }
 
 export type PaletteItem = { id: string; group: PaletteGroup; title: string; detail?: string; keys?: string; run: PaletteRun }
 
@@ -31,8 +31,10 @@ export function paletteItems(opts: { running: boolean; headed: boolean; detailsF
     if (!opts.chatWide) items.push({ id: "panels", group: "Action", title: "Move to the panels: plan, activity, files", keys: "shift+tab", run: { kind: "action", id: "panels" } })
   }
   if (opts.narrow) items.push({ id: "view", group: "Action", title: opts.view === "chat" ? "Show the details view" : "Back to the chat", keys: "ctrl+o", run: { kind: "action", id: opts.view === "chat" ? "details" : "chat" } })
+  items.push({ id: "shortcuts", group: "Action", title: "Keyboard shortcuts", keys: "?", run: { kind: "action", id: "shortcuts" } })
   command("features", "What ForgeQE can do here", "/features", "and what each feature still needs")
   command("auth", "Sign in to a system", "/auth", "Azure DevOps, GitHub, Jira, Confluence, TestRail, Zephyr, qTest, Xray")
+  command("init", "Set up ForgeQE in this folder", "/init", "forgeqe.yaml, llms.json, prompts, skills, knowledge")
   command("auth-status", "What is signed in", "/auth status")
   command("headed", opts.headed ? "Hide the browser window" : "Show the browser window", `/headed ${opts.headed ? "off" : "on"}`)
   command("details", opts.detailsFull ? "Show progress only" : "Show everything the agents do", `/details ${opts.detailsFull ? "off" : "on"}`)

package/src/tui/refine-panel.tsx

@@ -18,9 +18,21 @@ export type RefineChoice = (typeof REFINE_CHOICES)[number]["id"]
 
 const COLOR = theme.memory
 
+/** A fact as written in context and in grounded, compared without case, spaces, or a closing full stop. */
+const norm = (s: string) => s.trim().replace(/\.$/, "").replace(/\s+/g, " ").toLowerCase()
+
+/** The choice the panel starts on: Edit while Refine still has a question, so an unclear request is not sent. */
+export function initialChoice(missing: string[]): number {
+  return REFINE_CHOICES.findIndex((c) => c.id === (missing.length ? "edit" : "use"))
+}
+
 export function RefinePanel(props: { state: RefineState; width: number; onChoose: (id: RefineChoice) => void; onHover: (i: number) => void }) {
   const { state, width } = props
   const title = state.phase === "working" ? " ✦ Refining " : state.phase === "error" ? " ✦ Could not refine " : " ✦ Refined request "
+  // Facts Refine checked that are also context lines are marked there, not repeated under Checked.
+  const contextLines = state.phase === "done" ? state.result.refined.split("\n").filter((l) => l.startsWith("- ")).map((l) => norm(l.slice(2))) : []
+  const inContext = new Set(contextLines)
+  const checked = new Set(state.phase === "done" ? state.result.grounded.filter((g) => g.checked).map((g) => norm(g.fact)).filter((f) => inContext.has(f)) : [])
   const section = (label: string, color: string, mark: string, items: string[]) =>
     items.length ? (
       <box style={{ flexDirection: "column", marginTop: 1 }}>
@@ -52,6 +64,15 @@ export function RefinePanel(props: { state: RefineState; width: number; onChoose
             {/* The request as it is sent: its labelled parts (Goal, Context, Steps, Rules, Result) stand out. */}
             {state.result.refined.split("\n").map((line, i) => {
               const label = /^(Goal|Context|Steps|Rules|Result):/.exec(line)
+              // A context line Refine checked against the systems: ✓ in place of its dash, so it is not listed twice.
+              if (line.startsWith("- ") && checked.has(norm(line.slice(2)))) {
+                return (
+                  <text key={i}>
+                    <span fg={theme.ok}>{"✓ "}</span>
+                    <span fg={theme.text}>{line.slice(2)}</span>
+                  </text>
+                )
+              }
               return label ? (
                 <text key={i}>
                   <span fg={COLOR}>{label[0]}</span>
@@ -63,7 +84,7 @@ export function RefinePanel(props: { state: RefineState; width: number; onChoose
                 </text>
               )
             })}
-            {section("Checked", theme.ok, "✓", state.result.grounded.filter((g) => g.checked).map((g) => g.fact))}
+            {section("Checked", theme.ok, "✓", state.result.grounded.filter((g) => g.checked && !inContext.has(norm(g.fact))).map((g) => g.fact))}
             {section("Assumed", theme.warn, "~", [...state.result.grounded.filter((g) => !g.checked).map((g) => g.fact), ...state.result.assumed])}
             {section("Missing — answer these in your request", theme.err, "?", state.result.missing)}
           </>
@@ -88,7 +109,7 @@ export function RefinePanel(props: { state: RefineState; width: number; onChoose
           {state.phase === "done" ? (
             <>
               <span fg={theme.text}>{"enter"}</span>
-              <span fg={theme.muted}>{" use  "}</span>
+              <span fg={theme.muted}>{` ${REFINE_CHOICES[state.choice]!.id === "keep" ? "keep mine" : REFINE_CHOICES[state.choice]!.id}  `}</span>
               <span fg={theme.text}>{"e"}</span>
               <span fg={theme.muted}>{" edit  "}</span>
               <span fg={theme.text}>{"esc"}</span>

package/src/tui/shortcuts.tsx

@@ -0,0 +1,66 @@
+import { theme } from "./theme.ts"
+
+/** Every key the shell answers to, in one panel (? on an empty prompt); esc or ? closes it. */
+export const SHORTCUTS: { group: string; keys: [string, string][] }[] = [
+  {
+    group: "Prompt",
+    keys: [
+      ["enter", "send the request"],
+      ["shift+enter, ctrl+j", "new line"],
+      ["ctrl+r", "refine the request before it is sent"],
+      ["/  @", "commands; runs, files, and work items to reference"],
+      ["tab", "complete a suggestion, or the next model profile"],
+    ],
+  },
+  {
+    group: "Find and move",
+    keys: [
+      ["ctrl+p", "search: actions, commands, profiles, examples"],
+      ["shift+tab", "move between the chat and the plan, activity, and files panels"],
+      ["ctrl+o", "open or close the panels: plan, activity, files, context, tokens"],
+      ["alt+1 to alt+4", "a start action, or a next step"],
+    ],
+  },
+  {
+    group: "Run",
+    keys: [
+      ["esc", "stop the request (asks first)"],
+      ["ctrl+c", "close ForgeQE (asks first; twice closes)"],
+      ["drag", "copy the selected text"],
+    ],
+  },
+]
+
+export function ShortcutsPanel(props: { width: number; wide: boolean; onClose: () => void }) {
+  const boxWidth = Math.min(84, props.width - 8)
+  const keyWidth = 22
+  return (
+    <box
+      position="absolute"
+      zIndex={100}
+      border
+      borderStyle="rounded"
+      borderColor={theme.accent}
+      title=" Keyboard shortcuts "
+      titleColor={theme.accent}
+      bottomTitle=" esc close "
+      bottomTitleAlignment="right"
+      onMouseDown={props.onClose}
+      style={{ top: 2, left: Math.floor((props.width - boxWidth) / 2), width: boxWidth, flexDirection: "column", backgroundColor: theme.panel, paddingLeft: 2, paddingRight: 2, paddingTop: 1 }}
+    >
+      {SHORTCUTS.map((g) => (
+        <box key={g.group} style={{ flexDirection: "column", marginBottom: 1, flexShrink: 0 }}>
+          <text fg={theme.muted}>{g.group}</text>
+          {g.keys
+            .filter(([k]) => props.wide || k !== "shift+tab")
+            .map(([k, what]) => (
+              <text key={k}>
+                <span fg={theme.text}>{`  ${k.padEnd(keyWidth)}`}</span>
+                <span fg={theme.muted}>{what}</span>
+              </text>
+            ))}
+        </box>
+      ))}
+    </box>
+  )
+}