@turri-dev/cli 0.1.4-next.318a98a → 0.1.4-next.5a8c6e5

package/dist/ask.js

@@ -9,6 +9,9 @@ import { PANEL_KEY } from "./regenerate/job-panel.js";
 export const OTHER_OPTION = "Something else…";
 export const CHAT_OPTION = "Chat about this";
 export const DONE_OPTION = "Done — that's all of them";
+/** An option's box in a question of several, ticked and not. */
+export const TICKED = "☑";
+export const UNTICKED = "☐";
 export const DISMISSED = "The user dismissed the question without answering.";
 /** How an answer that is no answer starts: the person chose to talk about the question first. */
 export const CHAT_PREFIX = "The user has not answered this question yet: they chose to talk about it first.";
@@ -107,32 +110,48 @@ export async function runAsk(asked, io) {
             return choice;
         }
     }
-    // Pick several: keep offering what is left until they say they are done.
-    const chosen = [];
-    let remaining = [...options];
-    while (remaining.length > 0) {
-        const title = chosen.length === 0 ? request.question : `${request.question}  [so far: ${chosen.join(", ")}]`;
-        const choice = await io.select(title, [...remaining, ...extras, DONE_OPTION], context);
-        if (choice === undefined)
-            break;
-        if (choice === DONE_OPTION)
+    // Pick several: every option a box, ticked and unticked as it is chosen, until they say they are done. What they type
+    // is one more box, ticked - and can be unticked too. Something else, Chat about this and Done are no boxes.
+    const listed = [...options];
+    const ticked = new Set();
+    const picked = () => listed.filter((option) => ticked.has(option));
+    let at = 0;
+    for (;;) {
+        const rows = listed.map((option) => `${ticked.has(option) ? TICKED : UNTICKED} ${option}`);
+        const choice = await io.select(request.question, [...rows, ...extras, DONE_OPTION], context, at);
+        if (choice === undefined || choice === DONE_OPTION)
             break;
         if (choice === OTHER_OPTION) {
+            at = listed.length;
             const typed = await typeInstead();
-            if (!typedNothing(typed))
-                chosen.push(typed.trim());
+            if (typedNothing(typed))
+                continue;
+            const option = typed.trim();
+            if (!listed.includes(option))
+                listed.push(option);
+            ticked.add(option);
+            at = listed.indexOf(option);
             continue;
         }
         if (choice === CHAT_OPTION) {
+            at = listed.length + extras.indexOf(CHAT_OPTION);
             const said = await chatAbout();
             if (typedNothing(said))
                 continue;
-            return chatAnswer(said, chosen);
+            return chatAnswer(said, picked());
         }
-        chosen.push(choice);
-        remaining = remaining.filter((option) => option !== choice);
+        // A row, or - where the answer is typed, on the command line - an option by its text, or one more of their own.
+        const row = rows.indexOf(choice);
+        const option = row !== -1 ? listed[row] : choice.trim();
+        if (!listed.includes(option))
+            listed.push(option);
+        if (ticked.has(option))
+            ticked.delete(option);
+        else
+            ticked.add(option);
+        at = listed.indexOf(option);
     }
-    return chosen.length > 0 ? chosen.join(", ") : DISMISSED;
+    return ticked.size > 0 ? picked().join(", ") : DISMISSED;
 }
 /**
  * While a question is open, what catches ctrl+h on the terminal's input: pi gives an extension's shortcut only the keys

package/dist/brand.js

@@ -2,8 +2,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 /**
- * turri's colours for what its command line prints - the ones its themes use (.pi/themes): on a dark terminal its lime
- * accent and green, on a light one its blue. Nothing is coloured when the output is not a terminal, or NO_COLOR is set;
+ * turri's colours for what its command line prints - the design system's, as its themes use them (.pi/themes): on a
+ * dark terminal neon and pink, on a light one blue whale and eggplant. Nothing is coloured when the output is not a terminal, or NO_COLOR is set;
  * a terminal without 24-bit colour gets the nearest of its sixteen.
  */
 /** Whether the terminal is light: COLORFGBG says so (a light background, 7 or 15), or pi's theme is a light one. */
@@ -35,15 +35,15 @@ function paint(stream = process.stdout) {
     };
     return {
         /** turri's accent: what to look at - a heading, a choice's number, the command to run. */
-        accent: light ? ink("#0a1fd4", 34) : ink("#e0ff6e", 93),
+        accent: light ? ink("#1e3442", 34) : ink("#5ce1e6", 96),
         /** Done, and what was written. */
-        success: light ? ink("#223936", 32) : ink("#79fc96", 92),
+        success: light ? ink("#732553", 35) : ink("#ff5c8d", 95),
         /** What is wrong: what stops turri. */
-        error: light ? ink("#d00505", 31) : ink("#dd5353", 91),
+        error: ink("#ff7a3d", 33),
         /** What works, with limits. */
-        warning: ink("#dc6803", 33),
+        warning: ink("#ff7a3d", 33),
         /** What goes with it, and can be skimmed. */
-        muted: ink("#808080", 90),
+        muted: light ? ink("#3e5a6b", 90) : ink("#85a3b2", 37),
         bold: (text) => (on ? `\x1b[1m${text}\x1b[22m` : text),
     };
 }

package/dist/cli-options.js

@@ -1,4 +1,4 @@
-import { conformanceOption, overrideConfig, reviewOption, splitModelSpec } from "./config.js";
+import { booleanOption, conformanceOption, overrideConfig, splitModelSpec } from "./config.js";
 /**
  * The command line of turri's commands: their words, and the options that stand for the config's own keys - kept apart
  * from the commands that use them, so a light one (doctor) reads them as a regenerate does without loading it.
@@ -51,19 +51,24 @@ export function optionValue(options, name) {
 }
 /**
  * The options that stand for the config's own keys - `--harness-model`, `--coding-model` (`--model`), `--judge-model`
- * and, as asked, `--review` and `--conformance-tests` - read as if config.turri.yaml had them, in their place in the
+ * and, as asked, `--review`, `--mutation-testing` and `--conformance-tests` - read as if config.turri.yaml had them, in their place in the
  * order the config resolves them in (overrideConfig): a run, or doctor, with them is the same as one with them in the
  * file. Exits on a value it cannot read.
  */
 export function configKeyOptions(options, take = {}) {
+    const flag = (name) => {
+        const given = take.review === true ? optionValue(options, name) : undefined;
+        const value = given !== undefined ? booleanOption(given) : undefined;
+        if (given !== undefined && value === undefined)
+            failOption(`--${name} takes true or false, not ${given}`);
+        return value;
+    };
     const tests = take.conformance === true ? optionValue(options, "conformance-tests") : undefined;
     const setting = tests !== undefined ? conformanceOption(tests) : undefined;
     if (tests !== undefined && setting === undefined)
         failOption(`--conformance-tests takes all, chosen, module or false, not ${tests}`);
-    const reviewed = take.review === true ? optionValue(options, "review") : undefined;
-    const review = reviewed !== undefined ? reviewOption(reviewed) : undefined;
-    if (reviewed !== undefined && review === undefined)
-        failOption(`--review takes true or false, not ${reviewed}`);
+    const review = flag("review");
+    const mutationTesting = flag("mutation-testing");
     const model = (name, key) => {
         const spec = optionValue(options, name);
         return spec !== undefined ? { [key]: splitModelSpec(spec) } : {};
@@ -74,6 +79,7 @@ export function configKeyOptions(options, take = {}) {
         ...model("judge-model", "judgeModel"),
         ...(setting !== undefined ? { conformanceTests: setting } : {}),
         ...(review !== undefined ? { review } : {}),
+        ...(mutationTesting !== undefined ? { mutationTesting } : {}),
     });
 }
 function failOption(message) {

package/dist/config-edit.js

@@ -59,6 +59,7 @@ export function settings(rules = []) {
         { key: "conformance-tests", about: "which functional specs get conformance tests", kind: "choice", options: ["all", "chosen", "module", "false"], unset: "all, where a module has test reqs", effect: "next-plan" },
         { key: "conformance-budget", about: "under conformance-tests: chosen or module, how many may be chosen - a count or a share", kind: "budget", options: ["10%", "30%", "50%", "5", "10"], unset: "no limit", effect: "next-plan" },
         { key: "review", about: "whether the code and its tests are reviewed once they pass", kind: "boolean", unset: "true", effect: "next-pulse" },
+        { key: "mutation-testing", about: "whether the coding agent and the reviewer can put a bug in the code for one test run (can_it_fail)", kind: "boolean", unset: "true", effect: "next-pulse" },
         { key: "allow-to-stop-jobs", about: "whether turri stops a running pulse the spec has moved on from", kind: "boolean", unset: "true", effect: "now" },
         { key: "release-after-pulse", about: "whether every pulse that lands code releases it", kind: "boolean", unset: "false", effect: "next-landing" },
         { key: "unittests-script", about: "the unit testing script, by path from the project root", kind: "path", unset: "the one run_unittests*.sh found", effect: "next-test-run" },

package/dist/config.js

@@ -21,6 +21,7 @@ import { projectDirOf } from "./regenerate/paths.js";
  * conformance-tests: chosen                                 # all, chosen (those with acceptance tests, and those the chooser picks after each pulse), module (the chooser picks, and plans, once the module is regenerated) or false (default: false)
  * conformance-budget: 30%                                   # under chosen or module: how many functional specs a module may have chosen, beside those with acceptance tests - a count or a share (default: no limit)
  * review: false                                             # review the code and its tests once they pass (default: true)
+ * mutation-testing: false                                   # give the coding agent and the reviewer can_it_fail (default: true)
  * allow-to-stop-jobs: false                                 # stop a running job the spec moved on from (default: true)
  * release-after-pulse: true                                 # release what each pulse lands, as its last stage, before the next pulse (default: false)
  * rules-off: [integrations]                                 # ***plain rules to leave out of the prompts, by name (default: none)
@@ -331,6 +332,7 @@ export const CONFIG_KEYS = {
     conformanceTests: "conformance-tests",
     conformanceBudget: "conformance-budget",
     review: "review",
+    mutationTesting: "mutation-testing",
     allowToStopJobs: "allow-to-stop-jobs",
     releaseAfterPulse: "release-after-pulse",
     unittestsScript: "unittests-script",
@@ -416,8 +418,8 @@ export function overrideConfig(overrides) {
 export function conformanceOption(value) {
     return conformanceSetting(value);
 }
-/** `--review <value>`: the config's own, true or false. Undefined for anything else. */
-export function reviewOption(value) {
+/** `--review <value>`, `--mutation-testing <value>`: the config's own, true or false. Undefined for anything else. */
+export function booleanOption(value) {
     const word = value.trim().toLowerCase();
     return word === "true" ? true : word === "false" ? false : undefined;
 }
@@ -487,6 +489,7 @@ function readConfigFile(path) {
         conformanceTests: conformanceSetting(conformance),
         conformanceBudget: budgetSetting(raw[CONFIG_KEYS.conformanceBudget]),
         review: typeof raw[CONFIG_KEYS.review] === "boolean" ? raw[CONFIG_KEYS.review] : undefined,
+        mutationTesting: typeof raw[CONFIG_KEYS.mutationTesting] === "boolean" ? raw[CONFIG_KEYS.mutationTesting] : undefined,
         allowToStopJobs: typeof raw[CONFIG_KEYS.allowToStopJobs] === "boolean" ? raw[CONFIG_KEYS.allowToStopJobs] : undefined,
         releaseAfterPulse: typeof raw[CONFIG_KEYS.releaseAfterPulse] === "boolean" ? raw[CONFIG_KEYS.releaseAfterPulse] : undefined,
         unittestsScript: text(raw[CONFIG_KEYS.unittestsScript]),

package/dist/cultivate-cli.js

@@ -7,40 +7,33 @@ import { skillRunDir } from "./regenerate/paths.js";
 import { loadSkill } from "./skill.js";
 import { discoverSkills } from "./skills.js";
 import { PACKAGE_ROOT } from "./environment.js";
-const c = {
-    dim: (s) => `\x1b[2m${s}\x1b[0m`,
-    bold: (s) => `\x1b[1m${s}\x1b[0m`,
-    green: (s) => `\x1b[32m${s}\x1b[0m`,
-    red: (s) => `\x1b[31m${s}\x1b[0m`,
-    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
-    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
-};
+import { c } from "./module-report.js";
 const reporter = {
-    step: (name, attempt) => console.log(`\n${c.bold(c.cyan(`> step ${name}`))} ${c.dim(`attempt ${attempt}`)}`),
+    step: (name, attempt) => console.log(`\n${c.bold(c.accent(`> step ${name}`))} ${c.dim(`attempt ${attempt}`)}`),
     artifact: (path, body) => {
         console.log(c.dim(`  ${path}:`));
         for (const line of body.split("\n"))
             console.log(c.dim(`  | ${line}`));
     },
     gate: (name, judges) => console.log(judges === 0
-        ? `${c.bold(c.yellow(`> gate ${name}`))} ${c.dim("no artifact - failing without spending judges")}`
-        : `${c.bold(c.yellow(`> gate ${name}`))} ${c.dim(`${judges} independent judges`)}`),
+        ? `${c.bold(c.warning(`> gate ${name}`))} ${c.dim("no artifact - failing without spending judges")}`
+        : `${c.bold(c.warning(`> gate ${name}`))} ${c.dim(`${judges} independent judges`)}`),
     livePass: (step, scope, findings) => console.log(findings === 0
         ? c.dim(`  review ${step}: ${scope} - clean`)
-        : `  ${c.yellow(`review ${step}`)}: ${scope} ${c.dim(`- ${findings} to fix`)}`),
+        : `  ${c.warning(`review ${step}`)}: ${scope} ${c.dim(`- ${findings} to fix`)}`),
     liveReview: (name, passes, findings) => console.log(findings === 0
-        ? `${c.bold(c.yellow(`> gate ${name}`))} ${c.dim(`reviewer read along in ${passes} passes, nothing outstanding`)}`
-        : `${c.bold(c.yellow(`> gate ${name}`))} ${c.dim(`${findings} unresolved from the reviewer - failing without spending judges`)}`),
+        ? `${c.bold(c.warning(`> gate ${name}`))} ${c.dim(`reviewer read along in ${passes} passes, nothing outstanding`)}`
+        : `${c.bold(c.warning(`> gate ${name}`))} ${c.dim(`${findings} unresolved from the reviewer - failing without spending judges`)}`),
     judge: (index, model, verdict, violations) => {
-        const mark = verdict === "pass" ? c.green("pass") : c.red(verdict);
+        const mark = verdict === "pass" ? c.success("pass") : c.error(verdict);
         console.log(`  judge ${index + 1} ${c.dim(`(${model})`)}: ${mark}${violations ? c.dim(` (${violations})`) : ""}`);
     },
     outcome: (name, decision, critique) => {
         const colour = {
-            advance: c.green,
-            retry: c.yellow,
-            escalate: c.yellow,
-            abort: c.red,
+            advance: c.success,
+            retry: c.warning,
+            escalate: c.warning,
+            abort: c.error,
         };
         console.log(`  ${c.bold(colour[decision](decision))} ${c.dim(`<- gate ${name}`)}`);
         if (critique)
@@ -78,7 +71,7 @@ async function main() {
             select: async (title, options, context) => {
                 const rl = createInterface({ input: process.stdin, output: process.stdout });
                 const list = options.map((option, i) => `  ${c.bold(String(i + 1))}. ${option}`).join("\n");
-                const reply = (await rl.question(`\n${context !== undefined ? `${context}\n\n` : ""}${c.bold(c.cyan("? "))}${title}\n${list}\n> `)).trim();
+                const reply = (await rl.question(`\n${context !== undefined ? `${context}\n\n` : ""}${c.bold(c.accent("? "))}${title}\n${list}\n> `)).trim();
                 rl.close();
                 const index = Number.parseInt(reply, 10);
                 if (Number.isInteger(index) && index >= 1 && index <= options.length)
@@ -87,13 +80,13 @@ async function main() {
             },
             input: async (title, context) => {
                 const rl = createInterface({ input: process.stdin, output: process.stdout });
-                const reply = (await rl.question(`\n${context !== undefined ? `${context}\n\n` : ""}${c.bold(c.cyan("? "))}${title}\n> `)).trim();
+                const reply = (await rl.question(`\n${context !== undefined ? `${context}\n\n` : ""}${c.bold(c.accent("? "))}${title}\n> `)).trim();
                 rl.close();
                 return reply === "" ? undefined : reply;
             },
         }),
         escalate: async ({ question, critique }) => {
-            console.log(`\n${c.bold(c.yellow("! human review required"))}`);
+            console.log(`\n${c.bold(c.warning("! human review required"))}`);
             console.log(c.dim(critique));
             const rl = createInterface({ input: process.stdin, output: process.stdout });
             const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
@@ -101,7 +94,7 @@ async function main() {
             return answer === "y";
         },
     });
-    console.log(`\n${result.ok ? c.green(c.bold("run complete")) : c.red(c.bold("run aborted at a gate"))} ${c.dim(`artifacts in ${relative(cwd, skillRunDir(cwd, skill.name))}`)}`);
+    console.log(`\n${result.ok ? c.success(c.bold("run complete")) : c.error(c.bold("run aborted at a gate"))} ${c.dim(`artifacts in ${relative(cwd, skillRunDir(cwd, skill.name))}`)}`);
     process.exit(result.ok ? 0 : 1);
 }
 main().catch((err) => {

package/dist/extension.js

@@ -5,7 +5,7 @@ import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { conversationCommand, conversationSettled, conversationWriting } from "./regenerate/conversation-writes.js";
 import { fileURLToPath } from "node:url";
-import { allocateImageId, Box, getCapabilities, getPngDimensions, isKeyRelease, isKeyRepeat, matchesKey, renderImage, Text, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { allocateImageId, Box, getCapabilities, getPngDimensions, isKeyRelease, isKeyRepeat, matchesKey, renderImage, Text, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { CODING_MODEL_ENV } from "./chat-models.js";
@@ -16,7 +16,7 @@ import { readScript, scriptAgainstMachine, stackOnMachine, toolchainsBlock } fro
 import { sandboxAvailable, sandboxSummary } from "./regenerate/os-sandbox.js";
 import { findTestScripts } from "./regenerate/test-scripts.js";
 import { createAskUserTool } from "./tools.js";
-import { asksFromScratch, driftTool, fromWorkingDir, haltTool, loopReply, MODEL_PARAM, regenerateTool, stopJob, WAIT_PARAM, WORKING_DIR_PARAM } from "./loop-tools.js";
+import { asksFromScratch, asksWholeChain, driftTool, fromWorkingDir, haltTool, loopReply, MODEL_PARAM, regenerateTool, stopJob, WAIT_PARAM, WORKING_DIR_PARAM } from "./loop-tools.js";
 import { createWebTools } from "./regenerate/web.js";
 import { describeGates, interruptedRun, runSkill } from "./genome.js";
 import { skillStatus } from "./skill.js";
@@ -29,7 +29,8 @@ import { describeChoices, describeResolution, modelFor, resolveModel } from "./r
 import { checkPlainFile, checkPlainTargets, formatCheckResults } from "./plain/check.js";
 import { whyFailed } from "./regenerate/diagnose-job.js";
 import { createWorkLoop, describeModules, isUpToDate, previewJobs } from "./regenerate/loop.js";
-import { brandBlue, plainPaint } from "./regenerate/plain-palette.js";
+import { brandNeon, brandPink, plainPaint } from "./regenerate/plain-palette.js";
+import { halfBlocks, JELLYFISH_FRAME_MS, JELLYFISH_TEXT_FRAMES } from "./jellyfish.js";
 import { createJobPanel, didNotPass, keyPressed, PANEL_KEY, spinner } from "./regenerate/job-panel.js";
 import { clickToFocus, dockedWidth, narrowChat, shade, shadeChat } from "./regenerate/panel-dock.js";
 import { overPictureRow, PICTURE_AT } from "./picture-row.js";
@@ -41,13 +42,13 @@ import { createJobsTreeState, selectJob } from "./regenerate/jobs-tree.js";
 import { describeDiagnosis, diagnoseFailure } from "./regenerate/diagnose.js";
 import { HISTORY_DIR, historyLog, historyShow } from "./regenerate/lineage.js";
 import { defaultBuildDir } from "./regenerate/paths.js";
-import { describeUsage } from "./regenerate/activity.js";
+import { describeTurnIncident, describeUsage, onModelEvent } from "./regenerate/activity.js";
 import { describeSpecConflict } from "./regenerate/stop-report.js";
 import { inheritProviders, inheritThinkingLevel } from "./pi.js";
 import { beginCapture, captureConsole, describeCaptured, dropNoise } from "./quiet.js";
 import { loadRules, renderRulesBlock } from "./rules.js";
 import { registerTurriConfig } from "./config-command.js";
-import { describeStdlib, stdlibStackCount } from "./stdlib.js";
+import { describeStdlib } from "./stdlib.js";
 import { peekKeyListener, runAsk } from "./ask.js";
 import { QuestionDialog } from "./question-dialog.js";
 import { registerStacks } from "./stacks.js";
@@ -90,11 +91,12 @@ aside) {
             // The question, with what the asker gives to read for it - a brief to confirm - above it; what it said of its work
             // before asking is kept in its record, never put in the dialog.
             // A dialog of turri's own: a long brief scrolls above the question, and the options always show (question-dialog.ts).
-            const dialog = (question, context, options) => ctx.ui.custom((tui, theme, _keybindings, done) => {
+            const dialog = (question, context, options, selected) => ctx.ui.custom((tui, theme, _keybindings, done) => {
                 const shown = new QuestionDialog({
                     question,
                     ...(context !== undefined ? { context } : {}),
                     ...(options !== undefined ? { options } : {}),
+                    ...(selected !== undefined ? { selected } : {}),
                     rows: () => tui.terminal.rows,
                     style: { accent: (text) => theme.fg("accent", text), muted: (text) => theme.fg("muted", text), bold: (text) => theme.bold(text) },
                     done: (answer) => {
@@ -108,7 +110,7 @@ aside) {
                 return shown;
             });
             const asking = (asked) => runAsk(asked, {
-                select: (title, options, context) => dialog(title, context, options),
+                select: (title, options, context, at) => dialog(title, context, options, at),
                 input: (title, context) => dialog(title, context),
             });
             const bare = { ...request, said: undefined };
@@ -327,6 +329,19 @@ export default function (pi) {
     };
     pi.on("agent_end", endTurnCapture);
     pi.on("agent_settled", endTurnCapture);
+    // A pulse's provider failing and waited out, or a turn turri ended itself: said in the chat as it happens - the job
+    // panel's activity holds it too, but scrolls by.
+    let stopTurnIncidents;
+    pi.on("session_start", (_event, ctx) => {
+        stopTurnIncidents?.();
+        if (!ctx.hasUI)
+            return;
+        stopTurnIncidents = onModelEvent((event) => {
+            const line = describeTurnIncident(event);
+            if (line !== undefined)
+                ctx.ui.notify(event.job !== undefined ? `${event.job}: ${line}` : line, "warning");
+        });
+    });
     // What a turri that was killed left running - its commands' process groups - stopped as this one starts.
     const orphans = sweepOrphanedGroups();
     let orphansSaid = orphans === 0;
@@ -356,7 +371,7 @@ export default function (pi) {
         conversationModels = ctx.modelRegistry;
     });
     inheritProviders(() => conversationModels);
-    registerBranding(pi, rules.length, discoveredSkills);
+    registerBranding(pi, discoveredSkills);
     registerInterviewLog(pi);
     registerJobTools(pi, jobs, cwd);
     registerCheckPlain(pi, cwd);
@@ -610,7 +625,7 @@ function registerRegenerate(pi, cwd, jobs) {
     // by the planner: one functional spec at a time, a few together or the whole module in one, as it judges. What
     // follows the module is guidance for that plan, in the person's words.
     pi.registerCommand("regenerate", {
-        description: "Regenerate a module from its spec as it is now, in pulses the planner cuts - named functionalities though they did not change, or all of it from scratch: /regenerate [module | file.plain] [functionality ...] [from scratch] [how to cut the work]",
+        description: "Regenerate a module from its spec as it is now, in pulses the planner cuts - named functionalities though they did not change, or all of it from scratch, its whole chain too when asked: /regenerate [module | file.plain] [functionality ...] [from scratch [whole chain]] [how to cut the work]",
         handler: async (args, ctx) => {
             const command = `/regenerate ${args.trim()}`.trim();
             await echoCommand(pi, command);
@@ -652,13 +667,17 @@ function registerRegenerate(pi, cwd, jobs) {
             }
             // From scratch - started over, its code deleted - asked in the person's words: confirmed first, as it deletes.
             const scratch = asksFromScratch(guidance);
+            // The whole chain with it - "from scratch, the whole chain" - every module it requires built again from the bottom.
+            const chain = scratch && asksWholeChain(guidance);
             const module = basename(plainFile).replace(/\.plain$/, "");
             if (scratch && again.length > 0) {
                 say("Name functionalities or ask for it from scratch, not both: from scratch regenerates every one of them.", "warning");
                 return;
             }
             if (scratch && ctx.hasUI) {
-                const agreed = await ctx.ui.confirm(`Regenerate ${module} from scratch?`, `Its code and conformance tests are deleted - committed first, so /lineage ${module} keeps them - and the whole module is regenerated from its spec.`);
+                const agreed = await ctx.ui.confirm(chain ? `Regenerate ${module} and its whole chain from scratch?` : `Regenerate ${module} from scratch?`, chain
+                    ? `The code and conformance tests of ${module} and of every module it requires are deleted - committed first, so /lineage keeps them - and the whole chain is regenerated from its spec, from the bottom.`
+                    : `Its code and conformance tests are deleted - committed first, so /lineage ${module} keeps them - and the whole module is regenerated from its spec.`);
                 if (!agreed)
                     return;
             }
@@ -668,14 +687,14 @@ function registerRegenerate(pi, cwd, jobs) {
             // Said at once, and kept in the chat: what follows takes a while - the planner is an agent - and the person sees it
             // began, not a chat that stays empty until the first pulse starts. The plan is said under it once it is made.
             say(scratch
-                ? `Deleting ${module}'s code, then planning all of it again…`
+                ? `Deleting ${module}'s code${chain ? " and its whole chain's" : ""}, then planning all of it again…`
                 : again.length > 0
                     ? `Planning ${module}'s functionalit${again.length === 1 ? "y" : "ies"} ${again.join(", ")} again…`
                     : `Planning ${module}'s pulses…`, "info");
             await nextFrame();
             try {
                 const statuses = scratch
-                    ? await loop.fromScratch(plainFile, request)
+                    ? await loop.fromScratch(plainFile, { ...request, chain })
                     : again.length > 0
                         ? await loop.regenerateAgain(plainFile, again, request)
                         : await loop.bringUp(plainFile, request);
@@ -1499,7 +1518,8 @@ function registerJobTools(pi, jobs, cwd) {
     });
     // The side panel: the regeneration - and the pulses behind p - over the whole screen, or beside the chat (s, from one to
     // the other). Its key (PANEL_KEY) opens it; the key again closes it and goes back to the chat, as esc does over the
-    // screen - beside the chat, esc gives the chat its keys back and the panel stays, and the key gives them to the panel.
+    // screen - beside the chat, the key switches sides, giving the keys to the chat or the panel, as esc gives them to the
+    // chat, the panel staying; ctrl+c closes it.
     // While the panel has the keys, every key is its own.
     let panel;
     // Beside the chat or over it: as the person last left it, for the conversation.
@@ -1627,8 +1647,8 @@ function registerJobTools(pi, jobs, cwd) {
                     removed: (text) => theme.fg("toolDiffRemoved", text),
                     // A spec diff's ***plain highlighted as plyn highlights it, and its added and removed lines filled.
                     diff: plainPaint(theme),
-                    // What conformance tests show does what its spec says: brand blue.
-                    conforms: brandBlue(theme),
+                    // What conformance tests show does what its spec says: neon.
+                    conforms: brandNeon(theme),
                 },
                 back,
                 close,
@@ -1670,17 +1690,6 @@ function registerJobTools(pi, jobs, cwd) {
                 }
                 if (!state)
                     return undefined;
-                // Beside the chat, ⌥⌘← and ⌥⌘→ go to the side they point at, whichever has the keys - on a terminal that tells
-                // turri of ⌘ (the Kitty keyboard protocol). Its release goes nowhere.
-                if (panelBeside() > 0 && (matchesKey(data, SIDE_KEYS.chat) || matchesKey(data, SIDE_KEYS.panel))) {
-                    if (!isKeyRelease(data)) {
-                        if (matchesKey(data, SIDE_KEYS.chat))
-                            toChat();
-                        else
-                            toPanel();
-                    }
-                    return { consume: true };
-                }
                 // Beside the chat, with the chat's keys: they are the chat's - PANEL_KEY among them, for the shortcut that gives
                 // them to the panel. A click on the panel gives it the focus, and the keys with it.
                 if (!entry.keys && entry.handle?.isFocused() !== true)
@@ -1691,9 +1700,13 @@ function registerJobTools(pi, jobs, cwd) {
                 // presses count - and ctrl+h held down, repeating, does not open and close it over and over.
                 if (isKeyRelease(data) || (isKeyRepeat(data) && matchesKey(data, PANEL_KEY)))
                     return { consume: true };
-                // ctrl+c closes it too: whatever else goes wrong, a key always leads back to the chat.
-                if (matchesKey(data, PANEL_KEY) || matchesKey(data, "ctrl+c"))
+                // PANEL_KEY goes back: beside the chat, to the chat, the panel staying - the switch between the sides, as it is
+                // from the chat to the panel - and over the screen, closing it. ctrl+c closes it either way: whatever else goes
+                // wrong, a key always leads back to the chat.
+                if (matchesKey(data, "ctrl+c"))
                     close();
+                else if (matchesKey(data, PANEL_KEY))
+                    back();
                 else {
                     try {
                         view.handleInput(data);
@@ -1723,8 +1736,10 @@ function registerJobTools(pi, jobs, cwd) {
                 handleInput: (data) => {
                     if (isKeyRepeat(data) && matchesKey(data, PANEL_KEY))
                         return;
-                    if (matchesKey(data, PANEL_KEY))
+                    if (matchesKey(data, "ctrl+c"))
                         close();
+                    else if (matchesKey(data, PANEL_KEY))
+                        back();
                     else
                         view.handleInput(data);
                     tui.requestRender();
@@ -1859,8 +1874,6 @@ export const JOB_FINISHED_REACTION = [
     "  to do, and that \"resume\" picks it up once it is in.",
     "- a credential `agent-env:` names that is not there: never make one up - tell the person where it is read from.",
 ].join("\n");
-/** The keys that go to the chat and to the panel, side by side: ⌥⌘← and ⌥⌘→. */
-const SIDE_KEYS = { chat: "alt+super+left", panel: "alt+super+right" };
 /** Opens the side panel, and goes back to it from the conversation. */
 /** The modules in this project that have a history, by name. */
 function modulesWithHistory(cwd) {
@@ -2283,7 +2296,7 @@ const BANNER_ENTRY = "turri_banner";
 export function chatRulesBlock(rules = loadRules(join(PACKAGE_ROOT, "genome", "rules"))) {
     return renderRulesBlock(rules);
 }
-function registerBranding(pi, ruleCount, skills) {
+function registerBranding(pi, skills) {
     pi.registerCommand("stdlib", {
         description: "List the ***plain standard library: the stacks a spec can import instead of writing its implementation reqs.",
         handler: async (_args, ctx) => {
@@ -2296,24 +2309,18 @@ function registerBranding(pi, ruleCount, skills) {
         if (data === undefined)
             return undefined;
         const lines = [
-            `${theme.fg("accent", "turri")}  ${theme.fg("muted", `v${data.version}`)}` +
+            `${brandPink(theme)("turri")}  ${theme.fg("muted", `v${data.version}`)}` +
                 (data.commit !== undefined ? theme.fg("dim", `  from a clone, ${data.commit}${data.changed ? " with changes" : ""}`) : ""),
-            theme.fg("text", "regenerative software - the code is regenerated from the spec"),
-            theme.fg("muted", `${data.rules} rules · ${data.skills} skill${data.skills === 1 ? "" : "s"}` +
-                (data.projectSkills !== undefined && data.projectSkills > 0 ? ` (${data.projectSkills} the project's)` : "") +
-                (data.stdlib !== undefined && data.stdlib > 0 ? ` · ${data.stdlib} stdlib stacks (/stdlib)` : "") +
-                (data.pending > 0 ? theme.fg("warning", `  (${data.pending} failed to load)`) : "")),
+            theme.fg("text", "the first coding agent with the power of regenerative software"),
             // Where the settings are changed, without leaving the chat.
             theme.fg("muted", "configure with /turri-config"),
-            theme.fg("dim", data.cwd),
-            // Where every command an agent runs will run - or that none can.
-            ...(data.sandbox
-                ? [theme.fg(data.sandbox.level === "ok" ? "dim" : data.sandbox.level === "limited" ? "warning" : "error", data.sandbox.text)]
-                : []),
+            // Only what is wrong: skills that did not load, and agents' commands less fenced than they should be.
+            ...(data.pending > 0 ? [theme.fg("warning", `${data.pending} skill${data.pending === 1 ? "" : "s"} failed to load`)] : []),
+            ...(data.sandbox !== undefined && data.sandbox.level !== "ok" ? [theme.fg(data.sandbox.level === "limited" ? "warning" : "error", data.sandbox.text)] : []),
         ];
         // The jellyfish turri is named after, in ink for the theme's background: a picture where the
         // terminal shows images, drawn in text where it does not.
-        return new Banner(lines, (rule) => theme.fg("borderMuted", rule), jellyfishArt(theme.appearance, (art) => theme.fg("text", art)));
+        return new Banner(lines, (rule) => theme.fg("borderMuted", rule), jellyfishArt(theme.appearance, (theme.getColorMode?.() ?? "truecolor") === "truecolor"));
     });
     pi.on("session_start", (_event, ctx) => {
         if (ctx.hasUI)
@@ -2324,12 +2331,7 @@ function registerBranding(pi, ruleCount, skills) {
                 version: identity.version ?? "0.0.0",
                 commit: identity.git_commit?.slice(0, 7),
                 changed: identity.git_dirty === true,
-                rules: ruleCount,
-                skills: skills.skills.length,
-                projectSkills: skills.skills.filter((skill) => skill.origin !== "turri").length,
                 pending: skills.pending.length,
-                stdlib: stdlibStackCount(),
-                cwd: ctx.cwd,
                 sandbox: sandboxSummary(),
             });
         }
@@ -2338,10 +2340,8 @@ function registerBranding(pi, ruleCount, skills) {
         }
     });
 }
-/** How many rows the banner's jellyfish takes: taller than the lines beside it. */
-const JELLYFISH_ROWS = 13;
-/** How long each frame of the jellyfish shows. */
-const JELLYFISH_FRAME_MS = 250;
+/** How many rows the banner's jellyfish takes at most: as tall as the one drawn in text. */
+const JELLYFISH_ROWS = 10;
 /** Which frame of the jellyfish every banner shows, moved on by `animateJellyfish`. */
 let jellyfishFrame = 0;
 let jellyfishTimer;
@@ -2461,24 +2461,16 @@ class Banner {
 }
 const jellyfishFrameCache = new Map();
 /**
- * The banner's jellyfish for this terminal: where it shows images, the picture's frames spread evenly
- * over the video, light ink for a dark background and dark ink for a light one; where it does not, the
- * jellyfish drawn in text, in `ink`. None when they cannot be read.
+ * The banner's jellyfish for this terminal: where it shows images, the picture's frames
+ * (scripts/jellyfish-frames.mjs writes them), in the colours for the theme's background; where it does not, the
+ * small one in half blocks. None when the pictures cannot be read.
  */
-function jellyfishArt(appearance, ink) {
+function jellyfishArt(appearance, truecolor) {
     const dir = join(PACKAGE_ROOT, "assets", "jellyfish");
     try {
         if (getCapabilities().images === null) {
-            // Its frames one after another, each ended by a line of "---" (scripts/jellyfish-frames.mjs writes them).
-            const drawn = readFileSync(join(dir, "fallback.txt"), "utf8")
-                .split(/^---$/m)
-                .map((frame) => frame.replace(/^\n+|\n+$/g, "").split("\n"))
-                .filter((frame) => frame.some((line) => line.trim() !== ""));
-            if (drawn.length === 0)
-                return undefined;
-            const columns = Math.max(...drawn.flat().map((line) => visibleWidth(line)));
-            const rows = Math.max(...drawn.map((frame) => frame.length));
-            return { kind: "text", frames: drawn.map((frame) => frame.map((line) => ink(line.padEnd(columns)))), columns, rows };
+            const frames = JELLYFISH_TEXT_FRAMES.map((pixels) => halfBlocks(pixels, appearance, truecolor));
+            return { kind: "text", frames, columns: JELLYFISH_TEXT_FRAMES[0][0].length, rows: frames[0].length };
         }
         let frames = jellyfishFrameCache.get(appearance);
         if (frames === undefined) {