@capagents/forgeqe 1.1.8 → 1.1.9

package/HOW_TO_USE.md

@@ -647,7 +647,22 @@ What happens after the run passes:
 4. It writes the test from the handoff and the replay script: steps that worked are ported with their locators, steps that failed are fixed first. Every locator, including those for assertions, comes from the replay script, the page snapshots, page memory, or a check on the page; steps where the browser agent ran JavaScript to look around are left out. It does not walk the flow again or build tests to explore. Once a step fails (in the replay, or in its test), ForgeQE switches on its live browser: a Chrome that Playwright drives, set up like ForgeQE's, where it looks at the failing step's page one tool call per action (open, snapshot, click, type, wait, screenshot, run JavaScript, console errors, failed requests). Until then the live browser tools are off, so no tokens go into looking at pages that work. The live browser needs Node.js (`npx`), and Microsoft's Playwright MCP server is downloaded on first use; with `live_browser: false`, or without `npx`, it looks with a small throwaway script instead. When its browser gets a different page than ForgeQE's did (an error, a challenge, a control that will not open), it compares the two browsers (user agent, `navigator.webdriver`, headless, failed requests and CORS errors, headers the framework adds, console errors) and fixes the difference in the repo's browser configuration. It never judges the site with `curl` or `webfetch`.
 5. Scribe does not run the test itself: it may build or compile, then reports the test file and the command that runs only that test, and ForgeQE runs it. If one command it runs fails `stall_after` times in a row within its work (the same build again and again, say), ForgeQE stops that turn and sends the command and its last output back, asking it to change approach. If the same command stalls again, the job stops as a failure with that output in the notes.
 6. ForgeQE runs that command (with `CI=1`) and checks the exit code, and it watches the processes the command starts for a browser launched by Playwright, Puppeteer, Selenium, or Cypress. On a failure it sends the command, exit code, and output back to Scribe. The output is kept short so the error is never cut off: the page dump Playwright puts into a failed assertion ("Aria snapshot:", often thousands of lines) is taken out and saved as `<run>/test-runs/attempt-N-page.aria.yml`, then the start (where the first error and its stack trace are) and the end (the summary) are sent; the full output is in `<run>/test-runs/attempt-N.log`, and the prompt names both files. A command that exits 0 without starting a browser also goes back: the test must drive the app in a browser. If the repo's browser runs on another machine (Selenium Grid, a cloud service, a container), the agent says where and the check is skipped.
-7. A passing test then goes to a separate reviewer agent, which can read files and `git diff` but not change anything. It checks the change against the goal and the test rules: every part of the goal done through the page and asserted, generic page objects with data in the test, no values or URLs copied from the run, browser settings in the repo's configuration, no leftover files. The changed files come inline in its prompt, so it reads nothing again, and it does not ask to replace locators or texts that came from the replay or the checks, since those matched the live site. It judges only what this job changed: ForgeQE records the working tree before the job, so your uncommitted edits, your untracked files, and ForgeQE's own files (`.forgeqe/`, `forgeqe.yaml`, `llms.json`) are never part of the review. It checks the diff of every file that existed before the job: removing or rewriting an existing test, even a commented-out one, is a correctness problem. Credentials come from the environment, except a public demo login that the application itself shows to anyone (such as the logins on saucedemo.com's sign-in page), which may stay in the repo's test data. It gets the outlines of the classes the changed code uses, the repo's browser settings, and the same `code_*` tools, so it checks reuse and settings without reading those files. The code graph also tells it what the job added that it can check in the code: a new member that locates an element an existing member already locates (to reuse instead), and new XPath or position-based locators. If it finds problems, they go back to Scribe as the next attempt.
+7. A passing test then goes to a separate reviewer agent, which can read files and `git diff` but not change anything. It checks the change against the goal and the test rules: every part of the goal done through the page and asserted, generic page objects with data in the test, no values or URLs copied from the run, browser settings in the repo's configuration, no leftover files. The changed files come inline in its prompt, so it reads nothing again, and it does not ask to replace locators or texts that came from the replay or the checks, since those matched the live site. It judges only what this job changed: ForgeQE records the working tree before the job, so your uncommitted edits, your untracked files, and ForgeQE's own files (`.forgeqe/`, `forgeqe.yaml`, `llms.json`) are never part of the review. It checks the diff of every file that existed before the job: removing or rewriting an existing test, even a commented-out one, is a correctness problem. Credentials come from the environment, except a public demo login that the application itself shows to anyone (such as the logins on saucedemo.com's sign-in page), which may stay in the repo's test data. It gets the outlines of the classes the changed code uses, the repo's browser settings, and the same `code_*` tools, so it checks reuse and settings without reading those files. The code graph also tells it what the job added that it can check in the code: a new member that locates an element an existing member already locates (to reuse instead), and new XPath or position-based locators. If it finds problems, they go back to Scribe as the next attempt. The terminal shows the exchange as it happens, in order: the reviewer's verdict with its reason and each issue (✗ correctness, ~ coding standard) with the file and the fix it asks for; then why Scribe tries again and what it is fixing (the reviewer's issues, or the test's first error); then what Scribe says it did and which files it changed; then the next verdict:
+
+```
+⏺ Reviewer asked for changes  attempt 1 of 5 · 1 to fix, 1 coding-standard
+  ⎿ The test never checks that the pie chart is shown.
+    ✗ Correctness · tests/PracticeTests.cs: No assertion on the SVG pie chart.
+        Fix: Assert the chart's heading and SVG are visible.
+    ~ Coding standard · tests/PracticeTests.cs: Test data is inline.
+        Fix: Move it to the page object.
+⏺ Scribe tries again · attempt 2 of 5  the reviewer asked for changes
+  ⎿ → tests/PracticeTests.cs: No assertion on the SVG pie chart. — fix: Assert the chart's heading and SVG are visible.
+  ⎿ Scribe (attempt 2): Added the pie chart assertion · changed tests/PracticeTests.cs, Pages/PracticePage.cs
+⏺ Reviewer approved the test  attempt 2 of 5
+```
+
+The Activities panel has one line for each verdict and attempt, and `forgeqe` commands outside the terminal UI print the same blocks.
 
    Scribe cannot edit ForgeQE's files or run folders, and cannot run `git clean`, `git reset --hard`, `git stash`, `git restore`, or `git checkout -- <path>`. If it still removes a file that existed before the job, or reverts your uncommitted edits, ForgeQE puts the file back after that attempt and tells the agent.
 8. The job is done when ForgeQE's run passes with a browser and the reviewer approves. It stops as a failure after `max_attempts` attempts, when the job passes `code.max_tokens`, when the reviewer rejects a passing test twice, if the review cannot finish, when the test fails the same way three times in a row (the same output apart from numbers such as timings and line numbers; the second time, Scribe is told its change did not change the failure and to look at the failing step before changing code), or straight away on an auth, API, or context-limit error from the model.

package/docs/user-guide.html

@@ -1302,13 +1302,23 @@ Acceptance criteria:
 <p>ForgeQE runs that command (with <code>CI=1</code>) and checks the exit code, and it watches the processes the command starts for a browser launched by Playwright, Puppeteer, Selenium, or Cypress. On a failure it sends the command, exit code, and output back to Scribe. The output is kept short so the error is never cut off: the page dump Playwright puts into a failed assertion (&quot;Aria snapshot:&quot;, often thousands of lines) is taken out and saved as <code>&lt;run&gt;/test-runs/attempt-N-page.aria.yml</code>, then the start (where the first error and its stack trace are) and the end (the summary) are sent; the full output is in <code>&lt;run&gt;/test-runs/attempt-N.log</code>, and the prompt names both files. A command that exits 0 without starting a browser also goes back: the test must drive the app in a browser. If the repo's browser runs on another machine (Selenium Grid, a cloud service, a container), the agent says where and the check is skipped.</p>
 </li>
 <li>
-<p>A passing test then goes to a separate reviewer agent, which can read files and <code>git diff</code> but not change anything. It checks the change against the goal and the test rules: every part of the goal done through the page and asserted, generic page objects with data in the test, no values or URLs copied from the run, browser settings in the repo's configuration, no leftover files. The changed files come inline in its prompt, so it reads nothing again, and it does not ask to replace locators or texts that came from the replay or the checks, since those matched the live site. It judges only what this job changed: ForgeQE records the working tree before the job, so your uncommitted edits, your untracked files, and ForgeQE's own files (<code>.forgeqe/</code>, <code>forgeqe.yaml</code>, <code>llms.json</code>) are never part of the review. It checks the diff of every file that existed before the job: removing or rewriting an existing test, even a commented-out one, is a correctness problem. Credentials come from the environment, except a public demo login that the application itself shows to anyone (such as the logins on saucedemo.com's sign-in page), which may stay in the repo's test data. It gets the outlines of the classes the changed code uses, the repo's browser settings, and the same <code>code_*</code> tools, so it checks reuse and settings without reading those files. The code graph also tells it what the job added that it can check in the code: a new member that locates an element an existing member already locates (to reuse instead), and new XPath or position-based locators. If it finds problems, they go back to Scribe as the next attempt.</p>
-<p>Scribe cannot edit ForgeQE's files or run folders, and cannot run <code>git clean</code>, <code>git reset --hard</code>, <code>git stash</code>, <code>git restore</code>, or <code>git checkout -- &lt;path&gt;</code>. If it still removes a file that existed before the job, or reverts your uncommitted edits, ForgeQE puts the file back after that attempt and tells the agent.</p>
-</li>
-<li>
-<p>The job is done when ForgeQE's run passes with a browser and the reviewer approves. It stops as a failure after <code>max_attempts</code> attempts, when the job passes <code>code.max_tokens</code>, when the reviewer rejects a passing test twice, if the review cannot finish, when the test fails the same way three times in a row (the same output apart from numbers such as timings and line numbers; the second time, Scribe is told its change did not change the failure and to look at the failing step before changing code), or straight away on an auth, API, or context-limit error from the model.</p>
+<p>A passing test then goes to a separate reviewer agent, which can read files and <code>git diff</code> but not change anything. It checks the change against the goal and the test rules: every part of the goal done through the page and asserted, generic page objects with data in the test, no values or URLs copied from the run, browser settings in the repo's configuration, no leftover files. The changed files come inline in its prompt, so it reads nothing again, and it does not ask to replace locators or texts that came from the replay or the checks, since those matched the live site. It judges only what this job changed: ForgeQE records the working tree before the job, so your uncommitted edits, your untracked files, and ForgeQE's own files (<code>.forgeqe/</code>, <code>forgeqe.yaml</code>, <code>llms.json</code>) are never part of the review. It checks the diff of every file that existed before the job: removing or rewriting an existing test, even a commented-out one, is a correctness problem. Credentials come from the environment, except a public demo login that the application itself shows to anyone (such as the logins on saucedemo.com's sign-in page), which may stay in the repo's test data. It gets the outlines of the classes the changed code uses, the repo's browser settings, and the same <code>code_*</code> tools, so it checks reuse and settings without reading those files. The code graph also tells it what the job added that it can check in the code: a new member that locates an element an existing member already locates (to reuse instead), and new XPath or position-based locators. If it finds problems, they go back to Scribe as the next attempt. The terminal shows the exchange as it happens, in order: the reviewer's verdict with its reason and each issue (✗ correctness, ~ coding standard) with the file and the fix it asks for; then why Scribe tries again and what it is fixing (the reviewer's issues, or the test's first error); then what Scribe says it did and which files it changed; then the next verdict:</p>
 </li>
 </ol>
+<pre><code>⏺ Reviewer asked for changes  attempt 1 of 5 · 1 to fix, 1 coding-standard
+  ⎿ The test never checks that the pie chart is shown.
+    ✗ Correctness · tests/PracticeTests.cs: No assertion on the SVG pie chart.
+        Fix: Assert the chart's heading and SVG are visible.
+    ~ Coding standard · tests/PracticeTests.cs: Test data is inline.
+        Fix: Move it to the page object.
+⏺ Scribe tries again · attempt 2 of 5  the reviewer asked for changes
+  ⎿ → tests/PracticeTests.cs: No assertion on the SVG pie chart. — fix: Assert the chart's heading and SVG are visible.
+  ⎿ Scribe (attempt 2): Added the pie chart assertion · changed tests/PracticeTests.cs, Pages/PracticePage.cs
+⏺ Reviewer approved the test  attempt 2 of 5
+</code></pre>
+<p>The Activities panel has one line for each verdict and attempt, and <code>forgeqe</code> commands outside the terminal UI print the same blocks.</p>
+<p>Scribe cannot edit ForgeQE's files or run folders, and cannot run <code>git clean</code>, <code>git reset --hard</code>, <code>git stash</code>, <code>git restore</code>, or <code>git checkout -- &lt;path&gt;</code>. If it still removes a file that existed before the job, or reverts your uncommitted edits, ForgeQE puts the file back after that attempt and tells the agent.
+8. The job is done when ForgeQE's run passes with a browser and the reviewer approves. It stops as a failure after <code>max_attempts</code> attempts, when the job passes <code>code.max_tokens</code>, when the reviewer rejects a passing test twice, if the review cannot finish, when the test fails the same way three times in a row (the same output apart from numbers such as timings and line numbers; the second time, Scribe is told its change did not change the failure and to look at the failing step before changing code), or straight away on an auth, API, or context-limit error from the model.</p>
 <p><code>blocked</code> is a last resort. The first time the agent reports that the app blocks it, ForgeQE sends it back to compare its browser with ForgeQE's and fix the difference; only a second blocked report, with what it compared, ends the job as blocked.</p>
 <p>The transcript shows the handover and Scribe's work as it goes; files it writes or edits are marked ✎:</p>
 <pre><code>┃

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capagents/forgeqe",
-  "version": "1.1.8",
+  "version": "1.1.9",
   "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/src/code/exchange.ts

@@ -0,0 +1,53 @@
+import type { Card } from "../card.ts"
+import type { CodeEvent } from "../types.ts"
+
+/**
+ * The exchange between Scribe and the reviewer, as the shell and the CLI show it: what the reviewer found and why,
+ * why Scribe tries again and what it is fixing, and what Scribe says it did. One place, so both say the same.
+ */
+
+type Review = Extract<CodeEvent, { kind: "review" }>
+type Attempt = Extract<CodeEvent, { kind: "attempt" }>
+type Answer = Extract<CodeEvent, { kind: "answer" }>
+
+const clip = (t: string, n: number) => {
+  const s = t.replace(/\s+/g, " ").trim()
+  return s.length <= n ? s : `${s.slice(0, n - 1)}…`
+}
+
+/** "✗ Does not test the goal · tests/Practice.cs: the pie chart is never checked", then the fix under it. */
+export function reviewCard(e: Review): Card {
+  const correctness = e.issues.filter((i) => i.kind !== "standards").length
+  const standards = e.issues.length - correctness
+  const count = [correctness ? `${correctness} to fix` : "", standards ? `${standards} coding-standard` : ""].filter(Boolean).join(", ")
+  return {
+    status: e.approved ? "ok" : "fail",
+    title: e.approved ? (standards ? "Reviewer approved the test, with coding-standard notes" : "Reviewer approved the test") : "Reviewer asked for changes",
+    stats: [`attempt ${e.attempt} of ${e.max}`, count].filter(Boolean).join(" · "),
+    body: [
+      ...(e.summary ? [clip(e.summary, 400)] : []),
+      ...(e.issues.length ? [""] : []),
+      ...e.issues.flatMap((i) => [
+        // ✗ marks what makes the test wrong, ~ how it is written: the colours follow the mark.
+        `${i.kind === "standards" ? "~ Coding standard" : "✗ Correctness"}${i.file ? ` · ${i.file}` : ""}: ${clip(i.problem, 300)}`,
+        ...(i.fix ? [`    Fix: ${clip(i.fix, 300)}`] : []),
+      ]),
+    ],
+  }
+}
+
+/** "Scribe · attempt 2 of 5 · the reviewer asked for changes", then each thing it was asked to fix. */
+export function attemptCard(e: Attempt): Card {
+  return {
+    status: "info",
+    title: `Scribe tries again · attempt ${e.attempt} of ${e.max}`,
+    ...(e.why ? { stats: e.why } : {}),
+    body: e.fixing.map((f) => `→ ${clip(f, 300)}`),
+  }
+}
+
+/** "Scribe (attempt 2): Moved the values into PracticePage · changed tests/Practice.cs, pages/PracticePage.cs". */
+export function answerText(e: Answer): string {
+  const files = e.changed.length ? `changed ${e.changed.slice(0, 4).join(", ")}${e.changed.length > 4 ? ` +${e.changed.length - 4} more` : ""}` : ""
+  return `Scribe (attempt ${e.attempt}): ${[e.notes ? clip(e.notes, 300) : "", files].filter(Boolean).join(" · ")}`
+}

package/src/code/loop.ts

@@ -38,6 +38,7 @@ import {
   standardsFixPrompt,
   type AgentReport,
   type ExistingTest,
+  type ReviewIssue,
 } from "./prompt.ts"
 import { openReviewer, type Reviewer } from "./review.ts"
 import { runTestCommand } from "./testrun.ts"
@@ -254,6 +255,9 @@ export async function runCodeAgent(opts: {
   let spent: Usage = { input: 0, output: 0 }
   const attemptLog: string[] = []
   let nextTask: string | null = null
+  /** Why the next attempt runs and what it is to fix, as the shell shows it: "the reviewer asked for changes", its issues. */
+  let next: { why: string; fixing: string[] } = { why: "", fixing: [] }
+  const issueText = (i: ReviewIssue) => `${i.file ? `${i.file}: ` : ""}${i.problem}${i.fix ? ` — fix: ${i.fix}` : ""}`
   let notesText: string | undefined = known ? notesSection(known) : undefined
   // The repository's test setup, read by ForgeQE without a model; Scribe starts from it instead of a reading turn.
   const repoProfile = buildProfile(repo)
@@ -374,7 +378,7 @@ export async function runCodeAgent(opts: {
         session = await (opts.open || openSession)(sessionOptions())
         result.sessionId = session.sessionId
         saveSession()
-        emit({ type: "code", kind: "info", text: `Scribe starts attempt ${attempt} in a fresh session, from a summary of the job so far` })
+        emit({ type: "code", kind: "attempt", attempt, max: allowed, why: next.why, fixing: next.fixing })
         prompt = nextAttemptPrompt({
           handoff,
           notes: [profileText, notesText].filter(Boolean).join("\n\n") || undefined,
@@ -417,6 +421,8 @@ export async function runCodeAgent(opts: {
         break
       }
       if (reply.report) report = { ...report, ...reply.report }
+      // What Scribe says it did this time, so a retry is not only "Editing …" lines.
+      if (reply.report && (reply.report.notes || reply.report.changed?.length)) emit({ type: "code", kind: "answer", attempt, ...(reply.report.notes ? { notes: reply.report.notes } : {}), changed: reply.report.changed || [] })
       result.notes = report.notes || reply.text.slice(0, 500)
       if (reply.error && FATAL_ERRORS.some((name) => reply.error!.startsWith(name))) {
         result.notes = reply.error
@@ -477,6 +483,7 @@ export async function runCodeAgent(opts: {
         emit({ type: "code", kind: "test", ok: false, attempt, text: `${report.test_file} exited 0 in ${secs}s but opened no browser (attempt ${attempt}/${maxAttempts})` })
         attemptLog.push(attemptLine(attempt, "exited 0 but opened no browser", "", report.notes))
         nextTask = noBrowserPrompt(report.command)
+        next = { why: "the test passed without opening a browser", fixing: ["Make the test drive a real browser, as the run did"] }
         continue
       }
       if (run.ok) {
@@ -501,6 +508,8 @@ export async function runCodeAgent(opts: {
         result.review = verdict.review
         const correctness = verdict.review.issues.filter((i) => i.kind !== "standards")
         const standards = verdict.review.issues.filter((i) => i.kind === "standards")
+        // The verdict as the reviewer gave it: with only coding-standard issues the test is approved and gets a tidy-up.
+        emit({ type: "code", kind: "review", attempt, max: allowed, approved: verdict.review.approved || !correctness.length, summary: verdict.review.summary, issues: verdict.review.issues })
         // Coding standards alone never fail a test that works and tests the goal.
         if (tidying && correctness.length) {
           // The tidy-up changed what the test does: back to the version that passed.
@@ -515,6 +524,7 @@ export async function runCodeAgent(opts: {
             emit({ type: "code", kind: "test", ok: true, attempt, text: `${report.test_file} passed and tests the goal; the reviewer found ${standards.length} coding-standard ${standards.length === 1 ? "issue" : "issues"}, so the agent fixes ${standards.length === 1 ? "it" : "them"} in one more round (the passing version is kept if that breaks it)` })
             attemptLog.push(attemptLine(attempt, "passed and tests the goal; coding-standard issues to fix", standards.map((i) => i.problem).join(" "), report.notes))
             nextTask = standardsFixPrompt(standards)
+            next = { why: "the reviewer approved the test; one round for its coding-standard issues", fixing: standards.map(issueText) }
             continue
           }
           result.status = "passed"
@@ -526,8 +536,7 @@ export async function runCodeAgent(opts: {
           emit({ type: "code", kind: "test", ok: true, attempt, text: `${report.test_file} passed and was approved (attempt ${attempt}/${allowed})${standards.length ? `; ${standards.length} coding-standard ${standards.length === 1 ? "issue" : "issues"} left in the notes` : ""}` })
           break
         }
-        const n = verdict.review.issues.length
-        emit({ type: "code", kind: "test", ok: false, attempt, text: `review found ${n} ${n === 1 ? "issue" : "issues"}: ${verdict.review.summary} (attempt ${attempt}/${maxAttempts})` })
+        // The review event above says what was found; the rejection itself is its verdict.
         // A second rejection usually means the goal and the page disagree (a test case the page cannot satisfy), not a
         // fix the next attempt will find: stop and report the issues instead of spending the remaining attempts.
         if (++rejections >= MAX_REJECTIONS) {
@@ -537,6 +546,7 @@ export async function runCodeAgent(opts: {
         }
         attemptLog.push(attemptLine(attempt, "passed; the reviewer asked for changes", verdict.review.summary, report.notes))
         nextTask = reviewFixPrompt(verdict.review.summary, verdict.review.issues)
+        next = { why: "the reviewer asked for changes", fixing: verdict.review.issues.map(issueText) }
         continue
       }
       if (tidying) {
@@ -558,11 +568,13 @@ export async function runCodeAgent(opts: {
         emit({ type: "code", kind: "test", ok: false, attempt, text: `${report.test_file} failed the same way as the last attempt, ${why} (attempt ${attempt}/${maxAttempts})` })
         attemptLog.push(attemptLine(attempt, `failed, ${why}, the same way as before`, firstError(run.output), report.notes))
         nextTask = repeatedFailurePrompt(sameFailures + 1, report.command, run.exitCode, run.output, files) + mismatch + switchLiveOn()
+        next = { why: `the test failed the same way again (${why}); Scribe looks at the failing step first`, fixing: [firstError(run.output)].filter(Boolean) }
         continue
       }
       emit({ type: "code", kind: "test", ok: false, attempt, text: `${report.test_file} failed, ${why} (attempt ${attempt}/${maxAttempts})` })
       attemptLog.push(attemptLine(attempt, `failed, ${why}`, firstError(run.output), report.notes))
       nextTask = fixPrompt(attempt, report.command, run.exitCode, run.output, files) + mismatch
+      next = { why: `the test failed (${why})`, fixing: [firstError(run.output)].filter(Boolean) }
     }
     keepSession = result.status === "stopped" || runtimeFailed
     if (report.test_name) result.testName = report.test_name

package/src/detail.ts

@@ -27,7 +27,8 @@ export function shows(event: AgentEvent | CodeEvent, detail: Detail): boolean {
     case "memory":
       return false
     case "code":
-      if (event.kind === "info" || event.kind === "test") return true
+      // Milestones, and the exchange with the reviewer: why a test was rejected and what Scribe fixes.
+      if (event.kind === "info" || event.kind === "test" || event.kind === "review" || event.kind === "attempt" || event.kind === "answer") return true
       if (event.kind === "tool") return !event.ok || WRITES_FILE.test(event.text)
       return false
     default:

package/src/print.ts

@@ -1,3 +1,5 @@
+import { cardText } from "./card.ts"
+import { answerText, attemptCard, reviewCard } from "./code/exchange.ts"
 import { briefText, shows, stepIntent, type Detail } from "./detail.ts"
 import type { AgentEvent } from "./types.ts"
 
@@ -45,6 +47,13 @@ export function formatEvent(event: AgentEvent, color = true, detail: Detail = "b
           return paint(c.cyan, `  ${event.text}`)
         case "test":
           return event.ok ? paint(c.green, `✓ ${event.text}`) : paint(c.red, `✗ ${event.text}`)
+        // The reviewer's verdict and Scribe's retries, in full: why it was rejected, and what is being fixed.
+        case "review":
+          return paint(event.approved ? c.green : c.red, cardText(reviewCard(event)))
+        case "attempt":
+          return paint(c.magenta, cardText(attemptCard(event)))
+        case "answer":
+          return paint(c.cyan, `  ${answerText(event)}`)
         default:
           return null
       }

package/src/tui/App.tsx

@@ -30,10 +30,11 @@ import { initWorkspace } from "../init.ts"
 import { ShortcutsPanel } from "./shortcuts.tsx"
 import { ago, getStarted, projectLine, setupSentence, type Fact, type GetStarted, recentWork, startActions, type RecentItem, type StartAction } from "./landing.ts"
 import { TIPS, formatDuration, formatTokens, packageVersion, shortCwd, theme } from "./theme.ts"
-import { emptyProduced, Line, Produced, producedCard, settleCall, sinceRequest, TestsSetting, TranscriptLine, trimLines } from "./transcript.tsx"
+import { emptyProduced, Line, LineRoom, Produced, producedCard, settleCall, sinceRequest, TestsSetting, TranscriptLine, trimLines } from "./transcript.tsx"
 import { Dialog, dialogSpec } from "./dialogs.ts"
 import { activityFromLog, clip, modelLabel } from "./text.ts"
 import { featuresText } from "../capabilities/render.ts"
+import { answerText, attemptCard, reviewCard } from "../code/exchange.ts"
 import { Palette, paletteItems, searchPalette, SuggestList, type PaletteItem } from "./palette.tsx"
 import { commandSuggestions, complete, lookupWorkItem, recentRuns, referenceSuggestions, repoFiles, triggerAt, type Suggestion, type WorkItem } from "./suggest.ts"
 import { initialChoice, REFINE_CHOICES, RefinePanel, type RefineChoice, type RefineState } from "./refine-panel.tsx"
@@ -988,6 +989,17 @@ export function App({ options }: { options: TuiOptions }) {
           else if (ev.kind === "say") record("thought", ev.text, shown)
           else if (ev.kind === "tool") pushTool(ev.text, ev.ok, ev.id, shown)
           else if (ev.kind === "test") record(ev.ok ? "ok" : "err", ev.text, shown)
+          // The exchange with the reviewer: its verdict and Scribe's retries as cards in the conversation, each with a
+          // line in Activity, so it is clear why a test was rejected and what is being fixed.
+          else if (ev.kind === "review") {
+            const card = reviewCard(ev)
+            pushLine({ kind: "card", text: card.title, card })
+            record(ev.approved ? "ok" : "err", `Review, attempt ${ev.attempt}/${ev.max}: ${ev.approved ? "approved" : `changes needed (${ev.issues.length})`} · ${clip(ev.summary, 140)}`, false)
+          } else if (ev.kind === "attempt") {
+            const card = attemptCard(ev)
+            pushLine({ kind: "card", text: card.title, card })
+            record("code", `Attempt ${ev.attempt}/${ev.max}: ${ev.why}${ev.fixing.length ? ` · fixing ${ev.fixing.length}` : ""}`, false)
+          } else if (ev.kind === "answer") record("code", answerText(ev), true)
         }
         if (aborted()) return
         const who = codingRef.current ? "Coding agent" : "Agent"
@@ -995,6 +1007,8 @@ export function App({ options }: { options: TuiOptions }) {
         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…")
         else if (ev.kind === "say") setActivity(`${who} is working…`)
+        else if (ev.kind === "review") setActivity(ev.approved ? "The reviewer approved the test" : `Scribe is fixing ${ev.issues.length} review ${ev.issues.length === 1 ? "issue" : "issues"}…`)
+        else if (ev.kind === "attempt") setActivity(`Scribe, attempt ${ev.attempt} of ${ev.max}: ${clip(ev.why, 50)}…`)
         return
       }
       case "code-start": {
@@ -1626,7 +1640,7 @@ export function App({ options }: { options: TuiOptions }) {
     const startRows = loading ? 1 + 1 + 4 : offer.length ? 1 + 1 + offer.length : 0
     const recentRows = recent.length ? 1 + 1 + recent.length : 0
     const setupRows = loading || open.length ? 2 : 0
-    const fixed = 5 + 2 + 1 + 3 + 1 + 1 + 1 // logo, project line, gap, prompt border, buttons, footer, one row to spare
+    const fixed = 4 + 2 + 1 + 3 + 1 + 1 + 1 // logo and byline, project line, gap, prompt border, buttons, footer, one row to spare
     const room = height - fixed
     const want = Math.max(5, Math.min(promptLines, room - 1))
     // Refine or a question in the prompt's place takes the room the sections would: they are for starting, not deciding.
@@ -1661,7 +1675,7 @@ export function App({ options }: { options: TuiOptions }) {
           </box>
           <box style={{ height: 1, flexShrink: 0 }} />
           <box style={{ flexDirection: "column", width: promptWidth, flexShrink: 0 }}>
-            {renderControls(promptWidth, "Describe what you want to test…", [5, maxRows], height - 5 - 2 - 1 - 1 - 1)}
+            {renderControls(promptWidth, "Describe what you want to test…", [5, maxRows], height - 4 - 2 - 1 - 1 - 1)}
             {showStart ? (
               <box style={{ flexDirection: "column", marginTop: 1, height: startRows - 1, flexShrink: 0 }}>
                 {heading(offerTitle)}
@@ -1813,10 +1827,12 @@ export function App({ options }: { options: TuiOptions }) {
     )
   }
 
-  const transcript = (every: Line[], style: Record<string, unknown>) => {
+  /** `room`: the columns a line of the conversation has (less the scrollbar), so long links are drawn to fit. */
+  const transcript = (every: Line[], style: Record<string, unknown>, room: number) => {
     // Quiet lines (reads, searches, calls in progress) are the Activity panel's; the conversation stays readable.
     const all = every.filter((l) => !l.quiet)
     return (
+    <LineRoom.Provider value={Math.max(20, room - 1)}>
     <scrollbox ref={scrollRef} stickyScroll stickyStart="bottom" style={{ flexGrow: 1, ...style }} focused={false}>
       {all.map((line, i) => (
         <TranscriptLine key={line.id} line={line} prev={all[i - 1]} />
@@ -1832,6 +1848,7 @@ export function App({ options }: { options: TuiOptions }) {
         </box>
       ) : null}
     </scrollbox>
+    </LineRoom.Provider>
     )
   }
   // A long request gets room: the box grows with the text up to nearly half the screen, then scrolls.
@@ -1847,7 +1864,7 @@ export function App({ options }: { options: TuiOptions }) {
         <box style={{ flexDirection: "row", height: height - 1, flexShrink: 0, paddingTop: 1 }}>
           <box onMouseDown={() => navRef.current.focus !== "chat" && setNav((n) => ({ ...n, focus: "chat" }))} style={{ flexDirection: "column", width: leftWidth, height: height - 2, paddingLeft: 2, paddingRight: 1 }}>
             {infoPanels(leftWidth - 3)}
-            {transcript(chatLines, {})}
+            {transcript(chatLines, {}, leftWidth - 3)}
             <box style={{ flexDirection: "column", flexShrink: 0 }}>{controls(leftWidth - 3)}</box>
           </box>
           <box style={{ flexDirection: "column", width: width - leftWidth, height: height - 2, paddingLeft: 1, paddingRight: 2 }}>
@@ -1883,7 +1900,7 @@ export function App({ options }: { options: TuiOptions }) {
   }
   return (
     <box style={{ flexDirection: "column", flexGrow: 1 }}>
-      {transcript(lines, { paddingLeft: 2, paddingRight: 2, paddingTop: 1 })}
+      {transcript(lines, { paddingLeft: 2, paddingRight: 2, paddingTop: 1 }, width - 4)}
       <box style={{ flexDirection: "column", paddingLeft: 2, paddingRight: 2, flexShrink: 0 }}>{controls(promptWidth)}</box>
       <Footer left={shortCwd()} right={footerRight} width={width} />
       {paletteOverlay}

package/src/tui/components.tsx

@@ -18,14 +18,15 @@ export const BAR = {
 }
 
 export function Logo() {
-  const name = logoRows("forge")
+  // One wordmark in capitals, FORGE in the text colour and QE in the accent: one height, weight, and baseline.
+  const name = logoRows("FORGE")
   const suffix = logoRows("QE")
   return (
     <box style={{ flexDirection: "column", alignItems: "flex-end", flexShrink: 0 }}>
       {name.map((row, i) => (
         <text key={i}>
-          <span fg={theme.faint}>{row}</span>
-          <span fg={theme.text}>{` ${suffix[i]}`}</span>
+          <span fg={theme.text}>{row}</span>
+          <span fg={theme.accent}>{` ${suffix[i]}`}</span>
         </text>
       ))}
       <text fg={theme.muted}>by Capgemini</text>

package/src/tui/text.ts

@@ -31,3 +31,19 @@ export function activityFromLog(text: string): string {
   if (text.startsWith("ForgeQE engine ·")) return "Starting the browser…"
   return clip(text, 70)
 }
+
+/**
+ * A link's text shortened to `max` columns, so it never wraps into what reads as two links. The start and the last
+ * part (the file, or the folder of a path ending in "/") are kept: ".forgeqe/reports/open-defect-rep…/report.html".
+ * The link itself keeps its whole target; only what is drawn is shorter.
+ */
+export function shortLink(text: string, max: number): string {
+  if (text.length <= max || max < 8) return text
+  const trimmed = text.replace(/\/$/, "")
+  const slash = trimmed.lastIndexOf("/")
+  const tail = slash > 0 ? text.slice(slash) : ""
+  // The last part, whole, when it leaves room for a useful start; otherwise both ends of the text.
+  if (tail && tail.length <= max - 10) return `${text.slice(0, max - tail.length - 1)}…${tail}`
+  const end = Math.floor((max - 1) / 2)
+  return `${text.slice(0, max - 1 - end)}…${text.slice(text.length - end)}`
+}

package/src/tui/theme.ts

@@ -35,35 +35,34 @@ export function formatDuration(ms: number, precise = false): string {
   return `${m}m ${String(Math.floor(s % 60)).padStart(2, "0")}s`
 }
 
-/** Four rows: ascenders, then a three-row x-height. Capitals use all four. */
-const GLYPHS: Record<string, [string, string, string, string]> = {
-  w: ["     ", "█   █", "█ █ █", "▀▀▀▀▀"],
-  e: ["    ", "█▀▀█", "█▀▀▀", "▀▀▀▀"],
-  b: ["▄   ", "█▀▀█", "█  █", "▀▀▀▀"],
-  p: ["    ", "█▀▀█", "█  █", "█▀▀▀"],
-  i: [" ", "▀", "█", "▀"],
-  l: ["▄", "█", "█", "▀"],
-  o: ["    ", "█▀▀█", "█  █", "▀▀▀▀"],
-  t: [" ▄  ", "▀█▀▀", " █  ", " ▀▀▀"],
-  r: ["   ", "█▀▀", "█  ", "▀  "],
-  c: ["    ", "█▀▀▀", "█   ", "▀▀▀▀"],
-  h: ["▄   ", "█▀▀█", "█  █", "▀  ▀"],
-  s: ["    ", "█▀▀▀", "▀▀▀█", "▀▀▀▀"],
-  a: ["    ", "▀▀▀█", "█▀▀█", "▀▀▀▀"],
-  f: [" ▄▀", "▀█▀", " █ ", " ▀ "],
-  g: ["    ", "█▀▀█", "█  █", "▀▀▀█"],
-  Q: ["█▀▀█ ", "█  █ ", "█  █ ", "▀▀▀█▄"],
-  E: ["█▀▀▀", "█▄▄ ", "█   ", "▀▀▀▀"],
-  ".": [" ", " ", " ", "▀"],
+/**
+ * The wordmark's capitals as pixel maps, five pixels tall: every letter has the same weight, height and baseline. A
+ * sixth row, left blank, is the Q's tail. Two pixel rows go in one text row as half blocks, so it is three rows high.
+ */
+const LETTERS: Record<string, string[]> = {
+  F: ["####", "#...", "###.", "#...", "#..."],
+  O: ["####", "#..#", "#..#", "#..#", "####"],
+  R: ["####", "#..#", "###.", "#..#", "#..#"],
+  G: ["####", "#...", "#.##", "#..#", "####"],
+  E: ["####", "#...", "###.", "#...", "####"],
+  Q: ["####.", "#..#.", "#..#.", "#..#.", "####.", "...##"],
 }
 
+/** The letters of `word` (capitals; others are left out) as three rows of half blocks, one space between letters. */
 export function logoRows(word: string): string[] {
-  const rows = ["", "", "", ""]
-  const letters = [...word]
-  letters.forEach((ch, index) => {
-    const glyph = GLYPHS[ch] ?? GLYPHS[ch.toLowerCase()]
-    if (!glyph) return
-    for (let r = 0; r < 4; r++) rows[r] += (index ? " " : "") + glyph[r]
+  const rows = ["", "", ""]
+  ;[...word.toUpperCase()].filter((ch) => LETTERS[ch]).forEach((ch, index) => {
+    const px = LETTERS[ch]!
+    const at = (r: number, c: number) => px[r]?.[c] === "#"
+    for (let r = 0; r < 3; r++) {
+      let cells = ""
+      for (let c = 0; c < px[0]!.length; c++) {
+        const top = at(r * 2, c)
+        const bottom = at(r * 2 + 1, c)
+        cells += top && bottom ? "█" : top ? "▀" : bottom ? "▄" : " "
+      }
+      rows[r] += (index ? " " : "") + cells
+    }
   })
   return rows
 }

package/src/tui/transcript.tsx

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs"
 import os from "node:os"
 import path from "node:path"
 import { SyntaxStyle } from "@opentui/core"
-import type { ReactNode } from "react"
+import { createContext, useContext, type ReactNode } from "react"
 
 import type { CodeResult, RunStatus } from "../types.ts"
 import { CARD_MARK, type Card } from "../card.ts"
@@ -11,7 +11,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 { clip } from "./text.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. */
 
@@ -195,7 +195,7 @@ export function SummaryCard({ summary }: { summary: RunSummary }) {
         {summary.savedDir ? (
           <text>
             <span fg={theme.faint}>{"Saved     "}</span>
-            <Linked text={`${summary.savedDir}/  `} color={theme.muted} />
+            <Linked text={`${summary.savedDir}/  `} color={theme.muted} lead={UNDER + 10} />
             <span fg={theme.faint}>{summary.savedFiles.join(" · ")}</span>
           </text>
         ) : null}
@@ -218,14 +218,27 @@ export function linkTarget(token: string, cwd = process.cwd()): string | null {
  * Text whose web addresses and existing file paths can be opened from the terminal (OSC 8 links: cmd/ctrl+click in
  * VS Code and most terminals). A path that does not exist stays plain text, so no link leads nowhere.
  */
-export function Linked({ text, color }: { text: string; color: string }) {
-  const parts: { text: string; href?: string }[] = []
+/** The columns a line of the conversation has, for links to fit in; 0 when not known (no shortening). */
+export const LineRoom = createContext(0)
+
+/** Columns before a card's line of text: the "⎿" gutter under the card's title. */
+const UNDER = 4
+
+/**
+ * `lead`: the columns before this text on its row (a gutter, a label in another span). A link longer than what is left
+ * of the row is drawn shortened, its target whole, so it moves to the next row in one piece instead of splitting.
+ */
+export function Linked({ text, color, lead = UNDER }: { text: string; color: string; lead?: number }) {
+  const room = useContext(LineRoom)
+  const parts: { text: string; href?: string; max?: number }[] = []
   let at = 0
   for (const m of text.matchAll(LINKABLE)) {
     const href = linkTarget(m[0])
     if (!href) continue
     if (m.index! > at) parts.push({ text: text.slice(at, m.index) })
-    parts.push({ text: m[0], href })
+    // Beside its label when a useful part fits there ("Page      .forgeqe/…/report.html"), else alone on the next row.
+    const beside = room - lead - m.index! - 1
+    parts.push({ text: m[0], href, ...(room ? { max: beside >= 30 ? beside : room - lead - 1 } : {}) })
     at = m.index! + m[0].length
   }
   if (at < text.length) parts.push({ text: text.slice(at) })
@@ -234,7 +247,7 @@ export function Linked({ text, color }: { text: string; color: string }) {
       {parts.map((p, i) =>
         p.href ? (
           <a key={i} href={p.href} fg={theme.accent}>
-            {p.text}
+            {p.max ? shortLink(p.text, p.max) : p.text}
           </a>
         ) : (
           <span key={i} fg={color}>
@@ -251,7 +264,7 @@ export function Row({ label, value, color = theme.muted }: { label: string; valu
   return (
     <text>
       <span fg={theme.faint}>{label.padEnd(10)}</span>
-      <Linked text={value} color={color} />
+      <Linked text={value} color={color} lead={UNDER + 10} />
     </text>
   )
 }
@@ -307,7 +320,7 @@ export const CARD_COLOR: Record<Card["status"], string> = { ok: theme.ok, fail:
 
 export function ResultCard({ card }: { card: Card }) {
   const color = CARD_COLOR[card.status]
-  const lineColor = (l: string) => (/^\s*✓/.test(l) ? theme.ok : /^\s*[✗!]/.test(l) ? theme.err : /^\s*\?/.test(l) ? theme.warn : theme.muted)
+  const lineColor = (l: string) => (/^\s*✓/.test(l) ? theme.ok : /^\s*[✗!]/.test(l) ? theme.err : /^\s*[?~]/.test(l) ? theme.warn : /^\s*(Fix:|→)/.test(l) ? theme.text : theme.muted)
   // What a run used is in the footer and the reports; price talk stays out of the conversation.
   const body = card.body.filter((l) => !/^\s*Usage\s{2,}/.test(l)).filter((l, i, all) => l || (i > 0 && i < all.length - 1))
   return (

package/src/types.ts

@@ -136,6 +136,12 @@ export type CodeEvent =
   | { type: "code"; kind: "usage"; usage: Usage; context?: number }
   /** The agent's to-do list, each time it changes. */
   | { type: "code"; kind: "plan"; items: PlanItem[] }
+  /** The reviewer's verdict on a test that passed: approved or not, why, and each issue with its file and fix. */
+  | { type: "code"; kind: "review"; attempt: number; max: number; approved: boolean; summary: string; issues: CodeReview["issues"] }
+  /** Scribe starts another attempt: why, and what it was asked to fix (the reviewer's issues, the test's error). */
+  | { 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[] }
 
 export type AgentEvent =
   | { type: "log"; level: "info" | "warn" | "error"; text: string }