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

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, STACK_PARAM, stopJob, WAIT_PARAM, withCallStack, 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,17 +688,18 @@ 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)
+                // Built with the stack chosen now - pinned to its pulses - or refused, a project of stacks built with none.
+                const statuses = await withCallStack(plainFile, undefined, () => scratch
+                    ? loop.fromScratch(plainFile, { ...request, chain })
                     : again.length > 0
-                        ? await loop.regenerateAgain(plainFile, again, request)
-                        : await loop.bringUp(plainFile, request);
+                        ? loop.regenerateAgain(plainFile, again, request)
+                        : loop.bringUp(plainFile, request));
                 // Nothing to do: say how to build it again anyway.
                 const hint = statuses.length > 0 && statuses.every(isUpToDate)
                     ? `\nTo regenerate parts of it anyway, name their functionalities - /regenerate ${basename(plainFile)} 2.1 - or start over with /regenerate ${basename(plainFile)} from scratch.`
@@ -798,21 +818,24 @@ function conformTool(options) {
                 description: "Only when the user asks for them in pulses of their own grouping: the functional specs by id, a list a pulse - [[\"1\",\"2\",\"3\"],[\"4\",\"5\",\"6\"]]. Each is tested in a pulse of its own; they are added to those chosen, as frids are",
             })),
             one_by_one: Type.Optional(Type.Boolean({ description: "Only when the user asks for it: a pulse a functional spec. Omitted: every functional spec tested in one pulse, as far as the size guardrail lets" })),
+            stack: STACK_PARAM,
             model: MODEL_PARAM,
             wait: WAIT_PARAM,
         }),
         async execute(_id, given, _signal, _onUpdate, ctx) {
             const params = fromWorkingDir(cwd, given);
             const plainFile = resolve(params.base, params.plain_file);
-            const model = options.model(ctx, plainFile, params.model);
-            const loop = options.loop(ctx);
-            const statuses = await loop.conformance(plainFile, {
-                ...(params.frids !== undefined ? { frids: params.frids } : {}),
-                ...(params.groups !== undefined ? { groups: params.groups } : {}),
-                ...(model !== undefined ? { model } : {}),
-                ...(params.one_by_one === true ? { separately: true } : {}),
+            return withCallStack(plainFile, params.stack, async () => {
+                const model = options.model(ctx, plainFile, params.model);
+                const loop = options.loop(ctx);
+                const statuses = await loop.conformance(plainFile, {
+                    ...(params.frids !== undefined ? { frids: params.frids } : {}),
+                    ...(params.groups !== undefined ? { groups: params.groups } : {}),
+                    ...(model !== undefined ? { model } : {}),
+                    ...(params.one_by_one === true ? { separately: true } : {}),
+                });
+                return loopReply(loop, statuses, options.wait(ctx, params.wait));
             });
-            return loopReply(loop, statuses, options.wait(ctx, params.wait));
         },
     });
 }
@@ -830,34 +853,37 @@ function registerGlimpse(pi, cwd, jobs) {
         parameters: Type.Object({
             plain_file: Type.String({ description: "Path to the .plain file" }),
             working_dir: WORKING_DIR_PARAM,
+            stack: STACK_PARAM,
         }),
         async execute(_id, given, _signal, _onUpdate, ctx) {
             const params = fromWorkingDir(cwd, given);
             const plainFile = resolve(params.base, params.plain_file);
-            const running = new Set(workLoopFor(jobs, cwd, ctx).status().filter((status) => status.running !== undefined).map((status) => status.module));
-            const planner = chatModelOf(ctx);
-            const model = modelFor(chosenModels, "spec_changes", projectModel(ctx, plainFile) ?? planner);
-            const { statuses, previews, busy } = await previewJobs({
-                plainFile,
-                cwd,
-                ...(model !== undefined ? { model } : {}),
-                ...(planner !== undefined ? { plannerModel: planner } : {}),
-                steering: (file) => steeringFor(file, cwd, steeringStore),
-                busy: (module) => running.has(module),
-            });
-            const text = [
-                describeModules(statuses),
-                ...busy.map((module) => `\n${module} has a pulse running: its next pulse is planned from what that one lands - preview it once it has.`),
-                ...previews.map((preview) => [
+            return withCallStack(plainFile, params.stack, async () => {
+                const running = new Set(workLoopFor(jobs, cwd, ctx).status().filter((status) => status.running !== undefined).map((status) => status.module));
+                const planner = chatModelOf(ctx);
+                const model = modelFor(chosenModels, "spec_changes", projectModel(ctx, plainFile) ?? planner);
+                const { statuses, previews, busy } = await previewJobs({
+                    plainFile,
+                    cwd,
+                    ...(model !== undefined ? { model } : {}),
+                    ...(planner !== undefined ? { plannerModel: planner } : {}),
+                    steering: (file) => steeringFor(file, cwd, steeringStore),
+                    busy: (module) => running.has(module),
+                });
+                const text = [
+                    describeModules(statuses),
+                    ...busy.map((module) => `\n${module} has a pulse running: its next pulse is planned from what that one lands - preview it once it has.`),
+                    ...previews.map((preview) => [
+                        "",
+                        `<next pulse module="${preview.module}" track="${preview.track}" title="${preview.title}">`,
+                        preview.task ?? "A conformance pulse's prompt is built from what the code it tests holds once it is built: it is not shown before.",
+                        "</next pulse>",
+                    ].join("\n")),
                     "",
-                    `<next pulse module="${preview.module}" track="${preview.track}" title="${preview.title}">`,
-                    preview.task ?? "A conformance pulse's prompt is built from what the code it tests holds once it is built: it is not shown before.",
-                    "</next pulse>",
-                ].join("\n")),
-                "",
-                "Nothing was started. Tell the user what the next pulse is and what it will be told - the parts they are likely to care about, not the whole prompt unless they ask.",
-            ].join("\n");
-            return { content: [{ type: "text", text }], details: {} };
+                    "Nothing was started. Tell the user what the next pulse is and what it will be told - the parts they are likely to care about, not the whole prompt unless they ask.",
+                ].join("\n");
+                return { content: [{ type: "text", text }], details: {} };
+            });
         },
     });
 }
@@ -1015,7 +1041,7 @@ export function projectConfigBlock(root) {
         return [
             ...settings(readProjectConfig(dir), withStack(undefined, () => findTestScripts(dir)), dir === root ? `${projectConfigFile(dir)}, for the specs here:` : `${relative(root, dir)}/${projectConfigFile(dir)}, for the specs in ${relative(root, dir)}/ - built in ${relative(root, dir)}/plain_modules:`, where, stacks.length > 0 ? "project of stacks" : "project"),
             ...(stacks.length > 0
-                ? ["", `Stacks: ${stacks.join(", ")} - chosen now: ${chosen ?? "none, so the project's file alone"}. Everything is built with the chosen one; switch with the stack tool when the user asks.`]
+                ? ["", `Stacks: ${stacks.join(", ")} - chosen now: ${chosen ?? "none, so the project's file alone"}. Each module is built with the stack of its part - a backend's spec with the backend stack: pass it as stack to regenerate, conform and glimpse, and it is pinned to that module's pulses, whatever is chosen after. Choose one for the whole session with the stack tool when the user asks.`]
                 : []),
             // A stack: its file over the project's, for everything built while it is chosen.
             ...stacks.flatMap((stack) => [
@@ -1500,7 +1526,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 +1535,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 +1593,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 +1634,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 +1655,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 +1698,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 +1708,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 +1744,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 +1765,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 +1883,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 +2305,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 +2318,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 +2351,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 +2387,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 +2463,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 +2490,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) {

package/dist/init-config.js

@@ -110,6 +110,7 @@ export function withModels(text, lines) {
 export const DEFAULTS = {
     conformanceTests: false,
     review: false,
+    mutationTesting: true,
     allowToStopJobs: true,
     releaseAfterPulse: false,
     testingScriptsRunOn: "in-place",
@@ -143,6 +144,10 @@ export function quickStartConfig(vendor = "other", bedrock) {
         "# Whether the code and its tests are reviewed once they pass - two reviews at most, the second weighed by the arbiter.",
         `review: ${DEFAULTS.review}`,
         "",
+        "# Whether the coding agent and the reviewer can put a bug in the code for one run of the unit tests (can_it_fail),",
+        "# to see that a test catches it - on a copy of the code, or in place and put back after.",
+        `mutation-testing: ${DEFAULTS.mutationTesting}`,
+        "",
         "# Whether turri stops a running pulse the spec has moved on from. false: it lands, the change regenerated on top.",
         `allow-to-stop-jobs: ${DEFAULTS.allowToStopJobs}`,
         "",