@turri-dev/cli 0.1.4-next.fa9223b → 0.1.5-next.6df6879

package/dist/regenerate/jobs.js

@@ -52,6 +52,9 @@ export function createJobRegistry(options) {
         },
         start(input) {
             const id = randomUUID().slice(0, 8);
+            // The stack chosen as it is queued - or pinned for the work that queues it - not as it starts: a job that waits
+            // for a slot is built with the stack it was asked for, whatever is chosen meanwhile.
+            const stack = chosenStack();
             const claimed = [...new Set(input.lanes ?? [])];
             const blockers = [
                 ...new Set(claimed
@@ -70,6 +73,7 @@ export function createJobRegistry(options) {
                 ...(input.title !== undefined ? { title: input.title } : {}),
                 diff: input.diff,
                 model: input.model,
+                ...(stack !== undefined ? { stack } : {}),
                 ...(input.follows !== undefined ? { follows: input.follows } : {}),
                 status: blockers.length > 0 || (limit !== undefined && active >= limit) ? "queued" : "running",
                 sequence: (sequence += 1),
@@ -273,9 +277,9 @@ export function createJobRegistry(options) {
                 log = startJobLog(job, claimed);
                 if (log !== undefined)
                     job.logFile = log.file;
-                // What the job's agents start runs until it ends, and no longer (withPulse) - with the stack chosen as it
-                // starts, whatever is chosen while it runs.
-                return withStack(chosenStack(), () => (guarded ? runGuarded() : runOnce()));
+                // What the job's agents start runs until it ends, and no longer (withPulse) - with the stack it was queued
+                // with, whatever is chosen while it waits or runs.
+                return withStack(stack, () => (guarded ? runGuarded() : runOnce()));
             })
                 .then((outcome) => {
                 // Asked to stop, it is stopped - whether its work threw as it unwound or returned what it had.
@@ -385,10 +389,11 @@ export function pulseName(job) {
 }
 /** What the agent is told when it checks on a job. */
 export function describeJob(job) {
+    const name = `${pulseName(job)}${job.stack !== undefined ? ` (stack ${job.stack})` : ""}`;
     if (job.status === "queued") {
-        return `${pulseName(job)}: queued behind ${job.waitingOn.map((id) => `pulse ${id}`).join(" and ")}. It starts when that finishes.`;
+        return `${name}: queued behind ${job.waitingOn.map((id) => `pulse ${id}`).join(" and ")}. It starts when that finishes.`;
     }
-    const header = `${pulseName(job)}: ${job.status}, ${formatDuration(job)}`;
+    const header = `${name}: ${job.status}, ${formatDuration(job)}`;
     if (job.status === "running") {
         return [
             header,

package/dist/regenerate/list-arguments.js

@@ -0,0 +1,121 @@
+const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** The tool's arguments that take a list of objects. */
+function listArguments(schema) {
+    const required = new Set(schema.required ?? []);
+    return Object.entries(schema.properties ?? {})
+        .filter(([, property]) => property.type === "array" && property.items?.type === "object")
+        .map(([name, property]) => ({ name, required: required.has(name), item: property.items }));
+}
+/** JSON text, fenced or not, as what it holds; anything else as it is. */
+function parsed(value) {
+    if (typeof value !== "string")
+        return value;
+    const text = value
+        .trim()
+        .replace(/^```(?:json)?\s*/i, "")
+        .replace(/\s*```$/, "");
+    if (!/^[[{]/.test(text))
+        return value;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return value;
+    }
+}
+const escaped = (name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+ * Arguments the model wrote inside another argument's text - `answer</a>\n<b>[...]</b>\n<c>...` - taken out of it and
+ * given as their own, where they were not given already. Which argument each was found in, for the refusal.
+ */
+function untucked(args, names) {
+    const out = { ...args };
+    const foundIn = new Map();
+    const anyTag = names.map(escaped).join("|");
+    for (const [key, value] of Object.entries(args)) {
+        if (typeof value !== "string")
+            continue;
+        let cut = value.search(new RegExp(`</${escaped(key)}>`));
+        for (const name of names) {
+            if (name === key || (out[name] !== undefined && out[name] !== ""))
+                continue;
+            const match = new RegExp(`<${escaped(name)}>([\\s\\S]*?)(?:</${escaped(name)}>|(?=<(?:${anyTag})>)|$)`).exec(value);
+            if (match === null)
+                continue;
+            out[name] = match[1].trim();
+            foundIn.set(name, key);
+            cut = cut === -1 ? match.index : Math.min(cut, match.index);
+        }
+        if (cut !== -1)
+            out[key] = value.slice(0, cut).trim();
+    }
+    return { args: out, foundIn };
+}
+/** What an entry of the list looks like, as JSON: its fields, the optional ones marked. */
+function shapeOf(item) {
+    const required = new Set(item.required ?? []);
+    const entries = Object.entries(item.properties ?? {});
+    const fields = entries.map(([name, field]) => `"${name}"${required.has(name) ? "" : "?"}: ${field.type ?? "value"}`).join(", ");
+    const sample = (field) => (field.type === "number" || field.type === "integer" ? "1" : field.type === "boolean" ? "true" : field.type === "string" ? '"..."' : "...");
+    const example = entries
+        .filter(([name]) => required.has(name))
+        .map(([name, field]) => `"${name}": ${sample(field)}`)
+        .join(", ");
+    return { fields: `{${fields}}`, example: `{${example}}` };
+}
+/** Why a list argument is not one, said so a model can make the call right next time - or undefined when it is. */
+function problemOf(list, value, foundIn) {
+    if (value === undefined)
+        return list.required ? "you left it out" : undefined;
+    if (!Array.isArray(value)) {
+        if (foundIn !== undefined)
+            return `you wrote it inside \`${foundIn}\``;
+        return typeof value === "string" ? "you sent it as text, not a list" : `you sent ${isObject(value) ? "an object" : `a ${typeof value}`}, not a list`;
+    }
+    const bad = value.findIndex((entry) => !isObject(entry));
+    if (bad === -1)
+        return undefined;
+    return `entry ${bad + 1} is ${typeof value[bad] === "string" ? "text" : `a ${typeof value[bad]}`}, not an object`;
+}
+/** The arguments with their lists made lists where they plainly are; refused, saying what is wanted, where they are not. */
+export function prepareListArguments(toolName, schema, raw) {
+    const lists = listArguments(schema);
+    if (lists.length === 0 || !isObject(raw))
+        return raw;
+    const { args, foundIn } = untucked(raw, Object.keys(schema.properties ?? {}));
+    const problems = [];
+    for (const list of lists) {
+        let value = parsed(args[list.name]);
+        if (isObject(value))
+            value = [value];
+        if (Array.isArray(value))
+            value = value.map(parsed);
+        if (value !== undefined)
+            args[list.name] = value;
+        const problem = problemOf(list, value, foundIn.get(list.name));
+        if (problem === undefined)
+            continue;
+        const { fields, example } = shapeOf(list.item);
+        problems.push(`- \`${list.name}\`: ${problem}. It is a list of objects, each ${fields} - e.g. "${list.name}": [${example}].`);
+    }
+    if (problems.length === 0)
+        return args;
+    throw new Error([
+        `${toolName} was not run - its arguments are not in the shape it takes:`,
+        ...problems,
+        "Each argument is a field of its own in the call, at the top level: a list is a JSON array of objects, never text, and never written inside another argument's text.",
+    ].join("\n"));
+}
+/** The tools, each that takes a list of objects preparing its arguments so before they are checked. */
+export function withListArguments(tools) {
+    return tools.map((tool) => {
+        const schema = tool.parameters;
+        if (listArguments(schema).length === 0)
+            return tool;
+        const before = tool.prepareArguments;
+        return {
+            ...tool,
+            prepareArguments: (args) => prepareListArguments(tool.name, schema, before !== undefined ? before(args) : args),
+        };
+    });
+}

package/dist/regenerate/loop.js

@@ -13,7 +13,7 @@ import { adoptDigests, chainTree, codeTree, conformanceTarget, REGENERATE_AGAIN,
 import { describeSpecDiffConformance, renderSpecDiffConformance } from "./conform.js";
 import { conformanceDirFor } from "./conformance.js";
 import { modulesRoot } from "./paths.js";
-import { budgetFor, choosingWhen, configForSpec, conformanceSwitchedOn } from "../config.js";
+import { budgetFor, chosenStack, choosingWhen, configForSpec, conformanceSwitchedOn, withStack } from "../config.js";
 import { describeSpecChange } from "./prompt.js";
 import { resolveTemplateDirs } from "./paths.js";
 import { builtTips, copyRequiredCode, importingModules, isImportModule, newlyRequired, resolveRequiresChain, startFromScratch } from "./requires.js";
@@ -189,6 +189,8 @@ export function createWorkLoop(options) {
     // One tick at a time: each reads the records and the spec, and decides.
     let ticking = Promise.resolve();
     const tipEntry = (state) => tipOf(state.chain);
+    /** `work` with the codebase's stack chosen - the one it was asked for with - when it has one pinned. */
+    const inStack = (state, work) => (state.stack !== undefined ? withStack(state.stack.name, work) : work());
     const keyOf = (spec) => serializeTree(codeTree(spec.tree));
     /** What a codebase is built from: its record, or - nothing built - what it starts from, the code of the module it requires. */
     const builtOf = (state) => {
@@ -811,7 +813,7 @@ export function createWorkLoop(options) {
             // A codebase left behind - built on since - is not looked at, unless a job of it is still running; what it had
             // planned, or waited for, is no longer shown.
             if (now.has(state) || state.running !== undefined)
-                await look(state);
+                await inStack(state, () => look(state));
             else {
                 state.why = "left behind: the code is built on further up the chain, where changes to it are made";
                 state.waitsFor = undefined;
@@ -963,7 +965,8 @@ export function createWorkLoop(options) {
     };
     const statusOf = (state) => describe(state).status;
     /** A codebase's status, and beside each job it lists as planned, the planned job it is - none for one being planned or scheduled. */
-    const describe = (state) => {
+    const describe = (state) => inStack(state, () => describeIn(state));
+    const describeIn = (state) => {
         // What runs next: the code's jobs, then the conformance tests' - the module's, once its code is built - the running job first.
         const running = state.running?.planned;
         const own = (jobs) => (jobs ?? []).filter((job) => job !== running);
@@ -1011,6 +1014,7 @@ export function createWorkLoop(options) {
         const status = {
             module: tip.moduleName,
             plainFile: tip.plainFile,
+            ...(state.stack?.name !== undefined ? { stack: state.stack.name } : {}),
             ...(state.running !== undefined
                 ? {
                     running: {
@@ -1027,8 +1031,11 @@ export function createWorkLoop(options) {
         };
         return { status, jobs: (state.running !== undefined ? listed.slice(1) : listed).map((item) => item.job), scheduled: (state.running !== undefined ? listed.slice(1) : listed).map((item) => (item.entry.waitsFor !== undefined ? { title: item.entry.title, specs: item.entry.cases.add.map((touched) => touched.text) } : undefined)) };
     };
-    /** Look after a codebase - its chain up to it - from now on; says its state. */
-    const track = (chain, askedFile, request) => {
+    /**
+     * Look after a codebase - its chain up to it - from now on; says its state. `pin`: the stack it is built with from now
+     * on - kept, when `keep` and it has one already.
+     */
+    const track = (chain, askedFile, request, pin) => {
         const tip = tipOf(chain);
         let state = modules.get(tip.buildDir);
         if (state === undefined) {
@@ -1043,7 +1050,10 @@ export function createWorkLoop(options) {
         }
         state.chain = chain;
         state.askedFile = askedFile;
-        const model = request.model ?? options.modelFor?.(tip.plainFile);
+        if (pin !== undefined && (pin.keep !== true || state.stack === undefined))
+            state.stack = { name: pin.name };
+        // Its model as its stack has it: a stack's file can name a coding model of its own.
+        const model = request.model ?? inStack(state, () => options.modelFor?.(tip.plainFile));
         if (model !== undefined)
             state.model = model;
         if (request.guidance !== undefined && !state.guidance.includes(request.guidance))
@@ -1056,7 +1066,10 @@ export function createWorkLoop(options) {
             const files = codebasesOf(resolve(options.cwd, plainFile));
             for (const file of files)
                 asked.set(file, { ...asked.get(file), ...request });
-            const states = withParseCache(() => files.flatMap((file) => chainsFor(file).flatMap((chain) => toBuild(chain).map((entry) => track(chain.slice(0, chain.indexOf(entry) + 1), file, request)))));
+            // Asked for, it is built with the stack chosen now - pinned, whatever is chosen later; a spec change keeps the one
+            // it was asked for with.
+            const pin = { name: chosenStack(), keep: specChange === true };
+            const states = withParseCache(() => files.flatMap((file) => chainsFor(file).flatMap((chain) => toBuild(chain).map((entry) => track(chain.slice(0, chain.indexOf(entry) + 1), file, request, pin)))));
             // Asked again, a halted codebase is tried again - one the person halted too, unless only its spec changed.
             for (const state of states) {
                 state.halted = undefined;
@@ -1110,32 +1123,34 @@ export function createWorkLoop(options) {
                 const tip = tipOf(codebase);
                 // The codebase as the loop knows it, or - never asked for - as its records have it.
                 const state = modules.get(tip.buildDir) ?? { chain: codebase, askedFile: file, guidance: [] };
-                const report = { module: tip.moduleName, plainFile: tip.plainFile, code: undefined, conformance: undefined, scheduled: [] };
-                let spec;
-                try {
-                    spec = chainSpec(codebase);
-                }
-                catch (error) {
-                    return { ...report, why: `its spec does not parse: ${error instanceof Error ? error.message : String(error)}` };
-                }
-                const from = builtOf(state);
-                const fresh = tip.requires === null && !started(tip);
-                const code = codeWork(from, spec.tree);
-                report.code = code.length === 0 ? null : casesOf(from, code, { fresh, module: tip.moduleName });
-                if (conformanceWanted(state, spec)) {
-                    const tested = testedOf(state);
-                    const tests = workOf("conformance", tested, state, spec);
-                    report.conformance = tests.length === 0 ? null : casesOf(tested, tests, { module: tip.moduleName });
-                }
-                report.scheduled = (state.scheduled ?? []).map((group) => ({ frids: group.specs.map((touched) => touched.frid), unbuilt: group.unbuilt }));
-                if (state.running !== undefined)
-                    report.running = { jobId: state.running.jobId, title: state.running.planned.title };
-                const halted = state.held?.why ?? state.halted?.why ?? state.conformanceHalted?.why;
-                if (halted !== undefined)
-                    report.why = halted;
-                if (state.startOver !== undefined)
-                    report.startOver = state.startOver;
-                return report;
+                return inStack(state, () => {
+                    const report = { module: tip.moduleName, plainFile: tip.plainFile, code: undefined, conformance: undefined, scheduled: [] };
+                    let spec;
+                    try {
+                        spec = chainSpec(codebase);
+                    }
+                    catch (error) {
+                        return { ...report, why: `its spec does not parse: ${error instanceof Error ? error.message : String(error)}` };
+                    }
+                    const from = builtOf(state);
+                    const fresh = tip.requires === null && !started(tip);
+                    const code = codeWork(from, spec.tree);
+                    report.code = code.length === 0 ? null : casesOf(from, code, { fresh, module: tip.moduleName });
+                    if (conformanceWanted(state, spec)) {
+                        const tested = testedOf(state);
+                        const tests = workOf("conformance", tested, state, spec);
+                        report.conformance = tests.length === 0 ? null : casesOf(tested, tests, { module: tip.moduleName });
+                    }
+                    report.scheduled = (state.scheduled ?? []).map((group) => ({ frids: group.specs.map((touched) => touched.frid), unbuilt: group.unbuilt }));
+                    if (state.running !== undefined)
+                        report.running = { jobId: state.running.jobId, title: state.running.planned.title };
+                    const halted = state.held?.why ?? state.halted?.why ?? state.conformanceHalted?.why;
+                    if (halted !== undefined)
+                        report.why = halted;
+                    if (state.startOver !== undefined)
+                        report.startOver = state.startOver;
+                    return report;
+                });
             })));
         },
         async conformance(plainFile, request = {}) {
@@ -1176,7 +1191,7 @@ export function createWorkLoop(options) {
                     }
                 }
             }
-            const tracked = withParseCache(() => (wentBack ? [own] : chainsFor(file)).flatMap((chain) => toBuild(chain).map((entry) => track(chain.slice(0, chain.indexOf(entry) + 1), file, request))));
+            const tracked = withParseCache(() => (wentBack ? [own] : chainsFor(file)).flatMap((chain) => toBuild(chain).map((entry) => track(chain.slice(0, chain.indexOf(entry) + 1), file, request, { name: chosenStack() }))));
             // The module asked for, in its own codebase - and those below it: never the codebases built on it.
             const asking = tracked.find((state) => tipEntry(state).buildDir === self.buildDir);
             const states = asking !== undefined ? tracked.filter((state) => own.some((entry) => entry.buildDir === tipEntry(state).buildDir)) : tracked;
@@ -1194,7 +1209,7 @@ export function createWorkLoop(options) {
             // On for the whole module already - asked for before, or by the config: asked again, nothing changes, and it is said.
             const already = new Set(states.filter((state) => {
                 const file = tipEntry(state).plainFile;
-                return (state.conformance !== undefined && state.conformance.chosen === undefined) || (configConformance(file) && !configChosen(file));
+                return (state.conformance !== undefined && state.conformance.chosen === undefined) || inStack(state, () => configConformance(file) && !configChosen(file));
             }));
             // Only the module asked for: the modules below it keep their conformance tests as their config and choices have them.
             for (const state of tip !== undefined ? [tip] : []) {
@@ -1247,17 +1262,21 @@ export function createWorkLoop(options) {
                 startAgain(entry, `it now requires ${requires.join(", ")}, which its code was not built on`);
             return loop.bringUp(plainFile, request);
         },
-        async fromScratch(plainFile, request = {}) {
+        async fromScratch(plainFile, { chain, ...request } = {}) {
             const file = resolve(options.cwd, plainFile);
-            // Where its code lives: the tips its module is built in, or - none built yet - its own codebase.
-            const codebases = chainsFor(file).map(tipOf);
+            // Where its code lives: the tips its module is built in, or - none built yet - its own codebase. The whole chain:
+            // every codebase in those chains, bottom first - a tip taken back to nothing is otherwise started from a copy of
+            // the code below it.
+            const chains = chainsFor(file);
+            const codebases = [...new Map((chain === true ? chains.flat() : chains.map(tipOf)).map((entry) => [entry.buildDir, entry])).values()];
             for (const entry of codebases) {
                 if (modules.get(entry.buildDir)?.running !== undefined)
                     throw new Error(`${entry.moduleName} has a pulse running: halt it, or ask again once it is done.`);
             }
+            const why = chain === true ? "asked to be regenerated from scratch, with its whole chain" : "asked to be regenerated from scratch";
             for (const entry of codebases)
                 if (started(entry))
-                    startAgain(entry, "asked to be regenerated from scratch");
+                    startAgain(entry, why);
             return loop.bringUp(plainFile, request);
         },
         halt(target, reason) {
@@ -1398,7 +1417,7 @@ export function createWorkLoop(options) {
                         plainFile: tip.plainFile,
                         buildDir: tip.buildDir,
                         pulses,
-                        conformance: state.conformance !== undefined || configConformance(tip.plainFile),
+                        conformance: state.conformance !== undefined || inStack(state, () => configConformance(tip.plainFile)),
                         ...(state.planning !== undefined ? { planning: state.planning } : {}),
                         ...(running === undefined && state.waitsFor !== undefined ? { waitsFor: state.waitsFor } : {}),
                         ...(running === undefined && state.why !== undefined ? { why: state.why } : {}),
@@ -1409,7 +1428,11 @@ export function createWorkLoop(options) {
         },
         async drain() {
             for (;;) {
-                await ticking;
+                // A pulse that settles meanwhile ticks again: its next pulse is started by that tick, so it is waited for too.
+                const looking = ticking;
+                await looking;
+                if (looking !== ticking)
+                    continue;
                 const running = order.map((key) => modules.get(key).running?.jobId).filter((id) => id !== undefined);
                 if (running.length === 0)
                     return;
@@ -1518,7 +1541,7 @@ export function describeModules(statuses, options = {}) {
                 `  Ask the user whether to start ${codebases.join(", ")} over, and say why: ${codebases.join(", ")} was built without ` +
                     `${requires.join(", ")}, so no change to its code can bring ${requires.join(", ")} in - its code and conformance ` +
                     "tests are taken out, kept in its history, and built again from the bottom of the chain. Only if they agree, " +
-                    `call regenerate with ${basename(status.plainFile)} and from_scratch.`,
+                    `call regenerate with ${basename(status.plainFile)} and from_scratch: "module".`,
             ];
     };
     return statuses
@@ -1526,7 +1549,7 @@ export function describeModules(statuses, options = {}) {
         // Nothing to do there: said in a sentence, not as a status.
         if (isUpToDate(status))
             return `${status.module} is up to date: its code is built from the spec as it is now in ${basename(status.plainFile)}, so there is nothing to regenerate.`;
-        const lines = [`${status.module} (${basename(status.plainFile)}):`];
+        const lines = [`${status.module} (${basename(status.plainFile)}${status.stack !== undefined ? `, stack ${status.stack}` : ""}):`];
         if (status.running !== undefined) {
             lines.push(`  running: pulse ${status.running.jobId} - ${status.running.title}`);
             // Steered, not stopped or planned again: what changed went to its agent.

package/dist/regenerate/panel-dock.js

@@ -1,15 +1,16 @@
 import { HStack } from "@earendil-works/pi-tui";
+import { unpadded } from "../screen-padding.js";
 /**
  * The side panel beside the chat rather than over it: the chat drawn on the left in what the panel leaves it, the panel
  * laid over the columns on the right.
  *
  * pi draws its screen one of two ways, and the chat is narrowed in each as it is drawn: full screen (pi's default), a
  * layout - its root put in a row beside a filler as wide as the panel; the regular screen, the lines its render gives -
- * asked for in fewer columns.
+ * asked for in fewer columns. Either way inside the screen's padding (`screen-padding.ts`), when it has one.
  */
 /** Narrower than this, the chat and the panel have no room side by side: the panel takes the whole screen. */
 const SHARED_FROM = 100;
-/** The columns the panel takes beside the chat: half the screen, the rule between them in the middle - 0 when the terminal is too narrow to share. */
+/** The columns the panel takes beside the chat: half of what they share, the rule between them in the middle - 0 when that is too narrow to share. */
 export function dockedWidth(columns) {
     return columns < SHARED_FROM ? 0 : Math.floor(columns / 2);
 }
@@ -20,14 +21,15 @@ export function dockedWidth(columns) {
 export function narrowChat(tui, panelWidth) {
     const screen = tui;
     if (typeof screen.setLayoutRoot === "function" && screen.layoutRoot !== undefined) {
-        const root = screen.layoutRoot;
+        // What the padding pads: the row goes inside it, and is padded as it is set.
+        const root = unpadded(screen.layoutRoot);
         // A line as wide as the panel: the row gives the filler what it measures, the chat the rest.
         const filler = { render: () => [" ".repeat(panelWidth())], invalidate() { } };
         screen.setLayoutRoot(new HStack([{ component: root, basis: 0, grow: 1 }, { component: filler }]));
         return () => screen.setLayoutRoot(root);
     }
-    // Read from the prototype: the screen's own render, not one laid over it.
-    const render = Object.getPrototypeOf(tui).render;
+    // The render the screen has now - padded, when it is.
+    const render = screen.render;
     screen.render = function (width) {
         return render.call(this, Math.max(1, width - panelWidth()));
     };

package/dist/regenerate/plain-palette.js

@@ -1,45 +1,53 @@
-/** On a dark surface - turri-dark's #0f0f0f, pi's dark ones. Every colour at least 7:1 on it, and 4.5:1 on the fills. */
+/**
+ * On a dark surface - turri-dark's abyss, #0a0f1a, pi's dark ones - in the design system's colours alone: a section's
+ * header in pink, a concept in neon, text in quotes or backticks in siesta tan. Every colour at least 7:1 on abyss and 4.8:1 on the blue whale fill
+ * of an added line; on the eggplant of a removed one, the design system's only fill of that warmth, its pinks and
+ * grauzone drop to 3.7:1.
+ */
 const DARK = {
     roles: {
-        section: { colour: "#fcd34d", bold: true },
-        concept: { colour: "#7dd3fc" },
-        link: { colour: "#c4b5fd", underline: true },
-        literal: { colour: "#fdba74" },
-        keyword: { colour: "#f9a8d4", bold: true },
-        module: { colour: "#5eead4" },
-        comment: { colour: "#b4bfcf", italic: true },
-        bullet: { colour: "#b4bfcf" },
+        section: { colour: "#ff7fa6", bold: true },
+        concept: { colour: "#5ce1e6" },
+        link: { colour: "#f4f7f9", underline: true },
+        literal: { colour: "#e9d8c8" },
+        keyword: { colour: "#f4f7f9", bold: true },
+        module: { colour: "#f4f7f9" },
+        comment: { colour: "#85a3b2", italic: true },
+        bullet: { colour: "#85a3b2" },
     },
-    added: "#86efac",
-    removed: "#fca5a5",
-    addedFill: "#1f4d2e",
-    removedFill: "#5c2323",
-    muted: "#808080",
+    added: "#5ce1e6",
+    removed: "#ff7fa6",
+    addedFill: "#1e3442",
+    removedFill: "#732553",
+    muted: "#85a3b2",
 };
-/** On a light surface - turri-light's white, pi's light ones. Every colour at least 7:1 on it, and 5:1 on the fills. */
+/**
+ * On a light surface - turri-light's white, pi's light ones - in the design system's deep colours, the only ones it has
+ * that read on white. Every colour at least 7:1 on white, and 5:1 on the neon hover and siesta tan fills.
+ */
 const LIGHT = {
     roles: {
-        section: { colour: "#0a1fd4", bold: true },
-        concept: { colour: "#155e75" },
-        link: { colour: "#6d28d9", underline: true },
-        literal: { colour: "#92400e" },
-        keyword: { colour: "#9d174d", bold: true },
-        module: { colour: "#065f46" },
-        comment: { colour: "#475569", italic: true },
-        bullet: { colour: "#475569" },
+        section: { colour: "#3e5a6b", bold: true },
+        concept: { colour: "#732553" },
+        link: { colour: "#1e3442", underline: true },
+        literal: { colour: "#1e3442" },
+        keyword: { colour: "#0a0f1a", bold: true },
+        module: { colour: "#1e3442" },
+        comment: { colour: "#3e5a6b", italic: true },
+        bullet: { colour: "#3e5a6b" },
     },
-    added: "#166534",
-    removed: "#991b1b",
-    addedFill: "#d3f5dc",
-    removedFill: "#fcd9d9",
-    muted: "#6b7280",
+    added: "#1e3442",
+    removed: "#732553",
+    addedFill: "#8eebee",
+    removedFill: "#e9d8c8",
+    muted: "#3e5a6b",
 };
 const rgb = (hex) => {
     const value = Number.parseInt(hex.slice(1), 16);
     return [(value >> 16) & 255, (value >> 8) & 255, value & 255];
 };
 /** A colour's SGR parameters: 24-bit, or the nearest of the 256 where the terminal has no more. */
-function sgr(hex, background, truecolor) {
+export function sgr(hex, background, truecolor) {
     const [r, g, b] = rgb(hex);
     if (truecolor)
         return `${background ? 48 : 38};2;${r};${g};${b}`;
@@ -57,17 +65,24 @@ const fillWith = (hex, text, truecolor) => {
     return `${on}${text.replace(/\x1b\[(?:0|49)?m/g, (reset) => `${reset}${on}`)}\x1b[49m`;
 };
 /**
- * Brand blue, for what is shown to do what its spec says - regen's ◆. Brand blue itself on a light surface, 9.72:1
- * on white; on a dark one, where it is illegible (1.97:1 on brand black - see docs/theming.md), its tint 55% of the way
- * to white, 7.34:1 on brand black.
+ * Neon, for what is shown to do what its spec says - regen's ◆: the design system's colour for what can be followed,
+ * 12.2:1 on abyss. On a light surface, where neon is illegible (1.6:1 on white), blue whale, 12.9:1 on white.
  */
-export const BRAND_BLUE = { light: "#0a1fd4", dark: "#919aec" };
-/** Text in brand blue on a theme - its tint on a dark one - in as many colours as the terminal has. */
-export function brandBlue(theme) {
-    const colour = theme.appearance === "light" ? BRAND_BLUE.light : BRAND_BLUE.dark;
+export const BRAND_NEON = { light: "#1e3442", dark: "#5ce1e6" };
+/**
+ * Pink, the one pink thing in a view - the banner's wordmark: 6.54:1 on abyss. On a light surface, where pink is
+ * too pale (2.9:1 on white), eggplant, 9.9:1 on white.
+ */
+export const BRAND_PINK = { light: "#732553", dark: "#ff5c8d" };
+const brandInk = (colours) => (theme) => {
+    const colour = theme.appearance === "light" ? colours.light : colours.dark;
     const truecolor = (theme.getColorMode?.() ?? "truecolor") === "truecolor";
     return (text) => paintWith({ colour, bold: true }, text, truecolor);
-}
+};
+/** Text in neon on a theme - blue whale on a light one - in as many colours as the terminal has. */
+export const brandNeon = brandInk(BRAND_NEON);
+/** Text in pink on a theme - eggplant on a light one - in as many colours as the terminal has. */
+export const brandPink = brandInk(BRAND_PINK);
 /** How a spec diff is painted on a theme: its palette by whether the theme is dark or light, in as many colours as the terminal has. */
 export function plainPaint(theme) {
     const palette = theme.appearance === "light" ? LIGHT : DARK;

package/dist/regenerate/regenerate.js

@@ -281,9 +281,11 @@ export async function renderSpecDiff(options) {
     const work = createWorkLedger();
     // What it checks its own work with: the diff its reviewer is shown, and whether a test catches a bug - neither decides anything.
     const gate = createUnitGate(buildDir, scripts.unit);
+    // can_it_fail, for the coding agent and its reviewer: on unless mutation-testing says otherwise.
+    const mutationTesting = scripts.unit !== undefined && configForSpec(tip.plainFile).mutationTesting !== false;
     const selfChecks = [
         createMyDiffTool({ dir: buildDir, what: "code" }),
-        ...(scripts.runOn === "copy" ? [createCanItFailTool({ buildDir, script: scripts.unit })] : []),
+        ...(mutationTesting ? [createCanItFailTool({ buildDir, script: scripts.unit })] : []),
     ];
     // A server it built, it can start and try from outside - stopped when it is done.
     const services = createServiceTools({ dir: buildDir });
@@ -499,7 +501,7 @@ export async function renderSpecDiff(options) {
                 forChange: true,
                 ...(options.cases !== undefined ? { cases: options.cases } : {}),
                 label: `${moduleName} spec change`,
-                ...(scripts.runOn === "copy" ? { unitScript: scripts.unit } : {}),
+                ...(mutationTesting ? { unitScript: scripts.unit } : {}),
                 testingScript: { path: relative(root, scripts.unit), content: readFileSync(scripts.unit, "utf8") },
                 model: options.judgeModel ?? modelSpec(inheritModel(configForSpec(tip.plainFile).judgeModel, modelOnly(options.model))),
                 send: async (next) => {

package/dist/regenerate/self-check.js

@@ -1,9 +1,9 @@
-import { readFileSync, writeFileSync } from "node:fs";
-import { join, relative, resolve, sep } from "node:path";
+import { readFileSync } from "node:fs";
+import { relative, resolve, sep } from "node:path";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { workDiff } from "./lineage.js";
-import { lastPassingMs, runOnCode } from "./test-scripts.js";
+import { lastPassingMs, runOnCode, scriptsRunInPlace } from "./test-scripts.js";
 /**
  * Tools an agent checks its own work with, before the harness and the reviewer do: the diff the reviewer is shown, and
  * whether a test catches a change to the code. Neither decides anything - the testing scripts, run by the harness, still do.
@@ -43,16 +43,23 @@ export function canItFailLimitMs(buildDir, script) {
  */
 export function createCanItFailTool(options) {
     let left = options.runs ?? CAN_IT_FAIL_RUNS;
+    // In place, the change is made to the code itself for the run, and undone after it: the scripts run on the code there.
+    const inPlace = scriptsRunInPlace(options.buildDir);
     return defineTool({
         name: "can_it_fail",
         label: "Can it fail",
         description: "Check that the unit tests catch a bug: give one change to the code that breaks a behaviour the specification " +
             "states - a value or a status changed, a check taken out, a condition turned round where it cannot make a loop run for " +
             "ever - and the unit testing script " +
-            "runs on a copy of the code with that change. The code itself is never touched. The tests should fail; if they all " +
+            (inPlace
+                ? "runs with that change made to the code, which is put back as it was once the run ends, whatever its result. "
+                : "runs on a copy of the code with that change. The code itself is never touched. ") +
+            "The tests should fail; if they all " +
             "pass, no test catches that bug. Make a change that still builds and runs: a failure only because it no longer " +
             `compiles or imports says nothing about the tests. ${options.runs ?? CAN_IT_FAIL_RUNS} runs at most.`,
-        promptSnippet: "can_it_fail: whether the unit tests catch a bug you put in a copy of the code",
+        promptSnippet: "can_it_fail: whether the unit tests catch a bug you put in the code for one run",
+        // Never beside another call: in place, an edit made while the bug is in would be undone with it.
+        executionMode: "sequential",
         parameters: Type.Object({
             file: Type.String({ description: "The code file to change, relative to the code folder" }),
             find: Type.String({ description: "Text that is in the file exactly once - the code to change" }),
@@ -83,7 +90,7 @@ export function createCanItFailTool(options) {
             left -= 1;
             let run;
             try {
-                run = await runOnCode(options.buildDir, options.script, "unit testing script, with the change", (copy) => writeFileSync(join(copy, relative(options.buildDir, path)), text.slice(0, at) + replace + text.slice(at + find.length)), canItFailLimitMs(options.buildDir, options.script));
+                run = await runOnCode(options.buildDir, options.script, "unit testing script, with the change", { file: relative(options.buildDir, path), text: text.slice(0, at) + replace + text.slice(at + find.length) }, canItFailLimitMs(options.buildDir, options.script));
             }
             catch (error) {
                 return say(error instanceof Error ? error.message : String(error));

package/dist/regenerate/side-panel.js

@@ -16,7 +16,7 @@ export function createSidePanel(options) {
     const backKeys = () => {
         if (options.dock === undefined)
             return [`esc or ${options.key} back to the chat`];
-        return options.dock.docked() ? ["s full screen", "esc or ⌥⌘← to the chat", `${options.key} close`] : ["s beside the chat", `esc or ${options.key} back to the chat`];
+        return options.dock.docked() ? [`${options.key} or esc to the chat`, "ctrl+c close", "s full screen"] : ["s beside the chat", `esc or ${options.key} back to the chat`];
     };
     const waitingNote = () => 
     // A question asked while it showed waits in the chat, unanswered: the person is told it is there.