@turri-dev/cli 0.0.0-stage → 0.1.2-next.48dacfc

package/dist/regenerate/steering.js

@@ -0,0 +1,119 @@
+import { DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS } from "../plain/spec.js";
+import { describeSpecChange } from "./prompt.js";
+import { applyChanges, changesBetween, parseTree, serializeTree } from "./spec-steps.js";
+/**
+ * JobSteering a running code job: the spec changed while it regenerates, inside what it is regenerating - a functional
+ * spec it builds reworded, a sub-bullet added under one, a definition or an implementation req it is given edited, a
+ * file one links edited - and the coding agent is told, rather than the job stopped or the change left to the next
+ * one. A new or removed item is not a steer: the work changes shape, and that is the next job's. At most MAX_STEERS a
+ * job; the one after is the next job's, or stops this one, as `allow-to-stop-jobs` says.
+ *
+ * Three trees. `target`: what the job lands as built from - its code record. `agent`: what its agent is to build -
+ * the target, and a definition or req edited that functional specs built before the job use too: the agent is told,
+ * but the record keeps what those were built from, so the loop patches them - this one's with them - once it lands.
+ * `told`: what the agent has been told. A steer is waiting while `told` is not `agent`; edits made before it is
+ * given are one steer, the newest of each item.
+ */
+export const MAX_STEERS = 2;
+export function createSteering(tree, module) {
+    return { target: tree, agent: tree, told: tree, steers: 0, notes: [], ...(module !== undefined ? { module } : {}) };
+}
+/** What the agent is to be told and has not been: the steer waiting, or undefined when there is none. */
+export function waitingSteer(steering) {
+    const changes = changesBetween(serializeTree(steering.told), serializeTree(steering.agent));
+    return changes.length === 0 ? undefined : steerText(changes, steering.module);
+}
+/** The agent has it now. */
+export function markTold(steering) {
+    steering.told = steering.agent;
+}
+/** The message a steer is: the change since it was last told, as its first one was - and to make the code match. */
+export function steerText(changes, moduleName) {
+    return [
+        "The spec changed while you work, in what you are building. The change, from the spec as you were given it to the spec as it is now:",
+        "",
+        describeSpecChange(changes, moduleName),
+        "",
+        "Make the code and its unit tests match the spec as it is now - this change, and nothing else changes. Carry on from where you are: the harness runs the unit tests again once you have.",
+    ].join("\n");
+}
+/** A definition's concept: `:User:` of `- :User: is a person.`. */
+function conceptOf(serialized) {
+    if (serialized === undefined)
+        return undefined;
+    try {
+        const item = JSON.parse(serialized);
+        const text = typeof item === "string" ? item : (item.markdown ?? "");
+        return /^-\s+(:[^:\s]+:)/.exec(text)?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The functional specs of a tree, a line each, as its serialized form - and so a change's text - has them. */
+function functionalSpecs(tree) {
+    const header = JSON.stringify([FUNCTIONAL_REQUIREMENTS]);
+    const lines = serializeTree(tree).split("\n");
+    const start = lines.indexOf(header);
+    if (start === -1)
+        return [];
+    const own = [];
+    for (const line of lines.slice(start + 1)) {
+        if (line === "" || line.startsWith("["))
+            break;
+        own.push(line);
+    }
+    return own;
+}
+/**
+ * The part of `changes` - from a tree the job regenerates towards, to the spec - that steers it: changes to items it
+ * already has, never one added or removed. A functional spec only when it is one of the job's own (`mine`, as the job
+ * regenerates it); a definition or an implementation req always. `shared`: those of them that functional specs built
+ * before the job (`built`) use too - the agent is told, but they stay out of the record.
+ */
+export function steerableChanges(changes, mine, built) {
+    const steer = [];
+    const shared = [];
+    for (const change of changes) {
+        if (change.kind !== "change")
+            continue;
+        if (change.section === FUNCTIONAL_REQUIREMENTS) {
+            if (mine.has(change.before ?? ""))
+                steer.push(change);
+        }
+        else if (change.section === DEFINITIONS) {
+            steer.push(change);
+            const concept = conceptOf(change.before) ?? conceptOf(change.after);
+            if (concept !== undefined && built.some((spec) => spec.includes(concept)))
+                shared.push(change);
+        }
+        else if (change.section === NON_FUNCTIONAL_REQUIREMENTS) {
+            steer.push(change);
+            if (built.length > 0)
+                shared.push(change);
+        }
+    }
+    return { steer, shared };
+}
+/**
+ * Steer a job, when the spec moved on inside what it regenerates: the trees it moves to, or undefined when nothing in
+ * the change steers it. `toSpec(tree)` is the work from a tree to the spec, as the job's track sees it; `own` the job's
+ * changes, from its record `from` to what it regenerates towards now.
+ */
+export function steer(steering, from, own, toSpec) {
+    // The job's own functional specs, as it regenerates them; those built before it that it does not touch.
+    const mine = new Set(own.filter((change) => change.section === FUNCTIONAL_REQUIREMENTS && change.after !== undefined).map((change) => change.after));
+    const patched = new Set(own.filter((change) => change.section === FUNCTIONAL_REQUIREMENTS && change.kind === "change").map((change) => change.before ?? ""));
+    const built = functionalSpecs(from).filter((spec) => !patched.has(spec));
+    const forAgent = steerableChanges(toSpec(steering.agent), mine, built);
+    if (forAgent.steer.length === 0)
+        return undefined;
+    // The record takes what the agent is told but what was built before it uses too.
+    const forRecord = steerableChanges(toSpec(steering.target), mine, built);
+    const recordChanges = forRecord.steer.filter((change) => !forRecord.shared.includes(change));
+    return {
+        target: parseTree(applyChanges(serializeTree(steering.target), recordChanges)),
+        agent: parseTree(applyChanges(serializeTree(steering.agent), forAgent.steer)),
+        steered: forAgent.steer,
+    };
+}

package/dist/regenerate/stop-report.js

@@ -0,0 +1,161 @@
+import { basename } from "node:path";
+/** How many times each gate is tried before a build stops there. */
+export const ATTEMPTS = {
+    "unit tests": 20,
+    conformance: 20,
+    regression: 20,
+};
+/**
+ * Where it stopped, why, and what to do about it - for the person, in a few lines, and in terms
+ * of the spec. The spec is all the person works on: the code is generated from it, so every fix
+ * offered here is a change to a `.plain` file, never to code, tests or the machine.
+ */
+export function describeStop(facts) {
+    const what = facts.frid !== undefined ? `${facts.moduleName} functionality ${facts.frid}` : `the spec change in ${facts.moduleName}`;
+    // What actually happened, not the most it could have been.
+    const tries = facts.at === "unit tests" ? (facts.attempts ?? ATTEMPTS[facts.at]) : facts.at === "conformance" ? (facts.conformance?.rounds ?? ATTEMPTS[facts.at]) : ATTEMPTS[facts.at];
+    let why;
+    let todo;
+    // Not the spec's: what the tests are given to run with - only the person can fix it, and nothing in the spec changes.
+    if (facts.at === "conformance" && facts.conformance?.environment !== undefined) {
+        return [
+            `Stopped at ${what}: its conformance tests cannot pass with what their run is given - judged so ${facts.conformance.environment.times} times in a row:`,
+            facts.conformance.environment.reason.trim(),
+            "",
+            "What to do:",
+            "- Provide what the run is missing - a valid credential, an account, a service it can reach - where the conformance testing script reads it.",
+            "- The testing scripts run on this machine in your own environment: a credential they need is read from there - your shell's " +
+                "variables, or a .env the script loads.",
+            "",
+            "Then build again: it picks up here, and what is built stays built.",
+        ].join("\n");
+    }
+    // Not the spec's either: the script cannot run at all, so no code would pass it.
+    if (facts.at === "unit tests" && facts.missingToolchain !== undefined) {
+        const { command } = facts.missingToolchain;
+        const needs = command !== undefined ? `\`${command}\`` : "a toolchain it needs";
+        return [
+            `Stopped at ${what}: the unit testing script cannot run - ${needs} is not installed on this machine, where the testing scripts run.`,
+            "This needs you: no change to the spec or the code makes it run, and nothing was built.",
+            "",
+            "What to do:",
+            `- Install ${command ?? "it"} on this machine, so the testing script finds it on its PATH.`,
+            "",
+            "Then build again: it picks up here, and what is built stays built.",
+        ].join("\n");
+    }
+    if (facts.at === "unit tests" && facts.staticChecks === true) {
+        why = `after ${tries} attempt${tries === 1 ? "" : "s"} its unit tests passed, but the static checks the unit testing script runs with them - its formatter, linter and type checker, which count as the tests do - still did not.`;
+        todo = [
+            "If a check keeps failing on something the spec or the stack asks for - a library with no type information, a rule that " +
+                "does not fit the stack - say in the implementation reqs how the code is to be checked, or change the checks in the unit testing script.",
+            "If the functional spec leaves the shape of its data open, say exactly what it is: a type checker holds the code to one shape.",
+        ];
+    }
+    else if (facts.at === "unit tests") {
+        why = `after ${tries} attempt${tries === 1 ? "" : "s"} it still could not be built to pass its own unit tests.`;
+        todo = [
+            "The functional spec is most likely too big for one functionality, or leaves a choice open that keeps coming " +
+                "out wrong. Split it into smaller functional specs (`analyze-if-func-spec-too-complex`, `break-down-func-spec`), " +
+                "or say exactly what it should do.",
+            "If it needs something the stack does not name - a library, a tool, a service - add it to the implementation reqs.",
+            "If its unit tests have to be run in a particular way, say how in the implementation reqs.",
+        ];
+    }
+    else if (facts.at === "conformance" && facts.conformance?.specConflict !== undefined) {
+        const { functionalities, reason } = facts.conformance.specConflict;
+        const [one, two] = functionalities.map((ref) => `${ref.module} ${ref.frid}`);
+        why = `its spec contradicts itself: functionalities ${one} and ${two} cannot both hold. ${reason.trim()}`;
+        todo = [
+            `Compare functional specs ${one} and ${two} (\`analyze-2-func-specs\`, \`resolve-spec-conflict\`) and change whichever is wrong - ` +
+                "or both, so they say the same thing about where they meet.",
+            "If one is meant to change what the other does, say so in the one that changes it, and update its acceptance tests to match.",
+        ];
+    }
+    else if (facts.at === "conformance" && facts.conformance?.review !== undefined && facts.conformance.stuck === undefined) {
+        const problems = facts.conformance.review;
+        why =
+            `its conformance tests pass, but never passed review in ${tries} round${tries === 1 ? "" : "s"}: they do not yet test what the spec says, ` +
+                `black box. What the review last found:\n${problems.slice(0, 8).map((problem) => `    - ${problem.kind === "missing" ? "missing" : "bad"} · ${problem.file}${problem.test ? ` · ${problem.test}` : ""}: ${problem.what.trim().replace(/\s+/g, " ")}`).join("\n")}`;
+        todo = [
+            "If an acceptance test asks for something the tests cannot do - a service they cannot reach, data they cannot set up - say in the test " +
+                "reqs how they do it, or change the acceptance test to what can be checked.",
+            "If the test reqs leave open how the software is reached or what may be mocked, say so exactly.",
+        ];
+    }
+    else if (facts.at === "conformance" && facts.conformance?.unlabelled !== undefined) {
+        why =
+            "its conformance tests were never written and labelled as the two kinds - conformance tests and each acceptance test - " +
+                `though they were sent back for it again and again. Still missing:\n${facts.conformance.unlabelled.map((line) => `    - ${line}`).join("\n")}`;
+        todo = ["If the test reqs leave open where the tests go or how they are built, say so exactly - the folder, the files, the build."];
+    }
+    else if (facts.at === "conformance" && facts.conformance?.stuck !== undefined) {
+        const { error, times, rounds, changedNothing } = facts.conformance.stuck;
+        why =
+            changedNothing === true
+                ? `its conformance tests kept failing with ${error}, and the last ${times} fixes - in ${rounds} attempts - changed nothing, ` +
+                    "so nothing more would have come of the rest of them."
+                : `its conformance tests kept failing with ${error} - ${times} times, and ${times} more after the explorer was asked again ` +
+                    `what they lacked, in ${rounds} attempts - so nothing more would have come of the rest of them.`;
+        todo = [
+            "The tests most likely cannot reach the software the way the test reqs have them do it. Say exactly how in the test reqs: " +
+                "what the tests depend on or start - the package or entry point the conformance testing script builds or installs, by its exact name - " +
+                "and how they start it.",
+            "If the tests need longer than the time limit for a run - a long-running request - raise TURRI_COMMAND_TIMEOUT, or say in " +
+                "the test reqs how they keep it short.",
+            "If the test reqs contradict each other, settle which is meant.",
+        ];
+    }
+    else if (facts.at === "conformance") {
+        why = `after ${tries} round${tries === 1 ? "" : "s"}, its conformance tests and its code still disagree about what the spec means.`;
+        todo = [
+            "The functional spec can be read more than one way. Say exactly what should happen - the inputs, the outputs, " +
+                "the edge cases - and add acceptance tests that pin down the expected result.",
+            "If the conformance tests are meant to be written or run differently - framework, command, setup - change the test reqs.",
+        ];
+    }
+    else {
+        why =
+            `building it broke what was built before it, and ${facts.repairs ?? tries} attempt${facts.repairs === 1 ? "" : "s"} ` +
+                "to reconcile the two did not succeed.";
+        todo = [
+            "This most often means its spec contradicts an earlier one. Compare them (`analyze-func-specs`, " +
+                "`resolve-spec-conflict`) and change whichever is wrong.",
+            "If the new behaviour is meant to change what an earlier functionality does, change that earlier spec and its " +
+                "acceptance tests to say so.",
+        ];
+    }
+    return [
+        `Stopped at ${what}: ${why}`,
+        "Nothing after it was built - the functionalities after it, and the modules built on this one, wait on it.",
+        "",
+        "What to change in the spec:",
+        ...todo.map((line) => `- ${line}`),
+        "",
+        "Then build again: it picks up here, and what is built stays built.",
+    ].join("\n");
+}
+/**
+ * A spec that contradicts itself, for the person: exactly which two functional specs, as they
+ * read, and what cannot hold - then that the decision is theirs. Nothing about code or tests: the
+ * spec is all they work on, and the fix is theirs to choose.
+ */
+export function describeSpecConflict(conflict) {
+    const name = (spec) => `functional spec ${spec.frid} of ${spec.module}`;
+    const [one, two] = conflict.specs;
+    return [
+        `The spec contradicts itself: ${name(one)} and ${name(two)} cannot both hold.`,
+        "",
+        ...conflict.specs.flatMap((spec) => [
+            `Functional spec ${spec.frid} of ${spec.module} (${basename(spec.plainFile)}):`,
+            ...spec.text.trim().split("\n").map((line) => `  ${line}`),
+            "",
+        ]),
+        "What cannot hold:",
+        ...[...new Set(conflict.reasons)].map((reason) => `- ${reason.replace(/\s+/g, " ")}`),
+        "",
+        `This was found ${conflict.reasons.length} times running the conformance tests, and nothing in the code or the tests can`,
+        "settle it: only you can say what is meant. Decide which spec is right - or how the two should read together -",
+        "and the spec is changed to say it.",
+    ].join("\n");
+}

package/dist/regenerate/submit-work.js

@@ -0,0 +1,71 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+/** What the agent is told, at the end of its task: how it hands its work over. */
+export const SUBMIT_WORK_NOTE = [
+    "When you are done with a turn - the work written and its tests passing - call submit_work, last: a short summary of",
+    "what you did and why, and after a review, an answer for each problem it raised - fixed, or declined and why. Its",
+    "reviewer gets your account beside the diff of what you changed, and checks the one against the other: say what you",
+    "did, not what you meant to.",
+];
+/** What the agent is told with a review's problems: how it answers them. */
+export const SUBMIT_AFTER_REVIEW = [
+    "Then call submit_work, last: an answer for each problem, by its number - fixed, or declined and why - and the files.",
+];
+export function createWorkLedger() {
+    let accounts = [];
+    const tool = defineTool({
+        name: "submit_work",
+        label: "Submit the work",
+        description: "Hand your work over for review, last in a turn: a short summary of what you did, and for each problem a review " +
+            "raised, by its number - fixed, or declined and why, and the files. The reviewer checks it against the diff.",
+        promptSnippet: "hand the work over for review - what you did, and your answer to each problem raised",
+        parameters: Type.Object({
+            summary: Type.String({ description: "What you did in this turn and why, in a few sentences" }),
+            answers: Type.Optional(Type.Array(Type.Object({
+                problem: Type.Number({ description: "The problem's number in the review's list" }),
+                outcome: Type.Union([Type.Literal("fixed"), Type.Literal("declined")]),
+                why: Type.String({ description: "How you fixed it, or why you did not" }),
+                files: Type.Optional(Type.Array(Type.String(), { description: "The files you changed for it" })),
+            }), { description: "After a review: one answer for each problem it raised. Omit on a first turn." })),
+        }),
+        async execute(_id, params) {
+            accounts.push({ summary: params.summary, answers: (params.answers ?? []) });
+            return { content: [{ type: "text", text: "Handed over." }], details: {}, terminate: true };
+        },
+    });
+    return {
+        tool,
+        peek: () => [...accounts],
+        take() {
+            const taken = accounts;
+            accounts = [];
+            return taken;
+        },
+    };
+}
+/** The problems, numbered from 1, that no account answered. */
+export function unanswered(accounts, problems) {
+    const answered = new Set(accounts.flatMap((account) => account.answers.map((answer) => answer.problem)));
+    return Array.from({ length: problems }, (_, index) => index + 1).filter((n) => !answered.has(n));
+}
+/** The prompt that sends the agent back once for the problems its account left out. */
+export function unansweredPrompt(numbers) {
+    return [
+        `Your account answers no problem ${numbers.join(", ")} of the review's list. For each: fix it, or say why not - then`,
+        "call submit_work again, with an answer for each of them.",
+    ].join("\n");
+}
+/** The accounts, for the reviewer: labelled as a claim, the problems they answer named. */
+export function describeAccounts(accounts, problems) {
+    if (accounts.length === 0)
+        return "(the agent that did the work gave no account - go by the diff)";
+    return accounts
+        .map((account) => [
+        account.summary.trim(),
+        ...account.answers.map((answer) => {
+            const problem = problems?.[answer.problem - 1];
+            return `- problem ${answer.problem}${problem !== undefined ? ` (${problem.what.trim().slice(0, 160)})` : ""}: ${answer.outcome} - ${answer.why.trim()}${answer.files !== undefined && answer.files.length > 0 ? ` [${answer.files.join(", ")}]` : ""}`;
+        }),
+    ].join("\n"))
+        .join("\n\n");
+}

package/dist/regenerate/test-kinds.js

@@ -0,0 +1,124 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { listFiles } from "./testing.js";
+/**
+ * The two kinds of test the conformance step writes, and how each is told apart in the code.
+ *
+ * Conformance tests are written from the functional spec itself: what the functionality does,
+ * its edge cases, its errors - as if no acceptance tests had been given. Acceptance tests are the
+ * ones the spec's author wrote, each implemented as a test of its own, doing what it says. The
+ * two are kept apart even when the acceptance tests would seem to cover the functionality: tests
+ * derived only from the acceptance tests check what the author thought to check, and nothing
+ * the spec says beyond it.
+ *
+ * Each kind is labelled where anyone reading the tests can see it - in its file names, and in a
+ * comment the harness looks for - so which test is which, and which acceptance test a test
+ * implements, never has to be guessed.
+ */
+export function conformanceLabel(frid) {
+    return `conformance tests of functionality ${frid}`;
+}
+export function acceptanceLabel(frid, n) {
+    return `acceptance test ${n} of functionality ${frid}`;
+}
+/** An acceptance test as the spec gives it, without its bullet. */
+export function acceptanceText(item) {
+    return item.trim().replace(/^[-*]\s+/, "");
+}
+function normalise(text) {
+    return text.toLowerCase().replace(/\s+/g, " ");
+}
+/**
+ * What is missing from the labelling of a functionality's tests: the conformance label, when no
+ * test file carries it, and each acceptance test no test is labelled as implementing.
+ */
+export function missingTestLabels(testsDir, frid, acceptanceTests) {
+    const text = normalise(listFiles(testsDir)
+        .map((file) => {
+        try {
+            return readFileSync(join(testsDir, file), "utf8");
+        }
+        catch {
+            return "";
+        }
+    })
+        .join("\n"));
+    // Functionality 2's label must not be found in functionality 2.1's.
+    const has = (label) => new RegExp(`${normalise(label).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![0-9.]*[0-9])`).test(text);
+    const missing = [];
+    if (!has(conformanceLabel(frid)))
+        missing.push(`No test file is labelled "${conformanceLabel(frid)}".`);
+    acceptanceTests.forEach((item, i) => {
+        if (!has(acceptanceLabel(frid, i + 1)))
+            missing.push(`No test is labelled "${acceptanceLabel(frid, i + 1)}": ${acceptanceText(item)}`);
+    });
+    return missing;
+}
+/** Sent back when the labels are missing: which, and how to label them. */
+export function labelsPrompt(frid, missing, empty = false, hasAcceptance = true) {
+    return labelsPromptFor([{ frid, missing }], empty, hasAcceptance);
+}
+/**
+ * Sent back when the labels of several functionalities are missing - a spec change that touches them: every one that is
+ * missing, in one request, so none is asked for in place of another.
+ */
+export function labelsPromptFor(items, empty = false, hasAcceptance = true) {
+    const pending = items.filter((item) => item.missing.length > 0);
+    const frids = pending.map((item) => item.frid);
+    const which = frids.length === 1 ? `functionality ${frids[0]}` : `functionalities ${frids.slice(0, -1).join(", ")} and ${frids.at(-1)}`;
+    return [
+        empty
+            ? "There are no tests in your tests folder - nothing ran. Whatever a build folder or an earlier report there says, write " +
+                `the conformance tests of ${which} now, as files in your tests folder, labelled as the kinds they are:`
+            : `The tests are not labelled yet as the kinds they must be kept apart as. Missing, for ${which}:`,
+        "",
+        ...pending.flatMap((item) => item.missing.map((line) => `- ${line}`)),
+        "",
+        "Every functionality's conformance tests carry its own label, in a comment of its own line: " +
+            `"${conformanceLabel(frids[0] ?? "1")}"${frids.length > 1 ? `, "${conformanceLabel(frids[1])}", and so on - one line a functionality` : ""}. ` +
+            `A file that tests several functionalities has one such line for each. A label naming several at once - "conformance tests of functionality 1, 2 and 3" - counts for the first alone.`,
+        ...(hasAcceptance
+            ? [
+                `Every acceptance test is its own test, with a comment right above it: "${acceptanceLabel(frids[0] ?? "1", 1)}:" and the acceptance test's text - one not implemented yet is written as a test of its own, not folded into a conformance test.`,
+            ]
+            : []),
+        "Add every label missing above. Keep every label and every test that is there already: adding one functionality's label never takes another's away. Then run the tests again.",
+    ].join("\n");
+}
+/**
+ * Conformance and acceptance tests in the code folder, where they do not belong: they live in the
+ * module's tests folder, which the harness runs as the conformance suite. Found by their label, or
+ * by a test file under a name or folder that says conformance or acceptance - one written without
+ * a label is misplaced all the same.
+ */
+export function misplacedConformanceTests(codeDir) {
+    const label = /conformance tests of (functionality [0-9]|the spec)|acceptance test [0-9]+ of functionality/i;
+    return listFiles(codeDir).filter((file) => {
+        const parts = file.toLowerCase().split("/");
+        const named = parts.some((part) => /conformance|acceptance/.test(part)) && /test/.test(parts.at(-1));
+        if (named)
+            return true;
+        try {
+            const text = readFileSync(join(codeDir, file), "utf8");
+            return text.length < 500_000 && label.test(text);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Sent back when there are: to the agent writing the code, or to the one writing the tests. */
+export function misplacedTestsPrompt(files, codeDir, testsDir) {
+    return [
+        `These are conformance or acceptance tests, in the code folder (${codeDir}), where they do not belong:`,
+        "",
+        ...files.map((file) => `- ${file}`),
+        "",
+        testsDir === undefined
+            ? "Conformance and acceptance tests are not yours to write: the conformance step writes them, in the module's " +
+                "tests folder. Remove these from the code folder. Your tests are the unit tests - write them as unit tests."
+            : `Conformance and acceptance tests live in your working directory, ${testsDir}, and nowhere else. Move these ` +
+                "there - labelled as they must be - and remove them from the code folder; the harness runs only that folder as " +
+                "the conformance suite.",
+    ].join("\n");
+}