@capagents/forgeqe 1.1.8 → 1.2.0

package/src/code/notes.ts

@@ -73,3 +73,79 @@ export function notesSection(n: RepoNotes): string {
   lines.push("", "Start from these notes instead of reading the repository again: read only the files this test uses or changes, and read a file before you edit or reuse it, since it may have changed.")
   return lines.join("\n")
 }
+
+/**
+ * Words that say how a goal is phrased, not what flow it is: "verify each value is accepted and remains present" and
+ * "verify the values are accepted" ask for the same thing. Left out when two goals are compared.
+ */
+const FILLER = new Set(
+  "a an and the of in on to with within only each every any all then this that is are be as it its if for from by or not when also into page step steps result results report run test flow treat fail verify verifying check checks expected appears appear present remains accepted"
+    .split(" "),
+)
+
+/** A goal's content words, endings off ("toggles", "toggled" are one), for telling the same flow from another. */
+function goalWords(goal: string): Set<string> {
+  return new Set(
+    goal
+      .toLowerCase()
+      .replace(/https?:\/\/(www\.)?/g, "")
+      .split(/[^a-z0-9.@-]+/)
+      .map((w) => w.replace(/^[.-]+|[.-]+$/g, ""))
+      .filter((w) => w.length > 1 && !FILLER.has(w))
+      .map((w) => w.replace(/(ing|ed|es|s)$/, "")),
+  )
+}
+
+/** The website a goal names, if any: the same steps on another site are another flow. */
+function goalHost(goal: string): string {
+  return /https?:\/\/(?:www\.)?([^/\s,)]+)/i.exec(goal)?.[1]?.toLowerCase() || ""
+}
+
+/**
+ * How alike two goals are, 0 to 1: the content words they share, over the words they have (Dice). Measured on real
+ * goals ForgeQE's agent wrote: the same flow reworded scores 0.88; a shorter flow on the same page 0.59, and the same
+ * flow with a different final check 0.67.
+ */
+export function goalSimilarity(a: string, b: string): number {
+  const [ha, hb] = [goalHost(a), goalHost(b)]
+  if (ha && hb && ha !== hb) return 0
+  const x = goalWords(a)
+  const y = goalWords(b)
+  if (!x.size || !y.size) return 0
+  let shared = 0
+  for (const w of x) if (y.has(w)) shared++
+  return (2 * shared) / (x.size + y.size)
+}
+
+/** Goals this alike are the same flow asked again; ForgeQE's agent rewords a goal from one request to the next. */
+export const SAME_GOAL = 0.8
+
+/**
+ * Whether `goal` asks again for the flow an earlier test was written for. Rewording adds words and keeps the earlier
+ * ones; another flow drops what the earlier goal checked ("pie chart visible" becoming "list can be reordered"), so at
+ * most one of the earlier goal's content words may be missing, and the two must be alike overall.
+ */
+export function sameFlow(earlier: string, goal: string): boolean {
+  if (goalSimilarity(earlier, goal) < SAME_GOAL) return false
+  const now = goalWords(goal)
+  let dropped = 0
+  for (const w of goalWords(earlier)) if (!now.has(w)) dropped++
+  return dropped <= 1
+}
+
+/**
+ * The test an earlier job wrote in this repository for the same goal, when its file is still there: the newest of the
+ * closest matches. Notes of any age count here, since the test file itself is what is checked.
+ */
+export function findWrittenTest(memoryDir: string, repo: string, goal: string, exists: (file: string) => boolean): WrittenTest | null {
+  const tests = load(memoryDir).repos[repo]?.tests || []
+  let best: { test: WrittenTest; score: number } | null = null
+  for (const t of tests) {
+    const score = goalSimilarity(t.goal, goal)
+    if (sameFlow(t.goal, goal) && exists(t.test_file) && (!best || score > best.score || (score === best.score && t.at > best.test.at))) best = { test: t, score }
+  }
+  return best?.test || null
+}
+
+/** Where browser_run leaves the earlier test for a goal that failed, so write_test updates it instead of adding one. */
+export const EXISTING_TEST_FILE = "existing-test.json"

package/src/code/prompt.ts

@@ -74,6 +74,49 @@ export function preparePrompt(goal: string, checking = true): string {
 /** A test this case already has, which now fails: the job updates it instead of writing a new one. */
 export type ExistingTest = { testFile: string; command: string; output: string; why: string }
 
+/**
+ * An existing test the job works from, chosen from measured coverage (or by the person): `reuse` it as it is, or
+ * `extend` it with only the steps and checks it lacks.
+ */
+export type TestTarget = { mode: "reuse" | "extend" | "update"; testFile: string; test: string; line: number; covered: string[]; missing: string[]; why: string }
+
+function targetSection(t: TestTarget): string[] {
+  const list = (items: string[]) => items.map((i) => `- ${i}`)
+  if (t.mode === "update") {
+    return [
+      "## Update the existing test, do not write a new one",
+      "",
+      `The user asked to update ${t.test} (${t.testFile}:${t.line}) so it matches the verified run below. Change only what no longer matches the run (a step, a locator, an expected value); keep its other steps and assertions. Do not create a new test file.`,
+      "Do not change what an existing page-object member or method does for the other tests that use it (code_references shows them); add a member instead, or keep its behaviour for them, and say so in notes.",
+      "",
+    ]
+  }
+  if (t.mode === "reuse") {
+    return [
+      "## The existing test that already covers this flow",
+      "",
+      `ForgeQE's code graph found that ${t.test} (${t.testFile}:${t.line}) already reaches every element of this run (${t.why}). Do not write or change any test or page object.`,
+      "Find the command that runs only that test (from your notes on this repository, or the repository's test setup), and give the structured result with that test_file, test_name, and command. ForgeQE runs it. If it fails, ForgeQE stops and asks the user before anything is changed.",
+      "",
+    ]
+  }
+  return [
+    "## Extend the existing test, do not write a new one",
+    "",
+    `ForgeQE's code graph found that ${t.test} (${t.testFile}:${t.line}) already covers most of this flow (${t.why}). Extend that test: add only what it lacks, in the order of the flow, through the same page objects and helpers. Keep every step and assertion it has. Do not create a new test file.`,
+    "",
+    "It already covers:",
+    ...list(t.covered),
+    "",
+    "Add only these:",
+    ...list(t.missing),
+    "",
+    "When the missing steps start from a different place than the test does, add one test method next to it in the same class, reusing its setup and helpers, instead of a new file.",
+    "Add page-object members for elements the repository does not locate yet. Do not change what an existing member or method does: other tests use it (code_references shows which). When one must change, keep its behaviour for those tests and say so in notes.",
+    "",
+  ]
+}
+
 function existingSection(e: ExistingTest): string[] {
   return [
     "## The test this case already has",
@@ -91,7 +134,7 @@ function existingSection(e: ExistingTest): string[] {
   ]
 }
 
-export function firstPrompt(handoff: Handoff, opts: { liveBrowserDir?: string; liveOn?: boolean; notes?: string; profile?: string; existing?: ExistingTest } = {}): string {
+export function firstPrompt(handoff: Handoff, opts: { liveBrowserDir?: string; liveOn?: boolean; notes?: string; profile?: string; existing?: ExistingTest; target?: TestTarget } = {}): string {
   const live = opts.liveBrowserDir
     ? opts.liveOn
       ? `Your live_browser_* tools are on because the replay failed at a step; use them on that step's page. They save snapshots and screenshots in ${opts.liveBrowserDir}.`
@@ -100,9 +143,15 @@ export function firstPrompt(handoff: Handoff, opts: { liveBrowserDir?: string; l
   return [
     opts.existing
       ? `Update the existing test for the flow below so it passes again. When it is updated, give the structured result; ForgeQE then runs it.`
-      : `Write a test in this repository for the flow below, reusing the repository's existing test code. When it is written, give the structured result; ForgeQE then runs it.`,
+      : opts.target?.mode === "reuse"
+        ? `An existing test already covers the flow below. Report how to run it; change nothing. ForgeQE then runs it.`
+        : opts.target?.mode === "extend"
+          ? `Extend the existing test named below with what the flow below adds. When it is extended, give the structured result; ForgeQE then runs it.`
+          : opts.target?.mode === "update"
+            ? `Update the existing test named below to match the flow below. When it is updated, give the structured result; ForgeQE then runs it.`
+          : `Write a test in this repository for the flow below, reusing the repository's existing test code. When it is written, give the structured result; ForgeQE then runs it.`,
     "",
-    ...(opts.existing ? existingSection(opts.existing) : []),
+    ...(opts.existing ? existingSection(opts.existing) : opts.target ? targetSection(opts.target) : []),
     ...(opts.profile ? [opts.profile, ""] : []),
     ...(opts.notes ? [opts.notes, ""] : []),
     handoff.markdown,

package/src/code/review.ts

@@ -11,6 +11,7 @@ import { loadSkills } from "../skills/registry.ts"
 import type { Price } from "../usage.ts"
 import { prompt } from "../prompts.ts"
 import { domainNotes } from "../domain.ts"
+import type { TestTarget } from "./prompt.ts"
 
 const OUTPUT_CHARS = 4_000
 /** Changed files are shown in the prompt up to these sizes; the reviewer reads the rest itself. */
@@ -78,6 +79,8 @@ export type ReviewInput = {
   outlines?: string
   /** The repository's browser settings files and their values, as ForgeQE read them. */
   settings?: string[]
+  /** The existing test the job was asked to reuse or extend, from measured coverage or the user's choice. */
+  target?: TestTarget
 }
 
 const LIST_MAX = 60
@@ -125,6 +128,16 @@ export function reviewPrompt(input: ReviewInput, repo?: string): string {
     `The handoff it worked from: ${handoff.file}`,
     ...(checks ? ["", "The browser agent's checks, from the handoff:", checks] : []),
     "",
+    ...(input.target
+      ? [
+          "",
+          input.target.mode === "extend"
+            ? `The job was asked to extend the existing test ${input.target.test} (${input.target.testFile}) with only what it lacked: ${input.target.missing.join("; ")}. Adding those steps and checks to that test is the requested change, not a rewrite. A step or assertion of it removed or weakened, those steps duplicated in a new test file, or a shared page-object member changed in a way its other users would notice, is a correctness issue.`
+            : input.target.mode === "update"
+              ? `The user asked to update the existing test ${input.target.test} (${input.target.testFile}) to match this run. Changing its steps, locators, or expected values to match the run is the requested change. Removing an assertion the run still supports, or writing a new test file instead, is a correctness issue.`
+              : `The job was asked to reuse the existing test ${input.target.test} (${input.target.testFile}) as it is, since it already covers the flow. Any change to it, or a new test, is a correctness issue.`,
+        ]
+      : []),
     `Test file: ${report.test_file}`,
     `Command: ${report.command}`,
     input.changes

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/mcp/commands.ts

@@ -1,3 +1,7 @@
+import { coverageLines, EXTEND_FROM, measureCoverage, type Candidate } from "../code/coverage.ts"
+import { buildGraph } from "../code/graph/graph.ts"
+import { EXISTING_TEST_FILE } from "../code/notes.ts"
+import type { ExistingTest, TestTarget } from "../code/prompt.ts"
 import { existsSync, readFileSync } from "node:fs"
 import path from "node:path"
 
@@ -27,6 +31,62 @@ const clip = (s: string | undefined, n: number) => {
 }
 
 /** Marks a browser_run that was a task (a lookup in a tool), not a flow to automate; write_test refuses such runs. */
+
+/**
+ * Reuse, extend, or new, from what the repository's tests already cover of the run (code graph and page memory).
+ * The clear cases go ahead and say why; where the evidence fits more than one way, the user picks, seeing each
+ * option's effect. A mode the user gave (through ForgeQE's agent) is followed without asking.
+ */
+export async function chooseTarget(runDir: string, repo: string, args: Record<string, any>, ctx: ToolContext): Promise<{ target?: TestTarget } | { cancelled: true }> {
+  const asked = typeof args.mode === "string" && args.mode !== "auto" ? (args.mode as "new" | "extend" | "reuse" | "update") : null
+  if (asked === "new") return {}
+  const graph = await buildGraph(repo).catch(() => null)
+  if (!graph) return {}
+  const cov = measureCoverage(runDir, graph, ctx.config.memory.dir)
+  const named = args.test_file ? cov.candidates.find((c) => c.file === String(args.test_file).replace(/^\.\//, "")) : undefined
+  let decision = cov.decision
+  if (asked) decision = { mode: asked, ask: false, target: named || cov.candidates[0], why: "the user asked for it" }
+  const lines = coverageLines(cov)
+  const toTarget = (mode: TestTarget["mode"], c: Candidate): TestTarget => ({
+    mode,
+    testFile: c.file,
+    test: c.test,
+    line: c.line,
+    covered: c.covered.map((i) => cov.items[i]!.label),
+    missing: c.missing.map((i) => cov.items[i]!.label),
+    why: `it covers ${c.covered.length} of ${c.covered.length + c.missing.length} steps and checks this run located`,
+  })
+  const say = (title: string, why: string) =>
+    ctx.emit?.({ type: "card", card: { status: "info", title, stats: why, body: lines.length ? ["What the repository's tests already cover of this run:", ...lines] : [] } })
+  if (decision.ask && ctx.ask) {
+    const options = cov.candidates.filter((c) => c.share >= EXTEND_FROM).slice(0, 2).flatMap((c, n) => {
+      const name = `${path.basename(c.file)}`
+      return c.missing.length
+        ? [{ id: `extend:${n}`, label: `Extend ${name} (adds ${c.missing.length})` }]
+        : [{ id: `reuse:${n}`, label: `Reuse ${name} as it is` }]
+    })
+    const answer = await ctx.ask({
+      title: "Existing tests already cover this flow. Which way should Scribe go?",
+      detail: `${decision.why}. Extending keeps the test's steps and adds only what is missing; a new test duplicates what they cover.`,
+      lines,
+      options: [...options, { id: "new", label: "Write a new test" }, { id: "cancel", label: "Cancel" }],
+    })
+    if (!answer || answer === "cancel") return { cancelled: true }
+    if (answer === "new") return {}
+    const [mode, n] = answer.split(":") as ["reuse" | "extend", string]
+    const c = cov.candidates.filter((x) => x.share >= EXTEND_FROM)[Number(n)]!
+    say(mode === "reuse" ? `Reusing ${c.test}` : `Extending ${c.test}`, "the user chose it")
+    return { target: toTarget(mode, c) }
+  }
+  if (decision.mode === "new" || !decision.target) {
+    if (cov.candidates.length) say("Writing a new test", decision.why)
+    return {}
+  }
+  const mode: TestTarget["mode"] = decision.mode === "reuse" ? "reuse" : decision.mode === "update" ? "update" : "extend"
+  say(mode === "reuse" ? `Reusing ${decision.target.test}` : mode === "update" ? `Updating ${decision.target.test}` : `Extending ${decision.target.test}`, decision.why)
+  return { target: toTarget(mode, decision.target) }
+}
+
 export const TASK_FILE = "task.json"
 
 const inCwd = (ctx: ToolContext, p: unknown) => (p ? path.resolve(ctx.cwd, String(p)) : ctx.cwd)
@@ -96,6 +156,13 @@ export const COMMAND_TOOLS: McpTool[] = [
       properties: {
         run_dir: { type: "string", description: "Run folder from browser_run or run_test_cases (default: the latest run)" },
         repo: { type: "string", description: "Repository to write the test in, relative to the working directory (default: the working directory)" },
+        mode: {
+          type: "string",
+          enum: ["auto", "new", "extend", "reuse", "update"],
+          description:
+            "auto (default): ForgeQE measures which existing tests already cover the run, then reuses one that covers it all, extends one that covers most, or writes a new test, and asks the user when that is not clear. new, extend, reuse, update: only when the user said which (\"extend the login test\", \"write a separate test\", \"update it\" after a reused test failed).",
+        },
+        test_file: { type: "string", description: "With mode extend, reuse, or update: the existing test file (from the user, or from an earlier write_test result)" },
       },
     },
     async run(args, ctx) {
@@ -108,6 +175,12 @@ export const COMMAND_TOOLS: McpTool[] = [
       const t0 = Date.now()
       const repo = inCwd(ctx, args.repo)
       const goal = (readJson(path.join(runDir, "run.json")) as { goal?: string } | null)?.goal || ""
+      // browser_run found an earlier test for this flow and it failed: Scribe updates it rather than adding another.
+      const existingTest = readJson(path.join(runDir, EXISTING_TEST_FILE)) as ExistingTest | null
+      // Otherwise: what the repository's tests already cover of this run decides reuse, extend, or new.
+      const chosen = existingTest?.testFile ? { target: undefined } : await chooseTarget(runDir, repo, args, ctx)
+      if ("cancelled" in chosen) return { status: "cancelled", notes: "The user cancelled before Scribe started; nothing was changed." }
+      const target = chosen.target
       ctx.emit?.({ type: "code-start", runDir, repo, goal })
       let r
       try {
@@ -119,6 +192,8 @@ export const COMMAND_TOOLS: McpTool[] = [
           onEvent: (event) => ctx.emit?.({ type: "agent", event }),
           open: ctx.openSession as never,
           runTest: ctx.runTest,
+          ...(existingTest?.testFile ? { existingTest } : {}),
+          ...(target ? { target } : {}),
         })
       } catch (err) {
         ctx.emit?.({ type: "code-done", error: (err as Error).message, ms: Date.now() - t0 })
@@ -136,6 +211,7 @@ export const COMMAND_TOOLS: McpTool[] = [
         notes: r.notes || undefined,
         browsers: r.browsers,
         review: r.review,
+        ...(r.existing ? { existing: r.existing } : {}),
         output: r.status === "passed" ? undefined : clip(r.output, 4000),
       }
     },

package/src/mcp/tools.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs"
 import path from "node:path"
 
 import type { AgentEvent, CodeEvent, CodeResult, ReplayMode, RunResult } from "../types.ts"
@@ -16,6 +16,7 @@ import { buildHandoff } from "../code/handoff.ts"
 import { latestRunDir, runCodeAgent } from "../code/index.ts"
 import type { OpencodeSession } from "../code/runtime.ts"
 import { runTestCommand } from "../code/testrun.ts"
+import { EXISTING_TEST_FILE, findWrittenTest } from "../code/notes.ts"
 import { browserProvider, type AppConfig } from "../config.ts"
 import { clearMemory, memoryFilesFor, memoryFlows, memoryOverview, memoryShow } from "../memory.ts"
 import { executeRun, runDirectory } from "../run.ts"
@@ -329,6 +330,59 @@ function devicesFor(args: Record<string, unknown>, ctx: ToolContext): string[] {
   return [...new Set(devices)]
 }
 
+/**
+ * Runs the test an earlier job wrote for this goal, if there is one. `passed`: the tool's answer, the test having
+ * passed in a browser. `failed`: the test to update, for write_test. Null when there is no such test.
+ */
+async function existingTestFirst(goal: string, runDir: string, ctx: ToolContext): Promise<{ passed?: Record<string, unknown>; failed?: { testFile: string; command: string; output: string; why: string } } | null> {
+  const cfg = ctx.config
+  if (!cfg.memory.enabled) return null
+  let repo = ctx.cwd
+  try {
+    repo = realpathSync(ctx.cwd)
+  } catch {}
+  const known = findWrittenTest(cfg.memory.dir, repo, goal, (f) => existsSync(path.resolve(repo, f)))
+  if (!known) return null
+  const emit = ctx.emit || (() => {})
+  emit({ type: "info", text: `This flow already has a test, ${known.test_file} (written ${known.at.slice(0, 10)}): ForgeQE runs it first` })
+  mkdirSync(runDir, { recursive: true })
+  const run = await (ctx.runTest || runTestCommand)({
+    command: known.command,
+    cwd: repo,
+    timeoutSeconds: cfg.code.testTimeoutSeconds,
+    signal: ctx.signal,
+    hide: privateEnvNames(cfg),
+    save: path.join(runDir, "existing-test"),
+  })
+  if (ctx.signal?.aborted) return null
+  const secs = Math.round(run.ms / 1000)
+  if (run.ok && run.browsers.length) {
+    emit({
+      type: "card",
+      card: {
+        status: "ok",
+        title: "Existing test passed",
+        stats: `${secs}s · no browser run or new test needed`,
+        body: [`Test      ${known.test_file}`, `Command   ${known.command}`, `Browser   ${run.browsers.join(", ")}`, `Written   ${known.at.slice(0, 10)} for the same flow`],
+      },
+    })
+    return {
+      passed: {
+        status: "passed",
+        reused_test: known.test_file,
+        written_for: known.goal,
+        command: known.command,
+        browsers: run.browsers,
+        seconds: secs,
+        note: "An earlier job wrote a test for this flow (written_for) and it passed as it is, in a real browser: no browser run and no new test were needed. If the user's request asks for something written_for does not check, call browser_run again with fresh: true; otherwise say in one or two lines that the existing test passed.",
+      },
+    }
+  }
+  const why = run.ok ? "It exits 0 but opened no browser." : `It fails now (${run.exitCode === null ? "timed out" : `exit ${run.exitCode}`}): the application or the page changed since it was written.`
+  emit({ type: "info", text: `${known.test_file} ${run.ok ? "opened no browser" : "fails now"}: ForgeQE runs the flow in the browser, and Scribe updates that test instead of writing a new one` })
+  return { failed: { testFile: known.test_file, command: known.command, output: run.output, why } }
+}
+
 export const TOOLS: McpTool[] = [
   {
     name: "browser_run",
@@ -362,6 +416,11 @@ export const TOOLS: McpTool[] = [
           description:
             "test: a user flow of the app under test, to verify and turn into an automated test. task: anything else done in a browser, such as looking up or linking work items, checking a relationship, or reading data from a tool; no test is written for it.",
         },
+        fresh: {
+          type: "boolean",
+          description:
+            "true: run in the browser even when an earlier job wrote a test for this goal. Only when the user asks for a new browser run or a new test; by default an existing test is run first and reused when it passes.",
+        },
       },
       required: ["goal", "purpose"],
     },
@@ -378,6 +437,10 @@ export const TOOLS: McpTool[] = [
       if (devices.length > 1) return runGoalOnDevices(goal, url, devices, args, ctx)
       const runDir = runDirectory(ctx.config.export.outDir)
       const emit = ctx.emit || (() => {})
+      // The same flow asked again: an earlier job's test for it runs first. Passing in a browser, it answers the goal
+      // in seconds, with no browser run and no new test; failing, the run goes ahead and Scribe updates that test.
+      const reuse = ctx.writeTests && args.purpose !== "task" && !args.fresh && !resumeFrom && devices.length <= 1 ? await existingTestFirst(goal, runDir, ctx) : null
+      if (reuse?.passed) return reuse.passed
       const t0 = Date.now()
       emit({ type: "run-start", goal, url })
       try {
@@ -406,7 +469,11 @@ export const TOOLS: McpTool[] = [
           return summary
         }
         if (ctx.writeTests && result.status === "complete" && result.driver !== "synthetic") {
-          return { ...summary, next_step: `This session turns passed runs into tests: call write_test with run_dir ${runDir} now, before you reply.` }
+          if (reuse?.failed) writeFileSync(path.join(runDir, EXISTING_TEST_FILE), `${JSON.stringify(reuse.failed, null, 2)}\n`)
+          return {
+            ...summary,
+            next_step: `This session turns passed runs into tests: call write_test with run_dir ${runDir} now, before you reply.${reuse?.failed ? ` It updates the existing test ${reuse.failed.testFile} instead of writing a new one.` : ""}`,
+          }
         }
         return summary
       } catch (err) {

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)}`
+}