@capagents/forgeqe 2.0.0 → 2.0.2

package/HOW_TO_USE.md

@@ -74,7 +74,8 @@ Everything ForgeQE can do, by area. ForgeQE's agent answers "can you…?" questi
 | Operations | **Teams and email notifications**: Tells the team in Microsoft Teams channels or by email when a suite fails or passes, when a release readiness verdict is in, and when the domain evaluation falls below its gate, with the failing cases, their bugs, and links to the report and the CI build. Each channel picks its events; the agent also posts a summary to a channel when asked. | `notify` | [docs](#17-notifications) |
 | Release | **Reports you can share**: Writes up what ForgeQE's agent found, such as open defects across projects, release status, or pipeline health, as a page with filters (project, state, priority, assignee, …), charts, and a sortable table, plus Markdown and CSV. Every table is built from evidence: the results of the tool calls the agent made, or a read-only query ForgeQE runs itself, listed on the page's Sources with each raw result kept beside the report. | `write_report` | [docs](#reports-from-the-agent) |
 | Operations | **CI pipelines**: Writes a GitHub Actions or Azure Pipelines workflow that runs ForgeQE, stores the secrets it needs, pushes a branch, and makes the pipeline green. | `push_branch`, `set_ci_secret` | [docs](#8-pipelines) |
-| Systems | **Work with Azure DevOps, Jira, GitHub, and Confluence**: Reads anything in the configured systems (work items, issues, queries, boards, pages), makes changes the user asks for, puts run evidence (screenshots, reports) on work items and issues as attachments or comments, and builds Azure DevOps dashboards and wiki pages. | `query_api`, `read_confluence`, `create_ado_dashboard`, `write_ado_wiki_page`, `attach_to_work_item` | [docs](README.md#azure-devops-jira-and-other-systems) |
+| Systems | **Work with Azure DevOps, Jira, GitHub, and Confluence**: Reads anything in the configured systems (work items, issues, queries, boards, pages), makes changes the user asks for, puts run evidence (screenshots, reports) on work items and issues as attachments or comments, and builds Azure DevOps dashboards and wiki pages. | `read_confluence`, `create_ado_dashboard`, `write_ado_wiki_page`, `attach_to_work_item` | [docs](README.md#azure-devops-jira-and-other-systems) |
+| Systems | **Read any data in Azure DevOps, Jira, Xray, and Confluence**: Reads through a system's REST API what its MCP tools do not cover: pull requests and repositories, test plans and suites, classic releases, and anything else in Azure DevOps, Jira, Xray, or Confluence. Given on every turn once a system is set up, so the agent never turns to the browser or the shell to read it. | `query_api` | [docs](README.md#azure-devops-jira-and-other-systems) |
 | Setup | **Setup, skills, and documentation**: Shows the model profiles and MCP servers, installs or repairs the browser engine, creates a forgeqe.yaml, manages skills, and answers questions about ForgeQE from its documentation and this list. | `forgeqe_setup`, `capabilities`, `playbook`, `use_capabilities` | [docs](#2-scaffold-config) |
 
 Not supported: Native mobile apps (iOS, Android) and desktop applications (instead: web applications in local Chrome or Chromium, or configured remote web grids such as BrowserStack and TestMu AI/LambdaTest); Load, stress, or soak testing with many simultaneous users (instead: per-page Core Web Vitals with budgets); Penetration testing or dynamic security scanning (instead: security findings in pull request reviews).

package/docs/user-guide.html

@@ -389,7 +389,7 @@ forgeqe docs --copy ./docs   # copy the guide, the architecture page, and the re
 <div class="area"><a class="area-name" href="#area-api"><span class="mono">API</span></a><ul class="tiles"><li><a class="tile" href="#cap-api-testing"><b>API and contract testing</b><span>Turn the last run's API calls into tests</span></a></li></ul></div>
 <div class="area"><a class="area-name" href="#area-quality"><span class="mono">Quality</span></a><ul class="tiles"><li><a class="tile" href="#cap-accessibility-performance"><b>Accessibility and page performance</b><span>Is the checkout page accessible?</span></a></li><li><a class="tile" href="#cap-visual-comparison"><b>Visual comparison with baselines</b><span>What changed visually since the last run?</span></a></li><li><a class="tile" href="#cap-defect-intelligence"><b>Defect intelligence: trends and prediction</b><span>Which defects keep coming back?</span></a></li></ul></div>
 <div class="area"><a class="area-name" href="#area-release"><span class="mono">Release</span></a><ul class="tiles"><li><a class="tile" href="#cap-release-readiness"><b>Requirement coverage and release readiness</b><span>Are we ready to release?</span></a></li><li><a class="tile" href="#cap-reports"><b>Reports you can share</b><span>Create a release report for all projects</span></a></li></ul></div>
-<div class="area"><a class="area-name" href="#area-systems"><span class="mono">Systems</span></a><ul class="tiles"><li><a class="tile" href="#cap-systems"><b>Work with Azure DevOps, Jira, GitHub, and Confluence</b><span>Show the open bugs in this sprint</span></a></li></ul></div>
+<div class="area"><a class="area-name" href="#area-systems"><span class="mono">Systems</span></a><ul class="tiles"><li><a class="tile" href="#cap-systems"><b>Work with Azure DevOps, Jira, GitHub, and Confluence</b><span>Show the open bugs in this sprint</span></a></li><li><a class="tile" href="#cap-system-data"><b>Read any data in Azure DevOps, Jira, Xray, and Confluence</b><span>Are there open pull requests in any repository of QI-Claims?</span></a></li></ul></div>
 <h3 class="band-title">Not supported</h3>
 <ul class="plainlist"><li><b>Native mobile apps (iOS, Android) and desktop applications</b>. Instead: web applications in local Chrome or Chromium, or configured remote web grids such as BrowserStack and TestMu AI/LambdaTest.</li><li><b>Load, stress, or soak testing with many simultaneous users</b>. Instead: per-page Core Web Vitals with budgets.</li><li><b>Penetration testing or dynamic security scanning</b>. Instead: security findings in pull request reviews.</li></ul>
 </section>
@@ -2505,7 +2505,7 @@ forgeqe visual approve --page /home  # make this run's /home the baseline (asks
 <div class="facts">
 <div class="fact"><span class="mono">Ask it</span><ul class="asks"><li>Show the open bugs in this sprint</li><li>Read the checkout requirements from Confluence</li><li>Make a dashboard of this sprint's test results</li><li>Add the last screenshot of that run to ADO 256 as a comment</li><li>Run the GitHub issues labelled login as test cases</li></ul></div>
 <div class="fact"><span class="mono">What it needs</span><ul class="needs"><li><span class="need req">Required</span><span>Azure DevOps or Jira or Xray or Confluence: set up under sources: in forgeqe.yaml, or sign in with /auth</span></li></ul></div>
-<div class="fact"><span class="mono">Tools</span><p class="tools"><code>query_api</code> <code>read_confluence</code> <code>create_ado_dashboard</code> <code>write_ado_wiki_page</code> <code>attach_to_work_item</code></p></div>
+<div class="fact"><span class="mono">Tools</span><p class="tools"><code>read_confluence</code> <code>create_ado_dashboard</code> <code>write_ado_wiki_page</code> <code>attach_to_work_item</code></p></div>
 </div>
 <div class="detail"><span class="mono">In detail</span>
 <section class="doc" id="doc-readme-azure-devops-jira-and-other-systems">
@@ -2542,6 +2542,18 @@ mcp:
 </section>
 </div>
 </article>
+<article class="spec feat" id="cap-system-data">
+<div class="hd"><span class="mono">Systems</span><h3>Read any data in Azure DevOps, Jira, Xray, and Confluence</h3></div>
+<p class="ds">Reads through a system's REST API what its MCP tools do not cover: pull requests and repositories, test plans and suites, classic releases, and anything else in Azure DevOps, Jira, Xray, or Confluence. Given on every turn once a system is set up, so the agent never turns to the browser or the shell to read it.</p>
+<div class="facts">
+<div class="fact"><span class="mono">Ask it</span><ul class="asks"><li>Are there open pull requests in any repository of QI-Claims?</li><li>List the test plans in QI-MobileBanking with their suites</li></ul></div>
+<div class="fact"><span class="mono">What it needs</span><ul class="needs"><li><span class="need req">Required</span><span>Azure DevOps or Jira or Xray or Confluence: set up under sources: in forgeqe.yaml, or sign in with /auth</span></li></ul></div>
+<div class="fact"><span class="mono">Tools</span><p class="tools"><code>query_api</code></p></div>
+</div>
+<div class="detail"><span class="mono">In detail</span>
+<p class="see">See <a href="#doc-readme-azure-devops-jira-and-other-systems">Azure DevOps, Jira, and other systems</a> (from the README).</p>
+</div>
+</article>
 </section>
 <section class="chapter" id="reference" aria-labelledby="reference-h">
 <header class="chead"><span class="mono">16</span><h2 id="reference-h">Reference</h2><p>MCP, tuning, logs, environment variables, and every command</p></header>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capagents/forgeqe",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "ForgeQE: a browser agent CLI that runs goals and test cases in local Chrome or Chromium, or BrowserStack and TestMu AI/LambdaTest when configured, and turns passing runs into tests in your repo",
   "license": "MIT",
   "type": "module",

package/prompts/brain.md

@@ -53,11 +53,11 @@ Read data from Azure DevOps, Jira, Xray, Confluence, and other systems in this s
 **On failure**:
 - When a system refuses the credentials (401, 403, or "needs <NAME> in the environment"), tell the user to type /auth <system>. Outside the shell, it is forgeqe auth login <system>.
 - /auth signs in through the browser and saves the token. You get it on the next message.
-- When the MCP tools have no tool for the data, use query_api. You MUST NOT use the shell, curl, or a script instead.
+- When the MCP tools have no tool for the data (pull requests, test plans, releases), use query_api. You MUST NOT use the browser, the shell, curl, or a script to read data that a system's API gives.
 - When a browser_run fails and gives resume steps, run the same task again with resume_from and that run_dir, by the playbook "Browser runs".
 - When the browser engine does not start or is missing, use forgeqe_setup install_engine. Use force to install it again.
 
-**Evidence**: give the ids and links of the items that you read or changed, the run folders and report files, and the tool results that your answer depends on.
+**Evidence**: give the work item ids, the run folders and report files, and the tool calls that your answer depends on, in one short "Source:" line. Do not repeat what the answer already shows.
 
 ## Rules
 - You MUST NOT print, echo, or write the value of a secret or API key. Use the name of its environment variable.
@@ -356,7 +356,9 @@ The shell shows replies as markdown in a narrow chat pane. Write them so that th
 - When there is more than one group, you SHOULD give each group a short `##` heading.
 - You SHOULD write bullets of one line each.
 - You MUST use bold only for the one word or number that is important in a line, such as a status or a count.
-- You SHOULD use a table only for two or three short columns.
+- When the answer lists several items that have the same fields (projects, work items, builds, runs, test cases), you MUST give a markdown table: one row for each item, and only the two to four fields that answer the request. You MUST NOT write the fields of an item as a run of "key value;" in a bullet. When a field has the same value in every row, you MUST say it once under the table, not as a column, and you MUST NOT use bold in table cells.
+- You MUST put the link of an item on its name, as [name](url), with the address of its web page, not of its REST API.
+- You MUST NOT show internal ids (GUIDs), REST API URLs, revision numbers, or raw codes unless the user asks for them. Write a work item as #1234, and a date as YYYY-MM-DD.
 - You MUST keep your own comments short. You MUST give in full the test cases, tests, and reviews that the user asked for.
 - When the user asks for a report, a write-up, or a summary to share, you MUST save the report with write_report, with its data as datasets. You MUST NOT type rows, counts, or tables into the report yourself.
 - For "all" of something (all open defects, every project), you SHOULD give the dataset a query (a WIQL query or a REST path), so that ForgeQE reads every item itself. Otherwise, name the tool calls that you made in this session (from: the tool name or the evidence id).

package/src/capabilities/registry.ts

@@ -490,7 +490,7 @@ export const CAPABILITIES: Capability[] = [
     area: "Systems",
     title: "Work with Azure DevOps, Jira, GitHub, and Confluence",
     summary: "Reads anything in the configured systems (work items, issues, queries, boards, pages), makes changes the user asks for, puts run evidence (screenshots, reports) on work items and issues as attachments or comments, and builds Azure DevOps dashboards and wiki pages.",
-    tools: ["query_api", "read_confluence", "create_ado_dashboard", "write_ado_wiki_page", "attach_to_work_item"],
+    tools: ["read_confluence", "create_ado_dashboard", "write_ado_wiki_page", "attach_to_work_item"],
     keywords: ["jira", "azure devops", "ado", "confluence", "system", "github issue", "work item", "bug", "sprint", "dashboard", "wiki", "comment", "backlog", "issue", "ticket", "requirement"],
     examples: [
       "Show the open bugs in this sprint",
@@ -506,6 +506,18 @@ export const CAPABILITIES: Capability[] = [
       { heading: "Dashboards and wiki pages in Azure DevOps", when: "an Azure DevOps dashboard or wiki page" },
     ],
   },
+  {
+    id: "system-data",
+    area: "Systems",
+    title: "Read any data in Azure DevOps, Jira, Xray, and Confluence",
+    summary:
+      "Reads through a system's REST API what its MCP tools do not cover: pull requests and repositories, test plans and suites, classic releases, and anything else in Azure DevOps, Jira, Xray, or Confluence. Given on every turn once a system is set up, so the agent never turns to the browser or the shell to read it.",
+    tools: ["query_api"],
+    keywords: ["pull request", "pull requests", "prs", "open pr", "repos", "repository", "branch", "commit", "test plan", "test plans", "release"],
+    examples: ["Are there open pull requests in any repository of QI-Claims?", "List the test plans in QI-MobileBanking with their suites"],
+    requires: [{ kind: "system", anyOf: ["azure_devops", "jira", "xray", "confluence"] }],
+    docs: [{ doc: "README.md", heading: "Azure DevOps, Jira, and other systems" }],
+  },
   {
     id: "setup-help",
     area: "Setup",

package/src/code/runtime.ts

@@ -654,7 +654,9 @@ export async function openSession<R = AgentReport>(opts: {
     throw err
   }
   const client: OpencodeClient = createOpencodeClient({ baseUrl: server.url, directory: opts.repo })
-  const emit = opts.onEvent || (() => {})
+  /** The agent the prompt in progress runs as; every event is named with it, so the shell shows who is working. */
+  let speaker = agent.name
+  const emit = (e: CodeEvent) => opts.onEvent?.({ ...e, agent: speaker })
   const usage: Usage = { input: 0, output: 0 }
 
   let session: { id: string }
@@ -829,12 +831,13 @@ export async function openSession<R = AgentReport>(opts: {
     async prompt(text: string, options: PromptOptions = {}): Promise<PromptOutcome<R>> {
       sessionError = ""
       turn = { structured: null, error: "", text: [] }
+      speaker = options.agent || agent.name
       const done = new Promise<void>((resolve) => {
         idle = resolve
       })
       const sent = await client.session.promptAsync({
         sessionID: session.id,
-        agent: options.agent || agent.name,
+        agent: speaker,
         model,
         ...(options.structured === false ? {} : { format: { type: "json_schema" as const, schema: (opts.schema || RESULT_SCHEMA) as never } }),
         ...(options.tools ? { tools: options.tools } : {}),

package/src/mcp/scope.ts

@@ -23,6 +23,12 @@ import { MCP_NAME } from "./server.ts"
 
 /** Always given: the agent needs them to answer, to set up, and to know the environment and its apps. */
 export const CORE = ["setup-help", "test-apps"]
+/**
+ * Given on every turn once a system (Azure DevOps, Jira, Xray, Confluence) is set up: query_api reads what the
+ * system's MCP tools do not cover. Without it a question about pull requests or test plans, which no keyword names,
+ * left the agent the browser, and its rule to read such data through the API could not be followed.
+ */
+export const SYSTEM_DATA = "system-data"
 /** Turns a capability stays after its tools last ran. */
 export const STICKY_TURNS = 3
 /** Most capabilities picked from a request's words (recent and core ones come on top). */
@@ -119,12 +125,14 @@ export class CapabilityScope {
       reasons[id] = why
     }
     for (const id of CORE) take(id, "core")
+    if (usable.has(SYSTEM_DATA)) take(SYSTEM_DATA, "a system is set up: its API reads what its MCP tools do not cover")
+    const base = new Set(Object.keys(reasons))
     for (const id of this.cfg.agentScope?.always || []) take(id, "agent.capabilities.always")
     for (const id of this.requested) take(id, "asked for with use_capabilities")
     for (const [id, at] of this.lastUsed) if (this.turn - at < STICKY_TURNS) take(id, "used in a recent turn")
     const scored = [...scoreRequest(text, this.cfg, this.caps)].filter(([id]) => usable.has(id)).sort((a, b) => b[1].score - a[1].score)
     for (const [id, s] of scored.slice(0, MAX_PICKED)) take(id, `the request: ${s.why.slice(0, 3).join(", ")}`)
-    if (Object.keys(reasons).every((id) => CORE.includes(id))) take(FALLBACK, "nothing more specific in the request")
+    if (Object.keys(reasons).every((id) => base.has(id))) take(FALLBACK, "nothing more specific in the request")
     return { ids: Object.keys(reasons), reasons }
   }
 

package/src/tui/App.tsx

@@ -54,7 +54,10 @@ import { watchBudgets } from "../tokenomics/budget.ts"
 import {
   ACTIVITY_FILTERS,
   ActivityPanel,
+  AgentWorking,
   ContextPanel,
+  CrewStrip,
+  crewRows,
   FilesPanel,
   InfoStrip,
   nowNext,
@@ -70,10 +73,13 @@ import {
   type ContextInfo,
   type Focus,
 } from "./inspector.tsx"
+import { BRAIN, BROWSER, SCRIBE } from "./agentIcons.ts"
 import {
   addSkill,
+  agentWorking,
   caseDone,
   caseStarted,
+  crewDone,
   filesByUse,
   newInspector,
   newRequest,
@@ -81,7 +87,6 @@ import {
   progressDone,
   setContext,
   setPlan,
-  setWho,
   startProgress,
   stepOutcome,
   stepStarted,
@@ -287,6 +292,10 @@ export function App({ options }: { options: TuiOptions }) {
     else return
     bump()
   }
+  /** `agent` works now (its name in src/agents.ts): the status bar and the crew strip follow it. */
+  const working = (agent: string) => {
+    if (agentWorking(inspRef.current, agent)) bump()
+  }
   /** What the agent is on between calls: the plan's task in progress, rather than a bare "working". */
   const nowWorking = () => {
     const task = inspRef.current.plan.find((p) => p.status === "in_progress")
@@ -838,7 +847,7 @@ export function App({ options }: { options: TuiOptions }) {
         setStep(0)
         setBrowsing(true)
         startProgress(inspRef.current, `Browser · ${clip(e.goal, 40)}`)
-        setWho(inspRef.current, "Browser agent")
+        agentWorking(inspRef.current, BROWSER)
         bump()
         if (agent) push("code", `Browser: ${clip(e.goal, 110)}`)
         if (!aborted()) setActivity(cfg?.llm.provider === "mock" ? "Running the offline demo…" : "Starting the browser…")
@@ -909,7 +918,7 @@ export function App({ options }: { options: TuiOptions }) {
         setLastStats(summary.stats)
         setBrowsing(false)
         progressDone(inspRef.current, aborted())
-        setWho(inspRef.current, codingRef.current ? "Scribe" : "ForgeQE's agent")
+        agentWorking(inspRef.current, codingRef.current ? SCRIBE : BRAIN)
         bump()
         if (agent && !aborted()) setActivity("The agent is reading the result…")
         return
@@ -925,7 +934,7 @@ export function App({ options }: { options: TuiOptions }) {
         const tag = (id: string) => ((configRef.current?.suite.parallel || 1) > 1 ? `[${id}] ` : "")
         if (s.type === "case-start") {
           caseStarted(inspRef.current, s.case.id, s.case.title)
-          setWho(inspRef.current, "Browser agent")
+          agentWorking(inspRef.current, BROWSER)
           bump()
           push("code", `${s.index + 1}/${s.total}  ${s.case.id}  ${s.case.title}`)
           // What was read from the test management system: where the case lives and the steps the browser will follow.
@@ -985,6 +994,8 @@ export function App({ options }: { options: TuiOptions }) {
         return
       case "agent": {
         const ev = e.event
+        // A subagent's session names it on each event (openSession); from then on it is the one working.
+        if (ev.agent) working(ev.agent)
         inspect(ev)
         if (ev.kind === "plan") return
         if (ev.kind === "usage") useTokens(`agent-tool-${runIndex.current}`, ev.usage.input + ev.usage.output)
@@ -1009,7 +1020,7 @@ export function App({ options }: { options: TuiOptions }) {
           } else if (ev.kind === "answer") record("code", answerText(ev), true)
         }
         if (aborted()) return
-        const who = codingRef.current ? "Coding agent" : "Agent"
+        const who = inspRef.current.who
         if (ev.kind === "start") setActivity(`${who}: ${clip(ev.text, 60)}…`)
         else if (ev.kind === "tool") setActivity(`${who}: ${clip(ev.text, 60)}`)
         else if (ev.kind === "info" && ev.text.startsWith("ForgeQE runs the test")) setActivity("ForgeQE is running the new test…")
@@ -1022,7 +1033,7 @@ export function App({ options }: { options: TuiOptions }) {
         codingRef.current = true
         codeRunDir.current = e.runDir
         setCoding(true)
-        setWho(inspRef.current, "Scribe")
+        agentWorking(inspRef.current, SCRIBE)
         bump()
         const show = shortPath
         pushLine({
@@ -1047,7 +1058,7 @@ export function App({ options }: { options: TuiOptions }) {
       case "code-done":
         codingRef.current = false
         setCoding(false)
-        setWho(inspRef.current, "ForgeQE's agent")
+        agentWorking(inspRef.current, BRAIN)
         bump()
         producedRef.current.tests.push({ runDir: codeRunDir.current, result: e.result, error: e.error })
         if (e.error) push("err", `Coding agent: ${e.error}`)
@@ -1066,6 +1077,7 @@ export function App({ options }: { options: TuiOptions }) {
   }
 
   const onBrainEvent = (e: CodeEvent) => {
+    working(e.agent || BRAIN)
     inspect(e)
     if (e.kind === "plan") return
     if (e.kind === "usage") {
@@ -1133,6 +1145,7 @@ export function App({ options }: { options: TuiOptions }) {
     })
     setNext(nextSteps(producedRef.current, { testsOn: testsRef.current.on, followUps }))
     progressDone(inspRef.current, finalStatus === "stopped")
+    crewDone(inspRef.current, ended === "idle" ? "done" : ended)
     bump()
     setStatus(finalStatus)
     setActivity("")
@@ -1245,6 +1258,7 @@ export function App({ options }: { options: TuiOptions }) {
 
   const askAgent = async (text: string, cfg: AppConfig) => {
     const controller = begin("Thinking…", text)
+    working(BRAIN)
     const meterStart = meterSnapshot()
     setThinking(true)
     const setup = sessionSetup(cfg, options.repo)
@@ -1883,9 +1897,9 @@ export function App({ options }: { options: TuiOptions }) {
     capabilities: CAPABILITIES.length,
   }
   const placeholder = running
-    ? coding
-      ? "The coding agent is writing a test · esc to stop"
-      : `${thinking ? "ForgeQE's agent" : "The browser agent"} is working · esc to stop`
+    ? coding && insp.agent === SCRIBE
+      ? "Scribe is writing a test · esc to stop"
+      : `${insp.who} is working · esc to stop`
     : "Ask ForgeQE… (/ for commands, @ to reference a run, file, or work item)"
   const chatLines = lines.filter((l) => l.pane !== "activity")
   const activityLines = lines.filter((l) => l.pane === "activity")
@@ -1915,13 +1929,15 @@ export function App({ options }: { options: TuiOptions }) {
   const activityColumn = (paneWidth: number, rowsAvailable: number) => {
     const where = nowNext(insp)
     const plan = planRows(insp, Math.max(3, Math.min(10, Math.floor(rowsAvailable / 4))))
-    const activityRows = Math.max(5, rowsAvailable - STATUS_ROWS - 1 - plan)
+    const crew = crewRows(insp)
+    const activityRows = Math.max(5, rowsAvailable - STATUS_ROWS - 1 - crew - plan)
     const focusOn = (f: Focus) => () => setNav((n) => ({ ...n, focus: f }))
     const sel = nav.focus === "plan" ? Math.min(nav.plan, Math.max(0, planLines(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 || planProgress(insp)} actions={paneButtons} />
+        <StatusBar running={running} who={insp.who} agent={insp.agent} activity={activity} elapsed={elapsed} status={status} width={paneWidth} onStop={stop} progress={suiteProgress || planProgress(insp)} actions={paneButtons} />
         <box style={{ height: 1, flexShrink: 0 }} />
+        {crew ? <CrewStrip s={insp} width={paneWidth} running={running} /> : null}
         {plan ? <PlanPanel s={insp} width={paneWidth} height={plan} selected={sel} onFocus={focusOn("plan")} animate={running} /> : null}
         <ActivityPanel
           lines={activityLines}
@@ -1949,14 +1965,8 @@ export function App({ options }: { options: TuiOptions }) {
         <TranscriptLine key={line.id} line={line} prev={all[i - 1]} />
       ))}
       {running && !panelsOpen ? (
-        // What is happening now, for how long, and with how many tokens, as one line under the conversation.
-        <box style={{ flexDirection: "row", marginTop: 1, flexShrink: 0 }}>
-          <Spinner kind="dots" color={theme.memory} />
-          <text>
-            <span fg={theme.memory}>{` ${activity || "Working…"}`}</span>
-            <span fg={theme.faint}>{`  (${[elapsed, progressText, tokens ? `${formatTokens(tokens)} tokens` : "", "esc to interrupt"].filter(Boolean).join(" · ")})`}</span>
-          </text>
-        </box>
+        // Who is working and on what, the request's agents, how long, and how many tokens, under the conversation.
+        <AgentWorking s={insp} activity={activity} stats={[elapsed, progressText, tokens ? `${formatTokens(tokens)} tokens` : "", "esc to interrupt"].filter(Boolean).join(" · ")} width={room} />
       ) : null}
     </scrollbox>
     </LineRoom.Provider>

package/src/tui/agentIcons.ts

@@ -0,0 +1,109 @@
+import { AGENT_HUES, theme } from "./theme.ts"
+
+/**
+ * Each agent's face in the shell: a short name and an icon, so it is clear which agent or subagent is working. The
+ * icons follow one set of hexagon tiles (soft tones, a deeper one where shapes overlap); each agent has a picture of its
+ * job and a colour of its own, for its icon and its name.
+ * Plain data, tested without a terminal.
+ */
+
+/**
+ * Eight pixels wide and four high, drawn as two rows of half blocks: `#` the agent's main tone, `+` its deeper tone
+ * (where shapes overlap, or the part that stands out), `.` empty. Each agent's is a picture of its job.
+ */
+export const SHAPES = {
+  /** A plain hexagon: an agent not listed. */
+  hexagon: ["..####..", ".######.", ".######.", "..####.."],
+  /** Hexagons stacked into one: ForgeQE's agent, which starts the others. */
+  hub: ["...##...", ".##++##.", "##++++##", ".##..##."],
+  /** A browser window with its title bar. */
+  window: ["++++++++", "#......#", "#......#", "########"],
+  /** A magnifier. */
+  magnifier: [".###....", "#+++#...", ".###.#..", ".....##."],
+  /** A bar chart. */
+  chart: ["......##", "...##.##", "##.##.##", "++++++++"],
+  /** A funnel: a request narrowed to a specification. */
+  funnel: ["########", ".######.", "..++++..", "...++..."],
+  /** A list with its bullets. */
+  list: ["+.######", "........", "+.####..", "........"],
+  /** A flag on its pole. */
+  flag: ["##+++++.", "##++++..", "##......", "##......"],
+  /** A pencil, its tip at the bottom left. */
+  pencil: [".....+++", "...###+.", ".###....", "+#......"],
+  /** An open book on its spine. */
+  book: ["##....##", "###..###", "###++###", "...++..."],
+  /** A cross. */
+  cross: ["...##...", ".##++##.", ".##++##.", "...##..."],
+  /** A plug with its prongs and cable. */
+  plug: ["..#..#..", ".++++++.", ".++++++.", "...##..."],
+  /** A check mark. */
+  check: ["......##", "##...##.", ".##+##..", "..+++..."],
+  /** A comment bubble. */
+  bubble: ["########", "#.+.+.+#", "########", ".##....."],
+  /** A gavel on its block. */
+  gavel: [".++++...", ".++++#..", ".....##.", "###...##"],
+  /** A bug. */
+  bug: ["+..##..+", ".######.", "+##++##+", ".##++##."],
+} as const
+
+export type Shape = keyof typeof SHAPES
+export type Hue = keyof typeof AGENT_HUES
+
+export type AgentFace = { name: string; shape: Shape; hue: Hue }
+
+/**
+ * Keyed by the agent's name in src/agents.ts (its AgentSpec name, or "engine"). Each has its own hue; the hue's
+ * neighbourhood says what the agent does: purples plan and lead, blues run and look, greens write code, warm hues judge.
+ */
+export const FACES: Record<string, AgentFace> = {
+  forgeqe: { name: "ForgeQE's agent", shape: "hub", hue: "purple" },
+  "forgeqe-refine": { name: "Refine", shape: "funnel", hue: "indigo" },
+  "forgeqe-api-plan": { name: "API planner", shape: "list", hue: "orchid" },
+  "forgeqe-explore-plan": { name: "Explorer", shape: "flag", hue: "magenta" },
+  engine: { name: "Browser agent", shape: "window", hue: "blue" },
+  "forgeqe-find": { name: "Test finder", shape: "magnifier", hue: "cyan" },
+  "forgeqe-bi": { name: "Insights", shape: "chart", hue: "yellow" },
+  "forgeqe-test": { name: "Scribe", shape: "pencil", hue: "green" },
+  "forgeqe-read": { name: "Scribe, reading", shape: "book", hue: "leaf" },
+  "forgeqe-heal": { name: "Healer", shape: "cross", hue: "lime" },
+  "forgeqe-api": { name: "API test writer", shape: "plug", hue: "teal" },
+  "forgeqe-review": { name: "Reviewer", shape: "check", hue: "pink" },
+  "forgeqe-pr-review": { name: "PR reviewer", shape: "bubble", hue: "rose" },
+  "forgeqe-judge": { name: "Judge", shape: "gavel", hue: "coral" },
+  "forgeqe-defect-rca": { name: "Root cause", shape: "bug", hue: "orange" },
+}
+
+export const BRAIN = "forgeqe"
+export const BROWSER = "engine"
+export const SCRIBE = "forgeqe-test"
+
+/** An agent's face; one not listed is named by its id, without the "forgeqe-" prefix, with a plain grey hexagon. */
+export function faceOf(agent: string): AgentFace & { main: string; deep: string } {
+  const face = FACES[agent]
+  if (face) return { ...face, ...AGENT_HUES[face.hue] }
+  const name = agent.replace(/^forgeqe-/, "").replace(/-/g, " ")
+  return { name: name.charAt(0).toUpperCase() + name.slice(1), shape: "hexagon", hue: "blue", main: theme.faint, deep: theme.border }
+}
+
+/** One terminal cell of an icon: a half or full block in up to two colours, or a blank. */
+export type IconCell = { ch: string; fg?: string; bg?: string }
+
+/** The agent's icon as two rows of cells: a pixel's tone on top is the foreground of ▀, the one below its background. */
+export function iconCells(agent: string): IconCell[][] {
+  const face = faceOf(agent)
+  const px = SHAPES[face.shape]
+  const tone = (p: string | undefined) => (p === "#" ? face.main : p === "+" ? face.deep : undefined)
+  return [0, 1].map((r) =>
+    [...px[0]].map((_, c) => {
+      const top = tone(px[r * 2]![c])
+      const bottom = tone(px[r * 2 + 1]![c])
+      if (!top && !bottom) return { ch: " " }
+      if (!bottom) return { ch: "▀", fg: top }
+      if (!top) return { ch: "▄", fg: bottom }
+      return top === bottom ? { ch: "█", fg: top } : { ch: "▀", fg: top, bg: bottom }
+    }),
+  )
+}
+
+/** Columns an icon takes. */
+export const ICON_WIDTH = SHAPES.hexagon[0].length

package/src/tui/inspector.tsx

@@ -2,10 +2,11 @@ import type { ScrollBoxRenderable } from "@opentui/core"
 import type { ReactNode, RefObject } from "react"
 
 import type { Usage } from "../types.ts"
+import { faceOf, iconCells, ICON_WIDTH } from "./agentIcons.ts"
 import { fitButtons, Spinner, type Button } from "./components.tsx"
-import { filesByUse, type FileUse, type Inspector, type Progress } from "./session.ts"
-import { clip, tailCut } from "./text.ts"
-import { formatTokens, theme } from "./theme.ts"
+import { crewMs, filesByUse, type CrewMember, type FileUse, type Inspector, type Progress } from "./session.ts"
+import { clip, plainText, tailCut } from "./text.ts"
+import { formatDuration, formatTokens, theme } from "./theme.ts"
 import { isMarker, type Line } from "./transcript.tsx"
 
 /**
@@ -66,7 +67,23 @@ export function Panel(props: { title: string; color: string; width?: number; hei
   )
 }
 
-/** The right pane's first line: who is working on what and for how long, and Stop while something runs. */
+/** An agent's icon (src/tui/agentIcons.ts): two rows of half blocks in its hue. */
+export function AgentIcon({ agent }: { agent: string }) {
+  return (
+    <box style={{ flexDirection: "column", width: ICON_WIDTH, height: 2, flexShrink: 0 }}>
+      {iconCells(agent).map((row, r) => (
+        <text key={r}>
+          {row.map((cell, c) => (
+            <span key={c} {...(cell.fg ? { fg: cell.fg } : {})} {...(cell.bg ? { bg: cell.bg } : {})}>
+              {cell.ch}
+            </span>
+          ))}
+        </text>
+      ))}
+    </box>
+  )
+}
+
 /** How far the agent's own plan has got, while it has one of two steps or more. */
 export function planProgress(s: Inspector): { done: number; total: number } | null {
   return s.plan.length > 1 ? { done: s.plan.filter((p) => p.status === "completed").length, total: s.plan.length } : null
@@ -88,6 +105,10 @@ export const STATUS_ROWS = 2
 export function StatusBar(props: {
   running: boolean
   who: string
+  /** The agent working (its name in src/agents.ts): its icon leads both rows while the request runs. */
+  agent?: string
+  /** The colour `who` is written in: the working agent's own. */
+  whoColor?: string
   activity: string
   elapsed: string
   status: string
@@ -98,6 +119,17 @@ export function StatusBar(props: {
   /** Buttons for the view (Focus panels, Close), before Stop; the first to give way when the line is short. */
   actions?: Button[]
 }) {
+  const icon = props.running && props.agent ? props.agent : null
+  if (icon) {
+    return (
+      <box style={{ flexDirection: "row", height: STATUS_ROWS, flexShrink: 0, paddingLeft: 1 }}>
+        <AgentIcon agent={icon} />
+        <box style={{ width: props.width - ICON_WIDTH - 1, flexShrink: 0 }}>
+          <StatusBar {...props} agent={undefined} whoColor={faceOf(icon).main} width={props.width - ICON_WIDTH - 1} />
+        </box>
+      </box>
+    )
+  }
   const done = props.status === "done"
   const failed = props.status === "fail"
   const color = props.running ? theme.warn : done ? theme.ok : failed ? theme.err : theme.muted
@@ -114,7 +146,7 @@ export function StatusBar(props: {
       <box style={{ flexDirection: "row", justifyContent: "space-between", height: 1 }}>
         <box style={{ flexDirection: "row" }}>
           {props.running ? <Spinner kind="dots" color={theme.warn} /> : <text fg={color}>{"●"}</text>}
-          <text fg={props.running ? theme.text : color}>{` ${clip(state, Math.max(8, props.width - fixed + state.length))}`}</text>
+          <text fg={props.running ? props.whoColor || theme.text : color}>{` ${clip(state, Math.max(8, props.width - fixed + state.length))}`}</text>
         </box>
         <box style={{ flexDirection: "row" }}>
           {actions.map((b) => (
@@ -150,6 +182,123 @@ export function StatusBar(props: {
   )
 }
 
+/** Each crew member's state: its mark, the mark's colour, and the word for it when it has no time to show. */
+const CREW_MARK: Record<CrewMember["state"], [string, string]> = {
+  working: ["◐", theme.warn],
+  waiting: ["○", theme.faint],
+  done: ["✓", theme.ok],
+  failed: ["✗", theme.err],
+  stopped: ["■", theme.warn],
+}
+
+/** Rows the crew strip takes, the blank row under it included: none until a second agent has joined the request. */
+export function crewRows(s: Inspector): number {
+  return s.crew.length > 1 ? 3 : 0
+}
+
+/** What a member's second row says: "waiting", or how long it has worked. */
+function crewState(m: CrewMember, now: number): string {
+  return m.state === "waiting" ? "waiting" : formatDuration(crewMs(m, now))
+}
+
+/** Columns a tile's text takes, and the tile with its icon. */
+const CREW_TEXT = 18
+const crewTextWidth = (m: CrewMember, now: number) => Math.min(CREW_TEXT, Math.max(faceOf(m.agent).name.length, crewState(m, now).length + 2))
+const CREW_GAP = " › "
+
+/**
+ * The chat view's line under the conversation while a request runs (the panels closed): the working agent's icon, its
+ * name in its colour and what it is doing; under them the agents of the request ("✓ Browser agent › ◐ Scribe"), the
+ * latest that fit, then the time, tokens and how to interrupt.
+ */
+export function AgentWorking(props: { s: Inspector; activity: string; stats: string; width: number }) {
+  const { s } = props
+  const face = faceOf(s.agent)
+  const room = Math.max(10, props.width - ICON_WIDTH - 1)
+  const name = clip(face.name, Math.max(8, room - 4))
+  const stats = `(${props.stats})`
+  const chain = s.crew.length > 1 ? s.crew : []
+  const size = (m: CrewMember) => 2 + faceOf(m.agent).name.length
+  let first = chain.length
+  let used = 0
+  while (first > 0) {
+    const more = size(chain[first - 1]!) + (first < chain.length ? CREW_GAP.length : 0)
+    if (used + more + (first > 1 ? 4 : 0) + stats.length + 2 > room && first < chain.length) break
+    used += more
+    first--
+  }
+  return (
+    <box style={{ flexDirection: "row", marginTop: 1, flexShrink: 0 }}>
+      <AgentIcon agent={s.agent} />
+      <box style={{ flexDirection: "column", paddingLeft: 1, flexGrow: 1, flexShrink: 1 }}>
+        <box style={{ flexDirection: "row", height: 1 }}>
+          <Spinner kind="dots" color={face.main} />
+          <text>
+            <span fg={face.main}>{` ${name}`}</span>
+            <span fg={theme.memory}>{`  ${clip(props.activity || "Working…", Math.max(8, room - name.length - 4))}`}</span>
+          </text>
+        </box>
+        <text style={{ height: 1 }}>
+          {first > 0 ? <span fg={theme.faint}>{`+${first} `}</span> : null}
+          {chain.slice(first).flatMap((m, i) => {
+            const [mark, color] = CREW_MARK[m.state]
+            return [
+              ...(i ? [<span key={`${m.agent}-gap`} fg={theme.border}>{CREW_GAP}</span>] : []),
+              <span key={`${m.agent}-mark`} fg={color}>{`${mark} `}</span>,
+              <span key={m.agent} fg={faceOf(m.agent).main}>{faceOf(m.agent).name}</span>,
+            ]
+          })}
+          <span fg={theme.faint}>{`${chain.length ? "  " : ""}${clip(stats, Math.max(8, room - used))}`}</span>
+        </text>
+      </box>
+    </box>
+  )
+}
+
+/**
+ * Every agent that took part in the request, in the order they started, as tiles: the icon, its name, and whether it
+ * is working (spinning, with its time), waiting for a subagent, or done. The latest that fit; "+N" for the earlier.
+ */
+export function CrewStrip(props: { s: Inspector; width: number; running: boolean; now?: number }) {
+  const now = props.now ?? Date.now()
+  const crew = props.s.crew
+  const tileWidth = (m: CrewMember) => ICON_WIDTH + 1 + crewTextWidth(m, now)
+  let first = crew.length
+  let used = 0
+  while (first > 0) {
+    const more = tileWidth(crew[first - 1]!) + (first < crew.length ? CREW_GAP.length : 0)
+    // Room for "+N " in front when anything is left out.
+    if (used + more + (first > 1 ? 4 : 0) > props.width - 2 && first < crew.length) break
+    used += more
+    first--
+  }
+  return (
+    <box style={{ flexDirection: "row", height: 2, flexShrink: 0, marginBottom: 1, paddingLeft: 1 }}>
+      {first > 0 ? <text fg={theme.faint}>{`+${first} `}</text> : null}
+      {crew.slice(first).map((m, i) => {
+        const face = faceOf(m.agent)
+        const [mark, color] = CREW_MARK[m.state]
+        const live = m.state === "working" && props.running
+        const text = crewTextWidth(m, now)
+        return (
+          <box key={m.agent} style={{ flexDirection: "row", flexShrink: 0 }}>
+            {i ? <text fg={theme.border}>{CREW_GAP}</text> : null}
+            <AgentIcon agent={m.agent} />
+            <box style={{ flexDirection: "column", width: text + 1, paddingLeft: 1, flexShrink: 0 }}>
+              {/* Each agent's name in its own colour, so its tile, the status bar, and the icon read as one agent. */}
+              <text fg={face.main}>{clip(face.name, text)}</text>
+              <box style={{ flexDirection: "row", height: 1 }}>
+                <box style={{ width: 2, flexShrink: 0 }}>{live ? <Spinner kind="dots" color={color} /> : <text fg={color}>{mark}</text>}</box>
+                <text fg={m.state === "working" ? theme.warn : theme.faint}>{crewState(m, now)}</text>
+              </box>
+            </box>
+          </box>
+        )
+      })}
+    </box>
+  )
+}
+
 const PLAN_MARK: Record<string, [string, string]> = {
   completed: ["✓", theme.ok],
   in_progress: ["◐", theme.warn],
@@ -320,7 +469,7 @@ export function ActivityRow({ line, width = 0, first = false }: { line: Line; wi
         <ToolCall parts={toolArgs(line.text)!} width={width} />
       ) : (
         <text fg={textColor} style={{ flexGrow: 1, flexShrink: 1 }}>
-          {fit(line.text, oneRow ? 1 : NOTE_ROWS) || " "}
+          {fit(line.kind === "thought" ? plainText(line.text) : line.text, oneRow ? 1 : NOTE_ROWS) || " "}
         </text>
       )}
     </box>

package/src/tui/readable.ts

@@ -0,0 +1,220 @@
+/**
+ * Makes a model's markdown readable in the shell, whatever wrote it: the shape is fixed here, never the content, and
+ * nothing the text says is dropped. Records written as list items of "key value; key value" become a table (or, where
+ * a table would not fit, one short block per record), ISO timestamps become dates and times, and raw JSON a code block.
+ * Code, fenced or inline, is left as it was. Plain strings in, plain strings out, so it is tested without a terminal.
+ */
+
+/** A list item: its indent, its marker, and its text. */
+const ITEM = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/
+const FENCE = /^\s*(```|~~~)/
+
+/** "2023-02-24T09:07:36.893Z" → "2023-02-24 09:07 UTC"; an offset is kept, a time of midnight with no zone dropped. */
+const TIMESTAMP = /\b(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2})(?::\d{2}(?:\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?\b/g
+
+export function readableTimes(text: string): string {
+  return outsideCode(text, (part) =>
+    part.replace(TIMESTAMP, (_, date: string, time: string, zone?: string) => {
+      if (!zone && time === "00:00") return date
+      return `${date} ${time}${zone === "Z" ? " UTC" : zone ? ` ${zone}` : ""}`
+    }),
+  )
+}
+
+/** Applies `fix` to the text outside inline code spans. */
+function outsideCode(line: string, fix: (part: string) => string): string {
+  return line
+    .split(/(`[^`]*`)/)
+    .map((part) => (part.startsWith("`") ? part : fix(part)))
+    .join("")
+}
+
+/** One field of a record: "state wellFormed", "visibility code 2", "description: Card payments…". */
+export type Field = { key: string; value: string }
+
+/** A record: what names it, and its fields; `notes` holds what had no key. */
+export type Record = { name: string; fields: Field[]; notes: string[] }
+
+/** "**Autothon** — ID 6d73…; state wellFormed; URL https://…" → its name and the text of its fields. */
+const NAMED = /^(?:\*\*(.+?)\*\*|`(.+?)`|([^—–:;]{1,60}?))\s*(?:—|–|:|\s-)\s+(.+)$/
+
+/** A key is one to three words; the value is what follows it. */
+const KEY_VALUE = /^([A-Za-z][\w./-]*(?: [A-Za-z][\w./-]*){0,2}):\s+(.+)$/
+const KEY_TOKEN = /^([A-Za-z][\w./-]*(?: [a-z][\w./-]*){0,2}) (\S+)$/
+
+function field(segment: string): Field | null {
+  const s = segment.trim().replace(/\.$/, "")
+  const colon = KEY_VALUE.exec(s)
+  if (colon) return { key: colon[1]!, value: colon[2]!.trim() }
+  const spaced = KEY_TOKEN.exec(s)
+  return spaced ? { key: spaced[1]!, value: spaced[2]! } : null
+}
+
+/** A list item as a record, or null when it is a sentence rather than fields. */
+export function parseRecord(text: string): Record | null {
+  const named = NAMED.exec(text.trim())
+  if (!named) return null
+  const name = (named[1] ?? named[2] ?? named[3] ?? "").trim()
+  const body = named[4]!
+  // Fields are split by semicolons; by commas only when every part then reads "key: value".
+  let parts = body.split(/;\s+/)
+  if (parts.length < 2) {
+    const commas = body.split(/,\s+/)
+    parts = commas.length >= 2 && commas.every((c) => KEY_VALUE.test(c.trim())) ? commas : parts
+  }
+  if (parts.length < 2) return null
+  const fields: Field[] = []
+  const notes: string[] = []
+  for (const part of parts) {
+    const f = field(part)
+    if (f) fields.push(f)
+    else if (part.trim()) notes.push(part.trim().replace(/\.$/, ""))
+  }
+  return fields.length >= 2 ? { name, fields, notes } : null
+}
+
+const LINK_KEY = /^(url|link|href|web ?url|address)$/i
+const URL = /^<?(https?:\/\/[^\s>]+)>?$/
+
+/** The columns of a set of records: the keys more than half of them have (both of two), in the order they first appear. */
+function columnsOf(records: Record[]): string[] {
+  const seen = new Map<string, { key: string; n: number }>()
+  for (const r of records)
+    for (const k of new Set(r.fields.map((f) => f.key.toLowerCase()))) {
+      const at = seen.get(k)
+      if (at) at.n++
+      else seen.set(k, { key: r.fields.find((f) => f.key.toLowerCase() === k)!.key, n: 1 })
+    }
+  return [...seen.values()].filter((c) => c.n * 2 > records.length).map((c) => c.key)
+}
+
+/**
+ * Whether items read as records: two keys or more that half of them share, holding most of their fields. Steps or
+ * sentences split by semicolons ("open the page; click Search") share no keys, and stay as they were written.
+ */
+export function areRecords(records: Record[]): boolean {
+  const columns = new Set(columnsOf(records).map((c) => c.toLowerCase()))
+  const all = records.reduce((n, r) => n + r.fields.length + r.notes.length, 0)
+  const kept = records.reduce((n, r) => n + r.fields.filter((f) => columns.has(f.key.toLowerCase())).length, 0)
+  return columns.size >= 2 && kept >= all * 0.6
+}
+
+const cap = (s: string) => s.charAt(0).toUpperCase() + s.slice(1)
+/** A table cell: pipes escaped, so a value cannot open a column. */
+const cell = (s: string) => s.replace(/\|/g, "\\|").replace(/\s+/g, " ").trim() || "—"
+
+/**
+ * Records as markdown: a table where it fits `width` (a long column may wrap), else a block per record. Every field
+ * is kept: a link becomes the name's, a value every record shares is said once under them, the rest go in Notes.
+ */
+export function recordsMarkdown(records: Record[], width: number, indent = ""): string {
+  let columns = columnsOf(records)
+  const value = (r: Record, key: string) => r.fields.find((f) => f.key.toLowerCase() === key.toLowerCase())?.value
+  // A link column moves onto the name.
+  const linkKey = columns.find((c) => LINK_KEY.test(c) && records.every((r) => !value(r, c) || URL.test(value(r, c)!)))
+  const name = (r: Record) => {
+    const href = linkKey ? URL.exec(value(r, linkKey) || "")?.[1] : undefined
+    return href && !/[[\]]/.test(r.name) ? `[${r.name}](${href})` : r.name
+  }
+  if (linkKey) columns = columns.filter((c) => c !== linkKey)
+  // A value every record has the same is said once.
+  const shared = columns.filter((c) => records.every((r) => value(r, c) !== undefined) && new Set(records.map((r) => value(r, c))).size === 1 && records.length > 1)
+  columns = columns.filter((c) => !shared.includes(c))
+  const inColumns = new Set([...columns, ...shared, ...(linkKey ? [linkKey] : [])].map((c) => c.toLowerCase()))
+  const notes = (r: Record) => [...r.fields.filter((f) => !inColumns.has(f.key.toLowerCase())).map((f) => `${cap(f.key)}: ${f.value}`), ...r.notes].join("; ")
+  const withNotes = records.some((r) => notes(r))
+  const header = ["Name", ...columns.map(cap), ...(withNotes ? ["Notes"] : [])]
+  const rows = records.map((r) => [name(r), ...columns.map((c) => value(r, c) ?? "—"), ...(withNotes ? [notes(r)] : [])].map(cell))
+  const sharedLine = shared.length ? `${records.length === 2 ? "Both" : `All ${records.length}`}: ${shared.map((c) => `${c} ${value(records[0]!, c)}`).join("; ")}.` : ""
+
+  // How wide the table would be: its widest cells and the gaps between them. A long column may wrap; a table half as
+  // wide again as the pane would wrap every column, so then each record is a block of its own.
+  const shown = (s: string) => s.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").length
+  const widths = header.map((h, i) => Math.max(h.length, ...rows.map((row) => shown(row[i]!))))
+  const tableWidth = widths.reduce((a, b) => a + b, 0) + 2 * (widths.length - 1)
+  const out: string[] = []
+  if (tableWidth <= width * 1.5 || header.length <= 3) {
+    out.push(`${indent}| ${header.join(" | ")} |`, `${indent}|${header.map(() => "---").join("|")}|`)
+    for (const row of rows) out.push(`${indent}| ${row.join(" | ")} |`)
+  } else {
+    for (const [i, r] of records.entries()) {
+      out.push(`${indent}- **${name(r)}**`)
+      for (const [j, c] of columns.entries()) if (value(r, c) !== undefined) out.push(`${indent}  - ${cap(c)}: ${rows[i]![j + 1]}`)
+      if (notes(r)) out.push(`${indent}  - ${notes(r)}`)
+    }
+  }
+  if (sharedLine) out.push("", `${indent}${sharedLine}`)
+  return out.join("\n")
+}
+
+/** Raw JSON written as text: an object or array, whole, that parses. */
+function jsonBlock(text: string): string | null {
+  const t = text.trim()
+  if (!/^[[{]/.test(t) || t.length < 2) return null
+  try {
+    const value = JSON.parse(t)
+    if (value === null || typeof value !== "object") return null
+    return `\`\`\`json\n${JSON.stringify(value, null, 2)}\n\`\`\``
+  } catch {
+    return null
+  }
+}
+
+/** The whole pass. `width`: the columns the reply has, which decides between a table and blocks. */
+export function readable(md: string, width = 80): string {
+  const lines = md.replace(/\r/g, "").split("\n")
+  const out: string[] = []
+  let fence = false
+  for (let n = 0; n < lines.length; n++) {
+    const line = lines[n]!
+    if (FENCE.test(line)) {
+      fence = !fence
+      out.push(line)
+      continue
+    }
+    if (fence) {
+      out.push(line)
+      continue
+    }
+    // Raw JSON: the fewest lines from here, within the paragraph, that parse as an object or an array.
+    if (/^\s*[[{]/.test(line)) {
+      let json: string | null = null
+      let end = n
+      for (; end < lines.length && lines[end]!.trim(); end++) if ((json = jsonBlock(lines.slice(n, end + 1).join("\n")))) break
+      if (json) {
+        out.push(json)
+        n = end
+        continue
+      }
+    }
+    // A run of list items at one depth, each with the lines that continue it.
+    const first = ITEM.exec(line)
+    if (first) {
+      const depth = first[1]!.length
+      const items: string[] = []
+      let end = n - 1
+      while (end + 1 < lines.length) {
+        const next = lines[end + 1]!
+        const item = ITEM.exec(next)
+        if (item && item[1]!.length === depth) items.push(item[3]!)
+        else if (next.trim() && /^\s+\S/.test(next) && !item && items.length && next.search(/\S/) > depth) items[items.length - 1] += ` ${next.trim()}`
+        else break
+        end++
+      }
+      // Fields are read before times are rewritten: "last updated 2023-02-24T09:07Z" is one key and one value.
+      const records = items.map((t) => {
+        const r = parseRecord(t)
+        // A value wholly in backticks ("`100`", "`wellFormed`") is emphasis, not code: in a table it would colour every cell.
+        const plain = (v: string) => readableTimes(/^`[^`]+`$/.test(v) ? v.slice(1, -1) : v)
+        return r && { ...r, name: /^`[^`]+`$/.test(r.name) ? r.name.slice(1, -1) : r.name, fields: r.fields.map((f) => ({ ...f, value: plain(f.value) })), notes: r.notes.map(plain) }
+      })
+      if (items.length >= 2 && records.every(Boolean) && areRecords(records as Record[])) {
+        out.push(recordsMarkdown(records as Record[], width, " ".repeat(depth)))
+        n = end
+        continue
+      }
+    }
+    out.push(readableTimes(line))
+  }
+  return out.join("\n")
+}

package/src/tui/session.ts

@@ -1,4 +1,5 @@
 import type { FileAction, PlanItem } from "../types.ts"
+import { BRAIN, faceOf } from "./agentIcons.ts"
 
 /**
  * What the shell's right-hand pane shows about the request in progress: the agent's plan, the browser steps or suite
@@ -10,7 +11,11 @@ export type FileUse = { path: string; reads: number; changes: number; last: File
 
 export type Progress = { label: string; status: "running" | "ok" | "fail" | "skipped"; detail?: string; actions?: string[] }
 
-export type Who = "ForgeQE's agent" | "Browser agent" | "Scribe"
+/**
+ * An agent that took part in the request, by its name in src/agents.ts. Waiting: ForgeQE's agent while a subagent it
+ * started works. `ms`: how long it has worked, `since` when its current turn started.
+ */
+export type CrewMember = { agent: string; state: "working" | "waiting" | "done" | "failed" | "stopped"; ms: number; since?: number }
 
 export type Inspector = {
   /** The agent's own to-do list. */
@@ -21,7 +26,11 @@ export type Inspector = {
   /** Input tokens of the latest model call: how full its context window is. */
   context: number
   skills: string[]
-  who: Who
+  /** The agent working now (its name in src/agents.ts), and what the shell calls it. */
+  agent: string
+  who: string
+  /** Every agent that took part in the request, in the order they started. */
+  crew: CrewMember[]
   /** Counts file uses, so the most recent comes first. */
   seq: number
 }
@@ -29,14 +38,16 @@ export type Inspector = {
 export const MAX_PROGRESS = 200
 
 export function newInspector(): Inspector {
-  return { plan: [], progress: { title: "", items: [] }, files: new Map(), context: 0, skills: [], who: "ForgeQE's agent", seq: 0 }
+  return { plan: [], progress: { title: "", items: [] }, files: new Map(), context: 0, skills: [], agent: BRAIN, who: faceOf(BRAIN).name, crew: [], seq: 0 }
 }
 
 /** A new request keeps the files, skills, and context of the session, and starts a fresh plan and progress. */
 export function newRequest(s: Inspector): void {
   s.plan = []
   s.progress = { title: "", items: [] }
-  s.who = "ForgeQE's agent"
+  s.agent = BRAIN
+  s.who = faceOf(BRAIN).name
+  s.crew = []
 }
 
 export function setPlan(s: Inspector, items: PlanItem[]): void {
@@ -59,8 +70,39 @@ export function setContext(s: Inspector, tokens: number): void {
   if (tokens > 0) s.context = tokens
 }
 
-export function setWho(s: Inspector, who: Who): void {
-  s.who = who
+/**
+ * `agent` works now. The one that worked before stops its clock: ForgeQE's agent waits for what it started, any other
+ * is done until it works again. True when this changed who is working.
+ */
+export function agentWorking(s: Inspector, agent: string, now = Date.now()): boolean {
+  const member = s.crew.find((m) => m.agent === agent)
+  if (s.agent === agent && member?.state === "working") return false
+  for (const m of s.crew) {
+    if (m.state !== "working") continue
+    m.ms += now - (m.since ?? now)
+    m.since = undefined
+    m.state = m.agent === BRAIN ? "waiting" : "done"
+  }
+  if (member) Object.assign(member, { state: "working", since: now })
+  else s.crew.push({ agent, state: "working", ms: 0, since: now })
+  s.agent = agent
+  s.who = faceOf(agent).name
+  return true
+}
+
+/** The request is over: every agent is done, and the one working at the end failed or was stopped with it. */
+export function crewDone(s: Inspector, status: "done" | "fail" | "stopped", now = Date.now()): void {
+  for (const m of s.crew) {
+    const working = m.state === "working"
+    if (working) m.ms += now - (m.since ?? now)
+    m.since = undefined
+    m.state = working && status === "fail" ? "failed" : working && status === "stopped" ? "stopped" : "done"
+  }
+}
+
+/** How long a member has worked, its current turn included. */
+export function crewMs(m: CrewMember, now = Date.now()): number {
+  return m.ms + (m.since !== undefined ? now - m.since : 0)
 }
 
 export function startProgress(s: Inspector, title: string): void {

package/src/tui/text.ts

@@ -7,6 +7,14 @@ export function clip(text: string, n = 72): string {
   return s.length <= n ? s : `${s.slice(0, n - 1)}…`
 }
 
+/** Markdown as the text it reads as, for rows cut to a width, where markers would show: "**3** in `src`" → "3 in src". */
+export function plainText(md: string): string {
+  return md
+    .replace(/\[([^\]]+)\]\([^)\s]+\)/g, "$1")
+    .replace(/\*\*|__|`/g, "")
+    .replace(/^#{1,6}\s+/, "")
+}
+
 /** "…/pages/LoginPage.ts": a path cut from the start, since its end tells files apart. */
 export function tailCut(text: string, n: number): string {
   return text.length <= n ? text : `…${text.slice(text.length - n + 1)}`

package/src/tui/theme.ts

@@ -19,6 +19,32 @@ export const theme = {
   onButton: "#0d1117",
 }
 
+/**
+ * The agents' colours (src/tui/agentIcons.ts), one per agent: its main tone, for its name and icon, and the deeper one
+ * where its icon's shapes overlap. Neighbouring hues go to agents that do the same kind of work.
+ */
+export const AGENT_HUES = {
+  // Plan and lead.
+  purple: { main: "#a78bfa", deep: "#5b2bc4" },
+  indigo: { main: "#8fa2ff", deep: "#3d4fd6" },
+  orchid: { main: "#e0a3f5", deep: "#a443d6" },
+  magenta: { main: "#f59fe0", deep: "#c2389e" },
+  // Run and look.
+  blue: { main: "#a9d0f8", deep: "#5ea6f0" },
+  cyan: { main: "#8ee3f5", deep: "#1fa3c4" },
+  yellow: { main: "#f0e48c", deep: "#b8a32a" },
+  // Write code.
+  green: { main: "#6fd3b2", deep: "#3a9a7e" },
+  leaf: { main: "#9be89b", deep: "#3fa34d" },
+  lime: { main: "#cde88a", deep: "#86a92c" },
+  teal: { main: "#7fe0d6", deep: "#1f9c90" },
+  // Judge.
+  pink: { main: "#f29bc9", deep: "#e0457b" },
+  rose: { main: "#ff9eaa", deep: "#d93a52" },
+  coral: { main: "#ffb199", deep: "#e0603a" },
+  orange: { main: "#ffc58a", deep: "#d6701f" },
+}
+
 /** 950 → "950", 47_100 → "47.1K", 2_300_000 → "2.3M". */
 export function formatTokens(n: number): string {
   if (n < 1000) return String(n)

package/src/tui/transcript.tsx

@@ -2,7 +2,8 @@ import { existsSync } from "node:fs"
 import os from "node:os"
 import path from "node:path"
 import { SyntaxStyle } from "@opentui/core"
-import { createContext, useContext, type ReactNode } from "react"
+import { useRenderer } from "@opentui/react"
+import { createContext, useContext, useEffect, useState, type ReactNode } from "react"
 
 import type { CodeResult, RunStatus } from "../types.ts"
 import { CARD_MARK, type Card } from "../card.ts"
@@ -11,6 +12,7 @@ import { suiteExitCode, type SuiteResult } from "../suite/run.ts"
 import { STATUS_MARK, shortPath, type RunSummary } from "../summary.ts"
 import { BAR } from "./components.tsx"
 import { formatDuration, formatTokens, theme } from "./theme.ts"
+import { readable } from "./readable.ts"
 import { clip, shortLink } from "./text.ts"
 
 /** The transcript: its lines, and the cards for a run, a suite, a tool result, and what a request produced. */
@@ -363,30 +365,132 @@ function replyStyle(): SyntaxStyle {
   return style
 }
 
-/** A reply cut into what reads better laid out than wrapped: headings, list items with their depth, and the rest. */
+let notes: SyntaxStyle | undefined
+/** The agent's notes between its calls: the reply's markdown styles, in the colour of thoughts. */
+function noteStyle(): SyntaxStyle {
+  notes ||= SyntaxStyle.fromStyles({
+    default: { fg: theme.thought },
+    "markup.strong": { bold: true },
+    "markup.italic": { italic: true },
+    "markup.raw": { fg: theme.memory },
+    "markup.link": { fg: theme.accent, underline: true },
+    "markup.link.label": { fg: theme.accent, underline: true },
+    "markup.link.url": { fg: theme.muted },
+  })
+  return notes
+}
+
+/** A reply cut into what reads better laid out than wrapped: headings, list items with their depth, tables, and the rest. */
 export type ReplyBlock =
   | { kind: "heading"; text: string }
   | { kind: "item"; depth: number; mark: string; text: string }
+  | { kind: "table"; text: string }
   | { kind: "markdown"; text: string }
 
+/**
+ * A table cell in a terminal without hyperlinks shows a link's label only: there the address is written out beside
+ * it and would take the column over. Where links are clickable the cell keeps them.
+ */
+export function tableText(md: string): string {
+  return md.replace(/\[([^\]]+)\]\((?:https?:|mailto:)[^)\s]*\)/g, "$1")
+}
+
+/** Bare addresses longer than this get a short label, where the terminal makes the label a link. */
+const BARE_LINK_MAX = 40
+/** An address on its own: not a link's target ("](") or label, nor in angle brackets, quotes, or a word. */
+const BARE_URL = /(?<![\w[<"'`/])(?<!\]\()https?:\/\/[^\s<>()[\]`"']+/g
+
+/** "dev.azure.com/…/edit/1234": the host and the last parts of the path that fit, since those tell links apart. */
+export function urlLabel(href: string, max = BARE_LINK_MAX): string {
+  const shown = href.replace(/^https?:\/\//, "").replace(/\/$/, "")
+  if (shown.length <= max) return shown
+  const [host, ...parts] = shown.split("/")
+  let tail = ""
+  for (const part of parts.reverse()) {
+    const next = tail ? `${part}/${tail}` : part
+    if (host!.length + 3 + next.length > max) break
+    tail = next
+  }
+  // Even the last part does not fit: as much of its start as does.
+  if (!tail) tail = `${parts[0]!.slice(0, Math.max(4, max - host!.length - 4))}…`
+  return `${host}/…/${tail}`
+}
+
+/** A long bare address as a short link, clickable to the whole address. Inline code and trailing punctuation stay. */
+export function linkBareUrls(line: string): string {
+  return line
+    .split(/(`[^`]*`)/)
+    .map((part) =>
+      part.startsWith("`")
+        ? part
+        : part.replace(BARE_URL, (url) => {
+            const tail = /[.,;:!?]+$/.exec(url)?.[0] || ""
+            const href = tail ? url.slice(0, -tail.length) : url
+            if (href.replace(/^https?:\/\//, "").length <= BARE_LINK_MAX) return url
+            return `[${urlLabel(href).replace(/([\\`*_[\]])/g, "\\$1")}](${href})${tail}`
+          }),
+    )
+    .join("")
+}
+
+/** A table's delimiter row: "|---|:--:|", or "--- | ---" without the outer pipes. */
+const TABLE_RULE = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/
+
+/** A line that starts a table: a row with a leading pipe, or any row with a pipe that a delimiter row follows. */
+function startsTable(line: string, next: string | undefined): boolean {
+  return /^\s*\|/.test(line) || (line.includes("|") && next !== undefined && next.includes("|") && TABLE_RULE.test(next))
+}
+
+/** Whether the terminal makes links clickable (OSC 8); the answer can come after the first frame. */
+function useHyperlinks(): boolean {
+  const renderer = useRenderer()
+  const [on, setOn] = useState(renderer.capabilities?.hyperlinks === true)
+  useEffect(() => {
+    const changed = (c: { hyperlinks?: boolean } | null) => setOn(c?.hyperlinks === true)
+    renderer.on("capabilities", changed)
+    return () => {
+      renderer.off("capabilities", changed)
+    }
+  }, [renderer])
+  return on
+}
+
 const ITEM = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/
 
-export function replyBlocks(md: string): ReplyBlock[] {
+/** `hyperlinks`: the terminal makes links clickable, so long bare addresses become short links and table cells keep theirs. */
+export function replyBlocks(md: string, opts: { hyperlinks?: boolean } = {}): ReplyBlock[] {
   const blocks: ReplyBlock[] = []
   let rest: string[] = []
+  let table: string[] = []
   let fence = false
   const flush = () => {
     const text = rest.join("\n").trim()
     if (text) blocks.push({ kind: "markdown", text })
     rest = []
   }
-  for (const line of md.replace(/\r/g, "").split("\n")) {
-    if (/^\s*(```|~~~)/.test(line)) fence = !fence
+  // A table is a block of its own: in one block with the text around it, the text above it was not drawn.
+  const endTable = () => {
+    if (table.length) blocks.push({ kind: "table", text: table.join("\n") })
+    table = []
+  }
+  const links = (line: string) => (opts.hyperlinks ? linkBareUrls(line) : line)
+  const lines = md.replace(/\r/g, "").split("\n")
+  for (let n = 0; n < lines.length; n++) {
+    const raw = lines[n]!
+    if (/^\s*(```|~~~)/.test(raw)) fence = !fence
+    // A table runs from its first row while its lines have a pipe; a row may have no leading pipe.
+    if (!fence && (table.length ? raw.trim() !== "" && raw.includes("|") : startsTable(raw, lines[n + 1]))) {
+      if (!table.length) flush()
+      table.push(opts.hyperlinks ? linkBareUrls(raw) : tableText(raw))
+      continue
+    }
+    endTable()
     const last = blocks.at(-1)
-    if (fence || /^\s*(```|~~~)/.test(line) || /^\s*\|/.test(line)) {
-      rest.push(line)
+    if (fence || /^\s*(```|~~~)/.test(raw)) {
+      rest.push(raw)
       continue
     }
+    const line = links(raw)
     const heading = /^#{1,6}\s+(.*)$/.exec(line)
     const item = ITEM.exec(line)
     if (heading) {
@@ -404,13 +508,15 @@ export function replyBlocks(md: string): ReplyBlock[] {
       rest.push(line)
     } else rest.push(line)
   }
+  endTable()
   flush()
   return blocks
 }
 
 /** The agent's reply: headings with room above, list items with their marks in a column so wrapped lines hang under the text. */
 function ReplyBody({ text }: { text: string }) {
-  const blocks = replyBlocks(text)
+  // Whatever wrote it, the reply is made readable first: records as tables, times as dates, JSON as code.
+  const blocks = replyBlocks(readable(text, useContext(LineRoom) || 80), { hyperlinks: useHyperlinks() })
   return (
     <box style={{ flexDirection: "column", flexShrink: 0 }}>
       {blocks.map((b, i) =>
@@ -419,7 +525,7 @@ function ReplyBody({ text }: { text: string }) {
             <strong>{b.text}</strong>
           </text>
         ) : b.kind === "item" ? (
-          <box key={i} style={{ flexDirection: "row", flexShrink: 0, paddingLeft: b.depth * 2, marginTop: blocks[i - 1]?.kind === "markdown" ? 1 : 0 }}>
+          <box key={i} style={{ flexDirection: "row", flexShrink: 0, paddingLeft: b.depth * 2, marginTop: blocks[i - 1]?.kind === "markdown" || blocks[i - 1]?.kind === "table" ? 1 : 0 }}>
             <text fg={theme.accent} style={{ width: b.mark.length + 1, flexShrink: 0 }}>
               {b.mark}
             </text>
@@ -427,6 +533,11 @@ function ReplyBody({ text }: { text: string }) {
               <markdown content={b.text} syntaxStyle={replyStyle()} fg={theme.text} conceal />
             </box>
           </box>
+        ) : b.kind === "table" ? (
+          // Columns without a grid, so a long table stays one row per item; short columns (names, dates) keep their width and long ones wrap.
+          <box key={i} style={{ marginTop: i ? 1 : 0, flexShrink: 0 }}>
+            <markdown content={b.text} syntaxStyle={replyStyle()} fg={theme.text} conceal tableOptions={{ style: "columns", widthMode: "content", columnFitter: "balanced", wrapMode: "word", borderColor: theme.border }} />
+          </box>
         ) : (
           <box key={i} style={{ marginTop: i ? 1 : 0, flexShrink: 0 }}>
             <markdown content={b.text} syntaxStyle={replyStyle()} fg={theme.text} conceal tableOptions={{ widthMode: "content", wrapMode: "word" }} />
@@ -456,6 +567,7 @@ function callParts(text: string): [string, string] {
  * and the first line under an entry gets "⎿".
  */
 export function TranscriptLine({ line, prev }: { line: Line; prev?: Line }) {
+  const room = useContext(LineRoom)
   // An entry with nothing to say is left out rather than shown as a bare mark.
   if (!line.text.trim() && !line.card && !line.summary && !line.suite && line.kind !== "sys") return null
   if (line.kind === "card" && line.card) return <ResultCard card={line.card} />
@@ -517,7 +629,8 @@ export function TranscriptLine({ line, prev }: { line: Line; prev?: Line }) {
         <span fg={theme.text}>{line.text}</span>
       </text>
     ) : line.kind === "thought" ? (
-      <text fg={theme.thought}>{line.text}</text>
+      // What the agent says between its calls is markdown too: bold, code, and links read as they do in a reply.
+      <markdown content={readable(line.text, room || 80)} syntaxStyle={noteStyle()} fg={theme.thought} conceal />
     ) : line.kind === "timing" ? (
       <text fg={theme.faint}>{line.text}</text>
     ) : line.kind === "code" ? (

package/src/types.ts

@@ -135,7 +135,7 @@ export type FileAction = "read" | "write" | "edit"
 /** One item of an agent's own to-do list (the agent runtime's todowrite). */
 export type PlanItem = { text: string; status: "pending" | "in_progress" | "completed" | "cancelled" }
 
-export type CodeEvent =
+export type CodeEvent = (
   | { type: "code"; kind: "info"; text: string }
   /** A finished tool call: `tool` is its name, and `file` the file it read or changed, relative to the repository. */
   | { type: "code"; kind: "tool"; text: string; ok: boolean; tool?: string; file?: { path: string; action: FileAction }; skill?: string; id?: string }
@@ -153,6 +153,10 @@ export type CodeEvent =
   | { type: "code"; kind: "attempt"; attempt: number; max: number; why: string; fixing: string[] }
   /** What Scribe said it did in an attempt: its notes, and the files it changed. */
   | { type: "code"; kind: "answer"; attempt: number; notes?: string; changed: string[] }
+) & {
+  /** The agent whose session sent it (its name in src/agents.ts), set by openSession, so the shell shows who is working. */
+  agent?: string
+}
 
 export type AgentEvent =
   | { type: "log"; level: "info" | "warn" | "error"; text: string }