@turri-dev/cli 0.1.7-next.eb57c34 → 0.1.7-next.f0d55df

package/README.md

@@ -1,4 +1,4 @@
-<p align="center"><img src="docs/images/turri-banner.png" alt="turri - the first coding agent with the power of regenerative software, beside a pixel jellyfish: npm install -g @turri-dev/cli"></p>
+<p align="center"><img src="docs/images/turri-banner.gif" alt="turri, beside its mark - the first coding agent with the power of regenerative software: npm install -g @turri-dev/cli - and a pixel jellyfish regenerating, from a polyp on the sea floor"></p>
 
 <h1 align="center">turri<br>the first coding agent with the power of<br>regenerative software<br>&nbsp;</h1>
 
@@ -101,8 +101,6 @@ With **turri** you work on the durable intent. You say what the software must do
 
 ## How it works
 
-<p align="center"><img src="docs/images/turri-screenshot.png" width="900" alt="turri in the terminal: on the left the conversation, where /regenerate plans a project's modules and a coding agent works through one of them; on the right the spec map of that module's ***plain, each functionality marked as regenerated or being worked on"></p>
-
 **turri** captures the durable intent in [\*\*\*plain](https://plainlang.org/), a language for saying what software should do. \*\*\*plain breaks the intent down into functionalities - small units, each a single thing the software does - and **turri** regenerates the code from them piece by piece.
 
 1. **Define.** You say what the software should do; **turri** writes it down as \*\*\*plain.

package/dist/extension.js

@@ -30,7 +30,7 @@ import { checkPlainFile, checkPlainTargets, formatCheckResults } from "./plain/c
 import { whyFailed } from "./regenerate/diagnose-job.js";
 import { createWorkLoop, describeModules, isUpToDate, previewJobs } from "./regenerate/loop.js";
 import { brandNeon, brandPink, plainPaint } from "./regenerate/plain-palette.js";
-import { halfBlocks, JELLYFISH_FRAME_MS, JELLYFISH_TEXT_FRAMES } from "./jellyfish.js";
+import { halfBlocks, JELLYFISH_FRAME_MS, JELLYFISH_SEQUENCE, 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";
@@ -2353,8 +2353,8 @@ function registerBranding(pi, skills) {
             ...(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.
+        // The jellyfish turri is named after, regenerating, 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, (theme.getColorMode?.() ?? "truecolor") === "truecolor"));
     });
     pi.on("session_start", (_event, ctx) => {
@@ -2377,10 +2377,15 @@ function registerBranding(pi, skills) {
         }
     });
 }
-/** 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`. */
+/**
+ * How many rows the banner's picture takes at most: its frame reaches down to the sea floor the polyp stands on, so it
+ * is given more than the jellyfish drawn in text, ten.
+ */
+const JELLYFISH_ROWS = 14;
+/** How far along its sequence the jellyfish every banner shows is, moved on by `animateJellyfish`. */
 let jellyfishFrame = 0;
+/** The frame the jellyfish is on: the one its sequence has at this point. */
+const shownFrame = () => JELLYFISH_SEQUENCE[jellyfishFrame % JELLYFISH_SEQUENCE.length];
 let jellyfishTimer;
 /**
  * Moves the jellyfish on a frame every JELLYFISH_FRAME_MS while the banner is on the screen. An entry's
@@ -2481,7 +2486,7 @@ class Banner {
         const text = this.lines.flatMap((line) => wrapTextWithAnsi(line, Math.max(1, width - 1 - left)));
         const height = Math.max(text.length, placed?.rows ?? 0);
         const above = Math.floor((height - text.length) / 2);
-        const drawn = placed?.kind === "text" ? placed.frames[jellyfishFrame % placed.frames.length] : undefined;
+        const drawn = placed?.kind === "text" ? placed.frames[shownFrame()] : undefined;
         const rows = Array.from({ length: height }, (_, row) => {
             const line = text[row - above];
             const jellyfish = drawn !== undefined ? (drawn[row] ?? " ".repeat(placed.columns)) : " ".repeat(placed?.columns ?? 0);
@@ -2502,7 +2507,7 @@ class Banner {
         const kitty = getCapabilities().images === "kitty";
         if (kitty && this.kittyImageId === undefined)
             this.kittyImageId = allocateImageId();
-        const result = renderImage(art.frames[jellyfishFrame % art.frames.length], art.dimensions, {
+        const result = renderImage(art.frames[shownFrame()], art.dimensions, {
             maxWidthCells: room,
             maxHeightCells: rows,
             imageId: this.kittyImageId,

package/dist/jellyfish.d.ts

@@ -1,22 +1,32 @@
 /**
- * The jellyfish turri is named after, in pixels: a pink bell, an orange gut, neon tentacles coming apart into code at
- * their tips - the design system's colours, swimming a stroke a loop. Drawn at two sizes from one design: the banner's
- * pictures are rendered from the large one (scripts/jellyfish-frames.mjs writes assets/jellyfish/), and where a terminal
- * shows no images the small one is drawn here in half blocks, two pixels a cell - drawn at its size, not shrunk, so no
- * pixel of it is lost.
+ * The jellyfish turri is named after, in pixels, regenerating: a polyp on the sea floor grows into the jellyfish, it
+ * swims a while, then sinks back to the floor and the polyp grows again - the design system's hero and its lifecycle
+ * (its pixel kit's `sprite("hero")` and `cycleFrames()`, ported here pixel for pixel). The banner's pictures are
+ * rendered from these frames (scripts/jellyfish-frames.mjs writes assets/jellyfish/); where a terminal shows no
+ * images the same frames are drawn here in half blocks, at a third of the size.
  */
-/** What a pixel is: the bell, its glint and shine, the gut, the underside, a tentacle, an oral arm, a tip fading. */
-type Pixel = "p" | "h" | "w" | "o" | "e" | "N" | "n" | "l" | "g";
-/** The pixels' colours on a dark background and a light one - the tentacles darker on light, where neon does not show. */
+/**
+ * What a pixel is: the bell's pink, its midtone and shadow, its rim, its highlight, the gut, and a tentacle - whole,
+ * half seen, or a polyp's crown, a little more than half.
+ */
+type Pixel = "p" | "m" | "i" | "e" | "h" | "o" | "N" | "n" | "c";
+/** The pixels' colours on a dark background and a light one - the tentacles blue whale on light, where neon does not show. */
 export declare const JELLYFISH_COLOURS: Record<"dark" | "light", Record<Pixel, string>>;
+/** How much of a pixel shows, for a picture's alpha. */
+export declare function jellyfishAlpha(pixel: string): number;
+/** The jellyfish's frames, each as rows of pixels: what the pictures are rendered from. */
+export declare const JELLYFISH_FRAMES: string[][];
 export declare const JELLYFISH_WIDTH: number;
 export declare const JELLYFISH_HEIGHT: number;
-/** The large jellyfish's frames, a stroke: what the pictures are rendered from. */
-export declare const JELLYFISH_FRAMES: string[][];
-/** The small jellyfish's frames, a stroke: what a terminal without images draws, in half blocks. */
-export declare const JELLYFISH_TEXT_FRAMES: string[][];
+/**
+ * The order the frames play in, round and round: the polyp a moment, growing into the jellyfish, swimming four
+ * seconds - a stroke every five frames - then sinking, and the polyp growing back.
+ */
+export declare const JELLYFISH_SEQUENCE: number[];
 /** How long each frame shows. */
-export declare const JELLYFISH_FRAME_MS = 250;
+export declare const JELLYFISH_FRAME_MS = 150;
+/** The frames as a terminal without images draws them, in half blocks: the same order, a third of the size. */
+export declare const JELLYFISH_TEXT_FRAMES: string[][];
 /**
  * A frame drawn in half blocks for a terminal that shows no images: two pixels a cell, the upper one the text's colour
  * and the lower one the background's, in as many colours as the terminal has: a column a pixel, a row every two.

package/dist/jellyfish.js

@@ -1,114 +1,247 @@
 import { sgr } from "./regenerate/plain-palette.js";
-/** The pixels' colours on a dark background and a light one - the tentacles darker on light, where neon does not show. */
+/** How much of a pixel shows. */
+const ALPHA = { p: 1, m: 1, i: 1, e: 1, h: 1, o: 1, N: 1, n: 0.5, c: 0.6 };
+/** The pixels' colours on a dark background and a light one - the tentacles blue whale on light, where neon does not show. */
 export const JELLYFISH_COLOURS = {
-    dark: { p: "#ff5c8d", h: "#ff7fa6", w: "#f4f7f9", o: "#ff7a3d", e: "#732553", N: "#8eebee", n: "#5ce1e6", l: "#85a3b2", g: "#3e5a6b" },
-    light: { p: "#ff5c8d", h: "#ff7fa6", w: "#f4f7f9", o: "#ff7a3d", e: "#732553", N: "#3e5a6b", n: "#1e3442", l: "#85a3b2", g: "#85a3b2" },
+    dark: { p: "#ff5c8d", m: "#a9479a", i: "#5b57d9", e: "#732553", h: "#ff7fa6", o: "#ff7a3d", N: "#5ce1e6", n: "#5ce1e6", c: "#5ce1e6" },
+    light: { p: "#ff5c8d", m: "#a9479a", i: "#5b57d9", e: "#732553", h: "#ff7fa6", o: "#ff7a3d", N: "#1e3442", n: "#1e3442", c: "#1e3442" },
 };
-/**
- * How shut the bell is, frame by frame - a quarter second each: shut quickly, held a moment, opened slowly, at rest
- * until the next stroke.
- */
-const SHUT = [0.1, 0.55, 0.9, 1, 0.85, 0.7, 0.56, 0.44, 0.33, 0.23, 0.14, 0.06];
-const LARGE = {
-    width: 24,
-    height: 26,
-    open: [6, 12, 16, 18, 20, 22, 22, 24, 24],
-    shut: [6, 10, 14, 16, 18, 18, 18, 20, 20],
-    glint: [[-3, 2], [-4, 2], [-5, 3], [-6, 4], [-6, 5]],
-    shine: [-2, 2],
-    gut: [".oo..oo.", "oooooooo", "oooooooo", ".oo..oo."],
-    gutRow: 4,
-    strands: [
-        { at: -8, length: 10, sway: 1.1, ink: "N" },
-        { at: -4.5, length: 13, sway: 1.3, ink: "N" },
-        { at: -1, length: 14, sway: 0.8, ink: "n" },
-        { at: 2, length: 13, sway: 0.8, ink: "n" },
-        { at: 5.5, length: 13, sway: 1.3, ink: "N" },
-        { at: 9, length: 10, sway: 1.1, ink: "N" },
-    ],
-};
-const SMALL = {
-    width: 18,
-    height: 20,
-    open: [4, 10, 12, 14, 16, 18, 18],
-    shut: [4, 8, 10, 12, 14, 14, 14],
-    glint: [[-2, 1], [-3, 2], [-4, 3]],
-    shine: [-1, 1],
-    gut: ["oo..oo", "oooooo", "oo..oo"],
-    gutRow: 3,
-    strands: [
-        { at: -6, length: 8, sway: 0.9, ink: "N" },
-        { at: -3, length: 10, sway: 1, ink: "N" },
-        { at: -0.5, length: 11, sway: 0.7, ink: "n" },
-        { at: 1.5, length: 10, sway: 0.7, ink: "n" },
-        { at: 4, length: 10, sway: 1, ink: "N" },
-        { at: 7, length: 8, sway: 0.9, ink: "N" },
-    ],
+/** What a pixel short of whole is laid over, to draw it in half blocks: abyss, or white. */
+const BACKGROUND = { dark: "#0a0f1a", light: "#f4f7f9" };
+/** How much of a pixel shows, for a picture's alpha. */
+export function jellyfishAlpha(pixel) {
+    return ALPHA[pixel] ?? 0;
+}
+/** The lifecycle's grid, and the sea floor the polyp stands on. */
+const WIDTH = 40;
+const HEIGHT = 60;
+const FLOOR = 59;
+const put = (grid, x, y, pixel, bounded = true) => {
+    x = Math.round(x);
+    y = Math.round(y);
+    if (bounded && (x < 0 || x > WIDTH - 1 || y < 0 || y > FLOOR))
+        return;
+    grid.set(`${x},${y}`, pixel);
 };
-/** One frame of a design: its height in rows of its width in pixels, "." where there is none. */
-function frame(design, t) {
-    const grid = Array.from({ length: design.height }, () => Array(design.width).fill("."));
-    const centre = design.width / 2;
-    const set = (y, x, pixel, over = true) => {
-        if (y < 0 || y >= design.height || x < 0 || x >= design.width)
-            return;
-        if (over || grid[y][x] === ".")
-            grid[y][x] = pixel;
-    };
-    const shut = SHUT[t % SHUT.length];
-    // Shut, it has risen a pixel.
-    const top = shut > 0.6 ? 0 : 1;
-    const widths = design.open.map((open, row) => 2 * Math.round((open - (open - design.shut[row]) * shut) / 2));
-    widths.forEach((width, row) => {
-        for (let x = centre - width / 2; x < centre + width / 2; x++)
-            set(top + row, x, "p");
-    });
-    const rimWidth = widths.at(-1);
-    const rim = top + widths.length;
-    // The underside along the bottom row, the rim scalloped under it.
-    for (let x = centre - rimWidth / 2 + 2; x < centre + rimWidth / 2 - 2; x++)
-        set(rim - 1, x, "e");
-    for (let x = centre - rimWidth / 2; x < centre + rimWidth / 2; x += 2)
-        set(rim, x + 1, "p");
-    // A glint up on the left, curving with the dome, and a pixel of shine.
-    for (const [dx, dy] of design.glint)
-        set(top + dy, centre + dx, "h");
-    set(top + design.shine[1], centre + design.shine[0], "w");
-    const gutLeft = centre - Math.floor(design.gut[0].length / 2);
-    design.gut.forEach((line, dy) => [...line].forEach((pixel, dx) => pixel === "o" && set(top + design.gutRow + dy, gutLeft + dx, "o")));
-    // The tentacles: rooted under the bell, drawn in as it shuts, swaying - the further down, the later.
-    const phase = (2 * Math.PI * t) / SHUT.length;
-    design.strands.forEach((strand, i) => {
-        const root = centre - 0.5 + strand.at * (rimWidth / design.open.at(-1));
-        for (let y = 0; y < strand.length; y++) {
-            const x = Math.round(root + strand.sway * Math.sin(phase - y * 0.55 + i * 0.8) * Math.min(1, y / 3));
-            const left = strand.length - y;
-            // The tips come apart, every other pixel, fading - into code.
-            if (left <= 3 && y % 2 === 1)
+/** The bell's colour down its height: pink, through its midtone, to its shadow - dithered where one meets the next. */
+const band = (t, x, y) => t < 0.3 ? "p" : t < 0.42 ? ((x + y) % 2 ? "p" : "m") : t < 0.62 ? "m" : t < 0.74 ? ((x + y) % 2 ? "m" : "i") : "i";
+/** An ellipse filled with the bell's colours, or its top half - a dome. */
+function shape(grid, cx, cy, rx, ry, dome, bounded = true) {
+    for (let y = Math.floor(cy - ry); y <= Math.ceil(cy + ry); y++) {
+        if (dome && y > cy)
+            continue;
+        for (let x = Math.floor(cx - rx); x <= Math.ceil(cx + rx); x++) {
+            const dx = (x + 0.5 - cx) / rx;
+            const dy = (y + 0.5 - cy) / ry;
+            if (dx * dx + dy * dy > 1)
                 continue;
-            set(rim + 1 + y, x, left > 5 ? strand.ink : left > 2 ? "l" : "g", false);
-            // The oral arms are frilled.
-            if (strand.ink === "n" && left > 5 && (y + t) % 3 === 0)
-                set(rim + 1 + y, x + (strand.at < 0 ? -1 : 1), "n", false);
+            const t = dome ? (y - (cy - ry)) / ry : (y - (cy - ry)) / (2 * ry);
+            put(grid, x, y, band(Math.max(0, Math.min(1, t)), x, y), bounded);
         }
-    });
-    return grid.map((row) => row.join(""));
+    }
 }
-export const JELLYFISH_WIDTH = LARGE.width;
-export const JELLYFISH_HEIGHT = LARGE.height;
-/** The large jellyfish's frames, a stroke: what the pictures are rendered from. */
-export const JELLYFISH_FRAMES = SHUT.map((_, t) => frame(LARGE, t));
-/** The small jellyfish's frames, a stroke: what a terminal without images draws, in half blocks. */
-export const JELLYFISH_TEXT_FRAMES = SHUT.map((_, t) => frame(SMALL, t));
+/** The bell's rim: every fourth pixel from the middle left out, the rest eggplant. */
+function rim(grid, y) {
+    for (let x = 0; x < WIDTH + 1; x++) {
+        const key = `${x},${y}`;
+        if (!grid.has(key))
+            continue;
+        if (Math.abs(x - 20) % 4 === 2)
+            grid.delete(key);
+        else
+            grid.set(key, "e");
+    }
+}
+/** The glint on the bell, up on the left. */
+const GLINT = [[11, 6], [12, 5], [13, 5], [10, 7], [11, 7], [14, 4]];
+/** Where each of the thirteen tentacles hangs, how long it is, and its place in the sway. */
+const TENTACLES = [8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32].map((x, i) => ({ x, length: 16 + ((i * 7) % 12), i }));
+/** The jellyfish at a scale `k`, its rim on row `cy`, its tentacles grown `grown` of the way. */
+function medusa(grid, k, cy, grown) {
+    shape(grid, 20.5, cy, 14.5 * k, 16 * k, true);
+    if (k > 0.45)
+        rim(grid, Math.floor(cy));
+    if (k > 0.8) {
+        for (const [gx, gy] of GLINT) {
+            const x = Math.round(20 + (gx - 20) * k);
+            const y = Math.round(cy + (gy - 18) * k);
+            if (grid.has(`${x},${y}`))
+                put(grid, x, y, "h");
+        }
+    }
+    const gutY = cy - 7 * k;
+    const halfWidth = Math.max(1.5, 2.5 * k);
+    const halfHeight = Math.max(0.6, 1.5 * k);
+    for (let y = Math.round(gutY - halfHeight); y < gutY + halfHeight; y++)
+        for (let x = Math.round(20 - halfWidth); x < 20 + halfWidth; x++)
+            put(grid, x, y, "o");
+    if (k > 0.7) {
+        for (let x = 19; x <= 21; x++) {
+            put(grid, x, gutY - 2, "o");
+            put(grid, x, gutY + 2, "o");
+        }
+    }
+    for (const { x, length, i } of TENTACLES) {
+        const shown = Math.round(length * Math.pow(grown, 1.2));
+        const root = 20 + (x - 20) * k;
+        for (let j = 0; j < shown; j++)
+            put(grid, root + Math.round(Math.sin(j * 0.5 + i) * 1.6 * (j / shown)), cy + 1 + j, j % 2 ? "n" : "N");
+    }
+}
+/** The polyp on the floor, grown `u` of the way: a stalk, a head with its gut, a crown of tentacles. */
+function polyp(grid, u) {
+    shape(grid, 20, FLOOR, 3, 1.4, true);
+    const height = Math.round(2 + 12 * u);
+    const radius = 1.4 + 2.2 * u;
+    for (let y = FLOOR - height; y <= FLOOR; y++) {
+        for (let x = 19; x <= 20; x++)
+            put(grid, x, y, band(0.45 + (0.55 * (y - (FLOOR - height))) / Math.max(1, height), x, y));
+    }
+    const head = FLOOR - height - radius + 1;
+    shape(grid, 20, head, radius, radius, false);
+    put(grid, 19, head, "o");
+    put(grid, 20, head, "o");
+    if (radius > 2.5) {
+        put(grid, 19, head - 1, "o");
+        put(grid, 20, head - 1, "o");
+    }
+    const crown = [[-4, -3], [3, -3], [-1, -5], [1, -5], [-5, -4], [4, -4], [-1, -6], [1, -6], [-6, -5], [5, -5]];
+    const scale = radius / 3.6;
+    for (let i = 0; i < Math.floor(u * crown.length); i++) {
+        const [dx, dy] = crown[i];
+        put(grid, 20 + dx * scale + (dx < 0 ? 0 : 0.5), head + dy * scale, i % 2 ? "c" : "N");
+    }
+}
+const ease = (t) => (t < 0 ? 0 : t > 1 ? 1 : t * t * (3 - 2 * t));
+/** The lifecycle: twenty frames of the polyp growing into the jellyfish, nineteen of it sinking and the polyp growing back. */
+function lifecycle() {
+    const frames = [];
+    for (let f = 0; f < 20; f++) {
+        const grid = new Map();
+        const g = f / 19;
+        const p = ease((g - 0.2) / 0.65);
+        if (1 - p > 0.06)
+            polyp(grid, 1 - p);
+        else if (p < 1)
+            shape(grid, 20, FLOOR, 2.2, 1, true);
+        const e = ease((g - 0.08) / 0.92);
+        if (e > 0)
+            medusa(grid, 0.18 + 0.82 * e, 40 - 22 * e, Math.pow(e, 1.5));
+        frames.push(grid);
+    }
+    // It sinks to the floor first, and the polyp grows up from there.
+    for (let f = 0; f <= 18; f++) {
+        const grid = new Map();
+        if (f <= 8) {
+            const s = f / 8;
+            medusa(grid, 1 - 0.72 * s, 18 + 40 * s, 1 - s);
+        }
+        else if (f <= 11) {
+            const w = (f - 9) / 2;
+            shape(grid, 20, FLOOR, 4.2 - 1.2 * w, 3.2 - 0.8 * w, true);
+            put(grid, 19, FLOOR - 1, "o");
+            put(grid, 20, FLOOR - 1, "o");
+        }
+        else
+            polyp(grid, (f - 11) / 7);
+        frames.push(grid);
+    }
+    return frames;
+}
+/**
+ * The jellyfish swimming, grown: its bell still, its tentacles in one of two strokes - the second drawn a pixel higher,
+ * as it bobs.
+ */
+function hero(stroke) {
+    const grid = new Map();
+    shape(grid, 20.5, 18, 14.5, 16, true, false);
+    rim(grid, 18);
+    for (const [x, y] of GLINT)
+        if (grid.has(`${x},${y}`))
+            put(grid, x, y, "h", false);
+    for (let y = 10; y <= 12; y++)
+        for (let x = 18; x <= 22; x++)
+            put(grid, x, y, "o", false);
+    for (let x = 19; x <= 21; x++) {
+        put(grid, x, 9, "o", false);
+        put(grid, x, 13, "o", false);
+    }
+    for (const { x, length, i } of TENTACLES) {
+        for (let k = 0; k < length; k++) {
+            const sway = Math.round(Math.sin(k * 0.5 + i + (stroke === 1 ? 2.2 : 0)) * 1.6 * (k / length));
+            put(grid, x + sway, 19 + k, k % 2 ? "n" : "N", false);
+        }
+    }
+    if (stroke === 0)
+        return grid;
+    const raised = new Map();
+    for (const [key, pixel] of grid) {
+        const [x, y] = key.split(",").map(Number);
+        raised.set(`${x},${y - 1}`, pixel);
+    }
+    return raised;
+}
+/** Every frame on one grid, cut to what any of them draws on: rows of pixels, "." where there is none. */
+function crop(grids) {
+    const cells = grids.flatMap((grid) => [...grid.keys()].map((key) => key.split(",").map(Number)));
+    const left = Math.min(...cells.map(([x]) => x));
+    const right = Math.max(...cells.map(([x]) => x));
+    const top = Math.min(...cells.map(([, y]) => y));
+    const bottom = Math.max(...cells.map(([, y]) => y));
+    return grids.map((grid) => Array.from({ length: bottom - top + 1 }, (_, y) => Array.from({ length: right - left + 1 }, (_, x) => grid.get(`${x + left},${y + top}`) ?? ".").join("")));
+}
+/** The lifecycle's frames, then the jellyfish's two strokes, swimming. */
+const LIFECYCLE = lifecycle();
+const SWIM = LIFECYCLE.length;
+/** The jellyfish's frames, each as rows of pixels: what the pictures are rendered from. */
+export const JELLYFISH_FRAMES = crop([...LIFECYCLE, hero(0), hero(1)]);
+export const JELLYFISH_WIDTH = JELLYFISH_FRAMES[0][0].length;
+export const JELLYFISH_HEIGHT = JELLYFISH_FRAMES[0].length;
+/**
+ * The order the frames play in, round and round: the polyp a moment, growing into the jellyfish, swimming four
+ * seconds - a stroke every five frames - then sinking, and the polyp growing back.
+ */
+export const JELLYFISH_SEQUENCE = [
+    ...[0, 0, 0],
+    ...Array.from({ length: 20 }, (_, f) => f),
+    ...Array.from({ length: 27 }, (_, f) => SWIM + (Math.floor(f / 5) % 2)),
+    ...Array.from({ length: 19 }, (_, f) => 20 + f),
+];
 /** How long each frame shows. */
-export const JELLYFISH_FRAME_MS = 250;
+export const JELLYFISH_FRAME_MS = 150;
+/** How much smaller the frames are drawn in half blocks: a cell is a block of SHRINK pixels square. */
+const SHRINK = 3;
+/**
+ * A frame a third of the size: each block drawn as the pixel at its middle. What most of a block is would run the
+ * tentacles, two pixels apart, together into one fringe; its middle keeps strands apart.
+ */
+function shrink(pixels) {
+    const middle = Math.floor(SHRINK / 2);
+    const rows = [];
+    for (let y = middle; y < pixels.length; y += SHRINK) {
+        let row = "";
+        for (let x = middle; x < pixels[0].length; x += SHRINK)
+            row += pixels[y][x];
+        rows.push(row);
+    }
+    return rows;
+}
+/** The frames as a terminal without images draws them, in half blocks: the same order, a third of the size. */
+export const JELLYFISH_TEXT_FRAMES = JELLYFISH_FRAMES.map(shrink);
+/** A colour laid over another, `alpha` of it showing. */
+function over(hex, under, alpha) {
+    if (alpha >= 1)
+        return hex;
+    const channel = (colour, at) => Number.parseInt(colour.slice(at, at + 2), 16);
+    return `#${[1, 3, 5].map((at) => Math.round(channel(hex, at) * alpha + channel(under, at) * (1 - alpha)).toString(16).padStart(2, "0")).join("")}`;
+}
 /**
  * A frame drawn in half blocks for a terminal that shows no images: two pixels a cell, the upper one the text's colour
  * and the lower one the background's, in as many colours as the terminal has: a column a pixel, a row every two.
  */
 export function halfBlocks(pixels, appearance, truecolor) {
     const colours = JELLYFISH_COLOURS[appearance];
-    const colour = (pixel) => (pixel === undefined || pixel === "." ? undefined : colours[pixel]);
+    const colour = (pixel) => pixel === undefined || pixel === "." ? undefined : over(colours[pixel], BACKGROUND[appearance], ALPHA[pixel]);
     const rows = [];
     for (let y = 0; y < pixels.length; y += 2) {
         let row = "";

package/dist/regenerate/loop.d.ts

@@ -281,6 +281,8 @@ export interface ModuleCompletion {
     completed: number;
     /** Of the completed ones, those its conformance tests are recorded as written for, as the spec has them now. */
     conformanceTested: number;
+    /** Those conformance-tested ones, by number: for a host that shows each functional spec's state. */
+    tested: string[];
     /** Its functional specs not completed, by number. */
     incomplete: string[];
 }

package/dist/regenerate/loop.js

@@ -121,7 +121,7 @@ export function functionalityCompletion(plainFile) {
             if (readRecord(entry.buildDir) !== null)
                 delivered = index;
         });
-        const counts = chain.map((entry) => ({ module: entry.moduleName, specified: entry.frids.length, completed: 0, conformanceTested: 0, incomplete: [...entry.frids] }));
+        const counts = chain.map((entry) => ({ module: entry.moduleName, specified: entry.frids.length, completed: 0, conformanceTested: 0, tested: [], incomplete: [...entry.frids] }));
         if (delivered === -1)
             return { codebase: tipOf(chain).buildDir, modules: counts };
         const codebase = chain.slice(0, delivered + 1);
@@ -155,7 +155,8 @@ export function functionalityCompletion(plainFile) {
             const completed = entry.frids.filter((frid) => !touched.has(`${entry.moduleName}:${frid}`));
             const tested = (readRecord(conformanceDirFor(entry.moduleName, modulesRoot(projectDirOf(entry.plainFile))))?.[FUNCTIONAL_REQUIREMENTS] ?? []).filter((item) => item.frid !== undefined && item.markdown.trim() === specText(entry.moduleName, item.frid));
             count.completed = completed.length;
-            count.conformanceTested = completed.filter((frid) => tested.some((item) => item.frid === frid)).length;
+            count.tested = completed.filter((frid) => tested.some((item) => item.frid === frid));
+            count.conformanceTested = count.tested.length;
             count.incomplete = entry.frids.filter((frid) => !completed.includes(frid));
         });
         return { codebase: tip.buildDir, modules: counts };

package/docs/theming.md

@@ -14,7 +14,7 @@ Bad input fails quietly - an unknown `--use-theme` name and a malformed theme fi
 
 ## The palette
 
-Both themes, the command line's colours, the spec diff's, the banner's jellyfish and the docs' diagram are drawn from turri's design system and nothing else: dark, quiet surfaces, one pink thing to press, neon for anything you can follow. These are all the colours turri has - none is mixed, tinted or added.
+Both themes, the command line's colours, the spec diff's, the banner's jellyfish and the docs' diagram are drawn from turri's design system and nothing else: dark, quiet surfaces, one pink thing to press, neon for anything you can follow. These are all the colours turri has - none is mixed, tinted or added, but for the jellyfish's tentacles, every other pixel of which the design draws half seen.
 
 | name | value | in `turri-dark` |
 |---|---|---|
@@ -25,13 +25,15 @@ Both themes, the command line's colours, the spec diff's, the banner's jellyfish
 | lines | `#22344a` | rules, dividers, frames: `borderMuted`, `mdHr` |
 | path | `#3e5a6b` | the editor's border, what is dim: `dim`, line numbers |
 | grauzone | `#85a3b2` | body text, and what can be skimmed: `text`, `muted` |
-| white | `#f4f7f9` | headings, tool titles, what you typed, the jellyfish's shine |
+| white | `#f4f7f9` | headings, tool titles, what you typed |
 | siesta tan | `#e9d8c8` | strings in code, \*\*\*plain's text in quotes or backticks |
-| eggplant | `#732553` | a removed line's fill in a spec diff |
+| eggplant | `#732553` | a removed line's fill in a spec diff, the jellyfish's rim |
 | neon | `#5ce1e6` | links, focus, the selection, section labels, \*\*\*plain's concepts in a spec diff: `accent`, `mdLink`, regen's `◆` |
 | neon hover | `#8eebee` | inline code - siesta tan beside white text was too close to tell apart, and tiring to read - types in code, an added line's fill in a light theme's spec diff: `mdCode` |
 | pink | `#ff5c8d` | the wordmark, the jellyfish's bell, and what is done - its `✓`, the spec map's `◇` and `◆`: `success` |
-| pink hover | `#ff7fa6` | \*\*\*plain's section headers, a removed line's `-`, keywords in code |
+| pink hover | `#ff7fa6` | the glint on the jellyfish's bell, \*\*\*plain's section headers, a removed line's `-`, keywords in code |
+| orchid | `#a9479a` | the jellyfish's bell, between its pink and its indigo - nowhere else |
+| indigo | `#5b57d9` | the jellyfish's bell, at its rim - nowhere else |
 | orange | `#ff7a3d` | the jellyfish's gut, the `$` of bash mode, and everything that asks for you - what failed (`✗`), what works with limits, what needs you (the spec map's `!`): `error`, `warning` |
 
 The design system keeps pink for the one thing to press and orange for the `$` prompt alone. A terminal has no buttons, but it needs status colours, so pink carries what is done and orange everything that asks for you - what failed, what works with limits, what waits on you - the mark (`✗`, `!`, `■`) telling them apart. The palette has no red.

package/docs/using.md

@@ -7,7 +7,7 @@ cd ~/my-project
 turri
 ```
 
-That is pi, with turri's tools, skills and themes loaded - `turri` alone, or with pi's options (`turri -c`, `turri --harness-model <m>`). It opens with turri's own banner - the jellyfish it is named after, swimming until the conversation fills the screen: a pixel jellyfish - a pink bell, an orange gut, neon tentacles coming apart into code at their tips - swimming a stroke a loop, its bell shutting and rising, its tentacles following: a picture in a terminal that shows images (Kitty, Ghostty, WezTerm, Warp, iTerm2), and drawn smaller in half blocks in any other, tmux included (`src/jellyfish.ts` draws it, `scripts/jellyfish-frames.mjs` writes the pictures) - turri's version (and, run from a clone, the commit it is on, and whether the clone has changes) and where its settings are changed - and only when something is wrong, skills that failed to load or agents' commands less fenced than they should be - rather than pi's startup header and resource list; `turri --verbose` shows those too. pi's "Update Available" notice is left out - turri's pi is a pinned dependency `pi update` never touches - and the terminal's tab reads `🪼 turri - <folder>`, not pi's `π`. Talk to it: ask it to start a project, add a feature, render a module, fix a spec. It decides which skill or tool applies - but not *how* a skill runs: `cultivate` hands the work to the gated runner, which owns the steps, the gates and the judges (see [skills and gates](skills-and-gates.md)).
+That is pi, with turri's tools, skills and themes loaded - `turri` alone, or with pi's options (`turri -c`, `turri --harness-model <m>`). It opens with turri's own banner - the jellyfish it is named after, regenerating until the conversation fills the screen: a pixel polyp on the sea floor grows into the jellyfish - a bell from pink down to indigo, an orange gut, neon tentacles - which swims a while, sinks back to the floor, and the polyp grows again, round and round: a picture in a terminal that shows images (Kitty, Ghostty, WezTerm, Warp, iTerm2), and drawn at a third of the size in half blocks in any other, tmux included (`src/jellyfish.ts` draws it, ported from the design system's pixel kit, `scripts/jellyfish-frames.mjs` writes the pictures) - turri's version (and, run from a clone, the commit it is on, and whether the clone has changes) and where its settings are changed - and only when something is wrong, skills that failed to load or agents' commands less fenced than they should be - rather than pi's startup header and resource list; `turri --verbose` shows those too. pi's "Update Available" notice is left out - turri's pi is a pinned dependency `pi update` never touches - and the terminal's tab reads `🪼 turri - <folder>`, not pi's `π`. Talk to it: ask it to start a project, add a feature, render a module, fix a spec. It decides which skill or tool applies - but not *how* a skill runs: `cultivate` hands the work to the gated runner, which owns the steps, the gates and the judges (see [skills and gates](skills-and-gates.md)).
 
 The skills that build from scratch:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.7-next.eb57c34",
+  "version": "0.1.7-next.f0d55df",
   "license": "MIT",
   "type": "module",
   "repository": {