@jrpool/kilotest 58.2.0 → 59.0.0

package/util.test.ts

@@ -38,6 +38,7 @@ import {
   getObject,
   getPlainText,
   getRandomString,
+  getReportEndTime,
   getReportExtract,
   getReportExtracts,
   getReportPath,
@@ -1276,7 +1277,7 @@ test('getIssue returns null for a known engine with an unknown variable rule', (
 });
 
 test('getIssue returns an issue ID for a variable rule pattern match', () => {
-  const result = getIssue('nuVal', 'Duplicate attribute foo');
+  const result = getIssue('nuVal', 'Duplicate attribute foo.');
   assert.ok(typeof result === 'string');
   assert.equal(result, 'duplicateAttribute');
 });
@@ -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);
 });
@@ -1451,6 +1460,56 @@ test('getReportExtracts with onlyLatest returns only the latest report for each
   assert.equal(mixReports[0]!.timeStamp, '260202T0000');
 });
 
+test('getReportExtracts reflects reports added, modified, and removed after a previous call', async () => {
+  const os = await import('node:os');
+  const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kilotest-extracts-'));
+  const tmpReportsDir = path.join(tmpRoot, 'db', 'reports');
+  const savedDbDir = process.env.DB_DIR;
+  const sourcePath = path.join(reportsPath(), '260101T0000-mix.json');
+  process.env.DB_DIR = path.join(tmpRoot, 'db');
+  try {
+    await fs.mkdir(tmpReportsDir, {recursive: true});
+    const report = JSON.parse(await fs.readFile(sourcePath, 'utf8'));
+    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']);
+    // 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));
+    const later = new Date(Date.now() + 60000);
+    await fs.utimes(firstPath, later, later);
+    extracts = await getReportExtracts();
+    assert.deepEqual(extracts.map(e => e.description), ['Revised Page']);
+    // Add a report.
+    report.target.what = 'Added Page';
+    const secondPath = path.join(tmpReportsDir, '260101T0001-bbb.json');
+    await fs.writeFile(secondPath, JSON.stringify(report));
+    extracts = await getReportExtracts();
+    assert.deepEqual(extracts.map(e => e.description), ['Added Page', 'Revised Page']);
+    // Mutating a returned extract does not affect later results.
+    extracts[0]!.superseded = true;
+    extracts = await getReportExtracts();
+    assert.equal(extracts[0]!.superseded, undefined);
+    // Make a cached report unreadable.
+    await fs.writeFile(secondPath, 'not JSON');
+    extracts = await getReportExtracts();
+    assert.deepEqual(extracts.map(e => e.description), ['Revised Page']);
+    // Restore it.
+    await fs.writeFile(secondPath, JSON.stringify(report));
+    extracts = await getReportExtracts();
+    assert.deepEqual(extracts.map(e => e.description), ['Added Page', 'Revised Page']);
+    // Remove a report, as hiding would.
+    await fs.rm(firstPath);
+    extracts = await getReportExtracts();
+    assert.deepEqual(extracts.map(e => e.description), ['Added Page']);
+  }
+  finally {
+    process.env.DB_DIR = savedDbDir;
+    await fs.rm(tmpRoot, {recursive: true}).catch(() => {});
+  }
+});
+
 test('getExclusionCookieValue is deterministic for a given AUTH_CODE', async () => {
   const savedAuthCode = process.env.AUTH_CODE;
   process.env.AUTH_CODE = 'test-auth-code';
@@ -1522,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 {
@@ -1577,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;
@@ -1636,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: {}
   }));
@@ -1648,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 {

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 {
@@ -793,20 +798,58 @@ export const getReportExtract = async (timeStamp: string, jobID: string): Promis
     };
   }
 };
+// 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
+// is unchanged. Reports are mutable (e.g., reannotation rewrites all of them) and may be
+// 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.
 export const getReportExtracts = async (onlyLatest: boolean = false): Promise<ReportExtract[]> => {
-  // Get the names of the available report files.
-  const reportFileNames = await readdirOrCreate(reportsPath(), 'Reports directory');
+  const reportsDir = reportsPath();
+  // Get the names and paths of the available report files.
+  const reportFileNames = await readdirOrCreate(reportsDir, 'Reports directory');
+  const reportFilePaths = reportFileNames.map(fileName => path.join(reportsDir, fileName));
+  const reportFilePathSet = new Set(reportFilePaths);
+  // Remove from the cache any report that is no longer available (e.g., hidden or deleted).
+  for (const cachedPath of reportExtractCache.keys()) {
+    if (!reportFilePathSet.has(cachedPath)) {
+      reportExtractCache.delete(cachedPath);
+    }
+  }
+  // Get the current modification times and sizes of the report files. A file that disappeared
+  // after the directory was read gets values that match no cache entry, so it is reread, which
+  // fails and removes it from the cache.
+  const reportStats = await Promise.all(
+    reportFilePaths.map(filePath => fs.stat(filePath).catch(() => ({mtimeMs: NaN, size: NaN})))
+  );
   // Initialize an array of extracts.
   const extracts: ReportExtract[] = [];
-  // For each one:
-  for (const reportFileName of reportFileNames) {
+  // For each report file:
+  for (const [index, reportFileName] of reportFileNames.entries()) {
+    const filePath = reportFilePaths[index]!;
+    const stat = reportStats[index]!;
+    const cached = reportExtractCache.get(filePath);
+    // If its cached extract is current:
+    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+      // Add a copy of the cached extract to the array.
+      extracts.push({...cached.extract});
+      continue;
+    }
+    // Otherwise, get a new extract of it. The stat precedes the read, so a change between
+    // them leaves a stale modification time in the cache and causes a reread next time.
     const [timeStamp, jobID] = reportFileName.slice(0, -5).split('-') as [string, string];
-    // Get an extract of it.
     const extract = await getReportExtract(timeStamp, jobID);
+    // If this succeeded:
     if (!('error' in extract)) {
-      // Add the extract to the array.
-      extracts.push(extract);
+      // Cache it and add a copy of it to the array.
+      reportExtractCache.set(filePath, {mtimeMs: stat.mtimeMs, size: stat.size, extract});
+      extracts.push({...extract});
+    }
+    // Otherwise, i.e. if it failed:
+    else {
+      // Forget any outdated extract of it.
+      reportExtractCache.delete(filePath);
     }
   }
   // Sort the extracts by page description and, secondarily, completion time.
@@ -823,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/listIssues/index.html

@@ -25,7 +25,8 @@
         <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>

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

@@ -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>

package/web/listPages/index.ts

@@ -0,0 +1,99 @@
+/*
+  index.ts
+  Lists all tested pages, with links to the latest reports about them.
+*/
+
+// IMPORTS
+
+import {
+  getJobNames,
+  getObject,
+  getReportExtracts,
+  getTestRequests,
+  jobsPath,
+  populateTemplate
+} from '../../util.ts';
+import path from 'node:path';
+
+// FUNCTIONS
+
+// Adds parameters to a query for the answer page.
+const populateQuery = async (query: Record<string, any>) => {
+  const margin = ' '.repeat(8);
+  // Initialize the classes of lines.
+  const lines: {requests: string[], queue: string[], claimed: string[], tested: string[]} = {
+    requests: [],
+    queue: [],
+    claimed: [],
+    tested: []
+  };
+  // Get the test requests.
+  const testRequests = await getTestRequests();
+  // For each requested URL:
+  Object.keys(testRequests).forEach(url => {
+    // For each of its requests:
+    testRequests[url]!.forEach((req: any) => {
+      const {description, reason} = req;
+      // Add a line.
+      lines.requests.push(`${margin}<li><code>${url}</code> (${description}): ${reason}</li>`);
+    });
+  });
+  // Sort the lines in alphabetical order by URL and secondarily by proposed name.
+  lines.requests.sort();
+  // Add the lines to the query.
+  query.requests = lines.requests.join('\n');
+  // Add a no-requests message, if applicable, to the query.
+  query.noRequests = lines.requests.length
+  ? 'Kilotest managers can <a href="enqueueForm.html">approve or reject a request</a>.'
+  : 'No requests await approval now.';
+  // Get the file names of all queued and claimed jobs.
+  const jobFileNames = await getJobNames();
+  // For each job category:
+  for (const category of ['queue', 'claimed'] as const) {
+    // For each job in the category:
+    for (const fileName of jobFileNames[category]) {
+      // Get the job.
+      const job = await getObject(path.join(jobsPath(), category, fileName)) as {target: {url: string, what: string}};
+      // Add a line.
+      lines[category].push(`${margin}<li><code>${job.target.url}</code> (${job.target.what})</li>`);
+    }
+    // Add the lines to the query.
+    query[category] = lines[category].join('\n');
+  }
+  // Add a no-queued message, if applicable, to the query.
+  query.noQueued = lines.queue.length ? '' : 'No pages are queued for testing.';
+  // Add a no-claimed message, if applicable, to the query.
+  query.noClaimed = lines.claimed.length ? '' : 'No pages are being tested now.';
+  // Get extracts of the latest reports about all tested pages, sorted by page description.
+  const latestExtracts = await getReportExtracts(true);
+  const pageCount = latestExtracts.length;
+  // For each tested page:
+  for (const extract of latestExtracts) {
+    const {jobID, timeStamp, description} = extract;
+    // Add a link to the issues in the latest report about it to the lines.
+    const link = `<a href="listIssues.html/${timeStamp}/${jobID}" aria-label="Get test results for ${description}">${description}</a>`;
+    lines.tested.push(`${margin}  <li>${link}</li>`);
+  }
+  // Add the lines to the query, as an introduced list if there are any, or else a no-pages message.
+  query.testedPages = pageCount
+  ? [
+    `${margin}<p>Get test results for:</p>`,
+    `${margin}<ul class="links">`,
+    ...lines.tested,
+    `${margin}</ul>`
+  ].join('\n')
+  : `${margin}<p>No pages have been tested yet.</p>`;
+};
+// Returns a page listing the tested pages.
+export const answer = async () => {
+  const query: Record<string, any> = {};
+  // Create a query to replace placeholders.
+  await populateQuery(query);
+  // Get the populated template.
+  const answerPage = await populateTemplate(import.meta.dirname, query);
+  // Return the populated page.
+  return {
+    status: 'ok',
+    answerPage
+  };
+};