@jrpool/kilotest 59.0.0 → 59.0.4

package/api/getReport.test.ts

@@ -35,7 +35,7 @@ test('getReport returns the full report for a valid report', async () => {
   assert.ok((content['size of the report in bytes'] as number) > 0);
   const report = content['full report'] as any;
   assert.equal(report.id, '260101T0000-mix');
-  assert.equal(report.target.what, 'Mixed Outcomes Page');
+  assert.equal(report.target.what, 'Mixed Outcomes');
   assert.equal(report.target.url, 'https://example.com/mixed');
   assert.equal(report.acts.length, 2);
 });

package/api/listPages.test.ts

@@ -38,7 +38,7 @@ test('listPages returns one entry per tested page, sorted by page description',
       'All CantTell Page',
       'Branch Coverage Page',
       'Empty Results Page',
-      'Mixed Outcomes Page',
+      'Mixed Outcomes',
       'Multi Violator Page',
       'No Outcomes Page',
       'Prevented Page'
@@ -56,7 +56,7 @@ test('listPages does not include the page of the hidden report', async () => {
 test('listPages describes a multi-report page by its latest report and its report count', async () => {
   const body = await response();
   const pagesBasics = body['response content']['basics about all tested pages'];
-  const mixed = pagesBasics.find(b => b['tested web page'].description === 'Mixed Outcomes Page')!;
+  const mixed = pagesBasics.find(b => b['tested web page'].description === 'Mixed Outcomes')!;
   assert.equal(mixed['number of reports about the page'], 2);
   const latest = mixed['basics about the latest report'];
   assert.equal(latest.identifier, '260202T0000-new');

package/api/orderNewTest.test.ts

@@ -115,7 +115,7 @@ test('orderNewTest rejects a URL that redirects to a disallowed target, and aler
 });
 
 test('orderNewTest rejects an already-tested page', async () => {
-  const body = await response(['Mixed Outcomes Page', 'https://example.com/mixed', 'A reason that is long enough.']);
+  const body = await response(['Mixed Outcomes', 'https://example.com/mixed', 'A reason that is long enough.']);
   const details = body['response content']['details about your order'] as any;
   assert.equal(details.error, undefined);
   const disposition = body['response content']['disposition of your order'] as any;

package/api/orderRetest.test.ts

@@ -87,7 +87,7 @@ test('orderRetest rejects a reason longer than 100 characters', async () => {
 });
 
 test('orderRetest rejects a superseded report', async () => {
-  // 260101T0000-mix is an earlier report of "Mixed Outcomes Page" than 260202T0000-new,
+  // 260101T0000-mix is an earlier report of "Mixed Outcomes" than 260202T0000-new,
   // so it is superseded.
   const body = await response(['260101T0000', 'mix', 'A reason that is long enough.']);
   const details = body['response content']['details about your order'] as any;

package/api/requestNewTest.test.ts

@@ -110,7 +110,7 @@ test('requestNewTest rejects a URL that redirects to a disallowed target, and al
 });
 
 test('requestNewTest rejects an already-tested page', async () => {
-  const body = await response(['Mixed Outcomes Page', 'https://example.com/mixed', 'A reason that is long enough.']);
+  const body = await response(['Mixed Outcomes', 'https://example.com/mixed', 'A reason that is long enough.']);
   const details = body['response content']['details about your request'] as any;
   // A report for this description and URL already exists, so processTestRequest
   // returns 'reportExists' and the failure is reported via the disposition, not details.error.

package/api/requestRetest.test.ts

@@ -85,7 +85,7 @@ test('requestRetest rejects a malformed timestamp or job identifier', async () =
 });
 
 test('requestRetest rejects a superseded report', async () => {
-  // 260101T0000-mix is an earlier report of "Mixed Outcomes Page" than 260202T0000-new,
+  // 260101T0000-mix is an earlier report of "Mixed Outcomes" than 260202T0000-new,
   // so it is superseded and processTestRequest returns 'superseded', reported via the
   // disposition rather than details.error.
   const body = await response(['260101T0000', 'mix', 'A reason that is long enough.']);
@@ -168,10 +168,10 @@ test('requestRetest accepts a valid retest request for the latest report of a pa
   const body = await response(['260202T0000', 'new', 'A reason that is long enough.']);
   const details = body['response content']['details about your request'] as any;
   assert.equal(details.error, undefined);
-  assert.equal(details['page to be retested'].description, 'Mixed Outcomes Page');
+  assert.equal(details['page to be retested'].description, 'Mixed Outcomes');
   assert.ok(logged.some(line =>
     line.startsWith('WARNING (Kilotest: request for a retest awaits approval)')
-    && line.includes('Mixed Outcomes Page')
+    && line.includes('Mixed Outcomes')
     && line.includes('https://example.com/mixed')
     // The alert reports the resulting queue size, so a maintainer who has been away can
     // see at a glance how close the queue is to full.

package/docs/AI-TOOLS.md

@@ -21,7 +21,7 @@ The internal features that make Kilotest a collection of tools for language mode
 
 - An API, with specific functional and utility modules in the `api` directory.
 - Tests of the functionalities of the API.
-- A [`JSON-LD`](https://json-ld.org/) script in the `index.html` file, providing structured data about the Kilotest API.
+- A [`JSON-LD`](https://json-ld.org/) script in the `web/home/index.html` file, providing structured data about the Kilotest API.
 - Environment variables in the `env.example` file.
 - An `llms.txt` file and an `llms-full.txt` file, documenting the use of Kilotest by language models, conforming to the [llms-txt](https://llmstxt.org/) specification.
 - A generated `openapi.yaml` file, documenting the Kilotest API, conforming to the [OpenAPI specification](https://spec.openapis.org/oas/v3.1.0).

package/index.test.ts

@@ -471,7 +471,7 @@ test('POST /requestNewTest.html with valid data returns an HTML page', async ()
 
 test('POST /requestNewTest.html with an already-tested URL returns an error', async () => {
   const res = await formRequest('POST', '/requestNewTest.html', {
-    description: 'Mixed Outcomes Page',
+    description: 'Mixed Outcomes',
     url: 'https://example.com/mixed',
     why: 'Because accessibility matters'
   });

package/index.ts

@@ -31,7 +31,8 @@ import {
   jobsPath,
   metricsExclusionCookieName,
   recordMetric,
-  reportsPath
+  reportsPath,
+  unusableReportsPath
 } from './util.ts';
 import {sendAlert} from './alerts.ts';
 import {checkBalancesForAlerts} from './balances.ts';
@@ -40,6 +41,7 @@ import {handleMCP, mcpPath} from './mcp.ts';
 import fs from 'node:fs/promises';
 import {handleComment as handleTutorialWebComment} from './web/tutorialWeb/index.ts';
 import {answer as tutorialWeb} from './web/tutorialWeb/index.ts';
+import {answer as home} from './web/home/index.ts';
 import {answer as privacy} from './web/privacy/index.ts';
 import {answer as tutorialAI, handleComment as handleTutorialAIComment} from './web/tutorialAI/index.ts';
 import http, {type IncomingMessage, type ServerResponse} from 'node:http';
@@ -642,10 +644,10 @@ const handleRequest = async (request: IncomingMessage, response: ServerResponse)
     else if (['/', '/index.html'].includes(pathname)) {
       await recordPageMetric('pageViews', 'index');
       // Get the home page.
-      const homePage = await fs.readFile('index.html', 'utf8');
+      const {answerPage} = await home();
       // Serve it.
       setHeaders('text/html', '/index.html', 'medium');
-      response.end(homePage);
+      response.end(answerPage);
     }
     // Otherwise, if it is for the crawler specification:
     else if (pageName === 'robots.txt') {
@@ -1386,7 +1388,9 @@ export {requestHandler};
 
 const serve = async (protocolModule: typeof http | typeof https, options: {key?: string; cert?: string}) => {
   // Create any missing directories.
-  for (const path of [queuePath(), claimedPath(), failedPath(), hiddenReportsPath(), reportsPath()]) {
+  for (const path of [
+    queuePath(), claimedPath(), failedPath(), hiddenReportsPath(), reportsPath(), unusableReportsPath()
+  ]) {
     await fs.mkdir(path, {recursive: true});
   }
   const server = protocolModule === https

package/mcp.test.ts

@@ -225,7 +225,7 @@ test('orderRetest handler returns content and structuredContent, and enqueues a
   const {jobsPath} = await import('./util.ts');
   const server = createMCPServer();
   const countBefore = getToolCallCount('orderRetest');
-  // 260202T0000-new is the latest report of "Mixed Outcomes Page" (260101T0000-mix is an
+  // 260202T0000-new is the latest report of "Mixed Outcomes" (260101T0000-mix is an
   // earlier, superseded report of the same page), so this order is accepted.
   const result = await (server as any)._registeredTools.orderRetest.handler({
     timeStamp: '260202T0000',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jrpool/kilotest",
-  "version": "59.0.0",
+  "version": "59.0.4",
   "description": "Ensemble testing for front-end web quality",
   "type": "module",
   "main": "index.ts",

package/test/dbFixture.ts

@@ -24,6 +24,7 @@ fs.cpSync(path.join(import.meta.dirname, 'fixtures', 'db'), fixtureDBDir, {recur
 for (const category of ['queue', 'claimed', 'failed']) {
   fs.mkdirSync(path.join(fixtureDBDir, 'jobs', category), {recursive: true});
 }
+fs.mkdirSync(path.join(fixtureDBDir, 'unusableReports'), {recursive: true});
 
 // Remove the copy when the process exits.
 process.on('exit', () => fs.rmSync(fixtureDBDir, {recursive: true, force: true}));

package/test/fixtures/buildFixtures.ts

@@ -114,6 +114,7 @@ const main = async () => {
   await fs.mkdir(path.join(targetDir, 'jobs', 'claimed'), {recursive: true});
   await fs.mkdir(path.join(targetDir, 'jobs', 'failed'), {recursive: true});
   await fs.mkdir(path.join(targetDir, 'hiddenReports'), {recursive: true});
+  await fs.mkdir(path.join(targetDir, 'unusableReports'), {recursive: true});
 
   // Fixture 1: mixedOutcomes. Two rule engines, four instances: two failed (same issue, same violator, two engines), one cantTell (excluded from counts), one failed (different issue, different violator). Two distinct issues (linkNoText weight 4, allCaps weight 1) and two distinct violator catalog indexes (0 and 1).
   const mixedCatalog = {
@@ -136,7 +137,7 @@ const main = async () => {
   ];
   await writeJSON(
     path.join(reportsDir, '260101T0000-mix.json'),
-    report('260101T0000-mix', 'Mixed Outcomes Page',
+    report('260101T0000-mix', 'Mixed Outcomes',
       'https://example.com/mixed', mixedActs, mixedCatalog)
   );
 
@@ -188,7 +189,7 @@ const main = async () => {
   ];
   await writeJSON(
     path.join(reportsDir, '260202T0000-new.json'),
-    report('260202T0000-new', 'Mixed Outcomes Page',
+    report('260202T0000-new', 'Mixed Outcomes',
       'https://example.com/mixed', newerActs, mixedCatalog, '26-02-02T00:10')
   );
 

package/test/fixtures/db/reports/260101T0000-mix.json

@@ -1,6 +1,6 @@
 {
   "id": "260101T0000-mix",
-  "what": "Mixed Outcomes Page",
+  "what": "Mixed Outcomes",
   "strict": false,
   "standard": "only",
   "device": {
@@ -10,7 +10,7 @@
   "creationTimeStamp": "260101T0000",
   "executionTimeStamp": "260101T0000",
   "target": {
-    "what": "Mixed Outcomes Page",
+    "what": "Mixed Outcomes",
     "url": "https://example.com/mixed"
   },
   "sources": {

package/test/fixtures/db/reports/260202T0000-new.json

@@ -1,6 +1,6 @@
 {
   "id": "260202T0000-new",
-  "what": "Mixed Outcomes Page",
+  "what": "Mixed Outcomes",
   "strict": false,
   "standard": "only",
   "device": {
@@ -10,7 +10,7 @@
   "creationTimeStamp": "260202T0000",
   "executionTimeStamp": "260202T0000",
   "target": {
-    "what": "Mixed Outcomes Page",
+    "what": "Mixed Outcomes",
     "url": "https://example.com/mixed"
   },
   "sources": {

package/util.test.ts

@@ -24,6 +24,7 @@ import {
   awaitJob,
   checkCommentDuplicate,
   checkLength,
+  quarantineReport,
   createLock,
   dbPath,
   describeMax,
@@ -61,7 +62,8 @@ import {
   processTestRequest,
   testRequestsLock,
   testRequestsPath,
-  reportsPath
+  reportsPath,
+  unusableReportsPath
 } from './util.ts';
 
 // TESTS
@@ -142,7 +144,7 @@ test('dbPath honors DB_DIR when it is set', () => {
   }
 });
 
-test('jobsPath, testRequestsPath, reportsPath, and hiddenReportsPath derive from DB_DIR', () => {
+test('jobsPath, testRequestsPath, reportsPath, hiddenReportsPath, and unusableReportsPath derive from DB_DIR', () => {
   const saved = process.env.DB_DIR;
   process.env.DB_DIR = '/tmp/kilotest-fixtures';
   try {
@@ -150,6 +152,7 @@ test('jobsPath, testRequestsPath, reportsPath, and hiddenReportsPath derive from
     assert.equal(testRequestsPath(), path.join('/tmp/kilotest-fixtures', 'jobs', 'testRequests.json'));
     assert.equal(reportsPath(), path.join('/tmp/kilotest-fixtures', 'reports'));
     assert.equal(hiddenReportsPath(), path.join('/tmp/kilotest-fixtures', 'hiddenReports'));
+    assert.equal(unusableReportsPath(), path.join('/tmp/kilotest-fixtures', 'unusableReports'));
   }
   finally {
     if (saved !== undefined) {
@@ -769,14 +772,14 @@ test('processTestRequest returns a duplicate error for a repeated request', {tim
 test('processTestRequest returns a reportExists error when a report already exists for the page', async () => {
   // The fixture database already has a report for this description and URL.
   const {result} = await processTestRequest(
-    'because accessibility', {description: 'Mixed Outcomes Page', url: 'https://example.com/mixed'}
+    'because accessibility', {description: 'Mixed Outcomes', url: 'https://example.com/mixed'}
   );
   assert.equal(result, 'reportExists');
 });
 
 test('processTestRequest returns a reportExists error when a report exists about a page with the same description', async () => {
   const {result} = await processTestRequest(
-    'because accessibility', {description: 'Mixed Outcomes Page', url: 'https://example.com/drifted'}
+    'because accessibility', {description: 'Mixed Outcomes', url: 'https://example.com/drifted'}
   );
   assert.equal(result, 'reportExists');
 });
@@ -908,7 +911,7 @@ test('annotateReportObject handles a test act with no standardResult', async ()
 });
 
 test('isReportAvailable returns true for a known page description', async () => {
-  const result = await isReportAvailable('Mixed Outcomes Page', 'https://example.com/nonexistent');
+  const result = await isReportAvailable('Mixed Outcomes', 'https://example.com/nonexistent');
   assert.equal(result, true);
 });
 
@@ -1435,7 +1438,7 @@ test('getReportExtract returns an extract for a valid report', async () => {
   const extract = await getReportExtract('260101T0000', 'mix') as any;
   assert.equal(extract.timeStamp, '260101T0000');
   assert.equal(extract.jobID, 'mix');
-  assert.equal(extract.description, 'Mixed Outcomes Page');
+  assert.equal(extract.description, 'Mixed Outcomes');
   assert.equal(extract.url, 'https://example.com/mixed');
   assert.ok(extract.reportTime);
 });
@@ -1445,6 +1448,177 @@ test('getReportExtract returns an error for a nonexistent report', async () => {
   assert.ok(extract.error);
 });
 
+test('getReportExtract returns an error for an unusable report', async () => {
+  const os = await import('node:os');
+  const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kilotest-extract-bad-'));
+  const tmpReportsDir = path.join(tmpRoot, 'db', 'reports');
+  await fs.mkdir(tmpReportsDir, {recursive: true});
+  const savedDbDir = process.env.DB_DIR;
+  process.env.DB_DIR = path.join(tmpRoot, 'db');
+  try {
+    // A report with a target and a completion time but no usable acts or catalog is
+    // defective, so it must produce no extract rather than be exposed in listings.
+    await fs.writeFile(
+      path.join(tmpReportsDir, '260101T0000-bad.json'),
+      JSON.stringify({
+        target: {what: 'Defective Page', url: 'https://example.com/defective'},
+        jobData: {endTime: '26-01-01T00:00'}
+      })
+    );
+    const extract = await getReportExtract('260101T0000', 'bad') as any;
+    assert.ok(extract.error);
+  }
+  finally {
+    if (savedDbDir !== undefined) {
+      process.env.DB_DIR = savedDbDir;
+    }
+    else {
+      delete process.env.DB_DIR;
+    }
+    await fs.rm(tmpRoot, {recursive: true, force: true});
+  }
+});
+
+test('quarantineReport ignores a missing report', async () => {
+  const os = await import('node:os');
+  const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kilotest-quarantine-missing-'));
+  const savedDbDir = process.env.DB_DIR;
+  process.env.DB_DIR = path.join(tmpRoot, 'db');
+  try {
+    await quarantineReport('999999T9999', 'xxx', 'not usable');
+    // Nothing was created or moved.
+    assert.deepEqual(await fs.readdir(tmpRoot), []);
+  }
+  finally {
+    if (savedDbDir !== undefined) {
+      process.env.DB_DIR = savedDbDir;
+    }
+    else {
+      delete process.env.DB_DIR;
+    }
+    await fs.rm(tmpRoot, {recursive: true, force: true});
+  }
+});
+
+test('quarantineReport leaves a recently modified report in place', async () => {
+  const os = await import('node:os');
+  const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kilotest-quarantine-young-'));
+  const tmpReportsDir = path.join(tmpRoot, 'db', 'reports');
+  await fs.mkdir(tmpReportsDir, {recursive: true});
+  const filePath = path.join(tmpReportsDir, '260101T0000-bad.json');
+  await fs.writeFile(filePath, '{}');
+  const savedDbDir = process.env.DB_DIR;
+  process.env.DB_DIR = path.join(tmpRoot, 'db');
+  try {
+    await quarantineReport('260101T0000', 'bad', 'not usable');
+    // The fresh file may still be mid-write, so it was not moved.
+    await fs.access(filePath);
+  }
+  finally {
+    if (savedDbDir !== undefined) {
+      process.env.DB_DIR = savedDbDir;
+    }
+    else {
+      delete process.env.DB_DIR;
+    }
+    await fs.rm(tmpRoot, {recursive: true, force: true});
+  }
+});
+
+test('quarantineReport quarantines a report old enough to be quarantined', async () => {
+  const os = await import('node:os');
+  const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kilotest-quarantine-old-'));
+  const tmpReportsDir = path.join(tmpRoot, 'db', 'reports');
+  await fs.mkdir(tmpReportsDir, {recursive: true});
+  const filePath = path.join(tmpReportsDir, '260101T0000-bad.json');
+  await fs.writeFile(filePath, '{}');
+  // Age the file beyond the quarantine threshold.
+  const longAgo = new Date(Date.now() - 120000);
+  await fs.utimes(filePath, longAgo, longAgo);
+  const savedDbDir = process.env.DB_DIR;
+  process.env.DB_DIR = path.join(tmpRoot, 'db');
+  try {
+    await quarantineReport('260101T0000', 'bad', 'not usable');
+    // The file was moved to the unusable-reports directory.
+    await fs.access(filePath).then(
+      () => {throw new Error('Report should have been quarantined');},
+      () => {}
+    );
+    const quarantined = await fs.readdir(path.join(tmpRoot, 'db', 'unusableReports'));
+    assert.deepEqual(quarantined, ['260101T0000-bad.json']);
+  }
+  finally {
+    if (savedDbDir !== undefined) {
+      process.env.DB_DIR = savedDbDir;
+    }
+    else {
+      delete process.env.DB_DIR;
+    }
+    await fs.rm(tmpRoot, {recursive: true, force: true});
+  }
+});
+
+test('quarantineReport leaves the file and logs when the move fails', async () => {
+  const os = await import('node:os');
+  const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kilotest-quarantine-blocked-'));
+  const tmpReportsDir = path.join(tmpRoot, 'db', 'reports');
+  await fs.mkdir(tmpReportsDir, {recursive: true});
+  const filePath = path.join(tmpReportsDir, '260101T0000-bad.json');
+  await fs.writeFile(filePath, '{}');
+  // Age the file beyond the quarantine threshold.
+  const longAgo = new Date(Date.now() - 120000);
+  await fs.utimes(filePath, longAgo, longAgo);
+  // A directory already occupying the destination path makes the rename fail.
+  await fs.mkdir(path.join(tmpRoot, 'db', 'unusableReports', '260101T0000-bad.json'), {recursive: true});
+  const savedDbDir = process.env.DB_DIR;
+  process.env.DB_DIR = path.join(tmpRoot, 'db');
+  try {
+    await quarantineReport('260101T0000', 'bad', 'not usable');
+    // The report stays where it was.
+    await fs.access(filePath);
+  }
+  finally {
+    if (savedDbDir !== undefined) {
+      process.env.DB_DIR = savedDbDir;
+    }
+    else {
+      delete process.env.DB_DIR;
+    }
+    await fs.rm(tmpRoot, {recursive: true, force: true});
+  }
+});
+
+test('getReport quarantines a malformed report file old enough to be quarantined', async () => {
+  const os = await import('node:os');
+  const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kilotest-getreport-bad-'));
+  const tmpReportsDir = path.join(tmpRoot, 'db', 'reports');
+  await fs.mkdir(tmpReportsDir, {recursive: true});
+  const filePath = path.join(tmpReportsDir, '260101T0000-bad.json');
+  await fs.writeFile(filePath, 'not JSON');
+  // Age the file beyond the quarantine threshold.
+  const longAgo = new Date(Date.now() - 120000);
+  await fs.utimes(filePath, longAgo, longAgo);
+  const savedDbDir = process.env.DB_DIR;
+  process.env.DB_DIR = path.join(tmpRoot, 'db');
+  try {
+    const {getReport} = await import('./util.ts');
+    const result = await getReport('260101T0000', 'bad') as any;
+    assert.ok(result.error);
+    // The malformed file was quarantined.
+    const quarantined = await fs.readdir(path.join(tmpRoot, 'db', 'unusableReports'));
+    assert.deepEqual(quarantined, ['260101T0000-bad.json']);
+  }
+  finally {
+    if (savedDbDir !== undefined) {
+      process.env.DB_DIR = savedDbDir;
+    }
+    else {
+      delete process.env.DB_DIR;
+    }
+    await fs.rm(tmpRoot, {recursive: true, force: true});
+  }
+});
+
 test('getReportExtracts returns extracts of all available reports', async () => {
   const extracts = await getReportExtracts();
   assert.ok(extracts.length >= 8);
@@ -1455,7 +1629,7 @@ test('getReportExtracts returns extracts of all available reports', async () =>
 
 test('getReportExtracts with onlyLatest returns only the latest report for each page', async () => {
   const latest = await getReportExtracts(true);
-  const mixReports = latest.filter(e => e.description === 'Mixed Outcomes Page');
+  const mixReports = latest.filter(e => e.description === 'Mixed Outcomes');
   assert.equal(mixReports.length, 1);
   assert.equal(mixReports[0]!.timeStamp, '260202T0000');
 });
@@ -1473,7 +1647,7 @@ test('getReportExtracts reflects reports added, modified, and removed after a pr
     const firstPath = path.join(tmpReportsDir, '260101T0000-aaa.json');
     await fs.writeFile(firstPath, JSON.stringify(report));
     let extracts = await getReportExtracts();
-    assert.deepEqual(extracts.map(e => e.description), ['Mixed Outcomes Page']);
+    assert.deepEqual(extracts.map(e => e.description), ['Mixed Outcomes']);
     // Modify the report and give it a later modification time, as reannotation would.
     report.target.what = 'Revised Page';
     await fs.writeFile(firstPath, JSON.stringify(report));
@@ -1768,14 +1942,14 @@ test('orderJob enqueues a new-page order directly into the job queue', async ()
 
 test('orderJob returns a reportExists error when a report already exists for the ordered page', async () => {
   const {result} = await orderJob(
-    {description: 'Mixed Outcomes Page', url: 'https://example.com/mixed'}, 'because accessibility matters here'
+    {description: 'Mixed Outcomes', url: 'https://example.com/mixed'}, 'because accessibility matters here'
   );
   assert.equal(result, 'reportExists');
 });
 
 test('orderJob returns a reportExists error when a report exists about a page with the same description', async () => {
   const {result} = await orderJob(
-    {description: 'Mixed Outcomes Page', url: 'https://example.com/drifted'}, 'because accessibility matters here'
+    {description: 'Mixed Outcomes', url: 'https://example.com/drifted'}, 'because accessibility matters here'
   );
   assert.equal(result, 'reportExists');
 });
@@ -1841,7 +2015,7 @@ test('orderJob returns "nonreport" when a retest order cites a report that does
 });
 
 test('orderJob returns "superseded" when a retest order cites a superseded report', async () => {
-  // 260101T0000-mix is an earlier report of "Mixed Outcomes Page" than 260202T0000-new,
+  // 260101T0000-mix is an earlier report of "Mixed Outcomes" than 260202T0000-new,
   // so it is superseded.
   const {result} = await orderJob(
     {timeStamp: '260101T0000', jobID: 'mix'}, 'because accessibility matters here'
@@ -1854,12 +2028,12 @@ test('orderJob enqueues a retest order for the latest report of a page', async (
     {timeStamp: '260202T0000', jobID: 'new'}, 'because accessibility matters here'
   ) as any;
   assert.equal(result, 'ok');
-  assert.equal(description, 'Mixed Outcomes Page');
+  assert.equal(description, 'Mixed Outcomes');
   assert.equal(url, 'https://example.com/mixed');
   const queuedPath = path.join(jobsPath(), 'queue', `${jobID}.json`);
   try {
     const job = JSON.parse(await fs.readFile(queuedPath, 'utf8'));
-    assert.equal(job.target.what, 'Mixed Outcomes Page');
+    assert.equal(job.target.what, 'Mixed Outcomes');
   }
   finally {
     await fs.unlink(queuedPath);

package/util.ts

@@ -32,6 +32,9 @@ export const testRequestsPath = (): string => path.join(jobsPath(), 'testRequest
 export const reportsPath = (): string => path.join(dbPath(), 'reports');
 // Path of the hidden-reports directory.
 export const hiddenReportsPath = (): string => path.join(dbPath(), 'hiddenReports');
+// Path of the unusable-reports directory, where reports that fail the usability
+// checks are quarantined for a manager to repair or delete.
+export const unusableReportsPath = (): string => path.join(dbPath(), 'unusableReports');
 // Path of the usage-metrics file.
 export const metricsPath = (): string => path.join(dbPath(), 'metrics.json');
 // IDs, names, and sponsors of Testaro rule engines.
@@ -692,7 +695,49 @@ export const isUsableReport = (report: unknown): report is UsableReport => {
   && !isNaN(getReportEndTime(r).getTime())
   && typeof r.catalog === 'object';
 };
-// Returns a report.
+// Minimum age, in milliseconds, of the last modification of a report file for the
+// file to be quarantined. A more recently modified file may still be being written
+// by a worker or a reannotation, so quarantining it could mistake an incomplete write
+// for a defect. Read at call time so tests can shrink it via REPORT_QUARANTINE_MIN_AGE_MS;
+// a value of 0 disables the age check.
+const quarantineMinAgeMs = () => getEnvMax('REPORT_QUARANTINE_MIN_AGE_MS', 60000);
+// Moves a report file from the reports directory to the unusable-reports directory
+// and alerts a manager, if the file exists and is old enough that it can no longer
+// plausibly be mid-write. Called by getReport whenever a report proves defective, so
+// that a defective report is quarantined rather than merely hidden from whichever
+// listing encountered it. Never throws: a failure here must not displace the error
+// that getReport is already reporting.
+export const quarantineReport = async (timeStamp: string, jobID: string, defect: string): Promise<void> => {
+  const jobName = `${timeStamp}-${jobID}`;
+  // Get the modification time of the report file. A missing file needs no move.
+  const stat = await fs.stat(getReportPath(timeStamp, jobID)).catch(() => null);
+  if (!stat) {
+    return;
+  }
+  // Leave a recently modified file alone, since it may still be being written.
+  if (Date.now() - stat.mtimeMs < quarantineMinAgeMs()) {
+    return;
+  }
+  try {
+    await fs.mkdir(unusableReportsPath(), {recursive: true});
+    await fs.rename(
+      getReportPath(timeStamp, jobID), path.join(unusableReportsPath(), `${jobName}.json`)
+    );
+  }
+  catch (error: unknown) {
+    // The report stays excluded regardless, so a failed move is only logged.
+    console.error(`ERROR: Failed to quarantine report ${jobName} (${errorMessage(error)})`);
+    return;
+  }
+  // Alert a manager, who can repair the report in place or delete it.
+  await sendAlert(
+    'Kilotest: unusable report',
+    `Report ${jobName} is ${defect}. It was moved to the unusableReports directory, where a manager can repair or delete it.`
+  );
+};
+// Returns a report, or an error object if it is missing, unreadable, unparsable, or
+// unusable. A report that exists but cannot be read or is unusable is defective, so
+// it is quarantined rather than merely rejected by whichever read encountered it.
 export const getReport = async (timeStamp: string, jobID: string): Promise<UsableReport | {error: string}> => {
   try {
     const reportJSON = await fs.readFile(getReportPath(timeStamp, jobID), 'utf8');
@@ -702,11 +747,15 @@ export const getReport = async (timeStamp: string, jobID: string): Promise<Usabl
       // Return it.
       return report;
     }
-    // Otherwise, i.e. if it is unusable, return this.
-    return {error: `Report ${timeStamp}-${jobID} is not usable`};
   } catch (error: unknown) {
+    // The file exists but cannot be read or parsed, or is already missing.
+    // quarantineReport ignores a missing file, so no existence check is needed here.
+    await quarantineReport(timeStamp, jobID, 'unreadable or not JSON');
     return {error: `Report ${timeStamp}-${jobID} is missing, unreadable, or not JSON (${errorMessage(error)})`};
   }
+  // The report was read but is not usable, so quarantine it.
+  await quarantineReport(timeStamp, jobID, 'not usable');
+  return {error: `Report ${timeStamp}-${jobID} is not usable`};
 };
 // Returns whether a getReport result is an error (rather than a usable report).
 // A type predicate is used instead of `if (report.error)` because UsableReport
@@ -773,30 +822,27 @@ export const getReportEndTime = (report: {jobData?: {endTime?: string}}): Date =
   `20${report.jobData?.endTime}Z`
 );
 
-// Returns an extract of an available report, or an error object if it cannot be read or parsed.
+// Returns an extract of an available report, or an error object if the report cannot
+// be used. An extract exists to expose a report in listings, so it shares getReport's
+// usability bar: a report too defective to expose must produce no extract.
 export const getReportExtract = async (timeStamp: string, jobID: string): Promise<ReportExtract | {error: string}> => {
-  try {
-    // Get the report.
-    const reportJSON = await fs.readFile(
-      path.join(reportsPath(), `${timeStamp}-${jobID}.json`), 'utf8'
-    );
-    const report = JSON.parse(reportJSON);
-    const {target, jobData} = report;
-    const {what: description, url} = target;
-    // Return an extract of it.
-    return {
-      timeStamp,
-      jobID,
-      description,
-      url,
-      reportTime: getReportEndTime({jobData}).toISOString()
-    };
-  }
-  catch {
-    return {
-      error: `No report ${timeStamp}-${jobID} is available`
-    };
+  const report = await getReport(timeStamp, jobID);
+  // If the report is not usable:
+  if (isReportError(report)) {
+    // Return the reason.
+    return report;
   }
+  const {target, jobData} = report;
+  const {what: description, url} = target;
+  // Return an extract of it. Usability has already guaranteed these properties,
+  // including a valid completion time.
+  return {
+    timeStamp,
+    jobID,
+    description,
+    url,
+    reportTime: getReportEndTime({jobData}).toISOString()
+  };
 };
 // Cache of report extracts, keyed by report file path. Each entry records the modification
 // time and size of the file when it was extracted, so an entry is reused only while the file
@@ -804,7 +850,7 @@ export const getReportExtract = async (timeStamp: string, jobID: string): Promis
 // written, hidden, or deleted by any process, so the cache is validated against the files
 // before every use rather than invalidated by the code that changes them.
 const reportExtractCache = new Map<string, {mtimeMs: number, size: number, extract: ReportExtract}>();
-// Returns extracts of all available reports.
+// Returns extracts of all available reports, ordered by page description and completion time.
 export const getReportExtracts = async (onlyLatest: boolean = false): Promise<ReportExtract[]> => {
   const reportsDir = reportsPath();
   // Get the names and paths of the available report files.
@@ -866,8 +912,7 @@ export const getReportExtracts = async (onlyLatest: boolean = false): Promise<Re
   // Return the array, excluding extracts of superseded reports if so specified.
   return onlyLatest ? extracts.filter(extract => !extract.superseded) : extracts;
 };
-// Returns extracts of all available reports about the page with a description, from oldest
-// to latest.
+// Returns extracts of all available reports about a page, from oldest to latest.
 export const getPageReportExtracts = async (description: string): Promise<ReportExtract[]> => {
   const reportExtracts = await getReportExtracts();
   return reportExtracts.filter(extract => extract.description === description);

package/web/home/home.test.ts

@@ -0,0 +1,19 @@
+/*
+  home.test.ts
+  Unit tests for web/home/index.ts, covering the answer export.
+*/
+
+// IMPORTS
+
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {answer} from './index.ts';
+
+// TESTS
+
+test('answer returns the home page', async () => {
+  const result = await answer();
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage.includes('<h1>Kilotest</h1>'));
+  assert.ok(result.answerPage.includes('application/ld+json'));
+});

package/{index.html → web/home/index.html}

@@ -90,7 +90,7 @@
         <li><a href="listPages.html">Which web pages have been tested?</a></li>
         <li><a href="listTopIssues.html">Which issues have been reported?</a></li>
         <li><a href="manage.html">What can Kilotest managers do?</a></li>
-        <li><a href="privacy.html">What is the privacy policy?</a></li>
+        <li><a href="privacy.html">Privacy policy</a></li>
       </ul>
     </main>
   </body>

package/web/home/index.ts

@@ -0,0 +1,20 @@
+/*
+  index.ts
+  Serves the home page.
+*/
+
+// IMPORTS
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+// FUNCTIONS
+
+// Returns the home page.
+export const answer = async () => {
+  const answerPage = await fs.readFile(path.join(import.meta.dirname, 'index.html'), 'utf8');
+  return {
+    status: 'ok',
+    answerPage
+  };
+};

package/web/listDiagnoses/listDiagnoses.test.ts

@@ -200,7 +200,7 @@ test('listDiagnoses returns an error for an unknown issue with a valid report',
 
 test('listDiagnoses returns an error when report facts are not obtained', async () => {
   pageDataStringsOverride = {
-    what: 'Mixed Outcomes Page',
+    what: 'Mixed Outcomes',
     url: 'https://example.com/mixed',
     urlLink: '<a href="https://example.com/mixed">https://example.com/mixed</a>'
   };

package/web/listIssues/index.html

@@ -13,17 +13,8 @@
   <body>
     <main>
       <h1><a href="/">Kilotest</a>: Issues reported for __target__</h1>
-
+      __oldWarn__
       <h2>About the tests</h2>
-      <details>
-        <summary>How to deal with the issues</summary>
-        <h3>Do it yourself</h3>
-        <p>Explore the issues below in as much detail as you want. Decide which ones are actual defects. Plan and implement corrections.</p>
-        <h3>Or use AI</h3>
-        <p>Make Kilotest available to your AI assistant. There are <a href="/tutorialAI.html">step-by-step instructions</a> for this.</p>
-        <p>After that, you can ask:</p>
-        <blockquote>Kilotest reports defects on the __target__ web page. Summarize them and propose a plan to resolve the genuine ones.</blockquote>
-      </details>
 __pageFacts__
       <h2>History</h2>
 __history__
@@ -52,6 +43,13 @@ __history__
           __lowestDetails__
         </ul>
       </details>
+      <h2>What you can do</h2>
+      <p><strong>Choose how</strong> to address these issues:</p>
+      <h3>Do it yourself</h3>
+      <p>Explore the issues, following the links above. Decide which issues are actual defects. Plan and implement corrections. Then retest the page.</p>
+      <h3>Use artificial intelligence</h3>
+      <p><a href="/tutorialAI.html">Make Kilotest available to an AI assistant</a>. Then give it a prompt like this:</p>
+      <blockquote><q>Kilotest reports issues on the __target__ web page. Describe them and propose a plan to resolve the genuine defects.</q></blockquote>
     </main>
   </body>
 </html>

package/web/listIssues/index.ts

@@ -123,46 +123,62 @@ const getIssuesData = (report: UsableReport): ResultsSummary & Record<string, an
   // Return the data.
   return final;
 };
-// Returns the lines of the history of the reports about the page of a report.
-const getHistoryLines = async (
-  timeStamp: string, jobID: string, description: string, margin: string
-): Promise<string[]> => {
+// Returns data and HTML lines about the history of the reports about the page of a report.
+const getHistory = async (
+  timeStamp: string, jobID: string, description: string, margin: string = ''
+): Promise<{isLatest: boolean, lines: string[]}> => {
   // Get extracts of all reports about the page, from oldest to latest.
   const pageExtracts = await getPageReportExtracts(description);
-  const lastIndex = pageExtracts.length - 1;
-  // Initialize the list items and whether the report is the latest about the page.
-  const itemLines: string[] = [];
-  let isLatest = false;
-  // For each report about the page:
+  // The report's own extract may be absent if the report was quarantined between the
+  // report read and the extract listing, so an empty list means "not latest".
+  const lastExtract = pageExtracts[pageExtracts.length - 1];
+  const isLatest = lastExtract !== undefined
+  && lastExtract.timeStamp === timeStamp && lastExtract.jobID === jobID;
+  // Initialize the history.
+  const history = {
+    isLatest,
+    lines: [] as string[]
+  };
+  // For each report about the page, from oldest to latest:
   pageExtracts.forEach((extract, index) => {
+    // Get whether it is this report.
     const isThis = extract.timeStamp === timeStamp && extract.jobID === jobID;
-    isLatest ||= isThis && index === lastIndex;
     // Get the tags that identify its position and whether it is this report.
     const tags = [
       index === 0 ? 'oldest' : '',
-      index === lastIndex ? 'latest' : '',
+      index === pageExtracts.length - 1 ? 'latest' : '',
       isThis ? 'this report' : ''
     ]
     .filter(tag => tag);
+    // Get a string containing the applicable tags.
     const tagString = tags.length ? ` (${tags.join('; ')})` : '';
     const label = `${getAgoString(new Date(extract.reportTime))} ago${tagString}`;
-    // Add a list item describing it, linked unless it is this report, to the items.
-    const href = `/listIssues.html/${extract.timeStamp}/${extract.jobID}`;
-    const content = isThis ? label : `<a href="${href}">${label}</a>`;
-    itemLines.push(`${margin}  <li>${content}</li>`);
+    let content;
+    if (isThis) {
+      content = label;
+    }
+    else {
+      const href = `/listIssues.html/${extract.timeStamp}/${extract.jobID}`;
+      content = `<a href="${href}">${label}</a>`;
+    }
+    // Add a list item describing the report, linked if not this report, to the history.
+    history.lines.push(`${margin}<li>${content}</li>`);
   });
   // Initialize the lines with a list of the reports, or a statement that there is only one.
-  const lines = itemLines.length > 1
-  ? [`${margin}<ol>`, ...itemLines, `${margin}</ol>`]
-  : [`${margin}<p>This is the only report about the page.</p>`];
-  // If the report is the latest about the page:
+  const lines = history.lines.length > 1
+  ? [`${margin}<ol>`, ...history.lines, `${margin}</ol>`]
+  : [`${margin}<p>This is the only available report about the page.</p>`];
+  // If this report is the latest about the page:
   if (isLatest) {
     // Add a link to the form for requesting a retest to the lines.
-    const href = `/requestRetestForm.html/${timeStamp}/${jobID}`;
-    lines.push(`${margin}<p><a href="${href}">Should Kilotest retest the page?</a></p>`);
+    lines.push(
+      `${margin}<p><a href="/requestRetestForm.html/${timeStamp}/${jobID}">Request a retest</a></p>`
+    );
   }
-  // Return the lines.
-  return lines;
+  // Replace the bare list items with the assembled section lines.
+  history.lines = lines;
+  // Return the history.
+  return history;
 };
 // Adds parameters to a query for the answer page.
 const populateQuery = async (timeStamp: string, jobID: string, query: Record<string, any>) => {
@@ -191,10 +207,15 @@ const populateQuery = async (timeStamp: string, jobID: string, query: Record<str
   query.target = description;
   query.testInfo = testInfo;
   const margin = ' '.repeat(6);
+  const history = await getHistory(timeStamp, jobID, description, ' '.repeat(8));
+  // Add a warning if the report is not the latest about the page.
+  query.oldWarn = history.isLatest
+  ? ''
+  : '<p><strong>Warning: This report is not the latest about the page.</strong> See history below.</p>';
   // Add the page-facts list to the query.
   query.pageFacts = getPageFactsLines(pageInfo, issuesData, margin).join('\n');
   // Add the history of reports about the page to the query.
-  query.history = (await getHistoryLines(timeStamp, jobID, description, margin)).join('\n');
+  query.history = history.lines.join('\n');
   const {issues} = issuesData;
   // Add a summary of the issues to the query.
   query.highestCount = issues[4].length;

package/web/listIssues/listIssues.test.ts

@@ -58,17 +58,17 @@ test('listIssues returns an ok status with valid HTML for the mixed report', asy
 
 test('listIssues includes the page description in the HTML for the mixed report', async () => {
   const result = await answer('260101T0000/mix');
-  assert.ok(result.answerPage.includes('Mixed Outcomes Page'));
+  assert.ok(result.answerPage.includes('Mixed Outcomes'));
 });
 
 test('listIssues interpolates the page description into the AI prompt block quote', async () => {
   const result = await answer('260101T0000/mix');
   const html = parse(result.answerPage);
-  const blockQuote = html.querySelector('details blockquote');
+  const blockQuote = html.querySelector('blockquote');
   assert.ok(blockQuote);
-  assert.ok(
-    blockQuote.textContent.startsWith('Kilotest reports defects on the Mixed Outcomes Page web page.')
-  );
+  assert.ok(blockQuote.textContent.startsWith(
+    'Kilotest reports issues on the Mixed Outcomes web page.'
+  ));
   // No placeholder may remain uninterpolated.
   assert.ok(!blockQuote.textContent.includes('__target__'));
 });
@@ -153,7 +153,7 @@ test('listIssues returns an error when getPageDataStrings fails after getReport
 
 test('listIssues returns an error when report facts are not obtained', async () => {
   pageDataStringsOverride = {
-    what: 'Mixed Outcomes Page',
+    what: 'Mixed Outcomes',
     url: 'https://example.com/mixed',
     urlLink: '<a href="https://example.com/mixed">https://example.com/mixed</a>'
   };
@@ -231,7 +231,7 @@ test('listIssues History of an older report lists all reports, with this one unl
   assert.equal(items[0]!.href, null);
   assert.match(items[1]!.text, /^\d+ days? ago \(latest\)$/);
   assert.equal(items[1]!.href, '/listIssues.html/260202T0000/new');
-  assert.ok(!result.answerPage.includes('Should Kilotest retest the page?'));
+  assert.ok(!result.answerPage.includes('Request a retest'));
 });
 
 test('listIssues History of the latest report ends with the retest question', async () => {
@@ -244,7 +244,7 @@ test('listIssues History of the latest report ends with the retest question', as
   assert.match(items[1]!.text, /^\d+ days? ago \(latest; this report\)$/);
   assert.equal(items[1]!.href, null);
   const retestLink = history.querySelector('ol + p > a');
-  assert.equal(retestLink?.text, 'Should Kilotest retest the page?');
+  assert.equal(retestLink?.text, 'Request a retest');
   assert.equal(retestLink?.getAttribute('href'), '/requestRetestForm.html/260202T0000/new');
 });
 
@@ -253,7 +253,7 @@ test('listIssues History of the only report about a page says so and asks about
   const history = getHistory(result.answerPage);
   assert.equal(getHistoryItems(history).length, 0);
   const paragraphs = history.querySelectorAll('p');
-  assert.equal(paragraphs[0]?.text, 'This is the only report about the page.');
+  assert.equal(paragraphs[0]?.text, 'This is the only available report about the page.');
   assert.equal(paragraphs[1]?.querySelector('a')?.getAttribute('href'), '/requestRetestForm.html/260101T0001/ct');
 });
 

package/web/listPages/listPages.test.ts

@@ -58,7 +58,7 @@ test('listPages lists each of the 7 tested pages once, by description', async ()
       'All CantTell Page',
       'Branch Coverage Page',
       'Empty Results Page',
-      'Mixed Outcomes Page',
+      'Mixed Outcomes',
       'Multi Violator Page',
       'No Outcomes Page',
       'Prevented Page'
@@ -75,7 +75,7 @@ test('listPages introduces the list of tested pages', async () => {
 test('listPages links each page to the issues in its latest report', async () => {
   const result: any = await answer();
   const links = getPageLinks(result.answerPage);
-  const mixedLink = links.find(a => a.text === 'Mixed Outcomes Page');
+  const mixedLink = links.find(a => a.text === 'Mixed Outcomes');
   assert.equal(mixedLink?.getAttribute('href'), 'listIssues.html/260202T0000/new');
   const canttellLink = links.find(a => a.text === 'All CantTell Page');
   assert.equal(canttellLink?.getAttribute('href'), 'listIssues.html/260101T0001/ct');
@@ -107,7 +107,7 @@ test('listPages shows requests when testRequests.json has entries', {timeout: 50
   try {
     const testRequests = {
       'https://example.com/mixed': [
-        {description: 'Mixed Outcomes Page', reason: 'Needs retesting for accessibility'}
+        {description: 'Mixed Outcomes', reason: 'Needs retesting for accessibility'}
       ]
     };
     await fs.writeFile(testRequestsPath, JSON.stringify(testRequests, null, 2));
@@ -149,12 +149,12 @@ test('listPages shows queued and claimed jobs when they exist', async () => {
   }
 });
 
-test('listPages lists a page whose report is not usable', {timeout: 500}, async () => {
+test('listPages omits a page whose report is not usable', {timeout: 500}, async () => {
   const dbDir = (await import('../../test/dbFixture.ts')).fixtureDBDir;
   const reportsDir = path.join(dbDir, 'reports');
   const invalidReportPath = path.join(reportsDir, '260101T9999-bad.json');
   try {
-    // Valid for getReportExtract (has target and jobData.endTime) but not usable by isUsableReport (no acts or catalog).
+    // Not usable by isUsableReport (no acts or catalog), so it must not be exposed.
     const invalidReport = {
       target: {what: 'Invalid Report', url: 'https://example.com/invalid'},
       jobData: {endTime: '26-01-01T00:10'}
@@ -163,7 +163,7 @@ test('listPages lists a page whose report is not usable', {timeout: 500}, async
     const result: any = await answer();
     assert.equal(result.status, 'ok');
     const links = getPageLinks(result.answerPage);
-    assert.ok(links.some(a => a.text === 'Invalid Report'));
+    assert.ok(!links.some(a => a.text === 'Invalid Report'));
   }
   finally {
     await fs.unlink(invalidReportPath).catch(() => {});

package/web/listTopIssues/listTopIssues.test.ts

@@ -5,12 +5,31 @@
 
 // IMPORTS
 
-import {test, before, after} from 'node:test';
+import {test, before, after, mock} from 'node:test';
 import assert from 'node:assert/strict';
 import path from 'node:path';
 import fs from 'node:fs/promises';
 import {parse} from 'node-html-parser';
-import {answer} from './index.ts';
+
+// Mock the util functions called by index.ts before importing it, so that
+// it imports the mocked versions. Other exports delegate to the real module.
+import * as realUtil from '../../util.ts';
+let getReportCallCount = 0;
+let failGetReportOnCall = -1;
+mock.module('../../util.ts', {
+  exports: {
+    ...realUtil,
+    getReport: async (...args: any[]) => {
+      getReportCallCount++;
+      if (getReportCallCount === failGetReportOnCall) {
+        return {error: 'Report is invalid (test override)'};
+      }
+      return (realUtil.getReport as any)(...args);
+    }
+  }
+} as any);
+
+const {answer} = await import('./index.ts') as any;
 
 // SETUP AND TEARDOWN
 
@@ -54,23 +73,36 @@ test('listTopIssues excludes cantTell instances from issue counts', async () =>
   assert.ok(!result.answerPage.includes('focus indication poor'));
 });
 
-test('listTopIssues returns an error when a report file is invalid', async () => {
+test('listTopIssues omits a report that is not usable', async () => {
   const dbDir = (await import('../../test/dbFixture.ts')).fixtureDBDir;
   const reportsDir = path.join(dbDir, 'reports');
   const invalidReportPath = path.join(reportsDir, '260101T9999-bad.json');
   try {
-    // Valid for getReportExtract (has target and jobData.endTime) but not usable by isUsableReport (no acts or catalog).
+    // Not usable by isUsableReport (no acts or catalog), so it produces no extract
+    // and contributes nothing to the summary.
     const invalidReport = {
       target: {what: 'Invalid TopIssues Report', url: 'https://example.com/invalidtop'},
       jobData: {endTime: '26-01-01T00:10'}
     };
     await fs.writeFile(invalidReportPath, JSON.stringify(invalidReport, null, 2));
+    const result: any = await answer();
+    assert.equal(result.status, 'ok');
+  }
+  finally {
+    await fs.unlink(invalidReportPath).catch(() => {});
+  }
+});
+
+test('listTopIssues returns an error when a report read fails', async () => {
+  getReportCallCount = 0;
+  failGetReportOnCall = 1;
+  try {
     const result: any = await answer();
     assert.equal(result.status, 'error');
     assert.ok(result.message);
   }
   finally {
-    await fs.unlink(invalidReportPath).catch(() => {});
+    failGetReportOnCall = -1;
   }
 });
 

package/web/listViolators/listViolators.test.ts

@@ -188,7 +188,7 @@ test('listViolators includes take-me-there links for text-linkable violators', a
 
 test('listViolators returns an error when report facts are not obtained', async () => {
   pageDataStringsOverride = {
-    what: 'Mixed Outcomes Page',
+    what: 'Mixed Outcomes',
     url: 'https://example.com/mixed',
     urlLink: '<a href="https://example.com/mixed">https://example.com/mixed</a>'
   };

package/web/reannotate/reannotate.test.ts

@@ -90,8 +90,8 @@ test('answer returns an error when a report fails annotation', {timeout: 2000},
   // Back up all fixture reports, because reannotation modifies good reports
   // in place before it reaches the bad one and returns an error.
   const backups = await backupReports();
-  // Create a temporary report file that passes getReportExtract but fails
-  // getReport validation (acts is not an array).
+  // Create a temporary report file that fails getReport validation
+  // (acts is not an array). It is too fresh to be quarantined, so it stays put.
   const badReportName = '990101T0000-bad.json';
   const badReportPath = path.join(reportsDir, badReportName);
   const badReport = {

package/web/reannotateForm/reannotateForm.test.ts

@@ -6,13 +6,31 @@
 
 // IMPORTS
 
-import {test, before, after, beforeEach} from 'node:test';
+import {test, before, after, beforeEach, mock} from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import {parse} from 'node-html-parser';
 
+// Mock the util functions called by index.ts before it is ever imported, so that
+// it imports the mocked versions. Other exports delegate to the real module.
+import * as realUtil from '../../util.ts';
+let getReportCallCount = 0;
+let failGetReportOnCall = -1;
+mock.module('../../util.ts', {
+  exports: {
+    ...realUtil,
+    getReport: async (...args: any[]) => {
+      getReportCallCount++;
+      if (getReportCallCount === failGetReportOnCall) {
+        return {error: 'Report is invalid (test override)'};
+      }
+      return (realUtil.getReport as any)(...args);
+    }
+  }
+} as any);
+
 // CONSTANTS
 
 import {fixtureDBDir} from '../../test/dbFixture.ts';
@@ -101,9 +119,9 @@ test('answer returns ok with no-reclassified message when reports have no violat
   }
 });
 
-test('answer returns an error when a report fails to load', async () => {
-  // Create a temporary report file that passes getReportExtract but fails
-  // getReport validation (acts is not an array).
+test('answer ignores a report that is not usable', async () => {
+  // A report that fails getReport validation (acts is not an array) produces no
+  // extract, so it is ignored rather than causing an error.
   const badReportName = '990101T0000-bad.json';
   const badReportPath = path.join(reportsDir, badReportName);
   const badReport = {
@@ -117,8 +135,7 @@ test('answer returns an error when a report fails to load', async () => {
   try {
     const {answer} = await import('./index.ts');
     const result = await answer();
-    assert.equal(result.status, 'error');
-    assert.ok(result.message.includes('not usable'), `Expected message about unusable report, got: ${result.message}`);
+    assert.equal(result.status, 'ok');
   }
   finally {
     try {
@@ -129,3 +146,17 @@ test('answer returns an error when a report fails to load', async () => {
     }
   }
 });
+
+test('answer returns an error when a report read fails', async () => {
+  getReportCallCount = 0;
+  failGetReportOnCall = 1;
+  try {
+    const {answer} = await import('./index.ts');
+    const result = await answer();
+    assert.equal(result.status, 'error');
+    assert.ok(result.message);
+  }
+  finally {
+    failGetReportOnCall = -1;
+  }
+});

package/web/requestNewTest/requestNewTest.test.ts

@@ -123,7 +123,7 @@ test('answer returns an error when a report already exists for the page', {timeo
   const {answer} = await import('./index.ts');
   // The fixture database already has a report for this description and URL.
   const result: any = await answer(
-    'Mixed Outcomes Page', 'https://example.com/mixed', 'Because accessibility'
+    'Mixed Outcomes', 'https://example.com/mixed', 'Because accessibility'
   );
   assert.equal(result.status, 'error');
   assert.equal(result.message, 'A report about a page with the same description or URL is already available');

package/web/requestRetest/requestRetest.test.ts

@@ -102,7 +102,7 @@ test('answer returns an error for a duplicate retest request', async () => {
 
 test('answer returns an error when the cited report has been superseded', async () => {
   const {answer} = await import('./index.ts');
-  // 260101T0000-mix (Mixed Outcomes Page) is superseded by 260202T0000-new.
+  // 260101T0000-mix (Mixed Outcomes) is superseded by 260202T0000-new.
   const result: any = await answer('260101T0000/mix', 'Because changes were made');
   assert.equal(result.status, 'error');
   assert.equal(result.message, 'A later report about the page is already available');
@@ -141,4 +141,3 @@ test('answer returns an error with a fallback channel when the request queue is
   assert.ok(result.message.includes('https://github.com/jrpool/kilotest/issues'));
   assert.ok(result.message.includes('info@kilotest.com'));
 });
-

package/web/requestRetestForm/requestRetestForm.test.ts

@@ -35,7 +35,7 @@ test('requestRetestForm returns ok with the page name for a valid report', async
   assert.ok(result.answerPage);
   const html = parse(result.answerPage);
   const title = html.querySelector('title')?.text;
-  assert.ok(title?.includes('Mixed Outcomes Page'));
+  assert.ok(title?.includes('Mixed Outcomes'));
 });
 
 test('requestRetestForm populates the form action with the timeStamp and jobID', async () => {

package/web/util.test.ts

@@ -129,7 +129,7 @@ const getFixtureReport = async (timeStamp: string, jobID: string) => {
 
 test('getPageData returns page data for a valid report', async () => {
   const data = getPageData(await getFixtureReport('260101T0000', 'mix'));
-  assert.equal(data.description, 'Mixed Outcomes Page');
+  assert.equal(data.description, 'Mixed Outcomes');
   assert.equal(data.url, 'https://example.com/mixed');
   assert.equal(typeof data.daysAgo, 'number');
 });
@@ -141,7 +141,7 @@ test('getReport returns an error for a nonexistent report', async () => {
 
 test('getPageDataStrings returns HTML strings for a valid report', async () => {
   const strings = getPageDataStrings(await getFixtureReport('260101T0000', 'mix'));
-  assert.equal(strings.description, 'Mixed Outcomes Page');
+  assert.equal(strings.description, 'Mixed Outcomes');
   assert.equal(strings.url, 'https://example.com/mixed');
   assert.equal(strings.urlLink, '<a href="https://example.com/mixed">https://example.com/mixed</a>');
   assert.ok(strings.testInfo.includes('by job <code>260101T0000-mix</code>'));