@jrpool/kilotest 52.0.0 → 57.0.1

package/capability.md

@@ -2,11 +2,11 @@
 
 ## Capability
 
-Web-page front-end quality audit. Kilotest tests public web pages for front-end quality, namely accessibility, usability, and standards conformity, and makes structured findings available for retrieval.
+Web-page front-end quality audit. Kilotest tests web pages for front-end quality, namely accessibility, usability, and standards conformity, and makes structured findings available for retrieval.
 
 ## Purpose
 
-Language models and AI platforms often need accurate, page-specific data about the front-end quality of a web page to answer user questions. Rule engines, such as `axe-core`, `QualWeb`, and `WAVE`, provide such data, but with large coverage gaps. Orchestrating and reconciling numerous complementary rule engines would be difficult. Kilotest solves that problem by testing pages with an ensemble of numerous independent rule engines, making their results comparable, saving the results as JSON reports, mining the reports for facts at selectable levels of detail.
+Language models and AI platforms often need accurate, page-specific data about the front-end quality of a web page to answer user questions. Rule engines, such as `axe-core`, `QualWeb`, and `WAVE`, provide such data, but with large coverage gaps. Orchestrating and reconciling numerous complementary rule engines would be difficult. Kilotest solves that problem by testing pages with an ensemble of numerous independent rule engines, making their results comparable, saving the results as JSON reports, and mining the reports for facts at selectable levels of detail.
 
 ## Interfaces
 
@@ -26,17 +26,20 @@ A list of available reports.
 
 ## Subsequent inputs
 
-- If there is no report about the wanted page, a request to test it, with a page description and its URL.
-- If there is a report about the wanted page, requests for findings from the report at successive levels of detail.
+- If there is no report about the wanted page, a request or order for a new test, with a page description, its URL, and a reason for testing it.
+- If there is already a report about the wanted page, requests for findings from the report at successive levels of detail, or, if the report is deemed obsolete, a request or order for a retest, with a reason for retesting it.
+- Complaints and suggestions about features of Kilotest.
 
 ## Subsequent outputs
 
-- From a request to test a page: confirmation of receipt. Upon approval and execution, the list of available reports will include the new report.
+- From a **request** for a new test or a retest: if valid, confirmation of receipt. If the request is manager-approved and executed, the list of available reports will include the new report, typically in 1 hour to 1 day.
+- From an **order** for a new test or a retest: if valid, confirmation of receipt and immediate approval or rejection. If the request is approved, the output will include the identifier of the forthcoming report and two methods for getting the report: (1) allowing time (2 to 4 minutes) for completion of the report and then requesting it, and (2) making a request whose response will await the report and then link to it. Orders are enabled in the MCP and API interfaces only.
 - From a request for findings: Details about issues reported, related WCAG standards, what rules were violated, and which DOM elements violated them.
+- From complaints and suggestions about features: acknowledgment of receipt and of the manager being notified.
 
 ## Side effects
 
-Kilotest reads the specified public web page during testing. It does not modify the target site. Testing is asynchronous and may take up to approximately one day before reports are available for newly requested pages.
+Kilotest reads the specified web page during testing. It does not modify the target site.
 
 ## Cost
 

package/docs/AI-TOOLS.md

@@ -42,7 +42,7 @@ The external features that support the use of Kilotest as a collection of AI too
 - A [pull request](https://github.com/public-apis/public-apis/pull/6346/changes) to add Kilotest to the list of public APIs in the `public-apis` repository.
 - An [issue](https://github.com/APIs-guru/openapi-directory/issues/2677) to add Kilotest to `openapi-directory`.
 - A [pull request](https://github.com/w3c/wai-evaluation-tools-list/pull/1153) to add Kilotest to the WAI evaluation tools list.
-- Registration of Kilotest as an active server in the [official MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=kilotest) (`io.github.jrpool/kilotest`), maintained by the [Model Context Protocol](https://modelcontextprotocol.io/) project. The [PulseMCP](https://www.pulsemcp.com/servers) directory and the VS Code MCP gallery both crawl this registry, so Kilotest is discoverable through them with no separate submission.
+- Registration of Kilotest as an active server in the [official MCP Registry](https://registry.modelcontextprotocol.io) (`io.github.jrpool/kilotest`), maintained by the [Model Context Protocol](https://modelcontextprotocol.io/) project. The [PulseMCP](https://www.pulsemcp.com/servers) directory and the VS Code MCP gallery both crawl this registry, so Kilotest is discoverable through them with no separate submission.
 - Registration of Kilotest with the [Smithery](https://smithery.ai/servers/pool/kilotest) MCP server registry.
 - Registration of Kilotest with the [Glama](https://glama.ai/mcp/connectors/com.kilotest/kilotest) MCP server registry, including a claim of ownership of the MCP connector by the maintainer via a `TXT` DNS record for `_glama-claim.kilotest.com`, with the value `glama_claim_gVV4HrPdcXr9TEfj1p3icEUBJ3_OVJGX`.
 - Registration of Kilotest with [Awesome MCP Servers](https://www.tensorblock.co/mcp/servers/github-jrpool-kilotest-f518ba36).
@@ -107,7 +107,7 @@ Other future work:
     Capability: web-page-quality-audit
 
     Purpose:
-      Test a public web page for accessibility,
+      Test a web page for accessibility,
       usability, HTML and web-standards problems.
 
     Interfaces:
@@ -123,7 +123,7 @@ Other future work:
       rule-engine diagnoses, WCAG mappings
 
     Side effects:
-      Reads the specified public web page.
+      Reads the specified web page.
       Does not modify the target site.
 
     Cost:

package/docs/SERVICE.md

@@ -270,7 +270,7 @@ kilotest.com {
   }
   @allowedPOST {
     method POST
-    path /mcp /requestRetest.html/* /requestTest.html /requestAction.html /reannotate.html /renewWCAG.html /ai0BalanceForm.html /deleteNotesForm.html /expungeReportsForm.html /hideReportForm.html /metrics.html /pruneReportsForm.html /rewindReportsForm.html /showHiddenReportsForm.html /unhideReportForm.html /api/* /tutorialWebComment.html /tutorialAIComment.html /worker/job /worker/report
+    path /mcp /requestRetest.html/* /requestNewTest.html /requestAction.html /reannotate.html /renewWCAG.html /ai0BalanceForm.html /deleteNotesForm.html /expungeReportsForm.html /hideReportForm.html /metrics.html /pruneReportsForm.html /rewindReportsForm.html /showHiddenReportsForm.html /unhideReportForm.html /api/* /tutorialWebComment.html /tutorialAIComment.html /worker/job /worker/report
   }
   # Respond to OPTIONS requests.
   @allowedOPTIONS method OPTIONS
@@ -395,15 +395,13 @@ Alerts are sent to the maintainer in the following conditions:
 
 5. **Requested full report unavailable**: When a user requests a full report via the API but the report cannot be retrieved (e.g., the report file is missing from disk), an alert is sent with subject `"Kilotest: requested full report unavailable"`, including details on which report was requested and why it could not be retrieved.
 
-6. **Test request received via UI**: When a user submits a test request through the web interface, an alert is sent with subject `"Kilotest: new test request in the UI"` (via `/requestTest.html`) or `"Kilotest: new retest request in the UI"` (via `/requestRetest.html`), including the target URL, description, and the user's stated reason for the request. `test` and `retest` here are the only two literal values Kilotest passes as the request's type; they are hardcoded at each call site, not user-supplied.
+6. **Request for a test or retest received**: When a user submits a request to test or retest a page, whether through the web interface (`/requestNewTest.html` or `/requestRetest.html`) or the API (the `requestNewTest` or `requestRetest` operation), an alert is sent with subject `"Kilotest: request for a new test awaits approval"` or `"Kilotest: request for a retest awaits approval"`, including the target URL, description, and the user's stated reason for the request. Both the UI and API paths funnel through the same underlying request-queuing function, so the subject and the rest of this behavior are identical regardless of which path the request arrived through. A request is treated as a duplicate, and no alert is sent for it, only if a request already pending in `db/jobs/testRequests.json`, i.e., submitted but not yet manually approved by the maintainer into an actual job, for the same URL has the identical description; this check ignores the stated reason and the test-versus-retest distinction, and is not limited to a recent time window, it compares against every request still pending approval for that URL. Once the maintainer approves a pending request (turning it into a job via `/enqueue.html`), all pending requests for that URL are cleared, so this check cannot detect a duplicate against a request that has already been approved, is currently running, or has already completed; an identical request submitted after approval alerts again.
 
-7. **Test request received via API**: When a test request is submitted via the API, an alert is sent with subject `"Kilotest: new test request in the API"` (via the `requestTest` API operation) or `"Kilotest: new retest request in the API"` (via the `requestRetest` API operation), including the target URL, description, and the user's stated reason. A request is treated as a duplicate, and no alert is sent for it, only if a request already pending in `db/jobs/testRequests.json`, i.e., submitted but not yet manually approved by the maintainer into an actual job, for the same URL has the identical description; this check ignores the stated reason and the test-versus-retest distinction, and is not limited to a recent time window, it compares against every request still pending approval for that URL. Once the maintainer approves a pending request (turning it into a job via `/enqueue.html`), all pending requests for that URL are cleared, so this check cannot detect a duplicate against a request that has already been approved, is currently running, or has already completed; an identical request submitted after approval alerts again. The check and its dedup key are identical for the UI and API paths, since both funnel through the same underlying request-queuing function.
+7. **MCP feature request received**: When a user submits a feature request via the MCP server's `requestFeature` tool, an alert is sent with subject `"MCP feature request received"`, including the text of the feature request, and the request is also appended to `db/featureRequests.json`, the same way tutorial comments are appended to their own files (see item 1), so that a manager can review or delete it later via `/deleteNotesForm.html`.
 
-8. **MCP feature request received**: When a user submits a feature request via the MCP server's `requestFeature` tool, an alert is sent with subject `"MCP feature request received"`, including the text of the feature request, and the request is also appended to `db/featureRequests.json`, the same way tutorial comments are appended to their own files (see item 1), so that a manager can review or delete it later via `/deleteNotesForm.html`.
+8. **WAVE balance low**: When Kilotest detects that the account balance for the WAVE API service (used for accessibility testing) has fallen below a threshold, an alert is sent with subject `"Kilotest: WAVE balance low"`, indicating the number of credits remaining.
 
-9. **WAVE balance low**: When Kilotest detects that the account balance for the WAVE API service (used for accessibility testing) has fallen below a threshold, an alert is sent with subject `"Kilotest: WAVE balance low"`, indicating the number of credits remaining.
-
-10. **AI service balance low**: When Kilotest detects that the account balance for an AI service account (such as Anthropic) has fallen below a threshold, an alert is sent with subject `"Kilotest: AI service [N] balance low"`, indicating the approximate remaining balance in dollars and the estimated cost per job.
+9. **AI service balance low**: When Kilotest detects that the account balance for an AI service account (such as Anthropic) has fallen below a threshold, an alert is sent with subject `"Kilotest: AI service [N] balance low"`, indicating the approximate remaining balance in dollars and the estimated cost per job.
 
 ### Alert configuration
 
@@ -417,6 +415,19 @@ Alerts are sent via the `sendAlert()` function in [alerts.ts](../alerts.ts), whi
 
 If any of these five variables is missing or empty at alert time, the alert is not sent. Instead, a warning message is logged to the console, and the application continues normal operation. The warning includes the alert subject and body so the maintainer can manually review what would have been sent.
 
+### Inbox size limits
+
+Four submission types (test requests and retest requests together, web tutorial comments, AI tutorial comments, and MCP feature requests) are each held in a pending "inbox" (`db/jobs/testRequests.json`, `db/comments/tutorialWeb.json`, `db/comments/tutorialAI.json`, and `db/featureRequests.json` respectively) awaiting manual review by the maintainer. Each inbox has a maximum size; once reached, a new, distinct submission is rejected (with a message suggesting the requester instead post to the [GitHub issues page](https://github.com/jrpool/kilotest/issues) or email `info@kilotest.com`) rather than added, so neither the inbox file nor the manager alert emails it generates can grow without bound (see GitHub issue #3, abuse type 3, repeated/automated submissions). This is modeled on a full mailbox rejecting new mail, rather than on a submission rate limit: it is the backlog size itself, not how quickly it grows, that costs the maintainer review time and risks unbounded storage. Every alert sent for an accepted submission reports the resulting inbox count against its cap, so a maintainer returning after an absence can immediately see how close an inbox is to full.
+
+Each cap defaults to 20 and can be set independently via an environment variable:
+
+1. **`TEST_REQUEST_QUEUE_MAX`**: The maximum number of test and retest requests awaiting approval at once, summed across all requested URLs.
+2. **`TUTORIAL_WEB_COMMENTS_MAX`**: The maximum number of comments held on the web tutorial page (`/tutorialWeb.html`).
+3. **`TUTORIAL_AI_COMMENTS_MAX`**: The maximum number of comments held on the AI agent tutorial page (`/tutorialAI.html`).
+4. **`FEATURE_REQUESTS_MAX`**: The maximum number of feature requests held via the MCP server's `requestFeature` tool.
+
+Each variable, if set, must be a non-negative integer; if unset, empty, or not a non-negative integer, the default of 20 is used instead. A value of `0` means no limit: that inbox is never treated as full, regardless of size. Unlike the alert-configuration variables above, these are not required: an unset value never disables the limit, it only selects the default size.
+
 ### Resend integration
 
 Kilotest uses [Resend](https://resend.com/) as its transactional email delivery service. Resend is configured through the environment variables above.
@@ -489,7 +500,7 @@ Kilotest records basic counts of how it is used, so the maintainer can answer qu
 
 - The generic `.html` GET dispatch in `index.ts`, once per successfully served web page, recorded under the `pageViews` category by page name (for example `tutorialWeb`, `listReports`), unless the page is a manager-only page (see "Manager page activity" below), in which case it is recorded there instead.
 - The home page (`/` and `/index.html`), served by its own branch in `index.ts` rather than through the generic `.html` dispatch, recorded under `pageViews` as `index`.
-- Each of the 8 MCP tool handlers in `mcp.ts`, once per successful tool call, recorded under the `mcpToolCalls` category by tool name (for example `listReports`, `requestTest`).
+- Each of the 9 MCP tool handlers in `mcp.ts`, once per successful tool call, recorded under the `mcpToolCalls` category by tool name (for example `listReports`, `requestNewTest`).
 - The `/api/*` GET and POST service branches in `index.ts`, once per call, recorded under the `apiOperations` category by operation name.
 
 `db/metrics.json` also stores a `since` time stamp, set when the file is first created, so the counts can be read as "since this date" rather than assumed to cover Kilotest's entire history. `getMetrics()` backfills any category absent from an existing `db/metrics.json` (for example one written before a category such as `managerActivity` existed), so an older file remains readable rather than causing every subsequent request to error.

package/env.example

@@ -2,6 +2,12 @@
 ENVIRONMENT=__placeholder__
 # http (local or reverse-proxied server) or https.
 PROTOCOL=__placeholder__
+# Port the server listens on (defaults to 3000).
+PORT=__placeholder__
+# Path of the private key file. Required only when PROTOCOL is https.
+KEY=__placeholder__
+# Path of the certificate file. Required only when PROTOCOL is https.
+CERT=__placeholder__
 # 3-character password for manager operations.
 AUTH_CODE=__placeholder__
 # ID of each Testaro worker and, for each, its secret and published name.
@@ -23,6 +29,39 @@ DB_DIR=__placeholder__
 # since such a worker could otherwise be induced to fetch a target it has no legitimate reason
 # to reach, such as its own host’s cloud-metadata service.
 ALLOW_INTERNAL_TARGETS=__placeholder__
+# Path of the web tutorial comments file (defaults to db/comments/tutorialWeb.json).
+TUTORIAL_WEB_COMMENTS_PATH=__placeholder__
+# Path of the AI tutorial comments file (defaults to db/comments/tutorialAI.json).
+TUTORIAL_AI_COMMENTS_PATH=__placeholder__
+# Path of the feature requests file (defaults to db/featureRequests.json).
+FEATURE_REQUESTS_PATH=__placeholder__
+
+# Inbox size limits: each defaults to 20 if unset, empty, or not a non-negative integer.
+# A value of 0 means no limit.
+
+# Maximum number of test/retest requests awaiting approval at once, across all URLs.
+TEST_REQUEST_QUEUE_MAX=__placeholder__
+# Maximum number of comments held on the web tutorial page.
+TUTORIAL_WEB_COMMENTS_MAX=__placeholder__
+# Maximum number of comments held on the AI agent tutorial page.
+TUTORIAL_AI_COMMENTS_MAX=__placeholder__
+# Maximum number of feature requests held via the MCP server's requestFeature tool.
+FEATURE_REQUESTS_MAX=__placeholder__
+# Maximum number of jobs allowed in the job queue (db/jobs/queue) at once. Shared by every
+# path that enqueues a job: manager approval of a pending test/retest request, and the
+# orderNewTest/orderRetest MCP tools, which enqueue directly.
+JOB_QUEUE_MAX=__placeholder__
+
+# Timing for the awaitTest MCP tool's wait on a job ordered via orderNewTest/orderRetest.
+# Defaults: 2000ms poll interval, 300000ms (5 minutes) maximum wait. The maximum wait
+# deliberately exceeds the "occasionally up to 4 minutes" callers are told to expect, to
+# leave margin so a job that is genuinely still running is not mistaken for one that
+# never will finish. Lower values are useful for local testing.
+
+# Milliseconds between polls while awaitTest waits for a job to complete.
+AWAIT_JOB_POLL_MS=__placeholder__
+# Maximum milliseconds awaitTest waits before giving up.
+AWAIT_JOB_TIMEOUT_MS=__placeholder__
 
 # Alert configuration:
 

package/index.test.ts

@@ -24,7 +24,7 @@ process.env.TESTARO_WORKERS = JSON.stringify({
 // isAllowedTarget performs. Tests of the check itself (below) override this per test.
 process.env.ALLOW_INTERNAL_TARGETS = 'true';
 // Blank the alert configuration unconditionally, so this file sends no real alert
-// emails (e.g. from the requestTest/requestRetest/tutorial-comment tests below) even
+// emails (e.g. from the requestNewTest/requestRetest/tutorial-comment tests below) even
 // when run directly (e.g. `npx tsx --test index.test.ts`) rather than via `npm test`,
 // which normally guards against this by --require-ing test/setup.ts first. dotenv does
 // not override an already-set env var, so setting these here, before index.ts is ever
@@ -459,8 +459,8 @@ test('GET /forbidden-path returns an invalid GET request error', async () => {
 
 // TESTS: POST routes
 
-test('POST /requestTest.html with valid data returns an HTML page', async () => {
-  const res = await formRequest('POST', '/requestTest.html', {
+test('POST /requestNewTest.html with valid data returns an HTML page', async () => {
+  const res = await formRequest('POST', '/requestNewTest.html', {
     description: `Unique Test Page ${uniqueStamp}`,
     url: `https://example.com/unique-${uniqueStamp}`,
     why: 'Because accessibility matters'
@@ -469,8 +469,8 @@ test('POST /requestTest.html with valid data returns an HTML page', async () =>
   assert.ok(res.headers['content-type'].includes('text/html'));
 });
 
-test('POST /requestTest.html with an already-tested URL returns an error', async () => {
-  const res = await formRequest('POST', '/requestTest.html', {
+test('POST /requestNewTest.html with an already-tested URL returns an error', async () => {
+  const res = await formRequest('POST', '/requestNewTest.html', {
     description: 'Mixed Outcomes Page',
     url: 'https://example.com/mixed',
     why: 'Because accessibility matters'
@@ -479,8 +479,8 @@ test('POST /requestTest.html with an already-tested URL returns an error', async
   assert.ok(res.body.includes('already been tested'));
 });
 
-test('POST /requestTest.html with invalid data returns an error', async () => {
-  const res = await formRequest('POST', '/requestTest.html', {
+test('POST /requestNewTest.html with invalid data returns an error', async () => {
+  const res = await formRequest('POST', '/requestNewTest.html', {
     description: '',
     url: 'not-a-url',
     why: ''
@@ -489,8 +489,8 @@ test('POST /requestTest.html with invalid data returns an error', async () => {
   assert.ok(res.body.includes('Invalid test request'));
 });
 
-test('POST /requestTest.html with an unreadable body returns an error', async () => {
-  const res = await request('POST', '/requestTest.html', 'rawbody', {'content-type': 'text/plain'});
+test('POST /requestNewTest.html with an unreadable body returns an error', async () => {
+  const res = await request('POST', '/requestNewTest.html', 'rawbody', {'content-type': 'text/plain'});
   assert.equal(res.statusCode, 400);
   assert.ok(res.body.includes('Unreadable request body'));
 });
@@ -513,8 +513,8 @@ test('POST /requestRetest.html/invalid/invalid with invalid data returns an erro
   assert.ok(res.body.includes('Invalid retest request'));
 });
 
-test('POST /api/requestTest with valid JSON returns a JSON response', {timeout: 500}, async () => {
-  const res = await request('POST', '/api/requestTest', {
+test('POST /api/requestNewTest with valid JSON returns a JSON response', {timeout: 500}, async () => {
+  const res = await request('POST', '/api/requestNewTest', {
     description: `API Test Page ${uniqueStamp}`,
     URL: `https://example.com/api-test-${uniqueStamp}`,
     reason: 'Because accessibility matters'
@@ -544,6 +544,45 @@ test('POST /api/requestFeature with valid JSON returns a JSON response and recor
   assert.equal(await getMetricCount('apiOperations', 'requestFeature'), countBefore + 1);
 });
 
+test('POST /api/orderNewTest with valid JSON enqueues a job directly and records an API-operation metric', {timeout: 500}, async () => {
+  const countBefore = await getMetricCount('apiOperations', 'orderNewTest');
+  const res = await request('POST', '/api/orderNewTest', {
+    description: `API Ordered Page ${uniqueStamp}`,
+    URL: `https://example.com/api-ordered-${uniqueStamp}`,
+    reason: 'Because accessibility matters here'
+  });
+  assert.equal(res.statusCode, 200);
+  const body = jsonBody(res);
+  assert.ok(body['tool name'] || body['response content']);
+  assert.equal(await getMetricCount('apiOperations', 'orderNewTest'), countBefore + 1);
+  const reportIdentifier = body['response content']['disposition of your order']['report identifier'];
+  assert.ok(reportIdentifier);
+  await fs.unlink(path.join(fixtureDBDir, 'jobs', 'queue', `${reportIdentifier.timeStamp}-${reportIdentifier.jobID}.json`));
+});
+
+test('POST /api/orderRetest/260202T0000/new with valid JSON enqueues a job directly and records an API-operation metric', async () => {
+  const countBefore = await getMetricCount('apiOperations', 'orderRetest');
+  const res = await request('POST', '/api/orderRetest/260202T0000/new', {
+    reason: 'Because the report is obsolete and needs refreshing'
+  });
+  assert.equal(res.statusCode, 200);
+  const body = jsonBody(res);
+  assert.ok(body['tool name'] || body['response content']);
+  assert.equal(await getMetricCount('apiOperations', 'orderRetest'), countBefore + 1);
+  const reportIdentifier = body['response content']['disposition of your order']['report identifier'];
+  assert.ok(reportIdentifier);
+  await fs.unlink(path.join(fixtureDBDir, 'jobs', 'queue', `${reportIdentifier.timeStamp}-${reportIdentifier.jobID}.json`));
+});
+
+test('POST /api/awaitTest/260101T0000/mix with an already-completed report records an API-operation metric', async () => {
+  const countBefore = await getMetricCount('apiOperations', 'awaitTest');
+  const res = await request('POST', '/api/awaitTest/260101T0000/mix', {});
+  assert.equal(res.statusCode, 200);
+  const body = jsonBody(res);
+  assert.equal(body['response content']['disposition of your wait'].outcome, 'completed');
+  assert.equal(await getMetricCount('apiOperations', 'awaitTest'), countBefore + 1);
+});
+
 test('POST /api/invalidService returns an error', async () => {
   const res = await request('POST', '/api/invalidService', {data: 'test'});
   assert.equal(res.statusCode, 400);
@@ -697,7 +736,7 @@ test('POST /requestAction.html with invalid auth code returns an error and recor
 });
 
 test('POST /requestAction.html with valid auth code and rejection (no description) returns HTML and records a managerActivity success', async () => {
-  await formRequest('POST', '/requestTest.html', {
+  await formRequest('POST', '/requestNewTest.html', {
     description: `Reject Test Page ${uniqueStamp}`,
     url: `https://example.com/reject-${uniqueStamp}`,
     why: 'Because accessibility matters'
@@ -740,7 +779,7 @@ test('GET /fullReport.json/260101T0007/hid returns an error for an unavailable r
 
 test('POST /requestAction.html with valid auth code and approval returns HTML', {timeout: 500}, async () => {
   await fs.writeFile(testRequestsPath, '{}\n');
-  await formRequest('POST', '/requestTest.html', {
+  await formRequest('POST', '/requestNewTest.html', {
     description: `Approval Test Page ${uniqueStamp}`,
     url: `https://example.com/approval-${uniqueStamp}`,
     why: 'Because accessibility matters'
@@ -899,8 +938,40 @@ test('GET /targets.html redirects to /listReports.html', async () => {
   assert.equal(res.headers['location'], '/listReports.html');
 });
 
-test('POST /requestTest.html with non-https URL returns an error', async () => {
-  const res = await formRequest('POST', '/requestTest.html', {
+test('GET /requestTest.html redirects to /requestNewTest.html', async () => {
+  const res = await request('GET', '/requestTest.html', {}, {followRedirects: false});
+  assert.equal(res.statusCode, 301);
+  assert.equal(res.headers['location'], '/requestNewTest.html');
+});
+
+test('GET /requestTestForm.html redirects to /requestNewTestForm.html', async () => {
+  const res = await request('GET', '/requestTestForm.html', {}, {followRedirects: false});
+  assert.equal(res.statusCode, 301);
+  assert.equal(res.headers['location'], '/requestNewTestForm.html');
+});
+
+test('POST /api/requestTest redirects (308, preserving method) to /api/requestNewTest', async () => {
+  const res = await request('POST', '/api/requestTest', {
+    description: `Old Path Page ${uniqueStamp}`,
+    URL: `https://example.com/old-path-${uniqueStamp}`,
+    reason: 'Because accessibility matters'
+  }, {followRedirects: false});
+  assert.equal(res.statusCode, 308);
+  assert.equal(res.headers['location'], '/api/requestNewTest');
+});
+
+test('POST /api/orderTest redirects (308, preserving method) to /api/orderNewTest', async () => {
+  const res = await request('POST', '/api/orderTest', {
+    description: `Old Path Ordered Page ${uniqueStamp}`,
+    URL: `https://example.com/old-path-ordered-${uniqueStamp}`,
+    reason: 'Because accessibility matters'
+  }, {followRedirects: false});
+  assert.equal(res.statusCode, 308);
+  assert.equal(res.headers['location'], '/api/orderNewTest');
+});
+
+test('POST /requestNewTest.html with non-https URL returns an error', async () => {
+  const res = await formRequest('POST', '/requestNewTest.html', {
     description: 'Test Page',
     url: 'http://example.com',
     why: 'Because accessibility matters'
@@ -909,10 +980,10 @@ test('POST /requestTest.html with non-https URL returns an error', async () => {
   assert.ok(res.body.includes('Invalid test request'));
 });
 
-test('POST /requestTest.html with a private-address URL returns an error unless internal targets are allowed', async () => {
+test('POST /requestNewTest.html with a private-address URL returns an error unless internal targets are allowed', async () => {
   delete process.env.ALLOW_INTERNAL_TARGETS;
   try {
-    const res = await formRequest('POST', '/requestTest.html', {
+    const res = await formRequest('POST', '/requestNewTest.html', {
       description: 'Internal Page',
       url: 'https://192.168.1.1/page',
       why: 'Because accessibility matters'
@@ -1166,6 +1237,57 @@ test('POST /worker/job with a queued job assigns it to the worker', {timeout: 50
   await fs.unlink(path.join(claimedDir, jobFile)).catch(() => {});
 });
 
+test('POST /worker/job with a queued job whose host now redirects to a disallowed target rejects it without assigning it', {timeout: 500}, async (t) => {
+  delete process.env.ALLOW_INTERNAL_TARGETS;
+  // Clean up claimed, queue, and failed directories.
+  const claimedDir = path.join(fixtureDBDir, 'jobs', 'claimed');
+  const queueDir = path.join(fixtureDBDir, 'jobs', 'queue');
+  const failedDir = path.join(fixtureDBDir, 'jobs', 'failed');
+  for (const dir of [claimedDir, queueDir]) {
+    await fs.mkdir(dir, {recursive: true});
+    const files = await fs.readdir(dir).catch(() => []);
+    for (const file of files) {
+      await fs.unlink(path.join(dir, file)).catch(() => {});
+    }
+  }
+  const jobFile = '260101T0000-mix.json';
+  const failedJobPath = path.join(failedDir, jobFile);
+  await fs.unlink(failedJobPath).catch(() => {});
+  // The job's host still resolves publicly, but by the time it is dequeued for
+  // assignment it has been reconfigured (e.g. by an attacker) to redirect to a
+  // private address, which only a fetch-based check, not a DNS-only one, can see.
+  t.mock.method(globalThis, 'fetch', async () => ({url: 'https://192.168.1.1/test'}) as Response);
+  try {
+    await fs.writeFile(path.join(queueDir, jobFile), JSON.stringify({
+      id: '260101T0000-mix',
+      target: {what: 'Test Page', url: 'https://example.com/test'},
+      sources: {}
+    }));
+    const auth = Buffer.from('worker1:secret1').toString('base64');
+    const res = await request('POST', '/worker/job', {}, {
+      authorization: `Basic ${auth}`
+    });
+    // The worker should be told there is no job, not given the disallowed job.
+    assert.equal(res.statusCode, 200);
+    const body = jsonBody(res);
+    assert.equal(body.id, undefined);
+    // Wait for the async rename to complete.
+    await new Promise<void>(resolve => setTimeout(resolve, 100));
+    // The job should have been moved from queue to failed, never to claimed.
+    const queueExists = await fs.access(path.join(queueDir, jobFile)).then(() => true).catch(() => false);
+    assert.equal(queueExists, false, 'Job should be removed from queue');
+    const claimedExists = await fs.access(path.join(claimedDir, jobFile)).then(() => true).catch(() => false);
+    assert.equal(claimedExists, false, 'Job should not be moved to claimed directory');
+    const failedExists = await fs.access(failedJobPath).then(() => true).catch(() => false);
+    assert.ok(failedExists, 'Job should be moved to the failed directory');
+  } finally {
+    t.mock.reset();
+    process.env.ALLOW_INTERNAL_TARGETS = 'true';
+    // Clean up.
+    await fs.unlink(failedJobPath).catch(() => {});
+  }
+});
+
 // TESTS: worker/report valid submission
 
 test('POST /worker/report with valid authentication and valid claimed job processes the report', {timeout: 500}, async () => {
@@ -1319,14 +1441,14 @@ test('GET /style.css with a read error returns an error page', async () => {
   }
 });
 
-// requestTest.html and requestRetest.html are POST-only routes (see the
+// requestNewTest.html and requestRetest.html are POST-only routes (see the
 // `routes.POST` list above). They also match the generic '*.html*' GET pattern,
 // but the generic `pageName.endsWith('.html')` branch of the GET dispatcher
 // excludes any path that is POST-only, since such a path's answer handler
 // expects POST's argument list and performs no GET-appropriate rendering.
 
-test('GET /requestTest.html without arguments is rejected as an invalid GET request', async () => {
-  const res = await request('GET', '/requestTest.html');
+test('GET /requestNewTest.html without arguments is rejected as an invalid GET request', async () => {
+  const res = await request('GET', '/requestNewTest.html');
   assert.equal(res.statusCode, 400);
 });
 
@@ -1680,18 +1802,18 @@ test('POST /mcp with a valid initialize request returns server info via SSE', as
 
 // TESTS: answer error branches
 
-test('POST /requestTest.html with valid format but duplicate URL returns an answer error', {timeout: 500}, async () => {
+test('POST /requestNewTest.html with valid format but duplicate URL returns an answer error', {timeout: 500}, async () => {
   await fs.writeFile(testRequestsPath, '{}\n');
   // First request to create the request. processTestRequest treats a request as a
   // duplicate only when description, URL, AND reason all match an existing pending
   // request, so the reason must be identical between the two requests here.
-  await formRequest('POST', '/requestTest.html', {
+  await formRequest('POST', '/requestNewTest.html', {
     description: `Dup Test Page ${uniqueStamp}`,
     url: `https://example.com/dup-${uniqueStamp}`,
     why: 'Because accessibility matters'
   });
   // Second, identical request should get a duplicate error.
-  const res = await formRequest('POST', '/requestTest.html', {
+  const res = await formRequest('POST', '/requestNewTest.html', {
     description: `Dup Test Page ${uniqueStamp}`,
     url: `https://example.com/dup-${uniqueStamp}`,
     why: 'Because accessibility matters'
@@ -1719,7 +1841,7 @@ test('POST /requestRetest.html with valid format but duplicate retest returns an
 test('POST /requestAction.html with valid auth code approves the same target twice without error', {timeout: 500}, async () => {
   await fs.writeFile(testRequestsPath, '{}\n');
   // Create a request.
-  await formRequest('POST', '/requestTest.html', {
+  await formRequest('POST', '/requestNewTest.html', {
     description: `Action Dup Page ${uniqueStamp}`,
     url: `https://example.com/action-dup-${uniqueStamp}`,
     why: 'Because accessibility matters'