@turri-dev/cli 0.1.4-next.fa9223b → 0.1.4

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,10 +29,12 @@ 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";
+import { padScreen, paddedColumns, paddedRows, SCREEN_PADDING } from "./screen-padding.js";
 import { skillAboutLine, skillProgressLine } from "./skill-progress.js";
 import { createSidePanel } from "./regenerate/side-panel.js";
 import { createSpecMapSource, defaultMapFiles } from "./regenerate/spec-map.js";
@@ -41,13 +43,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";
@@ -96,7 +98,7 @@ aside) {
                     ...(context !== undefined ? { context } : {}),
                     ...(options !== undefined ? { options } : {}),
                     ...(selected !== undefined ? { selected } : {}),
-                    rows: () => tui.terminal.rows,
+                    rows: () => paddedRows(tui.terminal.rows),
                     style: { accent: (text) => theme.fg("accent", text), muted: (text) => theme.fg("muted", text), bold: (text) => theme.bold(text) },
                     done: (answer) => {
                         if (questionShown === shown)
@@ -328,6 +330,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;
@@ -357,7 +372,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);
@@ -611,7 +626,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);
@@ -653,13 +668,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;
             }
@@ -669,14 +688,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);
@@ -1500,7 +1519,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.
@@ -1508,7 +1528,7 @@ function registerJobTools(pi, jobs, cwd) {
     // The terminal the panel is drawn on, for its width: set as it opens.
     let panelTerminal;
     /** The columns the panel takes beside the chat - 0 over the whole screen, or when the terminal is too narrow to share. */
-    const panelBeside = () => (panelDocked && panelTerminal !== undefined ? dockedWidth(panelTerminal.columns) : 0);
+    const panelBeside = () => (panelDocked && panelTerminal !== undefined ? dockedWidth(paddedColumns(panelTerminal.columns)) : 0);
     // What is open in the pulse list and the map, and where their cursors are: the conversation's, as left each time it opens.
     const jobsTree = createJobsTreeState();
     const mapState = createSpecMapState();
@@ -1566,7 +1586,7 @@ function registerJobTools(pi, jobs, cwd) {
             const layOut = () => {
                 if (panelDocked && undock === undefined) {
                     const widen = narrowChat(tui, panelBeside);
-                    const unwatch = clickToFocus(tui, () => tui.terminal.columns - panelBeside(), (side) => {
+                    const unwatch = clickToFocus(tui, () => tui.terminal.columns - SCREEN_PADDING.right - panelBeside(), (side) => {
                         if (panelBeside() === 0)
                             return;
                         if (side === "chat")
@@ -1607,7 +1627,7 @@ function registerJobTools(pi, jobs, cwd) {
                 tree: jobsTree,
                 map: () => specMap.read(),
                 mapState,
-                rows: () => tui.terminal.rows,
+                rows: () => paddedRows(tui.terminal.rows),
                 key: PANEL_KEY,
                 dock: {
                     docked: () => panelBeside() > 0,
@@ -1628,8 +1648,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,
@@ -1671,17 +1691,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)
@@ -1692,9 +1701,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);
@@ -1724,8 +1737,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();
@@ -1743,14 +1758,15 @@ function registerJobTools(pi, jobs, cwd) {
             return component;
         }, {
             overlay: true,
-            // The whole screen, or the columns on the right beside the chat - read at each frame, so it follows the terminal.
+            // The whole screen, or the columns on the right beside the chat - read at each frame, so it follows the terminal -
+            // inside the screen's padding.
             overlayOptions: {
                 get width() {
                     return panelBeside() > 0 ? panelBeside() : "100%";
                 },
                 maxHeight: "100%",
                 anchor: "top-right",
-                margin: 0,
+                margin: { ...SCREEN_PADDING },
             },
             onHandle: (handle) => {
                 if (panel !== undefined)
@@ -1860,8 +1876,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) {
@@ -2284,7 +2298,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) => {
@@ -2297,40 +2311,31 @@ 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)
+        if (ctx.hasUI) {
+            padTheScreen(ctx);
             animateJellyfish(ctx);
+        }
         try {
             const identity = turriIdentity();
             pi.appendEntry(BANNER_ENTRY, {
                 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(),
             });
         }
@@ -2339,10 +2344,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;
@@ -2377,6 +2380,24 @@ function animateJellyfish(ctx) {
     }, { placement: "belowEditor" });
 }
 const JELLYFISH_CLOCK_KEY = "turri-jellyfish";
+/**
+ * The whole screen inside its padding (`screen-padding.ts`). An extension is given pi's screen only through what it
+ * draws, so an empty widget below the editor hands it over - at each frame, as pi starts a new screen when it changes
+ * how it draws.
+ */
+function padTheScreen(ctx) {
+    ctx.ui.setWidget(SCREEN_PADDING_KEY, (tui) => {
+        padScreen(tui);
+        return {
+            render: () => {
+                padScreen(tui);
+                return [];
+            },
+            invalidate: () => { },
+        };
+    }, { placement: "belowEditor" });
+}
+const SCREEN_PADDING_KEY = "turri-padding";
 /** The columns the banner's picture takes from the left edge, while it shows one; 0 when it does not. */
 let pictureRight = 0;
 /**
@@ -2435,7 +2456,7 @@ class Banner {
             return line !== undefined ? `${before}${line}` : placed?.kind === "text" ? ` ${jellyfish}` : "";
         });
         // The side panel is drawn beside the picture (drawOverlaysBesidePicture), which goes on showing.
-        pictureRight = placed?.kind === "image" ? 1 + placed.columns : 0;
+        pictureRight = placed?.kind === "image" ? SCREEN_PADDING.left + 1 + placed.columns : 0;
         if (placed?.kind === "image") {
             const at = placed.onLastRow ? placed.rows - 1 : 0;
             rows[at] = `${rows[at]}${PICTURE_AT}${placed.sequence}`;
@@ -2462,24 +2483,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) {