scanruler-mcp 0.4.0 → 0.4.5

package/src/mcp.js

@@ -24,7 +24,7 @@ import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises'
 import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path'
 import { Server } from '@modelcontextprotocol/sdk/server/index.js'
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js'
-import { absolute, agentJson, batchedPicture, fileKind, imageContent, inputFor, replacesSession, saveFileResult, toolFor, toolName, waitIn, withFiles } from './tools.js'
+import { absolute, agentJson, batchedPicture, fileKind, imageContent, inputFor, relativeFrom, replacesSession, saveFileResult, toolFor, toolName, waitIn, withFiles, writeNew } from './tools.js'
 import { jsonBytes, replyMeasure } from './trace.js'
 
 /** The app's own commands as of this release, so the tools are there before
@@ -117,6 +117,96 @@ function summary(command) {
   return /^.*?[.!?](?= |$)/.exec(description)?.[0] ?? description
 }
 
+/** The names a call would give new things, at the fields its command says
+ *  name them — `names: { space, at }` in the page's list, `at` paths into
+ *  the input ("feature.name", "features[].name", a `[]` stepping into each
+ *  item of a list) and `space` the things whose names may not repeat, in
+ *  words. Each `{ space, name }`; none for a command that says nothing. */
+export function namesGiven(command, args) {
+  const declared = command?.names
+  if (!declared || !Array.isArray(declared.at)) return []
+  const space = String(declared.space ?? 'names')
+  const found = []
+  const walk = (value, steps) => {
+    if (value === null || typeof value !== 'object') {
+      if (steps.length === 0 && typeof value === 'string' && value.trim()) found.push({ space, name: value })
+      return
+    }
+    if (steps.length === 0) return
+    const [step, ...rest] = steps
+    const list = step.endsWith('[]')
+    const next = value[list ? step.slice(0, -2) : step]
+    if (!list) walk(next, rest)
+    else if (Array.isArray(next)) for (const item of next) walk(item, rest)
+  }
+  for (const path of declared.at) walk(args ?? {}, String(path).split('.'))
+  return found
+}
+
+/** Why a batch's calls may not run together: two of them — or one twice —
+ *  giving new things the same name in one space, trimmed and in any case,
+ *  which the page refuses at the second, rolling back every change before
+ *  it. Null when none do. `commandOf` finds a call's command by its tool. */
+export function nameClash(calls, commandOf) {
+  const seen = new Map()
+  for (let i = 0; i < calls.length; i++) {
+    const tool = String(calls[i]?.tool ?? '')
+    for (const { space, name } of namesGiven(commandOf(tool), calls[i]?.arguments)) {
+      const key = `${space}\u0000${name.trim().toLowerCase()}`
+      const first = seen.get(key)
+      if (first) {
+        const which = first.index === i ? `calls[${i}] (${tool}) gives the name “${name.trim()}” twice` : `calls[${first.index}] (${first.tool}) and calls[${i}] (${tool}) both give the name “${name.trim()}”${first.name.trim() !== name.trim() ? ` (“${first.name.trim()}”)` : ''}`
+        return `${which} — names are unique across ${space}, so the page would refuse the second and the batch roll back what came before it. Nothing was run: give each its own name.`
+      }
+      seen.set(key, { index: i, tool, name })
+    }
+  }
+  return null
+}
+
+/** A batch's calls as the client sent them — `{ calls }`, or `{ error }`
+ *  when they cannot be read. Some clients send a large nested value as a
+ *  string of its JSON: the list of calls, a call, or a call's arguments
+ *  given so is read as that JSON. Anything else that is not a list is no
+ *  calls, as before. */
+export function callsGiven(given) {
+  const parse = (text) => {
+    if (!text.trim()) return { value: undefined }
+    try {
+      return { value: JSON.parse(text) }
+    } catch (e) {
+      return { error: e instanceof Error ? e.message : String(e) }
+    }
+  }
+  const SHAPE = '[{ "tool": "…", "arguments": { … } }]'
+  let list = given
+  if (typeof given === 'string') {
+    const read = parse(given)
+    if (read.error) return { error: `calls came as a string that is not JSON (${read.error}) — give calls as a list: ${SHAPE}.` }
+    list = Array.isArray(read.value?.calls) ? read.value.calls : read.value
+    if (!Array.isArray(list)) return { error: `calls came as a string whose JSON is not a list of calls — give calls as a list: ${SHAPE}.` }
+  }
+  if (!Array.isArray(list)) return { calls: [] }
+  const calls = []
+  for (let i = 0; i < list.length; i++) {
+    let c = list[i]
+    if (typeof c === 'string') {
+      const read = parse(c)
+      if (read.error || !read.value || typeof read.value !== 'object' || Array.isArray(read.value)) return { error: `calls[${i}] came as a string that is not a call's JSON${read.error ? ` (${read.error})` : ''} — each call is { "tool": "…", "arguments": { … } }. Nothing was run.` }
+      c = read.value
+    }
+    if (c && typeof c === 'object' && typeof c.arguments === 'string') {
+      const read = parse(c.arguments)
+      const tool = typeof c.tool === 'string' ? ` (${c.tool})` : ''
+      if (read.error) return { error: `calls[${i}].arguments${tool} came as a string that is not JSON (${read.error}) — give them as an object, {} for none. Nothing was run.` }
+      if (read.value !== undefined && (read.value === null || typeof read.value !== 'object' || Array.isArray(read.value))) return { error: `calls[${i}].arguments${tool} came as a string whose JSON is not an object — give them as an object, {} for none. Nothing was run.` }
+      c = { ...c, arguments: read.value ?? {} }
+    }
+    calls.push(c)
+  }
+  return { calls }
+}
+
 /** What the server says it is when it runs ScanRuler itself, headless. */
 const HEADLESS_ABOUT = [
   'These tools drive ScanRuler headless: the app runs inside this server, with no browser, no scan and no viewport — nobody watches it, and nothing is drawn. scanruler_status says so (backend: "headless").',
@@ -174,6 +264,27 @@ const LIST_WAIT_MS = 3_000
  *  says where, how large and what it holds. */
 export const ANSWER_CAP = 40_000
 
+/** Commands whose answer may run past ANSWER_CAP before it is written to a
+ *  file, and how far. A guide is read whole, before a task's first step,
+ *  and is worth its room: several asked for together are answered while
+ *  they fit some 80 k characters, the rest named to read next (the page's
+ *  guide.read), so a read does not reach this. 90 k stays under Claude Code's
+ *  default limit on a tool's answer, 25 000 tokens (MAX_MCP_OUTPUT_TOKENS)
+ *  — some 100 k characters at four a token, less for text with many
+ *  escapes and marks. */
+export const ANSWER_CAPS = { 'guide.read': 90_000 }
+
+/** What a spilled answer of a command says to ask for next time: less of
+ *  it, by the command's own fields — the command's own word (askForLess,
+ *  which a page sends with its commands) first, else this, for a page from
+ *  before it did. */
+const ASK_FOR_LESS = {
+  'guide.read': 'one section at a time (section, by its heading — a ### part of a long one too; guide_read with no topic lists them with what each costs)',
+}
+
+/** What a command's spilled answer says to ask for next time. */
+const lessOf = (command) => (typeof command?.askForLess === 'string' && command.askForLess ? command.askForLess : ASK_FOR_LESS[command?.name])
+
 /** How many jobs the status lists besides those running, the newest. */
 const JOBS_LISTED = 5
 
@@ -185,6 +296,18 @@ const FILES_LISTED = 300
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, Math.max(0, ms)))
 
+/** The notes an answer carries for the agent (`notes`), when it is an
+ *  object that has them. */
+const notesIn = (v) => (v !== null && typeof v === 'object' && !Array.isArray(v) && v.notes !== undefined && v.notes !== null ? v.notes : undefined)
+
+/** `d` as local time with its offset from UTC, to the second —
+ *  2026-10-23T18:04:05+02:00 — for an agent whose host gives it no clock. */
+export function localTime(d = new Date()) {
+  const pad = (n) => String(Math.trunc(Math.abs(n))).padStart(2, '0')
+  const off = -d.getTimezoneOffset()
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}${off < 0 ? '-' : '+'}${pad(off / 60)}:${pad(off % 60)}`
+}
+
 const text = (value, exact = false) => ({ content: [{ type: 'text', text: typeof value === 'string' ? value : agentJson(value, exact) }] })
 const failure = (e) => {
   const code = e?.code ?? 'failed'
@@ -214,7 +337,8 @@ const failure = (e) => {
  * }} options — `tools` is how the page's commands are listed (TOOL_MODES).
  *   `listWaitMs`: how long a listing waits for a page that connected before
  *   and is not back yet. `answerCap`: the most characters an answer
- *   carries; a longer one goes to a file in `outDir` (ANSWER_CAP).
+ *   carries; a longer one goes to a file in the folder the scan open now
+ *   came from, else in `outDir` (ANSWER_CAP).
  *   `trace`, when given, gets a line per call (trace.js).
  *   `answerWithinMs` is how long a job's call is held before it answers
  *   with the job, and the most scanruler_wait waits; 0 holds it to the end.
@@ -290,7 +414,7 @@ export function createMcpServer({
   // line, and one answered before it was done (queued) gets a line when it
   // is. `run` is handed the job's name, for the page.
   const startJob = (tool, run, ctx = null, queued = false) => {
-    const job = { job: `j${nextJob++}-${copyMark}`, tool, state: 'running', started: Date.now(), ms: null, reply: null, queued }
+    const job = { job: `j${nextJob++}-${copyMark}`, tool, state: 'running', started: Date.now(), ms: null, reply: null, queued, progress: null }
     if (ctx) Object.assign(ctx.fields, { job: job.job, ...(queued ? { queued: true } : {}) })
     const finished = (reply) => {
       job.state = reply.isError ? 'failed' : 'done'
@@ -312,7 +436,25 @@ export function createMcpServer({
     }
     return job
   }
-  const jobBrief = (j) => ({ job: j.job, tool: j.tool, state: j.state, ...(j.ms !== null ? { ms: j.ms } : { runningMs: Date.now() - j.started }) })
+  const jobBrief = (j) => ({
+    job: j.job,
+    tool: j.tool,
+    state: j.state,
+    ...(j.ms !== null ? { ms: j.ms } : { runningMs: Date.now() - j.started, ...(j.progress ? { progress: j.progress } : {}) }),
+  })
+  /** A job's last progress line from the page kept — what its status line
+   *  says, "Measuring deviation — 42%…" — as `{ phase, percent }`, percent
+   *  null when the line gives none; `call`, in a batch, the index of the
+   *  call it came from. The status and scanruler_wait answer it while the
+   *  job runs, whether or not the client asked for progress. */
+  const noteProgress = (job, line, call) => {
+    if (!job) return
+    const text = String(line ?? '').trim()
+    if (!text) return
+    const m = /(\d+(?:\.\d+)?)\s*%/.exec(text)
+    const phase = m ? text.replace(/\s*[—–-]?\s*\d+(?:\.\d+)?\s*%\s*/, ' ').replace(/\s+(?=[…:.,]|$)/g, '').trim() : text
+    job.progress = { phase: phase || text, percent: m ? Number(m[1]) : null, ...(call !== undefined ? { call } : {}) }
+  }
   /** A job's answer as scanruler_wait gives it: the tool's own answer
    *  under result, or its refusal under error. */
   const jobAnswer = (j) => {
@@ -356,9 +498,14 @@ export function createMcpServer({
   /** Whether the page is done with what it is busy with — polled until
    *  `until` (ms since the epoch). A page that does not say is taken as
    *  idle. */
+  /** What the page was busy with when pageIdle last looked — its busy
+   *  sentence (a build's step in play and how long it has run, say), and
+   *  the change running and for how long — or null. */
+  let pageBusy = null
   const pageIdle = async (until) => {
     for (;;) {
       const state = await link.run('session.state', {}).catch(() => null)
+      pageBusy = state && typeof state === 'object' ? { busy: state.busy ?? null, running: state.running ?? null, runningMs: state.runningMs ?? null } : null
       if (!state || typeof state !== 'object' || (state.busy == null && state.running == null)) return true
       if (Date.now() >= until) return false
       await sleep(Math.min(500, until - Date.now()))
@@ -423,20 +570,106 @@ export function createMcpServer({
   const startedAt = new Date().toISOString()
   const noJobs = `None asked of this server copy, which started at ${startedAt}. A change asked of an earlier copy is not known here: session_state says what the page holds.`
 
-  /** What the page's session holds, in brief, for the status: the scan,
-   *  the project's name, whether it has unsaved changes, and its work
-   *  counted — read off session.state, and left out when the page does not
-   *  answer soon. */
-  const sessionBrief = async () => {
-    if (!link.connected) return {}
+  /** The page's session.state, or null when there is no page or it does
+   *  not answer soon. */
+  const sessionRead = async () => {
+    if (!link.connected) return null
     let timer
     const state = await Promise.race([
       link.run('session.state', {}).catch(() => null),
       new Promise((r) => (timer = setTimeout(() => r(null), SESSION_WITHIN_MS))),
     ])
     clearTimeout(timer)
-    if (!state || typeof state !== 'object') return {}
+    return state && typeof state === 'object' ? state : null
+  }
+  /** Whether a session holds work: a scan, or anything counted. */
+  const holdsWork = (state) => Boolean(state?.scan) || Object.values(state?.project?.holds ?? {}).some((n) => typeof n === 'number' && n > 0)
+
+  // ---- the scan open now ----------------------------------------------------
+  // The folder the scan open in the page came from, when this server opened
+  // it — or the project holding it — from a file: the part's own folder,
+  // where an answer too long to carry and a batch's picture are written.
+  // Not the latest of the folders: a scan_open that saves the session it
+  // replaces (saveTo) puts the previous part's folder there, and a scan
+  // opened by hand puts nothing. Forgotten when a session is replaced
+  // without a file or the page reloads; and the page holding a scan of
+  // another name now (opened by hand) holds another part.
+  let openScan = null
+  /** What a session-replacing call leaves open: its file's folder and the
+   *  scan's name as the page answered it, or nothing known. */
+  const openedFrom = (file, result) => {
+    openScan = file ? { folder: dirname(file), scan: typeof result?.scan?.fileName === 'string' ? result.scan.fileName : null } : null
+  }
+  /** The folder of the scan open now, or null when it was not opened from
+   *  one here. A page that does not answer soon is taken to hold it still. */
+  const scanFolderNow = async () => {
+    if (!openScan) return null
+    const kept = openScan
+    const state = await sessionRead()
+    if (state && kept.scan !== null && (state.scan?.fileName ?? null) !== kept.scan) return null
+    return kept.folder
+  }
+
+  // ---- the page that came back ----------------------------------------------
+  // A page names itself — pageId, new each time it loads — and says when it
+  // loaded (since). Another name where the last page held work is a reload
+  // (Vite's after an edit, the person's, a tab the browser unloaded), and
+  // what that page held is gone: the next answer says so, with the project
+  // last opened or saved here, before a no_scan is read as a session never
+  // had. A page from before pageId is not told apart. `stale`: what the
+  // page said when it could not load a part of the app (stale_page).
+  let pageSeen = null
+  let reloaded = null
+  const seePage = (connected) => {
+    if (!link.page) return
+    const id = typeof link.page.pageId === 'string' && link.page.pageId ? link.page.pageId : null
+    if (pageSeen && (id === null ? !connected : pageSeen.id === id)) return
+    if (id !== null && pageSeen?.id && pageSeen.held) {
+      const r = { since: typeof link.page.since === 'string' ? link.page.since : null, empty: null }
+      reloaded = r
+      // Whether the new page holds anything, read once while it is new.
+      sessionRead().then((state) => {
+        if (state) r.empty = !holdsWork(state)
+      })
+    }
+    // Another page holds nothing this server opened.
+    if (pageSeen) openScan = null
+    pageSeen = { id, held: false, stale: null }
+  }
+  /** The note a reload is told by, once. */
+  const reloadNote = ({ since, empty }) => {
+    const at = since && Number.isFinite(Date.parse(since)) ? ` at ${localTime(new Date(since)).slice(11, 16)}` : ''
+    const now = empty === true ? ' and holds nothing now' : empty === false ? ' — a new page, holding work of its own' : ''
+    const project = knownProject()
+    return (
+      `The ScanRuler page reloaded${at}${now}: what the page held before is gone, unless it was saved. ` +
+      (project ? `The last project opened or saved here was ${project} (project_load opens it).` : 'No project was opened or saved through this server.')
+    )
+  }
+  /** A reply with the reload said in it, when one is to be said: in an
+   *  object answer as pageReloaded, first; after a refusal's message. */
+  const withReload = (reply) => {
+    if (!reloaded || !link.connected) return reply
+    const block = reply?.content?.find((x) => x.type === 'text')
+    if (!block) return reply
+    const note = reloadNote(reloaded)
+    reloaded = null
+    const body = block.text.trimStart()
+    const said = reply.isError || !body.startsWith('{') ? `${block.text} — ${note}` : `{"pageReloaded":${JSON.stringify(note)}${/^\{\s*\}$/.test(body) ? '}' : `,${body.slice(1)}`}`
+    // A copy: a job keeps its reply as it was, for scanruler_wait.
+    return { ...reply, content: reply.content.map((x) => (x === block ? { ...x, text: said } : x)) }
+  }
+
+  /** What the page's session holds, in brief, for the status: the scan,
+   *  the project's name, whether it has unsaved changes, and its work
+   *  counted — read off session.state, and left out when the page does not
+   *  answer soon. */
+  const sessionBrief = async () => {
+    const state = await sessionRead()
+    if (!state) return {}
     const project = state.project ?? {}
+    if (pageSeen && holdsWork(state)) pageSeen.held = true
+    if (pageSeen && typeof state.stale?.note === 'string') pageSeen.stale = state.stale.note
     return {
       session: {
         scan: state.scan?.fileName ?? null,
@@ -444,41 +677,72 @@ export function createMcpServer({
         unsaved: project.unsaved ?? null,
         ...(project.holds ?? {}),
       },
-      // The page's word that this server is older than its commands assume.
-      ...(typeof state.serverTooOld === 'string' ? { serverTooOld: state.serverTooOld } : {}),
+      // The page's word that the server it is connected to is older than its
+      // commands assume — while relaying, that is the holding copy.
+      ...(typeof state.serverTooOld === 'string' ? { serverTooOld: tooOldHere(state.serverTooOld) } : {}),
     }
   }
 
+  /** The page judges the copy it is connected to. A relaying copy is not
+   *  that one: say which is out of date, and that quitting its app is the
+   *  fix — updating this one changes nothing. */
+  const tooOldHere = (said) => {
+    const info = serverInfo()
+    if (info.role !== 'relay') return said
+    const holder = info.holder?.version ? `version ${info.holder.version}` : 'from before 0.4.1'
+    return (
+      `This server (${info.version}) is current; it sends its calls through another copy of scanruler-mcp, ${holder}, which holds the tab’s connection and is the one out of date. ` +
+      'Another AI app or chat started it — quit that app completely (Claude Desktop, Claude Code, Codex or another), and this copy takes the connection over within about ten seconds; or update that app’s setting as the page says: ' +
+      said
+    )
+  }
+
   // ---- answers that fit -----------------------------------------------------
   // An answer past answerCap — a read with every point in it, a batch of
   // many — would crowd out the agent's context: it is written whole to a
-  // file in outDir, and the answer says where, how large and what it holds.
-  /** `value` as an answer gives it: itself, or — its JSON past the cap —
-   *  `{ truncated, file, bytes, keys, brief }`, brief its short fields and
-   *  those named in `keep`. `tool` names the file. A file that cannot be
-   *  written leaves the answer whole. */
-  const fitted = async (value, tool, exact = false, keep = []) => {
+  // file, and the answer says where, how large and what it holds. The file
+  // goes into the folder the scan open now came from (scanFolderNow) — a
+  // sandboxed agent can open that one, not the server's outDir — else, or
+  // when that folder takes no file, into outDir.
+  /** The most characters a command's answer carries (ANSWER_CAPS), never
+   *  under answerCap. */
+  const capOf = (command) => Math.max(answerCap, ANSWER_CAPS[command?.name] ?? 0)
+  /** `value` as an answer gives it: itself, or — its JSON past `cap` —
+   *  `{ truncated, file, bytes, keys, brief }`, brief its short fields,
+   *  those named in `keep` and its notes. `tool` names the file, numbered
+   *  past one there (writeNew), so answers spilled at once never share it;
+   *  `less` says what to ask for next time. A file that cannot be written
+   *  leaves the answer whole. */
+  const fitted = async (value, tool, exact = false, keep = [], { cap = answerCap, less = 'fields, limit' } = {}) => {
     const body = agentJson(value, exact)
-    if (body.length <= answerCap) return value
+    if (body.length <= cap) return value
     const stamp = new Date().toISOString().replace(/[:.]/g, '-')
-    let file = join(outDir, `${tool}-${stamp}.json`)
+    const name = `${tool}-${stamp}.json`
+    const scanFolder = await scanFolderNow()
+    let file
+    let where
     try {
-      for (let n = 2; await stat(file).catch(() => null); n++) file = join(outDir, `${tool}-${stamp}-${n}.json`)
-      await mkdir(outDir, { recursive: true })
-      await writeFile(file, body, 'utf8')
+      file = scanFolder ? await writeNew(scanFolder, name, body).catch(() => null) : null
+      where = file ? `It is in ${scanFolder}, the folder the scan open now was opened from.` : `It is in ${outDir}, the server's output folder${scanFolder ? ` — ${scanFolder}, the scan's folder, took no file` : ': the scan open now was not opened from a folder through this server'}.`
+      file ??= await writeNew(outDir, name, body)
     } catch {
       return value
     }
     const object = value !== null && typeof value === 'object' && !Array.isArray(value)
-    const short = (k, v) => keep.includes(k) || v === null || typeof v === 'number' || typeof v === 'boolean' || (typeof v === 'string' && v.length <= 200)
+    const short = (k, v) => keep.includes(k) || k === 'notes' || v === null || typeof v === 'number' || typeof v === 'boolean' || (typeof v === 'string' && v.length <= 200)
     const brief = object ? Object.fromEntries(Object.entries(value).filter(([k, v]) => short(k, v))) : {}
+    // The notes the person left for the agent ride in every brief, where
+    // the answer gave them or one level down (a job's result, a
+    // workspace's part of the session): a note read late is a step done
+    // over.
+    if (object) for (const [k, v] of Object.entries(value)) if (!(k in brief) && notesIn(v) !== undefined) brief[k] = { notes: notesIn(v) }
     return {
       truncated: true,
       file,
       bytes: Buffer.byteLength(body, 'utf8'),
       ...(object ? { keys: Object.keys(value) } : Array.isArray(value) ? { items: value.length } : {}),
       ...(Object.keys(brief).length ? { brief } : {}),
-      note: `The answer is ${Math.round(body.length / 1000)} k characters, past the ${Math.round(answerCap / 1000)} k an answer carries, so it was written whole to file as JSON: read what you need from there, or ask for less next time (fields, limit).`,
+      note: `The answer is ${Math.round(body.length / 1000)} k characters, past the ${Math.round(cap / 1000)} k an answer carries, so it was written whole to file as JSON: read what you need from there, or ask for less next time (${less}). ${where}`,
     }
   }
 
@@ -506,6 +770,35 @@ export function createMcpServer({
       // Not kept: this copy still has it.
     }
   }
+  /** The folder every relative path is taken from — a batch's file, a
+   *  $file, a file read, a file written: the latest of those folders, as
+   *  scanruler_write and scanruler_files take it, else the folder this
+   *  server started in. A client may start the server anywhere (Claude
+   *  Desktop in its own install folder); the scan's folder is where the
+   *  agent's files are. */
+  const pathBase = () => knownFolders()[0] ?? cwd
+
+  // The project file last opened or saved here, kept with the folders: what
+  // a page that came back empty is pointed to.
+  let lastProject = null
+  const knownProject = () => {
+    try {
+      const kept = folderStore?.loadProject?.()
+      if (kept) lastProject = kept
+    } catch {
+      // Not read: this copy's own stands.
+    }
+    return lastProject
+  }
+  const rememberProject = (file) => {
+    if (extname(String(file)).toLowerCase() !== '.scanruler') return
+    lastProject = file
+    try {
+      folderStore?.saveProject?.(file)
+    } catch {
+      // Not kept: this copy still has it.
+    }
+  }
 
   /** The jobs as the status lists them, newest first: every one running
    *  and the newest JOBS_LISTED others; jobsMore counts the rest kept. */
@@ -529,13 +822,16 @@ export function createMcpServer({
           viewport: link.page.viewport ?? null,
           hidden: link.page.hidden ?? null,
           commands: link.page.commands.length,
+          ...(typeof link.page.since === 'string' ? { since: link.page.since } : {}),
+          ...(pageSeen?.stale ? { stale: true, staleNote: pageSeen.stale } : {}),
         }
       : null,
-    server: { ...serverInfo(), answerWithin: holdS },
+    server: { ...serverInfo(), now: localTime(), cwd, relativeTo: pathBase(), answerWithin: holdS },
     ...(link.connected || headless ? {} : { howToConnect: connectHelp() }),
     ...(link.page?.hidden ? { hiddenNote: 'The ScanRuler tab is hidden — in the background, its window covered or minimised, or the screen locked. Changes still run; pictures and anything that waits on the screen are slower, and a browser that unloads background tabs (Chrome’s Memory Saver) may close it: add the site to "Always keep these sites active".' } : {}),
     ...(jobs.size > 0 ? jobsListed() : { jobsNote: noJobs }),
     ...(!headless && knownFolders().length ? { folders: knownFolders() } : {}),
+    ...(!headless && knownProject() ? { lastProject: knownProject() } : {}),
     ...staleTools(),
   })
 
@@ -543,10 +839,14 @@ export function createMcpServer({
     {
       name: 'scanruler_status',
       title: 'ScanRuler connection status',
-      description: 'Whether a ScanRuler page is connected to this agent, which version and plugins it has, whether its tab is hidden (page.hidden), and — when none is — how the user connects one. session, with a page, says what it holds: the scan, the project’s name, whether it has changes not saved (unsaved), and its work counted — elements, features, notes … — so a session someone else left is seen before it is replaced (scan_open with saveTo keeps it). backend says whether ScanRuler runs in a tab (page) or in this server (headless). jobs lists the calls that change the session still running and the latest five others, newest first, each running, done or failed — a call whose answer you did not get is among them; scanruler_wait { for: "job", job } gives its answer, also for a job of an earlier copy of this server, which the page remembers; jobsMore counts the older ones kept. folders: where a scan or a project was opened from or saved into, the latest first — what scanruler_write writes into and scanruler_files lists; kept when the server restarts. server.answerWithin: the seconds a call is held at most before it answers with its job. server.version is this server’s, server.latest the newest on npm when known, server.handedOffFrom the older copy that started this one in its place. serverTooOld, when there, says this server is older than the page needs: tell the person once, in its words, and install nothing yourself. tools, when there, says the tools you were given are not the ones the page offers now (stale): which were added, removed or changed — named the first time, counted after — and which page they were listed from.',
+      description: 'Whether a ScanRuler page is connected to this agent, which version and plugins it has, whether its tab is hidden (page.hidden), and — when none is — how the user connects one. session, with a page, says what it holds: the scan, the project’s name, whether it has changes not saved (unsaved), and its work counted — elements, features, notes … — so a session someone else left is seen before it is replaced (scan_open with saveTo keeps it). page.since: when the page loaded. page.stale, when there: the page could not load a part of the app (an answer said stale_page) — it is older than the app it came from, rebuilt since: save the project, then ask the person to reload, as page.staleNote says. lastProject: the project file last opened or saved through this server — what to open again when the page reloaded (an answer then says pageReloaded). backend says whether ScanRuler runs in a tab (page) or in this server (headless). jobs lists the calls that change the session still running and the latest five others, newest first, each running, done or failed, a running one with progress: { phase, percent } when the page has said how far it is — a call whose answer you did not get is among them; scanruler_wait { for: "job", job } gives its answer, also for a job of an earlier copy of this server, which the page remembers; jobsMore counts the older ones kept. folders: where a scan or a project was opened from or saved into, the latest first — what scanruler_write writes into and scanruler_files lists; kept when the server restarts. server.answerWithin: the seconds a call is held at most before it answers with its job. server.now: the time on this computer, local, with its offset from UTC (2026-10-23T18:04:05+02:00) — the clock to date a report or time a step by. server.cwd: the folder this server started in; server.relativeTo: the folder every relative path is taken from — the latest of folders, else cwd; server.outDir: where a file goes that no path was given for — but an answer too long to carry (truncated: true, file), and a picture in a batch, go into the folder the scan open now was opened from, when it was opened here by a path. server.version is this server’s, server.latest the newest on npm when known, server.handedOffFrom the older copy that started this one in its place. server.role: holder — this copy holds the port and the tab’s connection; relay — another copy (another chat or AI app) holds them and this one sends its calls through it, the work still running in the tab, server.holder.version saying which (null: from before 0.4.1); none — neither yet, server.error saying why. serverTooOld, when there, says the server the page is connected to is older than the page needs — while relaying, the holding copy, not this one: tell the person once, in its words, and install nothing yourself. tools, when there, says the tools you were given are not the ones the page offers now (stale): which were added, removed or changed — named the first time, counted after — and which page they were listed from.',
       inputSchema: { type: 'object', properties: {}, additionalProperties: false },
       annotations: { readOnlyHint: true, openWorldHint: false },
-      call: async () => text({ ...status(), ...(await sessionBrief()) }),
+      call: async () => {
+        // The session read first: it may find the page stale.
+        const brief = await sessionBrief()
+        return text({ ...status(), ...brief })
+      },
     },
     {
       name: 'scanruler_open',
@@ -567,7 +867,7 @@ export function createMcpServer({
     {
       name: 'scanruler_wait',
       title: 'Wait for ScanRuler',
-      description: `Wait until a ScanRuler page is connected (for: "page", the default), or until it is also done with what it is busy with and every change still running has finished (for: "idle" — then finished lists the changes done or failed since the last such answer, a failed one with its error, and state says idle or running), or until a job is done (for: "job" with job — a call started with wait: false, one answered queued, or one whose answer did not come; scanruler_status lists them). Returns the status — for idle only connected, state and finished — or for a job its answer: { job, tool, state, ms, result } or { …, error: { code, message } } — state running if the time ran out first: call it again. A job of an earlier copy of this server is read from the page's record of it (session.recent), from says so.${holdS ? ` It waits ${holdS} s at most, this server's answer limit, whatever timeoutSeconds says.` : ''} connected is false if the time ran out waiting for a page.`,
+      description: `Wait until a ScanRuler page is connected (for: "page", the default), or until it is also done with what it is busy with and every change still running has finished (for: "idle" — then finished lists the changes done or failed since the last such answer, a failed one with its error, and state says idle or running; running, with busy — what the page is at, in its words: a model's build names the step in play and how long it has run — and running, the change still running, with runningS), or until a job is done (for: "job" with job — a call started with wait: false, one answered queued, or one whose answer did not come; scanruler_status lists them). Returns the status — for idle only connected, state and finished, and busy and running while running — or for a job its answer: { job, tool, state, ms, result } or { …, error: { code, message } } — state running if the time ran out first, with runningMs and, once the page has said how far it is, progress: { phase, percent } (its status line: "Measuring deviation", 42): call it again. A job of an earlier copy of this server is read from the page's record of it (session.recent), from says so.${holdS ? ` It waits ${holdS} s at most, this server's answer limit, whatever timeoutSeconds says.` : ''} connected is false if the time ran out waiting for a page.`,
       inputSchema: {
         type: 'object',
         properties: {
@@ -612,7 +912,10 @@ export function createMcpServer({
           for (const j of finished) j.told = true
           // The state and what finished, not the whole status: an agent
           // waits for idle many times in a run.
-          return text({ connected: link.connected, state: idle ? 'idle' : 'running', finished: finished.map(finishedOut), ...(hiddenNow() ? { hidden: true } : {}), ...staleTools() })
+          // Not idle: what the page is at, as it says it — a build's step
+          // in play and how long it has run.
+          const at = idle || !pageBusy ? {} : { ...(pageBusy.busy ? { busy: pageBusy.busy } : {}), ...(pageBusy.running ? { running: pageBusy.running, ...(pageBusy.runningMs != null ? { runningS: Math.round(pageBusy.runningMs / 1000) } : {}) } : {}) }
+          return text({ connected: link.connected, state: idle ? 'idle' : 'running', ...at, finished: finished.map(finishedOut), ...(hiddenNow() ? { hidden: true } : {}), ...staleTools() })
         }
         return text(status())
       },
@@ -738,7 +1041,7 @@ export function createMcpServer({
   // a picture — a batch gives a picture as its text and a file, so those are called
   // directly; scanruler_tools reads commands() when it is called.
   const shown = (c) => !compact || Boolean(c.returnsImage)
-  const listNow = () => [...own.map(definition), ...commands().filter(shown).map((c) => toolFor(c, { outDir }))]
+  const listNow = () => [...own.map(definition), ...commands().filter(shown).map((c) => toolFor(c, { outDir, cwd }))]
   const listSource = () =>
     link.page?.commands?.length ? `the page, ScanRuler ${link.page.version ?? 'of no version'}` : lastPage ? lastPage.from : `this server’s own list (scanruler-mcp ${version})`
 
@@ -802,14 +1105,18 @@ export function createMcpServer({
   }
   for (const event of ['connected', 'commands']) {
     link.on(event, () => {
+      seePage(event === 'connected')
       remember()
       relist()
     })
   }
+  seePage(true)
 
   /** One of the page's tools run on the page: the result as MCP content,
    *  or a failure. `batched`: a picture is written to a file — the call's
-   *  path or a new one in outDir — and given as its text, not shown. `job`:
+   *  path, or a new one in the scan's folder (scanFolderNow), else in
+   *  outDir — and
+   *  given as its text, not shown. `job`:
    *  the job the call is part of, which the page keeps its outcome under.
    *  `deferred`: more changes follow straight after it (a batch with
    *  build: "end"), and the page may leave their rebuild to the last.
@@ -823,18 +1130,28 @@ export function createMcpServer({
       return failure({ code: 'unavailable', message: `No ScanRuler page is connected; scanruler_open opens one. ${connectHelp()}` })
     }
     try {
-      const args = await withFiles(given ?? {}, cwd)
-      const { input, binaryKey, file } = await inputFor(command, args, { cwd })
+      // Every relative path in the call from one folder, taken before a
+      // scan opened by it moves it.
+      const base = pathBase()
+      const args = await withFiles(given ?? {}, base)
+      const { input, binaryKey, file } = await inputFor(command, args, { cwd: base })
       // A session kept before it is replaced: saved, then let go.
-      const savedTo = replacesSession(command) && args?.saveTo !== undefined ? await saveSession(String(args.saveTo), job) : undefined
+      const savedTo = replacesSession(command) && args?.saveTo !== undefined ? await saveSession(String(args.saveTo), job, base) : undefined
       if (savedTo !== undefined) input.discard = true
       const started = Date.now()
       let result = await link.run(command.name, input, binaryKey, onProgress, job, deferred)
       // The folder a scan or a project was opened from, for scanruler_write.
-      if (binaryKey && replacesSession(command) && file) rememberFolder(file)
+      if (binaryKey && replacesSession(command) && file) {
+        rememberFolder(file)
+        rememberProject(file)
+      }
+      // And the scan open now: this one's, or — replaced without a file —
+      // none known.
+      if (replacesSession(command)) openedFrom(binaryKey ? file : null, result)
+      if (!command.readOnly && pageSeen) pageSeen.held = true
       if (savedTo !== undefined && result && typeof result === 'object' && !Array.isArray(result)) result = { ...result, savedTo }
       if (ms && result && typeof result === 'object' && !Array.isArray(result)) result = { ...result, ms: Date.now() - started }
-      const image = command.returnsImage && !batched ? await imageContent(result, args, { cwd, outDir }) : null
+      const image = command.returnsImage && !batched ? await imageContent(result, args, { cwd: base, outDir }) : null
       if (image) return { content: image }
       // Which steps a change's build played, and how long each took, only
       // for a batch asked for its timings.
@@ -842,9 +1159,13 @@ export function createMcpServer({
         const { played: _played, ...steps } = result.steps
         result = { ...result, steps }
       }
-      const saved = command.returnsImage && batched ? await batchedPicture(result, args, { cwd, outDir }) : await saveFileResult(result, args, { cwd, outDir })
-      return text(await fitted(saved, name, Boolean(command.exact)), Boolean(command.exact))
+      const saved = command.returnsImage && batched ? await batchedPicture(result, args, { cwd: base, outDir, folder: args?.path ? null : await scanFolderNow() }) : await saveFileResult(result, args, { cwd: base, outDir })
+      // A project saved to a file: the one a reloaded page is pointed to.
+      if (saved?.file?.path) rememberProject(saved.file.path)
+      return text(await fitted(saved, name, Boolean(command.exact), [], { cap: capOf(command), ...(lessOf(command) ? { less: lessOf(command) } : {}) }), Boolean(command.exact))
     } catch (e) {
+      // A page older than its app, said once so: the status keeps it.
+      if (e?.code === 'stale_page' && pageSeen) pageSeen.stale ??= typeof e.message === 'string' ? e.message : 'stale_page'
       return failure(e)
     }
   }
@@ -852,7 +1173,7 @@ export function createMcpServer({
   /** The session saved as a project file at `path` (a file, or a folder
    *  for its own name): where it went, or null when the session held
    *  nothing to save. Throws, saving nothing, when the save fails. */
-  const saveSession = async (path, job) => {
+  const saveSession = async (path, job, base = pathBase()) => {
     let result
     try {
       result = await link.run('project.save', {}, undefined, undefined, job)
@@ -860,22 +1181,24 @@ export function createMcpServer({
       if (/nothing to save/i.test(e?.message ?? '')) return null
       throw { code: e?.code ?? 'failed', message: `Nothing was replaced: the session could not be saved first — ${e?.message ?? String(e)}` }
     }
-    const written = await saveFileResult(result, { path }, { cwd, outDir })
+    const written = await saveFileResult(result, { path }, { cwd: base, outDir })
     if (!written?.file?.path) throw { code: 'failed', message: 'Nothing was replaced: project.save gave no file to save.' }
     rememberFolder(written.file.path)
+    rememberProject(written.file.path)
     return written.file.path
   }
 
   // Several of the page's tools in one call — what cuts a run of twenty
   // scan_nearest calls to one round trip. Each answer is the tool's own; a
   // picture comes back as the text beside it, not as an image, and is
-  // written to a file — the call's path, or a new one in outDir — which the
+  // written to a file — the call's path, or a new one in the folder the
+  // scan open now came from (scanFolderNow), else in outDir — which the
   // text names.
   own.push({
     name: 'scanruler_batch',
     title: 'Run several ScanRuler tools',
     description:
-      `Run several of the ScanRuler tools in one call, in order, each with its own arguments — a run of scan_nearest, element_fit or section_get calls, say. Returns results, one per call in order: { tool, ok, result } or { tool, ok: false, error: { code, message } }. The first refused stops the rest (stopped says which index, failed: { index, tool, error } which call) unless stopOnError is false. When the refused call is a change, then with rollback (the default) every change the batch made before it is undone, so the batch stands or falls whole: undone names the steps taken back, newest first. A refused read — section_get, scan_query, any tool that changes nothing — undoes nothing: what came before it stands (kept says so). A call refused busy is run again once the page is idle (retried: "busy" on its result). Each call that changes the session is still its own undo step. build: "end" builds a modelled part once for a run of changes to it — sketches edited one after another, say — rather than after each: every call but the last is sent deferred, and a change so sent answers before its rebuild (build: "held", its result and bodies the part as last built; a pick by index names a face of that part); the last call builds them all, and so does a read of the part, or any other kind of tool, met on the way. timings: true gives each call its ms and the batch total_ms, and a change\'s build the steps it played with their ms (result.steps.played). wait: false answers at once with { queued, job }, and so does a batch still running at the server’s answer limit (with after, its seconds); scanruler_wait { for: "job", job } gives the batch\'s answer. A { "$file": path } anywhere in a call’s arguments is that JSON file’s contents. A tool that returns a picture is not shown here: the picture is written to a file — its call’s path, or a new file in ${outDir} — and its result gives that file.path; call the tool directly to see the picture. The server’s own tools (scanruler_status, _open, _wait, _batch, _write, _files, _tools) cannot be batched.`,
+      `Run several of the ScanRuler tools in one call, in order, each with its own arguments — a run of scan_nearest, element_fit or section_get calls, say. Returns results, one per call in order: { tool, ok, result } or { tool, ok: false, error: { code, message } }. The first refused stops the rest (stopped says which index, failed: { index, tool, error } which call) unless stopOnError is false. notes, when a call answered with the notes left for you, is the last call’s, repeated at the top. When the refused call is a change, then with rollback (the default) every change the batch made before it is undone, so the batch stands or falls whole: undone names the steps taken back, newest first, callsUndone counts the calls, and each of those answers ok: false and undone: true, its result kept as it was. Before anything runs, the names the calls would give new things (a command that says which of its fields name them, in one name space) are checked against each other: two alike — case and spaces at the ends aside — refuse the batch with nothing run, naming both calls; a name the session already has is the page’s to refuse. A refused read — section_get, scan_query, any tool that changes nothing — undoes nothing: what came before it stands (kept says so). A call refused busy is run again once the page is idle (retried: "busy" on its result). Each call that changes the session is still its own undo step. build: "end" builds a modelled part once for a run of changes to it — sketches edited one after another, say — rather than after each: every call but the last is sent deferred, and a change so sent answers before its rebuild (build: "held", its result and bodies the part as last built; a pick by index names a face of that part); the last call builds them all, and so does a read of the part, or any other kind of tool, met on the way. timings: true gives each call its ms and the batch total_ms, and a change\'s build the steps it played with their ms (result.steps.played). wait: false answers at once with { queued, job }, and so does a batch still running at the server’s answer limit (with after, its seconds); scanruler_wait { for: "job", job } gives the batch\'s answer. A { "$file": path } anywhere in a call’s arguments is that JSON file’s contents. ${relativeFrom(cwd)} A tool that returns a picture is not shown here: the picture is written to a file — its call’s path, or a new file in the folder the scan open now was opened from (by scan_open or project_load with a path), else in ${outDir} — and its result gives that file.path; call the tool directly to see the picture. The server’s own tools (scanruler_status, _open, _wait, _batch, _write, _files, _tools) cannot be batched.`,
     inputSchema: {
       type: 'object',
       properties: {
@@ -894,7 +1217,7 @@ export function createMcpServer({
             additionalProperties: false,
           },
         },
-        file: { type: 'string', minLength: 1, description: `A JSON file of the calls, read here in place of calls: [{ tool, arguments }], or [{ name, input }] by the command's own name (scan.open), or either under "calls" or "steps". For a long run a script wrote, which then need not pass through the conversation. A relative path is taken from ${cwd}.` },
+        file: { type: 'string', minLength: 1, description: `A JSON file of the calls, read here in place of calls: [{ tool, arguments }], or [{ name, input }] by the command's own name (scan.open), or either under "calls" or "steps". For a long run a script wrote, which then need not pass through the conversation. ${relativeFrom(cwd)}` },
         stopOnError: { type: 'boolean', description: 'Stop at the first refused call (the default), or run every call and report each.' },
         rollback: { type: 'boolean', description: 'When the batch stops at a refused change, undo what it changed before it (the default) — or leave those changes standing (false). A refused read undoes nothing either way.' },
         build: { type: 'string', enum: ['each', 'end'], description: 'each (the default): a change rebuilds the part before it answers. end: the changes build once, at the last call.' },
@@ -905,7 +1228,9 @@ export function createMcpServer({
     },
     annotations: { readOnlyHint: false, openWorldHint: false },
     call: async (args, ctx) => {
-      let calls = Array.isArray(args?.calls) ? args.calls : []
+      const given = callsGiven(args?.calls)
+      if (given.error) return failure({ code: 'invalid_input', message: given.error })
+      let calls = given.calls
       if (args?.file !== undefined) {
         if (calls.length > 0) return failure({ code: 'invalid_input', message: 'Give calls or file, not both.' })
         const read = await callsFromFile(String(args.file))
@@ -914,6 +1239,10 @@ export function createMcpServer({
       }
       if (calls.length === 0) return failure({ code: 'invalid_input', message: 'calls: give at least one call (or a file of them).' })
       if (ctx) ctx.fields.calls = calls.length
+      // Two calls naming new things alike would roll the batch back at the
+      // second, over every good change before it: refused before any runs.
+      const clash = nameClash(calls, (tool) => commands().find((c) => toolName(c) === tool))
+      if (clash) return failure({ code: 'invalid_input', message: clash })
       const job = startJob('scanruler_batch', (id) => runBatch(calls, args, ctx, id), ctx, args?.wait === false)
       return args?.wait === false ? queuedReply(job) : answerFor(job, ctx)
     },
@@ -923,7 +1252,7 @@ export function createMcpServer({
    *  batch takes them, or { name, input } by the command's own name, a
    *  list or one under "calls" or "steps". */
   const callsFromFile = async (file) => {
-    const path = absolute(file, cwd)
+    const path = absolute(file, pathBase())
     let data
     try {
       data = JSON.parse(await readFile(path, 'utf8'))
@@ -932,7 +1261,9 @@ export function createMcpServer({
     }
     const list = Array.isArray(data) ? data : Array.isArray(data?.calls) ? data.calls : Array.isArray(data?.steps) ? data.steps : null
     if (!list) return { error: `file: ${path} holds no list of calls — a list, or one under "calls" or "steps".` }
-    const calls = list.map((c) => (c && typeof c === 'object' && typeof c.name === 'string' && c.tool === undefined ? { tool: toolName({ name: c.name }), arguments: c.input ?? {} } : c))
+    const given = callsGiven(list.map((c) => (c && typeof c === 'object' && typeof c.name === 'string' && c.tool === undefined ? { tool: toolName({ name: c.name }), arguments: c.input ?? {} } : c)))
+    if (given.error) return { error: `file: ${path}: ${given.error}` }
+    const { calls } = given
     if (calls.some((c) => !c || typeof c !== 'object' || typeof c.tool !== 'string')) return { error: `file: every call in ${path} needs a tool (or a name).` }
     return { calls }
   }
@@ -977,7 +1308,7 @@ export function createMcpServer({
       const hiddenAt = hiddenNow()
       const deferred = atEnd && i < calls.length - 1
       lastDeferred = deferred
-      const run = () => runPageTool(tool, callArgs, undefined, { timings, batched: true, job, deferred })
+      const run = () => runPageTool(tool, callArgs, (line) => noteProgress(jobs.get(job), line, i), { timings, batched: true, job, deferred })
       let one = own.some((t) => t.name === tool) ? failure({ code: 'invalid_input', message: `${tool} is the server’s own and is not batched — call it on its own.` }) : await run()
       // Busy with something of the page's own — a map being worked out,
       // say: once it is idle, the call is run again, once.
@@ -1026,22 +1357,40 @@ export function createMcpServer({
         rollbackError = `${e?.code ?? 'failed'}: ${e?.message ?? String(e)}`
       }
     }
+    // Each change taken back says so: its result is what it did before the
+    // rollback, which no longer stands.
+    let callsUndone = 0
+    if (rollback && undone !== undefined) {
+      for (let i = 0; i < results.length - 1; i++) {
+        const { tool, ok, ...rest } = results[i]
+        if (!ok || !changes(tool)) continue
+        results[i] = { tool, ok: false, undone: true, ...rest }
+        callsUndone++
+      }
+    }
     // Stopped before its last call, a batch built at the end leaves no
     // rebuild held: the page, read for idle, builds what is.
     if (atEnd && lastDeferred && !rollback) await pageIdle(Date.now() + IDLE_WAIT_MS)
     const kept = failed && checkpoint && !rollback ? { kept: `${failed.tool} changes nothing, so its refusal undid nothing: what the batch changed before it stands.` } : {}
+    // The notes for the agent as the last call that gave them said — its
+    // result spilled to a file, from its brief — at the top: not left in
+    // the middle of a long batch, and kept in the batch's own brief.
+    const notes = results.reduce((last, r) => notesIn(r.result) ?? notesIn(r.result?.brief) ?? last, undefined)
     const answer = {
       results,
       ran: results.length,
       of: calls.length,
       ...(stopped !== undefined ? { stopped } : {}),
-      ...(failed ? { failed, ...(rollback ? { undone: undone ?? [] } : {}), ...kept, ...(rollbackError ? { rollbackError } : {}) } : {}),
+      ...(failed ? { failed, ...(rollback ? { undone: undone ?? [], callsUndone } : {}), ...kept, ...(rollbackError ? { rollbackError } : {}) } : {}),
+      ...(notes !== undefined ? { notes } : {}),
       ...(timings ? { total_ms: Date.now() - started } : {}),
     }
     // Each call's result is capped already; many together may still be
     // past it — then the whole goes to a file, and the answer keeps how
-    // the batch ended.
-    return text(await fitted(answer, 'scanruler_batch', exact, ['failed', 'undone']), exact)
+    // the batch ended. A call that may answer longer (a guide) lets the
+    // batch it is in answer as long.
+    const cap = Math.max(...calls.map((c) => capOf(commandOf(String(c?.tool ?? '')))))
+    return text(await fitted(answer, 'scanruler_batch', exact, ['failed', 'undone'], { cap }), exact)
   }
 
   // The page's tools for a client that does not list them: a line each,
@@ -1083,7 +1432,7 @@ export function createMcpServer({
         for (const name of names) {
           const command = list.find((c) => toolName(c) === name)
           const mine = own.find((t) => t.name === name)
-          if (command) found.push(toolFor(command, { outDir }))
+          if (command) found.push(toolFor(command, { outDir, cwd }))
           else if (mine) found.push(definition(mine))
           else unknown.push(name)
         }
@@ -1099,13 +1448,13 @@ export function createMcpServer({
   // lines of their own.
   let callNo = 0
   server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-    if (!trace) return dispatch(request, extra, null)
+    if (!trace) return withReload(await dispatch(request, extra, null))
     const { name, arguments: args } = request.params
     const ctx = { call: ++callNo, fields: {} }
     const t = trace.now()
     const hiddenAt = hiddenNow()
     const running = runningJobs()
-    const reply = await dispatch(request, extra, ctx)
+    const reply = withReload(await dispatch(request, extra, ctx))
     trace.write({
       ev: 'call',
       call: ctx.call,
@@ -1127,15 +1476,16 @@ export function createMcpServer({
     const { name, arguments: args } = request.params
     const mine = own.find((t) => t.name === name)
     if (mine) return mine.call(args, ctx)
-    // Progress lines from the page, for a client that asked for them.
+    // Progress lines from the page: kept on the call's job, for the status
+    // and scanruler_wait to answer, and sent on to a client that asked for
+    // them.
     const token = request.params._meta?.progressToken
     let step = 0
-    const onProgress =
-      token === undefined
-        ? undefined
-        : (line) => {
-            extra.sendNotification({ method: 'notifications/progress', params: { progressToken: token, progress: ++step, message: line } }).catch(() => {})
-          }
+    let job = null
+    const onProgress = (line) => {
+      noteProgress(job, line)
+      if (token !== undefined) extra.sendNotification({ method: 'notifications/progress', params: { progressToken: token, progress: ++step, message: line } }).catch(() => {})
+    }
     // A change runs as a job, and so does a long read: answered when done —
     // or with the job, at once for wait: false and at the answer limit
     // otherwise — and kept either way, for a client that stops waiting
@@ -1144,7 +1494,7 @@ export function createMcpServer({
     if (!command || (command.readOnly && !command.long)) return runPageTool(name, args, onProgress)
     const { wait, timings, ...rest } = args ?? {}
     const timed = timings === true && !command.readOnly
-    const job = startJob(name, (id) => runPageTool(name, rest, onProgress, { timings: timed, ms: timed, job: id }), ctx, wait === false)
+    job = startJob(name, (id) => runPageTool(name, rest, onProgress, { timings: timed, ms: timed, job: id }), ctx, wait === false)
     return wait === false ? queuedReply(job) : answerFor(job, ctx)
   }