@turri-dev/cli 0.1.24 → 0.1.25-next.d0c7575

package/dist/extension.d.ts

@@ -153,3 +153,14 @@ export declare function chatRulesBlock(rules?: {
     name: string;
     content: string;
 }[]): string;
+/** The frame the jellyfish is on: the one its sequence has at this point. */
+export declare const shownFrame: () => number;
+/**
+ * Moves the jellyfish on a frame every JELLYFISH_FRAME_MS while the banner is on the screen. An entry's
+ * renderer is given no TUI to redraw, so an empty widget below the editor - which pi gives no
+ * spacer - hands it over. Once the conversation is taller than the screen the banner has scrolled off,
+ * and a line changing up there would have pi-tui clear and redraw everything, frame after frame: the
+ * jellyfish stops for the rest of the session - swimming, whole, drawn once more if it was not, rather than on whatever
+ * frame it was at, a polyp half grown.
+ */
+export declare function animateJellyfish(ctx: ExtensionContext): void;

package/dist/extension.js

@@ -32,7 +32,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_SEQUENCE, JELLYFISH_TEXT_FRAMES } from "./jellyfish.js";
+import { halfBlocks, JELLYFISH_FRAME_MS, JELLYFISH_REST, 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";
@@ -2807,16 +2807,17 @@ 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];
+export 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
  * renderer is given no TUI to redraw, so an empty widget below the editor - which pi gives no
  * spacer - hands it over. Once the conversation is taller than the screen the banner has scrolled off,
  * and a line changing up there would have pi-tui clear and redraw everything, frame after frame: the
- * jellyfish stops on the frame it is at, for the rest of the session.
+ * jellyfish stops for the rest of the session - swimming, whole, drawn once more if it was not, rather than on whatever
+ * frame it was at, a polyp half grown.
  */
-function animateJellyfish(ctx) {
+export function animateJellyfish(ctx) {
     if (jellyfishTimer !== undefined)
         clearInterval(jellyfishTimer);
     jellyfishTimer = undefined;
@@ -2825,6 +2826,10 @@ function animateJellyfish(ctx) {
         const timer = setInterval(() => {
             if (tui.render(tui.terminal.columns).length > tui.terminal.rows) {
                 clearInterval(timer);
+                if (shownFrame() !== JELLYFISH_SEQUENCE[JELLYFISH_REST]) {
+                    jellyfishFrame = JELLYFISH_REST;
+                    tui.requestRender();
+                }
                 return;
             }
             jellyfishFrame++;

package/dist/jellyfish.d.ts

@@ -23,6 +23,11 @@ export declare const JELLYFISH_HEIGHT: number;
  * seconds - a stroke every five frames - then sinking, and the polyp growing back.
  */
 export declare const JELLYFISH_SEQUENCE: number[];
+/**
+ * Where in its sequence the jellyfish comes to rest once it can no longer move: swimming, whole - never stopped on a
+ * polyp half grown or a bell half sunk.
+ */
+export declare const JELLYFISH_REST: number;
 /** How long each frame shows. */
 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. */

package/dist/jellyfish.js

@@ -207,6 +207,11 @@ export const JELLYFISH_SEQUENCE = [
     ...Array.from({ length: 27 }, (_, f) => SWIM + (Math.floor(f / 5) % 2)),
     ...Array.from({ length: 19 }, (_, f) => 20 + f),
 ];
+/**
+ * Where in its sequence the jellyfish comes to rest once it can no longer move: swimming, whole - never stopped on a
+ * polyp half grown or a bell half sunk.
+ */
+export const JELLYFISH_REST = JELLYFISH_SEQUENCE.indexOf(SWIM);
 /** How long each frame shows. */
 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. */

package/docs/using.md

@@ -7,7 +7,7 @@ cd ~/my-project
 turri
 ```
 
-That is [pi](https://pi.dev), with turri's tools, skills and themes loaded - `turri` alone, or with [pi](https://pi.dev)'s options (`turri -c`, `turri --harness-model <m>`). It holds several chats side by side, each working while another is shown: `/chat new` or `alt+n` opens one, `alt+1` … `alt+9` switch, and `turri -c` opens them all again - see [chats](chats.md). 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](https://pi.dev)'s startup header and resource list; `turri --verbose` shows those too. [pi](https://pi.dev)'s "Update Available" notice is left out - turri's [pi](https://pi.dev) is a pinned dependency `pi update` never touches - and the terminal's tab reads `🪼 turri - <folder>`, not [pi](https://pi.dev)'s `π`. Talk to it: ask it to add a feature to \*\*\*plain, regenerate a module, fix a module's \*\*\*plain. 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](https://pi.dev), with turri's tools, skills and themes loaded - `turri` alone, or with [pi](https://pi.dev)'s options (`turri -c`, `turri --harness-model <m>`). It holds several chats side by side, each working while another is shown: `/chat new` or `alt+n` opens one, `alt+1` … `alt+9` switch, and `turri -c` opens them all again - see [chats](chats.md). 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 - and once the conversation fills the screen, comes to rest swimming, whole: 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](https://pi.dev)'s startup header and resource list; `turri --verbose` shows those too. [pi](https://pi.dev)'s "Update Available" notice is left out - turri's [pi](https://pi.dev) is a pinned dependency `pi update` never touches - and the terminal's tab reads `🪼 turri - <folder>`, not [pi](https://pi.dev)'s `π`. Talk to it: ask it to add a feature to \*\*\*plain, regenerate a module, fix a module's \*\*\*plain. 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)).
 
 To start a project, just say what you want - `create a small server in Java Spring Boot` - and turri asks how to start it, with three choices: `/brood`, the interview; `/spawn`, the quick start; or `Just do it`, no skill. A skill picked there starts at once, with what you asked for as its context - nothing to type again; saying so in your message - `just build it`, or the command itself - skips the question. Just do it starts the project in the conversation: turri takes the stack you named, or chooses one this machine can build, and says it in a line; writes the module importing the stack from the standard library, `config.turri.yaml` (conformance tests off unless you ask for them) and the unit testing script (with `implement-unit-testing-script`, unless there is one); then the smallest thing that runs, regenerated at once, and while it regenerates the main thing you described and at most one more, on their happy path - nothing you did not describe. You say `go on`, or what to change, and every change after is \*\*\*plain it writes and regenerates (`src/new-project.ts`).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.24",
+  "version": "0.1.25-next.d0c7575",
   "license": "MIT",
   "type": "module",
   "repository": {