@jrpool/kilotest 58.2.4 → 59.0.2

package/util.test.ts

@@ -38,6 +38,7 @@ import {
   getObject,
   getPlainText,
   getRandomString,
+  getReportEndTime,
   getReportExtract,
   getReportExtracts,
   getReportPath,
@@ -768,14 +769,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');
 });
@@ -907,7 +908,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);
 });
 
@@ -1408,10 +1409,18 @@ test('getReportPath returns the path of a report file', () => {
   assert.ok(result.endsWith('260101T0000-mix.json'));
 });
 
-test('getReportStats returns reportTime and reportSize for a valid report', async () => {
+test('getReportEndTime returns the completion time of a report', () => {
+  const endTime = getReportEndTime({jobData: {endTime: '26-03-04T05:06'}});
+  assert.equal(endTime.toISOString(), '2026-03-04T05:06:00.000Z');
+});
+
+test('getReportEndTime returns an invalid date for a report with no completion time', () => {
+  assert.ok(isNaN(getReportEndTime({}).getTime()));
+});
+
+test('getReportStats returns reportSize for a valid report', async () => {
   const stats = await getReportStats('260101T0000', 'mix');
   assert.ok(stats);
-  assert.ok(stats.reportTime instanceof Date);
   assert.equal(typeof stats.reportSize, 'number');
   assert.ok(stats.reportSize > 0);
 });
@@ -1426,7 +1435,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);
 });
@@ -1446,7 +1455,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');
 });
@@ -1464,7 +1473,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));
@@ -1572,11 +1581,11 @@ test('recordMetric increments an existing count rather than overwriting it', asy
   process.env.DB_DIR = tmpDir;
   try {
     const {recordMetric, metricsPath} = await import('./util.ts');
-    await recordMetric('mcpToolCalls', 'listReports');
-    await recordMetric('mcpToolCalls', 'listReports');
+    await recordMetric('mcpToolCalls', 'listPages');
+    await recordMetric('mcpToolCalls', 'listPages');
     await recordMetric('mcpToolCalls', 'getReport');
     const metrics = JSON.parse(fsSync.readFileSync(metricsPath(), 'utf8'));
-    assert.equal(metrics.mcpToolCalls.listReports, 2);
+    assert.equal(metrics.mcpToolCalls.listPages, 2);
     assert.equal(metrics.mcpToolCalls.getReport, 1);
   }
   finally {
@@ -1627,11 +1636,11 @@ test('recordMetric keeps categories independent for the same name', async () =>
   process.env.DB_DIR = tmpDir;
   try {
     const {recordMetric, metricsPath} = await import('./util.ts');
-    await recordMetric('apiOperations', 'listReports');
-    await recordMetric('mcpToolCalls', 'listReports');
+    await recordMetric('apiOperations', 'listPages');
+    await recordMetric('mcpToolCalls', 'listPages');
     const metrics = JSON.parse(fsSync.readFileSync(metricsPath(), 'utf8'));
-    assert.equal(metrics.apiOperations.listReports, 1);
-    assert.equal(metrics.mcpToolCalls.listReports, 1);
+    assert.equal(metrics.apiOperations.listPages, 1);
+    assert.equal(metrics.mcpToolCalls.listPages, 1);
   }
   finally {
     process.env.DB_DIR = savedDbDir;
@@ -1686,7 +1695,7 @@ test('getMetrics backfills categories missing from a metrics.json written before
   // Simulate a metrics.json written before the managerActivity category was added.
   fsSync.writeFileSync(tmpDir + '/metrics.json', JSON.stringify({
     since: '260101T0000',
-    pageViews: {listReports: 1},
+    pageViews: {listPages: 1},
     mcpToolCalls: {},
     apiOperations: {}
   }));
@@ -1698,7 +1707,7 @@ test('getMetrics backfills categories missing from a metrics.json written before
     await recordMetric('managerActivity', 'metrics', 'ok');
     const metrics = JSON.parse(fsSync.readFileSync(metricsPath(), 'utf8'));
     assert.equal(metrics.since, '260101T0000');
-    assert.equal(metrics.pageViews.listReports, 1);
+    assert.equal(metrics.pageViews.listPages, 1);
     assert.deepEqual(metrics.managerActivity.metrics, {ok: 1, error: 0});
   }
   finally {
@@ -1759,14 +1768,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');
 });
@@ -1832,7 +1841,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'
@@ -1845,12 +1854,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

@@ -689,7 +689,7 @@ export const isUsableReport = (report: unknown): report is UsableReport => {
   )
   && typeof r.jobData === 'object'
   && r.jobData.endTime
-  && !isNaN(new Date(`20${r.jobData.endTime}Z`).getTime())
+  && !isNaN(getReportEndTime(r).getTime())
   && typeof r.catalog === 'object';
 };
 // Returns a report.
@@ -754,7 +754,7 @@ export const annotateReportObject = async (report: UsableReport): Promise<void>
     );
   }
 };
-// Returns the creation time and size of a report.
+// Returns the size of a report, or null if the report does not exist.
 export const getReportStats = async (timeStamp: string, jobID: string) => {
   let reportStat;
   try {
@@ -763,10 +763,15 @@ export const getReportStats = async (timeStamp: string, jobID: string) => {
   catch {
     return null;
   }
-  const reportTime = reportStat.birthtime;
   const reportSize = reportStat.size;
-  return {reportTime, reportSize};
+  return {reportSize};
 };
+// Returns the completion time of a report. This, not the time stamp in the job ID nor the
+// file system time of the report file, is the time of a report. The date is invalid if the
+// report has no valid completion time.
+export const getReportEndTime = (report: {jobData?: {endTime?: string}}): Date => new Date(
+  `20${report.jobData?.endTime}Z`
+);
 
 // Returns an extract of an available report, or an error object if it cannot be read or parsed.
 export const getReportExtract = async (timeStamp: string, jobID: string): Promise<ReportExtract | {error: string}> => {
@@ -784,7 +789,7 @@ export const getReportExtract = async (timeStamp: string, jobID: string): Promis
       jobID,
       description,
       url,
-      reportTime: new Date(`20${jobData.endTime}Z`).toISOString()
+      reportTime: getReportEndTime({jobData}).toISOString()
     };
   }
   catch {
@@ -861,6 +866,12 @@ 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.
+export const getPageReportExtracts = async (description: string): Promise<ReportExtract[]> => {
+  const reportExtracts = await getReportExtracts();
+  return reportExtracts.filter(extract => extract.description === description);
+};
 // Returns whether a report with a description or URL is available.
 export const isReportAvailable = async (description: string, url: string): Promise<boolean> => {
   const reportExtracts = await getReportExtracts();

package/web/enqueueForm/index.html

@@ -14,7 +14,7 @@
     <main>
       <h1><a href="/">Kilotest</a>: Request approval or rejection</h1>
       <p>To approve a test or retest request, check its requested page name.</p>
-      <p>To approve testing a page that has not yet been requested, first <a href="listReports.html">request it</a>.</p>
+      <p>To approve testing a page that has not yet been requested, first <a href="listPages.html">request it</a>.</p>
       <p>To reject all requests for a page, check the radio button of its URL.</p>
       <form action="/requestAction.html" method="post">
         <fieldset>

package/web/hideReportForm/hideReportForm.test.ts

@@ -53,6 +53,11 @@ test('hideReportForm displays a list of reports on a GET request', async () => {
   assert.ok(radios.length > 0);
 });
 
+test('hideReportForm describes each report by its completion time', async () => {
+  const result: any = await answer(null, '', 'GET');
+  assert.ok(result.answerPage.includes('(job <code>260202T0000-new</code> completed 2026-02-02 at 00:10)'));
+});
+
 test('hideReportForm ignores a report query string on a GET request', async () => {
   const reportPath = path.join(reportsPath(), '260101T0009-brd.json');
   const hiddenPath = path.join(hiddenReportsPath(), '260101T0009-brd.json');

package/web/hideReportForm/index.ts

@@ -8,6 +8,7 @@
 import {
   getReportExtracts, hiddenReportsPath, isValidAuthCode, populateTemplate, reportsPath
 } from '../../util.ts';
+import {getDateTimeString} from '../util.ts';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
@@ -54,18 +55,19 @@ export const answer = async (_: any, search: string, method: string) => {
   const reportExtracts = await getReportExtracts();
   // For each report:
   for (const reportExtract of reportExtracts) {
-    const {jobID, timeStamp, description} = reportExtract;
+    const {jobID, timeStamp, description, reportTime} = reportExtract;
     // Add the report to the array.
     reportSpecs.push({
       description,
       timeStamp,
-      jobID
+      jobID,
+      reportTime
     });
   }
-  // Sort the data by page name and then by time stamp.
+  // Sort the data by page name and then by completion time.
   reportSpecs.sort((a, b) => {
     if (a.description === b.description) {
-      return a.timeStamp.localeCompare(b.timeStamp);
+      return a.reportTime.localeCompare(b.reportTime);
     }
     return a.description.localeCompare(b.description);
   });
@@ -73,8 +75,9 @@ export const answer = async (_: any, search: string, method: string) => {
   const margin = ' '.repeat(12);
   // For each available report:
   reportSpecs.forEach(spec => {
-    const {jobID, timeStamp, description} = spec;
-    const specString = `${description} (job <code>${jobID}</code> at ${timeStamp})`;
+    const {jobID, timeStamp, description, reportTime} = spec;
+    const when = getDateTimeString(new Date(reportTime));
+    const specString = `${description} (job <code>${timeStamp}-${jobID}</code> completed ${when})`;
     // Add a line with a radio button to hide it.
     lines.push(
       `${margin}<p><input type="radio" name="report" value="${timeStamp}-${jobID}"> ${specString}</p>`

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}

@@ -87,10 +87,10 @@
       </details>
       <h2>What do you want to know?</h2>
       <ul class="nav">
-        <li><a href="listReports.html">Which web pages have been tested?</a></li>
+        <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

@@ -15,17 +15,9 @@
       <h1><a href="/">Kilotest</a>: Issues reported for __target__</h1>
 
       <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__
-      <p><a href="/requestRetestForm.html/__timeStamp__/__jobID__">Should Kilotest retest the page?</a></p>
+      <h2>History</h2>
+__history__
       <h2>Issues reported</h2>
       <details>
         <summary>Highest priority: __highestCount__</summary>
@@ -51,6 +43,13 @@ __pageFacts__
           __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

@@ -6,6 +6,7 @@
 // IMPORTS
 
 import {
+  getPageReportExtracts,
   getReport,
   getTestActInstances,
   isReportError,
@@ -14,6 +15,7 @@ import {
 } from '../../util.ts';
 import type {UsableReport} from '../../util.ts';
 import {
+  getAgoString,
   getIssueFactsLines,
   getPageDataStrings,
   getPageFactsLines,
@@ -121,6 +123,47 @@ 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[]> => {
+  // 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:
+  pageExtracts.forEach((extract, index) => {
+    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' : '',
+      isThis ? 'this report' : ''
+    ]
+    .filter(tag => tag);
+    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>`);
+  });
+  // 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:
+  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>`);
+  }
+  // Return the lines.
+  return lines;
+};
 // Adds parameters to a query for the answer page.
 const populateQuery = async (timeStamp: string, jobID: string, query: Record<string, any>) => {
   // Get the report.
@@ -150,10 +193,9 @@ const populateQuery = async (timeStamp: string, jobID: string, query: Record<str
   const margin = ' '.repeat(6);
   // 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');
   const {issues} = issuesData;
-  // Add report data to the query.
-  query.timeStamp = timeStamp;
-  query.jobID = jobID;
   // Add a summary of the issues to the query.
   query.highestCount = issues[4].length;
   query.highCount = issues[3].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>'
   };
@@ -205,3 +205,79 @@ test('listIssues handles acts with no standardResult instances', async () => {
     await fs.unlink(reportPath).catch(() => {});
   }
 });
+
+// Returns the History section of a listIssues page, from its heading to the next heading.
+const getHistory = (answerPage: string) => {
+  const start = answerPage.indexOf('<h2>History</h2>');
+  const end = answerPage.indexOf('<h2>Issues reported</h2>');
+  assert.ok(start > -1 && end > start, 'History section exists before the issues');
+  return parse(answerPage.slice(start, end));
+};
+
+// Returns the text, and the link destination if any, of each item in a History list.
+const getHistoryItems = (history: ReturnType<typeof parse>) => history
+.querySelectorAll('ol > li')
+.map(li => ({
+  text: li.text.trim(),
+  href: li.querySelector('a')?.getAttribute('href') ?? null
+}));
+
+test('listIssues History of an older report lists all reports, with this one unlinked and no retest question', async () => {
+  const result = await answer('260101T0000/mix');
+  const history = getHistory(result.answerPage);
+  const items = getHistoryItems(history);
+  assert.equal(items.length, 2);
+  assert.match(items[0]!.text, /^\d+ days? ago \(oldest; this report\)$/);
+  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?'));
+});
+
+test('listIssues History of the latest report ends with the retest question', async () => {
+  const result = await answer('260202T0000/new');
+  const history = getHistory(result.answerPage);
+  const items = getHistoryItems(history);
+  assert.equal(items.length, 2);
+  assert.match(items[0]!.text, /^\d+ days? ago \(oldest\)$/);
+  assert.equal(items[0]!.href, '/listIssues.html/260101T0000/mix');
+  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?.getAttribute('href'), '/requestRetestForm.html/260202T0000/new');
+});
+
+test('listIssues History of the only report about a page says so and asks about retesting', async () => {
+  const result = await answer('260101T0001/ct');
+  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[1]?.querySelector('a')?.getAttribute('href'), '/requestRetestForm.html/260101T0001/ct');
+});
+
+test('listIssues History tags only the ends of a list of 3 reports and the current report', async () => {
+  const fs = await import('node:fs/promises');
+  const mixJSON = await fs.readFile(path.join(realUtil.reportsPath(), '260101T0000-mix.json'), 'utf8');
+  const report = JSON.parse(mixJSON);
+  report.jobData.endTime = '26-01-15T00:10';
+  const reportPath = path.join(realUtil.reportsPath(), '260115T0000-mid.json');
+  await fs.writeFile(reportPath, JSON.stringify(report));
+  try {
+    // From the middle report:
+    let items = getHistoryItems(getHistory((await answer('260115T0000/mid')).answerPage));
+    assert.equal(items.length, 3);
+    assert.match(items[0]!.text, /\(oldest\)$/);
+    assert.match(items[1]!.text, /^\d+ days? ago \(this report\)$/);
+    assert.equal(items[1]!.href, null);
+    assert.match(items[2]!.text, /\(latest\)$/);
+    // From the latest report:
+    items = getHistoryItems(getHistory((await answer('260202T0000/new')).answerPage));
+    assert.match(items[1]!.text, /^\d+ days? ago$/);
+    assert.equal(items[1]!.href, '/listIssues.html/260115T0000/mid');
+  }
+  finally {
+    await fs.unlink(reportPath);
+  }
+});

package/web/{listReports → listPages}/index.html

@@ -30,8 +30,7 @@
       </ul>
       <p>__noClaimed__</p>
       <h2>Already tested</h2>
-      <p>Kilotest has tested __which__ pages.</p>
-      __testedPages__
+__testedPages__
     </main>
   </body>
 </html>